tests/test_validation_decorator.py - develop-0.2.0 - liquid-g/liquid-code

tests/test_validation_decorator.py
207 строк7 KB
User
0.3.0-RC - Добавлена система валидации (Validator, базовые валидаторы, интеграция с ArgumentResolver, генератор `make:validator`)
04 июл 2026, 13:30
04 июл 2026, 13:306b33e13
"""Тесты для декоратора валидации LiquidCode."""

import pytest
from unittest.mock import Mock

from liquidcode.validation_decorator import validate_request
from liquidcode.validation import Required, Email, MinLength, ValidationError


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

    def test_validate_request_valid_data(self):
        """Декоратор пропускает валидные данные."""
        constraints = {
            'email': [Required(), Email()],
            'age': [Required(), MinLength(1)],
        }

        @validate_request(constraints)
        def test_func(self, data=None):
            return data

        result = test_func(None, data={'email': 'test@example.com', 'age': '25'})
        assert result == {'email': 'test@example.com', 'age': '25'}

    def test_validate_request_invalid_email(self):
        """Декоратор выбрасывает ValidationError для невалидного email."""
        constraints = {
            'email': [Email()],
        }

        @validate_request(constraints)
        def test_func(self, data=None):
            return data

        with pytest.raises(ValidationError) as exc_info:
            test_func(None, data={'email': 'invalid'})

        assert 'email' in exc_info.value.errors

    def test_validate_request_missing_required_field(self):
        """Декоратор выбрасывает ValidationError для отсутствующего Required поля."""
        constraints = {
            'email': [Required()],
        }

        @validate_request(constraints)
        def test_func(self, data=None):
            return data

        with pytest.raises(ValidationError) as exc_info:
            test_func(None, data={})

        assert 'email' in exc_info.value.errors

    def test_validate_request_empty_string_for_required(self):
        """Декоратор выбрасывает ValidationError для пустой строки Required."""
        constraints = {
            'name': [Required()],
        }

        @validate_request(constraints)
        def test_func(self, data=None):
            return data

        with pytest.raises(ValidationError) as exc_info:
            test_func(None, data={'name': ''})

        assert 'name' in exc_info.value.errors

    def test_validate_request_min_length(self):
        """Декоратор проверяет MinLength."""
        constraints = {
            'password': [MinLength(8)],
        }

        @validate_request(constraints)
        def test_func(self, data=None):
            return data

        with pytest.raises(ValidationError) as exc_info:
            test_func(None, data={'password': 'short'})

        assert 'password' in exc_info.value.errors

    def test_validate_request_with_request_object(self):
        """Декоратор работает с request объектом и JSON телом."""
        constraints = {
            'email': [Email()],
        }

        @validate_request(constraints)
        def test_func(self, request=None, **kwargs):
            return kwargs.get('data')

        # Создаем mock request с get_body
        mock_request = Mock()
        mock_request.get_body.return_value = b'{"email": "test@example.com"}'

        result = test_func(None, request=mock_request)
        assert result == {'email': 'test@example.com'}

    def test_validate_request_with_request_object_invalid_json(self):
        """Декоратор выбрасывает ValidationError для невалидного JSON."""
        constraints = {
            'email': [Email()],
        }

        @validate_request(constraints)
        def test_func(self, data=None):
            return data

        # Создаем mock request с невалидным JSON
        mock_request = Mock()
        mock_request.get_body.return_value = b'not valid json'

        with pytest.raises(ValidationError) as exc_info:
            test_func(None, request=mock_request)

        assert 'body' in exc_info.value.errors
        assert 'Invalid JSON' in exc_info.value.errors['body']

    def test_validate_request_with_request_object_empty_body(self):
        """Декоратор работает с пустым JSON телом."""
        # Пустой JSON не содержит email - Required должен сработать
        constraints = {
            'email': [Required(), Email()],
        }

        @validate_request(constraints)
        def test_func(self, request=None, **kwargs):
            return kwargs.get('data')

        # Создаем mock request с пустым JSON
        mock_request = Mock()
        mock_request.get_body.return_value = b'{}'

        with pytest.raises(ValidationError) as exc_info:
            test_func(None, request=mock_request)

        assert 'email' in exc_info.value.errors

    def test_validate_request_preserves_function_metadata(self):
        """Декоратор сохраняет метаданные функции."""
        constraints = {}

        @validate_request(constraints)
        def my_function(self, data=None):
            """This is my function."""
            return data

        assert my_function.__name__ == 'my_function'
        assert my_function.__doc__ == 'This is my function.'

    def test_validate_request_multiple_constraints(self):
        """Декоратор проверяет несколько constraint'ов для одного поля."""
        constraints = {
            'email': [Required(), Email(), MinLength(5)],
        }

        @validate_request(constraints)
        def test_func(self, data=None):
            return data

        # Валидные данные
        result = test_func(None, data={'email': 'test@example.com'})
        assert result == {'email': 'test@example.com'}

        # Невалидный email
        with pytest.raises(ValidationError) as exc_info:
            test_func(None, data={'email': 'invalid'})

        assert 'email' in exc_info.value.errors

    def test_validate_request_no_data_param(self):
        """Декоратор работает без data в kwargs."""
        constraints = {}

        @validate_request(constraints)
        def test_func(self):
            return 'success'

        result = test_func(None)
        assert result == 'success'

    def test_validate_request_data_not_dict(self):
        """Декоратор пропускает не-dict данные."""
        constraints = {}

        @validate_request(constraints)
        def test_func(self, data=None):
            return data

        result = test_func(None, data=['list', 'data'])
        assert result == ['list', 'data']

    def test_validate_request_with_none_data(self):
        """Декоратор работает с None data."""
        constraints = {}

        @validate_request(constraints)
        def test_func(self, data=None):
            return data

        result = test_func(None, data=None)
        assert result is None