/** * Returns message for the {@link PropertyValidation}. * * @return Returns message for the {@link PropertyValidation}. */ public String getMessage() { StringBuilder stringBuilder = new StringBuilder(); if (this.hasErrors()) { stringBuilder.append("Property "); stringBuilder.append(this.getProperty().getName()); stringBuilder.append(" can not be validated. Validation test failed because of the following errors:\n"); for (ValidationError validationError : this.getErrors()) { stringBuilder.append("||- "); stringBuilder.append(validationError.getMessage()); } } else { stringBuilder.append("Property "); stringBuilder.append(this.getProperty().getName()); stringBuilder.append("validated without errors."); } return stringBuilder.toString(); }
/** * Adds {@link ValidationError} to the {@link PropertyValidation}. * * @param property * {@link SingleProperty} being validated. * @param propertyValidation * {@link PropertyValidation} to add error to. * @param message * Message to add to {@link ValidationError}. */ private void addValidationError(SingleProperty<? extends T> property, PropertyValidation propertyValidation, String message) { ValidationError validationError = new ValidationError(Collections.<SingleProperty<?>> singletonList(property), message); propertyValidation.addValidationError(validationError); } }
/** * {@inheritDoc} */ @Override public int getValidationErrorsCount() { int count = super.getValidationErrorsCount(); if (null != propertyValidation) { count += propertyValidation.getErrorCount(); } return count; }
/** * Validates with the group validators this property, based on the changes of the single * properties reported by update list. * * @param propertyUpdates * Information about updates. * @throws PropertyValidationException * If validation fails. */ public void validateForPropertiesUpdate(Collection<IPropertyUpdate<?>> propertyUpdates) throws PropertyValidationException { PropertyValidation propertyValidation = PropertyValidation.createFor(this); for (IGroupedProperyValidator groupedProperyValidator : validators) { groupedProperyValidator.validateForPropertyUpdates(this, propertyUpdates, propertyValidation); } // if has errors raise exception, otherwise create property update if (propertyValidation.hasErrors()) { throw new PropertyValidationException(propertyValidation); } }
assertThat(captor1.getValue().getProperty(), is(equalTo((AbstractProperty) singleProperty))); assertThat(captor2.getValue().getProperty(), is(equalTo((AbstractProperty) singleProperty))); assertThat(propertyValidation.hasErrors(), is(true)); assertThat(propertyValidation.getErrorCount(), is(1)); assertThat(propertyValidation.getErrors(), hasSize(1)); assertThat(propertyValidation.getErrors().iterator().next().getMessage(), is(equalTo(validationMsg)));
@Test public void validationFailsOnSingleProperty() { GroupedProperty groupedProperty = new GroupedProperty(); groupedProperty.addSingleProperty(singleProperty1); groupedProperty.addSingleProperty(singleProperty2); groupedProperty.addValidator(validator1); groupedProperty.addValidator(validator2); doAnswer(new Answer<Object>() { @Override public Object answer(InvocationOnMock invocation) throws Throwable { Object[] args = invocation.getArguments(); PropertyValidation propertyValidation = (PropertyValidation) args[0]; propertyValidation.addValidationError(new ValidationError()); return null; } }).when(singleProperty1).validate(Matchers.<PropertyValidation> anyObject()); PropertyValidation propertyValidation = groupedProperty.validate(); assertThat(propertyValidation.hasErrors(), is(true)); assertThat(propertyValidation.getErrorCount(), is(1)); verify(singleProperty1, times(1)).validate(propertyValidation); verify(singleProperty2, times(1)).validate(propertyValidation); verify(validator1, times(1)).validate(groupedProperty, propertyValidation); verify(validator2, times(1)).validate(groupedProperty, propertyValidation); verifyNoMoreInteractions(singleProperty1, singleProperty2, validator1, validator2); }
/** * {@inheritDoc} */ @Override public void propertyValidationFailed(SingleProperty<?> property, PropertyValidation propertyValidation) { if (propertyValidation.hasErrors()) { validationMap.put(property, propertyValidation); correctUpdateMap.remove(property); } updatePage(); }
/** * {@inheritDoc} */ @Override public Collection<ValidationError> getValidationErrors() { List<ValidationError> errors = new ArrayList<>(); errors.addAll(super.getValidationErrors()); if (null != propertyValidation) { errors.addAll(propertyValidation.getErrors()); } return errors; }
/** * Default constructor. * * @param propertyValidation * {@link PropertyValidation} object that contains validation errors that caused * exception to be raised. */ public PropertyValidationException(PropertyValidation propertyValidation) { super(propertyValidation.getMessage()); this.propertyValidation = propertyValidation; }
/** * Validate current property value(s) and report any validation problems via the * {@link PropertyValidation} that is returned. * * @return {@link PropertyValidation} containing validation errors if found. */ public PropertyValidation validate() { PropertyValidation errors = PropertyValidation.createFor(this); validate(errors); return errors; }
/** * Creates new instance of {@link PropertyValidation} for given {@link AbstractProperty}. * * @param property * {@link AbstractProperty} for validation. * @return New instance of {@link PropertyValidation}. Note that returned object will not * contain any validation errors. */ public static PropertyValidation createFor(AbstractProperty property) { return new PropertyValidation(property); }
assertThat(propertyValidation.hasErrors(), is(true)); assertThat(propertyValidation.getErrorCount(), is(2));
/** * Validates all properties in this configuration returning the map of containing the properties * that have validation errors. * * @return Map of properties with {@link PropertyValidation} containing errors. */ public Map<AbstractProperty, PropertyValidation> validate() { Map<AbstractProperty, PropertyValidation> validationMap = new HashMap<>(); for (AbstractProperty property : getAllProperties()) { PropertyValidation propertyValidation = property.validate(); if (propertyValidation.hasErrors()) { validationMap.put(property, propertyValidation); } } return validationMap; }
/** * Returns all validation errors. Sub-class can override this method to provide additional * errors. * * @return Returns current validation errors on this page. */ public Collection<ValidationError> getValidationErrors() { if (MapUtils.isEmpty(validationMap)) { return Collections.emptyList(); } else { List<ValidationError> returnList = new ArrayList<>(); for (PropertyValidation propertyValidation : validationMap.values()) { returnList.addAll(propertyValidation.getErrors()); } return returnList; } }
LOG.warn(entry.getValue().getMessage());
/** * Check if the property would have validation errors if given value would be set. * * @param value * Value to check for. * @return {@link PropertyValidation} with errors if ones exist. */ protected PropertyValidation validateForValue(T value) { PropertyValidation propertyValidation = PropertyValidation.createFor(this); if (CollectionUtils.isNotEmpty(validators)) { for (ISinglePropertyValidator<? super T> validator : validators) { validator.validateForValue(this, propertyValidation, value); } } return propertyValidation; }
/** * {@inheritDoc} */ @Override protected void compare(SingleProperty<? extends T> property, SingleProperty<? extends T> againstProperty, T value, T against, PropertyValidation propertyValidation) { if (!matches(value, against)) { List<SingleProperty<?>> properties = new ArrayList<>(2); properties.add(property); properties.add(againstProperty); ValidationError validationError = new ValidationError(properties, "Value of property '" + property.getName() + "' must be less than value of property '" + againstProperty.getName() + "'"); propertyValidation.addValidationError(validationError); } }
@Test public void validate() { when(propertyValidation1.hasErrors()).thenReturn(true); when(property1.validate()).thenReturn(propertyValidation1); when(propertyValidation2.hasErrors()).thenReturn(false); when(property2.validate()).thenReturn(propertyValidation2); Map<AbstractProperty, PropertyValidation> validateMap = configuration.validate(); assertThat(validateMap, hasEntry(property1, propertyValidation1)); assertThat(validateMap, not(hasKey(property2))); } }
/** * Returns current count of validation errors. Sub-class can override this method to provide * additional errors in the count. * * @return Returns current count of validation errors on this page. */ public int getValidationErrorsCount() { if (MapUtils.isEmpty(validationMap)) { return 0; } else { int count = 0; for (PropertyValidation propertyValidation : validationMap.values()) { count += propertyValidation.getErrorCount(); } return count; } }
/** * {@inheritDoc} */ @Override protected void compare(SingleProperty<? extends T> property, T value, T against, PropertyValidation propertyValidation) { if (!matches(value, against)) { ValidationError validationError = new ValidationError(Collections.<SingleProperty<?>> singletonList(property), "Value of property '" + property.getName() + "' must be greater than " + against); propertyValidation.addValidationError(validationError); } }