yog 0.0.55

yog: the standalone server for litany loops — the world, the balls and the conversations, behind one wire
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

//! **What an answer stands over** (bl-94a5): the row a widened answer writes,
//! the class it is keyed on, and the two refusals that keep a wide one from
//! being given where permanence is wrong.

use super::{AGENT, Answer, Answers, Effect, Ruling, Scope, Standing, World, answer_hold, request};
use crate::control::judge::class_key;
use crate::control::policy::Policy;
use crate::opslog::tail;

/// The sentence litany's mark carries for an opaque routed call — the shape
/// bl-b65d's eleven holds all wore.
const OPAQUE: &str = "beta2_read_log {\"path\":\"/var/log/syslog\"} classified opaque \
                      (beta2_read_log is not a tool this control implements)";

/// Answer the park in `world` at `scope`, and hand back the trail.
fn answer(world: &World, scope: Scope) -> Result<Vec<crate::opslog::OpEntry>, String> {
    answer_hold(
        &world.deps(),
        "1000",
        &world.workspace(),
        AGENT,
        Answer {
            ruling: Ruling::Pass,
            scope,
        },
    )?;
    Ok(tail(&world.state(), usize::MAX))
}

#[test]
fn a_conversation_answer_is_keyed_on_the_conversation_and_the_class() {
    let world = World::new();
    world.repo();
    world.park_as(AGENT, "toolu_1", "beta2_read_log", OPAQUE);
    let rows = answer(&world, Scope::Conversation).expect("something is parked");
    let class = class_key("beta2_read_log", Effect::Opaque);
    assert_eq!(
        rows[0].argv,
        vec![
            "yog-control".to_owned(),
            "answer".to_owned(),
            format!("{AGENT} {class}"),
            "pass".to_owned(),
            "conversation".to_owned(),
        ]
    );
    // And it stands: the *next* call of that class, with another id and
    // another path, is answered without the operator being asked again.
    assert_eq!(
        Answers::fold(&rows).ruling(
            &request("toolu_2", "beta2_read_log", AGENT),
            &crate::nav::ws_key(&world.workspace()),
            Effect::Opaque,
            &Policy::default(),
        ),
        Standing {
            ruling: Ruling::Pass,
            scope: Scope::Conversation
        }
    );
}

#[test]
fn a_workspace_answer_is_keyed_on_the_class_and_the_row_s_own_workspace() {
    let world = World::new();
    world.repo();
    world.park_as(AGENT, "toolu_1", "beta2_read_log", OPAQUE);
    let rows = answer(&world, Scope::Workspace).expect("something is parked");
    assert_eq!(
        rows[0].argv,
        vec![
            "yog-control",
            "answer",
            "beta2_read_log@opaque",
            "pass",
            "workspace"
        ]
    );
    assert_eq!(rows[0].cwd, crate::nav::ws_key(&world.workspace()));
    // A conversation that never held anything is covered by it.
    assert_eq!(
        Answers::fold(&rows)
            .ruling(
                &request("toolu_9", "beta2_read_log", "somebody-else"),
                &crate::nav::ws_key(&world.workspace()),
                Effect::Opaque,
                &Policy::default(),
            )
            .ruling,
        Ruling::Pass
    );
}

#[test]
fn loss_is_answered_for_the_call_in_front_of_you_and_never_for_a_class() {
    let world = World::new();
    world.repo();
    world.park_as(
        AGENT,
        "toolu_1",
        "alpha2_Bash",
        "alpha2_Bash {\"command\":\"rm -rf /srv\"} classified destructive (`rm` reaches /srv)",
    );
    for scope in [Scope::Conversation, Scope::Workspace] {
        let refused = answer(&world, scope).expect_err("a class of destructive calls, forever");
        assert!(refused.contains("--scope call only"), "{refused}");
        assert!(refused.contains("capability.yaml"), "{refused}");
    }
    // Nothing was written: a refused gesture is not a partial one.
    assert!(tail(&world.state(), usize::MAX).is_empty());
    // The call itself still answers.
    assert_eq!(answer(&world, Scope::Call).expect("the one call").len(), 2);
}

#[test]
fn a_mark_whose_class_cannot_be_read_takes_the_call_alone() {
    let world = World::new();
    world.repo();
    world.park_as(AGENT, "toolu_1", "bash", "held, and nothing more is said");
    let refused = answer(&world, Scope::Conversation).expect_err("no class, no class grant");
    assert!(refused.contains("does not say which class"), "{refused}");
    assert!(refused.contains("--scope call"), "{refused}");
    assert!(tail(&world.state(), usize::MAX).is_empty());
    // …and the narrow answer is unaffected, because it stands over an id.
    assert!(answer(&world, Scope::Call).is_ok());
}