greentic-pack-lib 0.4.115

Greentic pack builder and reader
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

use std::collections::BTreeMap;
use std::fs;

use greentic_pack::pack_lock::{
    LockedComponent, LockedOperation, PackLockV1, read_pack_lock, write_pack_lock,
};
use tempfile::TempDir;

#[test]
fn pack_lock_roundtrips_with_sorted_components() {
    let temp = TempDir::new().expect("temp dir");
    let path = temp.path().join("pack.lock.cbor");

    let mut components = BTreeMap::new();
    components.insert(
        "beta.component".to_string(),
        LockedComponent {
            component_id: "beta.component".to_string(),
            r#ref: Some("oci://example/beta:1.0.0".into()),
            abi_version: "0.6.0".to_string(),
            resolved_digest: "sha256:bbbb".into(),
            describe_hash: "b".repeat(64),
            operations: vec![LockedOperation {
                operation_id: "run".into(),
                schema_hash: "c".repeat(64),
            }],
            world: Some("greentic:component/component@0.6.0".into()),
            component_version: Some("1.0.0".into()),
            role: Some("tool".into()),
        },
    );
    components.insert(
        "alpha.component".to_string(),
        LockedComponent {
            component_id: "alpha.component".to_string(),
            r#ref: Some("repo://example/alpha?rev=1".into()),
            abi_version: "0.6.0".to_string(),
            resolved_digest: "sha256:aaaa".into(),
            describe_hash: "a".repeat(64),
            operations: vec![
                LockedOperation {
                    operation_id: "alpha".into(),
                    schema_hash: "e".repeat(64),
                },
                LockedOperation {
                    operation_id: "zeta".into(),
                    schema_hash: "d".repeat(64),
                },
            ],
            world: None,
            component_version: None,
            role: None,
        },
    );
    let lock = PackLockV1::new(components);

    write_pack_lock(&path, &lock).expect("write pack.lock");
    let first = fs::read(&path).expect("read file");

    let roundtrip = read_pack_lock(&path).expect("read pack.lock");
    assert_eq!(roundtrip.version, 1);
    assert_eq!(roundtrip.components.len(), 2);
    let alpha = roundtrip.components.get("alpha.component").expect("alpha");
    assert_eq!(alpha.operations[0].operation_id, "alpha");

    write_pack_lock(&path, &roundtrip).expect("write pack.lock again");
    let second = fs::read(&path).expect("read file again");
    assert_eq!(first, second, "lock bytes should be deterministic");
}