added tests

Author: chrishayuk

tests/mcp/__init__.py

@@ -0,0 +1,76 @@
+# tests/mcp/test_mcp_tool.py
+import pytest
+from unittest.mock import Mock, AsyncMock
+
+from chuk_tool_processor.mcp.mcp_tool import MCPTool
+from chuk_tool_processor.mcp.stream_manager import StreamManager
+
+
+class TestMCPTool:
+    """Test MCPTool class."""
+    
+    @pytest.fixture
+    def mock_stream_manager(self):
+        """Mock StreamManager instance."""
+        mock = Mock(spec=StreamManager)
+        mock.call_tool = AsyncMock()
+        return mock
+    
+    @pytest.fixture
+    def mcp_tool(self, mock_stream_manager):
+        """Create MCPTool instance."""
+        return MCPTool("echo", mock_stream_manager)
+    
+    @pytest.mark.asyncio
+    async def test_execute_success(self, mcp_tool, mock_stream_manager):
+        """Test successful tool execution."""
+        # Setup
+        mock_stream_manager.call_tool.return_value = {
+            "isError": False,
+            "content": "Hello World"
+        }
+        
+        # Execute
+        result = await mcp_tool.execute(message="Hello")
+        
+        # Verify
+        assert result == "Hello World"
+        mock_stream_manager.call_tool.assert_called_once_with(
+            tool_name="echo",
+            arguments={"message": "Hello"}
+        )
+    
+    @pytest.mark.asyncio
+    async def test_execute_error(self, mcp_tool, mock_stream_manager):
+        """Test tool execution with error."""
+        # Setup
+        mock_stream_manager.call_tool.return_value = {
+            "isError": True,
+            "error": "Connection failed"
+        }
+        
+        # Execute and verify error
+        with pytest.raises(RuntimeError, match="Connection failed"):
+            await mcp_tool.execute(message="Hello")
+    
+    @pytest.mark.asyncio
+    async def test_execute_unknown_error(self, mcp_tool, mock_stream_manager):
+        """Test tool execution with unknown error."""
+        # Setup
+        mock_stream_manager.call_tool.return_value = {
+            "isError": True
+        }
+        
+        # Execute and verify default error message
+        with pytest.raises(RuntimeError, match="Unknown error"):
+            await mcp_tool.execute(message="Hello")
+    
+    @pytest.mark.asyncio
+    async def test_execute_transport_error(self, mcp_tool, mock_stream_manager):
+        """Test tool call with transport error."""
+        # Simulate transport error
+        mock_stream_manager.call_tool.side_effect = Exception("Transport error")
+        
+        # Should catch and reraise as RuntimeError
+        with pytest.raises(Exception, match="Transport error"):
+            await mcp_tool.execute(message="test")

tests/mcp/test_mcp_tool.py

@@ -0,0 +1,106 @@
+# tests/mcp/test_register_mcp_tools.py
+import pytest
+from unittest.mock import Mock, patch
+
+from chuk_tool_processor.mcp.register_mcp_tools import register_mcp_tools
+from chuk_tool_processor.mcp.stream_manager import StreamManager
+from chuk_tool_processor.registry.interface import ToolRegistryInterface
+
+
+class TestRegisterMCPTools:
+    """Test MCP tools registration."""
+    
+    @pytest.fixture
+    def mock_registry(self):
+        """Mock tool registry."""
+        mock = Mock(spec=ToolRegistryInterface)
+        mock.register_tool = Mock()
+        return mock
+    
+    @pytest.fixture
+    def mock_stream_manager(self):
+        """Mock stream manager."""
+        mock = Mock(spec=StreamManager)
+        tools = [
+            {"name": "echo", "description": "Echo tool", "inputSchema": {}},
+            {"name": "calc", "description": "Calculator", "inputSchema": {}}
+        ]
+        mock.get_all_tools = Mock(return_value=tools)
+        return mock
+    
+    def test_register_tools(self, mock_registry, mock_stream_manager):
+        """Test registering MCP tools."""
+        # Mock the registry provider
+        with patch('chuk_tool_processor.mcp.register_mcp_tools.ToolRegistryProvider.get_registry', return_value=mock_registry):
+            registered = register_mcp_tools(mock_stream_manager, namespace="mcp")
+            
+            # Check registration calls
+            assert len(registered) == 2
+            assert "echo" in registered
+            assert "calc" in registered
+            
+            # Verify register_tool was called with correct args
+            assert mock_registry.register_tool.call_count == 4  # 2 tools x 2 registrations each
+            
+            # Check that tools were registered in both namespaces
+            call_args = mock_registry.register_tool.call_args_list
+            
+            # Check tools are registered as both "tool" and "namespace.tool"
+            tool_names = []
+            for call in call_args:
+                # Extract name parameter from the call
+                args, kwargs = call
+                # The name is the second positional argument 
+                # or in kwargs with key 'name'
+                if 'name' in kwargs:
+                    tool_names.append(kwargs['name'])
+                elif len(args) > 1:
+                    tool_names.append(args[1])
+            
+            assert "echo" in tool_names
+            assert "mcp.echo" in tool_names
+            assert "calc" in tool_names
+            assert "mcp.calc" in tool_names
+    
+    def test_register_with_invalid_tool(self, mock_registry, mock_stream_manager):
+        """Test handling invalid tool definitions."""
+        tools = [
+            {"description": "No name"},  # Missing name
+            {"name": "", "description": "Empty name"}  # Empty name
+        ]
+        mock_stream_manager.get_all_tools = Mock(return_value=tools)
+        
+        with patch('chuk_tool_processor.mcp.register_mcp_tools.ToolRegistryProvider.get_registry', return_value=mock_registry):
+            registered = register_mcp_tools(mock_stream_manager)
+            
+            assert len(registered) == 0
+            assert mock_registry.register_tool.call_count == 0
+    
+    def test_empty_tools_registration(self, mock_registry):
+        """Test registering with no tools."""
+        mock_stream_manager = Mock(spec=StreamManager)
+        mock_stream_manager.get_all_tools = Mock(return_value=[])
+        
+        with patch('chuk_tool_processor.mcp.register_mcp_tools.ToolRegistryProvider.get_registry', return_value=mock_registry):
+            registered = register_mcp_tools(mock_stream_manager)
+            
+            assert len(registered) == 0
+            assert mock_registry.register_tool.call_count == 0
+    
+    def test_duplicate_tool_names(self, mock_registry):
+        """Test registering tools with duplicate names."""
+        mock_stream_manager = Mock(spec=StreamManager)
+        tools = [
+            {"name": "echo", "description": "First echo"},
+            {"name": "echo", "description": "Second echo"}  # Duplicate
+        ]
+        mock_stream_manager.get_all_tools = Mock(return_value=tools)
+        
+        with patch('chuk_tool_processor.mcp.register_mcp_tools.ToolRegistryProvider.get_registry', return_value=mock_registry):
+            registered = register_mcp_tools(mock_stream_manager)
+            
+            # Should register both (last one overwrites)
+            assert len(registered) == 2  # Count includes duplicates
+            # Each tool is registered twice (once in mcp namespace, once in default namespace)
+            # But due to duplicates, we expect 4 calls total (2 tools x 2 namespaces)
+            assert mock_registry.register_tool.call_count == 4  # 2 tools x 2 namespaces

tests/mcp/test_register_mcp_tools.py

@@ -0,0 +1,63 @@
+# tests/mcp/test_setup_mcp_sse.py
+import pytest
+from unittest.mock import Mock, AsyncMock, patch
+
+from chuk_tool_processor.mcp.setup_mcp_sse import setup_mcp_sse
+from chuk_tool_processor.core.processor import ToolProcessor
+from chuk_tool_processor.mcp.stream_manager import StreamManager
+
+
+class TestSetupMCPSSE:
+    """Test MCP SSE setup function."""
+    
+    @pytest.mark.asyncio
+    async def test_setup_mcp_sse(self):
+        """Test complete MCP SSE setup."""
+        # Mock dependencies
+        mock_stream_manager = Mock(spec=StreamManager)
+        mock_processor = Mock(spec=ToolProcessor)
+        registered_tools = ["weather", "geocoding"]
+        
+        with patch('chuk_tool_processor.mcp.setup_mcp_sse.StreamManager.create_with_sse', 
+                   AsyncMock(return_value=mock_stream_manager)):
+            with patch('chuk_tool_processor.mcp.setup_mcp_sse.register_mcp_tools', 
+                       return_value=registered_tools):
+                with patch('chuk_tool_processor.mcp.setup_mcp_sse.ToolProcessor', 
+                           return_value=mock_processor):
+                    
+                    servers = [
+                        {"name": "weather", "url": "http://test.com"},
+                        {"name": "geocoding", "url": "http://geo.com"}
+                    ]
+                    
+                    processor, stream_manager = await setup_mcp_sse(
+                        servers=servers,
+                        namespace="remote",
+                        enable_caching=True
+                    )
+                    
+                    assert processor == mock_processor
+                    assert stream_manager == mock_stream_manager
+    
+    @pytest.mark.asyncio
+    async def test_setup_with_custom_options(self):
+        """Test setup with custom configuration options."""
+        with patch('chuk_tool_processor.mcp.setup_mcp_sse.StreamManager.create_with_sse', 
+                   AsyncMock()):
+            with patch('chuk_tool_processor.mcp.setup_mcp_sse.register_mcp_tools'):
+                with patch('chuk_tool_processor.mcp.setup_mcp_sse.ToolProcessor') as mock_processor_class:
+                    
+                    servers = [{"name": "test", "url": "http://test.com"}]
+                    
+                    await setup_mcp_sse(
+                        servers=servers,
+                        default_timeout=45.0,
+                        max_concurrency=10,
+                        cache_ttl=900,
+                        enable_rate_limiting=True,
+                        max_retries=10
+                    )
+                    
+                    # Verify ToolProcessor was created with correct options
+                    mock_processor_class.assert_called_once()
+                    call_kwargs = mock_processor_class

tests/mcp/test_setup_mcp_sse.py

@@ -0,0 +1,66 @@
+# tests/mcp/test_setup_mcp_stdio.py
+import pytest
+from unittest.mock import Mock, AsyncMock, patch
+
+from chuk_tool_processor.mcp.setup_mcp_stdio import setup_mcp_stdio
+from chuk_tool_processor.core.processor import ToolProcessor
+from chuk_tool_processor.mcp.stream_manager import StreamManager
+
+
+class TestSetupMCPStdio:
+    """Test MCP stdio setup function."""
+    
+    @pytest.mark.asyncio
+    async def test_setup_mcp_stdio(self):
+        """Test complete MCP stdio setup."""
+        # Mock dependencies
+        mock_stream_manager = Mock(spec=StreamManager)
+        mock_processor = Mock(spec=ToolProcessor)
+        registered_tools = ["echo", "calc"]
+        
+        with patch('chuk_tool_processor.mcp.setup_mcp_stdio.StreamManager.create', 
+                   AsyncMock(return_value=mock_stream_manager)):
+            with patch('chuk_tool_processor.mcp.setup_mcp_stdio.register_mcp_tools', 
+                       return_value=registered_tools):
+                with patch('chuk_tool_processor.mcp.setup_mcp_stdio.ToolProcessor', 
+                           return_value=mock_processor):
+                    
+                    processor, stream_manager = await setup_mcp_stdio(
+                        config_file="test.json",
+                        servers=["echo"],
+                        namespace="mcp",
+                        enable_caching=True,
+                        enable_retries=True
+                    )
+                    
+                    assert processor == mock_processor
+                    assert stream_manager == mock_stream_manager
+    
+    @pytest.mark.asyncio
+    async def test_setup_with_custom_options(self):
+        """Test setup with custom configuration options."""
+        with patch('chuk_tool_processor.mcp.setup_mcp_stdio.StreamManager.create', 
+                   AsyncMock()):
+            with patch('chuk_tool_processor.mcp.setup_mcp_stdio.register_mcp_tools'):
+                with patch('chuk_tool_processor.mcp.setup_mcp_stdio.ToolProcessor') as mock_processor_class:
+                    
+                    await setup_mcp_stdio(
+                        config_file="test.json",
+                        servers=["echo"],
+                        default_timeout=30.0,
+                        max_concurrency=5,
+                        cache_ttl=600,
+                        enable_rate_limiting=True,
+                        global_rate_limit=100,
+                        max_retries=5
+                    )
+                    
+                    # Verify ToolProcessor was created with correct options
+                    mock_processor_class.assert_called_once()
+                    call_kwargs = mock_processor_class.call_args.kwargs
+                    assert call_kwargs['default_timeout'] == 30.0
+                    assert call_kwargs['max_concurrency'] == 5
+                    assert call_kwargs['cache_ttl'] == 600
+                    assert call_kwargs['enable_rate_limiting'] is True
+                    assert call_kwargs['global_rate_limit'] == 100
+                    assert call_kwargs['max_retries'] == 5