tests/unit/validation/test_validation.py - develop-0.4 - liquid-g/liquid-code

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

import pytest
from typing import Any

from liquidcode.validation import ValidationError, validate, validate_or_raise, Constraint, Required, Email, MinLength, MaxLength, Min, Max, Regex


class TestValidation:
    """Тесты валидации."""

    def test_validate_valid(self):
        """Валидация валидного значения."""
        result = validate(5, int)
        assert result is True

    def test_validate_invalid(self):
        """Валидация невалидного значения."""
        result = validate("not int", int)
        assert result is False

    def test_validate_or_raise_valid(self):
        """validate_or_raise с валидным значением."""
        # Функция ничего не возвращает, просто не выбрасывает исключение
        validate_or_raise(5, int)
        assert True

    def test_validate_or_raise_invalid(self):
        """validate_or_raise с невалидным значением."""
        with pytest.raises(ValidationError):
            validate_or_raise("not int", int)

    def test_validate_type_list(self):
        """Валидация типа list."""
        result = validate([1, 2, 3], list)
        assert result is True

    def test_validate_type_dict(self):
        """Валидация типа dict."""
        result = validate({"key": "value"}, dict)
        assert result is True

    def test_validate_none(self):
        """Валидация None."""
        result = validate(None, type(None))
        assert result is True

    def test_validate_or_raise_message(self):
        """Сообщение об ошибке."""
        with pytest.raises(ValidationError) as exc_info:
            validate_or_raise("test", int)
        assert "expected int" in str(exc_info.value).lower()


class TestConstraints:
    """Тесты ограничений (Constraints)."""

    def test_required_constraint_valid(self):
        """Required с валидным значением."""
        constraint = Required()
        assert constraint("test") is True
        assert constraint(0) is True
        assert constraint([]) is True

    def test_required_constraint_invalid(self):
        """Required с невалидным значением."""
        constraint = Required()
        assert constraint(None) is False
        assert constraint("") is False

    def test_email_constraint_valid(self):
        """Email с валидным адресом."""
        constraint = Email()
        assert constraint("test@example.com") is True
        assert constraint("user.name@domain.org") is True

    def test_email_constraint_invalid(self):
        """Email с невалидным адресом."""
        constraint = Email()
        assert constraint("not-an-email") is False
        assert constraint("test@") is False
        assert constraint("@example.com") is False

    def test_min_length_constraint_valid(self):
        """MinLength с валидной строкой."""
        constraint = MinLength(5)
        assert constraint("hello") is True
        assert constraint("hello world") is True

    def test_min_length_constraint_invalid(self):
        """MinLength с невалидной строкой."""
        constraint = MinLength(5)
        assert constraint("hi") is False

    def test_max_length_constraint_valid(self):
        """MaxLength с валидной строкой."""
        constraint = MaxLength(10)
        assert constraint("hi") is True
        assert constraint("hello") is True

    def test_max_length_constraint_invalid(self):
        """MaxLength с невалидной строкой."""
        constraint = MaxLength(5)
        assert constraint("hello world") is False

    def test_min_constraint_valid(self):
        """Min с валидным значением."""
        constraint = Min(10)
        assert constraint(10) is True
        assert constraint(15) is True

    def test_min_constraint_invalid(self):
        """Min с невалидным значением."""
        constraint = Min(10)
        assert constraint(5) is False

    def test_max_constraint_valid(self):
        """Max с валидным значением."""
        constraint = Max(10)
        assert constraint(10) is True
        assert constraint(5) is True

    def test_max_constraint_invalid(self):
        """Max с невалидным значением."""
        constraint = Max(10)
        assert constraint(15) is False

    def test_regex_constraint_valid(self):
        """Regex с валидной строкой."""
        constraint = Regex(r'^[a-z]+$')
        assert constraint("hello") is True

    def test_regex_constraint_invalid(self):
        """Regex с невалидной строкой."""
        constraint = Regex(r'^[a-z]+$')
        assert constraint("Hello123") is False

    def test_constraint_with_custom_message(self):
        """Constraint с кастомным сообщением."""
        constraint = MinLength(5, message="Too short")
        constraint2 = MaxLength(10, message="Too long")
        
        assert constraint("hi") is False
        assert constraint2("hello world") is False


class TestValidateDict:
    """Тесты валидации словарей."""

    def test_validate_dict_with_constraints(self):
        """Валидация словаря с ограничениями."""
        data = {"name": "John", "age": 25}
        constraints = {
            "name": [Required(), MinLength(2)],
            "age": [Min(0), Max(150)],
        }
        result = validate(data, constraints)
        assert result is True

    def test_validate_dict_with_errors(self):
        """Валидация словаря с ошибками."""
        data = {"name": "", "age": -5}
        constraints = {
            "name": [Required(), MinLength(2)],
            "age": [Min(0), Max(150)],
        }
        result = validate(data, constraints)
        assert result is False

    def test_validate_dict_with_list_constraint(self):
        """Валидация словаря с list constraint."""
        data = {"tags": ["a", "b"]}
        constraints = {
            "tags": [Required()],
        }
        result = validate(data, constraints)
        assert result is True


class TestValidateAny:
    """Тесты валидации Any."""

    def test_validate_any_type(self):
        """Валидация Any."""
        assert validate("test", Any) is True
        assert validate(123, Any) is True
        assert validate(None, Any) is True