Merge branch 'unstable' into rm_get_server_info

5 files changed, 333 insertions, 11 deletions

diff --git a/tests/unit/moduleapi/blockonkeys.tcl b/tests/unit/moduleapi/blockonkeys.tcl
new file mode 100644
index 000000000..cb99ab1c9
--- /dev/null
+++ b/tests/unit/moduleapi/blockonkeys.tcl
@@ -0,0 +1,85 @@
+set testmodule [file normalize tests/modules/blockonkeys.so]
+
+start_server {tags {"modules"}} {
+    r module load $testmodule
+
+    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.bpop2 k 0
+    } {34 33}
+
+    test {Module client blocked on keys (no metadata): Timeout} {
+        r del k
+        set rd [redis_deferring_client]
+        r fsl.push k 33
+        $rd fsl.bpop2 k 1
+        assert_equal {Request timedout} [$rd read]
+    }
+
+    test {Module client blocked on keys (no metadata): Blocked, case 1} {
+        r del k
+        set rd [redis_deferring_client]
+        r fsl.push k 33
+        $rd fsl.bpop2 k 0
+        r fsl.push k 34
+        assert_equal {34 33} [$rd read]
+    }
+
+    test {Module client blocked on keys (no metadata): Blocked, case 2} {
+        r del k
+        set rd [redis_deferring_client]
+        r fsl.push k 33
+        r fsl.push k 34
+        $rd fsl.bpop2 k 0
+        assert_equal {34 33} [$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]
+        r fsl.push k 33
+        $rd fsl.bpopgt k 35 1
+        assert_equal {Request timedout} [$rd read]
+    }
+
+    test {Module client blocked on keys (with metadata): Blocked, case 1} {
+        r del k
+        set rd [redis_deferring_client]
+        r fsl.push k 33
+        $rd fsl.bpopgt k 33 0
+        r fsl.push k 34
+        assert_equal {34} [$rd read]
+    }
+
+    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
+        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 does not wake up on wrong type} {
+        r del k
+        set rd [redis_deferring_client]
+        $rd fsl.bpop2 k 0
+        r lpush k 12
+        r lpush k 13
+        r lpush k 14
+        r del k
+        r fsl.push k 33
+        r fsl.push k 34
+        assert_equal {34 33} [$rd read]
+    }
+}
diff --git a/tests/unit/moduleapi/datatype.tcl b/tests/unit/moduleapi/datatype.tcl
new file mode 100644
index 000000000..c1da696d3
--- /dev/null
+++ b/tests/unit/moduleapi/datatype.tcl
@@ -0,0 +1,27 @@
+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_LoadDataTypeFromString() work} {
+        r datatype.set dtkey -1111 MyString
+        set encoded [r datatype.dump dtkey]
+
+        r datatype.restore dtkeycopy $encoded
+        assert {[r datatype.get dtkeycopy] eq {-1111 MyString}}
+    }
+
+    test {DataType: Handle truncated RM_LoadDataTypeFromString()} {
+        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} e
+        set e
+    } {*Invalid*}
+}
diff --git a/tests/unit/moduleapi/hooks.tcl b/tests/unit/moduleapi/hooks.tcl
index 7a727902d..cbca9c3eb 100644
--- a/tests/unit/moduleapi/hooks.tcl
+++ b/tests/unit/moduleapi/hooks.tcl
@@ -3,26 +3,138 @@ set testmodule [file normalize tests/modules/hooks.so]
 tags "modules" {
     start_server {} {
         r module load $testmodule
+        r config set appendonly yes
+
         test {Test clients connection / disconnection hooks} {
             for {set j 0} {$j < 2} {incr j} {
                 set rd1 [redis_deferring_client]
                 $rd1 close
             }
-            assert {[r llen connected] > 1}
-            assert {[r llen disconnected] > 1}
+            assert {[r hooks.event_count client-connected] > 1}
+            assert {[r hooks.event_count client-disconnected] > 1}
+        }
+
+        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 1
+            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 {[r hooks.event_count loading-progress-rdb] >= 2} ;# comes from the preamble section
+            assert {[r hooks.event_count loading-progress-aof] >= 2}
+        }
+        # 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 flushall ;# Note: only the "end" RPUSH will survive
-            r select 1
-            r flushdb
-            r select 2
             r flushdb
-            r select 9
-            assert {[r llen flush-start] == 2}
-            assert {[r llen flush-end] == 3}
-            assert {[r lrange flush-start 0 -1] eq {1 2}}
-            assert {[r lrange flush-end 0 -1] eq {-1 1 2}}
+            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_for_condition 50 100 {
+                [string match {*master_link_status:up*} [r info replication]]
+            } else {
+                fail "Can't turn the instance into a replica"
+            }
+
+            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
+            }
+
+            $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] 1
+                assert_equal [r -1 hooks.event_count replica-offline] 1
+            }
+            # get the replica stdout, to be used by the next test
+            set replica_stdout [srv 0 stdout]
         }
+
+
+        # 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/misc.tcl b/tests/unit/moduleapi/misc.tcl
index d392aeab0..748016f1a 100644
--- a/tests/unit/moduleapi/misc.tcl
+++ b/tests/unit/moduleapi/misc.tcl
@@ -16,4 +16,55 @@ start_server {tags {"modules"}} {
         assert { [string match "*cmdstat_module*" $info] }
     }
 
+    test {test long double conversions} {
+        set ld [r test.ld_conversion]
+        assert {[string match $ld "0.00000000000000001"]}
+    }
+
+    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 modle 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 modle 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 }
+    }
+
 }
diff --git a/tests/unit/moduleapi/scan.tcl b/tests/unit/moduleapi/scan.tcl
new file mode 100644
index 000000000..de1672e0a
--- /dev/null
+++ b/tests/unit/moduleapi/scan.tcl
@@ -0,0 +1,47 @@
+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} {
+        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 {}}}
+}