mirror of
https://github.com/hanzoai/kv.git
synced 2026-11-09 16:05:35 +00:00
Same shape as MSETEX: the `-X ours` upstream merge took new files and discarded edits to existing ones, so `clusterscan.json` and the whole 459-line test file landed while `clusterscanCommand` never did. The tests have been in the tree failing since; the spec was parked because it generated a reference to a symbol nobody had written. Recovered the chain in order, because the first commit alone is not correct:b70dbec66CLUSTERSCAN Command (#2934)e64150914MATCH pattern maps to a specific slot (#3380)f63e2ce07range bounded scanning across contiguous slots (#3391) #2934 parses SLOT itself and defers COUNT/MATCH/TYPE to scanGenericCommand — which the cursor-"0" path returns before ever reaching, so `CLUSTERSCAN 0 COUNT 0` answered instead of erroring. #3380 replaces that with parseScanOptionsOrReply up front. Landing only the base would have shipped a known-red test. Held back deliberately:3a7fe2ec7fingerprint from configurable_hash_seed (#3679) It needs getConfigurableHashSeed() from #3366, which this tree does not carry either. clusterscanFingerprint() therefore reads the per-process random hashtableGetHashFunctionSeed(), exactly as upstream did before #3679. Bounded, cluster-only consequence: a cursor restarts at 0 after failover rather than surviving it. The two tests that assert otherwise are removed with a comment naming the dependency, so whoever lands #3366 knows to bring them back in the same change. Also repaired four test files the rebrand missed — they called `valkey_cluster` / `valkey_deferring_client{,_by_addr}` when the procs are defined as `kv_*`, so unit/cluster/resharding and two moduleapi suites died with `invalid command name` before running a single test. And `clusterscan` was missing from cluster.tcl's routable-command list, which is a different error with the same cause. Tests: unit/cluster/clusterscan 19/19. Regression over scan, expire, keyspace, hash, set, zset, incr, list — 238 ok, 0 failures (#3391 rewrites scanGenericCommand's cursor handling, so those are the suites that matter). Co-authored-by: Hanzo Dev <[email protected]>
709 lines
22 KiB
Tcl
709 lines
22 KiB
Tcl
set testmodule [file normalize tests/modules/commandresult.so]
|
|
|
|
start_server {tags {"modules"}} {
|
|
r module load $testmodule
|
|
|
|
# Helper to ensure cleanup between tests
|
|
proc cleanup_callback {} {
|
|
catch {r cmdresult.unsubscribe}
|
|
r cmdresult.reset
|
|
}
|
|
|
|
test {Module commandresult - Subscribe to all command result events} {
|
|
cleanup_callback
|
|
r cmdresult.register all
|
|
|
|
# Execute some commands
|
|
r cmdresult.success
|
|
r ping
|
|
catch {r cmdresult.fail} e
|
|
|
|
# Check stats
|
|
set stats [r cmdresult.stats]
|
|
assert {[dict get $stats total_callbacks] >= 3}
|
|
assert {[dict get $stats success_count] >= 2}
|
|
assert {[dict get $stats failure_count] >= 1}
|
|
|
|
r cmdresult.unsubscribe
|
|
}
|
|
|
|
test {Module commandresult - Subscribe to success events only} {
|
|
cleanup_callback
|
|
r cmdresult.register success
|
|
|
|
# Execute successful and failing commands
|
|
r cmdresult.success
|
|
r ping
|
|
r cmdresult.success
|
|
catch {r cmdresult.fail} e
|
|
catch {r cmdresult.fail} e
|
|
|
|
# With success-only subscription, only success events are received
|
|
set stats [r cmdresult.stats]
|
|
assert {[dict get $stats success_count] >= 3}
|
|
# Failures should NOT be tracked since we only subscribed to success
|
|
assert_equal [dict get $stats failure_count] 0
|
|
|
|
r cmdresult.unsubscribe
|
|
}
|
|
|
|
test {Module commandresult - Subscribe to failure events only} {
|
|
cleanup_callback
|
|
r cmdresult.register failure
|
|
|
|
# Execute successful and failing commands
|
|
r cmdresult.success
|
|
r ping
|
|
r cmdresult.success
|
|
catch {r cmdresult.fail} e
|
|
catch {r cmdresult.fail} e
|
|
|
|
# With failure-only subscription, only failure events are received
|
|
set stats [r cmdresult.stats]
|
|
assert_equal [dict get $stats failure_count] 2
|
|
# Successes should NOT be tracked since we only subscribed to failure
|
|
assert_equal [dict get $stats success_count] 0
|
|
|
|
r cmdresult.unsubscribe
|
|
}
|
|
|
|
test {Module commandresult - Callback tracks duration} {
|
|
cleanup_callback
|
|
r cmdresult.register all
|
|
|
|
r eval {local sum = 0; for i = 1, 100000 do sum = sum + i end; return sum} 0
|
|
|
|
set stats [r cmdresult.stats]
|
|
assert {[dict get $stats total_duration_us] > 0}
|
|
|
|
r cmdresult.unsubscribe
|
|
}
|
|
|
|
test {Module commandresult - Callback tracks dirty keys} {
|
|
cleanup_callback
|
|
r cmdresult.register all
|
|
|
|
# This command modifies a key
|
|
r SET ss 3
|
|
|
|
set stats [r cmdresult.stats]
|
|
# Should have at least 1 dirty key
|
|
assert {[dict get $stats total_dirty] >= 1}
|
|
|
|
r cmdresult.unsubscribe
|
|
}
|
|
|
|
test {Module commandresult - Get command log} {
|
|
cleanup_callback
|
|
r cmdresult.register all
|
|
|
|
r cmdresult.success
|
|
catch {r cmdresult.fail} e
|
|
r ping
|
|
|
|
set log [r cmdresult.getlog 3]
|
|
assert_equal [llength $log] 3
|
|
|
|
# Check first entry (most recent - ping)
|
|
set entry [lindex $log 0]
|
|
assert {[dict get $entry command] eq "ping"}
|
|
assert {[dict get $entry status] eq "success"}
|
|
|
|
# Check second entry (cmdresult.fail)
|
|
set entry [lindex $log 1]
|
|
assert {[dict get $entry command] eq "cmdresult.fail"}
|
|
assert {[dict get $entry status] eq "failure"}
|
|
|
|
# Check third entry (cmdresult.success)
|
|
set entry [lindex $log 2]
|
|
assert {[dict get $entry command] eq "cmdresult.success"}
|
|
assert {[dict get $entry status] eq "success"}
|
|
|
|
r cmdresult.unsubscribe
|
|
}
|
|
|
|
test {Module commandresult - Client ID is captured} {
|
|
cleanup_callback
|
|
r cmdresult.register all
|
|
|
|
r cmdresult.success
|
|
|
|
set log [r cmdresult.getlog 1]
|
|
set entry [lindex $log 0]
|
|
# Client ID should be a positive integer
|
|
assert {[dict get $entry client_id] > 0}
|
|
|
|
r cmdresult.unsubscribe
|
|
}
|
|
|
|
test {Module commandresult - is_module_client detection} {
|
|
cleanup_callback
|
|
r cmdresult.register all
|
|
|
|
# Direct command - should NOT be from module client
|
|
r ping
|
|
|
|
set log [r cmdresult.getlog 1]
|
|
set entry [lindex $log 0]
|
|
assert_equal [dict get $entry is_module_client] 0
|
|
|
|
r cmdresult.unsubscribe
|
|
}
|
|
|
|
test {Module commandresult - RM_Call shows is_module_client=1} {
|
|
cleanup_callback
|
|
r cmdresult.register all
|
|
|
|
# This command calls PING via RM_Call
|
|
r cmdresult.rmcall ping
|
|
|
|
set log [r cmdresult.getlog 2]
|
|
# The inner ping should have is_module_client=1
|
|
set ping_entry [lindex $log 1]
|
|
assert {[dict get $ping_entry command] eq "ping"}
|
|
assert_equal [dict get $ping_entry is_module_client] 1
|
|
|
|
r cmdresult.unsubscribe
|
|
}
|
|
|
|
test {Module commandresult - Unsubscribe} {
|
|
cleanup_callback
|
|
r cmdresult.register all
|
|
|
|
r cmdresult.success
|
|
# Unsubscribe also triggers a callback before unsubscribing
|
|
r cmdresult.unsubscribe
|
|
|
|
# After unsubscribe, new commands shouldn't trigger callbacks
|
|
r cmdresult.success
|
|
r ping
|
|
|
|
set stats [r cmdresult.stats]
|
|
# Should have 2 callbacks (cmdresult.success + cmdresult.unsubscribe)
|
|
assert_equal [dict get $stats total_callbacks] 2
|
|
|
|
# Trying to unsubscribe again should fail
|
|
catch {r cmdresult.unsubscribe} err
|
|
assert_match {*not subscribed*} $err
|
|
}
|
|
|
|
test {Module commandresult - Cannot subscribe twice} {
|
|
cleanup_callback
|
|
r cmdresult.register all
|
|
|
|
# Trying to subscribe again should fail
|
|
catch {r cmdresult.register all} err
|
|
assert_match {*already subscribed*} $err
|
|
|
|
r cmdresult.unsubscribe
|
|
}
|
|
|
|
test {Module commandresult - Reset clears stats and log} {
|
|
cleanup_callback
|
|
r cmdresult.register all
|
|
|
|
r cmdresult.success
|
|
r ping
|
|
catch {r cmdresult.fail} e
|
|
|
|
# Verify we have stats
|
|
set stats [r cmdresult.stats]
|
|
assert {[dict get $stats total_callbacks] > 0}
|
|
|
|
# Reset should clear everything
|
|
cleanup_callback
|
|
|
|
set stats [r cmdresult.stats]
|
|
assert_equal [dict get $stats total_callbacks] 0
|
|
assert_equal [dict get $stats success_count] 0
|
|
assert_equal [dict get $stats failure_count] 0
|
|
assert_equal [dict get $stats rejected_count] 0
|
|
assert_equal [dict get $stats acl_denied_count] 0
|
|
|
|
set log [r cmdresult.getlog]
|
|
assert_equal [llength $log] 0
|
|
}
|
|
|
|
test {Module commandresult - Invalid mode returns error} {
|
|
cleanup_callback
|
|
|
|
catch {r cmdresult.register invalid_mode} err
|
|
assert_match {*invalid mode*} $err
|
|
}
|
|
|
|
test {Module commandresult - Command name is captured correctly} {
|
|
cleanup_callback
|
|
r cmdresult.register all
|
|
|
|
r cmdresult.success
|
|
r set mykey myvalue
|
|
r get mykey
|
|
|
|
set log [r cmdresult.getlog 3]
|
|
|
|
# Check that command names are correct
|
|
set commands [list]
|
|
foreach entry $log {
|
|
lappend commands [dict get $entry command]
|
|
}
|
|
|
|
assert {[lsearch $commands "get"] >= 0}
|
|
assert {[lsearch $commands "set"] >= 0}
|
|
assert {[lsearch $commands "cmdresult.success"] >= 0}
|
|
|
|
r cmdresult.unsubscribe
|
|
}
|
|
|
|
test {Module commandresult - Unload with active subscription} {
|
|
cleanup_callback
|
|
r cmdresult.register all
|
|
|
|
# Execute some commands to ensure callback is active
|
|
r cmdresult.success
|
|
r ping
|
|
|
|
set stats [r cmdresult.stats]
|
|
assert {[dict get $stats total_callbacks] >= 2}
|
|
|
|
# Unload module while subscription is still active.
|
|
assert_equal {OK} [r module unload commandresult]
|
|
|
|
# Unsubscribing after reload has no matching listener. It must not add
|
|
# NULL callbacks that would be invoked by later command result events.
|
|
r module load $testmodule
|
|
catch {r cmdresult.unsubscribe} err
|
|
assert_match {*not subscribed*} $err
|
|
assert_equal {PONG} [r ping]
|
|
}
|
|
|
|
test {Module commandresult - Multiple callbacks from different operations} {
|
|
cleanup_callback
|
|
r cmdresult.register all
|
|
|
|
# Test callbacks from various sources
|
|
r set testkey testvalue ;# Built-in command
|
|
r get testkey ;# Built-in command
|
|
r cmdresult.success ;# Module command
|
|
catch {r cmdresult.fail} e ;# Failing module command
|
|
|
|
set stats [r cmdresult.stats]
|
|
# Should have at least 4 callbacks
|
|
assert {[dict get $stats total_callbacks] >= 4}
|
|
assert {[dict get $stats success_count] >= 3}
|
|
assert {[dict get $stats failure_count] >= 1}
|
|
|
|
r cmdresult.unsubscribe
|
|
}
|
|
|
|
test {Module commandresult - Empty subscription optimization} {
|
|
cleanup_callback
|
|
# No subscription - this tests early return when no modules subscribed
|
|
|
|
# Execute commands without any subscriptions
|
|
r cmdresult.success
|
|
r ping
|
|
|
|
# Verify no callbacks were fired
|
|
set stats [r cmdresult.stats]
|
|
assert_equal [dict get $stats total_callbacks] 0
|
|
}
|
|
|
|
test {Module commandresult - Duration is always positive} {
|
|
cleanup_callback
|
|
r cmdresult.register all
|
|
|
|
# Execute a command
|
|
r cmdresult.success
|
|
|
|
set log [r cmdresult.getlog 1]
|
|
set entry [lindex $log 0]
|
|
|
|
# Duration should be >= 0 microseconds
|
|
assert {[dict get $entry duration_us] >= 0}
|
|
|
|
r cmdresult.unsubscribe
|
|
}
|
|
|
|
test {Module commandresult - RM_Call creates nested command execution} {
|
|
cleanup_callback
|
|
r cmdresult.register all
|
|
|
|
# cmdresult.rmcall calls PING via RM_Call
|
|
# Both the wrapper and inner command should be tracked
|
|
r cmdresult.rmcall ping
|
|
|
|
set stats [r cmdresult.stats]
|
|
# Should see both cmdresult.rmcall and ping callbacks
|
|
assert {[dict get $stats total_callbacks] >= 2}
|
|
|
|
r cmdresult.unsubscribe
|
|
}
|
|
|
|
test {Module commandresult - argv captures command arguments} {
|
|
cleanup_callback
|
|
r cmdresult.register all
|
|
|
|
# Execute a command with arguments
|
|
r set mykey myvalue
|
|
|
|
set log [r cmdresult.getlog 1]
|
|
set entry [lindex $log 0]
|
|
|
|
# Check argv is captured
|
|
set argv [dict get $entry argv]
|
|
assert_equal [lindex $argv 0] "set"
|
|
assert_equal [lindex $argv 1] "mykey"
|
|
assert_equal [lindex $argv 2] "myvalue"
|
|
|
|
r cmdresult.unsubscribe
|
|
}
|
|
|
|
test {Module commandresult - argv captures multi-argument commands} {
|
|
cleanup_callback
|
|
r cmdresult.register all
|
|
|
|
# Execute MSET with multiple key-value pairs
|
|
r mset key1 val1 key2 val2 key3 val3
|
|
|
|
set log [r cmdresult.getlog 1]
|
|
set entry [lindex $log 0]
|
|
|
|
set argv [dict get $entry argv]
|
|
assert_equal [lindex $argv 0] "mset"
|
|
assert_equal [lindex $argv 1] "key1"
|
|
assert_equal [lindex $argv 2] "val1"
|
|
assert_equal [lindex $argv 3] "key2"
|
|
assert_equal [lindex $argv 4] "val2"
|
|
|
|
r cmdresult.unsubscribe
|
|
}
|
|
|
|
test {Module commandresult - argv with command rewriting} {
|
|
cleanup_callback
|
|
r cmdresult.register all
|
|
|
|
# EXPIRE gets rewritten to PEXPIREAT internally
|
|
# But we should see original argv (EXPIRE)
|
|
r set rewritekey "value"
|
|
r expire rewritekey 100
|
|
|
|
set log [r cmdresult.getlog 1]
|
|
set entry [lindex $log 0]
|
|
|
|
set argv [dict get $entry argv]
|
|
# Should see original command, not rewritten one
|
|
assert_equal [string tolower [lindex $argv 0]] "expire"
|
|
assert_equal [lindex $argv 1] "rewritekey"
|
|
assert_equal [lindex $argv 2] "100"
|
|
|
|
r cmdresult.unsubscribe
|
|
}
|
|
|
|
test {Module commandresult - High volume command tracking} {
|
|
cleanup_callback
|
|
r cmdresult.register all
|
|
|
|
# Run many commands
|
|
for {set i 0} {$i < 100} {incr i} {
|
|
r ping
|
|
}
|
|
|
|
set stats [r cmdresult.stats]
|
|
assert {[dict get $stats total_callbacks] >= 100}
|
|
|
|
r cmdresult.unsubscribe
|
|
}
|
|
|
|
test {Module commandresult - acl_rejected: command not permitted (ACL_DENIED_CMD)} {
|
|
cleanup_callback
|
|
r cmdresult.register acl_rejected
|
|
|
|
# Create a user with no command permissions and authenticate
|
|
r acl setuser testuser_cmd on >testpass nocommands
|
|
set rd [kv_deferring_client]
|
|
$rd auth testuser_cmd testpass
|
|
$rd read
|
|
$rd get somekey
|
|
catch {$rd read} e
|
|
$rd close
|
|
|
|
set stats [r cmdresult.stats]
|
|
assert {[dict get $stats acl_denied_count] >= 1}
|
|
assert_equal [dict get $stats success_count] 0
|
|
assert_equal [dict get $stats failure_count] 0
|
|
assert_equal [dict get $stats rejected_count] 0
|
|
|
|
set log [r cmdresult.getlog 1]
|
|
set entry [lindex $log 0]
|
|
assert_equal [dict get $entry status] "acl_rejected"
|
|
# VALKEYMODULE_ACL_LOG_CMD = 1
|
|
assert_equal [dict get $entry subevent] 1
|
|
assert_equal [dict get $entry rejection_context] ""
|
|
|
|
r acl deluser testuser_cmd
|
|
r cmdresult.unsubscribe
|
|
}
|
|
|
|
test {Module commandresult - acl_rejected: key pattern not permitted (ACL_DENIED_KEY)} {
|
|
cleanup_callback
|
|
r cmdresult.register acl_rejected
|
|
|
|
# Create a user allowed to run GET but only on keys matching "allowed:*"
|
|
r acl setuser testuser_key on >testpass allcommands ~allowed:* nopass
|
|
set rd [kv_deferring_client]
|
|
$rd auth testuser_key testpass
|
|
$rd read
|
|
$rd get denied_key
|
|
catch {$rd read} e
|
|
$rd close
|
|
|
|
set stats [r cmdresult.stats]
|
|
assert {[dict get $stats acl_denied_count] >= 1}
|
|
|
|
set log [r cmdresult.getlog 1]
|
|
set entry [lindex $log 0]
|
|
assert_equal [dict get $entry status] "acl_rejected"
|
|
# VALKEYMODULE_ACL_LOG_KEY = 2
|
|
assert_equal [dict get $entry subevent] 2
|
|
assert_equal [dict get $entry rejection_context] "denied_key"
|
|
|
|
r acl deluser testuser_key
|
|
r cmdresult.unsubscribe
|
|
}
|
|
|
|
test {Module commandresult - acl_rejected: channel not permitted (ACL_DENIED_CHANNEL)} {
|
|
cleanup_callback
|
|
r cmdresult.register acl_rejected
|
|
|
|
# Create a user with allcommands but no pub/sub channel access
|
|
r acl setuser testuser_chan on >testpass allcommands allkeys resetchannels nopass
|
|
set rd [kv_deferring_client]
|
|
$rd auth testuser_chan testpass
|
|
$rd read
|
|
$rd subscribe secret_channel
|
|
catch {$rd read} e
|
|
$rd close
|
|
|
|
set stats [r cmdresult.stats]
|
|
assert {[dict get $stats acl_denied_count] >= 1}
|
|
|
|
set log [r cmdresult.getlog 1]
|
|
set entry [lindex $log 0]
|
|
assert_equal [dict get $entry status] "acl_rejected"
|
|
# VALKEYMODULE_ACL_LOG_CHANNEL = 3
|
|
assert_equal [dict get $entry subevent] 3
|
|
assert_equal [dict get $entry rejection_context] "secret_channel"
|
|
|
|
r acl deluser testuser_chan
|
|
r cmdresult.unsubscribe
|
|
}
|
|
|
|
test {Module commandresult - acl_rejected events not fired when not subscribed} {
|
|
cleanup_callback
|
|
r cmdresult.register failure
|
|
|
|
r acl setuser testuser_nosub on >testpass nocommands nopass
|
|
set rd [kv_deferring_client]
|
|
$rd auth testuser_nosub testpass
|
|
$rd read
|
|
$rd get somekey
|
|
catch {$rd read} e
|
|
$rd close
|
|
|
|
set stats [r cmdresult.stats]
|
|
assert_equal [dict get $stats acl_denied_count] 0
|
|
assert_equal [dict get $stats rejected_count] 0
|
|
|
|
r acl deluser testuser_nosub
|
|
r cmdresult.unsubscribe
|
|
}
|
|
|
|
test {Module commandresult - acl_rejected: unauthenticated command (NOAUTH)} {
|
|
cleanup_callback
|
|
r cmdresult.register acl_rejected
|
|
|
|
# Enable password so new connections require authentication
|
|
r config set requirepass testpass
|
|
|
|
# Open a raw unauthenticated connection and send a command without AUTH
|
|
set rd [kv_deferring_client_by_addr [srv 0 host] [srv 0 port]]
|
|
$rd get somekey
|
|
catch {$rd read} e
|
|
$rd close
|
|
|
|
# Restore: the existing r session stays authenticated; just clear the password
|
|
r config set requirepass ""
|
|
|
|
set stats [r cmdresult.stats]
|
|
assert {[dict get $stats acl_denied_count] >= 1}
|
|
|
|
set log [r cmdresult.getlog 1]
|
|
set entry [lindex $log 0]
|
|
assert_equal [dict get $entry status] "acl_rejected"
|
|
# VALKEYMODULE_ACL_LOG_AUTH = 0
|
|
assert_equal [dict get $entry subevent] 0
|
|
assert_equal [dict get $entry rejection_context] ""
|
|
|
|
r cmdresult.unsubscribe
|
|
}
|
|
|
|
test {Module commandresult - Reset clears acl_denied_count} {
|
|
cleanup_callback
|
|
r cmdresult.register acl_rejected
|
|
|
|
r acl setuser testuser_reset on >testpass nocommands nopass
|
|
set rd [kv_deferring_client]
|
|
$rd auth testuser_reset testpass
|
|
$rd read
|
|
$rd get somekey
|
|
catch {$rd read} e
|
|
$rd close
|
|
|
|
set stats [r cmdresult.stats]
|
|
assert {[dict get $stats acl_denied_count] >= 1}
|
|
|
|
r cmdresult.reset
|
|
set stats [r cmdresult.stats]
|
|
assert_equal [dict get $stats acl_denied_count] 0
|
|
assert_equal [dict get $stats rejected_count] 0
|
|
assert_equal [dict get $stats total_callbacks] 0
|
|
|
|
r acl deluser testuser_reset
|
|
r cmdresult.unsubscribe
|
|
}
|
|
|
|
test {Module commandresult - rejected: unknown command (UNKNOWNCMD)} {
|
|
cleanup_callback
|
|
r cmdresult.register rejected
|
|
|
|
catch {r thisdoesnotexist} e
|
|
|
|
set stats [r cmdresult.stats]
|
|
assert {[dict get $stats rejected_count] >= 1}
|
|
|
|
set log [r cmdresult.getlog 1]
|
|
set entry [lindex $log 0]
|
|
assert_equal [dict get $entry status] "rejected"
|
|
assert_match {*unknown*command*} [string tolower [dict get $entry rejection_context]]
|
|
|
|
r cmdresult.unsubscribe
|
|
}
|
|
|
|
test {Module commandresult - rejected: wrong number of arguments (WRONGARITY)} {
|
|
cleanup_callback
|
|
r cmdresult.register rejected
|
|
|
|
catch {r set} e
|
|
|
|
set stats [r cmdresult.stats]
|
|
assert {[dict get $stats rejected_count] >= 1}
|
|
|
|
set log [r cmdresult.getlog 1]
|
|
set entry [lindex $log 0]
|
|
assert_equal [dict get $entry status] "rejected"
|
|
assert_equal [dict get $entry command] "set"
|
|
assert_match {*wrong*number*arguments*} [string tolower [dict get $entry rejection_context]]
|
|
|
|
r cmdresult.unsubscribe
|
|
}
|
|
|
|
test {Module commandresult - rejected: command not allowed in MULTI (NOMULTI)} {
|
|
cleanup_callback
|
|
r cmdresult.register rejected
|
|
|
|
r multi
|
|
catch {r multi} e
|
|
r discard
|
|
|
|
set stats [r cmdresult.stats]
|
|
assert {[dict get $stats rejected_count] >= 1}
|
|
|
|
set log [r cmdresult.getlog 1]
|
|
set entry [lindex $log 0]
|
|
assert_equal [dict get $entry status] "rejected"
|
|
assert_equal [dict get $entry command] "multi"
|
|
assert_match {*not allowed inside a transaction*} [string tolower [dict get $entry rejection_context]]
|
|
|
|
r cmdresult.unsubscribe
|
|
}
|
|
|
|
test {Module commandresult - rejected: command not allowed in Pub/Sub context (PUBSUB)} {
|
|
cleanup_callback
|
|
if {$::force_resp3} {
|
|
skip "RESP3 Pub/Sub clients may issue arbitrary commands"
|
|
}
|
|
r cmdresult.register rejected
|
|
|
|
set rd [kv_deferring_client]
|
|
$rd subscribe testchan
|
|
$rd read
|
|
$rd set foo bar
|
|
catch {$rd read} e
|
|
$rd unsubscribe testchan
|
|
$rd read
|
|
$rd close
|
|
|
|
set stats [r cmdresult.stats]
|
|
assert {[dict get $stats rejected_count] >= 1}
|
|
|
|
set log [r cmdresult.getlog 1]
|
|
set entry [lindex $log 0]
|
|
assert_equal [dict get $entry status] "rejected"
|
|
assert_equal [dict get $entry command] "set"
|
|
assert_match {*only*(p|s)subscribe*} [string tolower [dict get $entry rejection_context]]
|
|
|
|
r cmdresult.unsubscribe
|
|
}
|
|
|
|
test {Module commandresult - rejected: not enough replicas (NOREPLICAS)} {
|
|
cleanup_callback
|
|
r cmdresult.register rejected
|
|
|
|
r config set min-replicas-to-write 100
|
|
|
|
catch {r set foo bar} e
|
|
assert_match {*NOREPLICAS*} $e
|
|
|
|
r config set min-replicas-to-write 0
|
|
|
|
set stats [r cmdresult.stats]
|
|
assert {[dict get $stats rejected_count] >= 1}
|
|
|
|
set log [r cmdresult.getlog 1]
|
|
set entry [lindex $log 0]
|
|
assert_equal [dict get $entry status] "rejected"
|
|
assert_equal [dict get $entry command] "set"
|
|
assert_match {*NOREPLICAS*} [dict get $entry rejection_context]
|
|
|
|
r cmdresult.unsubscribe
|
|
}
|
|
|
|
test {Module commandresult - rejected: out of memory (OOM)} {
|
|
cleanup_callback
|
|
r cmdresult.register rejected
|
|
|
|
r config set maxmemory 1
|
|
r config set maxmemory-policy noeviction
|
|
|
|
catch {r set oomkey oomval} e
|
|
assert_match {*OOM*} $e
|
|
|
|
r config set maxmemory 0
|
|
|
|
set stats [r cmdresult.stats]
|
|
assert {[dict get $stats rejected_count] >= 1}
|
|
|
|
set log [r cmdresult.getlog 1]
|
|
set entry [lindex $log 0]
|
|
assert_equal [dict get $entry status] "rejected"
|
|
assert_match {*OOM*} [dict get $entry rejection_context]
|
|
|
|
r cmdresult.unsubscribe
|
|
}
|
|
|
|
test {Unload the module - commandresult} {
|
|
catch {r cmdresult.unsubscribe}
|
|
assert_equal {OK} [r module unload commandresult]
|
|
}
|
|
}
|