pic/tests/test_integration.py

#!/usr/bin/env python3
"""
Integration Tests for Components
"""

import unittest
import json
import tempfile
import os
import shutil
import time
from unittest.mock import Mock, patch, MagicMock
import sys
from pathlib import Path

# Add api directory to path
api_dir = Path(__file__).parent.parent / 'api'
sys.path.insert(0, str(api_dir))

from base_service_manager import BaseServiceManager
from config_manager import ConfigManager
from service_bus import ServiceBus, EventType
from log_manager import LogManager
from network_manager import NetworkManager

class TestIntegration(unittest.TestCase):
    """Test integration between components"""
    
    def setUp(self):
        self.temp_dir = tempfile.mkdtemp()
        self.data_dir = os.path.join(self.temp_dir, 'data')
        self.config_dir = os.path.join(self.temp_dir, 'config')
        self.log_dir = os.path.join(self.temp_dir, 'logs')
        
        os.makedirs(self.data_dir, exist_ok=True)
        os.makedirs(self.config_dir, exist_ok=True)
        os.makedirs(self.log_dir, exist_ok=True)
        
        # Initialize components
        self.config_manager = ConfigManager(self.config_dir, self.data_dir)
        self.service_bus = ServiceBus()
        self.log_manager = LogManager(log_dir=self.log_dir)
        
        # Create a test service manager
        class TestServiceManager(BaseServiceManager):
            def get_status(self):
                return {'running': True, 'status': 'online'}
            
            def test_connectivity(self):
                return {'success': True, 'message': 'Connected'}
        
        self.test_service = TestServiceManager('test_service', self.data_dir, self.config_dir)
    
    def tearDown(self):
        self.log_manager.stop()
        self.service_bus.stop()
        shutil.rmtree(self.temp_dir)
    
    def test_service_bus_with_config_manager(self):
        """Test service bus integration with config manager"""
        # Register config manager with service bus
        self.service_bus.register_service('config_manager', self.config_manager)
        
        # Test calling config manager through service bus
        test_config = {
            'dns_port': 53,
            'dhcp_range': '10.0.0.100-10.0.0.200',
            'ntp_servers': ['pool.ntp.org']
        }
        
        # Update config through service bus
        result = self.service_bus.call_service(
            'config_manager', 
            'update_service_config', 
            service='network', 
            config=test_config
        )
        self.assertTrue(result)
        
        # Get config through service bus
        config = self.service_bus.call_service(
            'config_manager', 
            'get_service_config', 
            service='network'
        )
        self.assertEqual(config['dns_port'], 53)
    
    def test_service_bus_with_log_manager(self):
        """Test service bus integration with log manager"""
        # Register log manager with service bus
        self.service_bus.register_service('log_manager', self.log_manager)
        
        # Add service logger through service bus
        config = {'level': 'INFO', 'formatter': 'json'}
        result = self.service_bus.call_service(
            'log_manager',
            'add_service_logger',
            service='test_service',
            config=config
        )
        
        # Get logs through service bus
        logs = self.service_bus.call_service(
            'log_manager',
            'get_service_logs',
            service='test_service'
        )
        self.assertIsInstance(logs, list)
    
    def test_event_driven_config_updates(self):
        """Test event-driven configuration updates"""
        config_updates = []
        
        def config_change_handler(event):
            config_updates.append(event.data)
        
        # Subscribe to config change events
        self.service_bus.subscribe_to_event(EventType.CONFIG_CHANGED, config_change_handler)
        
        # Update config with valid configuration
        test_config = {
            'dns_port': 5353,
            'dhcp_range': '10.0.0.100-10.0.0.200',
            'ntp_servers': ['pool.ntp.org']
        }
        self.config_manager.update_service_config('network', test_config)
        
        # Publish config change event
        self.service_bus.publish_event(
            EventType.CONFIG_CHANGED,
            'config_manager',
            {'service': 'network', 'config': test_config}
        )
        
        # Give time for event processing
        time.sleep(0.1)
        
        # Check if event was received
        self.assertIsInstance(config_updates, list)
        # Note: Event processing might be async, so we can't guarantee immediate reception
    
    def test_service_lifecycle_with_logging(self):
        """Test service lifecycle with integrated logging"""
        # Add service logger
        self.log_manager.add_service_logger('test_service', {'level': 'INFO'})
        
        # Register service with bus
        self.service_bus.register_service('test_service', self.test_service)
        
        # Start service bus
        self.service_bus.start()
        
        # Test service operations
        status = self.service_bus.call_service('test_service', 'get_status')
        self.assertEqual(status['running'], True)
        
        # Check if logs were generated
        logs = self.log_manager.get_service_logs('test_service')
        self.assertIsInstance(logs, list)
        
        # Stop service bus
        self.service_bus.stop()
    
    def test_network_manager_inheritance(self):
        """Test NetworkManager inheritance from BaseServiceManager"""
        network_manager = NetworkManager(self.data_dir, self.config_dir)
        
        # Test inherited methods
        status = network_manager.get_status()
        self.assertIn('running', status)
        self.assertIn('status', status)
        
        connectivity = network_manager.test_connectivity()
        self.assertIn('success', connectivity)
        
        # Test network-specific methods
        self.assertTrue(hasattr(network_manager, 'get_dns_status'))
    
    def test_comprehensive_workflow(self):
        """Test comprehensive workflow with all components"""
        # Start all components
        self.service_bus.start()
        
        # Register all services
        self.service_bus.register_service('config_manager', self.config_manager)
        self.service_bus.register_service('log_manager', self.log_manager)
        self.service_bus.register_service('test_service', self.test_service)
        
        # Add logging for all services
        self.log_manager.add_service_logger('config_manager', {'level': 'INFO'})
        self.log_manager.add_service_logger('log_manager', {'level': 'INFO'})
        self.log_manager.add_service_logger('test_service', {'level': 'INFO'})
        
        # Perform workflow
        # 1. Update configuration
        test_config = {
            'dns_port': 53,
            'dhcp_range': '10.0.0.100-10.0.0.200',
            'ntp_servers': ['pool.ntp.org']
        }
        
        success = self.service_bus.call_service(
            'config_manager',
            'update_service_config',
            service='network',
            config=test_config
        )
        self.assertTrue(success)
        
        # 2. Check service status
        status = self.service_bus.call_service('test_service', 'get_status')
        self.assertEqual(status['running'], True)
        
        # 3. Get logs
        logs = self.service_bus.call_service(
            'log_manager',
            'get_service_logs',
            service='test_service'
        )
        self.assertIsInstance(logs, list)
        
        # 4. Get configuration
        config = self.service_bus.call_service(
            'config_manager',
            'get_service_config',
            service='network'
        )
        self.assertEqual(config['dns_port'], 53)
        
        # Stop all components
        self.service_bus.stop()
    
    def test_error_propagation(self):
        """Test error propagation through components"""
        # Register services
        self.service_bus.register_service('config_manager', self.config_manager)
        self.service_bus.register_service('log_manager', self.log_manager)
        
        # Add logging
        self.log_manager.add_service_logger('config_manager', {'level': 'ERROR'})
        
        # Test error handling
        with self.assertRaises(ValueError):
            self.service_bus.call_service(
                'config_manager',
                'get_service_config',
                service='nonexistent_service'
            )
        
        # Check if error was logged
        logs = self.log_manager.get_service_logs('config_manager', level='ERROR')
        self.assertIsInstance(logs, list)
    
    def test_component_initialization_order(self):
        """Test proper component initialization order"""
        # Test that components can be initialized in any order
        components = []
        
        # Initialize in different orders
        components.append(ConfigManager(self.config_dir, self.data_dir))
        components.append(ServiceBus())
        components.append(LogManager(log_dir=self.log_dir))
        
        # Verify all components are properly initialized
        for component in components:
            self.assertIsNotNone(component)
        
        # Clean up
        for component in components:
            if hasattr(component, 'stop'):
                component.stop()
    
    def test_memory_cleanup(self):
        """Test proper memory cleanup"""
        # Create components
        config_manager = ConfigManager(self.config_dir, self.data_dir)
        service_bus = ServiceBus()
        log_manager = LogManager(log_dir=self.log_dir)
        
        # Register services
        service_bus.register_service('config_manager', config_manager)
        service_bus.register_service('log_manager', log_manager)
        
        # Start services
        service_bus.start()
        
        # Stop services
        service_bus.stop()
        log_manager.stop()
        
        # Verify cleanup (no exceptions should be raised)
        self.assertTrue(True)

if __name__ == '__main__':
    unittest.main()