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

mcp_proxy_adapter/examples/test_framework_complete.py

@@ -0,0 +1,267 @@
+#!/usr/bin/env python3
+"""
+Complete framework testing with real MCP servers.
+
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+"""
+
+import asyncio
+import json
+import subprocess
+import time
+import requests
+import ssl
+from pathlib import Path
+
+# Configure logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+class FrameworkTester:
+    """Complete framework testing with real MCP servers."""
+    
+    def __init__(self):
+        self.project_root = Path(__file__).parent.parent.parent
+        self.configs_dir = self.project_root / "configs"
+        self.examples_dir = Path(__file__).parent
+        self.test_results = []
+        self.server_processes = []
+        
+    async def test_all_protocols(self):
+        """Test all protocols with real MCP server registration."""
+        get_global_logger().info("🧪 Starting Complete Framework Testing")
+        get_global_logger().info("=" * 60)
+        
+        # Test configurations
+        test_configs = [
+            ("http.json", "HTTP", 20000),
+            ("https.json", "HTTPS", 20003), 
+            ("mtls.json", "mTLS", 20006)
+        ]
+        
+        for config_file, protocol, port in test_configs:
+            get_global_logger().info(f"\n🔧 Testing {protocol} (port {port})")
+            get_global_logger().info("-" * 40)
+            
+            try:
+                # Start proxy adapter server
+                proxy_process = await self._start_proxy_server(config_file, port)
+                if not proxy_process:
+                    continue
+                
+                # Wait for server to start
+                await asyncio.sleep(2)
+                
+                # Test server registration
+                await self._test_server_registration(protocol, port)
+                
+                # Test MCP communication
+                await self._test_mcp_communication(protocol, port)
+                
+                # Test security features
+                await self._test_security_features(protocol, port)
+                
+                # Stop server
+                proxy_process.terminate()
+                await asyncio.sleep(1)
+                
+                get_global_logger().info(f"✅ {protocol} testing completed successfully")
+                
+            except Exception as e:
+                get_global_logger().error(f"❌ {protocol} testing failed: {e}")
+                self.test_results.append({
+                    "protocol": protocol,
+                    "status": "failed",
+                    "error": str(e)
+                })
+        
+        # Print summary
+        self._print_summary()
+    
+    async def _start_proxy_server(self, config_file: str, port: int) -> Optional[subprocess.Popen]:
+        """Start proxy adapter server."""
+        config_path = self.configs_dir / config_file
+        
+        if not config_path.exists():
+            get_global_logger().error(f"❌ Config file not found: {config_path}")
+            return None
+        
+        get_global_logger().info(f"🚀 Starting proxy server with {config_file}")
+        
+        try:
+            # Start server in background
+            process = subprocess.Popen([
+                "python", str(self.examples_dir / "main.py"),
+                "--config", str(config_path)
+            ], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+            
+            self.server_processes.append(process)
+            return process
+            
+        except Exception as e:
+            get_global_logger().error(f"❌ Failed to start server: {e}")
+            return None
+    
+    async def _test_server_registration(self, protocol: str, port: int):
+        """Test MCP server registration."""
+        get_global_logger().info(f"📝 Testing server registration for {protocol}")
+        
+        base_url = f"http://localhost:{port}" if protocol == "HTTP" else f"https://localhost:{port}"
+        
+        # Test registration endpoint
+        registration_data = {
+            "server_id": "test-mcp-server",
+            "server_url": "stdio://test-server",
+            "server_name": "Test MCP Server",
+            "description": "Test server for framework validation"
+        }
+        
+        try:
+            # Create SSL context for HTTPS/mTLS
+            ssl_context = None
+            if protocol in ["HTTPS", "mTLS"]:
+                ssl_context = ssl.create_default_context()
+                ssl_context.check_hostname = False
+                ssl_context.verify_mode = ssl.CERT_NONE
+            
+            response = requests.post(
+                f"{base_url}/register",
+                json=registration_data,
+                verify=False,
+                timeout=10
+            )
+            
+            if response.status_code == 200:
+                get_global_logger().info("✅ Server registration successful")
+            else:
+                get_global_logger().warning(f"⚠️ Registration returned status {response.status_code}")
+                
+        except Exception as e:
+            get_global_logger().error(f"❌ Registration failed: {e}")
+            raise
+    
+    async def _test_mcp_communication(self, protocol: str, port: int):
+        """Test MCP communication through proxy."""
+        get_global_logger().info(f"🔗 Testing MCP communication for {protocol}")
+        
+        base_url = f"http://localhost:{port}" if protocol == "HTTP" else f"https://localhost:{port}"
+        
+        # Test MCP JSON-RPC call
+        mcp_request = {
+            "jsonrpc": "2.0",
+            "id": 1,
+            "method": "tools/list",
+            "params": {}
+        }
+        
+        try:
+            ssl_context = None
+            if protocol in ["HTTPS", "mTLS"]:
+                ssl_context = ssl.create_default_context()
+                ssl_context.check_hostname = False
+                ssl_context.verify_mode = ssl.CERT_NONE
+            
+            response = requests.post(
+                f"{base_url}/mcp",
+                json=mcp_request,
+                headers={"Content-Type": "application/json"},
+                verify=False,
+                timeout=10
+            )
+            
+            if response.status_code == 200:
+                result = response.json()
+                if "result" in result:
+                    get_global_logger().info("✅ MCP communication successful")
+                else:
+                    get_global_logger().warning(f"⚠️ MCP response: {result}")
+            else:
+                get_global_logger().warning(f"⚠️ MCP call returned status {response.status_code}")
+                
+        except Exception as e:
+            get_global_logger().error(f"❌ MCP communication failed: {e}")
+            raise
+    
+    async def _test_security_features(self, protocol: str, port: int):
+        """Test security features."""
+        get_global_logger().info(f"🔒 Testing security features for {protocol}")
+        
+        base_url = f"http://localhost:{port}" if protocol == "HTTP" else f"https://localhost:{port}"
+        
+        # Test without authentication
+        try:
+            ssl_context = None
+            if protocol in ["HTTPS", "mTLS"]:
+                ssl_context = ssl.create_default_context()
+                ssl_context.check_hostname = False
+                ssl_context.verify_mode = ssl.CERT_NONE
+            
+            response = requests.get(
+                f"{base_url}/health",
+                verify=False,
+                timeout=10
+            )
+            
+            if response.status_code == 200:
+                get_global_logger().info("✅ Health check successful")
+            else:
+                get_global_logger().warning(f"⚠️ Health check returned status {response.status_code}")
+                
+        except Exception as e:
+            get_global_logger().error(f"❌ Security test failed: {e}")
+            raise
+    
+    def _print_summary(self):
+        """Print test summary."""
+        get_global_logger().info("\n" + "=" * 60)
+        get_global_logger().info("📊 FRAMEWORK TESTING SUMMARY")
+        get_global_logger().info("=" * 60)
+        
+        total_tests = len(self.test_results)
+        successful_tests = len([r for r in self.test_results if r["status"] == "success"])
+        
+        get_global_logger().info(f"Total tests: {total_tests}")
+        get_global_logger().info(f"Successful: {successful_tests}")
+        get_global_logger().info(f"Failed: {total_tests - successful_tests}")
+        
+        if total_tests > 0:
+            success_rate = (successful_tests / total_tests) * 100
+            get_global_logger().info(f"Success rate: {success_rate:.1f}%")
+            
+            if success_rate == 100:
+                get_global_logger().info("🎉 All tests passed! Framework is working correctly.")
+            elif success_rate >= 80:
+                get_global_logger().info("✅ Most tests passed. Framework is mostly functional.")
+            else:
+                get_global_logger().info("⚠️ Many tests failed. Framework needs attention.")
+        
+        get_global_logger().info("=" * 60)
+    
+    async def cleanup(self):
+        """Cleanup server processes."""
+        get_global_logger().info("🧹 Cleaning up server processes...")
+        
+        for process in self.server_processes:
+            try:
+                if process.poll() is None:  # Process is still running
+                    process.terminate()
+                    process.wait(timeout=5)
+            except subprocess.TimeoutExpired:
+                process.kill()
+            except Exception as e:
+                get_global_logger().warning(f"Warning: Failed to cleanup process: {e}")
+        
+        self.server_processes.clear()
+
+async def main():
+    """Main testing function."""
+    tester = FrameworkTester()
+    
+    try:
+        await tester.test_all_protocols()
+    finally:
+        await tester.cleanup()
+
+if __name__ == "__main__":
+    asyncio.run(main())

mcp_proxy_adapter/examples/test_mcp_server.py

@@ -0,0 +1,187 @@
+#!/usr/bin/env python3
+"""
+Test MCP Server for framework validation.
+
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+"""
+
+import asyncio
+import json
+import logging
+from mcp import types
+from mcp.server import Server
+from mcp.server.stdio import stdio_server
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+class TestMCPServer:
+    """Test MCP Server for framework validation."""
+    
+    def __init__(self):
+        self.server = Server("test-mcp-server")
+        self._setup_handlers()
+    
+    def _setup_handlers(self):
+        """Setup MCP server handlers."""
+        
+        @self.server.list_tools()
+        async def list_tools() -> List[types.Tool]:
+            """List available tools."""
+            return [
+                types.Tool(
+                    name="echo",
+                    description="Echo back the input message",
+                    inputSchema={
+                        "type": "object",
+                        "properties": {
+                            "message": {
+                                "type": "string",
+                                "description": "Message to echo back"
+                            }
+                        },
+                        "required": ["message"]
+                    }
+                ),
+                types.Tool(
+                    name="add",
+                    description="Add two numbers",
+                    inputSchema={
+                        "type": "object",
+                        "properties": {
+                            "a": {
+                                "type": "number",
+                                "description": "First number"
+                            },
+                            "b": {
+                                "type": "number", 
+                                "description": "Second number"
+                            }
+                        },
+                        "required": ["a", "b"]
+                    }
+                ),
+                types.Tool(
+                    name="get_info",
+                    description="Get server information",
+                    inputSchema={
+                        "type": "object",
+                        "properties": {}
+                    }
+                )
+            ]
+        
+        @self.server.call_tool()
+        async def call_tool(name: str, arguments: Dict[str, Any]) -> List[types.TextContent]:
+            """Handle tool calls."""
+            get_global_logger().info(f"Tool called: {name} with args: {arguments}")
+            
+            if name == "echo":
+                message = arguments.get("message", "")
+                return [types.TextContent(type="text", text=f"Echo: {message}")]
+            
+            elif name == "add":
+                a = arguments.get("a", 0)
+                b = arguments.get("b", 0)
+                result = a + b
+                return [types.TextContent(type="text", text=f"Result: {a} + {b} = {result}")]
+            
+            elif name == "get_info":
+                info = {
+                    "server_name": "test-mcp-server",
+                    "version": "1.0.0",
+                    "status": "running",
+                    "tools_count": 3
+                }
+                return [types.TextContent(type="text", text=json.dumps(info, indent=2))]
+            
+            else:
+                return [types.TextContent(type="text", text=f"Unknown tool: {name}")]
+        
+        @self.server.list_resources()
+        async def list_resources() -> List[types.Resource]:
+            """List available resources."""
+            return [
+                types.Resource(
+                    uri="test://config",
+                    name="Server Configuration",
+                    description="Current server configuration",
+                    mimeType="application/json"
+                ),
+                types.Resource(
+                    uri="test://status",
+                    name="Server Status", 
+                    description="Current server status",
+                    mimeType="application/json"
+                )
+            ]
+        
+        @self.server.read_resource()
+        async def read_resource(uri: str) -> str:
+            """Read resource content."""
+            if uri == "test://config":
+                config = {
+                    "server_name": "test-mcp-server",
+                    "port": 3001,
+                    "protocol": "stdio",
+                    "features": ["tools", "resources"]
+                }
+                return json.dumps(config, indent=2)
+            
+            elif uri == "test://status":
+                status = {
+                    "status": "running",
+                    "uptime": "0s",
+                    "requests_handled": 0,
+                    "last_request": None
+                }
+                return json.dumps(status, indent=2)
+            
+            else:
+                raise ValueError(f"Unknown resource: {uri}")
+        
+        @self.server.list_prompts()
+        async def list_prompts() -> List[types.Prompt]:
+            """List available prompts."""
+            return [
+                types.Prompt(
+                    name="greeting",
+                    description="Generate a greeting message",
+                    arguments=[
+                        types.PromptArgument(
+                            name="name",
+                            description="Name to greet",
+                            required=True
+                        )
+                    ]
+                )
+            ]
+        
+        @self.server.get_prompt()
+        async def get_prompt(name: str, arguments: Dict[str, str]) -> List[types.TextContent]:
+            """Get prompt content."""
+            if name == "greeting":
+                user_name = arguments.get("name", "User")
+                greeting = f"Hello, {user_name}! Welcome to the test MCP server."
+                return [types.TextContent(type="text", text=greeting)]
+            
+            else:
+                raise ValueError(f"Unknown prompt: {name}")
+
+async def main():
+    """Main server function."""
+    get_global_logger().info("Starting Test MCP Server...")
+    
+    server_instance = TestMCPServer()
+    
+    async with stdio_server() as (read_stream, write_stream):
+        await server_instance.server.run(
+            read_stream,
+            write_stream,
+            server_instance.server.create_initialization_options()
+        )
+
+if __name__ == "__main__":
+    asyncio.run(main())