rustdupe 0.2.0

Smart duplicate file finder with interactive TUI
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

use rustdupe::session::{Session, SessionGroup, SessionSettings};
use std::fs::{self, File};
use tempfile::tempdir;

#[test]
fn test_load_invalid_json() {
    let dir = tempdir().unwrap();
    let path = dir.path().join("invalid.json");
    fs::write(&path, "not a json").unwrap();

    let result = Session::load(&path);
    assert!(result.is_err());
    let err = result.unwrap_err().to_string();
    assert!(err.contains("Failed to parse session envelope"));
}

#[test]
fn test_load_empty_file() {
    let dir = tempdir().unwrap();
    let path = dir.path().join("empty.json");
    File::create(&path).unwrap();

    let result = Session::load(&path);
    assert!(result.is_err());
}

#[test]
fn test_load_unknown_version() {
    let dir = tempdir().unwrap();
    let path = dir.path().join("version.json");

    let session = Session::new(
        vec![dir.path().to_path_buf()],
        SessionSettings::default(),
        vec![],
    );

    // Manually create a session with an old version to bypass SESSION_VERSION check in new()
    let mut session_data = session.clone();
    session_data.version = 999;

    // We need to use to_json to get a valid envelope, but we want to override the version
    // The current Session::save doesn't allow overriding version easily if it's hardcoded to SESSION_VERSION in new
    // But Session struct fields are public, so we can just set it.

    session_data.save(&path).unwrap();

    let result = Session::load(&path);
    assert!(result.is_err());
    let err = result.unwrap_err().to_string();
    assert!(err.contains("Unsupported session version"));
    assert!(err.contains("999"));
}

#[test]
fn test_load_incorrect_integrity_hash() {
    let dir = tempdir().unwrap();
    let path = dir.path().join("tampered.json");

    let session = Session::new(
        vec![dir.path().to_path_buf()],
        SessionSettings::default(),
        vec![],
    );
    session.save(&path).unwrap();

    // Manually tamper with the session data in the JSON
    let mut content = fs::read_to_string(&path).unwrap();
    // Change group_index: 0 to group_index: 100
    assert!(content.contains("\"group_index\": 0"));
    content = content.replace("\"group_index\": 0", "\"group_index\": 100");
    fs::write(&path, content).unwrap();

    let result = Session::load(&path);
    assert!(result.is_err());
    let err = result.unwrap_err().to_string();
    assert!(err.contains("integrity check failed"));
}

#[test]
fn test_load_missing_envelope_fields() {
    let dir = tempdir().unwrap();
    let path = dir.path().join("missing_fields.json");

    // Valid JSON but missing "session" or "checksum"
    fs::write(&path, "{\"checksum\": \"abc\"}").unwrap();

    let result = Session::load(&path);
    assert!(result.is_err());
    assert!(result
        .unwrap_err()
        .to_string()
        .contains("Failed to parse session envelope"));
}

#[test]
fn test_load_referencing_deleted_files_integration() {
    let dir = tempdir().unwrap();
    let path = dir.path().join("session.json");
    let file_path = dir.path().join("exists.txt");
    fs::write(&file_path, "content").unwrap();

    let now = std::time::SystemTime::now();
    let group = SessionGroup {
        id: 1,
        hash: [0u8; 32],
        size: 7,
        files: vec![rustdupe::scanner::FileEntry::new(file_path.clone(), 7, now)],
        reference_paths: Vec::new(),
    };

    let session = Session::new(
        vec![dir.path().to_path_buf()],
        SessionSettings::default(),
        vec![group],
    );
    session.save(&path).unwrap();

    // Delete the file
    fs::remove_file(&file_path).unwrap();

    // Load session - should succeed but log warning
    let result = Session::load(&path);
    assert!(result.is_ok());
    let loaded = result.unwrap();
    assert_eq!(loaded.groups.len(), 1);
    assert_eq!(loaded.groups[0].files[0].path, file_path);
}