def test_validator_provides_almost_empty_dict_if_no_context_was_given(
self):
# we need a "result" in our context so validators can properly report
# results
dummy = self.AttributeHolder()
dummy.given_context = None
def store_empty(context):
dummy.given_context = context
return 21
self.init_validator(required=False)
self.validator().empty_value = store_empty
assert_equals(21, self.process('empty'))
assert_not_none(dummy.given_context)
result = dummy.given_context.pop('result', None)
assert_true(
is_result(result),
message=
'context must contain a result instance to return errors without using exceptions'
)
assert_equals({}, dummy.given_context)
# check that we did not change the real class used in other test cases
assert_not_equals(store_empty, self.init_validator().empty_value)
def _handle_field_validation_result(self, processed_value, result):
if not is_result(processed_value):
# this can only happen for old-style validators (exception on error,
# so this case must be a successful validation)
result.set(value=processed_value)
return
assert id(processed_value) == id(result)
def process(self, *args, **kwargs):
if len(args) == 1 and 'context' not in kwargs:
initial_value = args[0]
result = self._validator.new_result(initial_value)
kwargs['context'] = {'result': result}
ensure_valid = kwargs.pop('ensure_valid', True)
result = self._validator.process(*args, **kwargs)
if ensure_valid and is_result(result):
assert_false(result.contains_errors())
return result
def assert_error(self, value, *args, **kwargs):
message = kwargs.pop('message', None)
kwargs['ensure_valid'] = False
try:
result = self.process(value, *args, **kwargs)
except InvalidDataError as e:
return e
if (not is_result(result)) or (not result.contains_errors()):
default_message = 'InvalidDataError not raised!'
if message is None:
raise AssertionError(default_message)
raise AssertionError(default_message + ' ' + message)
return result
def _process_form_validators(self, result, context):
if result.contains_errors():
return
for formvalidator in self.formvalidators():
nr_previous_errors = result.nr_errors()
values = formvalidator.process(result.value, context=context)
if not is_result(values):
if values is None:
warnings.warn('form validator %r returned None' %
formvalidator)
continue
result.set(value=values)
if result.nr_errors() > nr_previous_errors:
# do not execute additional form validators if one of them
# found an error
break
def assert_error_with_key(self, error_key, *args, **kwargs):
message = kwargs.get('message', None)
result_or_exc = self.assert_error(*args, **kwargs)
if is_result(result_or_exc):
errors = result_or_exc.errors
_exc_keys = error_keys(errors)
else:
exc = result_or_exc
_exc_keys = (exc.details().key(), )
if error_key in _exc_keys:
return
fail_msg = 'No error with key %s (found %s)' % (error_key,
', '.join(_exc_keys))
if message:
fail_msg += ': ' + message
self.fail(fail_msg)
def _process_field(self, initial_value, context):
field_result = self._validator.new_result(initial_value)
list_result = context.pop('result')
context['result'] = field_result
try:
validator_result = self._validator.process(initial_value, context)
except InvalidDataError as e:
if not field_result.contains_errors():
errors = exception_to_errors(e)
if isinstance(errors, Error):
errors = (errors, )
field_result.update(errors=errors)
validator_result = field_result
if not is_result(validator_result):
# this can only happen for old-style validators (exception on error,
# so this case must be a successful validation)
field_result.set(value=validator_result)
context['result'] = list_result
return field_result