mcp-security-framework 1.1.0__py3-none-any.whl → 1.1.1__py3-none-any.whl

mcp_security_framework/examples/test_all_examples.py

@@ -14,25 +14,25 @@ Version: 1.0.0
 License: MIT
 """
 
-import os
-import sys
 import json
+import os
 import shutil
 import subprocess
+import sys
 import tempfile
-from pathlib import Path
-from typing import Dict, List, Tuple, Optional
-from datetime import datetime
 import traceback
+from datetime import datetime
+from pathlib import Path
+from typing import Dict, List, Optional, Tuple
 
 
 class ExampleTester:
     """Test runner for all MCP Security Framework examples."""
-    
+
     def __init__(self, test_dir: Optional[str] = None, install_deps: bool = True):
         """
         Initialize the example tester.
-        
+
         Args:
             test_dir: Directory for test environment. If None, creates temporary directory.
             install_deps: Whether to install missing dependencies automatically.
@@ -42,79 +42,74 @@ class ExampleTester:
         self.results: Dict[str, Dict] = {}
         self.errors: List[str] = []
         self.warnings: List[str] = []
-        
+
         # Example files to test
         self.examples = [
             "standalone_example.py",
-            "fastapi_example.py", 
+            "fastapi_example.py",
             "flask_example.py",
             "django_example.py",
             "gateway_example.py",
             "microservice_example.py",
-            "comprehensive_example.py"
+            "comprehensive_example.py",
         ]
-        
+
         # Required dependencies for examples
         self.required_deps = {
             "django_example.py": ["django"],
             "gateway_example.py": ["aiohttp"],
-            "microservice_example.py": ["aiohttp"]
+            "microservice_example.py": ["aiohttp"],
         }
-        
+
         print(f"🔧 Test environment: {self.test_dir}")
         if not self.install_deps:
             print("⚠️  Automatic dependency installation disabled")
-    
+
     def setup_environment(self) -> bool:
         """
         Set up the test environment with all required files and dependencies.
-        
+
         Returns:
             bool: True if setup was successful
         """
         print("\n📁 Setting up test environment...")
-        
+
         try:
             # Create required directories
             self._create_directories()
-            
+
             # Create configuration files
             self._create_config_files()
-            
+
             # Create dummy certificates
             self._create_certificates()
-            
+
             # Check dependencies
             self._check_dependencies()
-            
+
             # Install missing dependencies if enabled
             if self.install_deps:
                 if not self._install_missing_dependencies():
                     print("❌ Failed to install missing dependencies")
                     return False
-            
+
             print("✅ Environment setup completed successfully")
             return True
-            
+
         except Exception as e:
             self.errors.append(f"Environment setup failed: {str(e)}")
             print(f"❌ Environment setup failed: {str(e)}")
             return False
-    
+
     def _create_directories(self):
         """Create required directories for examples."""
-        directories = [
-            "certs",
-            "config", 
-            "logs",
-            "keys"
-        ]
-        
+        directories = ["certs", "config", "logs", "keys"]
+
         for directory in directories:
             dir_path = os.path.join(self.test_dir, directory)
             os.makedirs(dir_path, exist_ok=True)
             print(f"  📂 Created directory: {directory}")
-    
+
     def _create_config_files(self):
         """Create configuration files for examples."""
         # Create roles configuration
@@ -123,58 +118,58 @@ class ExampleTester:
                 "admin": {
                     "description": "Administrator role",
                     "permissions": ["*"],
-                    "parent_roles": []
+                    "parent_roles": [],
                 },
                 "user": {
-                    "description": "User role", 
+                    "description": "User role",
                     "permissions": ["read", "write"],
-                    "parent_roles": []
+                    "parent_roles": [],
                 },
                 "readonly": {
                     "description": "Read Only role",
                     "permissions": ["read"],
-                    "parent_roles": []
-                }
+                    "parent_roles": [],
+                },
             }
         }
-        
+
         roles_file = os.path.join(self.test_dir, "config", "roles.json")
-        with open(roles_file, 'w') as f:
+        with open(roles_file, "w") as f:
             json.dump(roles_config, f, indent=2)
-        
+
         print(f"  📄 Created roles configuration: config/roles.json")
-    
+
     def _create_certificates(self):
         """Create dummy SSL certificates for testing."""
         certs_dir = os.path.join(self.test_dir, "certs")
-        
+
         # Server certificate
         server_cert = os.path.join(certs_dir, "server.crt")
-        with open(server_cert, 'w') as f:
+        with open(server_cert, "w") as f:
             f.write("-----BEGIN CERTIFICATE-----\n")
             f.write("DUMMY SERVER CERTIFICATE FOR TESTING\n")
             f.write("-----END CERTIFICATE-----\n")
-        
+
         # Server private key
         server_key = os.path.join(certs_dir, "server.key")
-        with open(server_key, 'w') as f:
+        with open(server_key, "w") as f:
             f.write("-----BEGIN PRIVATE KEY-----\n")
             f.write("DUMMY SERVER PRIVATE KEY FOR TESTING\n")
             f.write("-----END PRIVATE KEY-----\n")
-        
+
         # CA certificate
         ca_cert = os.path.join(certs_dir, "ca.crt")
-        with open(ca_cert, 'w') as f:
+        with open(ca_cert, "w") as f:
             f.write("-----BEGIN CERTIFICATE-----\n")
             f.write("DUMMY CA CERTIFICATE FOR TESTING\n")
             f.write("-----END CERTIFICATE-----\n")
-        
+
         print(f"  🔐 Created dummy SSL certificates")
-    
+
     def _check_dependencies(self):
         """Check if required dependencies are available."""
         print("\n🔍 Checking dependencies...")
-        
+
         for example, deps in self.required_deps.items():
             missing_deps = []
             for dep in deps:
@@ -182,22 +177,24 @@ class ExampleTester:
                     __import__(dep)
                 except ImportError:
                     missing_deps.append(dep)
-            
+
             if missing_deps:
-                self.warnings.append(f"Missing dependencies for {example}: {', '.join(missing_deps)}")
+                self.warnings.append(
+                    f"Missing dependencies for {example}: {', '.join(missing_deps)}"
+                )
                 print(f"  ⚠️  {example}: Missing {', '.join(missing_deps)}")
             else:
                 print(f"  ✅ {example}: All dependencies available")
-    
+
     def _install_missing_dependencies(self) -> bool:
         """
         Install missing dependencies for examples.
-        
+
         Returns:
             bool: True if installation was successful
         """
         print("\n📦 Installing missing dependencies...")
-        
+
         # Collect all missing dependencies
         all_missing_deps = set()
         for example, deps in self.required_deps.items():
@@ -206,13 +203,13 @@ class ExampleTester:
                     __import__(dep)
                 except ImportError:
                     all_missing_deps.add(dep)
-        
+
         if not all_missing_deps:
             print("  ✅ All dependencies are already available")
             return True
-        
+
         print(f"  📥 Installing: {', '.join(all_missing_deps)}")
-        
+
         try:
             # Install missing dependencies
             for dep in all_missing_deps:
@@ -221,16 +218,16 @@ class ExampleTester:
                     [sys.executable, "-m", "pip", "install", "--user", dep],
                     capture_output=True,
                     text=True,
-                    timeout=120
+                    timeout=120,
                 )
-                
+
                 if result.returncode == 0:
                     print(f"      ✅ {dep} installed successfully")
                 else:
                     print(f"      ❌ Failed to install {dep}: {result.stderr}")
                     self.errors.append(f"Failed to install {dep}: {result.stderr}")
                     return False
-            
+
             # Verify installation by importing in a new process
             print("\n🔍 Verifying installations...")
             for dep in all_missing_deps:
@@ -241,23 +238,23 @@ class ExampleTester:
                         [sys.executable, "-c", test_script],
                         capture_output=True,
                         text=True,
-                        timeout=10
+                        timeout=10,
                     )
-                    
+
                     if result.returncode == 0:
                         print(f"  ✅ {dep} is now available")
                     else:
                         print(f"  ❌ {dep} is still not available after installation")
                         self.errors.append(f"{dep} installation verification failed")
                         return False
-                        
+
                 except Exception as e:
                     print(f"  ❌ {dep} verification failed: {str(e)}")
                     self.errors.append(f"{dep} verification failed: {str(e)}")
                     return False
-            
+
             return True
-            
+
         except subprocess.TimeoutExpired:
             self.errors.append("Dependency installation timed out")
             print("  ❌ Installation timed out")
@@ -266,19 +263,19 @@ class ExampleTester:
             self.errors.append(f"Dependency installation failed: {str(e)}")
             print(f"  ❌ Installation failed: {str(e)}")
             return False
-    
+
     def run_example(self, example_file: str) -> Dict:
         """
         Run a single example and capture results.
-        
+
         Args:
             example_file: Name of the example file to run
-            
+
         Returns:
             Dict: Test results for the example
         """
         print(f"\n🚀 Running {example_file}...")
-        
+
         result = {
             "file": example_file,
             "status": "unknown",
@@ -286,36 +283,36 @@ class ExampleTester:
             "end_time": None,
             "error": None,
             "output": "",
-            "warnings": []
+            "warnings": [],
         }
-        
+
         try:
             # Change to test directory
             original_cwd = os.getcwd()
             os.chdir(self.test_dir)
-            
+
             # Get the full path to the example file
             examples_dir = Path(__file__).parent
             example_path = examples_dir / example_file
-            
+
             if not example_path.exists():
                 result["status"] = "error"
                 result["error"] = f"Example file not found: {example_path}"
                 return result
-            
+
             # Run the example
             start_time = datetime.now()
             process = subprocess.run(
                 [sys.executable, str(example_path)],
                 capture_output=True,
                 text=True,
-                timeout=30  # 30 second timeout
+                timeout=30,  # 30 second timeout
             )
             end_time = datetime.now()
-            
+
             result["end_time"] = end_time
             result["output"] = process.stdout + process.stderr
-            
+
             # Analyze results
             if process.returncode == 0:
                 result["status"] = "success"
@@ -323,11 +320,11 @@ class ExampleTester:
             else:
                 # Check if the example actually worked despite test failures
                 output_lower = result["output"].lower()
-                
+
                 # Check for successful initialization and basic functionality
                 success_indicators = [
                     "security manager initialized successfully",
-                    "api key authentication successful", 
+                    "api key authentication successful",
                     "rate limiting test completed",
                     "middleware setup",
                     "fastapi example",
@@ -335,35 +332,46 @@ class ExampleTester:
                     "django example",
                     "gateway example",
                     "microservice example",
-                    "standalone example"
+                    "standalone example",
                 ]
-                
-                has_success_indicators = any(indicator in output_lower for indicator in success_indicators)
-                
+
+                has_success_indicators = any(
+                    indicator in output_lower for indicator in success_indicators
+                )
+
                 # Check if it's just a test assertion failure (not a real error)
-                is_test_failure = "assertionerror" in output_lower or "test assertion failed" in output_lower
-                
+                is_test_failure = (
+                    "assertionerror" in output_lower
+                    or "test assertion failed" in output_lower
+                )
+
                 if has_success_indicators and is_test_failure:
                     result["status"] = "success"
-                    result["warnings"].append("Test assertion failed but core functionality works")
-                    print(f"  ✅ {example_file}: Success (core functionality works, test assertions failed)")
+                    result["warnings"].append(
+                        "Test assertion failed but core functionality works"
+                    )
+                    print(
+                        f"  ✅ {example_file}: Success (core functionality works, test assertions failed)"
+                    )
                 else:
                     result["status"] = "error"
                     result["error"] = f"Exit code: {process.returncode}"
-                    print(f"  ❌ {example_file}: Failed (exit code: {process.returncode})")
-            
+                    print(
+                        f"  ❌ {example_file}: Failed (exit code: {process.returncode})"
+                    )
+
             # Check for specific patterns in output
             if "AssertionError" in result["output"]:
                 result["warnings"].append("Test assertion failed")
                 print(f"  ⚠️  {example_file}: Test assertion failed")
-            
+
             if "ModuleNotFoundError" in result["output"]:
                 result["warnings"].append("Missing dependencies")
                 print(f"  ⚠️  {example_file}: Missing dependencies")
-            
+
             # Restore original directory
             os.chdir(original_cwd)
-            
+
         except subprocess.TimeoutExpired:
             result["status"] = "timeout"
             result["error"] = "Test timed out after 30 seconds"
@@ -372,28 +380,28 @@ class ExampleTester:
             result["status"] = "error"
             result["error"] = str(e)
             print(f"  ❌ {example_file}: Exception - {str(e)}")
-        
+
         return result
-    
+
     def run_all_examples(self) -> Dict:
         """
         Run all examples and collect results.
-        
+
         Returns:
             Dict: Summary of all test results
         """
         print("\n🎯 Starting test run for all examples...")
-        
+
         for example in self.examples:
             result = self.run_example(example)
             self.results[example] = result
-        
+
         return self._generate_summary()
-    
+
     def _generate_summary(self) -> Dict:
         """
         Generate a comprehensive test summary.
-        
+
         Returns:
             Dict: Test summary with statistics
         """
@@ -401,7 +409,7 @@ class ExampleTester:
         successful = sum(1 for r in self.results.values() if r["status"] == "success")
         failed = sum(1 for r in self.results.values() if r["status"] == "error")
         timeout = sum(1 for r in self.results.values() if r["status"] == "timeout")
-        
+
         summary = {
             "total_examples": total,
             "successful": successful,
@@ -410,22 +418,22 @@ class ExampleTester:
             "success_rate": (successful / total * 100) if total > 0 else 0,
             "results": self.results,
             "errors": self.errors,
-            "warnings": self.warnings
+            "warnings": self.warnings,
         }
-        
+
         return summary
-    
+
     def print_report(self, summary: Dict):
         """
         Print a comprehensive test report.
-        
+
         Args:
             summary: Test summary dictionary
         """
-        print("\n" + "="*80)
+        print("\n" + "=" * 80)
         print("📊 MCP SECURITY FRAMEWORK EXAMPLES TEST REPORT")
-        print("="*80)
-        
+        print("=" * 80)
+
         # Overall statistics
         print(f"\n📈 OVERALL STATISTICS:")
         print(f"  Total examples tested: {summary['total_examples']}")
@@ -433,53 +441,61 @@ class ExampleTester:
         print(f"  Failed: {summary['failed']} ❌")
         print(f"  Timeout: {summary['timeout']} ⏰")
         print(f"  Success rate: {summary['success_rate']:.1f}%")
-        
+
         # Detailed results
         print(f"\n📋 DETAILED RESULTS:")
         for example, result in summary["results"].items():
             status_icon = {
                 "success": "✅",
-                "error": "❌", 
+                "error": "❌",
                 "timeout": "⏰",
-                "unknown": "❓"
+                "unknown": "❓",
             }.get(result["status"], "❓")
-            
+
             print(f"  {status_icon} {example}")
-            
+
             if result["status"] == "error" and result["error"]:
                 print(f"      Error: {result['error']}")
-            
+
             if result["warnings"]:
                 for warning in result["warnings"]:
                     print(f"      ⚠️  {warning}")
-        
+
         # Errors and warnings
         if summary["errors"]:
             print(f"\n❌ ERRORS:")
             for error in summary["errors"]:
                 print(f"  • {error}")
-        
+
         if summary["warnings"]:
             print(f"\n⚠️  WARNINGS:")
             for warning in summary["warnings"]:
                 print(f"  • {warning}")
-        
+
         # Recommendations
         print(f"\n💡 RECOMMENDATIONS:")
         if summary["failed"] > 0:
-            print(f"  • {summary['failed']} examples failed - check dependencies and configuration")
-        
+            print(
+                f"  • {summary['failed']} examples failed - check dependencies and configuration"
+            )
+
         if summary["timeout"] > 0:
-            print(f"  • {summary['timeout']} examples timed out - consider increasing timeout")
-        
+            print(
+                f"  • {summary['timeout']} examples timed out - consider increasing timeout"
+            )
+
         if summary["success_rate"] < 50:
-            print(f"  • Low success rate ({summary['success_rate']:.1f}%) - review setup and dependencies")
+            print(
+                f"  • Low success rate ({summary['success_rate']:.1f}%) - review setup and dependencies"
+            )
         elif summary["success_rate"] >= 80:
-            print(f"  • Excellent success rate ({summary['success_rate']:.1f}%) - examples are working well")
-        
+            print(
+                f"  • Excellent success rate ({summary['success_rate']:.1f}%) - examples are working well"
+            )
+
         print(f"\n🔧 Test environment: {self.test_dir}")
-        print("="*80)
-    
+        print("=" * 80)
+
     def cleanup(self):
         """Clean up the test environment."""
         if self.test_dir and os.path.exists(self.test_dir):
@@ -494,12 +510,12 @@ def main():
     """Main function to run all example tests."""
     print("🚀 MCP Security Framework Examples Test Runner")
     print("=" * 60)
-    
+
     # Parse command line arguments
     keep_env = "--keep-env" in sys.argv
     test_dir = None
     install_deps = True
-    
+
     if "--test-dir" in sys.argv:
         try:
             idx = sys.argv.index("--test-dir")
@@ -507,30 +523,30 @@ def main():
         except (IndexError, ValueError):
             print("❌ Invalid --test-dir argument")
             sys.exit(1)
-    
+
     if "--no-install-deps" in sys.argv:
         install_deps = False
         print("⚠️  Skipping automatic dependency installation.")
-    
+
     # Create tester
     tester = ExampleTester(test_dir, install_deps)
-    
+
     try:
         # Setup environment
         if not tester.setup_environment():
             print("❌ Failed to setup test environment")
             sys.exit(1)
-        
+
         # Run all examples
         summary = tester.run_all_examples()
-        
+
         # Print report
         tester.print_report(summary)
-        
+
         # Cleanup
         if not keep_env:
             tester.cleanup()
-        
+
         # Exit with appropriate code
         if summary["failed"] > 0:
             print(f"\n❌ Test run completed with {summary['failed']} failures")
@@ -538,7 +554,7 @@ def main():
         else:
             print(f"\n✅ Test run completed successfully!")
             sys.exit(0)
-            
+
     except KeyboardInterrupt:
         print("\n⏹️  Test run interrupted by user")
         if not keep_env: