mcp-proxy-adapter 3.0.0__py3-none-any.whl → 3.0.2__py3-none-any.whl

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 == {} 

mcp_proxy_adapter/tests/commands/test_help_command.py

@@ -0,0 +1,133 @@
+"""
+Tests for the help command.
+"""
+
+import pytest
+from unittest.mock import patch, MagicMock
+
+from mcp_proxy_adapter.commands.help_command import HelpCommand, HelpResult
+from mcp_proxy_adapter.core.errors import NotFoundError
+
+
+@pytest.fixture
+def mock_registry():
+    """Mock for command registry."""
+    with patch("mcp_proxy_adapter.commands.help_command.registry") as mock_reg:
+        yield mock_reg
+
+
+async def test_help_command_without_params(mock_registry):
+    """Test help command without parameters."""
+    # Setup mocks
+    mock_registry.get_all_metadata.return_value = {
+        "help": {
+            "name": "help",
+            "summary": "Get help information",
+            "description": "Get help information",
+            "params": {},
+            "examples": []
+        },
+        "health": {
+            "name": "health",
+            "summary": "Check server health",
+            "description": "Check server health",
+            "params": {},
+            "examples": []
+        }
+    }
+    
+    # Execute command
+    command = HelpCommand()
+    result = await command.execute()
+    
+    # Check result
+    assert isinstance(result, HelpResult)
+    assert result.commands_info is not None
+    assert result.command_info is None
+    
+    # Check content
+    commands_dict = result.to_dict()
+    assert "commands" in commands_dict
+    assert "help" in commands_dict["commands"]
+    assert "health" in commands_dict["commands"]
+    assert "summary" in commands_dict["commands"]["help"]
+    assert "Get help information" in commands_dict["commands"]["help"]["summary"]
+
+
+async def test_help_command_with_cmdname(mock_registry):
+    """Test help command with cmdname parameter."""
+    # Setup mocks
+    mock_registry.get_command_metadata.return_value = {
+        "name": "health",
+        "description": "Check server health",
+        "summary": "Check server health",
+        "params": {
+            "check_type": {
+                "type": "string",
+                "description": "Type of health check",
+                "required": False,
+                "default": "basic"
+            }
+        },
+        "examples": []
+    }
+    
+    # Execute command
+    command = HelpCommand()
+    result = await command.execute(cmdname="health")
+    
+    # Check result
+    assert isinstance(result, HelpResult)
+    assert result.commands_info is None
+    assert result.command_info is not None
+    
+    # Check content
+    command_dict = result.to_dict()
+    assert "cmdname" in command_dict
+    assert command_dict["cmdname"] == "health"
+    assert "info" in command_dict
+    assert "description" in command_dict["info"]
+    assert "Check server health" in command_dict["info"]["description"]
+    assert "params" in command_dict["info"]
+    assert "check_type" in command_dict["info"]["params"]
+
+
+async def test_help_command_with_invalid_cmdname(mock_registry):
+    """Test help command with invalid cmdname parameter."""
+    # Setup mocks
+    mock_registry.get_command_metadata.side_effect = NotFoundError("Command not found")
+    
+    # Execute command and check exception
+    command = HelpCommand()
+    with pytest.raises(NotFoundError) as excinfo:
+        await command.execute(cmdname="non_existent")
+    
+    assert "not found" in str(excinfo.value)
+
+
+def test_help_result_schema():
+    """Test help command result schema."""
+    schema = HelpResult.get_schema()
+    
+    assert schema["type"] == "object"
+    assert "oneOf" in schema
+    assert len(schema["oneOf"]) == 2
+    
+    commands_schema = schema["oneOf"][0]
+    assert "properties" in commands_schema
+    assert "commands" in commands_schema["properties"]
+    
+    command_schema = schema["oneOf"][1]
+    assert "properties" in command_schema
+    assert "cmdname" in command_schema["properties"]
+    assert "info" in command_schema["properties"]
+
+
+def test_help_command_schema():
+    """Test help command schema."""
+    schema = HelpCommand.get_schema()
+    
+    assert schema["type"] == "object"
+    assert "properties" in schema
+    assert "cmdname" in schema["properties"]
+    assert schema["properties"]["cmdname"]["type"] == "string" 

mcp_proxy_adapter/tests/conftest.py

@@ -0,0 +1,131 @@
+"""
+Module with fixtures and configuration for tests.
+"""
+
+import json
+import os
+import tempfile
+from typing import Any, Dict, Generator
+
+import pytest
+from fastapi.testclient import TestClient
+
+from mcp_proxy_adapter.api.app import create_app
+from mcp_proxy_adapter.commands.command_registry import registry
+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": 8888
+        },
+        "logging": {
+            "level": "DEBUG",
+            "file": None
+        },
+        # Отключаем аутентификацию и ограничение скорости для тестов
+        "auth_enabled": False,
+        "rate_limit_enabled": False
+    }
+    
+    with os.fdopen(fd, "w") as f:
+        json.dump(test_config, f)
+    
+    yield path
+    
+    # Remove temporary file after tests
+    os.unlink(path)
+
+
+@pytest.fixture
+def test_config(temp_config_file: str) -> Config:
+    """
+    Creates test configuration instance.
+
+    Args:
+        temp_config_file: Path to temporary configuration file.
+
+    Returns:
+        Test configuration instance.
+    """
+    return Config(temp_config_file)
+
+
+@pytest.fixture
+def test_client() -> TestClient:
+    """
+    Creates test client for FastAPI application.
+
+    Returns:
+        FastAPI test client.
+    """
+    app = create_app()
+    return TestClient(app)
+
+
+@pytest.fixture
+def clean_registry() -> Generator[None, None, None]:
+    """
+    Cleans command registry before test and restores it after.
+
+    Yields:
+        None
+    """
+    # Save current commands
+    original_commands = dict(registry._commands)
+    
+    # Clear registry
+    registry.clear()
+    
+    yield
+    
+    # Restore registry
+    registry.clear()
+    for name, command in original_commands.items():
+        registry._commands[name] = command
+
+
+@pytest.fixture
+def json_rpc_request() -> Dict[str, Any]:
+    """
+    Creates base JSON-RPC request.
+
+    Returns:
+        Dictionary with JSON-RPC request data.
+    """
+    return {
+        "jsonrpc": "2.0",
+        "method": "test_command",
+        "params": {},
+        "id": "test-id"
+    }
+
+
+@pytest.fixture(autouse=True)
+def register_test_commands():
+    """
+    Регистрирует тестовые команды в registry для всех тестов.
+    """
+    from mcp_proxy_adapter.tests.stubs.echo_command import EchoCommand
+    from mcp_proxy_adapter.commands.command_registry import registry
+    
+    # Регистрируем команды для тестирования
+    registry.register(EchoCommand)
+    
+    yield
+    
+    # Очищаем registry после тестов
+    registry.clear()

mcp_proxy_adapter/tests/functional/__init__.py

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

mcp_proxy_adapter/tests/functional/test_api.py

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

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