platform/dbops/binaries/redis/src/tests/unit/tracking.tcl

# logreqres:skip because it seems many of these tests rely heavily on RESP2
start_server {tags {"tracking network logreqres:skip"}} {
    # Create a deferred client we'll use to redirect invalidation
    # messages to.
    set rd_redirection [redis_deferring_client]
    $rd_redirection client id
    set redir_id [$rd_redirection read]
    $rd_redirection subscribe __redis__:invalidate
    $rd_redirection read ; # Consume the SUBSCRIBE reply.

    # Create another client that's not used as a redirection client
    # We should always keep this client's buffer clean
    set rd [redis_deferring_client]

    # Client to be used for SET and GET commands
    # We don't read this client's buffer
    set rd_sg [redis_client] 

    proc clean_all {} {
        uplevel {
            # We should make r TRACKING off first. If r is in RESP3,
            # r FLUSH ALL will send us tracking-redir-broken or other
            # info which will not be consumed.
            r CLIENT TRACKING off
            $rd QUIT
            $rd_redirection QUIT
            set rd [redis_deferring_client]
            set rd_redirection [redis_deferring_client]
            $rd_redirection client id
            set redir_id [$rd_redirection read]
            $rd_redirection subscribe __redis__:invalidate
            $rd_redirection read ; # Consume the SUBSCRIBE reply.
            r FLUSHALL
            r HELLO 2
            r config set tracking-table-max-keys 1000000
        }
    }

    test {Clients are able to enable tracking and redirect it} {
        r CLIENT TRACKING on REDIRECT $redir_id
    } {*OK}

    test {The other connection is able to get invalidations} {
        r SET a{t} 1
        r SET b{t} 1
        r GET a{t}
        r INCR b{t} ; # This key should not be notified, since it wasn't fetched.
        r INCR a{t}
        set keys [lindex [$rd_redirection read] 2]
        assert {[llength $keys] == 1}
        assert {[lindex $keys 0] eq {a{t}}}
    }

    test {The client is now able to disable tracking} {
        # Make sure to add a few more keys in the tracking list
        # so that we can check for leaks, as a side effect.
        r MGET a{t} b{t} c{t} d{t} e{t} f{t} g{t}
        r CLIENT TRACKING off
    } {*OK}

    test {Clients can enable the BCAST mode with the empty prefix} {
        r CLIENT TRACKING on BCAST REDIRECT $redir_id
    } {*OK*}

    test {The connection gets invalidation messages about all the keys} {
        r MSET a{t} 1 b{t} 2 c{t} 3
        set keys [lsort [lindex [$rd_redirection read] 2]]
        assert {$keys eq {a{t} b{t} c{t}}}
    }

    test {Clients can enable the BCAST mode with prefixes} {
        r CLIENT TRACKING off
        r CLIENT TRACKING on BCAST REDIRECT $redir_id PREFIX a: PREFIX b:
        r MULTI
        r INCR a:1{t}
        r INCR a:2{t}
        r INCR b:1{t}
        r INCR b:2{t}
        # we should not get this key
        r INCR c:1{t}
        r EXEC
        # Because of the internals, we know we are going to receive
        # two separated notifications for the two different prefixes.
        set keys1 [lsort [lindex [$rd_redirection read] 2]]
        set keys2 [lsort [lindex [$rd_redirection read] 2]]
        set keys [lsort [list {*}$keys1 {*}$keys2]]
        assert {$keys eq {a:1{t} a:2{t} b:1{t} b:2{t}}}
    }

    test {Adding prefixes to BCAST mode works} {
        r CLIENT TRACKING on BCAST REDIRECT $redir_id PREFIX c:
        r INCR c:1234
        set keys [lsort [lindex [$rd_redirection read] 2]]
        assert {$keys eq {c:1234}}
    }

    test {Tracking NOLOOP mode in standard mode works} {
        r CLIENT TRACKING off
        r CLIENT TRACKING on REDIRECT $redir_id NOLOOP
        r MGET otherkey1{t} loopkey{t} otherkey2{t}
        $rd_sg SET otherkey1{t} 1; # We should get this
        r SET loopkey{t} 1 ; # We should not get this
        $rd_sg SET otherkey2{t} 1; # We should get this
        # Because of the internals, we know we are going to receive
        # two separated notifications for the two different keys.
        set keys1 [lsort [lindex [$rd_redirection read] 2]]
        set keys2 [lsort [lindex [$rd_redirection read] 2]]
        set keys [lsort [list {*}$keys1 {*}$keys2]]
        assert {$keys eq {otherkey1{t} otherkey2{t}}}
    }

    test {Tracking NOLOOP mode in BCAST mode works} {
        r CLIENT TRACKING off
        r CLIENT TRACKING on BCAST REDIRECT $redir_id NOLOOP
        $rd_sg SET otherkey1 1; # We should get this
        r SET loopkey 1 ; # We should not get this
        $rd_sg SET otherkey2 1; # We should get this
        # Because $rd_sg send command synchronously, we know we are
        # going to receive two separated notifications.
        set keys1 [lsort [lindex [$rd_redirection read] 2]]
        set keys2 [lsort [lindex [$rd_redirection read] 2]]
        set keys [lsort [list {*}$keys1 {*}$keys2]]
        assert {$keys eq {otherkey1 otherkey2}}
    }

    test {Tracking gets notification of expired keys} {
        r CLIENT TRACKING off
        r CLIENT TRACKING on BCAST REDIRECT $redir_id NOLOOP
        r SET mykey myval px 1
        r SET mykeyotherkey myval ; # We should not get it
        after 1000
        set keys [lsort [lindex [$rd_redirection read] 2]]
        assert {$keys eq {mykey}}
    }

    test {Tracking gets notification of lazy expired keys} {
        r CLIENT TRACKING off
        r CLIENT TRACKING on BCAST REDIRECT $redir_id NOLOOP
        # Use multi-exec to expose a race where the key gets an two invalidations
        # in the same event loop, once by the client so filtered by NOLOOP, and
        # the second one by the lazy expire
        r MULTI
        r SET mykey{t} myval px 1
        r SET mykeyotherkey{t} myval ; # We should not get it
        r DEBUG SLEEP 0.1
        r GET mykey{t}
        r EXEC
        set keys [lsort [lindex [$rd_redirection read] 2]]
        assert {$keys eq {mykey{t}}}
    } {} {needs:debug}

    test {HELLO 3 reply is correct} {
        set reply [r HELLO 3]
        assert_equal [dict get $reply proto] 3
    }

    test {HELLO without protover} {
        set reply [r HELLO 3]
        assert_equal [dict get $reply proto] 3

        set reply [r HELLO]
        assert_equal [dict get $reply proto] 3

        set reply [r HELLO 2]
        assert_equal [dict get $reply proto] 2

        set reply [r HELLO]
        assert_equal [dict get $reply proto] 2

        # restore RESP3 for next test
        r HELLO 3
    }

    test {RESP3 based basic invalidation} {
        r CLIENT TRACKING off
        r CLIENT TRACKING on
        $rd_sg SET key1 1
        r GET key1
        $rd_sg SET key1 2
        r read
    } {invalidate key1}

    test {RESP3 tracking redirection} {
        r CLIENT TRACKING off
        r CLIENT TRACKING on REDIRECT $redir_id
        $rd_sg SET key1 1
        r GET key1
        $rd_sg SET key1 2
        set res [lindex [$rd_redirection read] 2]
        assert {$res eq {key1}}
    }

    test {Invalidations of previous keys can be redirected after switching to RESP3} {
        r HELLO 2
        $rd_sg SET key1 1
        r GET key1
        r HELLO 3
        $rd_sg SET key1 2
        set res [lindex [$rd_redirection read] 2]
        assert {$res eq {key1}}
    }

    test {Invalidations of new keys can be redirected after switching to RESP3} {
        r HELLO 3
        $rd_sg SET key1 1
        r GET key1
        $rd_sg SET key1 2
        set res [lindex [$rd_redirection read] 2]
        assert {$res eq {key1}}
    }

    test {Invalid keys should not be tracked for scripts in NOLOOP mode} {
        $rd_sg CLIENT TRACKING off
        $rd_sg CLIENT TRACKING on NOLOOP
        $rd_sg HELLO 3
        $rd_sg SET key1 1
        assert_equal "1" [$rd_sg GET key1]

        # For write command in script, invalid key should not be tracked with NOLOOP flag
        $rd_sg eval "return redis.call('set', 'key1', '2')" 1 key1
        assert_equal "2" [$rd_sg GET key1]
        $rd_sg CLIENT TRACKING off
    }

    test {Tracking only occurs for scripts when a command calls a read-only command} {
        r CLIENT TRACKING off
        r CLIENT TRACKING on
        $rd_sg MSET key2{t} 1 key2{t} 1

        # If a script doesn't call any read command, don't track any keys
        r EVAL "redis.call('set', 'key3{t}', 'bar')" 2 key1{t} key2{t} 
        $rd_sg MSET key2{t} 2 key1{t} 2
        assert_equal "PONG" [r ping]

        # If a script calls a read command, just the read keys
        r EVAL "redis.call('get', 'key2{t}')" 2 key1{t} key2{t}
        $rd_sg MSET key2{t} 2 key3{t} 2
        assert_equal {invalidate key2{t}} [r read]
        assert_equal "PONG" [r ping]

        # RO variants work like the normal variants

        # If a RO script doesn't call any read command, don't track any keys
        r EVAL_RO "redis.call('ping')" 2 key1{t} key2{t}
        $rd_sg MSET key2{t} 2 key1{t} 2
        assert_equal "PONG" [r ping]

        # If a RO script calls a read command, just the read keys
        r EVAL_RO "redis.call('get', 'key2{t}')" 2 key1{t} key2{t}
        $rd_sg MSET key2{t} 2 key3{t} 2
        assert_equal {invalidate key2{t}} [r read]
        assert_equal "PONG" [r ping]
    }

    test {RESP3 Client gets tracking-redir-broken push message after cached key changed when rediretion client is terminated} {
        r CLIENT TRACKING on REDIRECT $redir_id
        $rd_sg SET key1 1
        r GET key1
        $rd_redirection QUIT
        assert_equal OK [$rd_redirection read]
        $rd_sg SET key1 2
        set MAX_TRIES 100
        set res -1
        for {set i 0} {$i <= $MAX_TRIES && $res < 0} {incr i} {
            set res [lsearch -exact [r PING] "tracking-redir-broken"]
        }
        assert {$res >= 0}
        # Consume PING reply
        assert_equal PONG [r read]

        # Reinstantiating after QUIT
        set rd_redirection [redis_deferring_client]
        $rd_redirection CLIENT ID
        set redir_id [$rd_redirection read]
        $rd_redirection SUBSCRIBE __redis__:invalidate
        $rd_redirection read ; # Consume the SUBSCRIBE reply
    }

    test {Different clients can redirect to the same connection} {
        r CLIENT TRACKING on REDIRECT $redir_id
        $rd CLIENT TRACKING on REDIRECT $redir_id 
        assert_equal OK [$rd read] ; # Consume the TRACKING reply
        $rd_sg MSET key1{t} 1 key2{t} 1
        r GET key1{t}
        $rd GET key2{t} 
        assert_equal 1 [$rd read] ; # Consume the GET reply
        $rd_sg INCR key1{t}
        $rd_sg INCR key2{t}
        set res1 [lindex [$rd_redirection read] 2]
        set res2 [lindex [$rd_redirection read] 2]
        assert {$res1 eq {key1{t}}}
        assert {$res2 eq {key2{t}}}
    }

    test {Different clients using different protocols can track the same key} {
        $rd HELLO 3 
        set reply [$rd read] ; # Consume the HELLO reply
        assert_equal 3 [dict get $reply proto]
        $rd CLIENT TRACKING on 
        assert_equal OK [$rd read] ; # Consume the TRACKING reply
        $rd_sg set key1 1
        r GET key1
        $rd GET key1 
        assert_equal 1 [$rd read] ; # Consume the GET reply
        $rd_sg INCR key1
        set res1 [lindex [$rd_redirection read] 2]
        $rd PING ; # Non redirecting client has to talk to the server in order to get invalidation message
        set res2 [lindex [split [$rd read] " "] 1] 
        assert_equal PONG [$rd read] ; # Consume the PING reply, which comes together with the invalidation message
        assert {$res1 eq {key1}}
        assert {$res2 eq {key1}}
    }

    test {No invalidation message when using OPTIN option} {
        r CLIENT TRACKING on OPTIN REDIRECT $redir_id
        $rd_sg SET key1 1
        r GET key1 ; # This key should not be notified, since OPTIN is on and CLIENT CACHING yes wasn't called
        $rd_sg SET key1 2
        # Preparing some message to consume on $rd_redirection so we don't get blocked
        r CLIENT TRACKING off
        r CLIENT TRACKING on REDIRECT $redir_id
        $rd_sg SET key2 1
        r GET key2 ; # This key should be notified
        $rd_sg SET key2 2
        set res [lindex [$rd_redirection read] 2]
        assert {$res eq {key2}}
    }

    test {Invalidation message sent when using OPTIN option with CLIENT CACHING yes} {
        r CLIENT TRACKING on OPTIN REDIRECT $redir_id
        $rd_sg SET key1 3
        r CLIENT CACHING yes
        r GET key1
        $rd_sg SET key1 4
        set res [lindex [$rd_redirection read] 2]
        assert {$res eq {key1}}
    }

    test {Invalidation message sent when using OPTOUT option} {
        r CLIENT TRACKING off
        r CLIENT TRACKING on OPTOUT REDIRECT $redir_id
        $rd_sg SET key1 1
        r GET key1 
        $rd_sg SET key1 2
        set res [lindex [$rd_redirection read] 2]
        assert {$res eq {key1}}
    }

    test {No invalidation message when using OPTOUT option with CLIENT CACHING no} {
        $rd_sg SET key1 1
        r CLIENT CACHING no
        r GET key1 ; # This key should not be notified, since OPTOUT is on and CLIENT CACHING no was called
        $rd_sg SET key1 2
        # Preparing some message to consume on $rd_redirection so we don't get blocked
        $rd_sg SET key2 1
        r GET key2 ; # This key should be notified
        $rd_sg SET key2 2
        set res [lindex [$rd_redirection read] 2]
        assert {$res eq {key2}}
    }

    test {Able to redirect to a RESP3 client} {
        $rd_redirection UNSUBSCRIBE __redis__:invalidate ; # Need to unsub first before we can do HELLO 3
        set res [$rd_redirection read] ; # Consume the UNSUBSCRIBE reply
        assert_equal {__redis__:invalidate} [lindex $res 1]
        $rd_redirection HELLO 3
        set res [$rd_redirection read] ; # Consume the HELLO reply
        assert_equal [dict get $reply proto] 3
        $rd_redirection SUBSCRIBE __redis__:invalidate
        set res [$rd_redirection read] ; # Consume the SUBSCRIBE reply
        assert_equal {__redis__:invalidate} [lindex $res 1]
        r CLIENT TRACKING on REDIRECT $redir_id
        $rd_sg SET key1 1
        r GET key1
        $rd_sg INCR key1
        set res [lindex [$rd_redirection read] 1]
        assert {$res eq {key1}}
        $rd_redirection HELLO 2
        set res [$rd_redirection read] ; # Consume the HELLO reply
        assert_equal [dict get $res proto] 2
    }

    test {After switching from normal tracking to BCAST mode, no invalidation message is produced for pre-BCAST keys} {
        r CLIENT TRACKING off
        r HELLO 3
        r CLIENT TRACKING on
        $rd_sg SET key1 1
        r GET key1
        r CLIENT TRACKING off 
        r CLIENT TRACKING on BCAST
        $rd_sg INCR key1
        set inv_msg [r PING]
        set ping_reply [r read]
        assert {$inv_msg eq {invalidate key1}}
        assert {$ping_reply eq {PONG}}
    }

    test {BCAST with prefix collisions throw errors} {
        set r [redis_client] 
        catch {$r CLIENT TRACKING ON BCAST PREFIX FOOBAR PREFIX FOO} output
        assert_match {ERR Prefix 'FOOBAR'*'FOO'*} $output

        catch {$r CLIENT TRACKING ON BCAST PREFIX FOO PREFIX FOOBAR} output
        assert_match {ERR Prefix 'FOO'*'FOOBAR'*} $output

        $r CLIENT TRACKING ON BCAST PREFIX FOO PREFIX BAR
        catch {$r CLIENT TRACKING ON BCAST PREFIX FO} output
        assert_match {ERR Prefix 'FO'*'FOO'*} $output

        catch {$r CLIENT TRACKING ON BCAST PREFIX BARB} output
        assert_match {ERR Prefix 'BARB'*'BAR'*} $output

        $r CLIENT TRACKING OFF
    }

    test {hdel deliver invalidate message after response in the same connection} {
        r CLIENT TRACKING off
        r HELLO 3
        r CLIENT TRACKING on
        r HSET myhash f 1
        r HGET myhash f
        set res [r HDEL myhash f]
        assert_equal $res 1
        set res [r read]
        assert_equal $res {invalidate myhash}
    }

    test {Tracking invalidation message is not interleaved with multiple keys response} {
        r CLIENT TRACKING off
        r HELLO 3
        r CLIENT TRACKING on
        # We need disable active expire, so we can trigger lazy expire
        r DEBUG SET-ACTIVE-EXPIRE 0
        r MULTI
        r MSET x{t} 1 y{t} 2
        r PEXPIRE y{t} 100
        r GET y{t}
        r EXEC
        after 110
        # Read expired key y{t}, generate invalidate message about this key
        set res [r MGET x{t} y{t}]
        assert_equal $res {1 {}}
        # Consume the invalidate message which is after command response
        set res [r read]
        assert_equal $res {invalidate y{t}}
        r DEBUG SET-ACTIVE-EXPIRE 1
    } {OK} {needs:debug}

    test {Tracking invalidation message is not interleaved with transaction response} {
        r CLIENT TRACKING off
        r HELLO 3
        r CLIENT TRACKING on
        r MSET a{t} 1 b{t} 2
        r GET a{t}
        # Start a transaction, make a{t} generate an invalidate message
        r MULTI
        r INCR a{t}
        r GET b{t}
        set res [r EXEC]
        assert_equal $res {2 2}
        set res [r read]
        # Consume the invalidate message which is after command response
        assert_equal $res {invalidate a{t}}
    }

    test {Tracking invalidation message of eviction keys should be before response} {
        # Get the current memory limit and calculate a new limit.
        r CLIENT TRACKING off
        r HELLO 3
        r CLIENT TRACKING on

        # make the previous test is really done before sampling used_memory
        wait_lazyfree_done r

        set used [expr {[s used_memory] - [s mem_not_counted_for_evict]}]
        set limit [expr {$used+100*1024}]
        set old_policy [lindex [r config get maxmemory-policy] 1]
        r config set maxmemory $limit
        # We set policy volatile-random, so only keys with ttl will be evicted
        r config set maxmemory-policy volatile-random
        # Add a volatile key and tracking it.
        r setex volatile-key 10000 x
        r get volatile-key
        # We use SETBIT here, so we can set a big key and get the used_memory
        # bigger than maxmemory. Next command will evict volatile keys. We
        # can't use SET, as SET uses big input buffer, so it will fail.
        r setbit big-key 1600000 0 ;# this will consume 200kb
        # volatile-key is evicted before response.
        set res [r getbit big-key 0]
        assert_equal $res {invalidate volatile-key}
        set res [r read]
        assert_equal $res 0
        r config set maxmemory-policy $old_policy
        r config set maxmemory 0
    }

    test {Unblocked BLMOVE gets notification after response} {
        r RPUSH list2{t} a
        $rd HELLO 3
        $rd read
        $rd CLIENT TRACKING on
        $rd read
        # Tracking key list2{t}
        $rd LRANGE list2{t} 0 -1
        $rd read
        # We block on list1{t}
        $rd BLMOVE list1{t} list2{t} left left 0
        wait_for_blocked_clients_count 1
        # unblock $rd, list2{t} gets element and generate invalidation message
        r rpush list1{t} foo
        assert_equal [$rd read] {foo}
        assert_equal [$rd read] {invalidate list2{t}}
    }

    test {Tracking gets notification on tracking table key eviction} {
        r CLIENT TRACKING off
        r CLIENT TRACKING on REDIRECT $redir_id NOLOOP
        r MSET key1{t} 1 key2{t} 2
        # Let the server track the two keys for us
        r MGET key1{t} key2{t}
        # Force the eviction of all the keys but one:
        r config set tracking-table-max-keys 1
        # Note that we may have other keys in the table for this client,
        # since we disabled/enabled tracking multiple time with the same
        # ID, and tracking does not do ID cleanups for performance reasons.
        # So we check that eventually we'll receive one or the other key,
        # otherwise the test will die for timeout.
        while 1 {
            set keys [lindex [$rd_redirection read] 2]
            if {$keys eq {key1{t}} || $keys eq {key2{t}}} break
        }
        # We should receive an expire notification for one of
        # the two keys (only one must remain)
        assert {$keys eq {key1{t}} || $keys eq {key2{t}}}
    }

    test {Invalidation message received for flushall} {
        clean_all
        r CLIENT TRACKING on REDIRECT $redir_id
        $rd_sg SET key1 1
        r GET key1
        $rd_sg FLUSHALL
        set msg [$rd_redirection read]
        assert {[lindex msg 2] eq {} }
    }

    test {Invalidation message received for flushdb} {
        clean_all
        r CLIENT TRACKING on REDIRECT $redir_id
        $rd_sg SET key1 1
        r GET key1
        $rd_sg FLUSHDB
        set msg [$rd_redirection read]
        assert {[lindex msg 2] eq {} }
    }

    test {Test ASYNC flushall} {
        clean_all
        r CLIENT TRACKING on REDIRECT $redir_id
        r GET key1
        r GET key2
        assert_equal [s 0 tracking_total_keys] 2
        $rd_sg FLUSHALL ASYNC
        assert_equal [s 0 tracking_total_keys] 0
        assert_equal [lindex [$rd_redirection read] 2] {}
    }

    test {flushdb tracking invalidation message is not interleaved with transaction response} {
        clean_all
        r HELLO 3
        r CLIENT TRACKING on
        r SET a{t} 1
        r GET a{t}
        r MULTI
        r FLUSHDB
        set res [r EXEC]
        assert_equal $res {OK}
        # Consume the invalidate message which is after command response
        r read
    } {invalidate {}}

    # Keys are defined to be evicted 100 at a time by default.
    # If after eviction the number of keys still surpasses the limit
    # defined in tracking-table-max-keys, we increases eviction 
    # effort to 200, and then 300, etc. 
    # This test tests this effort incrementation. 
    test {Server is able to evacuate enough keys when num of keys surpasses limit by more than defined initial effort} {
        clean_all
        set NUM_OF_KEYS_TO_TEST 250
        set TRACKING_TABLE_MAX_KEYS 1
        r CLIENT TRACKING on REDIRECT $redir_id
        for {set i 0} {$i < $NUM_OF_KEYS_TO_TEST} {incr i} {
            $rd_sg SET key$i $i
            r GET key$i
        }
        r config set tracking-table-max-keys $TRACKING_TABLE_MAX_KEYS
        # If not enough keys are evicted, we won't get enough invalidation
        # messages, and "$rd_redirection read" will block.
        # If too many keys are evicted, we will get too many invalidation
        # messages, and the assert will fail.
        for {set i 0} {$i < $NUM_OF_KEYS_TO_TEST - $TRACKING_TABLE_MAX_KEYS} {incr i} {
            $rd_redirection read
        }
        $rd_redirection PING
        assert {[$rd_redirection read] eq {pong {}}}
    }

    test {Tracking info is correct} {
        clean_all
        r CLIENT TRACKING on REDIRECT $redir_id
        $rd_sg SET key1 1
        $rd_sg SET key2 2
        r GET key1 
        r GET key2
        $rd CLIENT TRACKING on BCAST PREFIX prefix:
        assert [string match *OK* [$rd read]]
        $rd_sg SET prefix:key1 1 
        $rd_sg SET prefix:key2 2
        set info [r info]
        regexp "\r\ntracking_total_items:(.*?)\r\n" $info _ total_items
        regexp "\r\ntracking_total_keys:(.*?)\r\n" $info _ total_keys
        regexp "\r\ntracking_total_prefixes:(.*?)\r\n" $info _ total_prefixes
        regexp "\r\ntracking_clients:(.*?)\r\n" $info _ tracking_clients
        assert {$total_items == 2}
        assert {$total_keys == 2}
        assert {$total_prefixes == 1}
        assert {$tracking_clients == 2}
    }

    test {CLIENT GETREDIR provides correct client id} {
        set res [r CLIENT GETREDIR]
        assert_equal $redir_id $res
        r CLIENT TRACKING off
        set res [r CLIENT GETREDIR]
        assert_equal -1 $res
        r CLIENT TRACKING on
        set res [r CLIENT GETREDIR]
        assert_equal 0 $res
    }

    test {CLIENT TRACKINGINFO provides reasonable results when tracking off} {
        r CLIENT TRACKING off
        set res [r client trackinginfo]
        set flags [dict get $res flags]
        assert_equal {off} $flags
        set redirect [dict get $res redirect]
        assert_equal {-1} $redirect
        set prefixes [dict get $res prefixes]
        assert_equal {} $prefixes
    }

    test {CLIENT TRACKINGINFO provides reasonable results when tracking on} {
        r CLIENT TRACKING on
        set res [r client trackinginfo]
        set flags [dict get $res flags]
        assert_equal {on} $flags
        set redirect [dict get $res redirect]
        assert_equal {0} $redirect
        set prefixes [dict get $res prefixes]
        assert_equal {} $prefixes
    }

    test {CLIENT TRACKINGINFO provides reasonable results when tracking on with options} {
        r CLIENT TRACKING on REDIRECT $redir_id noloop
        set res [r client trackinginfo]
        set flags [dict get $res flags]
        assert_equal {on noloop} $flags
        set redirect [dict get $res redirect]
        assert_equal $redir_id $redirect
        set prefixes [dict get $res prefixes]
        assert_equal {} $prefixes
    }

    test {CLIENT TRACKINGINFO provides reasonable results when tracking optin} {
        r CLIENT TRACKING off
        r CLIENT TRACKING on optin
        set res [r client trackinginfo]
        set flags [dict get $res flags]
        assert_equal {on optin} $flags
        set redirect [dict get $res redirect]
        assert_equal {0} $redirect
        set prefixes [dict get $res prefixes]
        assert_equal {} $prefixes

        r CLIENT CACHING yes
        set res [r client trackinginfo]
        set flags [dict get $res flags]
        assert_equal {on optin caching-yes} $flags
    }

    test {CLIENT TRACKINGINFO provides reasonable results when tracking optout} {
        r CLIENT TRACKING off
        r CLIENT TRACKING on optout
        set res [r client trackinginfo]
        set flags [dict get $res flags]
        assert_equal {on optout} $flags
        set redirect [dict get $res redirect]
        assert_equal {0} $redirect
        set prefixes [dict get $res prefixes]
        assert_equal {} $prefixes

        r CLIENT CACHING no
        set res [r client trackinginfo]
        set flags [dict get $res flags]
        assert_equal {on optout caching-no} $flags
    }

    test {CLIENT TRACKINGINFO provides reasonable results when tracking bcast mode} {
        r CLIENT TRACKING off
        r CLIENT TRACKING on BCAST PREFIX foo PREFIX bar
        set res [r client trackinginfo]
        set flags [dict get $res flags]
        assert_equal {on bcast} $flags
        set redirect [dict get $res redirect]
        assert_equal {0} $redirect
        set prefixes [lsort [dict get $res prefixes]]
        assert_equal {bar foo} $prefixes

        r CLIENT TRACKING off
        r CLIENT TRACKING on BCAST
        set res [r client trackinginfo]
        set prefixes [dict get $res prefixes]
        assert_equal {{}} $prefixes
    }

    test {CLIENT TRACKINGINFO provides reasonable results when tracking redir broken} {
        clean_all
        r HELLO 3
        r CLIENT TRACKING on REDIRECT $redir_id
        $rd_sg SET key1 1
        r GET key1
        $rd_redirection QUIT
        assert_equal OK [$rd_redirection read]
        $rd_sg SET key1 2
        set res [lsearch -exact [r read] "tracking-redir-broken"]
        assert {$res >= 0}
        set res [r client trackinginfo]
        set flags [dict get $res flags]
        assert_equal {on broken_redirect} $flags
        set redirect [dict get $res redirect]
        assert_equal $redir_id $redirect
        set prefixes [dict get $res prefixes]
        assert_equal {} $prefixes
    }

    test {Regression test for #11715} {
        # This issue manifests when a client invalidates keys through the max key
        # limit, which invalidates keys to get Redis below the limit, but no command is
        # then executed. This can occur in several ways but the simplest is through 
        # multi-exec which queues commands.
        clean_all
        r config set tracking-table-max-keys 2

        # The cron will invalidate keys if we're above the limit, so disable it.
        r debug pause-cron 1

        # Set up a client that has listened to 2 keys and start a multi, this
        # sets up the crash for later.
        $rd HELLO 3
        $rd read
        $rd CLIENT TRACKING on
        assert_match "OK" [$rd read]
        $rd mget "1{tag}" "2{tag}"
        assert_match "{} {}" [$rd read]
        $rd multi
        assert_match "OK" [$rd read]

        # Reduce the tracking table keys to 1, this doesn't immediately take affect, but
        # instead will apply on the next command.
        r config set tracking-table-max-keys 1

        # This command will get queued, so make sure this command doesn't crash.
        $rd ping
        $rd exec

        # Validate we got some invalidation message and then the command was queued.
        assert_match "invalidate *{tag}" [$rd read]
        assert_match "QUEUED" [$rd read]
        assert_match "PONG" [$rd read]

        r debug pause-cron 0
    } {OK} {needs:debug}

    foreach resp {3 2} {
        test "RESP$resp based basic invalidation with client reply off" {
            # This entire test is mostly irrelevant for RESP2, but we run it anyway just for some extra coverage.
            clean_all

            $rd hello $resp
            $rd read
            $rd client tracking on
            $rd read

            $rd_sg set foo bar
            $rd get foo
            $rd read

            $rd client reply off

            $rd_sg set foo bar2

            if {$resp == 3} {
                assert_equal {invalidate foo} [$rd read]
            } elseif {$resp == 2} { } ;# Just coverage

            # Verify things didn't get messed up and no unexpected reply was pushed to the client.
            $rd client reply on
            assert_equal {OK} [$rd read]
            $rd ping
            assert_equal {PONG} [$rd read]
        }
    }

    test {RESP3 based basic redirect invalidation with client reply off} {
        clean_all

        set rd_redir [redis_deferring_client]
        $rd_redir hello 3
        $rd_redir read

        $rd_redir client id
        set rd_redir_id [$rd_redir read]

        $rd client tracking on redirect $rd_redir_id
        $rd read

        $rd_sg set foo bar
        $rd get foo
        $rd read

        $rd_redir client reply off

        $rd_sg set foo bar2
        assert_equal {invalidate foo} [$rd_redir read]

        # Verify things didn't get messed up and no unexpected reply was pushed to the client.
        $rd_redir client reply on
        assert_equal {OK} [$rd_redir read]
        $rd_redir ping
        assert_equal {PONG} [$rd_redir read]

        $rd_redir close
    }

    test {RESP3 based basic tracking-redir-broken with client reply off} {
        clean_all

        $rd hello 3
        $rd read
        $rd client tracking on redirect $redir_id
        $rd read

        $rd_sg set foo bar
        $rd get foo
        $rd read

        $rd client reply off

        $rd_redirection quit
        $rd_redirection read

        $rd_sg set foo bar2

        set res [lsearch -exact [$rd read] "tracking-redir-broken"]
        assert_morethan_equal $res 0

        # Verify things didn't get messed up and no unexpected reply was pushed to the client.
        $rd client reply on
        assert_equal {OK} [$rd read]
        $rd ping
        assert_equal {PONG} [$rd read]
    }

    $rd_redirection close
    $rd_sg close
    $rd close
}

# Just some extra covergae for --log-req-res, because we do not
# run the full tracking unit in that mode
start_server {tags {"tracking network"}} {
    test {Coverage: Basic CLIENT CACHING} {
        set rd_redirection [redis_deferring_client]
        $rd_redirection client id
        set redir_id [$rd_redirection read]
        assert_equal {OK} [r CLIENT TRACKING on OPTIN REDIRECT $redir_id]
        assert_equal {OK} [r CLIENT CACHING yes]
        r CLIENT TRACKING off
    } {OK}

    test {Coverage: Basic CLIENT REPLY} {
        r CLIENT REPLY on
    } {OK}

    test {Coverage: Basic CLIENT TRACKINGINFO} {
        r CLIENT TRACKINGINFO
    } {flags off redirect -1 prefixes {}}

    test {Coverage: Basic CLIENT GETREDIR} {
        r CLIENT GETREDIR
    } {-1}
}