blazehash 0.2.5

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
109
110
111
112

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

const MANIFEST_CONTENT: &str = "\
## case: PATH-ONLY-TEST
%% created: 2026-04-14
sha256  aaaa1111111111111111111111111111111111111111111111111111111111111111  /evidence/file1.exe
blake3  bbbb2222222222222222222222222222222222222222222222222222222222222222  /docs/readme.txt
sha256  cccc3333333333333333333333333333333333333333333333333333333333333333  /images/photo.jpg
";

fn write_manifest(dir: &TempDir) -> std::path::PathBuf {
    let p = dir.path().join("test.hash");
    fs::write(&p, MANIFEST_CONTENT).unwrap();
    p
}

#[test]
fn test_path_only_emits_paths_one_per_line() {
    let dir = TempDir::new().unwrap();
    let manifest = write_manifest(&dir);
    let out = Command::cargo_bin("blazehash")
        .unwrap()
        .args(["path-only", manifest.to_str().unwrap()])
        .output()
        .unwrap();
    assert!(out.status.success(), "exit code must be 0");
    let stdout = String::from_utf8_lossy(&out.stdout);
    let lines: Vec<&str> = stdout.lines().filter(|l| !l.is_empty()).collect();
    assert_eq!(lines.len(), 3, "expected exactly 3 output lines, got: {stdout:?}");
    assert!(lines[0].starts_with('/'), "each line must be a path, got: {}", lines[0]);
    assert!(lines[1].starts_with('/'), "each line must be a path, got: {}", lines[1]);
    assert!(lines[2].starts_with('/'), "each line must be a path, got: {}", lines[2]);
}

#[test]
fn test_path_only_skips_headers() {
    let dir = TempDir::new().unwrap();
    let manifest = write_manifest(&dir);
    let out = Command::cargo_bin("blazehash")
        .unwrap()
        .args(["path-only", manifest.to_str().unwrap()])
        .output()
        .unwrap();
    assert!(out.status.success());
    let stdout = String::from_utf8_lossy(&out.stdout);
    assert!(
        !stdout.contains("##"),
        "output must not contain ## headers, got: {stdout:?}"
    );
    assert!(
        !stdout.contains("%%"),
        "output must not contain %% headers, got: {stdout:?}"
    );
}

#[test]
fn test_path_only_no_algo_or_hash_in_output() {
    let dir = TempDir::new().unwrap();
    let manifest = write_manifest(&dir);
    let out = Command::cargo_bin("blazehash")
        .unwrap()
        .args(["path-only", manifest.to_str().unwrap()])
        .output()
        .unwrap();
    assert!(out.status.success());
    let stdout = String::from_utf8_lossy(&out.stdout);
    assert!(
        !stdout.contains("sha256"),
        "output must not contain algorithm name, got: {stdout:?}"
    );
    assert!(
        !stdout.contains("aaaa111"),
        "output must not contain hash value, got: {stdout:?}"
    );
}

#[test]
fn test_path_only_missing_manifest_fails() {
    let dir = TempDir::new().unwrap();
    let nonexistent = dir.path().join("does_not_exist.hash");
    let out = Command::cargo_bin("blazehash")
        .unwrap()
        .args(["path-only", nonexistent.to_str().unwrap()])
        .output()
        .unwrap();
    assert!(
        !out.status.success(),
        "must exit non-zero for missing manifest"
    );
}

#[test]
fn test_path_only_output_to_file() {
    let dir = TempDir::new().unwrap();
    let manifest = write_manifest(&dir);
    let out_path = dir.path().join("paths.txt");
    Command::cargo_bin("blazehash")
        .unwrap()
        .args([
            "path-only",
            manifest.to_str().unwrap(),
            "-o",
            out_path.to_str().unwrap(),
        ])
        .assert()
        .success();
    let content = fs::read_to_string(&out_path).unwrap();
    let lines: Vec<&str> = content.lines().filter(|l| !l.is_empty()).collect();
    assert_eq!(lines.len(), 3, "output file must have exactly 3 lines, got: {content:?}");
}