def test_single_parameter(self) -> None:
parameter = Parameter(name='x', validators=[MaxLength(3)])
converted_value = parameter.validate(value='hed')
self.assertEqual(converted_value, 'hed')
with self.assertRaises(expected_exception=ParameterException):
parameter.validate(value='hello world')
class Foo:
@validate(Parameter(name='k', value_type=int, validators=[Min(42)]),
return_as=ReturnAs.KWARGS_WITHOUT_NONE)
async def bar(self, k):
return k
@validate(Parameter(name='k', value_type=int, validators=[Min(42)]), return_as=ReturnAs.ARGS)
async def bar_2(self, k):
return k
def test_multiple_parameters(self) -> None:
@validate(
Parameter(name='a', validators=[Min(3)]),
Parameter(name='b', validators=[Max(3)]),
Parameter(name='c', validators=[Max(43)]),
)
def bar(a, b, c):
return a + b + c
self.assertEqual(11, bar(3, 3, 5))
self.assertEqual(11, bar(a=3, b=3, c=5))
def test_empty_parameter_kwargs_without_none(self):
@validate(
Parameter(name='a', required=False),
Parameter(name='b', required=True),
Parameter(name='c', required=False),
return_as=ReturnAs.KWARGS_WITHOUT_NONE
)
def some_calculation(a: Optional[int] = 1, b: Optional[int] = 2, c: Optional[int] = 3):
return str(a) + str(b) + str(c)
self.assertEqual('430-50', some_calculation(43, 0, -50))
self.assertEqual('103', some_calculation(None, 0, None))
def test_empty_parameter_kwargs_with_none(self):
@validate(
Parameter(name='a', required=False),
Parameter(name='b', required=True),
Parameter(name='c', required=False),
return_as=ReturnAs.KWARGS_WITH_NONE
)
def some_calculation(a, b, c):
return str(a) + str(b) + str(c)
self.assertEqual('430-50', some_calculation(43, 0, -50))
self.assertEqual('None0None', some_calculation(None, 0, None))
def test_required(self):
@validate(
Parameter(name='a', required=True),
Parameter(name='b', required=True),
Parameter(name='c', required=True),
)
def some_calculation(a, b, c):
return a + b + c
some_calculation(43, 0, -50)
with self.assertRaises(expected_exception=ValidateException):
some_calculation(30, None, 50)
class MyClass:
@validate(
Parameter(name='x', validators=[Min(1)]),
)
def some_calculation(self, x: int) -> int:
return x
@validate(
Parameter(name='x', validators=[Min(1)]),
return_as=ReturnAs.KWARGS_WITHOUT_NONE,
)
def some_calculation_2(self, x: int) -> int:
return x
def test_return_as_args_advanced(self) -> None:
@validate(
Parameter(name='a'),
Parameter(name='b'),
Parameter(name='c'),
return_as=ReturnAs.ARGS,
)
def bar(a, b, *args, **kwargs):
return a, b, args, kwargs
bar(a=1, b=3, c=42)
bar(1, 3, 4)
bar(1, 3, c=4)
def test_return_multiple_args(self) -> None:
@validate(
Parameter(name='c'),
Parameter(name='a'),
Parameter(name='b'),
return_as=ReturnAs.KWARGS_WITH_NONE,
)
def bar(*args, **kwargs):
return args, kwargs
self.assertEqual(((), {'a': 1, 'b': 3, 'c': 42}), bar(a=1, b=3, c=42))
self.assertEqual(((), {'a': 3, 'b': 42, 'c': 1}), bar(1, 3, 42))
self.assertEqual(((), {'a': 1, 'b': 3, 'c': 42}), bar(1, 3, c=42))
def test_return_as_args_advanced_different_order(self) -> None:
@validate(
Parameter(name='c'),
Parameter(name='a'),
Parameter(name='b'),
return_as=ReturnAs.ARGS,
)
def bar(a, b, *args, **kwargs):
return a, b, args, kwargs
self.assertEqual((1, 3, (42,), {}), bar(a=1, b=3, c=42))
self.assertEqual((1, 3, (42,), {}), bar(1, 3, 42))
self.assertEqual((42, 1, (3,), {}), bar(1, 3, c=42))
def test_validate_args(self):
@validate(
Parameter(name='a', validators=[Min(42, include_boundary=False)]),
Parameter(name='b', validators=[Min(42, include_boundary=False)]),
Parameter(name='c', validators=[Min(42, include_boundary=False)]),
)
def some_calculation(a, b, c):
return a + b + c
some_calculation(43, 45, 50)
with self.assertRaises(expected_exception=ParameterException):
some_calculation(30, 40, 50)
with self.assertRaises(expected_exception=ParameterException):
some_calculation(c=30, a=40, b=50)
def test_validator_email_converts_to_lower_case(self) -> None:
@validate(Parameter(name='x', validators=[Email(post_processor=lambda x: x.lower())]))
def foo(x):
return x
for value in ['*****@*****.**', '*****@*****.**', '*****@*****.**']:
self.assertEqual(value.lower(), foo(value))
def test_return_as_args(self) -> None:
@validate(Parameter(name='x'), return_as=ReturnAs.ARGS)
def bar(*args, **kwargs):
return args, kwargs
self.assertEqual(((42,), {}), bar(42))
self.assertEqual(((42,), {}), bar(x=42))
def test_return_as_simple(self) -> None:
@validate(Parameter(name='x'), return_as=ReturnAs.ARGS)
def bar(x):
return x
self.assertEqual(42, bar(42))
self.assertEqual(42, bar(x=42))
class MyClass:
@staticmethod
@validate(
Parameter(name='x', validators=[Min(1)]),
)
def some_calculation(x: int) -> int:
return x
def test_return_as_kwargs_without_none(self) -> None:
@validate(Parameter(name='x'), return_as=ReturnAs.KWARGS_WITHOUT_NONE)
def bar(*args, **kwargs):
return args, kwargs
self.assertEqual(((), {'x': 42}), bar(42))
self.assertEqual(((), {'x': 42}), bar(x=42))
def test_no_default_value(self) -> None:
@validate(Parameter(name='a', required=False))
def bar(a: datetime) -> datetime:
return a
with self.assertRaises(expected_exception=ValidateException):
bar()
def test_call_with_args(self):
@validate(
Parameter(name='x', validators=[Min(1)]),
)
def some_calculation(x: int) -> int:
return x
some_calculation(42)
def test_validator_is_enum_to_upper_case_disabled(self) -> None:
@validate(Parameter(name='x', validators=[IsEnum(MyEnum, convert=False, to_upper_case=False)]))
def foo(x):
return x
for value in ['red', 'blue', 'Red', 'bLUe']:
with self.assertRaises(expected_exception=ParameterException):
foo(value)
def test_none_is_removed_for_not_required_parameter(self) -> None:
@validate(Parameter(name='a', required=False))
def bar(a: int = 42):
return a
self.assertEqual(42, bar())
self.assertEqual(2, bar(a=2))
self.assertEqual(2, bar(2))
def test_validator_is_enum_to_upper_case(self) -> None:
@validate(Parameter(name='x', validators=[IsEnum(MyEnum, convert=False)]))
def foo(x):
return x
self.assertEqual('RED', foo('red'))
self.assertEqual('BLUE', foo('blue'))
self.assertEqual('BLUE', foo('bLUe'))
def test_unexpected_parameter_strict(self) -> None:
@validate(Parameter(name='y'))
def bar(x):
return x
with self.assertRaises(expected_exception=ValidateException):
bar(42)
with self.assertRaises(expected_exception=ValidateException):
bar(x=42)
def test_validator_for_each_single_child(self) -> None:
@validate(Parameter(name='x', validators=[ForEach(Min(3))]))
def foo(x):
return x
self.assertEqual([3, 4, 5], foo([3, 4, 5]))
for value in [42, [3, 2, 5]]:
with self.assertRaises(expected_exception=ParameterException):
foo(value)
def test_default_value_is_not_validated_internal_parameter(self) -> None:
t = datetime(year=2021, month=11, day=24)
unix_timestamp = (t - datetime(year=1970, month=1, day=1)).total_seconds()
@validate(Parameter(name='a', required=False, default=t, validators=[DateTimeUnixTimestamp()]))
def bar(a: datetime) -> datetime:
return a
self.assertEqual(t, bar(a=unix_timestamp))
self.assertEqual(t, bar())
def test_none_is_not_validated_if_not_required_kwargs_without_none(self) -> None:
@validate(Parameter(name='a', validators=[Email()], required=False), return_as=ReturnAs.KWARGS_WITHOUT_NONE)
def bar(a: Optional[str] = None):
return a
self.assertIsNone(bar(a=None))
self.assertIsNone(bar(None))
with self.assertRaises(expected_exception=ParameterException):
bar('no_email')
def test_unexpected_parameter_not_strict(self) -> None:
@validate(Parameter(name='y'), strict=False)
def bar(x):
return x
with self.assertRaises(expected_exception=ValidateException):
self.assertEqual(42, bar(42))
with self.assertRaises(expected_exception=ValidateException):
self.assertEqual(42, bar(x=42))
def test_allow_renaming_of_parameter_of_custom_validator(self) -> None:
class MyCustomValidator(Validator):
def validate(self, i_renamed_this_arg: Any) -> Any:
return i_renamed_this_arg
@validate(Parameter(name='a', validators=[MyCustomValidator()]))
def bar(a: int):
return a
self.assertEqual(42, bar(42))
self.assertEqual(42, bar(a=42))
def test_too_many_arguments(self) -> None:
@validate(
Parameter(name='x'),
)
def bar(x):
return x
self.assertEqual(42, bar(42))
with self.assertRaises(expected_exception=ValidateException):
bar(42, 43)
def test_validator_email(self) -> None:
@validate(Parameter(name='x', validators=[Email()]))
def foo(x):
return x
for value in ['*****@*****.**', '*****@*****.**', '*****@*****.**']:
self.assertEqual(value, foo(value))
for value in ['fred', 'fred@web', 'fred@[email protected]', 'fred@@web.de', 'invalid@invalid']:
with self.assertRaises(expected_exception=ParameterException):
foo(value)
def test_validator_is_enum_convert_false(self) -> None:
@validate(Parameter(name='x', validators=[IsEnum(MyEnum, convert=False)]))
def foo(x):
return x
self.assertEqual('RED', foo('RED'))
self.assertEqual('BLUE', foo('BLUE'))
for value in ['fred', 1, 'GREEN']:
with self.assertRaises(expected_exception=ParameterException):
foo(value)
