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

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

import pytest
from unittest.mock import Mock

from liquidcode.routing import Router
from liquidcode.container import Container
from liquidcode.kernel import Kernel


class TestKernel:
    """Тесты ядра."""

    def test_kernel_creation(self):
        """Создание ядра."""
        router = Router()
        container = Container()
        kernel = Kernel(router, container)
        assert kernel.router == router
        assert kernel.container == container

    def test_kernel_with_response_class(self):
        """Ядро с кастомным классом ответа."""
        router = Router()
        container = Container()

        class CustomResponse:
            pass

        kernel = Kernel(router, container, CustomResponse)
        assert kernel.response_class == CustomResponse

    def test_kernel_with_profiler(self):
        """Ядро с профайлером."""
        router = Router()
        container = Container()
        kernel = Kernel(router, container, profiler_enabled=True)
        assert kernel.profiler_enabled is True

    def test_add_middleware(self):
        """Добавление middleware."""
        router = Router()
        container = Container()
        kernel = Kernel(router, container)

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

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

    def test_add_before_request_hook(self):
        """Добавление хука before_request."""
        router = Router()
        container = Container()
        kernel = Kernel(router, container)

        def hook(request):
            pass

        kernel.add_before_request(hook)
        assert len(kernel._before_request_hooks) == 1

    def test_add_after_request_hook(self):
        """Добавление хука after_request."""
        router = Router()
        container = Container()
        kernel = Kernel(router, container)

        def hook(response):
            pass

        kernel.add_after_request(hook)
        assert len(kernel._after_request_hooks) == 1

    def test_add_exception_hook(self):
        """Добавление хука exception."""
        router = Router()
        container = Container()
        kernel = Kernel(router, container)

        def hook(exception):
            pass

        kernel.add_exception(hook)
        assert len(kernel._exception_hooks) == 1

    def test_add_terminate_hook(self):
        """Добавление хука terminate."""
        router = Router()
        container = Container()
        kernel = Kernel(router, container)

        def hook():
            pass

        kernel.add_terminate(hook)
        assert len(kernel._terminate_hooks) == 1

    def test_kernel_with_debug(self):
        """Ядро с debug-режимом."""
        router = Router()
        container = Container()
        kernel = Kernel(router, container, debug=True)
        assert kernel.debug is True

    def test_middleware_returns_response_debug(self):
        """Middleware возвращает Response в debug-режиме."""
        from liquidcode.http import HttpResponse
        from liquidcode.routing import Router
        from liquidcode.container import Container
        from liquidcode.kernel import Kernel
        from liquidcode.contracts import Request

        router = Router()
        container = Container()
        kernel = Kernel(router, container, debug=True)

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

        kernel.add_middleware(valid_middleware)

        def dummy_controller(request):
            return HttpResponse('OK')

        router.add_route('/test', dummy_controller, ['GET'])

        request = Mock(spec=Request)
        request.get_method.return_value = 'GET'
        request.get_path.return_value = '/test'
        request.get_query_params.return_value = {}
        request.get_body.return_value = {}

        response = kernel.handle(request)
        assert response is not None

    def test_middleware_returns_non_response_debug_raises(self):
        """Middleware возвращает не Response в debug-режиме - должно вызвать TypeError."""
        from liquidcode.routing import Router
        from liquidcode.container import Container
        from liquidcode.kernel import Kernel
        from liquidcode.contracts import Request

        router = Router()
        container = Container()
        kernel = Kernel(router, container, debug=True)

        def invalid_middleware(request, call_next):
            result = call_next(request)
            return "not a response"  # Возвращаем строку вместо Response

        kernel.add_middleware(invalid_middleware)

        def dummy_controller(request):
            from liquidcode.http import HttpResponse
            return HttpResponse('OK')

        router.add_route('/test', dummy_controller, ['GET'])

        request = Mock(spec=Request)
        request.get_method.return_value = 'GET'
        request.get_path.return_value = '/test'
        request.get_query_params.return_value = {}
        request.get_body.return_value = {}

        with pytest.raises(TypeError) as exc_info:
            kernel.handle(request)

        assert "должен возвращать Response" in str(exc_info.value)

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

        router = Router()
        container = Container()
        kernel = Kernel(router, container)

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

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

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

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

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