harn-vm 0.10.53

Async bytecode virtual machine for the Harn programming language
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

use super::*;

#[test]
fn vm_value_to_serde_preserves_supported_shapes() {
    let mut map = BTreeMap::new();
    map.insert("key".to_string(), VmValue::Int(42));

    for (value, expected) in [
        (
            VmValue::String(arcstr::ArcStr::from("hello")),
            serde_json::json!("hello"),
        ),
        (VmValue::dict(map), serde_json::json!({"key": 42})),
        (
            VmValue::List(std::sync::Arc::new(vec![VmValue::Int(1), VmValue::Int(2)])),
            serde_json::json!([1, 2]),
        ),
    ] {
        assert_eq!(vm_value_to_serde(&value), expected);
    }
}

#[test]
fn extract_content_text_handles_text_and_non_text_blocks() {
    for (result, expected) in [
        (
            serde_json::json!({
                "content": [{"type": "text", "text": "hello world"}],
                "isError": false
            }),
            "hello world",
        ),
        (
            serde_json::json!({
                "content": [
                    {"type": "text", "text": "first"},
                    {"type": "text", "text": "second"}
                ],
                "isError": false
            }),
            "first\nsecond",
        ),
    ] {
        assert_eq!(extract_content_text(&result), expected);
    }

    let fallback = extract_content_text(&serde_json::json!({
        "content": [{"type": "image", "data": "abc"}],
        "isError": false
    }));
    assert!(fallback.contains("image"));
}

#[test]
fn sse_parser_selects_the_matching_json_rpc_response() {
    let body = "event: message\ndata: {\"jsonrpc\":\"2.0\",\"method\":\"notifications/message\"}\n\nevent: message\ndata: {\"jsonrpc\":\"2.0\",\"id\":1,\"result\":{\"tools\":[]}}\n\n";
    let parsed = parse_sse_jsonrpc_body("mock", body, Some(1)).unwrap();
    assert_eq!(parsed["result"]["tools"], serde_json::json!([]));
}

#[test]
fn embedded_input_rejects_unadvertised_methods() {
    let unknown = unsupported_embedded_input_response(&serde_json::json!({
        "jsonrpc": "2.0",
        "id": "custom-1",
        "method": "custom/method",
        "params": {}
    }))
    .expect("rejection");
    assert_eq!(unknown["error"]["code"], serde_json::json!(-32601));
    assert!(unknown["error"].get("data").is_none());
}