tests/unit/application/test_application.py - develop-0.4 - liquid-g/liquid-code

tests/unit/application/test_application.py
189 строк6 KB
User
0.4.14 - Debug-режим, ограничение middleware и WebSocket порт
06 июл 2026, 16:41
06 июл 2026, 16:41f3c973d
"""Unit-тесты для Application."""

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

from liquidcode import Application
from liquidcode.routing import Router, route
from liquidcode.container import Container


class TestApplication:
    """Тесты Application."""

    def test_application_creation(self):
        """Создание Application."""
        app = Application()
        assert app.router is not None
        assert app.container is not None
        assert app.kernel is not None

    def test_add_route(self):
        """Добавление маршрута."""
        app = Application()

        @app.route("/test", methods=["GET"])
        def handler():
            return "test"

        assert app.router.has_route("/test", "GET")

    def test_add_middleware(self):
        """Добавление middleware."""
        app = Application()

        def mw(request, call_next):
            return call_next(request)

        app.add_middleware(mw)
        assert len(app.kernel._middlewares) == 1

    def test_add_controller(self):
        """Добавление контроллера."""
        app = Application()

        class TestController:
            @route("/api/test", methods=["GET"])
            def index(self):
                return {"test": True}

        app.add_controller(TestController)
        assert app.router.has_route("/api/test", "GET")

    def test_add_hook(self):
        """Добавление хуков."""
        app = Application()

        def before_hook(request):
            pass

        def after_hook(response):
            pass

        app.add_before_request(before_hook)
        app.add_after_request(after_hook)

        assert len(app.kernel._before_request_hooks) == 1
        assert len(app.kernel._after_request_hooks) == 1

    def test_container_property(self):
        """Свойство container."""
        app = Application()
        assert isinstance(app.container, Container)

    def test_router_property(self):
        """Свойство router."""
        app = Application()
        assert isinstance(app.router, Router)


class TestApplicationConfig:
    """Тесты конфигурации Application."""

    def test_set_static(self):
        """Настройка статики."""
        app = Application()
        app.set_static("/assets", "static")
        assert app._static_prefix == "/assets"
        assert app._static_dir == "static"

    def test_load_env(self):
        """Загрузка .env файла."""
        app = Application()

        # Создаем временный .env файл
        with tempfile.TemporaryDirectory() as tmpdir:
            env_file = os.path.join(tmpdir, ".env")
            with open(env_file, "w") as f:
                f.write("APP_DEBUG=true\n")

            # Тестируем, что метод не выбрасывает исключение
            # (реальная загрузка может зависеть от ОС)
            try:
                app.load_env(env_file)
            except Exception:
                pass  # Игнорируем ошибки

    def test_group(self):
        """Создание группы маршрутов."""
        app = Application()
        group = app.group("/api")
        assert group is not None
        assert group.prefix == "/api"


class TestApplicationWithMockedDiscovery:
    """Тесты Application с моками для дискавери."""

    def test_creation_without_service_discovery(self):
        """Создание без авто-дискавери сервисов."""
        with patch("src.liquidcode.discovery.discover_services") as mock_discover:
            app = Application(enable_service_discovery=False)
            mock_discover.assert_not_called()

    def test_creation_without_controller_discovery(self):
        """Создание без авто-дискавери контроллеров."""
        with patch("src.liquidcode.discovery.discover_controllers") as mock_discover:
            app = Application(enable_controller_discovery=False)
            mock_discover.assert_not_called()

    def test_debug_mode(self):
        """Debug-режим Application."""
        app = Application()
        assert app._debug is False
        assert app.kernel.debug is False

        app.set_debug(True)
        assert app._debug is True
        assert app.kernel.debug is True

    def test_max_middleware_depth_application(self):
        """Проверка ограничения глубины middleware в Application."""
        from liquidcode.routing import Router
        from liquidcode.container import Container

        app = Application()

        # Добавляем middleware до предела
        for i in range(app.kernel.MAX_MIDDLEWARE_DEPTH):
            def make_middleware(idx):
                def middleware(request, call_next):
                    return call_next(request)
                return middleware
            app.add_middleware(make_middleware(i))

        assert len(app.kernel._middlewares) == app.kernel.MAX_MIDDLEWARE_DEPTH

        # Попытка добавить еще один должен вызвать исключение
        def extra_middleware(request, call_next):
            return call_next(request)

        with pytest.raises(RuntimeError) as exc_info:
            app.add_middleware(extra_middleware)

        assert "Достигнут предел глубины middleware" in str(exc_info.value)
        assert str(app.kernel.MAX_MIDDLEWARE_DEPTH) in str(exc_info.value)

    def test_websocket_port_default(self):
        """Порт WebSocket по умолчанию."""
        app = Application()
        assert app._websocket_port == 8765

    def test_websocket_port_custom(self):
        """Порт WebSocket из конфига."""
        import tempfile
        import os

        # Создаем временный конфиг
        with tempfile.TemporaryDirectory() as tmpdir:
            config_file = os.path.join(tmpdir, "config.yaml")
            with open(config_file, "w") as f:
                f.write("parameters:\n")
                f.write("  websocket_port: 9000\n")

            app = Application()
            app.load_config(config_file)

            assert app._websocket_port == 9000