cranpose-services 0.1.85

Multiplatform system services for Cranpose (HTTP, URI, and OS integrations)
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

use cranpose_core::{location_key, Composition, MemoryApplier};
use cranpose_services::{
    clear_platform_launch_args, isDebuggable, launch_args, local_launch_args,
    set_platform_launch_args, LaunchArgValue, LaunchArgs, ProvideLaunchArgs,
};
use std::cell::RefCell;
use std::rc::Rc;

fn run_test_composition(build: impl FnMut()) {
    let mut composition = Composition::new(MemoryApplier::new());
    composition
        .render(location_key(file!(), line!(), column!()), build)
        .expect("initial render succeeds");
}

fn debug_launch() -> Rc<LaunchArgs> {
    Rc::new(LaunchArgs::new(
        [
            ("ob_debug".to_string(), LaunchArgValue::Bool(true)),
            ("ob_level".to_string(), LaunchArgValue::Int(7)),
            (
                "ob_screen".to_string(),
                LaunchArgValue::Text("lobby".to_string()),
            ),
        ],
        true,
    ))
}

#[test]
fn integration_launch_arguments_installed_by_the_platform_reach_composition() {
    clear_platform_launch_args();
    set_platform_launch_args(debug_launch());
    let captured = Rc::new(RefCell::new(None));

    {
        let captured = Rc::clone(&captured);
        run_test_composition(move || {
            let captured = Rc::clone(&captured);
            let args = local_launch_args().current();
            *captured.borrow_mut() = Some((
                args.boolean("ob_debug"),
                args.int("ob_level"),
                args.string("ob_screen").map(str::to_string),
                isDebuggable(),
            ));
        });
    }

    assert_eq!(
        *captured.borrow(),
        Some((Some(true), Some(7), Some("lobby".to_string()), true))
    );
    clear_platform_launch_args();
}

#[test]
fn integration_a_replacement_snapshot_is_observed_by_the_next_render() {
    clear_platform_launch_args();
    set_platform_launch_args(debug_launch());
    assert_eq!(launch_args().int("ob_level"), Some(7));

    // What Android's onNewIntent does: the whole snapshot is swapped, so the
    // previous launch's arguments do not linger.
    set_platform_launch_args(Rc::new(LaunchArgs::new(
        [("ob_level".to_string(), LaunchArgValue::Int(9))],
        true,
    )));
    let captured = Rc::new(RefCell::new(None));

    {
        let captured = Rc::clone(&captured);
        run_test_composition(move || {
            let captured = Rc::clone(&captured);
            let args = local_launch_args().current();
            *captured.borrow_mut() = Some((args.int("ob_level"), args.boolean("ob_debug")));
        });
    }

    assert_eq!(*captured.borrow(), Some((Some(9), None)));
    clear_platform_launch_args();
}

#[test]
fn integration_provide_launch_args_overrides_the_platform_snapshot() {
    clear_platform_launch_args();
    set_platform_launch_args(debug_launch());
    let captured = Rc::new(RefCell::new(None));

    {
        let captured = Rc::clone(&captured);
        run_test_composition(move || {
            let captured = Rc::clone(&captured);
            let provided = Rc::new(LaunchArgs::new(std::iter::empty(), false));
            ProvideLaunchArgs(provided, move || {
                *captured.borrow_mut() = Some((
                    local_launch_args().current().int("ob_level"),
                    isDebuggable(),
                ));
            });
        });
    }

    assert_eq!(*captured.borrow(), Some((None, false)));
    clear_platform_launch_args();
}