Pass zrevrange key as a list in options["keys"] to match sibling range commands (#4244)

* Pass zrevrange key as a list to match sibling range commands

ZREVRANGE stored its key in options["keys"] as a bare string, while every
sibling range command (zrange, zrangebyscore, zrevrangebyscore) passes it as
a list: options["keys"] = [name].

Consumers of options["keys"] iterate it as a sequence of keys. For a bare
string that walks the key character by character -- for example client-side
cache key construction builds CacheKey(redis_keys=tuple(keys)), turning key
"myzset" into ('m', 'y', 'z', 's', 'e', 't') instead of ('myzset',).

Wrap the key in a list to match the other range commands, and add a
regression test asserting zrevrange passes keys=[name].

* Move zrevrange regression test to the cache level

Address review: replace the test that asserted the internal `keys` kwarg with
a behavior-level regression test in tests/test_cache.py. It caches a
`zrevrange` result, asserts the entry is stored under the whole-key cache key
(`redis_keys=("myzset",)`) rather than per-character, and that mutating the
sorted set from a second client invalidates it. This fails on master and
passes with the fix, and protects the behavior rather than the plumbing.

---------

Co-authored-by: uttam12331 <uttam12331@users.noreply.github.com>
Co-authored-by: petyaslavova <petya.slavova@redis.com>

Author: uttam12331

redis/commands/core.py

@@ -8988,7 +8988,7 @@ def zrevrange(
         if withscores:
             pieces.append(b"WITHSCORES")
         options = {"withscores": withscores, "score_cast_func": score_cast_func}
-        options["keys"] = name
+        options["keys"] = [name]
         return self.execute_command(*pieces, **options)
 
     @overload

tests/test_cache.py

@@ -99,6 +99,47 @@ def test_get_from_given_cache(self, r, r2):
             "barbar",
         ]
 
+    @pytest.mark.parametrize(
+        "r",
+        [
+            {
+                "cache": DefaultCache(CacheConfig(max_size=5)),
+                "single_connection_client": True,
+            },
+            {
+                "cache": DefaultCache(CacheConfig(max_size=5)),
+                "single_connection_client": False,
+            },
+        ],
+        ids=["single", "pool"],
+        indirect=True,
+    )
+    @pytest.mark.onlynoncluster
+    def test_zrevrange_cache_key_uses_whole_key(self, r, r2):
+        # Regression: zrevrange stored options["keys"] as a bare string, so the
+        # cache key was built from the key's individual characters
+        # (("m", "y", "z", ...)) instead of the whole key. Verify the result is
+        # cached under redis_keys=("myzset",) and invalidated when the set
+        # changes from another client.
+        cache = r.get_cache()
+        r.delete("myzset")
+        r.zadd("myzset", {"a": 1, "b": 2})
+        # populate the local cache
+        assert r.zrevrange("myzset", 0, -1) == [b"b", b"a"]
+        # the entry must be stored under the whole key, not per-character
+        cache_key = CacheKey(
+            command="ZREVRANGE",
+            redis_keys=("myzset",),
+            redis_args=("ZREVRANGE", "myzset", 0, -1),
+        )
+        assert cache.get(cache_key) is not None
+        # change the sorted set from a second client (causes invalidation)
+        r2.zadd("myzset", {"c": 3})
+        # Add a small delay to allow invalidation to be processed
+        time.sleep(0.1)
+        # a fresh value is fetched and re-cached
+        assert r.zrevrange("myzset", 0, -1) == [b"c", b"b", b"a"]
+
     @pytest.mark.parametrize(
         "r",
         [