baichun-framework-cache 0.1.0

Cache module for Baichun-Rust framework
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

#[cfg(feature = "redis")]
mod client;
mod config;
mod error;

#[cfg(feature = "redis")]
pub use client::RedisClient;
pub use config::{PoolConfig, RedisCluster, RedisConfig, RedisMode, RedisNode, RedisSentinel};
pub use error::{RedisError, Result};

#[cfg(feature = "redis")]
use std::sync::Arc;
#[cfg(feature = "redis")]
use tokio::sync::OnceCell;

#[cfg(feature = "redis")]
pub static REDIS_CLIENT: OnceCell<Arc<RedisClient>> = OnceCell::const_new();

/// Get the global Redis client instance
#[cfg(feature = "redis")]
pub async fn get_client() -> Arc<RedisClient> {
    REDIS_CLIENT
        .get()
        .expect("Redis client not initialized")
        .clone()
}

/// Initialize the Redis client with configuration
#[cfg(feature = "redis")]
pub async fn init(config: RedisConfig) -> Result<Arc<RedisClient>> {
    let client = RedisClient::new(config).await?;
    let client = Arc::new(client);

    if REDIS_CLIENT.set(client.clone()).is_err() {
        return Err(RedisError::AlreadyInitialized);
    }

    Ok(client)
}

#[cfg(all(test, feature = "redis"))]
mod tests {
    use super::*;

    #[tokio::test]
    async fn test_redis_global_client() {
        // Create test config
        let config = RedisConfig {
            mode: RedisMode::Standalone,
            node: Some(RedisNode {
                host: "localhost".to_string(),
                port: 6379,
            }),
            sentinel: None,
            cluster: None,
            pool: PoolConfig::default(),
            password: Some("1qaz!QAZ".to_string()),
            database: None,
        };

        // Initialize global client
        let client = init(config).await.unwrap();

        // Test set using initialized client
        client
            .set("test_init_key", "test_init_value")
            .await
            .unwrap();

        // Get client from global instance
        let global_client = get_client().await;

        // Test get using global client
        let value = global_client.get("test_init_key").await.unwrap();
        assert_eq!(value, Some("test_init_value".to_string()));

        // Test delete using global client
        // let deleted = global_client.del("test_init_key").await.unwrap();
        // assert!(deleted);

        // Verify deletion
        // let value = global_client.get("test_init_key").await.unwrap();
        // assert_eq!(value, None);
    }

    #[tokio::test]
    async fn test_redis_init_twice() {
        // Create test config
        let config = RedisConfig {
            mode: RedisMode::Standalone,
            node: Some(RedisNode {
                host: "localhost".to_string(),
                port: 6379,
            }),
            sentinel: None,
            cluster: None,
            pool: PoolConfig::default(),
            password: Some("1qaz!QAZ".to_string()),
            database: None,
        };

        // First initialization should succeed
        let result = init(config.clone()).await;
        match result {
            Err(RedisError::AlreadyInitialized) => (),
            _ => panic!("Expected AlreadyInitialized error"),
        }
    }
}