Buckets:
AnonymousSpottedToad/candidate_bucket / codebase /python /allen0099_FastAPI-CacheX /tests /session /test_middleware.py
| """Tests for session middleware and token extraction.""" | |
| from datetime import datetime | |
| from datetime import timedelta | |
| from datetime import timezone | |
| from unittest.mock import AsyncMock | |
| from unittest.mock import MagicMock | |
| import pytest | |
| from fastapi import FastAPI | |
| from fastapi import Request | |
| from fastapi import Response | |
| from fastapi.testclient import TestClient | |
| from fastapi_cachex.backends.memory import MemoryBackend | |
| from fastapi_cachex.session.config import SessionConfig | |
| from fastapi_cachex.session.manager import SessionManager | |
| from fastapi_cachex.session.middleware import SessionMiddleware | |
| from fastapi_cachex.session.models import SessionUser | |
| def config() -> SessionConfig: | |
| """Create session config for testing.""" | |
| return SessionConfig(secret_key="a" * 32) | |
| def manager(config: SessionConfig) -> SessionManager: | |
| """Create session manager for testing.""" | |
| backend = MemoryBackend() | |
| return SessionManager(backend, config) | |
| def test_middleware_initialization( | |
| manager: SessionManager, config: SessionConfig | |
| ) -> None: | |
| """Test middleware initialization.""" | |
| # Create a simple ASGI app | |
| async def app(scope, receive, send): | |
| pass | |
| middleware = SessionMiddleware(app, manager, config) | |
| assert middleware.session_manager is manager | |
| assert middleware.config is config | |
| def test_middleware_initialization_uses_manager_config( | |
| manager: SessionManager, | |
| ) -> None: | |
| """Ensure middleware defaults to manager config when none provided.""" | |
| async def app(scope, receive, send): | |
| pass | |
| middleware = SessionMiddleware(app, manager) | |
| assert middleware.config is manager.config | |
| def test_extract_token_from_header( | |
| manager: SessionManager, config: SessionConfig | |
| ) -> None: | |
| """Test token extraction from header.""" | |
| async def app(scope, receive, send): | |
| pass | |
| middleware = SessionMiddleware(app, manager, config) | |
| # Create a mock request with header | |
| request = MagicMock(spec=Request) | |
| request.headers = {config.header_name: "test-token"} | |
| token = middleware._extract_token(request) | |
| assert token == "test-token" | |
| def test_extract_token_from_bearer( | |
| manager: SessionManager, config: SessionConfig | |
| ) -> None: | |
| """Test token extraction from Bearer token.""" | |
| async def app(scope, receive, send): | |
| pass | |
| config.use_bearer_token = True | |
| middleware = SessionMiddleware(app, manager, config) | |
| # Create a mock request with Bearer token | |
| request = MagicMock(spec=Request) | |
| request.headers = {"authorization": "Bearer test-token"} | |
| token = middleware._extract_token(request) | |
| assert token == "test-token" | |
| def test_extract_token_none(manager: SessionManager, config: SessionConfig) -> None: | |
| """Test token extraction when no token is present.""" | |
| async def app(scope, receive, send): | |
| pass | |
| middleware = SessionMiddleware(app, manager, config) | |
| # Create a mock request with no token | |
| request = MagicMock(spec=Request) | |
| request.headers = {} | |
| token = middleware._extract_token(request) | |
| assert token is None | |
| def test_get_client_ip_from_x_forwarded_for( | |
| manager: SessionManager, | |
| config: SessionConfig, | |
| ) -> None: | |
| """Test getting client IP from X-Forwarded-For header.""" | |
| async def app(scope, receive, send): | |
| pass | |
| middleware = SessionMiddleware(app, manager, config) | |
| # Create a mock request | |
| request = MagicMock(spec=Request) | |
| request.headers = {"x-forwarded-for": "192.168.1.1, 10.0.0.1"} | |
| request.client = None | |
| ip = middleware._get_client_ip(request) | |
| assert ip == "192.168.1.1" | |
| def test_get_client_ip_from_real_ip( | |
| manager: SessionManager, | |
| config: SessionConfig, | |
| ) -> None: | |
| """Test getting client IP from X-Real-IP header.""" | |
| async def app(scope, receive, send): | |
| pass | |
| middleware = SessionMiddleware(app, manager, config) | |
| # Create a mock request | |
| request = MagicMock(spec=Request) | |
| request.headers = {"x-real-ip": "192.168.1.1"} | |
| request.client = None | |
| ip = middleware._get_client_ip(request) | |
| assert ip == "192.168.1.1" | |
| def test_get_client_ip_from_client( | |
| manager: SessionManager, | |
| config: SessionConfig, | |
| ) -> None: | |
| """Test getting client IP from client.""" | |
| async def app(scope, receive, send): | |
| pass | |
| middleware = SessionMiddleware(app, manager, config) | |
| # Create a mock request | |
| request = MagicMock(spec=Request) | |
| request.headers = {} | |
| client = MagicMock() | |
| client.host = "192.168.1.1" | |
| request.client = client | |
| ip = middleware._get_client_ip(request) | |
| assert ip == "192.168.1.1" | |
| async def test_dispatch_with_expired_session( | |
| manager: SessionManager, config: SessionConfig | |
| ) -> None: | |
| """Test dispatch with expired session token.""" | |
| app = FastAPI() | |
| SessionMiddleware(app, manager, config) | |
| async def test_route(): | |
| return {"message": "ok"} | |
| client = TestClient(app) | |
| # Create a session with past expiry | |
| user = SessionUser(user_id="test-user") | |
| session, token = await manager.create_session(user=user) | |
| session.expires_at = datetime.now(timezone.utc) - timedelta(seconds=10) | |
| await manager._save_session(session) | |
| # Make request with expired session | |
| response = client.get("/test", headers={config.header_name: token}) | |
| # Should succeed but without session loaded | |
| assert response.status_code == 200 | |
| async def test_dispatch_with_invalid_session( | |
| manager: SessionManager, config: SessionConfig | |
| ) -> None: | |
| """Test dispatch with invalid session token.""" | |
| app = FastAPI() | |
| SessionMiddleware(app, manager, config) | |
| async def test_route(): | |
| return {"message": "ok"} | |
| client = TestClient(app) | |
| # Make request with invalid session header | |
| response = client.get("/test", headers={config.header_name: "invalid-token"}) | |
| assert response.status_code == 200 | |
| async def test_dispatch_with_no_session( | |
| manager: SessionManager, config: SessionConfig | |
| ) -> None: | |
| """Test dispatch without session token.""" | |
| app = FastAPI() | |
| SessionMiddleware(app, manager, config) | |
| async def test_route(): | |
| return {"message": "ok"} | |
| client = TestClient(app) | |
| # Make request without session | |
| response = client.get("/test") | |
| assert response.status_code == 200 | |
| async def test_dispatch_sets_session_in_request_state( | |
| manager: SessionManager, config: SessionConfig | |
| ) -> None: | |
| """Test dispatch sets session in request state.""" | |
| app = FastAPI() | |
| SessionMiddleware(app, manager, config) | |
| captured_session = {} | |
| async def check_session_route(): | |
| request = Request({"type": "http", "method": "GET", "headers": []}) | |
| if hasattr(request.state, "session"): | |
| captured_session["session"] = request.state.session | |
| return {"has_session": hasattr(request.state, "session")} | |
| client = TestClient(app) | |
| # Create a session first | |
| user = SessionUser(user_id="test-user") | |
| _session, token = await manager.create_session(user=user) | |
| # Make request with session | |
| response = client.get("/check-session", headers={config.header_name: token}) | |
| assert response.status_code == 200 | |
| def test_extract_token_from_bearer_with_malformed_header( | |
| manager: SessionManager, config: SessionConfig | |
| ) -> None: | |
| """Test token extraction with malformed Bearer header.""" | |
| async def app(scope, receive, send): | |
| pass | |
| config.use_bearer_token = True | |
| middleware = SessionMiddleware(app, manager, config) | |
| # Create a mock request with malformed Bearer token | |
| request = MagicMock(spec=Request) | |
| request.headers = {"authorization": "Bearer"} # Missing token | |
| token = middleware._extract_token(request) | |
| assert token is None | |
| def test_get_client_ip_none( | |
| manager: SessionManager, | |
| config: SessionConfig, | |
| ) -> None: | |
| """Test getting client IP when none available.""" | |
| async def app(scope, receive, send): | |
| pass | |
| middleware = SessionMiddleware(app, manager, config) | |
| # Create a mock request with no IP info | |
| request = MagicMock(spec=Request) | |
| request.headers = {} | |
| request.client = None | |
| ip = middleware._get_client_ip(request) | |
| assert ip is None | |
| async def test_dispatch_with_session_and_ip_binding( | |
| config: SessionConfig, | |
| ) -> None: | |
| """Test dispatch validates IP binding.""" | |
| backend = MemoryBackend() | |
| manager = SessionManager(backend, config) | |
| config.ip_binding = True | |
| app = FastAPI() | |
| SessionMiddleware(app, manager, config) | |
| async def test_route(): | |
| return {"message": "ok"} | |
| client = TestClient(app) | |
| # Create session with IP binding | |
| user = SessionUser(user_id="test-user") | |
| _session, token = await manager.create_session( | |
| user=user, | |
| ip_address="127.0.0.1", | |
| ) | |
| # Request with same IP should work | |
| response = client.get("/test", headers={config.header_name: token}) | |
| assert response.status_code == 200 | |
| async def test_dispatch_with_user_agent_binding( | |
| config: SessionConfig, | |
| ) -> None: | |
| """Test dispatch validates User-Agent binding.""" | |
| backend = MemoryBackend() | |
| manager = SessionManager(backend, config) | |
| config.user_agent_binding = True | |
| app = FastAPI() | |
| SessionMiddleware(app, manager, config) | |
| async def test_route(): | |
| return {"message": "ok"} | |
| client = TestClient(app) | |
| # Create session with User-Agent binding | |
| user = SessionUser(user_id="test-user") | |
| _session, token = await manager.create_session( | |
| user=user, | |
| user_agent="TestClient/1.0", | |
| ) | |
| # Request with session | |
| response = client.get("/test", headers={config.header_name: token}) | |
| assert response.status_code == 200 | |
| async def test_dispatch_direct_call( | |
| manager: SessionManager, | |
| config: SessionConfig, | |
| ) -> None: | |
| """Test dispatch method directly to improve coverage.""" | |
| # Create a mock app | |
| mock_app = AsyncMock() | |
| middleware = SessionMiddleware(mock_app, manager, config) | |
| # Create a session | |
| user = SessionUser(user_id="test-user") | |
| _session, token = await manager.create_session(user=user) | |
| # Create a mock request | |
| request = MagicMock(spec=Request) | |
| request.headers = {config.header_name: token, "user-agent": "test-agent"} | |
| request.state = MagicMock() | |
| request.client = MagicMock() | |
| request.client.host = "127.0.0.1" | |
| # Create mock response | |
| mock_response = MagicMock(spec=Response) | |
| # Set up call_next to return response | |
| call_next = AsyncMock(return_value=mock_response) | |
| # Call dispatch directly | |
| result = await middleware.dispatch(request, call_next) | |
| # Verify result | |
| assert result == mock_response | |
| # Verify session was set in request state | |
| assert getattr(request.state, "__fastapi_cachex_session", None) is not None | |
| async def test_dispatch_with_session_error( | |
| manager: SessionManager, | |
| config: SessionConfig, | |
| ) -> None: | |
| """Test dispatch handles SessionError gracefully.""" | |
| # Create mock app | |
| mock_app = AsyncMock() | |
| middleware = SessionMiddleware(mock_app, manager, config) | |
| # Create mock request with invalid token | |
| request = MagicMock(spec=Request) | |
| request.headers = {config.header_name: "invalid-token-xyz"} | |
| request.state = MagicMock() | |
| request.client = MagicMock() | |
| request.client.host = "127.0.0.1" | |
| # Create mock response | |
| mock_response = MagicMock(spec=Response) | |
| # Set up call_next to return response | |
| call_next = AsyncMock(return_value=mock_response) | |
| # Call dispatch - should handle SessionError | |
| result = await middleware.dispatch(request, call_next) | |
| # Verify result | |
| assert result == mock_response | |
| # Session should be None in request state due to error | |
| assert getattr(request.state, "__fastapi_cachex_session", None) is None | |
| async def test_dispatch_sets_renewed_token_header_on_sliding_expiration() -> None: | |
| """Middleware must write the refreshed token to the response header and extend expires_at.""" | |
| from datetime import datetime, timedelta, timezone | |
| from fastapi.responses import JSONResponse | |
| backend = MemoryBackend() | |
| slide_config = SessionConfig( | |
| secret_key="a" * 32, | |
| session_ttl=3600, | |
| sliding_expiration=True, | |
| sliding_threshold=0.5, | |
| ) | |
| mgr = SessionManager(backend, slide_config) | |
| app = FastAPI() | |
| app.add_middleware(SessionMiddleware, session_manager=mgr, config=slide_config) | |
| async def ping() -> JSONResponse: | |
| return JSONResponse({"ok": True}) | |
| user = SessionUser(user_id="slide-user") | |
| created, original_token = await mgr.create_session(user=user) | |
| # Shorten expiry so time_remaining < sliding threshold (< 50% of 3600 s) | |
| shortened_expiry = datetime.now(timezone.utc) + timedelta(seconds=1000) | |
| created.expires_at = shortened_expiry | |
| await mgr._save_session(created) | |
| client = TestClient(app) | |
| response = client.get("/ping", headers={slide_config.header_name: original_token}) | |
| assert response.status_code == 200 | |
| renewed = response.headers.get(slide_config.header_name) | |
| # Middleware must write a new token to the response header | |
| assert renewed is not None, "Middleware must set renewed token header on sliding renewal" | |
| # The renewed session must have an extended expires_at (> the shortened value we set) | |
| renewed_session, _ = await mgr.get_session(renewed) | |
| assert renewed_session.expires_at is not None | |
| assert renewed_session.expires_at > shortened_expiry | |
Xet Storage Details
- Size:
- 13.9 kB
- Xet hash:
- ce140747291a400f9a7b9ae1fa1836d41cbf4aa6c90842132237bc3850122371
·
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.