liminal-cli 0.3.4

The liminal command: serve the network, maintain its stores, or serve its discovery MCP over stdio
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

//! SDK-017 R3: call returns the reply as structured content, a one-way call
//! waits for nothing, and a refusal is the server's words verbatim.

use serde_json::json;

use super::call;
use crate::network::Rail as _;
use crate::network::fake::{Answer, FAKE_PASS_PREFIX, Fake};

#[test]
fn call_returns_the_workers_reply_as_structured_content() {
    let rail = Fake::new(json!({}), &[("echo.request", Answer::Echo)]);
    let answer = call(&rail, "echo.request", &json!({ "text": "hi" }), true, None);
    assert!(!answer.is_error, "{:?}", answer.structured);
    assert_eq!(answer.structured, json!({ "echoed": { "text": "hi" } }));
    assert_eq!(
        rail.pushed(),
        vec![("echo.request".to_owned(), json!({ "text": "hi" }))]
    );
    assert_eq!(rail.counts().read(), [1, 1, 0, 0, 1, 1]);
}

#[test]
fn call_without_reply_is_one_push_and_no_wait() {
    let rail = Fake::new(json!({}), &[("echo.request", Answer::Echo)]);
    let answer = call(&rail, "echo.request", &json!({ "text": "hi" }), false, None);
    assert!(!answer.is_error);
    assert_eq!(
        answer.structured,
        json!({ "subject": "echo.request", "sent": true })
    );
    assert_eq!(rail.counts().read(), [1, 1, 0, 0, 1, 0]);
}

#[test]
fn a_refusal_is_the_servers_words_verbatim() {
    let words = "the service serving echo.request left before answering";
    let rail = Fake::new(
        json!({}),
        &[("echo.request", Answer::Refuse(words.to_owned()))],
    );
    let answer = call(&rail, "echo.request", &json!({}), true, None);
    assert!(answer.is_error);
    assert_eq!(answer.structured["error"], words);
    assert_eq!(answer.structured["subject"], "echo.request");
}

#[test]
fn an_oversize_request_is_refused_before_anything_is_opened() {
    let rail = Fake::new(json!({}), &[("echo.request", Answer::Echo)]);
    let big = json!({ "text": "x".repeat(5000) });
    let answer = call(&rail, "echo.request", &big, true, None);
    assert!(answer.is_error);
    assert_eq!(
        answer.structured["error"],
        "the request is over 4096 bytes and was not sent"
    );
    assert_eq!(rail.counts().read(), [0, 0, 0, 0, 0, 0]);
}

#[test]
fn pass_for_puts_the_seats_pass_for_that_audience_in_the_input_as_pass() {
    let rail = Fake::new(json!({}), &[("echo.request", Answer::Echo)]);
    let answer = call(
        &rail,
        "echo.request",
        &json!({ "text": "hi" }),
        true,
        Some("haematite"),
    );
    assert!(!answer.is_error, "{:?}", answer.structured);
    assert_eq!(
        rail.pushed(),
        vec![(
            "echo.request".to_owned(),
            json!({ "text": "hi", "pass": format!("{FAKE_PASS_PREFIX}haematite") })
        )]
    );
}

#[test]
fn an_input_already_carrying_a_pass_is_refused_with_pass_for_and_nothing_is_sent() {
    let rail = Fake::new(json!({}), &[("echo.request", Answer::Echo)]);
    let answer = call(
        &rail,
        "echo.request",
        &json!({ "pass": "mine" }),
        true,
        Some("haematite"),
    );
    assert!(answer.is_error);
    assert!(rail.pushed().is_empty());
    assert_eq!(rail.counts().read(), [0, 0, 0, 0, 0, 0]);
}