added mocks for Context via ContextTrait and mockall crate

updated examples to include tests

Signed-off-by: dmitrypol <dmitrypol@users.noreply.github.com>

Author: dmitrypol

Cargo.lock

@@ -173,16 +173,18 @@ cfg-if = "1"
 valkey-module-macros-internals = { path = "valkeymodule-rs-macros-internals", version = "0.1.4"}
 log = "0.4"
 paste = "1.0.15"
+mockall = { version = "0.14.0", optional = true }
 
 [dev-dependencies]
 anyhow = "1"
 redis = "0.28"
 lazy_static = "1"
 valkey-module-macros = { path = "valkeymodule-rs-macros", version = "0.1.4" }
-valkey-module = { path = "./", default-features = false, features = ["min-valkey-compatibility-version-8-0", "min-redis-compatibility-version-7-2"] }
+valkey-module = { path = "./", default-features = false, features = ["min-valkey-compatibility-version-8-0", "min-redis-compatibility-version-7-2", "test-mocks", "enable-system-alloc"] }
 cron = "0.15.0"
 chrono = "0.4.41"
 dashmap = "6.1.0"
+mockall = { version = "0.14.0"}
 
 [build-dependencies]
 bindgen = "0.70"
@@ -199,3 +201,5 @@ min-redis-compatibility-version-6-0 = []
 enable-system-alloc = []
 # this is to indicate the Module wants to use RedisModule APIs for calls
 use-redismodule-api = []
+# exposes MockContext (generated via mockall) for downstream unit tests
+test-mocks = ["dep:mockall"]

Cargo.toml

@@ -1,14 +1,15 @@
 use valkey_module::alloc::ValkeyAlloc;
 use valkey_module::{
-    valkey_module, Context, NextArg, Status, ValkeyError, ValkeyResult, ValkeyString, ValkeyValue,
+    valkey_module, ContextTrait, NextArg, Status, ValkeyError, ValkeyResult, ValkeyString,
+    ValkeyValue,
 };
 
-fn get_client_id(ctx: &Context, _args: Vec<ValkeyString>) -> ValkeyResult {
+fn get_client_id(ctx: &impl ContextTrait, _args: Vec<ValkeyString>) -> ValkeyResult {
     let client_id = ctx.get_client_id();
     Ok((client_id as i64).into())
 }
 
-fn get_client_name(ctx: &Context, _args: Vec<ValkeyString>) -> ValkeyResult {
+fn get_client_name(ctx: &impl ContextTrait, _args: Vec<ValkeyString>) -> ValkeyResult {
     // test for invalid client_id
     match ctx.get_client_name_by_id(0) {
         Ok(tmp) => ctx.log_notice(&format!(
@@ -21,7 +22,7 @@ fn get_client_name(ctx: &Context, _args: Vec<ValkeyString>) -> ValkeyResult {
     Ok(ValkeyValue::from(client_name.to_string()))
 }
 
-fn get_client_username(ctx: &Context, _args: Vec<ValkeyString>) -> ValkeyResult {
+fn get_client_username(ctx: &impl ContextTrait, _args: Vec<ValkeyString>) -> ValkeyResult {
     // test for invalid client_id
     match ctx.get_client_username_by_id(0) {
         Ok(tmp) => ctx.log_notice(&format!(
@@ -34,7 +35,7 @@ fn get_client_username(ctx: &Context, _args: Vec<ValkeyString>) -> ValkeyResult
     Ok(ValkeyValue::from(client_username.to_string()))
 }
 
-fn set_client_name(ctx: &Context, args: Vec<ValkeyString>) -> ValkeyResult {
+fn set_client_name(ctx: &impl ContextTrait, args: Vec<ValkeyString>) -> ValkeyResult {
     if args.len() != 2 {
         return Err(ValkeyError::WrongArity);
     }
@@ -47,7 +48,7 @@ fn set_client_name(ctx: &Context, args: Vec<ValkeyString>) -> ValkeyResult {
     Ok(ValkeyValue::Integer(resp2 as i64))
 }
 
-fn get_client_cert(ctx: &Context, _args: Vec<ValkeyString>) -> ValkeyResult {
+fn get_client_cert(ctx: &impl ContextTrait, _args: Vec<ValkeyString>) -> ValkeyResult {
     // unless connection is made with cert, this will return Err, so just log it and return nothing
     match ctx.get_client_cert() {
         Ok(tmp) => ctx.log_notice(&format!("client_cert: {:?}", tmp.to_string())),
@@ -56,7 +57,7 @@ fn get_client_cert(ctx: &Context, _args: Vec<ValkeyString>) -> ValkeyResult {
     Ok("".into())
 }
 
-fn get_client_info(ctx: &Context, _args: Vec<ValkeyString>) -> ValkeyResult {
+fn get_client_info(ctx: &impl ContextTrait, _args: Vec<ValkeyString>) -> ValkeyResult {
     // test for invalid client_id
     let client_info_by_id = ctx.get_client_info_by_id(0);
     ctx.log_notice(&format!(
@@ -69,7 +70,7 @@ fn get_client_info(ctx: &Context, _args: Vec<ValkeyString>) -> ValkeyResult {
     Ok(ValkeyValue::from(client_info.version.to_string()))
 }
 
-fn get_client_ip(ctx: &Context, _args: Vec<ValkeyString>) -> ValkeyResult {
+fn get_client_ip(ctx: &impl ContextTrait, _args: Vec<ValkeyString>) -> ValkeyResult {
     // test for invalid client_id
     let client_ip_by_id = ctx.get_client_ip_by_id(0);
     ctx.log_notice(&format!(
@@ -79,7 +80,7 @@ fn get_client_ip(ctx: &Context, _args: Vec<ValkeyString>) -> ValkeyResult {
     Ok(ctx.get_client_ip()?.into())
 }
 
-fn deauth_client_by_id(ctx: &Context, args: Vec<ValkeyString>) -> ValkeyResult {
+fn deauth_client_by_id(ctx: &impl ContextTrait, args: Vec<ValkeyString>) -> ValkeyResult {
     if args.len() != 2 {
         return Err(ValkeyError::WrongArity);
     }
@@ -95,7 +96,7 @@ fn deauth_client_by_id(ctx: &Context, args: Vec<ValkeyString>) -> ValkeyResult {
     }
 }
 
-fn config_get(ctx: &Context, args: Vec<ValkeyString>) -> ValkeyResult {
+fn config_get(ctx: &impl ContextTrait, args: Vec<ValkeyString>) -> ValkeyResult {
     if args.len() != 2 {
         return Err(ValkeyError::WrongArity);
     }
@@ -125,3 +126,152 @@ valkey_module! {
         ["client.config_get", config_get, "", 0, 0, 0]
     ]
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::ptr::null_mut;
+    use valkey_module::{MockContext, RedisModuleClientInfo};
+
+    fn null_valkey_string() -> ValkeyString {
+        ValkeyString::from_redis_module_string(null_mut(), null_mut())
+    }
+
+    fn module_client_info(id: u64) -> RedisModuleClientInfo {
+        RedisModuleClientInfo {
+            version: 1,
+            flags: 0,
+            id,
+            addr: [0; 46],
+            port: 6379,
+            db: 0,
+        }
+    }
+
+    #[test]
+    fn test_get_client_id() {
+        let mut ctx = MockContext::new();
+        ctx.expect_get_client_id().times(1).returning(|| 42);
+        let reply = get_client_id(&ctx, vec![]).unwrap();
+        assert_eq!(reply, ValkeyValue::Integer(42));
+    }
+
+    #[test]
+    fn test_get_client_name() {
+        let mut ctx = MockContext::new();
+        ctx.expect_log_notice().times(1).return_const(());
+        ctx.expect_get_client_name_by_id()
+            .times(1)
+            .returning(|_| Err(ValkeyError::Str("no such client")));
+        ctx.expect_get_client_name()
+            .times(1)
+            .returning(|| Err(ValkeyError::Str("no name")));
+
+        let err = get_client_name(&ctx, vec![]).unwrap_err();
+        assert!(matches!(err, ValkeyError::Str("no name")));
+    }
+
+    #[test]
+    fn test_get_client_username() {
+        let mut ctx = MockContext::new();
+        ctx.expect_log_notice().times(1).return_const(());
+        ctx.expect_get_client_username_by_id()
+            .times(1)
+            .returning(|_| Err(ValkeyError::Str("no such client")));
+        ctx.expect_get_client_username()
+            .times(1)
+            .returning(|| Err(ValkeyError::Str("no user")));
+
+        let err = get_client_username(&ctx, vec![]).unwrap_err();
+        assert!(matches!(err, ValkeyError::Str("no user")));
+    }
+
+    #[test]
+    fn test_set_client_name_wrong_arity() {
+        let ctx = MockContext::new();
+        let err = set_client_name(&ctx, vec![null_valkey_string()]).unwrap_err();
+        assert!(matches!(err, ValkeyError::WrongArity));
+    }
+
+    #[test]
+    fn test_set_client_name() {
+        let mut ctx = MockContext::new();
+        ctx.expect_log_notice().times(1).return_const(());
+        ctx.expect_set_client_name_by_id()
+            .times(1)
+            .returning(|_, _| Status::Ok);
+        ctx.expect_set_client_name()
+            .times(1)
+            .returning(|_| Status::Ok);
+
+        let reply =
+            set_client_name(&ctx, vec![null_valkey_string(), null_valkey_string()]).unwrap();
+        assert_eq!(reply, ValkeyValue::Integer(Status::Ok as i64));
+    }
+
+    #[test]
+    fn test_get_client_cert() {
+        let mut ctx = MockContext::new();
+        ctx.expect_log_notice().times(1).return_const(());
+        ctx.expect_get_client_cert()
+            .times(1)
+            .returning(|| Err(ValkeyError::Str("no cert")));
+        let reply = get_client_cert(&ctx, vec![]).unwrap();
+        assert_eq!(reply, ValkeyValue::BulkString(String::new()));
+    }
+
+    #[test]
+    fn test_get_client_info() {
+        let mut ctx = MockContext::new();
+        ctx.expect_log_notice().times(2).return_const(());
+        ctx.expect_get_client_info_by_id()
+            .times(1)
+            .returning(|_| Ok(module_client_info(0)));
+        ctx.expect_get_client_info()
+            .times(1)
+            .returning(|| Ok(module_client_info(42)));
+
+        let reply = get_client_info(&ctx, vec![]).unwrap();
+        assert_eq!(reply, ValkeyValue::BulkString("1".to_string()));
+    }
+
+    #[test]
+    fn test_get_client_ip() {
+        let mut ctx = MockContext::new();
+        ctx.expect_get_client_ip_by_id()
+            .times(1)
+            .returning(|_| Ok("0.0.0.0".to_string()));
+        ctx.expect_log_notice().times(1).return_const(());
+        ctx.expect_get_client_ip()
+            .times(1)
+            .returning(|| Ok("127.0.0.1".to_string()));
+        let reply = get_client_ip(&ctx, vec![]).unwrap();
+        assert_eq!(reply, ValkeyValue::BulkString("127.0.0.1".to_string()));
+    }
+
+    #[test]
+    fn test_deauth_client_by_id_wrong_arity() {
+        let ctx = MockContext::new();
+        let err = deauth_client_by_id(&ctx, vec![null_valkey_string()]).unwrap_err();
+        assert!(matches!(err, ValkeyError::WrongArity));
+    }
+
+    #[test]
+    #[ignore]
+    fn test_death_client_by_id() {
+        // TODO - test when ValkeyString is unit testable
+    }
+
+    #[test]
+    fn test_config_get_wrong_arity() {
+        let ctx = MockContext::new();
+        let err = config_get(&ctx, vec![null_valkey_string()]).unwrap_err();
+        assert!(matches!(err, ValkeyError::WrongArity));
+    }
+
+    #[test]
+    #[ignore]
+    fn test_config_get() {
+        // TODO - test when ValkeyString is unit testable
+    }
+}