sim-kernel 0.1.0-rc.1

SIM workspace package for sim kernel.
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

use super::*;
use crate::{
    Error, EventKind,
    capability::{
        control_capture_capability, control_multishot_capability, control_prompt_capability,
    },
};

use crate::testing::bare_cx as cx;

fn symbol_ref(namespace: &str, name: &str) -> Ref {
    Ref::Symbol(Symbol::qualified(namespace, name))
}

#[test]
fn prompt_body_can_return_normally() {
    let mut cx = cx();
    cx.grant(control_prompt_capability());
    let expected = symbol_ref("test", "prompt-result");

    let actual = prompt(
        &mut cx,
        ControlPrompt::new(
            default_control_prompt(),
            symbol_ref("test", "input"),
            default_control_result_shape(),
        ),
        {
            let expected = expected.clone();
            move |_cx| Ok(expected)
        },
    )
    .unwrap();

    assert_eq!(actual, expected);
    let events = cx.effect_ledger().events_for_run();
    assert!(matches!(events[0].kind, EventKind::EffectRequested { .. }));
    assert!(matches!(events[1].kind, EventKind::EffectResolved { .. }));
}

#[test]
fn capture_without_capability_is_denied() {
    let mut cx = cx();

    let err = capture(
        &mut cx,
        ControlCapture::new(
            default_control_prompt(),
            symbol_ref("test", "continuation"),
            symbol_ref("test", "value"),
            default_control_result_shape(),
        ),
    )
    .unwrap_err();

    assert!(
        matches!(err, Error::CapabilityDenied { capability } if capability == control_capture_capability())
    );
}

#[test]
fn noop_policy_returns_structured_unsupported_result() {
    let mut cx = cx();
    cx.grant(control_capture_capability());

    let result = capture(
        &mut cx,
        ControlCapture::new(
            default_control_prompt(),
            symbol_ref("test", "continuation"),
            symbol_ref("test", "value"),
            default_control_result_shape(),
        ),
    )
    .unwrap();

    assert_eq!(
        control_result_status(&cx, &result).unwrap(),
        Some(control_unsupported_status())
    );
    assert_eq!(cx.diagnostics().messages().len(), 1);
    assert_eq!(
        cx.diagnostics().messages()[0].code,
        Some(control_unsupported_status())
    );
}

#[test]
fn multishot_capture_requires_multishot_capability() {
    let mut cx = cx();
    cx.grant(control_capture_capability());

    let err = capture(
        &mut cx,
        ControlCapture::new(
            default_control_prompt(),
            symbol_ref("test", "continuation"),
            symbol_ref("test", "value"),
            default_control_result_shape(),
        )
        .multishot(),
    )
    .unwrap_err();

    assert!(
        matches!(err, Error::CapabilityDenied { capability } if capability == control_multishot_capability())
    );
}