cranpose-testing 0.13.0

Composition, semantics, accessibility, and robot test utilities for Cranpose
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88

//! `Dialog` through the headless robot: a tap on the dialog's own surface
//! keeps it open, even where nothing on the surface is clickable, a tap on
//! the scrim around it dismisses it, and a screen reader dismisses it as the
//! back gesture does.

use std::{cell::Cell, rc::Rc};

use cranpose_testing::{
    RobotTestRule, TestRenderer, create_headless_robot_test, robot_assertions::find_semantics_node,
};
use cranpose_ui::{
    Box, BoxSpec, Color, Modifier, SemanticsDismiss, Size, Text, TextStyle,
    widgets::{Dialog, DialogSpec, DismissReason},
};

fn screen() -> (RobotTestRule<TestRenderer>, Rc<Cell<Option<DismissReason>>>) {
    screen_with(DialogSpec::default())
}

fn screen_with(spec: DialogSpec) -> (RobotTestRule<TestRenderer>, Rc<Cell<Option<DismissReason>>>) {
    let dismissed = Rc::new(Cell::new(None));
    let recorded = Rc::clone(&dismissed);
    let robot = create_headless_robot_test(300, 400, move || {
        let recorded = Rc::clone(&recorded);
        Dialog(
            spec,
            move |reason| recorded.set(Some(reason)),
            || {
                Box(
                    Modifier::empty()
                        .size(Size::new(200.0, 120.0))
                        .background(Color::WHITE),
                    BoxSpec::default(),
                    || {
                        Text("Title", Modifier::empty(), TextStyle::default());
                    },
                );
            },
        );
    });
    (robot, dismissed)
}

#[test]
fn a_tap_on_the_surface_keeps_the_dialog_open() {
    let (mut robot, dismissed) = screen();
    let title = robot
        .find_by_text("Title")
        .center()
        .expect("the dialog shows its title");
    robot.click_at(title.x, title.y);
    robot.wait_for_idle();
    // The empty corner of the surface, away from the title.
    robot.click_at(150.0 + 90.0, 200.0 + 50.0);
    robot.wait_for_idle();
    assert_eq!(dismissed.get(), None);
}

#[test]
fn a_tap_on_the_scrim_dismisses_the_dialog() {
    let (mut robot, dismissed) = screen();
    robot.click_at(10.0, 10.0);
    robot.wait_for_idle();
    assert_eq!(dismissed.get(), Some(DismissReason::OutsideTap));
}

fn reader_dismiss(robot: &mut RobotTestRule<TestRenderer>) -> Option<SemanticsDismiss> {
    robot.shell_mut().set_semantics_enabled(true);
    robot.wait_for_idle();
    robot.shell_mut().semantics_tree().and_then(|tree| {
        find_semantics_node(tree.root(), &|node| node.details().dismiss.is_some())
            .and_then(|node| node.details().dismiss.clone())
    })
}

#[test]
fn a_screen_reader_dismisses_the_dialog_as_the_back_gesture_does() {
    let (mut robot, dismissed) = screen();
    let dismiss = reader_dismiss(&mut robot).expect("the dialog offers a dismiss action");
    assert!(dismiss.invoke());
    assert_eq!(dismissed.get(), Some(DismissReason::BackRequested));
}

#[test]
fn a_dialog_the_user_must_answer_offers_a_reader_no_dismiss() {
    let (mut robot, _) = screen_with(DialogSpec::required());
    assert!(reader_dismiss(&mut robot).is_none());
}