terseid 0.1.0

Adaptive-length, collision-resistant short IDs
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

#[derive(Debug, Clone, PartialEq, Eq, thiserror::Error)]
pub enum TerseIdError {
    #[error("invalid ID format: {id}")]
    InvalidId { id: String },

    #[error("prefix mismatch: expected '{expected}', found '{found}'")]
    PrefixMismatch { expected: String, found: String },

    #[error("ambiguous ID '{partial}': matches {matches:?}")]
    AmbiguousId {
        partial: String,
        matches: Vec<String>,
    },

    #[error("ID not found: {id}")]
    NotFound { id: String },
}

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

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

    #[test]
    fn test_invalid_id_display() {
        let error = TerseIdError::InvalidId {
            id: "bad-id".to_string(),
        };
        assert_eq!(error.to_string(), "invalid ID format: bad-id");
    }

    #[test]
    fn test_prefix_mismatch_display() {
        let error = TerseIdError::PrefixMismatch {
            expected: "usr".to_string(),
            found: "org".to_string(),
        };
        assert_eq!(
            error.to_string(),
            "prefix mismatch: expected 'usr', found 'org'"
        );
    }

    #[test]
    fn test_ambiguous_id_display() {
        let error = TerseIdError::AmbiguousId {
            partial: "usr_a".to_string(),
            matches: vec!["usr_abc123".to_string(), "usr_abd456".to_string()],
        };
        assert_eq!(
            error.to_string(),
            "ambiguous ID 'usr_a': matches [\"usr_abc123\", \"usr_abd456\"]"
        );
    }

    #[test]
    fn test_not_found_display() {
        let error = TerseIdError::NotFound {
            id: "usr_xyz789".to_string(),
        };
        assert_eq!(error.to_string(), "ID not found: usr_xyz789");
    }

    #[test]
    fn test_error_debug() {
        let error = TerseIdError::InvalidId {
            id: "test".to_string(),
        };
        assert!(format!("{error:?}").contains("InvalidId"));
    }

    #[test]
    fn test_error_clone() {
        let error1 = TerseIdError::NotFound {
            id: "test_id".to_string(),
        };
        let error2 = error1.clone();
        assert_eq!(error1, error2);
    }

    #[test]
    fn test_error_equality() {
        let error1 = TerseIdError::InvalidId {
            id: "same".to_string(),
        };
        let error2 = TerseIdError::InvalidId {
            id: "same".to_string(),
        };
        assert_eq!(error1, error2);
    }

    #[test]
    fn test_result_type_ok() {
        let result: Result<i32> = Ok(42);
        assert_eq!(result, Ok(42));
    }

    #[test]
    fn test_result_type_err() {
        let error = TerseIdError::NotFound {
            id: "test".to_string(),
        };
        let result: Result<i32> = Err(error.clone());
        assert_eq!(result, Err(error));
    }
}