canic 0.102.0

Canic — a canister orchestration and management toolkit for the Internet Computer
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

use canic::{
    api::canister::deployment::ComponentDeploymentApi,
    dto::component_deployment::ProtectedComponentDeployment,
    ids::{
        ComponentDeploymentConfigurationDigest, ComponentGroupDeploymentId, ComponentGroupMemberId,
        ComponentGroupMemberPath, ComponentGroupPlacementId, ComponentGroupSpecId, FleetServiceId,
    },
};

#[test]
fn facade_exposes_bounded_component_deployment_identities() {
    let deployment = "project_data_cells"
        .parse::<ComponentGroupDeploymentId>()
        .expect("Component Group deployment ID");
    let path = ComponentGroupMemberPath::try_from(vec![
        "databases"
            .parse::<ComponentGroupMemberId>()
            .expect("included group member"),
        "database_a"
            .parse::<ComponentGroupMemberId>()
            .expect("Component member"),
    ])
    .expect("Component Group member path");
    let placement = ComponentGroupPlacementId {
        deployment: deployment.clone(),
        ordinal: 3,
    };

    assert_eq!(
        "project_data_cell"
            .parse::<ComponentGroupSpecId>()
            .expect("Component Group Spec ID")
            .as_str(),
        "project_data_cell"
    );
    assert_eq!(
        "database_a"
            .parse::<FleetServiceId>()
            .expect("Fleet Service ID")
            .as_str(),
        "database_a"
    );
    assert_eq!(placement.deployment, deployment);
    assert_eq!(placement.ordinal, 3);
    assert_eq!(path.len(), 2);
}

#[test]
fn facade_exposes_protected_component_deployment_policy() {
    let current: fn() -> Result<ProtectedComponentDeployment, canic::Error> =
        ComponentDeploymentApi::current;
    let require_authority: fn(&FleetServiceId) -> Result<(), canic::Error> =
        ComponentDeploymentApi::require_service_authority;
    let access_guard: fn(&str) -> Result<(), canic::access::AccessError> =
        canic::access::deployment::require_service_authority;
    let digest = ComponentDeploymentConfigurationDigest::from_bytes([7; 32]);

    assert_eq!(digest.as_bytes(), &[7; 32]);
    let _ = current;
    let _ = require_authority;
    let _ = access_guard;
}