Refine search
public static PropertyDescriptor extractPropertyDescriptor(FacesContext context, PrimeApplicationContext applicationContext, ValueExpression ve) { if (ve != null) { ELContext elContext = context.getELContext(); ValueReference vr = ValueExpressionAnalyzer.getReference(elContext, ve); if (vr != null) { Validator validator = applicationContext.getValidator(); Object base = vr.getBase(); Object property = vr.getProperty(); if (base != null && property != null) { BeanDescriptor beanDescriptor = validator.getConstraintsForClass(base.getClass()); if (beanDescriptor != null) { return beanDescriptor.getConstraintsForProperty(property.toString()); } } } } return null; } }
boolean activateNotNull, Dialect dialect) { final BeanDescriptor descriptor = factory.getValidator().getConstraintsForClass( clazz ); for ( PropertyDescriptor propertyDesc : descriptor.getConstrainedProperties() ) { Property property = findPropertyByName( persistentClass, prefix + propertyDesc.getPropertyName() ); boolean hasNotNull;
@Override public void onValidate(final ValidationInterceptorContext ctx) { final Object resource = ctx.getResource(); final Invocable resourceMethod = ctx.getInvocable(); final Object[] args = ctx.getArgs(); final Set<ConstraintViolation<Object>> constraintViolations = new HashSet<>(); final BeanDescriptor beanDescriptor = getConstraintsForClass(resource.getClass()); // Resource validation. if (beanDescriptor.isBeanConstrained()) { constraintViolations.addAll(validate(resource)); } if (resourceMethod != null && configuration.getBootstrapConfiguration().isExecutableValidationEnabled()) { final Method handlingMethod = resourceMethod.getHandlingMethod(); // Resource method validation - input parameters. final MethodDescriptor methodDescriptor = beanDescriptor.getConstraintsForMethod(handlingMethod.getName(), handlingMethod.getParameterTypes()); if (methodDescriptor != null && methodDescriptor.hasConstrainedParameters() && validateOnExecutionHandler.validateMethod(resource.getClass(), resourceMethod.getDefinitionMethod(), resourceMethod.getHandlingMethod())) { constraintViolations.addAll(forExecutables().validateParameters(resource, handlingMethod, args)); } } if (!constraintViolations.isEmpty()) { throw new ConstraintViolationException(constraintViolations); } }
@Test @SpecAssertion(section = "3.4.4", id = "a") public void testImplicitGrouping() { Validator validator = TestUtil.getValidatorUnderTest(); BeanDescriptor beanDescriptor = validator.getConstraintsForClass( Order.class ); assertTrue( beanDescriptor.isBeanConstrained() ); // validating the Default Group should validate all 5 constraints Order order = new Order(); Set<ConstraintViolation<Order>> violations = validator.validate( order ); assertTrue( violations.size() == 5, "All 5 NotNull constraints should fail." ); // use implicit group Auditable - only the constraints defined on Auditable should be validated violations = validator.validate( order, Auditable.class ); assertTrue( violations.size() == 4, "All 4 NotNull constraints on Auditable should fail." ); }
if (validator != null) { BeanDescriptor bd = validator.getConstraintsForClass(bean.getClass()); bd.getConstraintDescriptors(); Set constraintViolations = validator.validate(bean, array);
boolean isClassConstrained(Class<?> clazz) { return serverSideValidator.getConstraintsForClass(clazz).isBeanConstrained(); }
public static MethodDescriptor getMethodDescriptor(Class<?> clazz, String name, Class<?>... parameterTypes) { Validator validator = getValidatorUnderTest(); return validator.getConstraintsForClass( clazz ) .getConstraintsForMethod( name, parameterTypes ); }
@Test @SpecAssertion(section = Sections.CONSTRAINTMETADATA_VALIDATOR, id = "a") @SpecAssertion(section = Sections.CONSTRAINTMETADATA_BEANDESCRIPTOR, id = "a") public void testUnconstrainedClass() { BeanDescriptor beanDescriptor = getValidator().getConstraintsForClass( UnconstrainedEntity.class ); assertFalse( beanDescriptor.hasConstraints(), "There should be no direct constraints on the specified bean." ); assertFalse( beanDescriptor.isBeanConstrained(), "Bean should be unconstrained." ); }
@Test @SpecAssertion(section = "3.4", id = "c") public void testConstraintCanBelongToMoreThanOneGroup() { Validator validator = TestUtil.getValidatorUnderTest(); BeanDescriptor beanDescriptor = validator.getConstraintsForClass( User.class ); assertTrue( beanDescriptor.isBeanConstrained() ); PropertyDescriptor propDesc = beanDescriptor.getConstraintsForProperty( "defaultCreditCard" ); assertTrue( propDesc.getConstraintDescriptors().size() == 1 ); ConstraintDescriptor descriptor = propDesc.getConstraintDescriptors().iterator().next(); assertTrue( descriptor.getGroups().size() == 2 ); }
@Test @SpecAssertion(section = "7.1", id = "a") public void testXmlConfiguredConstraintExposesCorrespondingAnnotationViaMetadata() { Configuration<?> config = TestUtil.getConfigurationUnderTest(); config.addMapping( TestUtil.getInputStreamForPath( packageName + mappingFile1 ) ); Validator validator = config.buildValidatorFactory().getValidator(); BeanDescriptor beanDescriptor = validator.getConstraintsForClass( User.class ); Set<ConstraintDescriptor<?>> constraintDescriptors = beanDescriptor.getConstraintDescriptors(); assertEquals( constraintDescriptors.size(), 1, "There should be one class level constraint defined in xml" ); ConstraintDescriptor<?> descriptor = constraintDescriptors.iterator().next(); assertTrue( descriptor.getAnnotation() instanceof ConsistentUserInformation ); constraintDescriptors = beanDescriptor.getConstraintsForProperty( "lastname" ) .getConstraintDescriptors(); assertEquals( constraintDescriptors.size(), 1, "There should be one constraint defined in xml for 'lastname'" ); descriptor = constraintDescriptors.iterator().next(); assertTrue( descriptor.getAnnotation() instanceof Pattern ); }
@Test @SpecAssertions({ @SpecAssertion(section = "7.1.1.4", id = "c"), @SpecAssertion(section = "7.1.1.4", id = "d"), @SpecAssertion(section = "7.1.1.4", id = "e"), @SpecAssertion(section = "7.1.1.4", id = "f"), @SpecAssertion(section = "7.1.1.4", id = "g") }) public void testElementConversionInXmlConfiguredConstraint() { Validator validator = TestUtil.getValidatorUnderTest(); BeanDescriptor beanDescriptor = validator.getConstraintsForClass( User.class ); assertTrue( beanDescriptor.isBeanConstrained() ); Set<ConstraintDescriptor<?>> constraintDescriptors = beanDescriptor.getConstraintDescriptors(); assertTrue( constraintDescriptors.size() == 1 ); ConstraintDescriptor<?> descriptor = constraintDescriptors.iterator().next(); ConsistentUserInformation constraintAnnotation = ( ConsistentUserInformation ) descriptor.getAnnotation(); assertEquals( constraintAnnotation.stringParam(), "foobar", "Wrong parameter value" ); assertEquals( constraintAnnotation.classParam(), String.class, "Wrong parameter value" ); assertEquals( constraintAnnotation.userType(), UserType.SELLER, "Wrong parameter value" ); assertEquals( constraintAnnotation.stringArrayParam(), new String[] { "foo", "bar" }, "Wrong parameter value" ); assertEquals( constraintAnnotation.max().value(), 10, "Wrong parameter value. Default should be used" ); assertEquals( constraintAnnotation.patterns().length, 2, "Wrong array size" ); }
@Test @SpecAssertion(section = Sections.CONSTRAINTMETADATA_ELEMENTDESCRIPTOR, id = "a") public void testGetElementClass() { Validator validator = getValidatorUnderTest(); BeanDescriptor beanDescriptor = validator.getConstraintsForClass( SuperClass.class ); assertEquals( beanDescriptor.getElementClass(), SuperClass.class, "Wrong element class" ); ElementDescriptor elementDescriptor = beanDescriptor.getConstraintsForProperty( "myField" ); assertEquals( elementDescriptor.getElementClass(), String.class, "Wrong element class" ); }
ensureFactoryValidator(); try { final BeanDescriptor classConstraints = validator.get().getConstraintsForClass(javaClass); && !classConstraints.getConstrainedConstructors().isEmpty(); final boolean validBusinessMethods = globalExecutableTypes.contains(ExecutableType.NON_GETTER_METHODS) && !classConstraints.getConstrainedMethods(MethodType.NON_GETTER).isEmpty(); final boolean validGetterMethods = globalExecutableTypes.contains(ExecutableType.GETTER_METHODS) && !classConstraints.getConstrainedMethods(MethodType.GETTER).isEmpty();
@Test @SpecAssertion(section = Sections.CONSTRAINTMETADATA_BEANDESCRIPTOR, id = "h") public void testGetConstrainedConstructorsForUnconstrainedEntity() { BeanDescriptor beanDescriptor = getValidator().getConstraintsForClass( UnconstrainedEntity.class ); Set<ConstructorDescriptor> constructorDescriptors = beanDescriptor.getConstrainedConstructors(); assertEquals( constructorDescriptors.size(), 0, "We should get the empty set." ); }
sw.println(".setConstrained(" + beanDescriptor.isBeanConstrained() + ")"); for (ConstraintDescriptor<?> constraint : beanDescriptor.getConstraintDescriptors()) { if (areConstraintDescriptorGroupsValid(constraint)) { for (PropertyDescriptor p : beanDescriptor.getConstrainedProperties()) { sw.print(".put(\""); sw.print(p.getPropertyName());
/** * Returns the class of a given property, but only if it is a constrained property of the * parent class. Otherwise, it returns null. */ final private static Class<?> getConstrainedPropertyClass(BeanDescriptor beanDescriptor, String propertyName) { Class<?> clasz = null; for (PropertyDescriptor descriptor : beanDescriptor.getConstrainedProperties()) { if (descriptor.getPropertyName().equals(propertyName)) { clasz = descriptor.getElementClass(); break; } } return clasz; }
for(Class<?> constrained : constrainedClasses) { BeanDescriptor beanDesc = DescriptorFactory.INSTANCE.getBeanDescriptor(constrained); for(ConstraintDescriptor<?> descriptor : beanDesc.getConstraintDescriptors()) { foundCandidateValidators.addAll(descriptor.getConstraintValidatorClasses()); for(PropertyDescriptor propDescriptor : beanDesc.getConstrainedProperties()) { for(ConstraintDescriptor<?> descriptor : propDescriptor.getConstraintDescriptors()) { foundCandidateValidators.addAll(descriptor.getConstraintValidatorClasses());
private boolean isGetterConstrained(BeanDescriptor beanDescriptor, Method method, String property) { PropertyDescriptor propertyDescriptor = beanDescriptor.getConstraintsForProperty( property ); return propertyDescriptor != null && propertyDescriptor.findConstraints() .declaredOn( ElementType.METHOD ) .hasConstraints(); }
@Override public boolean hasConstraints() { if ( beanDescriptor.isBeanConstrained() || !beanDescriptor.getConstrainedConstructors().isEmpty() || !beanDescriptor.getConstrainedMethods( MethodType.NON_GETTER, MethodType.GETTER ).isEmpty() ) { return true; } return false; }
@Override public void validateResourceAndInputParams(Object resource, final Invocable invocable, Object[] objects) throws ConstraintViolationException { final Class<?>[] groups = getGroup(invocable); final Set<ConstraintViolation<Object>> violations = new HashSet<>(); final BeanDescriptor beanDescriptor = getConstraintsForClass(resource.getClass()); if (beanDescriptor.isBeanConstrained()) { violations.addAll(validate(resource, groups)); } violations.addAll(forExecutables().validateParameters(resource, invocable.getHandlingMethod(), objects, groups)); if (!violations.isEmpty()) { throw new JerseyViolationException(violations, invocable); } }