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

mcp_proxy_adapter/tests/performance/test_performance.py

@@ -1,189 +0,0 @@
-"""
-Performance tests for the API.
-"""
-
-import asyncio
-import time
-from typing import Dict, Any
-
-import pytest
-import pytest_asyncio
-from fastapi.testclient import TestClient
-from httpx import AsyncClient, ASGITransport
-
-from mcp_proxy_adapter.api.app import create_app
-from mcp_proxy_adapter.commands.command_registry import registry
-from mcp_proxy_adapter.tests.stubs.echo_command import EchoCommand
-
-
-@pytest_asyncio.fixture
-async def async_client(test_config):
-    """
-    Fixture for async HTTP client.
-    
-    Args:
-        test_config: Test configuration instance.
-        
-    Returns:
-        AsyncClient instance for making async requests.
-    """
-    app = create_app()
-    transport = ASGITransport(app=app)
-    async with AsyncClient(transport=transport, base_url="http://test") as client:
-        yield client
-
-
-@pytest.fixture
-def register_echo_command(clean_registry):
-    """
-    Fixture to register the Echo command for testing.
-    
-    Args:
-        clean_registry: Fixture to clean registry before and after test.
-    """
-    registry.register(EchoCommand)
-    yield
-    registry.clear()
-
-
-@pytest.mark.performance
-@pytest.mark.asyncio
-async def test_sequential_requests(async_client: AsyncClient, json_rpc_request: Dict[str, Any], 
-                                   register_echo_command):
-    """
-    Test sequential API requests performance.
-    
-    Args:
-        async_client: Async HTTP client.
-        json_rpc_request: Base JSON-RPC request.
-        register_echo_command: Fixture to register test command.
-    """
-    num_requests = 50
-    
-    # Create JSON-RPC request
-    request_data = json_rpc_request.copy()
-    request_data["method"] = "echo"
-    request_data["params"] = {"test": "value"}
-    
-    # Measure execution time
-    start_time = time.time()
-    
-    for i in range(num_requests):
-        response = await async_client.post("/api/jsonrpc", json=request_data)
-        assert response.status_code == 200
-    
-    end_time = time.time()
-    total_time = end_time - start_time
-    
-    # Calculate requests per second
-    rps = num_requests / total_time
-    
-    print(f"Sequential requests: {num_requests} requests in {total_time:.2f}s ({rps:.2f} req/s)")
-    
-    # Check that performance is within expected range
-    # This threshold should be adjusted based on actual performance measurements
-    assert rps > 30, f"Performance too low: {rps:.2f} req/s"
-
-
-@pytest.mark.performance
-@pytest.mark.asyncio
-async def test_concurrent_requests(async_client: AsyncClient, json_rpc_request: Dict[str, Any],
-                                  register_echo_command):
-    """
-    Test concurrent API requests performance.
-    
-    Args:
-        async_client: Async HTTP client.
-        json_rpc_request: Base JSON-RPC request.
-        register_echo_command: Fixture to register test command.
-    """
-    num_requests = 50
-    
-    # Create JSON-RPC request
-    request_data = json_rpc_request.copy()
-    request_data["method"] = "echo"
-    request_data["params"] = {"test": "value"}
-    
-    # Create task list
-    tasks = []
-    for i in range(num_requests):
-        task = asyncio.create_task(async_client.post("/api/jsonrpc", json=request_data))
-        tasks.append(task)
-    
-    # Measure execution time
-    start_time = time.time()
-    
-    # Wait for all tasks to complete
-    responses = await asyncio.gather(*tasks)
-    
-    end_time = time.time()
-    total_time = end_time - start_time
-    
-    # Check that all responses are successful
-    for response in responses:
-        assert response.status_code == 200
-    
-    # Calculate requests per second
-    rps = num_requests / total_time
-    
-    print(f"Concurrent requests: {num_requests} requests in {total_time:.2f}s ({rps:.2f} req/s)")
-    
-    # Check that performance is within expected range
-    # This threshold should be adjusted based on actual performance measurements
-    assert rps > 100, f"Concurrent performance too low: {rps:.2f} req/s"
-
-
-@pytest.mark.performance
-@pytest.mark.asyncio
-async def test_batch_requests_performance(async_client: AsyncClient, json_rpc_request: Dict[str, Any],
-                                         register_echo_command):
-    """
-    Test batch requests performance.
-    
-    Args:
-        async_client: Async HTTP client.
-        json_rpc_request: Base JSON-RPC request.
-        register_echo_command: Fixture to register test command.
-    """
-    num_batches = 10
-    batch_size = 5
-    
-    # Create base request
-    base_request = json_rpc_request.copy()
-    base_request["method"] = "echo"
-    base_request["params"] = {"test": "value"}
-    
-    # Prepare batch requests
-    batch_requests = []
-    for i in range(num_batches):
-        batch = []
-        for j in range(batch_size):
-            request = base_request.copy()
-            request["id"] = f"batch-{i}-{j}"
-            batch.append(request)
-        batch_requests.append(batch)
-    
-    # Measure execution time
-    start_time = time.time()
-    
-    # Execute batch requests
-    for batch in batch_requests:
-        response = await async_client.post("/api/jsonrpc", json=batch)
-        assert response.status_code == 200
-        
-        # Check response structure
-        data = response.json()
-        assert isinstance(data, list)
-        assert len(data) == batch_size
-    
-    end_time = time.time()
-    total_time = end_time - start_time
-    
-    # Calculate total requests and requests per second
-    total_requests = num_batches * batch_size
-    rps = total_requests / total_time
-    
-    print(f"Batch requests: {total_requests} requests in {total_time:.2f}s ({rps:.2f} req/s)")
-    
-    # Check that performance is within expected range
-    assert rps > 50, f"Batch performance too low: {rps:.2f} req/s" 

mcp_proxy_adapter/tests/stubs/__init__.py

@@ -1,10 +0,0 @@
-"""
-Test stub modules for framework tests.
-"""
-
-from mcp_proxy_adapter.tests.stubs.echo_command import EchoCommand, EchoResult
-
-__all__ = [
-    "EchoCommand",
-    "EchoResult"
-]

mcp_proxy_adapter/tests/stubs/echo_command.py

@@ -1,104 +0,0 @@
-"""
-Stub module for echo command tests.
-"""
-
-from typing import Any, Dict, Optional, ClassVar, Type
-
-from mcp_proxy_adapter.commands.base import Command
-from mcp_proxy_adapter.core.logging import logger
-
-
-class EchoResult:
-    """
-    Result of the echo command execution (stub for tests).
-    """
-    
-    def __init__(self, params: Dict[str, Any] = None):
-        """
-        Initialize echo result.
-        
-        Args:
-            params: Parameters to echo back.
-        """
-        self.params = params or {}
-    
-    def to_dict(self) -> Dict[str, Any]:
-        """
-        Convert result to dictionary.
-        
-        Returns:
-            Dict[str, Any]: Result as dictionary
-        """
-        return {"params": self.params}
-    
-    @classmethod
-    def get_schema(cls) -> Dict[str, Any]:
-        """
-        Get JSON schema for result validation.
-        
-        Returns:
-            Dict[str, Any]: JSON schema
-        """
-        return {
-            "type": "object",
-            "properties": {
-                "params": {
-                    "type": "object",
-                    "additionalProperties": True
-                }
-            },
-            "required": ["params"]
-        }
-        
-    @classmethod
-    def from_dict(cls, data: Dict[str, Any]) -> "EchoResult":
-        """
-        Creates result instance from dictionary.
-
-        Args:
-            data: Dictionary with result data.
-
-        Returns:
-            EchoResult instance.
-        """
-        return cls(
-            params=data.get("params", {})
-        )
-
-
-class EchoCommand(Command):
-    """
-    Test stub for echo command.
-    """
-    
-    name: ClassVar[str] = "echo"
-    result_class: ClassVar[Type[EchoResult]] = EchoResult
-    
-    @classmethod
-    def get_schema(cls) -> Dict[str, Any]:
-        """
-        Returns JSON schema for command parameters validation.
-        
-        Returns:
-            Dictionary with JSON schema.
-        """
-        return {
-            "type": "object",
-            "additionalProperties": True,
-            "description": "Any parameters will be echoed back in the response"
-        }
-    
-    async def execute(self, **kwargs) -> EchoResult:
-        """
-        Executes echo command and returns the parameters back.
-        
-        Args:
-            **kwargs: Any parameters to echo back.
-            
-        Returns:
-            EchoResult: Command execution result with the parameters.
-        """
-        logger.debug(f"Echo command received parameters: {kwargs}")
-        
-        # Simply return the parameters that were passed
-        return EchoResult(params=kwargs)

mcp_proxy_adapter/tests/test_api_endpoints.py

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