mcp-proxy-adapter 2.0.1__py3-none-any.whl → 6.9.50__py3-none-any.whl

mcp_proxy_adapter/examples/test_config.py

@@ -0,0 +1,205 @@
+#!/usr/bin/env python3
+"""
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+Script for testing MCP Proxy Adapter configurations.
+Tests a specific configuration by creating an application and validating it.
+Uses mcp_security_framework for security validation.
+"""
+import json
+import os
+import sys
+import argparse
+import time
+from pathlib import Path
+
+# Import mcp_security_framework
+try:
+    from mcp_security_framework import SecurityManager
+    from mcp_security_framework.schemas.config import SecurityConfig
+
+    SECURITY_FRAMEWORK_AVAILABLE = True
+except ImportError:
+    SECURITY_FRAMEWORK_AVAILABLE = False
+    print("Warning: mcp_security_framework not available")
+# Add parent directory to path to import mcp_proxy_adapter
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), "../.."))
+
+
+def validate_config_with_new_system(config: Dict[str, Any]) -> bool:
+    """
+    Validate configuration using the new validation system.
+    Args:
+        config: Configuration dictionary
+    Returns:
+        True if validation passed, False otherwise
+    """
+    try:
+        from mcp_proxy_adapter.core.config_validator import ConfigValidator
+        
+        print("🔍 Validating configuration with new validation system...")
+        validator = ConfigValidator()
+        validator.config_data = config
+        results = validator.validate_config()
+        
+        if results:
+            print("⚠️ Validation issues found:")
+            for result in results:
+                level_symbol = {
+                    "error": "❌",
+                    "warning": "⚠️",
+                    "info": "ℹ️"
+                }[result.level]
+                print(f"  {level_symbol} {result.message}")
+                if result.suggestion:
+                    print(f"     Suggestion: {result.suggestion}")
+            return False
+        else:
+            print("✅ Configuration validation passed!")
+            return True
+            
+    except ImportError:
+        print("⚠️ New validation system not available")
+        return True
+    except Exception as e:
+        print(f"❌ Validation error: {e}")
+        return False
+
+
+def validate_security_config(config: Dict[str, Any]) -> bool:
+    """
+    Validate security configuration using mcp_security_framework (legacy).
+    Args:
+        config: Configuration dictionary
+    Returns:
+        True if validation passed, False otherwise
+    """
+    if not SECURITY_FRAMEWORK_AVAILABLE:
+        print("⚠️ Skipping security validation (mcp_security_framework not available)")
+        return True
+    try:
+        security_section = config.get("security", {})
+        if not security_section.get("enabled", False):
+            print("🔓 Security framework disabled in configuration")
+            return True
+        print("🔒 Validating security configuration with mcp_security_framework...")
+        # Create SecurityConfig from configuration
+        security_config = SecurityConfig(
+            auth=security_section.get("auth", {}),
+            ssl=security_section.get("ssl", {}),
+            permissions=security_section.get("permissions", {}),
+            rate_limit=security_section.get("rate_limit", {}),
+        )
+        # Create SecurityManager for validation
+        security_manager = SecurityManager(security_config)
+        # Validate configuration
+        validation_result = security_manager.validate_configuration()
+        if validation_result.is_valid:
+            print("✅ Security configuration validation passed")
+            return True
+        else:
+            print("❌ Security configuration validation failed:")
+            for error in validation_result.errors:
+                print(f"  - {error}")
+            return False
+    except Exception as e:
+        print(f"❌ Error validating security configuration: {e}")
+        return False
+
+
+def test_configuration(config_path: str, timeout: int = 30) -> bool:
+    """
+    Test a configuration by creating an application and validating it.
+    Args:
+        config_path: Path to configuration file
+        timeout: Timeout in seconds for server startup
+    Returns:
+        True if test passed, False otherwise
+    """
+    print(f"🧪 Testing configuration: {config_path}")
+    print("=" * 60)
+    try:
+        # Load configuration
+        with open(config_path, "r") as f:
+            config = json.load(f)
+        # Import required modules
+        from mcp_proxy_adapter.core.app_factory import create_application
+        from mcp_proxy_adapter.core.app_runner import ApplicationRunner
+
+        # Create application
+        print("🔧 Creating application...")
+        app = create_application(config)
+        print("✅ Application created successfully")
+        # Create runner and validate configuration
+        print("🔍 Validating configuration...")
+        runner = ApplicationRunner(app, config)
+        errors = runner.validate_configuration()
+        if errors:
+            print("❌ Configuration validation failed:")
+            for error in errors:
+                print(f"  - {error}")
+            return False
+        print("✅ Configuration validation passed")
+        # Validate configuration with new system
+        if not validate_config_with_new_system(config):
+            return False
+        
+        # Validate security configuration (legacy)
+        if not validate_security_config(config):
+            return False
+        # Test server startup (without actually starting)
+        print("🚀 Testing server startup...")
+        server_config = config.get("server", {})
+        host = server_config.get("host", "127.0.0.1")
+        port = server_config.get("port", 8000)
+        print(f"✅ Server configuration: {host}:{port}")
+        # Test SSL configuration if enabled
+        ssl_config = config.get("ssl", {})
+        if ssl_config.get("enabled", False):
+            print("🔐 SSL configuration:")
+            print(f"  - Certificate: {ssl_config.get('cert_file', 'N/A')}")
+            print(f"  - Key: {ssl_config.get('key_file', 'N/A')}")
+            print(f"  - Client verification: {ssl_config.get('verify_client', False)}")
+        # Test security configuration if enabled
+        security_config = config.get("security", {})
+        if security_config.get("enabled", False):
+            print("🔒 Security configuration:")
+            auth_config = security_config.get("auth", {})
+            if auth_config.get("enabled", False):
+                methods = auth_config.get("methods", [])
+                print(f"  - Authentication methods: {methods}")
+            permissions_config = security_config.get("permissions", {})
+            if permissions_config.get("enabled", False):
+                print(f"  - Roles file: {permissions_config.get('roles_file', 'N/A')}")
+        # Test protocol configuration
+        protocols_config = config.get("protocols", {})
+        if protocols_config.get("enabled", False):
+            allowed_protocols = protocols_config.get("allowed_protocols", [])
+            print(f"🌐 Allowed protocols: {allowed_protocols}")
+        print("=" * 60)
+        print("✅ Configuration test completed successfully!")
+        return True
+    except Exception as e:
+        print(f"❌ Configuration test failed: {e}")
+        return False
+
+
+def main():
+    """Main function for command line execution."""
+    parser = argparse.ArgumentParser(description="Test MCP Proxy Adapter configuration")
+    parser.add_argument(
+        "--config", "-c", required=True, help="Path to configuration file"
+    )
+    parser.add_argument(
+        "--timeout", "-t", type=int, default=30, help="Timeout in seconds"
+    )
+    args = parser.parse_args()
+    if not os.path.exists(args.config):
+        print(f"❌ Configuration file not found: {args.config}")
+        return 1
+    success = test_configuration(args.config, args.timeout)
+    return 0 if success else 1
+
+
+if __name__ == "__main__":
+    exit(main())

mcp_proxy_adapter/examples/test_config_builder.py

@@ -0,0 +1,110 @@
+#!/usr/bin/env python3
+"""
+Comprehensive Tests for Configuration Builder
+Tests all combinations of protocols, authentication methods, and other parameters.
+
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+"""
+import json
+import tempfile
+from pathlib import Path
+
+from config_builder import ConfigBuilder, ConfigFactory, Protocol, AuthMethod
+
+
+class TestConfigBuilder:
+    """Test cases for ConfigBuilder class."""
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+
+
+class TestConfigFactory:
+    """Test cases for ConfigFactory class."""
+    
+    
+    
+    
+    
+    
+    
+    
+
+
+class TestConfigurationCombinations:
+    """Test all possible combinations of configuration parameters."""
+    
+    
+    
+    
+
+
+def run_comprehensive_tests():
+    """Run comprehensive tests and generate report."""
+    print("🧪 Running Comprehensive Configuration Builder Tests")
+    print("=" * 60)
+    
+    test_classes = [
+        TestConfigBuilder,
+        TestConfigFactory,
+        TestConfigurationCombinations
+    ]
+    
+    total_tests = 0
+    passed_tests = 0
+    failed_tests = []
+    
+    for test_class in test_classes:
+        print(f"\n📋 Testing {test_class.__name__}")
+        print("-" * 40)
+        
+        test_instance = test_class()
+        test_methods = [method for method in dir(test_instance) if method.startswith('test_')]
+        
+        for test_method in test_methods:
+            total_tests += 1
+            try:
+                getattr(test_instance, test_method)()
+                print(f"✅ {test_method}")
+                passed_tests += 1
+            except Exception as e:
+                print(f"❌ {test_method}: {e}")
+                failed_tests.append(f"{test_class.__name__}.{test_method}: {e}")
+    
+    # Print summary
+    print(f"\n{'=' * 60}")
+    print("📊 TEST SUMMARY")
+    print(f"{'=' * 60}")
+    print(f"Total tests: {total_tests}")
+    print(f"Passed: {passed_tests}")
+    print(f"Failed: {len(failed_tests)}")
+    print(f"Success rate: {(passed_tests/total_tests)*100:.1f}%")
+    
+    if failed_tests:
+        print(f"\n❌ Failed tests:")
+        for failure in failed_tests:
+            print(f"   • {failure}")
+    else:
+        print(f"\n🎉 All tests passed!")
+    
+    return len(failed_tests) == 0
+
+
+if __name__ == "__main__":
+    success = run_comprehensive_tests()
+    exit(0 if success else 1)

mcp_proxy_adapter/examples/test_examples.py

@@ -0,0 +1,308 @@
+#!/usr/bin/env python3
+"""
+Test Examples Script
+This script tests all examples with different configurations.
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+"""
+import json
+import os
+import subprocess
+import time
+import requests
+from pathlib import Path
+
+# Configuration for testing
+CONFIGS = {
+    "basic_framework": {
+        "http_simple": {"port": 8000, "ssl": False, "auth": False},
+        "https_simple": {"port": 8443, "ssl": True, "auth": False},
+        "http_auth": {"port": 8001, "ssl": False, "auth": True},
+        "https_auth": {"port": 8444, "ssl": True, "auth": True},
+        "mtls_no_roles": {"port": 9443, "ssl": True, "auth": True, "mtls": True},
+        "mtls_with_roles": {"port": 9444, "ssl": True, "auth": True, "mtls": True},
+    },
+    "full_application": {
+        "http_simple": {"port": 9000, "ssl": False, "auth": False},
+        "https_simple": {"port": 9445, "ssl": True, "auth": False},
+        "http_auth": {"port": 9001, "ssl": False, "auth": True},
+        "https_auth": {"port": 9446, "ssl": True, "auth": True},
+        "mtls_no_roles": {"port": 9447, "ssl": True, "auth": True, "mtls": True},
+        "mtls_with_roles": {"port": 9448, "ssl": True, "auth": True, "mtls": True},
+    },
+}
+API_KEYS = {"admin": "admin-secret-key-123", "user": "user-secret-key-456"}
+
+
+class ExampleTester:
+    """Test examples with different configurations."""
+
+    def __init__(self):
+        self.examples_dir = Path(__file__).parent
+        self.results = {}
+        self.processes = []
+
+    def generate_certificates(self):
+        """Generate certificates for testing."""
+        print("🔐 Generating certificates...")
+        cert_script = self.examples_dir.parent / "generate_certificates.py"
+        if cert_script.exists():
+            result = subprocess.run(
+                [sys.executable, str(cert_script)], capture_output=True, text=True
+            )
+            if result.returncode == 0:
+                print("✅ Certificates generated successfully")
+                return True
+            else:
+                print(f"❌ Certificate generation failed: {result.stderr}")
+                return False
+        else:
+            print(
+                "⚠️ Certificate generation script not found, using existing certificates"
+            )
+            return True
+
+    def start_server(self, example_type: str, config_name: str) -> subprocess.Popen:
+        """Start a server with specific configuration."""
+        config_path = (
+            self.examples_dir / example_type / "configs" / f"{config_name}.json"
+        )
+        main_script = self.examples_dir / example_type / "main.py"
+        if not config_path.exists():
+            raise FileNotFoundError(f"Configuration file not found: {config_path}")
+        if not main_script.exists():
+            raise FileNotFoundError(f"Main script not found: {main_script}")
+        cmd = [sys.executable, str(main_script), "--config", str(config_path)]
+        print(f"🚀 Starting {example_type} server with {config_name} config...")
+        process = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+        # Wait for server to start
+        time.sleep(5)
+        return process
+
+    def test_health_endpoint(
+        self, port: int, ssl: bool = False, auth: bool = False, api_key: str = None
+    ) -> Dict[str, Any]:
+        """Test health endpoint."""
+        protocol = "https" if ssl else "http"
+        url = f"{protocol}://localhost:{port}/health"
+        headers = {}
+        if auth and api_key:
+            headers["X-API-Key"] = api_key
+        try:
+            response = requests.get(url, headers=headers, verify=False, timeout=10)
+            return {
+                "success": True,
+                "status_code": response.status_code,
+                "response": (
+                    response.json()
+                    if response.headers.get("content-type", "").startswith(
+                        "application/json"
+                    )
+                    else response.text
+                ),
+            }
+        except Exception as e:
+            return {"success": False, "error": str(e)}
+
+    def test_echo_command(
+        self, port: int, ssl: bool = False, auth: bool = False, api_key: str = None
+    ) -> Dict[str, Any]:
+        """Test echo command."""
+        protocol = "https" if ssl else "http"
+        url = f"{protocol}://localhost:{port}/cmd"
+        headers = {"Content-Type": "application/json"}
+        if auth and api_key:
+            headers["X-API-Key"] = api_key
+        data = {
+            "jsonrpc": "2.0",
+            "method": "echo",
+            "params": {"message": "Hello from test!"},
+            "id": 1,
+        }
+        try:
+            response = requests.post(
+                url, json=data, headers=headers, verify=False, timeout=10
+            )
+            return {
+                "success": True,
+                "status_code": response.status_code,
+                "response": response.json(),
+            }
+        except Exception as e:
+            return {"success": False, "error": str(e)}
+
+    def test_full_application_commands(
+        self, port: int, ssl: bool = False, auth: bool = False, api_key: str = None
+    ) -> Dict[str, Any]:
+        """Test full application specific commands."""
+        protocol = "https" if ssl else "http"
+        url = f"{protocol}://localhost:{port}/cmd"
+        headers = {"Content-Type": "application/json"}
+        if auth and api_key:
+            headers["X-API-Key"] = api_key
+        results = {}
+        # Test custom echo command
+        data = {
+            "jsonrpc": "2.0",
+            "method": "custom_echo",
+            "params": {"message": "Custom echo test", "repeat": 3},
+            "id": 1,
+        }
+        try:
+            response = requests.post(
+                url, json=data, headers=headers, verify=False, timeout=10
+            )
+            results["custom_echo"] = {
+                "success": True,
+                "status_code": response.status_code,
+                "response": response.json(),
+            }
+        except Exception as e:
+            results["custom_echo"] = {"success": False, "error": str(e)}
+        # Test dynamic calculator command
+        data = {
+            "jsonrpc": "2.0",
+            "method": "dynamic_calculator",
+            "params": {"operation": "add", "a": 10, "b": 5},
+            "id": 2,
+        }
+        try:
+            response = requests.post(
+                url, json=data, headers=headers, verify=False, timeout=10
+            )
+            results["dynamic_calculator"] = {
+                "success": True,
+                "status_code": response.status_code,
+                "response": response.json(),
+            }
+        except Exception as e:
+            results["dynamic_calculator"] = {"success": False, "error": str(e)}
+        return results
+
+    def run_tests(self):
+        """Run all tests."""
+        print("🧪 Starting Example Tests")
+        print("=" * 60)
+        # Generate certificates first
+        if not self.generate_certificates():
+            print("❌ Certificate generation failed, skipping tests")
+            return
+        for example_type, configs in CONFIGS.items():
+            print(f"\n📁 Testing {example_type.upper()}")
+            print("-" * 40)
+            for config_name, config_info in configs.items():
+                print(f"\n🔧 Testing {config_name} configuration...")
+                try:
+                    # Start server
+                    process = self.start_server(example_type, config_name)
+                    self.processes.append(process)
+                    port = config_info["port"]
+                    ssl = config_info.get("ssl", False)
+                    auth = config_info.get("auth", False)
+                    # Test health endpoint
+                    print(f"  📊 Testing health endpoint...")
+                    health_result = self.test_health_endpoint(port, ssl, auth)
+                    print(f"    Health: {'✅' if health_result['success'] else '❌'}")
+                    # Test echo command
+                    print(f"  📝 Testing echo command...")
+                    if auth:
+                        # Test with admin key
+                        echo_result = self.test_echo_command(
+                            port, ssl, auth, API_KEYS["admin"]
+                        )
+                    else:
+                        echo_result = self.test_echo_command(port, ssl, auth)
+                    print(f"    Echo: {'✅' if echo_result['success'] else '❌'}")
+                    # Test full application specific commands
+                    if example_type == "full_application":
+                        print(f"  🔧 Testing full application commands...")
+                        app_results = self.test_full_application_commands(
+                            port, ssl, auth, API_KEYS["admin"] if auth else None
+                        )
+                        for cmd_name, result in app_results.items():
+                            print(
+                                f"    {cmd_name}: {'✅' if result['success'] else '❌'}"
+                            )
+                    # Store results
+                    self.results[f"{example_type}_{config_name}"] = {
+                        "health": health_result,
+                        "echo": echo_result,
+                        "config_info": config_info,
+                    }
+                    if example_type == "full_application":
+                        self.results[f"{example_type}_{config_name}"][
+                            "app_commands"
+                        ] = app_results
+                except Exception as e:
+                    print(f"  ❌ Error testing {config_name}: {e}")
+                    self.results[f"{example_type}_{config_name}"] = {
+                        "error": str(e),
+                        "config_info": config_info,
+                    }
+                finally:
+                    # Stop server
+                    if process:
+                        process.terminate()
+                        process.wait()
+                        time.sleep(2)
+        self.print_results()
+
+    def print_results(self):
+        """Print test results."""
+        print("\n📊 Test Results Summary")
+        print("=" * 60)
+        total_tests = len(self.results)
+        successful_tests = 0
+        for test_name, result in self.results.items():
+            print(f"\n🔍 {test_name}")
+            if "error" in result:
+                print(f"  ❌ Error: {result['error']}")
+                continue
+            # Check health test
+            health_success = result.get("health", {}).get("success", False)
+            print(f"  Health: {'✅' if health_success else '❌'}")
+            # Check echo test
+            echo_success = result.get("echo", {}).get("success", False)
+            print(f"  Echo: {'✅' if echo_success else '❌'}")
+            # Check app commands for full application
+            if "app_commands" in result:
+                app_success = all(
+                    cmd_result.get("success", False)
+                    for cmd_result in result["app_commands"].values()
+                )
+                print(f"  App Commands: {'✅' if app_success else '❌'}")
+            # Overall test success
+            test_success = health_success and echo_success
+            if test_success:
+                successful_tests += 1
+        print(f"\n🎯 Overall Results: {successful_tests}/{total_tests} tests passed")
+        if successful_tests == total_tests:
+            print("🎉 All tests passed!")
+        else:
+            print("⚠️ Some tests failed. Check the details above.")
+
+    def cleanup(self):
+        """Cleanup processes."""
+        for process in self.processes:
+            if process.poll() is None:
+                process.terminate()
+                process.wait()
+
+
+def main():
+    """Main function."""
+    import sys
+
+    tester = ExampleTester()
+    try:
+        tester.run_tests()
+    except KeyboardInterrupt:
+        print("\n🛑 Tests interrupted by user")
+    except Exception as e:
+        print(f"\n❌ Test execution failed: {e}")
+    finally:
+        tester.cleanup()
+
+
+if __name__ == "__main__":
+    main()