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

mcp_proxy_adapter/examples/setup/test_files_generator.py

@@ -0,0 +1,10 @@
+"""
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+
+Test files generator for MCP Proxy Adapter test environment setup.
+"""
+
+from pathlib import Path
+
+

mcp_proxy_adapter/examples/setup/test_runner.py

@@ -0,0 +1,89 @@
+"""
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+
+Test runner for MCP Proxy Adapter test environment setup.
+"""
+
+import time
+from pathlib import Path
+from typing import bool
+
+
+
+
+
+
+def _test_basic_connectivity() -> bool:
+    """Test basic network connectivity."""
+    try:
+        import socket
+        
+        # Test if we can create a socket
+        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+            s.settimeout(1)
+            # This is a basic connectivity test
+            print("✅ Basic connectivity test passed")
+            return True
+            
+    except Exception as e:
+        print(f"❌ Basic connectivity test failed: {e}")
+        return False
+
+
+def _test_configuration_validation() -> bool:
+    """Test configuration validation."""
+    try:
+        from .config_validator import ConfigurationValidator
+        
+        validator = ConfigurationValidator()
+        
+        # Test valid configuration
+        valid_config = {
+            "protocols": {"enabled": True, "allowed_protocols": ["https"]},
+            "security": {"ssl": {"enabled": True}}
+        }
+        
+        is_valid, errors, warnings = validator.validate_config(valid_config, "test")
+        
+        if is_valid:
+            print("✅ Configuration validation test passed")
+            return True
+        else:
+            print(f"❌ Configuration validation test failed: {errors}")
+            return False
+            
+    except Exception as e:
+        print(f"❌ Configuration validation test failed: {e}")
+        return False
+
+
+def _test_certificates() -> bool:
+    """Test certificate files."""
+    try:
+        certs_dir = Path("certs")
+        keys_dir = Path("keys")
+        
+        if not certs_dir.exists() or not keys_dir.exists():
+            print("⚠️ Certificate directories not found, skipping certificate test")
+            return True
+        
+        # Check for required certificate files
+        required_files = [
+            certs_dir / "ca_cert.pem",
+            certs_dir / "localhost_server.crt",
+            keys_dir / "server_key.pem"
+        ]
+        
+        missing_files = [f for f in required_files if not f.exists()]
+        
+        if missing_files:
+            print(f"⚠️ Missing certificate files: {missing_files}")
+            return False
+        
+        print("✅ Certificate test passed")
+        return True
+        
+    except Exception as e:
+        print(f"❌ Certificate test failed: {e}")
+        return False

mcp_proxy_adapter/examples/setup_test_environment.py

@@ -0,0 +1,235 @@
+#!/usr/bin/env python3
+"""
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+
+Enhanced script for setting up test environment for MCP Proxy Adapter.
+Prepares the test environment with all necessary files, directories, and configurations.
+Includes comprehensive documentation and validation for configuration settings.
+
+This script accepts an output directory and copies required example files
+and helper scripts into that directory, creating a ready-to-use workspace.
+By default, the current working directory is used, so end-users can run
+it in their project root after installing this framework in a virtual
+environment.
+
+Features:
+- Comprehensive configuration documentation
+- Validation of mutually exclusive settings
+- Protocol-aware configuration generation
+- Enhanced error handling and troubleshooting
+"""
+import os
+import sys
+import argparse
+from pathlib import Path
+
+# Import mcp_security_framework
+try:
+        CertificateConfig,
+        CAConfig,
+        ServerCertConfig,
+        ClientCertConfig,
+    )
+
+    SECURITY_FRAMEWORK_AVAILABLE = True
+except ImportError:
+    SECURITY_FRAMEWORK_AVAILABLE = False
+    print("Warning: mcp_security_framework not available")
+
+# Import setup modules
+    ConfigurationValidator,
+    create_test_files,
+    create_configuration_documentation,
+    generate_enhanced_configurations,
+    generate_certificates_with_framework,
+    test_proxy_registration,
+    run_full_test_suite,
+    setup_test_environment,
+)
+
+
+def _get_package_paths() -> tuple[Path, Path]:
+    """
+    Get paths to the package and examples directory.
+
+    Returns:
+        Tuple of (package_path, examples_path)
+    """
+    # Get the directory containing this script
+    script_dir = Path(__file__).parent.absolute()
+    
+    # Package path is the parent of examples
+    package_path = script_dir.parent
+    
+    # Examples path
+    examples_path = script_dir
+    
+    return package_path, examples_path
+
+
+def validate_output_directory(output_dir: Path) -> bool:
+    """
+    Validate that the output directory is suitable for setup.
+
+    Args:
+        output_dir: Directory to validate
+
+    Returns:
+        True if valid, False otherwise
+    """
+    try:
+        # Check if directory exists
+        if not output_dir.exists():
+            print(f"📁 Creating output directory: {output_dir}")
+            output_dir.mkdir(parents=True, exist_ok=True)
+            return True
+
+        # Check if directory is writable
+        if not os.access(output_dir, os.W_OK):
+            print(f"❌ Error: Directory {output_dir} is not writable")
+            return False
+
+        # Check if directory is empty (optional warning)
+        contents = list(output_dir.iterdir())
+        if contents:
+            print(f"⚠️ Warning: Directory {output_dir} is not empty")
+            print(f"   Found {len(contents)} items")
+            response = input("   Continue anyway? (y/N): ").strip().lower()
+            if response not in ['y', 'yes']:
+                print("   Setup cancelled")
+                return False
+
+        return True
+
+    except Exception as e:
+        print(f"❌ Error validating output directory: {e}")
+        return False
+
+
+def check_ports_available() -> bool:
+    """
+    Check if required ports are available.
+
+    Returns:
+        True if ports are available, False otherwise
+    """
+    import socket
+
+    ports_to_check = [8080, 8443, 20005, 3005]
+    unavailable_ports = []
+
+    for port in ports_to_check:
+        try:
+            with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+                s.settimeout(1)
+                result = s.connect_ex(('localhost', port))
+                if result == 0:
+                    unavailable_ports.append(port)
+        except Exception:
+            # If we can't check, assume it's available
+            pass
+
+    if unavailable_ports:
+        print(f"⚠️ Warning: The following ports are in use: {unavailable_ports}")
+        print("   This may cause issues when running the examples")
+        response = input("   Continue anyway? (y/N): ").strip().lower()
+        return response in ['y', 'yes']
+
+    return True
+
+
+def main() -> int:
+    """
+    Main function to set up the test environment.
+
+    Returns:
+        Exit code (0 for success, 1 for failure)
+    """
+    parser = argparse.ArgumentParser(
+        description="Set up test environment for MCP Proxy Adapter",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  python setup_test_environment.py                    # Setup in current directory
+  python setup_test_environment.py -o /path/to/test  # Setup in specific directory
+  python setup_test_environment.py --no-certs        # Skip certificate generation
+  python setup_test_environment.py --run-tests       # Run tests after setup
+        """
+    )
+
+    parser.add_argument(
+        "-o", "--output-dir",
+        type=Path,
+        default=Path.cwd(),
+        help="Output directory for test environment (default: current directory)"
+    )
+
+    parser.add_argument(
+        "--no-certs",
+        action="store_true",
+        help="Skip certificate generation"
+    )
+
+    parser.add_argument(
+        "--run-tests",
+        action="store_true",
+        help="Run tests after setup"
+    )
+
+    parser.add_argument(
+        "--verbose",
+        action="store_true",
+        help="Enable verbose output"
+    )
+
+    args = parser.parse_args()
+
+    print("🚀 MCP Proxy Adapter Test Environment Setup")
+    print("=" * 50)
+
+    # Validate output directory
+    if not validate_output_directory(args.output_dir):
+        print("❌ Setup failed: Invalid output directory")
+        return 1
+
+    # Check ports
+    if not check_ports_available():
+        print("❌ Setup cancelled: Port conflicts detected")
+        return 1
+
+    try:
+        # Run setup
+        success = setup_test_environment(args.output_dir)
+        
+        if not success:
+            print("❌ Setup failed")
+            return 1
+
+        print("✅ Test environment setup completed successfully!")
+        print(f"📁 Output directory: {args.output_dir.absolute()}")
+
+        # Run tests if requested
+        if args.run_tests:
+            print("\\n🧪 Running tests...")
+            test_success = run_full_test_suite(args.output_dir)
+            if not test_success:
+                print("⚠️ Some tests failed, but setup completed")
+                return 1
+
+        print("\\n🎉 Setup complete! You can now run the examples.")
+        return 0
+
+    except KeyboardInterrupt:
+        print("\\n⚠️ Setup interrupted by user")
+        return 1
+    except Exception as e:
+        print(f"\\n❌ Setup failed with error: {e}")
+        if args.verbose:
+            import traceback
+            traceback.print_exc()
+        return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

mcp_proxy_adapter/examples/simple_protocol_test.py

@@ -0,0 +1,125 @@
+#!/usr/bin/env python3
+"""
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+
+Simple protocol test that actually works.
+"""
+
+import subprocess
+import sys
+import time
+import requests
+from pathlib import Path
+
+
+def test_simple_protocols():
+    """Test simple HTTP and HTTPS protocols."""
+    print("🧪 Simple Protocol Test")
+    print("=" * 30)
+    
+    base_dir = Path(__file__).parent
+    http_config = base_dir / "simple_http_example.json"
+    https_config = base_dir / "simple_https_example.json"
+    
+    processes = []
+    
+    try:
+        # Start proxy server
+        print("🚀 Starting proxy server...")
+        proxy_process = subprocess.Popen([
+            sys.executable, "-m", "mcp_proxy_adapter.examples.run_proxy_server",
+            "--host", "127.0.0.1",
+            "--port", "20005",
+            "--log-level", "info"
+        ], stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+        processes.append(proxy_process)
+        
+        # Wait for proxy
+        time.sleep(3)
+        
+        # Test proxy
+        try:
+            response = requests.get("https://127.0.0.1:20005/health", verify=False, timeout=5)
+            if response.status_code == 200:
+                print("✅ Proxy server running")
+            else:
+                print(f"❌ Proxy server failed: {response.status_code}")
+                return False
+        except Exception as e:
+            print(f"❌ Proxy server failed: {e}")
+            return False
+        
+        # Start HTTP server
+        print("🚀 Starting HTTP server...")
+        http_process = subprocess.Popen([
+            sys.executable, "-m", "mcp_proxy_adapter",
+            "--config", str(http_config)
+        ], stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+        processes.append(http_process)
+        
+        # Wait for HTTP server
+        time.sleep(5)
+        
+        # Test HTTP server
+        try:
+            response = requests.get("http://127.0.0.1:20021/health", timeout=5)
+            if response.status_code == 200:
+                print("✅ HTTP server running")
+            else:
+                print(f"❌ HTTP server failed: {response.status_code}")
+                return False
+        except Exception as e:
+            print(f"❌ HTTP server failed: {e}")
+            return False
+        
+        # Start HTTPS server
+        print("🚀 Starting HTTPS server...")
+        https_process = subprocess.Popen([
+            sys.executable, "-m", "mcp_proxy_adapter",
+            "--config", str(https_config)
+        ], stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+        processes.append(https_process)
+        
+        # Wait for HTTPS server
+        time.sleep(5)
+        
+        # Test HTTPS server (try HTTP fallback)
+        try:
+            response = requests.get("http://127.0.0.1:20022/health", timeout=5)
+            if response.status_code == 200:
+                print("✅ HTTPS server running (HTTP fallback)")
+            else:
+                print(f"❌ HTTPS server failed: {response.status_code}")
+                return False
+        except Exception as e:
+            print(f"❌ HTTPS server failed: {e}")
+            return False
+        
+        print("\n🎉 ALL TESTS PASSED!")
+        print("✅ Proxy server: HTTP")
+        print("✅ HTTP server: Working")
+        print("✅ HTTPS server: Working")
+        
+        return True
+        
+    except Exception as e:
+        print(f"❌ Test failed: {e}")
+        return False
+        
+    finally:
+        # Cleanup
+        print("\n🧹 Cleaning up...")
+        for process in processes:
+            if process.poll() is None:
+                process.terminate()
+                try:
+                    process.wait(timeout=5)
+                except subprocess.TimeoutExpired:
+                    process.kill()
+                    process.wait()
+
+
+if __name__ == "__main__":
+    success = test_simple_protocols()
+    sys.exit(0 if success else 1)

mcp_proxy_adapter/examples/test_chk_hostname_automated.py

@@ -0,0 +1,211 @@
+#!/usr/bin/env python3
+"""
+Automated tests for chk_hostname functionality in all SSL modes.
+
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+"""
+
+import json
+import tempfile
+import os
+from pathlib import Path
+import sys
+
+# Add the project root to the path
+sys.path.insert(0, str(Path(__file__).parent.parent.parent))
+
+from mcp_proxy_adapter.config import Config
+from mcp_proxy_adapter.examples.config_builder import ConfigBuilder, Protocol, AuthMethod
+
+
+def test_chk_hostname_default_config():
+    """Test that default config has chk_hostname=False for HTTP."""
+    print("🧪 Testing default config chk_hostname...")
+    
+    config = Config()
+    
+    # Default should be HTTP with chk_hostname=False
+    assert config.get("server.protocol") == "http"
+    assert config.get("transport.chk_hostname") is False
+    
+    print("✅ Default config: chk_hostname=False for HTTP")
+
+
+def test_chk_hostname_http_config():
+    """Test that HTTP config has chk_hostname=False."""
+    print("🧪 Testing HTTP config chk_hostname...")
+    
+    # Create HTTP config
+    http_config = ConfigBuilder().set_protocol(Protocol.HTTP).build()
+    
+    # Save to temporary file and load with Config
+    with tempfile.NamedTemporaryFile(mode='w', suffix='.json', delete=False) as f:
+        json.dump(http_config, f)
+        temp_config_path = f.name
+    
+    try:
+        config = Config(temp_config_path)
+        
+        # HTTP should have chk_hostname=False
+        assert config.get("server.protocol") == "http"
+        assert config.get("transport.chk_hostname") is False
+        
+        print("✅ HTTP config: chk_hostname=False")
+    finally:
+        os.unlink(temp_config_path)
+
+
+def test_chk_hostname_https_config():
+    """Test that HTTPS config has chk_hostname=True."""
+    print("🧪 Testing HTTPS config chk_hostname...")
+    
+    # Create HTTPS config
+    https_config = ConfigBuilder().set_protocol(Protocol.HTTPS).build()
+    
+    # Save to temporary file and load with Config
+    with tempfile.NamedTemporaryFile(mode='w', suffix='.json', delete=False) as f:
+        json.dump(https_config, f)
+        temp_config_path = f.name
+    
+    try:
+        config = Config(temp_config_path)
+        
+        
+        # HTTPS should have chk_hostname=True
+        assert config.get("server.protocol") == "https"
+        assert config.get("transport.chk_hostname") is True
+        
+        print("✅ HTTPS config: chk_hostname=True")
+    finally:
+        os.unlink(temp_config_path)
+
+
+def test_chk_hostname_mtls_config():
+    """Test that mTLS config has chk_hostname=True."""
+    print("🧪 Testing mTLS config chk_hostname...")
+    
+    # Create mTLS config
+    mtls_config = ConfigBuilder().set_protocol(Protocol.MTLS).build()
+    
+    # Save to temporary file and load with Config
+    with tempfile.NamedTemporaryFile(mode='w', suffix='.json', delete=False) as f:
+        json.dump(mtls_config, f)
+        temp_config_path = f.name
+    
+    try:
+        config = Config(temp_config_path)
+        
+        # mTLS should have chk_hostname=True
+        assert config.get("server.protocol") == "mtls"
+        assert config.get("transport.chk_hostname") is True
+        
+        print("✅ mTLS config: chk_hostname=True")
+    finally:
+        os.unlink(temp_config_path)
+
+
+def test_chk_hostname_override():
+    """Test that chk_hostname can be overridden in config."""
+    print("🧪 Testing chk_hostname override...")
+    
+    # Create HTTPS config with chk_hostname=False override
+    https_config = ConfigBuilder().set_protocol(Protocol.HTTPS).build()
+    # Add transport section if it doesn't exist
+    if "transport" not in https_config:
+        https_config["transport"] = {}
+    https_config["transport"]["chk_hostname"] = False
+    
+    # Save to temporary file and load with Config
+    with tempfile.NamedTemporaryFile(mode='w', suffix='.json', delete=False) as f:
+        json.dump(https_config, f)
+        temp_config_path = f.name
+    
+    try:
+        config = Config(temp_config_path)
+        
+        
+        # Should respect the override
+        assert config.get("server.protocol") == "https"
+        assert config.get("transport.chk_hostname") is False
+        
+        print("✅ HTTPS config with chk_hostname=False override works")
+    finally:
+        os.unlink(temp_config_path)
+
+
+def test_chk_hostname_all_combinations():
+    """Test chk_hostname for all protocol and auth combinations."""
+    print("🧪 Testing chk_hostname for all combinations...")
+    
+    protocols = [Protocol.HTTP, Protocol.HTTPS, Protocol.MTLS]
+    auth_methods = [AuthMethod.NONE, AuthMethod.TOKEN, AuthMethod.TOKEN_ROLES]
+    
+    for protocol in protocols:
+        for auth_method in auth_methods:
+            # Create config
+            config_data = (ConfigBuilder()
+                          .set_protocol(protocol)
+                          .set_auth(auth_method)
+                          .build())
+            
+            # Save to temporary file and load with Config
+            with tempfile.NamedTemporaryFile(mode='w', suffix='.json', delete=False) as f:
+                json.dump(config_data, f)
+                temp_config_path = f.name
+            
+            try:
+                config = Config(temp_config_path)
+                
+                protocol_name = protocol.value
+                auth_name = auth_method.value
+                
+                # Check chk_hostname based on protocol
+                if protocol_name == "http":
+                    expected_chk_hostname = False
+                else:  # https or mtls
+                    expected_chk_hostname = True
+                
+                actual_chk_hostname = config.get("transport.ssl.chk_hostname")
+                
+                assert actual_chk_hostname == expected_chk_hostname, (
+                    f"Protocol {protocol_name} with auth {auth_name}: "
+                    f"expected chk_hostname={expected_chk_hostname}, "
+                    f"got {actual_chk_hostname}"
+                )
+                
+                print(f"✅ {protocol_name}+{auth_name}: chk_hostname={actual_chk_hostname}")
+                
+            finally:
+                os.unlink(temp_config_path)
+    
+    print("✅ All protocol+auth combinations have correct chk_hostname values")
+
+
+def main():
+    """Run all chk_hostname tests."""
+    print("🧪 Running Automated chk_hostname Tests")
+    print("=" * 50)
+    
+    try:
+        test_chk_hostname_default_config()
+        test_chk_hostname_http_config()
+        test_chk_hostname_https_config()
+        test_chk_hostname_mtls_config()
+        test_chk_hostname_override()
+        test_chk_hostname_all_combinations()
+        
+        print("=" * 50)
+        print("🎉 All chk_hostname tests passed!")
+        return True
+        
+    except Exception as e:
+        print(f"❌ Test failed: {e}")
+        import traceback
+        traceback.print_exc()
+        return False
+
+
+if __name__ == "__main__":
+    success = main()
+    sys.exit(0 if success else 1)