mcp-proxy-adapter 6.3.4__py3-none-any.whl → 6.3.6__py3-none-any.whl

mcp_proxy_adapter/examples/run_security_tests.py

@@ -23,10 +23,17 @@ from typing import Dict, List, Optional, Any, Tuple
 
 import psutil
 import requests
+
 # Import security test client with proper module path
-from mcp_proxy_adapter.examples.security_test_client import SecurityTestClient, TestResult
+from mcp_proxy_adapter.examples.security_test_client import (
+    SecurityTestClient,
+    TestResult,
+)
+
+
 class SecurityTestRunner:
     """Main test runner for security testing."""
+
     def __init__(self):
         """Initialize test runner."""
         self.servers = {}
@@ -43,32 +50,32 @@ class SecurityTestRunner:
                 "config": "configs/http_simple.json",
                 "port": self.base_port + 0,
                 "url": f"http://localhost:{self.base_port + 0}",
-                "auth": "none"
+                "auth": "none",
             },
             "http_token": {
                 "config": "configs/http_token.json",
                 "port": self.base_port + 1,
                 "url": f"http://localhost:{self.base_port + 1}",
-                "auth": "api_key"
+                "auth": "api_key",
             },
             "https": {
                 "config": "configs/https_simple.json",
                 "port": self.base_port + 2,
                 "url": f"https://localhost:{self.base_port + 2}",
-                "auth": "none"
+                "auth": "none",
             },
             "https_token": {
                 "config": "configs/https_token.json",
                 "port": self.base_port + 3,
                 "url": f"https://localhost:{self.base_port + 3}",
-                "auth": "api_key"
+                "auth": "api_key",
             },
             "mtls": {
                 "config": "configs/mtls_no_roles.json",
                 "port": self.base_port + 4,
                 "url": f"https://localhost:{self.base_port + 4}",
-                "auth": "certificate"
-            }
+                "auth": "certificate",
+            },
         }
 
     def _port_in_use(self, port: int, host: str = "127.0.0.1") -> bool:
@@ -159,7 +166,11 @@ class SecurityTestRunner:
                 ssl = data.get("ssl", {})
                 for key in ("cert_file", "key_file", "ca_cert"):
                     exists, abs_path = self._validate_file(base, ssl.get(key))
-                    if ssl.get("enabled") and key in ("cert_file", "key_file") and not exists:
+                    if (
+                        ssl.get("enabled")
+                        and key in ("cert_file", "key_file")
+                        and not exists
+                    ):
                         ok = False
                         missing.append(f"{name}:{key} -> {abs_path}")
                 sec = data.get("security", {})
@@ -178,20 +189,23 @@ class SecurityTestRunner:
         else:
             print("✅ Configuration file paths validated")
         return ok
+
     def check_prerequisites(self) -> bool:
         """Check if all prerequisites are met."""
         print("🔍 Checking prerequisites...")
         # Check if we're in the right directory
         if not Path("configs").exists():
-            print("❌ configs directory not found. Please run from the test environment root directory.")
+            print(
+                "❌ configs directory not found. Please run from the test environment root directory."
+            )
             return False
         # Check if certificates exist
         cert_files = [
-             "certs/mcp_proxy_adapter_ca_ca.crt",
+            "certs/mcp_proxy_adapter_ca_ca.crt",
             "certs/localhost_server.crt",
-            "keys/localhost_server.key"
+            "keys/localhost_server.key",
         ]
-        
+
         missing_certs = []
         # Check if roles.json exists
         roles_file = "configs/roles.json"
@@ -202,11 +216,16 @@ class SecurityTestRunner:
                 missing_certs.append(cert_file)
         if missing_certs:
             print(f"❌ Missing certificates: {missing_certs}")
-            print("💡 Run: python -m mcp_proxy_adapter.examples.setup_test_environment to generate certificates")
+            print(
+                "💡 Run: python -m mcp_proxy_adapter.examples.setup_test_environment to generate certificates"
+            )
             return False
         print("✅ Prerequisites check passed")
         return True
-    def start_server(self, name: str, config_path: str, port: int) -> Optional[subprocess.Popen]:
+
+    def start_server(
+        self, name: str, config_path: str, port: int
+    ) -> Optional[subprocess.Popen]:
         """Start a server in background."""
         try:
             print(f"🚀 Starting {name} server on port {port}...")
@@ -222,14 +241,22 @@ class SecurityTestRunner:
                 print(f"❌ Port {port} is in use, cannot start {name}")
                 return None
             # Start server in background
-            logs_dir = Path("logs"); logs_dir.mkdir(exist_ok=True)
+            logs_dir = Path("logs")
+            logs_dir.mkdir(exist_ok=True)
             log_path = logs_dir / f"{name}.log"
             log_file = open(log_path, "wb")
             self.server_logs[name] = log_file
-            process = subprocess.Popen([
-                sys.executable, "-m", "mcp_proxy_adapter.main",
-                "--config", config_path
-            ], stdout=log_file, stderr=subprocess.STDOUT)
+            process = subprocess.Popen(
+                [
+                    sys.executable,
+                    "-m",
+                    "mcp_proxy_adapter.main",
+                    "--config",
+                    config_path,
+                ],
+                stdout=log_file,
+                stderr=subprocess.STDOUT,
+            )
             # Wait a bit for server to start
             time.sleep(3)
             # Check if process is still running
@@ -242,6 +269,7 @@ class SecurityTestRunner:
         except Exception as e:
             print(f"❌ Error starting {name} server: {e}")
             return None
+
     def stop_server(self, name: str, process: subprocess.Popen):
         """Stop a server."""
         try:
@@ -276,21 +304,30 @@ class SecurityTestRunner:
                 return False
 
             # Start proxy server
-            cmd = [sys.executable, str(proxy_script), "--host", "127.0.0.1", "--port", str(self.proxy_port)]
-            logs_dir = Path("logs"); logs_dir.mkdir(exist_ok=True)
+            cmd = [
+                sys.executable,
+                str(proxy_script),
+                "--host",
+                "127.0.0.1",
+                "--port",
+                str(self.proxy_port),
+            ]
+            logs_dir = Path("logs")
+            logs_dir.mkdir(exist_ok=True)
             proxy_log_path = logs_dir / "proxy_server.log"
             self.proxy_log = open(proxy_log_path, "wb")
             process = subprocess.Popen(
-                cmd,
-                stdout=self.proxy_log,
-                stderr=subprocess.STDOUT,
-                cwd=Path.cwd()
+                cmd, stdout=self.proxy_log, stderr=subprocess.STDOUT, cwd=Path.cwd()
             )
 
             # Check readiness
-            if process.poll() is None and self.wait_for_http(f"http://127.0.0.1:{self.proxy_port}"):
+            if process.poll() is None and self.wait_for_http(
+                f"http://127.0.0.1:{self.proxy_port}"
+            ):
                 self.proxy_server = process
-                print("✅ Proxy server started successfully (PID: {})".format(process.pid))
+                print(
+                    "✅ Proxy server started successfully (PID: {})".format(process.pid)
+                )
                 return True
             else:
                 print("❌ Failed to start proxy server (see logs/proxy_server.log)")
@@ -304,7 +341,11 @@ class SecurityTestRunner:
         """Stop the proxy server."""
         if self.proxy_server:
             try:
-                print("🛑 Stopping proxy server (PID: {})...".format(self.proxy_server.pid))
+                print(
+                    "🛑 Stopping proxy server (PID: {})...".format(
+                        self.proxy_server.pid
+                    )
+                )
                 self.proxy_server.terminate()
                 try:
                     self.proxy_server.wait(timeout=5)
@@ -323,6 +364,7 @@ class SecurityTestRunner:
                         self.proxy_log = None
                 except Exception:
                     pass
+
     async def test_server(self, name: str, config: Dict[str, Any]) -> List[TestResult]:
         """Test a specific server configuration."""
         print(f"\n🧪 Testing {name} server...")
@@ -335,21 +377,18 @@ class SecurityTestRunner:
             client.create_ssl_context = client.create_ssl_context_for_mtls
             async with client as client_session:
                 results = await client_session.run_security_tests(
-                    config["url"],
-                    config["auth"]
+                    config["url"], config["auth"]
                 )
         else:
             # For other auth types, use default SSL context
             async with SecurityTestClient(config["url"]) as client:
-                results = await client.run_security_tests(
-                    config["url"],
-                    config["auth"]
-                )
+                results = await client.run_security_tests(config["url"], config["auth"])
         # Print summary for this server
         passed = sum(1 for r in results if r.success)
         total = len(results)
         print(f"\n📊 {name} Results: {passed}/{total} tests passed")
         return results
+
     async def run_all_tests(self) -> Dict[str, List[TestResult]]:
         """Run tests against all server configurations."""
         print("🚀 Starting comprehensive security testing")
@@ -385,6 +424,7 @@ class SecurityTestRunner:
                 print(f"⚠️ Skipping {name} tests (server not running)")
                 all_results[name] = []
         return all_results
+
     def print_final_summary(self, all_results: Dict[str, List[TestResult]]):
         """Print final test summary."""
         print("\n" + "=" * 80)
@@ -419,11 +459,17 @@ class SecurityTestRunner:
             print("=" * 60)
             print("\n📋 NEXT STEPS:")
             print("1. Start basic framework example:")
-            print("   python -m mcp_proxy_adapter.examples.basic_framework.main --config configs/https_simple.json")
+            print(
+                "   python -m mcp_proxy_adapter.examples.basic_framework.main --config configs/https_simple.json"
+            )
             print("\n2. Start full application example:")
-            print("   python -m mcp_proxy_adapter.examples.full_application.main --config configs/mtls_with_roles.json")
+            print(
+                "   python -m mcp_proxy_adapter.examples.full_application.main --config configs/mtls_with_roles.json"
+            )
             print("\n3. Test with custom configurations:")
-            print("   python -m mcp_proxy_adapter.examples.basic_framework.main --config configs/http_simple.json")
+            print(
+                "   python -m mcp_proxy_adapter.examples.basic_framework.main --config configs/http_simple.json"
+            )
             print("=" * 60)
         elif total_passed > 0:
             print("⚠️ SOME TESTS FAILED")
@@ -433,7 +479,9 @@ class SecurityTestRunner:
             print("\n2. Check if certificates are generated:")
             print("   python -m mcp_proxy_adapter.examples.generate_certificates")
             print("\n3. Verify configuration files exist:")
-            print("   python -m mcp_proxy_adapter.examples.generate_test_configs --output-dir configs")
+            print(
+                "   python -m mcp_proxy_adapter.examples.generate_test_configs --output-dir configs"
+            )
             print("\n4. Check if ports are available (3004, 8000-8005)")
             print("=" * 60)
         else:
@@ -444,10 +492,13 @@ class SecurityTestRunner:
             print("\n2. Generate certificates:")
             print("   python -m mcp_proxy_adapter.examples.generate_certificates")
             print("\n3. Generate configurations:")
-            print("   python -m mcp_proxy_adapter.examples.generate_test_configs --output-dir configs")
+            print(
+                "   python -m mcp_proxy_adapter.examples.generate_test_configs --output-dir configs"
+            )
             print("\n4. Start proxy server manually if needed:")
             print("   python /path/to/run_proxy_server.py --host 127.0.0.1 --port 3004")
             print("=" * 60)
+
     def cleanup(self):
         """Cleanup all running servers and proxy."""
         print("\n🧹 Cleaning up...")
@@ -457,11 +508,13 @@ class SecurityTestRunner:
         self.servers.clear()
         # Stop proxy server
         self.stop_proxy_server()
+
     def signal_handler(self, signum, frame):
         """Handle interrupt signals."""
         print(f"\n⚠️ Received signal {signum}, cleaning up...")
         self.cleanup()
         sys.exit(0)
+
     async def run(self):
         """Main run method."""
         # Set up signal handlers
@@ -501,12 +554,19 @@ class SecurityTestRunner:
         finally:
             # Always cleanup
             self.cleanup()
+
+
 def main():
     """Main function."""
     import argparse
-    parser = argparse.ArgumentParser(description="Security Test Runner for MCP Proxy Adapter")
+
+    parser = argparse.ArgumentParser(
+        description="Security Test Runner for MCP Proxy Adapter"
+    )
     parser.add_argument("--config", help="Test specific configuration")
-    parser.add_argument("--no-cleanup", action="store_true", help="Don't cleanup servers after tests")
+    parser.add_argument(
+        "--no-cleanup", action="store_true", help="Don't cleanup servers after tests"
+    )
     parser.add_argument("--verbose", "-v", action="store_true", help="Verbose output")
     args = parser.parse_args()
 
@@ -540,5 +600,7 @@ def main():
     except Exception as e:
         print(f"❌ Unexpected error: {e}")
         sys.exit(1)
+
+
 if __name__ == "__main__":
     main()

mcp_proxy_adapter/examples/run_security_tests_fixed.py

@@ -15,26 +15,30 @@ import sys
 import time
 from pathlib import Path
 from typing import Dict, List, Optional, Tuple
+
 # Add project root to path
 project_root = Path(__file__).parent.parent.parent
 sys.path.insert(0, str(project_root))
 from security_test_client import SecurityTestClient, TestResult
+
+
 class SecurityTestRunner:
     """Security test runner with proper port management."""
+
     def __init__(self):
         self.project_root = Path(__file__).parent.parent.parent
-        self.configs_dir = self.project_root / "mcp_proxy_adapter" / "examples" / "server_configs"
+        self.configs_dir = (
+            self.project_root / "mcp_proxy_adapter" / "examples" / "server_configs"
+        )
         self.server_processes = {}
         self.test_results = []
+
     def kill_process_on_port(self, port: int) -> bool:
         """Kill process using specific port."""
         try:
             # Find process using the port
             result = subprocess.run(
-                ["lsof", "-ti", f":{port}"],
-                capture_output=True,
-                text=True,
-                timeout=5
+                ["lsof", "-ti", f":{port}"], capture_output=True, text=True, timeout=5
             )
             if result.returncode == 0 and result.stdout.strip():
                 pid = result.stdout.strip()
@@ -52,7 +56,10 @@ class SecurityTestRunner:
         except Exception as e:
             print(f"❌ Error killing process on port {port}: {e}")
             return False
-    def start_server(self, config_name: str, config_path: Path) -> Optional[subprocess.Popen]:
+
+    def start_server(
+        self, config_name: str, config_path: Path
+    ) -> Optional[subprocess.Popen]:
         """Start server with proper error handling."""
         try:
             # Get port from config
@@ -63,8 +70,11 @@ class SecurityTestRunner:
             self.kill_process_on_port(port)
             # Start server
             cmd = [
-                sys.executable, "-m", "mcp_proxy_adapter.main",
-                "--config", str(config_path)
+                sys.executable,
+                "-m",
+                "mcp_proxy_adapter.main",
+                "--config",
+                str(config_path),
             ]
             # For mTLS, start from examples directory
             if config_name == "mtls":
@@ -73,11 +83,7 @@ class SecurityTestRunner:
                 cwd = self.project_root
             print(f"🚀 Starting {config_name} on port {port}...")
             process = subprocess.Popen(
-                cmd,
-                cwd=cwd,
-                stdout=subprocess.PIPE,
-                stderr=subprocess.PIPE,
-                text=True
+                cmd, cwd=cwd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True
             )
             # Wait a bit for server to start
             time.sleep(3)
@@ -94,6 +100,7 @@ class SecurityTestRunner:
         except Exception as e:
             print(f"❌ Error starting {config_name}: {e}")
             return None
+
     def stop_server(self, config_name: str, process: subprocess.Popen):
         """Stop server gracefully."""
         try:
@@ -107,32 +114,43 @@ class SecurityTestRunner:
             process.wait()
         except Exception as e:
             print(f"❌ Error stopping {config_name}: {e}")
-    async def test_server(self, config_name: str, config_path: Path) -> List[TestResult]:
+
+    async def test_server(
+        self, config_name: str, config_path: Path
+    ) -> List[TestResult]:
         """Test a single server configuration."""
         results = []
         # Start server
         process = self.start_server(config_name, config_path)
         if not process:
-            return [TestResult(
-                test_name=f"{config_name}_startup",
-                server_url=f"http://localhost:{port}",
-                auth_type="none",
-                success=False,
-                error_message="Server failed to start"
-            )]
+            return [
+                TestResult(
+                    test_name=f"{config_name}_startup",
+                    server_url=f"http://localhost:{port}",
+                    auth_type="none",
+                    success=False,
+                    error_message="Server failed to start",
+                )
+            ]
         try:
             # Get config for client setup
             with open(config_path) as f:
                 config = json.load(f)
             port = config.get("server", {}).get("port", 8000)
-            auth_enabled = config.get("security", {}).get("auth", {}).get("enabled", False)
+            auth_enabled = (
+                config.get("security", {}).get("auth", {}).get("enabled", False)
+            )
             auth_methods = config.get("security", {}).get("auth", {}).get("methods", [])
             # Create test client with correct protocol
-            protocol = "https" if config.get("ssl", {}).get("enabled", False) else "http"
+            protocol = (
+                "https" if config.get("ssl", {}).get("enabled", False) else "http"
+            )
             client = SecurityTestClient(base_url=f"{protocol}://localhost:{port}")
             client.auth_enabled = auth_enabled
             client.auth_methods = auth_methods
-            client.api_keys = config.get("security", {}).get("auth", {}).get("api_keys", {})
+            client.api_keys = (
+                config.get("security", {}).get("auth", {}).get("api_keys", {})
+            )
             # For mTLS, override SSL context creation and change working directory
             if config_name == "mtls":
                 client.create_ssl_context = client.create_ssl_context_for_mtls
@@ -140,6 +158,7 @@ class SecurityTestRunner:
                 client.auth_methods = ["certificate"]
                 # Change to examples directory for mTLS tests
                 import os
+
                 os.chdir(self.project_root / "mcp_proxy_adapter" / "examples")
             # Run tests
             async with client:
@@ -157,13 +176,19 @@ class SecurityTestRunner:
                     result = await client.test_negative_authentication()
                     results.append(result)
                     # Test 5: Role-based access
-                    result = await client.test_role_based_access(client.base_url, "api_key")
+                    result = await client.test_role_based_access(
+                        client.base_url, "api_key"
+                    )
                     results.append(result)
                     # Test 6: Role permissions
-                    result = await client.test_role_permissions(client.base_url, "api_key")
+                    result = await client.test_role_permissions(
+                        client.base_url, "api_key"
+                    )
                     results.append(result)
                     # Test 7: Multiple roles test
-                    result = await client.test_multiple_roles(client.base_url, "api_key")
+                    result = await client.test_multiple_roles(
+                        client.base_url, "api_key"
+                    )
                     results.append(result)
                 else:
                     # Test 3: No authentication required
@@ -173,17 +198,20 @@ class SecurityTestRunner:
                     result = await client.test_negative_authentication()
                     results.append(result)
         except Exception as e:
-            results.append(TestResult(
-                test_name=f"{config_name}_client_error",
-                server_url=f"http://localhost:{port}",
-                auth_type="none",
-                success=False,
-                error_message=str(e)
-            ))
+            results.append(
+                TestResult(
+                    test_name=f"{config_name}_client_error",
+                    server_url=f"http://localhost:{port}",
+                    auth_type="none",
+                    success=False,
+                    error_message=str(e),
+                )
+            )
         finally:
             # Stop server
             self.stop_server(config_name, process)
         return results
+
     async def run_all_tests(self):
         """Run all security tests."""
         print("🔒 Starting Security Testing Suite")
@@ -194,7 +222,7 @@ class SecurityTestRunner:
             ("http_token", "config_http_token.json"),
             ("https", "config_https.json"),
             ("https_token", "config_https_token.json"),
-            ("mtls", "config_mtls.json")
+            ("mtls", "config_mtls.json"),
         ]
         total_tests = 0
         passed_tests = 0
@@ -221,7 +249,11 @@ class SecurityTestRunner:
         print(f"Total tests: {total_tests}")
         print(f"Passed: {passed_tests}")
         print(f"Failed: {total_tests - passed_tests}")
-        print(f"Success rate: {(passed_tests/total_tests*100):.1f}%" if total_tests > 0 else "N/A")
+        print(
+            f"Success rate: {(passed_tests/total_tests*100):.1f}%"
+            if total_tests > 0
+            else "N/A"
+        )
         # Detailed results
         print("\n📋 DETAILED RESULTS")
         print("-" * 30)
@@ -231,6 +263,8 @@ class SecurityTestRunner:
             if not result.success and result.error_message:
                 print(f"   Error: {result.error_message}")
         return passed_tests == total_tests
+
+
 async def main():
     """Main function."""
     runner = SecurityTestRunner()
@@ -243,5 +277,7 @@ async def main():
     except Exception as e:
         print(f"\n❌ Testing failed: {e}")
         sys.exit(1)
+
+
 if __name__ == "__main__":
     asyncio.run(main())