feat: comprehensive test suite update for AITBC Agent Systems

✅ Test Suite Enhancements
- Fixed async/await issues in communication tests
- Added comprehensive API integration tests
- Created performance benchmark tests
- Updated test runner with detailed reporting
- Enhanced test configuration and fixtures

✅ New Test Files
- test_communication_fixed.py - Fixed communication tests
- test_agent_coordinator_api.py - Complete API tests
- test_performance_benchmarks.py - Performance and load tests
- test_runner_updated.py - Enhanced test runner
- conftest_updated.py - Updated pytest configuration

✅ Test Coverage Improvements
- Unit tests: Communication protocols with async fixes
- Integration tests: Complete API endpoint testing
- Performance tests: Load testing and resource monitoring
- Phase tests: All phases 1-5 with comprehensive coverage
- Error handling: Robust error scenario testing

✅ Quality Assurance
- Fixed deprecation warnings (datetime.utcnow)
- Resolved async method issues
- Added proper error handling
- Improved test reliability and stability
- Enhanced reporting and metrics

🚀 Complete test suite now ready for continuous integration!

tests/conftest_updated.py

@@ -0,0 +1,134 @@
+"""
+Updated pytest configuration for AITBC Agent Systems
+"""
+
+import pytest
+import asyncio
+import sys
+import os
+from pathlib import Path
+
+# Add src directories to Python path
+project_root = Path(__file__).parent.parent
+sys.path.insert(0, str(project_root / "apps/agent-coordinator/src"))
+
+@pytest.fixture(scope="session")
+def event_loop():
+    """Create an instance of the default event loop for the test session."""
+    loop = asyncio.get_event_loop_policy().new_event_loop()
+    yield loop
+    loop.close()
+
+@pytest.fixture
+def sample_agent_data():
+    """Sample agent data for testing"""
+    return {
+        "agent_id": "test_agent_001",
+        "agent_type": "worker",
+        "capabilities": ["data_processing", "analysis"],
+        "services": ["process_data", "analyze_results"],
+        "endpoints": {
+            "http": "http://localhost:8001",
+            "ws": "ws://localhost:8002"
+        },
+        "metadata": {
+            "version": "1.0.0",
+            "region": "test"
+        }
+    }
+
+@pytest.fixture
+def sample_task_data():
+    """Sample task data for testing"""
+    return {
+        "task_data": {
+            "task_id": "test_task_001",
+            "task_type": "data_processing",
+            "data": {
+                "input": "test_data",
+                "operation": "process"
+            },
+            "required_capabilities": ["data_processing"]
+        },
+        "priority": "normal",
+        "requirements": {
+            "agent_type": "worker",
+            "min_health_score": 0.8
+        }
+    }
+
+@pytest.fixture
+def api_base_url():
+    """Base URL for API tests"""
+    return "http://localhost:9001"
+
+@pytest.fixture
+def mock_redis():
+    """Mock Redis connection for testing"""
+    import redis
+    from unittest.mock import Mock
+    
+    mock_redis = Mock()
+    mock_redis.ping.return_value = True
+    mock_redis.get.return_value = None
+    mock_redis.set.return_value = True
+    mock_redis.delete.return_value = True
+    mock_redis.hgetall.return_value = {}
+    mock_redis.hset.return_value = True
+    mock_redis.hdel.return_value = True
+    mock_redis.keys.return_value = []
+    mock_redis.exists.return_value = False
+    
+    return mock_redis
+
+# pytest configuration
+def pytest_configure(config):
+    """Configure pytest with custom markers"""
+    config.addinivalue_line(
+        "markers", "unit: Mark test as a unit test"
+    )
+    config.addinivalue_line(
+        "markers", "integration: Mark test as an integration test"
+    )
+    config.addinivalue_line(
+        "markers", "performance: Mark test as a performance test"
+    )
+    config.addinivalue_line(
+        "markers", "phase1: Mark test as Phase 1 test"
+    )
+    config.addinivalue_line(
+        "markers", "phase2: Mark test as Phase 2 test"
+    )
+    config.addinivalue_line(
+        "markers", "phase3: Mark test as Phase 3 test"
+    )
+    config.addinivalue_line(
+        "markers", "phase4: Mark test as Phase 4 test"
+    )
+    config.addinivalue_line(
+        "markers", "phase5: Mark test as Phase 5 test"
+    )
+
+# Custom markers for test selection
+def pytest_collection_modifyitems(config, items):
+    """Modify test collection to add markers based on file location"""
+    for item in items:
+        # Add phase markers based on file path
+        if "phase1" in str(item.fspath):
+            item.add_marker(pytest.mark.phase1)
+        elif "phase2" in str(item.fspath):
+            item.add_marker(pytest.mark.phase2)
+        elif "phase3" in str(item.fspath):
+            item.add_marker(pytest.mark.phase3)
+        elif "phase4" in str(item.fspath):
+            item.add_marker(pytest.mark.phase4)
+        elif "phase5" in str(item.fspath):
+            item.add_marker(pytest.mark.phase5)
+        
+        # Add type markers based on file content
+        if "api" in str(item.fspath).lower():
+            item.add_marker(pytest.mark.integration)
+        elif "performance" in str(item.fspath).lower():
+            item.add_marker(pytest.mark.performance)
+        elif "test_communication" in str(item.fspath):
+            item.add_marker(pytest.mark.unit)

tests/test_agent_coordinator_api.py

@@ -0,0 +1,322 @@
+"""
+Agent Coordinator API Integration Tests
+Tests the complete API functionality with real service
+"""
+
+import pytest
+import asyncio
+import requests
+import json
+from datetime import datetime
+from typing import Dict, Any
+
+class TestAgentCoordinatorAPI:
+    """Test Agent Coordinator API endpoints"""
+    
+    BASE_URL = "http://localhost:9001"
+    
+    def test_health_endpoint(self):
+        """Test health check endpoint"""
+        response = requests.get(f"{self.BASE_URL}/health")
+        assert response.status_code == 200
+        
+        data = response.json()
+        assert data["status"] == "healthy"
+        assert data["service"] == "agent-coordinator"
+        assert "timestamp" in data
+        assert "version" in data
+    
+    def test_root_endpoint(self):
+        """Test root endpoint"""
+        response = requests.get(f"{self.BASE_URL}/")
+        assert response.status_code == 200
+        
+        data = response.json()
+        assert "service" in data
+        assert "description" in data
+        assert "version" in data
+        assert "endpoints" in data
+    
+    def test_agent_registration(self):
+        """Test agent registration endpoint"""
+        agent_data = {
+            "agent_id": "api_test_agent_001",
+            "agent_type": "worker",
+            "capabilities": ["data_processing", "analysis"],
+            "services": ["process_data", "analyze_results"],
+            "endpoints": {
+                "http": "http://localhost:8001",
+                "ws": "ws://localhost:8002"
+            },
+            "metadata": {
+                "version": "1.0.0",
+                "region": "test"
+            }
+        }
+        
+        response = requests.post(
+            f"{self.BASE_URL}/agents/register",
+            json=agent_data,
+            headers={"Content-Type": "application/json"}
+        )
+        
+        assert response.status_code == 200
+        data = response.json()
+        assert data["status"] == "success"
+        assert data["agent_id"] == "api_test_agent_001"
+        assert "registered_at" in data
+    
+    def test_agent_discovery(self):
+        """Test agent discovery endpoint"""
+        query = {
+            "agent_type": "worker",
+            "status": "active"
+        }
+        
+        response = requests.post(
+            f"{self.BASE_URL}/agents/discover",
+            json=query,
+            headers={"Content-Type": "application/json"}
+        )
+        
+        assert response.status_code == 200
+        data = response.json()
+        assert data["status"] == "success"
+        assert "agents" in data
+        assert "count" in data
+        assert isinstance(data["agents"], list)
+    
+    def test_task_submission(self):
+        """Test task submission endpoint"""
+        task_data = {
+            "task_data": {
+                "task_id": "api_test_task_001",
+                "task_type": "data_processing",
+                "data": {
+                    "input": "test_data",
+                    "operation": "process"
+                },
+                "required_capabilities": ["data_processing"]
+            },
+            "priority": "high",
+            "requirements": {
+                "agent_type": "worker",
+                "min_health_score": 0.8
+            }
+        }
+        
+        response = requests.post(
+            f"{self.BASE_URL}/tasks/submit",
+            json=task_data,
+            headers={"Content-Type": "application/json"}
+        )
+        
+        assert response.status_code == 200
+        data = response.json()
+        assert data["status"] == "success"
+        assert data["task_id"] == "api_test_task_001"
+        assert "submitted_at" in data
+    
+    def test_load_balancer_stats(self):
+        """Test load balancer statistics endpoint"""
+        response = requests.get(f"{self.BASE_URL}/load-balancer/stats")
+        assert response.status_code == 200
+        
+        data = response.json()
+        assert data["status"] == "success"
+        assert "stats" in data
+        
+        stats = data["stats"]
+        assert "strategy" in stats
+        assert "total_assignments" in stats
+        assert "active_agents" in stats
+        assert "success_rate" in stats
+    
+    def test_load_balancer_strategy_update(self):
+        """Test load balancer strategy update endpoint"""
+        strategies = ["round_robin", "least_connections", "resource_based"]
+        
+        for strategy in strategies:
+            response = requests.put(
+                f"{self.BASE_URL}/load-balancer/strategy",
+                params={"strategy": strategy}
+            )
+            
+            assert response.status_code == 200
+            data = response.json()
+            assert data["status"] == "success"
+            assert data["strategy"] == strategy
+            assert "updated_at" in data
+    
+    def test_load_balancer_invalid_strategy(self):
+        """Test load balancer with invalid strategy"""
+        response = requests.put(
+            f"{self.BASE_URL}/load-balancer/strategy",
+            params={"strategy": "invalid_strategy"}
+        )
+        
+        assert response.status_code == 400
+        assert "Invalid strategy" in response.json()["detail"]
+    
+    def test_registry_stats(self):
+        """Test registry statistics endpoint"""
+        response = requests.get(f"{self.BASE_URL}/registry/stats")
+        assert response.status_code == 200
+        
+        data = response.json()
+        assert data["status"] == "success"
+        assert "stats" in data
+        
+        stats = data["stats"]
+        assert "total_agents" in stats
+        assert "status_counts" in stats
+        assert "type_counts" in stats
+        assert "service_count" in stats
+        assert "capability_count" in stats
+    
+    def test_agent_status_update(self):
+        """Test agent status update endpoint"""
+        status_data = {
+            "status": "busy",
+            "load_metrics": {
+                "cpu_usage": 0.7,
+                "memory_usage": 0.6,
+                "active_tasks": 3
+            }
+        }
+        
+        response = requests.put(
+            f"{self.BASE_URL}/agents/api_test_agent_001/status",
+            json=status_data,
+            headers={"Content-Type": "application/json"}
+        )
+        
+        assert response.status_code == 200
+        data = response.json()
+        assert data["status"] == "success"
+        assert data["agent_id"] == "api_test_agent_001"
+        assert data["new_status"] == "busy"
+        assert "updated_at" in data
+    
+    def test_service_based_discovery(self):
+        """Test service-based agent discovery"""
+        response = requests.get(f"{self.BASE_URL}/agents/service/process_data")
+        assert response.status_code == 200
+        
+        data = response.json()
+        assert data["status"] == "success"
+        assert "service" in data
+        assert "agents" in data
+        assert "count" in data
+    
+    def test_capability_based_discovery(self):
+        """Test capability-based agent discovery"""
+        response = requests.get(f"{self.BASE_URL}/agents/capability/data_processing")
+        assert response.status_code == 200
+        
+        data = response.json()
+        assert data["status"] == "success"
+        assert "capability" in data
+        assert "agents" in data
+        assert "count" in data
+
+class TestAPIPerformance:
+    """Test API performance and reliability"""
+    
+    BASE_URL = "http://localhost:9001"
+    
+    def test_response_times(self):
+        """Test API response times"""
+        import time
+        
+        endpoints = [
+            "/health",
+            "/load-balancer/stats",
+            "/registry/stats"
+        ]
+        
+        for endpoint in endpoints:
+            start_time = time.time()
+            response = requests.get(f"{self.BASE_URL}{endpoint}")
+            end_time = time.time()
+            
+            assert response.status_code == 200
+            response_time = end_time - start_time
+            assert response_time < 1.0  # Should respond within 1 second
+    
+    def test_concurrent_requests(self):
+        """Test concurrent request handling"""
+        import threading
+        import time
+        
+        results = []
+        
+        def make_request():
+            response = requests.get(f"{self.BASE_URL}/health")
+            results.append(response.status_code)
+        
+        # Make 10 concurrent requests
+        threads = []
+        for _ in range(10):
+            thread = threading.Thread(target=make_request)
+            threads.append(thread)
+            thread.start()
+        
+        # Wait for all threads to complete
+        for thread in threads:
+            thread.join()
+        
+        # All requests should succeed
+        assert all(status == 200 for status in results)
+        assert len(results) == 10
+
+class TestAPIErrorHandling:
+    """Test API error handling"""
+    
+    BASE_URL = "http://localhost:9001"
+    
+    def test_nonexistent_agent(self):
+        """Test requesting nonexistent agent"""
+        response = requests.get(f"{self.BASE_URL}/agents/nonexistent_agent")
+        assert response.status_code == 404
+        
+        data = response.json()
+        assert "detail" in data
+        assert "not found" in data["detail"].lower()
+    
+    def test_invalid_agent_data(self):
+        """Test invalid agent registration data"""
+        invalid_data = {
+            "agent_id": "",  # Empty agent ID
+            "agent_type": "invalid_type"
+        }
+        
+        response = requests.post(
+            f"{self.BASE_URL}/agents/register",
+            json=invalid_data,
+            headers={"Content-Type": "application/json"}
+        )
+        
+        # Should handle invalid data gracefully
+        assert response.status_code in [400, 422]
+    
+    def test_invalid_task_data(self):
+        """Test invalid task submission data"""
+        invalid_task = {
+            "task_data": {
+                # Missing required fields
+            },
+            "priority": "invalid_priority"
+        }
+        
+        response = requests.post(
+            f"{self.BASE_URL}/tasks/submit",
+            json=invalid_task,
+            headers={"Content-Type": "application/json"}
+        )
+        
+        # Should handle invalid data gracefully
+        assert response.status_code in [400, 422]
+
+if __name__ == '__main__':
+    pytest.main([__file__])

tests/test_performance_benchmarks.py

@@ -1,705 +1,237 @@
 """
-Performance Benchmarks for AITBC Mesh Network
+Performance Benchmark Tests for AITBC Agent Systems
-Tests performance requirements and scalability targets
+Tests system performance under various loads
 """
 
 import pytest
 import asyncio
 import time
-import statistics
+import requests
-from unittest.mock import Mock, AsyncMock
+import psutil
-from decimal import Decimal
-import concurrent.futures
 import threading
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from typing import List, Dict, Any
+import statistics
 
-class TestConsensusPerformance:
+class TestAPIPerformance:
-    """Test consensus layer performance"""
+    """Test API performance benchmarks"""
     
-    @pytest.mark.asyncio
+    BASE_URL = "http://localhost:9001"
-    async def test_block_propagation_time(self):
-        """Test block propagation time across network"""
-        # Mock network of 50 nodes
-        node_count = 50
-        propagation_times = []
     
-        # Simulate block propagation
+    def test_health_endpoint_performance(self):
-        for i in range(10):  # 10 test blocks
+        """Test health endpoint performance under load"""
+        def make_request():
             start_time = time.time()
-            
+            response = requests.get(f"{self.BASE_URL}/health")
-            # Simulate propagation through mesh network
-            # Each hop adds ~50ms latency
-            hops_required = 6  # Average hops in mesh
-            propagation_time = hops_required * 0.05  # 50ms per hop
-            
-            # Add some randomness
-            import random
-            propagation_time += random.uniform(0, 0.02)  # ±20ms variance
-            
             end_time = time.time()
-            actual_time = end_time - start_time + propagation_time
+            return {
-            propagation_times.append(actual_time)
+                'status_code': response.status_code,
-        
+                'response_time': end_time - start_time
-        # Calculate statistics
-        avg_propagation = statistics.mean(propagation_times)
-        max_propagation = max(propagation_times)
-        
-        # Performance requirements
-        assert avg_propagation < 5.0, f"Average propagation time {avg_propagation:.2f}s exceeds 5s target"
-        assert max_propagation < 10.0, f"Max propagation time {max_propagation:.2f}s exceeds 10s target"
-        
-        print(f"Block propagation - Avg: {avg_propagation:.2f}s, Max: {max_propagation:.2f}s")
-    
-    @pytest.mark.asyncio
-    async def test_consensus_throughput(self):
-        """Test consensus transaction throughput"""
-        transaction_count = 1000
-        start_time = time.time()
-        
-        # Mock consensus processing
-        processed_transactions = []
-        
-        # Process transactions in parallel (simulating multi-validator consensus)
-        with concurrent.futures.ThreadPoolExecutor(max_workers=10) as executor:
-            futures = []
-            
-            for i in range(transaction_count):
-                future = executor.submit(self._process_transaction, f"tx_{i}")
-                futures.append(future)
-            
-            # Wait for all transactions to be processed
-            for future in concurrent.futures.as_completed(futures):
-                result = future.result()
-                if result:
-                    processed_transactions.append(result)
-        
-        end_time = time.time()
-        processing_time = end_time - start_time
-        throughput = len(processed_transactions) / processing_time
-        
-        # Performance requirements
-        assert throughput >= 100, f"Throughput {throughput:.2f} tx/s below 100 tx/s target"
-        assert len(processed_transactions) == transaction_count, f"Only {len(processed_transactions)}/{transaction_count} transactions processed"
-        
-        print(f"Consensus throughput: {throughput:.2f} transactions/second")
-    
-    def _process_transaction(self, tx_id):
-        """Simulate transaction processing"""
-        # Simulate validation time
-        time.sleep(0.001)  # 1ms per transaction
-        return tx_id
-    
-    @pytest.mark.asyncio
-    async def test_validator_scalability(self):
-        """Test consensus scalability with validator count"""
-        validator_counts = [5, 10, 20, 50]
-        processing_times = []
-        
-        for validator_count in validator_counts:
-            start_time = time.time()
-            
-            # Simulate consensus with N validators
-            # More validators = more communication overhead
-            communication_overhead = validator_count * 0.001  # 1ms per validator
-            consensus_time = 0.1 + communication_overhead  # Base 100ms + overhead
-            
-            # Simulate consensus process
-            await asyncio.sleep(consensus_time)
-            
-            end_time = time.time()
-            processing_time = end_time - start_time
-            processing_times.append(processing_time)
-        
-        # Check that processing time scales reasonably
-        assert processing_times[-1] < 2.0, f"50-validator consensus too slow: {processing_times[-1]:.2f}s"
-        
-        # Check that scaling is sub-linear
-        time_5_validators = processing_times[0]
-        time_50_validators = processing_times[3]
-        scaling_factor = time_50_validators / time_5_validators
-        
-        assert scaling_factor < 10, f"Scaling factor {scaling_factor:.2f} too high (should be <10x for 10x validators)"
-        
-        print(f"Validator scaling - 5: {processing_times[0]:.3f}s, 50: {processing_times[3]:.3f}s")
-
-
-class TestNetworkPerformance:
-    """Test network layer performance"""
-    
-    @pytest.mark.asyncio
-    async def test_peer_discovery_speed(self):
-        """Test peer discovery performance"""
-        network_sizes = [10, 50, 100, 500]
-        discovery_times = []
-        
-        for network_size in network_sizes:
-            start_time = time.time()
-            
-            # Simulate peer discovery
-            # Discovery time grows with network size but should remain reasonable
-            discovery_time = 0.1 + (network_size * 0.0001)  # 0.1ms per peer
-            await asyncio.sleep(discovery_time)
-            
-            end_time = time.time()
-            total_time = end_time - start_time
-            discovery_times.append(total_time)
-        
-        # Performance requirements
-        assert discovery_times[-1] < 1.0, f"Discovery for 500 peers too slow: {discovery_times[-1]:.2f}s"
-        
-        print(f"Peer discovery - 10: {discovery_times[0]:.3f}s, 500: {discovery_times[-1]:.3f}s")
-    
-    @pytest.mark.asyncio
-    async def test_message_throughput(self):
-        """Test network message throughput"""
-        message_count = 10000
-        start_time = time.time()
-        
-        # Simulate message processing
-        processed_messages = []
-        
-        # Process messages in parallel
-        with concurrent.futures.ThreadPoolExecutor(max_workers=20) as executor:
-            futures = []
-            
-            for i in range(message_count):
-                future = executor.submit(self._process_message, f"msg_{i}")
-                futures.append(future)
-            
-            for future in concurrent.futures.as_completed(futures):
-                result = future.result()
-                if result:
-                    processed_messages.append(result)
-        
-        end_time = time.time()
-        processing_time = end_time - start_time
-        throughput = len(processed_messages) / processing_time
-        
-        # Performance requirements
-        assert throughput >= 1000, f"Message throughput {throughput:.2f} msg/s below 1000 msg/s target"
-        
-        print(f"Message throughput: {throughput:.2f} messages/second")
-    
-    def _process_message(self, msg_id):
-        """Simulate message processing"""
-        time.sleep(0.0005)  # 0.5ms per message
-        return msg_id
-    
-    @pytest.mark.asyncio
-    async def test_network_partition_recovery_time(self):
-        """Test network partition recovery time"""
-        recovery_times = []
-        
-        # Simulate 10 partition events
-        for i in range(10):
-            start_time = time.time()
-            
-            # Simulate partition detection and recovery
-            detection_time = 30  # 30 seconds to detect partition
-            recovery_time = 120  # 2 minutes to recover
-            
-            total_recovery_time = detection_time + recovery_time
-            await asyncio.sleep(0.1)  # Simulate time passing
-            
-            end_time = time.time()
-            recovery_times.append(total_recovery_time)
-        
-        # Performance requirements
-        avg_recovery = statistics.mean(recovery_times)
-        assert avg_recovery < 180, f"Average recovery time {avg_recovery:.0f}s exceeds 3 minute target"
-        
-        print(f"Partition recovery - Average: {avg_recovery:.0f}s")
-
-
-class TestEconomicPerformance:
-    """Test economic layer performance"""
-    
-    @pytest.mark.asyncio
-    async def test_staking_operation_speed(self):
-        """Test staking operation performance"""
-        operation_count = 1000
-        start_time = time.time()
-        
-        # Test different staking operations
-        operations = []
-        
-        for i in range(operation_count):
-            # Simulate staking operation
-            operation_time = 0.01  # 10ms per operation
-            await asyncio.sleep(operation_time)
-            operations.append(f"stake_{i}")
-        
-        end_time = time.time()
-        processing_time = end_time - start_time
-        throughput = len(operations) / processing_time
-        
-        # Performance requirements
-        assert throughput >= 50, f"Staking throughput {throughput:.2f} ops/s below 50 ops/s target"
-        
-        print(f"Staking throughput: {throughput:.2f} operations/second")
-    
-    @pytest.mark.asyncio
-    async def test_reward_calculation_speed(self):
-        """Test reward calculation performance"""
-        validator_count = 100
-        start_time = time.time()
-        
-        # Calculate rewards for all validators
-        rewards = {}
-        
-        for i in range(validator_count):
-            # Simulate reward calculation
-            calculation_time = 0.005  # 5ms per validator
-            await asyncio.sleep(calculation_time)
-            
-            rewards[f"validator_{i}"] = Decimal('10.0')  # 10 tokens reward
-        
-        end_time = time.time()
-        calculation_time_total = end_time - start_time
-        
-        # Performance requirements
-        assert calculation_time_total < 5.0, f"Reward calculation too slow: {calculation_time_total:.2f}s"
-        assert len(rewards) == validator_count, f"Only calculated rewards for {len(rewards)}/{validator_count} validators"
-        
-        print(f"Reward calculation for {validator_count} validators: {calculation_time_total:.2f}s")
-    
-    @pytest.mark.asyncio
-    async def test_gas_fee_calculation_speed(self):
-        """Test gas fee calculation performance"""
-        transaction_count = 5000
-        start_time = time.time()
-        
-        gas_fees = []
-        
-        for i in range(transaction_count):
-            # Simulate gas fee calculation
-            calculation_time = 0.0001  # 0.1ms per transaction
-            await asyncio.sleep(calculation_time)
-            
-            # Calculate gas fee (simplified)
-            gas_used = 21000 + (i % 10000)  # Variable gas usage
-            gas_price = Decimal('0.001')
-            fee = gas_used * gas_price
-            gas_fees.append(fee)
-        
-        end_time = time.time()
-        calculation_time_total = end_time - start_time
-        throughput = transaction_count / calculation_time_total
-        
-        # Performance requirements
-        assert throughput >= 10000, f"Gas calculation throughput {throughput:.2f} tx/s below 10000 tx/s target"
-        
-        print(f"Gas fee calculation: {throughput:.2f} transactions/second")
-
-
-class TestAgentNetworkPerformance:
-    """Test agent network performance"""
-    
-    @pytest.mark.asyncio
-    async def test_agent_registration_speed(self):
-        """Test agent registration performance"""
-        agent_count = 1000
-        start_time = time.time()
-        
-        registered_agents = []
-        
-        for i in range(agent_count):
-            # Simulate agent registration
-            registration_time = 0.02  # 20ms per agent
-            await asyncio.sleep(registration_time)
-            
-            registered_agents.append(f"agent_{i}")
-        
-        end_time = time.time()
-        registration_time_total = end_time - start_time
-        throughput = len(registered_agents) / registration_time_total
-        
-        # Performance requirements
-        assert throughput >= 25, f"Agent registration throughput {throughput:.2f} agents/s below 25 agents/s target"
-        
-        print(f"Agent registration: {throughput:.2f} agents/second")
-    
-    @pytest.mark.asyncio
-    async def test_capability_matching_speed(self):
-        """Test agent capability matching performance"""
-        job_count = 100
-        agent_count = 1000
-        start_time = time.time()
-        
-        matches = []
-        
-        for i in range(job_count):
-            # Simulate capability matching
-            matching_time = 0.05  # 50ms per job
-            await asyncio.sleep(matching_time)
-            
-            # Find matching agents (simplified)
-            matching_agents = [f"agent_{j}" for j in range(min(10, agent_count))]
-            matches.append({
-                'job_id': f"job_{i}",
-                'matching_agents': matching_agents
-            })
-        
-        end_time = time.time()
-        matching_time_total = end_time - start_time
-        throughput = job_count / matching_time_total
-        
-        # Performance requirements
-        assert throughput >= 10, f"Capability matching throughput {throughput:.2f} jobs/s below 10 jobs/s target"
-        
-        print(f"Capability matching: {throughput:.2f} jobs/second")
-    
-    @pytest.mark.asyncio
-    async def test_reputation_update_speed(self):
-        """Test reputation update performance"""
-        update_count = 5000
-        start_time = time.time()
-        
-        reputation_updates = []
-        
-        for i in range(update_count):
-            # Simulate reputation update
-            update_time = 0.002  # 2ms per update
-            await asyncio.sleep(update_time)
-            
-            reputation_updates.append({
-                'agent_id': f"agent_{i % 1000}",  # 1000 unique agents
-                'score_change': 0.01
-            })
-        
-        end_time = time.time()
-        update_time_total = end_time - start_time
-        throughput = update_count / update_time_total
-        
-        # Performance requirements
-        assert throughput >= 1000, f"Reputation update throughput {throughput:.2f} updates/s below 1000 updates/s target"
-        
-        print(f"Reputation updates: {throughput:.2f} updates/second")
-
-
-class TestSmartContractPerformance:
-    """Test smart contract performance"""
-    
-    @pytest.mark.asyncio
-    async def test_escrow_creation_speed(self):
-        """Test escrow contract creation performance"""
-        contract_count = 1000
-        start_time = time.time()
-        
-        created_contracts = []
-        
-        for i in range(contract_count):
-            # Simulate escrow contract creation
-            creation_time = 0.03  # 30ms per contract
-            await asyncio.sleep(creation_time)
-            
-            created_contracts.append({
-                'contract_id': f"contract_{i}",
-                'amount': Decimal('100.0'),
-                'created_at': time.time()
-            })
-        
-        end_time = time.time()
-        creation_time_total = end_time - start_time
-        throughput = len(created_contracts) / creation_time_total
-        
-        # Performance requirements
-        assert throughput >= 20, f"Escrow creation throughput {throughput:.2f} contracts/s below 20 contracts/s target"
-        
-        print(f"Escrow contract creation: {throughput:.2f} contracts/second")
-    
-    @pytest.mark.asyncio
-    async def test_dispute_resolution_speed(self):
-        """Test dispute resolution performance"""
-        dispute_count = 100
-        start_time = time.time()
-        
-        resolved_disputes = []
-        
-        for i in range(dispute_count):
-            # Simulate dispute resolution
-            resolution_time = 0.5  # 500ms per dispute
-            await asyncio.sleep(resolution_time)
-            
-            resolved_disputes.append({
-                'dispute_id': f"dispute_{i}",
-                'resolution': 'agent_favored',
-                'resolved_at': time.time()
-            })
-        
-        end_time = time.time()
-        resolution_time_total = end_time - start_time
-        throughput = len(resolved_disputes) / resolution_time_total
-        
-        # Performance requirements
-        assert throughput >= 1, f"Dispute resolution throughput {throughput:.2f} disputes/s below 1 dispute/s target"
-        
-        print(f"Dispute resolution: {throughput:.2f} disputes/second")
-    
-    @pytest.mark.asyncio
-    async def test_gas_optimization_speed(self):
-        """Test gas optimization performance"""
-        optimization_count = 100
-        start_time = time.time()
-        
-        optimizations = []
-        
-        for i in range(optimization_count):
-            # Simulate gas optimization analysis
-            analysis_time = 0.1  # 100ms per optimization
-            await asyncio.sleep(analysis_time)
-            
-            optimizations.append({
-                'contract_id': f"contract_{i}",
-                'original_gas': 50000,
-                'optimized_gas': 40000,
-                'savings': 10000
-            })
-        
-        end_time = time.time()
-        optimization_time_total = end_time - start_time
-        throughput = len(optimizations) / optimization_time_total
-        
-        # Performance requirements
-        assert throughput >= 5, f"Gas optimization throughput {throughput:.2f} optimizations/s below 5 optimizations/s target"
-        
-        print(f"Gas optimization: {throughput:.2f} optimizations/second")
-
-
-class TestSystemWidePerformance:
-    """Test system-wide performance under realistic load"""
-    
-    @pytest.mark.asyncio
-    async def test_full_workflow_performance(self):
-        """Test complete job execution workflow performance"""
-        workflow_count = 100
-        start_time = time.time()
-        
-        completed_workflows = []
-        
-        for i in range(workflow_count):
-            workflow_start = time.time()
-            
-            # 1. Create escrow contract (30ms)
-            await asyncio.sleep(0.03)
-            
-            # 2. Find matching agent (50ms)
-            await asyncio.sleep(0.05)
-            
-            # 3. Agent accepts job (10ms)
-            await asyncio.sleep(0.01)
-            
-            # 4. Execute job (variable time, avg 1s)
-            job_time = 1.0 + (i % 3) * 0.5  # 1-2.5 seconds
-            await asyncio.sleep(job_time)
-            
-            # 5. Complete milestone (20ms)
-            await asyncio.sleep(0.02)
-            
-            # 6. Release payment (10ms)
-            await asyncio.sleep(0.01)
-            
-            workflow_end = time.time()
-            workflow_time = workflow_end - workflow_start
-            
-            completed_workflows.append({
-                'workflow_id': f"workflow_{i}",
-                'total_time': workflow_time,
-                'job_time': job_time
-            })
-        
-        end_time = time.time()
-        total_time = end_time - start_time
-        throughput = len(completed_workflows) / total_time
-        
-        # Performance requirements
-        assert throughput >= 10, f"Workflow throughput {throughput:.2f} workflows/s below 10 workflows/s target"
-        
-        # Check average workflow time
-        avg_workflow_time = statistics.mean([w['total_time'] for w in completed_workflows])
-        assert avg_workflow_time < 5.0, f"Average workflow time {avg_workflow_time:.2f}s exceeds 5s target"
-        
-        print(f"Full workflow throughput: {throughput:.2f} workflows/second")
-        print(f"Average workflow time: {avg_workflow_time:.2f}s")
-    
-    @pytest.mark.asyncio
-    async def test_concurrent_load_performance(self):
-        """Test system performance under concurrent load"""
-        concurrent_users = 50
-        operations_per_user = 20
-        start_time = time.time()
-        
-        async def user_simulation(user_id):
-            """Simulate a single user's operations"""
-            user_operations = []
-            
-            for op in range(operations_per_user):
-                op_start = time.time()
-                
-                # Simulate random operation
-                import random
-                operation_type = random.choice(['create_contract', 'find_agent', 'submit_job'])
-                
-                if operation_type == 'create_contract':
-                    await asyncio.sleep(0.03)  # 30ms
-                elif operation_type == 'find_agent':
-                    await asyncio.sleep(0.05)  # 50ms
-                else:  # submit_job
-                    await asyncio.sleep(0.02)  # 20ms
-                
-                op_end = time.time()
-                user_operations.append({
-                    'user_id': user_id,
-                    'operation': operation_type,
-                    'time': op_end - op_start
-                })
-            
-            return user_operations
-        
-        # Run all users concurrently
-        tasks = [user_simulation(i) for i in range(concurrent_users)]
-        results = await asyncio.gather(*tasks)
-        
-        end_time = time.time()
-        total_time = end_time - start_time
-        
-        # Flatten results
-        all_operations = []
-        for user_ops in results:
-            all_operations.extend(user_ops)
-        
-        total_operations = len(all_operations)
-        throughput = total_operations / total_time
-        
-        # Performance requirements
-        assert throughput >= 100, f"Concurrent load throughput {throughput:.2f} ops/s below 100 ops/s target"
-        assert total_operations == concurrent_users * operations_per_user, f"Missing operations: {total_operations}/{concurrent_users * operations_per_user}"
-        
-        print(f"Concurrent load performance: {throughput:.2f} operations/second")
-        print(f"Total operations: {total_operations} from {concurrent_users} users")
-    
-    @pytest.mark.asyncio
-    async def test_memory_usage_under_load(self):
-        """Test memory usage under high load"""
-        import psutil
-        import os
-        
-        process = psutil.Process(os.getpid())
-        initial_memory = process.memory_info().rss / 1024 / 1024  # MB
-        
-        # Simulate high load
-        large_dataset = []
-        
-        for i in range(10000):
-            # Create large objects to simulate memory pressure
-            large_dataset.append({
-                'id': i,
-                'data': 'x' * 1000,  # 1KB per object
-                'timestamp': time.time(),
-                'metadata': {
-                    'field1': f"value_{i}",
-                    'field2': i * 2,
-                    'field3': i % 100
             }
-            })
         
-        peak_memory = process.memory_info().rss / 1024 / 1024  # MB
+        # Test with 100 concurrent requests
-        memory_increase = peak_memory - initial_memory
+        with ThreadPoolExecutor(max_workers=50) as executor:
+            futures = [executor.submit(make_request) for _ in range(100)]
+            results = [future.result() for future in as_completed(futures)]
         
-        # Clean up
+        # Analyze results
-        del large_dataset
+        response_times = [r['response_time'] for r in results]
+        success_count = sum(1 for r in results if r['status_code'] == 200)
         
-        final_memory = process.memory_info().rss / 1024 / 1024  # MB
+        assert success_count >= 95  # 95% success rate
-        memory_recovered = peak_memory - final_memory
+        assert statistics.mean(response_times) < 0.5  # Average < 500ms
+        assert statistics.median(response_times) < 0.3  # Median < 300ms
+        assert max(response_times) < 2.0  # Max < 2 seconds
     
-        # Performance requirements
+    def test_agent_registration_performance(self):
-        assert memory_increase < 500, f"Memory increase {memory_increase:.2f}MB exceeds 500MB limit"
+        """Test agent registration performance"""
-        assert memory_recovered > memory_increase * 0.8, f"Memory recovery {memory_recovered:.2f}MB insufficient"
+        def register_agent(i):
+            agent_data = {
+                "agent_id": f"perf_test_agent_{i}",
+                "agent_type": "worker",
+                "capabilities": ["test"],
+                "services": ["test_service"]
+            }
             
-        print(f"Memory usage - Initial: {initial_memory:.2f}MB, Peak: {peak_memory:.2f}MB, Final: {final_memory:.2f}MB")
+            start_time = time.time()
-        print(f"Memory increase: {memory_increase:.2f}MB, Recovered: {memory_recovered:.2f}MB")
+            response = requests.post(
+                f"{self.BASE_URL}/agents/register",
+                json=agent_data,
+                headers={"Content-Type": "application/json"}
+            )
+            end_time = time.time()
             
+            return {
+                'status_code': response.status_code,
+                'response_time': end_time - start_time
+            }
         
-class TestScalabilityLimits:
+        # Test with 50 concurrent registrations
-    """Test system scalability limits"""
+        with ThreadPoolExecutor(max_workers=25) as executor:
+            futures = [executor.submit(register_agent, i) for i in range(50)]
+            results = [future.result() for future in as_completed(futures)]
         
-    @pytest.mark.asyncio
+        response_times = [r['response_time'] for r in results]
-    async def test_maximum_validator_count(self):
+        success_count = sum(1 for r in results if r['status_code'] == 200)
-        """Test system performance with maximum validator count"""
+        
-        max_validators = 100
+        assert success_count >= 45  # 90% success rate
+        assert statistics.mean(response_times) < 1.0  # Average < 1 second
+    
+    def test_load_balancer_performance(self):
+        """Test load balancer performance"""
+        def get_stats():
+            start_time = time.time()
+            response = requests.get(f"{self.BASE_URL}/load-balancer/stats")
+            end_time = time.time()
+            return {
+                'status_code': response.status_code,
+                'response_time': end_time - start_time
+            }
+        
+        # Test with 200 concurrent requests
+        with ThreadPoolExecutor(max_workers=100) as executor:
+            futures = [executor.submit(get_stats) for _ in range(200)]
+            results = [future.result() for future in as_completed(futures)]
+        
+        response_times = [r['response_time'] for r in results]
+        success_count = sum(1 for r in results if r['status_code'] == 200)
+        
+        assert success_count >= 190  # 95% success rate
+        assert statistics.mean(response_times) < 0.3  # Average < 300ms
+
+class TestSystemResourceUsage:
+    """Test system resource usage during operations"""
+    
+    def test_memory_usage_during_load(self):
+        """Test memory usage during high load"""
+        process = psutil.Process()
+        initial_memory = process.memory_info().rss
+        
+        # Perform memory-intensive operations
+        def heavy_operation():
+            for _ in range(10):
+                response = requests.get("http://localhost:9001/registry/stats")
+                time.sleep(0.01)
+        
+        # Run 20 concurrent heavy operations
+        threads = []
+        for _ in range(20):
+            thread = threading.Thread(target=heavy_operation)
+            threads.append(thread)
+            thread.start()
+        
+        for thread in threads:
+            thread.join()
+        
+        final_memory = process.memory_info().rss
+        memory_increase = final_memory - initial_memory
+        
+        # Memory increase should be reasonable (< 50MB)
+        assert memory_increase < 50 * 1024 * 1024  # 50MB in bytes
+    
+    def test_cpu_usage_during_load(self):
+        """Test CPU usage during high load"""
+        process = psutil.Process()
+        
+        # Monitor CPU during load test
+        def cpu_monitor():
+            cpu_percentages = []
+            for _ in range(10):
+                cpu_percentages.append(process.cpu_percent())
+                time.sleep(0.1)
+            return statistics.mean(cpu_percentages)
+        
+        # Start CPU monitoring
+        monitor_thread = threading.Thread(target=cpu_monitor)
+        monitor_thread.start()
+        
+        # Perform CPU-intensive operations
+        for _ in range(50):
+            response = requests.get("http://localhost:9001/load-balancer/stats")
+            # Process response to simulate CPU work
+            data = response.json()
+            _ = len(str(data))
+        
+        monitor_thread.join()
+        
+        # CPU usage should be reasonable (< 80%)
+        # Note: This is a rough test, actual CPU usage depends on system load
+
+class TestConcurrencyLimits:
+    """Test system behavior under concurrency limits"""
+    
+    def test_maximum_concurrent_connections(self):
+        """Test maximum concurrent connections"""
+        def make_request():
+            try:
+                response = requests.get("http://localhost:9001/health", timeout=5)
+                return response.status_code == 200
+            except:
+                return False
+        
+        # Test with increasing concurrency
+        max_concurrent = 0
+        for concurrency in [50, 100, 200, 500]:
+            with ThreadPoolExecutor(max_workers=concurrency) as executor:
+                futures = [executor.submit(make_request) for _ in range(concurrency)]
+                results = [future.result() for future in as_completed(futures)]
+            
+            success_rate = sum(results) / len(results)
+            
+            if success_rate >= 0.8:  # 80% success rate
+                max_concurrent = concurrency
+            else:
+                break
+        
+        # Should handle at least 100 concurrent connections
+        assert max_concurrent >= 100
+
+class TestScalabilityMetrics:
+    """Test scalability metrics"""
+    
+    def test_response_time_scaling(self):
+        """Test how response times scale with load"""
+        loads = [1, 10, 50, 100]
+        response_times = []
+        
+        for load in loads:
+            def make_request():
+                start_time = time.time()
+                response = requests.get("http://localhost:9001/health")
+                end_time = time.time()
+                return end_time - start_time
+            
+            with ThreadPoolExecutor(max_workers=load) as executor:
+                futures = [executor.submit(make_request) for _ in range(load)]
+                results = [future.result() for future in as_completed(futures)]
+            
+            avg_time = statistics.mean(results)
+            response_times.append(avg_time)
+        
+        # Response times should scale reasonably
+        # (not more than 10x increase from 1 to 100 concurrent requests)
+        assert response_times[-1] < response_times[0] * 10
+    
+    def test_throughput_metrics(self):
+        """Test throughput metrics"""
+        duration = 10  # Test for 10 seconds
         start_time = time.time()
         
-        # Simulate consensus with maximum validators
+        def make_request():
-        consensus_time = 0.1 + (max_validators * 0.002)  # 2ms per validator
+            return requests.get("http://localhost:9001/health")
-        await asyncio.sleep(consensus_time)
         
-        end_time = time.time()
+        requests_made = 0
-        total_time = end_time - start_time
+        with ThreadPoolExecutor(max_workers=50) as executor:
+            while time.time() - start_time < duration:
+                futures = [executor.submit(make_request) for _ in range(10)]
+                for future in as_completed(futures):
+                    future.result()  # Wait for completion
+                    requests_made += 1
         
-        # Performance requirements
+        throughput = requests_made / duration  # requests per second
-        assert total_time < 5.0, f"Consensus with {max_validators} validators too slow: {total_time:.2f}s"
         
-        print(f"Maximum validator test ({max_validators} validators): {total_time:.2f}s")
+        # Should handle at least 50 requests per second
+        assert throughput >= 50
 
-    @pytest.mark.asyncio
+if __name__ == '__main__':
-    async def test_maximum_agent_count(self):
+    pytest.main([__file__])
-        """Test system performance with maximum agent count"""
-        max_agents = 10000
-        start_time = time.time()
-        
-        # Simulate agent registry operations
-        registry_time = max_agents * 0.0001  # 0.1ms per agent
-        await asyncio.sleep(registry_time)
-        
-        end_time = time.time()
-        total_time = end_time - start_time
-        
-        # Performance requirements
-        assert total_time < 10.0, f"Agent registry with {max_agents} agents too slow: {total_time:.2f}s"
-        
-        print(f"Maximum agent test ({max_agents} agents): {total_time:.2f}s")
-    
-    @pytest.mark.asyncio
-    async def test_maximum_concurrent_transactions(self):
-        """Test system performance with maximum concurrent transactions"""
-        max_transactions = 10000
-        start_time = time.time()
-        
-        # Simulate transaction processing
-        with concurrent.futures.ThreadPoolExecutor(max_workers=50) as executor:
-            futures = []
-            
-            for i in range(max_transactions):
-                future = executor.submit(self._process_heavy_transaction, f"tx_{i}")
-                futures.append(future)
-            
-            # Wait for completion
-            completed = 0
-            for future in concurrent.futures.as_completed(futures):
-                result = future.result()
-                if result:
-                    completed += 1
-        
-        end_time = time.time()
-        total_time = end_time - start_time
-        throughput = completed / total_time
-        
-        # Performance requirements
-        assert throughput >= 500, f"Max transaction throughput {throughput:.2f} tx/s below 500 tx/s target"
-        assert completed == max_transactions, f"Only {completed}/{max_transactions} transactions completed"
-        
-        print(f"Maximum concurrent transactions ({max_transactions} tx): {throughput:.2f} tx/s")
-    
-    def _process_heavy_transaction(self, tx_id):
-        """Simulate heavy transaction processing"""
-        # Simulate computation time
-        time.sleep(0.002)  # 2ms per transaction
-        return tx_id
-
-
-if __name__ == "__main__":
-    pytest.main([
-        __file__,
-        "-v",
-        "--tb=short",
-        "--maxfail=5"
-    ])

tests/test_runner_updated.py

@@ -0,0 +1,199 @@
+#!/usr/bin/env python3
+"""
+Updated Test Runner for AITBC Agent Systems
+Includes all test phases and API integration tests
+"""
+
+import subprocess
+import sys
+import os
+from pathlib import Path
+import time
+
+def run_test_suite():
+    """Run complete test suite"""
+    base_dir = Path(__file__).parent
+    
+    print("=" * 80)
+    print("AITBC AGENT SYSTEMS - COMPLETE TEST SUITE")
+    print("=" * 80)
+    
+    test_suites = [
+        {
+            "name": "Agent Coordinator Communication Tests",
+            "path": base_dir / "../apps/agent-coordinator/tests/test_communication_fixed.py",
+            "type": "unit"
+        },
+        {
+            "name": "Agent Coordinator API Tests",
+            "path": base_dir / "test_agent_coordinator_api.py",
+            "type": "integration"
+        },
+        {
+            "name": "Phase 1: Consensus Tests",
+            "path": base_dir / "phase1/consensus/test_consensus.py",
+            "type": "phase"
+        },
+        {
+            "name": "Phase 3: Decision Framework Tests",
+            "path": base_dir / "phase3/test_decision_framework.py",
+            "type": "phase"
+        },
+        {
+            "name": "Phase 4: Autonomous Decision Making Tests",
+            "path": base_dir / "phase4/test_autonomous_decision_making.py",
+            "type": "phase"
+        },
+        {
+            "name": "Phase 5: Vision Integration Tests",
+            "path": base_dir / "phase5/test_vision_integration.py",
+            "type": "phase"
+        }
+    ]
+    
+    results = {}
+    total_tests = 0
+    total_passed = 0
+    total_failed = 0
+    total_skipped = 0
+    
+    for suite in test_suites:
+        print(f"\n{'-' * 60}")
+        print(f"Running: {suite['name']}")
+        print(f"Type: {suite['type']}")
+        print(f"{'-' * 60}")
+        
+        if not suite['path'].exists():
+            print(f"❌ Test file not found: {suite['path']}")
+            results[suite['name']] = {
+                'status': 'skipped',
+                'reason': 'file_not_found'
+            }
+            continue
+        
+        try:
+            # Run the test suite
+            start_time = time.time()
+            result = subprocess.run([
+                sys.executable, '-m', 'pytest',
+                str(suite['path']),
+                '-v',
+                '--tb=short',
+                '--no-header'
+            ], capture_output=True, text=True, cwd=base_dir)
+            
+            end_time = time.time()
+            execution_time = end_time - start_time
+            
+            # Parse results
+            output_lines = result.stdout.split('\n')
+            passed = 0
+            failed = 0
+            skipped = 0
+            errors = 0
+            
+            for line in output_lines:
+                if ' passed' in line and ' failed' in line:
+                    # Parse pytest summary line
+                    parts = line.split()
+                    for i, part in enumerate(parts):
+                        if part.isdigit() and i > 0:
+                            if 'passed' in parts[i+1]:
+                                passed = int(part)
+                            elif 'failed' in parts[i+1]:
+                                failed = int(part)
+                            elif 'skipped' in parts[i+1]:
+                                skipped = int(part)
+                            elif 'error' in parts[i+1]:
+                                errors = int(part)
+                elif ' passed in ' in line:
+                    # Single test passed
+                    passed = 1
+                elif ' failed in ' in line:
+                    # Single test failed
+                    failed = 1
+                elif ' skipped in ' in line:
+                    # Single test skipped
+                    skipped = 1
+            
+            suite_total = passed + failed + errors
+            suite_passed = passed
+            suite_failed = failed + errors
+            suite_skipped = skipped
+            
+            # Update totals
+            total_tests += suite_total
+            total_passed += suite_passed
+            total_failed += suite_failed
+            total_skipped += suite_skipped
+            
+            # Store results
+            results[suite['name']] = {
+                'status': 'completed',
+                'total': suite_total,
+                'passed': suite_passed,
+                'failed': suite_failed,
+                'skipped': suite_skipped,
+                'execution_time': execution_time,
+                'returncode': result.returncode
+            }
+            
+            # Print summary
+            print(f"✅ Completed in {execution_time:.2f}s")
+            print(f"📊 Results: {suite_passed} passed, {suite_failed} failed, {suite_skipped} skipped")
+            
+            if result.returncode != 0:
+                print(f"❌ Some tests failed")
+                if result.stderr:
+                    print(f"Errors: {result.stderr[:200]}...")
+            
+        except Exception as e:
+            print(f"❌ Error running test suite: {e}")
+            results[suite['name']] = {
+                'status': 'error',
+                'error': str(e)
+            }
+    
+    # Print final summary
+    print("\n" + "=" * 80)
+    print("FINAL TEST SUMMARY")
+    print("=" * 80)
+    
+    print(f"Total Test Suites: {len(test_suites)}")
+    print(f"Total Tests: {total_tests}")
+    print(f"Passed: {total_passed} ({total_passed/total_tests*100:.1f}%)" if total_tests > 0 else "Passed: 0")
+    print(f"Failed: {total_failed} ({total_failed/total_tests*100:.1f}%)" if total_tests > 0 else "Failed: 0")
+    print(f"Skipped: {total_skipped} ({total_skipped/total_tests*100:.1f}%)" if total_tests > 0 else "Skipped: 0")
+    
+    print(f"\nSuite Details:")
+    for name, result in results.items():
+        print(f"\n{name}:")
+        if result['status'] == 'completed':
+            print(f"  Status: ✅ Completed")
+            print(f"  Tests: {result['total']} (✅ {result['passed']}, ❌ {result['failed']}, ⏭️ {result['skipped']})")
+            print(f"  Time: {result['execution_time']:.2f}s")
+        elif result['status'] == 'skipped':
+            print(f"  Status: ⏭️ Skipped ({result.get('reason', 'unknown')})")
+        else:
+            print(f"  Status: ❌ Error ({result.get('error', 'unknown')})")
+    
+    # Overall status
+    success_rate = (total_passed / total_tests * 100) if total_tests > 0 else 0
+    
+    print(f"\n{'=' * 80}")
+    if success_rate >= 90:
+        print("🎉 EXCELLENT: Test suite passed with high success rate!")
+    elif success_rate >= 75:
+        print("✅ GOOD: Test suite passed with acceptable success rate!")
+    elif success_rate >= 50:
+        print("⚠️  WARNING: Test suite has significant failures!")
+    else:
+        print("❌ CRITICAL: Test suite has major issues!")
+    
+    print(f"Overall Success Rate: {success_rate:.1f}%")
+    print("=" * 80)
+    
+    return results
+
+if __name__ == '__main__':
+    run_test_suite()