Add DELEX command support with tests

Author: petyaslavova

redis/commands/core.py

@@ -1729,6 +1729,47 @@ def delete(self, *names: KeyT) -> ResponseT:
     def __delitem__(self, name: KeyT):
         self.delete(name)
 
+    def delex(
+        self,
+        name: KeyT,
+        ifeq: Optional[EncodableT] = None,
+        ifne: Optional[EncodableT] = None,
+        ifdeq: Optional[str] = None,  # hex digest
+        ifdne: Optional[str] = None,  # hex digest
+    ) -> int:
+        """
+        Conditionally removes the specified key.
+
+        ifeq match-value - Delete the key only if its value is equal to match-value
+        ifne match-value - Delete the key only if its value is not equal to match-value
+        ifdeq match-digest - Delete the key only if the digest of its value is equal to match-digest
+        ifdne match-digest - Delete the key only if the digest of its value is not equal to match-digest
+
+        Returns:
+            int: 1 if the key was deleted, 0 otherwise.
+        Raises:
+            redis.exceptions.ResponseError: if key exists but is not a string
+                                            and a condition is specified.
+            ValueError: if more than one condition is provided.
+
+        For more information, see https://redis.io/commands/delex
+        """
+        conds = [x is not None for x in (ifeq, ifne, ifdeq, ifdne)]
+        if sum(conds) > 1:
+            raise ValueError("Only one of IFEQ/IFNE/IFDEQ/IFDNE may be specified")
+
+        pieces = ["DELEX", name]
+        if ifeq is not None:
+            pieces += ["IFEQ", ifeq]
+        elif ifne is not None:
+            pieces += ["IFNE", ifne]
+        elif ifdeq is not None:
+            pieces += ["IFDEQ", ifdeq]
+        elif ifdne is not None:
+            pieces += ["IFDNE", ifdne]
+
+        return self.execute_command(*pieces)
+
     def dump(self, name: KeyT) -> ResponseT:
         """
         Return a serialized version of the value stored at the specified key.

tests/test_asyncio/test_commands.py

@@ -1032,6 +1032,114 @@ async def test_delitem(self, r: redis.Redis):
         await r.delete("a")
         assert await r.get("a") is None
 
+    def _ensure_str(self, x):
+        return x.decode("ascii") if isinstance(x, (bytes, bytearray)) else x
+
+    async def _server_xxh3_digest(self, r, key):
+        """
+        Get the server-computed XXH3 hex digest for the key's value.
+        Requires the DIGEST command implemented on the server.
+        """
+        d = await r.execute_command("DIGEST", key)
+        return None if d is None else self._ensure_str(d).lower()
+
+    @skip_if_server_version_lt("8.3.224")
+    async def test_delex_nonexistent(self, r):
+        await r.delete("nope")
+        assert await r.delex("nope") == 0
+
+    @skip_if_server_version_lt("8.3.224")
+    async def test_delex_unconditional_delete_string(self, r):
+        await r.set("k", b"v")
+        assert await r.exists("k") == 1
+        assert await r.delex("k") == 1
+        assert await r.exists("k") == 0
+
+    @skip_if_server_version_lt("8.3.224")
+    async def test_delex_unconditional_delete_nonstring_allowed(self, r):
+        # Spec: error happens only when a condition is specified on a non-string key.
+        await r.lpush("lst", "a")
+        assert await r.delex("lst") == 1
+        assert await r.exists("lst") == 0
+
+        await r.lpush("lst", "a")
+
+        with pytest.raises(redis.ResponseError):
+            await r.delex("lst", ifeq=b"a")
+        assert await r.exists("lst") == 1
+
+    @skip_if_server_version_lt("8.3.224")
+    async def test_delex_ifeq(self, r):
+        await r.set("k", b"abc")
+        assert await r.delex("k", ifeq=b"abc") == 1  # matches → deleted
+        assert await r.exists("k") == 0
+
+        await r.set("k", b"abc")
+        assert await r.delex("k", ifeq=b"zzz") == 0  # not match → not deleted
+        assert await r.get("k") == b"abc"  # still there
+
+    @skip_if_server_version_lt("8.3.224")
+    async def test_delex_ifne(self, r):
+        await r.set("k2", b"abc")
+        assert await r.delex("k2", ifne=b"zzz") == 1  # different → deleted
+        assert await r.exists("k2") == 0
+
+        await r.set("k2", b"abc")
+        assert await r.delex("k2", ifne=b"abc") == 0  # equal → not deleted
+        assert await r.get("k2") == b"abc"
+
+    @skip_if_server_version_lt("8.3.224")
+    async def test_delex_with_conditionon_nonstring_values(self, r):
+        await r.lpush("nk", "x")
+        with pytest.raises(redis.ResponseError):
+            await r.delex("nk", ifeq=b"x")
+        with pytest.raises(redis.ResponseError):
+            await r.delex("nk", ifne=b"x")
+        with pytest.raises(redis.ResponseError):
+            await r.delex("nk", ifdeq="deadbeef")
+
+    @skip_if_server_version_lt("8.3.224")
+    @pytest.mark.parametrize("val", [b"", b"abc", b"The quick brown fox"])
+    async def test_delex_ifdeq_and_ifdne(self, r, val):
+        await r.set("h", val)
+        d = await self._server_xxh3_digest(r, "h")
+        assert d is not None
+
+        # IFDEQ should delete with exact digest
+        await r.set("h", val)
+        assert await r.delex("h", ifdeq=d) == 1
+        assert await r.exists("h") == 0
+
+        # IFDNE should NOT delete when digest matches
+        await r.set("h", val)
+        assert await r.delex("h", ifdne=d) == 0
+        assert await r.get("h") == val
+
+        # IFDNE should delete when digest doesn't match
+        await r.set("h", val)
+        wrong = "0" * len(d)
+        if wrong == d:
+            wrong = "f" * len(d)
+        assert await r.delex("h", ifdne=wrong) == 1
+        assert await r.exists("h") == 0
+
+    @skip_if_server_version_lt("8.3.224")
+    async def test_delex_pipeline(self, r):
+        await r.mset({"p1": b"A", "p2": b"B"})
+        p = r.pipeline()
+        p.delex("p1", ifeq=b"A")
+        p.delex("p2", ifne=b"B")  # false → 0
+        p.delex("nope")  # nonexistent → 0
+        out = await p.execute()
+        assert out == [1, 0, 0]
+
+    @skip_if_server_version_lt("8.3.224")
+    async def test_delex_mutual_exclusion_client_side(self, r):
+        with pytest.raises(ValueError):
+            await r.delex("k", ifeq=b"A", ifne=b"B")
+        with pytest.raises(ValueError):
+            await r.delex("k", ifdeq="aa", ifdne="bb")
+
     @skip_if_server_version_lt("4.0.0")
     async def test_unlink(self, r: redis.Redis):
         assert await r.unlink("a") == 0

tests/test_commands.py

@@ -1501,6 +1501,114 @@ def test_delitem(self, r):
         del r["a"]
         assert r.get("a") is None
 
+    def _ensure_str(self, x):
+        return x.decode("ascii") if isinstance(x, (bytes, bytearray)) else x
+
+    def _server_xxh3_digest(self, r, key):
+        """
+        Get the server-computed XXH3 hex digest for the key's value.
+        Requires the DIGEST command implemented on the server.
+        """
+        d = r.execute_command("DIGEST", key)
+        return None if d is None else self._ensure_str(d).lower()
+
+    @skip_if_server_version_lt("8.3.224")
+    def test_delex_nonexistent(self, r):
+        r.delete("nope")
+        assert r.delex("nope") == 0
+
+    @skip_if_server_version_lt("8.3.224")
+    def test_delex_unconditional_delete_string(self, r):
+        r.set("k", b"v")
+        assert r.exists("k") == 1
+        assert r.delex("k") == 1
+        assert r.exists("k") == 0
+
+    @skip_if_server_version_lt("8.3.224")
+    def test_delex_unconditional_delete_nonstring_allowed(self, r):
+        # Spec: error happens only when a condition is specified on a non-string key.
+        r.lpush("lst", "a")
+        assert r.delex("lst") == 1
+        assert r.exists("lst") == 0
+
+        r.lpush("lst", "a")
+
+        with pytest.raises(redis.ResponseError):
+            r.delex("lst", ifeq=b"a")
+        assert r.exists("lst") == 1
+
+    @skip_if_server_version_lt("8.3.224")
+    def test_delex_ifeq(self, r):
+        r.set("k", b"abc")
+        assert r.delex("k", ifeq=b"abc") == 1  # matches → deleted
+        assert r.exists("k") == 0
+
+        r.set("k", b"abc")
+        assert r.delex("k", ifeq=b"zzz") == 0  # not match → not deleted
+        assert r.get("k") == b"abc"  # still there
+
+    @skip_if_server_version_lt("8.3.224")
+    def test_delex_ifne(self, r):
+        r.set("k2", b"abc")
+        assert r.delex("k2", ifne=b"zzz") == 1  # different → deleted
+        assert r.exists("k2") == 0
+
+        r.set("k2", b"abc")
+        assert r.delex("k2", ifne=b"abc") == 0  # equal → not deleted
+        assert r.get("k2") == b"abc"
+
+    @skip_if_server_version_lt("8.3.224")
+    def test_delex_with_conditionon_nonstring_values(self, r):
+        r.lpush("nk", "x")
+        with pytest.raises(redis.ResponseError):
+            r.delex("nk", ifeq=b"x")
+        with pytest.raises(redis.ResponseError):
+            r.delex("nk", ifne=b"x")
+        with pytest.raises(redis.ResponseError):
+            r.delex("nk", ifdeq="deadbeef")
+
+    @skip_if_server_version_lt("8.3.224")
+    @pytest.mark.parametrize("val", [b"", b"abc", b"The quick brown fox"])
+    def test_delex_ifdeq_and_ifdne(self, r, val):
+        r.set("h", val)
+        d = self._server_xxh3_digest(r, "h")
+        assert d is not None
+
+        # IFDEQ should delete with exact digest
+        r.set("h", val)
+        assert r.delex("h", ifdeq=d) == 1
+        assert r.exists("h") == 0
+
+        # IFDNE should NOT delete when digest matches
+        r.set("h", val)
+        assert r.delex("h", ifdne=d) == 0
+        assert r.get("h") == val
+
+        # IFDNE should delete when digest doesn't match
+        r.set("h", val)
+        wrong = "0" * len(d)
+        if wrong == d:
+            wrong = "f" * len(d)
+        assert r.delex("h", ifdne=wrong) == 1
+        assert r.exists("h") == 0
+
+    @skip_if_server_version_lt("8.3.224")
+    def test_delex_pipeline(self, r):
+        r.mset({"p1": b"A", "p2": b"B"})
+        p = r.pipeline()
+        p.delex("p1", ifeq=b"A")
+        p.delex("p2", ifne=b"B")  # false → 0
+        p.delex("nope")  # nonexistent → 0
+        out = p.execute()
+        assert out == [1, 0, 0]
+
+    @skip_if_server_version_lt("8.3.224")
+    def test_delex_mutual_exclusion_client_side(self, r):
+        with pytest.raises(ValueError):
+            r.delex("k", ifeq=b"A", ifne=b"B")
+        with pytest.raises(ValueError):
+            r.delex("k", ifdeq="aa", ifdne="bb")
+
     @skip_if_server_version_lt("4.0.0")
     def test_unlink(self, r):
         assert r.unlink("a") == 0