FIX: delete_many not working properly in sync Django backend 🚑️

Author: eigenein

cachetory/backends/async_/redis.py

@@ -68,7 +68,8 @@ async def delete(self, key: str) -> bool:
         return bool(await self._client.delete(key))
 
     async def delete_many(self, *keys: str) -> None:
-        await self._client.delete(*keys)
+        if keys:
+            await self._client.delete(*keys)
 
     async def clear(self) -> None:
         await self._client.flushdb()

cachetory/backends/sync/django.py

@@ -58,7 +58,7 @@ def delete(self, key: str) -> bool:
         return self._cache.delete(key)  # type: ignore[no-any-return]
 
     def delete_many(self, *keys: str) -> None:
-        self._cache.delete_many(*keys)
+        self._cache.delete_many(keys)
 
     def clear(self) -> None:
         self._cache.clear()

cachetory/backends/sync/memory.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-from collections.abc import Set
 from datetime import datetime, timedelta, timezone
 from typing import Generic
 
@@ -51,10 +50,8 @@ def delete(self, key: str) -> bool:
         return self._entries.pop(key, _SENTINEL) is not _SENTINEL
 
     def delete_many(self, *keys: str) -> None:
-        keys: Set[str] = set(keys)  # type: ignore[no-redef]
-
-        # Replace the entire dictionary to make the operation atomic:
-        self._entries = {key: value for key, value in self._entries.items() if key not in keys}
+        for key in keys:
+            self._entries.pop(key, None)
 
     def clear(self) -> None:
         self._entries.clear()

cachetory/backends/sync/redis.py

@@ -68,7 +68,8 @@ def delete(self, key: str) -> bool:
         return bool(self._client.delete(key))
 
     def delete_many(self, *keys: str) -> None:
-        self._client.delete(*keys)
+        if keys:
+            self._client.delete(*keys)
 
     def clear(self) -> None:
         self._client.flushdb()

tests/backends/test_async.py

@@ -76,6 +76,21 @@ async def test_delete_missing(backend: AsyncBackend[bytes]) -> None:
     assert not await backend.delete("foo")
 
 
+async def test_delete_many(backend: AsyncBackend[bytes]) -> None:
+    await backend.set("foo", b"foo")
+    await backend.set("qux", b"qux")
+    await backend.delete_many("foo", "bar")
+
+    with pytest.raises(KeyError):
+        await backend.get("foo")
+    assert await backend.get("qux") == b"qux"
+
+
+async def test_delete_many_without_arguments(backend: AsyncBackend[bytes]) -> None:
+    """Verify that it does not raise an error."""
+    await backend.delete_many()
+
+
 async def test_set_get_many(backend: AsyncBackend[bytes]) -> None:
     await backend.set_many([("non-empty", b"foo"), ("empty", b"")])
     assert [entry async for entry in backend.get_many("non-empty", "missing", "empty")] == [

tests/backends/test_sync.py

@@ -75,6 +75,21 @@ def test_delete_missing(backend: SyncBackend[bytes]) -> None:
     assert not backend.delete("foo")
 
 
+def test_delete_many(backend: SyncBackend[bytes]) -> None:
+    backend.set("foo", b"foo")
+    backend.set("qux", b"qux")
+    backend.delete_many("foo", "bar")
+
+    with pytest.raises(KeyError):
+        backend.get("foo")
+    assert backend.get("qux") == b"qux"
+
+
+def test_delete_many_without_arguments(backend: SyncBackend[bytes]) -> None:
+    """Verify that it does not raise an error."""
+    backend.delete_many()
+
+
 def test_set_get_many(backend: SyncBackend[bytes]) -> None:
     backend.set_many([("non-empty", b"foo"), ("empty", b"")])
     assert list(backend.get_many("non-empty", "missing", "empty")) == [("non-empty", b"foo"), ("empty", b"")]