freya-core 0.5.2

Reactivity runtime, tree management, accessibility integration, rendering pipeline and more, for Freya
Documentation
use accesskit::TreeId;
use freya::prelude::*;
use freya_core::integration::{
    ACCESSIBILITY_ROOT_ID,
    AccessibilityTree,
    NodesState,
    Runner,
    Tree,
};
use freya_engine::prelude::{
    FontCollection,
    FontMgr,
};
use freya_testing::prelude::*;

#[test]
fn initialization_preserves_pending_focus() {
    let input_id = AccessibilityId(100);
    let mut runner = Runner::new(move || {
        rect()
            .expanded()
            .child(
                rect()
                    .a11y_id(input_id)
                    .a11y_focusable(true)
                    .a11y_role(AccessibilityRole::TextInput),
            )
            .into_element()
    });
    let mut tree = Tree::default();
    tree.apply_mutations(runner.sync_and_update(), 1.0);
    let (events_sender, _events_receiver) = futures_channel::mpsc::unbounded();
    tree.measure_layout(
        (300.0, 300.0).into(),
        &mut FontCollection::new(),
        &FontMgr::default(),
        &events_sender,
        &mut NodesState::default(),
        1.0,
        &[],
    );
    tree.accessibility_diff
        .request_focus(AccessibilityFocusStrategy::Node(input_id));
    let mut accessibility = AccessibilityTree::default();

    let update = accessibility.init(&mut tree, "");

    assert_eq!(update.focus, input_id);
    assert_eq!(accessibility.focused_id, input_id);
    assert!(tree.accessibility_diff.requested_focus.is_none());
}

#[test]
fn disabled_nodes_reject_focus_and_release_existing_focus() {
    let input_id = AccessibilityId(100);
    let (mut test, mut enabled) = TestingRunner::new(
        move || {
            let enabled = use_consume::<State<bool>>();
            rect().a11y_id(input_id).a11y_focusable(*enabled.read())
        },
        (300., 300.).into(),
        |runner| runner.provide_root_context(|| State::create(false)),
        1.,
    );
    test.sync_and_update();

    test.run_in(|| input_id.request_focus());
    assert_eq!(test.sync_and_update().focus, ACCESSIBILITY_ROOT_ID);

    enabled.set(true);
    test.sync_and_update();
    test.run_in(|| input_id.request_focus());
    assert_eq!(test.sync_and_update().focus, input_id);

    enabled.set(false);
    assert_eq!(test.sync_and_update().focus, ACCESSIBILITY_ROOT_ID);
}

#[test]
fn moving_an_a11y_id_between_siblings() {
    let (mut test, mut holder) = TestingRunner::new(
        || {
            let holder = use_consume::<State<usize>>();
            let a11y_id = use_a11y();

            rect().children(
                (0..3)
                    .map(|index| {
                        rect()
                            .width(Size::px(100.))
                            .height(Size::px(100.))
                            .maybe(index == *holder.read(), |el| el.a11y_id(a11y_id))
                            .into_element()
                    })
                    .collect::<Vec<_>>(),
            )
        },
        (500., 500.).into(),
        |runner| runner.provide_root_context(|| State::create(0usize)),
        1.,
    );
    test.sync_and_update();

    for index in 1..3 {
        holder.set(index);
        let update = test.sync_and_update();

        let mut children = update
            .nodes
            .iter()
            .flat_map(|(_, node)| node.children())
            .collect::<Vec<_>>();
        let total = children.len();
        children.sort_unstable();
        children.dedup();
        assert_eq!(children.len(), total, "duplicated accessibility children");
    }
}

#[test]
fn keyed_sibling_reorders_update_accessibility_children() {
    let (mut test, mut keys) = TestingRunner::new(
        || {
            let keys = use_consume::<State<[u64; 3]>>();
            rect()
                .a11y_id(AccessibilityId(1000))
                .a11y_role(AccessibilityRole::Group)
                .children(keys().into_iter().map(|key| {
                    rect()
                        .key(key)
                        .width(Size::px(100.))
                        .height(Size::px(20.))
                        .a11y_id(AccessibilityId(100 + key))
                        .a11y_role(AccessibilityRole::Button)
                }))
        },
        (300., 300.).into(),
        |runner| runner.provide_root_context(|| State::create([0u64, 1, 2])),
        1.,
    );
    test.sync_and_update();

    for next in [[2, 1, 0], [1, 0, 2], [0, 1, 2]] {
        keys.set(next);
        let update = test.sync_and_update();
        let (_, parent) = update
            .nodes
            .iter()
            .find(|(id, _)| *id == AccessibilityId(1000))
            .expect("reordered parent must receive an accessibility update");
        assert_eq!(
            parent.children(),
            next.map(|key| AccessibilityId(100 + key))
        );
    }
}

fn action_request(
    action: AccessibilityAction,
    target_node: AccessibilityId,
) -> AccessibilityActionEventData {
    AccessibilityActionEventData {
        action,
        target_tree: TreeId::ROOT,
        target_node,
        data: None,
    }
}

#[test]
fn accessibility_button_click() {
    let (mut test, count) = TestingRunner::new(
        || {
            let mut count = use_consume::<State<usize>>();
            Button::new()
                .on_press(move |_| *count.write() += 1)
                .child("Activate")
        },
        (300., 300.).into(),
        |runner| runner.provide_root_context(|| State::create(0usize)),
        1.,
    );
    let button = test
        .find(|_, element| {
            let accessibility = element.accessibility();
            (accessibility.builder.role() == AccessibilityRole::Button)
                .then(|| accessibility.into_owned())
        })
        .unwrap();
    assert!(button.builder.supports_action(AccessibilityAction::Click));
    assert!(test.send_accessibility_action(action_request(
        AccessibilityAction::Click,
        button.a11y_id.unwrap(),
    )));
    test.sync_and_update();
    assert_eq!(*count.peek(), 1);
}

#[test]
fn accessibility_disabled_nodes_reject_actions() {
    let mut test = launch_test(|| {
        rect()
            .a11y_id(AccessibilityId(100))
            .a11y_enabled(false)
            .on_accessibility_action(|_| panic!("Disabled nodes must not receive actions"))
    });
    test.sync_and_update();
    for action in [AccessibilityAction::Click, AccessibilityAction::Increment] {
        assert!(!test.send_accessibility_action(action_request(action, AccessibilityId(100))));
    }
    test.sync_and_update();
}