mcp-proxy-adapter 2.1.17__py3-none-any.whl → 3.0.1__py3-none-any.whl

mcp_proxy_adapter/tests/integration/test_integration.py

@@ -0,0 +1,255 @@
+"""
+Integration tests for the mcp_microservice package.
+"""
+
+import pytest
+import json
+from typing import Dict, Any
+
+from fastapi.testclient import TestClient
+
+from mcp_proxy_adapter.commands.command_registry import registry
+from mcp_proxy_adapter.tests.stubs.echo_command import EchoCommand
+from mcp_proxy_adapter.api.app import create_app
+from mcp_proxy_adapter.config import Config
+
+
+@pytest.fixture
+def integration_config():
+    """
+    Fixture for integration test configuration.
+    
+    Returns:
+        Config instance for integration tests.
+    """
+    config = Config()
+    # Загружаем тестовую конфигурацию
+    config._config = {
+        "server": {
+            "host": "127.0.0.1",
+            "port": 8889
+        },
+        "logging": {
+            "level": "DEBUG",
+            "file": None
+        },
+        "auth_enabled": False,
+        "rate_limit_enabled": False
+    }
+    return config
+
+
+@pytest.fixture
+def integration_app(integration_config):
+    """
+    Fixture for integration test application.
+    
+    Args:
+        integration_config: Configuration for integration tests.
+        
+    Returns:
+        FastAPI application instance.
+    """
+    return create_app()
+
+
+@pytest.fixture
+def integration_client(integration_app):
+    """
+    Fixture for integration test client.
+    
+    Args:
+        integration_app: FastAPI application for integration tests.
+        
+    Returns:
+        FastAPI test client.
+    """
+    return TestClient(integration_app)
+
+
+@pytest.mark.integration
+def test_command_registry_with_api(integration_client, clean_registry):
+    """
+    Test integration between command registry and API.
+    
+    Args:
+        integration_client: FastAPI test client.
+        clean_registry: Fixture to clean registry before and after test.
+    """
+    # Register command
+    registry.register(EchoCommand)
+    
+    # Create JSON-RPC request
+    request_data = {
+        "jsonrpc": "2.0",
+        "method": "echo",
+        "params": {"test_key": "test_value"},
+        "id": "test-id"
+    }
+    
+    # Send request
+    response = integration_client.post("/api/jsonrpc", json=request_data)
+    
+    # Check response
+    assert response.status_code == 200
+    
+    # Check response structure
+    data = response.json()
+    assert "jsonrpc" in data and data["jsonrpc"] == "2.0"
+    assert "result" in data
+    assert "id" in data and data["id"] == request_data["id"]
+    
+    # Check result content
+    assert "params" in data["result"]
+    assert data["result"]["params"] == {"test_key": "test_value"}
+    
+    # Clean up
+    registry.clear()
+
+
+@pytest.mark.integration
+def test_command_execution_through_api(integration_client, clean_registry):
+    """
+    Test command execution through API with complex parameters.
+    
+    Args:
+        integration_client: FastAPI test client.
+        clean_registry: Fixture to clean registry before and after test.
+    """
+    # Register command
+    registry.register(EchoCommand)
+    
+    # Create JSON-RPC request with parameters
+    request_data = {
+        "jsonrpc": "2.0",
+        "method": "echo",
+        "params": {"complex_param": {"nested": "value", "array": [1, 2, 3]}},
+        "id": "test-id"
+    }
+    
+    # Send request
+    response = integration_client.post("/api/jsonrpc", json=request_data)
+    
+    # Check response
+    assert response.status_code == 200
+    
+    # Check response content
+    data = response.json()
+    assert "params" in data["result"]
+    assert data["result"]["params"]["complex_param"]["nested"] == "value"
+    assert data["result"]["params"]["complex_param"]["array"] == [1, 2, 3]
+    
+    # Clean up
+    registry.clear()
+
+
+@pytest.mark.integration
+def test_api_error_handling_with_command(integration_client, clean_registry):
+    """
+    Test API error handling with command errors.
+    
+    Args:
+        integration_client: FastAPI test client.
+        clean_registry: Fixture to clean registry before and after test.
+    """
+    # Register command
+    registry.register(EchoCommand)
+    
+    # Create JSON-RPC request with parameters
+    request_data = {
+        "jsonrpc": "2.0",
+        "method": "echo",
+        "params": {"test": "value"},
+        "id": "test-id"
+    }
+    
+    # Send request
+    response = integration_client.post("/api/jsonrpc", json=request_data)
+    
+    # Check response
+    assert response.status_code == 200
+    
+    # Clean up
+    registry.clear()
+
+
+@pytest.mark.integration
+def test_api_commands_endpoint_with_registry(integration_client, clean_registry):
+    """
+    Test API commands endpoint with loaded registry.
+    
+    Args:
+        integration_client: FastAPI test client.
+        clean_registry: Fixture to clean registry before and after test.
+    """
+    # Register command
+    registry.register(EchoCommand)
+    
+    # Get commands list
+    response = integration_client.get("/api/commands")
+    
+    # Check response
+    assert response.status_code == 200
+    
+    # Check response structure
+    data = response.json()
+    assert "commands" in data
+    assert isinstance(data["commands"], dict)
+    
+    # Check that echo command is in the list
+    assert "echo" in data["commands"]
+    assert "description" in data["commands"]["echo"]
+    
+    # Clean up
+    registry.clear()
+
+
+@pytest.mark.integration
+def test_batch_requests_integration(integration_client, clean_registry):
+    """
+    Test batch requests processing.
+    
+    Args:
+        integration_client: FastAPI test client.
+        clean_registry: Fixture to clean registry before and after test.
+    """
+    # Register command
+    registry.register(EchoCommand)
+    
+    # Create batch request
+    batch_request = [
+        {
+            "jsonrpc": "2.0",
+            "method": "echo",
+            "params": {"request_id": "1"},
+            "id": "1"
+        },
+        {
+            "jsonrpc": "2.0",
+            "method": "echo",
+            "params": {"request_id": "2"},
+            "id": "2"
+        }
+    ]
+    
+    # Send request
+    response = integration_client.post("/api/jsonrpc", json=batch_request)
+    
+    # Check response
+    assert response.status_code == 200
+    
+    # Check response structure
+    data = response.json()
+    assert isinstance(data, list)
+    assert len(data) == 2
+    
+    # Check individual responses
+    for i, resp in enumerate(data):
+        assert "jsonrpc" in resp and resp["jsonrpc"] == "2.0"
+        assert "result" in resp
+        assert "params" in resp["result"]
+        assert resp["result"]["params"]["request_id"] == str(i + 1)
+        assert resp["id"] == str(i + 1)
+    
+    # Clean up
+    registry.clear() 

mcp_proxy_adapter/tests/performance/__init__.py

@@ -0,0 +1,3 @@
+"""
+Performance tests for the mcp_microservice package.
+""" 

mcp_proxy_adapter/tests/performance/test_performance.py

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

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

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