mcp-proxy-adapter 2.1.0__py3-none-any.whl → 2.1.1__py3-none-any.whl

tests/test_adapter_coverage.py

@@ -0,0 +1,274 @@
+"""
+Tests for MCPProxyAdapter code coverage.
+"""
+import sys
+import os
+import pytest
+import json
+import logging
+from unittest.mock import MagicMock, patch
+from typing import Dict, Any, List, Optional
+
+# Add parent directory to path for imports
+current_dir = os.path.dirname(os.path.abspath(__file__))
+parent_dir = os.path.dirname(current_dir)
+if parent_dir not in sys.path:
+    sys.path.insert(0, parent_dir)
+
+# Import tested modules
+try:
+    from mcp_proxy_adapter.adapter import MCPProxyAdapter, CommandRegistry
+    from mcp_proxy_adapter.models import JsonRpcRequest, JsonRpcResponse, MCPProxyConfig
+except ImportError:
+    from src.adapter import MCPProxyAdapter, CommandRegistry
+    from src.models import JsonRpcRequest, JsonRpcResponse, MCPProxyConfig
+
+from fastapi import FastAPI
+from fastapi.testclient import TestClient
+
+# Mock for command dispatcher
+class MockDispatcher:
+    """Mock for command dispatcher in tests."""
+    
+    def __init__(self):
+        self.commands = {
+            "success": lambda value=1: {"result": value * 2},
+            "error": lambda: exec('raise ValueError("Test error")'),
+            "execute": self.execute_from_params
+        }
+        self.commands_info = {
+            "success": {
+                "description": "Successful command",
+                "params": {
+                    "value": {
+                        "type": "integer",
+                        "description": "Input value",
+                        "required": False,
+                        "default": 1
+                    }
+                }
+            },
+            "error": {
+                "description": "Command with error",
+                "params": {}
+            },
+            "execute": {
+                "description": "Universal command for executing other commands",
+                "params": {
+                    "query": {
+                        "type": "string",
+                        "description": "Command or query to execute",
+                        "required": False
+                    }
+                }
+            }
+        }
+    
+    def execute_from_params(self, **params):
+        """Executes command based on parameters."""
+        if "query" in params and params["query"] in self.commands:
+            command = params.pop("query")
+            return self.execute(command, **params)
+        return {
+            "available_commands": self.get_valid_commands(),
+            "received_params": params
+        }
+    
+    def execute(self, command, **params):
+        """Executes command with specified parameters."""
+        if command not in self.commands:
+            raise KeyError(f"Unknown command: {command}")
+        return self.commands[command](**params)
+    
+    def get_valid_commands(self):
+        """Returns list of available commands."""
+        return list(self.commands.keys())
+    
+    def get_command_info(self, command):
+        """Returns information about command."""
+        return self.commands_info.get(command)
+    
+    def get_commands_info(self):
+        """Returns information about all commands."""
+        return self.commands_info
+
+# Mock for CommandRegistry
+class MockRegistry:
+    """Mock for CommandRegistry in tests."""
+    
+    def __init__(self):
+        self.dispatcher = MockDispatcher()
+        self.generators = []
+    
+    def get_commands_info(self):
+        """Returns command information from dispatcher."""
+        return self.dispatcher.get_commands_info()
+    
+    def add_generator(self, generator):
+        """Adds API generator."""
+        self.generators.append(generator)
+
+# Tests targeting uncovered code sections in adapter.py
+def test_openapi_generator_import_error():
+    """Test for simulating OpenApiGenerator import error situation."""
+    # Use more specific patch for OpenApiGenerator import
+    with patch('mcp_proxy_adapter.adapter.OpenApiGenerator', side_effect=ImportError("Mocked import error")):
+        registry = MockRegistry()
+        adapter = MCPProxyAdapter(registry)
+        
+        # Check that adapter was created and works even without OpenApiGenerator
+        assert adapter.openapi_generator is None
+        
+        # Create application and check functionality
+        app = FastAPI()
+        adapter.register_endpoints(app)
+        client = TestClient(app)
+        
+        # Check that API commands work
+        response = client.get("/api/commands")
+        assert response.status_code == 200
+        assert "commands" in response.json()
+
+def test_protocol_errors():
+    """Test for working with disabled schema."""
+    registry = MockRegistry()
+    
+    # Test without schema inclusion
+    adapter = MCPProxyAdapter(registry, include_schema=False, optimize_schema=False)
+    
+    # Check that adapter has no OpenAPI schema endpoint
+    # For this we look at router routes
+    routes = [route for route in adapter.router.routes if hasattr(route, 'path')]
+    openapi_routes = [route for route in routes if route.path == "/openapi.json"]
+    
+    # Make sure OpenAPI route is absent
+    assert len(openapi_routes) == 0
+
+def test_api_endpoints():
+    """Test for checking API endpoints."""
+    registry = MockRegistry()
+    adapter = MCPProxyAdapter(registry)
+    
+    app = FastAPI()
+    adapter.register_endpoints(app)
+    client = TestClient(app)
+    
+    # Check /api/commands endpoint
+    response = client.get("/api/commands")
+    assert response.status_code == 200
+    data = response.json()
+    assert "commands" in data
+
+def test_exception_handling():
+    """Test for handling exceptions during command execution."""
+    registry = MockRegistry()
+    adapter = MCPProxyAdapter(registry)
+    
+    app = FastAPI()
+    adapter.register_endpoints(app)
+    client = TestClient(app)
+    
+    # Test error during JSON parsing
+    response = client.post("/cmd", content="invalid json")
+    assert response.status_code == 200
+    data = response.json()
+    assert "error" in data
+    assert "Invalid JSON format" in data["error"]["message"]
+
+def test_mcp_proxy_format():
+    """Test for checking MCP Proxy format."""
+    registry = MockRegistry()
+    adapter = MCPProxyAdapter(registry)
+    
+    app = FastAPI()
+    adapter.register_endpoints(app)
+    client = TestClient(app)
+    
+    # Test MCP Proxy format
+    response = client.post("/cmd", json={
+        "command": "success",
+        "params": {"value": 10}
+    })
+    
+    assert response.status_code == 200
+    data = response.json()
+    assert "result" in data
+    assert data["result"] == {"result": 20}
+
+def test_query_subcommand():
+    """Test for extracting command from query with / separator."""
+    registry = MockRegistry()
+    adapter = MCPProxyAdapter(registry)
+    
+    # Patch execute method for test
+    registry.dispatcher.execute = MagicMock(return_value={"subcommand_executed": True})
+    
+    app = FastAPI()
+    adapter.register_endpoints(app)
+    client = TestClient(app)
+    
+    # Test command extraction from query with / separator
+    response = client.post("/cmd", json={
+        "params": {"query": "success/subcommand"}
+    })
+    
+    assert response.status_code == 200
+    registry.dispatcher.execute.assert_called_once()
+
+def test_only_params_with_command():
+    """Test for request with only params containing command."""
+    registry = MockRegistry()
+    adapter = MCPProxyAdapter(registry)
+    
+    app = FastAPI()
+    adapter.register_endpoints(app)
+    client = TestClient(app)
+    
+    # Test request with command in params
+    response = client.post("/cmd", json={
+        "params": {"command": "success", "value": 15}
+    })
+    
+    assert response.status_code == 200
+    data = response.json()
+    assert "result" in data
+    assert data["result"] == {"result": 30}
+
+def test_error_responses():
+    """Test for checking response formats for different errors."""
+    registry = MockRegistry()
+    adapter = MCPProxyAdapter(registry)
+    
+    app = FastAPI()
+    adapter.register_endpoints(app)
+    client = TestClient(app)
+    
+    # Test unknown command
+    response = client.post("/cmd", json={
+        "command": "unknown",
+        "params": {}
+    })
+    
+    assert response.status_code == 200
+    data = response.json()
+    assert "error" in data
+    assert "Unknown command" in data["error"]["message"]
+
+def test_register_endpoints_order():
+    """Test for checking order of endpoint registration."""
+    registry = MockRegistry()
+    adapter = MCPProxyAdapter(registry)
+    
+    # Create mock for router and include_router
+    app = FastAPI()
+    original_include_router = app.include_router
+    app.include_router = MagicMock()
+    
+    # Register endpoints
+    adapter.register_endpoints(app)
+    
+    # Check that include_router was called
+    app.include_router.assert_called_once()
+    
+    # Restore original method
+    app.include_router = original_include_router 

tests/test_basic_dispatcher.py

@@ -0,0 +1,169 @@
+"""
+Tests for basic command dispatcher functionality.
+"""
+import sys
+import os
+import pytest
+from typing import Dict, Any, List
+
+# Add parent directory to path for imports
+current_dir = os.path.dirname(os.path.abspath(__file__))
+parent_dir = os.path.dirname(current_dir)
+if parent_dir not in sys.path:
+    sys.path.insert(0, parent_dir)
+
+# Import classes for testing
+from mcp_proxy_adapter.dispatchers.json_rpc_dispatcher import JsonRpcDispatcher, CommandNotFoundError, CommandExecutionError
+
+# Fixture for creating dispatcher with test commands
+@pytest.fixture
+def test_dispatcher():
+    """Creates dispatcher with test commands"""
+    dispatcher = JsonRpcDispatcher()
+    
+    # Test command with parameters
+    def test_command(a: int, b: int = 1) -> int:
+        """
+        Test command for adding two numbers.
+        
+        Args:
+            a: First number
+            b: Second number (default 1)
+            
+        Returns:
+            int: Sum of numbers
+        """
+        return a + b
+    
+    # Command for error testing
+    def error_command(message: str = "Test error") -> None:
+        """
+        Command for testing error handling.
+        
+        Args:
+            message: Error message
+            
+        Raises:
+            ValueError: Always raises error
+        """
+        raise ValueError(message)
+    
+    # Command accepting params dictionary
+    def params_command(params: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Command for testing passing all parameters in dictionary.
+        
+        Args:
+            params: Parameters dictionary
+            
+        Returns:
+            Dict[str, Any]: Same parameters dictionary
+        """
+        return params
+    
+    # Register commands
+    dispatcher.register_handler(
+        command="test",
+        handler=test_command,
+        description="Test command for adding numbers",
+        params={
+            "a": {"type": "integer", "description": "First number", "required": True},
+            "b": {"type": "integer", "description": "Second number", "required": False, "default": 1}
+        }
+    )
+    
+    dispatcher.register_handler(
+        command="error",
+        handler=error_command,
+        description="Command for testing errors",
+        params={
+            "message": {"type": "string", "description": "Error message", "required": False}
+        }
+    )
+    
+    dispatcher.register_handler(
+        command="params",
+        handler=params_command,
+        description="Command for testing params passing",
+        params={}
+    )
+    
+    return dispatcher
+
+def test_dispatcher_initialization():
+    """Test dispatcher initialization"""
+    dispatcher = JsonRpcDispatcher()
+    
+    # Check that dispatcher contains built-in help command
+    assert "help" in dispatcher.get_valid_commands()
+    
+    # Check that help command metadata is correct
+    help_info = dispatcher.get_command_info("help")
+    assert help_info is not None
+    assert "description" in help_info
+    assert "summary" in help_info
+    assert "params" in help_info
+
+def test_register_and_execute_command(test_dispatcher):
+    """Test command registration and execution"""
+    # Check that command is registered
+    assert "test" in test_dispatcher.get_valid_commands()
+    
+    # Execute command with required parameter
+    result = test_dispatcher.execute("test", a=5)
+    assert result == 6  # 5 + 1 (default value)
+    
+    # Execute command with all parameters
+    result = test_dispatcher.execute("test", a=5, b=3)
+    assert result == 8  # 5 + 3
+
+def test_command_not_found(test_dispatcher):
+    """Test handling of non-existent command"""
+    with pytest.raises(CommandNotFoundError):
+        test_dispatcher.execute("non_existent_command")
+
+def test_command_execution_error(test_dispatcher):
+    """Test handling of error during command execution"""
+    with pytest.raises(CommandExecutionError):
+        test_dispatcher.execute("error")
+
+def test_get_commands_info(test_dispatcher):
+    """Test getting information about commands"""
+    commands_info = test_dispatcher.get_commands_info()
+    
+    # Check presence of all registered commands
+    assert "test" in commands_info
+    assert "error" in commands_info
+    assert "params" in commands_info
+    assert "help" in commands_info
+    
+    # Check presence of all fields in command information
+    test_info = commands_info["test"]
+    assert "description" in test_info
+    assert "summary" in test_info
+    assert "params" in test_info
+
+def test_params_command(test_dispatcher):
+    """Test command accepting params dictionary"""
+    test_params = {"key1": "value1", "key2": 123}
+    result = test_dispatcher.execute("params", **test_params)
+    assert result == test_params
+
+def test_help_command(test_dispatcher):
+    """Test built-in help command"""
+    # Request list of all commands
+    result = test_dispatcher.execute("help")
+    assert "commands" in result
+    assert "total" in result
+    assert result["total"] == 4  # help, test, error, params
+    
+    # Run second check through different approach - compare command list
+    assert "help" in result["commands"]
+    assert "test" in result["commands"]
+    assert "error" in result["commands"]
+    assert "params" in result["commands"]
+    
+    # Check that command data contains required fields
+    assert "summary" in result["commands"]["test"]
+    assert "description" in result["commands"]["test"]
+    assert "params_count" in result["commands"]["test"]