trellis-core 0.2.1

Deterministic reconciler: state changes in; resource commands, output frames, and auditable receipts out.
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

use trellis_core::{
    Graph, HostResourceCommandState, HostResourceOutcome, HostResourceStatus, HostStatusClass,
    ResourceKey, Revision, ScopeId, classify_host_resource_status,
};

fn scopes() -> (ScopeId, ScopeId) {
    let mut graph = Graph::<()>::new_with_command_type();
    let mut tx = graph.begin_transaction().unwrap();
    let primary = tx.create_scope("primary").unwrap();
    let other = tx.create_scope("other").unwrap();
    tx.commit().unwrap();
    (primary, other)
}

fn status(
    scope: ScopeId,
    command_revision: u64,
    status: HostResourceOutcome,
) -> HostResourceStatus {
    HostResourceStatus::new(
        ResourceKey::new("device:1"),
        scope,
        Revision::new(command_revision),
        Revision::new(100),
        status,
    )
}

fn live_state(
    scope: ScopeId,
    command_revision: u64,
    scope_owns_resource: bool,
) -> HostResourceCommandState {
    HostResourceCommandState {
        scope,
        command_revision: Revision::new(command_revision),
        resource_is_live: true,
        scope_owns_resource,
    }
}

fn closed_state(scope: ScopeId, command_revision: u64) -> HostResourceCommandState {
    HostResourceCommandState {
        scope,
        command_revision: Revision::new(command_revision),
        resource_is_live: false,
        scope_owns_resource: false,
    }
}

#[test]
fn live_resource_status_classifies_current_and_duplicate_revisions() {
    let (scope, _) = scopes();
    let status = status(scope, 3, HostResourceOutcome::Open);
    let state = live_state(scope, 3, true);

    assert_eq!(
        classify_host_resource_status(&status, Some(state), false),
        HostStatusClass::Current
    );
    assert_eq!(
        classify_host_resource_status(&status, Some(state), true),
        HostStatusClass::Duplicate
    );
}

#[test]
fn live_resource_status_classifies_stale_and_future_revisions() {
    let (scope, _) = scopes();
    let state = live_state(scope, 3, true);

    assert_eq!(
        classify_host_resource_status(
            &status(scope, 2, HostResourceOutcome::Failed("lost".to_owned())),
            Some(state),
            false
        ),
        HostStatusClass::Stale
    );
    assert_eq!(
        classify_host_resource_status(
            &status(scope, 4, HostResourceOutcome::Open),
            Some(state),
            false
        ),
        HostStatusClass::Future
    );
}

#[test]
fn live_resource_status_is_late_for_unknown_resource_or_non_owner_scope() {
    let (scope, other) = scopes();

    assert_eq!(
        classify_host_resource_status(&status(scope, 3, HostResourceOutcome::Open), None, false),
        HostStatusClass::Late
    );
    assert_eq!(
        classify_host_resource_status(
            &status(other, 3, HostResourceOutcome::Open),
            Some(live_state(scope, 3, false)),
            false
        ),
        HostStatusClass::Late
    );
}

#[test]
fn closed_resource_accepts_only_matching_scope_closed_ack() {
    let (scope, other) = scopes();
    let state = closed_state(scope, 3);

    assert_eq!(
        classify_host_resource_status(
            &status(scope, 3, HostResourceOutcome::Closed),
            Some(state),
            false
        ),
        HostStatusClass::Current
    );
    assert_eq!(
        classify_host_resource_status(
            &status(scope, 3, HostResourceOutcome::Open),
            Some(state),
            false
        ),
        HostStatusClass::Late
    );
    assert_eq!(
        classify_host_resource_status(
            &status(other, 3, HostResourceOutcome::Closed),
            Some(state),
            false
        ),
        HostStatusClass::Late
    );
}