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

mcp_proxy_adapter/tests/api/test_middleware.py

@@ -0,0 +1,336 @@
+"""
+Tests for middleware components.
+"""
+
+import pytest
+from unittest.mock import patch, MagicMock, AsyncMock
+import json
+import time
+
+from fastapi import FastAPI, Request, Response
+from fastapi.testclient import TestClient
+from starlette.applications import Starlette
+from starlette.responses import JSONResponse
+from starlette.routing import Route
+
+from mcp_proxy_adapter.api.middleware.base import BaseMiddleware
+from mcp_proxy_adapter.api.middleware.logging import LoggingMiddleware
+from mcp_proxy_adapter.api.middleware.auth import AuthMiddleware
+from mcp_proxy_adapter.api.middleware.rate_limit import RateLimitMiddleware
+from mcp_proxy_adapter.api.middleware.error_handling import ErrorHandlingMiddleware
+from mcp_proxy_adapter.api.middleware.performance import PerformanceMiddleware
+from mcp_proxy_adapter.core.errors import MicroserviceError, CommandError, ValidationError
+
+
+# Helper functions
+@pytest.mark.asyncio
+async def test_endpoint(request):
+    """Test endpoint that returns a simple JSON response."""
+    return JSONResponse({"message": "test"})
+
+@pytest.mark.asyncio
+async def error_endpoint(request):
+    """Test endpoint that raises an error."""
+    # Используем новый формат JSON-RPC ошибки
+    raise CommandError("Test error")
+
+@pytest.mark.asyncio
+async def validation_error_endpoint(request):
+    """Test endpoint that raises a validation error."""
+    # Изменяем параметр details на data в соответствии с новой структурой
+    raise ValidationError("Validation error", data={"field": "error"})
+
+@pytest.mark.asyncio
+async def json_rpc_error_endpoint(request):
+    """Test endpoint that emulates JSON-RPC error handling."""
+    # Сразу возвращаем готовый JSON-RPC ответ с ошибкой
+    return JSONResponse(
+        status_code=400,
+        content={
+            "jsonrpc": "2.0",
+            "error": {
+                "code": -32000,  # JSON-RPC код ошибки
+                "message": "Test error",
+                "data": {"test": "data"}
+            },
+            "id": 1
+        }
+    )
+
+# Test applications
+def create_test_app():
+    """Create a test application with routes for testing."""
+    routes = [
+        Route("/test", test_endpoint),
+        Route("/error", error_endpoint),
+        Route("/validation", validation_error_endpoint),
+        Route("/api/jsonrpc", json_rpc_error_endpoint),
+    ]
+    return Starlette(routes=routes)
+
+
+# Tests for BaseMiddleware
+def test_base_middleware():
+    """Test that base middleware works correctly."""
+    # Create a middleware that overrides methods
+    class TestMiddleware(BaseMiddleware):
+        async def before_request(self, request):
+            request.state.before_called = True
+        
+        async def after_response(self, request, response):
+            response.headers["X-After-Called"] = "True"
+            return response
+    
+    # Create app with middleware
+    app = create_test_app()
+    app.add_middleware(TestMiddleware)
+    
+    # Test
+    client = TestClient(app)
+    response = client.get("/test")
+    
+    # Verify
+    assert response.status_code == 200
+    assert response.headers.get("X-After-Called") == "True"
+
+
+# Tests for LoggingMiddleware
+def test_logging_middleware():
+    """Test that logging middleware logs requests and responses."""
+    # Create app with middleware
+    app = create_test_app()
+    app.add_middleware(LoggingMiddleware)
+    
+    # Test
+    with patch("mcp_proxy_adapter.api.middleware.logging.RequestLogger") as mock_request_logger:
+        # Настраиваем мок для RequestLogger
+        mock_logger_instance = MagicMock()
+        mock_request_logger.return_value = mock_logger_instance
+        
+        client = TestClient(app)
+        response = client.get("/test")
+        
+        # Verify
+        assert response.status_code == 200
+        assert "X-Request-ID" in response.headers
+        assert "X-Process-Time" in response.headers
+        
+        # Check that RequestLogger was created and used
+        mock_request_logger.assert_called_once()
+        mock_logger_instance.info.assert_called()
+
+
+# Tests for AuthMiddleware
+def test_auth_middleware_no_api_key():
+    """Test that auth middleware blocks requests without API key."""
+    # Create app with middleware
+    app = create_test_app()
+    app.add_middleware(AuthMiddleware, api_keys={"valid-key": "test-user"}, auth_enabled=True)
+    
+    # Test
+    client = TestClient(app)
+    response = client.get("/test")
+    
+    # Verify
+    assert response.status_code == 401
+    assert "API key not provided" in response.text
+
+
+def test_auth_middleware_invalid_api_key():
+    """Test that auth middleware blocks requests with invalid API key."""
+    # Create app with middleware
+    app = create_test_app()
+    app.add_middleware(AuthMiddleware, api_keys={"valid-key": "test-user"}, auth_enabled=True)
+    
+    # Test
+    client = TestClient(app)
+    response = client.get("/test", headers={"X-API-Key": "invalid-key"})
+    
+    # Verify
+    assert response.status_code == 401
+    assert "Invalid API key" in response.text
+
+
+def test_auth_middleware_valid_api_key():
+    """Test that auth middleware allows requests with valid API key."""
+    # Create app with middleware
+    app = create_test_app()
+    app.add_middleware(AuthMiddleware, api_keys={"valid-key": "test-user"}, auth_enabled=True)
+    
+    # Test
+    client = TestClient(app)
+    response = client.get("/test", headers={"X-API-Key": "valid-key"})
+    
+    # Verify
+    assert response.status_code == 200
+
+
+def test_auth_middleware_public_path():
+    """Test that auth middleware allows requests to public paths."""
+    # Create app with middleware
+    app = create_test_app()
+    app.add_middleware(AuthMiddleware, api_keys={"valid-key": "test-user"}, auth_enabled=True)
+    
+    # Test
+    client = TestClient(app)
+    response = client.get("/docs")  # Public path
+    
+    # Verify
+    assert response.status_code == 404  # 404 because path doesn't exist, but auth should pass
+
+
+def test_auth_middleware_disabled():
+    """Test that auth middleware passes requests when disabled."""
+    # Create app with middleware but with auth_enabled=False
+    app = create_test_app()
+    app.add_middleware(AuthMiddleware, api_keys={"valid-key": "test-user"}, auth_enabled=False)
+    
+    # Test
+    client = TestClient(app)
+    response = client.get("/test")  # No API key provided
+    
+    # Verify
+    assert response.status_code == 200  # Should pass because auth is disabled
+
+
+# Tests for RateLimitMiddleware
+def test_rate_limit_middleware_exceeds_limit():
+    """Test that rate limit middleware blocks requests when limit is exceeded."""
+    # Create app with middleware (low limit for testing)
+    app = create_test_app()
+    app.add_middleware(RateLimitMiddleware, rate_limit=2, time_window=60)
+    
+    # Test
+    client = TestClient(app)
+    
+    # First two requests should pass
+    response1 = client.get("/test")
+    response2 = client.get("/test")
+    
+    # Third request should be rate limited
+    response3 = client.get("/test")
+    
+    # Verify
+    assert response1.status_code == 200
+    assert response2.status_code == 200
+    assert response3.status_code == 429
+    assert "Rate limit exceeded" in response3.text
+
+
+def test_rate_limit_middleware_public_path():
+    """Test that rate limit middleware allows requests to public paths regardless of limit."""
+    # Create app with middleware (low limit for testing)
+    app = create_test_app()
+    app.add_middleware(RateLimitMiddleware, rate_limit=1, time_window=60)
+    
+    # Test
+    client = TestClient(app)
+    
+    # First request to normal path should pass
+    response1 = client.get("/test")
+    
+    # Second request to normal path should be rate limited
+    response2 = client.get("/test")
+    
+    # Request to public path should pass despite rate limit
+    response3 = client.get("/health")  # Public path
+    
+    # Verify
+    assert response1.status_code == 200
+    assert response2.status_code == 429
+    assert response3.status_code == 404  # 404 because path doesn't exist, but rate limit should pass
+
+
+# Tests for ErrorHandlingMiddleware
+def test_error_handling_middleware_command_error():
+    """Test that error handling middleware formats command errors correctly."""
+    # Create app with middleware
+    app = create_test_app()
+    app.add_middleware(ErrorHandlingMiddleware)
+    
+    # Test
+    client = TestClient(app)
+    response = client.get("/error")
+    
+    # Verify
+    assert response.status_code == 400  # ErrorHandlingMiddleware возвращает 400 для CommandError
+    result = response.json()
+    # В новом формате JSON-RPC мы возвращаем непосредственно объект с code и message
+    assert "code" in result
+    assert "message" in result
+    assert result["code"] == -32000  # Код ошибки JSON-RPC
+    assert result["message"] == "Test error"
+
+
+def test_error_handling_middleware_validation_error():
+    """Test that error handling middleware formats validation errors correctly."""
+    # Create app with middleware
+    app = create_test_app()
+    app.add_middleware(ErrorHandlingMiddleware)
+    
+    # Test
+    client = TestClient(app)
+    response = client.get("/validation")
+    
+    # Verify
+    assert response.status_code == 400
+    result = response.json()
+    # В новом формате JSON-RPC мы возвращаем непосредственно объект с code и message
+    assert "code" in result
+    assert "message" in result
+    assert "data" in result
+    assert result["code"] == -32602  # Код InvalidParams JSON-RPC
+    assert result["message"] == "Validation error"
+    assert result["data"]["field"] == "error"
+
+
+def test_error_handling_middleware_jsonrpc_error():
+    """Test that error handling middleware formats JSON-RPC errors correctly."""
+    # Для этого теста мы используем прямой запрос к эндпоинту, который
+    # возвращает заранее сформированный JSON-RPC ответ с ошибкой
+    app = create_test_app()
+    client = TestClient(app)
+    
+    # Выполняем запрос к JSON-RPC эндпоинту
+    response = client.get("/api/jsonrpc")
+    
+    # Verify
+    assert response.status_code == 400
+    assert response.json()["jsonrpc"] == "2.0"
+    assert "error" in response.json()
+    assert response.json()["error"]["code"] == -32000  # Обновленный код JSON-RPC
+    assert response.json()["error"]["message"] == "Test error"
+    assert response.json()["error"]["data"] == {"test": "data"}  # data вместо details
+    assert response.json()["id"] == 1
+
+
+# Tests for PerformanceMiddleware
+@pytest.mark.asyncio
+async def test_performance_middleware():
+    """Test that performance middleware tracks request times."""
+    # Создаем middleware напрямую для тестирования
+    middleware = PerformanceMiddleware(None)
+    
+    # Создаем мок для запроса
+    mock_request = MagicMock()
+    mock_request.url.path = "/test"
+    
+    # Создаем мок для call_next
+    mock_response = JSONResponse({"message": "test"})
+    
+    async def mock_call_next(request):
+        return mock_response
+    
+    # Симуляция нескольких запросов без использования кастомного event loop
+    for _ in range(5):
+        response = await middleware.dispatch(mock_request, mock_call_next)
+        assert response == mock_response
+    
+    # Проверка, что времена запросов сохранены
+    assert "/test" in middleware.request_times
+    assert len(middleware.request_times["/test"]) == 5
+    
+    # Тестируем метод логирования статистики
+    with patch("mcp_proxy_adapter.api.middleware.performance.logger") as mock_logger:
+        middleware._log_stats()
+        mock_logger.info.assert_called() 

mcp_proxy_adapter/tests/commands/__init__.py

@@ -0,0 +1,3 @@
+"""
+Tests for commands package.
+""" 

mcp_proxy_adapter/tests/commands/test_config_command.py

@@ -0,0 +1,211 @@
+"""
+Unit tests for config command.
+"""
+
+import json
+import os
+import tempfile
+from typing import Generator
+
+import pytest
+
+from mcp_proxy_adapter.commands.config_command import ConfigCommand, ConfigResult
+from mcp_proxy_adapter.config import Config
+
+
+@pytest.fixture
+def temp_config_file() -> Generator[str, None, None]:
+    """
+    Creates temporary configuration file for tests.
+    
+    Returns:
+        Path to temporary configuration file.
+    """
+    # Create temporary file
+    fd, path = tempfile.mkstemp(suffix=".json")
+    
+    # Write test configuration
+    test_config = {
+        "server": {
+            "host": "127.0.0.1",
+            "port": 8000
+        },
+        "logging": {
+            "level": "DEBUG",
+            "file": "test.log"
+        },
+        "test_section": {
+            "test_key": "test_value",
+            "nested": {
+                "key1": "value1",
+                "key2": 42
+            }
+        }
+    }
+    
+    with os.fdopen(fd, "w") as f:
+        json.dump(test_config, f)
+    
+    yield path
+    
+    # Remove temporary file after tests
+    os.unlink(path)
+
+
+@pytest.mark.unit
+async def test_config_command_get_all(temp_config_file: str):
+    """
+    Test getting all configuration values.
+    
+    Args:
+        temp_config_file: Path to temporary configuration file.
+    """
+    # Create config instance with test file
+    config_instance = Config(temp_config_file)
+    
+    # Create command with this config
+    command = ConfigCommand()
+    
+    # Override the config instance used in the command
+    from mcp_proxy_adapter.commands import config_command
+    original_config = config_command.config_instance
+    config_command.config_instance = config_instance
+    
+    try:
+        # Execute command with get operation and no path
+        result = await command.execute(operation="get")
+        
+        # Check result
+        assert isinstance(result, ConfigResult)
+        result_dict = result.to_dict()
+        assert result_dict["success"] is True
+        assert "data" in result_dict
+        assert "config" in result_dict["data"]
+        assert "operation" in result_dict["data"]
+        assert result_dict["data"]["operation"] == "get"
+        
+        # Check all config values are present
+        config_data = result_dict["data"]["config"]
+        assert "server" in config_data
+        assert "logging" in config_data
+        assert "test_section" in config_data
+        
+        assert config_data["server"]["host"] == "127.0.0.1"
+        assert config_data["logging"]["level"] == "DEBUG"
+        assert config_data["test_section"]["test_key"] == "test_value"
+    finally:
+        # Restore original config instance
+        config_command.config_instance = original_config
+
+
+@pytest.mark.unit
+async def test_config_command_get_specific(temp_config_file: str):
+    """
+    Test getting specific configuration value.
+    
+    Args:
+        temp_config_file: Path to temporary configuration file.
+    """
+    # Create config instance with test file
+    config_instance = Config(temp_config_file)
+    
+    # Create command with this config
+    command = ConfigCommand()
+    
+    # Override the config instance used in the command
+    from mcp_proxy_adapter.commands import config_command
+    original_config = config_command.config_instance
+    config_command.config_instance = config_instance
+    
+    try:
+        # Execute command with get operation and specific path
+        result = await command.execute(operation="get", path="server.host")
+        
+        # Check result
+        assert isinstance(result, ConfigResult)
+        result_dict = result.to_dict()
+        assert result_dict["success"] is True
+        assert "data" in result_dict
+        assert "config" in result_dict["data"]
+        assert "operation" in result_dict["data"]
+        assert result_dict["data"]["operation"] == "get"
+        
+        # Check specific config value
+        config_data = result_dict["data"]["config"]
+        assert "server.host" in config_data
+        assert config_data["server.host"] == "127.0.0.1"
+    finally:
+        # Restore original config instance
+        config_command.config_instance = original_config
+
+
+@pytest.mark.unit
+async def test_config_command_set_value(temp_config_file: str):
+    """
+    Test setting configuration value.
+    
+    Args:
+        temp_config_file: Path to temporary configuration file.
+    """
+    # Create config instance with test file
+    config_instance = Config(temp_config_file)
+    
+    # Create command with this config
+    command = ConfigCommand()
+    
+    # Override the config instance used in the command
+    from mcp_proxy_adapter.commands import config_command
+    original_config = config_command.config_instance
+    config_command.config_instance = config_instance
+    
+    try:
+        # Execute command with set operation
+        result = await command.execute(
+            operation="set", 
+            path="server.host", 
+            value="localhost"
+        )
+        
+        # Check result
+        assert isinstance(result, ConfigResult)
+        result_dict = result.to_dict()
+        assert result_dict["success"] is True
+        assert "data" in result_dict
+        assert "config" in result_dict["data"]
+        assert "operation" in result_dict["data"]
+        assert result_dict["data"]["operation"] == "set"
+        
+        # Check updated config value
+        config_data = result_dict["data"]["config"]
+        assert "server.host" in config_data
+        assert config_data["server.host"] == "localhost"
+        
+        # Check that value was updated in config instance
+        assert config_instance.get("server.host") == "localhost"
+    finally:
+        # Restore original config instance
+        config_command.config_instance = original_config
+
+
+@pytest.mark.unit
+async def test_config_command_validate_schema():
+    """
+    Test validation schema for config command.
+    """
+    command = ConfigCommand()
+    schema = command.get_schema()
+    
+    # Check schema structure
+    assert schema["type"] == "object"
+    assert "properties" in schema
+    assert "operation" in schema["properties"]
+    assert "path" in schema["properties"]
+    assert "value" in schema["properties"]
+    
+    # Check operation property
+    operation_prop = schema["properties"]["operation"]
+    assert operation_prop["type"] == "string"
+    assert "enum" in operation_prop
+    assert "get" in operation_prop["enum"]
+    assert "set" in operation_prop["enum"]
+    assert operation_prop["default"] == "get" 

mcp_proxy_adapter/tests/commands/test_echo_command.py

@@ -0,0 +1,127 @@
+"""
+Tests for the echo command.
+"""
+
+import pytest
+import asyncio
+from typing import Dict, Any
+import json
+
+from mcp_proxy_adapter.tests.stubs.echo_command import EchoCommand
+from mcp_proxy_adapter.tests.stubs.echo_command import EchoResult
+
+
+@pytest.mark.unit
+def test_echo_command_execution():
+    """
+    Test execution of echo command.
+    """
+    # Create test parameters
+    test_params = {
+        "string_param": "test_value",
+        "int_param": 42,
+        "bool_param": True,
+        "complex_param": {"nested": "value", "array": [1, 2, 3]}
+    }
+    
+    # Create and execute command
+    command = EchoCommand()
+    result = asyncio.run(command.execute(**test_params))
+    
+    # Check result type
+    assert isinstance(result, EchoResult)
+    
+    # Check result content
+    assert result.params == test_params
+    assert result.params["string_param"] == "test_value"
+    assert result.params["int_param"] == 42
+    assert result.params["bool_param"] is True
+    assert result.params["complex_param"]["nested"] == "value"
+    assert result.params["complex_param"]["array"] == [1, 2, 3]
+
+
+@pytest.mark.unit
+def test_echo_result_serialization():
+    """
+    Test serialization of echo result.
+    """
+    # Create test parameters
+    test_params = {
+        "string_param": "test_value",
+        "int_param": 42,
+        "bool_param": True,
+        "complex_param": {"nested": "value", "array": [1, 2, 3]}
+    }
+    
+    # Create result
+    result = EchoResult(params=test_params)
+    
+    # Test to_dict method
+    result_dict = result.to_dict()
+    assert isinstance(result_dict, dict)
+    assert "params" in result_dict
+    assert result_dict["params"] == test_params
+    
+    # Test that result can be properly serialized to JSON
+    json_str = json.dumps(result_dict)
+    parsed_json = json.loads(json_str)
+    assert parsed_json == result_dict
+
+
+@pytest.mark.unit
+def test_echo_command_schema():
+    """
+    Test command schema generation.
+    """
+    # Get schema
+    schema = EchoCommand.get_schema()
+    
+    # Check schema structure
+    assert isinstance(schema, dict)
+    assert "type" in schema and schema["type"] == "object"
+    assert "additionalProperties" in schema and schema["additionalProperties"] is True
+    assert "description" in schema
+
+
+@pytest.mark.unit
+def test_echo_result_schema():
+    """
+    Test result schema generation.
+    """
+    # Get schema
+    schema = EchoResult.get_schema()
+    
+    # Check schema structure
+    assert isinstance(schema, dict)
+    assert "type" in schema and schema["type"] == "object"
+    assert "properties" in schema
+    assert "params" in schema["properties"]
+    assert "required" in schema and "params" in schema["required"]
+    assert schema["properties"]["params"]["type"] == "object"
+    assert schema["properties"]["params"]["additionalProperties"] is True
+
+
+@pytest.mark.unit
+def test_echo_result_from_dict():
+    """
+    Test creating result from dictionary.
+    """
+    # Create test data
+    test_data = {
+        "params": {
+            "key1": "value1",
+            "key2": 42
+        }
+    }
+    
+    # Create result from dict
+    result = EchoResult.from_dict(test_data)
+    
+    # Check result
+    assert isinstance(result, EchoResult)
+    assert result.params == test_data["params"]
+    
+    # Test with empty params
+    empty_result = EchoResult.from_dict({})
+    assert isinstance(empty_result, EchoResult)
+    assert empty_result.params == {}