Refine search
public ValidationInterceptor(MessageInterpolator messageInterpolator) { // Yes, this cast is unnecessary in Java 6, but seems to be required in Java 5 this.factory = ((Configuration) Validation.byDefaultProvider().configure().messageInterpolator(messageInterpolator)).buildValidatorFactory(); }
Configuration<?> configuration; if (this.providerClass != null) { ProviderSpecificBootstrap bootstrap = Validation.byProvider(this.providerClass); if (this.validationProviderResolver != null) { bootstrap = bootstrap.providerResolver(this.validationProviderResolver); GenericBootstrap bootstrap = Validation.byDefaultProvider(); if (this.validationProviderResolver != null) { bootstrap = bootstrap.providerResolver(this.validationProviderResolver); configuration = bootstrap.configure(); targetInterpolator = configuration.getDefaultMessageInterpolator(); configuration.messageInterpolator(new LocaleContextMessageInterpolator(targetInterpolator)); configuration.traversableResolver(this.traversableResolver); configuration.constraintValidatorFactory(targetConstraintValidatorFactory); for (Resource location : this.mappingLocations) { try { configuration.addMapping(location.getInputStream()); this.validatorFactory = configuration.buildValidatorFactory(); setTargetValidator(this.validatorFactory.getValidator());
/** * Create a validator factory * @return The factory */ public static ValidatorFactory createValidatorFactory() { Configuration configuration = Validation.byDefaultProvider().configure(); Configuration<?> conf = configuration.traversableResolver(new JCATraversableResolver()); return conf.buildValidatorFactory(); }
@Test @SpecAssertion(section = "4.4.5", id = "a") public void testBuildDefaultValidatorFactory() { ValidatorFactory defaultFactory = Validation.buildDefaultValidatorFactory(); assertNotNull( defaultFactory, "We should be able to get a factory." ); ValidatorFactory defaultProviderFactory = Validation.byDefaultProvider().configure().buildValidatorFactory(); assertNotNull( defaultProviderFactory, "We should be able to get a factory." ); assertEquals( defaultFactory.getClass(), defaultFactory.getClass(), "The factories have to be identical." ); }
/** * Builds and returns a {@link ValidatorFactory} instance based on the * default Bean Validation provider and following the XML configuration. * <p> * The provider list is resolved using the default validation provider resolver * logic. * <p> * The code is semantically equivalent to * {@code Validation.byDefaultProvider().configure().buildValidatorFactory()}. * * @return {@code ValidatorFactory} instance * * @throws NoProviderFoundException if no Bean Validation provider was found * @throws ValidationException if a Bean Validation provider was found but the * {@code ValidatorFactory} cannot be built */ public static ValidatorFactory buildDefaultValidatorFactory() { return byDefaultProvider().configure().buildValidatorFactory(); }
@SuppressWarnings({"unchecked", "rawtypes"}) public JValidator(URL url) { this.clazz = ReflectUtils.forName(url.getServiceInterface()); String jvalidation = url.getParameter("jvalidation"); ValidatorFactory factory; if (jvalidation != null && jvalidation.length() > 0) { factory = Validation.byProvider((Class) ReflectUtils.forName(jvalidation)).configure().buildValidatorFactory(); } else { factory = Validation.buildDefaultValidatorFactory(); } this.validator = factory.getValidator(); this.methodClassMap = new ConcurrentHashMap<String, Class>(); }
target.ignoreXmlConfiguration(); @SuppressWarnings("unchecked") final Class<MessageInterpolator> clazz = (Class<MessageInterpolator>) classLoader.loadClass(messageInterpolatorClass); target.messageInterpolator(clazz.newInstance()); } catch (final Exception e) { logger.warning("Unable to set " + messageInterpolatorClass + " as message interpolator.", e); @SuppressWarnings("unchecked") final Class<TraversableResolver> clazz = (Class<TraversableResolver>) classLoader.loadClass(traversableResolverClass); target.traversableResolver(clazz.newInstance()); } catch (final Exception e) { logger.warning("Unable to set " + traversableResolverClass + " as traversable resolver.", e); @SuppressWarnings("unchecked") final Class<ConstraintValidatorFactory> clazz = (Class<ConstraintValidatorFactory>) classLoader.loadClass(constraintFactoryClass); target.constraintValidatorFactory(clazz.newInstance()); } catch (final Exception e) { logger.warning("Unable to set " + constraintFactoryClass + " as constraint factory.", e); logger.debug("Found property '" + property.getName() + "' with value '" + property.getValue()); target.addProperty(property.getName(), property.getValue()); logger.warning("Unable to open input stream for mapping file " + mappingFileName + ". It will be ignored"); } else { target.addMapping(in);
@Override public MessageInterpolator getObject() throws BeansException { try { return Validation.byDefaultProvider().configure() .getDefaultMessageInterpolator(); } catch (ValidationException ex) { MessageInterpolator fallback = getFallback(); if (fallback != null) { return fallback; } throw ex; } }
private ValidatorFactory initFactory() { final ClassLoader oldTCCL = WildFlySecurityManager.getCurrentContextClassLoaderPrivileged(); try { WildFlySecurityManager.setCurrentContextClassLoaderPrivileged(classLoader); if (configuration == null) { return Validation.byDefaultProvider().providerResolver(new WildFlyProviderResolver()).configure() .buildValidatorFactory(); } else { return configuration.buildValidatorFactory(); } } finally { WildFlySecurityManager.setCurrentContextClassLoaderPrivileged(oldTCCL); } }
@Test(expectedExceptions = ValueExtractorDefinitionException.class) @SpecAssertion(section = Sections.VALUEEXTRACTORDEFINITION_EXTRACTEDVALUE, id = "b") @SpecAssertion(section = Sections.VALUEEXTRACTORDEFINITION_EXTRACTEDVALUE, id = "f") @SpecAssertion(section = Sections.EXCEPTION_VALUEEXTRACTORDEFINITION, id = "a") public void noExtractedValueThrowsException() { Validation.byDefaultProvider().configure() .addValueExtractor( new NoExtractedValueValueExtractor() ) .buildValidatorFactory() .getValidator(); }
@Test(expectedExceptions = ValidationException.class) @SpecAssertion(section = Sections.CONSTRAINTDECLARATIONVALIDATIONPROCESS_VALIDATIONROUTINE_TRAVERSABLE, id = "j") public void testResolverExceptionsGetWrappedInValidationException() { ExceptionThrowingTraversableResolver resolver = new ExceptionThrowingTraversableResolver(); Configuration<?> config = TestUtil.getConfigurationUnderTest().traversableResolver( resolver ); ValidatorFactory factory = config.buildValidatorFactory(); Validator v = factory.getValidator(); v.validate( new Suit() ); }
public ValidationExtension() { Configuration<?> config = Validation.byDefaultProvider().configure(); // we use the default ParameterNameProvider here as we cannot use the injected one // as it hasn't been turned into a managed bean yet and might not be able to // return a parameter name. At this stage, we don't care about the parameter names. config.parameterNameProvider( config.getDefaultParameterNameProvider() ); BootstrapConfiguration bootstrap = config.getBootstrapConfiguration(); globalExecutableTypes = bootstrap.getDefaultValidatedExecutableTypes(); isExecutableValidationEnabled = bootstrap.isExecutableValidationEnabled(); validatorFactory = config.buildValidatorFactory(); validator = validatorFactory.getValidator(); getterPropertySelectionStrategyHelper = GetterPropertySelectionStrategyHelper.forValidationFactory( validatorFactory ); executableHelper = new ExecutableHelper( new TypeResolutionHelper() ); }
public StatisticalValidationState() { ValidatorFactory factory = null; final Configuration<?> configuration = Validation.byDefaultProvider().configure(); try ( InputStream mappingStream = StatisticalValidation.class.getResourceAsStream( "mapping.xml" ) ) { configuration.addMapping( mappingStream ); factory = configuration.buildValidatorFactory(); assertThat( factory ).isNotNull(); } catch (IOException e) { throw new IllegalStateException( "Mappings cannot be read. Validation factory cannot be configured correctly.", e ); } validator = factory.getValidator(); entitiesUnderTest = IntStream.rangeClosed( 0, NUMBER_OF_TEST_ENTITIES ) .mapToObj( index -> new TestEntity( index % 10 ) ) .collect( Collectors.toList() ); }
private DefaultValidationContext() { Configuration<?> validationConfig = Validation.byDefaultProvider().configure(); if (new DefaultSejdaContext().isIgnoreXmlConfiguration()) { validationConfig.ignoreXmlConfiguration(); } ValidatorFactory factory = validationConfig.buildValidatorFactory(); validator = factory.getValidator(); }
@Override public ValidatorFactory create(CreationalContext<ValidatorFactory> ctx) { Configuration<?> config = getConfiguration(); config.constraintValidatorFactory( createConstraintValidatorFactory( config ) ); config.messageInterpolator( createMessageInterpolator( config ) ); config.traversableResolver( createTraversableResolver( config ) ); config.parameterNameProvider( createParameterNameProvider( config ) ); config.clockProvider( createClockProvider( config ) ); addValueExtractorBeans( config ); return config.buildValidatorFactory(); }
@SpecAssertion(section = "2.5", id = "c") @Test(expectedExceptions = ValidationException.class) public void testValidationExceptionIsThrownInCaseFactoryReturnsNull() { Configuration<?> config = TestUtil.getConfigurationUnderTest().constraintValidatorFactory( new ConstraintValidatorFactory() { public <T extends ConstraintValidator<?, ?>> T getInstance(Class<T> key) { return null; } } ); Validator validator = config.buildValidatorFactory().getValidator(); validator.validate( new SecondDummy() ); }
/** * Build and return a <code>ValidatorFactory</code> instance based on the * default Bean Validation provider. * <p/> * The provider list is resolved using the default validation provider * resolver logic. * <p/> * The code is semantically equivalent to * <code>Validation.byDefaultProvider().configure().buildValidatorFactory()</code> * * @return <code>ValidatorFactory</code> instance. * * @throws ValidationException if the ValidatorFactory cannot be built */ public static ValidatorFactory buildDefaultValidatorFactory() { return byDefaultProvider().configure().buildValidatorFactory(); }
private static void initFactoryConfig(Configuration<?> factoryCfg, ValidationConfiguration cfg) { if (cfg != null) { factoryCfg.parameterNameProvider(cfg.getParameterNameProvider()); factoryCfg.messageInterpolator(cfg.getMessageInterpolator()); factoryCfg.traversableResolver(cfg.getTraversableResolver()); factoryCfg.constraintValidatorFactory(cfg.getConstraintValidatorFactory()); for (Map.Entry<String, String> entry : cfg.getProperties().entrySet()) { factoryCfg.addProperty(entry.getKey(), entry.getValue()); } } }
@Override public ValidatorFactory get() { return config.buildValidatorFactory(); } }
@Test @SpecAssertion(section = Sections.VALIDATIONAPI_MESSAGE_CUSTOMRESOLUTION, id = "a") @SpecAssertion(section = Sections.VALIDATIONAPI_MESSAGE_CUSTOMRESOLUTION, id = "b") @SpecAssertion(section = Sections.VALIDATIONAPI_MESSAGE_CUSTOMRESOLUTION, id = "c") public void testCorrectValuesArePassedToInterpolateForClassLevelConstraint() { TestMessageInterpolator messageInterpolator = new TestMessageInterpolator(); Validator validator = TestUtil.getConfigurationUnderTest() .messageInterpolator( messageInterpolator ) .buildValidatorFactory() .getValidator(); TestBeanWithClassLevelConstraint testBean = new TestBeanWithClassLevelConstraint(); validator.validate( testBean ); assertEquals( messageInterpolator.messageTemplate, TestBeanWithClassLevelConstraint.MESSAGE ); ConstraintDescriptor<?> constraintDescriptor = messageInterpolator.constraintDescriptor; assertEquals( constraintDescriptor.getAnnotation().annotationType(), ValidTestBean.class ); assertEquals( constraintDescriptor.getMessageTemplate(), TestBeanWithClassLevelConstraint.MESSAGE ); assertEquals( messageInterpolator.validatedValue, testBean ); }