khive-storage 0.12.0

Storage capability contracts and backend-neutral request context.
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
138
139
140
141
142
143
144
145
146

use super::*;

#[test]
fn upload_id_roundtrips_and_rejects_path_or_noncanonical_input() {
    let id = UploadId::from_bytes(&[0xab; 16]);
    assert_eq!(id.as_str(), "ab".repeat(16));
    assert_eq!(
        serde_json::from_str::<UploadId>(&serde_json::to_string(&id).unwrap()).unwrap(),
        id
    );
    for invalid in [
        String::new(),
        "a".repeat(31),
        "a".repeat(33),
        "A".repeat(32),
        "g".repeat(32),
        "../outside".into(),
        "a/b".repeat(11),
    ] {
        assert!(UploadId::from_hex(&invalid).is_err());
        assert!(serde_json::from_value::<UploadId>(serde_json::json!(invalid)).is_err());
    }
}

#[test]
fn from_hex_accepts_valid_lowercase_digest() {
    let hex = "a".repeat(64);
    let cref = ContentRef::from_hex(hex.clone()).unwrap();
    assert_eq!(cref.as_str(), hex);
    assert_eq!(cref.to_string(), hex);
}

#[test]
fn from_hex_rejects_short_string() {
    let err = ContentRef::from_hex("abc").unwrap_err();
    assert!(
        err.contains("64"),
        "error must mention expected length: {err}"
    );
}

#[test]
fn from_hex_rejects_long_string() {
    let err = ContentRef::from_hex("a".repeat(65)).unwrap_err();
    assert!(
        err.contains("64"),
        "error must mention expected length: {err}"
    );
}

#[test]
fn from_hex_rejects_uppercase() {
    let err = ContentRef::from_hex("A".repeat(64)).unwrap_err();
    assert!(
        err.contains("lowercase"),
        "error must mention lowercase requirement: {err}"
    );
}

#[test]
fn from_hex_rejects_non_hex_characters() {
    let mut hex = "a".repeat(63);
    hex.push('z');
    let err = ContentRef::from_hex(hex).unwrap_err();
    assert!(
        err.contains("lowercase hex"),
        "error must mention hex requirement: {err}"
    );
}

#[test]
fn from_digest_bytes_matches_known_blake3_hash() {
    // BLAKE3("") -> af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262
    let hash = blake3_hash_of_empty();
    let cref = ContentRef::from_digest_bytes(&hash);
    assert_eq!(
        cref.as_str(),
        "af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262"
    );
}

// hand-rolled BLAKE3("") vector (see docs/api/blob-store.md)
fn blake3_hash_of_empty() -> [u8; 32] {
    let hex = "af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262";
    let mut out = [0u8; 32];
    for (i, chunk) in hex.as_bytes().chunks(2).enumerate() {
        let s = std::str::from_utf8(chunk).unwrap();
        out[i] = u8::from_str_radix(s, 16).unwrap();
    }
    out
}

#[test]
fn deserialize_accepts_a_valid_lowercase_digest() {
    let hex = "d".repeat(64);
    let json = serde_json::to_string(&hex).unwrap();
    let cref: ContentRef = serde_json::from_str(&json).unwrap();
    assert_eq!(cref.as_str(), hex);
}

#[test]
fn deserialize_rejects_short_string() {
    let err = serde_json::from_str::<ContentRef>("\"x\"").unwrap_err();
    assert!(
        err.to_string().contains("64"),
        "deserialize error must mention the expected length: {err}"
    );
}

#[test]
fn deserialize_rejects_uppercase() {
    let hex = "A".repeat(64);
    let json = serde_json::to_string(&hex).unwrap();
    let err = serde_json::from_str::<ContentRef>(&json).unwrap_err();
    assert!(
        err.to_string().contains("lowercase"),
        "deserialize error must mention the lowercase requirement: {err}"
    );
}

#[test]
fn deserialize_rejects_non_hex_characters() {
    let mut hex = "a".repeat(63);
    hex.push('z');
    let json = serde_json::to_string(&hex).unwrap();
    let err = serde_json::from_str::<ContentRef>(&json).unwrap_err();
    assert!(
        err.to_string().contains("lowercase hex"),
        "deserialize error must mention the hex requirement: {err}"
    );
}

#[test]
fn content_ref_equality_and_hash_are_string_based() {
    let a = ContentRef::from_hex("b".repeat(64)).unwrap();
    let b = ContentRef::from_hex("b".repeat(64)).unwrap();
    let c = ContentRef::from_hex("c".repeat(64)).unwrap();
    assert_eq!(a, b);
    assert_ne!(a, c);

    use std::collections::HashSet;
    let mut set = HashSet::new();
    set.insert(a.clone());
    assert!(set.contains(&b));
    assert!(!set.contains(&c));
}