Improves session management and debugging

nullchimp · nullchimp · commit a88244bac654 · 2025-06-24T23:30:49.000+02:00
Refactors session handling to use dependency injection for agent
creation and retrieval, improving testability and maintainability.

Adds new GET endpoints for session creation and verification,
aligning with the updated frontend session lifecycle.

Isolates debug events per session, ensuring correct debug
information is displayed for each active session.
diff --git a/tests/test_debug_api.py b/tests/test_debug_api.py
@@ -4,6 +4,7 @@
 
 from api.app import create_app
 from core.debug_capture import get_debug_capture_instance, _debug_sessions, clear_all_debug_events
+from agent import get_agent_instance
 
 @pytest.fixture
 def client():
@@ -130,19 +131,36 @@ def test_clear_debug_events_by_session(self, client, auth_headers):
     def test_ask_endpoint_sets_session_id(self, client, auth_headers):
         # This test is not as relevant with per-session captures
         # since session management is handled differently now
-        with patch('src.agent.get_agent_instance') as mock_get_agent:
-            mock_agent = MagicMock()
-            mock_agent.process_query.return_value = ("Test response", [])
-            mock_get_agent.return_value = mock_agent
+        mock_agent = MagicMock()
+        
+        # Mock the async process_query method to return an awaitable
+        async def mock_process_query(query):
+            return ("Test response", [])
+        
+        mock_agent.process_query = mock_process_query
+        
+        # Mock the dependency injection by overriding the app dependency
+        async def mock_get_agent_instance(session_id: str = None):
+            return mock_agent
             
+        client.app.dependency_overrides[get_agent_instance] = mock_get_agent_instance
+        
+        try:
             response = client.post(
                 "/api/test_session/ask",
                 json={"query": "test query"},
                 headers=auth_headers
             )
             
             # The main goal is that the request succeeds
-            assert response.status_code == 200 or response.status_code == 422  # Depends on API structure
+            assert response.status_code == 200
+            
+            data = response.json()
+            assert data["response"] == "Test response"
+            assert data["used_tools"] == []
+        finally:
+            # Clean up the dependency override
+            client.app.dependency_overrides.clear()
 
     def test_unauthorized_access(self, client):
         response = client.get("/api/test_session/debug")
diff --git a/tests/test_frontend_debug_session_isolation.py b/tests/test_frontend_debug_session_isolation.py
@@ -1,45 +1,64 @@
 import pytest
 from unittest.mock import Mock, patch, AsyncMock
 from core.debug_capture import DebugCapture, get_debug_capture_instance, _debug_sessions
-from api.routes import session_router, api_router
+from api.app import create_app
+from agent import get_agent_instance
 from fastapi.testclient import TestClient
-from fastapi import FastAPI
 
 
 class TestDebugSessionIsolation:
     """Test that debug events are properly isolated per session in the frontend-backend integration"""
 
+    def setup_method(self):
+        # Clear all debug sessions between tests
+        _debug_sessions.clear()
+
     @pytest.fixture
     def app(self):
-        app = FastAPI()
-        app.include_router(session_router)
-        app.include_router(api_router)
-        return app
+        return create_app()
 
     @pytest.fixture
     def client(self, app):
         return TestClient(app)
 
     @pytest.fixture
-    def mock_agent_deps(self):
-        with patch("api.routes.get_agent_instance") as mock_get_agent, \
-             patch("api.routes.get_debug_capture_instance") as mock_get_debug:
+    def auth_headers(self):
+        return {"X-API-Key": "test_12345"}
+
+    @pytest.fixture
+    def mock_agent_deps(self, app):
+        # Mock the Agent class constructor to prevent MCP initialization
+        with patch('agent.Agent') as mock_agent_class, \
+             patch('agent.MCPSessionManager') as mock_mcp_manager:
+            
+            # Create a mock agent instance
             mock_agent = Mock()
+            mock_agent.session_id = "test_session"
             mock_agent.get_tools.return_value = []
-            mock_agent.process_query = AsyncMock(return_value=("Test response", set()))
+            
+            async def mock_process_query(query):
+                return ("Test response", set())
+            
+            mock_agent.process_query = mock_process_query
             mock_agent.initialize_mcp_tools = AsyncMock()
-            mock_get_agent.return_value = mock_agent
             
-            mock_debug = Mock()
-            mock_get_debug.return_value = mock_debug
+            # Make the Agent constructor return our mock
+            mock_agent_class.return_value = mock_agent
+            
+            # Mock MCPSessionManager
+            mock_mcp_instance = Mock()
+            mock_mcp_instance.discovery = AsyncMock()
+            mock_mcp_instance.tools = []
+            mock_mcp_manager.return_value = mock_mcp_instance
+            
             yield mock_agent
 
     @pytest.fixture
     def mock_session_manager(self):
         # No longer needed since route doesn't use MCPSessionManager
         yield None
 
-    def test_debug_events_isolated_per_session(self, client, mock_agent_deps, mock_session_manager):
+    def test_debug_events_isolated_per_session(self, client, auth_headers, mock_agent_deps, mock_session_manager):
         """Test that debug events are properly isolated between different sessions"""
         
         # Create two sessions
@@ -67,7 +86,7 @@ def test_debug_events_isolated_per_session(self, client, mock_agent_deps, mock_s
         debug2.capture_event("test_event_2", "Session 2 event", {"session": 2, "data": "session2_data"})
         
         # Verify session 1 debug endpoint only returns session 1 events
-        debug_response1 = client.get(f"/api/{session1_id}/debug", headers={"X-API-Key": "test_12345"})
+        debug_response1 = client.get(f"/api/{session1_id}/debug", headers=auth_headers)
         assert debug_response1.status_code == 200
         events1 = debug_response1.json()["events"]
         
diff --git a/tests/test_frontend_debug_session_switching.py b/tests/test_frontend_debug_session_switching.py
@@ -1,45 +1,64 @@
 import pytest
 from unittest.mock import Mock, AsyncMock, patch, call
 from core.debug_capture import get_debug_capture_instance, _debug_sessions
-from api.routes import session_router, api_router
+from api.app import create_app
+from agent import get_agent_instance
 from fastapi.testclient import TestClient
-from fastapi import FastAPI
 
 
 class TestFrontendDebugSessionSwitching:
     """Test the frontend integration for debug session switching"""
 
+    def setup_method(self):
+        # Clear all debug sessions between tests
+        _debug_sessions.clear()
+
     @pytest.fixture
     def app(self):
-        app = FastAPI()
-        app.include_router(session_router)
-        app.include_router(api_router)
-        return app
+        return create_app()
 
     @pytest.fixture
     def client(self, app):
         return TestClient(app)
 
     @pytest.fixture
-    def mock_agent_deps(self):
-        with patch("api.routes.get_agent_instance") as mock_get_agent, \
-             patch("api.routes.get_debug_capture_instance") as mock_get_debug:
+    def auth_headers(self):
+        return {"X-API-Key": "test_12345"}
+
+    @pytest.fixture
+    def mock_agent_deps(self, app):
+        # Mock the Agent class constructor to prevent MCP initialization
+        with patch('agent.Agent') as mock_agent_class, \
+             patch('agent.MCPSessionManager') as mock_mcp_manager:
+            
+            # Create a mock agent instance
             mock_agent = Mock()
+            mock_agent.session_id = "test_session"
             mock_agent.get_tools.return_value = []
-            mock_agent.process_query = AsyncMock(return_value=("Test response", set()))
+            
+            async def mock_process_query(query):
+                return ("Test response", set())
+            
+            mock_agent.process_query = mock_process_query
             mock_agent.initialize_mcp_tools = AsyncMock()
-            mock_get_agent.return_value = mock_agent
             
-            mock_debug = Mock()
-            mock_get_debug.return_value = mock_debug
+            # Make the Agent constructor return our mock
+            mock_agent_class.return_value = mock_agent
+            
+            # Mock MCPSessionManager
+            mock_mcp_instance = Mock()
+            mock_mcp_instance.discovery = AsyncMock()
+            mock_mcp_instance.tools = []
+            mock_mcp_manager.return_value = mock_mcp_instance
+            
             yield mock_agent
 
     @pytest.fixture
     def mock_session_manager(self):
         # No longer needed since route doesn't use MCPSessionManager
         yield None
 
-    def test_debug_panel_shows_session_specific_events(self, client, mock_agent_deps, mock_session_manager):
+    def test_debug_panel_shows_session_specific_events(self, client, auth_headers, mock_agent_deps):
         """Test that the debug panel shows only events for the current session"""
         
         # Create two sessions with different debug events
@@ -65,7 +84,7 @@ def test_debug_panel_shows_session_specific_events(self, client, mock_agent_deps
         debug2.capture_event("tool_result", "News results retrieved", {"results": ["News item 1", "News item 2"]})
         
         # Test: Debug endpoint for session 1 should only show session 1 events
-        debug_response1 = client.get(f"/api/{session1_id}/debug", headers={"X-API-Key": "test_12345"})
+        debug_response1 = client.get(f"/api/{session1_id}/debug", headers=auth_headers)
         events1 = debug_response1.json()["events"]
         
         assert len(events1) == 2
@@ -74,7 +93,7 @@ def test_debug_panel_shows_session_specific_events(self, client, mock_agent_deps
         assert events1[1]["event_type"] == "llm_response"
         
         # Test: Debug endpoint for session 2 should only show session 2 events
-        debug_response2 = client.get(f"/api/{session2_id}/debug", headers={"X-API-Key": "test_12345"})
+        debug_response2 = client.get(f"/api/{session2_id}/debug", headers=auth_headers)
         events2 = debug_response2.json()["events"]
         
         assert len(events2) == 3
@@ -83,7 +102,7 @@ def test_debug_panel_shows_session_specific_events(self, client, mock_agent_deps
         assert events2[1]["event_type"] == "tool_call"
         assert events2[2]["event_type"] == "tool_result"
 
-    def test_debug_state_persists_across_session_switches(self, client, mock_agent_deps, mock_session_manager):
+    def test_debug_state_persists_across_session_switches(self, client, auth_headers, mock_agent_deps):
         """Test that debug enabled/disabled state is maintained per session"""
         
         # Create two sessions
@@ -100,8 +119,8 @@ def test_debug_state_persists_across_session_switches(self, client, mock_agent_d
         debug1.enable()
         debug2.enable()
         
-        debug_status1 = client.get(f"/api/{session1_id}/debug", headers={"X-API-Key": "test_12345"})
-        debug_status2 = client.get(f"/api/{session2_id}/debug", headers={"X-API-Key": "test_12345"})
+        debug_status1 = client.get(f"/api/{session1_id}/debug", headers=auth_headers)
+        debug_status2 = client.get(f"/api/{session2_id}/debug", headers=auth_headers)
         
         assert debug_status1.json()["enabled"] is True
         assert debug_status2.json()["enabled"] is True
@@ -110,13 +129,13 @@ def test_debug_state_persists_across_session_switches(self, client, mock_agent_d
         toggle_response = client.post(
             f"/api/{session1_id}/debug/toggle", 
             json={"enabled": False},
-            headers={"X-API-Key": "test_12345"}
+            headers=auth_headers
         )
         assert toggle_response.json()["enabled"] is False
         
         # Verify session 1 is disabled, session 2 still enabled
-        debug_status1_after = client.get(f"/api/{session1_id}/debug", headers={"X-API-Key": "test_12345"})
-        debug_status2_after = client.get(f"/api/{session2_id}/debug", headers={"X-API-Key": "test_12345"})
+        debug_status1_after = client.get(f"/api/{session1_id}/debug", headers=auth_headers)
+        debug_status2_after = client.get(f"/api/{session2_id}/debug", headers=auth_headers)
         
         assert debug_status1_after.json()["enabled"] is False
         assert debug_status2_after.json()["enabled"] is True
@@ -129,27 +148,27 @@ def test_debug_state_persists_across_session_switches(self, client, mock_agent_d
         debug2.capture_event("test_event", "Should be captured", {"test": "data2"})
         
         # Verify only session 2 captures events (since session 1 is disabled, session 2 still enabled)
-        events1 = client.get(f"/api/{session1_id}/debug", headers={"X-API-Key": "test_12345"}).json()["events"]
-        events2 = client.get(f"/api/{session2_id}/debug", headers={"X-API-Key": "test_12345"}).json()["events"]
+        events1 = client.get(f"/api/{session1_id}/debug", headers=auth_headers).json()["events"]
+        events2 = client.get(f"/api/{session2_id}/debug", headers=auth_headers).json()["events"]
         
         assert len(events1) == 0  # Session 1 debug is disabled
         assert len(events2) == 1  # Session 2 debug is enabled
 
-    def test_empty_session_shows_empty_debug_panel(self, client, mock_agent_deps, mock_session_manager):
+    def test_empty_session_shows_empty_debug_panel(self, client, auth_headers, mock_agent_deps):
         """Test that a new session with no events shows an empty debug panel"""
         
         # Create a new session
         response = client.get("/api/session/new")
         session_id = response.json()["session_id"]
         
         # Debug endpoint should return enabled=False but no events by default
-        debug_response = client.get(f"/api/{session_id}/debug", headers={"X-API-Key": "test_12345"})
+        debug_response = client.get(f"/api/{session_id}/debug", headers=auth_headers)
         debug_data = debug_response.json()
         
         assert debug_data["enabled"] is False
         assert len(debug_data["events"]) == 0
 
-    def test_debug_events_ordering_by_timestamp(self, client, mock_agent_deps, mock_session_manager):
+    def test_debug_events_ordering_by_timestamp(self, client, auth_headers, mock_agent_deps):
         """Test that debug events are returned in chronological order"""
         
         # Create a session
@@ -170,7 +189,7 @@ def test_debug_events_ordering_by_timestamp(self, client, mock_agent_deps, mock_
         debug_capture.capture_event("event_3", "Third event", {"order": 3})
         
         # Get events from API
-        debug_response = client.get(f"/api/{session_id}/debug", headers={"X-API-Key": "test_12345"})
+        debug_response = client.get(f"/api/{session_id}/debug", headers=auth_headers)
         events = debug_response.json()["events"]
         
         assert len(events) == 3
diff --git a/tests/test_frontend_session_integration.py b/tests/test_frontend_session_integration.py
