scriptit 0.4.0

scriptit is a simple way to run JavaScript code in Rust (native+wasm)
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

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

use scriptit::{
    core::error::ScriptError,
    core::{value::ScriptValue, ScriptingEnvironment},
    platform::PlatformScriptingEnvironment,
};
use wasm_bindgen_test::*;

#[test]
#[wasm_bindgen_test]
fn register_count_handler() {
    let count = Rc::new(RefCell::new(0 as u32));
    let closure_count = Rc::clone(&count);
    let mut s_env = PlatformScriptingEnvironment::new();
    s_env.register_core_handler(
        "count",
        Box::new(move |_| {
            *closure_count.borrow_mut() += 1;
            Ok(String::from(format!("{}", *closure_count.borrow())))
        }),
    );
    let val = s_env
        .eval_expression(
            "(
                ScriptIt.core.callToRust('count', ''),
                ScriptIt.core.callToRust('count', ''),
                ScriptIt.core.callToRust('count', '')
            )",
        )
        .unwrap();

    assert_eq!(val, ScriptValue::String("3".to_string()));
}

#[test]
#[wasm_bindgen_test]
fn register_data_and_avg_handlers() {
    let count = Rc::new(RefCell::new(0 as u32));
    let data_count = Rc::clone(&count);
    let total = Rc::new(RefCell::new(0.0 as f64));
    let data_total = Rc::clone(&total);

    let mut s_env = PlatformScriptingEnvironment::new();

    s_env.register_core_handler(
        "data",
        Box::new(move |val| {
            let val: f64 = val.parse().unwrap();
            *data_count.borrow_mut() += 1;
            *data_total.borrow_mut() += val;
            Ok("".to_string())
        }),
    );

    s_env.register_core_handler(
        "avg",
        Box::new(move |_| {
            let val = *total.borrow() / (*count.borrow() as f64);
            Ok(format!("{}", val).to_string())
        }),
    );

    let val = s_env
        .eval_expression(
            "(
                ScriptIt.core.callToRust('data', '12.5'),
                ScriptIt.core.callToRust('data', '13.0'),
                ScriptIt.core.callToRust('data', '13.5'),
                ScriptIt.core.callToRust('avg', '')
            )",
        )
        .unwrap();

    assert_eq!(val, ScriptValue::String("13".to_string()));
}

#[test]
#[wasm_bindgen_test]
fn throw_in_js_if_failure() {
    let mut s_env = PlatformScriptingEnvironment::new();
    match s_env.run("ScriptIt.core.callToRust('not found', 'test')") {
        Err(ScriptError::RuntimeError(msg)) => {
            assert!(msg.contains("Can\'t get unregistered handler: not found"));
        }
        other => panic!("Expected a ScriptError::RuntimeError got {:?}", other),
    }

    s_env.register_core_handler("fail", Box::new(move |_| Err("I am failing".to_string())));
    match s_env.run("ScriptIt.core.callToRust('fail', 'test')") {
        Err(ScriptError::RuntimeError(msg)) => {
            assert!(msg.contains("I am failing"));
        }
        other => panic!("Expected a ScriptError::RuntimeError got {:?}", other),
    }
}