Merge pull request #6 from NyxiumYuuki/claude/add-mcp-authentication-01V5tbppGEtXc3tvjRGoTcfh

Fix CI/CD issues and add comprehensive tests for multi-user features

docker-compose.yml

@@ -1,12 +1,12 @@
 services:
   geoguessr-mcp:
     # Option 1: Build locally (for development)
-    # build:
+    build:
-    #   context: .
+      context: .
-    #   dockerfile: Dockerfile
+      dockerfile: Dockerfile
 
     # Option 2: Use pre-built image from Docker Hub (recommended)
-    image: nyxiumyuuki/geoguessr-mcp:latest
+    # image: nyxiumyuuki/geoguessr-mcp:latest
 
     container_name: geoguessr-mcp-server
     restart: unless-stopped

src/geoguessr_mcp/api/dynamic_response.py

@@ -25,11 +25,11 @@ class DynamicResponse:
     """
 
     def __init__(
-            self,
+        self,
-            data: Any,
+        data: Any,
-            endpoint: str,
+        endpoint: str,
-            status_code: int,
+        status_code: int,
-            response_time_ms: float,
+        response_time_ms: float,
     ):
         self.data = data
         self.endpoint = endpoint

src/geoguessr_mcp/auth/multi_user_session.py

@@ -64,9 +64,7 @@ class MultiUserSessionManager:
 
         return context
 
-    async def login_user(
+    async def login_user(self, api_key: str, email: str, password: str) -> tuple[str, UserSession]:
-        self, api_key: str, email: str, password: str
-    ) -> tuple[str, UserSession]:
         """
         Login a specific user (API key) to their GeoGuessr account.
 
@@ -90,9 +88,7 @@ class MultiUserSessionManager:
         # Perform login
         session_token, session = await manager.login(email, password)
 
-        logger.info(
+        logger.info(f"User {session.username} logged in successfully for API key {api_key[:8]}...")
-            f"User {session.username} logged in successfully for API key {api_key[:8]}..."
-        )
 
         return session_token, session
 

src/geoguessr_mcp/config.py

@@ -37,9 +37,7 @@ class Settings:
     MCP_AUTH_ENABLED: bool = field(
         default_factory=lambda: os.getenv("MCP_AUTH_ENABLED", "false").lower() == "true"
     )
-    MCP_API_KEYS: Optional[str] = field(
+    MCP_API_KEYS: Optional[str] = field(default_factory=lambda: os.getenv("MCP_API_KEYS"))
-        default_factory=lambda: os.getenv("MCP_API_KEYS")
-    )
 
     # Logging Configuration
     LOG_LEVEL: str = field(default_factory=lambda: os.getenv("LOG_LEVEL", "INFO"))

src/geoguessr_mcp/main.py

@@ -9,10 +9,10 @@ import logging
 import sys
 
 from mcp.server.fastmcp import FastMCP
+from starlette.middleware.cors import CORSMiddleware
 
 from .config import settings
 from .middleware import AuthenticationMiddleware
-from .monitoring import endpoint_monitor
 from .tools import register_all_tools
 
 # Configure logging
@@ -25,62 +25,60 @@ logging.basicConfig(
 logger = logging.getLogger(__name__)
 
 
-# Create the MCP server instance
-mcp = FastMCP(
-    "GeoGuessr Analyzer",
-    instructions="""
-    MCP server for analyzing GeoGuessr game statistics and optimizing gameplay strategy.
-    
-    This server provides:
-    - Profile and statistics retrieval
-    - Game history and analysis
-    - Performance tracking and recommendations
-    - API monitoring with automatic schema adaptation
-    
-    The server automatically tracks API endpoint changes and adapts to response format
-    modifications. Use the monitoring tools to check API status and discover available data.
-    
-    Authentication:
-    - Use 'login(email, password)' to authenticate with your GeoGuessr account
-    - Or use 'set_ncfa_cookie(cookie)' with a cookie from your browser
-    - Or set GEOGUESSR_NCFA_COOKIE environment variable for automatic auth
-    
-    Key tools:
-    - get_performance_summary() - Comprehensive overview of your account
-    - analyze_recent_games(count) - Analyze your recent gameplay
-    - get_strategy_recommendations() - Get personalized improvement tips
-    - check_api_status() - Monitor API endpoint availability
-    - explore_endpoint(path) - Discover new API endpoints
-    """,
-    host=settings.HOST,
-    port=settings.PORT,
-)
-
-# Register all tools
-services = register_all_tools(mcp)
-
-# Add authentication middleware if needed
-if settings.MCP_AUTH_ENABLED:
-    logger.info("Registering authentication middleware")
-    # Add middleware to the underlying ASGI app
-    mcp.app.add_middleware(AuthenticationMiddleware)
-
-
-async def start_background_tasks():
-    """Start background monitoring tasks."""
-    if settings.MONITORING_ENABLED:
-        logger.info("Starting API monitoring background task...")
-        await endpoint_monitor.start_periodic_monitoring()
-
-
-async def stop_background_tasks():
-    """Stop background monitoring tasks."""
-    if endpoint_monitor._running:
-        await endpoint_monitor.stop_monitoring()
-
-
 def main():
     """Main entry point for the server."""
+
+    # Create the MCP server instance
+    mcp = FastMCP(
+        "GeoGuessr Analyzer",
+        instructions="""
+        MCP server for analyzing GeoGuessr game statistics and optimizing gameplay strategy.
+
+        This server provides:
+        - Profile and statistics retrieval
+        - Game history and analysis
+        - Performance tracking and recommendations
+        - API monitoring with automatic schema adaptation
+
+        The server automatically tracks API endpoint changes and adapts to response format
+        modifications. Use the monitoring tools to check API status and discover available data.
+
+        Authentication:
+        - Use 'login(email, password)' to authenticate with your GeoGuessr account
+        - Or use 'set_ncfa_cookie(cookie)' with a cookie from your browser
+        - Or set GEOGUESSR_NCFA_COOKIE environment variable for automatic auth
+
+        Key tools:
+        - get_performance_summary() - Comprehensive overview of your account
+        - analyze_recent_games(count) - Analyze your recent gameplay
+        - get_strategy_recommendations() - Get personalized improvement tips
+        - check_api_status() - Monitor API endpoint availability
+        - explore_endpoint(path) - Discover new API endpoints
+        """,
+        host=settings.HOST,
+        port=settings.PORT,
+    )
+
+    # Register all tools
+    register_all_tools(mcp)
+
+    # Setup authentication middleware if enabled
+    if settings.MCP_AUTH_ENABLED:
+        logger.info("Setting up authentication middleware")
+
+        # Récupérez l'application ASGI via streamable_http_app
+        mcp_app = mcp.streamable_http_app()
+
+        # Ajoutez les middlewares
+        mcp_app.add_middleware(
+            CORSMiddleware,
+            allow_origins=["*"],
+            allow_credentials=True,
+            allow_methods=["*"],
+            allow_headers=["*"],
+        )
+        mcp_app.add_middleware(AuthenticationMiddleware)
+
     logger.info(
         f"Starting GeoGuessr MCP Server on {settings.HOST}:{settings.PORT} "
         f"with {settings.TRANSPORT} transport"
@@ -96,7 +94,8 @@ def main():
         logger.info("Default GeoGuessr authentication cookie configured from environment")
     else:
         logger.warning(
-            "No default GeoGuessr authentication cookie set. " "Users will need to login or provide a cookie."
+            "No default GeoGuessr authentication cookie set. "
+            "Users will need to login or provide a cookie."
         )
 
     # Run the server

src/geoguessr_mcp/middleware/auth.py

@@ -63,9 +63,9 @@ class AuthenticationMiddleware(BaseHTTPMiddleware):
                 status_code=401,
                 content={
                     "error": "Unauthorized",
-                    "message": "Missing Authorization header. Use 'Authorization: Bearer YOUR_API_KEY'"
+                    "message": "Missing Authorization header. Use 'Authorization: Bearer YOUR_API_KEY'",
                 },
-                headers={"WWW-Authenticate": "Bearer"}
+                headers={"WWW-Authenticate": "Bearer"},
             )
 
         # Parse Bearer token
@@ -76,9 +76,9 @@ class AuthenticationMiddleware(BaseHTTPMiddleware):
                 status_code=401,
                 content={
                     "error": "Unauthorized",
-                    "message": "Invalid Authorization header format. Use 'Authorization: Bearer YOUR_API_KEY'"
+                    "message": "Invalid Authorization header format. Use 'Authorization: Bearer YOUR_API_KEY'",
                 },
-                headers={"WWW-Authenticate": "Bearer"}
+                headers={"WWW-Authenticate": "Bearer"},
             )
 
         token = parts[1]
@@ -88,15 +88,14 @@ class AuthenticationMiddleware(BaseHTTPMiddleware):
             logger.warning(f"Invalid API key attempt from {request.client.host}")
             return JSONResponse(
                 status_code=403,
-                content={
+                content={"error": "Forbidden", "message": "Invalid API key"},
-                    "error": "Forbidden",
+                headers={"WWW-Authenticate": "Bearer"},
-                    "message": "Invalid API key"
-                },
-                headers={"WWW-Authenticate": "Bearer"}
             )
 
         # Authentication successful
-        logger.debug(f"Authenticated request from {request.client.host} with API key {token[:8]}...")
+        logger.debug(
+            f"Authenticated request from {request.client.host} with API key {token[:8]}..."
+        )
 
         # Get or create user context for this API key
         user_context = await multi_user_session_manager.get_user_context(token)

src/geoguessr_mcp/monitoring/schema/schema_registry.py

@@ -12,6 +12,7 @@ Classes:
 
 import json
 import logging
+import tempfile
 from datetime import UTC, datetime
 from pathlib import Path
 from typing import Any, Optional
@@ -33,7 +34,20 @@ class SchemaRegistry:
 
     def __init__(self, cache_dir: Optional[str] = None):
         self.cache_dir = Path(cache_dir or settings.SCHEMA_CACHE_DIR)
-        self.cache_dir.mkdir(parents=True, exist_ok=True)
+
+        # Try to create the cache directory, fall back to temp if permission denied
+        try:
+            self.cache_dir.mkdir(parents=True, exist_ok=True)
+        except (PermissionError, OSError) as e:
+            logger.warning(
+                f"Cannot create schema cache directory at {self.cache_dir}: {e}. "
+                f"Using temporary directory instead."
+            )
+            # Use a temporary directory that will be cleaned up
+            temp_dir = tempfile.mkdtemp(prefix="geoguessr_schema_")
+            self.cache_dir = Path(temp_dir)
+            logger.info(f"Using temporary schema cache directory: {self.cache_dir}")
+
         self.schemas: dict[str, EndpointSchema] = {}
         self.schema_history: dict[str, list[EndpointSchema]] = {}
         self.detector = SchemaDetector()

src/geoguessr_mcp/tools/auth_tools.py

@@ -99,9 +99,7 @@ def register_auth_tools(mcp: FastMCP, session_manager=None):
         if not user_context:
             return {"success": False, "error": "No user context available"}
 
-        success = await multi_user_session_manager.logout_user(
+        success = await multi_user_session_manager.logout_user(user_context.api_key, session_token)
-            user_context.api_key, session_token
-        )
 
         return {
             "success": success,

src/tests/integration/test_auth_flow.py

@@ -131,7 +131,7 @@ class TestAuthenticationFlow:
 
     @pytest.mark.asyncio
     async def test_session_replacement_same_user(
-            self, session_manager, mock_httpx_client, mock_profile_data
+        self, session_manager, mock_httpx_client, mock_profile_data
     ):
         """Test that logging in as same user replaces old session."""
         login_response = MagicMock()

src/tests/unit/auth/test_multi_user_session.py

@@ -0,0 +1,93 @@
+"""Tests for MultiUserSessionManager."""
+
+import pytest
+
+from geoguessr_mcp.auth.multi_user_session import MultiUserSessionManager
+from geoguessr_mcp.auth.session import SessionManager
+
+
+class TestMultiUserSessionManager:
+    """Tests for MultiUserSessionManager class."""
+
+    @pytest.fixture
+    def manager(self):
+        """Create a fresh MultiUserSessionManager for each test."""
+        return MultiUserSessionManager()
+
+    @pytest.mark.asyncio
+    async def test_get_user_context_creates_new_manager(self, manager):
+        """Test that getting context for a new API key creates a new session manager."""
+        context = await manager.get_user_context("new_api_key")
+
+        assert context.api_key == "new_api_key"
+        assert "new_api_key" in manager._user_managers
+        assert isinstance(manager._user_managers["new_api_key"], SessionManager)
+
+    @pytest.mark.asyncio
+    async def test_get_user_context_reuses_existing_manager(self, manager):
+        """Test that getting context for existing API key reuses the same manager."""
+        context1 = await manager.get_user_context("existing_key")
+        context2 = await manager.get_user_context("existing_key")
+
+        # Should use the same manager instance
+        assert manager._user_managers["existing_key"] is manager._user_managers["existing_key"]
+        assert len(manager._user_managers) == 1
+
+    @pytest.mark.asyncio
+    async def test_multiple_api_keys_get_separate_managers(self, manager):
+        """Test that different API keys get separate session managers."""
+        context1 = await manager.get_user_context("key1")
+        context2 = await manager.get_user_context("key2")
+        context3 = await manager.get_user_context("key3")
+
+        assert len(manager._user_managers) == 3
+        assert manager._user_managers["key1"] is not manager._user_managers["key2"]
+        assert manager._user_managers["key2"] is not manager._user_managers["key3"]
+
+    @pytest.mark.asyncio
+    async def test_get_auth_status_not_authenticated(self, manager):
+        """Test getting auth status for unauthenticated user."""
+        status = await manager.get_auth_status("test_key")
+
+        assert not status["authenticated"]
+        assert status["user_id"] is None
+        assert status["username"] is None
+        assert "test_key" in status["api_key"] or "***" in status["api_key"]
+
+    @pytest.mark.asyncio
+    async def test_get_session_for_api_key_none_when_not_logged_in(self, manager):
+        """Test that get_session_for_api_key returns None for non-existent key."""
+        session = await manager.get_session_for_api_key("nonexistent_key")
+        assert session is None
+
+    @pytest.mark.asyncio
+    async def test_login_user_creates_manager_if_not_exists(self, manager):
+        """Test that login_user creates a manager if it doesn't exist."""
+        # This test requires mocking the HTTP client for GeoGuessr API
+        # We'll mark it as a placeholder for now
+        pytest.skip("Requires mocking GeoGuessr API")
+
+    @pytest.mark.asyncio
+    async def test_logout_user_returns_false_for_nonexistent_key(self, manager):
+        """Test that logout_user returns False for non-existent API key."""
+        result = await manager.logout_user("nonexistent_key", "fake_session_token")
+        assert result is False
+
+    @pytest.mark.asyncio
+    async def test_set_user_cookie_validates_cookie(self, manager):
+        """Test that set_user_cookie validates the cookie."""
+        # Invalid cookie should return False
+        result = await manager.set_user_cookie("test_key", "invalid_cookie")
+        assert result is False
+
+    @pytest.mark.asyncio
+    async def test_context_isolation_between_users(self, manager):
+        """Test that contexts are properly isolated between different users."""
+        context_alice = await manager.get_user_context("alice_key")
+        context_bob = await manager.get_user_context("bob_key")
+
+        # Contexts should be different
+        assert context_alice.api_key != context_bob.api_key
+
+        # Should have separate session managers
+        assert manager._user_managers["alice_key"] is not manager._user_managers["bob_key"]

src/tests/unit/auth/test_request_context.py

@@ -0,0 +1,73 @@
+"""Tests for request context utilities."""
+
+import pytest
+
+from geoguessr_mcp.auth.request_context import (
+    get_current_user_context,
+    require_user_context,
+    set_current_user_context,
+)
+from geoguessr_mcp.auth.user_context import UserContext
+
+
+class TestRequestContext:
+    """Tests for request context utilities."""
+
+    def test_get_current_user_context_returns_none_initially(self):
+        """Test that get_current_user_context returns None when not set."""
+        # Note: This might fail if previous tests didn't clean up
+        # In a real scenario, each test would have isolated context
+        context = get_current_user_context()
+        # Context might be None or from previous test
+        assert context is None or isinstance(context, UserContext)
+
+    def test_set_and_get_current_user_context(self):
+        """Test setting and getting current user context."""
+        test_context = UserContext(api_key="test_key_123")
+
+        set_current_user_context(test_context)
+        retrieved_context = get_current_user_context()
+
+        assert retrieved_context is not None
+        assert retrieved_context.api_key == "test_key_123"
+
+    def test_require_user_context_raises_when_not_set(self):
+        """Test that require_user_context raises RuntimeError when context not set."""
+        # Clear any existing context
+        set_current_user_context(None)
+
+        with pytest.raises(RuntimeError, match="No user context available"):
+            require_user_context()
+
+    def test_require_user_context_returns_context_when_set(self):
+        """Test that require_user_context returns context when it's set."""
+        test_context = UserContext(api_key="test_key_456")
+
+        set_current_user_context(test_context)
+        retrieved_context = require_user_context()
+
+        assert retrieved_context is not None
+        assert retrieved_context.api_key == "test_key_456"
+
+    def test_context_can_be_updated(self):
+        """Test that context can be updated by setting a new one."""
+        context1 = UserContext(api_key="key1")
+        context2 = UserContext(api_key="key2")
+
+        set_current_user_context(context1)
+        assert get_current_user_context().api_key == "key1"
+
+        set_current_user_context(context2)
+        assert get_current_user_context().api_key == "key2"
+
+    def test_context_can_be_cleared(self):
+        """Test that context can be cleared by setting to None."""
+        test_context = UserContext(api_key="test_key")
+
+        set_current_user_context(test_context)
+        assert get_current_user_context() is not None
+
+        set_current_user_context(None)
+        context = get_current_user_context()
+        # After clearing, should be None
+        assert context is None

src/tests/unit/auth/test_user_context.py

@@ -0,0 +1,95 @@
+"""Tests for UserContext class."""
+
+import pytest
+
+from geoguessr_mcp.auth.session import UserSession
+from geoguessr_mcp.auth.user_context import UserContext
+from datetime import datetime, timedelta, UTC
+
+
+class TestUserContext:
+    """Tests for UserContext class."""
+
+    def test_user_context_without_session(self):
+        """Test user context without a GeoGuessr session."""
+        context = UserContext(api_key="test_key_123")
+
+        assert context.api_key == "test_key_123"
+        assert context.session is None
+        assert not context.is_authenticated
+        assert context.ncfa_cookie is None
+        assert "anonymous_" in context.user_id
+        assert "User-" in context.username
+
+    def test_user_context_with_session(self):
+        """Test user context with a GeoGuessr session."""
+        session = UserSession(
+            ncfa_cookie="test_cookie",
+            user_id="user123",
+            username="testuser",
+            email="test@example.com",
+            expires_at=datetime.now(UTC) + timedelta(days=1),
+        )
+
+        context = UserContext(api_key="test_key_123", session=session)
+
+        assert context.api_key == "test_key_123"
+        assert context.session == session
+        assert context.is_authenticated
+        assert context.ncfa_cookie == "test_cookie"
+        assert context.user_id == "user123"
+        assert context.username == "testuser"
+
+    def test_user_context_with_expired_session(self):
+        """Test user context with an expired session."""
+        session = UserSession(
+            ncfa_cookie="test_cookie",
+            user_id="user123",
+            username="testuser",
+            email="test@example.com",
+            expires_at=datetime.now(UTC) - timedelta(days=1),  # Expired
+        )
+
+        context = UserContext(api_key="test_key_123", session=session)
+
+        # Session is present but not valid
+        assert context.session == session
+        assert not context.is_authenticated  # Expired session = not authenticated
+
+    def test_user_context_repr(self):
+        """Test string representation of user context."""
+        context = UserContext(api_key="test_key_123")
+        repr_str = repr(context)
+
+        assert "UserContext" in repr_str
+        assert "not authenticated" in repr_str
+
+        session = UserSession(
+            ncfa_cookie="test_cookie",
+            user_id="user123",
+            username="testuser",
+            email="test@example.com",
+        )
+        context_with_session = UserContext(api_key="test_key_123", session=session)
+        repr_with_session = repr(context_with_session)
+
+        assert "authenticated" in repr_with_session
+        assert "user123" in repr_with_session
+
+    def test_user_context_consistent_ids(self):
+        """Test that user IDs are consistent for the same API key."""
+        context1 = UserContext(api_key="same_key")
+        context2 = UserContext(api_key="same_key")
+
+        # Same API key should produce same anonymous user ID
+        assert context1.user_id == context2.user_id
+        assert context1.username == context2.username
+
+    def test_user_context_different_ids_for_different_keys(self):
+        """Test that different API keys produce different anonymous user IDs."""
+        context1 = UserContext(api_key="key1")
+        context2 = UserContext(api_key="key2")
+
+        # Different API keys should produce different anonymous user IDs
+        assert context1.user_id != context2.user_id
+        assert context1.username != context2.username

src/tests/unit/services/test_analysis_service.py

@@ -200,7 +200,7 @@ class TestAnalysisService:
 
     @pytest.mark.asyncio
     async def test_analyze_recent_games_with_session(
-            self, analysis_service, mock_game_service, sample_games
+        self, analysis_service, mock_game_service, sample_games
     ):
         """Test analyze_recent_games with session token."""
         mock_game_service.get_recent_games.return_value = sample_games
@@ -211,14 +211,14 @@ class TestAnalysisService:
 
     @pytest.mark.asyncio
     async def test_get_performance_summary(
-            self,
+        self,
-            analysis_service,
+        analysis_service,
-            mock_game_service,
+        mock_game_service,
-            mock_profile_service,
+        mock_profile_service,
-            mock_client,
+        mock_client,
-            sample_games,
+        sample_games,
-            mock_season_stats_data,
+        mock_season_stats_data,
-            mock_dynamic_response,
+        mock_dynamic_response,
     ):
         """Test comprehensive performance summary."""
         mock_profile_service.get_comprehensive_profile.return_value = {
@@ -244,7 +244,7 @@ class TestAnalysisService:
 
     @pytest.mark.asyncio
     async def test_get_performance_summary_with_errors(
-            self, analysis_service, mock_game_service, mock_profile_service, mock_client
+        self, analysis_service, mock_game_service, mock_profile_service, mock_client
     ):
         """Test performance summary handles errors gracefully."""
         mock_profile_service.get_comprehensive_profile.side_effect = Exception("Profile error")
@@ -260,7 +260,7 @@ class TestAnalysisService:
 
     @pytest.mark.asyncio
     async def test_get_strategy_recommendations_low_perfect_rate(
-            self, analysis_service, mock_game_service
+        self, analysis_service, mock_game_service
     ):
         """Test strategy recommendations for low perfect round rate."""
         # Create games with no perfect rounds
@@ -289,7 +289,7 @@ class TestAnalysisService:
 
     @pytest.mark.asyncio
     async def test_get_strategy_recommendations_fast_play(
-            self, analysis_service, mock_game_service
+        self, analysis_service, mock_game_service
     ):
         """Test strategy recommendations for fast play style."""
         # Create games with very short time
@@ -317,7 +317,7 @@ class TestAnalysisService:
 
     @pytest.mark.asyncio
     async def test_get_strategy_recommendations_declining_trend(
-            self, analysis_service, mock_game_service
+        self, analysis_service, mock_game_service
     ):
         """Test strategy recommendations for declining performance."""
         # Create games with declining scores
@@ -346,7 +346,7 @@ class TestAnalysisService:
 
     @pytest.mark.asyncio
     async def test_get_strategy_recommendations_many_weak_areas(
-            self, analysis_service, mock_game_service
+        self, analysis_service, mock_game_service
     ):
         """Test strategy recommendations for many weak rounds."""
         # Create games with many low scores

src/tests/unit/services/test_game_service.py

@@ -19,7 +19,7 @@ class TestGameService:
 
     @pytest.mark.asyncio
     async def test_get_game_details_success(
-            self, game_service, mock_client, mock_game_data, mock_dynamic_response
+        self, game_service, mock_client, mock_game_data, mock_dynamic_response
     ):
         """Test successful game details retrieval."""
         mock_client.get.return_value = mock_dynamic_response(mock_game_data)
@@ -35,7 +35,7 @@ class TestGameService:
 
     @pytest.mark.asyncio
     async def test_get_game_details_with_session_token(
-            self, game_service, mock_client, mock_game_data, mock_dynamic_response
+        self, game_service, mock_client, mock_game_data, mock_dynamic_response
     ):
         """Test game details with explicit session token."""
         mock_client.get.return_value = mock_dynamic_response(mock_game_data)
@@ -86,7 +86,7 @@ class TestGameService:
 
     @pytest.mark.asyncio
     async def test_get_activity_feed(
-            self, game_service, mock_client, mock_activity_feed_data, mock_dynamic_response
+        self, game_service, mock_client, mock_activity_feed_data, mock_dynamic_response
     ):
         """Test activity feed retrieval."""
         mock_client.get.return_value = mock_dynamic_response(mock_activity_feed_data)
@@ -98,7 +98,7 @@ class TestGameService:
 
     @pytest.mark.asyncio
     async def test_get_activity_feed_pagination(
-            self, game_service, mock_client, mock_dynamic_response
+        self, game_service, mock_client, mock_dynamic_response
     ):
         """Test activity feed with pagination."""
         page_2_data = {"entries": [{"type": "PlayedGame", "payload": {"gameToken": "old-game"}}]}
@@ -111,12 +111,12 @@ class TestGameService:
 
     @pytest.mark.asyncio
     async def test_get_recent_games_success(
-            self,
+        self,
-            game_service,
+        game_service,
-            mock_client,
+        mock_client,
-            mock_activity_feed_data,
+        mock_activity_feed_data,
-            mock_game_data,
+        mock_game_data,
-            mock_dynamic_response,
+        mock_dynamic_response,
     ):
         """Test recent games retrieval."""
         # First call returns activity feed, subsequent calls return game details
@@ -133,7 +133,7 @@ class TestGameService:
 
     @pytest.mark.asyncio
     async def test_get_recent_games_empty_feed(
-            self, game_service, mock_client, mock_dynamic_response
+        self, game_service, mock_client, mock_dynamic_response
     ):
         """Test recent games with empty activity feed."""
         mock_client.get.return_value = mock_dynamic_response({"entries": []})
@@ -144,7 +144,7 @@ class TestGameService:
 
     @pytest.mark.asyncio
     async def test_get_recent_games_feed_failure(
-            self, game_service, mock_client, mock_dynamic_response
+        self, game_service, mock_client, mock_dynamic_response
     ):
         """Test recent games when feed fails."""
         mock_client.get.return_value = mock_dynamic_response({"error": "Failed"}, success=False)
@@ -155,12 +155,12 @@ class TestGameService:
 
     @pytest.mark.asyncio
     async def test_get_recent_games_skips_failed_game_fetch(
-            self,
+        self,
-            game_service,
+        game_service,
-            mock_client,
+        mock_client,
-            mock_activity_feed_data,
+        mock_activity_feed_data,
-            mock_game_data,
+        mock_game_data,
-            mock_dynamic_response,
+        mock_dynamic_response,
     ):
         """Test that failed individual game fetches are skipped."""
         mock_client.get.side_effect = [
@@ -175,7 +175,7 @@ class TestGameService:
 
     @pytest.mark.asyncio
     async def test_get_season_stats_success(
-            self, game_service, mock_client, mock_season_stats_data, mock_dynamic_response
+        self, game_service, mock_client, mock_season_stats_data, mock_dynamic_response
     ):
         """Test season stats retrieval."""
         mock_client.get.return_value = mock_dynamic_response(mock_season_stats_data)
@@ -200,7 +200,7 @@ class TestGameService:
 
     @pytest.mark.asyncio
     async def test_get_daily_challenge_today(
-            self, game_service, mock_client, mock_dynamic_response
+        self, game_service, mock_client, mock_dynamic_response
     ):
         """Test daily challenge retrieval for today."""
         challenge_data = {
@@ -219,7 +219,7 @@ class TestGameService:
 
     @pytest.mark.asyncio
     async def test_get_daily_challenge_specific_day(
-            self, game_service, mock_client, mock_dynamic_response
+        self, game_service, mock_client, mock_dynamic_response
     ):
         """Test daily challenge for specific day."""
         challenge_data = {
@@ -234,7 +234,7 @@ class TestGameService:
 
     @pytest.mark.asyncio
     async def test_get_daily_challenge_failure(
-            self, game_service, mock_client, mock_dynamic_response
+        self, game_service, mock_client, mock_dynamic_response
     ):
         """Test daily challenge failure."""
         mock_client.get.return_value = mock_dynamic_response(

src/tests/unit/services/test_profile_service.py

@@ -17,7 +17,7 @@ class TestProfileService:
 
     @pytest.mark.asyncio
     async def test_get_profile_success(
-            self, profile_service, mock_client, mock_profile_data, mock_dynamic_response
+        self, profile_service, mock_client, mock_profile_data, mock_dynamic_response
     ):
         """Test successful profile retrieval."""
         mock_client.get.return_value = mock_dynamic_response(mock_profile_data)
@@ -34,7 +34,7 @@ class TestProfileService:
 
     @pytest.mark.asyncio
     async def test_get_profile_with_session_token(
-            self, profile_service, mock_client, mock_profile_data, mock_dynamic_response
+        self, profile_service, mock_client, mock_profile_data, mock_dynamic_response
     ):
         """Test profile retrieval with explicit session token."""
         mock_client.get.return_value = mock_dynamic_response(mock_profile_data)
@@ -57,7 +57,7 @@ class TestProfileService:
 
     @pytest.mark.asyncio
     async def test_get_stats_success(
-            self, profile_service, mock_client, mock_stats_data, mock_dynamic_response
+        self, profile_service, mock_client, mock_stats_data, mock_dynamic_response
     ):
         """Test successful stats retrieval."""
         mock_client.get.return_value = mock_dynamic_response(mock_stats_data)
@@ -97,7 +97,7 @@ class TestProfileService:
 
     @pytest.mark.asyncio
     async def test_get_achievements_list_format(
-            self, profile_service, mock_client, mock_dynamic_response
+        self, profile_service, mock_client, mock_dynamic_response
     ):
         """Test achievements retrieval with list format response."""
         achievements_data = [
@@ -128,7 +128,7 @@ class TestProfileService:
 
     @pytest.mark.asyncio
     async def test_get_achievements_dict_format(
-            self, profile_service, mock_client, mock_dynamic_response
+        self, profile_service, mock_client, mock_dynamic_response
     ):
         """Test achievements retrieval with dict format response."""
         achievements_data = {
@@ -175,12 +175,12 @@ class TestProfileService:
 
     @pytest.mark.asyncio
     async def test_get_comprehensive_profile_success(
-            self,
+        self,
-            profile_service,
+        profile_service,
-            mock_client,
+        mock_client,
-            mock_profile_data,
+        mock_profile_data,
-            mock_stats_data,
+        mock_stats_data,
-            mock_dynamic_response,
+        mock_dynamic_response,
     ):
         """Test comprehensive profile aggregation."""
         # Setup mock responses for each call
@@ -208,7 +208,7 @@ class TestProfileService:
 
     @pytest.mark.asyncio
     async def test_get_comprehensive_profile_partial_failure(
-            self, profile_service, mock_client, mock_profile_data, mock_dynamic_response
+        self, profile_service, mock_client, mock_profile_data, mock_dynamic_response
     ):
         """Test comprehensive profile with some endpoints failing."""
         mock_client.get.side_effect = [