lernie 0.1.60

lernie: the operator seat — the window and wire client for a yog server
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
123
124
125
126

//! The config family as data: the row, and the typed door whose destination is
//! a nested object.

use super::{Where, config, lineages};
use crate::envelope;
use serde_json::json;

/// **The listing is a row like any other**, and its door builds the envelope
/// the command line would have.
#[test]
fn the_lineages_row_builds_the_envelope_its_word_names() {
    assert_eq!(
        lineages("home".to_owned()),
        json!({"op": "lineages", "workspace": "home"})
    );
    assert_eq!(super::LINEAGES.usage(), "lernie lineages <workspace>");
}

/// **Each destination is the `target` object the wire spells**, and the read
/// is the gesture with no `text` at all — upstream's own discriminator, so a
/// read this seat composes can never be mistaken for a write.
#[test]
fn every_destination_is_the_target_the_wire_spells_and_carries_no_text() {
    for (at, target) in [
        (
            Where::Brazen {
                workspace: "home".to_owned(),
            },
            json!({"file": "brazen", "workspace": "home"}),
        ),
        (Where::LitanyModels, json!({"file": "litany-models"})),
        (
            Where::LitanyWorkflow {
                name: "review".to_owned(),
            },
            json!({"file": "litany-workflow", "name": "review"}),
        ),
        (Where::Cadence, json!({"file": "cadence"})),
        (
            Where::Branch {
                workspace: "home".to_owned(),
                lineage: "default".to_owned(),
                path: "providers.yaml".to_owned(),
            },
            json!({"file": "branch", "workspace": "home", "lineage": "default",
                   "path": "providers.yaml", "origin": "advance"}),
        ),
    ] {
        let built = config(&at);
        assert_eq!(built[envelope::OP], json!("config"), "{}", at.label());
        assert_eq!(built[envelope::TARGET], target, "{}", at.label());
        assert!(
            built.get("text").is_none(),
            "a read carries no text: {built}"
        );
    }
}

/// **Two destinations name a workspace and three name an engine**, which is
/// what decides whether §8.2 routes the gesture by an address or the pane
/// addresses a channel outright.
#[test]
fn only_the_two_workspace_destinations_are_routed_by_an_address() {
    let branch = Where::Branch {
        workspace: "home".to_owned(),
        lineage: "default".to_owned(),
        path: "providers.yaml".to_owned(),
    };
    for at in [
        Where::Brazen {
            workspace: "home".to_owned(),
        },
        branch.clone(),
    ] {
        assert!(at.addresses_a_workspace(), "{}", at.label());
        assert_eq!(
            envelope::workspace(&config(&at)).as_deref(),
            Some("home"),
            "and the seat reads that address off the nested target"
        );
    }
    for at in [
        Where::LitanyModels,
        Where::Cadence,
        Where::LitanyWorkflow {
            name: "review".to_owned(),
        },
    ] {
        assert!(!at.addresses_a_workspace(), "{}", at.label());
        assert_eq!(envelope::workspace(&config(&at)), None);
    }
    assert_eq!(branch.label(), "default: providers.yaml");
    assert_eq!(Where::LitanyModels.label(), "litany models");
    assert_eq!(
        Where::LitanyWorkflow {
            name: "review".to_owned()
        }
        .label(),
        "workflow review"
    );
    assert_eq!(Where::Cadence.label(), "cadence");
    assert_eq!(
        Where::Brazen {
            workspace: "home".to_owned()
        }
        .label(),
        "brazen"
    );
}

/// **The write is the read's envelope and the whole new text**, which is
/// upstream's own discriminator: `text` present is a write, absent is a read,
/// and nothing else separates them (REMOTE §8.5, §9.18).
#[test]
fn the_write_is_the_read_plus_the_whole_text() {
    let at = Where::Cadence;
    let read = super::config(&at);
    let write = super::write(&at, "beat: 1\n".to_owned());
    assert_eq!(read["op"], "config");
    assert_eq!(read.get("text"), None, "no text is what makes it a read");
    assert_eq!(
        write["target"], read["target"],
        "one destination, one encoding"
    );
    assert_eq!(write["text"], "beat: 1\n");
}