Buckets:

download
raw
22.6 kB
"""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
@pytest.fixture
def backend() -> MemoryBackend:
"""Create a memory backend for testing."""
return MemoryBackend()
@pytest.fixture
def config() -> SessionConfig:
"""Create session config for testing."""
return SessionConfig(secret_key="a" * 32, session_ttl=3600)
@pytest.fixture
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
@pytest.mark.asyncio
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
@pytest.mark.asyncio
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
@pytest.mark.asyncio
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]
@pytest.mark.asyncio
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")
@pytest.mark.asyncio
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))
@pytest.mark.asyncio
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)
@pytest.mark.asyncio
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)
@pytest.mark.asyncio
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
@pytest.mark.asyncio
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")
@pytest.mark.asyncio
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")
@pytest.mark.asyncio
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
@pytest.mark.asyncio
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)
@pytest.mark.asyncio
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
@pytest.mark.asyncio
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)
@pytest.mark.asyncio
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"
@pytest.mark.asyncio
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
@pytest.mark.asyncio
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))
@pytest.mark.asyncio
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
@pytest.mark.asyncio
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]
@pytest.mark.asyncio
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
@pytest.mark.asyncio
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
# ---------------------------------------------------------------------------
@pytest.mark.asyncio
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)
@pytest.mark.asyncio
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
@pytest.mark.asyncio
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
@pytest.mark.asyncio
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
@pytest.mark.asyncio
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
@pytest.mark.asyncio
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
@pytest.mark.asyncio
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)
@pytest.mark.asyncio
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)
@pytest.mark.asyncio
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.