Address PR review feedback: fix test assertions, add allow_none test, improve error handling, document async limitations

Co-authored-by: Borda <6035284+Borda@users.noreply.github.com>

Author: Copilot

examples/async_example.py

@@ -82,9 +82,9 @@ async def fetch_github_user(username: str) -> dict:
         if duration2 > 0:
             print(f"  Cache speedup: {duration1 / duration2:.1f}x")
         else:
-            print(
-                "  Cache speedup: instantaneous (duration too small to measure)"
-            )
+            msg = "  Cache speedup: instantaneous "
+            msg += "(duration too small to measure)"
+            print(msg)
 
     except ImportError:
         msg = "  (Skipping - httpx not installed. "
@@ -109,7 +109,10 @@ async def main():
     user = await fetch_user_data(42)
     duration2 = time.time() - start
     print(f"Second call: {user} (took {duration2:.2f}s)")
-    print(f"Speedup: {duration1 / duration2:.1f}x faster!")
+    if duration2 > 0:
+        print(f"Speedup: {duration1 / duration2:.1f}x faster!")
+    else:
+        print("Speedup: instantaneous (duration too small to measure)")
 
     # Example 2: Memory backend
     print("\n=== Example 2: Memory Backend (Fast, Non-Persistent) ===")

src/cachier/core.py

@@ -61,7 +61,7 @@ async def _function_thread_async(core, key, func, args, kwds):
     try:
         func_res = await func(*args, **kwds)
         core.set_entry(key, func_res)
-    except BaseException as exc:
+    except Exception as exc:
         print(f"Function call failed with the following exception:\n{exc}")
 
 
@@ -422,6 +422,10 @@ def _call(*args, max_age: Optional[timedelta] = None, **kwds):
         async def _call_async(
             *args, max_age: Optional[timedelta] = None, **kwds
         ):
+            # NOTE: For async functions, wait_for_calc_timeout is not honored.
+            # Instead of blocking the event loop waiting for concurrent
+            # calculations, async functions will recalculate in parallel.
+            # This avoids deadlocks and maintains async efficiency.
             nonlocal allow_none, last_cleanup
             _allow_none = _update_with_defaults(allow_none, "allow_none", kwds)
             # print('Inside async wrapper for {}.'.format(func.__name__))

tests/test_async_core.py

@@ -87,10 +87,11 @@ async def async_func(x):
     assert result1 == 10
     assert call_count == 1
 
-    # Second call - should use cache
+    # Second call - should use cache (no additional call)
+    call_count_before = call_count
     result2 = await async_func(5)
     assert result2 == 10
-    assert call_count == 1
+    assert call_count == call_count_before  # Verify cache was used
 
     # Wait for cache to become stale
     await asyncio.sleep(1.5)
@@ -127,10 +128,11 @@ async def async_func(x):
     assert result1 == 10
     assert call_count == 1
 
-    # Second call - should use cache
+    # Second call - should use cache (no additional call)
+    call_count_before = call_count
     result2 = await async_func(5)
     assert result2 == 10
-    assert call_count == 1
+    assert call_count == call_count_before  # Verify cache was used
 
     # Wait for cache to become stale
     await asyncio.sleep(1.5)
@@ -329,10 +331,11 @@ async def async_func(x):
     assert result1 == 10
     assert call_count == 1
 
-    # Second call - should use cache
+    # Second call - should use cache (no additional call)
+    call_count_before = call_count
     result2 = await async_func(5)
     assert result2 == 10
-    assert call_count == 1
+    assert call_count == call_count_before  # Verify cache was used
 
     # Wait a bit
     await asyncio.sleep(0.5)
@@ -391,3 +394,68 @@ async def async_func(x):
     assert call_count == 0  # No new calls, all from cache
 
     async_func.clear_cache()
+
+
+# Test async with allow_none parameter
+@pytest.mark.memory
+@pytest.mark.asyncio
+async def test_async_allow_none():
+    """Test async caching with allow_none parameter."""
+    call_count = 0
+
+    # Test with allow_none=False (default)
+    @cachier(backend="memory")
+    async def async_func_no_none(x):
+        nonlocal call_count
+        call_count += 1
+        await asyncio.sleep(0.1)
+        return None if x == 0 else x * 2
+
+    async_func_no_none.clear_cache()
+    call_count = 0
+
+    # First call returning None - should not be cached
+    result1 = await async_func_no_none(0)
+    assert result1 is None
+    assert call_count == 1
+
+    # Second call with same args - should recalculate (None not cached)
+    result2 = await async_func_no_none(0)
+    assert result2 is None
+    assert call_count == 2
+
+    # Call with non-None result - should be cached
+    result3 = await async_func_no_none(5)
+    assert result3 == 10
+    assert call_count == 3
+
+    # Call again - should use cache
+    result4 = await async_func_no_none(5)
+    assert result4 == 10
+    assert call_count == 3  # No additional call
+
+    async_func_no_none.clear_cache()
+
+    # Test with allow_none=True
+    call_count = 0
+
+    @cachier(backend="memory", allow_none=True)
+    async def async_func_with_none(x):
+        nonlocal call_count
+        call_count += 1
+        await asyncio.sleep(0.1)
+        return None if x == 0 else x * 2
+
+    async_func_with_none.clear_cache()
+
+    # First call returning None - should be cached
+    result1 = await async_func_with_none(0)
+    assert result1 is None
+    assert call_count == 1
+
+    # Second call with same args - should use cached None
+    result2 = await async_func_with_none(0)
+    assert result2 is None
+    assert call_count == 1  # No additional call
+
+    async_func_with_none.clear_cache()