hara-native 0.1.13

HAL-free native host runtime and package launcher for Hara
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
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122

use hara_wasm::core::Value;
use hara_wasm::hta;
use hara_wasm::native_cli::RuntimeBroker;
use hara_wasm::{InvokeHtaError, Runtime};

fn arguments(values: Vec<Value>) -> Vec<u8> {
    hta::encode(&Value::Vector(values.into())).expect("canonical arguments")
}

fn number(bytes: &[u8]) -> i64 {
    let Value::Number(value) = hta::decode(bytes).expect("result HTA") else {
        panic!("expected integer result")
    };
    value
}

#[test]
fn runtime_invokes_only_an_already_loaded_qualified_var() {
    let mut runtime = Runtime::core();
    runtime
        .eval_native("(ns invoke.sample) (defn add [a b] (+ a b)) (def answer 42)")
        .expect("load sample namespace");

    let result = runtime
        .invoke_hta(
            "invoke.sample/add",
            &arguments(vec![Value::Number(20), Value::Number(22)]),
        )
        .expect("invoke add");
    assert_eq!(number(&result), 42);

    assert_eq!(
        runtime.invoke_hta("add", &arguments(vec![])),
        Err(InvokeHtaError::InvalidQualifiedVar)
    );
    assert_eq!(
        runtime.invoke_hta("missing.namespace/add", &arguments(vec![])),
        Err(InvokeHtaError::NamespaceMissing(
            "missing.namespace".to_owned()
        ))
    );
    assert_eq!(
        runtime.invoke_hta("invoke.sample/missing", &arguments(vec![])),
        Err(InvokeHtaError::VarMissing(
            "invoke.sample/missing".to_owned()
        ))
    );
    assert_eq!(
        runtime.invoke_hta("invoke.sample/answer", &arguments(vec![])),
        Err(InvokeHtaError::VarNotCallable(
            "invoke.sample/answer".to_owned()
        ))
    );
}

#[test]
fn runtime_rejects_malformed_noncanonical_and_non_vector_arguments() {
    let mut runtime = Runtime::core();
    runtime
        .eval_native("(ns invoke.input) (defn identity* [value] value)")
        .expect("load input namespace");

    assert!(matches!(
        runtime.invoke_hta("invoke.input/identity*", b"not-hta"),
        Err(InvokeHtaError::MalformedInput(_))
    ));
    assert_eq!(
        runtime.invoke_hta(
            "invoke.input/identity*",
            &hta::encode(&Value::Number(1)).expect("scalar HTA")
        ),
        Err(InvokeHtaError::ArgumentsNotVector)
    );

    let mut noncanonical = b"HTA0".to_vec();
    noncanonical.push(11);
    noncanonical.extend_from_slice(&2_u32.to_be_bytes());
    for (key, value) in [(b'z', 1_i64), (b'a', 2_i64)] {
        noncanonical.push(6);
        noncanonical.extend_from_slice(&1_u32.to_be_bytes());
        noncanonical.push(key);
        noncanonical.push(3);
        noncanonical.extend_from_slice(&value.to_be_bytes());
    }
    assert_eq!(
        runtime.invoke_hta("invoke.input/identity*", &noncanonical),
        Err(InvokeHtaError::NoncanonicalInput)
    );
}

#[test]
fn broker_keeps_invoke_hta_session_isolated() {
    let broker = RuntimeBroker::start_core().expect("broker");
    broker
        .eval("ROOT", "(ns invoke.broker) (defn value [] 1)")
        .expect("root function");
    broker.create("SECOND").expect("second session");
    broker
        .eval("SECOND", "(ns invoke.broker) (defn value [] 2)")
        .expect("second function");

    assert_eq!(
        number(
            &broker
                .invoke_hta("ROOT", "invoke.broker/value", &arguments(vec![]))
                .expect("root invoke")
        ),
        1
    );
    assert_eq!(
        number(
            &broker
                .invoke_hta("SECOND", "invoke.broker/value", &arguments(vec![]))
                .expect("second invoke")
        ),
        2
    );
    assert_eq!(
        broker.invoke_hta("MISSING", "invoke.broker/value", &arguments(vec![])),
        Err(InvokeHtaError::SessionMissing("MISSING".to_owned()))
    );
}