lernie 0.1.36

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
129
130
131
132
133
134
135
136
137

//! The block's four composers: what each carries, and the absence that makes
//! the control that spends it dark.

use serde_json::json;

use super::Authoring;
use crate::test_support::window::boarded;
use crate::ui::Model;

/// The block the fixture's wall opens on its one held ball.
fn amending() -> Model {
    let mut model = boarded();
    model.begin_amending(&crate::test_support::window::panes::board::bound("bl-1"));
    model
}

/// The block open on a ball that does not exist yet.
fn filing() -> Model {
    let mut model = boarded();
    model.begin_filing();
    model
}

/// What the block holds, for a test that types into it.
fn block(model: &mut Model) -> &mut Authoring {
    model.authoring.as_mut().expect("the block is open")
}

/// **A filing needs a project and a title**, and the body is optional — the
/// absence that makes `create` a door rather than a row.
#[test]
fn a_filing_goes_only_with_a_project_and_a_title() {
    let mut model = filing();
    assert!(block(&mut model).filing());
    assert_eq!(model.authoring.as_ref().and_then(Authoring::filed), None);

    block(&mut model).project = "  lernie ".to_owned();
    assert_eq!(model.authoring.as_ref().and_then(Authoring::filed), None);

    block(&mut model).title = " a title ".to_owned();
    assert_eq!(
        model.authoring.as_ref().and_then(Authoring::filed),
        Some(json!({
            "op": "create", "project": "lernie", "name": "home", "title": "a title"
        }))
    );

    block(&mut model).body = "the body".to_owned();
    assert_eq!(
        model.authoring.as_ref().and_then(Authoring::filed),
        Some(json!({
            "op": "create", "project": "lernie", "name": "home",
            "title": "a title", "body": "the body"
        }))
    );
}

/// **A block about an existing ball files nothing**, which is the fold's one
/// rule: one block, two subjects, and each offers only its own acts.
#[test]
fn a_block_about_a_held_ball_composes_no_filing() {
    let model = amending();
    assert_eq!(model.authoring.as_ref().and_then(Authoring::filed), None);
    assert!(!model.authoring.as_ref().is_some_and(Authoring::filing));
}

/// **An amendment carries only what was typed**, and an amendment of nothing
/// is not one: upstream refuses it by name, so this end never sends it.
#[test]
fn an_amendment_of_nothing_composes_nothing() {
    let mut model = amending();
    assert_eq!(model.authoring.as_ref().and_then(Authoring::amended), None);

    block(&mut model).note = "  what happened  ".to_owned();
    assert_eq!(
        model.authoring.as_ref().and_then(Authoring::amended),
        Some(json!({
            "op": "update", "project": "lernie", "id": "bl-1", "name": "home",
            "note": "what happened"
        }))
    );

    block(&mut model).title = "renamed".to_owned();
    block(&mut model).body = "rewritten".to_owned();
    assert_eq!(
        model.authoring.as_ref().and_then(Authoring::amended),
        Some(json!({
            "op": "update", "project": "lernie", "id": "bl-1", "name": "home",
            "title": "renamed", "body": "rewritten", "note": "what happened"
        }))
    );
}

/// **A release is offered whenever there is a ball**, because it is undone by
/// the claim on the board one section up. A filing has none to release.
#[test]
fn a_release_needs_nothing_but_a_ball() {
    assert_eq!(
        amending().authoring.as_ref().and_then(Authoring::released),
        Some(json!({
            "op": "release", "project": "lernie", "id": "bl-1", "name": "home"
        }))
    );
    assert_eq!(
        filing().authoring.as_ref().and_then(Authoring::released),
        None
    );
}

/// **The arming is the subject's own name** (§4.20): a delivery composes only
/// once the box holds this ball's id, and any other id arms nothing.
#[test]
fn a_delivery_waits_for_the_balls_own_id() {
    let mut model = amending();
    assert_eq!(
        model.authoring.as_ref().and_then(Authoring::delivered),
        None
    );

    block(&mut model).arm = "bl-2".to_owned();
    assert_eq!(
        model.authoring.as_ref().and_then(Authoring::delivered),
        None
    );

    block(&mut model).arm = " bl-1 ".to_owned();
    assert_eq!(
        model.authoring.as_ref().and_then(Authoring::delivered),
        Some(json!({
            "op": "close", "project": "lernie", "id": "bl-1", "name": "home"
        }))
    );
    assert_eq!(
        filing().authoring.as_ref().and_then(Authoring::delivered),
        None
    );
}