threatflux-cache 0.2.0

A bounded async cache library with in-memory and filesystem backends
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

//! Error types for the cache library

use std::io;
use thiserror::Error;

/// Main error type for cache operations
#[derive(Error, Debug)]
#[non_exhaustive]
pub enum CacheError {
    /// I/O error occurred during cache operations
    #[error("I/O error: {0}")]
    Io(#[from] io::Error),

    /// Serialization error
    #[error("Serialization error: {0}")]
    Serialization(String),

    /// Deserialization error
    #[error("Deserialization error: {0}")]
    Deserialization(String),

    /// Cache capacity exceeded
    #[error("Cache capacity exceeded: {message}")]
    CapacityExceeded {
        /// Error message
        message: String,
    },

    /// Storage backend error
    #[error("Storage backend error: {0}")]
    StorageBackend(String),

    /// Entry not found
    #[error("Entry not found for key")]
    NotFound,

    /// Invalid configuration
    #[error("Invalid configuration: {0}")]
    InvalidConfiguration(String),

    /// A persistence snapshot exceeded the configured byte limit
    #[error("Persistence snapshot is too large ({actual_bytes} bytes; limit is {max_bytes})")]
    SnapshotTooLarge {
        /// Actual snapshot size in bytes
        actual_bytes: u64,
        /// Configured maximum size in bytes
        max_bytes: u64,
    },

    /// The persisted data uses an unsupported layout or format version
    #[error("Unsupported persistence format: {0}")]
    UnsupportedPersistenceFormat(String),

    /// Custom error for extensions
    #[error("Custom error: {0}")]
    Custom(String),
}

/// Result type alias for cache operations
pub type Result<T> = std::result::Result<T, CacheError>;

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

    #[test]
    fn test_cache_error_variants() {
        let io_err: CacheError = io::Error::other("oops").into();
        assert!(matches!(io_err, CacheError::Io(_)));

        let ser_err = CacheError::Serialization("ser".into());
        assert_eq!(format!("{ser_err}"), "Serialization error: ser");

        let des_err = CacheError::Deserialization("de".into());
        assert_eq!(format!("{des_err}"), "Deserialization error: de");

        let cap_err = CacheError::CapacityExceeded {
            message: "full".into(),
        };
        assert!(matches!(cap_err, CacheError::CapacityExceeded { .. }));

        let backend_err = CacheError::StorageBackend("be".into());
        assert!(matches!(backend_err, CacheError::StorageBackend(_)));

        let not_found = CacheError::NotFound;
        assert_eq!(format!("{not_found}"), "Entry not found for key");

        let custom = CacheError::Custom("c".into());
        assert_eq!(format!("{custom}"), "Custom error: c");
    }
}