canic-host 0.110.53

Host-side App build and desired-state Fleet reconciliation library for Canic workspaces
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

//! Terminal history, retained deliveries and owner-qualified pointers are independent observations.

use super::*;
use crate::fleet_ensure::view::release::provisioning::{
    ReleaseProvisioningIdentity, ReleaseProvisioningOwner,
};
use candid::Principal;

fn operation(state: ReleaseProvisioningState) -> ReleaseProvisioningFacts {
    ReleaseProvisioningFacts {
        identity: ReleaseProvisioningIdentity {
            owner: ReleaseProvisioningOwner::Provisioning,
            operation_id: [1; 32],
        },
        plan_hash: [2; 32],
        state,
        delivery_in_flight: None,
    }
}

#[test]
fn every_stage_preserves_uncertain_delivery_before_terminal_classification() {
    for (state, expected) in [
        (
            ReleaseProvisioningState::Accepted,
            ReleaseProvisioningDisposition::OwnerReconciliation,
        ),
        (
            ReleaseProvisioningState::Provisioned,
            ReleaseProvisioningDisposition::OwnerReconciliation,
        ),
        (
            ReleaseProvisioningState::Publishing,
            ReleaseProvisioningDisposition::OwnerReconciliation,
        ),
        (
            ReleaseProvisioningState::Published,
            ReleaseProvisioningDisposition::OwnerReconciliation,
        ),
        (
            ReleaseProvisioningState::Activating,
            ReleaseProvisioningDisposition::OwnerReconciliation,
        ),
        (
            ReleaseProvisioningState::RuntimesActive,
            ReleaseProvisioningDisposition::RecordedCompletion,
        ),
        (
            ReleaseProvisioningState::DirectoryPlanned,
            ReleaseProvisioningDisposition::OwnerReconciliation,
        ),
        (
            ReleaseProvisioningState::DirectorySynchronizing,
            ReleaseProvisioningDisposition::OwnerReconciliation,
        ),
        (
            ReleaseProvisioningState::DirectorySynchronized,
            ReleaseProvisioningDisposition::RecordedCompletion,
        ),
    ] {
        let mut facts = operation(state);
        assert_eq!(disposition(&facts), expected);
        let recipient = Principal::from_slice(&[3]);
        facts.delivery_in_flight = Some(recipient);
        assert_eq!(
            disposition(&facts),
            ReleaseProvisioningDisposition::DeliveryReconciliation { recipient }
        );
    }
}

#[test]
fn stale_active_pointer_never_revives_a_terminal_row_or_matches_another_owner() {
    let completed = operation(ReleaseProvisioningState::RuntimesActive);
    let directory = ReleaseProvisioningIdentity {
        owner: ReleaseProvisioningOwner::DirectorySynchronization,
        operation_id: completed.identity.operation_id,
    };
    let assessed = assess_provisioning(ReleaseRootProvisioningFacts {
        root: Principal::from_slice(&[4]),
        active: [completed.identity, directory].into(),
        operations: vec![completed.clone()],
    });
    assert_eq!(assessed.unmatched_active, [directory].into());
    assert_eq!(assessed.operations[0].facts, completed);
    assert_eq!(
        assessed.operations[0].disposition,
        ReleaseProvisioningDisposition::RecordedCompletion
    );
}

#[test]
fn empty_journal_preserves_missing_active_identities() {
    let identity = operation(ReleaseProvisioningState::Accepted).identity;
    for active in [std::collections::BTreeSet::new(), [identity].into()] {
        let facts = ReleaseRootProvisioningFacts {
            root: Principal::from_slice(&[4]),
            active: active.clone(),
            operations: vec![],
        };
        let assessed = assess_provisioning(facts);
        assert!(assessed.operations.is_empty());
        assert_eq!(assessed.unmatched_active, active);
    }
}