Adding upstream version 5:7.0.15.upstream/5%7.0.15upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

37 files changed, 4827 insertions, 0 deletions

diff --git a/tests/unit/moduleapi/aclcheck.tcl b/tests/unit/moduleapi/aclcheck.tcl
new file mode 100644
index 0000000..d96ea89
--- /dev/null
+++ b/tests/unit/moduleapi/aclcheck.tcl
@@ -0,0 +1,99 @@
+set testmodule [file normalize tests/modules/aclcheck.so]
+
+start_server {tags {"modules acl"}} {
+    r module load $testmodule
+
+    test {test module check acl for command perm} {
+        # by default all commands allowed
+        assert_equal [r aclcheck.rm_call.check.cmd set x 5] OK
+        # block SET command for user
+        r acl setuser default -set
+        catch {r aclcheck.rm_call.check.cmd set x 5} e
+        assert_match {*DENIED CMD*} $e
+
+        # verify that new log entry added
+        set entry [lindex [r ACL LOG] 0]
+        assert {[dict get $entry username] eq {default}}
+        assert {[dict get $entry context] eq {module}}
+        assert {[dict get $entry object] eq {set}}
+        assert {[dict get $entry reason] eq {command}}
+    }
+
+    test {test module check acl for key perm} {
+        # give permission for SET and block all keys but x(READ+WRITE), y(WRITE), z(READ)
+        r acl setuser default +set resetkeys ~x %W~y %R~z
+
+        assert_equal [r aclcheck.set.check.key "*" x 5] OK
+        catch {r aclcheck.set.check.key "*" v 5} e
+        assert_match "*DENIED KEY*" $e
+
+        assert_equal [r aclcheck.set.check.key "~" x 5] OK
+        assert_equal [r aclcheck.set.check.key "~" y 5] OK
+        assert_equal [r aclcheck.set.check.key "~" z 5] OK
+        catch {r aclcheck.set.check.key "~" v 5} e
+        assert_match "*DENIED KEY*" $e
+
+        assert_equal [r aclcheck.set.check.key "W" y 5] OK
+        catch {r aclcheck.set.check.key "W" v 5} e
+        assert_match "*DENIED KEY*" $e
+
+        assert_equal [r aclcheck.set.check.key "R" z 5] OK
+        catch {r aclcheck.set.check.key "R" v 5} e
+        assert_match "*DENIED KEY*" $e
+    }
+
+    test {test module check acl for module user} {
+        # the module user has access to all keys
+        assert_equal [r aclcheck.rm_call.check.cmd.module.user set y 5] OK
+    }
+
+    test {test module check acl for channel perm} {
+        # block all channels but ch1
+        r acl setuser default resetchannels &ch1
+        assert_equal [r aclcheck.publish.check.channel ch1 msg] 0
+        catch {r aclcheck.publish.check.channel ch2 msg} e
+        set e
+    } {*DENIED CHANNEL*}
+
+    test {test module check acl in rm_call} {
+        # rm call check for key permission (x: READ + WRITE)
+        assert_equal [r aclcheck.rm_call set x 5] OK
+        assert_equal [r aclcheck.rm_call set x 6 get] 5
+
+        # rm call check for key permission (y: only WRITE)
+        assert_equal [r aclcheck.rm_call set y 5] OK
+        assert_error {*NOPERM*} {r aclcheck.rm_call set y 5 get}
+        assert_error {ERR acl verification failed, can't access at least one of the keys mentioned in the command arguments.} {r aclcheck.rm_call_with_errors set y 5 get}
+
+        # rm call check for key permission (z: only READ)
+        assert_error {*NOPERM*} {r aclcheck.rm_call set z 5}
+        assert_error {ERR acl verification failed, can't access at least one of the keys mentioned in the command arguments.} {r aclcheck.rm_call_with_errors set z 5}
+        assert_error {*NOPERM*} {r aclcheck.rm_call set z 6 get}
+        assert_error {ERR acl verification failed, can't access at least one of the keys mentioned in the command arguments.} {r aclcheck.rm_call_with_errors set z 6 get}
+
+        # verify that new log entry added
+        set entry [lindex [r ACL LOG] 0]
+        assert {[dict get $entry username] eq {default}}
+        assert {[dict get $entry context] eq {module}}
+        assert {[dict get $entry object] eq {z}}
+        assert {[dict get $entry reason] eq {key}}
+
+        # rm call check for command permission
+        r acl setuser default -set
+        catch {r aclcheck.rm_call set x 5} e
+        assert_match {*NOPERM*} $e
+        catch {r aclcheck.rm_call_with_errors set x 5} e
+        assert_match {ERR acl verification failed, can't run this command or subcommand.} $e
+
+        # verify that new log entry added
+        set entry [lindex [r ACL LOG] 0]
+        assert {[dict get $entry username] eq {default}}
+        assert {[dict get $entry context] eq {module}}
+        assert {[dict get $entry object] eq {set}}
+        assert {[dict get $entry reason] eq {command}}
+    }
+
+    test "Unload the module - aclcheck" {
+        assert_equal {OK} [r module unload aclcheck]
+    }
+}
diff --git a/tests/unit/moduleapi/auth.tcl b/tests/unit/moduleapi/auth.tcl
new file mode 100644
index 0000000..c7c2def
--- /dev/null
+++ b/tests/unit/moduleapi/auth.tcl
@@ -0,0 +1,90 @@
+set testmodule [file normalize tests/modules/auth.so]
+
+start_server {tags {"modules"}} {
+    r module load $testmodule
+
+    test {Modules can create a user that can be authenticated} {
+        # Make sure we start authenticated with default user
+        r auth default ""
+        assert_equal [r acl whoami] "default"
+        r auth.createmoduleuser
+
+        set id [r auth.authmoduleuser]
+        assert_equal [r client id] $id
+
+        # Verify returned id is the same as our current id and
+        # we are authenticated with the specified user
+        assert_equal [r acl whoami] "global"
+    }
+
+    test {De-authenticating clients is tracked and kills clients} {
+        assert_equal [r auth.changecount] 0
+        r auth.createmoduleuser
+
+        # Catch the I/O exception that was thrown when Redis
+        # disconnected with us. 
+        catch { [r ping] } e
+        assert_match {*I/O*} $e
+
+        # Check that a user change was registered
+        assert_equal [r auth.changecount] 1
+    }
+
+    test {Modules can't authenticate with ACLs users that dont exist} {
+        catch { [r auth.authrealuser auth-module-test-fake] } e
+        assert_match {*Invalid user*} $e
+    }
+
+    test {Modules can authenticate with ACL users} {
+        assert_equal [r acl whoami] "default"
+
+        # Create user to auth into
+        r acl setuser auth-module-test on allkeys allcommands
+
+        set id [r auth.authrealuser auth-module-test]
+
+        # Verify returned id is the same as our current id and
+        # we are authenticated with the specified user
+        assert_equal [r client id] $id
+        assert_equal [r acl whoami] "auth-module-test"
+    }
+
+    test {Client callback is called on user switch} {
+        assert_equal [r auth.changecount] 0
+
+        # Auth again and validate change count
+        r auth.authrealuser auth-module-test
+        assert_equal [r auth.changecount] 1
+
+        # Re-auth with the default user
+        r auth default ""
+        assert_equal [r auth.changecount] 1
+        assert_equal [r acl whoami] "default"
+
+        # Re-auth with the default user again, to
+        # verify the callback isn't fired again
+        r auth default ""
+        assert_equal [r auth.changecount] 0
+        assert_equal [r acl whoami] "default"
+    }
+
+    test {modules can redact arguments} {
+        r config set slowlog-log-slower-than 0
+        r slowlog reset
+        r auth.redact 1 2 3 4
+        r auth.redact 1 2 3
+        r config set slowlog-log-slower-than -1
+        set slowlog_resp [r slowlog get]
+
+        # There will be 3 records, slowlog reset and the
+        # two auth redact calls.
+        assert_equal 3 [llength $slowlog_resp]
+        assert_equal {slowlog reset} [lindex [lindex $slowlog_resp 2] 3]
+        assert_equal {auth.redact 1 (redacted) 3 (redacted)} [lindex [lindex $slowlog_resp 1] 3]
+        assert_equal {auth.redact (redacted) 2 (redacted)} [lindex [lindex $slowlog_resp 0] 3]
+    }
+
+    test "Unload the module - testacl" {
+        assert_equal {OK} [r module unload testacl]
+    }
+}
diff --git a/tests/unit/moduleapi/basics.tcl b/tests/unit/moduleapi/basics.tcl
new file mode 100644
index 0000000..040d9eb
--- /dev/null
+++ b/tests/unit/moduleapi/basics.tcl
@@ -0,0 +1,41 @@
+set testmodule [file normalize tests/modules/basics.so]
+
+start_server {tags {"modules"}} {
+    r module load $testmodule
+
+    test {test module api basics} {
+        r test.basics
+    } {ALL TESTS PASSED}
+
+    test {test rm_call auto mode} {
+        r hello 2
+        set reply [r test.rmcallautomode]
+        assert_equal [lindex $reply 0] f1
+        assert_equal [lindex $reply 1] v1
+        assert_equal [lindex $reply 2] f2
+        assert_equal [lindex $reply 3] v2
+        r hello 3
+        set reply [r test.rmcallautomode]
+        assert_equal [dict get $reply f1] v1
+        assert_equal [dict get $reply f2] v2
+    }
+
+    test {test get resp} {
+        r hello 2
+        set reply [r test.getresp]
+        assert_equal $reply 2
+        r hello 3
+        set reply [r test.getresp]
+        assert_equal $reply 3
+    }
+
+    test "Unload the module - test" {
+        assert_equal {OK} [r module unload test]
+    }
+}
+
+start_server {tags {"modules external:skip"} overrides {enable-module-command no}} {
+    test {module command disabled} {
+       assert_error "ERR *MODULE command not allowed*" {r module load $testmodule}
+    }
+}
\ No newline at end of file
diff --git a/tests/unit/moduleapi/blockedclient.tcl b/tests/unit/moduleapi/blockedclient.tcl
new file mode 100644
index 0000000..bdcef96
--- /dev/null
+++ b/tests/unit/moduleapi/blockedclient.tcl
@@ -0,0 +1,277 @@
+set testmodule [file normalize tests/modules/blockedclient.so]
+
+start_server {tags {"modules"}} {
+    r module load $testmodule
+
+    test {Locked GIL acquisition} {
+        assert_match "OK" [r acquire_gil]
+    }
+
+    test {Locked GIL acquisition during multi} {
+    	r multi
+    	r acquire_gil
+    	assert_equal {{Blocked client is not supported inside multi}} [r exec]
+    }
+
+    test {Locked GIL acquisition from RM_Call} {
+    	assert_equal {Blocked client is not allowed} [r do_rm_call acquire_gil]
+    }
+
+    test {Blocking command are not block the client on RM_Call} {
+    	r lpush l test
+    	assert_equal [r do_rm_call blpop l 0] {l test}
+    	
+    	r lpush l test
+    	assert_equal [r do_rm_call brpop l 0] {l test}
+    	
+    	r lpush l1 test
+    	assert_equal [r do_rm_call brpoplpush l1 l2 0] {test}
+    	assert_equal [r do_rm_call brpop l2 0] {l2 test}
+
+    	r lpush l1 test
+    	assert_equal [r do_rm_call blmove l1 l2 LEFT LEFT 0] {test}
+    	assert_equal [r do_rm_call brpop l2 0] {l2 test}
+
+    	r ZADD zset1 0 a 1 b 2 c
+    	assert_equal [r do_rm_call bzpopmin zset1 0] {zset1 a 0}
+    	assert_equal [r do_rm_call bzpopmax zset1 0] {zset1 c 2}
+
+    	r xgroup create s g $ MKSTREAM
+    	r xadd s * foo bar
+    	assert {[r do_rm_call xread BLOCK 0 STREAMS s 0-0] ne {}}
+    	assert {[r do_rm_call xreadgroup group g c BLOCK 0 STREAMS s >] ne {}}
+
+    	assert {[r do_rm_call blpop empty_list 0] eq {}}
+        assert {[r do_rm_call brpop empty_list 0] eq {}}
+        assert {[r do_rm_call brpoplpush empty_list1 empty_list2 0] eq {}}
+        assert {[r do_rm_call blmove empty_list1 empty_list2 LEFT LEFT 0] eq {}}
+        
+        assert {[r do_rm_call bzpopmin empty_zset 0] eq {}}
+        assert {[r do_rm_call bzpopmax empty_zset 0] eq {}}
+       
+        r xgroup create empty_stream g $ MKSTREAM
+        assert {[r do_rm_call xread BLOCK 0 STREAMS empty_stream $] eq {}}
+        assert {[r do_rm_call xreadgroup group g c BLOCK 0 STREAMS empty_stream >] eq {}}
+
+    }
+
+    test {Monitor disallow inside RM_Call} {
+        set e {}
+        catch {
+            r do_rm_call monitor
+        } e
+        set e
+    } {*ERR*DENY BLOCKING*}
+
+    test {subscribe disallow inside RM_Call} {
+        set e {}
+        catch {
+            r do_rm_call subscribe x
+        } e
+        set e
+    } {*ERR*DENY BLOCKING*}
+
+    test {RM_Call from blocked client} {
+        r hset hash foo bar
+        r do_bg_rm_call hgetall hash
+    } {foo bar}
+
+    test {RM_Call from blocked client with script mode} {
+        r do_bg_rm_call_format S hset k foo bar
+    } {1}
+
+    test {RM_Call from blocked client with oom mode} {
+        r config set maxmemory 1
+        # will set server.pre_command_oom_state to 1
+        assert_error {OOM command not allowed*} {r hset hash foo bar}
+        r config set maxmemory 0
+        # now its should be OK to call OOM commands
+        r do_bg_rm_call_format M hset k1 foo bar
+    } {1} {needs:config-maxmemory}
+
+    test {RESP version carries through to blocked client} {
+        for {set client_proto 2} {$client_proto <= 3} {incr client_proto} {
+            r hello $client_proto
+            r readraw 1
+            set ret [r do_fake_bg_true]
+            if {$client_proto == 2} {
+                assert_equal $ret {:1}
+            } else {
+                assert_equal $ret "#t"
+            }
+            r readraw 0
+        }
+    }
+
+foreach call_type {nested normal} {
+    test "Busy module command - $call_type" {
+        set busy_time_limit 50
+        set old_time_limit [lindex [r config get busy-reply-threshold] 1]
+        r config set busy-reply-threshold $busy_time_limit
+        set rd [redis_deferring_client]
+
+        # run command that blocks until released
+        set start [clock clicks -milliseconds]
+        if {$call_type == "nested"} {
+            $rd do_rm_call slow_fg_command 0
+        } else {
+            $rd slow_fg_command 0
+        }
+        $rd flush
+
+        # send another command after the blocked one, to make sure we don't attempt to process it
+        $rd ping
+        $rd flush
+
+        # make sure we get BUSY error, and that we didn't get it too early
+        assert_error {*BUSY Slow module operation*} {r ping}
+        assert_morethan_equal [expr [clock clicks -milliseconds]-$start] $busy_time_limit
+
+        # abort the blocking operation
+        r stop_slow_fg_command
+        wait_for_condition 50 100 {
+            [catch {r ping} e] == 0
+        } else {
+            fail "Failed waiting for busy command to end"
+        }
+        assert_equal [$rd read] "1"
+        assert_equal [$rd read] "PONG"
+
+        # run command that blocks for 200ms
+        set start [clock clicks -milliseconds]
+        if {$call_type == "nested"} {
+            $rd do_rm_call slow_fg_command 200000
+        } else {
+            $rd slow_fg_command 200000
+        }
+        $rd flush
+        after 10 ;# try to make sure redis started running the command before we proceed
+
+        # make sure we didn't get BUSY error, it simply blocked till the command was done
+        r ping
+        assert_morethan_equal [expr [clock clicks -milliseconds]-$start] 200
+        $rd read
+
+        $rd close
+        r config set busy-reply-threshold $old_time_limit
+    }
+}
+
+    test {RM_Call from blocked client} {
+        set busy_time_limit 50
+        set old_time_limit [lindex [r config get busy-reply-threshold] 1]
+        r config set busy-reply-threshold $busy_time_limit
+
+        # trigger slow operation
+        r set_slow_bg_operation 1
+        r hset hash foo bar
+        set rd [redis_deferring_client]
+        set start [clock clicks -milliseconds]
+        $rd do_bg_rm_call hgetall hash
+
+        # send another command after the blocked one, to make sure we don't attempt to process it
+        $rd ping
+        $rd flush
+
+        # wait till we know we're blocked inside the module
+        wait_for_condition 50 100 {
+            [r is_in_slow_bg_operation] eq 1
+        } else {
+            fail "Failed waiting for slow operation to start"
+        }
+
+        # make sure we get BUSY error, and that we didn't get here too early
+        assert_error {*BUSY Slow module operation*} {r ping}
+        assert_morethan [expr [clock clicks -milliseconds]-$start] $busy_time_limit
+        # abort the blocking operation
+        r set_slow_bg_operation 0
+
+        wait_for_condition 50 100 {
+            [r is_in_slow_bg_operation] eq 0
+        } else {
+            fail "Failed waiting for slow operation to stop"
+        }
+        assert_equal [r ping] {PONG}
+
+        r config set busy-reply-threshold $old_time_limit
+        assert_equal [$rd read] {foo bar}
+        assert_equal [$rd read] {PONG}
+        $rd close
+    }
+
+    test {blocked client reaches client output buffer limit} {
+        r hset hash big [string repeat x 50000]
+        r hset hash bada [string repeat x 50000]
+        r hset hash boom [string repeat x 50000]
+        r config set client-output-buffer-limit {normal 100000 0 0}
+        r client setname myclient
+        catch {r do_bg_rm_call hgetall hash} e
+        assert_match "*I/O error*" $e
+        reconnect
+        set clients [r client list]
+        assert_no_match "*name=myclient*" $clients
+    }
+
+    test {module client error stats} {
+        r config resetstat
+
+        # simple module command that replies with string error
+        assert_error "ERR unknown command 'hgetalllll', with args beginning with:" {r do_rm_call hgetalllll}
+        assert_equal [errorrstat ERR r] {count=1}
+
+        # simple module command that replies with string error
+        assert_error "ERR unknown subcommand 'bla'. Try CONFIG HELP." {r do_rm_call config bla}
+        assert_equal [errorrstat ERR r] {count=2}
+
+        # module command that replies with string error from bg thread
+        assert_error "NULL reply returned" {r do_bg_rm_call hgetalllll}
+        assert_equal [errorrstat NULL r] {count=1}
+
+        # module command that returns an arity error
+        r do_rm_call set x x
+        assert_error "ERR wrong number of arguments for 'do_rm_call' command" {r do_rm_call}
+        assert_equal [errorrstat ERR r] {count=3}
+
+        # RM_Call that propagates an error
+        assert_error "WRONGTYPE*" {r do_rm_call hgetall x}
+        assert_equal [errorrstat WRONGTYPE r] {count=1}
+        assert_match {*calls=1,*,rejected_calls=0,failed_calls=1} [cmdrstat hgetall r]
+
+        # RM_Call from bg thread that propagates an error
+        assert_error "WRONGTYPE*" {r do_bg_rm_call hgetall x}
+        assert_equal [errorrstat WRONGTYPE r] {count=2}
+        assert_match {*calls=2,*,rejected_calls=0,failed_calls=2} [cmdrstat hgetall r]
+
+        assert_equal [s total_error_replies] 6
+        assert_match {*calls=5,*,rejected_calls=0,failed_calls=4} [cmdrstat do_rm_call r]
+        assert_match {*calls=2,*,rejected_calls=0,failed_calls=2} [cmdrstat do_bg_rm_call r]
+    }
+
+    set master [srv 0 client]
+    set master_host [srv 0 host]
+    set master_port [srv 0 port]
+    start_server [list overrides [list loadmodule "$testmodule"]] {
+        set replica [srv 0 client]
+        set replica_host [srv 0 host]
+        set replica_port [srv 0 port]
+
+        # Start the replication process...
+        $replica replicaof $master_host $master_port
+        wait_for_sync $replica
+
+        test {WAIT command on module blocked client} {
+            pause_process [srv 0 pid]
+
+            $master do_bg_rm_call_format ! hset bk1 foo bar
+
+            assert_equal [$master wait 1 1000] 0
+            resume_process [srv 0 pid]
+            assert_equal [$master wait 1 1000] 1
+            assert_equal [$replica hget bk1 foo] bar
+        }
+    }
+    
+    test "Unload the module - blockedclient" {
+        assert_equal {OK} [r module unload blockedclient]
+    }
+}
diff --git a/tests/unit/moduleapi/blockonbackground.tcl b/tests/unit/moduleapi/blockonbackground.tcl
new file mode 100644
index 0000000..fcd7f1d
--- /dev/null
+++ b/tests/unit/moduleapi/blockonbackground.tcl
@@ -0,0 +1,126 @@
+set testmodule [file normalize tests/modules/blockonbackground.so]
+
+source tests/support/util.tcl
+
+proc latency_percentiles_usec {cmd} {
+    return [latencyrstat_percentiles $cmd r]
+}
+
+start_server {tags {"modules"}} {
+    r module load $testmodule
+
+    test { blocked clients time tracking - check blocked command that uses RedisModule_BlockedClientMeasureTimeStart() is tracking background time} {
+        r slowlog reset
+        r config set slowlog-log-slower-than 200000
+        if {!$::no_latency} {
+            assert_equal [r slowlog len] 0
+        }
+        r block.debug 0 10000
+        if {!$::no_latency} {
+            assert_equal [r slowlog len] 0
+        }
+        r config resetstat
+        r config set latency-tracking yes
+        r config set latency-tracking-info-percentiles "50.0"
+        r block.debug 200 10000
+        if {!$::no_latency} {
+            assert_equal [r slowlog len] 1
+        }
+
+        set cmdstatline [cmdrstat block.debug r]
+        set latencystatline_debug [latency_percentiles_usec block.debug]
+
+        regexp "calls=1,usec=(.*?),usec_per_call=(.*?),rejected_calls=0,failed_calls=0" $cmdstatline -> usec usec_per_call
+        regexp "p50=(.+\..+)" $latencystatline_debug  -> p50
+        assert {$usec >= 100000}
+        assert {$usec_per_call >= 100000}
+        assert {$p50 >= 100000}
+    }
+
+    test { blocked clients time tracking - check blocked command that uses RedisModule_BlockedClientMeasureTimeStart() is tracking background time even in timeout } {
+        r slowlog reset
+        r config set slowlog-log-slower-than 200000
+        if {!$::no_latency} {
+            assert_equal [r slowlog len] 0
+        }
+        r block.debug 0 20000
+        if {!$::no_latency} {
+            assert_equal [r slowlog len] 0
+        }
+        r config resetstat
+        r block.debug 20000 500
+        if {!$::no_latency} {
+            assert_equal [r slowlog len] 1
+        }
+
+        set cmdstatline [cmdrstat block.debug r]
+
+        regexp "calls=1,usec=(.*?),usec_per_call=(.*?),rejected_calls=0,failed_calls=0" $cmdstatline usec usec_per_call
+        assert {$usec >= 250000}
+        assert {$usec_per_call >= 250000}
+    }
+
+    test { blocked clients time tracking - check blocked command with multiple calls RedisModule_BlockedClientMeasureTimeStart()  is tracking the total background time } {
+        r slowlog reset
+        r config set slowlog-log-slower-than 200000
+        if {!$::no_latency} {
+            assert_equal [r slowlog len] 0
+        }
+        r block.double_debug 0
+        if {!$::no_latency} {
+            assert_equal [r slowlog len] 0
+        }
+        r config resetstat
+        r block.double_debug 100
+        if {!$::no_latency} {
+            assert_equal [r slowlog len] 1
+        }
+        set cmdstatline [cmdrstat block.double_debug r]
+
+        regexp "calls=1,usec=(.*?),usec_per_call=(.*?),rejected_calls=0,failed_calls=0" $cmdstatline usec usec_per_call
+        assert {$usec >= 60000}
+        assert {$usec_per_call >= 60000}
+    }
+
+    test { blocked clients time tracking - check blocked command without calling RedisModule_BlockedClientMeasureTimeStart() is not reporting background time } {
+        r slowlog reset
+        r config set slowlog-log-slower-than 200000
+        if {!$::no_latency} {
+            assert_equal [r slowlog len] 0
+        }
+        r block.debug_no_track 200 1000
+        # ensure slowlog is still empty
+        if {!$::no_latency} {
+            assert_equal [r slowlog len] 0
+        }
+    }
+
+    test "client unblock works only for modules with timeout support" {
+        set rd [redis_deferring_client]
+        $rd client id
+        set id [$rd read]
+
+        # Block with a timeout function - may unblock
+        $rd block.block 20000
+        wait_for_condition 50 100 {
+            [r block.is_blocked] == 1
+        } else {
+            fail "Module did not block"
+        }
+
+        assert_equal 1 [r client unblock $id]
+        assert_match {*Timed out*} [$rd read]
+
+        # Block without a timeout function - cannot unblock
+        $rd block.block 0
+        wait_for_condition 50 100 {
+            [r block.is_blocked] == 1
+        } else {
+            fail "Module did not block"
+        }
+
+        assert_equal 0 [r client unblock $id]
+        assert_equal "OK" [r block.release foobar]
+        assert_equal "foobar" [$rd read]
+    }
+}
diff --git a/tests/unit/moduleapi/blockonkeys.tcl b/tests/unit/moduleapi/blockonkeys.tcl
new file mode 100644
index 0000000..5e916c5
--- /dev/null
+++ b/tests/unit/moduleapi/blockonkeys.tcl
@@ -0,0 +1,306 @@
+set testmodule [file normalize tests/modules/blockonkeys.so]
+
+start_server {tags {"modules"}} {
+    r module load $testmodule
+
+    test "Module client blocked on keys: Circular BPOPPUSH" {
+        set rd1 [redis_deferring_client]
+        set rd2 [redis_deferring_client]
+
+        r del src dst
+
+        $rd1 fsl.bpoppush src dst 0
+        $rd2 fsl.bpoppush dst src 0
+        ;# wait until clients are actually blocked
+        wait_for_condition 50 100 {
+            [s 0 blocked_clients] eq {2}
+        } else {
+            fail "Clients are not blocked"
+        }
+
+        r fsl.push src 42
+
+        assert_equal {42} [r fsl.getall src]
+        assert_equal {} [r fsl.getall dst]
+    }
+
+    test "Module client blocked on keys: Self-referential BPOPPUSH" {
+        set rd1 [redis_deferring_client]
+
+        r del src
+
+        $rd1 fsl.bpoppush src src 0
+        ;# wait until clients are actually blocked
+        wait_for_condition 50 100 {
+            [s 0 blocked_clients] eq {1}
+        } else {
+            fail "Clients are not blocked"
+        }
+        r fsl.push src 42
+
+        assert_equal {42} [r fsl.getall src]
+    }
+
+    test {Module client blocked on keys (no metadata): No block} {
+        r del k
+        r fsl.push k 33
+        r fsl.push k 34
+        r fsl.bpop k 0
+    } {34}
+
+    test {Module client blocked on keys (no metadata): Timeout} {
+        r del k
+        set rd [redis_deferring_client]
+        $rd fsl.bpop k 1
+        assert_equal {Request timedout} [$rd read]
+    }
+
+    test {Module client blocked on keys (no metadata): Blocked} {
+        r del k
+        set rd [redis_deferring_client]
+        $rd fsl.bpop k 0
+        ;# wait until clients are actually blocked
+        wait_for_condition 50 100 {
+            [s 0 blocked_clients] eq {1}
+        } else {
+            fail "Clients are not blocked"
+        }
+        r fsl.push k 34
+        assert_equal {34} [$rd read]
+    }
+
+    test {Module client blocked on keys (with metadata): No block} {
+        r del k
+        r fsl.push k 34
+        r fsl.bpopgt k 30 0
+    } {34}
+
+    test {Module client blocked on keys (with metadata): Timeout} {
+        r del k
+        set rd [redis_deferring_client]
+        $rd client id
+        set cid [$rd read]
+        r fsl.push k 33
+        $rd fsl.bpopgt k 35 1
+        assert_equal {Request timedout} [$rd read]
+        r client kill id $cid ;# try to smoke-out client-related memory leak
+    }
+
+    test {Module client blocked on keys (with metadata): Blocked, case 1} {
+        r del k
+        set rd [redis_deferring_client]
+        $rd client id
+        set cid [$rd read]
+        r fsl.push k 33
+        $rd fsl.bpopgt k 33 0
+        ;# wait until clients are actually blocked
+        wait_for_condition 50 100 {
+            [s 0 blocked_clients] eq {1}
+        } else {
+            fail "Clients are not blocked"
+        }
+        r fsl.push k 34
+        assert_equal {34} [$rd read]
+        r client kill id $cid ;# try to smoke-out client-related memory leak
+    }
+
+    test {Module client blocked on keys (with metadata): Blocked, case 2} {
+        r del k
+        set rd [redis_deferring_client]
+        $rd fsl.bpopgt k 35 0
+        ;# wait until clients are actually blocked
+        wait_for_condition 50 100 {
+            [s 0 blocked_clients] eq {1}
+        } else {
+            fail "Clients are not blocked"
+        }
+        r fsl.push k 33
+        r fsl.push k 34
+        r fsl.push k 35
+        r fsl.push k 36
+        assert_equal {36} [$rd read]
+    }
+
+    test {Module client blocked on keys (with metadata): Blocked, CLIENT KILL} {
+        r del k
+        set rd [redis_deferring_client]
+        $rd client id
+        set cid [$rd read]
+        $rd fsl.bpopgt k 35 0
+        ;# wait until clients are actually blocked
+        wait_for_condition 50 100 {
+            [s 0 blocked_clients] eq {1}
+        } else {
+            fail "Clients are not blocked"
+        }
+        r client kill id $cid ;# try to smoke-out client-related memory leak
+    }
+
+    test {Module client blocked on keys (with metadata): Blocked, CLIENT UNBLOCK TIMEOUT} {
+        r del k
+        set rd [redis_deferring_client]
+        $rd client id
+        set cid [$rd read]
+        $rd fsl.bpopgt k 35 0
+        ;# wait until clients are actually blocked
+        wait_for_condition 50 100 {
+            [s 0 blocked_clients] eq {1}
+        } else {
+            fail "Clients are not blocked"
+        }
+        r client unblock $cid timeout ;# try to smoke-out client-related memory leak
+        assert_equal {Request timedout} [$rd read]
+    }
+
+    test {Module client blocked on keys (with metadata): Blocked, CLIENT UNBLOCK ERROR} {
+        r del k
+        set rd [redis_deferring_client]
+        $rd client id
+        set cid [$rd read]
+        $rd fsl.bpopgt k 35 0
+        ;# wait until clients are actually blocked
+        wait_for_condition 50 100 {
+            [s 0 blocked_clients] eq {1}
+        } else {
+            fail "Clients are not blocked"
+        }
+        r client unblock $cid error ;# try to smoke-out client-related memory leak
+        assert_error "*unblocked*" {$rd read}
+    }
+
+    test {Module client blocked on keys, no timeout CB, CLIENT UNBLOCK TIMEOUT} {
+        r del k
+        set rd [redis_deferring_client]
+        $rd client id
+        set cid [$rd read]
+        $rd fsl.bpop k 0 NO_TO_CB
+        ;# wait until clients are actually blocked
+        wait_for_condition 50 100 {
+            [s 0 blocked_clients] eq {1}
+        } else {
+            fail "Clients are not blocked"
+        }
+        assert_equal [r client unblock $cid timeout] {0}
+        $rd close
+    }
+
+    test {Module client blocked on keys, no timeout CB, CLIENT UNBLOCK ERROR} {
+        r del k
+        set rd [redis_deferring_client]
+        $rd client id
+        set cid [$rd read]
+        $rd fsl.bpop k 0 NO_TO_CB
+        ;# wait until clients are actually blocked
+        wait_for_condition 50 100 {
+            [s 0 blocked_clients] eq {1}
+        } else {
+            fail "Clients are not blocked"
+        }
+        assert_equal [r client unblock $cid error] {0}
+        $rd close
+    }
+
+    test {Module client re-blocked on keys after woke up on wrong type} {
+        r del k
+        set rd [redis_deferring_client]
+        $rd fsl.bpop k 0
+        ;# wait until clients are actually blocked
+        wait_for_condition 50 100 {
+            [s 0 blocked_clients] eq {1}
+        } else {
+            fail "Clients are not blocked"
+        }
+        r lpush k 12
+        r lpush k 13
+        r lpush k 14
+        r del k
+        r fsl.push k 34
+        assert_equal {34} [$rd read]
+        assert_equal {1} [r get fsl_wrong_type] ;# first lpush caused one wrong-type wake-up
+    }
+
+    test {Module client blocked on keys woken up by LPUSH} {
+        r del k
+        set rd [redis_deferring_client]
+        $rd blockonkeys.popall k
+        # wait until client is actually blocked
+        wait_for_condition 50 100 {
+            [s 0 blocked_clients] eq {1}
+        } else {
+            fail "Client is not blocked"
+        }
+        r lpush k 42 squirrel banana
+        assert_equal {banana squirrel 42} [$rd read]
+        $rd close
+    }
+
+    test {Module client unblocks BLPOP} {
+        r del k
+        set rd [redis_deferring_client]
+        $rd blpop k 3
+        # wait until client is actually blocked
+        wait_for_condition 50 100 {
+            [s 0 blocked_clients] eq {1}
+        } else {
+            fail "Client is not blocked"
+        }
+        r blockonkeys.lpush k 42
+        assert_equal {k 42} [$rd read]
+        $rd close
+    }
+
+    test {Module unblocks module blocked on non-empty list} {
+        r del k
+        r lpush k aa
+        # Module client blocks to pop 5 elements from list
+        set rd [redis_deferring_client]
+        $rd blockonkeys.blpopn k 5
+        # Wait until client is actually blocked
+        wait_for_condition 50 100 {
+            [s 0 blocked_clients] eq {1}
+        } else {
+            fail "Client is not blocked"
+        }
+        # Check that RM_SignalKeyAsReady() can wake up BLPOPN
+        r blockonkeys.lpush_unblock k bb cc ;# Not enough elements for BLPOPN
+        r lpush k dd ee ff                  ;# Doesn't unblock module
+        r blockonkeys.lpush_unblock k gg    ;# Unblocks module
+        assert_equal {gg ff ee dd cc} [$rd read]
+        $rd close
+    }
+
+    set master [srv 0 client]
+    set master_host [srv 0 host]
+    set master_port [srv 0 port]
+    start_server [list overrides [list loadmodule "$testmodule"]] {
+        set replica [srv 0 client]
+        set replica_host [srv 0 host]
+        set replica_port [srv 0 port]
+
+        # Start the replication process...
+        $replica replicaof $master_host $master_port
+        wait_for_sync $replica
+
+        test {WAIT command on module blocked client on keys} {
+            set rd [redis_deferring_client -1]
+            $rd set x y
+            $rd read
+
+            pause_process [srv 0 pid]
+
+            $master del k
+            $rd fsl.bpop k 0
+            wait_for_blocked_client -1
+            $master fsl.push k 34
+            $master fsl.push k 35
+            assert_equal {34} [$rd read]
+
+            assert_equal [$master wait 1 1000] 0
+            resume_process [srv 0 pid]
+            assert_equal [$master wait 1 1000] 1
+            $rd close
+            assert_equal {35} [$replica fsl.getall k]
+        }
+    }
+
+}
diff --git a/tests/unit/moduleapi/cluster.tcl b/tests/unit/moduleapi/cluster.tcl
new file mode 100644
index 0000000..bbd2562
--- /dev/null
+++ b/tests/unit/moduleapi/cluster.tcl
@@ -0,0 +1,204 @@
+# Primitive tests on cluster-enabled redis with modules using redis-cli
+
+source tests/support/cli.tcl
+
+set testmodule [file normalize tests/modules/blockonkeys.so]
+set testmodule_nokey [file normalize tests/modules/blockonbackground.so]
+set testmodule_blockedclient [file normalize tests/modules/blockedclient.so]
+
+# make sure the test infra won't use SELECT
+set old_singledb $::singledb
+set ::singledb 1
+
+# cluster creation is complicated with TLS, and the current tests don't really need that coverage
+tags {tls:skip external:skip cluster modules} {
+
+# start three servers
+set base_conf [list cluster-enabled yes cluster-node-timeout 1 loadmodule $testmodule]
+start_server [list overrides $base_conf] {
+start_server [list overrides $base_conf] {
+start_server [list overrides $base_conf] {
+
+    set node1 [srv 0 client]
+    set node2 [srv -1 client]
+    set node3 [srv -2 client]
+    set node3_pid [srv -2 pid]
+
+    # the "overrides" mechanism can only support one "loadmodule" directive
+    $node1 module load $testmodule_nokey
+    $node2 module load $testmodule_nokey
+    $node3 module load $testmodule_nokey
+
+    $node1 module load $testmodule_blockedclient
+    $node2 module load $testmodule_blockedclient
+    $node3 module load $testmodule_blockedclient
+
+    test {Create 3 node cluster} {
+        exec src/redis-cli --cluster-yes --cluster create \
+                           127.0.0.1:[srv 0 port] \
+                           127.0.0.1:[srv -1 port] \
+                           127.0.0.1:[srv -2 port]
+
+        wait_for_condition 1000 50 {
+            [csi 0 cluster_state] eq {ok} &&
+            [csi -1 cluster_state] eq {ok} &&
+            [csi -2 cluster_state] eq {ok}
+        } else {
+            fail "Cluster doesn't stabilize"
+        }
+    }
+
+    test "Run blocking command (blocked on key) on cluster node3" {
+        # key9184688 is mapped to slot 10923 (first slot of node 3)
+        set node3_rd [redis_deferring_client -2]
+        $node3_rd fsl.bpop key9184688 0
+        $node3_rd flush
+
+        wait_for_condition 50 100 {
+            [s -2 blocked_clients] eq {1}
+        } else {
+            fail "Client executing blocking command (blocked on key) not blocked"
+        }
+    }
+
+    test "Run blocking command (no keys) on cluster node2" {
+        set node2_rd [redis_deferring_client -1]
+        $node2_rd block.block 0
+        $node2_rd flush
+
+        wait_for_condition 50 100 {
+            [s -1 blocked_clients] eq {1}
+        } else {
+            fail "Client executing blocking command (no keys) not blocked"
+        }
+    }
+
+
+    test "Perform a Resharding" {
+        exec src/redis-cli --cluster-yes --cluster reshard 127.0.0.1:[srv -2 port] \
+                           --cluster-to [$node1 cluster myid] \
+                           --cluster-from [$node3 cluster myid] \
+                           --cluster-slots 1
+    }
+
+    test "Verify command (no keys) is unaffected after resharding" {
+        # verify there are blocked clients on node2
+        assert_equal [s -1 blocked_clients]  {1}
+
+        #release client 
+        $node2 block.release 0
+    }
+
+    test "Verify command (blocked on key) got unblocked after resharding" {
+        # this (read) will wait for the node3 to realize the new topology
+        assert_error {*MOVED*} {$node3_rd read}
+
+        # verify there are no blocked clients
+        assert_equal [s 0 blocked_clients]  {0}
+        assert_equal [s -1 blocked_clients]  {0}
+        assert_equal [s -2 blocked_clients]  {0}
+    }
+
+    test "Wait for cluster to be stable" {
+        wait_for_condition 1000 50 {
+            [catch {exec src/redis-cli --cluster check 127.0.0.1:[srv 0 port]}] == 0 &&
+            [catch {exec src/redis-cli --cluster check 127.0.0.1:[srv -1 port]}] == 0 &&
+            [catch {exec src/redis-cli --cluster check 127.0.0.1:[srv -2 port]}] == 0 &&
+            [CI 0 cluster_state] eq {ok} &&
+            [CI 1 cluster_state] eq {ok} &&
+            [CI 2 cluster_state] eq {ok}
+        } else {
+            fail "Cluster doesn't stabilize"
+        }
+    }
+
+    test "Sanity test push cmd after resharding" {
+        assert_error {*MOVED*} {$node3 fsl.push key9184688 1}
+
+        set node1_rd [redis_deferring_client 0]
+        $node1_rd fsl.bpop key9184688 0
+        $node1_rd flush
+
+        wait_for_condition 50 100 {
+            [s 0 blocked_clients] eq {1}
+        } else {
+            puts "Client not blocked"
+            puts "read from blocked client: [$node1_rd read]"
+            fail "Client not blocked"
+        }
+
+        $node1 fsl.push key9184688 2
+        assert_equal {2} [$node1_rd read]
+    }
+
+    $node1_rd close
+    $node2_rd close
+    $node3_rd close
+
+    test "Run blocking command (blocked on key) again on cluster node1" {
+        $node1 del key9184688
+        # key9184688 is mapped to slot 10923 which has been moved to node1
+        set node1_rd [redis_deferring_client 0]
+        $node1_rd fsl.bpop key9184688 0
+        $node1_rd flush
+
+        wait_for_condition 50 100 {
+            [s 0 blocked_clients] eq {1}
+        } else {
+            fail "Client executing blocking command (blocked on key) again not blocked"
+        }
+    }
+
+    test "Run blocking command (no keys) again on cluster node2" {
+        set node2_rd [redis_deferring_client -1]
+
+        $node2_rd block.block 0
+        $node2_rd flush
+
+        wait_for_condition 50 100 {
+            [s -1 blocked_clients] eq {1}
+        } else {
+            fail "Client executing blocking command (no keys) again not blocked"
+        }
+    }
+
+    test "Kill a cluster node and wait for fail state" {
+        # kill node3 in cluster
+        exec kill -SIGSTOP $node3_pid
+
+        wait_for_condition 1000 50 {
+            [csi 0 cluster_state] eq {fail} &&
+            [csi -1 cluster_state] eq {fail}
+        } else {
+            fail "Cluster doesn't fail"
+        }
+    }
+
+    test "Verify command (blocked on key) got unblocked after cluster failure" {
+        assert_error {*CLUSTERDOWN*} {$node1_rd read}
+    }
+
+    test "Verify command (no keys) got unblocked after cluster failure" {
+        assert_error {*CLUSTERDOWN*} {$node2_rd read}
+
+        # verify there are no blocked clients
+        assert_equal [s 0 blocked_clients]  {0}
+        assert_equal [s -1 blocked_clients]  {0}
+    }
+
+    test "Verify command RM_Call is rejected when cluster is down" {
+        assert_error "ERR Can not execute a command 'set' while the cluster is down" {$node1 do_rm_call set x 1}
+    }
+
+    exec kill -SIGCONT $node3_pid
+    $node1_rd close
+    $node2_rd close
+
+# stop three servers
+}
+}
+}
+
+} ;# tags
+
+set ::singledb $old_singledb
diff --git a/tests/unit/moduleapi/cmdintrospection.tcl b/tests/unit/moduleapi/cmdintrospection.tcl
new file mode 100644
index 0000000..4d67af1
--- /dev/null
+++ b/tests/unit/moduleapi/cmdintrospection.tcl
@@ -0,0 +1,47 @@
+set testmodule [file normalize tests/modules/cmdintrospection.so]
+
+start_server {tags {"modules"}} {
+    r module load $testmodule
+
+    # cmdintrospection.xadd mimics XADD with regards to how
+    # what COMMAND exposes. There are two differences:
+    #
+    # 1. cmdintrospection.xadd (and all module commands) do not have ACL categories
+    # 2. cmdintrospection.xadd's `group` is "module"
+    #
+    # This tests verify that, apart from the above differences, the output of
+    # COMMAND INFO and COMMAND DOCS are identical for the two commands.
+    test "Module command introspection via COMMAND INFO" {
+        set redis_reply [lindex [r command info xadd] 0]
+        set module_reply [lindex [r command info cmdintrospection.xadd] 0]
+        for {set i 1} {$i < [llength $redis_reply]} {incr i} {
+            if {$i == 2} {
+                # Remove the "module" flag
+                set mylist [lindex $module_reply $i]
+                set idx [lsearch $mylist "module"]
+                set mylist [lreplace $mylist $idx $idx]
+                lset module_reply $i $mylist
+            }
+            if {$i == 6} {
+                # Skip ACL categories
+                continue
+            }
+            assert_equal [lindex $redis_reply $i] [lindex $module_reply $i]
+        }
+    }
+
+    test "Module command introspection via COMMAND DOCS" {
+        set redis_reply [dict create {*}[lindex [r command docs xadd] 1]]
+        set module_reply [dict create {*}[lindex [r command docs cmdintrospection.xadd] 1]]
+        # Compare the maps. We need to pop "group" first.
+        dict unset redis_reply group
+        dict unset module_reply group
+        dict unset module_reply module
+
+        assert_equal $redis_reply $module_reply
+    }
+
+    test "Unload the module - cmdintrospection" {
+        assert_equal {OK} [r module unload cmdintrospection]
+    }
+}
diff --git a/tests/unit/moduleapi/commandfilter.tcl b/tests/unit/moduleapi/commandfilter.tcl
new file mode 100644
index 0000000..427609d
--- /dev/null
+++ b/tests/unit/moduleapi/commandfilter.tcl
@@ -0,0 +1,118 @@
+set testmodule [file normalize tests/modules/commandfilter.so]
+
+start_server {tags {"modules"}} {
+    r module load $testmodule log-key 0
+
+    test {Retain a command filter argument} {
+        # Retain an argument now. Later we'll try to re-read it and make sure
+        # it is not corrupt and that valgrind does not complain.
+        r rpush some-list @retain my-retained-string
+        r commandfilter.retained
+    } {my-retained-string}
+
+    test {Command Filter handles redirected commands} {
+        r set mykey @log
+        r lrange log-key 0 -1
+    } "{set mykey @log}"
+
+    test {Command Filter can call RedisModule_CommandFilterArgDelete} {
+        r rpush mylist elem1 @delme elem2
+        r lrange mylist 0 -1
+    } {elem1 elem2}
+
+    test {Command Filter can call RedisModule_CommandFilterArgInsert} {
+        r del mylist
+        r rpush mylist elem1 @insertbefore elem2 @insertafter elem3
+        r lrange mylist 0 -1
+    } {elem1 --inserted-before-- @insertbefore elem2 @insertafter --inserted-after-- elem3}
+
+    test {Command Filter can call RedisModule_CommandFilterArgReplace} {
+        r del mylist
+        r rpush mylist elem1 @replaceme elem2
+        r lrange mylist 0 -1
+    } {elem1 --replaced-- elem2}
+
+    test {Command Filter applies on RM_Call() commands} {
+        r del log-key
+        r commandfilter.ping
+        r lrange log-key 0 -1
+    } "{ping @log}"
+
+    test {Command Filter applies on Lua redis.call()} {
+        r del log-key
+        r eval "redis.call('ping', '@log')" 0
+        r lrange log-key 0 -1
+    } "{ping @log}"
+
+    test {Command Filter applies on Lua redis.call() that calls a module} {
+        r del log-key
+        r eval "redis.call('commandfilter.ping')" 0
+        r lrange log-key 0 -1
+    } "{ping @log}"
+
+    test {Command Filter strings can be retained} {
+        r commandfilter.retained
+    } {my-retained-string}
+
+    test {Command Filter is unregistered implicitly on module unload} {
+        r del log-key
+        r module unload commandfilter
+        r set mykey @log
+        r lrange log-key 0 -1
+    } {}
+
+    r module load $testmodule log-key 0
+
+    test {Command Filter unregister works as expected} {
+        # Validate reloading succeeded
+        r del log-key
+        r set mykey @log
+        assert_equal "{set mykey @log}" [r lrange log-key 0 -1]
+
+        # Unregister
+        r commandfilter.unregister
+        r del log-key
+
+        r set mykey @log
+        r lrange log-key 0 -1
+    } {}
+
+    r module unload commandfilter
+    r module load $testmodule log-key 1
+
+    test {Command Filter REDISMODULE_CMDFILTER_NOSELF works as expected} {
+        r set mykey @log
+        assert_equal "{set mykey @log}" [r lrange log-key 0 -1]
+
+        r del log-key
+        r commandfilter.ping
+        assert_equal {} [r lrange log-key 0 -1]
+
+        r eval "redis.call('commandfilter.ping')" 0
+        assert_equal {} [r lrange log-key 0 -1]
+    }
+
+    test "Unload the module - commandfilter" {
+        assert_equal {OK} [r module unload commandfilter]
+    }
+} 
+
+test {RM_CommandFilterArgInsert and script argv caching} {
+    # coverage for scripts calling commands that expand the argv array
+    # an attempt to add coverage for a possible bug in luaArgsToRedisArgv
+    # this test needs a fresh server so that lua_argv_size is 0.
+    # glibc realloc can return the same pointer even when the size changes
+    # still this test isn't able to trigger the issue, but we keep it anyway.
+    start_server {tags {"modules"}} {
+        r module load $testmodule log-key 0
+        r del mylist
+        # command with 6 args
+        r eval {redis.call('rpush', KEYS[1], 'elem1', 'elem2', 'elem3', 'elem4')} 1 mylist
+        # command with 3 args that is changed to 4
+        r eval {redis.call('rpush', KEYS[1], '@insertafter')} 1 mylist
+        # command with 6 args again
+        r eval {redis.call('rpush', KEYS[1], 'elem1', 'elem2', 'elem3', 'elem4')} 1 mylist
+        assert_equal [r lrange mylist 0 -1] {elem1 elem2 elem3 elem4 @insertafter --inserted-after-- elem1 elem2 elem3 elem4}
+    }
+}
+
diff --git a/tests/unit/moduleapi/datatype.tcl b/tests/unit/moduleapi/datatype.tcl
new file mode 100644
index 0000000..c8fd30e
--- /dev/null
+++ b/tests/unit/moduleapi/datatype.tcl
@@ -0,0 +1,88 @@
+set testmodule [file normalize tests/modules/datatype.so]
+
+start_server {tags {"modules"}} {
+    r module load $testmodule
+
+    test {DataType: Test module is sane, GET/SET work.} {
+        r datatype.set dtkey 100 stringval
+        assert {[r datatype.get dtkey] eq {100 stringval}}
+    }
+
+    test {DataType: RM_SaveDataTypeToString(), RM_LoadDataTypeFromStringEncver() work} {
+        r datatype.set dtkey -1111 MyString
+        set encoded [r datatype.dump dtkey]
+
+        assert {[r datatype.restore dtkeycopy $encoded 4] eq {4}}
+        assert {[r datatype.get dtkeycopy] eq {-1111 MyString}}
+    }
+
+    test {DataType: Handle truncated RM_LoadDataTypeFromStringEncver()} {
+        r datatype.set dtkey -1111 MyString
+        set encoded [r datatype.dump dtkey]
+        set truncated [string range $encoded 0 end-1]
+
+        catch {r datatype.restore dtkeycopy $truncated 4} e
+        set e
+    } {*Invalid*}
+
+    test {DataType: ModuleTypeReplaceValue() happy path works} {
+        r datatype.set key-a 1 AAA
+        r datatype.set key-b 2 BBB
+
+        assert {[r datatype.swap key-a key-b] eq {OK}}
+        assert {[r datatype.get key-a] eq {2 BBB}}
+        assert {[r datatype.get key-b] eq {1 AAA}}
+    }
+
+    test {DataType: ModuleTypeReplaceValue() fails on non-module keys} {
+        r datatype.set key-a 1 AAA
+        r set key-b RedisString
+
+        catch {r datatype.swap key-a key-b} e
+        set e
+    } {*ERR*}
+
+    test {DataType: Copy command works for modules} {
+        # Test failed copies
+        r datatype.set answer-to-universe 42 AAA
+        catch {r copy answer-to-universe answer2} e
+        assert_match {*module key failed to copy*} $e
+
+        # Our module's data type copy function copies the int value as-is
+        # but appends /<from-key>/<to-key> to the string value so we can
+        # track passed arguments.
+        r datatype.set sourcekey 1234 AAA
+        r copy sourcekey targetkey
+        r datatype.get targetkey
+    } {1234 AAA/sourcekey/targetkey}
+
+    test {DataType: Slow Loading} {
+        r config set busy-reply-threshold 5000 ;# make sure we're using a high default
+        # trigger slow loading
+        r datatype.slow_loading 1
+        set rd [redis_deferring_client]
+        set start [clock clicks -milliseconds]
+        $rd debug reload
+
+        # wait till we know we're blocked inside the module
+        wait_for_condition 50 100 {
+            [r datatype.is_in_slow_loading] eq 1
+        } else {
+            fail "Failed waiting for slow loading to start"
+        }
+
+        # make sure we get LOADING error, and that we didn't get here late (not waiting for busy-reply-threshold)
+        assert_error {*LOADING*} {r ping}
+        assert_lessthan [expr [clock clicks -milliseconds]-$start] 2000
+
+        # abort the blocking operation
+        r datatype.slow_loading 0
+        wait_for_condition 50 100 {
+            [s loading] eq {0}
+        } else {
+            fail "Failed waiting for loading to end"
+        }
+        $rd read
+        $rd close
+    }
+}
diff --git a/tests/unit/moduleapi/datatype2.tcl b/tests/unit/moduleapi/datatype2.tcl
new file mode 100644
index 0000000..95acc9a
--- /dev/null
+++ b/tests/unit/moduleapi/datatype2.tcl
@@ -0,0 +1,232 @@
+set testmodule [file normalize tests/modules/datatype2.so]
+
+start_server {tags {"modules"}} {
+    r module load $testmodule
+
+    test "datatype2: test mem alloc and free" {
+        r flushall
+
+        r select 0
+        assert_equal 3 [r mem.alloc k1 3]
+        assert_equal 2 [r mem.alloc k2 2]
+
+        r select 1
+        assert_equal 1 [r mem.alloc k1 1]
+        assert_equal 5 [r mem.alloc k2 5]
+
+        r select 0 
+        assert_equal 1 [r mem.free k1]
+        assert_equal 1 [r mem.free k2]
+
+        r select 1
+        assert_equal 1 [r mem.free k1]
+        assert_equal 1 [r mem.free k2]
+    }
+
+    test "datatype2: test del and unlink" {
+        r flushall
+
+        assert_equal 100 [r mem.alloc k1 100]
+        assert_equal 60 [r mem.alloc k2 60]
+
+        assert_equal 1 [r unlink k1]
+        assert_equal 1 [r del k2]
+    }
+
+    test "datatype2: test read and write" {
+        r flushall
+
+        assert_equal 3 [r mem.alloc k1 3]
+        
+        set data datatype2
+        assert_equal [string length $data] [r mem.write k1 0 $data]
+        assert_equal $data [r mem.read k1 0]
+    }
+
+    test "datatype2: test rdb save and load" {
+        r flushall
+
+        r select 0
+        set data k1
+        assert_equal 3 [r mem.alloc k1 3]
+        assert_equal [string length $data] [r mem.write k1 1 $data]
+
+        set data k2
+        assert_equal 2 [r mem.alloc k2 2]
+        assert_equal [string length $data] [r mem.write k2 0 $data]
+
+        r select 1
+        set data k3
+        assert_equal 3 [r mem.alloc k3 3]
+        assert_equal [string length $data] [r mem.write k3 1 $data]
+
+        set data k4
+        assert_equal 2 [r mem.alloc k4 2]
+        assert_equal [string length $data] [r mem.write k4 0 $data]
+
+        r bgsave
+        waitForBgsave r
+        r debug reload
+ 
+        r select 0
+        assert_equal k1 [r mem.read k1 1]
+        assert_equal k2 [r mem.read k2 0]
+
+        r select 1
+        assert_equal k3 [r mem.read k3 1]
+        assert_equal k4 [r mem.read k4 0]
+    }
+
+    test "datatype2: test aof rewrite" {
+        r flushall
+
+        r select 0
+        set data k1
+        assert_equal 3 [r mem.alloc k1 3]
+        assert_equal [string length $data] [r mem.write k1 1 $data]
+
+        set data k2
+        assert_equal 2 [r mem.alloc k2 2]
+        assert_equal [string length $data] [r mem.write k2 0 $data]
+
+        r select 1
+        set data k3
+        assert_equal 3 [r mem.alloc k3 3]
+        assert_equal [string length $data] [r mem.write k3 1 $data]
+
+        set data k4
+        assert_equal 2 [r mem.alloc k4 2]
+        assert_equal [string length $data] [r mem.write k4 0 $data]
+
+        r bgrewriteaof
+        waitForBgrewriteaof r
+        r debug loadaof
+ 
+        r select 0
+        assert_equal k1 [r mem.read k1 1]
+        assert_equal k2 [r mem.read k2 0]
+
+        r select 1
+        assert_equal k3 [r mem.read k3 1]
+        assert_equal k4 [r mem.read k4 0]
+    }
+
+    test "datatype2: test copy" {
+        r flushall
+
+        r select 0
+        set data k1
+        assert_equal 3 [r mem.alloc k1 3]
+        assert_equal [string length $data] [r mem.write k1 1 $data]
+        assert_equal $data [r mem.read k1 1]
+
+        set data k2
+        assert_equal 2 [r mem.alloc k2 2]
+        assert_equal [string length $data] [r mem.write k2 0 $data]
+        assert_equal $data [r mem.read k2 0]
+
+        r select 1
+        set data k3
+        assert_equal 3 [r mem.alloc k3 3]
+        assert_equal [string length $data] [r mem.write k3 1 $data]
+
+        set data k4
+        assert_equal 2 [r mem.alloc k4 2]
+        assert_equal [string length $data] [r mem.write k4 0 $data]
+
+        assert_equal {total 5 used 2} [r mem.usage 0]
+        assert_equal {total 5 used 2} [r mem.usage 1]
+
+        r select 0
+        assert_equal 1 [r copy k1 k3]
+        assert_equal k1 [r mem.read k3 1]
+        assert_equal {total 8 used 3} [r mem.usage 0]
+        assert_equal 1 [r copy k2 k1 db 1]
+
+        r select 1
+        assert_equal k2 [r mem.read k1 0]
+        assert_equal {total 8 used 3} [r mem.usage 0]
+        assert_equal {total 7 used 3} [r mem.usage 1]
+    }
+
+    test "datatype2: test swapdb" {
+        r flushall
+
+        r select 0
+        set data k1
+        assert_equal 5 [r mem.alloc k1 5]
+        assert_equal [string length $data] [r mem.write k1 1 $data]
+        assert_equal $data [r mem.read k1 1]
+
+        set data k2
+        assert_equal 4 [r mem.alloc k2 4]
+        assert_equal [string length $data] [r mem.write k2 0 $data]
+        assert_equal $data [r mem.read k2 0]
+
+        r select 1
+        set data k1
+        assert_equal 3 [r mem.alloc k3 3]
+        assert_equal [string length $data] [r mem.write k3 1 $data]
+
+        set data k2
+        assert_equal 2 [r mem.alloc k4 2]
+        assert_equal [string length $data] [r mem.write k4 0 $data]
+
+        assert_equal {total 9 used 2} [r mem.usage 0]
+        assert_equal {total 5 used 2} [r mem.usage 1]
+
+        assert_equal OK [r swapdb 0 1]
+        assert_equal {total 9 used 2} [r mem.usage 1]
+        assert_equal {total 5 used 2} [r mem.usage 0]
+    }
+
+    test "datatype2: test digest" {
+        r flushall
+
+        r select 0
+        set data k1
+        assert_equal 3 [r mem.alloc k1 3]
+        assert_equal [string length $data] [r mem.write k1 1 $data]
+        assert_equal $data [r mem.read k1 1]
+
+        set data k2
+        assert_equal 2 [r mem.alloc k2 2]
+        assert_equal [string length $data] [r mem.write k2 0 $data]
+        assert_equal $data [r mem.read k2 0]
+
+        r select 1
+        set data k1
+        assert_equal 3 [r mem.alloc k1 3]
+        assert_equal [string length $data] [r mem.write k1 1 $data]
+        assert_equal $data [r mem.read k1 1]
+
+        set data k2
+        assert_equal 2 [r mem.alloc k2 2]
+        assert_equal [string length $data] [r mem.write k2 0 $data]
+        assert_equal $data [r mem.read k2 0]
+
+        r select 0
+        set digest0 [debug_digest]
+
+        r select 1
+        set digest1 [debug_digest]
+
+        assert_equal $digest0 $digest1
+    }
+
+    test "datatype2: test memusage" {
+        r flushall
+
+        set data k1
+        assert_equal 3 [r mem.alloc k1 3]
+        assert_equal [string length $data] [r mem.write k1 1 $data]
+        assert_equal $data [r mem.read k1 1]
+
+        set data k2
+        assert_equal 3 [r mem.alloc k2 3]
+        assert_equal [string length $data] [r mem.write k2 0 $data]
+        assert_equal $data [r mem.read k2 0]
+
+        assert_equal [memory_usage k1] [memory_usage k2] 
+    }
+}
\ No newline at end of file
diff --git a/tests/unit/moduleapi/defrag.tcl b/tests/unit/moduleapi/defrag.tcl
new file mode 100644
index 0000000..b2e2396
--- /dev/null
+++ b/tests/unit/moduleapi/defrag.tcl
@@ -0,0 +1,46 @@
+set testmodule [file normalize tests/modules/defragtest.so]
+
+start_server {tags {"modules"} overrides {{save ""}}} {
+    r module load $testmodule 10000
+    r config set hz 100
+    r config set active-defrag-ignore-bytes 1
+    r config set active-defrag-threshold-lower 0
+    r config set active-defrag-cycle-min 99
+
+    # try to enable active defrag, it will fail if redis was compiled without it
+    catch {r config set activedefrag yes} e
+    if {[r config get activedefrag] eq "activedefrag yes"} {
+
+        test {Module defrag: simple key defrag works} {
+            r frag.create key1 1 1000 0
+
+            after 2000
+            set info [r info defragtest_stats]
+            assert {[getInfoProperty $info defragtest_datatype_attempts] > 0}
+            assert_equal 0 [getInfoProperty $info defragtest_datatype_resumes]
+        }
+
+        test {Module defrag: late defrag with cursor works} {
+            r flushdb
+            r frag.resetstats
+
+            # key can only be defragged in no less than 10 iterations
+            # due to maxstep
+            r frag.create key2 10000 100 1000
+
+            after 2000
+            set info [r info defragtest_stats]
+            assert {[getInfoProperty $info defragtest_datatype_resumes] > 10}
+            assert_equal 0 [getInfoProperty $info defragtest_datatype_wrong_cursor]
+        }
+
+        test {Module defrag: global defrag works} {
+            r flushdb
+            r frag.resetstats
+
+            after 2000
+            set info [r info defragtest_stats]
+            assert {[getInfoProperty $info defragtest_global_attempts] > 0}
+        }
+    }
+}
diff --git a/tests/unit/moduleapi/eventloop.tcl b/tests/unit/moduleapi/eventloop.tcl
new file mode 100644
index 0000000..81e01ca
--- /dev/null
+++ b/tests/unit/moduleapi/eventloop.tcl
@@ -0,0 +1,28 @@
+set testmodule [file normalize tests/modules/eventloop.so]
+
+start_server {tags {"modules"}} {
+    r module load $testmodule
+
+    test "Module eventloop sendbytes" {
+        assert_match "OK" [r test.sendbytes 5000000]
+        assert_match "OK" [r test.sendbytes 2000000]
+    }
+
+    test "Module eventloop iteration" {
+        set iteration [r test.iteration]
+        set next_iteration [r test.iteration]
+        assert {$next_iteration > $iteration}
+    }
+
+    test "Module eventloop sanity" {
+        r test.sanity
+    }
+
+    test "Module eventloop oneshot" {
+        r test.oneshot
+    }
+
+    test "Unload the module - eventloop" {
+        assert_equal {OK} [r module unload eventloop]
+    }
+}
diff --git a/tests/unit/moduleapi/fork.tcl b/tests/unit/moduleapi/fork.tcl
new file mode 100644
index 0000000..c89a6c5
--- /dev/null
+++ b/tests/unit/moduleapi/fork.tcl
@@ -0,0 +1,49 @@
+set testmodule [file normalize tests/modules/fork.so]
+
+proc count_log_message {pattern} {
+    set status [catch {exec grep -c $pattern < [srv 0 stdout]} result]
+    if {$status == 1} {
+        set result 0
+    }
+    return $result
+}
+
+start_server {tags {"modules"}} {
+    r module load $testmodule
+
+    test {Module fork} {
+        # the argument to fork.create is the exitcode on termination
+        # the second argument to fork.create is passed to usleep
+        r fork.create 3 100000 ;# 100ms
+        wait_for_condition 20 100 {
+            [r fork.exitcode] != -1
+        } else {
+            fail "fork didn't terminate"
+        }
+        r fork.exitcode
+    } {3}
+
+    test {Module fork kill} {
+        # use a longer time to avoid the child exiting before being killed
+        r fork.create 3 100000000 ;# 100s
+        wait_for_condition 20 100 {
+            [count_log_message "fork child started"] == 2
+        } else {
+            fail "fork didn't start"
+        }
+
+        # module fork twice
+        assert_error {Fork failed} {r fork.create 0 1}
+        assert {[count_log_message "Can't fork for module: File exists"] eq "1"}
+
+        r fork.kill
+
+        assert {[count_log_message "Received SIGUSR1 in child"] eq "1"}
+        # check that it wasn't printed again (the print belong to the previous test)
+        assert {[count_log_message "fork child exiting"] eq "1"}
+    }
+
+    test "Unload the module - fork" {
+        assert_equal {OK} [r module unload fork]
+    }
+}
diff --git a/tests/unit/moduleapi/getchannels.tcl b/tests/unit/moduleapi/getchannels.tcl
new file mode 100644
index 0000000..e8f557d
--- /dev/null
+++ b/tests/unit/moduleapi/getchannels.tcl
@@ -0,0 +1,40 @@
+set testmodule [file normalize tests/modules/getchannels.so]
+
+start_server {tags {"modules"}} {
+    r module load $testmodule
+
+    # Channels are currently used to just validate ACLs, so test them here
+    r ACL setuser testuser +@all resetchannels &channel &pattern*
+
+    test "module getchannels-api with literals - ACL" {
+        assert_equal "OK" [r ACL DRYRUN testuser getchannels.command subscribe literal channel subscribe literal pattern1]
+        assert_equal "OK" [r ACL DRYRUN testuser getchannels.command publish literal channel publish literal pattern1]
+        assert_equal "OK" [r ACL DRYRUN testuser getchannels.command unsubscribe literal channel unsubscribe literal pattern1]
+
+        assert_equal "This user has no permissions to access the 'nopattern1' channel" [r ACL DRYRUN testuser getchannels.command subscribe literal channel subscribe literal nopattern1]
+        assert_equal "This user has no permissions to access the 'nopattern1' channel" [r ACL DRYRUN testuser getchannels.command publish literal channel subscribe literal nopattern1]
+        assert_equal "OK" [r ACL DRYRUN testuser getchannels.command unsubscribe literal channel unsubscribe literal nopattern1]
+
+        assert_equal "This user has no permissions to access the 'otherchannel' channel" [r ACL DRYRUN testuser getchannels.command subscribe literal otherchannel subscribe literal pattern1]
+        assert_equal "This user has no permissions to access the 'otherchannel' channel" [r ACL DRYRUN testuser getchannels.command publish literal otherchannel subscribe literal pattern1]
+        assert_equal "OK" [r ACL DRYRUN testuser getchannels.command unsubscribe literal otherchannel unsubscribe literal pattern1]
+    }
+
+    test "module getchannels-api with patterns - ACL" {
+        assert_equal "OK" [r ACL DRYRUN testuser getchannels.command subscribe pattern pattern*]
+        assert_equal "OK" [r ACL DRYRUN testuser getchannels.command publish pattern pattern*]
+        assert_equal "OK" [r ACL DRYRUN testuser getchannels.command unsubscribe pattern pattern*]
+
+        assert_equal "This user has no permissions to access the 'pattern1' channel" [r ACL DRYRUN testuser getchannels.command subscribe pattern pattern1 subscribe pattern pattern*]
+        assert_equal "This user has no permissions to access the 'pattern1' channel" [r ACL DRYRUN testuser getchannels.command publish pattern pattern1 subscribe pattern pattern*]
+        assert_equal "OK" [r ACL DRYRUN testuser getchannels.command unsubscribe pattern pattern1 unsubscribe pattern pattern*]
+
+        assert_equal "This user has no permissions to access the 'otherpattern*' channel" [r ACL DRYRUN testuser getchannels.command subscribe pattern otherpattern* subscribe pattern pattern*]
+        assert_equal "This user has no permissions to access the 'otherpattern*' channel" [r ACL DRYRUN testuser getchannels.command publish pattern otherpattern* subscribe pattern pattern*]
+        assert_equal "OK" [r ACL DRYRUN testuser getchannels.command unsubscribe pattern otherpattern* unsubscribe pattern pattern*]
+    }
+
+    test "Unload the module - getchannels" {
+        assert_equal {OK} [r module unload getchannels]
+    }
+}
diff --git a/tests/unit/moduleapi/getkeys.tcl b/tests/unit/moduleapi/getkeys.tcl
new file mode 100644
index 0000000..734c55f
--- /dev/null
+++ b/tests/unit/moduleapi/getkeys.tcl
@@ -0,0 +1,80 @@
+set testmodule [file normalize tests/modules/getkeys.so]
+
+start_server {tags {"modules"}} {
+    r module load $testmodule
+
+    test {COMMAND INFO correctly reports a movable keys module command} {
+        set info [lindex [r command info getkeys.command] 0]
+
+        assert_equal {module movablekeys} [lindex $info 2]
+        assert_equal {0} [lindex $info 3]
+        assert_equal {0} [lindex $info 4]
+        assert_equal {0} [lindex $info 5]
+    }
+
+    test {COMMAND GETKEYS correctly reports a movable keys module command} {
+        r command getkeys getkeys.command arg1 arg2 key key1 arg3 key key2 key key3
+    } {key1 key2 key3}
+
+    test {COMMAND GETKEYS correctly reports a movable keys module command using flags} {
+        r command getkeys getkeys.command_with_flags arg1 arg2 key key1 arg3 key key2 key key3
+    } {key1 key2 key3}
+
+    test {COMMAND GETKEYSANDFLAGS correctly reports a movable keys module command not using flags} {
+        r command getkeysandflags getkeys.command arg1 arg2 key key1 arg3 key key2
+    } {{key1 {RW access update}} {key2 {RW access update}}}
+
+    test {COMMAND GETKEYSANDFLAGS correctly reports a movable keys module command using flags} {
+        r command getkeysandflags getkeys.command_with_flags arg1 arg2 key key1 arg3 key key2 key key3
+    } {{key1 {RO access}} {key2 {RO access}} {key3 {RO access}}}
+
+    test {RM_GetCommandKeys on non-existing command} {
+        catch {r getkeys.introspect 0 non-command key1 key2} e
+        set _ $e
+    } {*ENOENT*}
+
+    test {RM_GetCommandKeys on built-in fixed keys command} {
+        r getkeys.introspect 0 set key1 value1
+    } {key1}
+
+    test {RM_GetCommandKeys on built-in fixed keys command with flags} {
+        r getkeys.introspect 1 set key1 value1
+    } {{key1 OW}}
+
+    test {RM_GetCommandKeys on EVAL} {
+        r getkeys.introspect 0 eval "" 4 key1 key2 key3 key4 arg1 arg2
+    } {key1 key2 key3 key4}
+
+    test {RM_GetCommandKeys on a movable keys module command} {
+        r getkeys.introspect 0 getkeys.command arg1 arg2 key key1 arg3 key key2 key key3
+    } {key1 key2 key3}
+
+    test {RM_GetCommandKeys on a non-movable module command} {
+        r getkeys.introspect 0 getkeys.fixed arg1 key1 key2 key3 arg2
+    } {key1 key2 key3}
+
+    test {RM_GetCommandKeys with bad arity} {
+        catch {r getkeys.introspect 0 set key} e
+        set _ $e
+    } {*EINVAL*}
+
+    # user that can only read from "read" keys, write to "write" keys, and read+write to "RW" keys
+    r ACL setuser testuser +@all %R~read* %W~write* %RW~rw*
+
+    test "module getkeys-api - ACL" {
+        # legacy triple didn't provide flags, so they require both read and write
+        assert_equal "OK" [r ACL DRYRUN testuser getkeys.command key rw]
+        assert_equal "This user has no permissions to access the 'read' key" [r ACL DRYRUN testuser getkeys.command key read]
+        assert_equal "This user has no permissions to access the 'write' key" [r ACL DRYRUN testuser getkeys.command key write]
+    }
+
+    test "module getkeys-api with flags - ACL" {
+        assert_equal "OK" [r ACL DRYRUN testuser getkeys.command_with_flags key rw]
+        assert_equal "OK" [r ACL DRYRUN testuser getkeys.command_with_flags key read]
+        assert_equal "This user has no permissions to access the 'write' key" [r ACL DRYRUN testuser getkeys.command_with_flags key write]
+    }
+
+    test "Unload the module - getkeys" {
+        assert_equal {OK} [r module unload getkeys]
+    }
+}
diff --git a/tests/unit/moduleapi/hash.tcl b/tests/unit/moduleapi/hash.tcl
new file mode 100644
index 0000000..116b1c5
--- /dev/null
+++ b/tests/unit/moduleapi/hash.tcl
@@ -0,0 +1,27 @@
+set testmodule [file normalize tests/modules/hash.so]
+
+start_server {tags {"modules"}} {
+    r module load $testmodule
+
+    test {Module hash set} {
+        r set k mystring
+        assert_error "WRONGTYPE*" {r hash.set k "" hello world}
+        r del k
+        # "" = count updates and deletes of existing fields only
+        assert_equal 0 [r hash.set k "" squirrel yes]
+        # "a" = COUNT_ALL = count inserted, modified and deleted fields
+        assert_equal 2 [r hash.set k "a" banana no sushi whynot]
+        # "n" = NX = only add fields not already existing in the hash
+        # "x" = XX = only replace the value for existing fields
+        assert_equal 0 [r hash.set k "n" squirrel hoho what nothing]
+        assert_equal 1 [r hash.set k "na" squirrel hoho something nice]
+        assert_equal 0 [r hash.set k "xa" new stuff not inserted]
+        assert_equal 1 [r hash.set k "x" squirrel ofcourse]
+        assert_equal 1 [r hash.set k "" sushi :delete: none :delete:]
+        r hgetall k
+    } {squirrel ofcourse banana no what nothing something nice}
+
+    test "Unload the module - hash" {
+        assert_equal {OK} [r module unload hash]
+    }
+}
diff --git a/tests/unit/moduleapi/hooks.tcl b/tests/unit/moduleapi/hooks.tcl
new file mode 100644
index 0000000..6e79f94
--- /dev/null
+++ b/tests/unit/moduleapi/hooks.tcl
@@ -0,0 +1,179 @@
+set testmodule [file normalize tests/modules/hooks.so]
+
+tags "modules" {
+    start_server [list overrides [list loadmodule "$testmodule" appendonly yes]] {
+        test {Test module aof save on server start from empty} {
+            assert {[r hooks.event_count persistence-syncaof-start] == 1}
+        }
+
+        test {Test clients connection / disconnection hooks} {
+            for {set j 0} {$j < 2} {incr j} {
+                set rd1 [redis_deferring_client]
+                $rd1 close
+            }
+            assert {[r hooks.event_count client-connected] > 1}
+            assert {[r hooks.event_count client-disconnected] > 1}
+        }
+
+        test {Test module client change event for blocked client} {
+            set rd [redis_deferring_client]
+            # select db other than 0
+            $rd select 1
+            # block on key
+            $rd brpop foo 0
+            # kill blocked client
+            r client kill skipme yes
+            # assert server is still up
+            assert_equal [r ping] PONG
+            $rd close
+        } 
+
+        test {Test module cron hook} {
+            after 100
+            assert {[r hooks.event_count cron-loop] > 0}
+            set hz [r hooks.event_last cron-loop]
+            assert_equal $hz 10
+        }
+
+        test {Test module loaded / unloaded hooks} {
+            set othermodule [file normalize tests/modules/infotest.so]
+            r module load $othermodule
+            r module unload infotest
+            assert_equal [r hooks.event_last module-loaded] "infotest"
+            assert_equal [r hooks.event_last module-unloaded] "infotest"
+        }
+
+        test {Test module aofrw hook} {
+            r debug populate 1000 foo 10000 ;# 10mb worth of data
+            r config set rdbcompression no ;# rdb progress is only checked once in 2mb
+            r BGREWRITEAOF
+            waitForBgrewriteaof r
+            assert_equal [string match {*module-event-persistence-aof-start*} [exec tail -20 < [srv 0 stdout]]] 1
+            assert_equal [string match {*module-event-persistence-end*} [exec tail -20 < [srv 0 stdout]]] 1
+        }
+
+        test {Test module aof load and rdb/aof progress hooks} {
+            # create some aof tail (progress is checked only once in 1000 commands)
+            for {set j 0} {$j < 4000} {incr j} {
+                r set "bar$j" x
+            }
+            # set some configs that will cause many loading progress events during aof loading
+            r config set key-load-delay 500
+            r config set dynamic-hz no
+            r config set hz 500
+            r DEBUG LOADAOF
+            assert_equal [r hooks.event_last loading-aof-start] 0
+            assert_equal [r hooks.event_last loading-end] 0
+            assert {[r hooks.event_count loading-rdb-start] == 0}
+            assert_lessthan 2 [r hooks.event_count loading-progress-rdb] ;# comes from the preamble section
+            assert_lessthan 2 [r hooks.event_count loading-progress-aof]
+            if {$::verbose} {
+                puts "rdb progress events [r hooks.event_count loading-progress-rdb]"
+                puts "aof progress events [r hooks.event_count loading-progress-aof]"
+            }
+        }
+        # undo configs before next test
+        r config set dynamic-hz yes
+        r config set key-load-delay 0
+
+        test {Test module rdb save hook} {
+            # debug reload does: save, flush, load:
+            assert {[r hooks.event_count persistence-syncrdb-start] == 0}
+            assert {[r hooks.event_count loading-rdb-start] == 0}
+            r debug reload
+            assert {[r hooks.event_count persistence-syncrdb-start] == 1}
+            assert {[r hooks.event_count loading-rdb-start] == 1}
+        }
+
+        test {Test flushdb hooks} {
+            r flushdb
+            assert_equal [r hooks.event_last flush-start] 9
+            assert_equal [r hooks.event_last flush-end] 9
+            r flushall
+            assert_equal [r hooks.event_last flush-start] -1
+            assert_equal [r hooks.event_last flush-end] -1
+        }
+
+        # replication related tests
+        set master [srv 0 client]
+        set master_host [srv 0 host]
+        set master_port [srv 0 port]
+        start_server {} {
+            r module load $testmodule
+            set replica [srv 0 client]
+            set replica_host [srv 0 host]
+            set replica_port [srv 0 port]
+            $replica replicaof $master_host $master_port
+
+            wait_replica_online $master
+
+            test {Test master link up hook} {
+                assert_equal [r hooks.event_count masterlink-up] 1
+                assert_equal [r hooks.event_count masterlink-down] 0
+            }
+
+            test {Test role-replica hook} {
+                assert_equal [r hooks.event_count role-replica] 1
+                assert_equal [r hooks.event_count role-master] 0
+                assert_equal [r hooks.event_last role-replica] [s 0 master_host]
+            }
+
+            test {Test replica-online hook} {
+                assert_equal [r -1 hooks.event_count replica-online] 1
+                assert_equal [r -1 hooks.event_count replica-offline] 0
+            }
+
+            test {Test master link down hook} {
+                r client kill type master
+                assert_equal [r hooks.event_count masterlink-down] 1
+
+                wait_for_condition 50 100 {
+                    [string match {*master_link_status:up*} [r info replication]]
+                } else {
+                    fail "Replica didn't reconnect"
+                }
+
+                assert_equal [r hooks.event_count masterlink-down] 1
+                assert_equal [r hooks.event_count masterlink-up] 2
+            }
+
+            wait_for_condition 50 10 {
+                [string match {*master_link_status:up*} [r info replication]]
+            } else {
+                fail "Can't turn the instance into a replica"
+            }
+
+            $replica replicaof no one
+
+            test {Test role-master hook} {
+                assert_equal [r hooks.event_count role-replica] 1
+                assert_equal [r hooks.event_count role-master] 1
+                assert_equal [r hooks.event_last role-master] {}
+            }
+
+            test {Test replica-offline hook} {
+                assert_equal [r -1 hooks.event_count replica-online] 2
+                assert_equal [r -1 hooks.event_count replica-offline] 2
+            }
+            # get the replica stdout, to be used by the next test
+            set replica_stdout [srv 0 stdout]
+        }
+
+        test {Test swapdb hooks} {
+            r swapdb 0 10
+            assert_equal [r hooks.event_last swapdb-first] 0
+            assert_equal [r hooks.event_last swapdb-second] 10
+        }
+
+        test {Test configchange hooks} {
+            r config set rdbcompression no 
+            assert_equal [r hooks.event_last config-change-count] 1
+            assert_equal [r hooks.event_last config-change-first] rdbcompression
+        }
+
+        # look into the log file of the server that just exited
+        test {Test shutdown hook} {
+            assert_equal [string match {*module-event-shutdown*} [exec tail -5 < $replica_stdout]] 1
+        }
+    }
+}
diff --git a/tests/unit/moduleapi/infotest.tcl b/tests/unit/moduleapi/infotest.tcl
new file mode 100644
index 0000000..ccd8c4e
--- /dev/null
+++ b/tests/unit/moduleapi/infotest.tcl
@@ -0,0 +1,131 @@
+set testmodule [file normalize tests/modules/infotest.so]
+
+# Return value for INFO property
+proc field {info property} {
+    if {[regexp "\r\n$property:(.*?)\r\n" $info _ value]} {
+        set _ $value
+    }
+}
+
+start_server {tags {"modules"}} {
+    r module load $testmodule log-key 0
+
+    test {module reading info} {
+        # check string, integer and float fields
+        assert_equal [r info.gets replication role] "master"
+        assert_equal [r info.getc replication role] "master"
+        assert_equal [r info.geti stats expired_keys] 0
+        assert_equal [r info.getd stats expired_stale_perc] 0
+
+        # check signed and unsigned
+        assert_equal [r info.geti infotest infotest_global] -2
+        assert_equal [r info.getu infotest infotest_uglobal] -2
+
+        # the above are always 0, try module info that is non-zero
+        assert_equal [r info.geti infotest_italian infotest_due] 2
+        set tre [r info.getd infotest_italian infotest_tre]
+        assert {$tre > 3.2 && $tre < 3.4 }
+
+        # search using the wrong section
+        catch { [r info.gets badname redis_version] } e
+        assert_match {*not found*} $e
+
+        # check that section filter works
+        assert { [string match "*usec_per_call*" [r info.gets all cmdstat_info.gets] ] }
+        catch { [r info.gets default cmdstat_info.gets] ] } e
+        assert_match {*not found*} $e
+    }
+
+    test {module info all} {
+        set info [r info all]
+        # info all does not contain modules
+        assert { ![string match "*Spanish*" $info] }
+        assert { ![string match "*infotest_*" $info] }
+        assert { [string match "*used_memory*" $info] }
+    }
+
+    test {module info all infotest} {
+        set info [r info all infotest]
+        # info all infotest should contain both ALL and the module information
+        assert { [string match "*Spanish*" $info] }
+        assert { [string match "*infotest_*" $info] }
+        assert { [string match "*used_memory*" $info] }
+    }
+
+    test {module info everything} {
+        set info [r info everything]
+        # info everything contains all default sections, but not ones for crash report
+        assert { [string match "*infotest_global*" $info] }
+        assert { [string match "*Spanish*" $info] }
+        assert { [string match "*Italian*" $info] }
+        assert { [string match "*used_memory*" $info] }
+        assert { ![string match "*Klingon*" $info] }
+        field $info infotest_dos
+    } {2}
+
+    test {module info modules} {
+        set info [r info modules]
+        # info all does not contain modules
+        assert { [string match "*Spanish*" $info] }
+        assert { [string match "*infotest_global*" $info] }
+        assert { ![string match "*used_memory*" $info] }
+    }
+
+    test {module info one module} {
+        set info [r info INFOtest] ;# test case insensitive compare
+        # info all does not contain modules
+        assert { [string match "*Spanish*" $info] }
+        assert { ![string match "*used_memory*" $info] }
+        field $info infotest_global
+    } {-2}
+
+    test {module info one section} {
+        set info [r info INFOtest_SpanisH] ;# test case insensitive compare
+        assert { ![string match "*used_memory*" $info] }
+        assert { ![string match "*Italian*" $info] }
+        assert { ![string match "*infotest_global*" $info] }
+        field $info infotest_uno
+    } {one}
+
+    test {module info dict} {
+        set info [r info infotest_keyspace]
+        set keyspace [field $info infotest_db0]
+        set keys [scan [regexp -inline {keys\=([\d]*)} $keyspace] keys=%d]
+    } {3}
+
+    test {module info unsafe fields} {
+        set info [r info infotest_unsafe]
+        assert_match {*infotest_unsafe_field:value=1*} $info
+    }
+
+    test {module info multiply sections without all, everything, default keywords} {
+        set info [r info replication INFOTEST]
+        assert { [string match "*Spanish*" $info] }
+        assert { ![string match "*used_memory*" $info] }
+        assert { [string match "*repl_offset*" $info] }
+    }
+
+    test {module info multiply sections with all keyword and modules} {
+        set info [r info all modules]
+        assert { [string match "*cluster*" $info] }
+        assert { [string match "*cmdstat_info*" $info] }
+        assert { [string match "*infotest_global*" $info] }
+    }
+
+    test {module info multiply sections with everything keyword} {
+        set info [r info replication everything cpu]
+        assert { [string match "*client_recent*" $info] }
+        assert { [string match "*cmdstat_info*" $info] }
+        assert { [string match "*Italian*" $info] }
+        # check that we didn't get the same info twice
+        assert { ![string match "*used_cpu_user_children*used_cpu_user_children*" $info] }
+        assert { ![string match "*Italian*Italian*" $info] }
+        field $info infotest_dos
+    } {2}
+
+    test "Unload the module - infotest" {
+        assert_equal {OK} [r module unload infotest]
+    }
+
+    # TODO: test crash report.
+} 
diff --git a/tests/unit/moduleapi/infra.tcl b/tests/unit/moduleapi/infra.tcl
new file mode 100644
index 0000000..7bfa7d4
--- /dev/null
+++ b/tests/unit/moduleapi/infra.tcl
@@ -0,0 +1,22 @@
+set testmodule [file normalize tests/modules/infotest.so]
+
+test {modules config rewrite} {
+
+    start_server {tags {"modules"}} {
+        r module load $testmodule
+
+        assert_equal [lindex [lindex [r module list] 0] 1] infotest
+
+        r config rewrite
+        restart_server 0 true false
+
+        assert_equal [lindex [lindex [r module list] 0] 1] infotest
+
+        assert_equal {OK} [r module unload infotest]
+
+        r config rewrite
+        restart_server 0 true false
+
+        assert_equal [llength [r module list]] 0
+    }
+}
diff --git a/tests/unit/moduleapi/keyspace_events.tcl b/tests/unit/moduleapi/keyspace_events.tcl
new file mode 100644
index 0000000..ceec6fd
--- /dev/null
+++ b/tests/unit/moduleapi/keyspace_events.tcl
@@ -0,0 +1,101 @@
+set testmodule [file normalize tests/modules/keyspace_events.so]
+
+tags "modules" {
+    start_server [list overrides [list loadmodule "$testmodule"]] {
+
+        test {Test loaded key space event} {
+            r set x 1
+            r hset y f v
+            r lpush z 1 2 3
+            r sadd p 1 2 3
+            r zadd t 1 f1 2 f2
+            r xadd s * f v
+            r debug reload
+            assert_equal {1 x} [r keyspace.is_key_loaded x]
+            assert_equal {1 y} [r keyspace.is_key_loaded y]
+            assert_equal {1 z} [r keyspace.is_key_loaded z]
+            assert_equal {1 p} [r keyspace.is_key_loaded p]
+            assert_equal {1 t} [r keyspace.is_key_loaded t]
+            assert_equal {1 s} [r keyspace.is_key_loaded s]
+        }
+
+        test {Nested multi due to RM_Call} {
+            r del multi
+            r del lua
+
+            r set x 1
+            r set x_copy 1
+            r keyspace.del_key_copy x
+            r keyspace.incr_case1 x
+            r keyspace.incr_case2 x
+            r keyspace.incr_case3 x
+            assert_equal {} [r get multi]
+            assert_equal {} [r get lua]
+            r get x
+        } {3}
+        
+        test {Nested multi due to RM_Call, with client MULTI} {
+            r del multi
+            r del lua
+
+            r set x 1
+            r set x_copy 1
+            r multi
+            r keyspace.del_key_copy x
+            r keyspace.incr_case1 x
+            r keyspace.incr_case2 x
+            r keyspace.incr_case3 x
+            r exec
+            assert_equal {1} [r get multi]
+            assert_equal {} [r get lua]
+            r get x
+        } {3}
+        
+        test {Nested multi due to RM_Call, with EVAL} {
+            r del multi
+            r del lua
+
+            r set x 1
+            r set x_copy 1
+            r eval {
+                redis.pcall('keyspace.del_key_copy', KEYS[1])
+                redis.pcall('keyspace.incr_case1', KEYS[1])
+                redis.pcall('keyspace.incr_case2', KEYS[1])
+                redis.pcall('keyspace.incr_case3', KEYS[1])
+            } 1 x
+            assert_equal {} [r get multi]
+            assert_equal {1} [r get lua]
+            r get x
+        } {3}
+
+        test {Test module key space event} {
+            r keyspace.notify x
+            assert_equal {1 x} [r keyspace.is_module_key_notified x]
+        }
+
+        test "Keyspace notifications: module events test" {
+            r config set notify-keyspace-events Kd
+            r del x
+            set rd1 [redis_deferring_client]
+            assert_equal {1} [psubscribe $rd1 *]
+            r keyspace.notify x
+            assert_equal {pmessage * __keyspace@9__:x notify} [$rd1 read]
+            $rd1 close
+        }
+
+        test {Test expired key space event} {
+            set prev_expired [s expired_keys]
+            r set exp 1 PX 10
+            wait_for_condition 100 10 {
+                [s expired_keys] eq $prev_expired + 1
+            } else {
+                fail "key not expired"
+            }
+            assert_equal [r get testkeyspace:expired] 1
+        }
+
+        test "Unload the module - testkeyspace" {
+            assert_equal {OK} [r module unload testkeyspace]
+        }
+    }
+}
diff --git a/tests/unit/moduleapi/keyspecs.tcl b/tests/unit/moduleapi/keyspecs.tcl
new file mode 100644
index 0000000..8491bc1
--- /dev/null
+++ b/tests/unit/moduleapi/keyspecs.tcl
@@ -0,0 +1,160 @@
+set testmodule [file normalize tests/modules/keyspecs.so]
+
+start_server {tags {"modules"}} {
+    r module load $testmodule
+
+    test "Module key specs: No spec, only legacy triple" {
+        set reply [lindex [r command info kspec.none] 0]
+        # Verify (first, last, step) and not movablekeys
+        assert_equal [lindex $reply 2] {module}
+        assert_equal [lindex $reply 3] 1
+        assert_equal [lindex $reply 4] -1
+        assert_equal [lindex $reply 5] 2
+        # Verify key-spec auto-generated from the legacy triple
+        set keyspecs [lindex $reply 8]
+        assert_equal [llength $keyspecs] 1
+        assert_equal [lindex $keyspecs 0] {flags {RW access update} begin_search {type index spec {index 1}} find_keys {type range spec {lastkey -1 keystep 2 limit 0}}}
+        assert_equal [r command getkeys kspec.none key1 val1 key2 val2] {key1 key2}
+    }
+
+    test "Module key specs: No spec, only legacy triple with getkeys-api" {
+        set reply [lindex [r command info kspec.nonewithgetkeys] 0]
+        # Verify (first, last, step) and movablekeys
+        assert_equal [lindex $reply 2] {module movablekeys}
+        assert_equal [lindex $reply 3] 1
+        assert_equal [lindex $reply 4] -1
+        assert_equal [lindex $reply 5] 2
+        # Verify key-spec auto-generated from the legacy triple
+        set keyspecs [lindex $reply 8]
+        assert_equal [llength $keyspecs] 1
+        assert_equal [lindex $keyspecs 0] {flags {RW access update variable_flags} begin_search {type index spec {index 1}} find_keys {type range spec {lastkey -1 keystep 2 limit 0}}}
+        assert_equal [r command getkeys kspec.nonewithgetkeys key1 val1 key2 val2] {key1 key2}
+    }
+
+    test "Module key specs: Two ranges" {
+        set reply [lindex [r command info kspec.tworanges] 0]
+        # Verify (first, last, step) and not movablekeys
+        assert_equal [lindex $reply 2] {module}
+        assert_equal [lindex $reply 3] 1
+        assert_equal [lindex $reply 4] 2
+        assert_equal [lindex $reply 5] 1
+        # Verify key-specs
+        set keyspecs [lindex $reply 8]
+        assert_equal [lindex $keyspecs 0] {flags {RO access} begin_search {type index spec {index 1}} find_keys {type range spec {lastkey 0 keystep 1 limit 0}}}
+        assert_equal [lindex $keyspecs 1] {flags {RW update} begin_search {type index spec {index 2}} find_keys {type range spec {lastkey 0 keystep 1 limit 0}}}
+        assert_equal [r command getkeys kspec.tworanges foo bar baz quux] {foo bar}
+    }
+
+    test "Module key specs: Two ranges with gap" {
+        set reply [lindex [r command info kspec.tworangeswithgap] 0]
+        # Verify (first, last, step) and movablekeys
+        assert_equal [lindex $reply 2] {module movablekeys}
+        assert_equal [lindex $reply 3] 1
+        assert_equal [lindex $reply 4] 1
+        assert_equal [lindex $reply 5] 1
+        # Verify key-specs
+        set keyspecs [lindex $reply 8]
+        assert_equal [lindex $keyspecs 0] {flags {RO access} begin_search {type index spec {index 1}} find_keys {type range spec {lastkey 0 keystep 1 limit 0}}}
+        assert_equal [lindex $keyspecs 1] {flags {RW update} begin_search {type index spec {index 3}} find_keys {type range spec {lastkey 0 keystep 1 limit 0}}}
+        assert_equal [r command getkeys kspec.tworangeswithgap foo bar baz quux] {foo baz}
+    }
+
+    test "Module key specs: Keyword-only spec clears the legacy triple" {
+        set reply [lindex [r command info kspec.keyword] 0]
+        # Verify (first, last, step) and movablekeys
+        assert_equal [lindex $reply 2] {module movablekeys}
+        assert_equal [lindex $reply 3] 0
+        assert_equal [lindex $reply 4] 0
+        assert_equal [lindex $reply 5] 0
+        # Verify key-specs
+        set keyspecs [lindex $reply 8]
+        assert_equal [lindex $keyspecs 0] {flags {RO access} begin_search {type keyword spec {keyword KEYS startfrom 1}} find_keys {type range spec {lastkey -1 keystep 1 limit 0}}}
+        assert_equal [r command getkeys kspec.keyword foo KEYS bar baz] {bar baz}
+    }
+
+    test "Module key specs: Complex specs, case 1" {
+        set reply [lindex [r command info kspec.complex1] 0]
+        # Verify (first, last, step) and movablekeys
+        assert_equal [lindex $reply 2] {module movablekeys}
+        assert_equal [lindex $reply 3] 1
+        assert_equal [lindex $reply 4] 1
+        assert_equal [lindex $reply 5] 1
+        # Verify key-specs
+        set keyspecs [lindex $reply 8]
+        assert_equal [lindex $keyspecs 0] {flags RO begin_search {type index spec {index 1}} find_keys {type range spec {lastkey 0 keystep 1 limit 0}}}
+        assert_equal [lindex $keyspecs 1] {flags {RW update} begin_search {type keyword spec {keyword STORE startfrom 2}} find_keys {type range spec {lastkey 0 keystep 1 limit 0}}}
+        assert_equal [lindex $keyspecs 2] {flags {RO access} begin_search {type keyword spec {keyword KEYS startfrom 2}} find_keys {type keynum spec {keynumidx 0 firstkey 1 keystep 1}}}
+        assert_equal [r command getkeys kspec.complex1 foo dummy KEYS 1 bar baz STORE quux] {foo quux bar}
+    }
+
+    test "Module key specs: Complex specs, case 2" {
+        set reply [lindex [r command info kspec.complex2] 0]
+        # Verify (first, last, step) and movablekeys
+        assert_equal [lindex $reply 2] {module movablekeys}
+        assert_equal [lindex $reply 3] 1
+        assert_equal [lindex $reply 4] 2
+        assert_equal [lindex $reply 5] 1
+        # Verify key-specs
+        set keyspecs [lindex $reply 8]
+        assert_equal [lindex $keyspecs 0] {flags {RW update} begin_search {type keyword spec {keyword STORE startfrom 5}} find_keys {type range spec {lastkey 0 keystep 1 limit 0}}}
+        assert_equal [lindex $keyspecs 1] {flags {RO access} begin_search {type index spec {index 1}} find_keys {type range spec {lastkey 0 keystep 1 limit 0}}}
+        assert_equal [lindex $keyspecs 2] {flags {RO access} begin_search {type index spec {index 2}} find_keys {type range spec {lastkey 0 keystep 1 limit 0}}}
+        assert_equal [lindex $keyspecs 3] {flags {RW update} begin_search {type index spec {index 3}} find_keys {type keynum spec {keynumidx 0 firstkey 1 keystep 1}}}
+        assert_equal [lindex $keyspecs 4] {flags {RW update} begin_search {type keyword spec {keyword MOREKEYS startfrom 5}} find_keys {type range spec {lastkey -1 keystep 1 limit 0}}}
+        assert_equal [r command getkeys kspec.complex2 foo bar 2 baz quux banana STORE dst dummy MOREKEYS hey ho] {dst foo bar baz quux hey ho}
+    }
+
+    test "Module command list filtering" {
+        ;# Note: we piggyback this tcl file to test the general functionality of command list filtering
+        set reply [r command list filterby module keyspecs]
+        assert_equal [lsort $reply] {kspec.complex1 kspec.complex2 kspec.keyword kspec.none kspec.nonewithgetkeys kspec.tworanges kspec.tworangeswithgap}
+        assert_equal [r command getkeys kspec.complex2 foo bar 2 baz quux banana STORE dst dummy MOREKEYS hey ho] {dst foo bar baz quux hey ho}
+    }
+
+    test {COMMAND GETKEYSANDFLAGS correctly reports module key-spec without flags} {
+        r command getkeysandflags kspec.none key1 val1 key2 val2
+    } {{key1 {RW access update}} {key2 {RW access update}}}
+
+    test {COMMAND GETKEYSANDFLAGS correctly reports module key-spec with flags} {
+        r command getkeysandflags kspec.nonewithgetkeys key1 val1 key2 val2
+    } {{key1 {RO access}} {key2 {RO access}}}
+
+    test {COMMAND GETKEYSANDFLAGS correctly reports module key-spec flags} {
+        r command getkeysandflags kspec.keyword keys key1 key2 key3
+    } {{key1 {RO access}} {key2 {RO access}} {key3 {RO access}}}
+
+    # user that can only read from "read" keys, write to "write" keys, and read+write to "RW" keys
+    r ACL setuser testuser +@all %R~read* %W~write* %RW~rw*
+
+    test "Module key specs: No spec, only legacy triple - ACL" {
+        # legacy triple didn't provide flags, so they require both read and write
+        assert_equal "OK" [r ACL DRYRUN testuser kspec.none rw val1]
+        assert_equal "This user has no permissions to access the 'read' key" [r ACL DRYRUN testuser kspec.none read val1]
+        assert_equal "This user has no permissions to access the 'write' key" [r ACL DRYRUN testuser kspec.none write val1]
+    }
+
+    test "Module key specs: tworanges - ACL" {
+        assert_equal "OK" [r ACL DRYRUN testuser kspec.tworanges read write]
+        assert_equal "OK" [r ACL DRYRUN testuser kspec.tworanges rw rw]
+        assert_equal "This user has no permissions to access the 'read' key" [r ACL DRYRUN testuser kspec.tworanges rw read]
+        assert_equal "This user has no permissions to access the 'write' key" [r ACL DRYRUN testuser kspec.tworanges write rw]
+    }
+
+    foreach cmd {kspec.none kspec.tworanges} {
+        test "$cmd command will not be marked with movablekeys" {
+            set info [lindex [r command info $cmd] 0]
+            assert_no_match {*movablekeys*} [lindex $info 2]
+        }
+    }
+
+    foreach cmd {kspec.keyword kspec.complex1 kspec.complex2 kspec.nonewithgetkeys} {
+        test "$cmd command is marked with movablekeys" {
+            set info [lindex [r command info $cmd] 0]
+            assert_match {*movablekeys*} [lindex $info 2]
+        }
+    }
+
+    test "Unload the module - keyspecs" {
+        assert_equal {OK} [r module unload keyspecs]
+    }
+}
diff --git a/tests/unit/moduleapi/list.tcl b/tests/unit/moduleapi/list.tcl
new file mode 100644
index 0000000..0c44055
--- /dev/null
+++ b/tests/unit/moduleapi/list.tcl
@@ -0,0 +1,124 @@
+set testmodule [file normalize tests/modules/list.so]
+
+# The following arguments can be passed to args:
+#   i -- the number of inserts
+#   d -- the number of deletes
+#   r -- the number of replaces
+#   index -- the last index
+#   entry -- The entry pointed to by index
+proc verify_list_edit_reply {reply argv} {
+    foreach {k v} $argv {
+        assert_equal [dict get $reply $k] $v
+    }
+}
+
+start_server {tags {"modules"}} {
+    r module load $testmodule
+
+    test {Module list set, get, insert, delete} {
+        r del k
+        r rpush k x
+        # insert, set, get
+        r list.insert k 0 foo
+        r list.insert k -1 bar
+        r list.set k 1 xyz
+        assert_equal {foo xyz bar} [r list.getall k]
+        assert_equal {foo} [r list.get k 0]
+        assert_equal {xyz} [r list.get k 1]
+        assert_equal {bar} [r list.get k 2]
+        assert_equal {bar} [r list.get k -1]
+        assert_equal {foo} [r list.get k -3]
+        assert_error {ERR index out*} {r list.get k -4}
+        assert_error {ERR index out*} {r list.get k 3}
+        # remove
+        assert_error {ERR index out*} {r list.delete k -4}
+        assert_error {ERR index out*} {r list.delete k 3}
+        r list.delete k 0
+        r list.delete k -1
+        assert_equal {xyz} [r list.getall k]
+        # removing the last element deletes the list
+        r list.delete k 0
+        assert_equal 0 [r exists k]
+    }
+
+    test {Module list iteration} {
+        r del k
+        r rpush k x y z
+        assert_equal {x y z} [r list.getall k]
+        assert_equal {z y x} [r list.getall k REVERSE]
+    }
+
+    test {Module list insert & delete} {
+        r del k
+        r rpush k x y z
+        verify_list_edit_reply [r list.edit k ikikdi foo bar baz] {i 3 index 5}
+        r list.getall k
+    } {foo x bar y baz}
+
+    test {Module list insert & delete, neg index} {
+        r del k
+        r rpush k x y z
+        verify_list_edit_reply [r list.edit k REVERSE ikikdi foo bar baz] {i 3 index -6}
+        r list.getall k
+    } {baz y bar z foo}
+
+    test {Module list set while iterating} {
+        r del k
+        r rpush k x y z
+        verify_list_edit_reply [r list.edit k rkr foo bar] {r 2 index 3}
+        r list.getall k
+    } {foo y bar}
+
+    test {Module list set while iterating, neg index} {
+        r del k
+        r rpush k x y z
+        verify_list_edit_reply [r list.edit k reverse rkr foo bar] {r 2 index -4}
+        r list.getall k
+    } {bar y foo}
+
+    test {Module list - list entry and index should be updated when deletion} {
+        set original_config [config_get_set list-max-listpack-size 1]
+
+        # delete from start (index 0)
+        r del l
+        r rpush l x y z
+        verify_list_edit_reply [r list.edit l dd] {d 2 index 0 entry z}
+        assert_equal [r list.getall l] {z}
+
+        # delete from start (index -3)
+        r del l
+        r rpush l x y z
+        verify_list_edit_reply [r list.edit l reverse kkd] {d 1 index -3}
+        assert_equal [r list.getall l] {y z}
+
+        # # delete from tail (index 2)
+        r del l
+        r rpush l x y z
+        verify_list_edit_reply [r list.edit l kkd] {d 1 index 2}
+        assert_equal [r list.getall l] {x y}
+
+        # # delete from tail (index -1)
+        r del l
+        r rpush l x y z
+        verify_list_edit_reply [r list.edit l reverse dd] {d 2 index -1 entry x}
+        assert_equal [r list.getall l] {x}
+
+        # # delete from middle (index 1)
+        r del l
+        r rpush l x y z
+        verify_list_edit_reply [r list.edit l kdd] {d 2 index 1}
+        assert_equal [r list.getall l] {x}
+
+        # # delete from middle (index -2)
+        r del l
+        r rpush l x y z
+        verify_list_edit_reply [r list.edit l reverse kdd] {d 2 index -2}
+        assert_equal [r list.getall l] {z}
+
+        config_set list-max-listpack-size $original_config
+    }
+
+    test "Unload the module - list" {
+        assert_equal {OK} [r module unload list]
+    }
+}
diff --git a/tests/unit/moduleapi/mallocsize.tcl b/tests/unit/moduleapi/mallocsize.tcl
new file mode 100644
index 0000000..359a7ae
--- /dev/null
+++ b/tests/unit/moduleapi/mallocsize.tcl
@@ -0,0 +1,21 @@
+set testmodule [file normalize tests/modules/mallocsize.so]
+
+
+start_server {tags {"modules"}} {
+    r module load $testmodule
+
+    test {MallocSize of raw bytes} {
+        assert_equal [r mallocsize.setraw key 40] {OK}
+        assert_morethan [r memory usage key] 40
+    }
+    
+    test {MallocSize of string} {
+        assert_equal [r mallocsize.setstr key abcdefg] {OK}
+        assert_morethan [r memory usage key] 7 ;# Length of "abcdefg"
+    }
+    
+    test {MallocSize of dict} {
+        assert_equal [r mallocsize.setdict key f1 v1 f2 v2] {OK}
+        assert_morethan [r memory usage key] 8 ;# Length of "f1v1f2v2"
+    }
+}
diff --git a/tests/unit/moduleapi/misc.tcl b/tests/unit/moduleapi/misc.tcl
new file mode 100644
index 0000000..55f4036
--- /dev/null
+++ b/tests/unit/moduleapi/misc.tcl
@@ -0,0 +1,421 @@
+set testmodule [file normalize tests/modules/misc.so]
+
+start_server {tags {"modules"}} {
+    r module load $testmodule
+
+    test {test RM_Call} {
+        set info [r test.call_info commandstats]
+        # cmdstat is not in a default section, so we also test an argument was passed
+        assert { [string match "*cmdstat_module*" $info] }
+    }
+
+    test {test RM_Call args array} {
+        set info [r test.call_generic info commandstats]
+        # cmdstat is not in a default section, so we also test an argument was passed
+        assert { [string match "*cmdstat_module*" $info] }
+    }
+
+    test {test RM_Call recursive} {
+        set info [r test.call_generic test.call_generic info commandstats]
+        assert { [string match "*cmdstat_module*" $info] }
+    }
+
+    test {test redis version} {
+        set version [s redis_version]
+        assert_equal $version [r test.redisversion]
+    }
+
+    test {test long double conversions} {
+        set ld [r test.ld_conversion]
+        assert {[string match $ld "0.00000000000000001"]}
+    }
+    
+    test {test unsigned long long conversions} {
+        set ret [r test.ull_conversion]
+        assert {[string match $ret "ok"]}
+    }
+
+    test {test module db commands} {
+        r set x foo
+        set key [r test.randomkey]
+        assert_equal $key "x"
+        assert_equal [r test.dbsize] 1
+        r test.flushall
+        assert_equal [r test.dbsize] 0
+    }
+
+    test {test RedisModule_ResetDataset do not reset functions} {
+        r function load {#!lua name=lib
+            redis.register_function('test', function() return 1 end)
+        }
+        assert_equal [r function list] {{library_name lib engine LUA functions {{name test description {} flags {}}}}}
+        r test.flushall
+        assert_equal [r function list] {{library_name lib engine LUA functions {{name test description {} flags {}}}}}
+        r function flush
+    }
+
+    test {test module keyexists} {
+        r set x foo
+        assert_equal 1 [r test.keyexists x]
+        r del x
+        assert_equal 0 [r test.keyexists x]
+    }
+
+    test {test module lru api} {
+        r config set maxmemory-policy allkeys-lru
+        r set x foo
+        set lru [r test.getlru x]
+        assert { $lru <= 1000 }
+        set was_set [r test.setlru x 100000]
+        assert { $was_set == 1 }
+        set idle [r object idletime x]
+        assert { $idle >= 100 }
+        set lru [r test.getlru x]
+        assert { $lru >= 100000 }
+        r config set maxmemory-policy allkeys-lfu
+        set lru [r test.getlru x]
+        assert { $lru == -1 }
+        set was_set [r test.setlru x 100000]
+        assert { $was_set == 0 }
+    }
+    r config set maxmemory-policy allkeys-lru
+
+    test {test module lfu api} {
+        r config set maxmemory-policy allkeys-lfu
+        r set x foo
+        set lfu [r test.getlfu x]
+        assert { $lfu >= 1 }
+        set was_set [r test.setlfu x 100]
+        assert { $was_set == 1 }
+        set freq [r object freq x]
+        assert { $freq <= 100 }
+        set lfu [r test.getlfu x]
+        assert { $lfu <= 100 }
+        r config set maxmemory-policy allkeys-lru
+        set lfu [r test.getlfu x]
+        assert { $lfu == -1 }
+        set was_set [r test.setlfu x 100]
+        assert { $was_set == 0 }
+    }
+
+    test {test module clientinfo api} {
+        # Test basic sanity and SSL flag
+        set info [r test.clientinfo]
+        set ssl_flag [expr $::tls ? {"ssl:"} : {":"}]
+
+        assert { [dict get $info db] == 9 }
+        assert { [dict get $info flags] == "${ssl_flag}::::" }
+
+        # Test MULTI flag
+        r multi
+        r test.clientinfo
+        set info [lindex [r exec] 0]
+        assert { [dict get $info flags] == "${ssl_flag}::::multi" }
+
+        # Test TRACKING flag
+        r client tracking on
+        set info [r test.clientinfo]
+        assert { [dict get $info flags] == "${ssl_flag}::tracking::" }
+    }
+
+    test {test module get/set client name by id api} {
+        catch { r test.getname } e
+        assert_equal "-ERR No name" $e
+        r client setname nobody
+        catch { r test.setname "name with spaces" } e
+        assert_match "*Invalid argument*" $e
+        assert_equal nobody [r client getname]
+        assert_equal nobody [r test.getname]
+        r test.setname somebody
+        assert_equal somebody [r client getname]
+    }
+
+    test {test module getclientcert api} {
+        set cert [r test.getclientcert]
+
+        if {$::tls} {
+            assert {$cert != ""}
+        } else {
+            assert {$cert == ""}
+        }
+    }
+
+    test {test detached thread safe cnotext} {
+        r test.log_tsctx "info" "Test message"
+        verify_log_message 0 "*<misc> Test message*" 0
+    }
+
+    test {test RM_Call CLIENT INFO} {
+        assert_match "*fd=-1*" [r test.call_generic client info]
+    }
+
+    test {Unsafe command names are sanitized in INFO output} {
+        r test.weird:cmd
+        set info [r info commandstats]
+        assert_match {*cmdstat_test.weird_cmd:calls=1*} $info
+    }
+
+    test {test monotonic time} {
+        set x [r test.monotonic_time]
+        assert { [r test.monotonic_time] >= $x }
+    }
+
+    test {rm_call OOM} {
+        r config set maxmemory 1
+        r config set maxmemory-policy volatile-lru
+
+        # sanity test plain call
+        assert_equal {OK} [
+            r test.rm_call set x 1
+        ]
+
+        # add the M flag
+        assert_error {OOM *} {
+            r test.rm_call_flags M set x 1
+
+        }
+
+        # test a non deny-oom command
+        assert_equal {1} [
+            r test.rm_call_flags M get x
+        ]
+
+        r config set maxmemory 0
+    } {OK} {needs:config-maxmemory}
+
+    test {rm_call clear OOM} {
+        r config set maxmemory 1
+
+        # verify rm_call fails with OOM
+        assert_error {OOM *} {
+            r test.rm_call_flags M set x 1
+        }
+
+        # clear OOM state
+        r config set maxmemory 0
+
+        # test set command is allowed
+        r test.rm_call_flags M set x 1
+    } {OK} {needs:config-maxmemory}
+
+    test {rm_call OOM Eval} {
+        r config set maxmemory 1
+        r config set maxmemory-policy volatile-lru
+
+        # use the M flag without allow-oom shebang flag
+        assert_error {OOM *} {
+            r test.rm_call_flags M eval {#!lua
+                redis.call('set','x',1)
+                return 1
+            } 1 x
+        }
+
+        # add the M flag with allow-oom shebang flag
+        assert_equal {1} [
+            r test.rm_call_flags M eval {#!lua flags=allow-oom
+                redis.call('set','x',1)
+                return 1
+            } 1 x
+        ]
+
+        r config set maxmemory 0
+    } {OK} {needs:config-maxmemory}
+
+    test {rm_call write flag} {
+        # add the W flag
+        assert_error {ERR Write command 'set' was called while write is not allowed.} {
+            r test.rm_call_flags W set x 1
+        }
+
+        # test a non deny-oom command
+        r test.rm_call_flags W get x
+    } {1}
+
+    test {rm_call EVAL} {
+        r test.rm_call eval {
+            redis.call('set','x',1)
+            return 1
+        } 1 x
+
+        assert_error {ERR Write commands are not allowed from read-only scripts.*} {
+            r test.rm_call eval {#!lua flags=no-writes
+                redis.call('set','x',1)
+                return 1
+            } 1 x
+        }
+    }
+
+    test {rm_call EVAL - OOM} {
+        r config set maxmemory 1
+
+        assert_error {OOM command not allowed when used memory > 'maxmemory'. script*} {
+            r test.rm_call eval {
+                redis.call('set','x',1)
+                return 1
+            } 1 x
+        }
+
+        r test.rm_call eval {#!lua flags=no-writes
+            redis.call('get','x')
+            return 2
+        } 1 x
+
+        assert_error {OOM allow-oom flag is not set on the script,*} {
+            r test.rm_call eval {#!lua
+                redis.call('get','x')
+                return 3
+            } 1 x
+        }
+
+        r test.rm_call eval {
+            redis.call('get','x')
+            return 4
+        } 1 x
+
+        r config set maxmemory 0
+    } {OK} {needs:config-maxmemory}
+
+    test "not enough good replicas" {
+        r set x "some value"
+        r config set min-replicas-to-write 1
+
+        # rm_call in script mode
+        assert_error {NOREPLICAS *} {r test.rm_call_flags S set x s}
+
+        assert_equal [
+            r test.rm_call eval {#!lua flags=no-writes
+                return redis.call('get','x')
+            } 1 x
+        ] "some value"
+
+        assert_equal [
+            r test.rm_call eval {
+                return redis.call('get','x')
+            } 1 x
+        ] "some value"
+
+        assert_error {NOREPLICAS *} {
+            r test.rm_call eval {#!lua
+                return redis.call('get','x')
+            } 1 x
+        }
+
+        assert_error {NOREPLICAS *} {
+            r test.rm_call eval {
+                return redis.call('set','x', 1)
+            } 1 x
+        }
+
+        r config set min-replicas-to-write 0
+    }
+
+    test {rm_call EVAL - read-only replica} {
+        r replicaof 127.0.0.1 1
+
+        # rm_call in script mode
+        assert_error {READONLY *} {r test.rm_call_flags S set x 1}
+
+        assert_error {READONLY You can't write against a read only replica. script*} {
+            r test.rm_call eval {
+                redis.call('set','x',1)
+                return 1
+            } 1 x
+        }
+
+        r test.rm_call eval {#!lua flags=no-writes
+            redis.call('get','x')
+            return 2
+        } 1 x
+
+        assert_error {READONLY Can not run script with write flag on readonly replica*} {
+            r test.rm_call eval {#!lua
+                redis.call('get','x')
+                return 3
+            } 1 x
+        }
+
+        r test.rm_call eval {
+            redis.call('get','x')
+            return 4
+        } 1 x
+
+        r replicaof no one
+    } {OK} {needs:config-maxmemory}
+
+    test {rm_call EVAL - stale replica} {
+        r replicaof 127.0.0.1 1
+        r config set replica-serve-stale-data no
+
+        # rm_call in script mode
+        assert_error {MASTERDOWN *} {
+            r test.rm_call_flags S get x
+        }
+
+        assert_error {MASTERDOWN *} {
+            r test.rm_call eval {#!lua flags=no-writes
+                redis.call('get','x')
+                return 2
+            } 1 x
+        }
+
+        assert_error {MASTERDOWN *} {
+            r test.rm_call eval {
+                redis.call('get','x')
+                return 4
+            } 1 x
+        }
+
+        r replicaof no one
+        r config set replica-serve-stale-data yes
+    } {OK} {needs:config-maxmemory}
+
+    test "rm_call EVAL - failed bgsave prevents writes" {
+        r config set rdb-key-save-delay 10000000
+        populate 1000
+        r set x x
+        r bgsave
+        set pid1 [get_child_pid 0]
+        catch {exec kill -9 $pid1}
+        waitForBgsave r
+
+        # make sure a read command succeeds
+        assert_equal [r get x] x
+
+        # make sure a write command fails
+        assert_error {MISCONF *} {r set x y}
+
+        # rm_call in script mode
+        assert_error {MISCONF *} {r test.rm_call_flags S set x 1}
+
+        # repeate with script
+        assert_error {MISCONF *} {r test.rm_call eval {
+            return redis.call('set','x',1)
+            } 1 x
+        }
+        assert_equal {x} [r test.rm_call eval {
+            return redis.call('get','x')
+            } 1 x
+        ]
+
+        # again with script using shebang
+        assert_error {MISCONF *} {r test.rm_call eval {#!lua
+            return redis.call('set','x',1)
+            } 1 x
+        }
+        assert_equal {x} [r test.rm_call eval {#!lua flags=no-writes
+            return redis.call('get','x')
+            } 1 x
+        ]
+
+        r config set rdb-key-save-delay 0
+        r bgsave
+        waitForBgsave r
+
+        # server is writable again
+        r set x y
+    } {OK}
+
+    test "Unload the module - misc" {
+        assert_equal {OK} [r module unload misc]
+    }
+}
diff --git a/tests/unit/moduleapi/moduleconfigs.tcl b/tests/unit/moduleapi/moduleconfigs.tcl
new file mode 100644
index 0000000..8ebce35
--- /dev/null
+++ b/tests/unit/moduleapi/moduleconfigs.tcl
@@ -0,0 +1,259 @@
+set testmodule [file normalize tests/modules/moduleconfigs.so]
+set testmoduletwo [file normalize tests/modules/moduleconfigstwo.so]
+
+start_server {tags {"modules"}} {
+    r module load $testmodule
+    test {Config get commands work} {
+        # Make sure config get module config works
+        assert_equal [lindex [lindex [r module list] 0] 1] moduleconfigs
+        assert_equal [r config get moduleconfigs.mutable_bool] "moduleconfigs.mutable_bool yes"
+        assert_equal [r config get moduleconfigs.immutable_bool] "moduleconfigs.immutable_bool no"
+        assert_equal [r config get moduleconfigs.memory_numeric] "moduleconfigs.memory_numeric 1024"
+        assert_equal [r config get moduleconfigs.string] "moduleconfigs.string {secret password}"
+        assert_equal [r config get moduleconfigs.enum] "moduleconfigs.enum one"
+        assert_equal [r config get moduleconfigs.flags] "moduleconfigs.flags {one two}"
+        assert_equal [r config get moduleconfigs.numeric] "moduleconfigs.numeric -1"
+    }
+
+    test {Config set commands work} {
+        # Make sure that config sets work during runtime
+        r config set moduleconfigs.mutable_bool no
+        assert_equal [r config get moduleconfigs.mutable_bool] "moduleconfigs.mutable_bool no"
+        r config set moduleconfigs.memory_numeric 1mb
+        assert_equal [r config get moduleconfigs.memory_numeric] "moduleconfigs.memory_numeric 1048576"
+        r config set moduleconfigs.string wafflewednesdays
+        assert_equal [r config get moduleconfigs.string] "moduleconfigs.string wafflewednesdays"
+        set not_embstr [string repeat A 50]
+        r config set moduleconfigs.string $not_embstr
+        assert_equal [r config get moduleconfigs.string] "moduleconfigs.string $not_embstr"
+        r config set moduleconfigs.string \x73\x75\x70\x65\x72\x20\x00\x73\x65\x63\x72\x65\x74\x20\x70\x61\x73\x73\x77\x6f\x72\x64
+        assert_equal [r config get moduleconfigs.string] "moduleconfigs.string {super \0secret password}"
+        r config set moduleconfigs.enum two
+        assert_equal [r config get moduleconfigs.enum] "moduleconfigs.enum two"
+        r config set moduleconfigs.flags two
+        assert_equal [r config get moduleconfigs.flags] "moduleconfigs.flags two"
+        r config set moduleconfigs.numeric -2
+        assert_equal [r config get moduleconfigs.numeric] "moduleconfigs.numeric -2"
+    }
+
+    test {Config set commands enum flags} {
+        r config set moduleconfigs.flags "none"
+        assert_equal [r config get moduleconfigs.flags] "moduleconfigs.flags none"
+
+        r config set moduleconfigs.flags "two four"
+        assert_equal [r config get moduleconfigs.flags] "moduleconfigs.flags {two four}"
+
+        r config set moduleconfigs.flags "five"
+        assert_equal [r config get moduleconfigs.flags] "moduleconfigs.flags five"
+
+        r config set moduleconfigs.flags "one four"
+        assert_equal [r config get moduleconfigs.flags] "moduleconfigs.flags five"
+
+        r config set moduleconfigs.flags "one two four"
+        assert_equal [r config get moduleconfigs.flags] "moduleconfigs.flags {five two}"
+    }
+
+    test {Immutable flag works properly and rejected strings dont leak} {
+        # Configs flagged immutable should not allow sets
+        catch {[r config set moduleconfigs.immutable_bool yes]} e
+        assert_match {*can't set immutable config*} $e
+        catch {[r config set moduleconfigs.string rejectisfreed]} e
+        assert_match {*Cannot set string to 'rejectisfreed'*} $e
+    }
+    
+    test {Numeric limits work properly} {
+        # Configs over/under the limit shouldn't be allowed, and memory configs should only take memory values
+        catch {[r config set moduleconfigs.memory_numeric 200gb]} e
+        assert_match {*argument must be between*} $e
+        catch {[r config set moduleconfigs.memory_numeric -5]} e
+        assert_match {*argument must be a memory value*} $e
+        catch {[r config set moduleconfigs.numeric -10]} e
+        assert_match {*argument must be between*} $e
+    }
+
+    test {Enums only able to be set to passed in values} {
+        # Module authors specify what values are valid for enums, check that only those values are ok on a set
+        catch {[r config set moduleconfigs.enum asdf]} e
+        assert_match {*must be one of the following*} $e
+    }
+
+    test {Unload removes module configs} {
+        r module unload moduleconfigs
+        assert_equal [r config get moduleconfigs.*] ""
+        r module load $testmodule
+        # these should have reverted back to their module specified values
+        assert_equal [r config get moduleconfigs.mutable_bool] "moduleconfigs.mutable_bool yes"
+        assert_equal [r config get moduleconfigs.immutable_bool] "moduleconfigs.immutable_bool no"
+        assert_equal [r config get moduleconfigs.memory_numeric] "moduleconfigs.memory_numeric 1024"
+        assert_equal [r config get moduleconfigs.string] "moduleconfigs.string {secret password}"
+        assert_equal [r config get moduleconfigs.enum] "moduleconfigs.enum one"
+        assert_equal [r config get moduleconfigs.flags] "moduleconfigs.flags {one two}"
+        assert_equal [r config get moduleconfigs.numeric] "moduleconfigs.numeric -1"
+        r module unload moduleconfigs
+    }
+
+    test {test loadex functionality} {
+        r module loadex $testmodule CONFIG moduleconfigs.mutable_bool no CONFIG moduleconfigs.immutable_bool yes CONFIG moduleconfigs.memory_numeric 2mb CONFIG moduleconfigs.string tclortickle
+        assert_equal [lindex [lindex [r module list] 0] 1] moduleconfigs
+        assert_equal [r config get moduleconfigs.mutable_bool] "moduleconfigs.mutable_bool no"
+        assert_equal [r config get moduleconfigs.immutable_bool] "moduleconfigs.immutable_bool yes"
+        assert_equal [r config get moduleconfigs.memory_numeric] "moduleconfigs.memory_numeric 2097152"
+        assert_equal [r config get moduleconfigs.string] "moduleconfigs.string tclortickle"
+        # Configs that were not changed should still be their module specified value
+        assert_equal [r config get moduleconfigs.enum] "moduleconfigs.enum one"
+        assert_equal [r config get moduleconfigs.flags] "moduleconfigs.flags {one two}"
+        assert_equal [r config get moduleconfigs.numeric] "moduleconfigs.numeric -1"
+    }
+
+    test {apply function works} {
+        catch {[r config set moduleconfigs.mutable_bool yes]} e
+        assert_match {*Bool configs*} $e
+        assert_equal [r config get moduleconfigs.mutable_bool] "moduleconfigs.mutable_bool no"
+        catch {[r config set moduleconfigs.memory_numeric 1000 moduleconfigs.numeric 1000]} e
+        assert_match {*cannot equal*} $e
+        assert_equal [r config get moduleconfigs.memory_numeric] "moduleconfigs.memory_numeric 2097152"
+        assert_equal [r config get moduleconfigs.numeric] "moduleconfigs.numeric -1"
+        r module unload moduleconfigs
+    }
+
+    test {test double config argument to loadex} {
+        r module loadex $testmodule CONFIG moduleconfigs.mutable_bool yes CONFIG moduleconfigs.mutable_bool no
+        assert_equal [r config get moduleconfigs.mutable_bool] "moduleconfigs.mutable_bool no"
+        r module unload moduleconfigs
+    }
+
+    test {missing loadconfigs call} {
+        catch {[r module loadex $testmodule CONFIG moduleconfigs.string "cool" ARGS noload]} e
+        assert_match {*ERR*} $e
+    }
+
+    test {test loadex rejects bad configs} {
+        # Bad config 200gb is over the limit
+        catch {[r module loadex $testmodule CONFIG moduleconfigs.memory_numeric 200gb ARGS]} e
+        assert_match {*ERR*} $e
+        # We should completely remove all configs on a failed load
+        assert_equal [r config get moduleconfigs.*] ""
+        # No value for config, should error out
+        catch {[r module loadex $testmodule CONFIG moduleconfigs.mutable_bool CONFIG moduleconfigs.enum two ARGS]} e
+        assert_match {*ERR*} $e
+        assert_equal [r config get moduleconfigs.*] ""
+        # Asan will catch this if this string is not freed
+        catch {[r module loadex $testmodule CONFIG moduleconfigs.string rejectisfreed]}
+        assert_match {*ERR*} $e
+        assert_equal [r config get moduleconfigs.*] ""
+        # test we can't set random configs
+        catch {[r module loadex $testmodule CONFIG maxclients 333]}
+        assert_match {*ERR*} $e
+        assert_equal [r config get moduleconfigs.*] ""
+        assert_not_equal [r config get maxclients] "maxclients 333"
+        # test we can't set other module's configs
+        r module load $testmoduletwo
+        catch {[r module loadex $testmodule CONFIG configs.test no]}
+        assert_match {*ERR*} $e
+        assert_equal [r config get configs.test] "configs.test yes"
+        r module unload configs
+    }
+
+    test {test config rewrite with dynamic load} {
+        #translates to: super \0secret password
+        r module loadex $testmodule CONFIG moduleconfigs.string \x73\x75\x70\x65\x72\x20\x00\x73\x65\x63\x72\x65\x74\x20\x70\x61\x73\x73\x77\x6f\x72\x64 ARGS
+        assert_equal [lindex [lindex [r module list] 0] 1] moduleconfigs
+        assert_equal [r config get moduleconfigs.string] "moduleconfigs.string {super \0secret password}"
+        r config set moduleconfigs.mutable_bool yes
+        r config set moduleconfigs.memory_numeric 750
+        r config set moduleconfigs.enum two
+        r config set moduleconfigs.flags "four two"
+        r config rewrite
+        restart_server 0 true false
+        # Ensure configs we rewrote are present and that the conf file is readable
+        assert_equal [r config get moduleconfigs.mutable_bool] "moduleconfigs.mutable_bool yes"
+        assert_equal [r config get moduleconfigs.memory_numeric] "moduleconfigs.memory_numeric 750"
+        assert_equal [r config get moduleconfigs.string] "moduleconfigs.string {super \0secret password}"
+        assert_equal [r config get moduleconfigs.enum] "moduleconfigs.enum two"
+        assert_equal [r config get moduleconfigs.flags] "moduleconfigs.flags {two four}"
+        assert_equal [r config get moduleconfigs.numeric] "moduleconfigs.numeric -1"
+        r module unload moduleconfigs
+    }
+
+    test {test multiple modules with configs} {
+        r module load $testmodule
+        r module loadex $testmoduletwo CONFIG configs.test yes
+        assert_equal [r config get moduleconfigs.mutable_bool] "moduleconfigs.mutable_bool yes"
+        assert_equal [r config get moduleconfigs.immutable_bool] "moduleconfigs.immutable_bool no"
+        assert_equal [r config get moduleconfigs.memory_numeric] "moduleconfigs.memory_numeric 1024"
+        assert_equal [r config get moduleconfigs.string] "moduleconfigs.string {secret password}"
+        assert_equal [r config get moduleconfigs.enum] "moduleconfigs.enum one"
+        assert_equal [r config get moduleconfigs.numeric] "moduleconfigs.numeric -1"
+        assert_equal [r config get configs.test] "configs.test yes"
+        r config set moduleconfigs.mutable_bool no
+        r config set moduleconfigs.string nice
+        r config set moduleconfigs.enum two
+        r config set configs.test no
+        assert_equal [r config get moduleconfigs.mutable_bool] "moduleconfigs.mutable_bool no"
+        assert_equal [r config get moduleconfigs.string] "moduleconfigs.string nice"
+        assert_equal [r config get moduleconfigs.enum] "moduleconfigs.enum two"
+        assert_equal [r config get configs.test] "configs.test no"
+        r config rewrite
+        # test we can load from conf file with multiple different modules.
+        restart_server 0 true false
+        assert_equal [r config get moduleconfigs.mutable_bool] "moduleconfigs.mutable_bool no"
+        assert_equal [r config get moduleconfigs.string] "moduleconfigs.string nice"
+        assert_equal [r config get moduleconfigs.enum] "moduleconfigs.enum two"
+        assert_equal [r config get configs.test] "configs.test no"
+        r module unload moduleconfigs
+        r module unload configs
+    }
+
+    test {test 1.module load 2.config rewrite 3.module unload 4.config rewrite works} {
+        # Configs need to be removed from the old config file in this case.
+        r module loadex $testmodule CONFIG moduleconfigs.memory_numeric 500 ARGS
+        assert_equal [lindex [lindex [r module list] 0] 1] moduleconfigs
+        r config rewrite
+        r module unload moduleconfigs
+        r config rewrite
+        restart_server 0 true false
+        # Ensure configs we rewrote are no longer present
+        assert_equal [r config get moduleconfigs.*] ""
+    }
+    test {startup moduleconfigs} {
+        # No loadmodule directive
+        set nomodload [start_server [list overrides [list moduleconfigs.string "hello"]]]
+        wait_for_condition 100 50 {
+            ! [is_alive $nomodload]
+        } else {
+            fail "startup should've failed with no load and module configs supplied"
+        }
+        set stdout [dict get $nomodload stdout]
+        assert_equal [count_message_lines $stdout "Module Configuration detected without loadmodule directive or no ApplyConfig call: aborting"] 1
+
+        # Bad config value
+        set badconfig [start_server [list overrides [list loadmodule "$testmodule" moduleconfigs.string "rejectisfreed"]]]
+        wait_for_condition 100 50 {
+            ! [is_alive $badconfig]
+        } else {
+            fail "startup with bad moduleconfigs should've failed"
+        }
+        set stdout [dict get $badconfig stdout]
+        assert_equal [count_message_lines $stdout "Issue during loading of configuration moduleconfigs.string : Cannot set string to 'rejectisfreed'"] 1
+
+        set noload [start_server [list overrides [list loadmodule "$testmodule noload" moduleconfigs.string "hello"]]]
+        wait_for_condition 100 50 {
+            ! [is_alive $noload]
+        } else {
+            fail "startup with moduleconfigs and no loadconfigs call should've failed"
+        }
+        set stdout [dict get $noload stdout]
+        assert_equal [count_message_lines $stdout "Module Configurations were not set, likely a missing LoadConfigs call. Unloading the module."] 1
+
+        start_server [list overrides [list loadmodule "$testmodule" moduleconfigs.string "bootedup" moduleconfigs.enum two moduleconfigs.flags "two four"]] {
+            assert_equal [r config get moduleconfigs.string] "moduleconfigs.string bootedup"
+            assert_equal [r config get moduleconfigs.mutable_bool] "moduleconfigs.mutable_bool yes"
+            assert_equal [r config get moduleconfigs.immutable_bool] "moduleconfigs.immutable_bool no"
+            assert_equal [r config get moduleconfigs.enum] "moduleconfigs.enum two"
+            assert_equal [r config get moduleconfigs.flags] "moduleconfigs.flags {two four}"
+            assert_equal [r config get moduleconfigs.numeric] "moduleconfigs.numeric -1"
+            assert_equal [r config get moduleconfigs.memory_numeric] "moduleconfigs.memory_numeric 1024"
+        }
+    }
+}
+
diff --git a/tests/unit/moduleapi/propagate.tcl b/tests/unit/moduleapi/propagate.tcl
new file mode 100644
index 0000000..846d938
--- /dev/null
+++ b/tests/unit/moduleapi/propagate.tcl
@@ -0,0 +1,616 @@
+set testmodule [file normalize tests/modules/propagate.so]
+set keyspace_events [file normalize tests/modules/keyspace_events.so]
+
+tags "modules" {
+    test {Modules can propagate in async and threaded contexts} {
+        start_server [list overrides [list loadmodule "$testmodule"]] {
+            set replica [srv 0 client]
+            set replica_host [srv 0 host]
+            set replica_port [srv 0 port]
+            $replica module load $keyspace_events
+            start_server [list overrides [list loadmodule "$testmodule"]] {
+                set master [srv 0 client]
+                set master_host [srv 0 host]
+                set master_port [srv 0 port]
+                $master module load $keyspace_events
+
+                # Start the replication process...
+                $replica replicaof $master_host $master_port
+                wait_for_sync $replica
+                after 1000
+
+                test {module propagates from timer} {
+                    set repl [attach_to_replication_stream]
+
+                    $master propagate-test.timer
+
+                    wait_for_condition 500 10 {
+                        [$replica get timer] eq "3"
+                    } else {
+                        fail "The two counters don't match the expected value."
+                    }
+
+                    assert_replication_stream $repl {
+                        {select *}
+                        {incr timer}
+                        {incr timer}
+                        {incr timer}
+                    }
+                    close_replication_stream $repl
+                }
+
+                test {module propagation with notifications} {
+                    set repl [attach_to_replication_stream]
+
+                    $master set x y
+
+                    assert_replication_stream $repl {
+                        {select *}
+                        {multi}
+                        {incr notifications}
+                        {set x y}
+                        {exec}
+                    }
+                    close_replication_stream $repl
+                }
+
+                test {module propagation with notifications with multi} {
+                    set repl [attach_to_replication_stream]
+
+                    $master multi
+                    $master set x1 y1
+                    $master set x2 y2
+                    $master exec
+
+                    assert_replication_stream $repl {
+                        {select *}
+                        {multi}
+                        {incr notifications}
+                        {set x1 y1}
+                        {incr notifications}
+                        {set x2 y2}
+                        {exec}
+                    }
+                    close_replication_stream $repl
+                }
+
+                test {module propagation with notifications with active-expire} {
+                    $master debug set-active-expire 1
+                    set repl [attach_to_replication_stream]
+
+                    $master set asdf1 1 PX 300
+                    $master set asdf2 2 PX 300
+                    $master set asdf3 3 PX 300
+
+                    wait_for_condition 500 10 {
+                        [$replica keys asdf*] eq {}
+                    } else {
+                        fail "Not all keys have expired"
+                    }
+
+                    # Note whenever there's double notification: SET with PX issues two separate
+                    # notifications: one for "set" and one for "expire"
+                    assert_replication_stream $repl {
+                        {select *}
+                        {multi}
+                        {incr notifications}
+                        {incr notifications}
+                        {set asdf1 1 PXAT *}
+                        {exec}
+                        {multi}
+                        {incr notifications}
+                        {incr notifications}
+                        {set asdf2 2 PXAT *}
+                        {exec}
+                        {multi}
+                        {incr notifications}
+                        {incr notifications}
+                        {set asdf3 3 PXAT *}
+                        {exec}
+                        {incr notifications}
+                        {incr notifications}
+                        {incr testkeyspace:expired}
+                        {del asdf*}
+                        {incr notifications}
+                        {incr notifications}
+                        {incr testkeyspace:expired}
+                        {del asdf*}
+                        {incr notifications}
+                        {incr notifications}
+                        {incr testkeyspace:expired}
+                        {del asdf*}
+                    }
+                    close_replication_stream $repl
+
+                    $master debug set-active-expire 0
+                }
+
+                test {module propagation with notifications with eviction case 1} {
+                    $master flushall
+                    $master set asdf1 1
+                    $master set asdf2 2
+                    $master set asdf3 3
+          
+                    $master config set maxmemory-policy allkeys-random
+                    $master config set maxmemory 1
+
+                    # Please note the following loop:
+                    # We evict a key and send a notification, which does INCR on the "notifications" key, so
+                    # that every time we evict any key, "notifications" key exist (it happens inside the
+                    # performEvictions loop). So even evicting "notifications" causes INCR on "notifications".
+                    # If maxmemory_eviction_tenacity would have been set to 100 this would be an endless loop, but
+                    # since the default is 10, at some point the performEvictions loop would end.
+                    # Bottom line: "notifications" always exists and we can't really determine the order of evictions
+                    # This test is here only for sanity
+
+                    wait_for_condition 500 10 {
+                        [$replica dbsize] eq 1
+                    } else {
+                        fail "Not all keys have been evicted"
+                    }
+
+                    $master config set maxmemory 0
+                    $master config set maxmemory-policy noeviction
+                }
+
+                test {module propagation with notifications with eviction case 2} {
+                    $master flushall
+                    set repl [attach_to_replication_stream]
+
+                    $master set asdf1 1 EX 300
+                    $master set asdf2 2 EX 300
+                    $master set asdf3 3 EX 300
+
+                    # Please note we use volatile eviction to prevent the loop described in the test above.
+                    # "notifications" is not volatile so it always remains
+                    $master config resetstat
+                    $master config set maxmemory-policy volatile-ttl
+                    $master config set maxmemory 1
+
+                    wait_for_condition 500 10 {
+                        [s evicted_keys] eq 3
+                    } else {
+                        fail "Not all keys have been evicted"
+                    }
+
+                    $master config set maxmemory 0
+                    $master config set maxmemory-policy noeviction
+
+                    $master set asdf4 4
+
+                    # Note whenever there's double notification: SET with EX issues two separate
+                    # notifications: one for "set" and one for "expire"
+                    # Note that although CONFIG SET maxmemory is called in this flow (see issue #10014),
+                    # eviction will happen and will not induce propagation of the CONFIG command (see #10019).
+                    assert_replication_stream $repl {
+                        {select *}
+                        {multi}
+                        {incr notifications}
+                        {incr notifications}
+                        {set asdf1 1 PXAT *}
+                        {exec}
+                        {multi}
+                        {incr notifications}
+                        {incr notifications}
+                        {set asdf2 2 PXAT *}
+                        {exec}
+                        {multi}
+                        {incr notifications}
+                        {incr notifications}
+                        {set asdf3 3 PXAT *}
+                        {exec}
+                        {incr notifications}
+                        {del asdf*}
+                        {incr notifications}
+                        {del asdf*}
+                        {incr notifications}
+                        {del asdf*}
+                        {multi}
+                        {incr notifications}
+                        {set asdf4 4}
+                        {exec}
+                    }
+                    close_replication_stream $repl
+                }
+
+                test {module propagation with timer and CONFIG SET maxmemory} {
+                    set repl [attach_to_replication_stream]
+
+                    $master config resetstat
+                    $master config set maxmemory-policy volatile-random
+
+                    $master propagate-test.timer-maxmemory
+
+                    # Wait until the volatile keys are evicted
+                    wait_for_condition 500 10 {
+                        [s evicted_keys] eq 2
+                    } else {
+                        fail "Not all keys have been evicted"
+                    }
+
+                    assert_replication_stream $repl {
+                        {select *}
+                        {multi}
+                        {incr notifications}
+                        {incr notifications}
+                        {set timer-maxmemory-volatile-start 1 PXAT *}
+                        {incr timer-maxmemory-middle}
+                        {incr notifications}
+                        {incr notifications}
+                        {set timer-maxmemory-volatile-end 1 PXAT *}
+                        {exec}
+                        {incr notifications}
+                        {del timer-maxmemory-volatile-*}
+                        {incr notifications}
+                        {del timer-maxmemory-volatile-*}
+                    }
+                    close_replication_stream $repl
+
+                    $master config set maxmemory 0
+                    $master config set maxmemory-policy noeviction
+                }
+
+                test {module propagation with timer and EVAL} {
+                    set repl [attach_to_replication_stream]
+
+                    $master propagate-test.timer-eval
+
+                    assert_replication_stream $repl {
+                        {select *}
+                        {multi}
+                        {incr notifications}
+                        {incrby timer-eval-start 1}
+                        {incr notifications}
+                        {set foo bar}
+                        {incr timer-eval-middle}
+                        {incr notifications}
+                        {incrby timer-eval-end 1}
+                        {exec}
+                    }
+                    close_replication_stream $repl
+                }
+
+                test {module propagates nested ctx case1} {
+                    set repl [attach_to_replication_stream]
+
+                    $master propagate-test.timer-nested
+
+                    wait_for_condition 500 10 {
+                        [$replica get timer-nested-end] eq "1"
+                    } else {
+                        fail "The two counters don't match the expected value."
+                    }
+
+                    assert_replication_stream $repl {
+                        {select *}
+                        {multi}
+                        {incrby timer-nested-start 1}
+                        {incrby timer-nested-end 1}
+                        {exec}
+                    }
+                    close_replication_stream $repl
+
+                    # Note propagate-test.timer-nested just propagates INCRBY, causing an
+                    # inconsistency, so we flush
+                    $master flushall
+                }
+
+                test {module propagates nested ctx case2} {
+                    set repl [attach_to_replication_stream]
+
+                    $master propagate-test.timer-nested-repl
+
+                    wait_for_condition 500 10 {
+                        [$replica get timer-nested-end] eq "1"
+                    } else {
+                        fail "The two counters don't match the expected value."
+                    }
+
+                    assert_replication_stream $repl {
+                        {select *}
+                        {multi}
+                        {incrby timer-nested-start 1}
+                        {incr notifications}
+                        {incr using-call}
+                        {incr counter-1}
+                        {incr counter-2}
+                        {incr counter-3}
+                        {incr counter-4}
+                        {incr notifications}
+                        {incr after-call}
+                        {incr notifications}
+                        {incr before-call-2}
+                        {incr notifications}
+                        {incr asdf}
+                        {incr notifications}
+                        {del asdf}
+                        {incr notifications}
+                        {incr after-call-2}
+                        {incr notifications}
+                        {incr timer-nested-middle}
+                        {incrby timer-nested-end 1}
+                        {exec}
+                    }
+                    close_replication_stream $repl
+
+                    # Note propagate-test.timer-nested-repl just propagates INCRBY, causing an
+                    # inconsistency, so we flush
+                    $master flushall
+                }
+
+                test {module propagates from thread} {
+                    set repl [attach_to_replication_stream]
+
+                    $master propagate-test.thread
+
+                    wait_for_condition 500 10 {
+                        [$replica get a-from-thread] eq "3"
+                    } else {
+                        fail "The two counters don't match the expected value."
+                    }
+
+                    assert_replication_stream $repl {
+                        {select *}
+                        {multi}
+                        {incr a-from-thread}
+                        {incr notifications}
+                        {incr thread-call}
+                        {incr b-from-thread}
+                        {exec}
+                        {multi}
+                        {incr a-from-thread}
+                        {incr notifications}
+                        {incr thread-call}
+                        {incr b-from-thread}
+                        {exec}
+                        {multi}
+                        {incr a-from-thread}
+                        {incr notifications}
+                        {incr thread-call}
+                        {incr b-from-thread}
+                        {exec}
+                    }
+                    close_replication_stream $repl
+                }
+
+                test {module propagates from thread with detached ctx} {
+                    set repl [attach_to_replication_stream]
+
+                    $master propagate-test.detached-thread
+
+                    wait_for_condition 500 10 {
+                        [$replica get thread-detached-after] eq "1"
+                    } else {
+                        fail "The key doesn't match the expected value."
+                    }
+
+                    assert_replication_stream $repl {
+                        {select *}
+                        {multi}
+                        {incr thread-detached-before}
+                        {incr notifications}
+                        {incr thread-detached-1}
+                        {incr notifications}
+                        {incr thread-detached-2}
+                        {incr thread-detached-after}
+                        {exec}
+                    }
+                    close_replication_stream $repl
+                }
+
+                test {module propagates from command} {
+                    set repl [attach_to_replication_stream]
+
+                    $master propagate-test.simple
+                    $master propagate-test.mixed
+
+                    assert_replication_stream $repl {
+                        {select *}
+                        {multi}
+                        {incr counter-1}
+                        {incr counter-2}
+                        {exec}
+                        {multi}
+                        {incr notifications}
+                        {incr using-call}
+                        {incr counter-1}
+                        {incr counter-2}
+                        {incr notifications}
+                        {incr after-call}
+                        {exec}
+                    }
+                    close_replication_stream $repl
+                }
+
+                test {module propagates from EVAL} {
+                    set repl [attach_to_replication_stream]
+
+                    assert_equal [ $master eval { \
+                        redis.call("propagate-test.simple"); \
+                        redis.call("set", "x", "y"); \
+                        redis.call("propagate-test.mixed"); return "OK" } 0 ] {OK}
+
+                    assert_replication_stream $repl {
+                        {select *}
+                        {multi}
+                        {incr counter-1}
+                        {incr counter-2}
+                        {incr notifications}
+                        {set x y}
+                        {incr notifications}
+                        {incr using-call}
+                        {incr counter-1}
+                        {incr counter-2}
+                        {incr notifications}
+                        {incr after-call}
+                        {exec}
+                    }
+                    close_replication_stream $repl
+                }
+
+                test {module propagates from command after good EVAL} {
+                    set repl [attach_to_replication_stream]
+
+                    assert_equal [ $master eval { return "hello" } 0 ] {hello}
+                    $master propagate-test.simple
+                    $master propagate-test.mixed
+
+                    assert_replication_stream $repl {
+                        {select *}
+                        {multi}
+                        {incr counter-1}
+                        {incr counter-2}
+                        {exec}
+                        {multi}
+                        {incr notifications}
+                        {incr using-call}
+                        {incr counter-1}
+                        {incr counter-2}
+                        {incr notifications}
+                        {incr after-call}
+                        {exec}
+                    }
+                    close_replication_stream $repl
+                }
+
+                test {module propagates from command after bad EVAL} {
+                    set repl [attach_to_replication_stream]
+
+                    catch { $master eval { return "hello" } -12 } e
+                    assert_equal $e {ERR Number of keys can't be negative}
+                    $master propagate-test.simple
+                    $master propagate-test.mixed
+
+                    assert_replication_stream $repl {
+                        {select *}
+                        {multi}
+                        {incr counter-1}
+                        {incr counter-2}
+                        {exec}
+                        {multi}
+                        {incr notifications}
+                        {incr using-call}
+                        {incr counter-1}
+                        {incr counter-2}
+                        {incr notifications}
+                        {incr after-call}
+                        {exec}
+                    }
+                    close_replication_stream $repl
+                }
+
+                test {module propagates from multi-exec} {
+                    set repl [attach_to_replication_stream]
+
+                    $master multi
+                    $master propagate-test.simple
+                    $master propagate-test.mixed
+                    $master propagate-test.timer-nested-repl
+                    $master exec
+
+                    wait_for_condition 500 10 {
+                        [$replica get timer-nested-end] eq "1"
+                    } else {
+                        fail "The two counters don't match the expected value."
+                    }
+
+                    assert_replication_stream $repl {
+                        {select *}
+                        {multi}
+                        {incr counter-1}
+                        {incr counter-2}
+                        {incr notifications}
+                        {incr using-call}
+                        {incr counter-1}
+                        {incr counter-2}
+                        {incr notifications}
+                        {incr after-call}
+                        {exec}
+                        {multi}
+                        {incrby timer-nested-start 1}
+                        {incr notifications}
+                        {incr using-call}
+                        {incr counter-1}
+                        {incr counter-2}
+                        {incr counter-3}
+                        {incr counter-4}
+                        {incr notifications}
+                        {incr after-call}
+                        {incr notifications}
+                        {incr before-call-2}
+                        {incr notifications}
+                        {incr asdf}
+                        {incr notifications}
+                        {del asdf}
+                        {incr notifications}
+                        {incr after-call-2}
+                        {incr notifications}
+                        {incr timer-nested-middle}
+                        {incrby timer-nested-end 1}
+                        {exec}
+                    }
+                    close_replication_stream $repl
+
+                   # Note propagate-test.timer-nested just propagates INCRBY, causing an
+                    # inconsistency, so we flush
+                    $master flushall
+                }
+
+                test {module RM_Call of expired key propagation} {
+                    $master debug set-active-expire 0
+
+                    $master set k1 900 px 100
+                    after 110
+
+                    set repl [attach_to_replication_stream]
+                    $master propagate-test.incr k1
+
+                    assert_replication_stream $repl {
+                        {select *}
+                        {multi}
+                        {del k1}
+                        {propagate-test.incr k1}
+                        {exec}
+                    }
+                    close_replication_stream $repl
+
+                    assert_equal [$master get k1] 1
+                    assert_equal [$master ttl k1] -1
+                    assert_equal [$replica get k1] 1
+                    assert_equal [$replica ttl k1] -1
+                }
+
+                test "Unload the module - propagate-test/testkeyspace" {
+                    assert_equal {OK} [r module unload propagate-test]
+                    assert_equal {OK} [r module unload testkeyspace]
+                }
+
+                assert_equal [s -1 unexpected_error_replies] 0
+            }
+        }
+    }
+}
+
+tags "modules aof" {
+    test {Modules RM_Replicate replicates MULTI/EXEC correctly} {
+        start_server [list overrides [list loadmodule "$testmodule"]] {
+            # Enable the AOF
+            r config set appendonly yes
+            r config set auto-aof-rewrite-percentage 0 ; # Disable auto-rewrite.
+            waitForBgrewriteaof r
+
+            r propagate-test.simple
+            r propagate-test.mixed
+            r multi
+            r propagate-test.simple
+            r propagate-test.mixed
+            r exec
+
+            # Load the AOF
+            r debug loadaof
+
+            assert_equal {OK} [r module unload propagate-test]
+            assert_equal [s 0 unexpected_error_replies] 0
+        }
+    }
+}
diff --git a/tests/unit/moduleapi/publish.tcl b/tests/unit/moduleapi/publish.tcl
new file mode 100644
index 0000000..ccc966a
--- /dev/null
+++ b/tests/unit/moduleapi/publish.tcl
@@ -0,0 +1,17 @@
+set testmodule [file normalize tests/modules/publish.so]
+
+start_server {tags {"modules"}} {
+    r module load $testmodule
+
+    test {PUBLISH and SPUBLISH via a module} {
+        set rd1 [redis_deferring_client]
+        set rd2 [redis_deferring_client]
+
+        assert_equal {1} [ssubscribe $rd1 {chan1}]
+        assert_equal {1} [subscribe $rd2 {chan1}]
+        assert_equal 1 [r publish.shard chan1 hello]
+        assert_equal 1 [r publish.classic chan1 world]
+        assert_equal {smessage chan1 hello} [$rd1 read]
+        assert_equal {message chan1 world} [$rd2 read]
+    }
+}
diff --git a/tests/unit/moduleapi/reply.tcl b/tests/unit/moduleapi/reply.tcl
new file mode 100644
index 0000000..7fe8c86
--- /dev/null
+++ b/tests/unit/moduleapi/reply.tcl
@@ -0,0 +1,101 @@
+set testmodule [file normalize tests/modules/reply.so]
+
+start_server {tags {"modules"}} {
+    r module load $testmodule
+    
+    #   test all with hello 2/3
+    for {set proto 2} {$proto <= 3} {incr proto} {
+        r hello $proto
+
+        test "RESP$proto: RM_ReplyWithString: an string reply" {
+            # RedisString
+            set string [r rw.string "Redis"]
+            assert_equal "Redis" $string
+            # C string
+            set string [r rw.cstring]
+            assert_equal "A simple string" $string
+        }
+
+        test "RESP$proto: RM_ReplyWithBigNumber: an string reply" {
+            assert_equal "123456778901234567890" [r rw.bignumber "123456778901234567890"]
+        }
+
+        test "RESP$proto: RM_ReplyWithInt: an integer reply" {
+            assert_equal 42 [r rw.int 42]
+        }
+
+        test "RESP$proto: RM_ReplyWithDouble: a float reply" {
+            assert_equal 3.141 [r rw.double 3.141]
+        }
+
+        set ld 0.00000000000000001
+        test "RESP$proto: RM_ReplyWithLongDouble: a float reply" {
+            if {$proto == 2} {
+                # here the response gets to TCL as a string
+                assert_equal $ld [r rw.longdouble $ld]
+            } else {
+                # TCL doesn't support long double and the test infra converts it to a
+                # normal double which causes precision loss. so we use readraw instead
+                r readraw 1
+                assert_equal ",$ld" [r rw.longdouble $ld]
+                r readraw 0
+            }
+        }
+
+        test "RESP$proto: RM_ReplyWithVerbatimString: a string reply" {
+            assert_equal "bla\nbla\nbla" [r rw.verbatim "bla\nbla\nbla"]
+        }
+
+        test "RESP$proto: RM_ReplyWithArray: an array reply" {
+            assert_equal {0 1 2 3 4} [r rw.array 5]
+        }
+
+        test "RESP$proto: RM_ReplyWithMap: an map reply" {
+            set res [r rw.map 3]
+            if {$proto == 2} {
+                assert_equal {0 0 1 1.5 2 3} $res
+            } else {
+                assert_equal [dict create 0 0.0 1 1.5 2 3.0] $res
+            }
+        }
+
+        test "RESP$proto: RM_ReplyWithSet: an set reply" {
+            assert_equal {0 1 2} [r rw.set 3]
+        }
+
+        test "RESP$proto: RM_ReplyWithAttribute: an set reply" {
+            if {$proto == 2} {
+                catch {[r rw.attribute 3]} e
+                assert_match "Attributes aren't supported by RESP 2" $e
+            } else {
+                r readraw 1
+                set res [r rw.attribute 3]
+                assert_equal [r read] {:0}
+                assert_equal [r read] {,0}
+                assert_equal [r read] {:1}
+                assert_equal [r read] {,1.5}
+                assert_equal [r read] {:2}
+                assert_equal [r read] {,3}
+                assert_equal [r read] {+OK}
+                r readraw 0
+            }
+        }
+
+        test "RESP$proto: RM_ReplyWithBool: a boolean reply" {
+            assert_equal {0 1} [r rw.bool]
+        }
+
+        test "RESP$proto: RM_ReplyWithNull: a NULL reply" {
+            assert_equal {} [r rw.null]
+        }
+
+        test "RESP$proto: RM_ReplyWithError: an error reply" {
+            catch {r rw.error} e
+            assert_match "An error" $e
+        }
+    }
+
+    test "Unload the module - replywith" {
+        assert_equal {OK} [r module unload replywith]
+    }
+}
diff --git a/tests/unit/moduleapi/scan.tcl b/tests/unit/moduleapi/scan.tcl
new file mode 100644
index 0000000..66faf5e
--- /dev/null
+++ b/tests/unit/moduleapi/scan.tcl
@@ -0,0 +1,56 @@
+set testmodule [file normalize tests/modules/scan.so]
+
+start_server {tags {"modules"}} {
+    r module load $testmodule
+
+    test {Module scan keyspace} {
+        # the module create a scan command with filtering which also return values
+        r set x 1
+        r set y 2
+        r set z 3
+        r hset h f v
+        lsort [r scan.scan_strings]
+    } {{x 1} {y 2} {z 3}}
+
+    test {Module scan hash ziplist} {
+        r hmset hh f1 v1 f2 v2
+        lsort [r scan.scan_key hh]
+    } {{f1 v1} {f2 v2}}
+    
+    test {Module scan hash dict with int value} {
+        r hmset hh1 f1 1 
+        lsort [r scan.scan_key hh1]
+    } {{f1 1}}
+
+    test {Module scan hash dict} {
+        r config set hash-max-ziplist-entries 2
+        r hmset hh f3 v3
+        lsort [r scan.scan_key hh]
+    } {{f1 v1} {f2 v2} {f3 v3}}
+
+    test {Module scan zset ziplist} {
+        r zadd zz 1 f1 2 f2
+        lsort [r scan.scan_key zz]
+    } {{f1 1} {f2 2}}
+
+    test {Module scan zset dict} {
+        r config set zset-max-ziplist-entries 2
+        r zadd zz 3 f3
+        lsort [r scan.scan_key zz]
+    } {{f1 1} {f2 2} {f3 3}}
+
+    test {Module scan set intset} {
+        r sadd ss 1 2
+        lsort [r scan.scan_key ss]
+    } {{1 {}} {2 {}}}
+
+    test {Module scan set dict} {
+        r config set set-max-intset-entries 2
+        r sadd ss 3
+        lsort [r scan.scan_key ss]
+    } {{1 {}} {2 {}} {3 {}}}
+
+    test "Unload the module - scan" {
+        assert_equal {OK} [r module unload scan]
+    }
+}
diff --git a/tests/unit/moduleapi/stream.tcl b/tests/unit/moduleapi/stream.tcl
new file mode 100644
index 0000000..80c24ff
--- /dev/null
+++ b/tests/unit/moduleapi/stream.tcl
@@ -0,0 +1,159 @@
+set testmodule [file normalize tests/modules/stream.so]
+
+start_server {tags {"modules"}} {
+    r module load $testmodule
+
+    test {Module stream add and delete} {
+        r del mystream
+        # add to empty key
+        set streamid1 [r stream.add mystream item 1 value a]
+        # add to existing stream
+        set streamid2 [r stream.add mystream item 2 value b]
+        # check result
+        assert { [string match "*-*" $streamid1] }
+        set items [r XRANGE mystream - +]
+        assert_equal $items \
+            "{$streamid1 {item 1 value a}} {$streamid2 {item 2 value b}}"
+        # delete one of them and try deleting non-existing ID
+        assert_equal OK [r stream.delete mystream $streamid1]
+        assert_error "ERR StreamDelete*" {r stream.delete mystream 123-456}
+        assert_error "Invalid stream ID*" {r stream.delete mystream foo}
+        assert_equal "{$streamid2 {item 2 value b}}" [r XRANGE mystream - +]
+        # check error condition: wrong type
+        r del mystream
+        r set mystream mystring
+        assert_error "ERR StreamAdd*" {r stream.add mystream item 1 value a}
+        assert_error "ERR StreamDelete*" {r stream.delete mystream 123-456}
+    }
+
+    test {Module stream add unblocks blocking xread} {
+        r del mystream
+
+        # Blocking XREAD on an empty key
+        set rd1 [redis_deferring_client]
+        $rd1 XREAD BLOCK 3000 STREAMS mystream $
+        # wait until client is actually blocked
+        wait_for_condition 50 100 {
+            [s 0 blocked_clients] eq {1}
+        } else {
+            fail "Client is not blocked"
+        }
+        set id [r stream.add mystream field 1 value a]
+        assert_equal "{mystream {{$id {field 1 value a}}}}" [$rd1 read]
+
+        # Blocking XREAD on an existing stream
+        set rd2 [redis_deferring_client]
+        $rd2 XREAD BLOCK 3000 STREAMS mystream $
+        # wait until client is actually blocked
+        wait_for_condition 50 100 {
+            [s 0 blocked_clients] eq {1}
+        } else {
+            fail "Client is not blocked"
+        }
+        set id [r stream.add mystream field 2 value b]
+        assert_equal "{mystream {{$id {field 2 value b}}}}" [$rd2 read]
+    }
+
+    test {Module stream add benchmark (1M stream add)} {
+        set n 1000000
+        r del mystream
+        set result [r stream.addn mystream $n field value]
+        assert_equal $result $n
+    }
+
+    test {Module stream iterator} {
+        r del mystream
+        set streamid1 [r xadd mystream * item 1 value a]
+        set streamid2 [r xadd mystream * item 2 value b]
+        # range result
+        set result1 [r stream.range mystream "-" "+"]
+        set expect1 [r xrange mystream "-" "+"]
+        assert_equal $result1 $expect1
+        # reverse range
+        set result_rev [r stream.range mystream "+" "-"]
+        set expect_rev [r xrevrange mystream "+" "-"]
+        assert_equal $result_rev $expect_rev
+
+        # only one item: range with startid = endid
+        set result2 [r stream.range mystream "-" $streamid1]
+        assert_equal $result2 "{$streamid1 {item 1 value a}}"
+        assert_equal $result2 [list [list $streamid1 {item 1 value a}]]
+        # only one item: range with startid = endid
+        set result3 [r stream.range mystream $streamid2 $streamid2]
+        assert_equal $result3 "{$streamid2 {item 2 value b}}"
+        assert_equal $result3 [list [list $streamid2 {item 2 value b}]]
+    }
+
+    test {Module stream iterator delete} {
+        r del mystream
+        set id1 [r xadd mystream * normal item]
+        set id2 [r xadd mystream * selfdestruct yes]
+        set id3 [r xadd mystream * another item]
+        # stream.range deletes the "selfdestruct" item after returning it
+        assert_equal \
+            "{$id1 {normal item}} {$id2 {selfdestruct yes}} {$id3 {another item}}" \
+            [r stream.range mystream - +]
+        # now, the "selfdestruct" item is gone
+        assert_equal \
+            "{$id1 {normal item}} {$id3 {another item}}" \
+            [r stream.range mystream - +]
+    }
+
+    test {Module stream trim by length} {
+        r del mystream
+        # exact maxlen
+        r xadd mystream * item 1 value a
+        r xadd mystream * item 2 value b
+        r xadd mystream * item 3 value c
+        assert_equal 3 [r xlen mystream]
+        assert_equal 0 [r stream.trim mystream maxlen = 5]
+        assert_equal 3 [r xlen mystream]
+        assert_equal 2 [r stream.trim mystream maxlen = 1]
+        assert_equal 1 [r xlen mystream]
+        assert_equal 1 [r stream.trim mystream maxlen = 0]
+        # check that there is no limit for exact maxlen
+        r stream.addn mystream 20000 item x value y
+        assert_equal 20000 [r stream.trim mystream maxlen = 0]
+        # approx maxlen (100 items per node implies default limit 10K items)
+        r stream.addn mystream 20000 item x value y
+        assert_equal 20000 [r xlen mystream]
+        assert_equal 10000 [r stream.trim mystream maxlen ~ 2]
+        assert_equal 9900  [r stream.trim mystream maxlen ~ 2]
+        assert_equal 0     [r stream.trim mystream maxlen ~ 2]
+        assert_equal 100   [r xlen mystream]
+        assert_equal 100   [r stream.trim mystream maxlen ~ 0]
+        assert_equal 0     [r xlen mystream]
+    }
+
+    test {Module stream trim by ID} {
+        r del mystream
+        # exact minid
+        r xadd mystream * item 1 value a
+        r xadd mystream * item 2 value b
+        set minid [r xadd mystream * item 3 value c]
+        assert_equal 3 [r xlen mystream]
+        assert_equal 0 [r stream.trim mystream minid = -]
+        assert_equal 3 [r xlen mystream]
+        assert_equal 2 [r stream.trim mystream minid = $minid]
+        assert_equal 1 [r xlen mystream]
+        assert_equal 1 [r stream.trim mystream minid = +]
+        # check that there is no limit for exact minid
+        r stream.addn mystream 20000 item x value y
+        assert_equal 20000 [r stream.trim mystream minid = +]
+        # approx minid (100 items per node implies default limit 10K items)
+        r stream.addn mystream 19980 item x value y
+        set minid [r xadd mystream * item x value y]
+        r stream.addn mystream 19 item x value y
+        assert_equal 20000 [r xlen mystream]
+        assert_equal 10000 [r stream.trim mystream minid ~ $minid]
+        assert_equal 9900  [r stream.trim mystream minid ~ $minid]
+        assert_equal 0     [r stream.trim mystream minid ~ $minid]
+        assert_equal 100   [r xlen mystream]
+        assert_equal 100   [r stream.trim mystream minid ~ +]
+        assert_equal 0     [r xlen mystream]
+    }
+
+    test "Unload the module - stream" {
+        assert_equal {OK} [r module unload stream]
+    }
+}
diff --git a/tests/unit/moduleapi/subcommands.tcl b/tests/unit/moduleapi/subcommands.tcl
new file mode 100644
index 0000000..62de593
--- /dev/null
+++ b/tests/unit/moduleapi/subcommands.tcl
@@ -0,0 +1,57 @@
+set testmodule [file normalize tests/modules/subcommands.so]
+
+start_server {tags {"modules"}} {
+    r module load $testmodule
+
+    test "Module subcommands via COMMAND" {
+        # Verify that module subcommands are displayed correctly in COMMAND
+        set command_reply [r command info subcommands.bitarray]
+        set first_cmd [lindex $command_reply 0]
+        set subcmds_in_command [lsort [lindex $first_cmd 9]]
+        assert_equal [lindex $subcmds_in_command 0] {subcommands.bitarray|get -2 module 1 1 1 {} {} {{flags {RO access} begin_search {type index spec {index 1}} find_keys {type range spec {lastkey 0 keystep 1 limit 0}}}} {}}
+        assert_equal [lindex $subcmds_in_command 1] {subcommands.bitarray|set -2 module 1 1 1 {} {} {{flags {RW update} begin_search {type index spec {index 1}} find_keys {type range spec {lastkey 0 keystep 1 limit 0}}}} {}}
+
+        # Verify that module subcommands are displayed correctly in COMMAND DOCS
+        set docs_reply [r command docs subcommands.bitarray]
+        set docs [dict create {*}[lindex $docs_reply 1]]
+        set subcmds_in_cmd_docs [dict create {*}[dict get $docs subcommands]]
+        assert_equal [dict get $subcmds_in_cmd_docs "subcommands.bitarray|get"] {group module module subcommands}
+        assert_equal [dict get $subcmds_in_cmd_docs "subcommands.bitarray|set"] {group module module subcommands}
+    }
+
+    test "Module pure-container command fails on arity error" {
+        catch {r subcommands.bitarray} e
+        assert_match {*wrong number of arguments for 'subcommands.bitarray' command} $e
+
+        # Subcommands can be called
+        assert_equal [r subcommands.bitarray get k1] {OK}
+
+        # Subcommand arity error
+        catch {r subcommands.bitarray get k1 8 90} e
+        assert_match {*wrong number of arguments for 'subcommands.bitarray|get' command} $e
+    }
+
+    test "Module get current command fullname" {
+        assert_equal [r subcommands.parent_get_fullname] {subcommands.parent_get_fullname}
+    }
+
+    test "Module get current subcommand fullname" {
+        assert_equal [r subcommands.sub get_fullname] {subcommands.sub|get_fullname}
+    }
+
+    test "COMMAND LIST FILTERBY MODULE" {
+        assert_equal {} [r command list filterby module non_existing]
+
+        set commands [r command list filterby module subcommands]
+        assert_not_equal [lsearch $commands "subcommands.bitarray"] -1
+        assert_not_equal [lsearch $commands "subcommands.bitarray|set"] -1
+        assert_not_equal [lsearch $commands "subcommands.parent_get_fullname"] -1
+        assert_not_equal [lsearch $commands "subcommands.sub|get_fullname"] -1
+
+        assert_equal [lsearch $commands "set"] -1
+    }
+
+    test "Unload the module - subcommands" {
+        assert_equal {OK} [r module unload subcommands]
+    }
+}
diff --git a/tests/unit/moduleapi/test_lazyfree.tcl b/tests/unit/moduleapi/test_lazyfree.tcl
new file mode 100644
index 0000000..8d2c55a
--- /dev/null
+++ b/tests/unit/moduleapi/test_lazyfree.tcl
@@ -0,0 +1,32 @@
+set testmodule [file normalize tests/modules/test_lazyfree.so]
+
+start_server {tags {"modules"}} {
+    r module load $testmodule
+
+    test "modules allocated memory can be reclaimed in the background" {
+        set orig_mem [s used_memory]
+        set rd [redis_deferring_client]
+
+        # LAZYFREE_THRESHOLD is 64
+        for {set i 0} {$i < 10000} {incr i} {
+            $rd lazyfreelink.insert lazykey $i
+        }
+
+        for {set j 0} {$j < 10000} {incr j} {
+            $rd read 
+        }
+
+        assert {[r lazyfreelink.len lazykey] == 10000}
+
+        set peak_mem [s used_memory]
+        assert {[r unlink lazykey] == 1}
+        assert {$peak_mem > $orig_mem+10000}
+        wait_for_condition 50 100 {
+            [s used_memory] < $peak_mem &&
+            [s used_memory] < $orig_mem*2 &&
+            [string match {*lazyfreed_objects:1*} [r info Memory]]
+        } else {
+            fail "Module memory is not reclaimed by UNLINK"
+        }
+    }
+}
diff --git a/tests/unit/moduleapi/testrdb.tcl b/tests/unit/moduleapi/testrdb.tcl
new file mode 100644
index 0000000..a01bcb3
--- /dev/null
+++ b/tests/unit/moduleapi/testrdb.tcl
@@ -0,0 +1,259 @@
+set testmodule [file normalize tests/modules/testrdb.so]
+
+tags "modules" {
+    test {modules are able to persist types} {
+        start_server [list overrides [list loadmodule "$testmodule"]] {
+            r testrdb.set.key key1 value1
+            assert_equal "value1" [r testrdb.get.key key1]
+            r debug reload
+            assert_equal "value1" [r testrdb.get.key key1]
+        }
+    }
+
+    test {modules global are lost without aux} {
+        set server_path [tmpdir "server.module-testrdb"]
+        start_server [list overrides [list loadmodule "$testmodule" "dir" $server_path] keep_persistence true] {
+            r testrdb.set.before global1
+            assert_equal "global1" [r testrdb.get.before]
+        }
+        start_server [list overrides [list loadmodule "$testmodule" "dir" $server_path]] {
+            assert_equal "" [r testrdb.get.before]
+        }
+    }
+
+    test {modules are able to persist globals before and after} {
+        set server_path [tmpdir "server.module-testrdb"]
+        start_server [list overrides [list loadmodule "$testmodule 2" "dir" $server_path] keep_persistence true] {
+            r testrdb.set.before global1
+            r testrdb.set.after global2
+            assert_equal "global1" [r testrdb.get.before]
+            assert_equal "global2" [r testrdb.get.after]
+        }
+        start_server [list overrides [list loadmodule "$testmodule 2" "dir" $server_path]] {
+            assert_equal "global1" [r testrdb.get.before]
+            assert_equal "global2" [r testrdb.get.after]
+        }
+
+    }
+
+    test {modules are able to persist globals just after} {
+        set server_path [tmpdir "server.module-testrdb"]
+        start_server [list overrides [list loadmodule "$testmodule 1" "dir" $server_path] keep_persistence true] {
+            r testrdb.set.after global2
+            assert_equal "global2" [r testrdb.get.after]
+        }
+        start_server [list overrides [list loadmodule "$testmodule 1" "dir" $server_path]] {
+            assert_equal "global2" [r testrdb.get.after]
+        }
+    }
+
+    test {Verify module options info} {
+        start_server [list overrides [list loadmodule "$testmodule"]] {
+            assert_match "*\[handle-io-errors|handle-repl-async-load\]*" [r info modules]
+        }
+    }
+
+    tags {repl} {
+        test {diskless loading short read with module} {
+            start_server [list overrides [list loadmodule "$testmodule"]] {
+                set replica [srv 0 client]
+                set replica_host [srv 0 host]
+                set replica_port [srv 0 port]
+                start_server [list overrides [list loadmodule "$testmodule"]] {
+                    set master [srv 0 client]
+                    set master_host [srv 0 host]
+                    set master_port [srv 0 port]
+
+                    # Set master and replica to use diskless replication
+                    $master config set repl-diskless-sync yes
+                    $master config set rdbcompression no
+                    $replica config set repl-diskless-load swapdb
+                    $master config set hz 500
+                    $replica config set hz 500
+                    $master config set dynamic-hz no
+                    $replica config set dynamic-hz no
+                    set start [clock clicks -milliseconds]
+                    for {set k 0} {$k < 30} {incr k} {
+                        r testrdb.set.key key$k [string repeat A [expr {int(rand()*1000000)}]]
+                    }
+
+                    if {$::verbose} {
+                        set end [clock clicks -milliseconds]
+                        set duration [expr $end - $start]
+                        puts "filling took $duration ms (TODO: use pipeline)"
+                        set start [clock clicks -milliseconds]
+                    }
+
+                    # Start the replication process...
+                    set loglines [count_log_lines -1]
+                    $master config set repl-diskless-sync-delay 0
+                    $replica replicaof $master_host $master_port
+
+                    # kill the replication at various points
+                    set attempts 100
+                    if {$::accurate} { set attempts 500 }
+                    for {set i 0} {$i < $attempts} {incr i} {
+                        # wait for the replica to start reading the rdb
+                        # using the log file since the replica only responds to INFO once in 2mb
+                        set res [wait_for_log_messages -1 {"*Loading DB in memory*"} $loglines 2000 1]
+                        set loglines [lindex $res 1]
+
+                        # add some additional random sleep so that we kill the master on a different place each time
+                        after [expr {int(rand()*50)}]
+
+                        # kill the replica connection on the master
+                        set killed [$master client kill type replica]
+
+                        set res [wait_for_log_messages -1 {"*Internal error in RDB*" "*Finished with success*" "*Successful partial resynchronization*"} $loglines 500 10]
+                        if {$::verbose} { puts $res }
+                        set log_text [lindex $res 0]
+                        set loglines [lindex $res 1]
+                        if {![string match "*Internal error in RDB*" $log_text]} {
+                            # force the replica to try another full sync
+                            $master multi
+                            $master client kill type replica
+                            $master set asdf asdf
+                            # fill replication backlog with new content
+                            $master config set repl-backlog-size 16384
+                            for {set keyid 0} {$keyid < 10} {incr keyid} {
+                                $master set "$keyid string_$keyid" [string repeat A 16384]
+                            }
+                            $master exec
+                        }
+
+                        # wait for loading to stop (fail)
+                        # After a loading successfully, next loop will enter `async_loading`
+                        wait_for_condition 1000 1 {
+                            [s -1 async_loading] eq 0 &&
+                            [s -1 loading] eq 0
+                        } else {
+                            fail "Replica didn't disconnect"
+                        }
+                    }
+                    if {$::verbose} {
+                        set end [clock clicks -milliseconds]
+                        set duration [expr $end - $start]
+                        puts "test took $duration ms"
+                    }
+                    # enable fast shutdown
+                    $master config set rdb-key-save-delay 0
+                }
+            }
+        }
+
+        # Module events for diskless load swapdb when async_loading (matching master replid)
+        foreach testType {Successful Aborted} {
+            start_server [list overrides [list loadmodule "$testmodule 2"] tags [list external:skip]] {
+                set replica [srv 0 client]
+                set replica_host [srv 0 host]
+                set replica_port [srv 0 port]
+                set replica_log [srv 0 stdout]
+                start_server [list overrides [list loadmodule "$testmodule 2"]] {
+                    set master [srv 0 client]
+                    set master_host [srv 0 host]
+                    set master_port [srv 0 port]
+
+                    set start [clock clicks -milliseconds]
+
+                    # Set master and replica to use diskless replication on swapdb mode
+                    $master config set repl-diskless-sync yes
+                    $master config set repl-diskless-sync-delay 0
+                    $master config set save ""
+                    $replica config set repl-diskless-load swapdb
+                    $replica config set save "" 
+
+                    # Initial sync to have matching replids between master and replica
+                    $replica replicaof $master_host $master_port
+
+                    # Let replica finish initial sync with master
+                    wait_for_condition 100 100 {
+                        [s -1 master_link_status] eq "up"
+                    } else {
+                        fail "Master <-> Replica didn't finish sync"
+                    }
+
+                    # Set global values on module so we can check if module event callbacks will pick it up correctly
+                    $master testrdb.set.before value1_master
+                    $replica testrdb.set.before value1_replica
+
+                    # Put different data sets on the master and replica
+                    # We need to put large keys on the master since the replica replies to info only once in 2mb
+                    $replica debug populate 200 slave 10
+                    $master debug populate 1000 master 100000
+                    $master config set rdbcompression no
+
+                    # Force the replica to try another full sync (this time it will have matching master replid)
+                    $master multi
+                    $master client kill type replica
+                    # Fill replication backlog with new content
+                    $master config set repl-backlog-size 16384
+                    for {set keyid 0} {$keyid < 10} {incr keyid} {
+                        $master set "$keyid string_$keyid" [string repeat A 16384]
+                    }
+                    $master exec
+
+                    switch $testType {
+                        "Aborted" {
+                            # Set master with a slow rdb generation, so that we can easily intercept loading
+                            # 10ms per key, with 1000 keys is 10 seconds
+                            $master config set rdb-key-save-delay 10000
+
+                            test {Diskless load swapdb RedisModuleEvent_ReplAsyncLoad handling: during loading, can keep module variable same as before} {
+                                # Wait for the replica to start reading the rdb and module for acknowledgement
+                                # We wanna abort only after the temp db was populated by REDISMODULE_AUX_BEFORE_RDB
+                                wait_for_condition 100 100 {
+                                    [s -1 async_loading] eq 1 && [$replica testrdb.async_loading.get.before] eq "value1_master"
+                                } else {
+                                    fail "Module didn't receive or react to REDISMODULE_SUBEVENT_REPL_ASYNC_LOAD_STARTED"
+                                }
+
+                                assert_equal [$replica dbsize] 200
+                                assert_equal value1_replica [$replica testrdb.get.before]
+                            }
+
+                            # Make sure that next sync will not start immediately so that we can catch the replica in between syncs
+                            $master config set repl-diskless-sync-delay 5
+
+                            # Kill the replica connection on the master
+                            set killed [$master client kill type replica]
+
+                            test {Diskless load swapdb RedisModuleEvent_ReplAsyncLoad handling: when loading aborted, can keep module variable same as before} {
+                                # Wait for loading to stop (fail) and module for acknowledgement
+                                wait_for_condition 100 100 {
+                                    [s -1 async_loading] eq 0 && [$replica testrdb.async_loading.get.before] eq ""
+                                } else {
+                                    fail "Module didn't receive or react to REDISMODULE_SUBEVENT_REPL_ASYNC_LOAD_ABORTED"
+                                }
+
+                                assert_equal [$replica dbsize] 200
+                                assert_equal value1_replica [$replica testrdb.get.before]
+                            }
+
+                            # Speed up shutdown
+                            $master config set rdb-key-save-delay 0
+                        }
+                        "Successful" {
+                            # Let replica finish sync with master
+                            wait_for_condition 100 100 {
+                                [s -1 master_link_status] eq "up"
+                            } else {
+                                fail "Master <-> Replica didn't finish sync"
+                            }
+
+                            test {Diskless load swapdb RedisModuleEvent_ReplAsyncLoad handling: after db loaded, can set module variable with new value} {
+                                assert_equal [$replica dbsize] 1010
+                                assert_equal value1_master [$replica testrdb.get.before]
+                            }
+                        }
+                    }
+
+                    if {$::verbose} {
+                        set end [clock clicks -milliseconds]
+                        set duration [expr $end - $start]
+                        puts "test took $duration ms"
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/tests/unit/moduleapi/timer.tcl b/tests/unit/moduleapi/timer.tcl
new file mode 100644
index 0000000..4e9dd0f
--- /dev/null
+++ b/tests/unit/moduleapi/timer.tcl
@@ -0,0 +1,99 @@
+set testmodule [file normalize tests/modules/timer.so]
+
+start_server {tags {"modules"}} {
+    r module load $testmodule
+
+    test {RM_CreateTimer: a sequence of timers work} {
+        # We can't guarantee same-ms but we try using MULTI/EXEC
+        r multi
+        for {set i 0} {$i < 20} {incr i} {
+            r test.createtimer 10 timer-incr-key
+        }
+        r exec
+
+        after 500
+        assert_equal 20 [r get timer-incr-key]
+    }
+
+    test {RM_GetTimer: basic sanity} {
+        # Getting non-existing timer
+        assert_equal {} [r test.gettimer 0]
+
+        # Getting a real timer
+        set id [r test.createtimer 10000 timer-incr-key]
+        set info [r test.gettimer $id]
+
+        assert_equal "timer-incr-key" [lindex $info 0]
+        set remaining [lindex $info 1]
+        assert {$remaining < 10000 && $remaining > 1}
+        # Stop the timer after get timer test
+        assert_equal 1 [r test.stoptimer $id]
+    }
+
+    test {RM_StopTimer: basic sanity} {
+        r set "timer-incr-key" 0
+        set id [r test.createtimer 1000 timer-incr-key]
+
+        assert_equal 1 [r test.stoptimer $id]
+
+        # Wait to be sure timer doesn't execute
+        after 2000
+        assert_equal 0 [r get timer-incr-key]
+
+        # Stop non-existing timer
+        assert_equal 0 [r test.stoptimer $id]
+    }
+
+    test {Timer appears non-existing after it fires} {
+        r set "timer-incr-key" 0
+        set id [r test.createtimer 10 timer-incr-key]
+
+        # verify timer fired
+        after 500
+        assert_equal 1 [r get timer-incr-key]
+
+        # verify id does not exist
+        assert_equal {} [r test.gettimer $id]
+    }
+
+    test "Module can be unloaded when timer was finished" {
+        r set "timer-incr-key" 0
+        r test.createtimer 500 timer-incr-key
+
+        # Make sure the Timer has not been fired
+        assert_equal 0 [r get timer-incr-key]
+        # Module can not be unloaded since the timer was ongoing
+        catch {r module unload timer} err
+        assert_match {*the module holds timer that is not fired*} $err
+
+        # Wait to be sure timer has been finished
+        wait_for_condition 10 500 {
+            [r get timer-incr-key] == 1
+        } else {
+            fail "Timer not fired"
+        }
+
+        # Timer fired, can be unloaded now.
+        assert_equal {OK} [r module unload timer]
+    }
+
+    test "Module can be unloaded when timer was stopped" {
+        r module load $testmodule
+        r set "timer-incr-key" 0
+        set id [r test.createtimer 5000 timer-incr-key]
+
+        # Module can not be unloaded since the timer was ongoing
+        catch {r module unload timer} err
+        assert_match {*the module holds timer that is not fired*} $err
+
+        # Stop the timer
+        assert_equal 1 [r test.stoptimer $id]
+
+        # Make sure the Timer has not been fired
+        assert_equal 0 [r get timer-incr-key]
+
+        # Timer has stopped, can be unloaded now.
+        assert_equal {OK} [r module unload timer]
+    }
+}
+
diff --git a/tests/unit/moduleapi/usercall.tcl b/tests/unit/moduleapi/usercall.tcl
new file mode 100644
index 0000000..ed82a38
--- /dev/null
+++ b/tests/unit/moduleapi/usercall.tcl
@@ -0,0 +1,95 @@
+set testmodule [file normalize tests/modules/usercall.so]
+
+set test_script_set "#!lua
+redis.call('set','x',1)
+return 1"
+
+set test_script_get "#!lua
+redis.call('get','x')
+return 1"
+
+start_server {tags {"modules usercall"}} {
+    r module load $testmodule
+
+    # baseline test that module isn't doing anything weird
+    test {test module check regular redis command without user/acl} {
+        assert_equal [r usercall.reset_user] OK
+        assert_equal [r usercall.add_to_acl "~* &* +@all -set"] OK
+        assert_equal [r usercall.call_without_user set x 5] OK
+        assert_equal [r usercall.reset_user] OK
+    }
+
+    # call with user with acl set on it, but without testing the acl
+    test {test module check regular redis command with user} {
+        assert_equal [r set x 5] OK
+
+        assert_equal [r usercall.reset_user] OK
+        assert_equal [r usercall.add_to_acl "~* &* +@all -set"] OK
+        # off and sanitize-payload because module user / default value
+        assert_equal [r usercall.get_acl] "off ~* &* +@all -set"
+
+        # doesn't fail for regular commands as just testing acl here
+        assert_equal [r usercall.call_with_user_flag {} set x 10] OK
+
+        assert_equal [r get x] 10
+        assert_equal [r usercall.reset_user] OK
+    }
+
+    # call with user with acl set on it, but with testing the acl in rm_call (for cmd itself)
+    test {test module check regular redis command with user and acl} {
+        assert_equal [r set x 5] OK
+
+        assert_equal [r usercall.reset_user] OK
+        assert_equal [r usercall.add_to_acl "~* &* +@all -set"] OK
+        # off and sanitize-payload because module user / default value
+        assert_equal [r usercall.get_acl] "off ~* &* +@all -set"
+
+        # fails here as testing acl in rm call
+        catch {r usercall.call_with_user_flag C set x 10} e
+        assert_match {*ERR acl verification failed*} $e
+
+        assert_equal [r usercall.call_with_user_flag C get x] 5
+
+        assert_equal [r usercall.reset_user] OK
+    }
+
+    # baseline script test, call without user on script
+    test {test module check eval script without user} {
+        set sha_set [r script load $test_script_set]
+        set sha_get [r script load $test_script_get]
+
+        assert_equal [r usercall.call_without_user evalsha $sha_set 0] 1
+        assert_equal [r usercall.call_without_user evalsha $sha_get 0] 1
+    }
+
+    # baseline script test, call without user on script
+    test {test module check eval script with user being set, but not acl testing} {
+        set sha_set [r script load $test_script_set]
+        set sha_get [r script load $test_script_get]
+
+        assert_equal [r usercall.reset_user] OK
+        assert_equal [r usercall.add_to_acl "~* &* +@all -set"] OK
+        # off and sanitize-payload because module user / default value
+        assert_equal [r usercall.get_acl] "off ~* &* +@all -set"
+
+        # passes as not checking ACL
+        assert_equal [r usercall.call_with_user_flag {} evalsha $sha_set 0] 1
+        assert_equal [r usercall.call_with_user_flag {} evalsha $sha_get 0] 1
+    }
+
+    # call with user on script (without rm_call acl check) to ensure user carries through to script execution
+    # we already tested the check in rm_call above, here we are checking the script itself will enforce ACL
+    test {test module check eval script with user and acl} {
+        set sha_set [r script load $test_script_set]
+        set sha_get [r script load $test_script_get]
+
+        assert_equal [r usercall.reset_user] OK
+        assert_equal [r usercall.add_to_acl "~* &* +@all -set"] OK
+
+        # fails here in script, as rm_call will permit the eval call
+        catch {r usercall.call_with_user_flag C evalsha $sha_set 0} e
+        assert_match {*ERR The user executing the script can't run this command or subcommand script*} $e
+
+        assert_equal [r usercall.call_with_user_flag C evalsha $sha_get 0] 1
+    }
+}
\ No newline at end of file
diff --git a/tests/unit/moduleapi/zset.tcl b/tests/unit/moduleapi/zset.tcl
new file mode 100644
index 0000000..1c146ea
--- /dev/null
+++ b/tests/unit/moduleapi/zset.tcl
@@ -0,0 +1,20 @@
+set testmodule [file normalize tests/modules/zset.so]
+
+start_server {tags {"modules"}} {
+    r module load $testmodule
+
+    test {Module zset rem} {
+        r del k
+        r zadd k 100 hello 200 world
+        assert_equal 1 [r zset.rem k hello]
+        assert_equal 0 [r zset.rem k hello]
+        assert_equal 1 [r exists k]
+        # Check that removing the last element deletes the key
+        assert_equal 1 [r zset.rem k world]
+        assert_equal 0 [r exists k]
+    }
+
+    test "Unload the module - zset" {
+        assert_equal {OK} [r module unload zset]
+    }
+}