freya-testing 0.3.4

Headless test runner for Freya.
Documentation 
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
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132

use freya::prelude::*;
use freya_testing::prelude::*;

#[tokio::test]
async fn no_state() {
    fn no_state_app() -> Element {
        rsx!(
            label {
                "Hello"
            }
        )
    }

    let utils = launch_test(no_state_app);

    assert_eq!(utils.root().get(0).get(0).text(), Some("Hello"));
}

#[tokio::test]
async fn with_state() {
    fn stateful_app() -> Element {
        let mut state = use_signal(|| false);

        use_effect(move || {
            state.set(true);
        });

        rsx!(
            label {
                "Is enabled? {state}"
            }
        )
    }

    let mut utils = launch_test(stateful_app);

    let label = utils.root().get(0);

    assert_eq!(label.get(0).text(), Some("Is enabled? false"));

    utils.wait_for_update().await;

    assert_eq!(label.get(0).text(), Some("Is enabled? true"));
}

#[tokio::test]
async fn check_size() {
    fn stateful_app() -> Element {
        rsx!(rect {
            width: "50%",
            height: "calc(100% - 70)"
        })
    }

    let mut utils = launch_test(stateful_app);

    utils.wait_for_update().await;

    let rect = utils.root().get(0);

    assert_eq!(rect.area().unwrap().width(), 250.0);
    assert_eq!(rect.area().unwrap().height(), 430.0);
}

#[tokio::test]
async fn simulate_events() {
    fn stateful_app() -> Element {
        let mut enabled = use_signal(|| false);
        rsx!(
            rect {
                overflow: "clip",
                width: "100%",
                height: "100%",
                background: "red",
                onclick: move |_| {
                    enabled.set(true);
                },
                label {
                    "Is enabled? {enabled}"
                }
            }
        )
    }

    let mut utils = launch_test(stateful_app);

    let rect = utils.root().get(0);
    let label = rect.get(0);

    // Render initial layout
    utils.wait_for_update().await;

    let text = label.get(0);

    assert_eq!(text.text(), Some("Is enabled? false"));

    utils.click_cursor((5., 5.)).await;

    let text = label.get(0);

    assert_eq!(text.text(), Some("Is enabled? true"));
}

#[tokio::test]
async fn match_by_text() {
    fn app() -> Element {
        rsx!(
            label {
                "Hello, World!"
            }
            rect {
                label {
                    "Hello, Rust!"
                }
            }
        )
    }

    let utils = launch_test(app);

    assert_eq!(
        utils.root().get_by_text("Hello, World!").unwrap().text(),
        Some("Hello, World!")
    );

    assert!(utils.root().get_by_text("Blabla").is_none());

    assert_eq!(
        utils.root().get_by_text("Hello, Rust!").unwrap().text(),
        Some("Hello, Rust!")
    );
}