oxcache 0.1.4

A high-performance multi-level cache library for Rust with L1 (memory) and L2 (Redis) caching.
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

// Copyright (c) 2025-2026, Kirky.X
//
// MIT License
//
// L2后端测试

use oxcache::{
    backend::l2::L2Backend,
    config::{ClusterConfig, L2Config, RedisMode, SentinelConfig},
    error::CacheError,
};

mod common;

#[tokio::test]
async fn test_sentinel_mode_success() {
    common::setup_logging();

    // 等待 Sentinel 环境就绪
    // 注意：26382 是 sentinel 的端口，我们连接它来确认
    if !common::wait_for_redis("redis://127.0.0.1:26382").await {
        println!("Skipping test_sentinel_mode_success: Redis Sentinel not available");
        return;
    }

    // 尝试使用 redis-sentinel:// 协议格式，这是 redis-rs 0.22+ 官方支持的格式
    // 格式: redis-sentinel://[:password@]host:port/master_name[/db_index]
    // 注意：redis-rs 的 Sentinel URL 解析期望把 master_name 作为 path 的一部分

    let config = L2Config {
        mode: RedisMode::Sentinel,
        sentinel: Some(SentinelConfig {
            master_name: "mymaster".to_string(),
            nodes: vec!["127.0.0.1:26382".to_string()],
        }),
        default_ttl: None,
        connection_timeout_ms: 10000,
        ..Default::default()
    };

    let backend = L2Backend::new(&config).await;
    assert!(
        backend.is_ok(),
        "Backend creation failed: {:?}",
        backend.err()
    );
}

#[tokio::test]
async fn test_cluster_mode_success() {
    common::setup_logging();

    // 等待 Cluster 环境就绪
    if !common::wait_for_redis("redis://127.0.0.1:7000").await {
        println!("Skipping test_cluster_mode_success: Redis Cluster not available");
        return;
    }

    let config = L2Config {
        mode: RedisMode::Cluster,
        connection_string: "".to_string().into(),
        connection_timeout_ms: 5000,
        command_timeout_ms: 5000,
        sentinel: None,
        cluster: Some(ClusterConfig {
            nodes: vec!["redis://127.0.0.1:7000".to_string()],
        }),
        password: None,
        enable_tls: false,
        default_ttl: None,
        ..Default::default()
    };

    // 重试几次，因为集群状态可能还没完全收敛
    let mut backend = Err(CacheError::Configuration("Init".to_string()));
    for i in 0..5 {
        backend = L2Backend::new(&config).await;
        if backend.is_ok() {
            break;
        }
        println!(
            "Attempt {} failed: {:?}, retrying...",
            i + 1,
            backend.as_ref().err()
        );
        tokio::time::sleep(std::time::Duration::from_secs(2)).await;
    }

    if let Err(e) = &backend {
        println!("Cluster backend creation failed after retries: {:?}", e);
        panic!("Failed to connect to Redis Cluster: {:?}", e);
    }
}

#[tokio::test]
async fn test_sentinel_missing_config() {
    let config = L2Config {
        mode: RedisMode::Sentinel,
        connection_string: "".to_string().into(),
        connection_timeout_ms: 1000,
        command_timeout_ms: 1000,
        sentinel: None,
        cluster: None,
        password: None,
        enable_tls: false,
        default_ttl: None,
        ..Default::default()
    };

    // 这里我们直接调用 new，不再注入 provider
    // 预期会因为配置缺失直接返回错误，甚至不需要尝试连接
    match L2Backend::new(&config).await {
        Err(CacheError::Configuration(msg)) => {
            assert!(msg.contains("Sentinel configuration is missing"));
        }
        Err(e) => panic!("Expected Configuration error, got: {:?}", e),
        Ok(_) => panic!("Should return configuration error"),
    }
}

#[tokio::test]
async fn test_cluster_missing_config() {
    let config = L2Config {
        mode: RedisMode::Cluster,
        connection_string: "".to_string().into(),
        connection_timeout_ms: 1000,
        command_timeout_ms: 1000,
        sentinel: None,
        cluster: None,
        password: None,
        enable_tls: false,
        default_ttl: None,
        ..Default::default()
    };

    match L2Backend::new(&config).await {
        Err(CacheError::Configuration(msg)) => {
            assert!(msg.contains("Cluster configuration is missing"));
        }
        Err(e) => panic!("Expected Configuration error, got: {:?}", e),
        Ok(_) => panic!("Should return configuration error"),
    }
}