tests/unit/kernel/test_chain_builder.py - develop-0.4 - liquid-g/liquid-code

tests/unit/kernel/test_chain_builder.py
216 строк7 KB
User
0.4.9 - переработка документации, рефакторинг кода, покрытие тестами 70%
06 июл 2026, 13:37
06 июл 2026, 13:3779b2ebc
"""Unit-тесты для chain_builder module."""

import pytest
from unittest.mock import Mock

# Импортируем через пакет для покрытия
from liquidcode.kernel import build_middleware_chain
from liquidcode.kernel.chain_builder import _wrap_simple, _wrap_with_profiler
from liquidcode.kernel import Kernel
from liquidcode.routing import Router
from liquidcode.container import Container


def dummy_handler(request):
    """Простой обработчик для тестов."""
    return "response"


def dummy_middleware(request, call_next):
    """Простой middleware для тестов."""
    result = call_next(request)
    return result


class TestChainBuilder:
    """Тесты сборщика цепочек middleware."""

    def test_build_middleware_chain_empty(self):
        """Сборка цепочки без middleware."""
        handler = dummy_handler
        middlewares = []
        
        chain = build_middleware_chain(handler, middlewares)
        
        # Проверяем, что цепочка вызывается и возвращает результат
        result = chain(None)
        assert result == "response"

    def test_build_middleware_chain_single(self):
        """Сборка цепочки с одним middleware."""
        handler = dummy_handler
        middlewares = [dummy_middleware]
        
        chain = build_middleware_chain(handler, middlewares)
        
        result = chain(None)
        assert result == "response"

    def test_build_middleware_chain_multiple(self):
        """Сборка цепочки с несколькими middleware."""
        handler = dummy_handler
        
        def mw1(request, call_next):
            return call_next(request)
        
        def mw2(request, call_next):
            return call_next(request)
        
        def mw3(request, call_next):
            return call_next(request)
        
        middlewares = [mw1, mw2, mw3]
        
        chain = build_middleware_chain(handler, middlewares)
        
        result = chain(None)
        assert result == "response"

    def test_build_middleware_chain_with_profiler(self):
        """Сборка цепочки с профайлером."""
        handler = dummy_handler
        middlewares = [dummy_middleware]
        
        chain = build_middleware_chain(handler, middlewares, profiler_enabled=True)
        
        # Создаем mock request с profiler_context
        request = Mock()
        request.get_attr = Mock(return_value=None)
        
        result = chain(request)
        assert result == "response"

    def test_build_middleware_chain_order(self):
        """Проверка порядка выполнения middleware (LIFO)."""
        handler = dummy_handler
        execution_order = []
        
        def mw1(request, call_next):
            execution_order.append('mw1_before')
            result = call_next(request)
            execution_order.append('mw1_after')
            return result
        
        def mw2(request, call_next):
            execution_order.append('mw2_before')
            result = call_next(request)
            execution_order.append('mw2_after')
            return result
        
        middlewares = [mw1, mw2]
        
        chain = build_middleware_chain(handler, middlewares)
        chain(None)
        
        # Проверяем порядок выполнения
        # Порядок: mw1 -> mw2 -> handler (FIFO, так как добавляем в том же порядке)
        expected_order = ['mw1_before', 'mw2_before', 'mw2_after', 'mw1_after']
        assert execution_order == expected_order


class TestWrapSimple:
    """Тесты простой обёртки без профайлера."""

    def test_wrap_simple_basic(self):
        """Базовая обёртка middleware."""
        def middleware(request, call_next):
            return call_next(request)
        
        def next_step(request):
            return "next_result"
        
        wrapped = _wrap_simple(middleware, next_step)
        result = wrapped(None)
        
        assert result == "next_result"

    def test_wrap_simple_modifies_request(self):
        """Middleware может модифицировать request."""
        def middleware(request, call_next):
            request.modified = True
            return call_next(request)
        
        def next_step(request):
            return getattr(request, 'modified', False)
        
        wrapped = _wrap_simple(middleware, next_step)
        result = wrapped(Mock())
        
        assert result is True


class TestWrapWithProfiler:
    """Тесты обёртки с профайлером."""

    def test_wrap_with_profiler_basic(self):
        """Базовая обёртка с профайлером."""
        def middleware(request, call_next):
            return call_next(request)
        
        def next_step(request):
            return "result"
        
        wrapped = _wrap_with_profiler(middleware, next_step)
        result = wrapped(Mock())
        
        assert result == "result"

    def test_wrap_with_profiler_measures_time(self):
        """Профайлер измеряет время выполнения."""
        import time
        
        def middleware(request, call_next):
            time.sleep(0.01)  # Небольшая задержка
            return call_next(request)
        
        def next_step(request):
            return "result"
        
        wrapped = _wrap_with_profiler(middleware, next_step)
        result = wrapped(Mock())
        
        assert result == "result"

    def test_wrap_with_profiler_with_context(self):
        """Обёртка с профайлером и контекстом."""
        def middleware(request, call_next):
            return call_next(request)
        
        def next_step(request):
            return "result"
        
        # Создаем mock context
        context = Mock()
        context.add_middleware = Mock()
        
        request = Mock()
        request.get_attr = Mock(return_value=context)
        
        wrapped = _wrap_with_profiler(middleware, next_step)
        result = wrapped(request)
        
        assert result == "result"
        # Проверяем, что add_middleware был вызван
        context.add_middleware.assert_called()

    def test_wrap_with_profiler_middleware_name(self):
        """Профайлер использует имя middleware."""
        def my_middleware(request, call_next):
            return call_next(request)
        
        def next_step(request):
            return "result"
        
        context = Mock()
        context.add_middleware = Mock()
        
        request = Mock()
        request.get_attr = Mock(return_value=context)
        
        wrapped = _wrap_with_profiler(my_middleware, next_step)
        wrapped(request)
        
        # Проверяем, что add_middleware был вызван с именем функции
        context.add_middleware.assert_called()
        call_args = context.add_middleware.call_args
        assert call_args[0][0] == 'my_middleware'