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

mcp_proxy_adapter/tests/test_batch_requests.py

@@ -0,0 +1,117 @@
+"""
+Tests for JSON-RPC batch requests handling.
+"""
+
+import pytest
+from typing import Dict, Any, List
+from unittest.mock import AsyncMock, patch, MagicMock
+
+from mcp_proxy_adapter.api.handlers import handle_json_rpc, handle_batch_json_rpc
+from mcp_proxy_adapter.commands.result import SuccessResult
+from mcp_proxy_adapter.core.errors import NotFoundError, MicroserviceError
+
+
+@pytest.fixture
+def success_result():
+    """Fixture for test success result."""
+    result = SuccessResult(data={"key": "value"}, message="Success")
+    return result
+
+
+class TestBatchJsonRpc:
+    """Tests for JSON-RPC batch requests handling."""
+    
+    @pytest.mark.asyncio
+    @patch("mcp_proxy_adapter.api.handlers.handle_json_rpc")
+    async def test_batch_request_processing(self, mock_handle_json_rpc):
+        """Test handling of batch requests."""
+        # Setup handle_json_rpc mock to return different responses
+        mock_handle_json_rpc.side_effect = [
+            # First request - success
+            {
+                "jsonrpc": "2.0",
+                "result": {"key1": "value1"},
+                "id": "1"
+            },
+            # Second request - error
+            {
+                "jsonrpc": "2.0",
+                "error": {
+                    "code": -32601,
+                    "message": "Method not found"
+                },
+                "id": "2"
+            },
+            # Third request - success
+            {
+                "jsonrpc": "2.0",
+                "result": {"key3": "value3"},
+                "id": "3"
+            }
+        ]
+        
+        # Create batch request
+        batch_request = [
+            {"jsonrpc": "2.0", "method": "method1", "params": {"p1": "v1"}, "id": "1"},
+            {"jsonrpc": "2.0", "method": "non_existent", "id": "2"},
+            {"jsonrpc": "2.0", "method": "method3", "params": {"p3": "v3"}, "id": "3"}
+        ]
+        
+        # Process batch request
+        responses = await handle_batch_json_rpc(batch_request)
+        
+        # Assertions
+        assert len(responses) == 3
+        assert mock_handle_json_rpc.call_count == 3
+        
+        # Check first response
+        assert responses[0]["jsonrpc"] == "2.0"
+        assert responses[0]["result"] == {"key1": "value1"}
+        assert responses[0]["id"] == "1"
+        
+        # Check second response (error)
+        assert responses[1]["jsonrpc"] == "2.0"
+        assert responses[1]["error"]["code"] == -32601
+        assert responses[1]["id"] == "2"
+        
+        # Check third response
+        assert responses[2]["jsonrpc"] == "2.0"
+        assert responses[2]["result"] == {"key3": "value3"}
+        assert responses[2]["id"] == "3"
+    
+    @pytest.mark.asyncio
+    @patch("mcp_proxy_adapter.api.handlers.handle_json_rpc")
+    async def test_empty_batch_request(self, mock_handle_json_rpc):
+        """Test handling of empty batch request."""
+        # Create empty batch request
+        batch_request = []
+        
+        # Process batch request
+        responses = await handle_batch_json_rpc(batch_request)
+        
+        # Assertions
+        assert len(responses) == 0
+        assert mock_handle_json_rpc.call_count == 0
+    
+    @pytest.mark.asyncio
+    @patch("mcp_proxy_adapter.api.handlers.execute_command")
+    async def test_end_to_end_batch_processing(self, mock_execute_command, success_result):
+        """Test end-to-end processing of batch requests."""
+        # Setup execute_command mock
+        mock_execute_command.return_value = success_result.to_dict()
+        
+        # Create batch request
+        batch_request = [
+            {"jsonrpc": "2.0", "method": "method1", "params": {"p1": "v1"}, "id": "1"},
+            {"jsonrpc": "2.0", "method": "method2", "params": {"p2": "v2"}, "id": "2"}
+        ]
+        
+        # Process batch request
+        responses = await handle_batch_json_rpc(batch_request)
+        
+        # Assertions
+        assert len(responses) == 2
+        for response in responses:
+            assert response["jsonrpc"] == "2.0"
+            assert "result" in response
+            assert "error" not in response 

mcp_proxy_adapter/tests/test_command_registry.py

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

mcp_proxy_adapter/tests/test_config.py

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

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

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

mcp_proxy_adapter/tests/unit/test_base_command.py

@@ -0,0 +1,130 @@
+"""
+Tests for command base classes.
+"""
+
+import pytest
+from typing import Dict, Any
+
+from mcp_proxy_adapter.commands.base import Command
+from mcp_proxy_adapter.commands.result import CommandResult, SuccessResult, ErrorResult
+
+
+class MockResultClass(CommandResult):
+    """Test result class for testing."""
+    
+    def __init__(self, value: str):
+        self.value = value
+    
+    def to_dict(self) -> Dict[str, Any]:
+        return {"value": self.value}
+    
+    @classmethod
+    def get_schema(cls) -> Dict[str, Any]:
+        return {
+            "type": "object",
+            "properties": {
+                "value": {"type": "string"}
+            },
+            "required": ["value"]
+        }
+
+
+class TestCommand(Command):
+    """Test command for testing."""
+    
+    name = "test_command"
+    result_class = MockResultClass
+    
+    async def execute(self, value: str = "default") -> MockResultClass:
+        return MockResultClass(value)
+    
+    @classmethod
+    def get_schema(cls) -> Dict[str, Any]:
+        return {
+            "type": "object",
+            "properties": {
+                "value": {"type": "string"}
+            },
+            "additionalProperties": False
+        }
+
+
+@pytest.mark.unit
+def test_success_result():
+    """Test success result class."""
+    result = SuccessResult(data={"key": "value"}, message="success message")
+    
+    # Test to_dict method
+    result_dict = result.to_dict()
+    assert result_dict["success"] is True
+    assert result_dict["data"] == {"key": "value"}
+    assert result_dict["message"] == "success message"
+    
+    # Test from_dict method
+    result2 = SuccessResult.from_dict(result_dict)
+    assert result2.data == {"key": "value"}
+    assert result2.message == "success message"
+
+
+@pytest.mark.unit
+def test_error_result():
+    """Test error result class."""
+    result = ErrorResult(message="error message", code=400, details={"field": "invalid"})
+    
+    # Test to_dict method
+    result_dict = result.to_dict()
+    assert result_dict["success"] is False
+    assert result_dict["error"]["code"] == 400
+    assert result_dict["error"]["message"] == "error message"
+    assert result_dict["error"]["data"] == {"field": "invalid"}
+    
+    # Test from_dict method
+    result2 = ErrorResult.from_dict(result_dict)
+    assert result2.message == "error message"
+    assert result2.code == 400
+    assert result2.details == {"field": "invalid"}
+
+
+class TestCommandClass:
+    """Test command class."""
+    
+    @pytest.mark.unit
+    @pytest.mark.asyncio
+    async def test_execute(self):
+        """Test execute method."""
+        command = TestCommand()
+        result = await command.execute(value="test_value")
+        assert isinstance(result, MockResultClass)
+        assert result.value == "test_value"
+    
+    @pytest.mark.unit
+    @pytest.mark.asyncio
+    async def test_run(self):
+        """Test run method (with validation)."""
+        result = await TestCommand.run(value="test_value")
+        assert isinstance(result, MockResultClass)
+        assert result.value == "test_value"
+    
+    @pytest.mark.unit
+    def test_get_schema(self):
+        """Test get_schema method."""
+        schema = TestCommand.get_schema()
+        assert schema["type"] == "object"
+        assert "value" in schema["properties"]
+        assert schema["additionalProperties"] is False
+    
+    @pytest.mark.unit
+    def test_get_result_schema(self):
+        """Test get_result_schema method."""
+        schema = TestCommand.get_result_schema()
+        assert schema["type"] == "object"
+        assert "value" in schema["properties"]
+        assert "value" in schema["required"]
+    
+    @pytest.mark.unit
+    def test_get_param_info(self):
+        """Test get_param_info method."""
+        params = TestCommand.get_param_info()
+        assert "value" in params
+        assert params["value"]["required"] is False
+        assert params["value"]["default"] == "default"