tests/test_profiler.py - master - liquid-g/liquid-code

tests/test_profiler.py
284 строки9 KB
User
ci: настроен Black и flake8 для автоматического форматирования кода
04 июл 2026, 08:14
04 июл 2026, 08:144778ed6
"""Тесты для профайлера LiquidCode."""

import pytest
from unittest.mock import MagicMock

from liquidcode.profiler import ProfilerContext


class TestProfilerContext:
    """Тесты для ProfilerContext."""

    def test_init(self):
        """Инициализация ProfilerContext."""
        context = ProfilerContext()

        assert context._controller_duration is None
        assert context._total_duration is None
        assert len(context._middlewares) == 0

    def test_add_middleware(self):
        """Добавление записи о middleware."""
        context = ProfilerContext()
        context.add_middleware("LoggingMiddleware", 0.0123)

        assert len(context._middlewares) == 1
        assert context._middlewares[0]["name"] == "LoggingMiddleware"
        assert context._middlewares[0]["duration"] == 0.0123

    def test_add_multiple_middlewares(self):
        """Добавление нескольких middleware."""
        context = ProfilerContext()
        context.add_middleware("AuthMiddleware", 0.005)
        context.add_middleware("LoggingMiddleware", 0.008)
        context.add_middleware("CORSMiddleware", 0.003)

        assert len(context._middlewares) == 3
        assert context._middlewares[0]["name"] == "AuthMiddleware"
        assert context._middlewares[1]["name"] == "LoggingMiddleware"
        assert context._middlewares[2]["name"] == "CORSMiddleware"

    def test_set_controller(self):
        """Установка времени выполнения контроллера."""
        context = ProfilerContext()
        context.set_controller(0.0567)

        assert context._controller_duration == 0.0567

    def test_finish(self):
        """Завершение профайлинга."""
        import time

        context = ProfilerContext()

        # Небольшая задержка, чтобы time прошёл
        time.sleep(0.01)

        context.finish()

        assert context._total_duration is not None
        assert context._total_duration >= 0.01

    def test_report_empty(self):
        """Отчёт без middleware и контроллера."""
        import time

        context = ProfilerContext()
        time.sleep(0.01)
        context.finish()

        report = context.report()

        assert "Общее время:" in report
        assert "Middleware:" not in report
        assert "Контроллер:" not in report

    def test_report_with_middlewares(self):
        """Отчёт с middleware."""
        import time

        context = ProfilerContext()
        context.add_middleware("AuthMiddleware", 0.01)
        context.add_middleware("LoggingMiddleware", 0.02)
        time.sleep(0.01)
        context.finish()

        report = context.report()

        assert "AuthMiddleware:" in report
        assert "LoggingMiddleware:" in report
        assert "Контроллер:" not in report

    def test_report_with_controller(self):
        """Отчёт с контроллером."""
        import time

        context = ProfilerContext()
        context.set_controller(0.05)
        time.sleep(0.01)
        context.finish()

        report = context.report()

        assert "Контроллер: 0.05" in report
        assert "Middleware:" not in report

    def test_report_with_all(self):
        """Отчёт со всеми компонентами."""
        import time

        context = ProfilerContext()
        context.add_middleware("AuthMiddleware", 0.01)
        context.set_controller(0.05)
        time.sleep(0.01)
        context.finish()

        report = context.report()

        assert "AuthMiddleware:" in report
        assert "Контроллер:" in report
        assert "Общее время:" in report

    def test_get_data_empty(self):
        """Получение данных в виде словаря (пустой контекст)."""
        import time

        context = ProfilerContext()
        time.sleep(0.01)
        context.finish()

        data = context.get_data()

        assert "total" in data
        assert "middlewares" in data
        assert "controller" in data
        assert data["total"] is not None
        assert data["middlewares"] == []
        assert data["controller"] is None

    def test_get_data_with_middlewares(self):
        """Получение данных с middleware."""
        context = ProfilerContext()
        context.add_middleware("AuthMiddleware", 0.01)
        context.add_middleware("LoggingMiddleware", 0.02)

        data = context.get_data()

        assert len(data["middlewares"]) == 2
        assert data["middlewares"][0]["name"] == "AuthMiddleware"
        assert data["middlewares"][1]["name"] == "LoggingMiddleware"

    def test_get_data_with_controller(self):
        """Получение данных с контроллером."""
        context = ProfilerContext()
        context.set_controller(0.05)

        data = context.get_data()

        assert data["controller"] == 0.05

    def test_multiple_finish_calls(self):
        """Несколько вызовов finish() - использует последнее."""
        import time

        context = ProfilerContext()
        time.sleep(0.01)
        context.finish()
        first_duration = context._total_duration

        time.sleep(0.01)
        context.finish()
        second_duration = context._total_duration

        assert second_duration > first_duration

    def test_middleware_name_variations(self):
        """Разные имена middleware."""
        context = ProfilerContext()

        # Стандартное имя
        context.add_middleware("MyMiddleware", 0.01)

        # Имя с классом
        context.add_middleware(
            "<class liquidcode.middleware.logging.LoggingMiddleware>", 0.02
        )

        # Лямбда функция
        context.add_middleware("<lambda>", 0.005)

        assert len(context._middlewares) == 3

    def test_zero_duration(self):
        """Middleware с нулевой длительностью."""
        context = ProfilerContext()
        context.add_middleware("FastMiddleware", 0.0)

        assert context._middlewares[0]["duration"] == 0.0

    def test_controller_not_set(self):
        """Контроллер не был установлен."""
        context = ProfilerContext()

        assert context._controller_duration is None

        data = context.get_data()
        assert data["controller"] is None

    def test_report_formatting(self):
        """Форматирование отчёта (проверка структуры)."""
        import time

        context = ProfilerContext()
        context.add_middleware("TestMW", 0.1234)
        context.set_controller(0.5678)
        time.sleep(0.01)
        context.finish()

        report = context.report()
        lines = report.split("\n")

        # Проверяем, что отчёт не пустой
        assert len(lines) > 0

        # Проверяем, что строка с общим временем есть
        assert any("Общее время:" in line for line in lines)


class TestProfilerIntegration:
    """Интеграционные тесты профайлера с Kernel."""

    def test_profiler_enabled_in_kernel(self):
        """Профайлер включён в Kernel."""
        from liquidcode.kernel import Kernel
        from liquidcode.routing import Router
        from liquidcode.container import Container

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

        assert kernel.profiler_enabled is True

    def test_profiler_disabled_by_default(self):
        """Профайлер отключён по умолчанию."""
        from liquidcode.kernel import Kernel
        from liquidcode.routing import Router
        from liquidcode.container import Container

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

        assert kernel.profiler_enabled is False

    def test_enable_profiler_method(self):
        """Метод enable_profiler() включает профайлер."""
        from liquidcode.kernel import Kernel
        from liquidcode.routing import Router
        from liquidcode.container import Container

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

        kernel.enable_profiler()

        assert kernel.profiler_enabled is True

    def test_application_profiler_enabled(self):
        """Профайлер включается через Application."""
        from liquidcode import Application

        app = Application(profiler_enabled=True)

        assert app.kernel.profiler_enabled is True

    def test_application_enable_profiler(self):
        """Метод enable_profiler() в Application."""
        from liquidcode import Application

        app = Application(profiler_enabled=False)
        app.enable_profiler()

        assert app.kernel.profiler_enabled is True