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

tests/test_routing.py
393 строки12 KB
User
ci: настроен Black и flake8 для автоматического форматирования кода
04 июл 2026, 08:14
04 июл 2026, 08:144778ed6
"""Тесты для Router."""

import pytest
from liquidcode.routing import Router, Route, route


class TestRoute:
    """Тесты для Route."""

    def test_basic_route(self):
        """Базовый маршрут без параметров."""

        @route("/users")
        def handler():
            pass

        route_obj = Route("/users", ["GET"], handler)

        assert route_obj.path == "/users"
        assert route_obj.methods == ["GET"]

    def test_route_with_parameter(self):
        """Маршрут с параметром {id}."""

        @route("/users/{id}")
        def handler():
            pass

        route_obj = Route("/users/{id}", ["GET"], handler)

        result = route_obj.match("/users/123")
        assert result == {"id": "123"}

    def test_route_methods_case_insensitive(self):
        """Методы нормализуются в верхний регистр."""

        @route("/users")
        def handler():
            pass

        route_obj = Route("/users", ["get", "post"], handler)

        assert route_obj.methods == ["GET", "POST"]


class TestRouter:
    """Тесты для Router."""

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

        @route("/users")
        def handler():
            pass

        router.add_route("/users", handler, ["GET"])

        assert router.has_route("/users", "GET")

    def test_route_conflict(self):
        """Конфликт маршрутов (одинаковый путь и метод)."""
        router = Router()

        @route("/users")
        def handler1():
            pass

        @route("/users")
        def handler2():
            pass

        router.add_route("/users", handler1, ["GET"])

        with pytest.raises(ValueError):
            router.add_route("/users", handler2, ["GET"])

    def test_route_conflict_different_methods(self):
        """Один путь, разные методы - допустимо."""
        router = Router()

        @route("/users")
        def get_handler():
            pass

        @route("/users")
        def post_handler():
            pass

        router.add_route("/users", get_handler, ["GET"])
        router.add_route("/users", post_handler, ["POST"])

        assert router.has_route("/users", "GET")
        assert router.has_route("/users", "POST")

    def test_match_route(self):
        """Поиск маршрута."""
        router = Router()

        @route("/users/{id}")
        def handler(id):
            pass

        router.add_route("/users/{id}", handler, ["GET"])

        result = router.match("/users/123", "GET")
        assert result is not None
        controller, params, group_middlewares = result
        assert params == {"id": "123"}
        assert group_middlewares == []

    def test_match_not_found(self):
        """Маршрут не найден."""
        router = Router()

        @route("/users")
        def handler():
            pass

        router.add_route("/users", handler, ["GET"])

        result = router.match("/posts", "GET")
        assert result is None

    def test_match_wrong_method(self):
        """Неправильный HTTP-метод."""
        router = Router()

        @route("/users")
        def handler():
            pass

        router.add_route("/users", handler, ["POST"])

        result = router.match("/users", "GET")
        assert result is None

    def test_controller_with_route_decorator(self):
        """Контроллер с методом, помеченным @route."""
        router = Router()

        class UserController:
            @route("/users/{id}", methods=["GET"])
            def get(self, id):
                pass

        router.add_routes_from_controller(UserController)

        result = router.match("/users/123", "GET")
        assert result is not None
        controller, params, group_middlewares = result
        assert controller == (UserController, "get")
        assert params == {"id": "123"}
        assert group_middlewares == []

    def test_all_routes(self):
        """Получение всех маршрутов."""
        router = Router()

        class UserController:
            @route("/users", methods=["GET"])
            def list(self):
                pass

        router.add_routes_from_controller(UserController)

        routes = router.all_routes()
        # Проверяем, что маршрут добавлен (с завершающим слешем или без)
        assert len(routes) >= 1
        assert any(r["path"] == "/users" for r in routes)
        assert "GET" in routes[0]["methods"]
        assert "UserController.list" in routes[0]["controller"]


class TestRouterRouteDecorator:
    """Тесты декоратора route в Router."""

    def test_router_route_decorator(self):
        """Декоратор route у Router."""
        router = Router()

        @router.route("/users", methods=["GET"])
        def handler():
            pass

        assert router.has_route("/users", "GET")


class TestRouterGroup:
    """Тесты групп маршрутов."""

    def test_router_group(self):
        """Создание группы маршрутов."""
        router = Router()

        api = router.group("/api")

        @api.route("/users", methods=["GET"])
        def get_users():
            pass

        assert router.has_route("/api/users", "GET")

    def test_router_group_with_middlewares(self):
        """Группа с middleware."""
        router = Router()

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

        api = router.group("/api", middlewares=[test_middleware])

        @api.route("/users", methods=["GET"])
        def get_users():
            pass

        result = router.match("/api/users", "GET")
        assert result is not None
        controller, params, group_middlewares = result
        assert len(group_middlewares) == 1

    def test_router_nested_group(self):
        """Вложенные группы."""
        router = Router()

        api = router.group("/api")
        v1 = api.group("/v1")

        @v1.route("/users", methods=["GET"])
        def get_users():
            pass

        assert router.has_route("/api/v1/users", "GET")

    def test_router_group_with_kwargs(self):
        """Группа с **kwargs."""
        router = Router()

        # Вызываем group() с дополнительными аргументами (пока игнорируются)
        api = router.group("/api", extra_arg="test", another_kwarg=123)

        @api.route("/users", methods=["GET"])
        def get_users():
            pass

        assert router.has_route("/api/users", "GET")
        assert router.has_route("/api/users/", "GET")


class TestRouteGroup:
    """Тесты RouteGroup."""

    def test_route_group_prefix_normalization(self):
        """Нормализация префикса."""
        router = Router()

        # Без слеша
        group1 = router.group("api")
        assert group1.prefix == "/api"

        # С начальным слешем
        group2 = router.group("/api")
        assert group2.prefix == "/api"

        # С концевым слешем
        group3 = router.group("api/")
        assert group3.prefix == "/api"

    def test_group_args_kwargs_support(self):
        """Поддержка *args и **kwargs в RouteGroup.group()."""
        router = Router()

        api = router.group("/api")
        # Вызываем group() с дополнительными аргументами (пока игнорируются)
        v1 = api.group("/v1", extra_arg="test", another_kwarg=123)

        @v1.route("/users", methods=["GET"])
        def get_users():
            pass

        # Проверяем, что маршрут всё равно работает корректно
        assert router.has_route("/api/v1/users", "GET")
        assert router.has_route("/api/v1/users/", "GET")

    def test_group_with_args(self):
        """Поддержка *args в RouteGroup.group()."""
        router = Router()

        api = router.group("/api")
        # Используем *args
        args = ("extra_value",)
        v1 = api.group("/v1", *args)

        @v1.route("/items", methods=["GET"])
        def get_items():
            pass

        assert router.has_route("/api/v1/items", "GET")
        assert router.has_route("/api/v1/items/", "GET")

    def test_group_nested_with_args_kwargs(self):
        """Вложенные группы с *args и **kwargs."""
        router = Router()

        api = router.group("/api")
        v1 = api.group("/v1", middleware=None)
        users = v1.group("/users", prefix_type="resource")

        @users.route("/", methods=["GET"])
        def list_users():
            pass

        @users.route("/{id}", methods=["GET"])
        def get_user(id):
            pass

        # Маршрут /users добавляет вариант со слешем автоматически
        assert router.has_route("/api/v1/users/", "GET")
        assert router.has_route("/api/v1/users/{id}", "GET")
        assert router.has_route("/api/v1/users/{id}/", "GET")

        # Проверяем, что параметры извлекаются правильно
        result = router.match("/api/v1/users/123", "GET")
        assert result is not None
        controller, params, group_middlewares = result
        assert params == {"id": "123"}

    def test_group_middlewares_accumulation_with_kwargs(self):
        """Акумуляция middleware с использованием kwargs."""
        router = Router()

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

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

        api = router.group("/api", middlewares=[auth_middleware])
        v1 = api.group("/v1", middlewares=[logger_middleware])

        @v1.route("/users", methods=["GET"])
        def get_users():
            pass

        result = router.match("/api/v1/users", "GET")
        assert result is not None
        controller, params, group_middlewares = result
        # Проверяем, что middleware объединились
        assert len(group_middlewares) == 2
        assert group_middlewares[0] == auth_middleware
        assert group_middlewares[1] == logger_middleware


class TestRouterHasRoute:
    """Тесты has_route."""

    def test_has_route_exists(self):
        """Маршрут существует."""
        router = Router()

        @route("/users")
        def handler():
            pass

        router.add_route("/users", handler, ["GET", "POST"])

        assert router.has_route("/users", "GET")
        assert router.has_route("/users", "POST")
        assert not router.has_route("/users", "DELETE")

    def test_has_route_not_exists(self):
        """Маршрут не существует."""
        router = Router()

        assert not router.has_route("/nonexistent", "GET")


class TestRouterAddRouteWithSlash:
    """Тесты автоматического добавления слеша."""

    def test_add_route_slash_variant(self):
        """Автоматическое создание варианта со слешем."""
        router = Router()

        @route("/users")
        def handler():
            pass

        router.add_route("/users", handler, ["GET"])

        # Проверяем оба варианта
        assert router.has_route("/users", "GET")
        assert router.has_route("/users/", "GET")