enclava/backend/tests/integration_test.py

"""
Integration test for the live module system
Tests all modules through the running API endpoints
"""

import asyncio
import json
import time
import httpx
from typing import Dict, Any

class LiveModuleIntegrationTest:
    """Test the live module system through API endpoints"""
    
    def __init__(self, base_url: str = "http://localhost:8000"):
        self.base_url = base_url
        self.client = httpx.AsyncClient(timeout=30.0)
    
    async def test_all_modules_loaded(self):
        """Test that all 5 modules are loaded and operational"""
        print("🧪 Testing module loading...")
        
        response = await self.client.get(f"{self.base_url}/api/v1/modules/")
        assert response.status_code == 200
        
        data = response.json()
        print(f"✓ API Response: {response.status_code}")
        print(f"✓ Total modules: {data['total']}")
        
        # Verify we have all 5 modules (updated after 2025-08-10 cleanup)
        assert data["total"] >= 5, f"Expected at least 5 modules, got {data['total']}"
        assert data["module_count"] >= 5
        assert data["initialized"] is True
        
        expected_modules = ['cache', 'chatbot', 'rag', 'signal', 'workflow']
        loaded_modules = [mod["name"] for mod in data["modules"]]
        
        for expected in expected_modules:
            assert expected in loaded_modules, f"Module {expected} not found in {loaded_modules}"
            print(f"✓ Module '{expected}' is loaded")
        
        return data
    
    async def test_module_stats_availability(self, modules_data: Dict[str, Any]):
        """Test that all modules provide stats"""
        print("\n🧪 Testing module statistics...")
        
        stats_modules = []
        for module in modules_data["modules"]:
            module_name = module["name"]
            if "stats" in module:
                stats_modules.append(module_name)
                print(f"✓ Module '{module_name}' provides stats: {len(module['stats'])} metrics")
            else:
                print(f"⚠ Module '{module_name}' no stats available")
        
        # At least some modules should provide stats
        assert len(stats_modules) >= 3, f"Expected at least 3 modules with stats, got {len(stats_modules)}"
        return stats_modules
    
    async def test_specific_module_functionality(self, modules_data: Dict[str, Any]):
        """Test specific module functionality"""
        print("\n🧪 Testing specific module functionality...")
        
        modules_by_name = {mod["name"]: mod for mod in modules_data["modules"]}
        
        # Test Cache Module
        if "cache" in modules_by_name:
            cache_stats = modules_by_name["cache"].get("stats", {})
            expected_cache_fields = ["hits", "misses", "errors", "total_requests"]
            for field in expected_cache_fields:
                assert field in cache_stats, f"Cache module missing {field} stat"
            print("✓ Cache module stats structure verified")
        
        # Test Monitoring Module 
        if "monitoring" in modules_by_name:
            monitor_stats = modules_by_name["monitoring"].get("stats", {})
            expected_monitor_fields = ["current_cpu", "current_memory", "uptime"]
            for field in expected_monitor_fields:
                assert field in monitor_stats, f"Monitoring module missing {field} stat"
            print("✓ Monitoring module stats structure verified")
            print(f"  CPU: {monitor_stats.get('current_cpu', 'N/A')}%")
            print(f"  Memory: {monitor_stats.get('current_memory', 'N/A')}%")
            print(f"  Uptime: {monitor_stats.get('uptime', 'N/A')}s")
        
        # Test Security Module
        if "security" in modules_by_name:
            security_mod = modules_by_name["security"]
            assert security_mod.get("initialized", False), "Security module should be initialized"
            print("✓ Security module is initialized")
        
        # Test Config Module
        if "config" in modules_by_name:
            config_stats = modules_by_name["config"].get("stats", {})
            expected_config_fields = ["total_configs", "active_watchers", "config_versions"]
            for field in expected_config_fields:
                assert field in config_stats, f"Config module missing {field} stat"
            print("✓ Config module stats structure verified")
            print(f"  Configurations: {config_stats.get('total_configs', 'N/A')}")
            print(f"  Active watchers: {config_stats.get('active_watchers', 'N/A')}")
            print(f"  Versions: {config_stats.get('config_versions', 'N/A')}")
    
    async def test_module_performance(self):
        """Test module system performance"""
        print("\n🧪 Testing system performance...")
        
        # Test API response time
        start_time = time.time()
        response = await self.client.get(f"{self.base_url}/api/v1/modules/")
        response_time = time.time() - start_time
        
        assert response.status_code == 200
        assert response_time < 5.0, f"API response too slow: {response_time:.2f}s"
        print(f"✓ API response time: {response_time:.3f}s")
        
        # Test multiple rapid requests
        start_time = time.time()
        tasks = []
        for i in range(5):
            task = self.client.get(f"{self.base_url}/api/v1/modules/")
            tasks.append(task)
        
        responses = await asyncio.gather(*tasks)
        total_time = time.time() - start_time
        
        # All requests should succeed
        for resp in responses:
            assert resp.status_code == 200
        
        print(f"✓ 5 concurrent requests completed in {total_time:.3f}s")
        print(f"✓ Average per request: {total_time/5:.3f}s")
    
    async def test_system_health(self):
        """Test overall system health"""
        print("\n🧪 Testing system health...")
        
        # Test health endpoint if available
        try:
            health_response = await self.client.get(f"{self.base_url}/health")
            if health_response.status_code == 200:
                print("✓ Health endpoint responding")
            else:
                print(f"⚠ Health endpoint returned {health_response.status_code}")
        except:
            print("⚠ Health endpoint not available")
        
        # Test root endpoint
        try:
            root_response = await self.client.get(f"{self.base_url}/")
            print(f"✓ Root endpoint responding: {root_response.status_code}")
        except Exception as e:
            print(f"⚠ Root endpoint error: {e}")
    
    async def run_all_tests(self):
        """Run all integration tests"""
        print("🚀 Starting Live Module Integration Tests")
        print("=" * 50)
        
        try:
            # Test 1: Module Loading
            modules_data = await self.test_all_modules_loaded()
            
            # Test 2: Module Stats
            stats_modules = await self.test_module_stats_availability(modules_data)
            
            # Test 3: Specific Functionality  
            await self.test_specific_module_functionality(modules_data)
            
            # Test 4: Performance
            await self.test_module_performance()
            
            # Test 5: System Health
            await self.test_system_health()
            
            print("\n" + "=" * 50)
            print("🎉 ALL INTEGRATION TESTS PASSED!")
            print(f"✓ {modules_data['total']} modules operational")
            print(f"✓ {len(stats_modules)} modules providing statistics")
            print("✓ Performance within acceptable limits")
            print("✓ System health verified")
            
            return True
            
        except Exception as e:
            print(f"\n❌ Integration test failed: {e}")
            import traceback
            traceback.print_exc()
            return False
        
        finally:
            await self.client.aclose()

async def run_quick_test():
    """Run a quick verification test"""
    print("🔧 Quick Module Verification Test")
    print("-" * 30)
    
    async with httpx.AsyncClient(timeout=10.0) as client:
        try:
            response = await client.get("http://localhost:8000/api/v1/modules/")
            if response.status_code == 200:
                data = response.json()
                print(f"✅ System responding: {data['total']} modules loaded")
                print(f"✅ Module count: {data['module_count']}")
                print(f"✅ System initialized: {data['initialized']}")
                
                # List all modules
                for module in data["modules"]:
                    status = "🟢" if module.get("initialized", False) else "🟡"
                    stats_count = len(module.get("stats", {}))
                    print(f"   {status} {module['name']} v{module['version']} ({stats_count} stats)")
                
                return True
            else:
                print(f"❌ API returned {response.status_code}")
                return False
        except Exception as e:
            print(f"❌ Connection failed: {e}")
            return False

if __name__ == "__main__":
    import sys
    
    if len(sys.argv) > 1 and sys.argv[1] == "--quick":
        # Quick test
        result = asyncio.run(run_quick_test())
        sys.exit(0 if result else 1)
    else:
        # Full integration test
        test_runner = LiveModuleIntegrationTest()
        result = asyncio.run(test_runner.run_all_tests())
        sys.exit(0 if result else 1)