mcp-proxy-adapter 6.3.3__py3-none-any.whl → 6.3.5__py3-none-any.whl

mcp_proxy_adapter/examples/run_full_test_suite.py

@@ -12,9 +12,10 @@ import time
 from pathlib import Path
 from typing import List, Dict, Optional
 
+
 class FullTestSuiteRunner:
     """Comprehensive test suite runner that automates the entire testing process."""
-    
+
     def __init__(self):
         """Initialize the test suite runner."""
         self.working_dir = Path.cwd()
@@ -22,92 +23,109 @@ class FullTestSuiteRunner:
         self.certs_dir = self.working_dir / "certs"
         self.keys_dir = self.working_dir / "keys"
         self.roles_file = self.working_dir / "configs" / "roles.json"
-        
+
     def print_step(self, step: str, description: str):
         """Print a formatted step header."""
         print(f"\n{'='*60}")
         print(f"🔧 STEP {step}: {description}")
         print(f"{'='*60}")
-    
+
     def print_success(self, message: str):
         """Print a success message."""
         print(f"✅ {message}")
-    
+
     def print_error(self, message: str):
         """Print an error message."""
         print(f"❌ {message}")
-    
+
     def print_info(self, message: str):
         """Print an info message."""
         print(f"ℹ️  {message}")
-    
+
     def check_environment(self) -> bool:
         """Check if the environment is properly set up."""
         self.print_step("1", "Environment Validation")
-        
+
         # Check if we're in a virtual environment
-        if not hasattr(sys, 'real_prefix') and not (hasattr(sys, 'base_prefix') and sys.base_prefix != sys.prefix):
+        if not hasattr(sys, "real_prefix") and not (
+            hasattr(sys, "base_prefix") and sys.base_prefix != sys.prefix
+        ):
             self.print_error("Not running in a virtual environment!")
             self.print_info("Please activate your virtual environment first:")
             self.print_info("  source venv/bin/activate  # or .venv/bin/activate")
             return False
-        
+
         self.print_success("Virtual environment is active")
-        
+
         # Check if mcp_proxy_adapter is installed
         try:
             import mcp_proxy_adapter
-            self.print_success(f"mcp_proxy_adapter is installed (version: {mcp_proxy_adapter.__version__})")
+
+            self.print_success(
+                f"mcp_proxy_adapter is installed (version: {mcp_proxy_adapter.__version__})"
+            )
         except ImportError:
             self.print_error("mcp_proxy_adapter is not installed!")
             self.print_info("Please install it first:")
             self.print_info("  pip install mcp_proxy_adapter")
             return False
-        
+
         # Check Python version
         python_version = sys.version_info
         if python_version.major >= 3 and python_version.minor >= 8:
-            self.print_success(f"Python version: {python_version.major}.{python_version.minor}.{python_version.micro}")
+            self.print_success(
+                f"Python version: {python_version.major}.{python_version.minor}.{python_version.micro}"
+            )
         else:
-            self.print_error(f"Python {python_version.major}.{python_version.minor} is not supported. Need Python 3.8+")
+            self.print_error(
+                f"Python {python_version.major}.{python_version.minor} is not supported. Need Python 3.8+"
+            )
             return False
-        
+
         return True
-    
+
     def create_directories(self) -> bool:
         """Create necessary directories for testing."""
         self.print_step("2", "Directory Creation")
-        
+
         try:
             # Create configs directory
             self.configs_dir.mkdir(exist_ok=True)
-            self.print_success(f"Created/verified configs directory: {self.configs_dir}")
-            
+            self.print_success(
+                f"Created/verified configs directory: {self.configs_dir}"
+            )
+
             # Create certs directory
             self.certs_dir.mkdir(exist_ok=True)
             self.print_success(f"Created/verified certs directory: {self.certs_dir}")
-            
+
             # Create keys directory
             self.keys_dir.mkdir(exist_ok=True)
             self.print_success(f"Created/verified keys directory: {self.keys_dir}")
-            
+
             return True
-            
+
         except Exception as e:
             self.print_error(f"Failed to create directories: {e}")
             return False
-    
+
     def generate_certificates(self) -> bool:
         """Generate SSL certificates for testing."""
         self.print_step("3", "Certificate Generation")
-        
+
         try:
             # Run certificate generation script
-            cmd = [sys.executable, "-m", "mcp_proxy_adapter.examples.create_certificates_simple"]
+            cmd = [
+                sys.executable,
+                "-m",
+                "mcp_proxy_adapter.examples.create_certificates_simple",
+            ]
             self.print_info("Running certificate generation script...")
-            
-            result = subprocess.run(cmd, capture_output=True, text=True, cwd=self.working_dir)
-            
+
+            result = subprocess.run(
+                cmd, capture_output=True, text=True, cwd=self.working_dir
+            )
+
             if result.returncode == 0:
                 self.print_success("Certificates generated successfully")
                 if result.stdout:
@@ -119,22 +137,28 @@ class FullTestSuiteRunner:
                     print("Error output:")
                     print(result.stderr)
                 return False
-                
+
         except Exception as e:
             self.print_error(f"Failed to generate certificates: {e}")
             return False
-    
+
     def generate_configurations(self) -> bool:
         """Generate test configurations."""
         self.print_step("4", "Configuration Generation")
-        
+
         try:
             # Run configuration generation script
-            cmd = [sys.executable, "-m", "mcp_proxy_adapter.examples.generate_test_configs"]
+            cmd = [
+                sys.executable,
+                "-m",
+                "mcp_proxy_adapter.examples.generate_test_configs",
+            ]
             self.print_info("Running configuration generation script...")
-            
-            result = subprocess.run(cmd, capture_output=True, text=True, cwd=self.working_dir)
-            
+
+            result = subprocess.run(
+                cmd, capture_output=True, text=True, cwd=self.working_dir
+            )
+
             if result.returncode == 0:
                 self.print_success("Configurations generated successfully")
                 if result.stdout:
@@ -146,39 +170,52 @@ class FullTestSuiteRunner:
                     print("Error output:")
                     print(result.stderr)
                 return False
-                
+
         except Exception as e:
             self.print_error(f"Failed to generate configurations: {e}")
             return False
-    
+
     def run_security_tests(self) -> bool:
         """Run the security test suite."""
         self.print_step("5", "Security Testing")
-        
+
         try:
             # Run security tests
-            cmd = [sys.executable, "-m", "mcp_proxy_adapter.examples.run_security_tests", "--verbose"]
+            cmd = [
+                sys.executable,
+                "-m",
+                "mcp_proxy_adapter.examples.run_security_tests",
+                "--verbose",
+            ]
             self.print_info("Running security tests...")
-            
+
             # Debug: show current working directory and check files
             self.print_info(f"DEBUG: Current working directory: {os.getcwd()}")
             self.print_info(f"DEBUG: Working directory from class: {self.working_dir}")
-            
+
             # Check if certificates exist before running tests
             localhost_cert = self.certs_dir / "localhost_server.crt"
-            self.print_info(f"DEBUG: localhost_server.crt exists: {localhost_cert.exists()}")
+            self.print_info(
+                f"DEBUG: localhost_server.crt exists: {localhost_cert.exists()}"
+            )
             if localhost_cert.exists():
-                self.print_info(f"DEBUG: localhost_server.crt is symlink: {localhost_cert.is_symlink()}")
+                self.print_info(
+                    f"DEBUG: localhost_server.crt is symlink: {localhost_cert.is_symlink()}"
+                )
                 if localhost_cert.is_symlink():
-                    self.print_info(f"DEBUG: localhost_server.crt symlink target: {localhost_cert.readlink()}")
-            
+                    self.print_info(
+                        f"DEBUG: localhost_server.crt symlink target: {localhost_cert.readlink()}"
+                    )
+
             # List all files in certs directory
             self.print_info("DEBUG: Files in certs directory:")
             for file in self.certs_dir.iterdir():
                 self.print_info(f"DEBUG:   {file.name} -> {file}")
-            
-            result = subprocess.run(cmd, capture_output=True, text=True, cwd=self.working_dir)
-            
+
+            result = subprocess.run(
+                cmd, capture_output=True, text=True, cwd=self.working_dir
+            )
+
             if result.returncode == 0:
                 self.print_success("Security tests completed successfully!")
                 if result.stdout:
@@ -193,87 +230,85 @@ class FullTestSuiteRunner:
                     print("Error output:")
                     print(result.stderr)
                 return False
-                
+
         except Exception as e:
             self.print_error(f"Failed to run security tests: {e}")
             return False
-    
+
     def cleanup(self):
         """Clean up temporary files and processes."""
         self.print_info("Cleaning up...")
-        
+
         # Simple cleanup - just print success message
         # Process cleanup is handled by the test scripts themselves
         print("✅ Cleanup completed")
-    
-
 
     def cleanup_directories(self) -> bool:
         """Clean up existing test directories before starting."""
         self.print_info("Cleaning up existing test directories...")
-        
+
         try:
             import shutil
-            
+
             # Directories to clean
             dirs_to_clean = [self.configs_dir, self.certs_dir, self.keys_dir]
             files_to_clean = [self.working_dir / "roles.json"]
-            
+
             # Remove directories
             for dir_path in dirs_to_clean:
                 if dir_path.exists():
                     shutil.rmtree(dir_path)
                     print(f"🗑️  Removed directory: {dir_path}")
-            
+
             # Remove files
             for file_path in files_to_clean:
                 if file_path.exists():
                     file_path.unlink()
                     print(f"🗑️  Removed file: {file_path}")
-            
+
             self.print_success("Directory cleanup completed")
             return True
-            
+
         except Exception as e:
             self.print_error(f"Failed to cleanup directories: {e}")
             return False
-    
+
     def run_full_suite(self) -> bool:
         """Run the complete test suite."""
         print("🚀 MCP Proxy Adapter - Full Test Suite")
         print("=" * 60)
         print(f"Working directory: {self.working_dir}")
         print(f"Python executable: {sys.executable}")
-        
+
         try:
             # Step 0: Clean up existing directories
             if not self.cleanup_directories():
                 return False
-            
+
             # Step 1: Environment validation
             if not self.check_environment():
                 return False
-            
+
             # Step 2: Directory creation
             if not self.create_directories():
                 return False
-            
+
             # Step 3: Certificate generation
             if not self.generate_certificates():
                 return False
-            
+
             # Step 4: Configuration generation
             if not self.generate_configurations():
                 return False
-            
+
             # Step 5: Security testing
             if not self.run_security_tests():
                 return False
-            
+
             # All steps completed successfully
             print(f"\n{'='*60}")
             print("🎉 FULL TEST SUITE COMPLETED SUCCESSFULLY!")
-            print("="*60)
+            print("=" * 60)
             print("✅ Environment validated")
             print("✅ Directories cleaned")
             print("✅ Directories created")
@@ -284,9 +319,9 @@ class FullTestSuiteRunner:
             print(f"📁 Configurations: {self.configs_dir}")
             print(f"📁 Certificates: {self.certs_dir}")
             print(f"📁 Keys: {self.keys_dir}")
-            
+
             return True
-            
+
         except KeyboardInterrupt:
             print("\n\n⚠️  Test suite interrupted by user")
             return False
@@ -301,12 +336,14 @@ class FullTestSuiteRunner:
             except Exception as e:
                 self.print_error(f"Cleanup failed in finally block: {e}")
                 import traceback
+
                 traceback.print_exc()
 
+
 def main():
     """Main entry point."""
     runner = FullTestSuiteRunner()
-    
+
     try:
         success = runner.run_full_suite()
         sys.exit(0 if success else 1)
@@ -314,5 +351,6 @@ def main():
         print(f"❌ Fatal error: {e}")
         sys.exit(1)
 
+
 if __name__ == "__main__":
     main()

mcp_proxy_adapter/examples/run_proxy_server.py

@@ -52,7 +52,7 @@ class ProxyRouter:
                 "metadata": registration.metadata,
                 "registered_at": datetime.now().isoformat(),
                 "last_heartbeat": datetime.now().isoformat(),
-                "status": "active"
+                "status": "active",
             }
             print(f"✅ Registered adapter: {adapter_id} at {registration.url}")
             return {"status": "registered", "adapter_id": adapter_id}
@@ -72,7 +72,7 @@ class ProxyRouter:
             """List all registered adapters."""
             return {
                 "adapters": list(registered_adapters.values()),
-                "count": len(registered_adapters)
+                "count": len(registered_adapters),
             }
 
         @self.app.get("/proxy/health")
@@ -81,14 +81,16 @@ class ProxyRouter:
             return {
                 "status": "healthy",
                 "timestamp": datetime.now().isoformat(),
-                "adapters_count": len(registered_adapters)
+                "adapters_count": len(registered_adapters),
             }
 
         @self.app.post("/proxy/heartbeat")
         async def heartbeat(adapter_id: str):
             """Receive heartbeat from adapter."""
             if adapter_id in registered_adapters:
-                registered_adapters[adapter_id]["last_heartbeat"] = datetime.now().isoformat()
+                registered_adapters[adapter_id][
+                    "last_heartbeat"
+                ] = datetime.now().isoformat()
                 return {"status": "ok", "adapter_id": adapter_id}
             else:
                 raise HTTPException(status_code=404, detail="Adapter not found")
@@ -101,10 +103,21 @@ def create_proxy_app() -> FastAPI:
 
 
 def main() -> None:
-    parser = argparse.ArgumentParser(description="Run local proxy server for MCP examples")
-    parser.add_argument("--host", default="127.0.0.1", help="Host to bind to (default: 127.0.0.1)")
-    parser.add_argument("--port", type=int, default=3004, help="Port to bind to (default: 3004)")
-    parser.add_argument("--log-level", default="info", choices=["debug", "info", "warning", "error"], help="Log level")
+    parser = argparse.ArgumentParser(
+        description="Run local proxy server for MCP examples"
+    )
+    parser.add_argument(
+        "--host", default="127.0.0.1", help="Host to bind to (default: 127.0.0.1)"
+    )
+    parser.add_argument(
+        "--port", type=int, default=3004, help="Port to bind to (default: 3004)"
+    )
+    parser.add_argument(
+        "--log-level",
+        default="info",
+        choices=["debug", "info", "warning", "error"],
+        help="Log level",
+    )
 
     args = parser.parse_args()
 
@@ -143,4 +156,4 @@ def main() -> None:
 
 
 if __name__ == "__main__":
-    main()
+    main()