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
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

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

fn write_manifest(dir: &TempDir, name: &str, content: &str) -> std::path::PathBuf {
    let path = dir.path().join(name);
    fs::write(&path, content).unwrap();
    path
}

#[test]
fn test_annotate_adds_note_header() {
    let dir = TempDir::new().unwrap();
    let manifest = write_manifest(
        &dir,
        "manifest.hash",
        "## case: CASE001\n\
         sha256  abc123def456abc123def456abc123def456abc123def456abc123def456abc1  /tmp/file.txt\n",
    );
    let out = Command::cargo_bin("blazehash")
        .unwrap()
        .arg("annotate")
        .arg(&manifest)
        .arg("--note")
        .arg("test message")
        .output()
        .unwrap();
    let stdout = String::from_utf8_lossy(&out.stdout);
    assert!(
        stdout.contains("## note: test message"),
        "output should contain '## note: test message', got: {stdout}"
    );
}

#[test]
fn test_annotate_replaces_existing_note() {
    let dir = TempDir::new().unwrap();
    let manifest = write_manifest(
        &dir,
        "manifest.hash",
        "## case: CASE001\n\
         ## note: old note\n\
         sha256  abc123def456abc123def456abc123def456abc123def456abc123def456abc1  /tmp/file.txt\n",
    );
    let out = Command::cargo_bin("blazehash")
        .unwrap()
        .arg("annotate")
        .arg(&manifest)
        .arg("--note")
        .arg("new note")
        .output()
        .unwrap();
    let stdout = String::from_utf8_lossy(&out.stdout);
    assert!(
        stdout.contains("## note: new note"),
        "output should contain new note, got: {stdout}"
    );
    assert!(
        !stdout.contains("## note: old note"),
        "output should not contain old note, got: {stdout}"
    );
    let count = stdout.matches("## note:").count();
    assert_eq!(count, 1, "note should appear exactly once, got: {stdout}");
}

#[test]
fn test_annotate_preserves_other_headers() {
    let dir = TempDir::new().unwrap();
    let manifest = write_manifest(
        &dir,
        "manifest.hash",
        "## case: CASE_X\n\
         sha256  abc123def456abc123def456abc123def456abc123def456abc123def456abc1  /tmp/file.txt\n",
    );
    let out = Command::cargo_bin("blazehash")
        .unwrap()
        .arg("annotate")
        .arg(&manifest)
        .arg("--note")
        .arg("preserve test")
        .output()
        .unwrap();
    let stdout = String::from_utf8_lossy(&out.stdout);
    assert!(
        stdout.contains("## case: CASE_X"),
        "output should contain original case header, got: {stdout}"
    );
}

#[test]
fn test_annotate_preserves_data_entries() {
    let dir = TempDir::new().unwrap();
    let manifest = write_manifest(
        &dir,
        "manifest.hash",
        "## case: CASE001\n\
         sha256  abc123def456abc123def456abc123def456abc123def456abc123def456abc1  /tmp/file.txt\n",
    );
    let out = Command::cargo_bin("blazehash")
        .unwrap()
        .arg("annotate")
        .arg(&manifest)
        .arg("--note")
        .arg("data test")
        .output()
        .unwrap();
    let stdout = String::from_utf8_lossy(&out.stdout);
    assert!(
        stdout.contains("abc123def456abc123def456abc123def456abc123def456abc123def456abc1"),
        "output should contain original data entry, got: {stdout}"
    );
    assert!(
        stdout.contains("/tmp/file.txt"),
        "output should contain file path from data entry, got: {stdout}"
    );
}

#[test]
fn test_annotate_output_to_file() {
    let dir = TempDir::new().unwrap();
    let manifest = write_manifest(
        &dir,
        "manifest.hash",
        "## case: CASE001\n\
         sha256  abc123def456abc123def456abc123def456abc123def456abc123def456abc1  /tmp/file.txt\n",
    );
    let out_path = dir.path().join("annotated.hash");
    Command::cargo_bin("blazehash")
        .unwrap()
        .arg("annotate")
        .arg(&manifest)
        .arg("--note")
        .arg("file output test")
        .arg("-o")
        .arg(&out_path)
        .assert()
        .success();
    let content = fs::read_to_string(&out_path).unwrap();
    assert!(
        content.contains("## note: file output test"),
        "output file should contain note, got: {content}"
    );
}