Unverified Commit 8a86bca5 authored by Yossi Gottlieb's avatar Yossi Gottlieb Committed by GitHub
Browse files

Improve test suite to handle external servers better. (#9033)

This commit revives the improves the ability to run the test suite against
external servers, instead of launching and managing `redis-server` processes as
part of the test fixture.

This capability existed in the past, using the `--host` and `--port` options.
However, it was quite limited and mostly useful when running a specific tests.
Attempting to run larger chunks of the test suite experienced many issues:

* Many tests depend on being able to start and control `redis-server` themselves,
and there's no clear distinction between external server compatible and other
tests.
* Cluster mode is not supported (resulting with `CROSSSLOT` errors).

This PR cleans up many things and makes it possible to run the entire test suite
against an external server. It also provides more fine grained controls to
handle cases where the external server supports a subset of the Redis commands,
limited number of databases, cluster mode, etc.

The tests directory now contains a `README.md` file that describes how this
works.

This commit also includes additional cleanups and fixes:

* Tests can now be tagged.
* Tag-based selection is now unified across `start_server`, `tags` and `test`.
* More information is provided about skipped or ignored tests.
* Repeated patterns in tests have been extracted to common procedures, both at a
  global level and on a per-test file basis.
* Cleaned up some cases where test setup was based on a previous test executing
  (a major anti-pattern that repeats itself in many places).
* Cleaned up some cases where test teardown was not part of a test (in the
  future we should have dedicated teardown code that executes even when tests
  fail).
* Fixed some tests that were flaky running on external servers.
parent c396fd91
...@@ -97,7 +97,9 @@ start_server { ...@@ -97,7 +97,9 @@ start_server {
} }
test "Set encoding after DEBUG RELOAD" { test "Set encoding after DEBUG RELOAD" {
r del myintset myhashset mylargeintset r del myintset
r del myhashset
r del mylargeintset
for {set i 0} {$i < 100} {incr i} { r sadd myintset $i } for {set i 0} {$i < 100} {incr i} { r sadd myintset $i }
for {set i 0} {$i < 1280} {incr i} { r sadd mylargeintset $i } for {set i 0} {$i < 1280} {incr i} { r sadd mylargeintset $i }
for {set i 0} {$i < 256} {incr i} { r sadd myhashset [format "i%03d" $i] } for {set i 0} {$i < 256} {incr i} { r sadd myhashset [format "i%03d" $i] }
...@@ -109,7 +111,7 @@ start_server { ...@@ -109,7 +111,7 @@ start_server {
assert_encoding intset myintset assert_encoding intset myintset
assert_encoding hashtable mylargeintset assert_encoding hashtable mylargeintset
assert_encoding hashtable myhashset assert_encoding hashtable myhashset
} } {} {needs:debug}
test {SREM basics - regular set} { test {SREM basics - regular set} {
create_set myset {foo bar ciao} create_set myset {foo bar ciao}
...@@ -143,19 +145,19 @@ start_server { ...@@ -143,19 +145,19 @@ start_server {
foreach {type} {hashtable intset} { foreach {type} {hashtable intset} {
for {set i 1} {$i <= 5} {incr i} { for {set i 1} {$i <= 5} {incr i} {
r del [format "set%d" $i] r del [format "set%d{t}" $i]
} }
for {set i 0} {$i < 200} {incr i} { for {set i 0} {$i < 200} {incr i} {
r sadd set1 $i r sadd set1{t} $i
r sadd set2 [expr $i+195] r sadd set2{t} [expr $i+195]
} }
foreach i {199 195 1000 2000} { foreach i {199 195 1000 2000} {
r sadd set3 $i r sadd set3{t} $i
} }
for {set i 5} {$i < 200} {incr i} { for {set i 5} {$i < 200} {incr i} {
r sadd set4 $i r sadd set4{t} $i
} }
r sadd set5 0 r sadd set5{t} 0
# To make sure the sets are encoded as the type we are testing -- also # To make sure the sets are encoded as the type we are testing -- also
# when the VM is enabled and the values may be swapped in and out # when the VM is enabled and the values may be swapped in and out
...@@ -167,81 +169,81 @@ start_server { ...@@ -167,81 +169,81 @@ start_server {
} }
for {set i 1} {$i <= 5} {incr i} { for {set i 1} {$i <= 5} {incr i} {
r sadd [format "set%d" $i] $large r sadd [format "set%d{t}" $i] $large
} }
test "Generated sets must be encoded as $type" { test "Generated sets must be encoded as $type" {
for {set i 1} {$i <= 5} {incr i} { for {set i 1} {$i <= 5} {incr i} {
assert_encoding $type [format "set%d" $i] assert_encoding $type [format "set%d{t}" $i]
} }
} }
test "SINTER with two sets - $type" { test "SINTER with two sets - $type" {
assert_equal [list 195 196 197 198 199 $large] [lsort [r sinter set1 set2]] assert_equal [list 195 196 197 198 199 $large] [lsort [r sinter set1{t} set2{t}]]
} }
test "SINTERSTORE with two sets - $type" { test "SINTERSTORE with two sets - $type" {
r sinterstore setres set1 set2 r sinterstore setres{t} set1{t} set2{t}
assert_encoding $type setres assert_encoding $type setres{t}
assert_equal [list 195 196 197 198 199 $large] [lsort [r smembers setres]] assert_equal [list 195 196 197 198 199 $large] [lsort [r smembers setres{t}]]
} }
test "SINTERSTORE with two sets, after a DEBUG RELOAD - $type" { test "SINTERSTORE with two sets, after a DEBUG RELOAD - $type" {
r debug reload r debug reload
r sinterstore setres set1 set2 r sinterstore setres{t} set1{t} set2{t}
assert_encoding $type setres assert_encoding $type setres{t}
assert_equal [list 195 196 197 198 199 $large] [lsort [r smembers setres]] assert_equal [list 195 196 197 198 199 $large] [lsort [r smembers setres{t}]]
} } {} {needs:debug}
test "SUNION with two sets - $type" { test "SUNION with two sets - $type" {
set expected [lsort -uniq "[r smembers set1] [r smembers set2]"] set expected [lsort -uniq "[r smembers set1{t}] [r smembers set2{t}]"]
assert_equal $expected [lsort [r sunion set1 set2]] assert_equal $expected [lsort [r sunion set1{t} set2{t}]]
} }
test "SUNIONSTORE with two sets - $type" { test "SUNIONSTORE with two sets - $type" {
r sunionstore setres set1 set2 r sunionstore setres{t} set1{t} set2{t}
assert_encoding $type setres assert_encoding $type setres{t}
set expected [lsort -uniq "[r smembers set1] [r smembers set2]"] set expected [lsort -uniq "[r smembers set1{t}] [r smembers set2{t}]"]
assert_equal $expected [lsort [r smembers setres]] assert_equal $expected [lsort [r smembers setres{t}]]
} }
test "SINTER against three sets - $type" { test "SINTER against three sets - $type" {
assert_equal [list 195 199 $large] [lsort [r sinter set1 set2 set3]] assert_equal [list 195 199 $large] [lsort [r sinter set1{t} set2{t} set3{t}]]
} }
test "SINTERSTORE with three sets - $type" { test "SINTERSTORE with three sets - $type" {
r sinterstore setres set1 set2 set3 r sinterstore setres{t} set1{t} set2{t} set3{t}
assert_equal [list 195 199 $large] [lsort [r smembers setres]] assert_equal [list 195 199 $large] [lsort [r smembers setres{t}]]
} }
test "SUNION with non existing keys - $type" { test "SUNION with non existing keys - $type" {
set expected [lsort -uniq "[r smembers set1] [r smembers set2]"] set expected [lsort -uniq "[r smembers set1{t}] [r smembers set2{t}]"]
assert_equal $expected [lsort [r sunion nokey1 set1 set2 nokey2]] assert_equal $expected [lsort [r sunion nokey1{t} set1{t} set2{t} nokey2{t}]]
} }
test "SDIFF with two sets - $type" { test "SDIFF with two sets - $type" {
assert_equal {0 1 2 3 4} [lsort [r sdiff set1 set4]] assert_equal {0 1 2 3 4} [lsort [r sdiff set1{t} set4{t}]]
} }
test "SDIFF with three sets - $type" { test "SDIFF with three sets - $type" {
assert_equal {1 2 3 4} [lsort [r sdiff set1 set4 set5]] assert_equal {1 2 3 4} [lsort [r sdiff set1{t} set4{t} set5{t}]]
} }
test "SDIFFSTORE with three sets - $type" { test "SDIFFSTORE with three sets - $type" {
r sdiffstore setres set1 set4 set5 r sdiffstore setres{t} set1{t} set4{t} set5{t}
# When we start with intsets, we should always end with intsets. # When we start with intsets, we should always end with intsets.
if {$type eq {intset}} { if {$type eq {intset}} {
assert_encoding intset setres assert_encoding intset setres{t}
} }
assert_equal {1 2 3 4} [lsort [r smembers setres]] assert_equal {1 2 3 4} [lsort [r smembers setres{t}]]
} }
} }
test "SDIFF with first set empty" { test "SDIFF with first set empty" {
r del set1 set2 set3 r del set1{t} set2{t} set3{t}
r sadd set2 1 2 3 4 r sadd set2{t} 1 2 3 4
r sadd set3 a b c d r sadd set3{t} a b c d
r sdiff set1 set2 set3 r sdiff set1{t} set2{t} set3{t}
} {} } {}
test "SDIFF with same set two times" { test "SDIFF with same set two times" {
...@@ -258,11 +260,11 @@ start_server { ...@@ -258,11 +260,11 @@ start_server {
set num_sets [expr {[randomInt 10]+1}] set num_sets [expr {[randomInt 10]+1}]
for {set i 0} {$i < $num_sets} {incr i} { for {set i 0} {$i < $num_sets} {incr i} {
set num_elements [randomInt 100] set num_elements [randomInt 100]
r del set_$i r del set_$i{t}
lappend args set_$i lappend args set_$i{t}
while {$num_elements} { while {$num_elements} {
set ele [randomValue] set ele [randomValue]
r sadd set_$i $ele r sadd set_$i{t} $ele
if {$i == 0} { if {$i == 0} {
set s($ele) x set s($ele) x
} else { } else {
...@@ -277,42 +279,42 @@ start_server { ...@@ -277,42 +279,42 @@ start_server {
} }
test "SINTER against non-set should throw error" { test "SINTER against non-set should throw error" {
r set key1 x r set key1{t} x
assert_error "WRONGTYPE*" {r sinter key1 noset} assert_error "WRONGTYPE*" {r sinter key1{t} noset{t}}
} }
test "SUNION against non-set should throw error" { test "SUNION against non-set should throw error" {
r set key1 x r set key1{t} x
assert_error "WRONGTYPE*" {r sunion key1 noset} assert_error "WRONGTYPE*" {r sunion key1{t} noset{t}}
} }
test "SINTER should handle non existing key as empty" { test "SINTER should handle non existing key as empty" {
r del set1 set2 set3 r del set1{t} set2{t} set3{t}
r sadd set1 a b c r sadd set1{t} a b c
r sadd set2 b c d r sadd set2{t} b c d
r sinter set1 set2 set3 r sinter set1{t} set2{t} set3{t}
} {} } {}
test "SINTER with same integer elements but different encoding" { test "SINTER with same integer elements but different encoding" {
r del set1 set2 r del set1{t} set2{t}
r sadd set1 1 2 3 r sadd set1{t} 1 2 3
r sadd set2 1 2 3 a r sadd set2{t} 1 2 3 a
r srem set2 a r srem set2{t} a
assert_encoding intset set1 assert_encoding intset set1{t}
assert_encoding hashtable set2 assert_encoding hashtable set2{t}
lsort [r sinter set1 set2] lsort [r sinter set1{t} set2{t}]
} {1 2 3} } {1 2 3}
test "SINTERSTORE against non existing keys should delete dstkey" { test "SINTERSTORE against non existing keys should delete dstkey" {
r set setres xxx r set setres{t} xxx
assert_equal 0 [r sinterstore setres foo111 bar222] assert_equal 0 [r sinterstore setres{t} foo111{t} bar222{t}]
assert_equal 0 [r exists setres] assert_equal 0 [r exists setres{t}]
} }
test "SUNIONSTORE against non existing keys should delete dstkey" { test "SUNIONSTORE against non existing keys should delete dstkey" {
r set setres xxx r set setres{t} xxx
assert_equal 0 [r sunionstore setres foo111 bar222] assert_equal 0 [r sunionstore setres{t} foo111{t} bar222{t}]
assert_equal 0 [r exists setres] assert_equal 0 [r exists setres{t}]
} }
foreach {type contents} {hashtable {a b c} intset {1 2 3}} { foreach {type contents} {hashtable {a b c} intset {1 2 3}} {
...@@ -555,81 +557,81 @@ start_server { ...@@ -555,81 +557,81 @@ start_server {
} }
proc setup_move {} { proc setup_move {} {
r del myset3 myset4 r del myset3{t} myset4{t}
create_set myset1 {1 a b} create_set myset1{t} {1 a b}
create_set myset2 {2 3 4} create_set myset2{t} {2 3 4}
assert_encoding hashtable myset1 assert_encoding hashtable myset1{t}
assert_encoding intset myset2 assert_encoding intset myset2{t}
} }
test "SMOVE basics - from regular set to intset" { test "SMOVE basics - from regular set to intset" {
# move a non-integer element to an intset should convert encoding # move a non-integer element to an intset should convert encoding
setup_move setup_move
assert_equal 1 [r smove myset1 myset2 a] assert_equal 1 [r smove myset1{t} myset2{t} a]
assert_equal {1 b} [lsort [r smembers myset1]] assert_equal {1 b} [lsort [r smembers myset1{t}]]
assert_equal {2 3 4 a} [lsort [r smembers myset2]] assert_equal {2 3 4 a} [lsort [r smembers myset2{t}]]
assert_encoding hashtable myset2 assert_encoding hashtable myset2{t}
# move an integer element should not convert the encoding # move an integer element should not convert the encoding
setup_move setup_move
assert_equal 1 [r smove myset1 myset2 1] assert_equal 1 [r smove myset1{t} myset2{t} 1]
assert_equal {a b} [lsort [r smembers myset1]] assert_equal {a b} [lsort [r smembers myset1{t}]]
assert_equal {1 2 3 4} [lsort [r smembers myset2]] assert_equal {1 2 3 4} [lsort [r smembers myset2{t}]]
assert_encoding intset myset2 assert_encoding intset myset2{t}
} }
test "SMOVE basics - from intset to regular set" { test "SMOVE basics - from intset to regular set" {
setup_move setup_move
assert_equal 1 [r smove myset2 myset1 2] assert_equal 1 [r smove myset2{t} myset1{t} 2]
assert_equal {1 2 a b} [lsort [r smembers myset1]] assert_equal {1 2 a b} [lsort [r smembers myset1{t}]]
assert_equal {3 4} [lsort [r smembers myset2]] assert_equal {3 4} [lsort [r smembers myset2{t}]]
} }
test "SMOVE non existing key" { test "SMOVE non existing key" {
setup_move setup_move
assert_equal 0 [r smove myset1 myset2 foo] assert_equal 0 [r smove myset1{t} myset2{t} foo]
assert_equal 0 [r smove myset1 myset1 foo] assert_equal 0 [r smove myset1{t} myset1{t} foo]
assert_equal {1 a b} [lsort [r smembers myset1]] assert_equal {1 a b} [lsort [r smembers myset1{t}]]
assert_equal {2 3 4} [lsort [r smembers myset2]] assert_equal {2 3 4} [lsort [r smembers myset2{t}]]
} }
test "SMOVE non existing src set" { test "SMOVE non existing src set" {
setup_move setup_move
assert_equal 0 [r smove noset myset2 foo] assert_equal 0 [r smove noset{t} myset2{t} foo]
assert_equal {2 3 4} [lsort [r smembers myset2]] assert_equal {2 3 4} [lsort [r smembers myset2{t}]]
} }
test "SMOVE from regular set to non existing destination set" { test "SMOVE from regular set to non existing destination set" {
setup_move setup_move
assert_equal 1 [r smove myset1 myset3 a] assert_equal 1 [r smove myset1{t} myset3{t} a]
assert_equal {1 b} [lsort [r smembers myset1]] assert_equal {1 b} [lsort [r smembers myset1{t}]]
assert_equal {a} [lsort [r smembers myset3]] assert_equal {a} [lsort [r smembers myset3{t}]]
assert_encoding hashtable myset3 assert_encoding hashtable myset3{t}
} }
test "SMOVE from intset to non existing destination set" { test "SMOVE from intset to non existing destination set" {
setup_move setup_move
assert_equal 1 [r smove myset2 myset3 2] assert_equal 1 [r smove myset2{t} myset3{t} 2]
assert_equal {3 4} [lsort [r smembers myset2]] assert_equal {3 4} [lsort [r smembers myset2{t}]]
assert_equal {2} [lsort [r smembers myset3]] assert_equal {2} [lsort [r smembers myset3{t}]]
assert_encoding intset myset3 assert_encoding intset myset3{t}
} }
test "SMOVE wrong src key type" { test "SMOVE wrong src key type" {
r set x 10 r set x{t} 10
assert_error "WRONGTYPE*" {r smove x myset2 foo} assert_error "WRONGTYPE*" {r smove x{t} myset2{t} foo}
} }
test "SMOVE wrong dst key type" { test "SMOVE wrong dst key type" {
r set x 10 r set x{t} 10
assert_error "WRONGTYPE*" {r smove myset2 x foo} assert_error "WRONGTYPE*" {r smove myset2{t} x{t} foo}
} }
test "SMOVE with identical source and destination" { test "SMOVE with identical source and destination" {
r del set r del set{t}
r sadd set a b c r sadd set{t} a b c
r smove set set b r smove set{t} set{t} b
lsort [r smembers set] lsort [r smembers set{t}]
} {a b c} } {a b c}
tags {slow} { tags {slow} {
......
...@@ -214,24 +214,24 @@ start_server { ...@@ -214,24 +214,24 @@ start_server {
} }
test {RENAME can unblock XREADGROUP with data} { test {RENAME can unblock XREADGROUP with data} {
r del mystream r del mystream{t}
r XGROUP CREATE mystream mygroup $ MKSTREAM r XGROUP CREATE mystream{t} mygroup $ MKSTREAM
set rd [redis_deferring_client] set rd [redis_deferring_client]
$rd XREADGROUP GROUP mygroup Alice BLOCK 0 STREAMS mystream ">" $rd XREADGROUP GROUP mygroup Alice BLOCK 0 STREAMS mystream{t} ">"
r XGROUP CREATE mystream2 mygroup $ MKSTREAM r XGROUP CREATE mystream2{t} mygroup $ MKSTREAM
r XADD mystream2 100 f1 v1 r XADD mystream2{t} 100 f1 v1
r RENAME mystream2 mystream r RENAME mystream2{t} mystream{t}
assert_equal "{mystream {{100-0 {f1 v1}}}}" [$rd read] ;# mystream2 had mygroup before RENAME assert_equal "{mystream{t} {{100-0 {f1 v1}}}}" [$rd read] ;# mystream2{t} had mygroup before RENAME
} }
test {RENAME can unblock XREADGROUP with -NOGROUP} { test {RENAME can unblock XREADGROUP with -NOGROUP} {
r del mystream r del mystream{t}
r XGROUP CREATE mystream mygroup $ MKSTREAM r XGROUP CREATE mystream{t} mygroup $ MKSTREAM
set rd [redis_deferring_client] set rd [redis_deferring_client]
$rd XREADGROUP GROUP mygroup Alice BLOCK 0 STREAMS mystream ">" $rd XREADGROUP GROUP mygroup Alice BLOCK 0 STREAMS mystream{t} ">"
r XADD mystream2 100 f1 v1 r XADD mystream2{t} 100 f1 v1
r RENAME mystream2 mystream r RENAME mystream2{t} mystream{t}
assert_error "*NOGROUP*" {$rd read} ;# mystream2 didn't have mygroup before RENAME assert_error "*NOGROUP*" {$rd read} ;# mystream2{t} didn't have mygroup before RENAME
} }
test {XCLAIM can claim PEL items from another consumer} { test {XCLAIM can claim PEL items from another consumer} {
...@@ -548,7 +548,7 @@ start_server { ...@@ -548,7 +548,7 @@ start_server {
assert_error "*NOGROUP*" {r XGROUP CREATECONSUMER mystream mygroup consumer} assert_error "*NOGROUP*" {r XGROUP CREATECONSUMER mystream mygroup consumer}
} }
start_server {tags {"stream"} overrides {appendonly yes aof-use-rdb-preamble no appendfsync always}} { start_server {tags {"stream needs:debug"} overrides {appendonly yes aof-use-rdb-preamble no appendfsync always}} {
test {XREADGROUP with NOACK creates consumer} { test {XREADGROUP with NOACK creates consumer} {
r del mystream r del mystream
r XGROUP CREATE mystream mygroup $ MKSTREAM r XGROUP CREATE mystream mygroup $ MKSTREAM
...@@ -596,7 +596,7 @@ start_server { ...@@ -596,7 +596,7 @@ start_server {
} }
} }
start_server {} { start_server {tags {"external:skip"}} {
set master [srv -1 client] set master [srv -1 client]
set master_host [srv -1 host] set master_host [srv -1 host]
set master_port [srv -1 port] set master_port [srv -1 port]
...@@ -647,7 +647,7 @@ start_server { ...@@ -647,7 +647,7 @@ start_server {
} }
} }
start_server {tags {"stream"} overrides {appendonly yes aof-use-rdb-preamble no}} { start_server {tags {"stream needs:debug"} overrides {appendonly yes aof-use-rdb-preamble no}} {
test {Empty stream with no lastid can be rewrite into AOF correctly} { test {Empty stream with no lastid can be rewrite into AOF correctly} {
r XGROUP CREATE mystream group-name $ MKSTREAM r XGROUP CREATE mystream group-name $ MKSTREAM
assert {[dict get [r xinfo stream mystream] length] == 0} assert {[dict get [r xinfo stream mystream] length] == 0}
......
...@@ -117,6 +117,7 @@ start_server { ...@@ -117,6 +117,7 @@ start_server {
test {XADD with MAXLEN option and the '~' argument} { test {XADD with MAXLEN option and the '~' argument} {
r DEL mystream r DEL mystream
r config set stream-node-max-entries 100
for {set j 0} {$j < 1000} {incr j} { for {set j 0} {$j < 1000} {incr j} {
if {rand() < 0.9} { if {rand() < 0.9} {
r XADD mystream MAXLEN ~ 555 * xitem $j r XADD mystream MAXLEN ~ 555 * xitem $j
...@@ -172,19 +173,23 @@ start_server { ...@@ -172,19 +173,23 @@ start_server {
assert_equal [r XRANGE mystream - +] {{3-0 {f v}} {4-0 {f v}} {5-0 {f v}}} assert_equal [r XRANGE mystream - +] {{3-0 {f v}} {4-0 {f v}} {5-0 {f v}}}
} }
test {XADD mass insertion and XLEN} { proc insert_into_stream_key {key {count 10000}} {
r DEL mystream
r multi r multi
for {set j 0} {$j < 10000} {incr j} { for {set j 0} {$j < $count} {incr j} {
# From time to time insert a field with a different set # From time to time insert a field with a different set
# of fields in order to stress the stream compression code. # of fields in order to stress the stream compression code.
if {rand() < 0.9} { if {rand() < 0.9} {
r XADD mystream * item $j r XADD $key * item $j
} else { } else {
r XADD mystream * item $j otherfield foo r XADD $key * item $j otherfield foo
} }
} }
r exec r exec
}
test {XADD mass insertion and XLEN} {
r DEL mystream
insert_into_stream_key mystream
set items [r XRANGE mystream - +] set items [r XRANGE mystream - +]
for {set j 0} {$j < 10000} {incr j} { for {set j 0} {$j < 10000} {incr j} {
...@@ -267,32 +272,33 @@ start_server { ...@@ -267,32 +272,33 @@ start_server {
} }
test {Non blocking XREAD with empty streams} { test {Non blocking XREAD with empty streams} {
set res [r XREAD STREAMS s1 s2 0-0 0-0] set res [r XREAD STREAMS s1{t} s2{t} 0-0 0-0]
assert {$res eq {}} assert {$res eq {}}
} }
test {XREAD with non empty second stream} { test {XREAD with non empty second stream} {
set res [r XREAD COUNT 1 STREAMS nostream mystream 0-0 0-0] insert_into_stream_key mystream{t}
assert {[lindex $res 0 0] eq {mystream}} set res [r XREAD COUNT 1 STREAMS nostream{t} mystream{t} 0-0 0-0]
assert {[lindex $res 0 0] eq {mystream{t}}}
assert {[lrange [lindex $res 0 1 0 1] 0 1] eq {item 0}} assert {[lrange [lindex $res 0 1 0 1] 0 1] eq {item 0}}
} }
test {Blocking XREAD waiting new data} { test {Blocking XREAD waiting new data} {
r XADD s2 * old abcd1234 r XADD s2{t} * old abcd1234
set rd [redis_deferring_client] set rd [redis_deferring_client]
$rd XREAD BLOCK 20000 STREAMS s1 s2 s3 $ $ $ $rd XREAD BLOCK 20000 STREAMS s1{t} s2{t} s3{t} $ $ $
r XADD s2 * new abcd1234 r XADD s2{t} * new abcd1234
set res [$rd read] set res [$rd read]
assert {[lindex $res 0 0] eq {s2}} assert {[lindex $res 0 0] eq {s2{t}}}
assert {[lindex $res 0 1 0 1] eq {new abcd1234}} assert {[lindex $res 0 1 0 1] eq {new abcd1234}}
} }
test {Blocking XREAD waiting old data} { test {Blocking XREAD waiting old data} {
set rd [redis_deferring_client] set rd [redis_deferring_client]
$rd XREAD BLOCK 20000 STREAMS s1 s2 s3 $ 0-0 $ $rd XREAD BLOCK 20000 STREAMS s1{t} s2{t} s3{t} $ 0-0 $
r XADD s2 * foo abcd1234 r XADD s2{t} * foo abcd1234
set res [$rd read] set res [$rd read]
assert {[lindex $res 0 0] eq {s2}} assert {[lindex $res 0 0] eq {s2{t}}}
assert {[lindex $res 0 1 0 1] eq {old abcd1234}} assert {[lindex $res 0 1 0 1] eq {old abcd1234}}
} }
...@@ -410,12 +416,13 @@ start_server { ...@@ -410,12 +416,13 @@ start_server {
} }
test {XRANGE fuzzing} { test {XRANGE fuzzing} {
set items [r XRANGE mystream{t} - +]
set low_id [lindex $items 0 0] set low_id [lindex $items 0 0]
set high_id [lindex $items end 0] set high_id [lindex $items end 0]
for {set j 0} {$j < 100} {incr j} { for {set j 0} {$j < 100} {incr j} {
set start [streamRandomID $low_id $high_id] set start [streamRandomID $low_id $high_id]
set end [streamRandomID $low_id $high_id] set end [streamRandomID $low_id $high_id]
set range [r xrange mystream $start $end] set range [r xrange mystream{t} $start $end]
set tcl_range [streamSimulateXRANGE $items $start $end] set tcl_range [streamSimulateXRANGE $items $start $end]
if {$range ne $tcl_range} { if {$range ne $tcl_range} {
puts "*** WARNING *** - XRANGE fuzzing mismatch: $start - $end" puts "*** WARNING *** - XRANGE fuzzing mismatch: $start - $end"
...@@ -546,7 +553,7 @@ start_server { ...@@ -546,7 +553,7 @@ start_server {
} }
} }
start_server {tags {"stream"} overrides {appendonly yes}} { start_server {tags {"stream needs:debug"} overrides {appendonly yes}} {
test {XADD with MAXLEN > xlen can propagate correctly} { test {XADD with MAXLEN > xlen can propagate correctly} {
for {set j 0} {$j < 100} {incr j} { for {set j 0} {$j < 100} {incr j} {
r XADD mystream * xitem v r XADD mystream * xitem v
...@@ -561,7 +568,7 @@ start_server {tags {"stream"} overrides {appendonly yes}} { ...@@ -561,7 +568,7 @@ start_server {tags {"stream"} overrides {appendonly yes}} {
} }
} }
start_server {tags {"stream"} overrides {appendonly yes}} { start_server {tags {"stream needs:debug"} overrides {appendonly yes}} {
test {XADD with MINID > lastid can propagate correctly} { test {XADD with MINID > lastid can propagate correctly} {
for {set j 0} {$j < 100} {incr j} { for {set j 0} {$j < 100} {incr j} {
set id [expr {$j+1}] set id [expr {$j+1}]
...@@ -577,7 +584,7 @@ start_server {tags {"stream"} overrides {appendonly yes}} { ...@@ -577,7 +584,7 @@ start_server {tags {"stream"} overrides {appendonly yes}} {
} }
} }
start_server {tags {"stream"} overrides {appendonly yes}} { start_server {tags {"stream needs:debug"} overrides {appendonly yes stream-node-max-entries 100}} {
test {XADD with ~ MAXLEN can propagate correctly} { test {XADD with ~ MAXLEN can propagate correctly} {
for {set j 0} {$j < 100} {incr j} { for {set j 0} {$j < 100} {incr j} {
r XADD mystream * xitem v r XADD mystream * xitem v
...@@ -593,7 +600,7 @@ start_server {tags {"stream"} overrides {appendonly yes}} { ...@@ -593,7 +600,7 @@ start_server {tags {"stream"} overrides {appendonly yes}} {
} }
} }
start_server {tags {"stream"} overrides {appendonly yes stream-node-max-entries 10}} { start_server {tags {"stream needs:debug"} overrides {appendonly yes stream-node-max-entries 10}} {
test {XADD with ~ MAXLEN and LIMIT can propagate correctly} { test {XADD with ~ MAXLEN and LIMIT can propagate correctly} {
for {set j 0} {$j < 100} {incr j} { for {set j 0} {$j < 100} {incr j} {
r XADD mystream * xitem v r XADD mystream * xitem v
...@@ -607,7 +614,7 @@ start_server {tags {"stream"} overrides {appendonly yes stream-node-max-entries ...@@ -607,7 +614,7 @@ start_server {tags {"stream"} overrides {appendonly yes stream-node-max-entries
} }
} }
start_server {tags {"stream"} overrides {appendonly yes}} { start_server {tags {"stream needs:debug"} overrides {appendonly yes stream-node-max-entries 100}} {
test {XADD with ~ MINID can propagate correctly} { test {XADD with ~ MINID can propagate correctly} {
for {set j 0} {$j < 100} {incr j} { for {set j 0} {$j < 100} {incr j} {
set id [expr {$j+1}] set id [expr {$j+1}]
...@@ -624,7 +631,7 @@ start_server {tags {"stream"} overrides {appendonly yes}} { ...@@ -624,7 +631,7 @@ start_server {tags {"stream"} overrides {appendonly yes}} {
} }
} }
start_server {tags {"stream"} overrides {appendonly yes stream-node-max-entries 10}} { start_server {tags {"stream needs:debug"} overrides {appendonly yes stream-node-max-entries 10}} {
test {XADD with ~ MINID and LIMIT can propagate correctly} { test {XADD with ~ MINID and LIMIT can propagate correctly} {
for {set j 0} {$j < 100} {incr j} { for {set j 0} {$j < 100} {incr j} {
set id [expr {$j+1}] set id [expr {$j+1}]
...@@ -639,7 +646,7 @@ start_server {tags {"stream"} overrides {appendonly yes stream-node-max-entries ...@@ -639,7 +646,7 @@ start_server {tags {"stream"} overrides {appendonly yes stream-node-max-entries
} }
} }
start_server {tags {"stream"} overrides {appendonly yes stream-node-max-entries 10}} { start_server {tags {"stream needs:debug"} overrides {appendonly yes stream-node-max-entries 10}} {
test {XTRIM with ~ MAXLEN can propagate correctly} { test {XTRIM with ~ MAXLEN can propagate correctly} {
for {set j 0} {$j < 100} {incr j} { for {set j 0} {$j < 100} {incr j} {
r XADD mystream * xitem v r XADD mystream * xitem v
...@@ -678,7 +685,7 @@ start_server {tags {"stream xsetid"}} { ...@@ -678,7 +685,7 @@ start_server {tags {"stream xsetid"}} {
} {ERR no such key} } {ERR no such key}
} }
start_server {tags {"stream"} overrides {appendonly yes aof-use-rdb-preamble no}} { start_server {tags {"stream needs:debug"} overrides {appendonly yes aof-use-rdb-preamble no}} {
test {Empty stream can be rewrite into AOF correctly} { test {Empty stream can be rewrite into AOF correctly} {
r XADD mystream MAXLEN 0 * a b r XADD mystream MAXLEN 0 * a b
assert {[dict get [r xinfo stream mystream] length] == 0} assert {[dict get [r xinfo stream mystream] length] == 0}
......
This diff is collapsed.
This diff is collapsed.
source tests/support/cli.tcl source tests/support/cli.tcl
start_server {tags {"wait network"}} { start_server {tags {"wait network external:skip"}} {
start_server {} { start_server {} {
set slave [srv 0 client] set slave [srv 0 client]
set slave_host [srv 0 host] set slave_host [srv 0 host]
......
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment