yog 0.0.57

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

//! The one room both intakes open onto.

use super::*;
use crate::boundary::consumer::ConsumerCtx;
use crate::cli_outbound::Cli;
use crate::ui_state::SystemClock;
use crate::wire::server::Answerer;
use serde_json::json;
use std::path::PathBuf;
use tempfile::tempdir;

/// The in-world caller as a peer — operator grade, which every intake without
/// a certificate is (REMOTE §4.2).
fn local() -> crate::registry::Peer {
    crate::registry::Peer {
        client: crate::registry::Client::local(),
        grade: crate::registry::Grade::Operator,
    }
}

fn intake(state_root: &std::path::Path) -> Intake {
    let snap = Arc::new(crate::app::Snapshot::empty(0));
    Intake::new(Arc::new(ConsumerCtx {
        yog_binary: PathBuf::from("/no/such/yog"),
        world: crate::test_support::no_world(),
        litany: Cli::new("/no/such/litany"),
        bl: Cli::new("/no/such/bl"),
        state_root: state_root.to_path_buf(),
        home: PathBuf::from("/home/x"),
        yog_data_root: PathBuf::from("/data"),
        ui_path: state_root.join("ui.json"),
        cell: crate::state::new_snapshot_cell(snap),
        presence: crate::registry::presence::Presence::default(),
        mailbox: crate::registry::mailbox::Mailbox::default(),
        logins: crate::login::runs::Runs::default(),
        listening: crate::wire::Listening::default(),
        clock: Arc::new(SystemClock),
    }))
}

/// A seat as a peer, **registered somewhere** — which is what a certificate
/// that has been enrolled is, and what an answer rather than the bl-2a84
/// refusal needs. `local` stands in for a wire peer nowhere else because no
/// certificate can carry that name (`Client::parse` refuses it).
fn seated(state_root: &std::path::Path) -> crate::registry::Peer {
    let client = crate::registry::Client::parse("laptop").expect("identity");
    crate::registry::register(state_root, &client, "home").expect("its enrolment's file");
    crate::registry::Peer {
        client,
        grade: crate::registry::Grade::Operator,
    }
}

/// A request becomes a one-frame reply stream — today's every answer.
#[test]
fn a_request_is_one_reply_frame() {
    let root = tempdir().expect("tmp");
    let stream: Vec<_> = intake(root.path())
        .answer(&seated(root.path()), json!({"op": "workspaces"}))
        .collect();
    assert_eq!(stream.len(), 1);
    assert_eq!(stream[0]["kind"], "workspaces");
    assert_eq!(stream[0]["ok"], true);
}

/// **The wire adds no verb** (REMOTE §3): a request the codec does not know is
/// refused by the codec, in-band, exactly as a deposited one is.
#[test]
fn an_unknown_verb_refuses_in_band() {
    let root = tempdir().expect("tmp");
    let stream: Vec<_> = intake(root.path())
        .answer(&local(), json!({"op": "teleport"}))
        .collect();
    assert_eq!(stream.len(), 1);
    assert_eq!(stream[0]["ok"], false);
    assert!(
        stream[0]["error"]
            .as_str()
            .unwrap_or_default()
            .contains("teleport"),
        "names the offender: {}",
        stream[0]
    );
}

/// **A client that speaks is seen** (bl-d542): the stamp is written at this one
/// door, per request, ahead of both arms — so a follow-class read that parks
/// for thirty seconds is stamped when it arrives rather than when it ends.
#[test]
fn answering_a_request_stamps_the_client_as_seen() {
    let root = tempdir().expect("tmp");
    let peer = crate::registry::Peer {
        client: crate::registry::Client::parse("laptop").expect("identity"),
        grade: crate::registry::Grade::Operator,
    };
    crate::registry::register(root.path(), &peer.client, "home").expect("its enrolment's file");
    assert_eq!(crate::registry::seen::read(root.path(), &peer.client), None);
    let _ = intake(root.path())
        .answer(&peer, json!({"op": "workspaces"}))
        .count();
    assert!(
        crate::registry::seen::read(root.path(), &peer.client).is_some(),
        "the connection left a durable mark"
    );
}