nodejs 0.4.0

Embedding Node.js in Rust
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

use nodejs::neon::result::NeonResult;
use nodejs::neon::types::{JsArray, JsString};
use nodejs::neon::{context::Context, types::JsNumber};

#[chazi::test(check_reach)]
fn test_simple() {
    let mut answer = 0;
    let exit_code = unsafe {
        nodejs::run(|mut cx| {
            let script = cx.string("40+2");
            let forty_two = neon::reflect::eval(&mut cx, script)?;
            answer = forty_two
                .downcast_or_throw::<JsNumber, _>(&mut cx)?
                .value(&mut cx) as _;
            Ok(())
        })
    };
    assert_eq!(answer, 42);
    assert_eq!(exit_code, 0);
    chazi::reached::last()
}

#[chazi::test(check_reach)]
fn test_process_exit() {
    let exit_code = unsafe {
        nodejs::run(|mut cx| {
            let script = cx.string("process.exit(40+2)");
            neon::reflect::eval(&mut cx, script)?;
            Ok(())
        })
    };
    assert_eq!(exit_code, 42);
    chazi::reached::last()
}

#[chazi::test(check_reach)]
fn test_argv() {
    let mut args = Vec::<String>::new();
    let exit_code = unsafe {
        nodejs::run(|mut cx| {
            let script = cx.string("[process.argv0, ...process.argv.slice(1)]");
            let process_args = neon::reflect::eval(&mut cx, script)?;
            let process_args = process_args
                .downcast_or_throw::<JsArray, _>(&mut cx)?
                .to_vec(&mut cx)?;
            args = process_args
                .iter()
                .map(|arg| {
                    Ok(arg
                        .downcast_or_throw::<JsString, _>(&mut cx)?
                        .value(&mut cx))
                })
                .collect::<NeonResult<Vec<String>>>()?;
            Ok(())
        })
    };
    assert_eq!(args, std::env::args().collect::<Vec<String>>());
    assert_eq!(exit_code, 0);
    chazi::reached::last()
}

#[chazi::test(check_reach)]
fn test_uncaught_error() {
    let exit_code = unsafe {
        nodejs::run(|mut cx| {
            let script = cx.string("setImmediate(() => throw new Error())");
            neon::reflect::eval(&mut cx, script)?;
            Ok(())
        })
    };
    assert_eq!(exit_code, 1);
    chazi::reached::last()
}