fixed tests

RedisKeyWritable, RedisLogLevel, RedisGlobalLogger,
RedisLockIndicator, RedisGILGuardScope, RedisCommandFlags
RedisCommandKeySpecFlags, RedisModuleCallback,
RedisKey, REDIS_OK, MY_REDIS_TYPE
start_redis_server_with_module, get_redis_connection
updated numerous text references to Redis

Signed-off-by: Dmitry Polyakovsky <[email protected]>

Author: Dmitry Polyakovsky

.gitignore

@@ -12,7 +12,7 @@ src/redisraw/bindings.rs
 # VS Code
 .vscode
 
-# Redis database
+# Valkey database
 dump.rdb
 
 # Debugger-related files:

build.rs

@@ -6,9 +6,9 @@ use std::env;
 use std::path::PathBuf;
 
 #[derive(Debug)]
-struct RedisModuleCallback;
+struct ValkeyModuleCallback;
 
-impl ParseCallbacks for RedisModuleCallback {
+impl ParseCallbacks for ValkeyModuleCallback {
     fn int_macro(&self, name: &str, _value: i64) -> Option<IntKind> {
         if name.starts_with("REDISMODULE_SUBEVENT_") || name.starts_with("REDISMODULE_EVENT_") {
             Some(IntKind::U64)
@@ -34,10 +34,10 @@ impl ParseCallbacks for RedisModuleCallback {
 }
 
 fn main() {
-    // Build a Redis pseudo-library so that we have symbols that we can link
+    // Build a Valkey pseudo-library so that we have symbols that we can link
     // against while building Rust code.
     //
-    // include/redismodule.h is vendored in from the Redis project and
+    // include/redismodule.h is vendored in from the Valkey project and
     // src/redismodule.c is a stub that includes it and plays a few other
     // tricks that we need to complete the build.
 
@@ -59,7 +59,7 @@ fn main() {
         .allowlist_var("(REDIS|Redis).*")
         .blocklist_type("__darwin_.*")
         .allowlist_type("RedisModule.*")
-        .parse_callbacks(Box::new(RedisModuleCallback))
+        .parse_callbacks(Box::new(ValkeyModuleCallback))
         .size_t_is_usize(true)
         .generate()
         .expect("error generating bindings");

examples/call.rs

@@ -52,7 +52,7 @@ fn call_test(ctx: &Context, _: Vec<ValkeyString>) -> ValkeyResult {
         .try_into()?;
     if "TEST" != &res {
         return Err(ValkeyError::Str(
-            "Failed calling 'ECHO TEST' with RedisString",
+            "Failed calling 'ECHO TEST' with ValkeyString",
         ));
     }
 
@@ -61,7 +61,7 @@ fn call_test(ctx: &Context, _: Vec<ValkeyString>) -> ValkeyResult {
         .try_into()?;
     if "TEST" != &res {
         return Err(ValkeyError::Str(
-            "Failed calling 'ECHO TEST' with dynamic array of RedisString",
+            "Failed calling 'ECHO TEST' with dynamic array of ValkeyString",
         ));
     }
 

examples/data_type.rs

@@ -7,7 +7,7 @@ struct MyType {
     data: String,
 }
 
-static MY_REDIS_TYPE: ValkeyType = ValkeyType::new(
+static MY_VALKEY_TYPE: ValkeyType = ValkeyType::new(
     "mytype123",
     0,
     raw::RedisModuleTypeMethods {
@@ -52,14 +52,14 @@ fn alloc_set(ctx: &Context, args: Vec<ValkeyString>) -> ValkeyResult {
 
     let key = ctx.open_key_writable(&key);
 
-    if let Some(value) = key.get_value::<MyType>(&MY_REDIS_TYPE)? {
+    if let Some(value) = key.get_value::<MyType>(&MY_VALKEY_TYPE)? {
         value.data = "B".repeat(size as usize);
     } else {
         let value = MyType {
             data: "A".repeat(size as usize),
         };
 
-        key.set_value(&MY_REDIS_TYPE, value)?;
+        key.set_value(&MY_VALKEY_TYPE, value)?;
     }
     Ok(size.into())
 }
@@ -70,7 +70,7 @@ fn alloc_get(ctx: &Context, args: Vec<ValkeyString>) -> ValkeyResult {
 
     let key = ctx.open_key(&key);
 
-    let value = match key.get_value::<MyType>(&MY_REDIS_TYPE)? {
+    let value = match key.get_value::<MyType>(&MY_VALKEY_TYPE)? {
         Some(value) => value.data.as_str().into(),
         None => ().into(),
     };
@@ -85,7 +85,7 @@ valkey_module! {
     version: 1,
     allocator: (valkey_module::alloc::ValkeyAlloc, valkey_module::alloc::ValkeyAlloc),
     data_types: [
-        MY_REDIS_TYPE,
+        MY_VALKEY_TYPE,
     ],
     commands: [
         ["alloc.set", alloc_set, "write", 1, 1, 1],

examples/load_unload.rs

@@ -1,4 +1,4 @@
-use valkey_module::{logging::RedisLogLevel, valkey_module, Context, Status, ValkeyString};
+use valkey_module::{logging::ValkeyLogLevel, valkey_module, Context, Status, ValkeyString};
 
 static mut GLOBAL_STATE: Option<String> = None;
 
@@ -10,7 +10,7 @@ fn init(ctx: &Context, args: &[ValkeyString]) -> Status {
         (before, after)
     };
     ctx.log(
-        RedisLogLevel::Warning,
+        ValkeyLogLevel::Warning,
         &format!("Update global state on LOAD. BEFORE: {before:?}, AFTER: {after:?}",),
     );
 
@@ -24,7 +24,7 @@ fn deinit(ctx: &Context) -> Status {
         (before, after)
     };
     ctx.log(
-        RedisLogLevel::Warning,
+        ValkeyLogLevel::Warning,
         &format!("Update global state on UNLOAD. BEFORE: {before:?}, AFTER: {after:?}"),
     );
 

examples/scan_keys.rs

@@ -1,12 +1,12 @@
 use valkey_module::{
-    key::RedisKey, valkey_module, Context, KeysCursor, ValkeyResult, ValkeyString, ValkeyValue,
+    key::ValkeyKey, valkey_module, Context, KeysCursor, ValkeyResult, ValkeyString, ValkeyValue,
 };
 
 fn scan_keys(ctx: &Context, _args: Vec<ValkeyString>) -> ValkeyResult {
     let cursor = KeysCursor::new();
     let mut res = Vec::new();
 
-    let scan_callback = |_ctx: &Context, key_name: ValkeyString, _key: Option<&RedisKey>| {
+    let scan_callback = |_ctx: &Context, key_name: ValkeyString, _key: Option<&ValkeyKey>| {
         res.push(ValkeyValue::BulkValkeyString(key_name));
     };
 

redismodule-rs-macros-internals/src/lib.rs

@@ -31,7 +31,7 @@ impl Parse for Args {
 }
 
 /// This proc macro allows specifying which RedisModuleAPI is required by some redismodue-rs
-/// function. The macro finds, for a given set of RedisModuleAPI, what the minimal Redis version is
+/// function. The macro finds, for a given set of RedisModuleAPI, what the minimal Valkey version is
 /// that contains all those APIs and decides whether or not the function might raise an [APIError].
 ///
 /// In addition, for each RedisModuleAPI, the proc macro injects a code that extracts the actual

redismodule-rs-macros/src/command.rs

@@ -10,7 +10,7 @@ use syn::{
 };
 
 #[derive(Debug, Deserialize)]
-pub enum RedisCommandFlags {
+pub enum ValkeyCommandFlags {
     /// The command may modify the data set (it may also read from it).
     Write,
 
@@ -82,29 +82,29 @@ pub enum RedisCommandFlags {
     GetchannelsApi,
 }
 
-impl From<&RedisCommandFlags> for &'static str {
-    fn from(value: &RedisCommandFlags) -> Self {
+impl From<&ValkeyCommandFlags> for &'static str {
+    fn from(value: &ValkeyCommandFlags) -> Self {
         match value {
-            RedisCommandFlags::Write => "write",
-            RedisCommandFlags::ReadOnly => "readonly",
-            RedisCommandFlags::Admin => "admin",
-            RedisCommandFlags::DenyOOM => "deny-oom",
-            RedisCommandFlags::DenyScript => "deny-script",
-            RedisCommandFlags::AllowLoading => "allow-loading",
-            RedisCommandFlags::PubSub => "pubsub",
-            RedisCommandFlags::Random => "random",
-            RedisCommandFlags::AllowStale => "allow-stale",
-            RedisCommandFlags::NoMonitor => "no-monitor",
-            RedisCommandFlags::NoSlowlog => "no-slowlog",
-            RedisCommandFlags::Fast => "fast",
-            RedisCommandFlags::GetkeysApi => "getkeys-api",
-            RedisCommandFlags::NoCluster => "no-cluster",
-            RedisCommandFlags::NoAuth => "no-auth",
-            RedisCommandFlags::MayReplicate => "may-replicate",
-            RedisCommandFlags::NoMandatoryKeys => "no-mandatory-keys",
-            RedisCommandFlags::Blocking => "blocking",
-            RedisCommandFlags::AllowBusy => "allow-busy",
-            RedisCommandFlags::GetchannelsApi => "getchannels-api",
+            ValkeyCommandFlags::Write => "write",
+            ValkeyCommandFlags::ReadOnly => "readonly",
+            ValkeyCommandFlags::Admin => "admin",
+            ValkeyCommandFlags::DenyOOM => "deny-oom",
+            ValkeyCommandFlags::DenyScript => "deny-script",
+            ValkeyCommandFlags::AllowLoading => "allow-loading",
+            ValkeyCommandFlags::PubSub => "pubsub",
+            ValkeyCommandFlags::Random => "random",
+            ValkeyCommandFlags::AllowStale => "allow-stale",
+            ValkeyCommandFlags::NoMonitor => "no-monitor",
+            ValkeyCommandFlags::NoSlowlog => "no-slowlog",
+            ValkeyCommandFlags::Fast => "fast",
+            ValkeyCommandFlags::GetkeysApi => "getkeys-api",
+            ValkeyCommandFlags::NoCluster => "no-cluster",
+            ValkeyCommandFlags::NoAuth => "no-auth",
+            ValkeyCommandFlags::MayReplicate => "may-replicate",
+            ValkeyCommandFlags::NoMandatoryKeys => "no-mandatory-keys",
+            ValkeyCommandFlags::Blocking => "blocking",
+            ValkeyCommandFlags::AllowBusy => "allow-busy",
+            ValkeyCommandFlags::GetchannelsApi => "getchannels-api",
         }
     }
 }
@@ -125,7 +125,7 @@ impl From<&RedisEnterpriseCommandFlags> for &'static str {
 }
 
 #[derive(Debug, Deserialize)]
-pub enum RedisCommandKeySpecFlags {
+pub enum ValkeyCommandKeySpecFlags {
     /// Read-Only. Reads the value of the key, but doesn't necessarily return it.
     ReadOnly,
 
@@ -160,20 +160,20 @@ pub enum RedisCommandKeySpecFlags {
     VariableFlags,
 }
 
-impl From<&RedisCommandKeySpecFlags> for &'static str {
-    fn from(value: &RedisCommandKeySpecFlags) -> Self {
+impl From<&ValkeyCommandKeySpecFlags> for &'static str {
+    fn from(value: &ValkeyCommandKeySpecFlags) -> Self {
         match value {
-            RedisCommandKeySpecFlags::ReadOnly => "READ_ONLY",
-            RedisCommandKeySpecFlags::ReadWrite => "READ_WRITE",
-            RedisCommandKeySpecFlags::Overwrite => "OVERWRITE",
-            RedisCommandKeySpecFlags::Remove => "REMOVE",
-            RedisCommandKeySpecFlags::Access => "ACCESS",
-            RedisCommandKeySpecFlags::Update => "UPDATE",
-            RedisCommandKeySpecFlags::Insert => "INSERT",
-            RedisCommandKeySpecFlags::Delete => "DELETE",
-            RedisCommandKeySpecFlags::NotKey => "NOT_KEY",
-            RedisCommandKeySpecFlags::Incomplete => "INCOMPLETE",
-            RedisCommandKeySpecFlags::VariableFlags => "VARIABLE_FLAGS",
+            ValkeyCommandKeySpecFlags::ReadOnly => "READ_ONLY",
+            ValkeyCommandKeySpecFlags::ReadWrite => "READ_WRITE",
+            ValkeyCommandKeySpecFlags::Overwrite => "OVERWRITE",
+            ValkeyCommandKeySpecFlags::Remove => "REMOVE",
+            ValkeyCommandKeySpecFlags::Access => "ACCESS",
+            ValkeyCommandKeySpecFlags::Update => "UPDATE",
+            ValkeyCommandKeySpecFlags::Insert => "INSERT",
+            ValkeyCommandKeySpecFlags::Delete => "DELETE",
+            ValkeyCommandKeySpecFlags::NotKey => "NOT_KEY",
+            ValkeyCommandKeySpecFlags::Incomplete => "INCOMPLETE",
+            ValkeyCommandKeySpecFlags::VariableFlags => "VARIABLE_FLAGS",
         }
     }
 }
@@ -218,15 +218,15 @@ pub enum BeginSearch {
 #[derive(Debug, Deserialize)]
 pub struct KeySpecArg {
     notes: Option<String>,
-    flags: Vec<RedisCommandKeySpecFlags>,
+    flags: Vec<ValkeyCommandKeySpecFlags>,
     begin_search: BeginSearch,
     find_keys: FindKeys,
 }
 
 #[derive(Debug, Deserialize)]
 struct Args {
     name: Option<String>,
-    flags: Vec<RedisCommandFlags>,
+    flags: Vec<ValkeyCommandFlags>,
     enterprise_flags: Option<Vec<RedisEnterpriseCommandFlags>>,
     summary: Option<String>,
     complexity: Option<String>,

redismodule-rs-macros/src/lib.rs

@@ -6,7 +6,7 @@ mod command;
 mod info_section;
 mod redis_value;
 
-/// This proc macro allow to specify that the follow function is a Redis command.
+/// This proc macro allow to specify that the follow function is a Valkey command.
 /// The macro accept the following arguments that discribe the command properties:
 /// * name (optional) - The command name. in case not given, the function name will be taken.
 /// * flags - An array of [`command::RedisCommandFlags`].
@@ -31,12 +31,12 @@ mod redis_value;
 ///       * NotKey - The key is not actually a key, but should be routed in cluster mode as if it was a key.
 ///       * Incomplete - The keyspec might not point out all the keys it should cover.
 ///       * VariableFlags - Some keys might have different flags depending on arguments.
-///    * begin_search - Represents how Redis should start looking for keys.
+///    * begin_search - Represents how Valkey should start looking for keys.
 ///      There are 2 possible options:
 ///       * Index - start looking for keys from a given position.
 ///       * Keyword - Search for a specific keyward and start looking for keys from this keyword
-///    * FindKeys - After Redis finds the location from where it needs to start looking for keys,
-///      Redis will start finding keys base on the information in this struct.
+///    * FindKeys - After Valkey finds the location from where it needs to start looking for keys,
+///      Valkey will start finding keys base on the information in this struct.
 ///      There are 2 possible options:
 ///       * Range - An object of three element `last_key`, `steps`, `limit`.
 ///          * last_key - Index of the last key relative to the result of the
@@ -80,7 +80,7 @@ mod redis_value;
 /// }
 /// ```
 ///
-/// **Notice**, by default Redis does not validate the command spec. User should validate the command keys on the module command code. The command spec is used for validation on cluster so Redis can raise a cross slot error when needed.
+/// **Notice**, by default Valkey does not validate the command spec. User should validate the command keys on the module command code. The command spec is used for validation on cluster so Valkey can raise a cross slot error when needed.
 #[proc_macro_attribute]
 pub fn command(attr: TokenStream, item: TokenStream) -> TokenStream {
     command::redis_command(attr, item)
@@ -197,7 +197,7 @@ pub fn config_changed_event_handler(_attr: TokenStream, item: TokenStream) -> To
     gen.into()
 }
 
-/// Proc macro which is set on a function that need to be called on Redis cron.
+/// Proc macro which is set on a function that need to be called on Valkey cron.
 /// The function must accept a [Context] and [u64] that represent the cron hz.
 ///
 /// Example:

src/alloc.rs

@@ -16,19 +16,19 @@ fn allocation_free_panic(message: &'static str) -> ! {
     std::process::abort();
 }
 
-const REDIS_ALLOCATOR_NOT_AVAILABLE_MESSAGE: &str =
-    "Critical error: the Redis Allocator isn't available.\n";
+const VALKEY_ALLOCATOR_NOT_AVAILABLE_MESSAGE: &str =
+    "Critical error: the Valkey Allocator isn't available.\n";
 
-/// Defines the Redis allocator. This allocator delegates the allocation
-/// and deallocation tasks to the Redis server when available, otherwise
+/// Defines the Valkey allocator. This allocator delegates the allocation
+/// and deallocation tasks to the Valkey server when available, otherwise
 /// it panics.
 #[derive(Copy, Clone)]
 pub struct ValkeyAlloc;
 
 unsafe impl GlobalAlloc for ValkeyAlloc {
     unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
         /*
-         * To make sure the memory allocation by Redis is aligned to the according to the layout,
+         * To make sure the memory allocation by Valkey is aligned to the according to the layout,
          * we need to align the size of the allocation to the layout.
          *
          * "Memory is conceptually broken into equal-sized chunks,
@@ -42,14 +42,14 @@ unsafe impl GlobalAlloc for ValkeyAlloc {
 
         match raw::RedisModule_Alloc {
             Some(alloc) => alloc(size).cast(),
-            None => allocation_free_panic(REDIS_ALLOCATOR_NOT_AVAILABLE_MESSAGE),
+            None => allocation_free_panic(VALKEY_ALLOCATOR_NOT_AVAILABLE_MESSAGE),
         }
     }
 
     unsafe fn dealloc(&self, ptr: *mut u8, _layout: Layout) {
         match raw::RedisModule_Free {
             Some(f) => f(ptr.cast()),
-            None => allocation_free_panic(REDIS_ALLOCATOR_NOT_AVAILABLE_MESSAGE),
+            None => allocation_free_panic(VALKEY_ALLOCATOR_NOT_AVAILABLE_MESSAGE),
         };
     }
 }