blazehash 0.2.4

Forensic file hasher — hashdeep for the modern era, BLAKE3 by default
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

use assert_cmd::Command;
use std::fs;
use tempfile::tempdir;

#[test]
fn test_dedup_finds_duplicate_files() {
    let dir = tempdir().unwrap();
    fs::write(dir.path().join("file1.bin"), b"same content").unwrap();
    fs::write(dir.path().join("file2.bin"), b"same content").unwrap();
    fs::write(dir.path().join("unique.bin"), b"unique content").unwrap();

    let output = Command::cargo_bin("blazehash")
        .unwrap()
        .args(["dedup", dir.path().to_str().unwrap(), "-c", "blake3"])
        .output()
        .unwrap();
    let stdout = String::from_utf8(output.stdout).unwrap();
    assert!(
        stdout.contains("file1.bin") || stdout.contains("file2.bin"),
        "expected duplicate files in output: {stdout}"
    );
}

#[test]
fn test_dedup_exits_one_when_duplicates_found() {
    let dir = tempdir().unwrap();
    fs::write(dir.path().join("a.bin"), b"dup").unwrap();
    fs::write(dir.path().join("b.bin"), b"dup").unwrap();

    Command::cargo_bin("blazehash")
        .unwrap()
        .args(["dedup", dir.path().to_str().unwrap()])
        .assert()
        .code(1);
}

#[test]
fn test_dedup_exits_zero_when_no_duplicates() {
    let dir = tempdir().unwrap();
    fs::write(dir.path().join("a.bin"), b"aaa").unwrap();
    fs::write(dir.path().join("b.bin"), b"bbb").unwrap();

    Command::cargo_bin("blazehash")
        .unwrap()
        .args(["dedup", dir.path().to_str().unwrap()])
        .assert()
        .code(0);
}

#[test]
fn test_dedup_from_manifest() {
    let dir = tempdir().unwrap();
    let manifest = dir.path().join("manifest.hash");
    std::fs::write(&manifest,
        "%%%% HASHDEEP-1.0\n%%%% size,blake3,filename\n##\n5,aaaa,/a.bin\n5,aaaa,/b.bin\n5,bbbb,/c.bin\n"
    ).unwrap();

    let output = Command::cargo_bin("blazehash")
        .unwrap()
        .args(["dedup", manifest.to_str().unwrap()])
        .output()
        .unwrap();
    let stdout = String::from_utf8(output.stdout).unwrap();
    assert!(
        stdout.contains("a.bin") || stdout.contains("b.bin"),
        "expected duplicate files: {stdout}"
    );
}

#[test]
fn test_dedup_dupes_excludes_canonical() {
    let dir = tempdir().unwrap();
    fs::write(dir.path().join("a.bin"), b"same").unwrap();
    fs::write(dir.path().join("b.bin"), b"same").unwrap();
    fs::write(dir.path().join("c.bin"), b"same").unwrap();

    let output = Command::cargo_bin("blazehash")
        .unwrap()
        .args(["dedup", "--dedup-dupes", dir.path().to_str().unwrap()])
        .output()
        .unwrap();
    let stdout = String::from_utf8(output.stdout).unwrap();
    let lines: Vec<&str> = stdout.lines().collect();
    // Should print 2 redundant copies (not 3 — canonical is excluded)
    assert_eq!(lines.len(), 2, "expected 2 redundant copies, got: {stdout}");
}

#[test]
fn test_dedup_grouping_is_deterministic() {
    let dir = tempdir().unwrap();
    fs::write(dir.path().join("a.bin"), b"dup").unwrap();
    fs::write(dir.path().join("b.bin"), b"dup").unwrap();

    let out1 = Command::cargo_bin("blazehash")
        .unwrap()
        .args(["dedup", dir.path().to_str().unwrap(), "-c", "blake3"])
        .output()
        .unwrap();
    let out2 = Command::cargo_bin("blazehash")
        .unwrap()
        .args(["dedup", dir.path().to_str().unwrap(), "-c", "blake3"])
        .output()
        .unwrap();
    assert_eq!(
        out1.stdout, out2.stdout,
        "dedup output must be deterministic"
    );
}