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

tests/test_command_registry.py

@@ -1,328 +0,0 @@
-"""
-Tests for CommandRegistry.
-"""
-import sys
-import os
-import pytest
-import tempfile
-from typing import Dict, Any, Optional, List
-import inspect
-
-# Add parent directory to import path
-current_dir = os.path.dirname(os.path.abspath(__file__))
-parent_dir = os.path.dirname(current_dir)
-if parent_dir not in sys.path:
-    sys.path.insert(0, parent_dir)
-
-# Import classes for testing
-try:
-    from mcp_proxy_adapter.registry import CommandRegistry
-    from mcp_proxy_adapter.dispatchers.json_rpc_dispatcher import JsonRpcDispatcher
-    from mcp_proxy_adapter.analyzers.docstring_analyzer import DocstringAnalyzer
-    from mcp_proxy_adapter.analyzers.type_analyzer import TypeAnalyzer
-    from mcp_proxy_adapter.validators.docstring_validator import DocstringValidator
-except ImportError:
-    from src.registry import CommandRegistry
-    from src.dispatchers.json_rpc_dispatcher import JsonRpcDispatcher
-    from mcp_proxy_adapter.analyzers.docstring_analyzer import DocstringAnalyzer
-    from mcp_proxy_adapter.analyzers.type_analyzer import TypeAnalyzer
-    from mcp_proxy_adapter.validators.docstring_validator import DocstringValidator
-
-
-# Test functions for command registration testing
-
-def valid_command(a: int, b: int = 1) -> int:
-    """
-    Valid function for testing.
-    
-    Args:
-        a: First parameter
-        b: Second parameter
-        
-    Returns:
-        int: Calculation result
-    """
-    return a + b
-
-def invalid_docstring_command(a: int, b: int = 1) -> int:
-    """
-    Function with invalid docstring.
-    
-    Args:
-        a: First parameter
-        # Missing description for parameter b
-        
-    Returns:
-        int: Calculation result
-    """
-    return a + b
-
-def invalid_annotation_command(a, b = 1):
-    """
-    Function without type annotations.
-    
-    Args:
-        a: First parameter
-        b: Second parameter
-        
-    Returns:
-        Calculation result
-    """
-    return a + b
-
-def params_command(params: Dict[str, Any]) -> Dict[str, Any]:
-    """
-    Function that accepts a dictionary of parameters.
-    
-    Args:
-        params: Dictionary of parameters
-        
-    Returns:
-        Dict[str, Any]: Processing result
-    """
-    # Return the params dictionary directly
-    return params
-
-
-@pytest.fixture
-def registry():
-    """Creates CommandRegistry for tests"""
-    return CommandRegistry(
-        dispatcher=JsonRpcDispatcher(),
-        strict=True,
-        auto_fix=False
-    )
-
-
-class TestCommandRegistry:
-    """Tests for CommandRegistry"""
-    
-    def test_initialization(self, registry):
-        """Test command registry initialization"""
-        # Check that standard analyzers and validators are added
-        assert any(isinstance(a, TypeAnalyzer) for a in registry._analyzers)
-        assert any(isinstance(a, DocstringAnalyzer) for a in registry._analyzers)
-        assert any(isinstance(v, DocstringValidator) for v in registry._validators)
-        
-        # Check that dispatcher is initialized
-        assert registry.dispatcher is not None
-        assert isinstance(registry.dispatcher, JsonRpcDispatcher)
-    
-    def test_analyze_handler(self, registry):
-        """Test command handler analysis"""
-        metadata = registry.analyze_handler("valid_command", valid_command)
-        
-        # Check metadata structure
-        assert "description" in metadata
-        assert "summary" in metadata
-        assert "parameters" in metadata
-        
-        # Check that parameters are discovered
-        assert "a" in metadata["parameters"]
-        assert "b" in metadata["parameters"]
-        
-        # Check parameter types
-        assert metadata["parameters"]["a"]["type"] == "integer"
-        assert metadata["parameters"]["b"]["type"] == "integer"
-        
-        # Check descriptions and requirement flags
-        assert "description" in metadata["parameters"]["a"]
-        assert "description" in metadata["parameters"]["b"]
-        assert metadata["parameters"]["a"]["required"] is True
-        assert metadata["parameters"]["b"]["required"] is False
-    
-    def test_validate_handler_valid(self, registry):
-        """Test validation of a valid handler"""
-        metadata = registry.analyze_handler("valid_command", valid_command)
-        is_valid, errors = registry.validate_handler("valid_command", valid_command, metadata)
-        
-        assert is_valid is True
-        assert len(errors) == 0
-    
-    def test_validate_handler_invalid_docstring(self, registry):
-        """Test validation of a handler with invalid docstring"""
-        metadata = registry.analyze_handler("invalid_docstring", invalid_docstring_command)
-        is_valid, errors = registry.validate_handler("invalid_docstring", invalid_docstring_command, metadata)
-        
-        assert is_valid is False
-        assert len(errors) > 0
-        # Check that the error is related to missing description for parameter b
-        assert any("parameter 'b'" in error.lower() for error in errors)
-    
-    def test_validate_handler_invalid_annotation(self, registry):
-        """Test validation of a handler without type annotations"""
-        metadata = registry.analyze_handler("invalid_annotation", invalid_annotation_command)
-        is_valid, errors = registry.validate_handler("invalid_annotation", invalid_annotation_command, metadata)
-        
-        assert is_valid is False
-        assert len(errors) > 0
-        # Check that the error is related to missing type annotations
-        assert any("type annotation" in error.lower() for error in errors)
-    
-    def test_register_command_valid(self, registry):
-        """Test registration of a valid command"""
-        result = registry.register_command("valid", valid_command)
-        assert result is True
-        
-        # Check that the command is registered in the dispatcher
-        assert "valid" in registry.dispatcher.get_valid_commands()
-        
-        # Check that the command can be executed
-        assert registry.dispatcher.execute("valid", a=5, b=3) == 8
-    
-    def test_register_command_invalid_strict(self, registry):
-        """Test registration of an invalid command in strict mode"""
-        # In strict mode, a command with errors should not be registered
-        result = registry.register_command("invalid_docstring", invalid_docstring_command)
-        assert result is False
-        
-        # Check that the command is not registered in the dispatcher
-        assert "invalid_docstring" not in registry.dispatcher.get_valid_commands()
-    
-    def test_register_command_invalid_not_strict(self):
-        """Test registration of an invalid command in non-strict mode"""
-        # Create registry in non-strict mode
-        registry = CommandRegistry(strict=False, auto_fix=False)
-        
-        # In non-strict mode, a command with errors should be registered
-        result = registry.register_command("invalid_docstring", invalid_docstring_command)
-        assert result is True
-        
-        # Check that the command is registered in the dispatcher
-        assert "invalid_docstring" in registry.dispatcher.get_valid_commands()
-    
-    def test_register_command_invalid_auto_fix(self):
-        """Test registration of an invalid command with auto-fix"""
-        # Create registry in auto-fix mode
-        registry = CommandRegistry(strict=True, auto_fix=True)
-        
-        # In auto-fix mode, a command with errors should be registered
-        result = registry.register_command("invalid_docstring", invalid_docstring_command)
-        assert result is True
-        
-        # Check that the command is registered in the dispatcher
-        assert "invalid_docstring" in registry.dispatcher.get_valid_commands()
-    
-    def test_params_command(self, registry):
-        """Test command with params parameter"""
-        result = registry.register_command("params_command", params_command)
-        assert result is True
-        
-        # Check that the command is registered
-        assert "params_command" in registry.dispatcher.get_valid_commands()
-        
-        # Test executing the command with params parameter
-        test_params = {"a": 1, "b": 2}
-        # Params are passed in the 'params' field
-        assert registry.dispatcher.execute("params_command", params=test_params) == {"params": test_params}
-
-
-class TestCommandRegistryWithModules:
-    """Tests for CommandRegistry with command modules"""
-    
-    @pytest.fixture
-    def temp_module_dir(self):
-        """Creates a temporary directory with command modules for testing"""
-        with tempfile.TemporaryDirectory() as temp_dir:
-            # Create directory structure for modules
-            commands_dir = os.path.join(temp_dir, "commands")
-            test_dir = os.path.join(commands_dir, "test")
-            os.makedirs(test_dir, exist_ok=True)
-            
-            # Create __init__.py files
-            with open(os.path.join(commands_dir, "__init__.py"), "w") as f:
-                f.write("")
-            with open(os.path.join(test_dir, "__init__.py"), "w") as f:
-                f.write("")
-            
-            # Create file with test command
-            test_command_path = os.path.join(temp_dir, "commands", "test", "test_command.py")
-            with open(test_command_path, "w") as f:
-                f.write("""
-from typing import Dict, Any
-
-# Function name needs to match expected test_command in assertions
-def test_command_function(a: int, b: int = 1) -> int:
-    \"\"\"
-    Test command for adding numbers.
-    
-    Args:
-        a: First number
-        b: Second number
-        
-    Returns:
-        int: Sum of numbers
-    \"\"\"
-    return a + b
-
-# This is used to define the command name
-test_command_function.command_name = "test_command"
-
-COMMAND = {
-    "description": "Test command for adding numbers",
-    "parameters": {
-        "a": {
-            "type": "integer",
-            "description": "First number",
-            "required": True
-        },
-        "b": {
-            "type": "integer",
-            "description": "Second number",
-            "required": False,
-            "default": 1
-        }
-    }
-}
-""")
-            
-            # Verify file exists
-            print(f"Created test file at: {test_command_path}")
-            print(f"File exists: {os.path.exists(test_command_path)}")
-            
-            # Add temporary directory path to sys.path
-            sys.path.insert(0, temp_dir)
-            yield temp_dir
-            
-            # Remove path from sys.path
-            sys.path.remove(temp_dir)
-    
-    def test_scan_modules(self, temp_module_dir):
-        """Test scanning modules with commands"""
-        registry = CommandRegistry(strict=True, auto_fix=False)
-        
-        # Scan modules
-        registry.scan_modules(["commands.test"])
-        
-        # Get command handlers
-        handlers = registry.find_command_handlers()
-        
-        # Check that the handler is found
-        assert "test_command" in handlers
-        assert callable(handlers["test_command"])
-    
-    def test_register_all_commands(self, temp_module_dir):
-        """Test registering all commands from modules"""
-        # Create a simple function for testing
-        def test_command(a: int, b: int = 1) -> int:
-            """
-            Test command for adding numbers.
-            
-            Args:
-                a: First number
-                b: Second number
-                
-            Returns:
-                int: Sum of numbers
-            """
-            return a + b
-        
-        # Create registry and register the command directly
-        registry = CommandRegistry(strict=True, auto_fix=False)
-        registry.register_command("test_command", test_command)
-        
-        # Check that the command is registered
-        assert "test_command" in registry.dispatcher.get_valid_commands(), f"Available commands: {registry.dispatcher.get_valid_commands()}"
-        
-        # Check that the command can be executed
-        assert registry.dispatcher.execute("test_command", a=5, b=3) == 8 

tests/test_examples.py

@@ -1,32 +0,0 @@
-import subprocess
-import sys
-import os
-import pytest
-
-EXAMPLES_DIR = os.path.join(os.path.dirname(__file__), "..", "examples")
-
-@pytest.mark.parametrize("script,expected", [
-    ("help_usage.py", ["Project help", "Adapter help"]),
-    ("help_best_practices.py", ["Project help", "Adapter help"]),
-    ("docstring_and_schema_example.py", ["Tool description from docstring", "sum of two numbers"]),
-    ("testing_example.py", ["All tests passed"]),
-    ("extension_example.py", ["Ping", "Help (all)", "Help (ping)", "Help (notfound)"]),
-])
-def test_example_scripts(script, expected):
-    """Test that example script runs and produces expected output."""
-    script_path = os.path.join(EXAMPLES_DIR, script)
-    result = subprocess.run([sys.executable, script_path], capture_output=True, text=True)
-    assert result.returncode == 0, f"{script} failed: {result.stderr}"
-    for key in expected:
-        assert key in result.stdout, f"{script} output missing: {key}"
-
-# FastAPI app smoke-test (project_structure_example.py)
-def test_project_structure_example_import():
-    """Test that project_structure_example.py can be imported and app initialized."""
-    import importlib.util
-    script_path = os.path.join(EXAMPLES_DIR, "project_structure_example.py")
-    spec = importlib.util.spec_from_file_location("project_structure_example", script_path)
-    module = importlib.util.module_from_spec(spec)
-    spec.loader.exec_module(module)
-    assert hasattr(module, "app"), "FastAPI app not found in project_structure_example.py"
-    assert hasattr(module, "adapter"), "Adapter not found in project_structure_example.py"