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

mcp_proxy_adapter/tests/test_command_registry.py

@@ -1,281 +0,0 @@
-"""
-Tests for command registry.
-"""
-
-import pytest
-from unittest.mock import MagicMock, patch
-
-from mcp_proxy_adapter.commands.base import Command
-from mcp_proxy_adapter.commands.result import CommandResult
-from mcp_proxy_adapter.commands.command_registry import CommandRegistry
-from mcp_proxy_adapter.core.errors import NotFoundError
-
-
-class MockResult(CommandResult):
-    """Test result class for testing."""
-    
-    def __init__(self):
-        pass
-    
-    def to_dict(self):
-        return {}
-    
-    @classmethod
-    def get_schema(cls):
-        return {}
-
-
-class TestCommand1(Command):
-    """First test command."""
-    
-    name = "test_command1"
-    result_class = MockResult
-    
-    async def execute(self, **kwargs):
-        return MockResult()
-
-
-class TestCommand2(Command):
-    """Second test command."""
-    
-    name = "test_command2"
-    result_class = MockResult
-    
-    async def execute(self, **kwargs):
-        return MockResult()
-
-
-def test_registry_initialization():
-    """Test registry initialization."""
-    registry = CommandRegistry()
-    assert len(registry._commands) == 0
-
-
-def test_register_command():
-    """Test registering command."""
-    registry = CommandRegistry()
-    
-    # Register first command
-    registry.register(TestCommand1)
-    assert len(registry._commands) == 1
-    assert "test_command1" in registry._commands
-    
-    # Register second command
-    registry.register(TestCommand2)
-    assert len(registry._commands) == 2
-    assert "test_command2" in registry._commands
-
-
-def test_register_duplicated_command():
-    """Test registering duplicated command."""
-    registry = CommandRegistry()
-    
-    # Register command
-    registry.register(TestCommand1)
-    
-    # Try to register again
-    with pytest.raises(ValueError):
-        registry.register(TestCommand1)
-
-
-def test_register_command_without_name():
-    """Test registering command without name attribute."""
-    registry = CommandRegistry()
-    
-    # Create command without name
-    class CommandWithoutName(Command):
-        result_class = MockResult
-        
-        async def execute(self, **kwargs):
-            return MockResult()
-    
-    # Register command
-    registry.register(CommandWithoutName)
-    
-    # Check if registered with class name
-    assert "commandwithoutname" in registry._commands
-
-
-def test_unregister_command():
-    """Test unregistering command."""
-    registry = CommandRegistry()
-    
-    # Register command
-    registry.register(TestCommand1)
-    assert "test_command1" in registry._commands
-    
-    # Unregister command
-    registry.unregister("test_command1")
-    assert "test_command1" not in registry._commands
-
-
-def test_unregister_nonexistent_command():
-    """Test unregistering nonexistent command."""
-    registry = CommandRegistry()
-    
-    # Try to unregister nonexistent command
-    with pytest.raises(NotFoundError):
-        registry.unregister("nonexistent")
-
-
-def test_get_command():
-    """Test getting command."""
-    registry = CommandRegistry()
-    
-    # Register command
-    registry.register(TestCommand1)
-    
-    # Get command
-    command = registry.get_command("test_command1")
-    assert command == TestCommand1
-
-
-def test_get_nonexistent_command():
-    """Test getting nonexistent command."""
-    registry = CommandRegistry()
-    
-    # Try to get nonexistent command
-    with pytest.raises(NotFoundError):
-        registry.get_command("nonexistent")
-
-
-def test_get_all_commands():
-    """Test getting all commands."""
-    registry = CommandRegistry()
-    
-    # Register commands
-    registry.register(TestCommand1)
-    registry.register(TestCommand2)
-    
-    # Get all commands
-    commands = registry.get_all_commands()
-    assert len(commands) == 2
-    assert "test_command1" in commands
-    assert "test_command2" in commands
-    assert commands["test_command1"] == TestCommand1
-    assert commands["test_command2"] == TestCommand2
-
-
-def test_get_command_info():
-    """Test getting command info."""
-    registry = CommandRegistry()
-    
-    # Register command
-    registry.register(TestCommand1)
-    
-    # Get command info
-    info = registry.get_command_info("test_command1")
-    
-    # Check info structure
-    assert info["name"] == "test_command1"
-    assert "description" in info
-    assert "params" in info
-    assert "schema" in info
-    assert "result_schema" in info
-
-
-def test_get_all_commands_info():
-    """Test getting all commands info."""
-    registry = CommandRegistry()
-    
-    # Register commands
-    registry.register(TestCommand1)
-    registry.register(TestCommand2)
-    
-    # Get all commands info
-    info = registry.get_all_commands_info()
-    
-    # Check info structure
-    assert len(info) == 2
-    assert "test_command1" in info
-    assert "test_command2" in info
-    assert info["test_command1"]["name"] == "test_command1"
-    assert info["test_command2"]["name"] == "test_command2"
-
-
-@patch("importlib.import_module")
-@patch("pkgutil.iter_modules")
-@patch("inspect.getmembers")
-def test_discover_commands(mock_getmembers, mock_iter_modules, mock_import_module):
-    """Test discovering commands."""
-    registry = CommandRegistry()
-    
-    # Mock package
-    mock_package = MagicMock()
-    mock_package.__file__ = "/path/to/package"
-    mock_import_module.return_value = mock_package
-    
-    # Mock modules
-    mock_iter_modules.return_value = [
-        (None, "test_command", False),
-        (None, "other_module", False)
-    ]
-    
-    # Mock command classes
-    class DiscoveredCommand(Command):
-        name = "discovered"
-        result_class = MockResult
-        
-        async def execute(self, **kwargs):
-            return MockResult()
-    
-    # Mock getmembers to return command class
-    mock_getmembers.return_value = [
-        ("DiscoveredCommand", DiscoveredCommand)
-    ]
-    
-    # Discover commands
-    registry.discover_commands()
-    
-    # Check if command was registered
-    assert len(mock_import_module.mock_calls) > 0
-
-
-def test_clear_registry():
-    """Test clearing registry."""
-    registry = CommandRegistry()
-    
-    # Register commands
-    registry.register(TestCommand1)
-    registry.register(TestCommand2)
-    assert len(registry._commands) == 2
-    
-    # Clear registry
-    registry.clear()
-    assert len(registry._commands) == 0
-
-
-def test_register_command_instance():
-    """Test registering a command instance (with dependencies)."""
-    registry = CommandRegistry()
-
-    class Service:
-        def __init__(self, value):
-            self.value = value
-
-    class CommandWithDependency(Command):
-        name = "command_with_dep"
-        result_class = MockResult
-        def __init__(self, service: Service):
-            self.service = service
-        async def execute(self, **kwargs):
-            # Return the value from the injected service
-            result = MockResult()
-            result.service_value = self.service.value
-            return result
-
-    service = Service(value=42)
-    command_instance = CommandWithDependency(service=service)
-    registry.register(command_instance)
-
-    # Проверяем, что экземпляр зарегистрирован
-    assert registry.has_instance("command_with_dep")
-    # Проверяем, что get_command_instance возвращает именно этот экземпляр
-    assert registry.get_command_instance("command_with_dep") is command_instance
-    # Проверяем, что execute использует внедрённый сервис
-    import asyncio
-    result = asyncio.run(
-        registry.get_command_instance("command_with_dep").execute()
-    )
-    assert hasattr(result, "service_value")
-    assert result.service_value == 42 

mcp_proxy_adapter/tests/test_config.py

@@ -1,127 +0,0 @@
-"""
-Test module for configuration class.
-"""
-
-import os
-import json
-import tempfile
-from pathlib import Path
-
-import pytest
-
-from mcp_proxy_adapter.config import Config
-
-
-def test_config_initialization(temp_config_file):
-    """
-    Test configuration initialization.
-    """
-    config = Config(temp_config_file)
-    assert config.config_path == temp_config_file
-    assert isinstance(config.config_data, dict)
-
-
-def test_config_get_existing_values(test_config):
-    """
-    Test getting existing values from configuration.
-    """
-    # Test top-level key
-    server_config = test_config.get("server")
-    assert server_config.get("host") == "127.0.0.1"
-    assert server_config.get("port") == 8888
-    
-    # Test nested key with dot notation
-    assert test_config.get("server.host") == "127.0.0.1"
-    assert test_config.get("server.port") == 8888
-    
-    # Test logging values
-    assert test_config.get("logging.level") == "DEBUG"
-    assert test_config.get("logging.file") is None
-
-
-def test_config_get_default_values(test_config):
-    """
-    Test getting default values for non-existent keys.
-    """
-    # Non-existent key with default
-    assert test_config.get("non_existent", "default") == "default"
-    
-    # Non-existent nested key with default
-    assert test_config.get("server.non_existent", 42) == 42
-    
-    # Non-existent top level with nested key
-    assert test_config.get("non_existent.key", False) is False
-
-
-def test_config_set_values(test_config):
-    """
-    Test setting values in configuration.
-    """
-    # Set top-level value
-    test_config.set("new_key", "value")
-    assert test_config.get("new_key") == "value"
-    
-    # Set nested value for existing parent
-    test_config.set("server.api_key", "secret")
-    assert test_config.get("server.api_key") == "secret"
-    
-    # Set nested value with non-existent parent
-    test_config.set("database.url", "postgres://localhost")
-    assert test_config.get("database.url") == "postgres://localhost"
-    
-    # Overwrite existing value
-    test_config.set("server.host", "0.0.0.0")
-    assert test_config.get("server.host") == "0.0.0.0"
-
-
-def test_config_save_load(temp_config_file):
-    """
-    Test saving and loading configuration.
-    """
-    # Create and modify config
-    config = Config(temp_config_file)
-    config.set("test_key", "test_value")
-    config.set("nested.key", 123)
-    
-    # Save config
-    config.save()
-    
-    # Create new config instance to load from the same file
-    new_config = Config(temp_config_file)
-    
-    # Verify values were saved and loaded
-    assert new_config.get("test_key") == "test_value"
-    assert new_config.get("nested.key") == 123
-    assert new_config.get("server.host") == "127.0.0.1"
-
-
-def test_config_environment_variables():
-    """
-    Test environment variables override configuration values.
-    """
-    with tempfile.NamedTemporaryFile(suffix=".json", delete=False, mode="w") as temp:
-        temp_path = temp.name
-        json.dump({"server": {"host": "localhost", "port": 8000}}, temp)
-    
-    try:
-        # Set environment variables
-        os.environ["SERVICE_SERVER_HOST"] = "192.168.1.1"
-        os.environ["SERVICE_SERVER_PORT"] = "9000"
-        os.environ["SERVICE_LOGGING_LEVEL"] = "INFO"
-        
-        # Create config that should load from env vars
-        config = Config(temp_path)
-        
-        # Check values are overridden by environment
-        assert config.get("server.host") == "192.168.1.1"
-        assert config.get("server.port") == 9000
-        assert config.get("logging.level") == "INFO"
-    finally:
-        # Clean up
-        os.unlink(temp_path)
-        if "SERVICE_SERVER_HOST" in os.environ:
-            del os.environ["SERVICE_SERVER_HOST"]
-        if "SERVICE_SERVER_PORT" in os.environ:
-            del os.environ["SERVICE_SERVER_PORT"]
-        if "SERVICE_LOGGING_LEVEL" in os.environ:
-            del os.environ["SERVICE_LOGGING_LEVEL"]

mcp_proxy_adapter/tests/test_utils.py

@@ -1,65 +0,0 @@
-"""
-Test utilities for mcp_microservice.
-"""
-
-from typing import Any, Dict
-from mcp_proxy_adapter.commands.result import CommandResult
-
-
-class MockResult(CommandResult):
-    """
-    Mock result class for testing.
-    
-    Attributes:
-        message: Test message.
-        timestamp: Test timestamp.
-    """
-    
-    def __init__(self, message: str = "Test message", timestamp: float = 12345.0):
-        self.message = message
-        self.timestamp = timestamp
-    
-    def to_dict(self) -> Dict[str, Any]:
-        """
-        Converts result to dictionary for serialization.
-
-        Returns:
-            Dictionary with result data.
-        """
-        return {
-            "message": self.message,
-            "timestamp": self.timestamp
-        }
-    
-    @classmethod
-    def get_schema(cls) -> Dict[str, Any]:
-        """
-        Returns JSON schema for result validation.
-
-        Returns:
-            Dictionary with JSON schema.
-        """
-        return {
-            "type": "object",
-            "properties": {
-                "message": {"type": "string", "description": "Test message"},
-                "timestamp": {"type": "number", "description": "Test timestamp"}
-            },
-            "required": ["message", "timestamp"]
-        }
-    
-    @classmethod
-    def from_dict(cls, data: Dict[str, Any]) -> "MockResult":
-        """
-        Creates result instance from dictionary.
-
-        Args:
-            data: Dictionary with result data.
-
-        Returns:
-            MockResult instance.
-        """
-        return cls(
-            message=data.get("message", ""),
-            timestamp=data.get("timestamp", 0.0)
-        ) 

mcp_proxy_adapter/tests/unit/__init__.py

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