Added more tests on caching and update project test dependencies

Author: eadwinCode

pyproject.toml

@@ -75,6 +75,10 @@ test = [
     "anyio[trio] >= 3.2.1",
     "autoflake",
     "email_validator >=1.1.1",
+    "pylibmc",
+    "pymemcache",
+    "aiomcache",
+    "redis",
 
     # types
     "types-ujson ==5.7.0.0",

tests/test_application/test_application_functions.py

@@ -212,7 +212,7 @@ def test_app_staticfiles_route(self, tmpdir):
 
         config = Config(STATIC_DIRECTORIES=[tmpdir])
         injector = EllarInjector()
-        CoreServiceRegistration(injector).register_all()
+        CoreServiceRegistration(injector, config=Config()).register_all()
         injector.container.register_instance(config)
         app = App(injector=injector, config=config)
         client = TestClient(app)
@@ -234,7 +234,7 @@ def test_app_staticfiles_with_different_static_path(self, tmpdir):
             STATIC_MOUNT_PATH="/static-modified", STATIC_DIRECTORIES=[tmpdir]
         )
         injector = EllarInjector()
-        CoreServiceRegistration(injector).register_all()
+        CoreServiceRegistration(injector, config=Config()).register_all()
         injector.container.register_instance(config)
         app = App(injector=injector, config=config)
         client = TestClient(app)
@@ -284,7 +284,7 @@ def test_app_initialization_completion(self):
         injector = EllarInjector(
             auto_bind=False
         )  # will raise an exception is service is not registered
-        CoreServiceRegistration(injector).register_all()
+        CoreServiceRegistration(injector, config=Config()).register_all()
         injector.container.register_instance(config)
 
         app = App(config=config, injector=injector)
@@ -308,7 +308,7 @@ async def catch(
         injector = EllarInjector(
             auto_bind=False
         )  # will raise an exception is service is not registered
-        CoreServiceRegistration(injector).register_all()
+        CoreServiceRegistration(injector, config=Config()).register_all()
         injector.container.register_instance(config)
         app = App(config=config, injector=injector)
         app.add_exception_handler(CustomExceptionHandler())

tests/test_cache/pylib_mock.py

@@ -0,0 +1,69 @@
+import time
+from unittest import mock
+
+from pylibmc import Client
+
+
+class MockClient(Client):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.args = args
+        self.kwargs = kwargs
+        self._cache = {}
+
+    def set(self, *args, **kwargs):
+        key, value, _time = args
+        with mock.patch.object(Client, "set") as set_mock:
+            set_mock.return_value = True
+            res = super().set(*args, **kwargs)
+        assert set_mock.call_args.args == args
+        self._cache[key] = (value, _time)
+        return res
+
+    def get(self, *args, **kwargs):
+        (key,) = args
+        _res = self._cache.get(key)
+
+        if _res and time.time() >= _res[1]:
+            del self._cache[key]
+            _res = None
+
+        with mock.patch.object(Client, "get") as get_mock:
+            get_mock.return_value = _res[0] if _res else None
+            res = super().get(*args, **kwargs)
+        assert get_mock.call_args.args == args
+        return res
+
+    def touch(self, *args, **kwargs):
+        key, _time = args
+        _res = self._cache.get(key)
+        value = False
+        if _res:
+            self._cache.update({key: (_res[0], _time)})
+            value = True
+
+        with mock.patch.object(Client, "touch") as touch_mock:
+            touch_mock.return_value = value
+            res = super().touch(*args, **kwargs)
+        assert touch_mock.call_args.args == args
+        return res
+
+    def delete(self, *args, **kwargs):
+        (key,) = args
+        value = True
+        if self._cache.get(key):
+            del self._cache[key]
+        else:
+            value = False
+        with mock.patch.object(Client, "delete") as delete_mock:
+            delete_mock.return_value = value
+            res = super().delete(*args, **kwargs)
+        assert delete_mock.call_args.args == args
+        return res
+
+    def disconnect_all(self, *args, **kwargs):
+        with mock.patch.object(Client, "disconnect_all") as disconnect_all_mock:
+            disconnect_all_mock.return_value = None
+            res = super().disconnect_all(*args, **kwargs)
+        assert disconnect_all_mock.call_args.args == args
+        return res

tests/test_cache/redis_mock.py

@@ -0,0 +1,75 @@
+import time
+
+
+class MockAsyncMemCacheClient:
+    def __init__(self, *args, time_lookup="ex", **kwargs):
+        self.args = args
+        self.kwargs = kwargs
+        self._time_lookup = time_lookup
+        self._cache_default = {}
+
+    @property
+    def _cache(self):
+        return self._cache_default
+
+    def get_backend_timeout(self, timeout):
+        return timeout
+
+    async def set(self, *args, **kwargs):
+        key, value = args
+        self._cache[key] = (
+            value,
+            self.get_backend_timeout(kwargs.get(self._time_lookup)),
+        )
+        return True
+
+    async def get(self, *args, **kwargs):
+        (key,) = args
+        _res = self._cache.get(key)
+
+        if _res and time.time() >= _res[1]:
+            del self._cache[key]
+            _res = None
+        return _res[0] if _res else None
+
+    async def touch(self, *args, **kwargs):
+        (key,) = args
+        _res = self._cache.get(key)
+        value = False
+        if _res:
+            self._cache.update(
+                {
+                    key: (
+                        _res[0],
+                        self.get_backend_timeout(kwargs.get(self._time_lookup)),
+                    )
+                }
+            )
+            value = True
+        return value
+
+    async def delete(self, *args, **kwargs):
+        (key,) = args
+        value = True
+        if self._cache.get(key):
+            del self._cache[key]
+        else:
+            value = False
+        return value
+
+
+class MockRedisClient(MockAsyncMemCacheClient):
+    _cache_static = {}
+
+    @property
+    def _cache(self):
+        return self._cache_static
+
+    def get_backend_timeout(self, timeout):
+        return time.time() + int(timeout)
+
+    async def persist(self, key):
+        return self._cache.get(key) is not None
+
+    async def expire(self, key, ex):
+        return await self.touch(key, ex=ex)

tests/test_cache/test_cache_many_config.py

@@ -0,0 +1,53 @@
+from ellar.cache import ICacheService
+from ellar.cache.backends.local_cache import LocalMemCacheBackend
+from ellar.common import Controller, cache, get
+from ellar.core import TestClientFactory
+from ellar.core.response import PlainTextResponse
+from ellar.helper.importer import get_class_import
+
+
+class ManyCacheBackendConfig:
+    CACHES = {
+        "default": LocalMemCacheBackend(key_prefix="default"),
+        "another": LocalMemCacheBackend(key_prefix="another", version=2),
+    }
+
+
+@Controller("")
+class ExampleController:
+    @get("/index-1")
+    @cache(timeout=1, backend="another")
+    def index_1(self):
+        return PlainTextResponse("ExampleController cache 1")
+
+    @get("/index-2")
+    @cache(timeout=1, backend="default")
+    def index_2(self):
+        return dict(message="ExampleController cache 2")
+
+
+tm = TestClientFactory.create_test_module(
+    controllers=[ExampleController],
+    config_module=get_class_import(ManyCacheBackendConfig),
+)
+
+
+def test_cache_backend_has_many_cache_backend():
+    cache_service = tm.app.injector.get(ICacheService)
+    assert isinstance(cache_service._get_backend("another"), LocalMemCacheBackend)
+    assert isinstance(cache_service._get_backend("default"), LocalMemCacheBackend)
+
+
+def test_cache_operation_with_backend_works():
+    cache_service = tm.app.injector.get(ICacheService)
+    client = tm.get_client(base_url="http://testserver")
+
+    response = client.get("/index-1")
+    assert response.text == "ExampleController cache 1"
+    result = cache_service.get("http://testserver/index-1:view", backend="another")
+    assert result.body == b"ExampleController cache 1"
+
+    response = client.get("/index-2")
+    assert response.json() == dict(message="ExampleController cache 2")
+    result = cache_service.get("http://testserver/index-2:view", backend="default")
+    assert result == dict(message="ExampleController cache 2")

tests/test_cache/test_local_cache.py

@@ -0,0 +1,66 @@
+from time import sleep
+
+from ellar.cache.backends.local_cache import LocalMemCacheBackend
+
+
+class TestLocalMemCacheBackend:
+    def setup(self):
+        self.backend = LocalMemCacheBackend()
+
+    def test_set(self):
+        assert self.backend.set("test", "1", 0.1)
+        value = self.backend.get("test")
+        assert value == "1"
+
+    def test_has_key(self):
+        assert not self.backend.has_key("test-has-key")
+        assert self.backend.set("test-has-key", "1", 0.1)
+        assert self.backend.has_key("test-has-key")
+
+    def test_delete(self):
+        assert not self.backend.delete("test-delete")
+        assert self.backend.set("test-delete", "1", 0.1)
+        assert self.backend.delete("test-delete")
+
+    def test_touch(self):
+        assert not self.backend.touch("test-touch")
+        assert self.backend.set("test-touch", "1", 0.1)
+        assert self.backend.touch("test-touch", 30)
+        sleep(0.22)
+        assert self.backend.get("test-touch") == "1"
+
+
+class TestLocalMemCacheBackendAsync:
+    def setup(self):
+        self.backend = LocalMemCacheBackend()
+
+    async def test_set_async(self, anyio_backend):
+        assert await self.backend.set_async("test", "1", 0.1)
+        value = await self.backend.get_async("test")
+        assert value == "1"
+
+    async def test_has_key_async(self, anyio_backend):
+        assert not await self.backend.has_key_async("test-has-key")
+        assert await self.backend.set_async("test-has-key", "1", 0.1)
+        assert await self.backend.has_key_async("test-has-key")
+
+    async def test_delete_async(self, anyio_backend):
+        assert not await self.backend.delete_async("test-delete")
+        assert await self.backend.set_async("test-delete", "1", 0.1)
+        assert await self.backend.delete_async("test-delete")
+
+    async def test_touch_async(self, anyio_backend):
+        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)
+        sleep(0.22)
+        assert await self.backend.get_async("test-touch") == "1"
+
+    async def test_simple_cache_backend_with_init_params(
+        self, anyio_backend: str
+    ) -> None:
+        backend = LocalMemCacheBackend(key_prefix="ellar", timeout=300, version=2)
+        await backend.set_async("test", "2", 20)  # type: ignore
+        key = backend.make_key("test")
+        assert backend._cache[key]
+        assert isinstance(backend._cache[key], bytes)