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

mcp_proxy_adapter/tests/commands/test_config_command.py

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

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

@@ -1,136 +0,0 @@
-"""
-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 result fields
-    command = HelpCommand()
-    result = await command.execute(cmdname="non_existent")
-    result_dict = result.to_dict()
-    assert "error" in result_dict
-    assert "example" in result_dict
-    assert "note" in result_dict
-    assert result_dict["error"].startswith("Command")
-    assert result_dict["example"]["command"] == "help"
-
-
-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

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

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