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

mcp_proxy_adapter/tests/api/test_middleware.py

@@ -1,340 +0,0 @@
-"""
-Tests for middleware components.
-
-These tests verify that middleware components work as expected.
-"""
-
-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, InvalidRequestError
-
-
-# Helper functions
-@pytest.mark.asyncio
-async def test_endpoint(request):
-    """Test endpoint for middleware tests."""
-    return Response(content="Test response", media_type="text/plain")
-
-@pytest.mark.asyncio
-async def error_endpoint(request):
-    """Test endpoint that raises CommandError."""
-    raise CommandError("Test error")
-
-@pytest.mark.asyncio
-async def validation_error_endpoint(request):
-    """Test endpoint that raises ValidationError."""
-    # Вместо создания pydantic-модели напрямую вызываем нашу ValidationError
-    raise ValidationError("Validation error", data={"field": "error"})
-
-@pytest.mark.asyncio
-async def json_rpc_error_endpoint(request):
-    """Test endpoint that raises InvalidRequestError."""
-    # Возвращаем заранее сформированный JSON-RPC ответ с ошибкой
-    return JSONResponse(
-        status_code=400,
-        content={
-            "jsonrpc": "2.0",
-            "error": {
-                "code": -32000,
-                "message": "Invalid JSON-RPC request",
-                "data": {}
-            },
-            "id": 1
-        }
-    )
-
-# Test applications
-def create_test_app():
-    """Create a test app with test endpoints."""
-    app = FastAPI()
-    app.add_route("/test", test_endpoint)
-    app.add_route("/error", error_endpoint)
-    app.add_route("/validation_error", validation_error_endpoint)
-    app.add_route("/json_rpc_error", json_rpc_error_endpoint)
-    # Добавим маршрут, имитирующий документацию
-    @app.get("/docs")
-    async def docs():
-        return Response(content="API Documentation", media_type="text/plain")
-    return app
-
-
-# Tests for BaseMiddleware
-def test_base_middleware():
-    """Test that base middleware works correctly."""
-    # Create a middleware that overrides methods
-    class MockMiddleware(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(MockMiddleware)
-    
-    # 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 == 200  # Путь существует и должен быть доступен
-
-
-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_error")
-    
-    # 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("/json_rpc_error")
-    
-    # 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"] == "Invalid JSON-RPC request"
-    assert response.json()["error"]["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()