Buckets:
AnonymousSpottedToad/candidate_bucket / codebase /python /allen0099_FastAPI-CacheX /tests /session /test_manager.py
| """Tests for session manager.""" | |
| from datetime import datetime | |
| from datetime import timedelta | |
| from datetime import timezone | |
| import pytest | |
| from pydantic import SecretStr | |
| from fastapi_cachex.backends.memory import MemoryBackend | |
| from fastapi_cachex.session.config import SessionConfig | |
| from fastapi_cachex.session.exceptions import SessionExpiredError | |
| from fastapi_cachex.session.exceptions import SessionInvalidError | |
| from fastapi_cachex.session.exceptions import SessionNotFoundError | |
| from fastapi_cachex.session.exceptions import SessionSecurityError | |
| from fastapi_cachex.session.exceptions import SessionTokenError | |
| from fastapi_cachex.session.manager import SessionManager | |
| from fastapi_cachex.session.models import SessionToken | |
| from fastapi_cachex.session.models import SessionUser | |
| from fastapi_cachex.types import CacheEntry | |
| from fastapi_cachex.types import CacheItem | |
| def backend() -> MemoryBackend: | |
| """Create a memory backend for testing.""" | |
| return MemoryBackend() | |
| def config() -> SessionConfig: | |
| """Create session config for testing.""" | |
| return SessionConfig(secret_key="a" * 32, session_ttl=3600) | |
| def manager(backend: MemoryBackend, config: SessionConfig) -> SessionManager: | |
| """Create session manager for testing.""" | |
| return SessionManager(backend, config) | |
| class DummySerializer: | |
| """Stub serializer used to verify DI override coverage.""" | |
| def __init__(self) -> None: | |
| self.last_token: SessionToken | None = None | |
| self.to_string_calls = 0 | |
| self.from_string_calls = 0 | |
| def to_string(self, token: SessionToken) -> str: | |
| self.last_token = token | |
| self.to_string_calls += 1 | |
| return f"dummy.{token.session_id}" | |
| def from_string(self, token_str: str) -> SessionToken: | |
| self.from_string_calls += 1 | |
| _prefix, session_id = token_str.split(".", 1) | |
| return SessionToken( | |
| session_id=session_id, | |
| signature="", | |
| issued_at=datetime.now(timezone.utc), | |
| ) | |
| def test_session_manager_accepts_secretstr(backend: MemoryBackend) -> None: | |
| """Ensure SessionManager works with SecretStr secrets.""" | |
| config = SessionConfig(secret_key=SecretStr("a" * 32)) | |
| manager = SessionManager(backend, config) | |
| signature = manager.security.sign_session_id("test-session-id") | |
| assert len(signature) == 64 | |
| async def test_create_session(manager: SessionManager) -> None: | |
| """Test creating a session.""" | |
| user = SessionUser(user_id="123", username="testuser") | |
| session, token = await manager.create_session(user=user) | |
| assert session.session_id is not None | |
| assert session.user is not None | |
| assert session.user.user_id == "123" | |
| assert token is not None | |
| async def test_create_anonymous_session(manager: SessionManager) -> None: | |
| """Test creating an anonymous session.""" | |
| session, token = await manager.create_anonymous_session() | |
| assert session.session_id is not None | |
| assert session.user is None | |
| retrieved, _ = await manager.get_session(token) | |
| assert retrieved.user is None | |
| async def test_get_session(manager: SessionManager) -> None: | |
| """Test retrieving a session.""" | |
| user = SessionUser(user_id="123", username="testuser") | |
| created_session, token = await manager.create_session(user=user) | |
| retrieved_session, _ = await manager.get_session(token) | |
| assert retrieved_session.session_id == created_session.session_id | |
| assert retrieved_session.user.user_id == "123" # type: ignore[union-attr] | |
| async def test_get_invalid_token(manager: SessionManager) -> None: | |
| """Test getting session with invalid token.""" | |
| with pytest.raises(SessionTokenError): | |
| await manager.get_session("invalid-token") | |
| async def test_get_nonexistent_session(manager: SessionManager) -> None: | |
| """Test getting nonexistent session.""" | |
| # Create a valid token for a session that doesn't exist | |
| from fastapi_cachex.session.models import SessionToken | |
| from fastapi_cachex.session.token_serializers import SimpleTokenSerializer | |
| token = SessionToken( | |
| session_id="nonexistent", | |
| signature=manager.security.sign_session_id("nonexistent"), | |
| ) | |
| serializer = SimpleTokenSerializer() | |
| with pytest.raises(SessionNotFoundError): | |
| await manager.get_session(serializer.to_string(token)) | |
| async def test_session_expiry(manager: SessionManager) -> None: | |
| """Test session expiry.""" | |
| # Create session with short TTL | |
| manager.config.session_ttl = 1 | |
| user = SessionUser(user_id="123", username="testuser") | |
| session, token = await manager.create_session(user=user) | |
| # Manually expire the session | |
| session.expires_at = datetime.now(timezone.utc) - timedelta(seconds=1) | |
| await manager.update_session(session) | |
| with pytest.raises(SessionExpiredError): | |
| await manager.get_session(token) | |
| async def test_delete_session(manager: SessionManager) -> None: | |
| """Test deleting a session.""" | |
| user = SessionUser(user_id="123", username="testuser") | |
| session, token = await manager.create_session(user=user) | |
| await manager.delete_session(session.session_id) | |
| with pytest.raises(SessionNotFoundError): | |
| await manager.get_session(token) | |
| async def test_regenerate_session_id(manager: SessionManager) -> None: | |
| """Test regenerating session ID.""" | |
| user = SessionUser(user_id="123", username="testuser") | |
| session, old_token = await manager.create_session(user=user) | |
| old_id = session.session_id | |
| updated_session, new_token = await manager.regenerate_session_id(session) | |
| assert updated_session.session_id != old_id | |
| assert new_token != old_token | |
| # Old token should not work | |
| with pytest.raises(SessionNotFoundError): | |
| await manager.get_session(old_token) | |
| # New token should work | |
| retrieved, _ = await manager.get_session(new_token) | |
| assert retrieved.session_id == updated_session.session_id | |
| async def test_ip_binding(backend: MemoryBackend) -> None: | |
| """Test IP address binding.""" | |
| config = SessionConfig(secret_key="a" * 32, ip_binding=True) | |
| manager = SessionManager(backend, config) | |
| user = SessionUser(user_id="123", username="testuser") | |
| session, token = await manager.create_session( | |
| user=user, | |
| ip_address="192.168.1.1", | |
| ) | |
| # Same IP should work | |
| retrieved, _ = await manager.get_session(token, ip_address="192.168.1.1") | |
| assert retrieved.session_id == session.session_id | |
| # Different IP should fail | |
| with pytest.raises(SessionSecurityError, match="IP address mismatch"): | |
| await manager.get_session(token, ip_address="192.168.1.2") | |
| async def test_user_agent_binding(backend: MemoryBackend) -> None: | |
| """Test User-Agent binding.""" | |
| config = SessionConfig(secret_key="a" * 32, user_agent_binding=True) | |
| manager = SessionManager(backend, config) | |
| user = SessionUser(user_id="123", username="testuser") | |
| session, token = await manager.create_session( | |
| user=user, | |
| user_agent="Mozilla/5.0", | |
| ) | |
| # Same UA should work | |
| retrieved, _ = await manager.get_session(token, user_agent="Mozilla/5.0") | |
| assert retrieved.session_id == session.session_id | |
| # Different UA should fail | |
| with pytest.raises(SessionSecurityError, match="User-Agent mismatch"): | |
| await manager.get_session(token, user_agent="Chrome/91.0") | |
| async def test_sliding_expiration(backend: MemoryBackend) -> None: | |
| """Test sliding expiration.""" | |
| import asyncio | |
| config = SessionConfig( | |
| secret_key="a" * 32, | |
| session_ttl=3600, | |
| sliding_expiration=True, | |
| sliding_threshold=0.5, | |
| ) | |
| manager = SessionManager(backend, config) | |
| user = SessionUser(user_id="123", username="testuser") | |
| session, token = await manager.create_session(user=user) | |
| original_expiry = session.expires_at | |
| # Sleep briefly to ensure time passes | |
| await asyncio.sleep(0.01) | |
| # Set expiry to be past the threshold (only 1000 seconds left vs 3600 TTL) | |
| session.expires_at = datetime.now(timezone.utc) + timedelta(seconds=1000) | |
| await manager.update_session(session) | |
| # Access session - should trigger renewal since < 50% of TTL remains | |
| retrieved, new_token = await manager.get_session(token) | |
| # Should be renewed to be further in the future than original | |
| assert retrieved.expires_at > original_expiry # type: ignore[operator] | |
| # A fresh token must be returned so the client's JWT exp stays in sync | |
| assert new_token is not None | |
| async def test_invalidate_session(manager: SessionManager) -> None: | |
| """Test invalidating a session.""" | |
| user = SessionUser(user_id="123", username="testuser") | |
| session, token = await manager.create_session(user=user) | |
| await manager.invalidate_session(session) | |
| # Token should no longer work | |
| with pytest.raises(SessionInvalidError): | |
| await manager.get_session(token) | |
| async def test_clear_expired_sessions(backend: MemoryBackend) -> None: | |
| """Test clearing expired sessions.""" | |
| config = SessionConfig(secret_key="a" * 32, session_ttl=1) | |
| manager = SessionManager(backend, config) | |
| # Create a few sessions | |
| user1 = SessionUser(user_id="1", username="user1") | |
| user2 = SessionUser(user_id="2", username="user2") | |
| session1, _token1 = await manager.create_session(user=user1) | |
| session2, _token2 = await manager.create_session(user=user2) | |
| # Manually expire one session | |
| session1.expires_at = datetime.now(timezone.utc) - timedelta(seconds=1) | |
| await manager.update_session(session1) | |
| # Keep the other session valid | |
| session2.expires_at = datetime.now(timezone.utc) + timedelta(seconds=3600) | |
| await manager.update_session(session2) | |
| # Clear expired sessions | |
| count = await manager.clear_expired_sessions() | |
| assert count == 1 # Only one session should be cleared | |
| async def test_save_session_with_expired_session( | |
| backend: MemoryBackend, | |
| ) -> None: | |
| """Test saving an expired session and its TTL calculation.""" | |
| config = SessionConfig(secret_key="a" * 32, session_ttl=3600) | |
| manager = SessionManager(backend, config) | |
| user = SessionUser(user_id="123", username="testuser") | |
| session, token = await manager.create_session(user=user) | |
| # Manually expire the session | |
| session.expires_at = datetime.now(timezone.utc) - timedelta(seconds=10) | |
| # Save the expired session | |
| await manager._save_session(session) | |
| # Try to retrieve - should fail with SessionExpiredError | |
| with pytest.raises(SessionExpiredError): | |
| await manager.get_session(token) | |
| async def test_update_session(manager: SessionManager) -> None: | |
| """Test updating a session.""" | |
| user = SessionUser(user_id="123", username="testuser") | |
| session, token = await manager.create_session(user=user) | |
| # Update session data | |
| session.data["updated_field"] = "updated_value" | |
| await manager.update_session(session) | |
| # Retrieve and verify | |
| retrieved, _ = await manager.get_session(token) | |
| assert retrieved.data.get("updated_field") == "updated_value" | |
| async def test_delete_user_sessions(manager: SessionManager) -> None: | |
| """Test deleting all sessions for a specific user.""" | |
| user1 = SessionUser(user_id="user1", username="testuser1") | |
| user2 = SessionUser(user_id="user2", username="testuser2") | |
| # Create multiple sessions for user1 | |
| _session1, _token1 = await manager.create_session(user=user1) | |
| _session2, _token2 = await manager.create_session(user=user1) | |
| # Create a session for user2 | |
| session3, token3 = await manager.create_session(user=user2) | |
| # Delete all sessions for user1 | |
| count = await manager.delete_user_sessions("user1") | |
| assert count == 2 | |
| # user2's session should still be accessible | |
| retrieved, _ = await manager.get_session(token3) | |
| assert retrieved.session_id == session3.session_id | |
| async def test_invalid_session_signature( | |
| backend: MemoryBackend, | |
| ) -> None: | |
| """Test that invalid session signature raises SessionSecurityError.""" | |
| config = SessionConfig(secret_key="a" * 32) | |
| manager = SessionManager(backend, config) | |
| user = SessionUser(user_id="123", username="testuser") | |
| _session, token = await manager.create_session(user=user) | |
| # Tamper with the token signature | |
| from fastapi_cachex.session.models import SessionToken | |
| from fastapi_cachex.session.token_serializers import SimpleTokenSerializer | |
| serializer = SimpleTokenSerializer() | |
| original_token = serializer.from_string(token) | |
| tampered_token = SessionToken( | |
| session_id=original_token.session_id, | |
| signature="invalid_signature_' " + original_token.signature, | |
| issued_at=original_token.issued_at, | |
| ) | |
| # Try to get session with tampered token | |
| with pytest.raises(SessionSecurityError, match="Invalid session signature"): | |
| await manager.get_session(serializer.to_string(tampered_token)) | |
| async def test_session_manager_respects_custom_serializer( | |
| backend: MemoryBackend, | |
| ) -> None: | |
| """Ensure DI serializer override is used for token operations.""" | |
| config = SessionConfig(secret_key="a" * 32, token_format="jwt") | |
| serializer = DummySerializer() | |
| manager = SessionManager(backend, config, token_serializer=serializer) | |
| session, token = await manager.create_anonymous_session() | |
| assert token.startswith("dummy.") | |
| retrieved, _ = await manager.get_session(token) | |
| assert retrieved.session_id == session.session_id | |
| assert serializer.to_string_calls == 1 | |
| assert serializer.from_string_calls == 1 | |
| assert serializer.last_token is not None | |
| async def test_jwt_token_format_uses_serializer( | |
| monkeypatch: pytest.MonkeyPatch, backend: MemoryBackend | |
| ) -> None: | |
| """Cover JWT token path without requiring external jwt dependency.""" | |
| class StubJWTSerializer: | |
| def __init__(self, config: SessionConfig) -> None: | |
| self.config = config | |
| self.to_string_tokens: list[SessionToken] = [] | |
| self.from_string_payloads: list[str] = [] | |
| def to_string(self, token: SessionToken) -> str: | |
| self.to_string_tokens.append(token) | |
| return f"jwt.{token.session_id}" | |
| def from_string(self, token_str: str) -> SessionToken: | |
| self.from_string_payloads.append(token_str) | |
| _prefix, session_id = token_str.split(".", 1) | |
| return SessionToken( | |
| session_id=session_id, | |
| signature="", | |
| issued_at=datetime.now(timezone.utc), | |
| ) | |
| monkeypatch.setattr( | |
| "fastapi_cachex.session.manager.JWTTokenSerializer", StubJWTSerializer | |
| ) | |
| config = SessionConfig(secret_key="a" * 32, token_format="jwt") | |
| manager = SessionManager(backend, config) | |
| assert isinstance(manager._serializer, StubJWTSerializer) | |
| user = SessionUser(user_id="jwt-user", username=None) | |
| session, token = await manager.create_session(user=user) | |
| stub = manager._serializer | |
| assert stub.to_string_tokens[0].signature == "" | |
| retrieved, _ = await manager.get_session(token) | |
| assert retrieved.session_id == session.session_id | |
| assert stub.from_string_payloads == [token] | |
| async def test_load_session_by_key_invalid_payload_returns_none( | |
| manager: SessionManager, backend: MemoryBackend | |
| ) -> None: | |
| """Ensure invalid cached payloads are ignored gracefully.""" | |
| key = manager._get_backend_key("invalid-id") | |
| backend.cache[key] = CacheItem( | |
| value=CacheEntry(fingerprint="bad", content=b"{not-json}"), | |
| expiry=None, | |
| ) | |
| session = await manager._load_session_by_key(key) | |
| assert session is None | |
| async def test_save_session_without_ttl_uses_none_expiry( | |
| backend: MemoryBackend, | |
| ) -> None: | |
| """Sessions without TTL should persist with no expiry set.""" | |
| config = SessionConfig(secret_key="a" * 32, session_ttl=0) | |
| manager = SessionManager(backend, config) | |
| session, token = await manager.create_anonymous_session() | |
| cache_data = await backend.get_cache_data() | |
| key = manager._get_backend_key(session.session_id) | |
| assert session.expires_at is None | |
| assert key in cache_data | |
| _value, expiry = cache_data[key] | |
| assert expiry is None | |
| retrieved, _ = await manager.get_session(token) | |
| assert retrieved.session_id == session.session_id | |
| # --------------------------------------------------------------------------- | |
| # New tests for fixes applied in this session | |
| # --------------------------------------------------------------------------- | |
| async def test_absolute_timeout_raises_session_expired_error( | |
| backend: MemoryBackend, | |
| ) -> None: | |
| """absolute_timeout must expire the session even if sliding TTL would renew it.""" | |
| # absolute_timeout=1 means the session must not live beyond 1 second from creation | |
| config = SessionConfig(secret_key="a" * 32, session_ttl=3600, absolute_timeout=1) | |
| manager = SessionManager(backend, config) | |
| user = SessionUser(user_id="abs-user", username="testuser") | |
| _session, token = await manager.create_session(user=user) | |
| # Wait for the absolute timeout to pass | |
| import asyncio | |
| await asyncio.sleep(1.1) | |
| with pytest.raises(SessionExpiredError): | |
| await manager.get_session(token) | |
| async def test_absolute_timeout_zero_disables_enforcement( | |
| backend: MemoryBackend, | |
| ) -> None: | |
| """absolute_timeout=None (default/disabled) must not prematurely expire sessions.""" | |
| config = SessionConfig(secret_key="a" * 32, session_ttl=3600, absolute_timeout=None) | |
| manager = SessionManager(backend, config) | |
| user = SessionUser(user_id="no-abs", username="testuser") | |
| _session, token = await manager.create_session(user=user) | |
| # Should still be valid | |
| retrieved, _ = await manager.get_session(token) | |
| assert retrieved is not None | |
| async def test_absolute_timeout_not_triggered_before_expiry( | |
| backend: MemoryBackend, | |
| ) -> None: | |
| """Session should remain valid before the absolute_timeout is reached.""" | |
| config = SessionConfig(secret_key="a" * 32, session_ttl=3600, absolute_timeout=60) | |
| manager = SessionManager(backend, config) | |
| user = SessionUser(user_id="fresh-user", username="testuser") | |
| _session, token = await manager.create_session(user=user) | |
| # Should be valid immediately (well within 60 s absolute timeout) | |
| retrieved, _ = await manager.get_session(token) | |
| assert retrieved is not None | |
| async def test_delete_user_sessions_no_sessions(backend: MemoryBackend) -> None: | |
| """delete_user_sessions returns 0 when the user has no sessions.""" | |
| manager = SessionManager(backend, SessionConfig(secret_key="a" * 32)) | |
| count = await manager.delete_user_sessions("nonexistent-user") | |
| assert count == 0 | |
| async def test_clear_expired_sessions_none_expired(backend: MemoryBackend) -> None: | |
| """clear_expired_sessions returns 0 when no sessions are expired.""" | |
| config = SessionConfig(secret_key="a" * 32, session_ttl=3600) | |
| manager = SessionManager(backend, config) | |
| user = SessionUser(user_id="active-user", username="active") | |
| await manager.create_session(user=user) | |
| count = await manager.clear_expired_sessions() | |
| assert count == 0 | |
| async def test_load_session_by_key_invalid_json(backend: MemoryBackend) -> None: | |
| """_load_session_by_key returns None for corrupt (non-JSON) session data.""" | |
| config = SessionConfig(secret_key="a" * 32) | |
| manager = SessionManager(backend, config) | |
| bad_key = "session:corrupt-id" | |
| await backend.set(bad_key, CacheEntry(fingerprint="x", content=b"{not valid json}")) | |
| result = await manager._load_session_by_key(bad_key) | |
| assert result is None | |
| async def test_ip_binding_with_none_ip_emits_warning( | |
| backend: MemoryBackend, caplog: pytest.LogCaptureFixture | |
| ) -> None: | |
| """ip_binding=True with ip_address=None must log a warning and still create session.""" | |
| import logging | |
| config = SessionConfig(secret_key="a" * 32, ip_binding=True) | |
| manager = SessionManager(backend, config) | |
| user = SessionUser(user_id="ip-test", username="testuser") | |
| with caplog.at_level(logging.WARNING, logger="fastapi_cachex.session.manager"): | |
| session, token = await manager.create_session(user=user, ip_address=None) | |
| assert session is not None | |
| assert token | |
| assert session.ip_address is None | |
| assert any("ip_binding" in msg for msg in caplog.messages) | |
| async def test_user_agent_binding_with_none_ua_emits_warning( | |
| backend: MemoryBackend, caplog: pytest.LogCaptureFixture | |
| ) -> None: | |
| """user_agent_binding=True with user_agent=None must log a warning and still create session.""" | |
| import logging | |
| config = SessionConfig(secret_key="a" * 32, user_agent_binding=True) | |
| manager = SessionManager(backend, config) | |
| user = SessionUser(user_id="ua-test", username="testuser") | |
| with caplog.at_level(logging.WARNING, logger="fastapi_cachex.session.manager"): | |
| session, token = await manager.create_session(user=user, user_agent=None) | |
| assert session is not None | |
| assert token | |
| assert session.user_agent is None | |
| assert any("user_agent_binding" in msg for msg in caplog.messages) | |
| async def test_session_scans_ignore_keys_outside_the_session_prefix( | |
| backend: MemoryBackend, | |
| ) -> None: | |
| """Route-cache or CacheManager keys sharing the backend are never read or deleted.""" | |
| config = SessionConfig(secret_key="a" * 32, session_ttl=1) | |
| manager = SessionManager(backend, config) | |
| await backend.set("cache:unrelated", CacheEntry(fingerprint="x", content=b"1")) | |
| session, _ = await manager.create_session( | |
| user=SessionUser(user_id="1", username="user1") | |
| ) | |
| session.expires_at = datetime.now(timezone.utc) - timedelta(seconds=1) | |
| await manager.update_session(session) | |
| assert await manager.clear_expired_sessions() == 1 | |
| assert await manager.delete_user_sessions("1") == 0 | |
| assert await backend.get("cache:unrelated") is not None | |
Xet Storage Details
- Size:
- 22.6 kB
- Xet hash:
- 30a4e4545f4c59c7608dbfa61088c6f3386c35a697764575b02e83d8b39966cc
·
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.