pctx_executor 0.2.0

TypeScript execution environment orchestration
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

use super::serial;
use crate::{ExecuteOptions, execute};

#[tokio::test]
#[serial]
async fn test_execute_simple_code() {
    let code = r"
const x = 1 + 1;
export default x;
";

    let result = execute(code, ExecuteOptions::new())
        .await
        .expect("execution should succeed");
    assert!(result.success, "Simple code should execute successfully");
    assert!(
        result.runtime_error.is_none(),
        "Should have no runtime errors"
    );
    assert!(result.diagnostics.is_empty(), "Should have no type errors");
}

#[tokio::test]
#[serial]
async fn test_execute_runtime_error() {
    let code = r#"
throw new Error("This is a runtime error");
"#;

    let result = execute(code, ExecuteOptions::new())
        .await
        .expect("execution should succeed");
    assert!(!result.success, "Code with runtime error should fail");
    assert!(result.runtime_error.is_some(), "Should have runtime error");

    let error = result.runtime_error.unwrap();
    assert!(
        error.message.contains("runtime error"),
        "Error should contain the thrown message"
    );
}

#[tokio::test]
#[serial]
async fn test_execute_syntax_error() {
    let code = r"
const x = ;
";

    let result = execute(code, ExecuteOptions::new())
        .await
        .expect("execution should succeed");
    assert!(!result.success, "Code with syntax error should fail");
    // Syntax errors are caught during execution
    assert!(
        result.runtime_error.is_some() || !result.diagnostics.is_empty(),
        "Should have error information"
    );
}

#[tokio::test]
#[serial]
async fn test_fetch_not_available() {
    let code = r#"
async function test() {
    const res = await fetch("https://example.com");
    return { res }
}

export default await test();
"#;

    let result = execute(code, ExecuteOptions::new())
        .await
        .expect("execute should not error");

    assert!(!result.success);
    assert!(
        result
            .stderr
            .starts_with("ReferenceError: fetch is not defined")
    );
}