mcp-proxy-adapter 3.0.0__py3-none-any.whl → 3.0.2__py3-none-any.whl

mcp_proxy_adapter/tests/test_api_endpoints.py

@@ -0,0 +1,271 @@
+"""
+Tests for API endpoints.
+"""
+
+import pytest
+from typing import Dict, Any
+from unittest.mock import patch, MagicMock, AsyncMock
+from fastapi.testclient import TestClient
+import asyncio
+
+from mcp_proxy_adapter.api.app import create_app
+from mcp_proxy_adapter.commands.result import SuccessResult
+from mcp_proxy_adapter.core.errors import NotFoundError
+
+
+@pytest.fixture
+def client():
+    """Fixture for test client."""
+    # Создаем приложение с очищенным реестром команд для тестов
+    with patch("mcp_proxy_adapter.commands.registry.discover_commands"):  # Предотвращаем автообнаружение команд
+        app = create_app()
+        return TestClient(app)
+
+
+@pytest.fixture
+def success_result():
+    """Fixture for test success result."""
+    result = SuccessResult(data={"key": "value"}, message="Success")
+    return result
+
+
+class TestCommandsEndpoint:
+    """Tests for the /api/commands endpoint."""
+    
+    @patch("mcp_proxy_adapter.api.app.get_commands_list")
+    def test_commands_list_endpoint(self, mock_get_commands_list, client):
+        """Test getting list of available commands."""
+        # Create mock commands info
+        mock_commands_info = {
+            "command1": {
+                "name": "command1",
+                "description": "Test command 1",
+                "params": {},
+                "schema": {"type": "object"},
+                "result_schema": {"type": "object"}
+            },
+            "command2": {
+                "name": "command2",
+                "description": "Test command 2",
+                "params": {},
+                "schema": {"type": "object"},
+                "result_schema": {"type": "object"}
+            }
+        }
+        
+        # Setup mock для асинхронного метода
+        mock_get_commands_list.return_value = mock_commands_info
+        
+        # Get commands list
+        response = client.get("/api/commands")
+        
+        # Assertions
+        assert response.status_code == 200
+        assert response.json() == {"commands": mock_commands_info}
+        mock_get_commands_list.assert_called_once()
+
+
+class TestHealthEndpoint:
+    """Tests for the /health endpoint."""
+    
+    @patch("mcp_proxy_adapter.api.app.get_server_health")
+    def test_health_endpoint(self, mock_get_server_health, client):
+        """Test getting server health information."""
+        # Create mock health info
+        mock_health_info = {
+            "status": "ok",
+            "model": "mcp-proxy-adapter",
+            "version": "1.0.0"
+        }
+        
+        # Setup mock для асинхронного метода
+        mock_get_server_health.return_value = mock_health_info
+        
+        # Get health info
+        response = client.get("/health")
+        
+        # Assertions
+        assert response.status_code == 200
+        response_data = response.json()
+        assert "status" in response_data
+        assert response_data["status"] == "ok"
+        assert "version" in response_data
+
+
+class TestJsonRpcEndpoint:
+    """Tests for JSON-RPC endpoint."""
+    
+    @pytest.mark.asyncio
+    async def test_jsonrpc_endpoint_empty_batch(self, client):
+        """Test JSON-RPC endpoint handles empty batch requests."""
+        # Make request with empty array
+        response = client.post("/api/jsonrpc", json=[])
+        
+        # Assertions
+        assert response.status_code == 400
+        data = response.json()
+        assert data["jsonrpc"] == "2.0"
+        assert "error" in data
+        assert data["error"]["code"] == -32600
+        assert "Empty batch request" in data["error"]["message"]
+    
+    @pytest.mark.asyncio
+    @patch("mcp_proxy_adapter.commands.command_registry.registry.get_command")
+    async def test_handle_json_rpc_success(self, mock_get_command):
+        """Test handle_json_rpc function with success result."""
+        from mcp_proxy_adapter.commands.result import SuccessResult
+        
+        # Create mock command class
+        mock_command = MagicMock()
+        mock_command.run = AsyncMock(return_value=SuccessResult(
+            data={"status": "success"},
+            message="Success message"
+        ))
+        mock_get_command.return_value = mock_command
+        
+        # Create JSON-RPC request
+        request_data = {
+            "jsonrpc": "2.0",
+            "method": "test_command",
+            "params": {"param": "value"},
+            "id": "1"
+        }
+        
+        # Call handler directly
+        from mcp_proxy_adapter.api.handlers import handle_json_rpc
+        response = await handle_json_rpc(request_data)
+        
+        # Assertions
+        assert response["jsonrpc"] == "2.0"
+        assert "result" in response
+        assert response["result"]["data"]["status"] == "success"
+        assert response["id"] == "1"
+        mock_get_command.assert_called_once_with("test_command")
+        mock_command.run.assert_called_once_with(param="value")
+    
+    @pytest.mark.asyncio
+    async def test_handle_batch_json_rpc(self):
+        """Test handle_batch_json_rpc function."""
+        from mcp_proxy_adapter.api.handlers import handle_batch_json_rpc
+        
+        # Create mock for handle_json_rpc
+        with patch("mcp_proxy_adapter.api.handlers.handle_json_rpc") as mock_handle_json_rpc:
+            # Setup mock responses
+            mock_handle_json_rpc.side_effect = [
+                {"jsonrpc": "2.0", "result": {"status": "success1"}, "id": "1"},
+                {"jsonrpc": "2.0", "result": {"status": "success2"}, "id": "2"}
+            ]
+            
+            # Create batch request
+            batch_request = [
+                {"jsonrpc": "2.0", "method": "method1", "params": {}, "id": "1"},
+                {"jsonrpc": "2.0", "method": "method2", "params": {}, "id": "2"}
+            ]
+            
+            # Create mock request
+            mock_request = MagicMock()
+            mock_request.state.request_id = "test-request-id"
+            
+            # Call batch handler
+            responses = await handle_batch_json_rpc(batch_request, mock_request)
+            
+            # Assertions
+            assert len(responses) == 2
+            assert responses[0]["jsonrpc"] == "2.0"
+            assert responses[0]["result"]["status"] == "success1"
+            assert responses[0]["id"] == "1"
+            
+            assert responses[1]["jsonrpc"] == "2.0"
+            assert responses[1]["result"]["status"] == "success2"
+            assert responses[1]["id"] == "2"
+            
+            # Check mock calls
+            assert mock_handle_json_rpc.call_count == 2
+            mock_handle_json_rpc.assert_any_call(batch_request[0], "test-request-id")
+            mock_handle_json_rpc.assert_any_call(batch_request[1], "test-request-id")
+
+
+class TestCommandEndpoint:
+    """Tests for the /api/command/{command_name} endpoint."""
+    
+    @patch("mcp_proxy_adapter.api.app.execute_command")
+    def test_command_endpoint_success(self, mock_execute_command, client, success_result):
+        """Test direct command execution with success."""
+        # Create mock params and result
+        mock_params = {"param": "value"}
+        mock_result = success_result.to_dict()
+        
+        # Setup mock
+        mock_execute_command.return_value = mock_result
+        
+        # Execute command
+        response = client.post("/api/command/test_command", json=mock_params)
+        
+        # Assertions
+        assert response.status_code == 200
+        assert response.json() == mock_result
+        mock_execute_command.assert_called_once()
+    
+    @patch("mcp_proxy_adapter.api.app.execute_command")
+    def test_command_endpoint_error(self, mock_execute_command, client):
+        """Test direct command execution with error."""
+        # Create mock error
+        from mcp_proxy_adapter.core.errors import MicroserviceError
+        mock_error = MicroserviceError("Test error", code=400)
+        mock_error_dict = {"error": {"code": 400, "message": "Test error"}}
+        mock_error.to_dict = MagicMock(return_value=mock_error_dict)
+        
+        # Setup mock
+        mock_execute_command.side_effect = mock_error
+        
+        # Execute command
+        response = client.post("/api/command/test_command", json={})
+        
+        # Assertions
+        assert response.status_code == 400
+        assert response.json() == mock_error_dict
+        mock_execute_command.assert_called_once()
+
+
+class TestCommandInfoEndpoint:
+    """Tests for command info endpoint."""
+    
+    @patch("mcp_proxy_adapter.commands.command_registry.registry.get_command_info")
+    def test_command_info_endpoint_success(self, mock_get_command_info, client):
+        """Test command info endpoint returns command information."""
+        # Setup mock
+        mock_get_command_info.return_value = {
+            "name": "test_command",
+            "description": "Test command description",
+            "params": {"param1": {"type": "string"}},
+            "schema": {"properties": {"param1": {"type": "string"}}},
+            "result_schema": {"properties": {"key": {"type": "string"}}}
+        }
+        
+        # Make request
+        response = client.get("/api/commands/test_command")
+        
+        # Assertions
+        assert response.status_code == 200
+        data = response.json()
+        assert data["name"] == "test_command"
+        assert data["description"] == "Test command description"
+        assert "params" in data
+        assert "schema" in data
+        assert "result_schema" in data
+    
+    @patch("mcp_proxy_adapter.commands.command_registry.registry.get_command_info")
+    def test_command_info_endpoint_not_found(self, mock_get_command_info, client):
+        """Test command info endpoint returns 404 for non-existent command."""
+        # Setup mock to raise NotFoundError
+        mock_get_command_info.side_effect = NotFoundError("Command not found")
+        
+        # Make request
+        response = client.get("/api/commands/non_existent")
+        
+        # Assertions
+        assert response.status_code == 404
+        data = response.json()
+        assert "error" in data
+        assert data["error"]["code"] == 404
+        assert "Command 'non_existent' not found" in data["error"]["message"] 

mcp_proxy_adapter/tests/test_api_handlers.py

@@ -0,0 +1,289 @@
+"""
+Tests for API handlers.
+"""
+
+import json
+import pytest
+from typing import Dict, Any
+from unittest.mock import AsyncMock, patch, MagicMock
+
+from mcp_proxy_adapter.api.handlers import (
+    execute_command, handle_json_rpc, handle_batch_json_rpc,
+    get_server_health, get_commands_list
+)
+from mcp_proxy_adapter.commands.result import SuccessResult, ErrorResult
+from mcp_proxy_adapter.tests.stubs.echo_command import EchoResult
+from mcp_proxy_adapter.core.errors import (
+    ValidationError, CommandError, NotFoundError, MethodNotFoundError,
+    InvalidRequestError, ParseError, InternalError
+)
+
+
+@pytest.fixture
+def success_result():
+    """Fixture for test success result."""
+    result = SuccessResult(data={"key": "value"}, message="Success")
+    return result
+
+
+@pytest.fixture
+def error_result():
+    """Fixture for test error result."""
+    result = ErrorResult(message="Error message", code=400)
+    return result
+
+
+class TestExecuteCommand:
+    """Tests for execute_command function."""
+    
+    @pytest.mark.asyncio
+    async def test_execute_command_success(self):
+        """Test successful command execution."""
+        # Mock successful result
+        mock_result = EchoResult(params={"test_key": "test_value"})
+        
+        # Mock command class and registry
+        with patch("mcp_proxy_adapter.commands.command_registry.registry.get_command") as mock_get_command:
+            # Создаем асинхронную mock-функцию
+            mock_run = AsyncMock(return_value=mock_result)
+            mock_command_class = MagicMock()
+            # Присваиваем асинхронную функцию методу run
+            mock_command_class.run = mock_run
+            mock_get_command.return_value = mock_command_class
+            
+            # Execute command
+            result = await execute_command("test_command", {"param": "value"})
+            
+            # Assert command was called correctly
+            mock_get_command.assert_called_once_with("test_command")
+            mock_run.assert_called_once_with(param="value")
+            
+            # Assert result is as expected
+            assert result == mock_result.to_dict()
+    
+    @pytest.mark.asyncio
+    async def test_execute_command_not_found(self):
+        """Test command not found error."""
+        # Mock registry raising NotFoundError
+        with patch("mcp_proxy_adapter.commands.command_registry.registry.get_command") as mock_get_command:
+            mock_get_command.side_effect = NotFoundError("Command not found")
+            
+            # Execute command and expect MethodNotFoundError
+            with pytest.raises(MethodNotFoundError) as exc_info:
+                await execute_command("unknown_command", {})
+            
+            # Check error message
+            assert "Method not found" in str(exc_info.value)
+    
+    @pytest.mark.asyncio
+    async def test_execute_command_internal_error(self):
+        """Test internal error during command execution."""
+        # Mock registry raising an unexpected error
+        with patch("mcp_proxy_adapter.commands.command_registry.registry.get_command") as mock_get_command:
+            mock_get_command.side_effect = Exception("Unexpected error")
+            
+            # Execute command and expect InternalError
+            with pytest.raises(InternalError) as exc_info:
+                await execute_command("test_command", {})
+            
+            # Check error details
+            assert "Error executing command" in str(exc_info.value)
+            assert "original_error" in exc_info.value.data
+
+
+class TestHandleJsonRpc:
+    """Tests for handle_json_rpc function."""
+    
+    @pytest.mark.asyncio
+    async def test_handle_json_rpc_success(self):
+        """Test successful JSON-RPC request handling."""
+        # Mock execute_command
+        with patch("mcp_proxy_adapter.api.handlers.execute_command") as mock_execute:
+            # AsyncMock для асинхронной функции
+            mock_execute.return_value = {"result": "success"}
+            
+            # Create request data
+            request_data = {
+                "jsonrpc": "2.0",
+                "method": "test_command",
+                "params": {"param": "value"},
+                "id": 123
+            }
+            
+            # Handle request
+            response = await handle_json_rpc(request_data)
+            
+            # Assert command was executed
+            mock_execute.assert_called_once_with("test_command", {"param": "value"}, None)
+            
+            # Assert response format
+            assert response["jsonrpc"] == "2.0"
+            assert response["result"] == {"result": "success"}
+            assert response["id"] == 123
+    
+    @pytest.mark.asyncio
+    async def test_handle_json_rpc_invalid_version(self):
+        """Test invalid JSON-RPC version."""
+        # Create request with invalid version
+        request_data = {
+            "jsonrpc": "1.0",
+            "method": "test_command",
+            "id": 123
+        }
+        
+        # Handle request
+        response = await handle_json_rpc(request_data)
+        
+        # Assert error response
+        assert response["jsonrpc"] == "2.0"
+        assert response["error"]["code"] == -32600
+        assert "Invalid Request" in response["error"]["message"]
+        assert response["id"] == 123
+    
+    @pytest.mark.asyncio
+    async def test_handle_json_rpc_missing_method(self):
+        """Test missing method in JSON-RPC request."""
+        # Create request with missing method
+        request_data = {
+            "jsonrpc": "2.0",
+            "params": {},
+            "id": 123
+        }
+        
+        # Handle request
+        response = await handle_json_rpc(request_data)
+        
+        # Assert error response
+        assert response["jsonrpc"] == "2.0"
+        assert response["error"]["code"] == -32600
+        assert "Method is required" in response["error"]["message"]
+        assert response["id"] == 123
+    
+    @pytest.mark.asyncio
+    async def test_handle_json_rpc_microservice_error(self):
+        """Test microservice error during command execution."""
+        # Mock execute_command raising MicroserviceError
+        with patch("mcp_proxy_adapter.api.handlers.execute_command") as mock_execute:
+            mock_execute.side_effect = CommandError("Command failed", data={"reason": "test"})
+            
+            # Create request data
+            request_data = {
+                "jsonrpc": "2.0",
+                "method": "test_command",
+                "params": {},
+                "id": 123
+            }
+            
+            # Handle request
+            response = await handle_json_rpc(request_data)
+            
+            # Assert error response
+            assert response["jsonrpc"] == "2.0"
+            assert response["error"]["code"] == -32000
+            assert "Command failed" in response["error"]["message"]
+            assert response["error"]["data"]["reason"] == "test"
+            assert response["id"] == 123
+    
+    @pytest.mark.asyncio
+    async def test_handle_json_rpc_unhandled_error(self):
+        """Test unhandled error during command execution."""
+        # Mock execute_command raising unexpected error
+        with patch("mcp_proxy_adapter.api.handlers.execute_command") as mock_execute:
+            mock_execute.side_effect = Exception("Unexpected error")
+            
+            # Create request data
+            request_data = {
+                "jsonrpc": "2.0",
+                "method": "test_command",
+                "params": {},
+                "id": 123
+            }
+            
+            # Handle request
+            response = await handle_json_rpc(request_data)
+            
+            # Assert error response
+            assert response["jsonrpc"] == "2.0"
+            assert response["error"]["code"] == -32603
+            assert "Internal error" in response["error"]["message"]
+            assert "Unexpected error" in response["error"]["data"]["error"]
+            assert response["id"] == 123
+
+
+class TestHandleBatchJsonRpc:
+    """Tests for handle_batch_json_rpc function."""
+    
+    @pytest.mark.asyncio
+    async def test_handle_batch_json_rpc(self):
+        """Test batch JSON-RPC request handling."""
+        # Mock handle_json_rpc
+        with patch("mcp_proxy_adapter.api.handlers.handle_json_rpc") as mock_handle:
+            # AsyncMock для асинхронных результатов
+            mock_handle.side_effect = [
+                {"jsonrpc": "2.0", "result": "result1", "id": 1},
+                {"jsonrpc": "2.0", "result": "result2", "id": 2}
+            ]
+            
+            # Create batch request
+            batch_requests = [
+                {"jsonrpc": "2.0", "method": "method1", "id": 1},
+                {"jsonrpc": "2.0", "method": "method2", "id": 2}
+            ]
+            
+            # Handle batch request
+            responses = await handle_batch_json_rpc(batch_requests)
+            
+            # Assert responses
+            assert len(responses) == 2
+            assert responses[0]["result"] == "result1"
+            assert responses[1]["result"] == "result2"
+
+
+class TestGetServerHealth:
+    """Tests for get_server_health function."""
+    
+    @pytest.mark.asyncio
+    async def test_get_server_health(self):
+        """Test getting server health information."""
+        # Call server health function
+        result = await get_server_health()
+        
+        # Check basic structure and keys
+        assert "status" in result
+        assert result["status"] == "ok"
+        assert "version" in result
+        assert "uptime" in result
+        assert "components" in result
+        assert "system" in result["components"]
+        assert "process" in result["components"]
+        assert "commands" in result["components"]
+
+
+class TestGetCommandsList:
+    """Tests for get_commands_list function."""
+    
+    @pytest.mark.asyncio
+    async def test_get_commands_list(self):
+        """Test getting commands list."""
+        # Mock registry.get_all_commands
+        with patch("mcp_proxy_adapter.commands.command_registry.registry.get_all_commands") as mock_get_all:
+            # Create mock command class
+            mock_command = MagicMock()
+            mock_command.get_schema.return_value = {
+                "type": "object",
+                "description": "Test command description"
+            }
+            
+            # Setup mock to return test commands
+            mock_get_all.return_value = {
+                "test_command": mock_command
+            }
+            
+            # Call get_commands_list
+            result = await get_commands_list()
+            
+            # Check result structure
+            assert "test_command" in result
+            assert result["test_command"]["name"] == "test_command"
+            assert result["test_command"]["description"] == "Test command description"
+            assert result["test_command"]["schema"]["type"] == "object" 

mcp_proxy_adapter/tests/test_base_command.py

@@ -0,0 +1,123 @@
+"""
+Tests for command base classes.
+"""
+
+import pytest
+from typing import Dict, Any
+
+from mcp_proxy_adapter.commands.base import Command
+from mcp_proxy_adapter.commands.result import CommandResult, SuccessResult, ErrorResult
+
+
+class MockResultClass(CommandResult):
+    """Test result class for testing."""
+    
+    def __init__(self, value: str):
+        self.value = value
+    
+    def to_dict(self) -> Dict[str, Any]:
+        return {"value": self.value}
+    
+    @classmethod
+    def get_schema(cls) -> Dict[str, Any]:
+        return {
+            "type": "object",
+            "properties": {
+                "value": {"type": "string"}
+            },
+            "required": ["value"]
+        }
+
+
+class TestCommand(Command):
+    """Test command for testing."""
+    
+    name = "test_command"
+    result_class = MockResultClass
+    
+    async def execute(self, value: str = "default") -> MockResultClass:
+        return MockResultClass(value)
+    
+    @classmethod
+    def get_schema(cls) -> Dict[str, Any]:
+        return {
+            "type": "object",
+            "properties": {
+                "value": {"type": "string"}
+            },
+            "additionalProperties": False
+        }
+
+
+def test_success_result():
+    """Test success result class."""
+    result = SuccessResult(data={"key": "value"}, message="success message")
+    
+    # Test to_dict method
+    result_dict = result.to_dict()
+    assert result_dict["success"] is True
+    assert result_dict["data"] == {"key": "value"}
+    assert result_dict["message"] == "success message"
+    
+    # Test from_dict method
+    result2 = SuccessResult.from_dict(result_dict)
+    assert result2.data == {"key": "value"}
+    assert result2.message == "success message"
+
+
+def test_error_result():
+    """Test error result class."""
+    result = ErrorResult(message="error message", code=400, details={"field": "invalid"})
+    
+    # Test to_dict method
+    result_dict = result.to_dict()
+    assert result_dict["success"] is False
+    assert result_dict["error"]["code"] == 400
+    assert result_dict["error"]["message"] == "error message"
+    assert result_dict["error"]["data"] == {"field": "invalid"}
+    
+    # Test from_dict method
+    result2 = ErrorResult.from_dict(result_dict)
+    assert result2.message == "error message"
+    assert result2.code == 400
+    assert result2.details == {"field": "invalid"}
+
+
+class TestCommandClass:
+    """Test command class."""
+    
+    @pytest.mark.asyncio
+    async def test_execute(self):
+        """Test execute method."""
+        command = TestCommand()
+        result = await command.execute(value="test_value")
+        assert isinstance(result, MockResultClass)
+        assert result.value == "test_value"
+    
+    @pytest.mark.asyncio
+    async def test_run(self):
+        """Test run method (with validation)."""
+        result = await TestCommand.run(value="test_value")
+        assert isinstance(result, MockResultClass)
+        assert result.value == "test_value"
+    
+    def test_get_schema(self):
+        """Test get_schema method."""
+        schema = TestCommand.get_schema()
+        assert schema["type"] == "object"
+        assert "value" in schema["properties"]
+        assert schema["additionalProperties"] is False
+    
+    def test_get_result_schema(self):
+        """Test get_result_schema method."""
+        schema = TestCommand.get_result_schema()
+        assert schema["type"] == "object"
+        assert "value" in schema["properties"]
+        assert "value" in schema["required"]
+    
+    def test_get_param_info(self):
+        """Test get_param_info method."""
+        params = TestCommand.get_param_info()
+        assert "value" in params
+        assert params["value"]["required"] is False
+        assert params["value"]["default"] == "default"