yog 0.0.76

yog: the standalone server for litany loops — the world, the balls and the conversations, behind one wire
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
129
130
131
132
133
134
135
136
137

//! The **§9 config family's** line parity (bl-719a's carrier, bl-2410's sixth
//! member): every read of that family, through the line and back.
//!
//! Its own file beside `balls`/`inspector`/`policy`/`tools` on the seam those
//! four already draw — one family, one file — and because the parent reached
//! §12's cap when the sixth member arrived.

use super::rt;
use crate::boundary::config::{ConfigFile, Read};
use crate::boundary::{Gesture, Query};

/// The config family's reads (§8.5, bl-0164): the same verb as the write
/// beside them, spelled with nothing after the destination.
#[test]
fn the_config_familys_reads_round_trip() {
    for file in [
        ConfigFile::Brazen {
            workspace: "ws".to_owned(),
        },
        ConfigFile::LitanyModels,
        ConfigFile::Cadence,
        ConfigFile::LitanyWorkflow {
            name: "review".to_owned(),
        },
    ] {
        rt(Gesture::Ask(Query::Config(Read::File { file })));
    }
    // A lineage destination reads too (bl-dff8), in all three of its origins:
    // the same words the write takes, with nothing after them.
    for origin in [
        crate::config_edit::branch::edit::EditOrigin::Advance,
        crate::config_edit::branch::edit::EditOrigin::Orphan,
        crate::config_edit::branch::edit::EditOrigin::Fork {
            source: "base".to_owned(),
        },
    ] {
        rt(Gesture::Ask(Query::Config(Read::File {
            file: ConfigFile::Branch {
                workspace: "ws".to_owned(),
                lineage: "strict".to_owned(),
                origin,
                path: "workflow.yaml".to_owned(),
            },
        })));
    }
    rt(Gesture::Ask(Query::Config(Read::Marks {
        workspace: "ws".to_owned(),
    })));
    rt(Gesture::Ask(Query::Config(Read::Roles {
        workspace: "ws".to_owned(),
    })));
    rt(Gesture::Ask(Query::Config(Read::Providers {
        workspace: "ws".to_owned(),
    })));
    // The browse and the roster beside them (bl-dff8).
    rt(Gesture::Ask(Query::Config(Read::Lineages {
        workspace: "ws".to_owned(),
    })));
    rt(Gesture::Ask(Query::Config(Read::Models {
        workspace: "ws".to_owned(),
        provider: "acme".to_owned(),
    })));
}

/// **The §8.3 sign-in, both halves** (REMOTE §8.3, bl-c285): the act and its
/// lane, in this file because they are the sixth thing a provider row is
/// addressed by — `/providers` lists the rows, `/model` picks off one, and
/// these two sign one in and watch it. Both elide the workspace, which is the
/// seat's, and state the row, which is not.
#[test]
fn the_sign_in_and_its_lane_round_trip() {
    rt(Gesture::Act(crate::boundary::Action::Login {
        workspace: "ws".to_owned(),
        provider: "acme".to_owned(),
    }));
    rt(Gesture::Ask(Query::LoginTail {
        workspace: "ws".to_owned(),
        provider: "acme".to_owned(),
    }));
}

/// Neither takes a bare line: a sign-in with no row named is not a gesture, and
/// a lane with none is not a question. The refusal names the usage rather than
/// guessing at a row, exactly as `/models`' does.
#[test]
fn a_sign_in_with_no_provider_named_refuses_with_its_usage() {
    for verb in ["login", "login-tail"] {
        let refusal = crate::boundary::line::parse(&format!("/{verb}"), &super::super::ctx())
            .expect_err("a row is required");
        assert!(refusal.contains("usage"), "{verb}: {refusal}");
        assert!(
            crate::boundary::line::parse(&format!("/{verb} a b"), &super::super::ctx()).is_err(),
            "{verb}: one word, not a sentence"
        );
    }
}

/// **The §9.6 learning-loop pair, both depths and both verdicts** (bl-dd88).
/// The read at its two depths, because naming an id and naming none are two
/// questions; the settle at both, because the verdict is the whole of what the
/// line says and a table that only spelled accept would prove only that.
#[test]
fn the_learning_loops_pair_round_trips() {
    for id in [None, Some("20260906T090000Z-r001".to_owned())] {
        rt(Gesture::Ask(Query::Config(Read::Proposals {
            workspace: "ws".to_owned(),
            id,
        })));
    }
    for verdict in [
        crate::proposals::Verdict::Accept,
        crate::proposals::Verdict::Reject,
    ] {
        rt(Gesture::Act(crate::boundary::Action::Config(
            crate::boundary::config::Write::Proposal(crate::proposals::Settle {
                workspace: "ws".to_owned(),
                id: "20260906T090000Z-r001".to_owned(),
                verdict,
            }),
        )));
    }
}

/// Both refusals of the pair, in the words the line gives them: the read takes
/// at most one id, and the settle takes exactly an id and a verdict — a
/// mistyped verdict is refused rather than guessed at, because the destructive
/// half must never be reached by a typo.
#[test]
fn the_pairs_usages_refuse_rather_than_guess() {
    use crate::boundary::line::parse;
    let ctx = crate::boundary::line::tests::ctx();
    assert!(parse("/proposals a b", &ctx).is_err());
    assert!(parse("/proposal", &ctx).is_err());
    assert!(parse("/proposal only-an-id", &ctx).is_err());
    assert!(parse("/proposal an-id maybe", &ctx).is_err());
    assert!(parse("/proposal an-id accept extra", &ctx).is_err());
}