chkpt-core 0.3.1

Core library for chkpt – a fast, content-addressable checkpoint system
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

use chkpt_core::store::tree::{EntryType, TreeEntry, TreeStore};
use tempfile::TempDir;

fn loose_tree_path(dir: &TempDir, hash: &str) -> std::path::PathBuf {
    let (prefix, rest) = hash.split_at(2);
    dir.path().join(prefix).join(rest)
}

#[test]
fn test_tree_roundtrip() {
    let dir = TempDir::new().unwrap();
    let store = TreeStore::new(dir.path().to_path_buf());
    let entries = vec![
        TreeEntry {
            name: "bar.txt".into(),
            entry_type: EntryType::File,
            hash: [1u8; 16],
            size: 100,
            mode: 0o644,
        },
        TreeEntry {
            name: "foo.txt".into(),
            entry_type: EntryType::File,
            hash: [2u8; 16],
            size: 200,
            mode: 0o644,
        },
    ];
    let hash = store.write(&entries).unwrap();
    assert!(dir.path().join("trees.dat").exists());
    assert!(dir.path().join("trees.idx").exists());
    assert!(!loose_tree_path(&dir, &hash).exists());

    let read_back = store.read(&hash).unwrap();
    assert_eq!(read_back.len(), 2);
    assert_eq!(read_back[0].name, "bar.txt"); // sorted
}

#[test]
fn test_tree_hash_deterministic() {
    let dir = TempDir::new().unwrap();
    let store = TreeStore::new(dir.path().to_path_buf());
    let entries = vec![TreeEntry {
        name: "a.txt".into(),
        entry_type: EntryType::File,
        hash: [0u8; 16],
        size: 10,
        mode: 0o644,
    }];
    let h1 = store.write(&entries).unwrap();
    let h2 = store.write(&entries).unwrap();
    assert_eq!(h1, h2);
}

#[test]
fn test_tree_sorts_entries() {
    let dir = TempDir::new().unwrap();
    let store = TreeStore::new(dir.path().to_path_buf());
    let entries = vec![
        TreeEntry {
            name: "z".into(),
            entry_type: EntryType::File,
            hash: [0u8; 16],
            size: 0,
            mode: 0o644,
        },
        TreeEntry {
            name: "a".into(),
            entry_type: EntryType::File,
            hash: [1u8; 16],
            size: 0,
            mode: 0o644,
        },
    ];
    let hash = store.write(&entries).unwrap();
    let read_back = store.read(&hash).unwrap();
    assert_eq!(read_back[0].name, "a");
    assert_eq!(read_back[1].name, "z");
}

#[test]
fn test_tree_with_dir_entry() {
    let dir = TempDir::new().unwrap();
    let store = TreeStore::new(dir.path().to_path_buf());
    let entries = vec![
        TreeEntry {
            name: "src".into(),
            entry_type: EntryType::Dir,
            hash: [5u8; 16],
            size: 0,
            mode: 0o755,
        },
        TreeEntry {
            name: "README.md".into(),
            entry_type: EntryType::File,
            hash: [6u8; 16],
            size: 50,
            mode: 0o644,
        },
    ];
    let hash = store.write(&entries).unwrap();
    let read_back = store.read(&hash).unwrap();
    assert_eq!(read_back.len(), 2);
}