lernie 0.1.39

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
127
128

//! A gesture that names no workspace, asked of every channel this box holds.

use super::fanned;
use crate::channel::entries::WORKSPACE;
use crate::cli::Stream;
use crate::render::Form;
use crate::test_support::wire::{entry, flat, wired, yes};
use crate::test_support::{Scratch, mint};
use serde_json::json;

/// **The union, stamped**: this box's own engine first, then the entries in
/// leaf order, each answer under the name of the channel it came from — the
/// same composition the window's roster is, so the two surfaces agree on one
/// box (bl-0d54).
#[test]
fn every_channel_answers_under_its_own_name() {
    let scratch = Scratch::new();
    let own = wired(&scratch, &flat(), vec![vec![yes()]]);
    let alpha = wired(
        &scratch,
        &entry("alpha"),
        vec![vec![json!({"ok": true, "n": 1})]],
    );

    let verdict = fanned(scratch.path(), &json!({"op": "workspaces"}), Form::Json);
    assert_eq!(verdict.code, 0);
    assert_eq!(verdict.stream, Stream::Out);
    assert_eq!(
        verdict.text,
        format!(
            "(this box's own engine)\n    {}\nalpha\n    {}",
            yes(),
            json!({"ok": true, "n": 1})
        )
    );
    assert!(own.heard().contains(&json!({"op": "workspaces"})));
    assert!(alpha.heard().contains(&json!({"op": "workspaces"})));
}

/// **The sharp case**: a box that holds no engine of its own and is a client of
/// a server elsewhere. It has channels, it has workspaces — and the verb whose
/// whole subject is "every workspace" used to tell the operator nothing was
/// provisioned.
#[test]
fn a_box_with_no_flat_channel_still_answers_from_its_entries() {
    let scratch = Scratch::new();
    wired(&scratch, &entry("alpha"), vec![vec![yes()]]);
    let verdict = fanned(scratch.path(), &json!({"op": "workspaces"}), Form::Json);
    assert_eq!(verdict.code, 0, "{}", verdict.text);
    assert!(
        verdict.text.contains(&yes().to_string()),
        "{}",
        verdict.text
    );
}

/// **The hole is still SAID.** A flat root that holds nothing is a real gap on
/// a box that is supposed to hold one, so it keeps its section and its own
/// sentence beside the entries that answered.
#[test]
fn a_channel_that_cannot_answer_says_so_beside_the_ones_that_did() {
    let scratch = Scratch::new();
    wired(&scratch, &entry("alpha"), vec![vec![yes()]]);
    let verdict = fanned(scratch.path(), &json!({"op": "workspaces"}), Form::Json);
    let lines: Vec<&str> = verdict.text.lines().collect();
    assert_eq!(lines[0], "(this box's own engine)");
    assert!(lines[1].contains("no wire provisioned at"), "{}", lines[1]);
    assert_eq!(lines[2], "alpha");
}

/// A channel that renames carries the host's spelling in its stamp, exactly as
/// the listing prints it — one home for the label, so the two cannot disagree.
#[test]
fn a_renamed_entry_is_stamped_the_way_the_listing_names_it() {
    let scratch = Scratch::new();
    wired(&scratch, &entry("alpha"), vec![vec![yes()]]);
    std::fs::write(
        scratch.path().join(entry("alpha")).join(WORKSPACE),
        "personal",
    )
    .expect("the workspace file");
    let verdict = fanned(scratch.path(), &json!({"op": "workspaces"}), Form::Json);
    assert!(
        verdict
            .text
            .contains(r#"alpha (named "personal" on its host)"#),
        "{}",
        verdict.text
    );
}

/// **A fan that learned nothing is a failure**, because only then was the
/// question unanswered — where one good channel among several is an answer,
/// and the rest say why they are not.
#[test]
fn a_box_no_channel_of_which_answers_fails() {
    let scratch = Scratch::new();
    mint::provisioned(&scratch.path().join(entry("alpha")), "127.0.0.1:1");
    let verdict = fanned(scratch.path(), &json!({"op": "workspaces"}), Form::Json);
    assert_eq!(verdict.code, 1);
    assert!(
        verdict.text.contains("connect 127.0.0.1:1"),
        "{}",
        verdict.text
    );
    assert!(
        verdict.text.contains("no wire provisioned at"),
        "{}",
        verdict.text
    );
}

/// An engine answering `ok: false` has ANSWERED, and its section is the
/// product — but it is not a channel this fan learned anything from, so it does
/// not carry the verdict on its own.
#[test]
fn a_channel_that_answers_no_is_printed_and_does_not_count_as_an_answer() {
    let scratch = Scratch::new();
    wired(
        &scratch,
        &flat(),
        vec![vec![json!({"ok": false, "said": "no"})]],
    );
    let verdict = fanned(scratch.path(), &json!({"op": "workspaces"}), Form::Json);
    assert_eq!(verdict.code, 1);
    assert_eq!(verdict.stream, Stream::Out, "an answer is not a diagnosis");
    assert!(verdict.text.contains(r#""said":"no""#), "{}", verdict.text);
}