Refine search
testValidator.validate(tb, errors); errors.setNestedPath("spouse."); assertEquals("spouse.", errors.getNestedPath()); Validator spouseValidator = new SpouseValidator(); spouseValidator.validate(tb.getSpouse(), errors); errors.setNestedPath(""); assertTrue(errors.hasErrors()); assertEquals(6, errors.getErrorCount());
logger.debug("Invoking validator [" + validator + "]"); if (!validator.supports(target.getClass())) { throw new IllegalArgumentException( "Validator [" + validator.getClass() + "] does not support [" + target.getClass() + "]"); validator.validate(target, errors); if (errors.hasErrors()) { logger.debug("Validator found " + errors.getErrorCount() + " errors");
private void validateAndPush(ConfigurationPropertyName name, Object target, Class<?> type) { BindingResult errors = new BeanPropertyBindingResult(target, name.toString()); Arrays.stream(this.validators).filter((validator) -> validator.supports(type)) .forEach((validator) -> validator.validate(target, errors)); if (errors.hasErrors()) { this.exceptions.push(getBindValidationException(name, errors)); } }
/** * @see Validator#validate(Object) */ @Override public void validate(T item) throws ValidationException { if (!validator.supports(item.getClass())) { throw new ValidationException("Validation failed for " + item + ": " + item.getClass().getName() + " class is not supported by validator."); } BeanPropertyBindingResult errors = new BeanPropertyBindingResult(item, "item"); validator.validate(item, errors); if (errors.hasErrors()) { throw new ValidationException("Validation failed for " + item + ": " + errorsToString(errors), new BindException(errors)); } }
/** * @see ProgramValidator#validate(Object,Errors) */ @Test public void validate_shouldPassValidationIfFieldLengthsAreCorrect() { Program prog = new Program(); prog.setName("Hypochondriasis program"); prog.setConcept(Context.getConceptService().getConcept(3)); Errors errors = new BindException(prog, "prog"); programValidator.validate(prog, errors); Assert.assertFalse(errors.hasErrors()); }
/** * @see PersonValidator#validate(Object,Errors) */ @Test public void validate_shouldFailValidationIfBirthdateIsAFutureDate() { Patient pa = new Patient(1); Calendar birth = Calendar.getInstance(); birth.setTime(new Date()); birth.add(Calendar.YEAR, 20); pa.setBirthdate(birth.getTime()); Errors errors = new BindException(pa, "patient"); validator.validate(pa, errors); Assert.assertTrue(errors.hasFieldErrors("birthdate")); }
/** * Validate given form object using a registered validator. If a "validatorMethod" action property is specified for * the currently executing action, the identified validator method will be invoked. When no such property is found, * the defualt <code>validate()</code> method is invoked. * @param context the action execution context, for accessing and setting data in "flow scope" or "request scope" * @param formObject the form object * @param errors the errors instance to record validation errors in * @throws Exception when an unrecoverable exception occurs */ protected void doValidate(RequestContext context, Object formObject, Errors errors) throws Exception { Assert.notNull(getValidator(), "The validator must not be null when attempting validation -- programmer error"); String validatorMethodName = context.getAttributes().getString(VALIDATOR_METHOD_ATTRIBUTE); if (StringUtils.hasText(validatorMethodName)) { if (logger.isDebugEnabled()) { logger.debug("Invoking validation method '" + validatorMethodName + "' on validator " + getValidator()); } invokeValidatorMethod(validatorMethodName, formObject, errors); } else { if (logger.isDebugEnabled()) { logger.debug("Invoking validator " + getValidator()); } getValidator().validate(formObject, errors); } if (logger.isDebugEnabled()) { logger.debug("Validation completed for form object"); logger.debug("There are [" + errors.getErrorCount() + "] errors, details: " + errors.getAllErrors()); } }
public void validate() { allErrors = new HashMap<String,Errors>(); for(Entry<String, HasValidator> entry : getBeansOfType(HasValidator.class).entrySet()) { String name = entry.getKey(); HasValidator hv = entry.getValue(); Validator v = hv.getValidator(); Errors errors = new BeanPropertyBindingResult(hv,name); v.validate(hv, errors); if(errors.hasErrors()) { allErrors.put(name,errors); } } for(String name : allErrors.keySet()) { for(Object obj : allErrors.get(name).getAllErrors()) { LOGGER.fine("validation error for '"+name+"': "+obj); } } }
public static void bind(Object o, Map<String, Object> properties, String configurationPropertyName, String bindingName, Validator validator, ConversionService conversionService) { Object toBind = getTargetObject(o); new Binder(Collections.singletonList(new MapConfigurationPropertySource(properties)), null, conversionService) .bind(configurationPropertyName, Bindable.ofInstance(toBind)); if (validator != null) { BindingResult errors = new BeanPropertyBindingResult(toBind, bindingName); validator.validate(toBind, errors); if (errors.hasErrors()) { throw new RuntimeException(new BindException(errors)); } } }
Errors errors = db.getBindingResult(); Validator testValidator = new TestBeanValidator(); testValidator.validate(tb, errors); errors.setNestedPath("spouse"); assertEquals("spouse.", errors.getNestedPath()); assertEquals("argh", errors.getFieldValue("age")); Validator spouseValidator = new SpouseValidator(); spouseValidator.validate(tb.getSpouse(), errors); errors.setNestedPath("");
@Test public void testValidatorWithNestedObjectNull() { TestBean tb = new TestBean(); Errors errors = new BeanPropertyBindingResult(tb, "tb"); Validator testValidator = new TestBeanValidator(); testValidator.validate(tb, errors); errors.setNestedPath("spouse."); assertEquals("spouse.", errors.getNestedPath()); Validator spouseValidator = new SpouseValidator(); spouseValidator.validate(tb.getSpouse(), errors); errors.setNestedPath(""); assertTrue(errors.hasFieldErrors("spouse")); assertEquals(1, errors.getFieldErrorCount("spouse")); assertEquals("SPOUSE_NOT_AVAILABLE", errors.getFieldError("spouse").getCode()); assertEquals("tb", (errors.getFieldErrors("spouse").get(0)).getObjectName()); assertEquals(null, (errors.getFieldErrors("spouse").get(0)).getRejectedValue()); }
/** * @see PersonValidator#validate(Object,Errors) */ @Test public void validate_shouldFailValidationIfCauseOfDeathIsBlankWhenPatientIsDead() { Patient pa = new Patient(1); pa.setDead(true); Errors errors = new BindException(pa, "patient"); validator.validate(pa, errors); Assert.assertTrue(errors.hasFieldErrors("causeOfDeath")); Assert.assertEquals("Person.dead.causeOfDeathAndCauseOfDeathNonCodedNull", errors.getFieldError("causeOfDeath").getCode()); }
/** * Invoke the specified Validators, if any. * @see #setValidator(Validator) * @see #getBindingResult() */ public void validate() { Object target = getTarget(); Assert.state(target != null, "No target to validate"); BindingResult bindingResult = getBindingResult(); // Call each validator with the same binding result for (Validator validator : getValidators()) { validator.validate(target, bindingResult); } }
validator.validate(target,errors); int oldErrorCount = errors.getErrorCount(); errors = filterErrors(errors, validatedFields, target); if (errors.hasErrors()) { valid = Boolean.FALSE; if (evict) { if (errors.getErrorCount() != oldErrorCount) { MetaClass metaClass = GroovySystem.getMetaClassRegistry().getMetaClass(target.getClass()); metaClass.setProperty(target, ERRORS_PROPERTY, errors);
public Object getValue(ProgressListener subListener) throws Exception { Object value = delegate.getValue(subListener); Errors errors = new BeanPropertyBindingResult(value, getInputId()); for (Validator v : validators) { if (v.supports(value.getClass())) { v.validate(value, errors); } } if (errors.hasErrors()) { throw new ValidationException(errors, getInputId()); } return value; }
@Test public void testValidationUtilsEmpty() throws Exception { TestBean tb = new TestBean(""); Errors errors = new BeanPropertyBindingResult(tb, "tb"); Validator testValidator = new EmptyValidator(); testValidator.validate(tb, errors); assertTrue(errors.hasFieldErrors("name")); assertEquals("EMPTY", errors.getFieldError("name").getCode()); }
@Test public void testNestedValidatorWithoutNestedPath() { TestBean tb = new TestBean(); tb.setName("XXX"); Errors errors = new BeanPropertyBindingResult(tb, "tb"); Validator spouseValidator = new SpouseValidator(); spouseValidator.validate(tb, errors); assertTrue(errors.hasGlobalErrors()); assertEquals(1, errors.getGlobalErrorCount()); assertEquals("SPOUSE_NOT_AVAILABLE", errors.getGlobalError().getCode()); assertEquals("tb", (errors.getGlobalErrors().get(0)).getObjectName()); }
if (identifierLength > maxLength) { errors.rejectValue(identifierName, "error.exceededMaxLengthOfField", new Object[] { maxLength }, null); int propertyValueLength = propertyValue.length(); if (propertyValueLength > maxLength) { errors.rejectValue(propName, "error.exceededMaxLengthOfField", new Object[] { maxLength }, null); try { for (Validator validator : getValidators(object)) { validator.validate(object, errors);
private Errors validate(String event, Object entity) { if (entity == null) { return null; } Errors errors = new ValidationErrors(entity, persistentEntitiesFactory.getObject()); for (Validator validator : getValidatorsForEvent(event)) { if (validator.supports(entity.getClass())) { LOGGER.debug("{}: {} with {}", event, entity, validator); ValidationUtils.invokeValidator(validator, entity, errors); } } if (errors.hasErrors()) { throw new RepositoryConstraintViolationException(errors); } return errors; }