fornix 0.2.0

Knowledge storage, retrieval, and graph infrastructure for cognitive systems
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
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149

//! Null cache adapter — accepts all writes and returns nothing.
//!
//! Useful for disabling caching in test environments or when a cache
//! is optional and the caller wants a no-op implementation.

use async_trait::async_trait;

use crate::cache::{
    adapter::CacheAdapter,
    config::CacheConfig,
    error::Result,
    stats::CacheStats,
};
use crate::common::namespace::Namespace;
use crate::store::health::{HealthReport, HealthStatus};

/// A no-op cache adapter.
///
/// All writes succeed silently. All reads return `None`.
/// Useful for disabling caching without changing call sites.
pub struct NullCacheAdapter {
    config: CacheConfig,
}

impl NullCacheAdapter {
    /// Create a connected null adapter. Never fails.
    pub fn new(config: CacheConfig) -> Self {
        Self { config }
    }
}

impl Default for NullCacheAdapter {
    fn default() -> Self {
        Self::new(CacheConfig::default())
    }
}

#[async_trait]
impl CacheAdapter for NullCacheAdapter {
    fn name(&self) -> &'static str {
        "null"
    }

    fn is_connected(&self) -> bool {
        true
    }

    fn config(&self) -> &CacheConfig {
        &self.config
    }

    async fn set(
        &self,
        _key: &str,
        _value: Vec<u8>,
        _namespace: Option<&Namespace>,
        _ttl: Option<std::time::Duration>,
    ) -> Result<()> {
        Ok(())
    }

    async fn get(&self, _key: &str, _namespace: Option<&Namespace>) -> Result<Option<Vec<u8>>> {
        Ok(None)
    }

    async fn delete(&self, _key: &str, _namespace: Option<&Namespace>) -> Result<bool> {
        Ok(false)
    }

    async fn clear(&self, _namespace: Option<&Namespace>) -> Result<usize> {
        Ok(0)
    }

    async fn exists(&self, _key: &str, _namespace: Option<&Namespace>) -> Result<bool> {
        Ok(false)
    }

    async fn stats(&self, _namespace: Option<&Namespace>) -> Result<CacheStats> {
        Ok(CacheStats::default())
    }

    async fn healthcheck(&self) -> HealthReport {
        HealthReport::begin("null-cache").finish(HealthStatus::Healthy)
    }
}

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

    fn adapter() -> NullCacheAdapter {
        NullCacheAdapter::default()
    }

    #[tokio::test]
    async fn is_always_connected() {
        assert!(adapter().is_connected());
    }

    #[tokio::test]
    async fn name_is_null() {
        assert_eq!(adapter().name(), "null");
    }

    #[tokio::test]
    async fn set_always_succeeds() {
        let a = adapter();
        a.set("k", b"v".to_vec(), None, None).await.unwrap();
    }

    #[tokio::test]
    async fn get_always_returns_none() {
        let a = adapter();
        a.set("k", b"v".to_vec(), None, None).await.unwrap();
        assert_eq!(a.get("k", None).await.unwrap(), None);
    }

    #[tokio::test]
    async fn delete_always_returns_false() {
        let a = adapter();
        assert!(!a.delete("k", None).await.unwrap());
    }

    #[tokio::test]
    async fn clear_always_returns_zero() {
        let a = adapter();
        assert_eq!(a.clear(None).await.unwrap(), 0);
    }

    #[tokio::test]
    async fn exists_always_returns_false() {
        let a = adapter();
        a.set("k", b"v".to_vec(), None, None).await.unwrap();
        assert!(!a.exists("k", None).await.unwrap());
    }

    #[tokio::test]
    async fn stats_always_returns_zeros() {
        let a = adapter();
        let s = a.stats(None).await.unwrap();
        assert_eq!(s, CacheStats::default());
    }

    #[tokio::test]
    async fn healthcheck_always_healthy() {
        let r = adapter().healthcheck().await;
        assert!(r.status.is_healthy());
    }
}