alkblobs 0.1.0

Content-addressed blob storage: multi-hash put/get/verify store with pluggable backends, transport- and protocol-agnostic
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

use serde_json::json;

use crate::{fetch_ranges_ingress, FetchRange, RangedBounds};

#[test]
fn doc_hidden_reexports_reach_the_crate_root() {
    let bounds = RangedBounds {
        max_ranges: 4,
        max_total_bytes: 16,
    };
    assert_eq!(bounds.max_ranges, 4);
    assert_eq!(bounds.max_total_bytes, 16);

    let absent = fetch_ranges_ingress(&json!({}), &bounds).unwrap();
    assert!(absent.is_none(), "no ranges field is the whole form");

    let accepted = fetch_ranges_ingress(
        &json!({"ranges": [{"offset": 0, "len": 8}, {"offset": 16, "len": 4}]}),
        &bounds,
    )
    .unwrap();
    let ranges: &[FetchRange] = accepted.as_deref().expect("a within-bounds request parses");
    assert_eq!(ranges.len(), 2, "items parse in request order");
    assert_eq!((ranges[0].offset, ranges[0].len), (0, 8));
    assert_eq!((ranges[1].offset, ranges[1].len), (16, 4));

    let rejected = match fetch_ranges_ingress(
        &json!({"ranges": [{"offset": 0, "len": 12}, {"offset": 0, "len": 8}]}),
        &bounds,
    ) {
        Ok(_) => panic!("the over-bytes sum must reject"),
        Err(message) => message,
    };
    assert!(
        rejected.contains("total-bytes bound"),
        "the over-bytes sum is the ingress' own bound: {rejected}"
    );

    let malformed =
        match fetch_ranges_ingress(&json!({"ranges": [{"offset": 0, "len": -1}]}), &bounds) {
            Ok(_) => panic!("a malformed item must reject"),
            Err(message) => message,
        };
    assert!(
        malformed.contains("offset and len are required"),
        "a rejected item answers the stable domain text: {malformed}"
    );
}