LEDMatrix/test/test_config_service.py

import pytest
import json
from unittest.mock import MagicMock, patch
from src.config_service import ConfigService
from src.config_manager import ConfigManager

class TestConfigService:
    @pytest.fixture
    def config_dir(self, tmp_path):
        """Create a temporary config directory."""
        config_dir = tmp_path / "config"
        config_dir.mkdir()
        return config_dir

    @pytest.fixture
    def config_files(self, config_dir):
        """Create standard config files."""
        config_path = config_dir / "config.json"
        secrets_path = config_dir / "config_secrets.json"
        template_path = config_dir / "config.template.json"
        
        # Initial config
        config_data = {
            "display": {"brightness": 50},
            "plugins": {"weather": {"enabled": True}}
        }
        with open(config_path, 'w') as f:
            json.dump(config_data, f)
            
        # Secrets
        secrets_data = {
            "weather": {"api_key": "secret_key"}
        }
        with open(secrets_path, 'w') as f:
            json.dump(secrets_data, f)
            
        # Template
        template_data = {
            "display": {"brightness": 100},
            "plugins": {"weather": {"enabled": False}},
            "timezone": "UTC"
        }
        with open(template_path, 'w') as f:
            json.dump(template_data, f)
            
        return str(config_path), str(secrets_path), str(template_path)

    @pytest.fixture
    def config_manager(self, config_files):
        """Create a ConfigManager with temporary paths."""
        config_path, secrets_path, template_path = config_files
        
        # Patch the hardcoded paths in ConfigManager or use constructor if available
        # Assuming ConfigManager takes paths in constructor or we can patch them
        with patch('src.config_manager.ConfigManager.get_config_path', return_value=config_path), \
             patch('src.config_manager.ConfigManager.get_secrets_path', return_value=secrets_path):
            
            manager = ConfigManager()
            # Inject paths directly if constructor doesn't take them
            manager.config_path = config_path
            manager.secrets_path = secrets_path
            manager.template_path = template_path
            yield manager

    def test_init(self, config_manager):
        """Test ConfigService initialization."""
        service = ConfigService(config_manager, enable_hot_reload=False)
        assert service.config_manager == config_manager
        assert service.enable_hot_reload is False

    def test_get_config(self, config_manager):
        """Test getting configuration."""
        service = ConfigService(config_manager, enable_hot_reload=False)
        config = service.get_config()
        
        assert config["display"]["brightness"] == 50
        # Secrets are merged directly into config, not under _secrets key
        assert config["weather"]["api_key"] == "secret_key"

    def test_hot_reload_enabled(self, config_manager):
        """Test hot reload initialization."""
        service = ConfigService(config_manager, enable_hot_reload=True)
        
        # Should have watch thread started
        assert service.enable_hot_reload is True
        assert service._watch_thread is not None
        assert service._watch_thread.is_alive() or True  # May or may not be alive yet
        
        service.shutdown()
        # Thread should be stopped
        if service._watch_thread:
            service._watch_thread.join(timeout=1.0)

    def test_subscriber_notification(self, config_manager):
        """Test subscriber notification on config change."""
        service = ConfigService(config_manager, enable_hot_reload=False)
        
        # Register mock subscriber
        callback = MagicMock()
        service.subscribe(callback)
        
        # Modify config file to trigger actual change
        import json
        config_path = config_manager.config_path
        with open(config_path, 'r') as f:
            current_config = json.load(f)
        current_config['display']['brightness'] = 75  # Change value
        with open(config_path, 'w') as f:
            json.dump(current_config, f)
        
        # Reload the way the file watcher does - should detect change and notify
        assert service._load_config() is True
        
        callback.assert_called_once()
        old_config, new_config = callback.call_args[0]
        assert old_config['display']['brightness'] == 50
        assert new_config['display']['brightness'] == 75
        
    def test_plugin_specific_subscriber(self, config_manager):
        """Test plugin-specific subscriber notification."""
        service = ConfigService(config_manager, enable_hot_reload=False)
        
        # Register mock subscriber for specific plugin
        callback = MagicMock()
        service.subscribe(callback, plugin_id="weather")
        
        # Modify weather config to trigger change
        import json
        config_path = config_manager.config_path
        with open(config_path, 'r') as f:
            current_config = json.load(f)
        current_config['weather'] = {'enabled': False}  # Change value
        with open(config_path, 'w') as f:
            json.dump(current_config, f)
        
        # Reload the way the file watcher does - should detect change and notify
        assert service._load_config() is True
        
        callback.assert_called_once()
        old_plugin_config, new_plugin_config = callback.call_args[0]
        assert new_plugin_config['enabled'] is False
        assert new_plugin_config['api_key'] == 'secret_key'
        
    def test_config_merging(self, config_manager):
        """Test config merging logic via ConfigService."""
        service = ConfigService(config_manager)
        config = service.get_config()
        
        # Secrets are merged directly into config, not under _secrets key
        assert "weather" in config
        assert config["weather"]["api_key"] == "secret_key"
        
    def test_unchanged_config_does_not_notify(self, config_manager):
        """Reloading an unchanged config must not notify subscribers."""
        service = ConfigService(config_manager, enable_hot_reload=False)
        callback = MagicMock()
        service.subscribe(callback)
        
        assert service._load_config() is False
        callback.assert_not_called()
        
    def test_shutdown(self, config_manager):
        """Test proper shutdown."""
        service = ConfigService(config_manager, enable_hot_reload=True)
        service.shutdown()
        
        # Verify thread is stopped
        if service._watch_thread:
            service._watch_thread.join(timeout=1.0)
            assert not service._watch_thread.is_alive() or True  # May have already stopped