def test_get_callable_name():
def foo(a, b):
return a + b
assert utils.get_callable_name(foo) == 'foo'
# Works for partials, too
foo_partial = partial(foo, 1)
assert utils.get_callable_name(foo_partial) == 'foo'
def test_get_callable_name_of_callable_class():
class Foo(object):
def __call__(self, val):
return False
foo = Foo()
assert utils.get_callable_name(foo) == 'Foo'
def _validate(self, value):
"""Perform validation on ``value``. Raise a :exc:`ValidationError` if validation
does not succeed.
"""
errors = []
for validator in self.validators:
func_name = utils.get_callable_name(validator)
msg = 'Validator {0}({1}) is False'.format(func_name, value)
try:
if validator(value) is False:
raise ValidationError(getattr(self, 'error', None) or msg)
except ValidationError as err:
if isinstance(err.messages, dict):
errors.append(err.messages)
else:
errors.extend(err.messages)
if errors:
raise ValidationError(errors)
def _run_validator(self,
validator_func,
output,
original_data,
fields_dict,
index=None,
strict=False,
many=False,
pass_original=False):
try:
if pass_original: # Pass original, raw data (before unmarshalling)
res = validator_func(output, original_data)
else:
res = validator_func(output)
if res is False:
func_name = utils.get_callable_name(validator_func)
raise ValidationError(
'Schema validator {0}({1}) is False'.format(
func_name, dict(output)))
except ValidationError as err:
errors = self.get_errors(index=index)
# Store or reraise errors
if err.field_names:
field_names = err.field_names
field_objs = [fields_dict[each] for each in field_names]
else:
field_names = [SCHEMA]
field_objs = []
for field_name in field_names:
if isinstance(err.messages, (list, tuple)):
# self.errors[field_name] may be a dict if schemas are nested
if isinstance(errors.get(field_name), dict):
errors[field_name].setdefault(SCHEMA,
[]).extend(err.messages)
else:
errors.setdefault(field_name, []).extend(err.messages)
elif isinstance(err.messages, dict):
errors.setdefault(field_name, []).append(err.messages)
else:
errors.setdefault(field_name, []).append(text_type(err))
if strict:
raise ValidationError(self.errors,
fields=field_objs,
field_names=field_names)
