Java Code Examples for com.openpojo.validation.Validator#validate()

@Test
public void executeOpenPojoValidationsWithSetter() {

    final Validator pojoValidator =
            ValidatorBuilder.create()
                    .with(new GetterMustExistRule())
                    .with(new SetterMustExistRule())
                    .with(new SetterTester())
                    .with(new GetterTester())
                    .with(new EqualsAndHashCodeMatchRule())
                    .with(new NoPrimitivesRule())
                    .with(new NoPublicFieldsExceptStaticFinalRule())
                    .build();

    pojoValidator.validate(PojoClassFactory.getPojoClass(MessageHash.class));
}
 

@Test
public void shouldNotFail() {
  Validator validator = ValidatorBuilder
      .create()
      .with(new GetterTester())
      .with(new SetterTester())
      .build();

  final PojoClass pojoClass = PojoClassFactory.getPojoClass(AClassWithXMLGregorianCalendar.class);
  validator.validate(pojoClass);

  Assert.assertThat(appender.getEventsForLogger(GetterTester.class).size(), is(1));
  Assert.assertThat(appender.getEventsForLogger(SetterTester.class).size(), is(1));

  PojoField xmlGregorianCalendarPojoField = pojoClass.getPojoFields().get(0);
  final String message = "Testing Field [" + xmlGregorianCalendarPojoField + "] with value [";

  validateLogMessages(appender, GetterTester.class, message);
  validateLogMessages(appender, SetterTester.class, message);
}
 

@Test
public void test_pojo_structure_and_behavior() {

  List<Class> classes =
      Lists.newArrayList(
          GetCallerIdentityFullResponse.class,
          GetCallerIdentityResponse.class,
          AwsStsHttpHeader.class);

  List<PojoClass> pojoClasses =
      classes.stream().map(PojoClassFactory::getPojoClass).collect(Collectors.toList());

  Validator validator =
      ValidatorBuilder.create()
          .with(new GetterMustExistRule())
          .with(new SetterMustExistRule())
          .with(new SetterTester())
          .with(new GetterTester())
          .build();

  validator.validate(pojoClasses);
}
 

@Test
public void test_pojo_structure_and_behavior() {

  List<PojoClass> pojoClasses = PojoClassFactory.getPojoClasses("com.nike.cerberus.record");

  Assert.assertEquals(15, pojoClasses.size());

  Validator validator =
      ValidatorBuilder.create()
          .with(new GetterMustExistRule())
          .with(new SetterMustExistRule())
          .with(new SetterTester())
          .with(new GetterTester())
          .build();

  validator.validate(pojoClasses);
}
 

/**
 * Check all classes in package.
 *
 * @param string the string
 * @return true, if successful
 */
protected final boolean checkAllClassesInPackage(final String string) {
	final List<PojoClass> pojoClassesRecursively = PojoClassFactory.getPojoClassesRecursively(string,
			new FilterTestClasses());

	final Validator validator = ValidatorBuilder.create().with(new SetterMustExistRule(), new GetterMustExistRule())
			.with(new SetterTester(), new GetterTester()).with(new InvokeToStringTester())
			.with(new InvokeHashcodeTester()).with(new DummyEqualsTester()).with(new WithTester())
			.with(new ObjectFactoryTester()).with(new EqualsAndHashCodeMatchRule()).build();
	validator.validate(pojoClassesRecursively);

	final List<PojoClass> enumClassesRecursively = PojoClassFactory.getPojoClassesRecursively(string,
			new FilterNonEnumClasses());

	final Validator enumValidator = ValidatorBuilder.create().with(new EnumTester()).build();
	enumValidator.validate(enumClassesRecursively);

	return true;
}
 

@Test
public void shouldReportMissingASMProperly() {
  Validator validator = ValidatorBuilder.create()
      .with(new Tester() {
        public void run(PojoClass pojoClass) {
          throw ASMNotLoadedException.getInstance();
        }
      }).build();

  LogHelper.initialize(MockAppenderLog4J.class);
  validator.validate(PojoClassFactory.getPojoClass(this.getClass()));
  List<LogEvent> warnEvents = LogHelper.getWarnEvents(MockAppenderLog4J.class, DefaultValidator.class.getName());
  Assert.assertEquals(1, warnEvents.size());
  String expectedMessage = "ASM not loaded while attempting to execute behavioural tests on non-constructable class["
      + this.getClass() + "], either filter abstract classes or add asm to your classpath.";
  Assert.assertEquals(expectedMessage, warnEvents.get(0).getMessage());
}
 

@Test
public void testPojoStructureAndBehavior() {
    List<PojoClass> pojoClasses = PojoClassFactory.getPojoClassesRecursively(MODEL_PACKAGE, BASE_CLASS_FILTER);

    Validator validator = ValidatorBuilder.create()
            .with(new SetterMustExistRule(),
                    new GetterMustExistRule())
            .with(new GetterTester())
            .with(new NoPublicFieldsExceptStaticFinalRule())
            .with(new NoStaticExceptFinalRule())
            .with(new NoNestedClassRule())
            .with(new NoFieldShadowingRule())
            .build();
    validator.validate(pojoClasses);

    validator = ValidatorBuilder.create()
            .with(new SetterTester())
            .build();
    validator.validate(pojoClasses);
    // openpojo will do for now (seems buggy) but later would worth experimenting with pojo-tester (https://www.pojo.pl/)
}
 

@Test
void testPojoStructureAndBehavior() {

    List<PojoClass> pojoClasses = new ArrayList<>();
    pojoClasses.add(PojoClassFactory.getPojoClass(Region.class));
    pojoClasses.add(PojoClassFactory.getPojoClass(CompactView.class));
    pojoClasses.add(PojoClassFactory.getPojoClass(EnvironmentAuthentication.class));

    Validator validator = ValidatorBuilder.create()
            .with(new SetterMustExistRule(),
                    new GetterMustExistRule())
            .with(new GetterTester())
            .with(new NoPublicFieldsExceptStaticFinalRule())
            .with(new NoStaticExceptFinalRule())
            .with(new NoNestedClassRule())
            .with(new NoFieldShadowingRule())
            .build();
    validator.validate(pojoClasses);

    validator = ValidatorBuilder.create()
            .with(new SetterTester())
            .build();
    validator.validate(pojoClasses);
    // openpojo will do for now (seems buggy) but later would worth experimenting with pojo-tester (https://www.pojo.pl/)
}
 

@Test
public void whenBooleanStartsWith_is_AndThirdCharacterIsNotUpperCase_Getter_isIsY_Setter_setIsy() {
  PojoClass pojoClass = PojoClassFactory.getPojoClass(ClassWithBoolean_isy.class);

  Validator pojoValidator = ValidatorBuilder.create()
      .with(new GetterMustExistRule())
      .with(new SetterMustExistRule())
      .build();

  pojoValidator.validate(pojoClass);

}
 

@Test
public void testPojoStructureAndBehavior() {
    List<PojoClass> pojoClasses = PojoClassFactory.getPojoClassesRecursively(DOMAIN_PACKAGE, POJO_CLASS_FILTER);

    Validator validator = ValidatorBuilder.create()
            .with(new SetterMustExistRule(),
                    new GetterMustExistRule())
            .with(new SetterTester(),
                    new GetterTester())
            .with(new NoStaticExceptFinalRule())
            .with(new NoNestedClassRule())
            .build();
    validator.validate(pojoClasses);
}
 

@Test
public void testEndToEndMap() {
  Validator pojoValidator = ValidatorBuilder.create()
      .with(new SetterMustExistRule())
      .with(new SetterTester())
      .build();

  pojoValidator.validate(PojoClassFactory.getPojoClass(ClassWithVariousGenericMap.class));
}
 

@Test
public void SampleClassMustUseBusinessIdentity() {
  Validator pojoValidator = ValidatorBuilder.create()
      .with(new BusinessKeyMustExistRule())
      .with(new BusinessIdentityTester())
      .build();
  pojoValidator.validate(PojoClassFactory.getPojoClass(StringArrayCaseSensitive.class));
  pojoValidator.validate(PojoClassFactory.getPojoClass(StringArrayCaseInsensitive.class));
}
 

@Test
public void testPojoStructureAndBehavior() {
    final Validator validator = ValidatorBuilder.create()
            // Add Testers to validate behaviour for pojoPackage
            // See com.openpojo.validation.test.impl for more ...
            .with(new SetterTester())
            .with(new GetterTester())
            .build();

    validator.validate(this.pojoPackage, this.filterChain);
}
 

@Test
public void issueTest() {

  Validator validator = ValidatorBuilder.create()
      .with(new SetterTester())
      .with(new GetterTester())
      .build();

  validator.validate(PojoClassFactory.getPojoClass(TestClass.class));
}
 

@Test
public void exhaustiveTest() {
  PojoClass pojoClass = PojoClassFactory.getPojoClass(AClassWithExhaustiveCollection.class);
  Validator pojoValidator = ValidatorBuilder.create()
      .with(new SetterMustExistRule())
      .with(new SetterTester())
      .build();

  pojoValidator.validate(pojoClass);
}
 

@Test
public void test_pojo_structure_and_behavior() {

  List<Class> classes =
      Lists.newArrayList(
          CreateSessionLoginTokenRequest.class,
          CreateSessionLoginTokenResponse.class,
          GenerateTokenRequest.class,
          GenerateTokenResponse.class,
          GenerateTokenResponseData.class,
          GetUserResponse.class,
          MfaDevice.class,
          ResponseStatus.class,
          SessionLoginTokenData.class,
          SessionUser.class,
          UserData.class,
          VerifyFactorRequest.class,
          VerifyFactorResponse.class);

  List<PojoClass> pojoClasses =
      classes.stream().map(PojoClassFactory::getPojoClass).collect(Collectors.toList());

  Validator validator =
      ValidatorBuilder.create()
          .with(new GetterMustExistRule())
          .with(new SetterMustExistRule())
          .with(new SetterTester())
          .with(new GetterTester())
          .build();

  validator.validate(pojoClasses);
}
 

@Test
public void end2endTest() {
  PojoClass pojoClass = PojoClassFactory.getPojoClass(classWithCredentialsDumperClass);
  Validator validator = ValidatorBuilder.create()
      .with(new GetterTester())
      .with(new SetterTester())
      .build();
  validator.validate(pojoClass);
}
 

@Test
public void ensureClassIsDefinedCorrectly() {
  Validator validator = ValidatorBuilder.create()
      .with(new GetterMustExistRule())
      .with(new SetterMustExistRule())
      .with(new AllPimitivesAsArraysDeclaredRule())
      .with(new GetterTester())
      .with(new SetterTester())
      .build();
  validator.validate(pojoClass);
}
 

@Test(expected = AssertionError.class)
public void shouldFailValidationWithIntegerFieldAndPrimitiveIntReturnTypeGetter() {
  final PojoClass pojoClass = PojoClassFactory.getPojoClass(ClassWithIntegerFieldAndPrimitiveIntReturnTypeGetter.class);
  final Validator pojoValidator = ValidatorBuilder.create().with(new GetterMustExistRule()).build();
  pojoValidator.validate(pojoClass);
}
 

@Test(expected = AssertionError.class)
public void shouldFailValidationWithIntegerFieldAndPrimitiveIntParameterSetter() {
  final PojoClass pojoClass = PojoClassFactory.getPojoClass(ClassWithIntegerFieldAndPrimitiveIntParameterSetter.class);
  final Validator pojoValidator = ValidatorBuilder.create().with(new SetterMustExistRule()).build();
  pojoValidator.validate(pojoClass);
}