tests/unit/test_config_loader.py - develop-0.4 - liquid-g/liquid-code

tests/unit/test_config_loader.py
316 строк12 KB
User
0.4.19 - refactor: удалить прокси-методы _load_middleware_* в app.py (T-002)
07 июл 2026, 22:22
07 июл 2026, 22:229d1cf79
"""Unit-тесты для application/config_loader module."""

import pytest
from unittest.mock import patch, MagicMock, Mock
import os

from liquidcode.application.config_loader import load_config_to_app, interpolate_config
from liquidcode.application import Application


class TestInterpolateConfig:
    """Тесты interpolate_config."""

    def test_interpolates_dict(self):
        """Интерполирует словарь."""
        config = {
            "host": "$HOST",
            "port": "$PORT",
            "nested": {"key": "$VALUE"},
        }
        
        with patch.dict(os.environ, {"HOST": "localhost", "PORT": "8000", "VALUE": "test"}):
            result = interpolate_config(config)
            
            assert result["host"] == "localhost"
            assert result["port"] == "8000"
            assert result["nested"]["key"] == "test"

    def test_interpolates_list(self):
        """Интерполирует список."""
        config = ["$VALUE1", "$VALUE2"]
        
        with patch.dict(os.environ, {"VALUE1": "test1", "VALUE2": "test2"}):
            result = interpolate_config(config)
            
            assert result[0] == "test1"
            assert result[1] == "test2"

    def test_interpolates_string(self):
        """Интерполирует строку."""
        with patch.dict(os.environ, {"NAME": "test"}):
            result = interpolate_config("$NAME")
            
            assert result == "test"

    def test_returns_other_types_unchanged(self):
        """Возвращает другие типы без изменений."""
        assert interpolate_config(123) == 123
        assert interpolate_config(True) is True
        assert interpolate_config(None) is None


class TestLoadConfigToApp:
    """Тесты load_config_to_app."""

    def test_loads_config_successfully(self):
        """Успешная загрузка конфига."""
        app = Application()
        app._config_loaded = False
        
        config = {
            "parameters": {
                "host": "localhost",
                "port": "8000",
                "debug": "true",
            }
        }
        
        with patch("liquidcode.application.config_loader.load_config") as mock_load:
            mock_load.return_value = config
            
            with patch("os.path.exists", return_value=True):
                load_config_to_app(app, "config.yaml")
                
                assert app.host == "localhost"
                assert app.port == 8000
                assert app._debug is True
                assert app._config_loaded is True

    def test_skips_already_loaded_config(self):
        """Пропускает загрузку если конфиг уже загружен."""
        app = Application()
        app._config_loaded = True
        app.host = "localhost"
        app.port = 8000
        
        config = {
            "parameters": {
                "host": "127.0.0.1",
                "port": "9000",
            }
        }
        
        with patch("liquidcode.application.config_loader.load_config") as mock_load:
            mock_load.return_value = config
            
            with patch("logging.Logger.warning") as mock_warn:
                load_config_to_app(app, "config.yaml")
                
                # Конфиг не должен быть перезагружен
                assert app.host == "localhost"
                assert app.port == 8000
                mock_warn.assert_called_once()

    def test_handles_config_error(self):
        """Обрабатывает ошибку загрузки конфига."""
        app = Application()
        app._config_loaded = False
        
        with patch("liquidcode.application.config_loader.load_config") as mock_load:
            from liquidcode.config import ConfigError
            mock_load.side_effect = ConfigError("File not found")
            
            with patch("logging.Logger.error") as mock_error:
                load_config_to_app(app, "config.yaml")
                
                mock_error.assert_called_once()
                assert app._config_loaded is False

    def test_loads_static_config(self):
        """Загружает настройки статики."""
        app = Application()
        app._config_loaded = False
        
        config = {
            "parameters": {
                "static_prefix": "/static",
                "static_dir": "/path/to/static",
            }
        }
        
        with patch("liquidcode.application.config_loader.load_config") as mock_load:
            mock_load.return_value = config
            
            with patch("os.path.exists", return_value=True):
                load_config_to_app(app, "config.yaml")
                
                assert app._static_prefix == "/static"
                assert app._static_dir == "/path/to/static"

    def test_loads_template_config(self):
        """Загружает настройки шаблонов."""
        app = Application()
        app._config_loaded = False
        
        config = {
            "parameters": {
                "template_dir": "/path/to/templates",
            }
        }
        
        with patch("liquidcode.application.config_loader.load_config") as mock_load:
            mock_load.return_value = config
            
            with patch("os.path.exists", return_value=True):
                load_config_to_app(app, "config.yaml")
                
                assert app._template_dir == "/path/to/templates"
                assert app.template_manager is not None

    def test_loads_middleware_config(self):
        """Загружает настройки middleware."""
        app = Application()
        app._config_loaded = False
        
        config = {
            "parameters": {
                "middleware_config": "config/middleware.yaml",
            }
        }
        
        with patch("liquidcode.application.config_loader.load_config") as mock_load:
            mock_load.return_value = config
            
            with patch.object(app, "load_middleware_config") as mock_load_mw:
                load_config_to_app(app, "config.yaml")
                
                mock_load_mw.assert_called_once_with("config/middleware.yaml")

    def test_loads_middleware_from_config(self):
        """Загружает middleware из config['middleware']."""
        app = Application()
        app._config_loaded = False
        
        config = {
            "middleware": [
                {"class": "m1.M1", "enabled": True},
            ],
        }
        
        with patch("liquidcode.application.config_loader.load_config") as mock_load:
            mock_load.return_value = config
            
            with patch("liquidcode.application.config_loader.load_middleware_from_config") as mock_load_mw:
                load_config_to_app(app, "config.yaml")
                
                mock_load_mw.assert_called_once_with(app, config["middleware"])

    def test_warns_missing_static_dir(self):
        """Предупреждает если директория статики не существует."""
        app = Application()
        app._config_loaded = False
        
        config = {
            "parameters": {
                "static_dir": "/nonexistent/static",
            }
        }
        
        with patch("liquidcode.application.config_loader.load_config") as mock_load:
            mock_load.return_value = config
            
            with patch("os.path.exists", return_value=False):
                with patch("logging.Logger.warning") as mock_warn:
                    load_config_to_app(app, "config.yaml")
                    
                    mock_warn.assert_called_once()

    def test_warns_missing_template_dir(self):
        """Предупреждает если директория шаблонов не существует."""
        app = Application()
        app._config_loaded = False
        
        config = {
            "parameters": {
                "template_dir": "/nonexistent/templates",
            }
        }
        
        with patch("liquidcode.application.config_loader.load_config") as mock_load:
            mock_load.return_value = config
            
            with patch("os.path.exists", return_value=False):
                with patch("logging.Logger.warning") as mock_warn:
                    load_config_to_app(app, "config.yaml")
                    
                    mock_warn.assert_called_once()

    def test_loads_websocket_port_config(self):
        """Загружает настройки порта WebSocket."""
        app = Application()
        app._config_loaded = False
        
        config = {
            "parameters": {
                "websocket_port": "9000",
            }
        }
        
        with patch("liquidcode.application.config_loader.load_config") as mock_load:
            mock_load.return_value = config
            
            with patch("os.path.exists", return_value=True):
                load_config_to_app(app, "config.yaml")
                
                assert app._websocket_port == 9000

    def test_handles_file_not_found_gracefully(self):
        """Обрабатывает файл не найден корректно."""
        from liquidcode.config import ConfigError
        
        app = Application()
        app._config_loaded = False
        
        with patch("liquidcode.application.config_loader.load_config") as mock_load:
            mock_load.side_effect = ConfigError(
                "File not found",
                error_type=ConfigError.FILE_NOT_FOUND
            )
            
            with patch("logging.Logger.warning") as mock_warn:
                load_config_to_app(app, "config.yaml")
                
                mock_warn.assert_called_once()
                assert "не найден" in mock_warn.call_args[0][0]
                assert app._config_loaded is False

    def test_handles_permission_error(self):
        """Обрабатывает ошибку доступа."""
        from liquidcode.config import ConfigError
        
        app = Application()
        app._config_loaded = False
        
        with patch("liquidcode.application.config_loader.load_config") as mock_load:
            mock_load.side_effect = ConfigError(
                "Permission denied",
                error_type=ConfigError.PERMISSION_DENIED
            )
            
            with patch("logging.Logger.error") as mock_error:
                load_config_to_app(app, "config.yaml")
                
                # Проверяем, что был вызван logger.error
                assert mock_error.call_count >= 1
                # Проверяем, что сообщение содержит "нет прав доступа"
                error_messages = [str(call_args[0][0]) for call_args in mock_error.call_args_list]
                assert any("нет прав доступа" in msg.lower() for msg in error_messages)
                assert app._config_loaded is False

    def test_handles_other_config_errors(self):
        """Обрабатывает другие ошибки конфига."""
        from liquidcode.config import ConfigError
        
        app = Application()
        app._config_loaded = False
        
        with patch("liquidcode.application.config_loader.load_config") as mock_load:
            mock_load.side_effect = ConfigError("Invalid syntax")
            
            with patch("logging.Logger.error") as mock_error:
                load_config_to_app(app, "config.yaml")
                
                mock_error.assert_called_once()
                assert "Ошибка загрузки конфига" in mock_error.call_args[0][0]
                assert app._config_loaded is False