tests/feature/middleware/test_middleware.py - develop-0.4 - liquid-g/liquid-code

tests/feature/middleware/test_middleware.py
185 строк5 KB
User
0.4.1 - продолжаю переписывать тесты. пофиксил несколько багов по дороге.
04 июл 2026, 23:46
04 июл 2026, 23:467632abc
"""Feature-тесты для middleware."""

import pytest

from liquidcode import Application, route, controller, TestClient


class TestMiddlewareFeature:
    """Feature-тесты для middleware."""

    def test_middleware_request_modification(self):
        """Мiddleware модификация запроса."""
        app = Application()

        def add_header_middleware(request, call_next):
            request.set_attr("custom_header", "value")
            return call_next(request)

        app.add_middleware(add_header_middleware)

        @app.route("/test")
        def handler():
            return {"test": True}

        client = TestClient(app)
        response = client.get("/test")

        assert response.status == 200
        assert response.json() == {"test": True}

    def test_middleware_response_modification(self):
        """Мiddleware модификация ответа."""
        app = Application()

        def add_cache_header(request, call_next):
            response = call_next(request)
            response.set_header("Cache-Control", "no-cache")
            return response

        app.add_middleware(add_cache_header)

        @app.route("/test")
        def handler():
            return {"test": True}

        client = TestClient(app)
        response = client.get("/test")

        assert response.status == 200
        assert "Cache-Control" in response.headers
        assert response.headers["Cache-Control"] == "no-cache"

    def test_middleware_auth_flow(self):
        """Мiddleware аутентификации."""
        app = Application()

        def auth_middleware(request, call_next):
            # Проверяем токен
            token = request.get_headers().get("Authorization")
            if token:
                request.set_attr("authenticated", True)
            else:
                request.set_attr("authenticated", False)
            return call_next(request)

        app.add_middleware(auth_middleware)

        @app.route("/protected")
        def protected(request):
            if not request.get_attr("authenticated"):
                return {"error": "Unauthorized"}, 401
            return {"data": "secret"}

        client = TestClient(app)
        # С токеном
        response = client.get(
            "/protected", headers={"Authorization": "Bearer token123"}
        )
        assert response.status == 200

        # Без токена
        response = client.get("/protected")
        assert response.status == 401

    def test_middleware_logging(self):
        """Мiddleware логирования."""
        app = Application()

        logged_requests = []

        def log_middleware(request, call_next):
            path = request.get_path()
            method = request.get_method()
            logged_requests.append({"method": method, "path": path})
            return call_next(request)

        app.add_middleware(log_middleware)

        @app.route("/test1")
        def handler1():
            return {"test": 1}

        @app.route("/test2")
        def handler2():
            return {"test": 2}

        client = TestClient(app)
        client.get("/test1")
        client.get("/test2")

        assert len(logged_requests) == 2
        assert logged_requests[0]["path"] == "/test1"
        assert logged_requests[1]["path"] == "/test2"


class TestMiddlewareControllerIntegration:
    """Feature-тесты для интеграции middleware и контроллеров."""

    def test_controller_level_middleware(self):
        """Middleware на уровне контроллера."""
        app = Application()

        middleware_calls = []

        def auth_middleware(request, call_next):
            middleware_calls.append("auth")
            return call_next(request)

        def log_middleware(request, call_next):
            middleware_calls.append("log")
            return call_next(request)

        @controller(prefix="/api", middlewares=[auth_middleware, log_middleware])
        class ApiController:
            @route("/users")
            def users(self):
                return {"users": []}

        app.add_controller(ApiController)

        client = TestClient(app)
        response = client.get("/api/users")

        assert response.status == 200
        # Проверяем, что middleware были вызваны
        assert "auth" in middleware_calls
        assert "log" in middleware_calls

    def test_middleware_execution_order(self):
        """Порядок выполнения middleware."""
        app = Application()

        execution_order = []

        def first_middleware(request, call_next):
            execution_order.append("first_before")
            response = call_next(request)
            execution_order.append("first_after")
            return response

        def second_middleware(request, call_next):
            execution_order.append("second_before")
            response = call_next(request)
            execution_order.append("second_after")
            return response

        app.add_middleware(first_middleware)
        app.add_middleware(second_middleware)

        @app.route("/test")
        def handler():
            execution_order.append("handler")
            return {"test": True}

        client = TestClient(app)
        response = client.get("/test")

        expected_order = [
            "first_before",
            "second_before",
            "handler",
            "second_after",
            "first_after",
        ]
        assert execution_order == expected_order