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