simple-dep-cache 0.2.0__tar.gz → 0.2.1__tar.gz

{simple_dep_cache-0.2.0 → simple_dep_cache-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: simple-dep-cache
-Version: 0.2.0
+Version: 0.2.1
 Summary: Redis-based caching library with intelligent dependency tracking for Python applications
 Project-URL: Homepage, https://github.com/tintty1/simple-dep-cache
 Project-URL: Repository, https://github.com/tintty1/simple-dep-cache

{simple_dep_cache-0.2.0 → simple_dep_cache-0.2.1}/src/simple_dep_cache/decorators.py

@@ -149,6 +149,32 @@ def _handle_callback_error(error: Exception, cache_manager: CacheManager, contex
         pass
 
 
+def _handle_backend_error(operation: str, func_name: str, error: Exception, silent: bool) -> None:
+    """Handle backend errors by logging or re-raising based on silent flag."""
+    if not silent:
+        raise
+    logger = logging.getLogger(__name__)
+    logger.warning("Backend error during %s for %s: %s", operation, func_name, error, exc_info=True)
+
+
+def _safe_backend_op(op: Callable, silent: bool, func_name: str, operation: str) -> Any:
+    """Execute a backend operation with optional error silencing."""
+    try:
+        return op()
+    except Exception as e:
+        _handle_backend_error(operation, func_name, e, silent)
+        return None
+
+
+async def _safe_backend_op_async(op: Callable, silent: bool, func_name: str, operation: str) -> Any:
+    """Execute an async backend operation with optional error silencing."""
+    try:
+        return await op()
+    except Exception as e:
+        _handle_backend_error(operation, func_name, e, silent)
+        return None
+
+
 def _cache_result_or_exception_sync(
     cache_manager: CacheManager,
     cache_key: str,
@@ -211,6 +237,7 @@ def cache_with_deps(
     dependencies: set | None = None,
     cache_exception_types: list[type[Exception]] | None = None,
     callback: Callable | None = None,
+    silent_backend_errors: bool = False,
 ) -> Callable:
     """
     Decorator for caching function results with dependency tracking.
@@ -226,6 +253,9 @@ def cache_with_deps(
         callback: Callback function invoked on cache hit or miss.
             Called with keyword arguments: func, cache_manager, args, kwargs, is_hit, cached_result
             is_hit=True for cache hits, False for cache misses (optional)
+        silent_backend_errors: If True, silently log backend errors (e.g., Redis connection errors)
+            instead of raising them. The decorated function will execute normally when backend
+            errors occur. Defaults to False (optional)
     """
 
     def decorator(func: Callable) -> Callable:
@@ -244,7 +274,14 @@ def cache_with_deps(
 
                 cache_key = _generate_cache_key(func, args, kwargs)
 
-                cached_result = await active_cache_manager.aget(cache_key)
+                # Try to get from cache with optional error silencing
+                cached_result = await _safe_backend_op_async(
+                    lambda: active_cache_manager.aget(cache_key),
+                    silent_backend_errors,
+                    func.__qualname__,
+                    "cache get",
+                )
+
                 if cached_result is not None:
                     cache_hit_result = _handle_cache_hit(cached_result)
                     if cache_hit_result is not None:
@@ -284,14 +321,21 @@ def cache_with_deps(
                 finally:
                     current_deps = get_current_dependencies()
                     effective_ttl = get_cache_ttl()
-                    await _cache_result_or_exception_async(
-                        active_cache_manager,
-                        cache_key,
-                        result,
-                        exception,
-                        current_deps,
-                        effective_ttl,
-                        cache_exception_types,
+
+                    # Try to set cache with optional error silencing
+                    await _safe_backend_op_async(
+                        lambda: _cache_result_or_exception_async(
+                            active_cache_manager,
+                            cache_key,
+                            result,
+                            exception,
+                            current_deps,
+                            effective_ttl,
+                            cache_exception_types,
+                        ),
+                        silent_backend_errors,
+                        func.__qualname__,
+                        "cache set",
                     )
 
                     # Invoke callback for cache miss
@@ -338,7 +382,14 @@ def cache_with_deps(
 
                 cache_key = _generate_cache_key(func, args, kwargs)
 
-                cached_result = active_cache_manager.get(cache_key)
+                # Try to get from cache with optional error silencing
+                cached_result = _safe_backend_op(
+                    lambda: active_cache_manager.get(cache_key),
+                    silent_backend_errors,
+                    func.__qualname__,
+                    "cache get",
+                )
+
                 if cached_result is not None:
                     cache_hit_result = _handle_cache_hit(cached_result)
                     if cache_hit_result is not None:
@@ -368,14 +419,21 @@ def cache_with_deps(
                 finally:
                     current_deps = get_current_dependencies()
                     effective_ttl = get_cache_ttl()
-                    _cache_result_or_exception_sync(
-                        active_cache_manager,
-                        cache_key,
-                        result,
-                        exception,
-                        current_deps,
-                        effective_ttl,
-                        cache_exception_types,
+
+                    # Try to set cache with optional error silencing
+                    _safe_backend_op(
+                        lambda: _cache_result_or_exception_sync(
+                            active_cache_manager,
+                            cache_key,
+                            result,
+                            exception,
+                            current_deps,
+                            effective_ttl,
+                            cache_exception_types,
+                        ),
+                        silent_backend_errors,
+                        func.__qualname__,
+                        "cache set",
                     )
 
                     # Invoke callback for cache miss

simple_dep_cache-0.2.1/tests/test_silent_backend_errors.py

@@ -0,0 +1,207 @@
+"""Tests for the silent_backend_errors parameter in cache_with_deps decorator."""
+
+from unittest.mock import Mock
+
+import pytest
+
+from simple_dep_cache.decorators import cache_with_deps
+from simple_dep_cache.fakes import FakeAsyncCacheBackend, FakeCacheBackend, FakeConfig
+from simple_dep_cache.manager import get_or_create_cache_manager
+
+
+class TestSilentBackendErrors:
+    """Test cases for silent_backend_errors parameter."""
+
+    def test_silent_backend_errors_on_get(self):
+        """Test that backend errors during get are silently logged."""
+        # Create a fake backend that will raise an error on get
+        config = FakeConfig(prefix="test_get_error")
+        backend = FakeCacheBackend(config)
+        cache_manager = get_or_create_cache_manager(
+            name="test_get_error", config=config, backend=backend
+        )
+        assert cache_manager is not None
+
+        # Mock the backend's get method to raise an error
+        backend.get = Mock(side_effect=ConnectionError("Redis connection failed"))
+
+        call_count = 0
+
+        @cache_with_deps(name=cache_manager.name, silent_backend_errors=True)
+        def my_function(x):
+            nonlocal call_count
+            call_count += 1
+            return x * 2
+
+        # Should execute function normally despite backend error
+        result = my_function(5)
+        assert result == 10
+        assert call_count == 1
+
+    def test_silent_backend_errors_on_set(self):
+        """Test that backend errors during set are silently logged."""
+        # Create a fake backend that will raise an error on set
+        config = FakeConfig(prefix="test_set_error")
+        backend = FakeCacheBackend(config)
+        cache_manager = get_or_create_cache_manager(
+            name="test_set_error", config=config, backend=backend
+        )
+        assert cache_manager is not None
+
+        # Mock the backend's set method to raise an error
+        backend.set = Mock(side_effect=ConnectionError("Redis connection failed"))
+
+        call_count = 0
+
+        @cache_with_deps(name=cache_manager.name, silent_backend_errors=True)
+        def my_function(x):
+            nonlocal call_count
+            call_count += 1
+            return x * 2
+
+        # Should execute function normally despite backend error
+        result = my_function(5)
+        assert result == 10
+        assert call_count == 1
+
+    def test_silent_backend_errors_disabled_by_default(self):
+        """Test that backend errors are raised by default (silent_backend_errors=False)."""
+        # Create a fake backend that will raise an error on get
+        config = FakeConfig(prefix="test_error_default")
+        backend = FakeCacheBackend(config)
+        cache_manager = get_or_create_cache_manager(
+            name="test_error_default", config=config, backend=backend
+        )
+        assert cache_manager is not None
+
+        # Mock the backend's get method to raise an error
+        backend.get = Mock(side_effect=ConnectionError("Redis connection failed"))
+
+        @cache_with_deps(name=cache_manager.name)
+        def my_function(x):
+            return x * 2
+
+        # Should raise the backend error
+        with pytest.raises(ConnectionError, match="Redis connection failed"):
+            my_function(5)
+
+    @pytest.mark.asyncio
+    async def test_silent_backend_errors_with_async(self):
+        """Test that silent_backend_errors works with async functions."""
+        # Create a fake async backend that will raise an error on get
+        config = FakeConfig(prefix="test_async_error")
+        async_backend = FakeAsyncCacheBackend(config)
+        cache_manager = get_or_create_cache_manager(
+            name="test_async_error",
+            config=config,
+            async_backend=async_backend,
+            create_async_backend=True,
+        )
+        assert cache_manager is not None
+
+        # Mock the backend's get method to raise an error
+        async def mock_get(key):
+            raise ConnectionError("Redis connection failed")
+
+        async_backend.get = mock_get
+
+        call_count = 0
+
+        @cache_with_deps(name=cache_manager.name, silent_backend_errors=True)
+        async def my_async_function(x):
+            nonlocal call_count
+            call_count += 1
+            return x * 2
+
+        # Should execute function normally despite backend error
+        result = await my_async_function(5)
+        assert result == 10
+        assert call_count == 1
+
+    @pytest.mark.asyncio
+    async def test_silent_backend_errors_async_disabled_by_default(self):
+        """Test that backend errors are raised by default in async functions."""
+        # Create a fake async backend that will raise an error on get
+        config = FakeConfig(prefix="test_async_error_default")
+        async_backend = FakeAsyncCacheBackend(config)
+        cache_manager = get_or_create_cache_manager(
+            name="test_async_error_default",
+            config=config,
+            async_backend=async_backend,
+            create_async_backend=True,
+        )
+        assert cache_manager is not None
+
+        # Mock the backend's get method to raise an error
+        async def mock_get(key):
+            raise ConnectionError("Redis connection failed")
+
+        async_backend.get = mock_get
+
+        @cache_with_deps(name=cache_manager.name)
+        async def my_async_function(x):
+            return x * 2
+
+        # Should raise the backend error
+        with pytest.raises(ConnectionError, match="Redis connection failed"):
+            await my_async_function(5)
+
+    def test_silent_backend_errors_multiple_calls(self):
+        """Test that function executes correctly with persistent backend errors."""
+        config = FakeConfig(prefix="test_multiple_calls")
+        backend = FakeCacheBackend(config)
+        cache_manager = get_or_create_cache_manager(
+            name="test_multiple_calls", config=config, backend=backend
+        )
+        assert cache_manager is not None
+
+        # Mock the backend to always fail
+        backend.get = Mock(side_effect=ConnectionError("Redis connection failed"))
+        backend.set = Mock(side_effect=ConnectionError("Redis connection failed"))
+
+        call_count = 0
+
+        @cache_with_deps(name=cache_manager.name, silent_backend_errors=True)
+        def my_function(x):
+            nonlocal call_count
+            call_count += 1
+            return x * 2
+
+        # Call multiple times - should work each time
+        result1 = my_function(5)
+        result2 = my_function(10)
+        result3 = my_function(5)  # Same arg as first call
+
+        assert result1 == 10
+        assert result2 == 20
+        assert result3 == 10
+        assert call_count == 3  # Function called every time (no caching due to backend errors)
+
+    def test_silent_backend_errors_partial_failure(self):
+        """Test behavior when only get fails but set works."""
+        config = FakeConfig(prefix="test_partial_failure")
+        backend = FakeCacheBackend(config)
+        cache_manager = get_or_create_cache_manager(
+            name="test_partial_failure", config=config, backend=backend
+        )
+        assert cache_manager is not None
+
+        # Mock the backend's get to fail, but set works normally
+        backend.get = Mock(side_effect=ConnectionError("Redis connection failed"))
+        call_count = 0
+
+        @cache_with_deps(name=cache_manager.name, silent_backend_errors=True)
+        def my_function(x):
+            nonlocal call_count
+            call_count += 1
+            return x * 2
+
+        # First call: get fails, function executes, set succeeds
+        result1 = my_function(5)
+        assert result1 == 10
+        assert call_count == 1
+
+        # Second call: get still fails, function executes again
+        result2 = my_function(5)
+        assert result2 == 10
+        assert call_count == 2  # Function called again due to get failure