Buckets:
AnonymousSpottedToad/candidate_bucket / codebase /python /allen0099_FastAPI-CacheX /tests /state /test_manager.py
| """Tests for OAuth state manager functionality.""" | |
| import hashlib | |
| import json | |
| import socket | |
| from collections.abc import AsyncGenerator | |
| from datetime import datetime | |
| from datetime import timedelta | |
| from datetime import timezone | |
| from typing import Any | |
| import pytest | |
| import pytest_asyncio | |
| from fastapi_cachex.backends.base import BaseCacheBackend | |
| from fastapi_cachex.backends.memory import MemoryBackend | |
| from fastapi_cachex.proxy import BackendProxy | |
| from fastapi_cachex.state.exceptions import InvalidStateError | |
| from fastapi_cachex.state.exceptions import StateDataError | |
| from fastapi_cachex.state.manager import StateManager | |
| from fastapi_cachex.state.models import StateData | |
| from fastapi_cachex.types import CacheEntry | |
| def is_redis_running(host: str = "127.0.0.1", port: int = 6379) -> bool: | |
| """Check if Redis server is running.""" | |
| try: | |
| s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) | |
| s.settimeout(1.0) | |
| s.connect((host, port)) | |
| s.close() | |
| except (TimeoutError, ConnectionRefusedError, OSError): | |
| return False | |
| else: | |
| return True | |
| def has_redis_package() -> bool: | |
| """Return True if the redis package is importable.""" | |
| try: | |
| import redis.asyncio # type: ignore[unused-ignore] # noqa: F401 | |
| except Exception: | |
| return False | |
| return True | |
| async def memory_backend_for_state() -> AsyncGenerator[BaseCacheBackend, Any]: | |
| """Create a MemoryBackend instance.""" | |
| backend = MemoryBackend() | |
| backend.start_cleanup() | |
| yield backend | |
| backend.stop_cleanup() | |
| async def redis_backend_for_state() -> AsyncGenerator[BaseCacheBackend, Any]: | |
| """Create a Redis backend instance if Redis is available.""" | |
| if not is_redis_running() or not has_redis_package(): | |
| pytest.skip("Redis server is not running or redis package not installed") | |
| from fastapi_cachex.backends import AsyncRedisCacheBackend | |
| backend = AsyncRedisCacheBackend( | |
| host="127.0.0.1", | |
| port=6379, | |
| socket_timeout=1.0, | |
| socket_connect_timeout=1.0, | |
| key_prefix="test_state:", | |
| ) | |
| yield backend | |
| await backend.clear() | |
| async def state_manager( | |
| request: Any, | |
| ) -> AsyncGenerator[StateManager, Any]: | |
| """Create a StateManager instance with different backends. | |
| This fixture is parametrized to test with: | |
| - MemoryBackend (always runs) | |
| - RedisBackend (runs only if Redis is available) | |
| """ | |
| backend_type = request.param | |
| if backend_type == "memory": | |
| mem_backend = MemoryBackend() | |
| mem_backend.start_cleanup() | |
| backend: BaseCacheBackend = mem_backend | |
| else: # redis | |
| from fastapi_cachex.backends import AsyncRedisCacheBackend | |
| backend = AsyncRedisCacheBackend( | |
| host="127.0.0.1", | |
| port=6379, | |
| socket_timeout=1.0, | |
| socket_connect_timeout=1.0, | |
| key_prefix="test_state:", | |
| ) | |
| BackendProxy.set(backend) | |
| manager = StateManager() | |
| yield manager | |
| # Cleanup | |
| await backend.clear() | |
| if backend_type == "memory" and isinstance(backend, MemoryBackend): | |
| backend.stop_cleanup() | |
| async def test_create_state_basic(state_manager: StateManager) -> None: | |
| """Test creating a basic OAuth state.""" | |
| state = await state_manager.create_state() | |
| assert state is not None | |
| assert isinstance(state, str) | |
| assert len(state) > 0 | |
| async def test_create_state_with_metadata(state_manager: StateManager) -> None: | |
| """Test creating OAuth state with metadata.""" | |
| metadata = { | |
| "callback_url": "http://localhost:8000/callback", | |
| "user_id": "user123", | |
| "provider": "google", | |
| } | |
| state = await state_manager.create_state(metadata=metadata) | |
| # Verify state was created | |
| assert state is not None | |
| # Retrieve and verify metadata | |
| retrieved_metadata = await state_manager.get_state_metadata(state) | |
| assert retrieved_metadata == metadata | |
| async def test_create_state_with_custom_ttl(state_manager: StateManager) -> None: | |
| """Test creating OAuth state with custom TTL.""" | |
| custom_ttl = 1800 # 30 minutes | |
| state = await state_manager.create_state(ttl=custom_ttl) | |
| # Verify state was created and stored | |
| is_valid = await state_manager.validate_state(state) | |
| assert is_valid is True | |
| async def test_consume_state(state_manager: StateManager) -> None: | |
| """Test consuming a valid OAuth state.""" | |
| state = await state_manager.create_state() | |
| # Consume the state | |
| state_data = await state_manager.consume_state(state) | |
| assert isinstance(state_data, StateData) | |
| assert state_data.state == state | |
| assert state_data.created_at is not None | |
| assert state_data.expires_at is not None | |
| assert state_data.metadata is not None | |
| # State should no longer be valid after consumption | |
| is_valid = await state_manager.validate_state(state) | |
| assert is_valid is False | |
| async def test_consume_state_with_different_manager( | |
| memory_backend: MemoryBackend, | |
| ) -> None: | |
| """Test consuming state with a different StateManager instance.""" | |
| BackendProxy.set(memory_backend) | |
| manager1 = StateManager() | |
| state = await manager1.create_state() | |
| # Create a new StateManager instance | |
| new_manager = StateManager() | |
| state_data = await new_manager.consume_state(state) | |
| assert isinstance(state_data, StateData) | |
| assert state_data.state == state | |
| # Original manager should also see the state as consumed | |
| is_valid = await manager1.validate_state(state) | |
| assert is_valid is False | |
| async def test_consume_state_with_metadata(state_manager: StateManager) -> None: | |
| """Test consuming state and retrieving its metadata.""" | |
| metadata = { | |
| "callback_url": "http://localhost:8000/callback", | |
| "nonce": "random_nonce", | |
| } | |
| state = await state_manager.create_state(metadata=metadata) | |
| # Consume the state | |
| state_data = await state_manager.consume_state(state) | |
| assert state_data.metadata == metadata | |
| async def test_consume_invalid_state(state_manager: StateManager) -> None: | |
| """Test consuming an invalid state raises InvalidStateError.""" | |
| with pytest.raises(InvalidStateError, match="Invalid or expired state"): | |
| await state_manager.consume_state("invalid_state_string") | |
| async def test_consume_expired_state(state_manager: StateManager) -> None: | |
| """Test consuming an expired state raises an error. | |
| Different backends behave differently for expired states: | |
| - MemoryBackend: InvalidStateError (auto-removes expired entries) | |
| - RedisBackend: StateExpiredError (TTL expired but data still exists) | |
| """ | |
| from fastapi_cachex.state.exceptions import StateExpiredError | |
| # Create state with very short TTL | |
| state = await state_manager.create_state(ttl=1) | |
| # Wait for state to expire from cache backend | |
| import asyncio | |
| await asyncio.sleep(1.1) | |
| # Try to consume expired state - should fail with one of these exceptions | |
| with pytest.raises((InvalidStateError, StateExpiredError)): | |
| await state_manager.consume_state(state) | |
| async def test_validate_state(state_manager: StateManager) -> None: | |
| """Test validating a state without consuming it.""" | |
| state = await state_manager.create_state() | |
| # Validate the state | |
| is_valid = await state_manager.validate_state(state) | |
| assert is_valid is True | |
| # State should still be valid after validation | |
| is_valid_again = await state_manager.validate_state(state) | |
| assert is_valid_again is True | |
| async def test_validate_invalid_state(state_manager: StateManager) -> None: | |
| """Test validating an invalid state.""" | |
| is_valid = await state_manager.validate_state("invalid_state") | |
| assert is_valid is False | |
| async def test_get_state_metadata_valid(state_manager: StateManager) -> None: | |
| """Test retrieving metadata from a valid state.""" | |
| metadata = {"key": "value", "nested": {"data": 123}} | |
| state = await state_manager.create_state(metadata=metadata) | |
| # Retrieve metadata without consuming | |
| retrieved = await state_manager.get_state_metadata(state) | |
| assert retrieved == metadata | |
| async def test_get_state_metadata_invalid(state_manager: StateManager) -> None: | |
| """Test retrieving metadata from an invalid state.""" | |
| retrieved = await state_manager.get_state_metadata("invalid_state") | |
| assert retrieved is None | |
| async def test_delete_state(state_manager: StateManager) -> None: | |
| """Test manually deleting a state.""" | |
| state = await state_manager.create_state() | |
| # Verify state exists | |
| is_valid = await state_manager.validate_state(state) | |
| assert is_valid is True | |
| # Delete the state | |
| deleted = await state_manager.delete_state(state) | |
| assert deleted is True | |
| # Verify state no longer exists | |
| is_valid_after = await state_manager.validate_state(state) | |
| assert is_valid_after is False | |
| async def test_multiple_states_independent(state_manager: StateManager) -> None: | |
| """Test that multiple states are independent.""" | |
| metadata1 = {"user_id": "user1"} | |
| metadata2 = {"user_id": "user2"} | |
| state1 = await state_manager.create_state(metadata=metadata1) | |
| state2 = await state_manager.create_state(metadata=metadata2) | |
| # States should be different | |
| assert state1 != state2 | |
| # Each state should have its own metadata | |
| retrieved1 = await state_manager.get_state_metadata(state1) | |
| retrieved2 = await state_manager.get_state_metadata(state2) | |
| assert retrieved1 == metadata1 | |
| assert retrieved2 == metadata2 | |
| # Consuming one shouldn't affect the other | |
| await state_manager.consume_state(state1) | |
| is_valid1 = await state_manager.validate_state(state1) | |
| is_valid2 = await state_manager.validate_state(state2) | |
| assert is_valid1 is False | |
| assert is_valid2 is True | |
| async def test_state_expiry_information(state_manager: StateManager) -> None: | |
| """Test that state data contains correct expiry information.""" | |
| ttl = 3600 | |
| state = await state_manager.create_state(ttl=ttl) | |
| state_data = await state_manager.consume_state(state) | |
| # Verify timestamps are present and correct | |
| assert isinstance(state_data.created_at, datetime) | |
| assert isinstance(state_data.expires_at, datetime) | |
| # Expiry should be approximately TTL seconds after creation | |
| time_diff = (state_data.expires_at - state_data.created_at).total_seconds() | |
| assert abs(time_diff - ttl) < 5 # Allow 5 seconds tolerance | |
| async def test_state_manager_custom_prefix(memory_backend: MemoryBackend) -> None: | |
| """Test StateManager with custom key prefix.""" | |
| BackendProxy.set(memory_backend) | |
| manager = StateManager(key_prefix="custom_prefix:") | |
| state = await manager.create_state(metadata={"test": "data"}) | |
| # Verify state works with custom prefix | |
| is_valid = await manager.validate_state(state) | |
| assert is_valid is True | |
| # Different manager with different prefix shouldn't find the state | |
| other_manager = StateManager(key_prefix="other_prefix:") | |
| is_valid_other = await other_manager.validate_state(state) | |
| assert is_valid_other is False | |
| async def test_state_reuse_prevention(state_manager: StateManager) -> None: | |
| """Test that consumed states cannot be reused.""" | |
| state = await state_manager.create_state() | |
| # Consume the state once | |
| await state_manager.consume_state(state) | |
| # Try to consume again - should fail | |
| with pytest.raises(InvalidStateError): | |
| await state_manager.consume_state(state) | |
| async def test_get_state_metadata_after_expire(state_manager: StateManager) -> None: | |
| """Test retrieving metadata from an expired state.""" | |
| # Create state with very short TTL | |
| state = await state_manager.create_state(ttl=1, metadata={"test": "data"}) | |
| # Wait for state to expire | |
| import asyncio | |
| await asyncio.sleep(1.1) | |
| # Try to retrieve metadata - should return None since it's expired | |
| retrieved = await state_manager.get_state_metadata(state) | |
| assert retrieved is None | |
| async def test_consume_state_with_invalid_json(state_manager: StateManager) -> None: | |
| """Test consuming state when backend returns invalid JSON.""" | |
| # Directly set invalid JSON in backend | |
| cache_key = f"{state_manager.key_prefix}bad_state" | |
| etag = hashlib.sha256(b"not valid json").hexdigest() | |
| entry = CacheEntry(fingerprint=etag, content=b"not valid json") | |
| await state_manager.backend.set(cache_key, entry, ttl=600) | |
| # Try to consume - should raise StateDataError | |
| with pytest.raises(StateDataError, match="Failed to parse state data"): | |
| await state_manager.consume_state("bad_state") | |
| async def test_get_metadata_with_invalid_json(state_manager: StateManager) -> None: | |
| """Test retrieving metadata when backend returns invalid JSON.""" | |
| # Directly set invalid JSON in backend | |
| cache_key = f"{state_manager.key_prefix}bad_state" | |
| etag = hashlib.sha256(b"not valid json").hexdigest() | |
| entry = CacheEntry(fingerprint=etag, content=b"not valid json") | |
| await state_manager.backend.set(cache_key, entry, ttl=600) | |
| # Try to retrieve metadata - should return None | |
| retrieved = await state_manager.get_state_metadata("bad_state") | |
| assert retrieved is None | |
| async def test_validate_state_with_invalid_json(state_manager: StateManager) -> None: | |
| """Test validating state when backend returns invalid JSON.""" | |
| # Directly set invalid JSON in backend | |
| cache_key = f"{state_manager.key_prefix}bad_state" | |
| etag = hashlib.sha256(b"not valid json").hexdigest() | |
| entry = CacheEntry(fingerprint=etag, content=b"not valid json") | |
| await state_manager.backend.set(cache_key, entry, ttl=600) | |
| # Try to validate - should return False | |
| is_valid = await state_manager.validate_state("bad_state") | |
| assert is_valid is False | |
| async def test_create_state_empty_metadata(state_manager: StateManager) -> None: | |
| """Test creating state with empty metadata.""" | |
| state = await state_manager.create_state(metadata={}) | |
| # Verify metadata is empty dict | |
| metadata = await state_manager.get_state_metadata(state) | |
| assert metadata == {} | |
| async def test_state_with_complex_nested_metadata(state_manager: StateManager) -> None: | |
| """Test state with complex nested metadata structures.""" | |
| complex_metadata = { | |
| "level1": { | |
| "level2": { | |
| "level3": ["item1", "item2", {"key": "value"}], | |
| "numbers": [1, 2, 3], | |
| }, | |
| "boolean": True, | |
| "null_value": None, | |
| }, | |
| "list_of_dicts": [{"a": 1}, {"b": 2}], | |
| } | |
| state = await state_manager.create_state(metadata=complex_metadata) | |
| retrieved = await state_manager.get_state_metadata(state) | |
| assert retrieved == complex_metadata | |
| async def test_get_metadata_with_missing_expiry(state_manager: StateManager) -> None: | |
| """Test retrieving metadata when state data is missing expiry.""" | |
| state = "test_state" | |
| cache_key = f"{state_manager.key_prefix}{state}" | |
| # Create StateData with default expires_at | |
| state_data_obj = StateData( | |
| state=state, | |
| metadata={"test": "data"}, | |
| expires_at=datetime.now(timezone.utc) + timedelta(hours=1), | |
| ) | |
| json_content = json.dumps(state_data_obj.model_dump(mode="json")) | |
| etag = hashlib.sha256(json_content.encode()).hexdigest() | |
| entry = CacheEntry(fingerprint=etag, content=json_content.encode("utf-8")) | |
| await state_manager.backend.set(cache_key, entry, ttl=600) | |
| # Should still work and return metadata | |
| retrieved = await state_manager.get_state_metadata(state) | |
| assert retrieved == {"test": "data"} | |
| async def test_validate_state_with_missing_expiry(state_manager: StateManager) -> None: | |
| """Test validating state when state data is missing expiry.""" | |
| state = "test_state" | |
| cache_key = f"{state_manager.key_prefix}{state}" | |
| state_data_obj = StateData( | |
| state=state, | |
| metadata={"test": "data"}, | |
| expires_at=datetime.now(timezone.utc) + timedelta(hours=1), | |
| ) | |
| json_content = json.dumps(state_data_obj.model_dump(mode="json")) | |
| etag = hashlib.sha256(json_content.encode()).hexdigest() | |
| entry = CacheEntry(fingerprint=etag, content=json_content.encode("utf-8")) | |
| await state_manager.backend.set(cache_key, entry, ttl=600) | |
| # Should validate as valid | |
| is_valid = await state_manager.validate_state(state) | |
| assert is_valid is True | |
| async def test_validate_state_with_invalid_expiry_format( | |
| state_manager: StateManager, | |
| ) -> None: | |
| """Test validating state when expires_at has invalid format.""" | |
| state = "test_state" | |
| cache_key = f"{state_manager.key_prefix}{state}" | |
| # Manually construct invalid state data | |
| state_data = { | |
| "state": state, | |
| "created_at": datetime.now(timezone.utc).isoformat(), | |
| "expires_at": "invalid-date-format", | |
| "metadata": {"test": "data"}, | |
| } | |
| json_content = json.dumps(state_data) | |
| etag = hashlib.sha256(json_content.encode()).hexdigest() | |
| entry = CacheEntry(fingerprint=etag, content=json_content.encode("utf-8")) | |
| await state_manager.backend.set(cache_key, entry, ttl=600) | |
| # Should return False due to invalid expiry | |
| is_valid = await state_manager.validate_state(state) | |
| assert is_valid is False | |
| async def test_get_metadata_with_invalid_expiry_format( | |
| state_manager: StateManager, | |
| ) -> None: | |
| """Test retrieving metadata when expires_at has invalid format.""" | |
| state = "test_state" | |
| cache_key = f"{state_manager.key_prefix}{state}" | |
| # Manually construct invalid state data | |
| state_data = { | |
| "state": state, | |
| "created_at": datetime.now(timezone.utc).isoformat(), | |
| "expires_at": "invalid-date-format", | |
| "metadata": {"test": "data"}, | |
| } | |
| json_content = json.dumps(state_data) | |
| etag = hashlib.sha256(json_content.encode()).hexdigest() | |
| entry = CacheEntry(fingerprint=etag, content=json_content.encode("utf-8")) | |
| await state_manager.backend.set(cache_key, entry, ttl=600) | |
| # Should return None due to invalid expiry | |
| retrieved = await state_manager.get_state_metadata(state) | |
| assert retrieved is None | |
| async def test_consume_state_with_missing_expiry(state_manager: StateManager) -> None: | |
| """Test consuming state when state data is missing expiry.""" | |
| state = "test_state" | |
| cache_key = f"{state_manager.key_prefix}{state}" | |
| # Manually construct state data without expires_at | |
| state_data = { | |
| "state": state, | |
| "created_at": datetime.now(timezone.utc).isoformat(), | |
| "metadata": {"test": "data"}, | |
| } | |
| json_content = json.dumps(state_data) | |
| etag = hashlib.sha256(json_content.encode()).hexdigest() | |
| entry = CacheEntry(fingerprint=etag, content=json_content.encode("utf-8")) | |
| await state_manager.backend.set(cache_key, entry, ttl=600) | |
| with pytest.raises(StateDataError): | |
| await state_manager.consume_state(state) | |
| async def test_consume_state_with_non_string_content( | |
| state_manager: StateManager, | |
| ) -> None: | |
| """Test consuming state when backend content is not a string.""" | |
| # Directly set non-string content in backend | |
| cache_key = f"{state_manager.key_prefix}bad_state" | |
| # CacheEntry with non-string content (testing edge case) | |
| entry = CacheEntry(fingerprint="test", content=b"\xff\xfe non-utf8") | |
| await state_manager.backend.set(cache_key, entry, ttl=600) | |
| # Try to consume - should raise StateDataError | |
| with pytest.raises(StateDataError, match="Unexpected state data format"): | |
| await state_manager.consume_state("bad_state") | |
| async def test_validate_state_with_non_string_content( | |
| state_manager: StateManager, | |
| ) -> None: | |
| """Test validating state when backend content is not a string.""" | |
| cache_key = f"{state_manager.key_prefix}bad_state" | |
| entry = CacheEntry(fingerprint="test", content=b"\xff\xfe non-utf8") | |
| await state_manager.backend.set(cache_key, entry, ttl=600) | |
| # Try to validate - should return False | |
| is_valid = await state_manager.validate_state("bad_state") | |
| assert is_valid is False | |
| async def test_get_metadata_with_non_string_content( | |
| state_manager: StateManager, | |
| ) -> None: | |
| """Test retrieving metadata when backend content is not a string.""" | |
| cache_key = f"{state_manager.key_prefix}bad_state" | |
| entry = CacheEntry(fingerprint="test", content=b"\xff\xfe non-utf8") | |
| await state_manager.backend.set(cache_key, entry, ttl=600) | |
| # Try to retrieve metadata - should return None | |
| retrieved = await state_manager.get_state_metadata("bad_state") | |
| assert retrieved is None | |
| async def test_get_metadata_with_non_dict_metadata(state_manager: StateManager) -> None: | |
| """Test retrieving metadata when metadata is not a dict.""" | |
| state = "test_state" | |
| cache_key = f"{state_manager.key_prefix}{state}" | |
| # Manually construct state data with invalid metadata | |
| state_data = { | |
| "state": state, | |
| "created_at": datetime.now(timezone.utc).isoformat(), | |
| "expires_at": (datetime.now(timezone.utc) + timedelta(hours=1)).isoformat(), | |
| "metadata": "not a dict", # Invalid metadata type | |
| } | |
| json_content = json.dumps(state_data) | |
| etag = hashlib.sha256(json_content.encode()).hexdigest() | |
| entry = CacheEntry(fingerprint=etag, content=json_content.encode("utf-8")) | |
| await state_manager.backend.set(cache_key, entry, ttl=600) | |
| # Should return None since metadata validation fails | |
| retrieved = await state_manager.get_state_metadata(state) | |
| assert retrieved is None | |
| async def test_consume_state_with_bad_expiry_date(state_manager: StateManager) -> None: | |
| """Test consuming state when expiry date has invalid format.""" | |
| state = "test_state" | |
| cache_key = f"{state_manager.key_prefix}{state}" | |
| # Manually construct state data with invalid expiry | |
| state_data = { | |
| "state": state, | |
| "created_at": datetime.now(timezone.utc).isoformat(), | |
| "expires_at": "bad-date", | |
| "metadata": {}, | |
| } | |
| json_content = json.dumps(state_data) | |
| etag = hashlib.sha256(json_content.encode()).hexdigest() | |
| entry = CacheEntry(fingerprint=etag, content=json_content.encode("utf-8")) | |
| await state_manager.backend.set(cache_key, entry, ttl=600) | |
| # Should raise StateDataError due to bad expiry format | |
| with pytest.raises(StateDataError, match="Invalid state data structure"): | |
| await state_manager.consume_state(state) | |
| # --------------------------------------------------------------------------- | |
| # New tests for fixes applied in this session | |
| # --------------------------------------------------------------------------- | |
| async def test_delete_state_nonexistent_returns_false( | |
| state_manager: StateManager, | |
| ) -> None: | |
| """delete_state() must return False for a state that was never created.""" | |
| result = await state_manager.delete_state("this_state_does_not_exist") | |
| assert result is False | |
| async def test_delete_state_existing_returns_true( | |
| state_manager: StateManager, | |
| ) -> None: | |
| """delete_state() must return True when the state exists and is deleted.""" | |
| state = await state_manager.create_state() | |
| result = await state_manager.delete_state(state) | |
| assert result is True | |
| # And it's gone now | |
| is_valid = await state_manager.validate_state(state) | |
| assert is_valid is False | |
| async def test_delete_state_idempotent_returns_false_on_second_call( | |
| state_manager: StateManager, | |
| ) -> None: | |
| """Deleting a state twice: second call must return False.""" | |
| state = await state_manager.create_state() | |
| assert await state_manager.delete_state(state) is True | |
| assert await state_manager.delete_state(state) is False | |
| async def test_state_manager_accepts_explicit_backend() -> None: | |
| """StateManager(backend=...) must use the provided backend without touching BackendProxy.""" | |
| backend = MemoryBackend() | |
| backend.start_cleanup() | |
| try: | |
| # Ensure BackendProxy is NOT set (or set to something else); the manager | |
| # should never call BackendProxy.get() when a backend is passed directly. | |
| BackendProxy.set(None) | |
| manager = StateManager(backend=backend) | |
| assert manager.backend is backend | |
| state = await manager.create_state(metadata={"direct": True}) | |
| is_valid = await manager.validate_state(state) | |
| assert is_valid is True | |
| finally: | |
| backend.stop_cleanup() | |
| await backend.clear() | |
| async def test_state_manager_falls_back_to_backend_proxy( | |
| memory_backend: MemoryBackend, | |
| ) -> None: | |
| """StateManager() with no backend argument must use BackendProxy.get().""" | |
| # setup_default_backend (autouse) already set a backend on BackendProxy. | |
| # StateManager() must pick that up via BackendProxy.get(). | |
| proxy_backend = BackendProxy.get() | |
| manager = StateManager() | |
| # The manager should use whatever BackendProxy currently holds | |
| assert manager.backend is proxy_backend | |
| state = await manager.create_state() | |
| assert await manager.validate_state(state) is True | |
| def test_state_manager_raises_when_no_backend_configured() -> None: | |
| """StateManager() raises BackendNotFoundError if no backend is configured in the proxy.""" | |
| from fastapi_cachex.exceptions import BackendNotFoundError | |
| BackendProxy.set(None) | |
| try: | |
| with pytest.raises(BackendNotFoundError): | |
| StateManager() | |
| finally: | |
| # Restore a backend so the autouse fixture teardown works correctly | |
| BackendProxy.set(MemoryBackend()) | |
| async def test_consume_state_has_exactly_one_winner_under_concurrency( | |
| state_manager: StateManager, | |
| ) -> None: | |
| """A replayed callback racing the real one must not be accepted twice.""" | |
| import asyncio | |
| state = await state_manager.create_state(metadata={"n": 1}) | |
| results = await asyncio.gather( | |
| *(state_manager.consume_state(state) for _ in range(10)), | |
| return_exceptions=True, | |
| ) | |
| winners = [r for r in results if isinstance(r, StateData)] | |
| losers = [r for r in results if isinstance(r, InvalidStateError)] | |
| assert len(winners) == 1 | |
| assert len(losers) == 9 | |
| assert winners[0].metadata == {"n": 1} | |
| async def test_consume_state_past_wall_clock_expiry_removes_the_entry( | |
| state_manager: StateManager, | |
| ) -> None: | |
| """An entry whose expires_at passed before the backend TTL is gone after consume.""" | |
| from datetime import datetime | |
| from datetime import timedelta | |
| from datetime import timezone | |
| from fastapi_cachex.state.exceptions import StateExpiredError | |
| state = await state_manager.create_state(ttl=60) | |
| cache_key = f"{state_manager.key_prefix}{state}" | |
| cached = await state_manager.backend.get(cache_key) | |
| assert cached is not None | |
| stale = json.loads(cached.content.decode()) | |
| stale["expires_at"] = ( | |
| datetime.now(timezone.utc) - timedelta(seconds=1) | |
| ).isoformat() | |
| await state_manager.backend.set( | |
| cache_key, | |
| CacheEntry(fingerprint="stale", content=json.dumps(stale).encode()), | |
| ttl=60, | |
| ) | |
| with pytest.raises(StateExpiredError): | |
| await state_manager.consume_state(state) | |
| assert await state_manager.backend.get(cache_key) is None | |
| assert await state_manager.validate_state(state) is False | |
| async def test_peeking_a_state_past_its_wall_clock_expiry_treats_it_as_gone( | |
| state_manager: StateManager, | |
| ) -> None: | |
| """A stored entry whose expires_at already passed neither validates nor yields metadata.""" | |
| state = "stale_state" | |
| state_data_obj = StateData( | |
| state=state, | |
| metadata={"test": "data"}, | |
| expires_at=datetime.now(timezone.utc) - timedelta(seconds=1), | |
| ) | |
| content = state_data_obj.model_dump_json().encode("utf-8") | |
| entry = CacheEntry(fingerprint=hashlib.sha256(content).hexdigest(), content=content) | |
| await state_manager.backend.set( | |
| f"{state_manager.key_prefix}{state}", entry, ttl=600 | |
| ) | |
| assert await state_manager.validate_state(state) is False | |
| assert await state_manager.get_state_metadata(state) is None | |
Xet Storage Details
- Size:
- 29.3 kB
- Xet hash:
- cfbe3160b2934e8a99435ce1e211149b95fa13185305d13e0678c0cceb01099b
·
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.