oxcache 0.2.0

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

//! Copyright (c) 2025-2026, Kirky.X
//!
//! MIT License
//!
//! Redis 命令枚举

/// Redis 命令枚举
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum RedisCommand {
    Ping,
    Get,
    Set,
    SetEx,
    Del,
    Exists,
    Expire,
    Ttl,
    Scan,
    Keys,
    Dbsize,
    Info,
    FlushAll,
    FlushDb,
    Shutdown,
    Debug,
    Config,
    Save,
    BgSave,
    BgRewriteAof,
    SlaveOf,
    ReplicaOf,
    Cluster,
    Admin,
    Monitor,
    Eval,
    EvalSha,
    Script,
}

impl RedisCommand {
    pub fn as_str(&self) -> &'static str {
        match self {
            Self::Ping => "PING",
            Self::Get => "GET",
            Self::Set => "SET",
            Self::SetEx => "SETEX",
            Self::Del => "DEL",
            Self::Exists => "EXISTS",
            Self::Expire => "EXPIRE",
            Self::Ttl => "TTL",
            Self::Scan => "SCAN",
            Self::Keys => "KEYS",
            Self::Dbsize => "DBSIZE",
            Self::Info => "INFO",
            Self::FlushAll => "FLUSHALL",
            Self::FlushDb => "FLUSHDB",
            Self::Shutdown => "SHUTDOWN",
            Self::Debug => "DEBUG",
            Self::Config => "CONFIG",
            Self::Save => "SAVE",
            Self::BgSave => "BGSAVE",
            Self::BgRewriteAof => "BGREWRITEAOF",
            Self::SlaveOf => "SLAVEOF",
            Self::ReplicaOf => "REPLICAOF",
            Self::Cluster => "CLUSTER",
            Self::Admin => "ADMIN",
            Self::Monitor => "MONITOR",
            Self::Eval => "EVAL",
            Self::EvalSha => "EVALSHA",
            Self::Script => "SCRIPT",
        }
    }
}

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

    #[test]
    fn test_all_commands_have_non_empty_str() {
        // Test all variants return a non-empty string
        let variants = [
            RedisCommand::Ping,
            RedisCommand::Get,
            RedisCommand::Set,
            RedisCommand::SetEx,
            RedisCommand::Del,
            RedisCommand::Exists,
            RedisCommand::Expire,
            RedisCommand::Ttl,
            RedisCommand::Scan,
            RedisCommand::Keys,
            RedisCommand::Dbsize,
            RedisCommand::Info,
            RedisCommand::FlushAll,
            RedisCommand::FlushDb,
            RedisCommand::Shutdown,
            RedisCommand::Debug,
            RedisCommand::Config,
            RedisCommand::Save,
            RedisCommand::BgSave,
            RedisCommand::BgRewriteAof,
            RedisCommand::SlaveOf,
            RedisCommand::ReplicaOf,
            RedisCommand::Cluster,
            RedisCommand::Admin,
            RedisCommand::Monitor,
            RedisCommand::Eval,
            RedisCommand::EvalSha,
            RedisCommand::Script,
        ];
        for cmd in &variants {
            assert!(!cmd.as_str().is_empty(), "Command {:?} has empty as_str()", cmd);
        }
    }

    #[test]
    fn test_as_str_returns_uppercase() {
        assert_eq!(RedisCommand::Ping.as_str(), "PING");
        assert_eq!(RedisCommand::Get.as_str(), "GET");
        assert_eq!(RedisCommand::Set.as_str(), "SET");
        assert_eq!(RedisCommand::SetEx.as_str(), "SETEX");
        assert_eq!(RedisCommand::Del.as_str(), "DEL");
        assert_eq!(RedisCommand::Exists.as_str(), "EXISTS");
        assert_eq!(RedisCommand::Expire.as_str(), "EXPIRE");
        assert_eq!(RedisCommand::Ttl.as_str(), "TTL");
        assert_eq!(RedisCommand::Scan.as_str(), "SCAN");
        assert_eq!(RedisCommand::Keys.as_str(), "KEYS");
        assert_eq!(RedisCommand::Dbsize.as_str(), "DBSIZE");
        assert_eq!(RedisCommand::Info.as_str(), "INFO");
        assert_eq!(RedisCommand::FlushAll.as_str(), "FLUSHALL");
        assert_eq!(RedisCommand::FlushDb.as_str(), "FLUSHDB");
    }
}