ellar.cache test-cov 100%

Author: eadwinCode

ellar/cache/backends/aio_cache.py

@@ -13,7 +13,7 @@
 
 
 from ..interface import IBaseCacheBackendAsync
-from ..make_key_decorator import make_key_decorator
+from ..make_key_decorator import make_key_decorator, make_key_decorator_and_validate
 from ..model import BaseCacheBackend
 
 
@@ -53,6 +53,7 @@ class AioMemCacheBackend(AioMemCacheBackendSync, BaseCacheBackend):
     """Memcached-based cache backend."""
 
     pickle_protocol = pickle.HIGHEST_PROTOCOL
+    MEMCACHE_CLIENT: t.Type = Client
 
     def __init__(
         self,
@@ -78,7 +79,7 @@ def get_backend_timeout(self, timeout: t.Union[float, int] = None) -> int:
     @property
     def _cache_client(self) -> Client:
         if self._client is None:
-            self._client = Client(**self._client_options)
+            self._client = self.MEMCACHE_CLIENT(**self._client_options)
         return self._client
 
     @make_key_decorator
@@ -88,7 +89,7 @@ async def get_async(self, key: str, version: str = None) -> t.Optional[t.Any]:
             return self._deserializer(value)
         return None  # pragma: no cover
 
-    @make_key_decorator
+    @make_key_decorator_and_validate
     async def set_async(
         self,
         key: str,

ellar/cache/backends/base.py

@@ -53,32 +53,23 @@ def clear(self) -> None:
 
 
 class BasePylibMemcachedCache(BasePylibMemcachedCacheSync):
-    def __init__(
-        self,
-        server: t.List[str],
-        library_client_type: t.Type,
-        options: t.Dict = None,
-        **kwargs: t.Any
-    ):
+    MEMCACHE_CLIENT: t.Type
+
+    def __init__(self, servers: t.List[str], options: t.Dict = None, **kwargs: t.Any):
         super().__init__(**kwargs)
-        self._servers = server
+        self._servers = servers
 
-        self._cache_client_class: t.Type = library_client_type
         self._cache_client_init: t.Any = None
         self._options = options or {}
 
-    @property
-    def client_servers(self) -> t.List[str]:
-        return self._servers
-
     @property
     def _cache_client(self) -> t.Any:
         """
         Implement transparent thread-safe access to a memcached client.
         """
         if self._cache_client_init is None:
-            self._cache_client_init = self._cache_client_class(
-                self.client_servers, **self._options
+            self._cache_client_init = self.MEMCACHE_CLIENT(
+                self._servers, **self._options
             )
         return self._cache_client_init
 

ellar/cache/backends/pylib_cache.py

@@ -16,15 +16,10 @@
 class PyLibMCCacheBackend(BasePylibMemcachedCache):
     """An implementation of a cache binding using pylibmc"""
 
-    def __init__(self, server: t.List[str], options: t.Dict = None, **kwargs: t.Any):
-        super().__init__(server, library_client_type=Client, options=options, **kwargs)
-
-    @property
-    def client_servers(self) -> t.List[str]:
-        output = []
-        for server in self._servers:
-            output.append(server.replace("unix:", ""))
-        return output
+    MEMCACHE_CLIENT = Client
+
+    def __init__(self, servers: t.List[str], options: t.Dict = None, **kwargs: t.Any):
+        super().__init__(servers, options=options, **kwargs)
 
     async def close_async(self, **kwargs: t.Any) -> None:
         # libmemcached manages its own connections. Don't call disconnect_all()

ellar/cache/backends/pymem_cache.py

@@ -16,7 +16,9 @@
 class PyMemcacheCacheBackend(BasePylibMemcachedCache):
     """An implementation of a cache binding using pymemcache."""
 
-    def __init__(self, server: t.List[str], options: t.Dict = None, **kwargs: t.Any):
+    MEMCACHE_CLIENT = HashClient
+
+    def __init__(self, servers: t.List[str], options: t.Dict = None, **kwargs: t.Any):
 
         _default_options = options or {}
 
@@ -27,6 +29,4 @@ def __init__(self, server: t.List[str], options: t.Dict = None, **kwargs: t.Any)
             **_default_options,
         }
 
-        super().__init__(
-            server, library_client_type=HashClient, options=_options, **kwargs
-        )
+        super().__init__(servers, options=_options, **kwargs)

ellar/cache/backends/redis/backend.py

@@ -12,7 +12,7 @@
         "To use `RedisCacheBackend`, you have to install 'redis' package e.g. `pip install redis`"
     ) from e
 from ...interface import IBaseCacheBackendAsync
-from ...make_key_decorator import make_key_decorator
+from ...make_key_decorator import make_key_decorator, make_key_decorator_and_validate
 from ...model import BaseCacheBackend
 from .serializer import IRedisSerializer, RedisSerializer
 
@@ -50,6 +50,7 @@ def touch(
 
 
 class RedisCacheBackend(RedisCacheBackendSync, BaseCacheBackend):
+    MEMCACHE_CLIENT: t.Any = Redis
     """Redis-based cache backend.
 
     Redis Server Construct example::
@@ -101,7 +102,7 @@ def _get_client(self, *, write: bool = False) -> Redis:
         # cache client can be implemented which might require the key to select
         # the server, e.g. sharding.
         pool = self._get_connection_pool(write)
-        return Redis(connection_pool=pool)
+        return self.MEMCACHE_CLIENT(connection_pool=pool)
 
     def get_backend_timeout(
         self, timeout: t.Union[float, int] = None
@@ -120,7 +121,7 @@ async def get_async(self, key: str, version: str = None) -> t.Any:
             return self._serializer.load(value)
         return None
 
-    @make_key_decorator
+    @make_key_decorator_and_validate
     async def set_async(
         self,
         key: str,

ellar/cache/backends/redis/serializer.py

@@ -7,11 +7,11 @@ class IRedisSerializer(ABC):
     default_protocol: int = pickle.HIGHEST_PROTOCOL
 
     @abstractmethod
-    def load(self, data: t.Any) -> t.Any:
+    def load(self, data: t.Any) -> t.Any:  # pragma: no cover
         ...
 
     @abstractmethod
-    def dumps(self, data: t.Any) -> t.Any:
+    def dumps(self, data: t.Any) -> t.Any:  # pragma: no cover
         ...
 
 
@@ -26,7 +26,7 @@ def load(self, data: t.Any) -> t.Any:
             return pickle.loads(data)
 
     def dumps(self, data: t.Any) -> t.Any:
-        # Only skip pickling for integers, a int subclasses as bool should be
+        # Only skip pickling for integers, an int subclasses as bool should be
         # pickled.
         if type(data) is int:
             return data

ellar/cache/make_key_decorator.py

@@ -29,9 +29,9 @@ async def _wrap(
             version: str = None,
             **kwargs: t.Any
         ) -> t.Any:
-            _key = instance.make_key(key, version=version)
             if self._validate:
-                instance.validate_key(_key)
+                instance.validate_key(key)
+            _key = instance.make_key(key, version=version)
             return await self._func(instance, _key, *args, version=version, **kwargs)
 
         return _wrap
@@ -45,9 +45,9 @@ def _wrap(
             version: str = None,
             **kwargs: t.Any
         ) -> t.Any:
-            _key = instance.make_key(key, version=version)
             if self._validate:
-                instance.validate_key(_key)
+                instance.validate_key(key)
+            _key = instance.make_key(key, version=version)
             return self._func(instance, _key, *args, version=version, **kwargs)
 
         return _wrap

tests/test_cache/pylib_mock.py

@@ -45,3 +45,13 @@ def delete(self, *args, **kwargs):
 
     def disconnect_all(self, *args, **kwargs):
         return None
+
+    def flush_all(self):
+        self._cache.clear()
+
+
+class MockSetFailureClient(MockClient):
+    def set(self, *args, **kwargs):
+        key, value, _time = args
+        self._cache[key] = (value, _time)
+        return False

tests/test_cache/test_memcache.py renamed to tests/test_cache/test_aio_memcache.py

@@ -3,18 +3,17 @@
 import pytest
 
 from ellar.cache.backends.aio_cache import AioMemCacheBackend
+from ellar.cache.model import CacheKeyWarning
 
 from .redis_mock import MockAsyncMemCacheClient
 
 
 class AioMemCacheBackendMock(AioMemCacheBackend):
-    @property
-    def _cache_client(self):
-        if self._client is None:
-            self._client = MockAsyncMemCacheClient(
-                **self._client_options, time_lookup="exptime"
-            )
-        return self._client
+    MEMCACHE_CLIENT = MockAsyncMemCacheClient
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._client_options.update(time_lookup="exptime")
 
 
 @pytest.mark.asyncio
@@ -28,7 +27,7 @@ async def test_aio_memcache_backend() -> None:
     assert not value
 
 
-class TestRedisCacheBackend:
+class TestAioMemCacheBackend:
     def setup(self):
         self.backend = AioMemCacheBackendMock(host="localhost", port=11211, pool_size=4)
 
@@ -54,8 +53,19 @@ def test_touch(self):
         sleep(0.22)
         assert self.backend.get("test-touch") == "1"
 
+    def test_invalid_key_length(self):
+        # memcached limits key length to 250.
+        key = ("a" * 250) + "清"
+        expected_warning = (
+            "Cache key will cause errors if used with memcached: "
+            "%r (longer than %s)" % (key, self.backend.MEMCACHE_MAX_KEY_LENGTH)
+        )
+        with pytest.warns(CacheKeyWarning) as wa:
+            self.backend.set(key, "value")
+        assert str(wa.list[0].message) == str(CacheKeyWarning(expected_warning))
+
 
-class TestRedisCacheBackendAsync:
+class TestAioMemCacheBackendAsync:
     def setup(self):
         self.backend = AioMemCacheBackendMock(host="localhost", port=11211, pool_size=4)
 
@@ -68,9 +78,7 @@ async def test_set_async(
         assert value == "1"
 
     @pytest.mark.asyncio
-    async def test_has_key_async(
-        self,
-    ):
+    async def test_has_key_async(self):
         assert not await self.backend.has_key_async("test-has-key")
         assert await self.backend.set_async("test-has-key", "1", 1)
         assert await self.backend.has_key_async("test-has-key")
@@ -84,9 +92,7 @@ async def test_delete_async(
         assert await self.backend.delete_async("test-delete")
 
     @pytest.mark.asyncio
-    async def test_touch_async(
-        self,
-    ):
+    async def test_touch_async(self):
         assert not await self.backend.touch_async("test-touch")
         assert await self.backend.set_async("test-touch", "1", 0.1)
         assert await self.backend.touch_async("test-touch", 30)

tests/test_cache/test_cache_service.py

@@ -0,0 +1,58 @@
+from time import sleep
+
+from ellar.cache.backends.local_cache import LocalMemCacheBackend
+from ellar.cache.service import CacheService
+
+
+class TestCacheService:
+    def setup(self):
+        self.cache_service = CacheService(dict(default=LocalMemCacheBackend()))
+
+    def test_set(self):
+        assert self.cache_service.set("test", "1", 0.1)
+        value = self.cache_service.get("test")
+        assert value == "1"
+
+    def test_has_key(self):
+        assert not self.cache_service.has_key("test-has-key")
+        assert self.cache_service.set("test-has-key", "1", 0.1)
+        assert self.cache_service.has_key("test-has-key")
+
+    def test_delete(self):
+        assert not self.cache_service.delete("test-delete")
+        assert self.cache_service.set("test-delete", "1", 0.1)
+        assert self.cache_service.delete("test-delete")
+
+    def test_touch(self):
+        assert not self.cache_service.touch("test-touch")
+        assert self.cache_service.set("test-touch", "1", 0.1)
+        assert self.cache_service.touch("test-touch", 30)
+        sleep(0.22)
+        assert self.cache_service.get("test-touch") == "1"
+
+
+class TestCacheServiceAsync:
+    def setup(self):
+        self.cache_service = CacheService(dict(default=LocalMemCacheBackend()))
+
+    async def test_set_async(self, anyio_backend):
+        assert await self.cache_service.set_async("test", "1", 0.1)
+        value = await self.cache_service.get_async("test")
+        assert value == "1"
+
+    async def test_has_key_async(self, anyio_backend):
+        assert not await self.cache_service.has_key_async("test-has-key")
+        assert await self.cache_service.set_async("test-has-key", "1", 0.1)
+        assert await self.cache_service.has_key_async("test-has-key")
+
+    async def test_delete_async(self, anyio_backend):
+        assert not await self.cache_service.delete_async("test-delete")
+        assert await self.cache_service.set_async("test-delete", "1", 0.1)
+        assert await self.cache_service.delete_async("test-delete")
+
+    async def test_touch_async(self, anyio_backend):
+        assert not await self.cache_service.touch_async("test-touch")
+        assert await self.cache_service.set_async("test-touch", "1", 0.1)
+        assert await self.cache_service.touch_async("test-touch", 30)
+        sleep(0.22)
+        assert await self.cache_service.get_async("test-touch") == "1"