cranpose-testing 0.0.63

Testing utilities and harness for Cranpose
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

use super::*;
use cranpose_core::useState;

thread_local! {
    static ROOT_RENDER_TEST_INVALIDATED: Cell<bool> = const { Cell::new(false) };
}

#[derive(Default)]
struct TestNode {
    value: i32,
}

impl Node for TestNode {}

#[derive(Default)]
struct TestTextValueNode {
    value: String,
}

impl Node for TestTextValueNode {}

#[test]
fn cranpose_test_rule_reports_content_and_root() {
    run_test_composition(|rule| {
        assert!(!rule.has_content());
        assert!(rule.root_id().is_none());

        let runtime = rule.runtime_handle();
        let state = MutableState::with_runtime(0, runtime.clone());
        let recompositions = Rc::new(Cell::new(0));

        rule.set_content({
            let recompositions = Rc::clone(&recompositions);
            move || {
                recompositions.set(recompositions.get() + 1);
                let id = with_current_composer(|composer| composer.emit_node(TestNode::default));
                let value = state.value();
                with_node_mut(id, |node: &mut TestNode| {
                    node.value = value;
                })
                .expect("update node text");
            }
        })
        .expect("install content");

        assert!(rule.has_content());
        assert_eq!(recompositions.get(), 1);

        let root = rule.root_id().expect("root id available");
        let stored_value = {
            rule.applier_mut()
                .with_node(root, |node: &mut TestNode| node.value)
                .expect("read node")
        };
        assert_eq!(stored_value, 0);

        state.set_value(5);
        rule.pump_until_idle().expect("process invalidation");

        assert_eq!(recompositions.get(), 2);
        let updated_value = {
            rule.applier_mut()
                .with_node(root, |node: &mut TestNode| node.value)
                .expect("read updated node")
        };
        assert_eq!(updated_value, 5);
    });
}

#[test]
fn cranpose_test_rule_replays_root_render_requests_before_returning() {
    run_test_composition(|rule| {
        ROOT_RENDER_TEST_INVALIDATED.with(|flag| flag.set(false));
        let render_count = Rc::new(Cell::new(0));

        rule.set_content({
            let render_count = Rc::clone(&render_count);
            move || {
                let root_trigger = useState(|| false);
                render_count.set(render_count.get() + 1);
                cranpose_core::with_key(&"testing-root-render-probe", || {
                    let _ = root_trigger.value();
                });

                let value = format!("render {}", render_count.get());
                let initial_value = value.clone();
                let id = with_current_composer(|composer| {
                    composer.emit_node(|| TestTextValueNode {
                        value: initial_value,
                    })
                });
                with_node_mut(id, |node: &mut TestTextValueNode| {
                    node.value = value;
                })
                .expect("update test text value node");

                cranpose_core::SideEffect(move || {
                    let already_invalidated =
                        ROOT_RENDER_TEST_INVALIDATED.with(|flag| flag.replace(true));
                    if already_invalidated {
                        return;
                    }
                    root_trigger.set_value(true);
                });
            }
        })
        .expect("install content");

        assert_eq!(
            render_count.get(),
            2,
            "ComposeTestRule::set_content must replay pending root renders before returning"
        );
        assert!(
            !rule.composition().take_root_render_request(),
            "test harness should not leave a pending root render request behind"
        );

        let root = rule.root_id().expect("root id available");
        let stored_value = rule
            .applier_mut()
            .with_node(root, |node: &mut TestTextValueNode| node.value.clone())
            .expect("read test node");
        assert_eq!(stored_value, "render 2");
    });
}