fncache 0.1.2

A zero-boilerplate Rust library for function-level caching with pluggable 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
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

//! Advanced metrics tests

use crate::backends::memory::{MemoryBackend, MemoryBackendConfig};
use crate::backends::CacheBackend;

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

    #[tokio::test]
    async fn test_advanced_metrics() {
        let backend = MemoryBackend::with_config(MemoryBackendConfig {
            max_capacity: 10,
            eviction_policy: "lru".to_string(),
        });

        let metrics = backend.metrics();
        assert_eq!(metrics.entry_count(), 0);
        assert_eq!(metrics.total_bytes(), 0);

        backend
            .set("key1".to_string(), vec![1, 2, 3], None)
            .await
            .unwrap();
        backend
            .set("key2".to_string(), vec![4, 5, 6], None)
            .await
            .unwrap();

        let metrics = backend.metrics();
        assert_eq!(metrics.entry_count(), 2);
        assert!(metrics.total_bytes() > 0, "Total bytes should be non-zero");
        assert!(
            metrics.average_entry_size() > 0,
            "Average entry size should be non-zero"
        );

        assert_eq!(metrics.get_latency().count, 0);
        assert!(metrics.set_latency().count >= 2);
        assert!(
            metrics.average_set_latency_ns() > 0.0,
            "Set latency should be non-zero"
        );

        let _value = backend.get(&"key1".to_string()).await.unwrap();

        let metrics = backend.metrics();
        assert_eq!(metrics.get_latency().count, 1);
        assert!(
            metrics.average_get_latency_ns() > 0.0,
            "Get latency should be non-zero"
        );

        backend
            .set("key3".to_string(), vec![7, 8, 9], None)
            .await
            .unwrap();

        let metrics = backend.metrics();
        assert_eq!(metrics.entry_count(), 3);

        for i in 4..12 {
            backend
                .set(format!("key{}", i), vec![i as u8], None)
                .await
                .unwrap();
        }

        let metrics = backend.metrics();
        assert!(metrics.evictions() > 0, "Should have evictions");
        assert_eq!(metrics.entry_count(), 10); // Should be at max capacity
    }

    #[tokio::test]
    async fn test_metrics_size_tracking() {
        let backend = MemoryBackend::default();

        backend
            .set("size_key".to_string(), vec![1, 2, 3, 4, 5], None)
            .await
            .unwrap();

        let metrics = backend.metrics();
        let initial_size = metrics.total_bytes();
        assert!(initial_size > 0, "Initial size should be non-zero");

        backend
            .set(
                "size_key".to_string(),
                vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
                None,
            )
            .await
            .unwrap();

        let metrics = backend.metrics();
        let new_size = metrics.total_bytes();
        assert!(
            new_size > initial_size,
            "New size should be larger than initial size"
        );
        assert_eq!(metrics.entry_count(), 1, "Entry count should remain 1");

        backend.remove(&"size_key".to_string()).await.unwrap();

        let metrics = backend.metrics();
        assert_eq!(
            metrics.total_bytes(),
            0,
            "Total bytes should be zero after removal"
        );
        assert_eq!(
            metrics.entry_count(),
            0,
            "Entry count should be zero after removal"
        );
    }
}