Refine search
public static <T> String format(ConstraintViolation<T> v) { if (v.getConstraintDescriptor().getAnnotation() instanceof ValidationMethod) { return v.getMessage(); } else { return String.format("%s %s", v.getPropertyPath(), v.getMessage()); } }
@Override public Map<String, Object> getAttributes() { return wrapped.getAttributes(); }
@Override public Set<ConstraintDescriptor<?>> getComposingConstraints() { return wrapped.getComposingConstraints(); }
private static void applyLength(Property property, ConstraintDescriptor<?> descriptor, PropertyDescriptor propertyDescriptor) { if ( "org.hibernate.validator.constraints.Length".equals( descriptor.getAnnotation().annotationType().getName() ) && String.class.equals( propertyDescriptor.getElementClass() ) ) { @SuppressWarnings("unchecked") int max = (Integer) descriptor.getAttributes().get( "max" ); @SuppressWarnings("unchecked") final Iterator<Selectable> itor = property.getColumnIterator(); if ( itor.hasNext() ) { final Selectable selectable = itor.next(); if ( Column.class.isInstance( selectable ) ) { Column col = (Column) selectable; if ( max < Integer.MAX_VALUE ) { col.setLength( max ); } } } } }
private ViolationExpectation(ConstraintViolation<?> violation, ViolationExpectationPropertiesToTest propertiesToTest) { this.constraintType = violation.getConstraintDescriptor().getAnnotation().annotationType(); if ( propertiesToTest.testRootBeanClass ) { withRootBeanClass( violation.getRootBeanClass() ); } if ( propertiesToTest.testMessage ) { withMessage( violation.getMessage() ); } if ( propertiesToTest.testInvalidValue ) { withInvalidValue( violation.getInvalidValue() ); } if ( propertiesToTest.testPropertyPath ) { withPropertyPath( new PathExpectation( violation.getPropertyPath() ) ); } }
@Test public void testSimpleValidationWithClassLevel() { LocalValidatorFactoryBean validator = new LocalValidatorFactoryBean(); validator.afterPropertiesSet(); ValidPerson person = new ValidPerson(); person.setName("Juergen"); person.getAddress().setStreet("Juergen's Street"); Set<ConstraintViolation<ValidPerson>> result = validator.validate(person); assertEquals(1, result.size()); Iterator<ConstraintViolation<ValidPerson>> iterator = result.iterator(); ConstraintViolation<?> cv = iterator.next(); assertEquals("", cv.getPropertyPath().toString()); assertTrue(cv.getConstraintDescriptor().getAnnotation() instanceof NameAddressValid); }
private static boolean isValidationMethod(ConstraintViolation<?> v) { return v.getConstraintDescriptor().getAnnotation() instanceof ValidationMethod; }
/** * Determine a Spring-reported error code for the given constraint descriptor. * <p>The default implementation returns the simple class name of the descriptor's * annotation type. Note that the configured * {@link org.springframework.validation.MessageCodesResolver} will automatically * generate error code variations which include the object name and the field name. * @param descriptor the JSR-303 ConstraintDescriptor for the current violation * @return a corresponding error code (for use with {@link Errors}) * @since 4.2 * @see javax.validation.metadata.ConstraintDescriptor#getAnnotation() * @see org.springframework.validation.MessageCodesResolver */ protected String determineErrorCode(ConstraintDescriptor<?> descriptor) { return descriptor.getAnnotation().annotationType().getSimpleName(); }
/** * Create a new ConstraintDescriptorImpl instance. * * @param descriptor */ public ConstraintDescriptorImpl(ConstraintDescriptor<T> descriptor) { this(descriptor.getAnnotation(), descriptor.getGroups(), descriptor.getPayload(), descriptor .getConstraintValidatorClasses(), descriptor.getAttributes(), descriptor.getComposingConstraints(), descriptor.isReportAsSingleViolation()); }
private boolean isRequired(Set<ConstraintDescriptor<?>> descriptors) { for (ConstraintDescriptor<?> descriptor : descriptors) { if (ClassUtils.isAssignableValue(NotNull.class, descriptor.getAnnotation())) { return true; } if (isRequired(descriptor.getComposingConstraints())) { return true; } } return false; } }
protected void verifyExplicitGroupClientError(Object form, Set<ConstraintViolation<Object>> vioSet) { // e.g. @Required(groups = { Sea.class, ClientError.class }) (when Sea group specified) final Set<ConstraintViolation<Object>> clientErrorSet = vioSet.stream().filter(vio -> { return containsDefinedGroup(vio.getConstraintDescriptor().getGroups(), CLIENT_ERROR_TYPE); }).collect(Collectors.toSet()); handleClientErrorViolation(form, clientErrorSet); }
@Test @SpecAssertion(section = "2.3", id = "p") public void testPayloadPropagationInComposedConstraints() { Friend john = new Friend( "John", "Doe" ); Validator validator = TestUtil.getValidatorUnderTest(); Set<ConstraintViolation<Friend>> constraintViolations = validator.validate( john ); assertCorrectNumberOfViolations( constraintViolations, 1 ); assertCorrectConstraintTypes( constraintViolations, NotNull.class ); ConstraintViolation<Friend> constraintViolation = constraintViolations.iterator().next(); Set<Class<? extends Payload>> payloads = constraintViolation.getConstraintDescriptor().getPayload(); assertTrue( payloads.size() == 1, "There should be one payload in the set" ); Class<? extends Payload> payload = payloads.iterator().next(); assertTrue( payload.getName().equals( Severity.Warn.class.getName() ), "Unexpected payload" ); }
@Test @SpecAssertion(section = Sections.CONSTRAINTMETADATA_CONSTRAINTDESCRIPTOR, id = "j") @SpecAssertion(section = Sections.CONSTRAINTMETADATA_CONSTRAINTDESCRIPTOR, id = "k") public void testComposingConstraintsPayload() { ConstraintDescriptor<?> descriptor = getConstraintDescriptor( Person.class, "firstName" ); Set<ConstraintDescriptor<?>> composingDescriptors = descriptor.getComposingConstraints(); assertEquals( composingDescriptors.size(), 2, "Wrong number of composing constraints" ); for ( ConstraintDescriptor<?> desc : composingDescriptors ) { assertTrue( desc.getGroups().size() == 1 ); assertEquals( desc.getPayload().iterator().next(), Severity.Info.class, "Wrong payload" ); } }
boolean hasNotNull = false; for ( ConstraintDescriptor<?> descriptor : constraintDescriptors ) { if ( groups != null && Collections.disjoint( descriptor.getGroups(), groups ) ) { continue; descriptor.getComposingConstraints(), property, propertyDesc, null, canApplyNotNull,
@Override public Set<Class<?>> getGroups() { return wrapped.getGroups(); }
@Override public Set<Class<? extends Payload>> getPayload() { return wrapped.getPayload(); }
@Test @SpecAssertion(section = Sections.CONSTRAINTMETADATA_CONSTRAINTDESCRIPTOR, id = "l") public void testGetValidationAppliesToFromComposingConstraint() { ConstraintDescriptor<?> descriptor = getConstraintDescriptor( Person.class, "age" ); Set<ConstraintDescriptor<?>> composingDescriptors = descriptor.getComposingConstraints(); assertEquals( composingDescriptors.size(), 1, "Wrong number of composing constraints" ); ConstraintTarget constraintTarget = composingDescriptors.iterator().next().getValidationAppliesTo(); assertNotNull( constraintTarget ); assertEquals( constraintTarget, ConstraintTarget.RETURN_VALUE ); }
@Test public void testSimpleValidationWithClassLevel() { LocalValidatorFactoryBean validator = new LocalValidatorFactoryBean(); validator.afterPropertiesSet(); ValidPerson person = new ValidPerson(); person.setName("Juergen"); person.getAddress().setStreet("Juergen's Street"); Set<ConstraintViolation<ValidPerson>> result = validator.validate(person); assertEquals(1, result.size()); Iterator<ConstraintViolation<ValidPerson>> iterator = result.iterator(); ConstraintViolation<?> cv = iterator.next(); assertEquals("", cv.getPropertyPath().toString()); assertTrue(cv.getConstraintDescriptor().getAnnotation() instanceof NameAddressValid); }
private static boolean isSelfValidating(ConstraintViolation<?> v) { return v.getConstraintDescriptor().getAnnotation() instanceof SelfValidating; }
@Override public T getAnnotation() { return wrapped.getAnnotation(); }