Files
kv/tests/unit/hashexpire.tcl
zeekay 5b2e5fe98e fix: revert the -X ours upstream merge, which left the tree uncompilable
`merge: upstream/unstable (-X ours, brand preserved)` resolved every conflicting
hunk in our favour. That is right for brand strings and wrong for code: it kept
our old server.h beside their new module.c, so module.c calls
commandResultSuccessListeners and reads from_call_argv off a struct that has
neither, and zslFreeLexRange lost the declarations it still has call sites for.
kvReaderFeed got a newer body calling kvReaderGetReadBuf/CommitRead grafted onto
older locals — an sds newbuf and an oom: label the new body never uses. Across
398 files nothing downstream noticed, because main has not compiled since.

That is what the Dockerfile was working around. Pulling valkey/valkey and copying
binaries out of it produced an image no matter what the source did, so a tree
that cannot build looked like a tree that builds. Now the image compiles this
source, so the build breaking is visible the moment it breaks.

src, deps and tests return to the last coherent commit. Carried forward on top:

  - Two identical rdbIsVersionAccepted definitions, differing only in a
    parameter name. The rename pass copied the function instead of editing it,
    so this never compiled either.
  - kv_strtod.h lost the #ifdef USE_FAST_FLOAT that separated its two
    implementations, leaving both definitions and a stray #endif.
  - extended-redis-compatibility is deleted, not defaulted off. It made the
    server answer HELLO with "redis" and name itself Redis in five error
    strings. A server that can be configured to lie about what it is has one
    setting too many. HELLO now reports kv unconditionally.
  - The redis-server and redis-cli install symlinks, on by default via
    USE_REDIS_SYMLINKS?=yes. This is why a running instance answered to
    redis-cli at all.
  - valkeymodule.h and redismodule.h, 3094 lines of adapters mapping old
    prefixes onto KVMODULE_*, included by nothing. kvmodule.h is the header.
  - deps/libvalkey, one documentation file the rename stranded.

Wire contract is untouched. INFO still reports redis_version, redis_git_sha1,
redis_git_dirty and redis_build_id, and the Lua sandbox still exports
REDIS_VERSION — clients parse those field names, so they are protocol, not
branding. What we choose is what the server calls itself, and it calls itself kv.

Verified: builds clean, and a live instance answers HELLO with "server kv",
reports server_name:kv, has no extended-redis-compatibility directive, and
serves strings and lists.
2026-07-26 15:04:44 -07:00

4788 lines
183 KiB
Tcl

proc info_field {info field} {
foreach line [split $info "\n"] {
if {[string match "$field:*" $line]} {
return [string trim [lindex [split $line ":"] 1]]
}
}
return [s field_name]
}
proc get_keys_with_volatile_items {r} {
set line [$r info keyspace]
set match [regexp -inline {keys_with_volatile_items=([\d]+)} $line]
if {[llength $match] == 2} {
return [lindex $match 1]
} else {
return 0
}
}
proc get_keys {r} {
set line [$r info keyspace]
set match [regexp -inline {keys=([\d]+)} $line]
if {[llength $match] == 2} {
return [lindex $match 1]
} else {
return 0
}
}
proc check_myhash_and_expired_subkeys {r myhash expected_len initial_expired expected_increment} {
expr {
[$r HLEN $myhash] == $expected_len &&
[info_field [$r info stats] expired_fields] == ($initial_expired + $expected_increment)
}
}
proc get_short_expire_value {command} {
expr {
($command eq "HEXPIRE" || $command eq "EX") ? 1 :
($command eq "HPEXPIRE" || $command eq "PX") ? 1000 :
($command eq "HEXPIREAT" || $command eq "EXAT") ? [clock seconds] + 1 :
[clock milliseconds] + 1000
}
}
proc get_long_expire_value {command} {
expr {
($command eq "HEXPIRE" || $command eq "EX") ? 60000000 :
($command eq "HPEXPIRE" || $command eq "PX") ? 60000000 :
($command eq "HEXPIREAT" || $command eq "EXAT") ? [clock seconds] + 60000000 :
[clock milliseconds] + 60000000
}
}
proc get_longer_then_long_expire_value {command} {
expr {
($command eq "HEXPIRE" || $command eq "EX") ? 1200000000 :
($command eq "HPEXPIRE" || $command eq "PX") ? 1200000000 :
($command eq "HEXPIREAT" || $command eq "EXAT") ? [clock seconds] + 1200000000 :
[clock milliseconds] + 1200000000
}
}
proc get_past_zero_expire_value {command} {
expr {
($command eq "HEXPIRE" || $command eq "EX") ? 0 :
($command eq "HPEXPIRE" || $command eq "PX") ? 0 :
($command eq "HEXPIREAT" || $command eq "EXAT") ? [clock seconds] - 200000 :
[clock milliseconds] - 200000
}
}
proc get_check_ttl_command {command} {
if {$command eq "EX"} {
return "HTTL"
} elseif {$command eq "PX"} {
return "HPTTL"
} elseif {$command eq "EXAT"} {
return "HEXPIRETIME"
} else {
return "HPEXPIRETIME"
}
}
proc assert_keyevent_patterns {rd key args} {
foreach event_type $args {
set event [$rd read]
assert_match "pmessage __keyevent@* __keyevent@*:$event_type $key" $event
}
}
proc setup_replication_test {primary replica primary_host primary_port} {
$primary FLUSHALL
$replica replicaof $primary_host $primary_port
wait_for_condition 50 100 {
[lindex [$replica role] 0] eq {slave} &&
[string match {*master_link_status:up*} [$replica info replication]]
} else {
fail "Can't turn the instance into a replica"
}
set primary_initial_expired [info_field [$primary info stats] expired_fields]
set replica_initial_expired [info_field [$replica info stats] expired_fields]
return [list $primary_initial_expired $replica_initial_expired]
}
proc setup_single_keyspace_notification {r} {
$r config set notify-keyspace-events KEA
set rd [kv_deferring_client]
assert_equal {1} [psubscribe $rd __keyevent@*]
return $rd
}
proc wait_for_active_expiry {r key expected_len initial_expired expected_increment {timeout 100} {interval 100}} {
wait_for_condition $timeout $interval {
[check_myhash_and_expired_subkeys $r $key $expected_len $initial_expired $expected_increment]
} else {
set expired_fields [info_field [$r info stats] expired_fields]
set expected_expired [expr {$initial_expired + $expected_increment}]
fail "Active expiry did not occur as expected expected: $expected_expired ststs: $expired_fields"
}
}
start_server {tags {"hashexpire"}} {
####### Valid scenarios tests #######
foreach command {EX PX EXAT PXAT} {
test "HGETEX $command expiry" {
r FLUSHALL
r DEBUG SET-ACTIVE-EXPIRE 0
r HSET myhash f1 v1
set ttl_cmd [get_check_ttl_command $command]
set expire_time [get_long_expire_value $command]
# Verify HGETEX command
assert_equal "v1" [r HGETEX myhash $command $expire_time FIELDS 1 f1]
set expire_result [r $ttl_cmd myhash FIELDS 1 f1]
# Verify expiry
if {[regexp "AT$" $command]} {
assert_equal $expire_result $expire_time
} else {
assert_morethan $expire_result 0
}
# Re-enable active expiry
r DEBUG SET-ACTIVE-EXPIRE 1
} {OK} {needs:debug}
test "HGETEX $command with mix of existing and non-existing fields" {
r FLUSHALL
r HSET myhash f1 v1 f3 v3
# HGETEX on exist/non-exist fields
assert_equal "v1 {} v3" [r HGETEX myhash $command [get_long_expire_value $command] FIELDS 3 f1 f2 f3]
# Verification checks (f2 should not be created)
assert_equal "" [r HGET myhash f2]
assert_equal -2 [r HTTL myhash FIELDS 1 f2]
assert_morethan [r HTTL myhash FIELDS 1 f1] 0
assert_morethan [r HTTL myhash FIELDS 1 f3] 0
}
test "HGETEX $command on more then 1 field" {
r FLUSHALL
r DEBUG SET-ACTIVE-EXPIRE 0
r HSET myhash f1 v1 f2 v2
set ttl_cmd [get_check_ttl_command $command]
set expire_time [get_long_expire_value $command]
assert_equal "v1 v2" [r HGETEX myhash $command $expire_time FIELDS 2 f1 f2]
# Verify expiration
if {[regexp "AT$" $command]} {
assert_equal $expire_time [r $ttl_cmd myhash FIELDS 1 f1]
assert_equal $expire_time [r $ttl_cmd myhash FIELDS 1 f2]
} else {
assert_morethan [r $ttl_cmd myhash FIELDS 1 f1] 0
assert_morethan [r $ttl_cmd myhash FIELDS 1 f2] 0
}
# Re-enable active expiry
r DEBUG SET-ACTIVE-EXPIRE 1
} {OK} {needs:debug}
test "HGETEX $command -> PERSIST" {
r FLUSHALL
r HSET myhash f1 v1
r HSETEX myhash EX 10000 FIELDS 1 f2 v2
set ttl_cmd [get_check_ttl_command $command]
set expire_time [get_long_expire_value $command]
assert_equal "v1" [r HGETEX myhash $command $expire_time FIELDS 1 f1]
if {[regexp "AT$" $command]} {
assert_equal $expire_time [r $ttl_cmd myhash FIELDS 1 f1]
} else {
assert_morethan [r $ttl_cmd myhash FIELDS 1 f1] 0
}
assert_equal "v1" [r HGETEX myhash PERSIST FIELDS 1 f1]
assert_equal -1 [r HTTL myhash FIELDS 1 f1]
# Verify f2 still has ttl
assert_morethan [r HTTL myhash FIELDS 1 f2] 100
}
test "HGETEX $command on non-exist field" {
r FLUSHALL
r HSET myhash f1 v1
assert_equal {{}} [r HGETEX myhash $command [get_short_expire_value $command] FIELDS 1 f2]
}
test "HGETEX $command on non-exist key" {
r FLUSHALL
assert_equal {{} {} {}} [r HGETEX myhash $command [get_long_expire_value $command] FIELDS 3 f1 f2 f3]
}
test "HGETEX $command with duplicate field names" {
r FLUSHALL
r HSET myhash f1 v1
assert_equal "v1 v1" [r HGETEX myhash $command [get_long_expire_value $command] FIELDS 2 f1 f1]
}
test "HGETEX $command overwrites existing field TTL with bigger value" {
r FLUSHALL
r HSETEX myhash $command [get_long_expire_value $command] FIELDS 1 f1 v1
set old_ttl [r HTTL myhash FIELDS 1 f1]
r HGETEX myhash $command [get_longer_then_long_expire_value $command] FIELDS 1 f1
set new_ttl [r HTTL myhash FIELDS 1 f1]
assert {$new_ttl > $old_ttl}
}
test "HGETEX $command overwrites existing field TTL with smaller value" {
r FLUSHALL
r HSETEX myhash $command [get_long_expire_value $command] FIELDS 1 f1 v1
set old_ttl [r HTTL myhash FIELDS 1 f1]
r HGETEX myhash $command [get_short_expire_value $command] FIELDS 1 f1
set new_ttl [r HTTL myhash FIELDS 1 f1]
assert {$new_ttl <= $old_ttl}
}
}
foreach command {EX PX EXAT PXAT} {
test "HGETEX $command overwrites existing field TTL with bigger value" {
r FLUSHALL
set config [dict create \
EX [list setup_cmd EX setup_val 100000 bigger_val 200000] \
PX [list setup_cmd PX setup_val 100000000 bigger_val 200000000] \
EXAT [list setup_cmd EX setup_val 100000 bigger_val [expr {[clock seconds] + 200000}]] \
PXAT [list setup_cmd PX setup_val 100000000 bigger_val [expr {[clock milliseconds] + 200000000}]] \
]
set params [dict get $config $command]
set setup_cmd [dict get $params setup_cmd]
set setup_val [dict get $params setup_val]
set bigger_val [dict get $params bigger_val]
r HSETEX myhash $setup_cmd $setup_val FIELDS 1 f1 v1
set old_ttl [r HTTL myhash FIELDS 1 f1]
r HGETEX myhash $command $bigger_val FIELDS 1 f1
set new_ttl [r HTTL myhash FIELDS 1 f1]
assert {$new_ttl > $old_ttl}
}
test "HGETEX $command overwrites existing field TTL with smaller value" {
r FLUSHALL
set config [dict create \
EX [list setup_cmd EX setup_val 100000 smaller_val 50000] \
PX [list setup_cmd PX setup_val 100000000 smaller_val 50000000] \
EXAT [list setup_cmd EX setup_val 100000 smaller_val [expr {[clock seconds] + 50000}]] \
PXAT [list setup_cmd PX setup_val 100000000 smaller_val [expr {[clock milliseconds] + 50000000}]] \
]
set params [dict get $config $command]
set setup_cmd [dict get $params setup_cmd]
set setup_val [dict get $params setup_val]
set smaller_val [dict get $params smaller_val]
r HSETEX myhash $setup_cmd $setup_val FIELDS 1 f1 v1
set old_ttl [r HTTL myhash FIELDS 1 f1]
r HGETEX myhash $command $smaller_val FIELDS 1 f1
set new_ttl [r HTTL myhash FIELDS 1 f1]
assert {$new_ttl <= $old_ttl}
}
}
test {HGETEX - verify no change when field does not exist} {
r FLUSHALL
r HSET myhash f1 v1
set mem_before [r MEMORY USAGE myhash]
assert_equal {{}} [r HGETEX myhash EX 1 FIELDS 1 f2]
set memory_after [r MEMORY USAGE myhash]
assert_equal $mem_before $memory_after
}
####### Invalid scenarios tests #######
test {HGETEX EX- multiple options used (EX + PX)} {
r FLUSHALL
r HSET myhash f1 v1
assert_error "ERR*" {r HGETEX myhash EX 60 PX 1000 FIELDS 1 f1}
}
test {HGETEX EXAT- multiple options used (EXAT + PXAT)} {
r FLUSHALL
r HSET myhash f1 v1
assert_error "ERR*" {r HGETEX myhash EXAT [expr {[clock seconds] + 100}] PXAT [expr {[clock milliseconds] + 100000}] 1000 FIELDS 1 f1}
}
# Common error scenarios for all commands
foreach cmd {EX PX EXAT PXAT} {
test "HGETEX $cmd- missing TTL value" {
r FLUSHALL
r HSET myhash f1 v1
catch {r HGETEX myhash $cmd FIELDS 1 f1} e
set e
} {ERR *}
test "HGETEX $cmd- negative TTL" {
r FLUSHALL
r HSET myhash f1 v1
catch {r HGETEX myhash $cmd -10 FIELDS 1 f1} e
set e
} {ERR invalid expire time in 'hgetex' command}
test "HGETEX $cmd- non-integer TTL" {
r FLUSHALL
r HSET myhash f1 v1
catch {r HGETEX myhash $cmd abc FIELDS 1 f1} e
set e
} {ERR value is not an integer or out of range}
test "HGETEX $cmd- missing FIELDS keyword" {
r FLUSHALL
r HSET myhash f1 v1
catch {r HGETEX myhash $cmd [get_short_expire_value $cmd] 1 f1} e
set e
} {ERR *}
test "HGETEX $cmd- wrong numfields count (too few fields)" {
r FLUSHALL
r HSET myhash f1 v1 f2 v2
catch {r HGETEX myhash $cmd [get_short_expire_value $cmd] FIELDS 2 f1} e
set e
} {ERR *}
test "HGETEX $cmd- wrong numfields count (too many fields)" {
r FLUSHALL
r HSET myhash f1 v1
catch {r HGETEX myhash $cmd [get_short_expire_value $cmd] FIELDS 1 f1 f2} e
set e
} {ERR *}
test "HGETEX $cmd- key is wrong type (string instead of hash)" {
r FLUSHALL
r SET mystring "v1"
catch {r HGETEX mystring $cmd [get_short_expire_value $cmd] FIELDS 1 f1} e
set e
} {WRONGTYPE Operation against a key holding the wrong kind of value}
test "HGETEX $cmd with FIELDS 0" {
r FLUSHALL
catch {r HGETEX myhash $cmd [get_short_expire_value $cmd] FIELDS 0} e
set e
} {ERR *}
test "HGETEX $cmd with negative numfields" {
r FLUSHALL
catch {r HGETEX myhash $cmd [get_short_expire_value $cmd] FIELDS -10} e
set e
} {ERR *}
test "HGETEX $cmd with missing key" {
r FLUSHALL
catch {r HGETEX $cmd [get_short_expire_value $cmd] FIELDS 1 f1} e
set e
} {ERR *}
}
}
start_server {tags {"hashexpire"}} {
if {$::singledb} {
set db 0
} else {
set db 9
}
set all_h_pattern "h*"
set hexpire_pattern "hexpire"
set hpersist_pattern "hpersist"
r config set notify-keyspace-events KEA
## HGETEX -> Keyspace notification tests ####
foreach command {EX PX EXAT PXAT} {
test "HGETEX $command generates hexpire keyspace notification" {
r FLUSHALL
r HSET myhash f1 v1
assert_equal 0 [get_keys_with_volatile_items r]
set rd [setup_single_keyspace_notification r]
r HGETEX myhash $command [get_long_expire_value $command] FIELDS 1 f1
assert_keyevent_patterns $rd myhash hexpire
assert_equal 1 [get_keys_with_volatile_items r]
$rd close
}
test "HGETEX $command with multiple fields generates single notification" {
r FLUSHALL
r HSET myhash f1 v1 f2 v2 f3 v3
assert_equal 0 [get_keys_with_volatile_items r]
set rd [setup_single_keyspace_notification r]
r HGETEX myhash $command [get_long_expire_value $command] FIELDS 3 f1 f2 f3
assert_keyevent_patterns $rd myhash hexpire
# Verify no notification (getting hset and not hexpire)
r HSET dummy dummy dummy
assert_keyevent_patterns $rd dummy hset
assert_equal 1 [get_keys_with_volatile_items r]
$rd close
}
test "HGETEX $command on non-existent field generates no notification" {
r FLUSHALL
r HSET myhash f1 v1
assert_equal 0 [get_keys_with_volatile_items r]
set rd [setup_single_keyspace_notification r]
# This HGETEX targets a non-existent field, so no notification about hexpire should be emitted
r HGETEX myhash $command [get_long_expire_value $command] FIELDS 1 f2
# Verify no notification (getting hset and not hexpire)
r HSET dummy dummy dummy
assert_keyevent_patterns $rd dummy hset
assert_equal 0 [get_keys_with_volatile_items r]
$rd close
}
}
test {HGETEX PERSIST generates hpersist keyspace notification} {
r FLUSHALL
r HSET myhash f1 v1
assert_equal 0 [get_keys_with_volatile_items r]
r HEXPIRE myhash [get_long_expire_value HEXPIRE] FIELDS 1 f1
assert_equal 1 [get_keys_with_volatile_items r]
set rd [setup_single_keyspace_notification r]
r HGETEX myhash PERSIST FIELDS 1 f1
assert_keyevent_patterns $rd myhash hpersist
assert_equal 0 [get_keys_with_volatile_items r]
$rd close
}
foreach command {EX PX EXAT PXAT} {
test "HGETEX $command 0/past time works correctly with 1 field" {
r FLUSHALL
r config resetstat
# Create hash with field
r HSET myhash f1 v1
assert_equal 1 [r HLEN myhash]
assert_equal 0 [get_keys_with_volatile_items r]
assert_equal 1 [get_keys r]
set rd [setup_single_keyspace_notification r]
# Set field to expire immediately
r HGETEX myhash $command [get_past_zero_expire_value $command] FIELDS 1 f1
# Verify field and keys are deleted
assert_keyevent_patterns $rd myhash hexpired del
assert_equal -2 [r HTTL myhash FIELDS 1 f1]
assert_equal 0 [r HLEN myhash]
assert_equal 0 [r EXISTS myhash]
assert_equal 0 [get_keys r]
assert_equal 0 [get_keys_with_volatile_items r]
assert_equal 1 [info_field [r info stats] expired_fields]
$rd close
}
}
# HSETEX ####
test {HSETEX KEEPTTL - preserves existing TTL of field} {
r FLUSHALL
# Set a field with a known TTL
r HSETEX myhash PX 1000 FIELDS 1 field1 val1
set original_pttl [r HPTTL myhash FIELDS 1 field1]
set original_expiretime [r HEXPIRETIME myhash FIELDS 1 field1]
assert_equal 1 [get_keys_with_volatile_items r]
# Validate TTL is active and expiretime is in the future
assert {$original_pttl > 0}
assert {$original_expiretime > [clock seconds]}
# Overwrite the field with KEEPTTL
r HSETEX myhash KEEPTTL FIELDS 1 field1 newval
# Ensure TTL is preserved
set updated_pttl [r HPTTL myhash FIELDS 1 field1]
set updated_expiretime [r HEXPIRETIME myhash FIELDS 1 field1]
assert {$updated_pttl > 0}
assert {$updated_pttl <= $original_pttl}
assert_equal $original_expiretime $updated_expiretime
# Ensure value was updated
assert_equal newval [r HGET myhash field1]
}
test {HSETEX EX - FIELDS 0 returns error} {
r FLUSHALL
catch {r HSETEX myhash EX 10 FIELDS 0} e
set e
} {ERR *}
test {HSETEX EX - test negative ttl} {
set ttl -10
catch {r HSETEX myhash EX $ttl FIELDS 1 field1 val1} e
set e
} {ERR invalid expire time in 'hsetex' command}
test {HSETEX EX - test non-numeric ttl} {
set ttl abc
catch {r HSETEX myhash EX $ttl FIELDS 1 field1 val1} e
set e
} {ERR value is not an integer or out of range}
test {HSETEX EX - overwrite field resets TTL} {
r FLUSHALL
r HSETEX myhash EX 100 FIELDS 1 field1 val1
r HSETEX myhash EX 200 FIELDS 1 field1 newval
assert_equal 200 [r HTTL myhash FIELDS 1 field1]
assert_equal newval [r HGET myhash field1]
}
test {HSETEX EX - test mix of expiring and persistent fields} {
r FLUSHALL
r HSET myhash field2 "persistent"
r HSETEX myhash EX 1 FIELDS 1 field1 "temp"
assert_equal 1 [get_keys_with_volatile_items r]
after 1100
assert_equal 0 [r HEXISTS myhash field1]
assert_equal 1 [r HEXISTS myhash field2]
}
test {HSETEX EX - test missing TTL} {
catch {r HSETEX myhash EX FIELDS 1 field1 val1} e
set e
} {ERR *}
test {HSETEX EX - mismatched field/value count} {
catch {r HSETEX myhash EX 10 FIELDS 2 field1 val1} e
set e
} {ERR *}
foreach command {EX PX EXAT PXAT} {
test "HSETEX $command 0/past time works correctly with 2 fields" {
r FLUSHALL
r config resetstat
# Create hash with field
r HSET myhash f1 v1
assert_equal 1 [r HLEN myhash]
assert_equal 0 [get_keys_with_volatile_items r]
assert_equal 1 [get_keys r]
set rd [setup_single_keyspace_notification r]
# Set field to expire immediately
assert_equal {1} [r HSETEX myhash $command [get_past_zero_expire_value $command] FIELDS 2 f1 v1 f2 v2]
# Verify field and keys are deleted
assert_keyevent_patterns $rd myhash hset hexpire hexpired del
assert_equal -2 [r HTTL myhash FIELDS 1 f1]
assert_equal 0 [r HLEN myhash]
assert_equal 0 [r EXISTS myhash]
assert_equal 0 [get_keys r]
assert_equal 0 [get_keys_with_volatile_items r]
assert_equal 2 [info_field [r info stats] expired_fields]
$rd close
}
}
###### PX #######
test {HSETEX PX - test negative ttl} {
set ttl -50
catch {r HSETEX myhash PX $ttl FIELDS 1 field1 val1} e
set e
} {ERR invalid expire time in 'hsetex' command}
test {HSETEX PX - test non-numeric ttl} {
set ttl xyz
catch {r HSETEX myhash PX $ttl FIELDS 1 field1 val1} e
set e
} {ERR value is not an integer or out of range}
test {HSETEX PX - overwrite field resets TTL} {
r FLUSHALL
r HSETEX myhash PX 10000 FIELDS 1 field1 val1
r HSETEX myhash PX 20000 FIELDS 1 field1 newval
set ttl [r HPTTL myhash FIELDS 1 field1]
assert {$ttl >= 19000 && $ttl <= 20000}
assert_equal newval [r HGET myhash field1]
assert_equal 1 [get_keys_with_volatile_items r]
}
test {HSETEX PX - test zero ttl expires immediately} {
r FLUSHALL
r HSETEX myhash PX 0 FIELDS 1 field1 val1
after 10
assert_equal 0 [r HEXISTS myhash field1]
# The hash should also not exist
assert_equal 0 [r EXISTS myhash]
assert_equal 0 [r HLEN myhash]
}
test {HSETEX PX - test mix of expiring and persistent fields} {
r FLUSHALL
r HSET myhash field2 "persistent"
r HSETEX myhash PX 10 FIELDS 1 field1 "temp"
after 20
assert_equal 0 [r HEXISTS myhash field1]
assert_equal 1 [r HEXISTS myhash field2]
}
test {HSETEX PX - test missing TTL} {
catch {r HSETEX myhash PX FIELDS 1 field1 val1} e
set e
} {ERR *}
test {HSETEX PX - mismatched field/value count} {
assert_error {ERR numfields should be greater than 0 and match the provided number of fields} {r HSETEX myhash PX 100 FIELDS 1 field1 val1 extra}
}
## NX/XX key-level tests
test {HSETEX NX - non-existing key creates the key} {
r FLUSHALL
set res [r HSETEX myhash NX FIELDS 2 f1 v1 f2 v2]
assert_equal 1 $res
assert_equal v1 [r HGET myhash f1]
assert_equal v2 [r HGET myhash f2]
}
test {HSETEX NX - existing key blocked} {
r FLUSHALL
r HSET myhash f1 v1
set res [r HSETEX myhash NX FIELDS 2 f1 new1 f2 new2]
assert_equal 0 $res
assert_equal v1 [r HGET myhash f1]
assert_equal 0 [r HEXISTS myhash f2]
}
test {HSETEX XX - existing key updates fields} {
r FLUSHALL
r HSET myhash f1 v1 f2 v2
set res [r HSETEX myhash XX FIELDS 2 f1 new1 f2 new2]
assert_equal 1 $res
assert_equal new1 [r HGET myhash f1]
assert_equal new2 [r HGET myhash f2]
}
test {HSETEX XX - non-existing key blocked} {
r FLUSHALL
set res [r HSETEX myhash XX FIELDS 2 f1 v1 f2 v2]
assert_equal 0 $res
assert_equal 0 [r EXISTS myhash]
assert_equal 0 [r HEXISTS myhash f1]
assert_equal 0 [r HEXISTS myhash f2]
}
## FNX/FXX
# hsetex throws ERR *, it shouldn't
test {HSETEX EX FNX - set only if none of the fields exist} {
r FLUSHALL
r HSET myhash field1 val1
set res [r HSETEX myhash EX 10 FNX FIELDS 1 field1 val2]
assert_equal 0 $res
assert_equal val1 [r HGET myhash field1]
# Now try with all-new fields
set res [r HSETEX myhash EX 10 FNX FIELDS 2 f2 v2 f3 v3]
assert_equal 1 $res
assert_equal v2 [r HGET myhash f2]
assert_equal v3 [r HGET myhash f3]
}
test {HSETEX EX FXX - set only if all fields exist} {
r FLUSHALL
r HSET myhash field1 val1 field2 val2
set res [r HSETEX myhash EX 10 FXX FIELDS 2 field1 new1 field2 new2]
assert_equal 1 $res
assert_equal new1 [r HGET myhash field1]
assert_equal new2 [r HGET myhash field2]
# Now try when one field doesn't exist
set res [r HSETEX myhash EX 10 FXX FIELDS 2 field1 x fieldX y]
assert_equal 0 $res
assert_equal new1 [r HGET myhash field1]
assert_equal 0 [r HEXISTS myhash fieldX]
}
# Syntax error: HSETEX myhash PX 100 FNX FIELDS 2 x 2 y 3
test {HSETEX PX FNX - partial conflict returns 0} {
r FLUSHALL
r HSET myhash x 1
set res [r HSETEX myhash PX 100 FNX FIELDS 2 x 2 y 3]
assert_equal 0 $res
assert_equal 1 [r HEXISTS myhash x]
assert_equal 0 [r HEXISTS myhash y]
}
test {HSETEX PX FXX - one field missing returns 0} {
r FLUSHALL
r HSET myhash a 1
set res [r HSETEX myhash PX 100 FXX FIELDS 2 a 2 b 3]
assert_equal 0 $res
assert_equal 1 [r HGET myhash a]
assert_equal 0 [r HEXISTS myhash b]
}
test {HSETEX EX - FNX and FXX conflict error} {
catch {r HSETEX myhash EX 10 FNX FXX FIELDS 1 x y} e
set e
} {ERR *}
test {HSETEX EX - FXX does not create object in case key does not exist} {
r FLUSHALL
assert_equal 0 [r HSETEX myhash EX 10 FXX FIELDS 1 x y]
assert_equal 0 [r EXISTS myhash]
}
## NX/XX + FNX/FXX combinations
# NX + FNX — only set if key does not exist AND fields do not exist
test {HSETEX EX NX FNX - set only if key missing and fields missing} {
r FLUSHALL
set res [r HSETEX myhash EX 10 NX FNX FIELDS 2 f1 v1 f2 v2]
assert_equal 1 $res
assert_equal v1 [r HGET myhash f1]
assert_equal v2 [r HGET myhash f2]
# Try again — key exists now, should block
set res [r HSETEX myhash EX 10 NX FNX FIELDS 2 f3 v3 f4 v4]
assert_equal 0 $res
assert_equal 0 [r HEXISTS myhash f3]
assert_equal 0 [r HEXISTS myhash f4]
}
# NX + FXX — only set if key does not exist AND all fields exist (key missing → blocked)
test {HSETEX EX NX FXX - key missing blocks all} {
r FLUSHALL
set res [r HSETEX myhash EX 10 NX FXX FIELDS 2 f1 v1 f2 v2]
assert_equal 0 $res
assert_equal 0 [r EXISTS myhash]
assert_equal 0 [r HEXISTS myhash f1]
assert_equal 0 [r HEXISTS myhash f2]
}
# XX + FNX — only set if key exists AND none of the fields exist
test {HSETEX EX XX FNX - set only if key exists and fields missing} {
r FLUSHALL
r HSET myhash f1 old1
set res [r HSETEX myhash EX 10 XX FNX FIELDS 2 f2 v2 f3 v3]
assert_equal 1 $res
assert_equal v2 [r HGET myhash f2]
assert_equal v3 [r HGET myhash f3]
# Try again — fields already exist → should block
set res [r HSETEX myhash EX 10 XX FNX FIELDS 2 f2 x f4 y]
assert_equal 0 $res
assert_equal v2 [r HGET myhash f2]
assert_equal 0 [r HEXISTS myhash f4]
}
# XX + FXX — only set if key exists AND all fields exist
test {HSETEX EX XX FXX - set only if key exists and all fields exist} {
r FLUSHALL
r HSET myhash f1 old1 f2 old2
set res [r HSETEX myhash EX 10 XX FXX FIELDS 2 f1 new1 f2 new2]
assert_equal 1 $res
assert_equal new1 [r HGET myhash f1]
assert_equal new2 [r HGET myhash f2]
# Try when one field is missing → should block
set res [r HSETEX myhash EX 10 XX FXX FIELDS 2 f1 x f3 y]
assert_equal 0 $res
assert_equal new1 [r HGET myhash f1]
assert_equal 0 [r HEXISTS myhash f3]
}
test {HSETEX is not replicating validation arguments} {
r flushall
set repl [attach_to_replication_stream]
set exp [get_longer_then_long_expire_value PXAT]
r HSETEX myhash NX PXAT $exp FIELDS 1 f1 v1
r HSETEX myhash XX PXAT $exp FIELDS 1 f1 v1
r HSETEX myhash FNX PXAT $exp FIELDS 1 f2 v2
r HSETEX myhash FXX PXAT $exp FIELDS 1 f2 v2
r HSETEX myhash2 nx PXAT $exp FIELDS 1 f1 v1
r HSETEX myhash2 xx PXAT $exp FIELDS 1 f1 v1
r HSETEX myhash2 fnx PXAT $exp FIELDS 1 f2 v2
r HSETEX myhash2 fxx PXAT $exp FIELDS 1 f2 v2
assert_replication_stream $repl [subst {
{select *}
{hsetex myhash PXAT $exp FIELDS 1 f1 v1}
{hsetex myhash PXAT $exp FIELDS 1 f1 v1}
{hsetex myhash PXAT $exp FIELDS 1 f2 v2}
{hsetex myhash PXAT $exp FIELDS 1 f2 v2}
{hsetex myhash2 PXAT $exp FIELDS 1 f1 v1}
{hsetex myhash2 PXAT $exp FIELDS 1 f1 v1}
{hsetex myhash2 PXAT $exp FIELDS 1 f2 v2}
{hsetex myhash2 PXAT $exp FIELDS 1 f2 v2}
}]
close_replication_stream $repl
}
###### Test EXPIRE #############
# Basic Expiry Functionality
test {HEXPIRE - set TTL on existing field} {
r FLUSHALL
r HSET myhash field1 hello
r HEXPIRE myhash 10 FIELDS 1 field1
set ttl [r HTTL myhash FIELDS 1 field1]
assert {$ttl > 0}
}
test {HEXPIRE - TTL 0 deletes field} {
r FLUSHALL
r HSET myhash field1 goodbye
set res [r HEXPIRE myhash 0 FIELDS 1 field1]
assert_equal {2} $res
assert_equal 0 [r HEXISTS myhash field1]
}
test {HEXPIRE - negative TTL returns error} {
r FLUSHALL
r HSET myhash field1 val
catch {r HEXPIRE myhash -5 FIELDS 1 field1} e
set e
} {ERR invalid expire time in 'hexpire' command}
test {HEXPIRE - wrong type key returns error} {
r FLUSHALL
r SET myhash notahash
catch {r HEXPIRE myhash 10 FIELDS 1 field1} e
set e
} {WRONGTYPE Operation against a key holding the wrong kind of value}
# Conditionals: NX
test {HEXPIRE NX - only set when field has no TTL} {
r FLUSHALL
r HSETEX myhash PX 100 FIELDS 1 field1 val
set res [r HEXPIRE myhash 10 NX FIELDS 1 field1]
assert_equal {0} $res
r HSET myhash field2 val2
set res2 [r HEXPIRE myhash 10 NX FIELDS 1 field2]
assert_equal {1} $res2
}
# Conditionals: XX
test {HEXPIRE XX - only set when field has TTL} {
r FLUSHALL
r HSET myhash field1 val1 field2 val2
r HEXPIRE myhash 20 FIELDS 1 field1
set res [r HEXPIRE myhash 30 XX FIELDS 2 field1 field2]
assert_equal {1 0} $res
}
# Conditionals: GT
test {HEXPIRE GT - only set if new TTL > existing TTL} {
r FLUSHALL
r HSETEX myhash EX 300 FIELDS 1 field1 val1
after 10
set res [r HEXPIRE myhash 600 GT FIELDS 1 field1] ;# 600s > 300s remaining
assert_equal {1} $res
# GT should fail if field is persistent
r HSET myhash field2 val2
set res2 [r HEXPIRE myhash 1 GT FIELDS 1 field2]
assert_equal {0} $res2
}
test {HEXPIRE GT - Do not expire items when expiration in the past} {
r FLUSHALL
r HSETEX myhash EX 600 FIELDS 1 field1 val1
assert_equal {1} [r HLEN myhash]
assert_equal {0 -2} [r HEXPIRE myhash 0 GT FIELDS 2 field1 field2]
assert_equal {1} [r HLEN myhash]
assert_equal {0 -2} [r HEXPIRE myhash 0 NX FIELDS 2 field1 field2]
assert_equal {1} [r HLEN myhash]
r HSET myhash field1 val1
assert_equal {0 -2} [r HEXPIRE myhash 0 XX FIELDS 2 field1 field2]
assert_equal {1} [r HLEN myhash]
}
# Conditionals: LT
test {HEXPIRE LT - only set if new TTL < existing TTL} {
r FLUSHALL
r HSETEX myhash EX 600 FIELDS 1 field1 val1
set res [r HEXPIRE myhash 1 LT FIELDS 1 field1]
assert_equal {1} $res
## TODO this is an expected behavior really? what does non existintg ttl mean?
r HSET myhash field2 val2
set res2 [r HEXPIRE myhash 1 LT FIELDS 1 field2]
assert_equal {1} $res2
}
# TTL Refresh
test {HEXPIRE - refresh TTL with new value} {
r FLUSHALL
r HSET myhash field1 val1
r HEXPIRE myhash 1 FIELDS 1 field1
after 500
r HEXPIRE myhash 3 FIELDS 1 field1
set ttl [r HTTL myhash FIELDS 1 field1]
assert {$ttl >= 2}
}
# HEXPIRE on a non-existent field
test {HEXPIRE on a non-existent field (should not create field)} {
r FLUSHALL
r HSET myhash f1 v1
r HEXPIRE myhash 1000 FIELDS 1 f2
assert_equal 0 [r HEXISTS myhash f2]
assert_equal -2 [r HTTL myhash FIELDS 1 f2]
}
# HEXPIRE on a non-existent field
test {HEXPIRE on a non-existent field (should not issue notifications)} {
r FLUSHALL
r HSET myhash f1 v1
set rd [setup_single_keyspace_notification r]
r HEXPIRE myhash 1000 FIELDS 1 f2
r HEXPIRE myhash 0 FIELDS 1 f2
# Verify no notification (getting hset and not hexpire)
r HSET dummy dummy dummy
assert_keyevent_patterns $rd dummy hset
assert_equal 0 [get_keys_with_volatile_items r]
$rd close
}
# Error Cases
test {HEXPIRE - conflicting conditions error} {
r FLUSHALL
r HSET myhash field1 val
catch {r HEXPIRE myhash 10 NX XX FIELDS 1 field1} e
set e
} {ERR NX and XX, GT or LT options at the same time are not compatible}
test {HEXPIRE - missing FIELDS error} {
r FLUSHALL
r HSET myhash field1 val
catch {r HEXPIRE myhash 10} e
set e
} {ERR wrong number of arguments for 'hexpire' command}
test {HEXPIRE - no fields after FIELDS keyword} {
r FLUSHALL
r HSET myhash field1 val
catch {r HEXPIRE myhash 10 FIELDS 0} e
set e
} {ERR wrong number of arguments for 'hexpire' command}
test {HEXPIRE - non-integer TTL error} {
r FLUSHALL
r HSET myhash field1 val
catch {r HEXPIRE myhash abc FIELDS 1 field1} e
set e
} {ERR value is not an integer or out of range}
test {HEXPIRE - non-existing key returns -2} {
r FLUSHALL
set res [r HEXPIRE nokey 10 FIELDS 1 field1]
assert_equal {-2} $res
}
test {HEXPIRE EX - set TTL on multiple fields} {
r FLUSHALL
r HSET myhash fieldA valA fieldB valB
set ttl 100
r HEXPIRE myhash $ttl FIELDS 2 fieldA fieldB
set ttlA [r HTTL myhash FIELDS 1 fieldA]
set ttlB [r HTTL myhash FIELDS 1 fieldB]
assert { $ttlA > 0 && $ttlA <= $ttl }
assert { $ttlB > 0 && $ttlB <= $ttl }
} {}
test {HEXPIRE returns -2 on non-existing key} {
r FLUSHALL
assert_equal {-2 -2} [r HEXPIRE nokey 10 FIELDS 2 field1 field2]
} {}
test {HEXPIRE - GT condition fails when field has no TTL} {
r FLUSHALL
r HSET myhash f1 v1
assert_equal 0 [r HEXPIRE myhash 10 GT fields 1 f1]
}
test {HEXPIRE - LT condition succeeds when field has no TTL} {
r FLUSHALL
r HSET myhash f1 v1
assert_equal 1 [r HEXPIRE myhash 10 LT fields 1 f1]
}
foreach command {HEXPIRE HPEXPIRE HEXPIREAT HPEXPIREAT} {
test "HSETEX $command 0/past time works correctly with 1 field" {
r FLUSHALL
r config resetstat
# Create hash with field
r HSET myhash f1 v1
assert_equal 1 [r HLEN myhash]
assert_equal 0 [get_keys_with_volatile_items r]
assert_equal 1 [get_keys r]
set rd [setup_single_keyspace_notification r]
# Set field to expire immediately
assert_equal {2} [r $command myhash [get_past_zero_expire_value $command] FIELDS 1 f1]
# Verify field and keys are deleted
assert_keyevent_patterns $rd myhash hexpired del
assert_equal -2 [r HTTL myhash FIELDS 1 f1]
assert_equal 0 [r HLEN myhash]
assert_equal 0 [r EXISTS myhash]
assert_equal 0 [get_keys r]
assert_equal 0 [get_keys_with_volatile_items r]
assert_equal 1 [info_field [r info stats] expired_fields]
$rd close
}
}
##### HTTL #####
test {HTTL - persistent field returns -1} {
r FLUSHALL
r HSET myhash field1 val1
assert_equal -1 [r HTTL myhash FIELDS 1 field1]
} {}
test {HTTL - non-existent field returns -2} {
r FLUSHALL
r HSET myhash field1 val1
assert_equal -2 [r HTTL myhash FIELDS 1 nofield]
} {}
test {HTTL - non-existent key returns -2} {
r FLUSHALL
assert_equal -2 [r HTTL nokey FIELDS 1 field1]
} {}
##### EXPIRETIME ######
# Basic Expiry Functionality
test {HEXPIREAT - set absolute expiry on field} {
r FLUSHALL
r HSET myhash field1 hello
set now [clock seconds]
set exp [expr {$now + 30}]
r HEXPIREAT myhash $exp FIELDS 1 field1
set etime [r HEXPIRETIME myhash FIELDS 1 field1]
assert_equal $exp $etime
}
test {HEXPIREAT - timestamp in past deletes field immediately} {
r FLUSHALL
r HSET myhash field1 gone
set past [expr {[clock seconds] - 1000}]
set res [r HEXPIREAT myhash $past FIELDS 1 field1]
assert_equal {2} $res
assert_equal 0 [r HEXISTS myhash field1]
}
test {HEXPIREAT - set TTL on multiple fields (existing + non-existing)} {
r FLUSHALL
r HSET myhash field1 hello field2 world
set exp [expr {[clock seconds] + 10}]
set res [r HEXPIREAT myhash $exp FIELDS 3 field1 field2 fieldX]
assert_equal {1 1 -2} $res
}
# Conditionals: NX
test {HEXPIREAT NX - only set when field has no TTL} {
r FLUSHALL
r HSETEX myhash EX 100 FIELDS 1 field1 val
set exp [expr {[clock seconds] + 100}]
set res [r HEXPIREAT myhash $exp NX FIELDS 1 field1]
assert_equal {0} $res
r HSET myhash field2 val2
set res2 [r HEXPIREAT myhash $exp NX FIELDS 1 field2]
assert_equal {1} $res2
}
# Conditionals: XX
test {HEXPIREAT XX - only set when field has TTL} {
r FLUSHALL
r HSET myhash field1 val1 field2 val2
set exp1 [expr {[clock seconds] + 20}]
r HEXPIREAT myhash $exp1 FIELDS 1 field1
set exp2 [expr {[clock seconds] + 30}]
set res [r HEXPIREAT myhash $exp2 XX FIELDS 2 field1 field2]
assert_equal {1 0} $res
}
# Conditionals: GT
test {HEXPIREAT GT - only set if new expiry > existing} {
r FLUSHALL
r HSETEX myhash PX 5000 FIELDS 1 field1 val1
after 10
set now [clock seconds]
set future [expr {$now + 10}]
set res [r HEXPIREAT myhash $future GT FIELDS 1 field1]
assert_equal {1} $res
r HSET myhash field2 val2
set res2 [r HEXPIREAT myhash $future GT FIELDS 1 field2]
assert_equal {0} $res2
}
# Conditionals: LT
test {HEXPIREAT LT - only set if new expiry < existing} {
r FLUSHALL
set now [clock seconds]
# now + 20K seconds
set long_future_expiration [expr {$now + 20000}]
# now + 1K seconds
set short_future_expiration [expr {$now + 1000}]
r HSETEX myhash EX $long_future_expiration FIELDS 1 field1 val1
assert_equal {1} [r HEXPIREAT myhash $short_future_expiration LT FIELDS 1 field1]
r HSET myhash field2 val2
assert_equal {1} [r HEXPIREAT myhash $short_future_expiration LT FIELDS 1 field2]
# TODO is this the expected behavior? if no TTL exist, it should be treated as minimum ttl possible?
}
test {HEXPIREAT - refresh TTL with new future timestamp} {
r FLUSHALL
r HSET myhash field1 val1
# Set initial expiry to very near future
set ts1 [expr {[clock seconds] + 10}]
r HEXPIREAT myhash $ts1 FIELDS 1 field1
# Immediately refresh to a further expiry (no sleep needed)
set ts2 [expr {$ts1 + 5}]
r HEXPIREAT myhash $ts2 FIELDS 1 field1
# Confirm that expiry was updated
set actual [r HEXPIRETIME myhash FIELDS 1 field1]
assert_equal $ts2 $actual
}
# TTL Validations
test {HEXPIREAT - TTL is accurate via HEXPIRETIME} {
r FLUSHALL
r HSET myhash field1 val1
set ts [expr {[clock seconds] + 50}]
r HEXPIREAT myhash $ts FIELDS 1 field1
set returned [r HEXPIRETIME myhash FIELDS 1 field1]
assert_equal $ts $returned
}
# Error Cases
test {HEXPIREAT - conflicting options error} {
r FLUSHALL
r HSET myhash field1 val
set ts [expr {[clock seconds] + 5}]
catch {r HEXPIREAT myhash $ts NX XX FIELDS 1 field1} e
set e
} {ERR NX and XX, GT or LT options at the same time are not compatible}
test {HEXPIREAT - missing FIELDS keyword} {
r FLUSHALL
r HSET myhash field1 val
set ts [expr {[clock seconds] + 5}]
catch {r HEXPIREAT myhash $ts} e
set e
} {ERR wrong number of arguments for 'hexpireat' command}
test {HEXPIREAT - no fields after FIELDS} {
r FLUSHALL
r HSET myhash field1 val
set ts [expr {[clock seconds] + 5}]
catch {r HEXPIREAT myhash $ts FIELDS 0} e
set e
} {ERR wrong number of arguments for 'hexpireat' command}
test {HEXPIREAT - non-integer timestamp} {
r FLUSHALL
r HSET myhash field1 val
catch {r HEXPIREAT myhash tomorrow FIELDS 1 field1} e
set e
} {ERR value is not an integer or out of range}
test {HEXPIREAT - non-existing key returns -2} {
r FLUSHALL
set ts [expr {[clock seconds] + 5}]
set res [r HEXPIREAT nokey $ts FIELDS 1 field1]
assert_equal {-2} $res
}
#################### HEXPIRETIME ##################
# Basic TTL retrieval
test {HEXPIRETIME - returns expiry timestamp for single field with TTL} {
r FLUSHALL
r HSET myhash field1 val
set ts [expr {[clock seconds] + 3}]
r HEXPIREAT myhash $ts FIELDS 1 field1
set out [r HEXPIRETIME myhash FIELDS 1 field1]
assert_equal $ts $out
}
# No expiration set
test {HEXPIRETIME - field has no TTL returns -1} {
r FLUSHALL
r HSET myhash field1 val
set out [r HEXPIRETIME myhash FIELDS 1 field1]
assert_equal -1 $out
}
# Non-existent field
test {HEXPIRETIME - field does not exist returns -2} {
r FLUSHALL
r HSET myhash field1 val
set out [r HEXPIRETIME myhash FIELDS 1 fieldX]
assert_equal -2 $out
}
# Non-existent key
test {HEXPIRETIME - key does not exist returns -2} {
r FLUSHALL
set out [r HEXPIRETIME missingkey FIELDS 1 field1]
assert_equal -2 $out
}
# Multiple fields: mix of TTL, no TTL, and missing
test {HEXPIRETIME - multiple fields mixed cases} {
r FLUSHALL
r HSET myhash f1 a f2 b
set now [clock seconds]
r HEXPIREAT myhash [expr {$now + 100}] FIELDS 1 f1
set out [r HEXPIRETIME myhash FIELDS 3 f1 f2 f3]
# Should return: expiry for f1, -1 for f2 (no TTL), -2 for f3 (not found)
assert_equal [list [expr {$now + 100}] -1 -2] $out
}
# Invalid usages
test {HEXPIRETIME - no FIELDS keyword} {
r FLUSHALL
r HSET myhash f1 a
catch {r HEXPIRETIME myhash} e
set e
} {ERR wrong number of arguments for 'hexpiretime' command}
test {HEXPIRETIME - FIELDS 0} {
r FLUSHALL
r HSET myhash f1 a
catch {r HEXPIRETIME myhash FIELDS 0} e
set e
} {ERR wrong number of arguments for 'hexpiretime' command}
test {HEXPIRETIME - wrong FIELDS count} {
r FLUSHALL
r HSET myhash f1 a
catch {r HEXPIRETIME myhash FIELDS 1} e
set e
} {ERR wrong number of arguments for 'hexpiretime' command}
test {HEXPIRETIME - wrong type key} {
r FLUSHALL
r SET myhash "not a hash"
catch {r HEXPIRETIME myhash FIELDS 1 f1} e
set e
} {WRONGTYPE Operation against a key holding the wrong kind of value}
# Basic expiration in milliseconds
test {HPEXPIREAT - set absolute expiry with ms precision} {
r FLUSHALL
r HSET myhash field1 val
set now [clock milliseconds]
set future [expr {$now + 123456789}]
r HPEXPIREAT myhash $future FIELDS 1 field1
set t [r HPEXPIRETIME myhash FIELDS 1 field1]
assert_equal $future $t
}
test {HPEXPIREAT - past timestamp deletes field immediately} {
r FLUSHALL
r HSET myhash field1 val
set past [expr {[clock milliseconds] - 10000}]
set res [r HPEXPIREAT myhash $past FIELDS 1 field1]
assert_equal {2} $res
assert_equal 0 [r HEXISTS myhash field1]
}
test {HPEXPIREAT - non-existent key returns -2} {
r FLUSHALL
set ts [expr {[clock milliseconds] + 1000}]
set res [r HPEXPIREAT nokey $ts FIELDS 1 field1]
assert_equal {-2} $res
}
test {HPEXPIREAT - mixed fields} {
r FLUSHALL
r HSET myhash f1 a f2 b
set ts [expr {[clock milliseconds] + 200000}]
set res [r HPEXPIREAT myhash $ts FIELDS 3 f1 f2 fX]
assert_equal {1 1 -2} $res
}
test {HPEXPIREAT - GT and LT options with success and failure cases} {
r FLUSHALL
r HSET myhash f1 a
# Setup: assign a baseline expiry time
set now [clock milliseconds]
set ts1 [expr {$now + 10000}]
set ts2 [expr {$now + 20000}]
r HPEXPIREAT myhash $ts1 FIELDS 1 f1
# --- GT Case ---
# ts2 > ts1 → should succeed
set res_gt_pass [r HPEXPIREAT myhash $ts2 GT FIELDS 1 f1]
assert_equal {1} $res_gt_pass
# ts1 < ts2 → now try GT with ts1 again (should fail because ts2 is already set)
set res_gt_fail [r HPEXPIREAT myhash $ts1 GT FIELDS 1 f1]
assert_equal {0} $res_gt_fail
# --- LT Case ---
# ts1 < ts2 → LT should fail
set res_lt_fail [r HPEXPIREAT myhash $ts2 LT FIELDS 1 f1]
assert_equal {0} $res_lt_fail
# ts1 < ts2 → try LT with earlier timestamp, should succeed
set ts0 [expr {$now + 5000}]
set res_lt_pass [r HPEXPIREAT myhash $ts0 LT FIELDS 1 f1]
assert_equal {1} $res_lt_pass
}
test {HPEXPIREAT - invalid inputs} {
r FLUSHALL
r HSET myhash f1 a
catch {r HPEXPIREAT myhash abc FIELDS 1 f1} e
assert_match {*not an integer*} $e
catch {r HPEXPIREAT myhash 12345 NX XX FIELDS 1 f1} e2
assert_match {ERR NX and XX, GT or LT options at the same time are not compatible} $e2
}
test {HPEXPIRETIME - check with multiple fields} {
r FLUSHALL
# Setup: one expiring field, one persistent, one missing
r HSET myhash f1 v1 f2 v2
set ts [expr {[clock milliseconds] + 1000}]
r HPEXPIREAT myhash $ts FIELDS 1 f1
# Query all 3 fields
set result [r HPEXPIRETIME myhash FIELDS 3 f1 f2 f3]
# Expect: [timestamp] for f1, -1 for f2, -2 for f3
assert {[llength $result] == 3}
# f1: has TTL → returns exact timestamp
assert_equal $ts [lindex $result 0]
# f2: exists, no TTL → returns -1
assert_equal -1 [lindex $result 1]
# f3: doesn't exist → returns -2
assert_equal -2 [lindex $result 2]
}
#################### HPERSIST ##################
test "HPERSIST - field does not exist" {
r FLUSHALL
r hset myhash field1 value1
assert_equal {-2} [r hpersist myhash FIELDS 1 field2]
}
test "HPERSIST - key does not exist" {
r FLUSHALL
assert_equal {-2} [r hpersist nonexistent FIELDS 1 field1]
}
test "HPERSIST - field exists but no expiration" {
r del myhash
r hset myhash field1 value1
assert_equal {-1} [r hpersist myhash FIELDS 1 field1]
}
test "HPERSIST - field exists with expiration" {
r FLUSHALL
r hset myhash field1 value1
r hexpire myhash 600 FIELDS 1 field1
assert_morethan [r httl myhash FIELDS 1 field1] 0
assert_equal {1} [r hpersist myhash FIELDS 1 field1]
assert_equal {-1} [r httl myhash FIELDS 1 field1]
}
test "HPERSIST - multiple fields with mixed state" {
r FLUSHALL
r hset myhash f1 v1
r hset myhash f2 v2
r hset myhash f3 v3
r hexpire myhash 600 FIELDS 1 f1
# f2 will have no expiration
# f4 does not exist
assert_equal {1 -1 -2} [r hpersist myhash FIELDS 3 f1 f2 f4]
}
test {HPERSIST, then HEXPIRE, check new TTL is set} {
r FLUSHALL
r HSET myhash f1 v1
r HEXPIRE myhash 1000 FIELDS 1 f1
assert_equal 1 [r HPERSIST myhash FIELDS 1 f1]
r HEXPIRE myhash 2000 FIELDS 1 f1
assert_morethan [r HTTL myhash FIELDS 1 f1] 1000
}
#################### HRANDFIELD ##################
test "HRANDFIELD - CASE 1: negative count" {
r FLUSHALL
assert_equal {1} [r HSETEX myhash PX 1 fields 5 f1 v1 f2 v2 f3 v3 f4 v4 f5 v5]
wait_for_condition 100 100 {
[r HGETALL myhash] eq {}
} else {
fail "Hash is showing expired elements"
}
# check that we get an empty response even though there are expired fields
assert_match {} [r hrandfield myhash 1]
# Now write a persistent element
assert_equal {1} [r HSET myhash f5 v5]
# make sure this is the element we will get all the time
for {set i 1} {$i <= 50} {incr i} {
assert_equal {f5 f5 f5 f5 f5} [r hrandfield myhash -5]
}
}
test "HRANDFIELD - CASE 2: The number of requested elements is greater than the number of elements inside the hash" {
r FLUSHALL
assert_equal {1} [r HSETEX myhash PX 1 fields 5 f1 v1 f2 v2 f3 v3 f4 v4 f5 v5]
wait_for_condition 100 100 {
[r HGETALL myhash] eq {}
} else {
fail "Hash is showing expired elements"
}
# check that we get an empty response even though there are expired fields
assert_match {} [r hrandfield myhash 10]
# Now write a persistent element
assert_equal {3} [r HSET myhash f5 v5 f6 v6 f7 v7]
# make sure this is the element we will get all the time
for {set i 1} {$i <= 50} {incr i} {
set result [r hrandfield myhash 10]
assert_equal 3 [llength [split $result]]
assert_match {*f5*} $result
assert_match {*f6*} $result
assert_match {*f7*} $result
}
}
test "HRANDFIELD - CASE 3: The number of elements inside the hash is not greater than 3 times the number of requested elements" {
r FLUSHALL
assert_equal {1} [r HSETEX myhash PX 1 fields 5 f1 v1 f2 v2 f3 v3 f4 v4 f5 v5]
wait_for_condition 100 100 {
[r HGETALL myhash] eq {}
} else {
fail "Hash is showing expired elements"
}
# check that we get an empty response even though there are expired fields
assert_match {} [r hrandfield myhash 4]
# Now write a persistent elements
assert_equal {4} [r HSET myhash f5 v5 f6 v6 f7 v7 f8 v8]
# make sure this is the elements we will get all the time
for {set i 1} {$i <= 50} {incr i} {
set result [r hrandfield myhash 4]
assert_equal 4 [llength [split $result]]
assert_match {*f5*} $result
assert_match {*f6*} $result
assert_match {*f7*} $result
assert_match {*f8*} $result
}
}
test "HRANDFIELD - CASE 4: The number of elements inside the hash is greater than 3 times the number of requested elements" {
r FLUSHALL
assert_equal {1} [r HSETEX myhash PX 1 fields 8 f1 v1 f2 v2 f3 v3 f4 v4 f5 v5 f6 v6 f7 v7 f8 v8]
wait_for_condition 100 100 {
[r HGETALL myhash] eq {}
} else {
fail "Hash is showing expired elements"
}
# check that we get an empty response even though there are expired fields
assert_match {} [r hrandfield myhash 2]
# Now write a persistent elements
assert_equal {3} [r HSET myhash f8 v8 f9 v9 f10 v10]
# make sure this is the elements we will get all the time
for {set i 1} {$i <= 50} {incr i} {
set result [r hrandfield myhash 3]
assert_equal 3 [llength [split $result]]
assert_match {*f8*} $result
assert_match {*f9*} $result
assert_match {*f10*} $result
}
}
test "HRANDFIELD - returns null response when all fields are expired" {
r FLUSHALL
r DEBUG SET-ACTIVE-EXPIRE 0
assert_equal {1} [r HSETEX myhash PX 1 fields 2 f1 v1 f2 v2]
wait_for_condition 100 100 {
[r HGETALL myhash] eq {}
} else {
fail "Hash is showing expired elements"
}
assert_equal {} [r hrandfield myhash2]
r DEBUG SET-ACTIVE-EXPIRE 1
} {OK} {needs:debug}
foreach cmd {RENAME RESTORE} {
test "$cmd Preserves Field TTLs" {
r FLUSHALL
r DEBUG SET-ACTIVE-EXPIRE 0
r HSET myhash{t} f1 v1 f2 v2
r HEXPIRE myhash{t} 200 FIELDS 1 f1
# Verify initial TTL state
set mem_before [r MEMORY USAGE myhash{t}]
assert_equal "v1 v2" [r HMGET myhash{t} f1 f2]
assert_morethan [r HTTL myhash{t} FIELDS 1 f1] 100
assert_equal -1 [r HTTL myhash{t} FIELDS 1 f2]
assert_equal 2 [r HLEN myhash{t}]
assert_equal 1 [get_keys r]
assert_equal 1 [get_keys_with_volatile_items r]
# Run the command
if {$cmd eq "RENAME"} {
r rename myhash{t} nwhash{t}
set newhash nwhash{t}
} elseif {$cmd eq "RESTORE"} {
set serialized [r DUMP myhash{t}]
r RESTORE rstrhs{t} 0 $serialized
set newhash rstrhs{t}
}
# Verify field values and TTLs are preserved
set memory_after [r MEMORY USAGE $newhash]
assert_equal "v1 v2" [r HMGET $newhash f1 f2]
assert_morethan [r HTTL $newhash FIELDS 1 f1] 100
assert_equal -1 [r HTTL $newhash FIELDS 1 f2]
assert_equal 2 [r HLEN $newhash]
if {$cmd eq "RESTORE"} {
assert_equal 2 [get_keys r]
assert_equal 2 [get_keys_with_volatile_items r]
} else {
assert_equal 1 [get_keys r]
assert_equal 1 [get_keys_with_volatile_items r]
}
assert_equal $mem_before $memory_after
} {} {needs:debug}
}
test {COPY Preserves TTLs} {
r flushall
# Create hash with fields
r HSET myhash{t} f1 v1 f3 v3 f4 v4
# Set TTL on f1 only
r HEXPIRE myhash{t} 2000 FIELDS 1 f1
r HEXPIRE myhash{t} 5000 FIELDS 1 f3
# Copy hash to new key
r copy myhash{t} nwhash{t}
# Verify initial TTL state
assert_equal [r MEMORY USAGE myhash{t}] [r MEMORY USAGE nwhash{t}]
assert_equal "v1 v3 v4" [r HMGET myhash{t} f1 f3 f4]
assert_equal "v1 v3 v4" [r HMGET nwhash{t} f1 f3 f4]
assert_equal [r HEXPIRETIME myhash{t} FIELDS 1 f1] [r HEXPIRETIME nwhash{t} FIELDS 1 f1]
assert_equal [r HEXPIRETIME myhash{t} FIELDS 1 f2] [r HEXPIRETIME nwhash{t} FIELDS 1 f2]
assert_equal [r HEXPIRETIME myhash{t} FIELDS 1 f3] [r HEXPIRETIME nwhash{t} FIELDS 1 f3]
assert_equal [r HEXPIRETIME myhash{t} FIELDS 1 f4] [r HEXPIRETIME nwhash{t} FIELDS 1 f4]
}
test {Hash Encoding Transitions with TTL - Add TTL to Existing Fields} {
r flushall
r DEBUG SET-ACTIVE-EXPIRE 0
# Create small hash with listpack encoding
r HSET myhash f1 v1 f2 v2
# Verify initial encoding
set "listpack" [r OBJECT ENCODING myhash]
# Add TTL to existing field
r HEXPIRE myhash 300 FIELDS 1 f1
# Verify encoding changed to hashtable
set "hashtable" [r OBJECT ENCODING myhash]
# Verify field values are preserved
assert_equal "v1 v2" [r HMGET myhash f1 f2]
# Veridy expiry
assert_morethan [r HTTL myhash FIELDS 1 f1] 100
assert_equal -1 [r HTTL myhash FIELDS 1 f2]
# Re-enable active expiry
r DEBUG SET-ACTIVE-EXPIRE 1
} {OK} {needs:debug}
test {Hash Encoding Transitions with TTL - Create New Fields with TTL} {
r flushall
r DEBUG SET-ACTIVE-EXPIRE 0
# Create small hash with listpack encoding
r HSET myhash f1 v1 f2 v2
# Verify initial encoding
set "listpack" [r OBJECT ENCODING myhash]
# Add many fields to force encoding transition
for {set i 3} {$i <= 600} {incr i} {
lappend pairs "f$i" "v$i"
}
r HSET myhash {*}$pairs
set expire_time [get_long_expire_value HEXPIREAT]
r HEXPIREAT myhash $expire_time FIELDS 5 f1 f10 f100 f200 f300
# Verify encoding changed to hashtable
set "hashtable" [r OBJECT ENCODING myhash]
# Verify all field values and TTLs are correct
for {set i 1} {$i <= 600} {incr i} {
assert_equal "v$i" [r HGET myhash "f$i"]
if {$i == 1 || $i == 10 || $i == 100 || $i == 200 || $i == 300} {
assert_equal [r HEXPIRETIME myhash FIELDS 1 "f$i"] $expire_time
} else {
assert_equal [r HTTL myhash FIELDS 1 "f$i"] -1
}
}
# Re-enable active expiry
r DEBUG SET-ACTIVE-EXPIRE 1
} {OK} {needs:debug}
test {HGETALL skips expired fields} {
r FLUSHALL
r DEBUG SET-ACTIVE-EXPIRE 0
# Set two fields: one persistent, one with short TTL
r HSET myhash persistent "val1"
r HSETEX myhash PX 5 FIELDS 1 expiring "val2"
# Wait for expiry to pass
after 10
# HGETALL should skip expired field
set result [r HGETALL myhash]
assert_equal {persistent val1} $result
# Re-enable active expiry
r DEBUG SET-ACTIVE-EXPIRE 1
} {OK} {needs:debug}
test {HSCAN skips expired fields} {
r FLUSHALL
r DEBUG SET-ACTIVE-EXPIRE 0
# Set multiple fields, one with expiry
r HSET myhash persistent1 "a" persistent2 "b"
r HSETEX myhash PX 5 FIELDS 1 expiring "c"
# Wait for expiration
after 10
# HSCAN must not return the expired field
set cursor 0
set allfields {}
while {1} {
set res [r HSCAN myhash $cursor]
set cursor [lindex $res 0]
set kvs [lindex $res 1]
lappend allfields {*}$kvs
if {$cursor eq "0"} break
}
# Extract just the field names
set fieldnames [lmap {k v} $allfields { set k }]
set fieldnames_sorted [lsort $fieldnames]
# Should only include persistent1 and persistent2
assert_equal {persistent1 persistent2} $fieldnames_sorted
# Re-enable active expiry for future tests
r DEBUG SET-ACTIVE-EXPIRE 1
} {OK} {needs:debug}
test {MOVE preserves field TTLs} {
r FLUSHALL
r SELECT 0
r HSETEX myhash PX 50000 FIELDS 1 field1 val1
# Capture original TTL
set original_ttl [r HPTTL myhash FIELDS 1 field1]
assert {$original_ttl > 0}
# Move to DB 1
assert_equal 1 [r MOVE myhash 1]
# Switch to target DB
r SELECT 1
# Field must exist and TTL must be preserved
set moved_ttl [r HPTTL myhash FIELDS 1 field1]
assert {$moved_ttl > 0 && $moved_ttl <= $original_ttl}
} {} {needs:debug}
test {HSET - overwrite expired field without TTL clears expiration} {
r FLUSHALL
r DEBUG SET-ACTIVE-EXPIRE 0
# This test verifies that if a field has expired (but not yet lazily deleted),
# and it is overwritten using a plain HSET (i.e., no TTL),
# KV treats the field as non existing and updates it,
# effectively clearing the old TTL and making the field persistent.
r HSETEX myhash PX 10 FIELDS 1 field1 oldval
wait_for_condition 100 100 {
[r HTTL myhash FIELDS 1 field1] eq "-2"
} else {
fail "hash value was not expired after timeout"
}
# Field should still be present in memory due to lazy expiry
assert_equal 1 [r HLEN myhash]
# Overwrite with HSET (no TTL) before accessing
r HSET myhash field1 newval
# TTL should now be gone; field becomes persistent
set ttl [r HPTTL myhash FIELDS 1 field1]
assert_equal -1 $ttl
assert_equal newval [r HGET myhash field1]
assert_equal 1 [r HLEN myhash]
r DEBUG SET-ACTIVE-EXPIRE 1
} {OK} {needs:debug}
test {HINCRBY - on expired field} {
r FLUSHALL
r DEBUG SET-ACTIVE-EXPIRE 0
# This test verifies that if a field has expired,
# and it is overwritten using a plain HINCRBY (i.e., no TTL),
# KV treats the field as still existing and updates it,
# effectively clearing the old TTL and starting the value from 0.
r HSETEX myhash PX 10 FIELDS 1 field1 1
wait_for_condition 100 100 {
[r HTTL myhash FIELDS 1 field1] eq "-2"
} else {
fail "hash value was not expired after timeout"
}
# Field should still be present in memory
assert_equal 1 [r HLEN myhash]
# Overwrite with HINCRBY (no TTL) before accessing
r HINCRBY myhash field1 1
# Sanity check: check we only have one field in the hash
assert_equal 1 [r HLEN myhash]
# TTL should now be gone; field becomes persistent; key should not be tracked
set ttl [r HPTTL myhash FIELDS 1 field1]
assert_equal -1 $ttl
assert_equal 1 [r HGET myhash field1]
assert_equal 1 [r HLEN myhash]
assert_equal 0 [get_keys_with_volatile_items r]
# set expiration on the field
assert_equal 1 [r HEXPIRE myhash 100000000 FIELDS 1 field1]
# verify the field has TTL
assert_morethan [r HPTTL myhash FIELDS 1 field1] 0
# now incr the field again
assert_equal 2 [r HINCRBY myhash field1 1]
# verify the field has TTL
assert_morethan [r HPTTL myhash FIELDS 1 field1] 0
r DEBUG SET-ACTIVE-EXPIRE 1
} {OK} {needs:debug}
test {HINCRBYFLOAT - on expired field} {
r FLUSHALL
r DEBUG SET-ACTIVE-EXPIRE 0
# This test verifies that if a field has expired,
# and it is overwritten using a plain HINCRBYFLOAT (i.e., no TTL),
# KV treats the field as still existing and updates it,
# effectively clearing the old TTL and starting the value from 0.
r HSETEX myhash PX 10 FIELDS 1 field1 1
wait_for_condition 100 100 {
[r HTTL myhash FIELDS 1 field1] eq "-2"
} else {
fail "hash value was not expired after timeout"
}
# Field should still be present in memory
assert_equal 1 [r HLEN myhash]
# Overwrite with HINCRBYFLOAT (no TTL) before accessing
r HINCRBYFLOAT myhash field1 1
# Sanity check: check we only have one field in the hash
assert_equal 1 [r HLEN myhash]
# TTL should now be gone; field becomes persistent; key should not be tracked
set ttl [r HPTTL myhash FIELDS 1 field1]
assert_equal -1 $ttl
assert_equal 1 [r HGET myhash field1]
assert_equal 1 [r HLEN myhash]
assert_equal 0 [get_keys_with_volatile_items r]
# set expiration on the field
assert_equal 1 [r HEXPIRE myhash 100000000 FIELDS 1 field1]
# verify the field has TTL
assert_morethan [r HPTTL myhash FIELDS 1 field1] 0
# now incr the field again
assert_equal 2 [r HINCRBYFLOAT myhash field1 1]
# verify the field has TTL
assert_morethan [r HPTTL myhash FIELDS 1 field1] 0
r DEBUG SET-ACTIVE-EXPIRE 1
} {OK} {needs:debug}
test {HSET - overwrite unexpired field removes TTL} {
r FLUSHALL
r DEBUG SET-ACTIVE-EXPIRE 0
# This test verifies that overwriting a field with HSET,
# even while its TTL is still valid (not expired),
# clears the TTL and makes the field persistent.
# This behavior is consistent with how HSET works for normal keys.
# Set field with long TTL
r HSETEX myhash PX 1000 FIELDS 1 field1 val1
# Confirm TTL is active
set before [r HPTTL myhash FIELDS 1 field1]
assert {$before > 0}
# Overwrite with HSET before TTL expires
r HSET myhash field1 newval
# TTL should now be gone
set after [r HPTTL myhash FIELDS 1 field1]
assert_equal -1 $after
assert_equal newval [r HGET myhash field1]
r DEBUG SET-ACTIVE-EXPIRE 1
} {OK} {needs:debug}
test {HDEL - expired field is removed without triggering expiry logic} {
r FLUSHALL
r DEBUG SET-ACTIVE-EXPIRE 0
# This test proves that deleting an expired field with HDEL
# does NOT trigger KV's expiration mechanism.
#
# The key observation is that KV tracks how many fields were
# expired via TTL using the `expired_fields` counter in INFO stats.
# If HDEL caused expiration to be processed internally,
# this counter would increment. We assert that it remains unchanged.
# Capture expired_fields before
set before_info [r INFO stats]
set before [info_field $before_info expired_fields]
# Create field with short TTL
r HSETEX myhash PX 10 FIELDS 1 field1 val1
after 20
# Field is technically expired, but still in-memory due to lazy expiry
assert_equal 1 [r HLEN myhash]
# Delete the expired field directly
r HDEL myhash field1
# Field should be gone
assert_equal 0 [r HEXISTS myhash field1]
# Capture expired_fields again
set after_info [r INFO stats]
set after [info_field $after_info expired_fields]
# Verify that no expiry occurred internally
assert_equal $before $after
r DEBUG SET-ACTIVE-EXPIRE 1
} {OK} {needs:debug}
test {HDEL on field with TTL, then re-add and check TTL is gone} {
r FLUSHALL
r HSET myhash f1 v1
r HEXPIRE myhash 10000 FIELDS 1 f1
assert_morethan [r HTTL myhash FIELDS 1 f1] 0
r HDEL myhash f1
r HSET myhash f1 v2
assert_equal -1 [r HTTL myhash FIELDS 1 f1]
}
## expired_fields Tests ####
test {expired_fields metric increments by one when single hash field expires} {
r FLUSHALL
set initial_expired [info_field [r info stats] expired_fields]
# Create hash with fields and ttl
r HSET myhash f1 v1 f2 v2 f3 v3
assert_equal 3 [r HLEN myhash]
# Force expiration by setting very short TTL
r HPEXPIRE myhash 1 FIELDS 1 f1
# Wait for expiration
wait_for_active_expiry r myhash 2 $initial_expired 1
# Verify expired field returns empty string and non-expired return values
assert_equal "{} v2 v3" [r HMGET myhash f1 f2 f3]
}
test {expired_fields metric tracks multiple field expirations with keyspace notifications} {
r FLUSHALL
set initial_expired [info_field [r info stats] expired_fields]
set rd [setup_single_keyspace_notification r]
# Create hash with expiring fields
r HSET myhash f1 v1 f2 v2 f3 v3 f4 v4 f5 v5
r HEXPIRE myhash 1000 FIELDS 1 f1
r HEXPIRE myhash 2000 FIELDS 1 f2
# Force expiration with short ttl
r HPEXPIRE myhash 1 FIELDS 1 f1
# Wait for expiration
wait_for_active_expiry r myhash 4 $initial_expired 1
# Verify expired_fields incremented
assert_equal 1 [expr {[info_field [r info stats] expired_fields] - $initial_expired}]
# Verify expired field returns empty string and non-expired return values
assert_equal "{} v2 v3 v4 v5" [r HMGET myhash f1 f2 f3 f4 f5]
# Test HPERSIST remove TTL from f2
r HPERSIST myhash FIELDS 1 f2
# Verify f2 no longer has TTL
assert_equal -1 [r HTTL myhash FIELDS 1 f2]
assert_equal 1 [expr {[info_field [r info stats] expired_fields] - $initial_expired}]
# Expire 2 fields at once
r HPEXPIRE myhash 1 FIELDS 2 f4 f5
wait_for_active_expiry r myhash 2 $initial_expired 3
assert_equal 3 [expr {[info_field [r info stats] expired_fields] - $initial_expired}]
# Verify expired fields return empty string and non-expired return values
assert_equal "{} v2 v3 {} {}" [r HMGET myhash f1 f2 f3 f4 f5]
# Wait for hset and hexpire events
assert_keyevent_patterns $rd myhash hset hexpire hexpire hexpire hexpired hpersist hexpire hexpired
$rd close
}
foreach time_unit {s, ms} {
test "Key TTL expires before field TTL: entire hash should be deleted timeunit: $time_unit" {
r FLUSHALL
r DEBUG SET-ACTIVE-EXPIRE 0
r config set notify-keyspace-events KEA
set rd [kv_deferring_client]
assert_equal {1} [psubscribe $rd __keyevent@*]
r HSET myhash f1 v1 f2 v2 f3 v3
assert_equal 1 [get_keys r]
assert_equal 0 [get_keys_with_volatile_items r]
assert_equal 3 [r HLEN myhash]
if {$time_unit eq "s"} {
r HEXPIRE hash1 10 FIELDS 1 f1
r EXPIRE hash1 1
} else {
r HPEXPIRE myhash 10000 FIELDS 1 f1
r PEXPIRE myhash 1000
}
wait_for_condition 100 100 {
[r EXISTS myhash] eq "0"
} else {
fail "myhash still exists"
}
assert_equal 0 [r HLEN myhash]
assert_equal 0 [get_keys r]
assert_keyevent_patterns $rd myhash hset hexpire expire
assert_equal 0 [get_keys_with_volatile_items r]
$rd close
# Re-enable active expiry
r DEBUG SET-ACTIVE-EXPIRE 1
} {OK} {needs:debug}
test "Field TTL expires before key TTL: only the specific field should expire: $time_unit" {
r FLUSHALL
r DEBUG SET-ACTIVE-EXPIRE 0
set rd [kv_deferring_client]
assert_equal {1} [psubscribe $rd __keyevent@*]
r HSET myhash f1 v1 f2 v2 f3 v3
assert_equal 1 [get_keys r]
assert_equal 0 [get_keys_with_volatile_items r]
assert_equal 3 [r HLEN myhash]
if {$time_unit eq "s"} {
r HEXPIRE myhash 1 FIELDS 1 f1
r EXPIRE myhash 10
} else {
r HPEXPIRE myhash 1000 FIELDS 1 f1
r PEXPIRE myhash 10000
}
wait_for_condition 100 100 {
[r HGET myhash f1] eq ""
} else {
fail "f1 not expired"
}
assert_equal 1 [get_keys r]
assert_equal 1 [r EXISTS myhash]
assert_equal "{} v2 v3" [r HMGET myhash f1 f2 f3]
assert_keyevent_patterns $rd myhash hset hexpire
# When active expire is disabled, expired key is
# not deleted and get_keys_with_volatile_items is the same
assert_equal 1 [get_keys_with_volatile_items r]
$rd close
# Re-enable active expiry
r DEBUG SET-ACTIVE-EXPIRE 1
} {OK} {needs:debug}
test "Key and field TTL expire simultaneously: entire hash should be deleted: $time_unit" {
r FLUSHALL
r DEBUG SET-ACTIVE-EXPIRE 0
r HSET myhash f1 v1 f2 v2 f3 v3
assert_equal 1 [get_keys r]
assert_equal 3 [r HLEN myhash]
if {$time_unit eq "s"} {
set expire [expr {[clock seconds] + 1}]
r HEXPIREAT myhash $expire FIELDS 1 f1
r EXPIREAT myhash $expire
} else {
set expire [expr {[clock milliseconds] + 1000}]
r HPEXPIREAT myhash $expire FIELDS 1 f1
r PEXPIREAT myhash $expire
}
wait_for_condition 100 100 {
[r EXISTS myhash] eq 0
} else {
fail "myhash still exist"
}
assert_equal "{} {} {}" [r HMGET myhash f1 f2 f3]
assert_equal 0 [get_keys r]
assert_equal 0 [r HLEN myhash]
# Re-enable active expiry
r DEBUG SET-ACTIVE-EXPIRE 1
} {OK} {needs:debug}
test {Millisecond/Seconds precision} {
r flushall
r DEBUG SET-ACTIVE-EXPIRE 0
r HSET myhash f1 v1 f2 v2
if {$time_unit eq "s"} {
r HEXPIRE myhash 3 FIELDS 1 f1
r EXPIRE myhash 1
} else {
r HPEXPIRE myhash 3000 FIELDS 1 f1
r PEXPIRE myhash 1000
}
after 1500
assert_equal 0 [r EXISTS myhash]
# Re-enable active expiry
r DEBUG SET-ACTIVE-EXPIRE 1
} {OK} {needs:debug}
}
test {Ensure that key-level PERSIST on the key don't affect field TTL} {
r FLUSHALL
r HSET myhash f1 v1 f2 v2
assert_equal 1 [get_keys r]
assert_equal 0 [get_keys_with_volatile_items r]
assert_equal 2 [r HLEN myhash]
r HEXPIRE myhash 100000 FIELDS 1 f1
r PERSIST myhash
assert_equal -1 [r TTL myhash]
assert_morethan [r HTTL myhash FIELDS 1 f1] 0
assert_equal 1 [get_keys_with_volatile_items r]
}
test {Verify error when hash expire commands num fields is not provided} {
r FLUSHALL
catch {r hsetex myhash KEEPTTL KEEPTTL KEEPTTL FIELDS} e
assert_match $e {ERR numfields should be greater than 0 and match the provided number of fields}
catch {r hexpire myhash 10 NX NX FIELDS} e
assert_match $e {ERR numfields should be greater than 0 and match the provided number of fields}
catch {r hgetex myhash PERSIST PERSIST FIELDS} e
assert_match $e {ERR numfields should be greater than 0 and match the provided number of fields}
}
}
####### Test info
start_server {tags {"hash-ttl-info external:skip"}} {
test {Hash ttl - check command stats} {
r FLUSHALL
# Run all relevant hash TTL commands
r HSET myhash f1 v1 f2 v2
r HEXPIRE myhash 10 FIELDS 1 f1
r HEXPIREAT myhash [expr {[clock seconds] + 10}] FIELDS 1 f2
r HEXPIRETIME myhash FIELDS 2 f1 f2
r HPEXPIRE myhash 1000 FIELDS 1 f1
r HPEXPIREAT myhash [expr {[clock milliseconds] + 2000}] FIELDS 1 f2
r HPEXPIRETIME myhash FIELDS 2 f1 f2
r HGETEX myhash EX 120 FIELDS 1 f1
r HTTL myhash FIELDS 1 f2
r HPTTL myhash FIELDS 1 f1
# Fetch commandstats
set info [r INFO commandstats]
# Extract call counts
proc get_calls {info cmd} {
foreach line [split $info "\n"] {
if {[string match "cmdstat_$cmd:*" $line]} {
regexp {calls=(\d+)} $line -> count
return $count
}
}
return -1
}
# Assert each command appears with correct call count (1 call each)
assert_equal 1 [get_calls $info hexpire]
assert_equal 1 [get_calls $info hexpireat]
assert_equal 1 [get_calls $info hexpiretime]
assert_equal 1 [get_calls $info hpexpire]
assert_equal 1 [get_calls $info hpexpireat]
assert_equal 1 [get_calls $info hpexpiretime]
assert_equal 1 [get_calls $info hgetex]
assert_equal 1 [get_calls $info httl]
assert_equal 1 [get_calls $info hpttl]
}
}
#### Replication ####
start_server {tags {"hashexpire external:skip"}} {
# 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 {Setup replica and check field expiry after full sync} {
$primary flushall
# Set up some TTLs on primary BEFORE replica connects
set now [clock milliseconds]
set f1_exp [expr {$now + 50000}]
set f2_exp [expr {$now + 70000}]
$primary HSET myhash f1 v1 f2 v2
$primary HPEXPIREAT myhash $f1_exp FIELDS 1 f1
$primary HPEXPIREAT myhash $f2_exp FIELDS 1 f2
# Now connect replica
$replica replicaof $primary_host $primary_port
wait_for_condition 100 100 {
[info_field [$replica info replication] master_link_status] eq "up"
} else {
fail "Master <-> Replica didn't finish sync"
}
# Wait for full sync
wait_for_ofs_sync $primary $replica
# Validate TTLs replicated correctly
set r1 [$replica HPEXPIRETIME myhash FIELDS 1 f1]
set r2 [$replica HPEXPIRETIME myhash FIELDS 1 f2]
assert_equal $f1_exp $r1
assert_equal $f2_exp $r2
}
test {HASH TTL - replicated TTL is absolute and consistent on replica} {
$primary flushall
set now [clock milliseconds]
set future [expr {$now + 5000}]
set future_sec [expr {$future / 1000}]
# HPEXPIREAT
$primary HSET myhash f1 v1
$primary HPEXPIREAT myhash $future FIELDS 1 f1
# HSETEX EX
$primary HSETEX myhash EX 5 FIELDS 1 f2 v2
# HEXPIRE
$primary HSET myhash f3 v3
$primary HEXPIRE myhash 5 FIELDS 1 f3
wait_for_ofs_sync $primary $replica
set t1 [$primary HPEXPIRETIME myhash FIELDS 1 f1]
set t1r [$replica HPEXPIRETIME myhash FIELDS 1 f1]
assert_equal $t1 $t1r
set t2 [$primary HEXPIRETIME myhash FIELDS 1 f2]
set t2r [$replica HEXPIRETIME myhash FIELDS 1 f2]
assert_equal $t2 $t2r
set t3 [$primary HEXPIRETIME myhash FIELDS 1 f3]
set t3r [$replica HEXPIRETIME myhash FIELDS 1 f3]
assert_equal $t3 $t3r
}
test {HASH TTL - field expired on master gets deleted on replica} {
$primary flushall
$primary HSETEX myhash PX 10 FIELDS 1 f1 val1
after 20
wait_for_ofs_sync $primary $replica
# Trigger lazy expiry
catch {$primary HGET myhash f1}
wait_for_ofs_sync $primary $replica
assert_equal 0 [$replica HEXISTS myhash f1]
}
test {HASH TTL - replica retains TTL and field before expiration} {
$primary flushall
$primary HSETEX myhash PX 1000 FIELDS 1 f1 val1
wait_for_ofs_sync $primary $replica
set master_ttl [$primary HPTTL myhash FIELDS 1 f1]
set replica_ttl [$replica HPTTL myhash FIELDS 1 f1]
assert {$replica_ttl > 0}
assert {$replica_ttl <= $master_ttl}
}
test {HSETEX with expired time is propagated to the replica} {
$primary flushall
assert_equal [$primary HSET myhash f1 val1] "1"
wait_for_condition 100 100 {
[$replica HGET myhash f1] eq {val1}
} else {
fail "hash field was not set on replica after timeout"
}
assert_equal [$primary HSETEX myhash EXAT 0 FIELDS 1 f1 val1] {1}
wait_for_condition 100 100 {
[$primary EXISTS myhash] eq "0"
} else {
fail "hash object was not deleted on primary after timeout"
}
wait_for_ofs_sync $primary $replica
wait_for_condition 100 100 {
[$replica EXISTS myhash] eq "0"
} else {
fail "hash object was not deleted on replica after timeout"
}
}
test {HGETEX with expired time is propagated to the replica} {
$primary flushall
assert_equal [$primary HSET myhash f1 val1] "1"
wait_for_condition 100 100 {
[$replica HGET myhash f1] eq {val1}
} else {
fail "hash field was not set on replica after timeout"
}
assert_equal [$primary HGETEX myhash EXAT 0 FIELDS 1 f1] {val1}
wait_for_condition 100 100 {
[$primary EXISTS myhash] eq "0"
} else {
fail "hash object was not deleted on primary after timeout"
}
wait_for_ofs_sync $primary $replica
wait_for_condition 100 100 {
[$replica EXISTS myhash] eq "0"
} else {
fail "hash object was not deleted on replica after timeout"
}
}
test {HEXPIREAT with expired time is propagated to the replica} {
$primary flushall
assert_equal [$primary HSET myhash f1 val1] "1"
wait_for_condition 100 100 {
[$replica HGET myhash f1] eq {val1}
} else {
fail "hash field was not set on replica after timeout"
}
assert_equal [$primary HEXPIREAT myhash 0 FIELDS 1 f1] {2}
wait_for_condition 100 100 {
[$primary EXISTS myhash] eq "0"
} else {
fail "hash object was not deleted on primary after timeout"
}
wait_for_ofs_sync $primary $replica
wait_for_condition 100 100 {
[$replica EXISTS myhash] eq "0"
} else {
fail "hash object was not deleted on replica after timeout"
}
}
}
}
start_server {tags {"hashexpire external:skip"}} {
set primary [srv 0 client]
set primary_host [srv 0 host]
set primary_port [srv 0 port]
start_server {tags {needs:repl external:skip}} {
set replica_1 [srv 0 client]
set replica_1_host [srv 0 host]
set replica_1_port [srv 0 port]
test {Replication Primary -> R1} {
lassign [setup_replication_test $primary $replica_1 $primary_host $primary_port] primary_initial_expired replica_1_initial_expired
# Initialize deferred clients and subscribe to keyspace notifications
foreach instance [list $primary $replica_1] {
$instance config set notify-keyspace-events KEA
}
set rd_primary [kv_deferring_client -1]
set rd_replica_1 [kv_deferring_client $replica_1_host $replica_1_port]
foreach rd [list $rd_primary $rd_replica_1] {
assert_equal {1} [psubscribe $rd __keyevent@*]
}
# Setup hash, set expire and set expire 0
$primary HSET myhash f1 v1 f2 v2 ;# Should trigger 3 hset
# Create hash and timing - f1 < f2 expiry times
set f1_exp [expr {[clock seconds] + 10000}]
$primary HEXPIREAT myhash $f1_exp FIELDS 1 f1 ;# Should trigger 3 hexpire
wait_for_ofs_sync $primary $replica_1
$primary HEXPIRE myhash 0 FIELDS 1 f1 ;# Should trigger 1 hexpired (for primary) and 1 hdel (for replica)
wait_for_ofs_sync $primary $replica_1
# Wait for f1 expiration
wait_for_condition 50 100 {
[$primary HTTL myhash FIELDS 1 f1] eq -2 && \
[$replica_1 HTTL myhash FIELDS 1 f1] eq -2
} else {
fail "f1 still exists"
}
# Verify keyspace notification
foreach rd [list $rd_primary $rd_replica_1] {
assert_keyevent_patterns $rd myhash hset hexpire
}
# primary gets hexpired and replica gets hdel
assert_keyevent_patterns $rd_primary myhash hexpired
assert_keyevent_patterns $rd_replica_1 myhash hdel
$rd_primary close
$rd_replica_1 close
}
start_server {tags {needs:repl external:skip}} {
$primary FLUSHALL
set replica_2 [srv 0 client]
set replica_2_host [srv 0 host]
set replica_2_port [srv 0 port]
test {Chain Replication (Primary -> R1 -> R2) preserves TTL} {
$replica_1 replicaof $primary_host $primary_port
# Wait for R2 to connect to R1
wait_for_condition 100 100 {
[info_field [$replica_1 info replication] master_link_status] eq "up"
} else {
fail "R1 <-> PRIMARY didn't establish connection"
}
$replica_2 replicaof $replica_1_host $replica_1_port
# Wait for R2 to connect to R1
wait_for_condition 100 100 {
[info_field [$replica_1 info replication] master_link_status] eq "up"
} else {
fail "R2 <-> R1 didn't establish connection"
}
# Initialize deferred clients and subscribe to keyspace notifications
set rd_primary [kv_deferring_client -2]
set rd_replica_1 [kv_deferring_client -1]
set rd_replica_2 [kv_deferring_client $replica_2_host $replica_2_port]
assert_equal {1} [psubscribe $rd_primary __keyevent@*]
assert_equal {1} [psubscribe $rd_replica_1 __keyevent@*]
assert_equal {1} [psubscribe $rd_replica_2 __keyevent@*]
# Create hash and timing - f1 < f2 < f3 expiry times
set f1_exp [expr {[clock seconds] + 1000000}]
wait_for_ofs_sync $primary $replica_1
wait_for_ofs_sync $replica_1 $replica_2
############################################# STEUP HASH #############################################
$primary HSETEX myhash FIELDS 2 f1 v1 f2 v2 ;# Should trigger 3 hset
wait_for_ofs_sync $primary $replica_1
wait_for_ofs_sync $replica_1 $replica_2
# Verify hset event was generated on all 3 nodes
foreach rd [list $rd_primary $rd_replica_1 $rd_replica_2] {
assert_keyevent_patterns $rd myhash hset
}
$primary HEXPIREAT myhash $f1_exp FIELDS 1 f1 ;# Should trigger 3 hexpire
wait_for_ofs_sync $primary $replica_1
wait_for_ofs_sync $replica_1 $replica_2
# Verify hexpire event was generated on all 3 nodes
foreach rd [list $rd_primary $rd_replica_1 $rd_replica_2] {
assert_keyevent_patterns $rd myhash hexpire
}
$primary HPEXPIRE myhash 0 FIELDS 1 f1 ;# Should trigger 1 hexpired (for primary) and 2 hdel (for replicas)
wait_for_ofs_sync $primary $replica_1
wait_for_ofs_sync $replica_1 $replica_2
# Wait for f1 expiration
wait_for_condition 50 100 {
[$primary HTTL myhash FIELDS 1 f1] eq -2 && \
[$replica_1 HTTL myhash FIELDS 1 f1] eq -2 && \
[$replica_2 HTTL myhash FIELDS 1 f1] eq -2
} else {
fail "f1 still exists"
}
# primary gets hexpired and replicas get hdel
assert_keyevent_patterns $rd_primary myhash hexpired
assert_keyevent_patterns $rd_replica_1 myhash hdel
assert_keyevent_patterns $rd_replica_2 myhash hdel
$rd_primary close
$rd_replica_1 close
$rd_replica_2 close
}
}
test {Replica Failover} {
$primary FLUSHALL
$primary DEBUG SET-ACTIVE-EXPIRE 0
$replica_1 DEBUG SET-ACTIVE-EXPIRE 0
####### Replication setup #######
$replica_1 replicaof $primary_host $primary_port
wait_for_condition 50 100 {
[lindex [$replica_1 role] 0] eq {slave} &&
[string match {*master_link_status:up*} [$replica_1 info replication]]
} else {
fail "Can't turn the instance into a replica"
}
# Create hash fields with TTL on primary
set f1_exp [expr {[clock seconds] + 200}]
set f2_exp [expr {[clock seconds] + 300000}]
$primary HSET myhash f1 v1 f2 v2 f3 v3
$primary HEXPIREAT myhash $f1_exp FIELDS 1 f1
$primary HEXPIREAT myhash $f2_exp FIELDS 1 f2
# f3 remains persistent
# Wait for full sync
wait_for_ofs_sync $primary $replica_1
# Verify primary and replica are the same
foreach instance [list $primary $replica_1] {
assert_equal $f1_exp [$instance HEXPIRETIME myhash FIELDS 1 f1]
assert_equal $f2_exp [$instance HEXPIRETIME myhash FIELDS 1 f2]
assert_equal -1 [$instance HTTL myhash FIELDS 1 f3]
assert_equal 1 [get_keys $instance]
assert_equal 1 [get_keys_with_volatile_items $instance]
assert_equal "v1 v2 v3" [$instance HMGET myhash f1 f2 f3]
assert_equal 3 [$instance HLEN myhash]
}
# Perform failover
$replica_1 replicaof no one
# Wait for replica to become primary
wait_for_condition 100 100 {
[info_field [$replica_1 info replication] role] eq "master"
} else {
fail "Replica didn't become master"
}
# Setup keyspace notifications for the promoted replica
$replica_1 config set notify-keyspace-events KEA
set rd_replica [kv_deferring_client $replica_1_host $replica_1_port]
assert_equal {1} [psubscribe $rd_replica __keyevent@*]
# Check all values that checked before are the same
assert_equal 3 [$replica_1 HLEN myhash]
assert_equal $f1_exp [$replica_1 HEXPIRETIME myhash FIELDS 1 f1]
assert_equal $f2_exp [$replica_1 HEXPIRETIME myhash FIELDS 1 f2]
assert_equal -1 [$replica_1 HTTL myhash FIELDS 1 f3]
assert_equal "v1 v2 v3" [$replica_1 HGETEX myhash FIELDS 3 f1 f2 f3]
assert_equal 3 [$replica_1 HLEN myhash]
# Set f1 to expire in 1 second and wait for expiration
$replica_1 HEXPIRE myhash 1 FIELDS 1 f1 ;# will trigger hexpire
wait_for_condition 50 100 {
[$replica_1 HTTL myhash FIELDS 1 f1] eq -2
} else {
fail "f1 not expired"
}
# Verify expiry in replica
assert_equal "" [$replica_1 HGET myhash f1]
assert_equal 3 [$replica_1 HLEN myhash]
# Verify no expiry in primary
assert_equal "v1" [$primary HGET myhash f1]
# Change TTL of f2
$replica_1 HEXPIRE myhash 1000000 FIELDS 1 f2 ;# will trigger hexpire
assert_morethan [$replica_1 HTTL myhash FIELDS 1 f2] 9000
assert_equal $f2_exp [$primary HEXPIRETIME myhash FIELDS 1 f2]
# Change TTL of f2 to 0 (immediate expiry)
$replica_1 HGETEX myhash EX 0 FIELDS 1 f2 ;# will trigger hexpired
# Verify final state
assert_equal 2 [$replica_1 HLEN myhash]
assert_equal "{} {} v3" [$replica_1 HGETEX myhash FIELDS 3 f1 f2 f3]
assert_equal "v1 v2 v3" [$primary HGETEX myhash FIELDS 3 f1 f2 f3] ;# No change for primary
assert_keyevent_patterns $rd_replica myhash hexpire hexpire hexpired
$rd_replica close
# Re-enable active expiry
$primary DEBUG SET-ACTIVE-EXPIRE 1
$replica_1 DEBUG SET-ACTIVE-EXPIRE 1
} {OK} {needs:debug}
test {Promotion to primary} {
lassign [setup_replication_test $primary $replica_1 $primary_host $primary_port] primary_initial_expired replica_1_initial_expired
# Initialize deferred clients and subscribe to keyspace notifications
foreach instance [list $primary $replica_1] {
$instance config set notify-keyspace-events KEA
$instance DEBUG SET-ACTIVE-EXPIRE 0
}
####### Replication setup #######
$replica_1 replicaof $primary_host $primary_port
wait_for_condition 50 100 {
[lindex [$replica_1 role] 0] eq {slave} &&
[string match {*master_link_status:up*} [$replica_1 info replication]]
} else {
fail "Can't turn the instance into a replica"
}
# Create hash fields with TTL on primary
set f1_exp [expr {[clock seconds] + 200}]
set f2_exp [expr {[clock seconds] + 300000}]
$primary HSET myhash f1 v1 f2 v2 f3 v3
$primary HEXPIREAT myhash $f1_exp FIELDS 1 f1
$primary HEXPIREAT myhash $f2_exp FIELDS 1 f2
# f3 remains persistent
# Wait for full sync
wait_for_ofs_sync $primary $replica_1
# Verify primary and replica are the same
foreach instance [list $primary $replica_1] {
assert_equal $f1_exp [$instance HEXPIRETIME myhash FIELDS 1 f1]
assert_equal $f2_exp [$instance HEXPIRETIME myhash FIELDS 1 f2]
assert_equal -1 [$instance HTTL myhash FIELDS 1 f3]
assert_equal 1 [get_keys $instance]
assert_equal 1 [get_keys_with_volatile_items $instance]
assert_equal "v1 v2 v3" [$instance HMGET myhash f1 f2 f3]
assert_equal 3 [$instance HLEN myhash]
}
# Perform promotion to primary
$primary FAILOVER TO $replica_1_host $replica_1_port
# Wait for replica to become primary
wait_for_condition 100 100 {
[info_field [$replica_1 info replication] role] eq "master"
} else {
fail "Replica didn't become master"
}
# Setup keyspace notifications
$primary config set notify-keyspace-events KEA
$replica_1 config set notify-keyspace-events KEA
set rd_primary [kv_deferring_client -1]
set rd_replica_1 [kv_deferring_client $replica_1_host $replica_1_port]
assert_equal {1} [psubscribe $rd_primary __keyevent@*]
assert_equal {1} [psubscribe $rd_replica_1 __keyevent@*]
# Check all values that checked before are the same after the failover
foreach instance [list $primary $replica_1] {
assert_equal $f1_exp [$instance HEXPIRETIME myhash FIELDS 1 f1]
assert_equal $f2_exp [$instance HEXPIRETIME myhash FIELDS 1 f2]
assert_equal -1 [$instance HTTL myhash FIELDS 1 f3]
assert_equal 1 [get_keys $instance]
assert_equal 1 [get_keys_with_volatile_items $instance]
assert_equal "v1 v2 v3" [$instance HMGET myhash f1 f2 f3]
assert_equal 3 [$instance HLEN myhash]
}
# Set f1 to expire in 1 second and wait for expiration
$replica_1 HEXPIRE myhash 1 FIELDS 1 f1 ;# will trigger hexpire
wait_for_ofs_sync $replica_1 $primary
wait_for_condition 50 100 {
[$replica_1 HTTL myhash FIELDS 1 f1] eq -2
} else {
fail "f1 not expired"
}
# Verify replica and primary are sync
foreach instance [list $primary $replica_1] {
assert_equal $f2_exp [$instance HEXPIRETIME myhash FIELDS 1 f2]
assert_equal -2 [$instance HTTL myhash FIELDS 1 f1]
assert_equal 1 [get_keys $instance]
assert_equal 1 [get_keys_with_volatile_items $instance]
assert_equal "{} v2 v3" [$instance HMGET myhash f1 f2 f3]
assert_equal 3 [$instance HLEN myhash]
}
# Change TTL of f2
$replica_1 HEXPIRE myhash 1000000 FIELDS 1 f2 ;# will trigger hexpire
wait_for_ofs_sync $replica_1 $primary
foreach instance [list $primary $replica_1] {
assert_morethan [$instance HTTL myhash FIELDS 1 f2] 9000
}
# Change TTL of f2 to 0 (immediate expiry)
$replica_1 HGETEX myhash EX 0 FIELDS 1 f2 ;# will trigger hexpired for replica_1 and hdel for primary
# Verify final state
wait_for_ofs_sync $replica_1 $primary
foreach instance [list $primary $replica_1] {
assert_equal 2 [$instance HLEN myhash]
assert_equal "{} {} v3" [r HMGET myhash f1 f2 f3]
}
foreach rd [list $rd_replica_1 $rd_primary] {
assert_keyevent_patterns $rd myhash hexpire hexpire
}
assert_keyevent_patterns $rd_replica_1 myhash hexpired
assert_keyevent_patterns $rd_primary myhash hdel
$rd_replica_1 close
$rd_primary close
# Re-enable active expiry
$primary DEBUG SET-ACTIVE-EXPIRE 1
$replica_1 DEBUG SET-ACTIVE-EXPIRE 1
} {OK} {needs:debug}
}
}
### Slot Migration ####
start_cluster 3 0 {tags {"cluster mytest external:skip"} overrides {cluster-node-timeout 1000}} {
# Flush all data on all cluster nodes before starting
for {set i 0} {$i < 3} {incr i} {
R $i FLUSHALL
}
if {$::singledb} {
set db 0
} else {
set db 9
}
set R0_id [R 0 CLUSTER MYID]
set R1_id [R 1 CLUSTER MYID]
# Use a fixed hash tag to ensure key is in one slot
set key "{mymigrate}myhash"
test {Hash with TTL fields migrates correctly between nodes} {
R 0 DEBUG SET-ACTIVE-EXPIRE 0
R 1 DEBUG SET-ACTIVE-EXPIRE 0
# Create hash fields
R 0 HSET $key f1 v1 f2 v2 f3 v3
# Set TTL on fields f1 and f2
R 0 HEXPIRE $key 300 FIELDS 2 f1 f2
# Verify before slot migration
assert_equal 3 [R 0 HLEN $key]
assert_morethan [R 0 HTTL $key FIELDS 1 f1] 290
assert_match {1} [scan [regexp -inline {keys\=([\d]*)} [R 0 info keyspace]] keys=%d]
assert_equal 1 [scan [lindex [regexp -inline {keys_with_volatile_items=([\d]+)} [R 0 info keyspace]] 1] "%d"]
# Prepare slot migration
set slot [R 0 CLUSTER KEYSLOT $key]
assert_equal OK [R 1 CLUSTER SETSLOT $slot IMPORTING $R0_id]
assert_equal OK [R 0 CLUSTER SETSLOT $slot MIGRATING $R1_id]
# Migrate key to destination node
R 0 MIGRATE [srv -1 host] [srv -1 port] $key 0 5000
# Complete slot migration
R 0 CLUSTER SETSLOT $slot NODE $R1_id
R 1 CLUSTER SETSLOT $slot NODE $R1_id
# Verify after slot migration
assert_equal 3 [R 1 HLEN $key]
assert_morethan [R 1 HTTL $key FIELDS 1 f1] 280
assert_match {1} [scan [regexp -inline {keys\=([\d]*)} [R 1 info keyspace]] keys=%d]
assert_equal 1 [scan [lindex [regexp -inline {keys_with_volatile_items=([\d]+)} [R 1 info keyspace]] 1] "%d"]
# Setup keyspace notifications
R 1 config set notify-keyspace-events KEA
set rd [kv_deferring_client -1]
assert_equal {1} [psubscribe $rd __keyevent@0__:hexpired]
# Set expiration to 0
R 1 HGETEX $key EX 0 FIELDS 1 f1
# Veridy expiration
assert_keyevent_patterns $rd "{$key}" hexpired
assert_equal 2 [R 1 HLEN $key]
assert_equal "" [R 1 HGET $key f1]
assert_equal -2 [R 1 HTTL $key FIELDS 1 f1]
$rd close
# Re-enable active expiry
R 0 DEBUG SET-ACTIVE-EXPIRE 1
R 1 DEBUG SET-ACTIVE-EXPIRE 1
} {OK} {needs:debug}
}
#### AOF Test #####
proc validate_aof_content {aof_file pxat_count hdel_count} {
wait_for_condition 100 100 {
[file exists $aof_file] eq 1
} else {
fail "hash value was not expired after timeout"
}
set aof_content [exec cat $aof_file]
# Verify amount of PXAT and HDEL
# Count PXAT commands
set got_pxat_count [regexp -all {PXAT} $aof_content]
assert_equal $got_pxat_count $pxat_count
# Count HDEL commands
set got_hdel_count [regexp -all {HDEL} $aof_content]
assert_equal $got_hdel_count $hdel_count
}
tags {"aof external:skip"} {
foreach rdb_preamble {"yes" "no"} {
set defaults {appendonly {yes} appendfilename {appendonly.aof} appenddirname {appendonlydir} auto-aof-rewrite-percentage {0}}
set server_path [tmpdir server.multi.aof]
start_server_aof [list dir $server_path aof-use-rdb-preamble $rdb_preamble] {
set rdb_preamble [lindex [r config get aof-use-rdb-preamble] 1]
test "TTL Persistence in AOF aof-use-rdb-preamble $rdb_preamble" {
r flushall
r DEBUG SET-ACTIVE-EXPIRE 0
r config set appendonly yes
r config set appendfsync always
assert_equal 0 [get_keys_with_volatile_items r]
# Create hash with 1 short, long and no expired fields
set long_expire [expr {[clock seconds] + 1000000}]
# Create 10 fields with long expiry
for {set i 1} {$i <= 10} {incr i} {
r HSETEX myhash EXAT $long_expire FIELDS 1 f$i v$i ;# 10 PXAT to aof
}
# Create 10 fields with short expiry
for {set i 11} {$i <= 20} {incr i} {
r HSETEX myhash PXAT [expr {[clock milliseconds] + 10}] FIELDS 1 f$i v$i ;# 10 PXAT to aof
}
# Create 10 fields with expire 0
for {set i 21} {$i <= 30} {incr i} {
r HSET myhash f$i v$i
r HEXPIRE myhash 0 FIELDS 1 f$i ;# 10 HDEL to aof
}
# Create 10 fields with no expiry
for {set i 31} {$i <= 40} {incr i} {
r HSET myhash f$i v$i
}
# Now wait for expire of the short expiry
for {set i 11} {$i <= 20} {incr i} {
wait_for_condition 100 100 {
[r HTTL myhash FIELDS 1 f$i] eq "-2"
} else {
fail "hash value was not expired after timeout"
}
}
# Verify initial HLEN
assert_equal 30 [r HLEN myhash]
# Verify values
for {set i 1} {$i <= 40} {incr i} {
if {$i >= 11 && $i <= 30} {
assert_equal "" [r HGET myhash f$i]
} else {
assert_equal v$i [r HGET myhash f$i]
}
}
assert_equal 1 [get_keys_with_volatile_items r]
# Ensure the initial rewrite finishes
waitForBgrewriteaof r
# Get the last incremental AOF file path and validate its content
# Count PXAT commands (should be 20: 10 long + 10 short)
# Count HDEL commands (should be 10: from expire 0)
validate_aof_content [get_last_incr_aof_path r] 20 10
# Restart the server and load the AOF
restart_server 0 true false
r DEBUG SET-ACTIVE-EXPIRE 0
r debug loadaof
set hlen [r HLEN myhash]
set expired_fields [info_field [r info stats] expired_fields]
assert_equal 1 [get_keys_with_volatile_items r]
# Verify that HLEN is between 20 and 30 (inclusive), and
# when combined with expired_fields, the total should be 30
if {$hlen < 20 || $hlen > 30} {
fail "Expected HLEN to be between 20 and 30, but got $hlen"
}
assert_equal 30 [expr ($expired_fields + $hlen)]
# Verify the TTLs are preserved
for {set i 1} {$i <= 10} {incr i} {
assert_equal $long_expire [r HEXPIRETIME myhash FIELDS 1 f$i]
assert_equal v$i [r HGET myhash f$i]
}
# Verify expired fields
for {set i 11} {$i <= 30} {incr i} {
assert_equal -2 [r HTTL myhash FIELDS 1 f$i]
assert_equal "" [r HGET myhash f$i]
}
# Verify fields with no TTL
for {set i 31} {$i <= 40} {incr i} {
assert_equal -1 [r HTTL myhash FIELDS 1 f$i]
assert_equal v$i [r HGET myhash f$i]
}
# Trigger and wait for a second rewrite
r BGREWRITEAOF
waitForBgrewriteaof r
if {"$rdb_preamble" eq "no"} {
# Get the last base AOF file path and validate its content
# Count PXAT commands (should be 10: just the long expiry fields)
# Count HDEL commands (should be rewritten out)
validate_aof_content [get_base_aof_path r] 10 0
}
# Restart the server and load the AOF
restart_server 0 true false
r DEBUG SET-ACTIVE-EXPIRE 0
r debug loadaof
set hlen [r HLEN myhash]
set expired_fields [info_field [r info stats] expired_fields]
assert_equal 1 [get_keys_with_volatile_items r]
# Verify that HLEN is 20, and we should now have no expired fields
if {$hlen != 20} {
fail "Expected HLEN to be 20, but got $hlen"
}
assert_equal 20 [expr ($expired_fields + $hlen)]
# Verify the TTLs are preserved
for {set i 1} {$i <= 10} {incr i} {
assert_equal $long_expire [r HEXPIRETIME myhash FIELDS 1 f$i]
assert_equal v$i [r HGET myhash f$i]
}
# Verify expired fields
for {set i 11} {$i <= 30} {incr i} {
assert_equal -2 [r HTTL myhash FIELDS 1 f$i]
assert_equal "" [r HGET myhash f$i]
}
# Verify fields with no TTL
for {set i 31} {$i <= 40} {incr i} {
assert_equal -1 [r HTTL myhash FIELDS 1 f$i]
assert_equal v$i [r HGET myhash f$i]
}
# Re-enable active expiry
r DEBUG SET-ACTIVE-EXPIRE 1
} {OK} {needs:debug}
}
}
}
### ACTIVE EXPIRY TESTS ####
##### HGETEX Active Expiry Tests #####
start_server {tags {"hashexpire external:skip"}} {
r config set notify-keyspace-events KEA
foreach command {EX PX EXAT PXAT} {
test "HGETEX $command active expiry with single field" {
r FLUSHALL
set initial_expired [info_field [r info stats] expired_fields]
r HSET myhash f1 v1 f2 v2
assert_equal 2 [r HLEN myhash]
assert_equal 0 [get_keys_with_volatile_items r]
# Use HGETEX to set expiry
assert_equal "v1" [r HGETEX myhash $command [get_short_expire_value $command] FIELDS 1 f1]
wait_for_active_expiry r myhash 1 $initial_expired 1
assert_equal "{} v2" [r HGETEX myhash FIELDS 2 f1 f2]
assert_equal 0 [get_keys_with_volatile_items r]
}
test "HGETEX $command active expiry with multiple fields" {
r FLUSHALL
set initial_expired [info_field [r info stats] expired_fields]
r HSET myhash f1 v1 f2 v2 f3 v3
assert_equal 3 [r HLEN myhash]
assert_equal 0 [get_keys_with_volatile_items r]
# Set expiry on multiple fields with HGETEX
assert_equal "v1 v3" [r HGETEX myhash $command [get_short_expire_value $command] FIELDS 2 f1 f3]
wait_for_active_expiry r myhash 1 $initial_expired 2
# Verify only non-expired field remains
assert_equal "{} v2 {}" [r HGETEX myhash FIELDS 3 f1 f2 f3]
assert_equal 0 [get_keys_with_volatile_items r]
}
test "HGETEX $command active expiry removes entire key when last field expires" {
r FLUSHALL
set initial_expired [info_field [r info stats] expired_fields]
r HSET myhash f1 v1
assert_equal 0 [get_keys_with_volatile_items r]
assert_equal "v1" [r HGETEX myhash $command [get_short_expire_value $command] FIELDS 1 f1]
wait_for_active_expiry r myhash 0 $initial_expired 1
assert_equal 0 [r EXISTS myhash]
assert_equal 0 [get_keys_with_volatile_items r]
}
test "HGETEX $command and HPEXPIRE" {
r FLUSHALL
r HSET myhash f1 v1 f2 v2 f3 v3 f4 v4
r HEXPIRE myhash 3000 FIELDS 1 f1
r HSETEX myhash EX 5000 FIELDS 1 f2 v2
r HEXPIRE myhash 60000 FIELDS 1 f3
assert_equal "v1 v2 v3 v4" [r HGETEX myhash FIELDS 4 f1 f2 f3 f4]
assert_equal "v3" [r HGETEX myhash PERSIST FIELDS 1 f3]
r HPEXPIRE myhash 1 FIELDS 1 f1
}
}
test "HGETEX PERSIST removes expiry and prevents active expiry" {
r FLUSHALL
r HSET myhash f1 v1 f2 v2
assert_equal 2 [r HLEN myhash]
assert_equal 0 [get_keys_with_volatile_items r]
# Set short expiry
assert_equal "v1" [r HGETEX myhash PX 1000 FIELDS 1 f1]
# Immediately persist to prevent expiry
assert_equal "v1" [r HGETEX myhash PERSIST FIELDS 1 f1]
assert_equal -1 [r HTTL myhash FIELDS 1 f1]
# Wait longer than original expiry time
after 200
# Field should still exist due to PERSIST
assert_equal "v1" [r HGET myhash f1]
assert_equal 2 [r HLEN myhash]
assert_equal 0 [get_keys_with_volatile_items r]
}
test "HGETEX overwrite existing expiry with active expiry" {
r FLUSHALL
set initial_expired [info_field [r info stats] expired_fields]
r HSET myhash f1 v1
assert_equal 1 [r HLEN myhash]
assert_equal 0 [get_keys_with_volatile_items r]
# Set initial long expiry
r HEXPIRE myhash [get_long_expire_value HEXPIRE] FIELDS 1 f1
assert_morethan [r HTTL myhash FIELDS 1 f1] 5000
# Use HGETEX to set shorter expiry
assert_equal "v1" [r HGETEX myhash PX 100 FIELDS 1 f1]
# Wait for active expiry with new shorter time
wait_for_active_expiry r myhash 0 $initial_expired 1
assert_equal 0 [r EXISTS myhash]
assert_equal 0 [get_keys_with_volatile_items r]
}
##### HGETEX Active Expiry Keyspace Notifications #####
foreach command {EX PX EXAT PXAT} {
test "HGETEX $command keyspace notifications for active expiry" {
r FLUSHALL
set initial_expired [info_field [r info stats] expired_fields]
r HSET myhash f1 v1 f2 v2
assert_equal 2 [r HLEN myhash]
assert_equal 0 [get_keys_with_volatile_items r]
assert_equal 2 [r HLEN myhash]
set rd [setup_single_keyspace_notification r]
# Set expiry with HGETEX
r HGETEX myhash $command [get_short_expire_value $command] FIELDS 1 f1
wait_for_active_expiry r myhash 1 $initial_expired 1
assert_keyevent_patterns $rd myhash hexpire hexpired
assert_equal 0 [get_keys_with_volatile_items r]
$rd close
}
}
test "HGETEX keyspace notification when key deleted with active expiry" {
r FLUSHALL
set initial_expired [info_field [r info stats] expired_fields]
r HSET myhash f1 v1
assert_equal 1 [r HLEN myhash]
assert_equal 0 [get_keys_with_volatile_items r]
set rd [setup_single_keyspace_notification r]
# Set expiry on only field
r HGETEX myhash PX [get_short_expire_value PX] FIELDS 1 f1
wait_for_active_expiry r myhash 0 $initial_expired 1
assert_equal 0 [r EXISTS myhash]
# Should get both hexpired and del notifications
assert_keyevent_patterns $rd myhash hexpire hexpired del
assert_equal 0 [get_keys_with_volatile_items r]
$rd close
}
##### HSETEX Active Expiry Tests #####
foreach command {EX PX EXAT PXAT} {
test "HSETEX $command single field expires leaving other fields intact" {
r FLUSHALL
set initial_expired [info_field [r info stats] expired_fields]
r HSET myhash f1 v1 f2 v2
assert_equal 2 [r HLEN myhash]
assert_equal 0 [get_keys_with_volatile_items r]
# Use HSETEX to set expiry
r HSETEX myhash $command [get_short_expire_value $command] FIELDS 1 f1 v1
wait_for_active_expiry r myhash 1 $initial_expired 1
assert_equal 0 [get_keys_with_volatile_items r]
assert_equal "{} v2" [r HGETEX myhash FIELDS 2 f1 f2]
}
test "HSETEX $command multiple fields expire leaving non-expired fields intact" {
r FLUSHALL
set initial_expired [info_field [r info stats] expired_fields]
r HSET myhash f2 v2
assert_equal 1 [r HLEN myhash]
assert_equal 0 [get_keys_with_volatile_items r]
# Set expiry on multiple fields with HSETEX
r HSETEX myhash $command [get_short_expire_value $command] FIELDS 2 f1 v1 f3 v3
wait_for_active_expiry r myhash 1 $initial_expired 2
assert_equal 0 [get_keys_with_volatile_items r]
# Verify only non-expired field remains
assert_equal "{} v2 {}" [r HGETEX myhash FIELDS 3 f1 f2 f3]
}
test "HSETEX $command hash key deleted when all fields expire" {
r FLUSHALL
set initial_expired [info_field [r info stats] expired_fields]
r HSETEX myhash $command [get_short_expire_value $command] FIELDS 1 f1 v1
wait_for_active_expiry r myhash 0 $initial_expired 1
assert_equal 0 [r EXISTS myhash]
}
test "HSETEX $command after HSETEX $command" {
r FLUSHALL
r HSETEX myhash EX 1000000000 FIELDS 1 f1 v1
r HSETEX myhash PX 10 FIELDS 1 f2 v2
}
}
test "HPERSIST cancels HSETEX expiry preventing field deletion" {
r FLUSHALL
r HSET myhash f2 v2
assert_equal 1 [r HLEN myhash]
# Set short expiry
r HSETEX myhash PX [get_short_expire_value PX] FIELDS 1 f1 v1
# Immediately persist to prevent expiry
r HPERSIST myhash FIELDS 1 f1
assert_equal -1 [r HTTL myhash FIELDS 1 f1]
# Wait longer than original expiry time
after 200
# Field should still exist due to PERSIST
assert_equal "v1" [r HGET myhash f1]
assert_equal 2 [r HLEN myhash]
}
test "HSETEX overwrites existing field expiry with new shorter expiry" {
r FLUSHALL
set initial_expired [info_field [r info stats] expired_fields]
r HSET myhash f1 v1
assert_equal 1 [r HLEN myhash]
assert_equal 0 [get_keys_with_volatile_items r]
# Set initial long expiry
r HEXPIRE myhash [get_long_expire_value HEXPIRE] FIELDS 1 f1
assert_equal 1 [get_keys_with_volatile_items r]
assert_morethan [r HTTL myhash FIELDS 1 f1] 5000
# Use HSETEX to set shorter expiry
r HSETEX myhash PX 100 FIELDS 1 f1 v1
# Wait for active expiry with new shorter time
wait_for_active_expiry r myhash 0 $initial_expired 1
assert_equal 0 [get_keys_with_volatile_items r]
assert_equal 0 [r EXISTS myhash]
}
##### HSETEX Active Expiry Keyspace Notifications #####
foreach command {EX PX EXAT PXAT} {
test "HSETEX $command - keyspace notifications fired on field expiry" {
r FLUSHALL
set initial_expired [info_field [r info stats] expired_fields]
r HSET myhash f2 v2
assert_equal 1 [r HLEN myhash]
assert_equal 0 [get_keys_with_volatile_items r]
set rd [setup_single_keyspace_notification r]
r HSETEX myhash $command [get_short_expire_value $command] FIELDS 1 f1 v1
wait_for_active_expiry r myhash 1 $initial_expired 1
assert_keyevent_patterns $rd myhash hset hexpire hexpired
assert_equal 0 [get_keys_with_volatile_items r]
$rd close
}
}
test "HSETEX - keyspace notifications include del event when hash key removed" {
r FLUSHALL
set initial_expired [info_field [r info stats] expired_fields]
set rd [setup_single_keyspace_notification r]
r HSETEX myhash PX 100 FIELDS 1 f1 v1
wait_for_active_expiry r myhash 0 $initial_expired 1
assert_equal 0 [r EXISTS myhash]
assert_keyevent_patterns $rd myhash hset hexpire hexpired del
$rd close
}
##### Active expiry test with 1 node #####
set rd [kv_deferring_client]
assert_equal {1} [psubscribe $rd __keyevent@*]
test {Active expiry deletes entire key when only field expires} {
r FLUSHALL
set initial_expired [info_field [r info stats] expired_fields]
r HSET myhash f1 v1
assert_equal 1 [r HLEN myhash]
assert_equal 1 [get_keys r]
assert_equal 0 [get_keys_with_volatile_items r]
r HPEXPIRE myhash 100 FIELDS 1 f1
wait_for_active_expiry r myhash 0 $initial_expired 1
# Key is deleted after its only field got expired
assert_equal 0 [get_keys r]
assert_equal 0 [get_keys_with_volatile_items r]
assert_equal "" [r HGET myhash f1]
assert_equal 0 [r EXISTS myhash]
# Verify keyspace notifications
assert_keyevent_patterns $rd myhash hset hexpire hexpired del
}
test {Active expiry removes only expired field while preserving others} {
r FLUSHALL
set initial_expired [info_field [r info stats] expired_fields]
r HSET myhash f1 v1 f2 v2 f3 v3
assert_equal 3 [r HLEN myhash]
assert_equal 1 [get_keys r]
assert_equal 0 [get_keys_with_volatile_items r]
r HPEXPIRE myhash 100 FIELDS 1 f1
set mem_before [r MEMORY USAGE myhash]
wait_for_active_expiry r myhash 2 $initial_expired 1
# Key still exists because it has 2 fields remaining
assert_equal 1 [get_keys r]
assert_equal 0 [get_keys_with_volatile_items r]
assert_equal "{} v2 v3" [r HGETEX myhash FIELDS 3 f1 f2 f3]
# Verify memory decreased after field expiry
set mem_after [r MEMORY USAGE myhash]
assert_morethan $mem_before $mem_after
# Verify keyspace notifications
assert_keyevent_patterns $rd myhash hset hexpire hexpired
assert_equal 0 [get_keys_with_volatile_items r]
}
test {Active expiry reclaims memory correctly with large hash containing many fields} {
r FLUSHALL
set initial_expired [info_field [r info stats] expired_fields]
set value [string repeat x 1024]
set num_fields 10000
# Set multiple fields
for {set i 1} {$i <= $num_fields} {incr i} {
lappend pairs "f$i" $value$i
}
r HSET myhash {*}$pairs
assert_equal 0 [get_keys_with_volatile_items r]
assert_equal $num_fields [r HLEN myhash]
set mem_before_expire [r MEMORY USAGE myhash]
if {$mem_before_expire eq ""} {set mem_before_expire 0}
assert_morethan $mem_before_expire 10000000
assert_equal 1 [get_keys r]
assert_equal $num_fields [r HLEN myhash]
r HPEXPIRE myhash 100 FIELDS 1 f1
wait_for_active_expiry r myhash [expr {$num_fields - 1}] $initial_expired 1
# Key still exists because it has num_fields 1 fields remaining
assert_equal 1 [get_keys r]
assert_equal "" [r HGET myhash f1]
for {set i 2} {$i <= $num_fields} {incr i} {
assert_equal $value$i [r HGET myhash "f$i"]
}
assert_equal 0 [get_keys_with_volatile_items r]
# Expire all remaining fields
set all_field_names {}
for {set i 2} {$i <= $num_fields} {incr i} {
lappend all_field_names "f$i"
}
r HPEXPIRE myhash 100 FIELDS [expr {$num_fields - 1}] {*}$all_field_names
wait_for_active_expiry r myhash 0 $initial_expired $num_fields 350 100
# Verify memory decreased by at least 15MB (size of hash key)
set mem_after_expire [r MEMORY USAGE myhash]
if {$mem_after_expire eq ""} {set mem_after_expire 0}
assert_morethan [expr {$mem_before_expire - $mem_after_expire}] 10000000
# Verify keyspace notifications
assert_keyevent_patterns $rd myhash hset hexpire hexpired hexpire hexpired
# Wait for del, maximum num_fields reads
for {set i 2} {$i <= $num_fields} {incr i} {
if {[string match "pmessage __keyevent@* __keyevent@*:del myhash" [$rd read]]} {
break
}
}
assert_equal 0 [get_keys_with_volatile_items r]
}
test {Active expiry handles fields with different TTL values correctly} {
r FLUSHALL
set initial_expired [info_field [r info stats] expired_fields]
r HSET myhash f1 v1 f2 v2 f3 v3
assert_equal 3 [r HLEN myhash]
# Set very short expiry and longer expiry
r HPEXPIRE myhash [get_short_expire_value HPEXPIRE] FIELDS 1 f1
# Wait for f1 to expire
wait_for_active_expiry r myhash 2 $initial_expired 1
r HEXPIRE myhash [get_long_expire_value HEXPIRE] FIELDS 1 f2
# f3 has no expiry
# Verify f2 and f3 still exist
assert_equal 2 [r HLEN myhash]
assert_equal "{} v2 v3" [r HGETEX myhash FIELDS 3 f1 f2 f3]
assert_keyevent_patterns $rd myhash hset hexpire hexpired hexpire
}
test {Active expiry removes only specified fields leaving others intact} {
r FLUSHALL
set initial_expired [info_field [r info stats] expired_fields]
r HSET myhash f1 v1 f2 v2 f3 v3 f4 v4 f5 v5
assert_equal 5 [r HLEN myhash]
# Set expiry on alternating fields
r HPEXPIRE myhash 100 FIELDS 2 f1 f3
# f2, f4, f5 have no expiry
wait_for_active_expiry r myhash 3 $initial_expired 2
# Verify expired fields are gone and non-expired exists
assert_equal "{} v2 {} v4 v5" [r HGETEX myhash FIELDS 5 f1 f2 f3 f4 f5]
# Key should still exist
assert_equal 1 [get_keys r]
}
$rd close
test {Field TTL is removed when field value is overwritten with HSET} {
r FLUSHALL
r HSET myhash f1 v1
r HEXPIRE myhash 100000 FIELDS 1 f1
r HSET myhash f1 v2
# TTL should be removed after overwrite
assert_equal -1 [r HPTTL myhash FIELDS 1 f1]
# Field should still exist
assert_equal "v2" [r HGET myhash f1]
}
# Active expiry with field deletion and recreation
test {Field TTL is cleared when field is deleted and recreated} {
r FLUSHALL
r HSET myhash f1 v1
r HPEXPIRE myhash 100 FIELDS 1 f1
r HDEL myhash f1
r HSET myhash f1 v2
assert_equal -1 [r HPTTL myhash FIELDS 1 f1]
after 200
assert_equal v2 [r HGET myhash f1]
}
##### Test Active Expiry Tests with all hash expire commands #####
foreach command {HEXPIRE HPEXPIRE HEXPIREAT HPEXPIREAT} {
test "$command active expiry on single field" {
r FLUSHALL
set initial_expired [info_field [r info stats] expired_fields]
r HSET myhash f1 v1 f2 v2
assert_equal 2 [r HLEN myhash]
# Set expiry based on command type
r $command myhash [get_short_expire_value $command] FIELDS 1 f1
# Wait for active expiry
wait_for_active_expiry r myhash 1 $initial_expired 1
# Verify only expired field is gone
assert_equal "{} v2" [r HGETEX myhash FIELDS 2 f1 f2]
}
test "$command active expiry with multiple fields" {
r FLUSHALL
set initial_expired [info_field [r info stats] expired_fields]
r HSET myhash f1 v1 f2 v2 f3 v3 f4 v4
assert_equal 4 [r HLEN myhash]
# Set expiry on multiple fields
r $command myhash [get_short_expire_value $command] FIELDS 3 f1 f2 f4
# Wait for active expiry
wait_for_active_expiry r myhash 1 $initial_expired 3
# Only f3 should remain
assert_equal "{} {} v3 {}" [r HGETEX myhash FIELDS 4 f1 f2 f3 f4]
}
test "$command active expiry removes entire key when last field expires" {
r FLUSHALL
set initial_expired [info_field [r info stats] expired_fields]
r HSET myhash f1 v1
assert_equal 1 [r HLEN myhash]
# Set expiry on only field
r $command myhash [get_short_expire_value $command] FIELDS 1 f1
# Wait for active expiry to remove key
wait_for_active_expiry r myhash 0 $initial_expired 1
assert_equal 0 [r EXISTS myhash]
}
test "$command active expiry with non-existing fields" {
r FLUSHALL
set initial_expired [info_field [r info stats] expired_fields]
r HSET myhash f1 v1 f2 v2
assert_equal 2 [r HLEN myhash]
# Try to expire non-existing fields
r $command myhash [get_short_expire_value $command] FIELDS 2 f3 f4
# Wait to ensure no active expiry occurs
after 1500
assert [check_myhash_and_expired_subkeys r myhash 2 $initial_expired 0]
}
test "$command active expiry with mixed existing and non-existing fields" {
r FLUSHALL
set initial_expired [info_field [r info stats] expired_fields]
r HSET myhash f1 v1 f2 v2 f3 v3
assert_equal 3 [r HLEN myhash]
# Mix of existing and non-existing fields
r $command myhash [get_short_expire_value $command] FIELDS 4 f1 f4 f3 f5
# Wait for active expiry of existing fields only
wait_for_active_expiry r myhash 1 $initial_expired 2
# Only f2 should remain
assert_equal "{} v2 {}" [r HGETEX myhash FIELDS 3 f1 f2 f3]
}
test "$command active expiry with already expired fields" {
r FLUSHALL
set initial_expired [info_field [r info stats] expired_fields]
r HSET myhash f1 v1 f2 v2 f3 v3
assert_equal 3 [r HLEN myhash]
# Set very short expiry on f1
r $command myhash [get_short_expire_value $command] FIELDS 1 f1
# Wait for active expiry
wait_for_active_expiry r myhash 2 $initial_expired 1
# Now try to expire f1 again (already expired) and f2 (existing)
r $command myhash [get_short_expire_value $command] FIELDS 2 f1 f2
# Wait for f2 to expire
wait_for_active_expiry r myhash 1 $initial_expired 2
# Only f3 should remain
assert_equal "{} {} v3" [r HGETEX myhash FIELDS 3 f1 f2 f3]
}
}
test "CLIENT PAUSE WRITE blocks hash field active expiry until pause ends" {
r FLUSHALL
set initial_expired [info_field [r info stats] expired_fields]
r HSET myhash f1 v1 f2 v2
assert_equal 2 [r HLEN myhash]
# To avoid flakiness - run commands in transaction
r multi
r HPEXPIRE myhash 500 FIELDS 1 f1
r CLIENT PAUSE 1200 WRITE
r exec
# Verify no expiry happened immediately after transaction
assert_equal 2 [r HLEN myhash]
assert_equal 0 [expr {[info_field [r info stats] expired_fields] - $initial_expired}]
# Wait longer than expiry time while paused
after 600
# Field should still exist because active expiry is paused
assert_equal 2 [r HLEN myhash]
assert_equal 0 [expr {[info_field [r info stats] expired_fields] - $initial_expired}]
# Wait for pause to end
after 600
# Now active expiry should work
wait_for_active_expiry r myhash 1 $initial_expired 1 50 20
assert_equal "{} v2" [r HMGET myhash f1 f2]
}
##### Active Expiry Tests After RENAME/COPY/RESTORE Operations #####
foreach command {HEXPIRE HPEXPIRE HEXPIREAT HPEXPIREAT} {
foreach op {RENAME COPY RESTORE MOVE} {
test "$command active expiry works correctly after $op operation" {
r FLUSHALL
r SELECT 0
set initial_expired [info_field [r info stats] expired_fields]
r HSET myhash f1 v1 f2 v2 f3 v3 f4 v4
assert_equal 4 [r HLEN myhash]
assert_equal 0 [get_keys_with_volatile_items r]
# Set expiry on fields
r $command myhash [get_short_expire_value $command] FIELDS 1 f1
wait_for_active_expiry r myhash 3 $initial_expired 1
r $command myhash [get_long_expire_value $command] FIELDS 1 f4
assert_equal 1 [get_keys_with_volatile_items r]
# Run op command
if {$op eq "RENAME"} {
r RENAME myhash newhash
set target_key newhash
} elseif {$op eq "COPY"} {
r COPY myhash copyhash
set target_key copyhash
} elseif {$op eq "RESTORE"} {
# RESTORE
set serialized [r DUMP myhash]
r DEL myhash
r RESTORE restorehash 0 $serialized
set target_key restorehash
} else {
r MOVE myhash 1
# Switch to target DB
r SELECT 1
set target_key myhash
}
if {$op eq "COPY"} {
assert_equal 2 [get_keys_with_volatile_items r]
} else {
assert_equal 1 [get_keys_with_volatile_items r]
}
# Set expiry on fields after op command
r $command $target_key [get_short_expire_value $command] FIELDS 1 f3
# Wait for active expiry on "new" key
wait_for_active_expiry r $target_key 2 $initial_expired 2
assert_equal "{} v2 {}" [r HMGET $target_key f1 f2 f3]
# In copy verify original hash hasnt changed
if {$op eq "COPY"} {
assert_equal "{} v2 v3" [r HMGET myhash f1 f2 f3]
}
}
}
}
foreach command {HEXPIRE HPEXPIRE HEXPIREAT HPEXPIREAT} {
test "$command active expiry processes multiple hash keys with different field counts" {
r FLUSHALL
set initial_expired [info_field [r info stats] expired_fields]
# Create multiple hash keys
for {set i 1} {$i <= 5} {incr i} {
r HSET hash$i f1 v1_$i f2 v2_$i f3 v3_$i
}
assert_equal 5 [get_keys r]
assert_equal 0 [get_keys_with_volatile_items r]
r $command hash1 [get_short_expire_value $command] FIELDS 1 f1
r $command hash2 [get_short_expire_value $command] FIELDS 2 f1 f2
r $command hash3 [get_short_expire_value $command] FIELDS 3 f1 f2 f3
r $command hash4 [get_short_expire_value $command] FIELDS 1 f2
wait_for_condition 100 100 {
[r HLEN hash1] eq 2 && [r HLEN hash2] eq 1 &&
[r HLEN hash3] eq 0 && [r HLEN hash4] eq 2 && [r HLEN hash5] eq 3 &&
[expr {[info_field [r info stats] expired_fields] - $initial_expired}] eq 7
} else {
fail "Fields should expire across multiple keys"
}
assert_equal "{} v2_1 v3_1" [r HMGET hash1 f1 f2 f3]
assert_equal "{} {} v3_2" [r HMGET hash2 f1 f2 f3]
assert_equal 0 [r EXISTS hash3]
assert_equal "v1_4 {} v3_4" [r HMGET hash4 f1 f2 f3]
assert_equal "v1_5 v2_5 v3_5" [r HMGET hash5 f1 f2 f3]
assert_equal 4 [get_keys r]
assert_equal 0 [get_keys_with_volatile_items r]
# Set long expire
r $command hash1 [get_long_expire_value $command] FIELDS 1 f2
assert_equal 1 [get_keys_with_volatile_items r]
r $command hash2 [get_long_expire_value $command] FIELDS 1 f3
assert_equal 2 [get_keys_with_volatile_items r]
}
}
foreach command {HEXPIRE HPEXPIRE HEXPIREAT HPEXPIREAT} {
test "$command handles mixed short and long expiry times across multiple keys" {
r FLUSHALL
set initial_expired [info_field [r info stats] expired_fields]
r HSET key1 f1 v1 f2 v2 f3 v3
r HSET key2 f1 v1 f2 v2 f3 v3
r HSET key3 f1 v1 f2 v2 f3 v3
r HSET key4 f1 v1 f2 v2 f3 v3
assert_equal 4 [get_keys r]
assert_equal 0 [get_keys_with_volatile_items r]
r $command key2 [get_long_expire_value $command] FIELDS 1 f1
assert_equal 1 [get_keys_with_volatile_items r]
set short_expire [get_short_expire_value $command]
r $command key1 $short_expire FIELDS 1 f1
r $command key3 $short_expire FIELDS 2 f1 f2
r $command key4 $short_expire FIELDS 3 f1 f2 f3
wait_for_condition 100 100 {
[r HLEN key1] eq 2 && [r HLEN key3] eq 1 &&
[r HLEN key4] eq 0 && [expr {[info_field [r info stats] expired_fields] - $initial_expired}] eq 6
} else {
fail "Short expiry fields should expire"
}
assert_equal "{} v2 v3" [r HMGET key1 f1 f2 f3]
assert_equal "v1 v2 v3" [r HMGET key2 f1 f2 f3]
assert_equal "{} {} v3" [r HMGET key3 f1 f2 f3]
assert_equal 0 [r EXISTS key4]
assert_equal 3 [get_keys r]
assert_equal 1 [get_keys_with_volatile_items r]
assert_morethan [r HTTL key2 FIELDS 1 f1] 3000
}
}
foreach command {HEXPIRE HPEXPIRE HEXPIREAT HPEXPIREAT} {
test "$command deletes entire keys when all fields expire while preserving partial keys" {
r FLUSHALL
set initial_expired [info_field [r info stats] expired_fields]
# Create keys where some will be completely deleted
for {set i 1} {$i <= 4} {incr i} {
r HSET delkey$i f1 v1
}
r HSET keepkey f1 v1 f2 v2
# Set expiry on f1 field in delkey1-4 (which is all the fields there)
for {set i 1} {$i <= 4} {incr i} {
r $command delkey$i [get_short_expire_value $command] FIELDS 1 f1
}
r $command keepkey [get_short_expire_value $command] FIELDS 1 f1
# Wait for active expiry - 4 keys deleted, 1 key reduced
wait_for_condition 100 100 {
[r EXISTS delkey1] eq 0 && [r EXISTS delkey2] eq 0 &&
[r EXISTS delkey3] eq 0 && [r EXISTS delkey4] eq 0 &&
[r HLEN keepkey] eq 1 &&
[info_field [r info stats] expired_fields] eq [expr {$initial_expired + 5}]
} else {
fail "Keys should be deleted when last field expires"
}
assert_equal "{} v2" [r HMGET keepkey f1 f2]
}
}
foreach command {HEXPIRE HPEXPIRE HEXPIREAT HPEXPIREAT} {
test "$command active expiry reclaims memory efficiently across multiple large hash keys" {
r FLUSHALL
set initial_expired [info_field [r info stats] expired_fields]
# Create keys with large values
set large_value [string repeat "x" 1024]
# 5 keys, 10 "large" fields in each
for {set i 1} {$i <= 5} {incr i} {
for {set j 1} {$j <= 10} {incr j} {
r HSET myhash$i f$j $large_value$i$j
}
}
# Save initial memory
set total_mem_before 0
for {set i 1} {$i <= 5} {incr i} {
set mem [r MEMORY USAGE myhash$i]
if {$mem eq ""} {set mem 0}
incr total_mem_before $mem
}
# For each key, set expire for 5 fields
for {set i 1} {$i <= 5} {incr i} {
assert_equal {1 1 1 1 1} [r $command myhash$i [get_short_expire_value $command] FIELDS 5 f1 f2 f3 f4 f5]
}
# Wait for expiry
wait_for_condition 100 100 {
[r HLEN myhash1] eq 5 && [r HLEN myhash2] eq 5 &&
[r HLEN myhash3] eq 5 && [r HLEN myhash4] eq 5 &&
[r HLEN myhash5] eq 5 &&
[info_field [r info stats] expired_fields] eq [expr {$initial_expired + 25}]
} else {
fail "25 fields should expire across 5 keys"
}
# Verify memory reduction
set total_mem_after 0
for {set i 1} {$i <= 5} {incr i} {
set mem [r MEMORY USAGE myhash$i]
if {$mem eq ""} {set mem 0}
incr total_mem_after $mem
}
# Memory should be reduced
if {$total_mem_before > 0} {
assert_morethan [expr {$total_mem_before - $total_mem_after}] 10000
}
}
}
##### HINCRBY/HINCRBYFLOAT Active Expiry Tests #####
foreach cmd {HINCRBY HINCRBYFLOAT} {
# Set increment values
if {$cmd eq "HINCRBY"} {
set inc1 2
set inc2 3
set inc3 4
} else {
set inc1 2.5
set inc2 3.5
set inc3 4.5
}
# 1 key, 1 field
test "$cmd recreates field with correct value after active expiry deletion" {
r FLUSHALL
set initial_expired [info_field [r info stats] expired_fields]
r HSET myhash f1 1
assert_equal 1 [r HLEN myhash]
# Set expiry on f1
r HPEXPIRE myhash 100 FIELDS 1 f1
# Wait for active expiry
wait_for_active_expiry r myhash 0 $initial_expired 1
# Try increment after expiry (should recreate field)
r $cmd myhash f1 $inc1
assert_equal $inc1 [r HGET myhash f1]
}
# 1 key, 1 field, increment before expiry
test "$cmd preserves existing TTL when incrementing field value" {
r FLUSHALL
set initial_expired [info_field [r info stats] expired_fields]
r HSET myhash f1 1
assert_equal 1 [r HLEN myhash]
# Set expiry after increment
r HEXPIRE myhash 100000 FIELDS 1 f1
# Increment after expiry set
r $cmd myhash f1 $inc1
# Check value and expiry is still set
assert_equal [expr {$inc1 + 1}] [r HGET myhash f1]
assert_morethan [r HTTL myhash FIELDS 1 f1] 90000
}
# 1 key, 3 fields, increment multiple fields, expiry on multiple fields
test "$cmd handles mix of expired and existing fields during increment operations" {
r FLUSHALL
set initial_expired [info_field [r info stats] expired_fields]
r HSET myhash f1 1 f2 2 f3 3
assert_equal 3 [r HLEN myhash]
# Set expiry on f1 and f3
r HPEXPIRE myhash 100 FIELDS 2 f1 f3
# Wait for active expiry
wait_for_active_expiry r myhash 1 $initial_expired 2
# Increment all fields (f1 and f3 should be recreated, f2 should increment)
r $cmd myhash f1 $inc1
r $cmd myhash f2 $inc2
r $cmd myhash f3 $inc3
# Check values
assert_equal "$inc1 [expr {$inc2+2}] $inc3" [r HMGET myhash f1 f2 f3]
}
# 1 key, 3 fields, increment before expiry, then expire
test "$cmd maintains TTL values when incrementing fields with existing expiry" {
r FLUSHALL
set initial_expired [info_field [r info stats] expired_fields]
r HSET myhash f1 1 f2 2 f3 3
assert_equal 3 [r HLEN myhash]
# Set expiry on f1 and f3
r HEXPIRE myhash 100000 FIELDS 2 f1 f3
# Increment/ Decrement all fields
r $cmd myhash f1 $inc1
r $cmd myhash f3 -$inc3
# Only f2 should remain
assert_equal "[expr {$inc1+1}] 2 [expr {-$inc3+3}]" [r HMGET myhash f1 f2 f3]
}
}
### HDEL WITH ACTIVE EXPIRE #####
test {HDEL removes both expired and non-expired fields deleting key when empty} {
r FLUSHALL
set initial_expired [info_field [r info stats] expired_fields]
r HSET myhash f1 v1 f2 v2
r HEXPIRE myhash 1 FIELDS 1 f1
wait_for_active_expiry r myhash 1 $initial_expired 1
# f1 is expired, f2 is not, f3 does not exist
r HDEL myhash f1 f2 f3
# f1 and f2 should be gone, f3 never existed
assert_equal 0 [r HEXISTS myhash f1]
assert_equal 0 [r HEXISTS myhash f2]
assert_equal 0 [r HEXISTS myhash f3]
# The key should be deleted since all fields are gone
assert_equal 0 [r EXISTS myhash]
}
##### HPERSIST TEST WITH ACTIVE EXPIRY #####
test {HPERSIST returns -2 when attempting to persist already expired field} {
r FLUSHALL
set initial_expired [info_field [r info stats] expired_fields]
r HSET myhash f1 v1
r HPEXPIRE myhash 50 FIELDS 1 f1
wait_for_active_expiry r myhash 0 $initial_expired 1
assert_equal -2 [r HPERSIST myhash FIELDS 1 f1]
assert_equal -2 [r HTTL myhash FIELDS 1 f1]
assert_equal "" [r HGET myhash f1]
}
test {HPEXPIRE works correctly on field after HPERSIST removes its TTL} {
r FLUSHALL
set initial_expired [info_field [r info stats] expired_fields]
r HSET myhash f1 v1
r HEXPIRE myhash 10000 FIELDS 1 f1
r HPERSIST myhash FIELDS 1 f1
r HPEXPIRE myhash 150 FIELDS 1 f1
wait_for_active_expiry r myhash 0 $initial_expired 1
assert_equal 0 [r EXISTS myhash]
}
}
##### Active expiry test slot migration #####
start_cluster 3 0 {tags {"cluster mytest external:skip"} overrides {cluster-node-timeout 1000}} {
# Flush all data on all cluster nodes before starting
for {set i 0} {$i < 3} {incr i} {
R $i FLUSHALL
}
set R0_id [R 0 CLUSTER MYID]
set R1_id [R 1 CLUSTER MYID]
# Use a fixed hash tag to ensure key is in one slot
set key "{mymigrate}myhash"
test {Hash field TTL values and active expiry state preserved during cluster slot migration} {
set initial_expired [info_field [R 0 info stats] expired_fields]
R 0 HSET $key f1 v1 f2 v2 f3 v3
assert_equal 3 [R 0 HLEN $key]
set far_exp [expr {[clock seconds] + 30000}]
R 0 HEXPIREAT $key $far_exp FIELDS 1 f1 ; # f1 with far expire
R 0 HPEXPIRE $key 100 FIELDS 1 f2 ; # f2 with short expire
assert_equal 1 [scan [lindex [regexp -inline {keys_with_volatile_items=([\d]+)} [R 0 info keyspace]] 1] "%d"]
# Wait for short expire field (f2) to be expired by active expire
wait_for_condition 100 100 {
[R 0 HLEN $key] eq 2 &&
[info_field [R 0 info stats] expired_fields] eq [expr {$initial_expired + 1}]
} else {
fail "Fields should have expired"
}
# Verify expired field returns empty string and non-expired returns value
assert_equal "v1 {} v3" [R 0 HMGET $key f1 f2 f3]
# Prepare slot migration
set slot [R 0 CLUSTER KEYSLOT $key]
assert_equal OK [R 1 CLUSTER SETSLOT $slot IMPORTING $R0_id]
assert_equal OK [R 0 CLUSTER SETSLOT $slot MIGRATING $R1_id]
# Migrate key to destination node
R 0 MIGRATE [srv -1 host] [srv -1 port] $key 0 5000
# Complete slot migration
R 0 CLUSTER SETSLOT $slot NODE $R1_id
R 1 CLUSTER SETSLOT $slot NODE $R1_id
set initial_expired [info_field [R 1 info stats] expired_fields]
# Verify after slot migration all fields are present and ttl is kept
assert_match {1} [scan [regexp -inline {keys=([\d]*)} [R 1 info keyspace]] keys=%d]
assert_equal 1 [scan [lindex [regexp -inline {keys_with_volatile_items=([\d]+)} [R 1 info keyspace]] 1] "%d"]
assert_equal 2 [R 1 HLEN $key]
assert_equal "v1 {} v3" [R 1 HMGET $key f1 f2 f3]
assert_equal -1 [R 1 HTTL $key FIELDS 1 f3]
assert_equal $far_exp [R 1 HEXPIRETIME $key FIELDS 1 f1]
assert_equal -2 [R 1 HTTL $key FIELDS 1 f2]
# Set short expiration on all fields (some do not exist)
R 1 HPEXPIRE $key 100 FIELDS 3 f1 f2 f3
# Verify active expiry
wait_for_condition 200 50 {
[R 1 HLEN $key] eq 0 &&
[info_field [R 1 info stats] expired_fields] eq [expr {$initial_expired + 2}]
} else {
fail "All fields should have expired"
}
assert_match "" [scan [regexp -inline {keys=([\d]*)} [R 1 info keyspace]] keys=%d]
# TODO handle empty #Keyspace properly
# assert_equal 0 [scan [lindex [regexp -inline {keys_with_volatile_items=([\d]+)} [R 1 info keyspace]] 1] "%d"]
}
}
##### Active expiry test slot migration with multiple fields #####
start_cluster 3 0 {tags {"cluster mytest external:skip"} overrides {cluster-node-timeout 1000}} {
# Flush all data on all cluster nodes before starting
for {set i 0} {$i < 3} {incr i} {
R $i FLUSHALL
}
set R0_id [R 0 CLUSTER MYID]
set R1_id [R 1 CLUSTER MYID]
# Use a fixed hash tag to ensure key is in one slot
set key "{mymigrate}myhash"
test {Large hash with mixed TTL fields maintains expiry state after cluster slot migration} {
set initial_expired [info_field [R 0 info stats] expired_fields]
set num_fields 100
# Create hash fields
for {set i 1} {$i <= $num_fields} {incr i} {
lappend pairs "f$i" "v$i"
}
R 0 HSET $key {*}$pairs
assert_equal $num_fields [R 0 HLEN $key]
set far_exp [expr {[clock seconds] + 30000}]
# Set large TTL on 25 fields
for {set i 1} {$i <= 25} {incr i} {
R 0 HEXPIREAT $key $far_exp FIELDS 1 "f$i"
}
# Set short TTL on 25 fields
for {set i 26} {$i <= 50} {incr i} {
R 0 HPEXPIRE $key 100 FIELDS 1 "f$i"
}
# wait for short expire field to be expired by active expire
wait_for_condition 100 100 {
[R 0 HLEN $key] eq 75 &&
[info_field [R 0 info stats] expired_fields] eq [expr {$initial_expired + 25}]
} else {
fail "Fields should have expired"
}
# Verify expired fields return empty string and non-expired return values
for {set i 26} {$i <= 50} {incr i} {
assert_equal "" [R 0 HGET $key "f$i"]
}
for {set i 1} {$i <= 25} {incr i} {
assert_equal "v$i" [R 0 HGET $key "f$i"]
}
for {set i 51} {$i <= $num_fields} {incr i} {
assert_equal "v$i" [R 0 HGET $key "f$i"]
}
# Prepare slot migration
set slot [R 0 CLUSTER KEYSLOT $key]
assert_equal OK [R 1 CLUSTER SETSLOT $slot IMPORTING $R0_id]
assert_equal OK [R 0 CLUSTER SETSLOT $slot MIGRATING $R1_id]
# Migrate key to destination node
R 0 MIGRATE [srv -1 host] [srv -1 port] $key 0 5000
# Complete slot migration
R 0 CLUSTER SETSLOT $slot NODE $R1_id
R 1 CLUSTER SETSLOT $slot NODE $R1_id
set initial_expired [info_field [R 1 info stats] expired_fields]
# Verify after slot migration all fields are present and ttl is kept
assert_equal 75 [R 1 HLEN $key]
for {set i 1} {$i <= $num_fields} {incr i} {
if {$i > 50} {
assert_equal -1 [R 1 HTTL $key FIELDS 1 "f$i"]
assert_equal "v$i" [R 1 HGET $key "f$i"]
} else {
if {$i <= 25} {
assert_equal $far_exp [R 1 HEXPIRETIME $key FIELDS 1 f$i]
assert_equal "v$i" [R 1 HGET $key "f$i"]
} else {
assert_equal -2 [R 1 HTTL $key FIELDS 1 "f$i"]
assert_equal "" [R 1 HGET $key "f$i"]
}
}
}
# Set short expiration on all fields (some do not exist)
set fields {}
for {set i 1} {$i <= 100} {incr i} {
lappend fields "f$i"
}
R 1 HPEXPIRE $key 100 FIELDS 100 {*}$fields
# Verify active expiry
wait_for_condition 100 100 {
[R 1 HLEN $key] eq 0 &&
[info_field [R 1 info stats] expired_fields] eq [expr {$initial_expired + 75}]
} else {
fail "All fields should have expired"
}
}
}
##### Active expiry test replication #####
start_server {tags {"hashexpire external:skip"}} {
set primary [srv 0 client]
set primary_host [srv 0 host]
set primary_port [srv 0 port]
start_server {tags {needs:repl external:skip}} {
set replica [srv 0 client]
set replica_host [srv 0 host]
set replica_port [srv 0 port]
# Set this inner layer server as replica
set replica [srv 0 client]
test {Hash field active expiry on primary triggers HDEL replication to replica} {
lassign [setup_replication_test $primary $replica $primary_host $primary_port] primary_initial_expired replica_initial_expired
# Initialize deferred clients and subscribe to keyspace notifications
foreach instance [list $primary $replica] {
$instance config set notify-keyspace-events KEA
}
set rd_primary [kv_deferring_client -1]
set rd_replica [kv_deferring_client $replica_host $replica_port]
foreach rd [list $rd_primary $rd_replica] {
assert_equal {1} [psubscribe $rd __keyevent@*]
}
# Create hash and timing f1 < f2 expiry times
set f1_exp [expr {[clock seconds] + 10000}]
# Setup hash, set expire and set expire 0
$primary HSET myhash f1 v1 f2 v2 ;# Should trigger hset
wait_for_ofs_sync $primary $replica
$primary HPEXPIRE myhash 500 FIELDS 1 f1 ;# Should trigger 1 hexpire and then hexpired (for primary) and 1 hdel (for replica)
wait_for_ofs_sync $primary $replica
# Wait for active expiry
wait_for_active_expiry $primary myhash 1 $primary_initial_expired 1
# Ensure the replica does not increment expired_fields
assert_equal $replica_initial_expired [info_field [$replica info stats] expired_fields]
# Verify expired field returns empty string and non-expired returns value
foreach instance [list $primary $replica] {
assert_equal "{} v2" [$instance HMGET myhash f1 f2]
assert_equal 0 [get_keys_with_volatile_items $instance]
}
# Verify keyspace notification
foreach rd [list $rd_primary $rd_replica] {
assert_keyevent_patterns $rd myhash hset
assert_keyevent_patterns $rd myhash hexpire
}
# primary gets hexpired and replica gets hdel
assert_keyevent_patterns $rd_primary myhash hexpired
assert_keyevent_patterns $rd_replica myhash hdel
$rd_primary close
$rd_replica close
}
start_server {tags {needs:repl external:skip}} {
$primary FLUSHALL
set replica_2 [srv 0 client]
set replica_2_host [srv 0 host]
set replica_2_port [srv 0 port]
test {Hash field TTL and active expiry propagates correctly through chain replication} {
$replica replicaof $primary_host $primary_port
# Wait for R1 to connect to Primary
wait_for_condition 100 100 {
[info_field [$replica info replication] master_link_status] eq "up"
} else {
fail "Replica <-> Primary connection not established"
}
$replica_2 replicaof $replica_host $replica_port
# Wait for R2 to connect to R1
wait_for_condition 100 100 {
[info_field [$replica_2 info replication] master_link_status] eq "up"
} else {
fail "Second replica <-> First replica connection not established"
}
# Initialize deferred clients and subscribe to keyspace notifications
foreach instance [list $primary $replica $replica_2] {
$instance config set notify-keyspace-events KEA
}
set rd_primary [kv_deferring_client -2]
set rd_replica [kv_deferring_client -1]
set rd_replica_2 [kv_deferring_client $replica_2_host $replica_2_port]
foreach rd [list $rd_primary $rd_replica $rd_replica_2] {
assert_equal {1} [psubscribe $rd __keyevent@*]
}
# Create hash and timing f1 < f2 expiry times
set f1_exp [expr {[clock seconds] + 10000}]
############################################# STEUP HASH #############################################
$primary HSET myhash f1 v1 f2 v2 ;# Should trigger 3 hset
$primary HEXPIREAT myhash $f1_exp FIELDS 1 f1 ;# Should trigger 3 hexpire
wait_for_ofs_sync $primary $replica
wait_for_ofs_sync $replica $replica_2
set primary_initial_expired [info_field [$primary info stats] expired_fields]
set replica_initial_expired [info_field [$replica info stats] expired_fields]
set replica_2_initial_expired [info_field [$replica_2 info stats] expired_fields]
$primary HPEXPIRE myhash 100 FIELDS 1 f1 ;# Should trigger 1 hexpired (for primary) and 2 hdel (for replicas)
wait_for_ofs_sync $primary $replica
wait_for_ofs_sync $replica $replica_2
# Wait for active expire
wait_for_active_expiry $primary myhash 1 $primary_initial_expired 1
# Ensure the replica does not increment expired_fields
assert_equal $replica_initial_expired [info_field [$replica info stats] expired_fields]
assert_equal $replica_2_initial_expired [info_field [$replica_2 info stats] expired_fields]
# Verify expired field returns empty string and non-expired returns value
foreach instance [list $primary $replica $replica_2] {
assert_equal "{} v2" [$instance HMGET myhash f1 f2]
assert_equal 0 [get_keys_with_volatile_items $instance]
}
# primary gets hexpired and replicas get hdel
foreach rd [list $rd_primary $rd_replica $rd_replica_2] {
assert_keyevent_patterns $rd myhash hset hexpire hexpire
}
assert_keyevent_patterns $rd_primary myhash hexpired
assert_keyevent_patterns $rd_replica myhash hdel
assert_keyevent_patterns $rd_replica_2 myhash hdel
$rd_primary close
$rd_replica close
$rd_replica_2 close
}
}
proc verify_values {instance f1_exp f2_exp} {
assert_equal $f1_exp [$instance HEXPIRETIME myhash FIELDS 1 f1]
assert_equal $f2_exp [$instance HEXPIRETIME myhash FIELDS 1 f2]
assert_equal -1 [$instance HTTL myhash FIELDS 1 f3]
assert_match {1} [scan [regexp -inline {keys=([\d]*)} [$instance info keyspace]] keys=%d]
assert_equal "v1" [$instance HGET myhash f1]
assert_equal "v2" [$instance HGET myhash f2]
assert_equal "v3" [$instance HGET myhash f3]
assert_equal 3 [$instance HLEN myhash]
}
test {Hash field TTL values remain intact after replica promotion to primary} {
lassign [setup_replication_test $primary $replica $primary_host $primary_port] primary_initial_expired replica_initial_expired
# Initialize deferred clients and subscribe to keyspace notifications
foreach instance [list $primary $replica] {
$instance config set notify-keyspace-events KEA
}
set rd_primary [kv_deferring_client -1]
set rd_replica [kv_deferring_client $replica_host $replica_port]
foreach rd [list $rd_primary $rd_replica] {
assert_equal {1} [psubscribe $rd __keyevent@*]
}
# Create hash fields with TTL on primary
set f1_exp [expr {[clock seconds] + 2000}]
set f2_exp [expr {[clock seconds] + 300000}]
$primary HSET myhash f1 v1 f2 v2 f3 v3
$primary HEXPIREAT myhash $f1_exp FIELDS 1 f1
$primary HEXPIREAT myhash $f2_exp FIELDS 1 f2
# f3 remains persistent
# Wait for full sync
wait_for_ofs_sync $primary $replica
# Verify primary and replica are the same
foreach instance [list $primary $replica] {
verify_values $instance $f1_exp $f2_exp
assert_equal 1 [get_keys_with_volatile_items $instance]
}
# Perform failover
$replica replicaof no one
# Wait for replica to become primary
wait_for_condition 100 100 {
[info_field [$replica info replication] role] eq "master"
} else {
fail "Replica didn't become master"
}
# Check all values that checked before are the same
verify_values $replica $f1_exp $f2_exp
# Set f1 to expire in 1 second and wait for active expiration
set replica_initial_expired [info_field [$replica info stats] expired_fields]
$replica HEXPIRE myhash 1 FIELDS 1 f1
wait_for_active_expiry $replica myhash 2 $replica_initial_expired 1
assert_equal "{} v2 v3" [$replica HMGET myhash f1 f2 f3]
# Not affected primary
assert_equal 3 [$primary HLEN myhash]
assert_equal "v1 v2 v3" [$primary HMGET myhash f1 f2 f3]
set primary_initial_expired [info_field [$primary info stats] expired_fields]
assert_equal 0 [expr {[info_field [$primary info stats] expired_fields] - $primary_initial_expired}]
foreach rd [list $rd_primary $rd_replica] {
assert_keyevent_patterns $rd myhash hset hexpire hexpire
}
assert_keyevent_patterns $rd_replica myhash hexpire
assert_keyevent_patterns $rd_replica myhash hexpired
$rd_primary close
$rd_replica close
}
test {Hash field TTL values persist correctly during FAILOVER command execution} {
lassign [setup_replication_test $primary $replica $primary_host $primary_port] primary_initial_expired replica_initial_expired
# Initialize deferred clients and subscribe to keyspace notifications
foreach instance [list $primary $replica] {
$instance config set notify-keyspace-events KEA
}
set rd_primary [kv_deferring_client -1]
set rd_replica [kv_deferring_client $replica_host $replica_port]
foreach rd [list $rd_primary $rd_replica] {
assert_equal {1} [psubscribe $rd __keyevent@*]
}
# Create hash fields with TTL on primary
set f1_exp [expr {[clock seconds] + 2000}]
set f2_exp [expr {[clock seconds] + 300000}]
$primary HSET myhash f1 v1 f2 v2 f3 v3
$primary HEXPIREAT myhash $f1_exp FIELDS 1 f1
$primary HEXPIREAT myhash $f2_exp FIELDS 1 f2
# f3 remains persistent
# Wait for full sync
wait_for_ofs_sync $primary $replica
# Verify primary and replica are the same
foreach instance [list $primary $replica] {
verify_values $instance $f1_exp $f2_exp
assert_equal 1 [get_keys_with_volatile_items $instance]
}
# Perform failover swap roles
$primary FAILOVER TO $replica_host $replica_port
# Wait for role swap
wait_for_condition 100 100 {
[info_field [$replica info replication] role] eq "master" &&
[info_field [$primary info replication] role] eq "slave"
} else {
fail "Failover didn't complete"
}
# Verify primary and replica are still the same
foreach instance [list $primary $replica] {
verify_values $instance $f1_exp $f2_exp
assert_equal 1 [get_keys_with_volatile_items $instance]
}
# Set f1 to expire in 1 second and wait for active expiration
$replica HEXPIRE myhash 1 FIELDS 1 f1 ;# will trigger hexpire
wait_for_ofs_sync $replica $primary
set replica_initial_expired [info_field [$replica info stats] expired_fields]
wait_for_active_expiry $replica myhash 2 $replica_initial_expired 1
# Verify prev primary, which is now replica of new primary (prev primary) is sync
assert_equal 2 [$primary HLEN myhash]
# Verify expiry
assert_equal "{} v2 v3" [$replica HMGET myhash f1 f2 f3]
assert_equal "" [$primary HGET myhash f1]
assert_equal "v2" [$primary HGET myhash f2]
assert_equal "v3" [$primary HGET myhash f3]
# Primary is now replica, so no expected change in expired_fields
assert_equal [info_field [$primary info stats] expired_fields] $primary_initial_expired
foreach rd [list $rd_primary $rd_replica] {
assert_keyevent_patterns $rd myhash hset hexpire hexpire hexpire
}
assert_keyevent_patterns $rd_replica myhash hexpired
assert_keyevent_patterns $rd_primary myhash hdel
$rd_primary close
$rd_replica close
}
}
}
## Check monitor tests ###
start_server {tags {"hashexpire external:skip"}} {
set primary [srv 0 client]
set primary_host [srv 0 host]
set primary_port [srv 0 port]
start_server {tags {needs:repl external:skip}} {
set replica [srv 0 client]
set replica_host [srv 0 host]
set replica_port [srv 0 port]
# Set this inner layer server as replica
set replica [srv 0 client]
proc setup_replica_monitor_test {primary replica primary_host primary_port replica_host replica_port} {
lassign [setup_replication_test $primary $replica $primary_host $primary_port] primary_initial_expired replica_initial_expired
set rd_replica [kv_deferring_client $replica_host $replica_port]
$rd_replica monitor
assert_match {*OK*} [$rd_replica read]
return [list $primary_initial_expired $rd_replica]
}
proc read_monitor_output {rd_replica read_amount} {
set res {}
set i 0
while {$i < $read_amount} {
set curr_read [$rd_replica read]
# Skip lines with INFO commands
if {[regexp {\"info\"} $curr_read] || [regexp {\"SELECT\"} $curr_read]} {
continue
}
lappend res $curr_read
incr i
}
$rd_replica close
return [join $res " "]
}
# These tests are flaky, probably monitor output should be filtered
test {Multiple expired hash fields are replicated as single HDEL command to replica} {
lassign [setup_replica_monitor_test $primary $replica $primary_host $primary_port $replica_host $replica_port] primary_initial_expired rd_replica
$primary HSET myhash f1 v1 f2 v2 f3 v3
wait_for_ofs_sync $primary $replica
$primary HPEXPIRE myhash 50 FIELDS 1 f2
wait_for_ofs_sync $primary $replica
wait_for_active_expiry $primary myhash 2 $primary_initial_expired 1
set _ [read_monitor_output $rd_replica 3]
} {*HSET*myhash*f1*f2*f3*HDEL*myhash*f2*}
test {HDEL replication includes only actually expired fields not non-existent ones} {
lassign [setup_replica_monitor_test $primary $replica $primary_host $primary_port $replica_host $replica_port] primary_initial_expired rd_replica
$primary HSET myhash f1 v1 f2 v2 f3 v3
wait_for_ofs_sync $primary $replica
$primary HPEXPIRE myhash 50 FIELDS 2 f1 f5
wait_for_ofs_sync $primary $replica
wait_for_active_expiry $primary myhash 2 $primary_initial_expired 1
set _ [read_monitor_output $rd_replica 3]
} {*HSET*myhash*f1*f2*f3*HDEL*myhash*f1*}
}
}
start_server {tags {"hashexpire external:skip"}} {
set primary [srv 0 client]
set primary_host [srv 0 host]
set primary_port [srv 0 port]
start_server {tags {needs:repl external:skip}} {
set replica [srv 0 client]
set replica_host [srv 0 host]
set replica_port [srv 0 port]
set replica_pid [srv 0 pid]
test {expired_fields metric increments only on primary not replica during field expiry} {
lassign [setup_replication_test $primary $replica $primary_host $primary_port] primary_initial_expired replica_initial_expired
# Create hash fields with different TTLs
$primary HSET myhash f1 v1 f2 v2 f3 v3 f4 v4
$primary HEXPIRE myhash 3000 FIELDS 1 f1
$primary HSETEX myhash EX 5000 FIELDS 1 f2 v2
$primary HEXPIRE myhash 60000 FIELDS 1 f3
wait_for_ofs_sync $primary $replica
# Verify PERSIST
assert_equal "v3" [$primary HGETEX myhash PERSIST FIELDS 1 f3]
wait_for_ofs_sync $primary $replica
assert_equal -1 [$primary HTTL myhash FIELDS 1 f3]
assert_equal -1 [$replica HTTL myhash FIELDS 1 f3]
$primary HPEXPIRE myhash 1 FIELDS 1 f1
wait_for_ofs_sync $primary $replica
# Wait for active expiry
wait_for_active_expiry $primary myhash 3 $primary_initial_expired 1
assert_equal 0 [info_field [$replica info stats] expired_fields]
}
test {expired_fields metric correctly tracks sequential field expirations in replication} {
lassign [setup_replication_test $primary $replica $primary_host $primary_port] primary_initial_expired replica_initial_expired
# Initialize deferred clients and subscribe to keyspace notifications
foreach instance [list $primary $replica] {
$instance config set notify-keyspace-events KEA
}
set rd_primary [kv_deferring_client -1]
set rd_replica [kv_deferring_client $replica_host $replica_port]
foreach rd [list $rd_primary $rd_replica] {
assert_equal {1} [psubscribe $rd __keyevent@*]
}
# Create hash fields with different TTLs
$primary HSET myhash f1 v1 f2 v2 f3 v3 f4 v4
$primary HEXPIRE myhash 3000 FIELDS 1 f1
$primary HSETEX myhash EX 5000 FIELDS 1 f2 v2
$primary HEXPIRE myhash 60000 FIELDS 1 f3
wait_for_ofs_sync $primary $replica
# Verify TTLs are set correctly
assert_morethan [$primary HTTL myhash FIELDS 1 f1] 0
assert_morethan [$primary HTTL myhash FIELDS 1 f2] 0
assert_morethan [$primary HTTL myhash FIELDS 1 f3] 0
assert_equal -1 [$primary HTTL myhash FIELDS 1 f4]
assert_equal 4 [$primary HLEN myhash]
assert_equal 4 [$replica HLEN myhash]
# Verify values
assert_equal "v1 v2 v3 v4" [$primary HMGET myhash f1 f2 f3 f4]
assert_equal "v1 v2 v3 v4" [$replica HMGET myhash f1 f2 f3 f4]
# Verify PERSIST
assert_equal "v3" [$primary HGETEX myhash PERSIST FIELDS 1 f3]
wait_for_ofs_sync $primary $replica
assert_equal -1 [$primary HTTL myhash FIELDS 1 f3]
assert_equal -1 [$replica HTTL myhash FIELDS 1 f3]
assert_equal 1 [get_keys_with_volatile_items $primary]
assert_equal 1 [get_keys_with_volatile_items $replica]
# Expire fields one by one
for {set i 1} {$i <= 4} {incr i} {
assert_equal 1 [get_keys $primary]
assert_equal 1 [get_keys $replica]
# Set field to expire immediately
$primary HPEXPIRE myhash 1 FIELDS 1 f$i
wait_for_ofs_sync $primary $replica
# Wait for active expiry
wait_for_active_expiry $primary myhash [expr {4 - $i}] $primary_initial_expired $i
# Replica should NOT increment expired_fields
assert_equal 0 [info_field [$replica info stats] expired_fields]
# Replica should also have the field removed with replication
assert_equal [expr {4 - $i}] [$replica HLEN myhash]
}
assert_equal 0 [get_keys_with_volatile_items $primary]
assert_equal 0 [get_keys_with_volatile_items $replica]
# Hash should be deleted when all fields expire
assert_equal 0 [$primary EXISTS myhash]
assert_equal 0 [$replica EXISTS myhash]
assert_equal 0 [get_keys $primary]
assert_equal 0 [get_keys $replica]
assert_equal 0 [get_keys_with_volatile_items $primary]
assert_equal 0 [get_keys_with_volatile_items $replica]
foreach rd [list $rd_primary $rd_replica] {
assert_keyevent_patterns $rd myhash hset hexpire hset hexpire hexpire hpersist hexpire
}
assert_keyevent_patterns $rd_primary myhash hexpired ; # f1
assert_keyevent_patterns $rd_replica myhash hdel
foreach rd [list $rd_primary $rd_replica] {
assert_keyevent_patterns $rd myhash hexpire
}
assert_keyevent_patterns $rd_primary myhash hexpired ; # f2
assert_keyevent_patterns $rd_replica myhash hdel
foreach rd [list $rd_primary $rd_replica] {
assert_keyevent_patterns $rd myhash hexpire
}
assert_keyevent_patterns $rd_primary myhash hexpired ; # f3
assert_keyevent_patterns $rd_replica myhash hdel
foreach rd [list $rd_primary $rd_replica] {
assert_keyevent_patterns $rd myhash hexpire
}
assert_keyevent_patterns $rd_primary myhash hexpired del ; # f4
assert_keyevent_patterns $rd_replica myhash hdel del
$rd_primary close
$rd_replica close
}
foreach command {HINCRBY HINCRBYFLOAT} {
array set primary_ksn_event {
HINCRBY hincrby
HINCRBYFLOAT hincrbyfloat
}
array set replica_ksn_event {
HINCRBY hincrby
HINCRBYFLOAT hset
}
test "$command is executed on repilca's expired fields" {
lassign [setup_replication_test $primary $replica $primary_host $primary_port] primary_initial_expired replica_initial_expired
# Initialize deferred clients and subscribe to keyspace notifications
foreach instance [list $primary $replica] {
$instance config set notify-keyspace-events KEA
}
set primary_ksn [kv_deferring_client -1]
set replica_ksn [kv_deferring_client $replica_host $replica_port]
foreach rd [list $primary_ksn $replica_ksn] {
assert_equal {1} [psubscribe $rd __keyevent@*]
}
$primary debug set-active-expire 0
$primary flushall
$primary $command myhash f1 1
wait_for_ofs_sync $primary $replica
assert_equal 1 [$primary hpexpire myhash 1 fields 1 f1]
wait_for_condition 50 100 {
[$primary hexists myhash f1] == 0
} else {
fail "Field was not logically expired on primary"
}
$primary $command myhash f1 1
wait_for_ofs_sync $primary $replica
# verify the value is freshly incremented on the primary and replica
assert_equal {1} [$primary hget myhash f1]
assert_equal {1} [$replica hget myhash f1]
# verify the entry has no expiry on the primary and the replica
assert_equal {-1} [$primary httl myhash fields 1 f1]
assert_equal {-1} [$replica httl myhash fields 1 f1]
assert_keyevent_patterns $primary_ksn myhash $primary_ksn_event($command) hexpire hexpired $primary_ksn_event($command)
assert_keyevent_patterns $replica_ksn myhash $replica_ksn_event($command) hexpire hset
$primary_ksn close
$replica_ksn close
$primary debug set-active-expire 1
} {OK} {needs:debug}
}
test {HINCRBYFLOAT maintains TTL on repilca's fields} {
lassign [setup_replication_test $primary $replica $primary_host $primary_port] primary_initial_expired replica_initial_expired
$primary debug set-active-expire 0
$primary flushall
set long_expiry [get_long_expire_value HEXPIRE]
$primary hsetex myhash ex $long_expiry fields 1 f1 1
wait_for_ofs_sync $primary $replica
assert_equal {1} [$primary hget myhash f1]
assert_equal [$replica hget myhash f1] [$primary hget myhash f1]
assert_equal [$primary HPEXPIRETIME myhash FIELDS 1 f1] [$replica HPEXPIRETIME myhash FIELDS 1 f1]
$primary hincrbyfloat myhash f1 1.0
wait_for_ofs_sync $primary $replica
assert_equal {2} [$primary hget myhash f1]
assert_equal [$replica hget myhash f1] [$primary hget myhash f1]
assert_equal [$primary HPEXPIRETIME myhash FIELDS 1 f1] [$replica HPEXPIRETIME myhash FIELDS 1 f1]
$primary debug set-active-expire 1
} {OK} {needs:debug}
test {HSETNX set the value for expired replica field} {
lassign [setup_replication_test $primary $replica $primary_host $primary_port] primary_initial_expired replica_initial_expired
# Initialize deferred clients and subscribe to keyspace notifications
foreach instance [list $primary $replica] {
$instance config set notify-keyspace-events KEA
}
set primary_ksn [kv_deferring_client -1]
set replica_ksn [kv_deferring_client $replica_host $replica_port]
foreach rd [list $primary_ksn $replica_ksn] {
assert_equal {1} [psubscribe $rd __keyevent@*]
}
$primary debug set-active-expire 0
$primary flushall
$primary hsetex myhash px 1 fields 1 f1 v1
wait_for_condition 50 100 {
[$primary hexists myhash f1] == 0
} else {
fail "Field was not logically expired on primary"
}
wait_for_ofs_sync $primary $replica
assert_equal {1} [$primary hlen myhash]
assert_equal {1} [$replica hlen myhash]
assert_equal {0} [$replica hexists myhash f1]
$primary hsetnx myhash f1 v2
wait_for_ofs_sync $primary $replica
assert_equal {v2} [$primary hget myhash f1]
assert_equal {v2} [$replica hget myhash f1]
assert_equal [$primary HPEXPIRETIME myhash FIELDS 1 f1] [$replica HPEXPIRETIME myhash FIELDS 1 f1]
assert_keyevent_patterns $primary_ksn myhash hset hexpire hexpired hset
assert_keyevent_patterns $replica_ksn myhash hset hexpire hset
$primary debug set-active-expire 1
} {OK} {needs:debug}
test {HMSET reports hexpired when overwrites expired fields} {
lassign [setup_replication_test $primary $replica $primary_host $primary_port] primary_initial_expired replica_initial_expired
# Initialize deferred clients and subscribe to keyspace notifications
foreach instance [list $primary $replica] {
$instance config set notify-keyspace-events KEA
}
set primary_ksn [kv_deferring_client -1]
set replica_ksn [kv_deferring_client $replica_host $replica_port]
foreach rd [list $primary_ksn $replica_ksn] {
assert_equal {1} [psubscribe $rd __keyevent@*]
}
$primary debug set-active-expire 0
$primary flushall
$primary hsetex myhash px 1 fields 5 f1 v1 f2 v2 f3 v3 f4 v4 f5 v5
wait_for_condition 50 100 {
[$primary hgetall myhash] eq {}
} else {
fail "Fields were not logically expired on primary"
}
wait_for_ofs_sync $primary $replica
assert_equal {5} [$primary hlen myhash]
assert_equal {5} [$replica hlen myhash]
assert_equal {} [$replica hgetall myhash]
$primary hmset myhash f1 v1 f2 v2 f3 v3 f4 v4 f5 v5
wait_for_ofs_sync $primary $replica
assert_equal [$primary hgetall myhash] [$replica hgetall myhash]
assert_keyevent_patterns $primary_ksn myhash hset hexpire hexpired hset
assert_keyevent_patterns $replica_ksn myhash hset hexpire hset
$primary debug set-active-expire 1
} {OK} {needs:debug}
test {HSETEX KEEPTTL replica should preserve ttl when field is not expired on primary} {
lassign [setup_replication_test $primary $replica $primary_host $primary_port] primary_initial_expired replica_initial_expired
$primary debug set-active-expire 0
$primary hset myhash f1 v1
wait_for_ofs_sync $primary $replica
pause_process $replica_pid
$primary multi
$primary hpexpire myhash 1 fields 1 f1
$primary hsetex myhash KEEPTTL fields 1 f1 v2
$primary exec
# wait for f1 to expired
wait_for_condition 50 100 {
[$primary httl myhash fields 1 f1] == -2
} else {
fail "Field was not logically expired on primary"
}
resume_process $replica_pid
wait_for_ofs_sync $primary $replica
assert_equal {-2} [$primary httl myhash fields 1 f1]
assert_equal {-2} [$replica httl myhash fields 1 f1]
$primary debug set-active-expire 1
} {OK} {needs:debug}
test {HSETEX KEEPTTL replica should NOT preserve ttl when field is expired on primary} {
lassign [setup_replication_test $primary $replica $primary_host $primary_port] primary_initial_expired replica_initial_expired
$primary debug set-active-expire 0
# write a short lived field on the primary and wait for the propagation
$primary hsetex myhash PX 1 fields 1 f1 v1
# wait for f1 to expired
wait_for_condition 50 100 {
[$primary httl myhash fields 1 f1] == -2
} else {
fail "Field was not logically expired on primary"
}
# Now overite the expired field on the primary and wait for it to propagate to the replica
$primary hsetex myhash KEEPTTL fields 1 f1 v2
wait_for_ofs_sync $primary $replica
assert_equal {v2} [$primary hget myhash f1]
assert_equal {v2} [$replica hget myhash f1]
$primary debug set-active-expire 1
} {OK} {needs:debug}
}
}
start_server {tags {"hash"}} {
test {Overwriting hash with volatile fields updates keys_with_volatile_items tracking} {
r FLUSHALL
r DEBUG SET-ACTIVE-EXPIRE 0
r HSETEX myhash EX 100 FIELDS 1 field1 value1
set info1 [r INFO keyspace]
assert_match {*keys_with_volatile_items=1*} $info1
assert_equal 1 [r EXISTS myhash]
r SET myhash "I'm a string now"
set info2 [r INFO keyspace]
assert_match {*keys_with_volatile_items=0*} $info2
assert_equal {string} [r TYPE myhash]
assert_equal "I'm a string now" [r GET myhash]
r DEBUG SET-ACTIVE-EXPIRE 1
} {OK} {needs:debug}
test {RESTORE REPLACE clears keys_with_volatile_items tracking} {
r FLUSHALL
r HSETEX myhash EX 100 FIELDS 1 f1 v1
assert_match {*keys_with_volatile_items=1*} [r INFO keyspace]
r SET tempkey "I'm a string"
set serialized [r DUMP tempkey]
r RESTORE myhash 0 $serialized REPLACE
assert_match {*keys_with_volatile_items=0*} [r INFO keyspace]
assert_equal {string} [r TYPE myhash]
}
test {Zero is a valid ttl in HFE} {
r flushall
r hset myhash f1 v1
assert_equal [r OBJECT ENCODING myhash] "listpack"
assert_equal [r hsetex myhash exat 0 fields 2 f2 v2 f3 v3] 1
assert_equal [r hlen myhash] 1
assert_equal [r OBJECT ENCODING myhash] "listpack"
r config set import-mode yes
assert_equal [r hsetex myhash exat 0 fields 2 f2 v2 f3 v3] 1
assert_equal [r hlen myhash] 3
assert_equal [r OBJECT ENCODING myhash] "hashtable"
r config set import-mode no
wait_for_condition 30 100 {
[r hlen myhash] == 1
} else {
fail "field wasn't expired"
}
}
}