mcp-proxy-adapter 6.0.0__py3-none-any.whl → 6.1.0__py3-none-any.whl

mcp_proxy_adapter/tests/test_api_handlers.py

@@ -1,289 +0,0 @@
-"""
-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

@@ -1,123 +0,0 @@
-"""
-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 MockCommand(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 CommandClassTests:
-    """Test command class."""
-    
-    @pytest.mark.asyncio
-    async def test_execute(self):
-        """Test execute method."""
-        command = MockCommand()
-        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 MockCommand.run(value="test_value")
-        assert isinstance(result, MockResultClass)
-        assert result.value == "test_value"
-    
-    def test_get_schema(self):
-        """Test get_schema method."""
-        schema = MockCommand.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 = MockCommand.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 = MockCommand.get_param_info()
-        assert "value" in params
-        assert params["value"]["required"] is False
-        assert params["value"]["default"] == "default" 

mcp_proxy_adapter/tests/test_batch_requests.py

@@ -1,117 +0,0 @@
-"""
-Tests for JSON-RPC batch requests handling.
-"""
-
-import pytest
-from typing import Dict, Any, List
-from unittest.mock import AsyncMock, patch, MagicMock
-
-from mcp_proxy_adapter.api.handlers import handle_json_rpc, handle_batch_json_rpc
-from mcp_proxy_adapter.commands.result import SuccessResult
-from mcp_proxy_adapter.core.errors import NotFoundError, MicroserviceError
-
-
-@pytest.fixture
-def success_result():
-    """Fixture for test success result."""
-    result = SuccessResult(data={"key": "value"}, message="Success")
-    return result
-
-
-class TestBatchJsonRpc:
-    """Tests for JSON-RPC batch requests handling."""
-    
-    @pytest.mark.asyncio
-    @patch("mcp_proxy_adapter.api.handlers.handle_json_rpc")
-    async def test_batch_request_processing(self, mock_handle_json_rpc):
-        """Test handling of batch requests."""
-        # Setup handle_json_rpc mock to return different responses
-        mock_handle_json_rpc.side_effect = [
-            # First request - success
-            {
-                "jsonrpc": "2.0",
-                "result": {"key1": "value1"},
-                "id": "1"
-            },
-            # Second request - error
-            {
-                "jsonrpc": "2.0",
-                "error": {
-                    "code": -32601,
-                    "message": "Method not found"
-                },
-                "id": "2"
-            },
-            # Third request - success
-            {
-                "jsonrpc": "2.0",
-                "result": {"key3": "value3"},
-                "id": "3"
-            }
-        ]
-        
-        # Create batch request
-        batch_request = [
-            {"jsonrpc": "2.0", "method": "method1", "params": {"p1": "v1"}, "id": "1"},
-            {"jsonrpc": "2.0", "method": "non_existent", "id": "2"},
-            {"jsonrpc": "2.0", "method": "method3", "params": {"p3": "v3"}, "id": "3"}
-        ]
-        
-        # Process batch request
-        responses = await handle_batch_json_rpc(batch_request)
-        
-        # Assertions
-        assert len(responses) == 3
-        assert mock_handle_json_rpc.call_count == 3
-        
-        # Check first response
-        assert responses[0]["jsonrpc"] == "2.0"
-        assert responses[0]["result"] == {"key1": "value1"}
-        assert responses[0]["id"] == "1"
-        
-        # Check second response (error)
-        assert responses[1]["jsonrpc"] == "2.0"
-        assert responses[1]["error"]["code"] == -32601
-        assert responses[1]["id"] == "2"
-        
-        # Check third response
-        assert responses[2]["jsonrpc"] == "2.0"
-        assert responses[2]["result"] == {"key3": "value3"}
-        assert responses[2]["id"] == "3"
-    
-    @pytest.mark.asyncio
-    @patch("mcp_proxy_adapter.api.handlers.handle_json_rpc")
-    async def test_empty_batch_request(self, mock_handle_json_rpc):
-        """Test handling of empty batch request."""
-        # Create empty batch request
-        batch_request = []
-        
-        # Process batch request
-        responses = await handle_batch_json_rpc(batch_request)
-        
-        # Assertions
-        assert len(responses) == 0
-        assert mock_handle_json_rpc.call_count == 0
-    
-    @pytest.mark.asyncio
-    @patch("mcp_proxy_adapter.api.handlers.execute_command")
-    async def test_end_to_end_batch_processing(self, mock_execute_command, success_result):
-        """Test end-to-end processing of batch requests."""
-        # Setup execute_command mock
-        mock_execute_command.return_value = success_result.to_dict()
-        
-        # Create batch request
-        batch_request = [
-            {"jsonrpc": "2.0", "method": "method1", "params": {"p1": "v1"}, "id": "1"},
-            {"jsonrpc": "2.0", "method": "method2", "params": {"p2": "v2"}, "id": "2"}
-        ]
-        
-        # Process batch request
-        responses = await handle_batch_json_rpc(batch_request)
-        
-        # Assertions
-        assert len(responses) == 2
-        for response in responses:
-            assert response["jsonrpc"] == "2.0"
-            assert "result" in response
-            assert "error" not in response