summaryrefslogtreecommitdiff
path: root/examples/redis-unstable/tests/unit/expire.tcl
diff options
context:
space:
mode:
Diffstat (limited to 'examples/redis-unstable/tests/unit/expire.tcl')
-rw-r--r--examples/redis-unstable/tests/unit/expire.tcl972
1 files changed, 0 insertions, 972 deletions
diff --git a/examples/redis-unstable/tests/unit/expire.tcl b/examples/redis-unstable/tests/unit/expire.tcl
deleted file mode 100644
index 69fa0d1..0000000
--- a/examples/redis-unstable/tests/unit/expire.tcl
+++ /dev/null
@@ -1,972 +0,0 @@
-start_server {tags {"expire"}} {
- test {EXPIRE - set timeouts multiple times} {
- r set x foobar
- set v1 [r expire x 5]
- set v2 [r ttl x]
- set v3 [r expire x 10]
- set v4 [r ttl x]
- r expire x 2
- list $v1 $v2 $v3 $v4
- } {1 [45] 1 10}
-
- test {EXPIRE - It should be still possible to read 'x'} {
- r get x
- } {foobar}
-
- tags {"slow"} {
- test {EXPIRE - After 2.1 seconds the key should no longer be here} {
- after 2100
- list [r get x] [r exists x]
- } {{} 0}
- }
-
- test {EXPIRE - write on expire should work} {
- r del x
- r lpush x foo
- r expire x 1000
- r lpush x bar
- r lrange x 0 -1
- } {bar foo}
-
- test {EXPIREAT - Check for EXPIRE alike behavior} {
- r del x
- r set x foo
- r expireat x [expr [clock seconds]+15]
- r ttl x
- } {1[345]}
-
- test {SETEX - Set + Expire combo operation. Check for TTL} {
- r setex x 12 test
- r ttl x
- } {1[012]}
-
- test {SETEX - Check value} {
- r get x
- } {test}
-
- test {SETEX - Overwrite old key} {
- r setex y 1 foo
- r get y
- } {foo}
-
- tags {"slow"} {
- test {SETEX - Wait for the key to expire} {
- after 1100
- r get y
- } {}
- }
-
- test {SETEX - Wrong time parameter} {
- catch {r setex z -10 foo} e
- set _ $e
- } {*invalid expire*}
-
- test {PERSIST can undo an EXPIRE} {
- r set x foo
- r expire x 50
- list [r ttl x] [r persist x] [r ttl x] [r get x]
- } {50 1 -1 foo}
-
- test {PERSIST returns 0 against non existing or non volatile keys} {
- r set x foo
- list [r persist foo] [r persist nokeyatall]
- } {0 0}
-
- test {EXPIRE precision is now the millisecond} {
- # This test is very likely to do a false positive if the
- # server is under pressure, so if it does not work give it a few more
- # chances.
- for {set j 0} {$j < 30} {incr j} {
- r del x
- r setex x 1 somevalue
- after 800
- set a [r get x]
- if {$a ne {somevalue}} continue
- after 300
- set b [r get x]
- if {$b eq {}} break
- }
- if {$::verbose} {
- puts "millisecond expire test attempts: $j"
- }
- assert_equal $a {somevalue}
- assert_equal $b {}
- }
-
- test "PSETEX can set sub-second expires" {
- # This test is very likely to do a false positive if the server is
- # under pressure, so if it does not work give it a few more chances.
- for {set j 0} {$j < 50} {incr j} {
- r del x
- r psetex x 100 somevalue
- set a [r get x]
- after 101
- set b [r get x]
-
- if {$a eq {somevalue} && $b eq {}} break
- }
- if {$::verbose} { puts "PSETEX sub-second expire test attempts: $j" }
- list $a $b
- } {somevalue {}}
-
- test "PEXPIRE can set sub-second expires" {
- # This test is very likely to do a false positive if the server is
- # under pressure, so if it does not work give it a few more chances.
- for {set j 0} {$j < 50} {incr j} {
- r set x somevalue
- r pexpire x 100
- set c [r get x]
- after 101
- set d [r get x]
-
- if {$c eq {somevalue} && $d eq {}} break
- }
- if {$::verbose} { puts "PEXPIRE sub-second expire test attempts: $j" }
- list $c $d
- } {somevalue {}}
-
- test "PEXPIREAT can set sub-second expires" {
- # This test is very likely to do a false positive if the server is
- # under pressure, so if it does not work give it a few more chances.
- for {set j 0} {$j < 50} {incr j} {
- r set x somevalue
- set now [r time]
- r pexpireat x [expr ([lindex $now 0]*1000)+([lindex $now 1]/1000)+200]
- set e [r get x]
- after 201
- set f [r get x]
-
- if {$e eq {somevalue} && $f eq {}} break
- }
- if {$::verbose} { puts "PEXPIREAT sub-second expire test attempts: $j" }
- list $e $f
- } {somevalue {}}
-
- test {TTL returns time to live in seconds} {
- r del x
- r setex x 10 somevalue
- set ttl [r ttl x]
- assert {$ttl > 8 && $ttl <= 10}
- }
-
- test {PTTL returns time to live in milliseconds} {
- r del x
- r setex x 1 somevalue
- set ttl [r pttl x]
- assert {$ttl > 500 && $ttl <= 1000}
- }
-
- test {TTL / PTTL / EXPIRETIME / PEXPIRETIME return -1 if key has no expire} {
- r del x
- r set x hello
- list [r ttl x] [r pttl x] [r expiretime x] [r pexpiretime x]
- } {-1 -1 -1 -1}
-
- test {TTL / PTTL / EXPIRETIME / PEXPIRETIME return -2 if key does not exit} {
- r del x
- list [r ttl x] [r pttl x] [r expiretime x] [r pexpiretime x]
- } {-2 -2 -2 -2}
-
- test {EXPIRETIME returns absolute expiration time in seconds} {
- r del x
- set abs_expire [expr [clock seconds] + 100]
- r set x somevalue exat $abs_expire
- assert_equal [r expiretime x] $abs_expire
- }
-
- test {PEXPIRETIME returns absolute expiration time in milliseconds} {
- r del x
- set abs_expire [expr [clock milliseconds] + 100000]
- r set x somevalue pxat $abs_expire
- assert_equal [r pexpiretime x] $abs_expire
- }
-
- test {Redis should actively expire keys incrementally} {
- r flushdb
- r psetex key1 500 a
- r psetex key2 500 a
- r psetex key3 500 a
- assert_equal 3 [r dbsize]
- # Redis expires random keys ten times every second so we are
- # fairly sure that all the three keys should be evicted after
- # two seconds.
- wait_for_condition 20 100 {
- [r dbsize] eq 0
- } else {
- fail "Keys did not actively expire."
- }
- }
-
- test {Redis should lazy expire keys} {
- r flushdb
- r debug set-active-expire 0
- r psetex key1{t} 500 a
- r psetex key2{t} 500 a
- r psetex key3{t} 500 a
- set size1 [r dbsize]
- # Redis expires random keys ten times every second so we are
- # fairly sure that all the three keys should be evicted after
- # one second.
- after 1000
- set size2 [r dbsize]
- r mget key1{t} key2{t} key3{t}
- set size3 [r dbsize]
- r debug set-active-expire 1
- list $size1 $size2 $size3
- } {3 3 0} {needs:debug}
-
- test {EXPIRE should not resurrect keys (issue #1026)} {
- r debug set-active-expire 0
- r set foo bar
- r pexpire foo 500
- after 1000
- r expire foo 10
- r debug set-active-expire 1
- r exists foo
- } {0} {needs:debug}
-
- test {5 keys in, 5 keys out} {
- r flushdb
- r set a c
- r expire a 5
- r set t c
- r set e c
- r set s c
- r set foo b
- assert_equal [lsort [r keys *]] {a e foo s t}
- r del a ; # Do not leak volatile keys to other tests
- }
-
- test {EXPIRE with empty string as TTL should report an error} {
- r set foo bar
- catch {r expire foo ""} e
- set e
- } {*not an integer*}
-
- test {SET with EX with big integer should report an error} {
- catch {r set foo bar EX 10000000000000000} e
- set e
- } {ERR invalid expire time in 'set' command}
-
- test {SET with EX with smallest integer should report an error} {
- catch {r SET foo bar EX -9999999999999999} e
- set e
- } {ERR invalid expire time in 'set' command}
-
- test {GETEX with big integer should report an error} {
- r set foo bar
- catch {r GETEX foo EX 10000000000000000} e
- set e
- } {ERR invalid expire time in 'getex' command}
-
- test {GETEX with smallest integer should report an error} {
- r set foo bar
- catch {r GETEX foo EX -9999999999999999} e
- set e
- } {ERR invalid expire time in 'getex' command}
-
- test {EXPIRE with big integer overflows when converted to milliseconds} {
- r set foo bar
-
- # Hit `when > LLONG_MAX - basetime`
- assert_error "ERR invalid expire time in 'expire' command" {r EXPIRE foo 9223370399119966}
-
- # Hit `when > LLONG_MAX / 1000`
- assert_error "ERR invalid expire time in 'expire' command" {r EXPIRE foo 9223372036854776}
- assert_error "ERR invalid expire time in 'expire' command" {r EXPIRE foo 10000000000000000}
- assert_error "ERR invalid expire time in 'expire' command" {r EXPIRE foo 18446744073709561}
-
- assert_equal {-1} [r ttl foo]
- }
-
- test {PEXPIRE with big integer overflow when basetime is added} {
- r set foo bar
- catch {r PEXPIRE foo 9223372036854770000} e
- set e
- } {ERR invalid expire time in 'pexpire' command}
-
- test {EXPIRE with big negative integer} {
- r set foo bar
-
- # Hit `when < LLONG_MIN / 1000`
- assert_error "ERR invalid expire time in 'expire' command" {r EXPIRE foo -9223372036854776}
- assert_error "ERR invalid expire time in 'expire' command" {r EXPIRE foo -9999999999999999}
-
- r ttl foo
- } {-1}
-
- test {PEXPIREAT with big integer works} {
- r set foo bar
- r PEXPIREAT foo 9223372036854770000
- } {1}
-
- test {PEXPIREAT with big negative integer works} {
- r set foo bar
- r PEXPIREAT foo -9223372036854770000
- r ttl foo
- } {-2}
-
- # Start a new server with empty data and AOF file.
- start_server {overrides {appendonly {yes} appendfsync always} tags {external:skip}} {
- test {All time-to-live(TTL) in commands are propagated as absolute timestamp in milliseconds in AOF} {
- # This test makes sure that expire times are propagated as absolute
- # times to the AOF file and not as relative time, so that when the AOF
- # is reloaded the TTLs are not being shifted forward to the future.
- # We want the time to logically pass when the server is restarted!
-
- set aof [get_last_incr_aof_path r]
-
- # Apply each TTL-related command to a unique key
- # SET commands
- r set foo1 bar ex 100
- r set foo2 bar px 100000
- r set foo3 bar exat [expr [clock seconds]+100]
- r set foo4 bar PXAT [expr [clock milliseconds]+100000]
- r setex foo5 100 bar
- r psetex foo6 100000 bar
- # EXPIRE-family commands
- r set foo7 bar
- r expire foo7 100
- r set foo8 bar
- r pexpire foo8 100000
- r set foo9 bar
- r expireat foo9 [expr [clock seconds]+100]
- r set foo10 bar
- r pexpireat foo10 [expr [clock seconds]*1000+100000]
- r set foo11 bar
- r expireat foo11 [expr [clock seconds]-100]
- # GETEX commands
- r set foo12 bar
- r getex foo12 ex 100
- r set foo13 bar
- r getex foo13 px 100000
- r set foo14 bar
- r getex foo14 exat [expr [clock seconds]+100]
- r set foo15 bar
- r getex foo15 pxat [expr [clock milliseconds]+100000]
- # RESTORE commands
- r set foo16 bar
- set encoded [r dump foo16]
- r restore foo17 100000 $encoded
- r restore foo18 [expr [clock milliseconds]+100000] $encoded absttl
-
- # Assert that each TTL-related command are persisted with absolute timestamps in AOF
- assert_aof_content $aof {
- {select *}
- {set foo1 bar PXAT *}
- {set foo2 bar PXAT *}
- {set foo3 bar PXAT *}
- {set foo4 bar PXAT *}
- {set foo5 bar PXAT *}
- {set foo6 bar PXAT *}
- {set foo7 bar}
- {pexpireat foo7 *}
- {set foo8 bar}
- {pexpireat foo8 *}
- {set foo9 bar}
- {pexpireat foo9 *}
- {set foo10 bar}
- {pexpireat foo10 *}
- {set foo11 bar}
- {del foo11}
- {set foo12 bar}
- {pexpireat foo12 *}
- {set foo13 bar}
- {pexpireat foo13 *}
- {set foo14 bar}
- {pexpireat foo14 *}
- {set foo15 bar}
- {pexpireat foo15 *}
- {set foo16 bar}
- {restore foo17 * * ABSTTL}
- {restore foo18 * * absttl}
- }
-
- # Remember the absolute TTLs of all the keys
- set ttl1 [r pexpiretime foo1]
- set ttl2 [r pexpiretime foo2]
- set ttl3 [r pexpiretime foo3]
- set ttl4 [r pexpiretime foo4]
- set ttl5 [r pexpiretime foo5]
- set ttl6 [r pexpiretime foo6]
- set ttl7 [r pexpiretime foo7]
- set ttl8 [r pexpiretime foo8]
- set ttl9 [r pexpiretime foo9]
- set ttl10 [r pexpiretime foo10]
- assert_equal "-2" [r pexpiretime foo11] ; # foo11 is gone
- set ttl12 [r pexpiretime foo12]
- set ttl13 [r pexpiretime foo13]
- set ttl14 [r pexpiretime foo14]
- set ttl15 [r pexpiretime foo15]
- assert_equal "-1" [r pexpiretime foo16] ; # foo16 has no TTL
- set ttl17 [r pexpiretime foo17]
- set ttl18 [r pexpiretime foo18]
-
- # Let some time pass and reload data from AOF
- after 2000
- r debug loadaof
-
- # Assert that relative TTLs are roughly the same
- assert_range [r ttl foo1] 90 98
- assert_range [r ttl foo2] 90 98
- assert_range [r ttl foo3] 90 98
- assert_range [r ttl foo4] 90 98
- assert_range [r ttl foo5] 90 98
- assert_range [r ttl foo6] 90 98
- assert_range [r ttl foo7] 90 98
- assert_range [r ttl foo8] 90 98
- assert_range [r ttl foo9] 90 98
- assert_range [r ttl foo10] 90 98
- assert_equal [r ttl foo11] "-2" ; # foo11 is gone
- assert_range [r ttl foo12] 90 98
- assert_range [r ttl foo13] 90 98
- assert_range [r ttl foo14] 90 98
- assert_range [r ttl foo15] 90 98
- assert_equal [r ttl foo16] "-1" ; # foo16 has no TTL
- assert_range [r ttl foo17] 90 98
- assert_range [r ttl foo18] 90 98
-
- # Assert that all keys have restored the same absolute TTLs from AOF
- assert_equal [r pexpiretime foo1] $ttl1
- assert_equal [r pexpiretime foo2] $ttl2
- assert_equal [r pexpiretime foo3] $ttl3
- assert_equal [r pexpiretime foo4] $ttl4
- assert_equal [r pexpiretime foo5] $ttl5
- assert_equal [r pexpiretime foo6] $ttl6
- assert_equal [r pexpiretime foo7] $ttl7
- assert_equal [r pexpiretime foo8] $ttl8
- assert_equal [r pexpiretime foo9] $ttl9
- assert_equal [r pexpiretime foo10] $ttl10
- assert_equal [r pexpiretime foo11] "-2" ; # foo11 is gone
- assert_equal [r pexpiretime foo12] $ttl12
- assert_equal [r pexpiretime foo13] $ttl13
- assert_equal [r pexpiretime foo14] $ttl14
- assert_equal [r pexpiretime foo15] $ttl15
- assert_equal [r pexpiretime foo16] "-1" ; # foo16 has no TTL
- assert_equal [r pexpiretime foo17] $ttl17
- assert_equal [r pexpiretime foo18] $ttl18
- } {} {needs:debug}
- }
-
- test {All TTL in commands are propagated as absolute timestamp in replication stream} {
- # Make sure that both relative and absolute expire commands are propagated
- # as absolute to replicas for two reasons:
- # 1) We want to avoid replicas retaining data much longer than primary due
- # to replication lag.
- # 2) We want to unify the way TTLs are replicated in both RDB and replication
- # stream, which is as absolute timestamps.
- # See: https://github.com/redis/redis/issues/8433
-
- r flushall ; # Clean up keyspace to avoid interference by keys from other tests
- set repl [attach_to_replication_stream]
- # SET commands
- r set foo1 bar ex 200
- r set foo1 bar px 100000
- r set foo1 bar exat [expr [clock seconds]+100]
- r set foo1 bar pxat [expr [clock milliseconds]+100000]
- r setex foo1 100 bar
- r psetex foo1 100000 bar
- r set foo2 bar
- # EXPIRE-family commands
- r expire foo2 100
- r pexpire foo2 100000
- r set foo3 bar
- r expireat foo3 [expr [clock seconds]+100]
- r pexpireat foo3 [expr [clock seconds]*1000+100000]
- r expireat foo3 [expr [clock seconds]-100]
- # GETEX-family commands
- r set foo4 bar
- r getex foo4 ex 200
- r getex foo4 px 200000
- r getex foo4 exat [expr [clock seconds]+100]
- r getex foo4 pxat [expr [clock milliseconds]+100000]
- # RESTORE commands
- r set foo5 bar
- set encoded [r dump foo5]
- r restore foo6 100000 $encoded
- r restore foo7 [expr [clock milliseconds]+100000] $encoded absttl
-
- assert_replication_stream $repl {
- {select *}
- {set foo1 bar PXAT *}
- {set foo1 bar PXAT *}
- {set foo1 bar PXAT *}
- {set foo1 bar pxat *}
- {set foo1 bar PXAT *}
- {set foo1 bar PXAT *}
- {set foo2 bar}
- {pexpireat foo2 *}
- {pexpireat foo2 *}
- {set foo3 bar}
- {pexpireat foo3 *}
- {pexpireat foo3 *}
- {del foo3}
- {set foo4 bar}
- {pexpireat foo4 *}
- {pexpireat foo4 *}
- {pexpireat foo4 *}
- {pexpireat foo4 *}
- {set foo5 bar}
- {restore foo6 * * ABSTTL}
- {restore foo7 * * absttl}
- }
- close_replication_stream $repl
- } {} {needs:repl}
-
- # Start another server to test replication of TTLs
- start_server {tags {needs:repl external:skip}} {
- # Set the outer layer server as primary
- set primary [srv -1 client]
- set primary_host [srv -1 host]
- set primary_port [srv -1 port]
- # Set this inner layer server as replica
- set replica [srv 0 client]
-
- test {First server should have role slave after REPLICAOF} {
- $replica replicaof $primary_host $primary_port
- wait_for_condition 50 100 {
- [s 0 role] eq {slave}
- } else {
- fail "Replication not started."
- }
- }
-
- test {For all replicated TTL-related commands, absolute expire times are identical on primary and replica} {
- # Apply each TTL-related command to a unique key on primary
- # SET commands
- $primary set foo1 bar ex 100
- $primary set foo2 bar px 100000
- $primary set foo3 bar exat [expr [clock seconds]+100]
- $primary set foo4 bar pxat [expr [clock milliseconds]+100000]
- $primary setex foo5 100 bar
- $primary psetex foo6 100000 bar
- # EXPIRE-family commands
- $primary set foo7 bar
- $primary expire foo7 100
- $primary set foo8 bar
- $primary pexpire foo8 100000
- $primary set foo9 bar
- $primary expireat foo9 [expr [clock seconds]+100]
- $primary set foo10 bar
- $primary pexpireat foo10 [expr [clock milliseconds]+100000]
- # GETEX commands
- $primary set foo11 bar
- $primary getex foo11 ex 100
- $primary set foo12 bar
- $primary getex foo12 px 100000
- $primary set foo13 bar
- $primary getex foo13 exat [expr [clock seconds]+100]
- $primary set foo14 bar
- $primary getex foo14 pxat [expr [clock milliseconds]+100000]
- # RESTORE commands
- $primary set foo15 bar
- set encoded [$primary dump foo15]
- $primary restore foo16 100000 $encoded
- $primary restore foo17 [expr [clock milliseconds]+100000] $encoded absttl
-
- # Wait for replica to get the keys and TTLs
- assert {[$primary wait 1 0] == 1}
-
- # Verify absolute TTLs are identical on primary and replica for all keys
- # This is because TTLs are always replicated as absolute values
- foreach key [$primary keys *] {
- assert_equal [$primary pexpiretime $key] [$replica pexpiretime $key]
- }
- }
-
- test {expired key which is created in writeable replicas should be deleted by active expiry} {
- $primary flushall
- $replica config set replica-read-only no
- foreach {yes_or_no} {yes no} {
- $replica config set appendonly $yes_or_no
- waitForBgrewriteaof $replica
- set prev_expired [s expired_keys]
- $replica set foo bar PX 1
- wait_for_condition 100 10 {
- [s expired_keys] eq $prev_expired + 1
- } else {
- fail "key not expired"
- }
- assert_equal {} [$replica get foo]
- }
- }
- }
-
- test {SET command will remove expire} {
- r set foo bar EX 100
- r set foo bar
- r ttl foo
- } {-1}
-
- test {SET command will remove expire with large string (optimization path)} {
- # This test specifically targets the dbSetValue optimization path
- # that was missing TTL handling for large strings
- set large_value [string repeat "A" 1000]
- r set foo $large_value EX 100
- r set foo $large_value KEEPTTL
- set ttl1 [r ttl foo]
- assert {$ttl1 <= 100 && $ttl1 > 90}
-
- # Plain SET should remove TTL even with large strings
- r set foo $large_value
- set ttl2 [r ttl foo]
- assert_equal $ttl2 -1
- }
-
- test {SET - use KEEPTTL option, TTL should not be removed} {
- r set foo bar EX 100
- r set foo bar KEEPTTL
- set ttl [r ttl foo]
- assert {$ttl <= 100 && $ttl > 90}
- }
-
- test {SET - use KEEPTTL option, TTL should not be removed after loadaof} {
- r config set appendonly yes
- r set foo bar EX 100
- r set foo bar2 KEEPTTL
- after 2000
- r debug loadaof
- set ttl [r ttl foo]
- assert {$ttl <= 98 && $ttl > 90}
- } {} {needs:debug}
-
- test {GETEX use of PERSIST option should remove TTL} {
- r set foo bar EX 100
- r getex foo PERSIST
- r ttl foo
- } {-1}
-
- test {GETEX use of PERSIST option should remove TTL after loadaof} {
- r config set appendonly yes
- r set foo bar EX 100
- r getex foo PERSIST
- r debug loadaof
- r ttl foo
- } {-1} {needs:debug}
-
- test {GETEX propagate as to replica as PERSIST, DEL, or nothing} {
- # In the above tests, many keys with random expiration times are set, flush
- # the DBs to avoid active expiry kicking in and messing the replication streams.
- r flushall
- set repl [attach_to_replication_stream]
- r set foo bar EX 100
- r getex foo PERSIST
- r getex foo
- r getex foo exat [expr [clock seconds]-100]
- assert_replication_stream $repl {
- {select *}
- {set foo bar PXAT *}
- {persist foo}
- {del foo}
- }
- close_replication_stream $repl
- } {} {needs:repl}
-
- test {EXPIRE with NX option on a key with ttl} {
- r SET foo bar EX 100
- assert_equal [r EXPIRE foo 200 NX] 0
- assert_range [r TTL foo] 50 100
- } {}
-
- test {EXPIRE with NX option on a key without ttl} {
- r SET foo bar
- assert_equal [r EXPIRE foo 200 NX] 1
- assert_range [r TTL foo] 100 200
- } {}
-
- test {EXPIRE with XX option on a key with ttl} {
- r SET foo bar EX 100
- assert_equal [r EXPIRE foo 200 XX] 1
- assert_range [r TTL foo] 100 200
- } {}
-
- test {EXPIRE with XX option on a key without ttl} {
- r SET foo bar
- assert_equal [r EXPIRE foo 200 XX] 0
- assert_equal [r TTL foo] -1
- } {}
-
- test {EXPIRE with GT option on a key with lower ttl} {
- r SET foo bar EX 100
- assert_equal [r EXPIRE foo 200 GT] 1
- assert_range [r TTL foo] 100 200
- } {}
-
- test {EXPIRE with GT option on a key with higher ttl} {
- r SET foo bar EX 200
- assert_equal [r EXPIRE foo 100 GT] 0
- assert_range [r TTL foo] 100 200
- } {}
-
- test {EXPIRE with GT option on a key without ttl} {
- r SET foo bar
- assert_equal [r EXPIRE foo 200 GT] 0
- assert_equal [r TTL foo] -1
- } {}
-
- test {EXPIRE with LT option on a key with higher ttl} {
- r SET foo bar EX 100
- assert_equal [r EXPIRE foo 200 LT] 0
- assert_range [r TTL foo] 50 100
- } {}
-
- test {EXPIRE with LT option on a key with lower ttl} {
- r SET foo bar EX 200
- assert_equal [r EXPIRE foo 100 LT] 1
- assert_range [r TTL foo] 50 100
- } {}
-
- test {EXPIRE with LT option on a key without ttl} {
- r SET foo bar
- assert_equal [r EXPIRE foo 100 LT] 1
- assert_range [r TTL foo] 50 100
- } {}
-
- test {EXPIRE with LT and XX option on a key with ttl} {
- r SET foo bar EX 200
- assert_equal [r EXPIRE foo 100 LT XX] 1
- assert_range [r TTL foo] 50 100
- } {}
-
- test {EXPIRE with LT and XX option on a key without ttl} {
- r SET foo bar
- assert_equal [r EXPIRE foo 200 LT XX] 0
- assert_equal [r TTL foo] -1
- } {}
-
- test {EXPIRE with conflicting options: LT GT} {
- catch {r EXPIRE foo 200 LT GT} e
- set e
- } {ERR GT and LT options at the same time are not compatible}
-
- test {EXPIRE with conflicting options: NX GT} {
- catch {r EXPIRE foo 200 NX GT} e
- set e
- } {ERR NX and XX, GT or LT options at the same time are not compatible}
-
- test {EXPIRE with conflicting options: NX LT} {
- catch {r EXPIRE foo 200 NX LT} e
- set e
- } {ERR NX and XX, GT or LT options at the same time are not compatible}
-
- test {EXPIRE with conflicting options: NX XX} {
- catch {r EXPIRE foo 200 NX XX} e
- set e
- } {ERR NX and XX, GT or LT options at the same time are not compatible}
-
- test {EXPIRE with unsupported options} {
- catch {r EXPIRE foo 200 AB} e
- set e
- } {ERR Unsupported option AB}
-
- test {EXPIRE with unsupported options} {
- catch {r EXPIRE foo 200 XX AB} e
- set e
- } {ERR Unsupported option AB}
-
- test {EXPIRE with negative expiry} {
- r SET foo bar EX 100
- assert_equal [r EXPIRE foo -10 LT] 1
- assert_equal [r TTL foo] -2
- } {}
-
- test {EXPIRE with negative expiry on a non-valitale key} {
- r SET foo bar
- assert_equal [r EXPIRE foo -10 LT] 1
- assert_equal [r TTL foo] -2
- } {}
-
- test {EXPIRE with non-existed key} {
- assert_equal [r EXPIRE none 100 NX] 0
- assert_equal [r EXPIRE none 100 XX] 0
- assert_equal [r EXPIRE none 100 GT] 0
- assert_equal [r EXPIRE none 100 LT] 0
- } {}
-
- test {Redis should not propagate the read command on lazy expire} {
- r debug set-active-expire 0
- r flushall ; # Clean up keyspace to avoid interference by keys from other tests
- r set foo bar PX 1
- set repl [attach_to_replication_stream]
- wait_for_condition 50 100 {
- [r get foo] eq {}
- } else {
- fail "Replication not started."
- }
-
- # dummy command to verify nothing else gets into the replication stream.
- r set x 1
-
- assert_replication_stream $repl {
- {select *}
- {del foo}
- {set x 1}
- }
- close_replication_stream $repl
- assert_equal [r debug set-active-expire 1] {OK}
- } {} {needs:debug}
-
- test {SCAN: Lazy-expire should not be wrapped in MULTI/EXEC} {
- r debug set-active-expire 0
- r flushall
-
- r set foo1 bar PX 1
- r set foo2 bar PX 1
- after 2
-
- set repl [attach_to_replication_stream]
-
- r scan 0
-
- assert_replication_stream $repl {
- {select *}
- {del foo*}
- {del foo*}
- }
- close_replication_stream $repl
- assert_equal [r debug set-active-expire 1] {OK}
- } {} {needs:debug}
-
- test {RANDOMKEY: Lazy-expire should not be wrapped in MULTI/EXEC} {
- r debug set-active-expire 0
- r flushall
-
- r set foo1 bar PX 1
- r set foo2 bar PX 1
- after 2
-
- set repl [attach_to_replication_stream]
-
- r randomkey
-
- assert_replication_stream $repl {
- {select *}
- {del foo*}
- {del foo*}
- }
- close_replication_stream $repl
- assert_equal [r debug set-active-expire 1] {OK}
- } {} {needs:debug}
-}
-
-start_cluster 1 0 {tags {"expire external:skip cluster"}} {
- test "expire scan should skip dictionaries with lot's of empty buckets" {
- r debug set-active-expire 0
-
- # Collect two slots to help determine the expiry scan logic is able
- # to go past certain slots which aren't valid for scanning at the given point of time.
- # And the next non empty slot after that still gets scanned and expiration happens.
-
- # hashslot(alice) is 749
- r psetex alice 500 val
-
- # hashslot(foo) is 12182
- # fill data across different slots with expiration
- for {set j 1} {$j <= 100} {incr j} {
- r psetex "{foo}$j" 500 a
- }
- # hashslot(key) is 12539
- r psetex key 500 val
-
- # disable resizing, the reason for not using slow bgsave is because
- # it will hit the dict_force_resize_ratio.
- r debug dict-resizing 0
-
- # delete data to have lot's (99%) of empty buckets (slot 12182 should be skipped)
- for {set j 1} {$j <= 99} {incr j} {
- r del "{foo}$j"
- }
-
- # Trigger a full traversal of all dictionaries.
- r keys *
-
- r debug set-active-expire 1
-
- # Verify {foo}100 still exists and remaining got cleaned up
- wait_for_condition 20 100 {
- [r dbsize] eq 1
- } else {
- if {[r dbsize] eq 0} {
- puts [r debug htstats 0]
- fail "scan didn't handle slot skipping logic."
- } else {
- puts [r debug htstats 0]
- fail "scan didn't process all valid slots."
- }
- }
-
- # Enable resizing
- r debug dict-resizing 1
-
- # put some data into slot 12182 and trigger the resize
- r psetex "{foo}0" 500 a
-
- # Verify all keys have expired
- wait_for_condition 400 100 {
- [r dbsize] eq 0
- } else {
- puts [r dbsize]
- flush stdout
- fail "Keys did not actively expire."
- }
-
- # Make sure we don't have any timeouts.
- assert_equal 0 [s 0 expired_time_cap_reached_count]
- } {} {needs:debug}
-}
-
-# Config lazyexpire-nested-arbitrary-keys test body
-proc conf_le_test {option mode} {
- r config set lazyexpire-nested-arbitrary-keys $option
- r debug set-active-expire 0
- r flushall
- r script LOAD {return redis.call('SCAN', 0)}
-
- r set foo bar
- r pexpire foo 1
- after 2
-
- set repl [attach_to_replication_stream]
-
- # First two conditions hit lazy expire within a 'transaction', meaning
- # DEL propagation should be blocked if 'lazyexpire-nested-arbitrary-keys' is set.
- if {$mode == "lua"} {
- r eval "return redis.call('SCAN', 0)" 0
- } elseif {$mode == "multi"} {
- r multi
- r scan 0
- r exec
- } else {
- r scan 0
- }
-
- # dummy command to verify nothing else gets into the replication stream.
- r set x 1
-
- if {$option == "no" && $mode != "direct"} {
- assert_replication_stream $repl {
- {select *}
- {set x 1}
- }
- } else {
- assert_replication_stream $repl {
- {select *}
- {del foo}
- {set x 1}
- }
- }
-
- close_replication_stream $repl
- r script flush
- assert_equal [r config set lazyexpire-nested-arbitrary-keys yes] {OK}
- assert_equal [r debug set-active-expire 1] {OK}
-}
-
-foreach option {yes no} {
-foreach mode {direct multi lua} {
- start_server {tags {"expire"}} {
- test "Config lazyexpire-nested-arbitrary-keys ($option, $mode)" {
- conf_le_test $option $mode
- } {} {needs:debug repl}
- }
-}}
generated by cgit v1.2.3 (git 2.46.0) at 2026-04-29 13:00:18 +0000