Added some test on caching

Author: eadwinCode

tests/test_cache/__init__.py

@@ -0,0 +1,10 @@
+from ellar.cache.backends.aio_cache import AioMemCacheBackend
+
+
+# @pytest.mark.asyncio
+def test_aio_mem_cache(anyio_backend):
+    backend = AioMemCacheBackend("localhost", port=11211)
+    assert backend
+    # backend.set("test", "values", timeout=10)
+    # res = backend.get("test")
+    # assert res == "values"

tests/test_cache/test_memcache.py

@@ -0,0 +1,113 @@
+from time import sleep
+
+from ellar.common import ModuleRouter, cache
+from ellar.core import TestClientFactory
+from ellar.core.response import PlainTextResponse
+
+
+def test_cache_route_function_return_data():
+    called_count = 0
+
+    mr = ModuleRouter()
+
+    @mr.get("/index")
+    @cache(timeout=0.12)  # cache for 3sec
+    def homepage():
+        nonlocal called_count
+
+        called_count += 1
+        return dict(message="Response Information cached.")
+
+    client = TestClientFactory.create_test_module(
+        routers=[
+            mr,
+        ]
+    ).get_client()
+
+    for i in range(2):
+        client.get("/index")
+
+    sleep(0.22)
+    res = client.get("/index")
+
+    assert res.json() == dict(message="Response Information cached.")
+    assert res.status_code == 200
+    assert called_count == 2
+
+
+def test_cache_for_async_route_function_return_data():
+    called_count = 0
+
+    mr = ModuleRouter()
+
+    @mr.get("/index")
+    @cache(timeout=3)  # cache for 3sec
+    async def homepage():
+        nonlocal called_count
+
+        called_count += 1
+        return dict(message="Response Information cached Async")
+
+    client = TestClientFactory.create_test_module(
+        routers=[
+            mr,
+        ]
+    ).get_client()
+
+    res = client.get("/index")
+
+    assert res.json() == dict(message="Response Information cached Async")
+    assert res.status_code == 200
+    assert called_count == 1
+
+
+def test_cache_for_async_route_function_return_response():
+    called_count = 0
+
+    mr = ModuleRouter()
+
+    @mr.get("/index")
+    @cache(timeout=3)  # cache for 3sec
+    async def homepage():
+        nonlocal called_count
+
+        called_count += 1
+        return PlainTextResponse("Response Information cached Async")
+
+    client = TestClientFactory.create_test_module(
+        routers=[
+            mr,
+        ]
+    ).get_client()
+
+    res = client.get("/index")
+
+    assert res.text == "Response Information cached Async"
+    assert res.status_code == 200
+    assert called_count == 1
+
+
+def test_cache_route_function_return_response():
+    called_count = 0
+
+    mr = ModuleRouter()
+
+    @mr.get("/index")
+    @cache(timeout=2)  # cache for 3sec
+    def homepage():
+        nonlocal called_count
+
+        called_count += 1
+        return PlainTextResponse("Response Information cached")
+
+    client = TestClientFactory.create_test_module(
+        routers=[
+            mr,
+        ]
+    ).get_client()
+
+    res = client.get("/index")
+
+    assert res.text == "Response Information cached"
+    assert res.status_code == 200
+    assert called_count == 1

tests/test_cache/test_operation_cache.py

@@ -0,0 +1,18 @@
+import pytest
+
+from ellar.cache.backends.pylib_cache import PyLibMCCacheBackend
+
+
+@pytest.mark.asyncio
+async def test_simple_cache_backend() -> None:
+    backend = PyLibMCCacheBackend(
+        server=["127.0.0.1:11211"],
+        options=dict(binary=True, behaviors={"tcp_nodelay": True, "ketama": True}),
+    )
+    assert backend
+    # await backend.set_async("test", "rdtyfuhg", 1)  # type: ignore
+    # value = await backend.get_async("test")
+    # assert value
+    # sleep(2)
+    # value = await backend.get("test")
+    # assert not value

tests/test_cache/test_pylibmc_cache.py

@@ -0,0 +1,38 @@
+from time import sleep
+
+from ellar.cache.backends.simple_cache import SimpleCacheBackend
+
+
+async def test_simple_cache_backend(anyio_backend: str) -> None:
+    backend = SimpleCacheBackend()
+    await backend.set("test", "1", 0.1)  # type: ignore
+    value = await backend.get("test")
+    assert value
+    sleep(0.2)
+    value = await backend.get("test")
+    assert not value
+
+
+async def test_simple_cache_backend_with_init_params(anyio_backend: str) -> None:
+    backend = SimpleCacheBackend(key_prefix="ellar", timeout=300, version=2)
+    await backend.set("test", "1", 20)  # type: ignore
+    key = backend.make_key("test")
+    assert backend._cache[key]
+    assert isinstance(backend._cache[key], bytes)
+
+
+async def test_simple_cache_backend_has_key_and_delete(anyio_backend: str) -> None:
+    backend = SimpleCacheBackend()
+    await backend.set_async("test", "1", 2000)  # type: ignore
+    assert await backend.has_key_async("test")
+    assert await backend.delete_async("test") is True
+    assert not await backend.has_key_async("test")
+
+
+def test_simple_cache_backend_has_key_and_delete_sync(anyio_backend: str) -> None:
+    backend = SimpleCacheBackend()
+    backend.set("test", "1", 2000)  # type: ignore
+    assert backend.get("test") == "1"
+    assert backend.has_key("test")
+    assert backend.delete("test") is True
+    assert not backend.has_key("test")