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

mcp_proxy_adapter/tests/functional/test_api.py

@@ -1,253 +0,0 @@
-"""
-Functional tests for the API.
-"""
-
-import pytest
-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
-
-
-@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.functional
-def test_execute_command(test_client: TestClient, json_rpc_request: Dict[str, Any], register_echo_command):
-    """
-    Test execution of command via API.
-    
-    Args:
-        test_client: FastAPI test client.
-        json_rpc_request: Base JSON-RPC request.
-        register_echo_command: Fixture to register test command.
-    """
-    # Create JSON-RPC request
-    request_data = json_rpc_request.copy()
-    request_data["method"] = "echo"
-    request_data["params"] = {"test_key": "test_value"}
-    
-    # Send request
-    response = test_client.post("/api/jsonrpc", json=request_data)
-    
-    # Check response
-    assert response.status_code == 200
-    assert response.headers["content-type"] == "application/json"
-    
-    # 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"}
-
-
-@pytest.mark.functional
-def test_execute_nonexistent_command(test_client: TestClient, json_rpc_request: Dict[str, Any]):
-    """
-    Test execution of nonexistent command.
-    
-    Args:
-        test_client: FastAPI test client.
-        json_rpc_request: Base JSON-RPC request.
-    """
-    # Create JSON-RPC request with nonexistent command
-    request_data = json_rpc_request.copy()
-    request_data["method"] = "nonexistent_command"
-    
-    # Send request
-    response = test_client.post("/api/jsonrpc", json=request_data)
-    
-    # Check response
-    assert response.status_code == 400 or response.status_code == 200
-    
-    # Check response structure
-    data = response.json()
-    assert "jsonrpc" in data and data["jsonrpc"] == "2.0"
-    assert "error" in data
-    assert "id" in data and data["id"] == request_data["id"]
-    
-    # Check error content
-    assert "code" in data["error"]
-    assert "message" in data["error"]
-    assert data["error"]["code"] == -32601  # Method not found
-    assert "not found" in data["error"]["message"].lower()
-
-
-@pytest.mark.functional
-def test_invalid_json_rpc_request(test_client: TestClient):
-    """
-    Test invalid JSON-RPC request.
-    
-    Args:
-        test_client: FastAPI test client.
-    """
-    # Create invalid JSON-RPC request
-    request_data = {
-        "method": "echo",
-        "params": {}
-        # Missing jsonrpc and id fields
-    }
-    
-    # Send request
-    response = test_client.post("/api/jsonrpc", json=request_data)
-    
-    # Check response
-    assert response.status_code == 400 or response.status_code == 200
-    
-    # Check response structure
-    data = response.json()
-    assert "jsonrpc" in data and data["jsonrpc"] == "2.0"
-    assert "error" in data
-    
-    # Check error content
-    assert "code" in data["error"]
-    assert "message" in data["error"]
-    assert data["error"]["code"] == -32600  # Invalid Request
-
-
-@pytest.mark.functional
-def test_get_commands(test_client: TestClient, register_echo_command):
-    """
-    Test getting list of commands.
-    
-    Args:
-        test_client: FastAPI test client.
-        register_echo_command: Fixture to register test command.
-    """
-    # Send request
-    response = test_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"]
-    assert "schema" in data["commands"]["echo"]
-
-
-@pytest.mark.functional
-def test_health_check(test_client: TestClient):
-    """
-    Test health check endpoint.
-    
-    Args:
-        test_client: FastAPI test client.
-    """
-    # Send request
-    response = test_client.get("/health")
-    
-    # Check response
-    assert response.status_code == 200
-    
-    # Check response structure
-    data = response.json()
-    assert "status" in data
-    assert data["status"] == "ok"
-
-
-@pytest.mark.functional
-def test_openapi_schema(test_client: TestClient):
-    """
-    Test OpenAPI schema endpoint.
-    
-    Args:
-        test_client: FastAPI test client.
-    """
-    # Send request
-    response = test_client.get("/openapi.json")
-    
-    # Check response
-    assert response.status_code == 200
-    
-    # Check response content
-    data = response.json()
-    assert "openapi" in data
-    assert "info" in data
-    assert "paths" in data
-    
-    # Check that API endpoints are in schema
-    assert "/cmd" in data["paths"]
-    assert "/api/commands" in data["paths"]
-    assert "/health" in data["paths"]
-
-
-@pytest.mark.functional
-def test_batch_requests(test_client: TestClient, json_rpc_request: Dict[str, Any], register_echo_command):
-    """
-    Test batch requests processing.
-    
-    Args:
-        test_client: FastAPI test client.
-        json_rpc_request: Base JSON-RPC request.
-        register_echo_command: Fixture to register test command.
-    """
-    # Create batch request
-    request1 = json_rpc_request.copy()
-    request1["method"] = "echo"
-    request1["params"] = {"request_id": "1"}
-    request1["id"] = "1"
-    
-    request2 = json_rpc_request.copy()
-    request2["method"] = "echo"
-    request2["params"] = {"request_id": "2"}
-    request2["id"] = "2"
-    
-    batch_request = [request1, request2]
-    
-    # Send request
-    response = test_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
-    assert data[0]["result"]["params"] == {"request_id": "1"}
-    assert data[0]["id"] == "1"
-    
-    assert data[1]["result"]["params"] == {"request_id": "2"}
-    assert data[1]["id"] == "2"
-
-
-def test_custom_openapi_schema_fields():
-    """
-    Test that custom title, description, and version are set in the OpenAPI schema.
-    """
-    from fastapi import FastAPI
-    from mcp_proxy_adapter.custom_openapi import custom_openapi
-
-    app = FastAPI(
-        title="Custom Title",
-        description="Custom Description",
-        version="9.9.9"
-    )
-    schema = custom_openapi(app)
-    assert schema["info"]["title"] == "Custom Title"
-    assert schema["info"]["description"] == "Custom Description"
-    assert schema["info"]["version"] == "9.9.9" 

mcp_proxy_adapter/tests/integration/__init__.py

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

mcp_proxy_adapter/tests/integration/test_cmd_integration.py

@@ -1,129 +0,0 @@
-"""
-Integration tests for /cmd endpoint and help command.
-"""
-
-import pytest
-from fastapi.testclient import TestClient
-
-from mcp_proxy_adapter.api.app import app
-from mcp_proxy_adapter.commands.command_registry import registry
-from mcp_proxy_adapter.commands.help_command import HelpCommand
-
-
-@pytest.fixture(autouse=True)
-def setup_registry():
-    """Setup command registry for tests."""
-    # Store original commands
-    original_commands = dict(registry._commands)
-    
-    # Clear registry
-    registry._commands.clear()
-    
-    # Register help command
-    registry.register(HelpCommand)
-    
-    yield
-    
-    # Restore original commands
-    registry._commands.clear()
-    for name, command in original_commands.items():
-        registry._commands[name] = command
-
-
-@pytest.fixture
-def client():
-    """Test client for FastAPI app."""
-    return TestClient(app)
-
-
-def test_cmd_help_without_params(client):
-    """Test /cmd endpoint with help command without parameters."""
-    response = client.post(
-        "/cmd",
-        json={"command": "help"}
-    )
-    
-    assert response.status_code == 200
-    assert "result" in response.json()
-    result = response.json()["result"]
-    
-    assert "commands" in result
-    assert "help" in result["commands"]
-    assert "summary" in result["commands"]["help"]
-
-
-def test_cmd_help_with_cmdname(client):
-    """Test /cmd endpoint with help command with cmdname parameter."""
-    response = client.post(
-        "/cmd",
-        json={
-            "command": "help",
-            "params": {
-                "cmdname": "help"
-            }
-        }
-    )
-    
-    assert response.status_code == 200
-    assert "result" in response.json()
-    result = response.json()["result"]
-    
-    assert "cmdname" in result
-    assert result["cmdname"] == "help"
-    assert "info" in result
-    assert "description" in result["info"]
-    assert "params" in result["info"]
-    assert "cmdname" in result["info"]["params"]
-
-
-def test_cmd_help_unknown_command(client):
-    """Test /cmd endpoint with help command for unknown command."""
-    response = client.post(
-        "/cmd",
-        json={
-            "command": "help",
-            "params": {
-                "cmdname": "unknown_command"
-            }
-        }
-    )
-    
-    assert response.status_code == 200
-    assert "result" in response.json()
-    result = response.json()["result"]
-    
-    assert "error" in result
-    assert "example" in result
-    assert "note" in result
-    assert result["error"].startswith("Command")
-    assert result["example"]["command"] == "help"
-
-
-def test_cmd_unknown_command(client):
-    """Test /cmd endpoint with unknown command."""
-    response = client.post(
-        "/cmd",
-        json={"command": "unknown_command"}
-    )
-    
-    assert response.status_code == 200
-    assert "error" in response.json()
-    error = response.json()["error"]
-    
-    assert error["code"] == -32601
-    assert "не найдена" in error["message"]
-
-
-def test_cmd_invalid_request(client):
-    """Test /cmd endpoint with invalid request format."""
-    response = client.post(
-        "/cmd",
-        json={"invalid": "request"}
-    )
-    
-    assert response.status_code == 200
-    assert "error" in response.json()
-    error = response.json()["error"]
-    
-    assert error["code"] == -32600
-    assert "Отсутствует обязательное поле 'command'" in error["message"] 

mcp_proxy_adapter/tests/integration/test_integration.py

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

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