make test cases reusable for cluster

(cherry picked from commit a0ae7c9)

Author: amirreza8002

tests/test_backend.py

@@ -15,6 +15,7 @@
 
 from django_valkey.cache import ValkeyCache
 from django_valkey.client import ShardClient, herd
+from django_valkey.cluster_cache.client import DefaultClusterClient
 from django_valkey.serializers.json import JSONSerializer
 from django_valkey.serializers.msgpack import MSGPackSerializer
 from django_valkey.serializers.pickle import PickleSerializer
@@ -99,7 +100,7 @@ def test_unicode_keys(self, cache: ValkeyCache):
         res = cache.get("ключ")
         assert res == "value"
 
-    def test_save_and_integer(self, cache: ValkeyCache):
+    def test_save_an_integer(self, cache: ValkeyCache):
         cache.set("test_key", 2)
         res = cache.get("test_key", "Foo")
 
@@ -223,7 +224,9 @@ def test_get_many(self, cache: ValkeyCache):
         assert res == {"a": 1, "b": 2, "c": 3}
 
     def test_mget(self, cache: ValkeyCache):
-        if isinstance(cache.client, ShardClient):
+        if isinstance(cache.client, ShardClient) or isinstance(
+            cache.client, DefaultClusterClient
+        ):
             pytest.skip()
         cache.set("a", 1)
         cache.set("b", 2)
@@ -240,13 +243,28 @@ def test_get_many_unicode(self, cache: ValkeyCache):
         res = cache.get_many(["a", "ب", "c"])
         assert res == {"a": "1", "ب": "2", "c": "الف"}
 
+    def test_mget_unicode(self, cache: ValkeyCache):
+        if isinstance(cache.client, ShardClient) or isinstance(
+            cache.client, DefaultClusterClient
+        ):
+            pytest.skip()
+
+        cache.set("fooa", "1")
+        cache.set("fooب", "2")
+        cache.set("fooc", "الف")
+
+        res = cache.mget(["fooa", "fooب", "fooc"])
+        assert res == {"fooa": "1", "fooب": "2", "fooc": "الف"}
+
     def test_set_many(self, cache: ValkeyCache):
         cache.set_many({"a": 1, "b": 2, "c": 3})
         res = cache.get_many(["a", "b", "c"])
         assert res == {"a": 1, "b": 2, "c": 3}
 
     def test_mset(self, cache: ValkeyCache):
-        if isinstance(cache.client, ShardClient):
+        if isinstance(cache.client, ShardClient) or isinstance(
+            cache.client, DefaultClusterClient
+        ):
             pytest.skip()
         cache.mset({"a": 1, "b": 2, "c": 3})
         res = cache.mget(["a", "b", "c"])
@@ -518,6 +536,9 @@ def test_ttl_incr_version_no_timeout(self, cache: ValkeyCache):
         assert my_value == "hello world!"
 
     def test_delete_pattern(self, cache: ValkeyCache):
+        if isinstance(cache.client, DefaultClusterClient):
+            pytest.skip("cluster client has a specific test")
+
         for key in ["foo-aa", "foo-ab", "foo-bb", "foo-bc"]:
             cache.set(key, "foo")
 
@@ -532,6 +553,9 @@ def test_delete_pattern(self, cache: ValkeyCache):
 
     @patch("django_valkey.cache.ValkeyCache.client")
     def test_delete_pattern_with_custom_count(self, client_mock, cache: ValkeyCache):
+        if isinstance(cache.client, DefaultClusterClient):
+            pytest.skip("cluster client has a specific test")
+
         for key in ["foo-aa", "foo-ab", "foo-bb", "foo-bc"]:
             cache.set(key, "foo")
 
@@ -547,6 +571,9 @@ def test_delete_pattern_with_settings_default_scan_count(
         cache: ValkeyCache,
         settings: SettingsWrapper,
     ):
+        if isinstance(cache.client, DefaultClusterClient):
+            pytest.skip("cluster client has a specific test")
+
         for key in ["foo-aa", "foo-ab", "foo-bb", "foo-bc"]:
             cache.set(key, "foo")
         expected_count = settings.DJANGO_VALKEY_SCAN_ITERSIZE
@@ -715,6 +742,11 @@ def test_lock(self, cache: ValkeyCache):
         lock.release()
         assert not cache.has_key("foobar")
 
+    def test_lock_context_manager(self, cache: ValkeyCache):
+        with cache.lock("foobar"):
+            assert cache.has_key("foobar")
+        assert not cache.has_key("foobar")
+
     def test_lock_released_by_thread(self, cache: ValkeyCache):
         lock = cache.lock("foobar", thread_local=False)
         lock.acquire(blocking=True)
@@ -964,6 +996,9 @@ def test_sinter(self, cache: ValkeyCache):
         if isinstance(cache.client, ShardClient):
             pytest.skip("ShardClient doesn't support sinter")
 
+        if isinstance(cache.client, DefaultClusterClient):
+            pytest.skip("cluster client has a specific test")
+
         cache.sadd("foo1", "bar1", "bar2")
         cache.sadd("foo2", "bar2", "bar3")
         assert cache.sinter("foo1", "foo2") == {"bar2"}
@@ -972,6 +1007,9 @@ def test_interstore(self, cache: ValkeyCache):
         if isinstance(cache.client, ShardClient):
             pytest.skip("ShardClient doesn't support sinterstore")
 
+        if isinstance(cache.client, DefaultClusterClient):
+            pytest.skip("cluster client has a specific test")
+
         cache.sadd("foo1", "bar1", "bar2")
         cache.sadd("foo2", "bar2", "bar3")
         assert cache.sinterstore("foo3", "foo1", "foo2") == 1
@@ -1066,6 +1104,9 @@ def test_smove(self, cache: ValkeyCache):
         # if isinstance(cache.client, ShardClient):
         #     pytest.skip("ShardClient doesn't support get_client")
 
+        if isinstance(cache.client, DefaultClusterClient):
+            pytest.skip("cluster client has a specific test")
+
         cache.sadd("foo1", "bar1", "bar2")
         cache.sadd("foo2", "bar2", "bar3")
         assert cache.smove("foo1", "foo2", "bar1") is True
@@ -1130,6 +1171,9 @@ def test_sunion(self, cache: ValkeyCache):
         if isinstance(cache.client, ShardClient):
             pytest.skip("ShardClient doesn't support sunion")
 
+        if isinstance(cache.client, DefaultClusterClient):
+            pytest.skip("cluster client has a specific test")
+
         cache.sadd("foo1", "bar1", "bar2")
         cache.sadd("foo2", "bar2", "bar3")
         assert cache.sunion("foo1", "foo2") == {"bar1", "bar2", "bar3"}
@@ -1138,6 +1182,9 @@ def test_sunionstore(self, cache: ValkeyCache):
         if isinstance(cache.client, ShardClient):
             pytest.skip("ShardClient doesn't support sunionstore")
 
+        if isinstance(cache.client, DefaultClusterClient):
+            pytest.skip("cluster client has a specific test")
+
         cache.sadd("foo1", "bar1", "bar2")
         cache.sadd("foo2", "bar2", "bar3")
         assert cache.sunionstore("foo3", "foo1", "foo2") == 3

tests/test_cache_options.py

@@ -3,13 +3,16 @@
 from typing import cast
 
 import pytest
-from django.core.cache import caches
 from pytest import LogCaptureFixture
 from pytest_django.fixtures import SettingsWrapper
+
+from django.core.cache import caches, cache as default_cache
+
 from valkey.exceptions import ConnectionError
 
 from django_valkey.cache import ValkeyCache
 from django_valkey.client import ShardClient
+from django_valkey.cluster_cache.client import DefaultClusterClient
 
 
 def make_key(key: str, prefix: str, version: str) -> str:
@@ -31,13 +34,21 @@ def ignore_exceptions_cache(settings: SettingsWrapper) -> ValkeyCache:
     return cast(ValkeyCache, caches["doesnotexist"])
 
 
+@pytest.mark.skipif(
+    isinstance(default_cache.client, DefaultClusterClient),
+    reason="cluster client doesn't support ignore exception",
+)
 def test_get_django_omit_exceptions_many_returns_default_arg(
     ignore_exceptions_cache: ValkeyCache,
 ):
     assert ignore_exceptions_cache._ignore_exceptions is True
     assert ignore_exceptions_cache.get_many(["key1", "key2", "key3"]) == {}
 
 
+@pytest.mark.skipif(
+    isinstance(default_cache.client, DefaultClusterClient),
+    reason="cluster client doesn't support ignore exception",
+)
 def test_get_django_omit_exceptions(
     caplog: LogCaptureFixture, ignore_exceptions_cache: ValkeyCache
 ):
@@ -55,6 +66,10 @@ def test_get_django_omit_exceptions(
     )
 
 
+@pytest.mark.skipif(
+    isinstance(default_cache.client, DefaultClusterClient),
+    reason="cluster client doesn't support ignore exception",
+)
 def test_get_django_omit_exceptions_priority_1(settings: SettingsWrapper):
     caches_setting = copy.deepcopy(settings.CACHES)
     caches_setting["doesnotexist"]["OPTIONS"]["IGNORE_EXCEPTIONS"] = True
@@ -65,6 +80,10 @@ def test_get_django_omit_exceptions_priority_1(settings: SettingsWrapper):
     assert cache.get("key") is None
 
 
+@pytest.mark.skipif(
+    isinstance(default_cache.client, DefaultClusterClient),
+    reason="cluster client doesn't support ignore exception",
+)
 def test_get_django_omit_exceptions_priority_2(settings: SettingsWrapper):
     caches_setting = copy.deepcopy(settings.CACHES)
     caches_setting["doesnotexist"]["OPTIONS"]["IGNORE_EXCEPTIONS"] = False
@@ -113,6 +132,10 @@ def test_iter_keys(
         with_prefix_cache.set("b", "2")
         assert list(key_prefix_cache.iter_keys("*")) == ["a"]
 
+    @pytest.mark.skipif(
+        isinstance(default_cache.client, DefaultClusterClient),
+        reason="cluster client doesn't support ignore exception",
+    )
     def test_keys(self, key_prefix_cache: ValkeyCache, with_prefix_cache: ValkeyCache):
         key_prefix_cache.set("a", "1")
         with_prefix_cache.set("b", "2")
@@ -121,6 +144,10 @@ def test_keys(self, key_prefix_cache: ValkeyCache, with_prefix_cache: ValkeyCach
         assert "b" not in keys
 
 
+@pytest.mark.skipif(
+    isinstance(default_cache.client, DefaultClusterClient),
+    reason="cluster client doesn't support ignore exception",
+)
 def test_custom_key_function(cache: ValkeyCache, settings: SettingsWrapper):
     caches_setting = copy.deepcopy(settings.CACHES)
     caches_setting["default"]["KEY_FUNCTION"] = "tests.test_cache_options.make_key"

tests/test_client.py

@@ -2,10 +2,11 @@
 from unittest.mock import Mock, call, patch
 
 import pytest
-from django.core.cache import DEFAULT_CACHE_ALIAS
 from pytest_django.fixtures import SettingsWrapper
 from pytest_mock import MockerFixture
 
+from django.core.cache import DEFAULT_CACHE_ALIAS, cache as default_cache
+
 from django_valkey.cache import ValkeyCache
 from django_valkey.client import DefaultClient, ShardClient
 
@@ -58,9 +59,12 @@ def test_close_disconnect_client_options(
         assert mock.called
 
 
+@pytest.mark.skipif(
+    not isinstance(default_cache.client, DefaultClient), reason="shard only test"
+)
 class TestDefaultClient:
-    @patch("tests.test_client.DefaultClient.get_client")
-    @patch("tests.test_client.DefaultClient.__init__", return_value=None)
+    @patch("django_valkey.base_client.ClientCommands.get_client")
+    @patch("django_valkey.base_client.BaseClient.__init__", return_value=None)
     def test_delete_pattern_calls_get_client_given_no_client(
         self, init_mock, get_client_mock
     ):
@@ -71,9 +75,9 @@ def test_delete_pattern_calls_get_client_given_no_client(
         client.delete_pattern(pattern="foo*")
         get_client_mock.assert_called_once_with(write=True, tried=None)
 
-    @patch("tests.test_client.DefaultClient.make_pattern")
-    @patch("tests.test_client.DefaultClient.get_client", return_value=Mock())
-    @patch("tests.test_client.DefaultClient.__init__", return_value=None)
+    @patch("django_valkey.base_client.BaseClient.make_pattern")
+    @patch("django_valkey.base_client.ClientCommands.get_client", return_value=Mock())
+    @patch("django_valkey.base_client.BaseClient.__init__", return_value=None)
     def test_delete_pattern_calls_make_pattern(
         self, init_mock, get_client_mock, make_pattern_mock
     ):
@@ -87,9 +91,9 @@ def test_delete_pattern_calls_make_pattern(
         kwargs = {"version": None, "prefix": None}
         make_pattern_mock.assert_called_once_with("foo*", **kwargs)
 
-    @patch("tests.test_client.DefaultClient.make_pattern")
-    @patch("tests.test_client.DefaultClient.get_client", return_value=Mock())
-    @patch("tests.test_client.DefaultClient.__init__", return_value=None)
+    @patch("django_valkey.base_client.BaseClient.make_pattern")
+    @patch("django_valkey.base_client.ClientCommands.get_client", return_value=Mock())
+    @patch("django_valkey.base_client.BaseClient.__init__", return_value=None)
     def test_delete_pattern_calls_scan_iter_with_count_if_itersize_given(
         self, init_mock, get_client_mock, make_pattern_mock
     ):
@@ -104,9 +108,9 @@ def test_delete_pattern_calls_scan_iter_with_count_if_itersize_given(
             count=90210, match=make_pattern_mock.return_value
         )
 
-    @patch("tests.test_client.DefaultClient.make_pattern")
-    @patch("tests.test_client.DefaultClient.get_client", return_value=Mock())
-    @patch("tests.test_client.DefaultClient.__init__", return_value=None)
+    @patch("django_valkey.base_client.BaseClient.make_pattern")
+    @patch("django_valkey.base_client.ClientCommands.get_client", return_value=Mock())
+    @patch("django_valkey.base_client.BaseClient.__init__", return_value=None)
     def test_delete_pattern_calls_pipeline_delete_and_execute(
         self, init_mock, get_client_mock, make_pattern_mock
     ):
@@ -127,6 +131,9 @@ def test_delete_pattern_calls_pipeline_delete_and_execute(
         get_client_mock.return_value.pipeline.return_value.execute.assert_called_once()
 
 
+@pytest.mark.skipif(
+    not isinstance(default_cache.client, ShardClient), reason="shard only test"
+)
 class TestShardClient:
     CLIENT_METHODS_FOR_MOCK = {
         "add",
@@ -166,8 +173,8 @@ def connection(self, mocker):
 
         yield connection
 
-    @patch("tests.test_client.ShardClient.make_pattern")
-    @patch("tests.test_client.ShardClient.__init__", return_value=None)
+    @patch("django_valkey.base_client.BaseClient.make_pattern")
+    @patch("django_valkey.client.sharded.ShardClient.__init__", return_value=None)
     def test_delete_pattern_calls_scan_iter_with_count_if_itersize_given(
         self,
         init_mock,

tests/test_session.py

@@ -3,16 +3,12 @@
 from datetime import timedelta
 from typing import Optional, Type
 
-import django
-import pytest
 from django.conf import settings
 from django.contrib.sessions.backends.base import SessionBase
 from django.contrib.sessions.backends.cache import SessionStore as CacheSession
-from django.core.cache import DEFAULT_CACHE_ALIAS, caches
 from django.test import override_settings
 from django.utils import timezone
 
-from django_valkey.serializers.msgpack import MSGPackSerializer
 
 SessionType = Type[SessionBase]
 
@@ -304,27 +300,23 @@ def test_decode_failure_logged_to_security(self):
         self.assertIn("corrupted", cm.output[0])
 
     def test_actual_expiry(self):
-        # this doesn't work with JSONSerializer (serializing timedelta)
-        with override_settings(
-            SESSION_SERIALIZER="django.contrib.sessions.serializers.PickleSerializer"
-        ):
-            self.session = self.backend()  # reinitialize after overriding settings
-
-            # Regression test for #19200
-            old_session_key = None
-            new_session_key = None
-            try:
-                self.session["foo"] = "bar"
-                self.session.set_expiry(-timedelta(seconds=10))
-                self.session.save()
-                old_session_key = self.session.session_key
-                # With an expiry date in the past, the session expires instantly.
-                new_session = self.backend(self.session.session_key)
-                new_session_key = new_session.session_key
-                self.assertNotIn("foo", new_session)
-            finally:
-                self.session.delete(old_session_key)
-                self.session.delete(new_session_key)
+        self.session = self.backend()  # reinitialize after overriding settings
+
+        # Regression test for #19200
+        old_session_key = None
+        new_session_key = None
+        try:
+            self.session["foo"] = "bar"
+            self.session.set_expiry(-timedelta(seconds=10))
+            self.session.save()
+            old_session_key = self.session.session_key
+            # With an expiry date in the past, the session expires instantly.
+            new_session = self.backend(self.session.session_key)
+            new_session_key = new_session.session_key
+            self.assertNotIn("foo", new_session)
+        finally:
+            self.session.delete(old_session_key)
+            self.session.delete(new_session_key)
 
     def test_session_load_does_not_create_record(self):
         """
@@ -366,14 +358,3 @@ def test_session_save_does_not_resurrect_session_logged_out_in_other_context(sel
 
 class SessionTests(SessionTestsMixin, unittest.TestCase):
     backend = CacheSession
-
-    @pytest.mark.skipif(
-        django.VERSION >= (4, 2),
-        reason="PickleSerializer is removed as of https://code.djangoproject.com/ticket/29708",
-    )
-    def test_actual_expiry(self):
-        if isinstance(
-            caches[DEFAULT_CACHE_ALIAS].client._serializer, MSGPackSerializer
-        ):
-            self.skipTest("msgpack serializer doesn't support datetime serialization")
-        super().test_actual_expiry()