event mocked tests

Author: naji247

src/mcpcat/modules/event_queue.py

@@ -24,13 +24,19 @@
 class EventQueue:
     """Manages event queue and sending to MCPCat API."""
 
-    def __init__(self):
+    def __init__(self, api_client=None):
         self.queue: queue.Queue[UnredactedEvent] = queue.Queue(maxsize=10000)
         self.max_retries = 3
         self.max_queue_size = 10000  # Prevent unbounded growth
         self.concurrency = 5  # Max parallel requests
-        config = Configuration(host=MCPCAT_API_URL)
-        self.api_client = EventsApi(config)
+        
+        # Allow injection of api_client for testing
+        if api_client is None:
+            config = Configuration(host=MCPCAT_API_URL)
+            self.api_client = EventsApi(config)
+        else:
+            self.api_client = api_client
+            
         self._shutdown = False
         self._shutdown_event = threading.Event()
 
@@ -86,10 +92,9 @@ def _process_event(self, event: UnredactedEvent) -> None:
             # Redact sensitive information if a redaction function is provided
             try:
                 redacted_event = redact_event_sync(event)
+                # The redacted event is already the full event object, not a dict
+                event = redacted_event
                 event.redaction_fn = None  # Clear the function to avoid reprocessing
-                # Update event with redacted data
-                for key, value in redacted_event.items():
-                    setattr(event, key, value)
             except Exception as error:
                 write_to_log(f"WARNING: Dropping event {event.id or 'unknown'} due to redaction failure: {error}")
                 return  # Skip this event if redaction fails
@@ -157,6 +162,14 @@ def _shutdown_handler(*_):
     event_queue.destroy()
 
 
+def set_event_queue(new_queue: EventQueue) -> None:
+    """Replace the global event queue instance (for testing)."""
+    global event_queue
+    # Destroy the old queue first
+    event_queue.destroy()
+    event_queue = new_queue
+
+
 # Register shutdown handlers
 signal.signal(signal.SIGINT, _shutdown_handler)
 signal.signal(signal.SIGTERM, _shutdown_handler)

src/mcpcat/modules/overrides/mcp_server.py

@@ -146,7 +146,7 @@ async def wrapped_call_tool_handler(request: CallToolRequest) -> ServerResult:
 
             parameters=request.params.model_dump() if request.params else {},
             event_type=EventType.MCP_TOOLS_CALL.value,
-            resourceName=tool_name,
+            resource_name=tool_name,
             redaction_fn=data.options.redact_sensitive_information,
         )
 

tests/test_event_queue.py

@@ -116,8 +116,21 @@ def test_process_event_with_redaction(self, mock_redact):
         """Test processing event with redaction function."""
         eq = EventQueue()
         mock_redaction_fn = MagicMock()
-        # Mock redact_event_sync to return a dict with redacted values
-        mock_redact.return_value = {"parameters": {"secret": "[REDACTED]"}, "user_intent": "redacted intent"}
+        
+        # Create a redacted event
+        redacted_event = UnredactedEvent(
+            id="test-id",
+            event_type="mcp:tools/call",
+            project_id="project-123",
+            session_id="session-123",
+            timestamp=datetime.now(),
+            parameters={"secret": "[REDACTED]"},
+            user_intent="redacted intent",
+            redaction_fn=None  # This should be cleared after redaction
+        )
+        
+        # Mock redact_event_sync to return the redacted event
+        mock_redact.return_value = redacted_event
 
         event = UnredactedEvent(
             id="test-id",
@@ -134,10 +147,11 @@ def test_process_event_with_redaction(self, mock_redact):
             eq._process_event(event)
 
             mock_redact.assert_called_once_with(event)
-            assert event.redaction_fn is None
-            # Check that attributes were updated
-            assert event.parameters == {"secret": "[REDACTED]"}
-            assert event.user_intent == "redacted intent"
+            # The send_event should be called with the redacted event
+            called_event = mock_send.call_args[0][0]
+            assert called_event.parameters == {"secret": "[REDACTED]"}
+            assert called_event.user_intent == "redacted intent"
+            assert called_event.redaction_fn is None
             mock_send.assert_called_once()
 
     @patch('mcpcat.modules.event_queue.redact_event_sync')

tests/test_report_missing.py

@@ -1,6 +1,8 @@
 """Test report_missing functionality."""
 
 import pytest
+from unittest.mock import MagicMock
+import time
 
 from mcpcat import MCPCatOptions, track
 
@@ -285,4 +287,133 @@ async def test_report_missing_with_invalid_types(self):
             )
             # Should convert to string and work
             assert result.content[0].text
-            assert "12345" in result.content[0].text
+            assert "12345" in result.content[0].text
+
+    @pytest.mark.asyncio
+    async def test_report_missing_publishes_event(self):
+        """Verify that calling report_missing tool publishes an event to the queue."""
+        from mcpcat.modules.event_queue import EventQueue, set_event_queue
+        
+        # Create a mock API client
+        mock_api_client = MagicMock()
+        mock_api_client.publish_event = MagicMock(return_value=None)
+        
+        # Create a new EventQueue with our mock
+        test_queue = EventQueue(api_client=mock_api_client)
+        
+        # Replace the global event queue
+        set_event_queue(test_queue)
+        
+        try:
+            server = create_todo_server()
+            options = MCPCatOptions(enable_report_missing=True, enable_tracing=True)
+            track(server, "test_project", options)
+            
+            async with create_test_client(server) as client:
+                # Call the report_missing tool
+                await client.call_tool(
+                    "report_missing",
+                    {
+                        "missing_tool": "image_resize",
+                        "description": "Need to resize images to different dimensions"
+                    }
+                )
+                
+                # Give the event queue worker thread time to process
+                time.sleep(1.0)
+                
+                # Verify that publish_event was called
+                assert mock_api_client.publish_event.called
+                assert mock_api_client.publish_event.call_count >= 1  # At least one call
+                
+                # Find the tool call event
+                tool_call_event = None
+                for call in mock_api_client.publish_event.call_args_list:
+                    event = call[1]["publish_event_request"]
+                    if event.event_type == "mcp:tools/call" and event.resource_name == "report_missing":
+                        tool_call_event = event
+                        break
+                
+                assert tool_call_event is not None, "No report_missing tool call event found"
+                
+                # Verify event properties
+                assert tool_call_event.project_id == "test_project"
+                
+                # Verify the arguments contain our input
+                assert tool_call_event.parameters["arguments"]["missing_tool"] == "image_resize"
+                assert tool_call_event.parameters["arguments"]["description"] == "Need to resize images to different dimensions"
+                
+        finally:
+            # Clean up: restore original event queue
+            from mcpcat.modules.event_queue import EventQueue, set_event_queue
+            set_event_queue(EventQueue())
+
+    @pytest.mark.asyncio
+    async def test_multiple_tool_calls_publish_multiple_events(self):
+        """Verify that multiple tool calls result in multiple events being published."""
+        from mcpcat.modules.event_queue import EventQueue, set_event_queue
+        
+        # Create a mock API client
+        mock_api_client = MagicMock()
+        mock_api_client.publish_event = MagicMock(return_value=None)
+        
+        # Create a new EventQueue with our mock
+        test_queue = EventQueue(api_client=mock_api_client)
+        
+        # Replace the global event queue
+        set_event_queue(test_queue)
+        
+        try:
+            server = create_todo_server()
+            options = MCPCatOptions(enable_report_missing=True, enable_tracing=True)
+            track(server, "test_project", options)
+            
+            async with create_test_client(server) as client:
+                # Call report_missing tool
+                await client.call_tool(
+                    "report_missing",
+                    {"missing_tool": "tool1", "description": "desc1"}
+                )
+                
+                # Call a regular tool
+                await client.call_tool(
+                    "add_todo",
+                    {"text": "Test todo item"}
+                )
+                
+                # Call report_missing again
+                await client.call_tool(
+                    "report_missing",
+                    {"missing_tool": "tool2", "description": "desc2"}
+                )
+                
+                # Allow time for processing
+                import time
+                time.sleep(1.0)
+                
+                # Should have at least 3 tool call events (plus initialize and list_tools events)
+                assert mock_api_client.publish_event.call_count >= 3
+                
+                # Get all published events
+                events = [call[1]["publish_event_request"] for call in mock_api_client.publish_event.call_args_list]
+                
+                # Filter to just tool call events
+                tool_events = [e for e in events if e.event_type == "mcp:tools/call"]
+                
+                # Should have exactly 3 tool calls
+                assert len(tool_events) == 3
+                
+                # Verify event types and tool names
+                assert tool_events[0].resource_name == "report_missing"
+                assert tool_events[0].parameters["arguments"]["missing_tool"] == "tool1"
+                
+                assert tool_events[1].resource_name == "add_todo"
+                assert tool_events[1].parameters["arguments"]["text"] == "Test todo item"
+                
+                assert tool_events[2].resource_name == "report_missing"
+                assert tool_events[2].parameters["arguments"]["missing_tool"] == "tool2"
+                
+        finally:
+            # Clean up: restore original event queue
+            from mcpcat.modules.event_queue import EventQueue, set_event_queue
+            set_event_queue(EventQueue())