acyclic-fs 0.1.5

Rust SDK for versioned workspaces and embedded native mounts
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

use super::*;

#[test]
#[allow(clippy::too_many_lines)]
fn every_identity_round_trips_and_authority_hash_inputs_are_bound()
-> Result<(), Box<dyn std::error::Error>> {
    assert_ne!(AuthorityId::new().into_bytes(), [0; 16]);
    assert_ne!(AuthorityId::default().into_bytes(), [0; 16]);
    assert_eq!(AuthorityId::from_bytes([1; 16]).into_bytes(), [1; 16]);
    assert_ne!(OperationId::new().into_bytes(), [0; 16]);
    assert_ne!(OperationId::default().into_bytes(), [0; 16]);
    assert_eq!(OperationId::from_bytes([2; 16]).into_bytes(), [2; 16]);

    macro_rules! assert_uuid_identity {
        ($identity:ty, $byte:expr) => {{
            let fresh = <$identity>::new();
            let defaulted = <$identity>::default();
            assert_ne!(fresh.into_bytes(), [0; 16]);
            assert_ne!(defaulted.into_bytes(), [0; 16]);
            assert_eq!(
                <$identity>::from_bytes([$byte; 16]).into_bytes(),
                [$byte; 16]
            );
        }};
    }
    assert_uuid_identity!(VolumeId, 3);
    assert_uuid_identity!(CheckoutId, 4);
    assert_uuid_identity!(MountId, 5);
    assert_uuid_identity!(WatchId, 6);
    assert_uuid_identity!(FileId, 7);

    assert_eq!(Epoch::new(0), Err(IdentityError::ZeroEpoch));
    assert_eq!(Epoch::new(2)?.get(), 2);
    assert_eq!(Sequence::GENESIS.checked_next()?.get(), 1);
    assert_eq!(
        Sequence::new(u64::MAX).checked_next(),
        Err(IdentityError::SequenceExhausted)
    );
    let digest = Digest::from_bytes([8; 32]);
    assert_eq!(digest.as_bytes(), &[8; 32]);
    assert_eq!(digest.into_bytes(), [8; 32]);
    assert!(format!("{digest:?}").contains(&hex::encode([8; 32])));
    assert_eq!(GenerationId::new(digest).digest(), digest);
    assert_eq!(Head::genesis(Epoch::GENESIS).sequence, Sequence::GENESIS);
    assert_eq!(Head::genesis(Epoch::GENESIS).digest, Digest::ZERO);

    let authority = AuthorityId::from_bytes([9; 16]);
    let operation = OperationId::from_bytes([10; 16]);
    let base = authority_commit_digest(
        authority,
        Epoch::GENESIS,
        Sequence::new(1),
        operation,
        Digest::from_bytes([11; 32]),
        Digest::from_bytes([12; 32]),
        b"payload",
    );
    let changed = [
        authority_commit_digest(
            AuthorityId::from_bytes([13; 16]),
            Epoch::GENESIS,
            Sequence::new(1),
            operation,
            Digest::from_bytes([11; 32]),
            Digest::from_bytes([12; 32]),
            b"payload",
        ),
        authority_commit_digest(
            authority,
            Epoch::new(2)?,
            Sequence::new(1),
            operation,
            Digest::from_bytes([11; 32]),
            Digest::from_bytes([12; 32]),
            b"payload",
        ),
        authority_commit_digest(
            authority,
            Epoch::GENESIS,
            Sequence::new(2),
            operation,
            Digest::from_bytes([11; 32]),
            Digest::from_bytes([12; 32]),
            b"payload",
        ),
        authority_commit_digest(
            authority,
            Epoch::GENESIS,
            Sequence::new(1),
            OperationId::from_bytes([14; 16]),
            Digest::from_bytes([11; 32]),
            Digest::from_bytes([12; 32]),
            b"payload",
        ),
        authority_commit_digest(
            authority,
            Epoch::GENESIS,
            Sequence::new(1),
            operation,
            Digest::from_bytes([15; 32]),
            Digest::from_bytes([12; 32]),
            b"payload",
        ),
        authority_commit_digest(
            authority,
            Epoch::GENESIS,
            Sequence::new(1),
            operation,
            Digest::from_bytes([11; 32]),
            Digest::from_bytes([16; 32]),
            b"payload",
        ),
        authority_commit_digest(
            authority,
            Epoch::GENESIS,
            Sequence::new(1),
            operation,
            Digest::from_bytes([11; 32]),
            Digest::from_bytes([12; 32]),
            b"other",
        ),
    ];
    assert!(changed.into_iter().all(|candidate| candidate != base));
    Ok(())
}