tests/unit/test_validation_decorator.py - develop-0.4 - liquid-g/liquid-code

tests/unit/test_validation_decorator.py
170 строк6 KB
User
0.4.2 - покрытие тестами 52%, цель 80-90.
05 июл 2026, 00:06
05 июл 2026, 00:06f107982
"""Unit-тесты для validation_decorator."""

import pytest

from liquidcode.validation import Required, Email, Min, Max, ValidationError, MinLength, MaxLength
from liquidcode.validation_decorator import validate_request
from liquidcode.contracts import Request


class MockRequest:
    """Мок для Request."""
    def __init__(self, body=None):
        self._body = body

    def get_body(self):
        return self._body


class TestValidateRequest:
    """Тесты validate_request декоратора."""

    def test_validate_request_valid_data(self):
        """Валидация валидных данных."""
        class Controller:
            @validate_request({
                'email': [Required(), Email()],
                'age': [Required(), Min(18)],
            })
            def create_user(self, data):
                return data

        controller = Controller()
        result = controller.create_user(data={'email': 'test@example.com', 'age': 25})
        assert result == {'email': 'test@example.com', 'age': 25}

    def test_validate_request_invalid_email(self):
        """Валидация невалидного email."""
        class Controller:
            @validate_request({
                'email': [Required(), Email()],
            })
            def create_user(self, data):
                return data

        controller = Controller()
        with pytest.raises(ValidationError):
            controller.create_user(data={'email': 'not-an-email'})

    def test_validate_request_invalid_age(self):
        """Валидация возраста меньше минимума."""
        class Controller:
            @validate_request({
                'age': [Required(), Min(18)],
            })
            def create_user(self, data):
                return data

        controller = Controller()
        with pytest.raises(ValidationError):
            controller.create_user(data={'age': 15})

    def test_validate_request_missing_field(self):
        """Отсутствует обязательное поле."""
        class Controller:
            @validate_request({
                'email': [Required()],
            })
            def create_user(self, data):
                return data

        controller = Controller()
        with pytest.raises(ValidationError):
            controller.create_user(data={})

    def test_validate_request_with_request_object(self):
        """Валидация с Request объектом."""
        class Controller:
            @validate_request({
                'email': [Required(), Email()],
                'age': [Required(), Min(18)],
            })
            def create_user(self, request, data=None):
                if data is None:
                    data = {'email': request.email, 'age': request.age}
                return {'request': request, 'data': data}

        request = MockRequest(b'{"email": "test@example.com", "age": 25}')
        controller = Controller()
        # Просто проверяем, что декоратор не выбрасывает исключение
        result = controller.create_user(request=request)
        assert result is not None

    def test_validate_request_invalid_json(self):
        """Невалидный JSON в теле запроса."""
        class Controller:
            @validate_request({
                'email': [Required()],
            })
            def create_user(self, request):
                return 'ok'

        request = MockRequest(b'invalid json')
        controller = Controller()
        with pytest.raises(ValidationError) as exc_info:
            controller.create_user(request=request)

        assert 'body' in exc_info.value.errors

    def test_validate_request_no_data_in_kwargs(self):
        """Контроллер без data в kwargs."""
        class Controller:
            @validate_request({
                'name': [Required()],
            })
            def create_user(self, name='default'):
                return name

        controller = Controller()
        result = controller.create_user(name='test')
        assert result == 'test'

    def test_validate_request_data_not_dict(self):
        """Данные не являются словарем."""
        class Controller:
            @validate_request({
                'key': [Required()],
            })
            def create_user(self, data):
                return data

        controller = Controller()
        # Если data не dict, валидация не должна применяться
        result = controller.create_user(data="not a dict")
        assert result == "not a dict"

    def test_validate_request_preserves_other_kwargs(self):
        """Декоратор сохраняет другие kwargs."""
        class Controller:
            @validate_request({
                'email': [Required()],
            })
            def create_user(self, email, extra=None):
                return {'email': email, 'extra': extra}

        controller = Controller()
        result = controller.create_user(email='test@example.com', extra='value')
        assert result['extra'] == 'value'

    def test_validate_request_empty_constraints(self):
        """Пустые ограничения."""
        class Controller:
            @validate_request({})
            def create_user(self, data):
                return data

        controller = Controller()
        result = controller.create_user(data={'any': 'value'})
        assert result == {'any': 'value'}

    def test_validate_request_decorator_name_preserved(self):
        """Имя декорированной функции сохраняется."""
        class Controller:
            @validate_request({'name': [Required()]})
            def my_controller(self, data):
                """Docstring."""
                return data

        controller = Controller()
        assert controller.my_controller.__name__ == 'my_controller'
        assert controller.my_controller.__doc__ == 'Docstring.'