mcp-proxy-adapter 2.1.2__py3-none-any.whl → 2.1.3__py3-none-any.whl

tests/test_schema.py

@@ -1,358 +0,0 @@
-"""
-Tests for SchemaOptimizer, checking OpenAPI schema optimization for MCP Proxy.
-"""
-import json
-import sys
-import os
-import pytest
-from typing import Dict, Any
-
-# Add path to source files
-project_root = os.path.abspath(os.path.join(os.path.dirname(__file__), '..'))
-sys.path.insert(0, os.path.join(project_root, 'src'))
-
-from mcp_proxy_adapter.schema import SchemaOptimizer
-
-# Test fixtures
-@pytest.fixture
-def base_schema() -> Dict[str, Any]:
-    """Returns base OpenAPI schema for tests."""
-    return {
-        "openapi": "3.0.2",
-        "info": {
-            "title": "Test API",
-            "description": "Test API for SchemaOptimizer",
-            "version": "1.0.0"
-        },
-        "paths": {
-            "/test": {
-                "get": {
-                    "summary": "Test endpoint",
-                    "description": "Test endpoint for SchemaOptimizer",
-                    "responses": {
-                        "200": {
-                            "description": "Successful response"
-                        }
-                    }
-                }
-            }
-        }
-    }
-
-@pytest.fixture
-def commands_info() -> Dict[str, Dict[str, Any]]:
-    """Returns command information for tests."""
-    return {
-        "test_command": {
-            "description": "Test command",
-            "params": {
-                "param1": {
-                    "type": "string",
-                    "description": "String parameter",
-                    "required": True
-                },
-                "param2": {
-                    "type": "integer",
-                    "description": "Numeric parameter",
-                    "required": False,
-                    "default": 42
-                },
-                "param3": {
-                    "type": "boolean",
-                    "description": "Boolean parameter",
-                    "required": False,
-                    "default": False
-                }
-            }
-        },
-        "no_params_command": {
-            "description": "Command without parameters",
-            "params": {}
-        },
-        "enum_params_command": {
-            "description": "Command with enumerations",
-            "params": {
-                "enum_param": {
-                    "type": "string",
-                    "description": "Enumeration parameter",
-                    "required": True,
-                    "enum": ["value1", "value2", "value3"]
-                }
-            }
-        },
-        "example_command": {
-            "description": "Command with example",
-            "params": {
-                "example_param": {
-                    "type": "string",
-                    "description": "Parameter with example",
-                    "required": True,
-                    "example": "example_value"
-                }
-            }
-        }
-    }
-
-# Tests for SchemaOptimizer
-def test_optimize_basic(base_schema, commands_info):
-    """Test basic schema optimization."""
-    optimizer = SchemaOptimizer()
-    cmd_endpoint = "/cmd"
-    
-    optimized = optimizer.optimize(base_schema, cmd_endpoint, commands_info)
-    
-    # Check basic structure
-    assert "openapi" in optimized
-    assert "info" in optimized
-    assert "paths" in optimized
-    assert cmd_endpoint in optimized["paths"]
-    assert "post" in optimized["paths"][cmd_endpoint]
-    
-    # Check presence of components
-    assert "components" in optimized
-    assert "schemas" in optimized["components"]
-    assert "CommandRequest" in optimized["components"]["schemas"]
-    assert "CommandResponse" in optimized["components"]["schemas"]
-    
-    # Check presence of parameter schemas for each command
-    for cmd_name in commands_info.keys():
-        param_schema_name = f"{cmd_name.capitalize()}Params"
-        assert param_schema_name in optimized["components"]["schemas"]
-
-def test_optimize_with_examples(base_schema, commands_info):
-    """Test optimization with examples."""
-    optimizer = SchemaOptimizer()
-    cmd_endpoint = "/cmd"
-    
-    optimized = optimizer.optimize(base_schema, cmd_endpoint, commands_info)
-    
-    # Check presence of examples
-    assert "examples" in optimized["components"]
-    
-    for cmd_name in commands_info.keys():
-        example_id = f"{cmd_name}_example"
-        assert example_id in optimized["components"]["examples"]
-        
-        # Check example correctness
-        example = optimized["components"]["examples"][example_id]
-        assert "value" in example
-        assert "command" in example["value"]
-        assert example["value"]["command"] == cmd_name
-        
-        # For commands with parameters check that params is present
-        if commands_info[cmd_name]["params"]:
-            assert "params" in example["value"]
-        # For commands without parameters check that params is absent
-        else:
-            assert "params" not in example["value"]
-
-def test_optimize_command_request_schema(base_schema, commands_info):
-    """Test CommandRequest schema."""
-    optimizer = SchemaOptimizer()
-    cmd_endpoint = "/cmd"
-    
-    optimized = optimizer.optimize(base_schema, cmd_endpoint, commands_info)
-    
-    command_request = optimized["components"]["schemas"]["CommandRequest"]
-    
-    # Check basic structure
-    assert "properties" in command_request
-    assert "command" in command_request["properties"]
-    assert "params" in command_request["properties"]
-    
-    # Check enum in command
-    assert "enum" in command_request["properties"]["command"]
-    for cmd_name in commands_info.keys():
-        assert cmd_name in command_request["properties"]["command"]["enum"]
-    
-    # Check oneOf in params
-    assert "oneOf" in command_request["properties"]["params"]
-    
-    # Last element in oneOf should be null for commands without parameters
-    last_oneof = command_request["properties"]["params"]["oneOf"][-1]
-    assert ("type" in last_oneof and last_oneof["type"] == "null") or last_oneof.get("nullable") is True or "$ref" in last_oneof
-    
-    # Check references to parameter schemas
-    param_refs = [ref["$ref"].split("/")[-1] for ref in command_request["properties"]["params"]["oneOf"][:-1] if "$ref" in ref]
-    for cmd_name in commands_info.keys():
-        param_schema_name = f"{cmd_name.capitalize()}Params"
-        if commands_info[cmd_name]["params"]:  # Проверяем только если есть параметры
-            assert param_schema_name in param_refs
-
-def test_optimize_parameter_schemas(base_schema, commands_info):
-    """Test parameter schemas."""
-    optimizer = SchemaOptimizer()
-    cmd_endpoint = "/cmd"
-    
-    optimized = optimizer.optimize(base_schema, cmd_endpoint, commands_info)
-    
-    # Check parameter schemas for each command
-    for cmd_name, cmd_info in commands_info.items():
-        param_schema_name = f"{cmd_name.capitalize()}Params"
-        param_schema = optimized["components"]["schemas"][param_schema_name]
-        
-        assert "properties" in param_schema
-        
-        # Check parameters
-        for param_name, param_info in cmd_info.get("params", {}).items():
-            assert param_name in param_schema["properties"]
-            assert "type" in param_schema["properties"][param_name]
-            assert param_schema["properties"][param_name]["type"] == param_info["type"]
-            
-            # Check description
-            assert "description" in param_schema["properties"][param_name]
-            assert param_schema["properties"][param_name]["description"] == param_info["description"]
-            
-            # Check default if present
-            if "default" in param_info:
-                assert "default" in param_schema["properties"][param_name]
-                assert param_schema["properties"][param_name]["default"] == param_info["default"]
-            
-            # Check enum if present
-            if "enum" in param_info:
-                assert "enum" in param_schema["properties"][param_name]
-                assert param_schema["properties"][param_name]["enum"] == param_info["enum"]
-        
-        # Check required if there are required parameters
-        required_params = [
-            param_name for param_name, param_info in cmd_info.get("params", {}).items()
-            if param_info.get("required", False)
-        ]
-        
-        if required_params:
-            assert "required" in param_schema
-            assert set(param_schema["required"]) == set(required_params)
-
-def test_add_tool_descriptions(base_schema, commands_info):
-    """Test adding tool descriptions."""
-    optimizer = SchemaOptimizer()
-    cmd_endpoint = "/cmd"
-    
-    optimized = optimizer.optimize(base_schema, cmd_endpoint, commands_info)
-    
-    # Check presence of x-mcp-tools
-    assert "x-mcp-tools" in optimized
-    assert isinstance(optimized["x-mcp-tools"], list)
-    
-    # Check tool descriptions
-    for cmd_name, cmd_info in commands_info.items():
-        # Find corresponding tool
-        tool = next((t for t in optimized["x-mcp-tools"] if t["name"] == f"mcp_{cmd_name}"), None)
-        
-        assert tool is not None
-        assert "description" in tool
-        assert "parameters" in tool
-        assert "type" in tool["parameters"]
-        assert tool["parameters"]["type"] == "object"
-        assert "properties" in tool["parameters"]
-        
-        # Check parameters
-        for param_name, param_info in cmd_info.get("params", {}).items():
-            assert param_name in tool["parameters"]["properties"]
-            
-            # Check type and description
-            assert "type" in tool["parameters"]["properties"][param_name]
-            assert tool["parameters"]["properties"][param_name]["type"] == param_info["type"]
-            assert "description" in tool["parameters"]["properties"][param_name]
-            
-            # Check enum if present
-            if "enum" in param_info:
-                assert "enum" in tool["parameters"]["properties"][param_name]
-                assert tool["parameters"]["properties"][param_name]["enum"] == param_info["enum"]
-            
-            # Check default if present
-            if "default" in param_info:
-                assert "default" in tool["parameters"]["properties"][param_name]
-                assert tool["parameters"]["properties"][param_name]["default"] == param_info["default"]
-        
-        # Check required
-        required_params = [
-            param_name for param_name, param_info in cmd_info.get("params", {}).items()
-            if param_info.get("required", False)
-        ]
-        
-        if required_params:
-            assert "required" in tool["parameters"]
-            assert set(tool["parameters"]["required"]) == set(required_params)
-
-def test_optimize_with_empty_schema():
-    """Test optimization with empty schema."""
-    optimizer = SchemaOptimizer()
-    empty_schema = {}
-    cmd_endpoint = "/cmd"
-    commands_info = {
-        "test_command": {
-            "description": "Test command",
-            "params": {}
-        }
-    }
-    
-    optimized = optimizer.optimize(empty_schema, cmd_endpoint, commands_info)
-    
-    # Ensure that optimizer created a valid schema even from empty
-    assert "openapi" in optimized
-    assert "info" in optimized
-    assert "paths" in optimized
-    assert cmd_endpoint in optimized["paths"]
-    assert "components" in optimized
-    assert "schemas" in optimized["components"]
-    assert "CommandRequest" in optimized["components"]["schemas"]
-    assert "CommandResponse" in optimized["components"]["schemas"]
-
-def test_optimize_command_with_all_param_types(base_schema):
-    """Test optimization of command with all parameter types."""
-    optimizer = SchemaOptimizer()
-    cmd_endpoint = "/cmd"
-    commands_info = {
-        "all_types": {
-            "description": "Command with all parameter types",
-            "params": {
-                "string_param": {
-                    "type": "string",
-                    "description": "String parameter",
-                    "required": True
-                },
-                "integer_param": {
-                    "type": "integer",
-                    "description": "Integer parameter",
-                    "required": False,
-                    "default": 0
-                },
-                "number_param": {
-                    "type": "number",
-                    "description": "Numeric parameter",
-                    "required": False,
-                    "default": 0.0
-                },
-                "boolean_param": {
-                    "type": "boolean",
-                    "description": "Boolean parameter",
-                    "required": False,
-                    "default": False
-                },
-                "array_param": {
-                    "type": "array",
-                    "description": "Array",
-                    "required": False
-                },
-                "object_param": {
-                    "type": "object",
-                    "description": "Object",
-                    "required": False
-                }
-            }
-        }
-    }
-    
-    optimized = optimizer.optimize(base_schema, cmd_endpoint, commands_info)
-    
-    # Check parameter schema
-    param_schema = optimized["components"]["schemas"]["All_typesParams"]
-    
-    # Check parameter types
-    assert param_schema["properties"]["string_param"]["type"] == "string"
-    assert param_schema["properties"]["integer_param"]["type"] == "integer"
-    assert param_schema["properties"]["number_param"]["type"] == "number"
-    assert param_schema["properties"]["boolean_param"]["type"] == "boolean"
-    assert param_schema["properties"]["array_param"]["type"] == "array"
-    assert param_schema["properties"]["object_param"]["type"] == "object" 

tests/test_simple_adapter.py

@@ -1,251 +0,0 @@
-"""
-Simplified test for MCPProxyAdapter.
-"""
-import json
-import pytest
-from unittest.mock import MagicMock
-from fastapi import FastAPI
-from fastapi.testclient import TestClient
-
-# Create mock classes for testing
-class MockDispatcher:
-    def __init__(self):
-        self.commands = {
-            "test_command": lambda value=1: {"result": value * 2}
-        }
-        self.commands_info = {
-            "test_command": {
-                "description": "Test command",
-                "params": {
-                    "value": {
-                        "type": "integer",
-                        "required": False,
-                        "default": 1
-                    }
-                }
-            }
-        }
-    
-    def execute(self, command, **params):
-        return self.commands[command](**params)
-    
-    def get_valid_commands(self):
-        return list(self.commands.keys())
-    
-    def get_command_info(self, command):
-        return self.commands_info.get(command)
-    
-    def get_commands_info(self):
-        return self.commands_info
-
-class MockRegistry:
-    def __init__(self):
-        self.dispatcher = MockDispatcher()
-        self.generators = []
-    
-    def get_commands_info(self):
-        return self.dispatcher.get_commands_info()
-    
-    def add_generator(self, generator):
-        self.generators.append(generator)
-
-# Создаем минимальную версию JsonRpcRequest и JsonRpcResponse
-class JsonRpcRequest:
-    def __init__(self, method, params=None, id=None):
-        self.jsonrpc = "2.0"
-        self.method = method
-        self.params = params or {}
-        self.id = id
-
-class JsonRpcResponse:
-    def __init__(self, result=None, error=None, id=None, jsonrpc="2.0"):
-        self.jsonrpc = jsonrpc
-        self.result = result
-        self.error = error
-        self.id = id
-    
-    def dict(self):
-        response = {"jsonrpc": self.jsonrpc}
-        if self.result is not None:
-            response["result"] = self.result
-        if self.error is not None:
-            response["error"] = self.error
-        if self.id is not None:
-            response["id"] = self.id
-        return response
-
-# Мок для SchemaOptimizer
-class MockSchemaOptimizer:
-    def optimize(self, schema, cmd_endpoint, commands_info):
-        return schema
-
-# Определяем класс MCPProxyAdapter для тестов
-class MCPProxyAdapter:
-    def __init__(self, registry, cmd_endpoint="/cmd", include_schema=True, optimize_schema=True, tool_name_prefix="mcp_"):
-        self.registry = registry
-        self.cmd_endpoint = cmd_endpoint
-        self.include_schema = include_schema
-        self.optimize_schema = optimize_schema
-        self.tool_name_prefix = tool_name_prefix
-        self.router = MagicMock()
-        self.schema_optimizer = MockSchemaOptimizer()
-        self.openapi_generator = None
-    
-    def register_endpoints(self, app):
-        # Регистрируем эндпоинт для выполнения команд
-        @app.post(self.cmd_endpoint)
-        async def execute_command(request_data: dict):
-            request = JsonRpcRequest(
-                method=request_data.get("method", ""),
-                params=request_data.get("params", {}),
-                id=request_data.get("id")
-            )
-            
-            # Проверяем существование команды
-            if request.method not in self.registry.dispatcher.get_valid_commands():
-                return {
-                    "jsonrpc": "2.0",
-                    "error": {
-                        "code": -32601,
-                        "message": f"Command '{request.method}' not found"
-                    },
-                    "id": request.id
-                }
-            
-            # Выполняем команду
-            try:
-                result = self.registry.dispatcher.execute(
-                    request.method, 
-                    **request.params
-                )
-                
-                # Возвращаем результат
-                return {
-                    "jsonrpc": "2.0",
-                    "result": result,
-                    "id": request.id
-                }
-            except Exception as e:
-                return {
-                    "jsonrpc": "2.0",
-                    "error": {
-                        "code": -32603,
-                        "message": str(e)
-                    },
-                    "id": request.id
-                }
-    
-    def generate_mcp_proxy_config(self):
-        return {
-            "version": "1.0",
-            "tools": [
-                {
-                    "name": f"{self.tool_name_prefix}{cmd_name}",
-                    "description": cmd_info.get("description", ""),
-                    "parameters": {
-                        "type": "object",
-                        "properties": {param_name: {"type": param_info.get("type", "string")} 
-                                      for param_name, param_info in cmd_info.get("params", {}).items()},
-                        "required": [param_name for param_name, param_info in cmd_info.get("params", {}).items() 
-                                    if param_info.get("required", False)]
-                    }
-                }
-                for cmd_name, cmd_info in self.registry.get_commands_info().items()
-            ],
-            "routes": [
-                {
-                    "tool_name": f"{self.tool_name_prefix}{cmd_name}",
-                    "endpoint": self.cmd_endpoint,
-                    "method": "post",
-                    "json_rpc": {"method": cmd_name}
-                }
-                for cmd_name in self.registry.get_commands_info()
-            ]
-        }
-
-# Тесты
-@pytest.fixture
-def registry():
-    return MockRegistry()
-
-@pytest.fixture
-def adapter(registry):
-    return MCPProxyAdapter(registry)
-
-@pytest.fixture
-def custom_endpoint_adapter(registry):
-    return MCPProxyAdapter(registry, cmd_endpoint="/api/execute")
-
-@pytest.fixture
-def test_app(adapter):
-    app = FastAPI()
-    adapter.register_endpoints(app)
-    return TestClient(app)
-
-@pytest.fixture
-def custom_endpoint_app(custom_endpoint_adapter):
-    app = FastAPI()
-    custom_endpoint_adapter.register_endpoints(app)
-    return TestClient(app)
-
-def test_successful_command_execution(test_app):
-    """Тест успешного выполнения команды."""
-    response = test_app.post("/cmd", json={
-        "jsonrpc": "2.0",
-        "method": "test_command",
-        "params": {"value": 5},
-        "id": 1
-    })
-    assert response.status_code == 200
-    data = response.json()
-    assert data["result"] == {"result": 10}
-
-def test_unknown_command(test_app):
-    """Тест обработки неизвестной команды."""
-    response = test_app.post("/cmd", json={
-        "jsonrpc": "2.0",
-        "method": "unknown_command",
-        "id": 1
-    })
-    assert response.status_code == 200
-    data = response.json()
-    assert "error" in data
-    assert "not found" in data["error"]["message"]
-
-def test_custom_endpoint(custom_endpoint_app):
-    """Тест работы адаптера с кастомным эндпоинтом."""
-    # Проверяем, что стандартный эндпоинт недоступен
-    response = custom_endpoint_app.post("/cmd", json={
-        "jsonrpc": "2.0",
-        "method": "test_command",
-        "params": {"value": 5},
-        "id": 1
-    })
-    assert response.status_code == 404
-    
-    # Проверяем, что кастомный эндпоинт работает
-    response = custom_endpoint_app.post("/api/execute", json={
-        "jsonrpc": "2.0",
-        "method": "test_command",
-        "params": {"value": 5},
-        "id": 1
-    })
-    assert response.status_code == 200
-    data = response.json()
-    assert data["result"] == {"result": 10}
-
-def test_mcp_proxy_config(adapter):
-    """Test MCP Proxy configuration generation."""
-    config = adapter.generate_mcp_proxy_config()
-    
-    assert "version" in config
-    assert "tools" in config
-    assert len(config["tools"]) == 1
-    
-    tool = config["tools"][0]
-    assert tool["name"] == "mcp_test_command"
-    assert "parameters" in tool
-    
-    assert "routes" in config
-    assert len(config["routes"]) == 1
-    assert config["routes"][0]["endpoint"] == "/cmd"