Organize test directories by cache backend; Add async pickle and memory tests

Author: gencurrent

src/cachier/core.py

@@ -49,23 +49,23 @@ def _get_executor(reset=False):
     return _get_executor.executor
 
 
-def _function_thread(core, key, func, args, kwds):
+def _function_thread(core: _BaseCore, key, func, args, kwds):
     try:
         func_res = func(*args, **kwds)
         core.set_entry(key, func_res)
     except BaseException as exc:
         print(f"Function call failed with the following exception:\n{exc}")
 
 
-async def _function_thread_async(core, key, func, args, kwds):
+async def _function_thread_async(core: _BaseCore, key, func, args, kwds):
     try:
         func_res = await func(*args, **kwds)
         await core.aset_entry(key, func_res)
     except BaseException as exc:
         print(f"Function call failed with the following exception:\n{exc}")
 
 
-def _calc_entry(core, key, func, args, kwds, printer=lambda *_: None) -> Optional[Any]:
+def _calc_entry(core: _BaseCore, key, func, args, kwds, printer=lambda *_: None) -> Optional[Any]:
     core.mark_entry_being_calculated(key)
     try:
         func_res = func(*args, **kwds)
@@ -77,7 +77,7 @@ def _calc_entry(core, key, func, args, kwds, printer=lambda *_: None) -> Optiona
         core.mark_entry_not_calculated(key)
 
 
-async def _calc_entry_async(core, key, func, args, kwds, printer=lambda *_: None) -> Optional[Any]:
+async def _calc_entry_async(core: _BaseCore, key, func, args, kwds, printer=lambda *_: None) -> Optional[Any]:
     await core.amark_entry_being_calculated(key)
     try:
         func_res = await func(*args, **kwds)

src/cachier/cores/memory.py

@@ -28,6 +28,14 @@ def get_entry_by_key(self, key: str, reload=False) -> Tuple[str, Optional[CacheE
         with self.lock:
             return key, self.cache.get(self._hash_func_key(key), None)
 
+    async def aget_entry(self, args: tuple[Any, ...], kwds: dict[str, Any]) -> Tuple[str, Optional[CacheEntry]]:
+        key = self.get_key(args, kwds)
+        return await self.aget_entry_by_key(key)
+
+    async def aget_entry_by_key(self, key: str) -> Tuple[str, Optional[CacheEntry]]:
+        """Get an entry by key."""
+        return self.get_entry_by_key(key)
+
     def set_entry(self, key: str, func_res: Any) -> bool:
         if not self._should_store(func_res):
             return False
@@ -50,6 +58,10 @@ def set_entry(self, key: str, func_res: Any) -> bool:
             )
         return True
 
+    async def aset_entry(self, key: str, func_res: Any) -> bool:
+        """Set an entry."""
+        return self.set_entry(key, func_res)
+
     def mark_entry_being_calculated(self, key: str) -> None:
         with self.lock:
             condition = threading.Condition()
@@ -67,6 +79,9 @@ def mark_entry_being_calculated(self, key: str) -> None:
                     _condition=condition,
                 )
 
+    async def amark_entry_being_calculated(self, key: str) -> None:
+        self.mark_entry_being_calculated(key)
+
     def mark_entry_not_calculated(self, key: str) -> None:
         hash_key = self._hash_func_key(key)
         with self.lock:
@@ -81,6 +96,9 @@ def mark_entry_not_calculated(self, key: str) -> None:
                 cond.release()
                 entry._condition = None
 
+    async def amark_entry_not_calculated(self, key: str) -> None:
+        self.mark_entry_not_calculated(key)
+
     def wait_on_entry_calc(self, key: str) -> Any:
         hash_key = self._hash_func_key(key)
         with self.lock:  # pragma: no cover

src/cachier/cores/pickle.py

@@ -182,6 +182,13 @@ def get_entry_by_key(self, key: str, reload: bool = False) -> Tuple[str, Optiona
             return key, self._load_cache_by_key(key)
         return key, self.get_cache_dict(reload).get(key)
 
+    async def aget_entry(self, args: tuple[Any, ...], kwds: dict[str, Any]) -> Tuple[str, Optional[CacheEntry]]:
+        key = self.get_key(args, kwds)
+        return await self.aget_entry_by_key(key)
+
+    async def aget_entry_by_key(self, key: str) -> Tuple[str, Optional[CacheEntry]]:
+        return self.get_entry_by_key(key)
+
     def set_entry(self, key: str, func_res: Any) -> bool:
         if not self._should_store(func_res):
             return False
@@ -202,6 +209,9 @@ def set_entry(self, key: str, func_res: Any) -> bool:
             self._save_cache(cache)
         return True
 
+    async def aset_entry(self, key: str, func_res: Any) -> bool:
+        return self.set_entry(key, func_res)
+
     def mark_entry_being_calculated_separate_files(self, key: str) -> None:
         self._save_cache(
             CacheEntry(value=None, time=datetime.now(), stale=False, _processing=True),
@@ -228,6 +238,9 @@ def mark_entry_being_calculated(self, key: str) -> None:
                 cache[key] = CacheEntry(value=None, time=datetime.now(), stale=False, _processing=True)
             self._save_cache(cache)
 
+    async def amark_entry_being_calculated(self, key: str) -> None:
+        self.mark_entry_being_calculated(key)
+
     def mark_entry_not_calculated(self, key: str) -> None:
         if self.separate_files:
             self._mark_entry_not_calculated_separate_files(key)
@@ -238,6 +251,9 @@ def mark_entry_not_calculated(self, key: str) -> None:
                 cache[key]._processing = False
                 self._save_cache(cache)
 
+    async def amark_entry_not_calculated(self, key: str) -> None:
+        self.mark_entry_not_calculated(key)
+
     def _create_observer(self) -> Observer:  # type: ignore[valid-type]
         """Create a new observer instance."""
         return Observer()

tests/conftest.py

@@ -17,7 +17,7 @@ def cleanup_mongo_clients():
 
     # Cleanup after all tests
     try:
-        from tests.test_mongo_core import _test_mongetter
+        from tests.mongo_tests.test_mongo_core import _test_mongetter
     except ImportError:
         return
 

tests/memory_tests/__init__.py

@@ -0,0 +1,72 @@
+"""Tests for async support in the memory core."""
+
+import asyncio
+from datetime import timedelta
+
+import pytest
+
+from cachier import cachier
+
+
+@pytest.mark.memory
+@pytest.mark.asyncio
+async def test_async_memory_basic_caching():
+    """Ensure async functions are cached by the memory backend."""
+    call_count = 0
+
+    @cachier(backend="memory")
+    async def async_memory_cached(x: int) -> int:
+        nonlocal call_count
+        call_count += 1
+        await asyncio.sleep(0.01)
+        return x + call_count
+
+    async_memory_cached.clear_cache()
+    try:
+        value1 = await async_memory_cached(3)
+        value2 = await async_memory_cached(3)
+        assert value1 == value2 == 4
+        assert call_count == 1
+    finally:
+        async_memory_cached.clear_cache()
+
+
+@pytest.mark.memory
+@pytest.mark.asyncio
+async def test_async_memory_next_time_returns_stale_then_updates():
+    """Ensure next_time returns stale value and updates asynchronously."""
+    call_count = 0
+
+    @cachier(
+        backend="memory",
+        stale_after=timedelta(milliseconds=150),
+        next_time=True,
+    )
+    async def async_memory_next_time(_: int) -> int:
+        nonlocal call_count
+        call_count += 1
+        await asyncio.sleep(0.05)
+        return call_count
+
+    async_memory_next_time.clear_cache()
+    try:
+        first = await async_memory_next_time(1)
+        assert first == 1
+
+        await asyncio.sleep(0.2)
+
+        stale = await async_memory_next_time(1)
+        assert stale == 1
+
+        updated = stale
+        for _ in range(10):
+            await asyncio.sleep(0.05)
+            updated = await async_memory_next_time(1)
+            if updated > 1:
+                break
+
+        assert updated > 1
+        assert call_count >= 2
+        await asyncio.sleep(0.1)
+    finally:
+        async_memory_next_time.clear_cache()

tests/memory_tests/test_async_memory_core.py

@@ -1,4 +1,4 @@
-"""Tests for async client factories (redis_client / mongetter) with async functions."""
+"""Tests for async Mongo client with async functions."""
 
 import asyncio
 from contextlib import suppress
@@ -9,80 +9,6 @@
 from cachier import cachier
 
 
-class _AsyncInMemoryRedis:
-    """Minimal async Redis-like client implementing required hash operations."""
-
-    def __init__(self):
-        self._data: dict[str, dict[str, object]] = {}
-
-    async def hgetall(self, key: str) -> dict[bytes, object]:
-        raw = self._data.get(key, {})
-        res: dict[bytes, object] = {}
-        for k, v in raw.items():
-            res[k.encode("utf-8")] = v.encode("utf-8") if isinstance(v, str) else v
-        return res
-
-    async def hset(self, key: str, field=None, value=None, mapping=None, **kwargs):
-        if key not in self._data:
-            self._data[key] = {}
-
-        if mapping is not None:
-            self._data[key].update(mapping)
-            return
-        if field is not None and value is not None:
-            self._data[key][field] = value
-            return
-        if kwargs:
-            self._data[key].update(kwargs)
-
-
-@pytest.mark.redis
-@pytest.mark.asyncio
-async def test_async_redis_client_factory():
-    pytest.importorskip("redis")
-
-    client = _AsyncInMemoryRedis()
-
-    async def get_redis_client():
-        return client
-
-    @cachier(backend="redis", redis_client=get_redis_client)
-    async def async_cached_redis(x: int) -> float:
-        await asyncio.sleep(0.01)
-        return random() + x
-
-    val1 = await async_cached_redis(3)
-    val2 = await async_cached_redis(3)
-    assert val1 == val2
-
-
-@pytest.mark.redis
-@pytest.mark.asyncio
-async def test_async_redis_client_factory_method_args_and_kwargs():
-    pytest.importorskip("redis")
-
-    client = _AsyncInMemoryRedis()
-
-    async def get_redis_client():
-        return client
-
-    call_count = 0
-
-    class _RedisMethods:
-        @cachier(backend="redis", redis_client=get_redis_client)
-        async def async_cached_redis_method_args_kwargs(self, x: int, y: int) -> int:
-            nonlocal call_count
-            call_count += 1
-            await asyncio.sleep(0.01)
-            return call_count
-
-    obj = _RedisMethods()
-    val1 = await obj.async_cached_redis_method_args_kwargs(1, 2)
-    val2 = await obj.async_cached_redis_method_args_kwargs(y=2, x=1)
-    assert val1 == val2 == 1
-    assert call_count == 1
-
-
 @pytest.mark.mongo
 @pytest.mark.filterwarnings("ignore:Python 3\\.14 will, by default, filter extracted tar archives.*:DeprecationWarning")
 @pytest.mark.asyncio