refactor cache instantiation

only context manager is supported to instantiate ValkeyBackend

Author: amirreza8002

aiocache/backends/valkey.py

@@ -1,6 +1,6 @@
 import logging
 import time
-from typing import Any, Callable, Optional, TYPE_CHECKING, List
+from typing import Any, Callable, List, Optional, Self, TYPE_CHECKING
 
 from glide import (
     ConditionalChange,
@@ -24,14 +24,24 @@
 
 
 class ValkeyBackend(BaseCache[str]):
-    def __init__(
-        self,
-        client: GlideClient,
-        **kwargs,
-    ):
+    def __init__(self, config: GlideClientConfiguration = None, **kwargs):
+        self.config = config
         super().__init__(**kwargs)
 
-        self.client = client
+    async def __aenter__(self) -> Self:
+        if not self.config:
+            raise AttributeError("Configuration must be provided for context manager")
+        self.client = await self._connect(self.config)
+        return self
+
+    async def __aexit__(self, *args, **kwargs) -> None:
+        await self._disconnect()
+
+    async def _connect(self, config: GlideClientConfiguration) -> GlideClient:
+        return await GlideClient.create(config=config)
+
+    async def _disconnect(self) -> None:
+        await self.client.close()
 
     async def _get(self, key, encoding="utf-8", _conn=None):
         value = await self.client.get(key)
@@ -203,32 +213,17 @@ class ValkeyCache(ValkeyBackend):
 
     def __init__(
         self,
-        client: Optional[GlideClient] = None,
         serializer: Optional["BaseSerializer"] = None,
         namespace: str = "",
         key_builder: Callable[[str, str], str] = lambda k, ns: f"{ns}:{k}" if ns else k,
-        backend: type[GlideClient] = GlideClient,
-        config: GlideClientConfiguration = None,
         **kwargs: Any,
     ):
         super().__init__(
-            client=client,
             serializer=serializer or JsonSerializer(),
             namespace=namespace,
             key_builder=key_builder,
             **kwargs,
         )
-        self.backend = backend
-        self.config = config
-
-    async def __aenter__(self):
-        if not self.config:
-            raise AttributeError("Configuration must be provided for context manager")
-        self.client = await self.backend.create(config=self.config)
-        return self
-
-    async def __aexit__(self, *args, **kwargs):
-        await self.client.close()
 
     @classmethod
     def parse_uri_path(cls, path):

tests/conftest.py

@@ -19,14 +19,3 @@ def valkey_config():
     conf = GlideClientConfiguration(addresses=addresses, database_id=0)
 
     yield conf
-
-
-@pytest.fixture
-async def valkey_client(max_conns, decode_responses, valkey_config):
-    from glide import GlideClient
-
-    client = await GlideClient.create(valkey_config)
-
-    yield client
-
-    await client.close()

tests/ut/backends/test_valkey.py

@@ -12,8 +12,8 @@
 
 
 @pytest.fixture
-def valkey(valkey_client):
-    valkey = ValkeyBackend(client=valkey_client)
+async def valkey(valkey_config):
+    valkey = await ValkeyBackend(config=valkey_config).__aenter__()
     with patch.object(valkey, "client", autospec=True) as m:
         # These methods actually return an awaitable.
         for method in (
@@ -34,6 +34,8 @@ def valkey(valkey_client):
 
         yield valkey
 
+    await valkey.__aexit__()
+
 
 class TestValkeyBackend:
     async def test_get(self, valkey):
@@ -55,7 +57,9 @@ async def test_set(self, valkey):
 
     async def test_set_cas_token(self, mocker, valkey):
         mocker.patch.object(valkey, "_cas")
-        await valkey._set(Keys.KEY, "value", _cas_token="old_value", _conn=valkey.client)
+        await valkey._set(
+            Keys.KEY, "value", _cas_token="old_value", _conn=valkey.client
+        )
         valkey._cas.assert_called_with(
             Keys.KEY, "value", "old_value", ttl=None, _conn=valkey.client
         )
@@ -196,18 +200,18 @@ def set_test_namespace(self, valkey_cache):
     def test_name(self):
         assert ValkeyCache.NAME == "valkey"
 
-    def test_inheritance(self, valkey_client):
-        assert isinstance(ValkeyCache(client=valkey_client), BaseCache)
+    def test_inheritance(self, valkey_config):
+        assert isinstance(ValkeyCache(config=valkey_config), BaseCache)
 
-    def test_default_serializer(self, valkey_client):
-        assert isinstance(ValkeyCache(client=valkey_client).serializer, JsonSerializer)
+    def test_default_serializer(self, valkey_config):
+        assert isinstance(ValkeyCache(config=valkey_config).serializer, JsonSerializer)
 
     @pytest.mark.parametrize(
         "path,expected",
         [("", {}), ("/", {}), ("/1", {"db": "1"}), ("/1/2/3", {"db": "1"})],
     )
-    def test_parse_uri_path(self, path, expected, valkey_client):
-        assert ValkeyCache(client=valkey_client).parse_uri_path(path) == expected
+    def test_parse_uri_path(self, path, expected, valkey_config):
+        assert ValkeyCache(config=valkey_config).parse_uri_path(path) == expected
 
     @pytest.mark.parametrize(
         "namespace, expected",
@@ -217,7 +221,9 @@ def test_parse_uri_path(self, path, expected, valkey_client):
             ["my_ns", "my_ns:" + ensure_key(Keys.KEY)],
         ),  # noqa: B950
     )
-    def test_build_key_double_dot(self, set_test_namespace, valkey_cache, namespace, expected):
+    def test_build_key_double_dot(
+        self, set_test_namespace, valkey_cache, namespace, expected
+    ):
         assert valkey_cache.build_key(Keys.KEY, namespace) == expected
 
     def test_build_key_no_namespace(self, valkey_cache):