added redismodule_test.rs with ValkeyString::create_for_test

updated examples to use it

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

Author: dmitrypol

README.md

@@ -93,7 +93,7 @@ mod tests {
         let mut ctx = MockContext::new();
         ctx.expect_get_client_id().times(1).returning(|| 42);
 
-        let reply = get_client_id(&ctx, vec![]).unwrap();
+        let reply = get_client_id(&ctx, vec![ValkeyString::create_for_test("")]).unwrap();
         assert_eq!(reply, ValkeyValue::Integer(42));
     }
 }

examples/client.rs

@@ -133,10 +133,6 @@ mod tests {
     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,
@@ -189,7 +185,8 @@ mod tests {
     #[test]
     fn test_set_client_name_wrong_arity() {
         let ctx = MockContext::new();
-        let err = set_client_name(&ctx, vec![null_valkey_string()]).unwrap_err();
+        let err = set_client_name(&ctx, vec![ValkeyString::create_for_test("client.set_name")])
+            .unwrap_err();
         assert!(matches!(err, ValkeyError::WrongArity));
     }
 
@@ -199,13 +196,25 @@ mod tests {
         ctx.expect_log_notice().times(1).return_const(());
         ctx.expect_set_client_name_by_id()
             .times(1)
-            .returning(|_, _| Status::Ok);
+            .returning(|_, client_name| {
+                assert_eq!(client_name.try_as_str().unwrap(), "my-client");
+                Status::Ok
+            });
         ctx.expect_set_client_name()
             .times(1)
-            .returning(|_| Status::Ok);
+            .returning(|client_name| {
+                assert_eq!(client_name.try_as_str().unwrap(), "my-client");
+                Status::Ok
+            });
 
-        let reply =
-            set_client_name(&ctx, vec![null_valkey_string(), null_valkey_string()]).unwrap();
+        let reply = set_client_name(
+            &ctx,
+            vec![
+                ValkeyString::create_for_test("client.set_name"),
+                ValkeyString::create_for_test("my-client"),
+            ],
+        )
+        .unwrap();
         assert_eq!(reply, ValkeyValue::Integer(Status::Ok as i64));
     }
 
@@ -252,7 +261,7 @@ mod tests {
     #[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();
+        let err = deauth_client_by_id(&ctx, vec![ValkeyString::create_for_test("")]).unwrap_err();
         assert!(matches!(err, ValkeyError::WrongArity));
     }
 
@@ -265,7 +274,7 @@ mod tests {
     #[test]
     fn test_config_get_wrong_arity() {
         let ctx = MockContext::new();
-        let err = config_get(&ctx, vec![null_valkey_string()]).unwrap_err();
+        let err = config_get(&ctx, vec![ValkeyString::create_for_test("")]).unwrap_err();
         assert!(matches!(err, ValkeyError::WrongArity));
     }
 

examples/crontab.rs

@@ -2,7 +2,7 @@ use std::collections::HashMap;
 use std::str::FromStr;
 use std::sync::{LazyLock, RwLock};
 use valkey_module::alloc::ValkeyAlloc;
-use valkey_module::{valkey_module, Context, Status, ValkeyString};
+use valkey_module::{valkey_module, Context, ContextTrait, Status, ValkeyString};
 use valkey_module_macros::cron_event_handler;
 
 // struct to hold environment-specific configs, based on the environment name passed in via MODULE LOAD
@@ -86,7 +86,7 @@ fn cron_event_handler(ctx: &Context, _hz: u64) {
     }
 }
 
-fn initialize(ctx: &Context, args: &[ValkeyString]) -> Status {
+fn initialize(ctx: &impl ContextTrait, args: &[ValkeyString]) -> Status {
     // if arg passed in MODULE LOAD use it to set env_name
     let env_name = match args.get(0) {
         Some(tmp) => tmp.to_string(),
@@ -113,3 +113,41 @@ valkey_module! {
     commands: [
     ],
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::sync::Mutex;
+    use valkey_module::MockContext;
+
+    static TEST_LOCK: Mutex<()> = Mutex::new(());
+
+    #[test]
+    fn initialize_uses_dev_environment_config() {
+        let _guard = TEST_LOCK.lock().unwrap();
+        let mut ctx = MockContext::new();
+        ctx.expect_log_notice().times(1).return_const(());
+        let args = vec![ValkeyString::create_for_test("dev")];
+
+        let status = initialize(&ctx, &args);
+        let config = ENV_CONFIG.read().unwrap();
+
+        assert_eq!(status, Status::Ok);
+        assert_eq!(config.cron_fn1_fn2, "*/5 * * * * * *");
+        assert_eq!(config.cron_fn3, "*/10 * * * * * *");
+    }
+
+    #[test]
+    fn initialize_uses_default_config_without_args() {
+        let _guard = TEST_LOCK.lock().unwrap();
+        let mut ctx = MockContext::new();
+        ctx.expect_log_notice().times(1).return_const(());
+
+        let test = initialize(&ctx, &[]);
+        let config = ENV_CONFIG.read().unwrap();
+
+        assert_eq!(test, Status::Ok);
+        assert_eq!(config.cron_fn1_fn2, "*/15 * * * * * *");
+        assert_eq!(config.cron_fn3, "*/30 * * * * * *");
+    }
+}

examples/hello.rs

@@ -30,3 +30,45 @@ valkey_module! {
         ["hello.mul", hello_mul, "", 0, 0, 0],
     ],
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use valkey_module::{Context, ValkeyValue};
+
+    fn test_args(values: &[&str]) -> Vec<ValkeyString> {
+        values
+            .iter()
+            .map(|value| ValkeyString::create_for_test(*value))
+            .collect()
+    }
+
+    #[test]
+    fn hello_mul_returns_inputs_and_product() {
+        let reply = hello_mul(&Context::dummy(), test_args(&["hello.mul", "2", "3", "4"])).unwrap();
+
+        assert_eq!(
+            reply,
+            ValkeyValue::Array(vec![
+                ValkeyValue::Integer(2),
+                ValkeyValue::Integer(3),
+                ValkeyValue::Integer(4),
+                ValkeyValue::Integer(24),
+            ])
+        );
+    }
+
+    #[test]
+    fn hello_mul_returns_wrong_arity_without_numbers() {
+        let err = hello_mul(&Context::dummy(), test_args(&["hello.mul"])).unwrap_err();
+
+        assert!(matches!(err, ValkeyError::WrongArity));
+    }
+
+    #[test]
+    fn hello_mul_rejects_invalid_integer() {
+        let err = hello_mul(&Context::dummy(), test_args(&["hello.mul", "2", "xx"])).unwrap_err();
+
+        assert!(matches!(err, ValkeyError::Str("Couldn't parse as integer")));
+    }
+}

src/lib.rs

@@ -11,6 +11,8 @@ pub mod native_types;
 pub mod raw;
 pub mod rediserror;
 mod redismodule;
+#[cfg(any(test, feature = "test-mocks"))]
+mod redismodule_test;
 pub mod redisraw;
 pub mod redisvalue;
 pub mod stream;