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 {
}
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 < 1280} {incr i} { r sadd mylargeintset $i }
for {set i 0} {$i < 256} {incr i} { r sadd myhashset [format "i%03d" $i] }
......@@ -109,7 +111,7 @@ start_server {
assert_encoding intset myintset
assert_encoding hashtable mylargeintset
assert_encoding hashtable myhashset
}
} {} {needs:debug}
test {SREM basics - regular set} {
create_set myset {foo bar ciao}
......@@ -143,19 +145,19 @@ start_server {
foreach {type} {hashtable intset} {
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} {
r sadd set1 $i
r sadd set2 [expr $i+195]
r sadd set1{t} $i
r sadd set2{t} [expr $i+195]
}
foreach i {199 195 1000 2000} {
r sadd set3 $i
r sadd set3{t} $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
# when the VM is enabled and the values may be swapped in and out
......@@ -167,81 +169,81 @@ start_server {
}
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" {
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" {
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" {
r sinterstore setres set1 set2
assert_encoding $type setres
assert_equal [list 195 196 197 198 199 $large] [lsort [r smembers setres]]
r sinterstore setres{t} set1{t} set2{t}
assert_encoding $type setres{t}
assert_equal [list 195 196 197 198 199 $large] [lsort [r smembers setres{t}]]
}
test "SINTERSTORE with two sets, after a DEBUG RELOAD - $type" {
r debug reload
r sinterstore setres set1 set2
assert_encoding $type setres
assert_equal [list 195 196 197 198 199 $large] [lsort [r smembers setres]]
}
r sinterstore setres{t} set1{t} set2{t}
assert_encoding $type setres{t}
assert_equal [list 195 196 197 198 199 $large] [lsort [r smembers setres{t}]]
} {} {needs:debug}
test "SUNION with two sets - $type" {
set expected [lsort -uniq "[r smembers set1] [r smembers set2]"]
assert_equal $expected [lsort [r sunion set1 set2]]
set expected [lsort -uniq "[r smembers set1{t}] [r smembers set2{t}]"]
assert_equal $expected [lsort [r sunion set1{t} set2{t}]]
}
test "SUNIONSTORE with two sets - $type" {
r sunionstore setres set1 set2
assert_encoding $type setres
set expected [lsort -uniq "[r smembers set1] [r smembers set2]"]
assert_equal $expected [lsort [r smembers setres]]
r sunionstore setres{t} set1{t} set2{t}
assert_encoding $type setres{t}
set expected [lsort -uniq "[r smembers set1{t}] [r smembers set2{t}]"]
assert_equal $expected [lsort [r smembers setres{t}]]
}
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" {
r sinterstore setres set1 set2 set3
assert_equal [list 195 199 $large] [lsort [r smembers setres]]
r sinterstore setres{t} set1{t} set2{t} set3{t}
assert_equal [list 195 199 $large] [lsort [r smembers setres{t}]]
}
test "SUNION with non existing keys - $type" {
set expected [lsort -uniq "[r smembers set1] [r smembers set2]"]
assert_equal $expected [lsort [r sunion nokey1 set1 set2 nokey2]]
set expected [lsort -uniq "[r smembers set1{t}] [r smembers set2{t}]"]
assert_equal $expected [lsort [r sunion nokey1{t} set1{t} set2{t} nokey2{t}]]
}
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" {
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" {
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.
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" {
r del set1 set2 set3
r sadd set2 1 2 3 4
r sadd set3 a b c d
r sdiff set1 set2 set3
r del set1{t} set2{t} set3{t}
r sadd set2{t} 1 2 3 4
r sadd set3{t} a b c d
r sdiff set1{t} set2{t} set3{t}
} {}
test "SDIFF with same set two times" {
......@@ -258,11 +260,11 @@ start_server {
set num_sets [expr {[randomInt 10]+1}]
for {set i 0} {$i < $num_sets} {incr i} {
set num_elements [randomInt 100]
r del set_$i
lappend args set_$i
r del set_$i{t}
lappend args set_$i{t}
while {$num_elements} {
set ele [randomValue]
r sadd set_$i $ele
r sadd set_$i{t} $ele
if {$i == 0} {
set s($ele) x
} else {
......@@ -277,42 +279,42 @@ start_server {
}
test "SINTER against non-set should throw error" {
r set key1 x
assert_error "WRONGTYPE*" {r sinter key1 noset}
r set key1{t} x
assert_error "WRONGTYPE*" {r sinter key1{t} noset{t}}
}
test "SUNION against non-set should throw error" {
r set key1 x
assert_error "WRONGTYPE*" {r sunion key1 noset}
r set key1{t} x
assert_error "WRONGTYPE*" {r sunion key1{t} noset{t}}
}
test "SINTER should handle non existing key as empty" {
r del set1 set2 set3
r sadd set1 a b c
r sadd set2 b c d
r sinter set1 set2 set3
r del set1{t} set2{t} set3{t}
r sadd set1{t} a b c
r sadd set2{t} b c d
r sinter set1{t} set2{t} set3{t}
} {}
test "SINTER with same integer elements but different encoding" {
r del set1 set2
r sadd set1 1 2 3
r sadd set2 1 2 3 a
r srem set2 a
assert_encoding intset set1
assert_encoding hashtable set2
lsort [r sinter set1 set2]
r del set1{t} set2{t}
r sadd set1{t} 1 2 3
r sadd set2{t} 1 2 3 a
r srem set2{t} a
assert_encoding intset set1{t}
assert_encoding hashtable set2{t}
lsort [r sinter set1{t} set2{t}]
} {1 2 3}
test "SINTERSTORE against non existing keys should delete dstkey" {
r set setres xxx
assert_equal 0 [r sinterstore setres foo111 bar222]
assert_equal 0 [r exists setres]
r set setres{t} xxx
assert_equal 0 [r sinterstore setres{t} foo111{t} bar222{t}]
assert_equal 0 [r exists setres{t}]
}
test "SUNIONSTORE against non existing keys should delete dstkey" {
r set setres xxx
assert_equal 0 [r sunionstore setres foo111 bar222]
assert_equal 0 [r exists setres]
r set setres{t} xxx
assert_equal 0 [r sunionstore setres{t} foo111{t} bar222{t}]
assert_equal 0 [r exists setres{t}]
}
foreach {type contents} {hashtable {a b c} intset {1 2 3}} {
......@@ -555,81 +557,81 @@ start_server {
}
proc setup_move {} {
r del myset3 myset4
create_set myset1 {1 a b}
create_set myset2 {2 3 4}
assert_encoding hashtable myset1
assert_encoding intset myset2
r del myset3{t} myset4{t}
create_set myset1{t} {1 a b}
create_set myset2{t} {2 3 4}
assert_encoding hashtable myset1{t}
assert_encoding intset myset2{t}
}
test "SMOVE basics - from regular set to intset" {
# move a non-integer element to an intset should convert encoding
setup_move
assert_equal 1 [r smove myset1 myset2 a]
assert_equal {1 b} [lsort [r smembers myset1]]
assert_equal {2 3 4 a} [lsort [r smembers myset2]]
assert_encoding hashtable myset2
assert_equal 1 [r smove myset1{t} myset2{t} a]
assert_equal {1 b} [lsort [r smembers myset1{t}]]
assert_equal {2 3 4 a} [lsort [r smembers myset2{t}]]
assert_encoding hashtable myset2{t}
# move an integer element should not convert the encoding
setup_move
assert_equal 1 [r smove myset1 myset2 1]
assert_equal {a b} [lsort [r smembers myset1]]
assert_equal {1 2 3 4} [lsort [r smembers myset2]]
assert_encoding intset myset2
assert_equal 1 [r smove myset1{t} myset2{t} 1]
assert_equal {a b} [lsort [r smembers myset1{t}]]
assert_equal {1 2 3 4} [lsort [r smembers myset2{t}]]
assert_encoding intset myset2{t}
}
test "SMOVE basics - from intset to regular set" {
setup_move
assert_equal 1 [r smove myset2 myset1 2]
assert_equal {1 2 a b} [lsort [r smembers myset1]]
assert_equal {3 4} [lsort [r smembers myset2]]
assert_equal 1 [r smove myset2{t} myset1{t} 2]
assert_equal {1 2 a b} [lsort [r smembers myset1{t}]]
assert_equal {3 4} [lsort [r smembers myset2{t}]]
}
test "SMOVE non existing key" {
setup_move
assert_equal 0 [r smove myset1 myset2 foo]
assert_equal 0 [r smove myset1 myset1 foo]
assert_equal {1 a b} [lsort [r smembers myset1]]
assert_equal {2 3 4} [lsort [r smembers myset2]]
assert_equal 0 [r smove myset1{t} myset2{t} foo]
assert_equal 0 [r smove myset1{t} myset1{t} foo]
assert_equal {1 a b} [lsort [r smembers myset1{t}]]
assert_equal {2 3 4} [lsort [r smembers myset2{t}]]
}
test "SMOVE non existing src set" {
setup_move
assert_equal 0 [r smove noset myset2 foo]
assert_equal {2 3 4} [lsort [r smembers myset2]]
assert_equal 0 [r smove noset{t} myset2{t} foo]
assert_equal {2 3 4} [lsort [r smembers myset2{t}]]
}
test "SMOVE from regular set to non existing destination set" {
setup_move
assert_equal 1 [r smove myset1 myset3 a]
assert_equal {1 b} [lsort [r smembers myset1]]
assert_equal {a} [lsort [r smembers myset3]]
assert_encoding hashtable myset3
assert_equal 1 [r smove myset1{t} myset3{t} a]
assert_equal {1 b} [lsort [r smembers myset1{t}]]
assert_equal {a} [lsort [r smembers myset3{t}]]
assert_encoding hashtable myset3{t}
}
test "SMOVE from intset to non existing destination set" {
setup_move
assert_equal 1 [r smove myset2 myset3 2]
assert_equal {3 4} [lsort [r smembers myset2]]
assert_equal {2} [lsort [r smembers myset3]]
assert_encoding intset myset3
assert_equal 1 [r smove myset2{t} myset3{t} 2]
assert_equal {3 4} [lsort [r smembers myset2{t}]]
assert_equal {2} [lsort [r smembers myset3{t}]]
assert_encoding intset myset3{t}
}
test "SMOVE wrong src key type" {
r set x 10
assert_error "WRONGTYPE*" {r smove x myset2 foo}
r set x{t} 10
assert_error "WRONGTYPE*" {r smove x{t} myset2{t} foo}
}
test "SMOVE wrong dst key type" {
r set x 10
assert_error "WRONGTYPE*" {r smove myset2 x foo}
r set x{t} 10
assert_error "WRONGTYPE*" {r smove myset2{t} x{t} foo}
}
test "SMOVE with identical source and destination" {
r del set
r sadd set a b c
r smove set set b
lsort [r smembers set]
r del set{t}
r sadd set{t} a b c
r smove set{t} set{t} b
lsort [r smembers set{t}]
} {a b c}
tags {slow} {
......
......@@ -214,24 +214,24 @@ start_server {
}
test {RENAME can unblock XREADGROUP with data} {
r del mystream
r XGROUP CREATE mystream mygroup $ MKSTREAM
r del mystream{t}
r XGROUP CREATE mystream{t} mygroup $ MKSTREAM
set rd [redis_deferring_client]
$rd XREADGROUP GROUP mygroup Alice BLOCK 0 STREAMS mystream ">"
r XGROUP CREATE mystream2 mygroup $ MKSTREAM
r XADD mystream2 100 f1 v1
r RENAME mystream2 mystream
assert_equal "{mystream {{100-0 {f1 v1}}}}" [$rd read] ;# mystream2 had mygroup before RENAME
$rd XREADGROUP GROUP mygroup Alice BLOCK 0 STREAMS mystream{t} ">"
r XGROUP CREATE mystream2{t} mygroup $ MKSTREAM
r XADD mystream2{t} 100 f1 v1
r RENAME mystream2{t} mystream{t}
assert_equal "{mystream{t} {{100-0 {f1 v1}}}}" [$rd read] ;# mystream2{t} had mygroup before RENAME
}
test {RENAME can unblock XREADGROUP with -NOGROUP} {
r del mystream
r XGROUP CREATE mystream mygroup $ MKSTREAM
r del mystream{t}
r XGROUP CREATE mystream{t} mygroup $ MKSTREAM
set rd [redis_deferring_client]
$rd XREADGROUP GROUP mygroup Alice BLOCK 0 STREAMS mystream ">"
r XADD mystream2 100 f1 v1
r RENAME mystream2 mystream
assert_error "*NOGROUP*" {$rd read} ;# mystream2 didn't have mygroup before RENAME
$rd XREADGROUP GROUP mygroup Alice BLOCK 0 STREAMS mystream{t} ">"
r XADD mystream2{t} 100 f1 v1
r RENAME mystream2{t} mystream{t}
assert_error "*NOGROUP*" {$rd read} ;# mystream2{t} didn't have mygroup before RENAME
}
test {XCLAIM can claim PEL items from another consumer} {
......@@ -548,7 +548,7 @@ start_server {
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} {
r del mystream
r XGROUP CREATE mystream mygroup $ MKSTREAM
......@@ -596,7 +596,7 @@ start_server {
}
}
start_server {} {
start_server {tags {"external:skip"}} {
set master [srv -1 client]
set master_host [srv -1 host]
set master_port [srv -1 port]
......@@ -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} {
r XGROUP CREATE mystream group-name $ MKSTREAM
assert {[dict get [r xinfo stream mystream] length] == 0}
......
......@@ -117,6 +117,7 @@ start_server {
test {XADD with MAXLEN option and the '~' argument} {
r DEL mystream
r config set stream-node-max-entries 100
for {set j 0} {$j < 1000} {incr j} {
if {rand() < 0.9} {
r XADD mystream MAXLEN ~ 555 * xitem $j
......@@ -172,19 +173,23 @@ start_server {
assert_equal [r XRANGE mystream - +] {{3-0 {f v}} {4-0 {f v}} {5-0 {f v}}}
}
test {XADD mass insertion and XLEN} {
r DEL mystream
proc insert_into_stream_key {key {count 10000}} {
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
# of fields in order to stress the stream compression code.
if {rand() < 0.9} {
r XADD mystream * item $j
r XADD $key * item $j
} else {
r XADD mystream * item $j otherfield foo
r XADD $key * item $j otherfield foo
}
}
r exec
}
test {XADD mass insertion and XLEN} {
r DEL mystream
insert_into_stream_key mystream
set items [r XRANGE mystream - +]
for {set j 0} {$j < 10000} {incr j} {
......@@ -267,32 +272,33 @@ start_server {
}
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 {}}
}
test {XREAD with non empty second stream} {
set res [r XREAD COUNT 1 STREAMS nostream mystream 0-0 0-0]
assert {[lindex $res 0 0] eq {mystream}}
insert_into_stream_key mystream{t}
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}}
}
test {Blocking XREAD waiting new data} {
r XADD s2 * old abcd1234
r XADD s2{t} * old abcd1234
set rd [redis_deferring_client]
$rd XREAD BLOCK 20000 STREAMS s1 s2 s3 $ $ $
r XADD s2 * new abcd1234
$rd XREAD BLOCK 20000 STREAMS s1{t} s2{t} s3{t} $ $ $
r XADD s2{t} * new abcd1234
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}}
}
test {Blocking XREAD waiting old data} {
set rd [redis_deferring_client]
$rd XREAD BLOCK 20000 STREAMS s1 s2 s3 $ 0-0 $
r XADD s2 * foo abcd1234
$rd XREAD BLOCK 20000 STREAMS s1{t} s2{t} s3{t} $ 0-0 $
r XADD s2{t} * foo abcd1234
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}}
}
......@@ -410,12 +416,13 @@ start_server {
}
test {XRANGE fuzzing} {
set items [r XRANGE mystream{t} - +]
set low_id [lindex $items 0 0]
set high_id [lindex $items end 0]
for {set j 0} {$j < 100} {incr j} {
set start [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]
if {$range ne $tcl_range} {
puts "*** WARNING *** - XRANGE fuzzing mismatch: $start - $end"
......@@ -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} {
for {set j 0} {$j < 100} {incr j} {
r XADD mystream * xitem v
......@@ -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} {
for {set j 0} {$j < 100} {incr j} {
set id [expr {$j+1}]
......@@ -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} {
for {set j 0} {$j < 100} {incr j} {
r XADD mystream * xitem v
......@@ -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} {
for {set j 0} {$j < 100} {incr j} {
r XADD mystream * xitem v
......@@ -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} {
for {set j 0} {$j < 100} {incr j} {
set id [expr {$j+1}]
......@@ -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} {
for {set j 0} {$j < 100} {incr j} {
set id [expr {$j+1}]
......@@ -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} {
for {set j 0} {$j < 100} {incr j} {
r XADD mystream * xitem v
......@@ -678,7 +685,7 @@ start_server {tags {"stream xsetid"}} {
} {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} {
r XADD mystream MAXLEN 0 * a b
assert {[dict get [r xinfo stream mystream] length] == 0}
......
This diff is collapsed.
This diff is collapsed.
source tests/support/cli.tcl
start_server {tags {"wait network"}} {
start_server {tags {"wait network external:skip"}} {
start_server {} {
set slave [srv 0 client]
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