sledoview 1.1.1

A CLI tool for viewing and managing SLED database files
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

use thiserror::Error;

pub type Result<T> = std::result::Result<T, SledoViewError>;

#[derive(Error, Debug)]
pub enum SledoViewError {
    #[error("Database file not found: {path}")]
    DatabaseNotFound { path: String },

    #[error("Database file is not readable: {path}")]
    DatabaseNotReadable { path: String },

    #[error("File is not a SLED database: {path}")]
    InvalidSledDatabase { path: String },

    #[error("Database is locked by another process: {path}")]
    DatabaseLocked { path: String },

    #[error("Permission denied accessing database: {path}")]
    PermissionDenied { path: String },

    #[error("Invalid regex pattern: {pattern}")]
    InvalidRegex { pattern: String },

    #[error("Key not found: {key}")]
    KeyNotFound { key: String },

    #[error("Tree operation failed: {message}")]
    TreeOperation { message: String },

    #[error("IO error: {0}")]
    Io(#[from] std::io::Error),

    #[error("SLED error: {0}")]
    Sled(#[from] sled::Error),

    #[error("Regex error: {0}")]
    Regex(#[from] regex::Error),
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_error_display() {
        let err = SledoViewError::DatabaseNotFound {
            path: "/test/path".to_string(),
        };
        assert_eq!(err.to_string(), "Database file not found: /test/path");

        let err = SledoViewError::InvalidRegex {
            pattern: "[invalid".to_string(),
        };
        assert_eq!(err.to_string(), "Invalid regex pattern: [invalid");

        let err = SledoViewError::KeyNotFound {
            key: "missing_key".to_string(),
        };
        assert_eq!(err.to_string(), "Key not found: missing_key");
    }

    #[test]
    fn test_error_debug() {
        let err = SledoViewError::DatabaseLocked {
            path: "/test/path".to_string(),
        };
        let debug_str = format!("{:?}", err);
        assert!(debug_str.contains("DatabaseLocked"));
        assert!(debug_str.contains("/test/path"));
    }
}