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

tests/unit/kernel/test_pydantic.py
144 строки4 KB
User
0.4.18 - fix: устранение дублирования парсинга тела запроса (T-001)
07 июл 2026, 22:07
07 июл 2026, 22:073182883
"""Тесты Pydantic интеграции."""

import pytest

from liquidcode.kernel.argument_resolver import ArgumentResolver
from liquidcode.kernel.response_normalizer import normalize_response
from liquidcode.container import Container
from liquidcode.contracts import Request
from liquidcode.http import HttpRequest

# Проверка наличия Pydantic
try:
    from pydantic import BaseModel
    PYDANTIC_AVAILABLE = True
except ImportError:
    BaseModel = None
    PYDANTIC_AVAILABLE = False


pytestmark = pytest.mark.skipif(
    not PYDANTIC_AVAILABLE,
    reason="Pydantic не установлен"
)


class TestPydanticArgumentResolver:
    """Тесты валидации Pydantic моделей в ArgumentResolver."""

    def setup_method(self):
        self.container = Container()
        self.resolver = ArgumentResolver(self.container)

    def test_pydantic_model_validation_success(self):
        """Валидная Pydantic модель проходит валидацию."""
        class User(BaseModel):
            email: str
            age: int

        def controller(request: Request, data: User):
            return data

        # Создаем реальный HttpRequest
        body = b'{"email": "test@example.com", "age": 25}'
        request = HttpRequest(
            method='POST',
            path='/test',
            headers={'Content-Type': 'application/json'},
            body=body,
            query_params={}
        )
        # Имитируем работу BodyParserMiddleware
        import json
        parsed = json.loads(body.decode('utf-8'))
        request.set_attr('parsed_body', parsed)

        kwargs = self.resolver.resolve(
            controller_method=controller,
            request=request,
            route_params={},
            query_params={},
            method='POST',
        )

        assert 'data' in kwargs
        assert isinstance(kwargs['data'], User)
        assert kwargs['data'].email == 'test@example.com'
        assert kwargs['data'].age == 25

    def test_pydantic_model_validation_fail(self):
        """Невалидная Pydantic модель обрабатывается корректно."""
        class User(BaseModel):
            email: str
            age: int

        def controller(request: Request, data: User):
            return data

        request = HttpRequest(
            method='POST',
            path='/test',
            headers={'Content-Type': 'application/json'},
            body=b'{"email": "test@example.com", "age": "invalid"}',
            query_params={}
        )

        kwargs = self.resolver.resolve(
            controller_method=controller,
            request=request,
            route_params={},
            query_params={},
            method='POST',
        )

        assert 'data' in kwargs
        # При ошибке валидации data будет None (или можно выбросить исключение)
        assert kwargs['data'] is None


class TestPydanticResponseNormalizer:
    """Тесты сериализации Pydantic моделей в Response."""

    def test_pydantic_model_serialization(self):
        """Pydantic модель автоматически сериализуется в dict."""
        class User(BaseModel):
            id: int
            email: str

        user = User(id=1, email="test@example.com")

        class MockResponse:
            def __init__(self, content, status, headers):
                self.content = content
                self.status = status
                self.headers = headers

        result = normalize_response(user, MockResponse)

        assert result.status == 200
        assert result.content == {'id': 1, 'email': 'test@example.com'}

    def test_list_of_pydantic_models(self):
        """Список Pydantic моделей сериализуется корректно."""
        class User(BaseModel):
            id: int
            email: str

        users = [
            User(id=1, email="user1@example.com"),
            User(id=2, email="user2@example.com"),
        ]

        class MockResponse:
            def __init__(self, content, status, headers):
                self.content = content
                self.status = status
                self.headers = headers

        result = normalize_response(users, MockResponse)

        assert result.status == 200
        assert result.content == [
            {'id': 1, 'email': 'user1@example.com'},
            {'id': 2, 'email': 'user2@example.com'},
        ]