mcp-proxy-adapter 6.9.17__py3-none-any.whl → 6.9.19__py3-none-any.whl

mcp_proxy_adapter/examples/validate_generator_compatibility.py

@@ -0,0 +1,386 @@
+#!/usr/bin/env python3
+"""
+Script to validate compatibility between config generator and validator.
+
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+"""
+
+import json
+import sys
+import tempfile
+import shutil
+from pathlib import Path
+from typing import Dict, Any, List
+
+# Add the project root to the path
+project_root = Path(__file__).parent.parent.parent
+sys.path.insert(0, str(project_root))
+
+from mcp_proxy_adapter.core.config_validator import ConfigValidator
+from mcp_proxy_adapter.examples.config_builder import generate_complete_config
+
+
+def test_generator_validator_compatibility():
+    """Test that generated configs pass validation."""
+    print("🔍 Testing Generator-Validator Compatibility")
+    print("=" * 50)
+    
+    # Test configurations to generate
+    test_configs = [
+        {
+            "name": "HTTP Basic",
+            "protocol": "http",
+            "ssl_enabled": False,
+            "security_enabled": False,
+            "roles_enabled": False,
+            "proxy_registration_enabled": False
+        },
+        {
+            "name": "HTTP + Token",
+            "protocol": "http", 
+            "ssl_enabled": False,
+            "security_enabled": True,
+            "roles_enabled": False,
+            "proxy_registration_enabled": False
+        },
+        {
+            "name": "HTTP + Token + Roles",
+            "protocol": "http",
+            "ssl_enabled": False, 
+            "security_enabled": True,
+            "roles_enabled": True,
+            "proxy_registration_enabled": False
+        },
+        {
+            "name": "HTTPS Basic",
+            "protocol": "https",
+            "ssl_enabled": True,
+            "security_enabled": False,
+            "roles_enabled": False,
+            "proxy_registration_enabled": False
+        },
+        {
+            "name": "HTTPS + Token",
+            "protocol": "https",
+            "ssl_enabled": True,
+            "security_enabled": True,
+            "roles_enabled": False,
+            "proxy_registration_enabled": False
+        },
+        {
+            "name": "HTTPS + Token + Roles",
+            "protocol": "https",
+            "ssl_enabled": True,
+            "security_enabled": True,
+            "roles_enabled": True,
+            "proxy_registration_enabled": False
+        },
+        {
+            "name": "mTLS + Proxy Registration",
+            "protocol": "mtls",
+            "ssl_enabled": True,
+            "security_enabled": False,
+            "roles_enabled": False,
+            "proxy_registration_enabled": True
+        }
+    ]
+    
+    results = []
+    
+    for test_config in test_configs:
+        print(f"\n📋 Testing: {test_config['name']}")
+        print("-" * 30)
+        
+        try:
+            # Generate configuration
+            print("  🔧 Generating configuration...")
+            generated_config = generate_complete_config(
+                host="localhost",
+                port=8080
+            )
+            
+            # Create temporary test files
+            temp_dir = Path(tempfile.mkdtemp())
+            test_files = {}
+            
+            # Modify config based on test parameters
+            if test_config["protocol"] != "http":
+                generated_config["server"]["protocol"] = test_config["protocol"]
+            
+            if test_config["ssl_enabled"]:
+                generated_config["ssl"]["enabled"] = True
+                # Create test SSL certificates
+                cert_file = temp_dir / "test_cert.crt"
+                key_file = temp_dir / "test_key.key"
+                ca_cert = temp_dir / "test_ca.crt"
+                
+                # Create dummy certificate files
+                cert_file.write_text("-----BEGIN CERTIFICATE-----\nDUMMY CERT\n-----END CERTIFICATE-----")
+                key_file.write_text("-----BEGIN PRIVATE KEY-----\nDUMMY KEY\n-----END PRIVATE KEY-----")
+                ca_cert.write_text("-----BEGIN CERTIFICATE-----\nDUMMY CA\n-----END CERTIFICATE-----")
+                
+                generated_config["ssl"]["cert_file"] = str(cert_file)
+                generated_config["ssl"]["key_file"] = str(key_file)
+                generated_config["ssl"]["ca_cert"] = str(ca_cert)
+                
+                test_files["ssl"] = [cert_file, key_file, ca_cert]
+            
+            if test_config["security_enabled"]:
+                generated_config["security"]["enabled"] = True
+                generated_config["security"]["tokens"] = {
+                    "test_token": {"permissions": ["*"]}
+                }
+            
+            if test_config["roles_enabled"]:
+                generated_config["roles"]["enabled"] = True
+                roles_file = temp_dir / "test_roles.json"
+                roles_file.write_text('{"admin": ["*"], "user": ["read"]}')
+                generated_config["roles"]["config_file"] = str(roles_file)
+                test_files["roles"] = [roles_file]
+            
+            if test_config["proxy_registration_enabled"]:
+                generated_config["proxy_registration"]["enabled"] = True
+                generated_config["proxy_registration"]["proxy_url"] = "http://localhost:3005"
+                
+                # Create test client certificates
+                client_cert = temp_dir / "test_client.crt"
+                client_key = temp_dir / "test_client.key"
+                client_cert.write_text("-----BEGIN CERTIFICATE-----\nDUMMY CLIENT CERT\n-----END CERTIFICATE-----")
+                client_key.write_text("-----BEGIN PRIVATE KEY-----\nDUMMY CLIENT KEY\n-----END PRIVATE KEY-----")
+                
+                generated_config["proxy_registration"]["certificate"] = {
+                    "cert_file": str(client_cert),
+                    "key_file": str(client_key)
+                }
+                generated_config["proxy_registration"]["ssl"] = {
+                    "ca_cert": str(ca_cert) if test_config["ssl_enabled"] else str(temp_dir / "test_ca.crt")
+                }
+                
+                if "proxy" not in test_files:
+                    test_files["proxy"] = []
+                test_files["proxy"].extend([client_cert, client_key])
+            
+            # Validate configuration
+            print("  ✅ Validating configuration...")
+            validator = ConfigValidator()
+            validator.config_data = generated_config
+            validation_results = validator.validate_config()
+            
+            # Analyze results
+            errors = [r for r in validation_results if r.level == "error"]
+            warnings = [r for r in validation_results if r.level == "warning"]
+            info = [r for r in validation_results if r.level == "info"]
+            
+            result = {
+                "name": test_config["name"],
+                "success": len(errors) == 0,
+                "errors": len(errors),
+                "warnings": len(warnings),
+                "info": len(info),
+                "error_details": errors,
+                "warning_details": warnings
+            }
+            
+            results.append(result)
+            
+            # Clean up temporary files
+            try:
+                shutil.rmtree(temp_dir)
+            except Exception as e:
+                print(f"    ⚠️  Warning: Could not clean up temp files: {e}")
+            
+            # Print results
+            if result["success"]:
+                print(f"  ✅ PASS - {len(warnings)} warnings, {len(info)} info")
+            else:
+                print(f"  ❌ FAIL - {len(errors)} errors, {len(warnings)} warnings")
+                for error in errors[:3]:  # Show first 3 errors
+                    print(f"    • {error.message}")
+                if len(errors) > 3:
+                    print(f"    ... and {len(errors) - 3} more errors")
+            
+        except Exception as e:
+            print(f"  💥 EXCEPTION: {str(e)}")
+            results.append({
+                "name": test_config["name"],
+                "success": False,
+                "errors": 1,
+                "warnings": 0,
+                "info": 0,
+                "error_details": [f"Exception: {str(e)}"],
+                "warning_details": []
+            })
+    
+    # Summary
+    print("\n" + "=" * 50)
+    print("📊 COMPATIBILITY SUMMARY")
+    print("=" * 50)
+    
+    total_tests = len(results)
+    passed_tests = sum(1 for r in results if r["success"])
+    failed_tests = total_tests - passed_tests
+    
+    print(f"Total tests: {total_tests}")
+    print(f"Passed: {passed_tests}")
+    print(f"Failed: {failed_tests}")
+    print(f"Success rate: {(passed_tests/total_tests)*100:.1f}%")
+    
+    if failed_tests > 0:
+        print("\n❌ FAILED TESTS:")
+        for result in results:
+            if not result["success"]:
+                print(f"  • {result['name']}: {result['errors']} errors")
+                for error in result["error_details"][:2]:
+                    print(f"    - {error}")
+    
+    return results
+
+
+def test_validation_coverage():
+    """Test that validator covers all generator features."""
+    print("\n🔍 Testing Validation Coverage")
+    print("=" * 50)
+    
+    # Test that validator checks all required sections
+    required_sections = [
+        "server", "logging", "commands", "debug"
+    ]
+    
+    optional_sections = [
+        "ssl", "security", "roles", "proxy_registration", "transport"
+    ]
+    
+    print("📋 Required sections validation:")
+    for section in required_sections:
+        print(f"  ✅ {section}")
+    
+    print("\n📋 Optional sections validation:")
+    for section in optional_sections:
+        print(f"  ✅ {section}")
+    
+    return True
+
+
+def test_edge_cases():
+    """Test edge cases and error conditions."""
+    print("\n🔍 Testing Edge Cases")
+    print("=" * 50)
+    
+    edge_cases = [
+        {
+            "name": "Empty config",
+            "config": {},
+            "should_fail": True
+        },
+        {
+            "name": "Missing server section",
+            "config": {"logging": {"level": "INFO"}},
+            "should_fail": True
+        },
+        {
+            "name": "Invalid protocol",
+            "config": {
+                "server": {"protocol": "invalid", "host": "localhost", "port": 8080},
+                "logging": {"level": "INFO"},
+                "commands": {"enabled": True},
+                "debug": {"enabled": False}
+            },
+            "should_fail": True
+        },
+        {
+            "name": "SSL enabled without certificates",
+            "config": {
+                "server": {"protocol": "https", "host": "localhost", "port": 8080},
+                "ssl": {"enabled": True},
+                "logging": {"level": "INFO"},
+                "commands": {"enabled": True},
+                "debug": {"enabled": False}
+            },
+            "should_fail": True
+        }
+    ]
+    
+    results = []
+    
+    for case in edge_cases:
+        print(f"\n🧪 Testing: {case['name']}")
+        
+        try:
+            validator = ConfigValidator()
+            validator.config_data = case["config"]
+            validation_results = validator.validate_config()
+            
+            errors = [r for r in validation_results if r.level == "error"]
+            has_errors = len(errors) > 0
+            
+            expected_failure = case["should_fail"]
+            test_passed = (has_errors == expected_failure)
+            
+            if test_passed:
+                print(f"  ✅ PASS - {'Correctly failed' if has_errors else 'Correctly passed'}")
+            else:
+                print(f"  ❌ FAIL - Expected {'failure' if expected_failure else 'success'}, got {'failure' if has_errors else 'success'}")
+            
+            results.append({
+                "name": case["name"],
+                "passed": test_passed,
+                "errors": len(errors)
+            })
+            
+        except Exception as e:
+            print(f"  💥 EXCEPTION: {str(e)}")
+            results.append({
+                "name": case["name"],
+                "passed": False,
+                "errors": 1
+            })
+    
+    return results
+
+
+def main():
+    """Main test function."""
+    print("🚀 Generator-Validator Compatibility Test")
+    print("=" * 60)
+    
+    try:
+        # Test 1: Generator-Validator compatibility
+        compatibility_results = test_generator_validator_compatibility()
+        
+        # Test 2: Validation coverage
+        test_validation_coverage()
+        
+        # Test 3: Edge cases
+        edge_case_results = test_edge_cases()
+        
+        # Final summary
+        print("\n" + "=" * 60)
+        print("🎯 FINAL RESULTS")
+        print("=" * 60)
+        
+        compatibility_passed = sum(1 for r in compatibility_results if r["success"])
+        edge_cases_passed = sum(1 for r in edge_case_results if r["passed"])
+        
+        print(f"Compatibility tests: {compatibility_passed}/{len(compatibility_results)} passed")
+        print(f"Edge case tests: {edge_cases_passed}/{len(edge_case_results)} passed")
+        
+        total_passed = compatibility_passed + edge_cases_passed
+        total_tests = len(compatibility_results) + len(edge_case_results)
+        
+        print(f"Overall: {total_passed}/{total_tests} tests passed")
+        
+        if total_passed == total_tests:
+            print("🎉 ALL TESTS PASSED! Generator and validator are compatible.")
+            return 0
+        else:
+            print("❌ Some tests failed. Check the output above for details.")
+            return 1
+            
+    except Exception as e:
+        print(f"💥 Test suite failed with exception: {str(e)}")
+        return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

mcp_proxy_adapter/examples/validate_generator_compatibility_simple.py

@@ -0,0 +1,248 @@
+#!/usr/bin/env python3
+"""
+Simple compatibility test between config generator and validator.
+Tests only the structure and required fields, not file existence or certificate validity.
+
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+"""
+
+import json
+import sys
+from pathlib import Path
+from typing import Dict, Any, List
+
+# Add the project root to the path
+project_root = Path(__file__).parent.parent.parent
+sys.path.insert(0, str(project_root))
+
+from mcp_proxy_adapter.core.config_validator import ConfigValidator
+from mcp_proxy_adapter.examples.config_builder import generate_complete_config
+
+
+def test_generator_validator_structure():
+    """Test that generated configs have the correct structure."""
+    print("🔍 Testing Generator-Validator Structure Compatibility")
+    print("=" * 60)
+    
+    # Test basic HTTP configuration
+    print("\n📋 Testing: HTTP Basic Configuration")
+    print("-" * 40)
+    
+    try:
+        # Generate configuration
+        print("  🔧 Generating configuration...")
+        config = generate_complete_config(host="localhost", port=8080)
+        
+        # Check required sections exist
+        required_sections = ["server", "logging", "commands", "debug", "ssl", "security", "roles", "proxy_registration"]
+        missing_sections = []
+        
+        for section in required_sections:
+            if section not in config:
+                missing_sections.append(section)
+        
+        if missing_sections:
+            print(f"  ❌ FAIL - Missing sections: {missing_sections}")
+            return False
+        
+        # Check server section
+        server_required = ["host", "port", "protocol", "debug", "log_level"]
+        server_missing = [key for key in server_required if key not in config["server"]]
+        
+        if server_missing:
+            print(f"  ❌ FAIL - Server section missing keys: {server_missing}")
+            return False
+        
+        # Check protocol is HTTP
+        if config["server"]["protocol"] != "http":
+            print(f"  ❌ FAIL - Expected protocol 'http', got '{config['server']['protocol']}'")
+            return False
+        
+        # Check SSL is disabled
+        if config["ssl"]["enabled"] != False:
+            print(f"  ❌ FAIL - Expected SSL disabled, got {config['ssl']['enabled']}")
+            return False
+        
+        # Check security is disabled
+        if config["security"]["enabled"] != False:
+            print(f"  ❌ FAIL - Expected security disabled, got {config['security']['enabled']}")
+            return False
+        
+        # Check roles is disabled
+        if config["roles"]["enabled"] != False:
+            print(f"  ❌ FAIL - Expected roles disabled, got {config['roles']['enabled']}")
+            return False
+        
+        # Check proxy registration is disabled
+        if config["proxy_registration"]["enabled"] != False:
+            print(f"  ❌ FAIL - Expected proxy registration disabled, got {config['proxy_registration']['enabled']}")
+            return False
+        
+        print("  ✅ PASS - All required sections and fields present")
+        print("  ✅ PASS - All features correctly disabled")
+        print("  ✅ PASS - Protocol correctly set to HTTP")
+        
+        return True
+        
+    except Exception as e:
+        print(f"  💥 EXCEPTION: {str(e)}")
+        return False
+
+
+def test_config_modification():
+    """Test that we can modify generated configs for different scenarios."""
+    print("\n📋 Testing: Configuration Modification")
+    print("-" * 40)
+    
+    try:
+        # Generate base config
+        config = generate_complete_config(host="localhost", port=8080)
+        
+        # Test 1: Enable HTTPS
+        print("  🔧 Testing HTTPS modification...")
+        config["server"]["protocol"] = "https"
+        config["ssl"]["enabled"] = True
+        
+        if config["server"]["protocol"] != "https":
+            print("  ❌ FAIL - Could not change protocol to HTTPS")
+            return False
+        
+        if config["ssl"]["enabled"] != True:
+            print("  ❌ FAIL - Could not enable SSL")
+            return False
+        
+        print("  ✅ PASS - HTTPS modification successful")
+        
+        # Test 2: Enable security
+        print("  🔧 Testing security modification...")
+        config["security"]["enabled"] = True
+        config["security"]["tokens"] = {"test_token": {"permissions": ["*"]}}
+        
+        if config["security"]["enabled"] != True:
+            print("  ❌ FAIL - Could not enable security")
+            return False
+        
+        if "tokens" not in config["security"]:
+            print("  ❌ FAIL - Could not add tokens")
+            return False
+        
+        print("  ✅ PASS - Security modification successful")
+        
+        # Test 3: Enable roles
+        print("  🔧 Testing roles modification...")
+        config["roles"]["enabled"] = True
+        config["roles"]["config_file"] = "./test_roles.json"
+        
+        if config["roles"]["enabled"] != True:
+            print("  ❌ FAIL - Could not enable roles")
+            return False
+        
+        if config["roles"]["config_file"] != "./test_roles.json":
+            print("  ❌ FAIL - Could not set roles config file")
+            return False
+        
+        print("  ✅ PASS - Roles modification successful")
+        
+        return True
+        
+    except Exception as e:
+        print(f"  💥 EXCEPTION: {str(e)}")
+        return False
+
+
+def test_validator_accepts_generated_config():
+    """Test that validator accepts the basic generated config without file checks."""
+    print("\n📋 Testing: Validator Accepts Generated Config")
+    print("-" * 40)
+    
+    try:
+        # Generate config
+        config = generate_complete_config(host="localhost", port=8080)
+        
+        # Create a mock validator that doesn't check files
+        class MockValidator(ConfigValidator):
+            def _validate_file_existence(self):
+                """Skip file existence checks for testing."""
+                pass
+            
+            def _validate_certificate_file(self, cert_file, section, key):
+                """Skip certificate validation for testing."""
+                pass
+            
+            def _validate_key_file(self, key_file, section, key):
+                """Skip key validation for testing."""
+                pass
+            
+            def _validate_ca_certificate_file(self, ca_cert_file, section, key):
+                """Skip CA certificate validation for testing."""
+                pass
+        
+        # Validate with mock validator
+        validator = MockValidator()
+        validator.config_data = config
+        results = validator.validate_config()
+        
+        errors = [r for r in results if r.level == "error"]
+        warnings = [r for r in results if r.level == "warning"]
+        
+        if len(errors) > 0:
+            print(f"  ❌ FAIL - {len(errors)} validation errors:")
+            for error in errors[:3]:
+                print(f"    • {error.message}")
+            return False
+        
+        print(f"  ✅ PASS - No validation errors ({len(warnings)} warnings)")
+        return True
+        
+    except Exception as e:
+        print(f"  💥 EXCEPTION: {str(e)}")
+        return False
+
+
+def main():
+    """Main test function."""
+    print("🚀 Generator-Validator Structure Compatibility Test")
+    print("=" * 70)
+    
+    tests = [
+        ("Structure Test", test_generator_validator_structure),
+        ("Modification Test", test_config_modification),
+        ("Validator Acceptance Test", test_validator_accepts_generated_config)
+    ]
+    
+    results = []
+    
+    for test_name, test_func in tests:
+        print(f"\n🧪 Running: {test_name}")
+        try:
+            result = test_func()
+            results.append((test_name, result))
+        except Exception as e:
+            print(f"  💥 Test failed with exception: {str(e)}")
+            results.append((test_name, False))
+    
+    # Summary
+    print("\n" + "=" * 70)
+    print("🎯 FINAL RESULTS")
+    print("=" * 70)
+    
+    passed = sum(1 for _, result in results if result)
+    total = len(results)
+    
+    print(f"Tests passed: {passed}/{total}")
+    
+    for test_name, result in results:
+        status = "✅ PASS" if result else "❌ FAIL"
+        print(f"  {status} - {test_name}")
+    
+    if passed == total:
+        print("\n🎉 ALL TESTS PASSED! Generator and validator are structurally compatible.")
+        return 0
+    else:
+        print(f"\n❌ {total - passed} tests failed. Check the output above for details.")
+        return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

mcp_proxy_adapter/main.py

@@ -49,6 +49,9 @@ def main():
     else:
         config = Config()
 
+    # Load configuration from file
+    config.load_config()
+
     # Validate UUID configuration (mandatory)
     validator = ConfigValidator(config.get_all())
     if not validator.validate_all():

mcp_proxy_adapter/version.py

@@ -2,4 +2,4 @@
 Version information for MCP Proxy Adapter.
 """
 
-__version__ = "6.9.17"
+__version__ = "6.9.19"

{mcp_proxy_adapter-6.9.17.dist-info → mcp_proxy_adapter-6.9.19.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mcp-proxy-adapter
-Version: 6.9.17
+Version: 6.9.19
 Summary: Powerful JSON-RPC microservices framework with built-in security, authentication, and proxy registration
 Home-page: https://github.com/maverikod/mcp-proxy-adapter
 Author: Vasiliy Zdanovskiy