org.javers.core.Javers Java Examples

@Test
public void shouldCompareTwoObjects() {

  //given
  Javers javers = JaversBuilder.javers().build();

  Address address1 = new Address("New York","5th Avenue");
  Address address2 = new Address("New York","6th Avenue");

  //when
  Diff diff = javers.compare(address1, address2);

  //then
  //there should be one change of type {@link ValueChange}
  ValueChange change = diff.getChangesByType(ValueChange.class).get(0);

  assertThat(diff.getChanges()).hasSize(1);
  assertThat(change.getAffectedGlobalId().value())
            .isEqualTo("org.javers.core.examples.model.Address/");
  assertThat(change.getPropertyName()).isEqualTo("street");
  assertThat(change.getLeft()).isEqualTo("5th Avenue");
  assertThat(change.getRight()).isEqualTo("6th Avenue");

  System.out.println(diff);
}
 

@Test
public void givenListOfPerson_whenPersonRemovedAddress_thenDetectThatChange() {
    // given
    Javers javers = JaversBuilder.javers().build();

    PersonWithAddress person = new PersonWithAddress(1, "Tom", Arrays.asList(new Address("England")));

    PersonWithAddress personWithNewAddress = new PersonWithAddress(1, "Tom", Collections.emptyList());

    // when
    Diff diff = javers.compare(person, personWithNewAddress);
    List objectsByChangeType = diff.getObjectsByChangeType(ObjectRemoved.class);

    // then
    assertThat(objectsByChangeType).hasSize(1);
    assertThat(objectsByChangeType.get(0).equals(new Address("England")));
}
 

@Test
public void givenListOfPerson_whenPersonHasNewAddress_thenDetectThatChange() {
    // given
    Javers javers = JaversBuilder.javers().build();

    PersonWithAddress person = new PersonWithAddress(1, "Tom", Arrays.asList(new Address("England")));

    PersonWithAddress personWithNewAddress = new PersonWithAddress(1, "Tom", Arrays.asList(new Address("England"), new Address("USA")));

    // when
    Diff diff = javers.compare(person, personWithNewAddress);
    List objectsByChangeType = diff.getObjectsByChangeType(NewObject.class);

    // then
    assertThat(objectsByChangeType).hasSize(1);
    assertThat(objectsByChangeType.get(0).equals(new Address("USA")));
}
 

@Test
public void givenListOfPersons_whenCompare_ThenShouldDetectChanges() {
    // given
    Javers javers = JaversBuilder.javers().build();
    Person personThatWillBeRemoved = new Person(2, "Thomas Link");
    List<Person> oldList = Lists.asList(new Person(1, "Michael Program"), personThatWillBeRemoved);
    List<Person> newList = Lists.asList(new Person(1, "Michael Not Program"));

    // when
    Diff diff = javers.compareCollections(oldList, newList, Person.class);

    // then
    assertThat(diff.getChanges()).hasSize(3);

    ValueChange valueChange = diff.getChangesByType(ValueChange.class).get(0);
    assertThat(valueChange.getPropertyName()).isEqualTo("name");
    assertThat(valueChange.getLeft()).isEqualTo("Michael Program");
    assertThat(valueChange.getRight()).isEqualTo("Michael Not Program");

    ObjectRemoved objectRemoved = diff.getChangesByType(ObjectRemoved.class).get(0);
    assertThat(objectRemoved.getAffectedObject().get().equals(personThatWillBeRemoved)).isTrue();

    ListChange listChange = diff.getChangesByType(ListChange.class).get(0);
    assertThat(listChange.getValueRemovedChanges().size()).isEqualTo(1);

}
 

@Test
public void givenPersonObject_whenApplyModificationOnIt_thenShouldDetectChange() {
    // given
    Javers javers = JaversBuilder.javers().build();

    Person person = new Person(1, "Michael Program");
    Person personAfterModification = new Person(1, "Michael Java");

    // when
    Diff diff = javers.compare(person, personAfterModification);

    // then
    ValueChange change = diff.getChangesByType(ValueChange.class).get(0);

    assertThat(diff.getChanges()).hasSize(1);
    assertThat(change.getPropertyName()).isEqualTo("name");
    assertThat(change.getLeft()).isEqualTo("Michael Program");
    assertThat(change.getRight()).isEqualTo("Michael Java");
}
 

/**
 * Creates JaVers instance with {@link JaversSqlRepository}
 */
@Bean
public Javers javers(PlatformTransactionManager txManager) {
    JaversSqlRepository sqlRepository = SqlRepositoryBuilder
            .sqlRepository()
            .withConnectionProvider(jpaConnectionProvider())
            .withDialect(DialectName.H2)
            .build();

    return TransactionalJaversBuilder
            .javers()
            .withTxManager(txManager)
            .withObjectAccessHook(new HibernateUnproxyObjectAccessHook())
            .registerJaversRepository(sqlRepository)
            .build();
}
 

@Test
public void shouldCalculateChangedPropertyNamesForNullifiedValues() {
    //given
    Javers javers = JaversBuilder.javers().build();
    SimpleTypes obj = new SimpleTypes("1");
    javers.commit("anonymous", obj);

    //when
    obj.shortNumber = -1;
    javers.commit("anonymous", obj);
    CdoSnapshot s = javers.getLatestSnapshot("1", SimpleTypes.class).get();

    //then
    Assertions.assertThat(s.getChanged()).containsExactly("shortNumber");

    //when
    obj.nullify();
    javers.commit("anonymous", obj);
    s = javers.getLatestSnapshot("1", SimpleTypes.class).get();

    //then
    Assertions.assertThat(s.getChanged()).hasSize(11);
}
 

@Test
public void shouldCompareTwoObjectsWithCharSequencePropertiesOfString() {
    //given
    Javers javers = JaversBuilder.javers().build();

    AvroAddress oldVersion = new AvroAddress("New York", "First Avenue");
    AvroAddress currentVersion = new AvroAddress("New York", "Second Avenue");

    //when
    Diff diff = javers.compare(oldVersion, currentVersion);
    System.out.println(diff);

    //then
    ValueChange change = diff.getChangesByType(ValueChange.class).get(0);

    assertThat(diff.getChanges()).hasSize(1);
    assertThat(change.getPropertyName()).isEqualTo("street");
    assertThat(change.getLeft()).isEqualTo(oldVersion.getStreet());
    assertThat(change.getRight()).isEqualTo(currentVersion.getStreet());
}
 

@Test
public void shouldSupportInterfaceProperty() {
    // given
    TestClassWithInterfaceProperty foo = new TestClassWithInterfaceProperty("1", new TestInterfaceImpl("Foo"));
    TestClassWithInterfaceProperty bar = new TestClassWithInterfaceProperty("1", new TestInterfaceImpl("Bar"));
    Javers javers = JaversBuilder.javers().build();

    // when
    Diff diff = javers.compare(foo, bar);

    System.out.println(diff);

    // then
    assertTrue(diff.getChanges().size() == 1);
    ValueChange change = diff.getChangesByType(ValueChange.class).get(0);
    ValueObjectIdDTO voId = ValueObjectIdDTO.valueObjectId("1", TestClassWithInterfaceProperty.class, "interfaceProperty");

    Assertions.assertThat(change.getAffectedGlobalId().value()).isEqualTo(voId.value());
    Assertions.assertThat(change.getPropertyName()).isEqualTo("value");
    Assertions.assertThat(change.getLeft()).isEqualTo("Foo");
    Assertions.assertThat(change.getRight()).isEqualTo("Bar");
}
 

@Test
public void shouldSerializeValueToJsonWithTypeAdapter() {
    //given
    Javers javers = JaversBuilder.javers()
            .registerValueTypeAdapter(new ObjectIdTypeAdapter())
            .build();

    //when
    ObjectId id = ObjectId.get();
    MongoStoredEntity entity1 = new MongoStoredEntity(id, "alg1", "1.0", "name");
    MongoStoredEntity entity2 = new MongoStoredEntity(id, "alg1", "1.0", "another");
    Diff diff = javers.compare(entity1, entity2);

    //then
    String json = javers.getJsonConverter().toJson(diff);
    Assertions.assertThat(json).contains(id.toString());

    System.out.println(json);
}
 

/**
 * Gets the javers.
 *
 * @param txManager the tx manager
 * @return the javers
 */
@Bean
public Javers getJavers(final PlatformTransactionManager txManager) {
	final JaversSqlRepository sqlRepository = SqlRepositoryBuilder.sqlRepository()
			.withConnectionProvider(new ConnectionProvider() {

				@Override
				public Connection getConnection() {
					final SessionImpl session = (SessionImpl) entityManager.unwrap(Session.class);

					return session.connection();
				}
			}).withDialect(DialectName.POSTGRES).build();

	return TransactionalJaversBuilder.javers().withTxManager(txManager)
			.withObjectAccessHook(new HibernateUnproxyObjectAccessHook()).registerJaversRepository(sqlRepository)
			.withMappingStyle(MappingStyle.BEAN).build();
}
 

@Test
public void shouldDeeplyCompareTwoTopLevelCollections() {
  //given
  Javers javers = JaversBuilder.javers().build();

  List<Person> oldList = Lists.asList( new Person("tommy", "Tommy Smart") );
  List<Person> newList = Lists.asList( new Person("tommy", "Tommy C. Smart") );

  //when
  Diff diff = javers.compareCollections(oldList, newList, Person.class);

  //then
  //there should be one change of type {@link ValueChange}
  ValueChange change = diff.getChangesByType(ValueChange.class).get(0);

  assertThat(diff.getChanges()).hasSize(1);
  assertThat(change.getPropertyName()).isEqualTo("name");
  assertThat(change.getLeft()).isEqualTo("Tommy Smart");
  assertThat(change.getRight()).isEqualTo("Tommy C. Smart");

  System.out.println(diff);
}
 

@Bean(name = "JaversFromStarter")
@ConditionalOnMissingBean
public Javers javers(JaversSqlRepository sqlRepository, PlatformTransactionManager transactionManager) {
    return TransactionalJaversBuilder
            .javers()
            .withTxManager(transactionManager)
            .registerJaversRepository(sqlRepository)
            .withObjectAccessHook(javersSqlProperties.createObjectAccessHookInstance())
            .withProperties(javersSqlProperties)
            .build();
}
 

@Bean
@ConditionalOnProperty(name = "javers.auditableAspectEnabled", havingValue = "true", matchIfMissing = true)
public JaversAuditableAspect javersAuditableAspect(
        Javers javers,
        AuthorProvider authorProvider,
        CommitPropertiesProvider commitPropertiesProvider) {
    return new JaversAuditableAspect(javers, authorProvider, commitPropertiesProvider);
}
 

/**
 * Creates JaVers instance backed by {@link MongoRepository}
 */
@Bean
public Javers javers() {
    MongoRepository javersMongoRepository =
            new MongoRepository(mongo().getDatabase(DATABASE_NAME));

    return JaversBuilder.javers()
            .registerJaversRepository(javersMongoRepository)
            .build();
}
 

@Override
public Javers build() {
    if (txManager == null) {
        throw new JaversException(JaversExceptionCode.TRANSACTION_MANAGER_NOT_SET);
    }

    Javers javersCore = super.assembleJaversInstance();

    Javers javersTransactional =
            new JaversTransactionalDecorator(javersCore, getContainerComponent(JaversSqlRepository.class), txManager);

    return javersTransactional;
}
 

@Bean
@ConditionalOnProperty(name = "javers.springDataAuditableRepositoryAspectEnabled", havingValue = "true", matchIfMissing = true)
public JaversSpringDataAuditableRepositoryAspect javersSpringDataAuditableAspect(
        Javers javers,
        AuthorProvider authorProvider,
        CommitPropertiesProvider commitPropertiesProvider) {
    return new JaversSpringDataAuditableRepositoryAspect(javers, authorProvider, commitPropertiesProvider);
}
 

@Test
public void shouldCommitEntityWithSerializableId() {
    //given
    Javers javers = JaversBuilder.javers().
            registerJaversRepository(H2RepositoryFactory.create()).build();

    //when
    Account acc = new Account("1","2");
    javers.commit("author", acc);

    //then
    CdoSnapshot snapshot = javers.getLatestSnapshot("1", Account.class).get();
    Assertions.assertThat(snapshot.getPropertyValue("id")).isEqualTo("1");
    Assertions.assertThat(snapshot.getPropertyValue("value")).isEqualTo("2");
}
 

@Bean(name = "JaversFromStarter")
@ConditionalOnMissingBean
public Javers javers() {
    logger.info("Starting javers-spring-boot-starter-mongo ...");

    MongoDatabase mongoDatabase = initJaversMongoDatabase();

    MongoRepository javersRepository = createMongoRepository(mongoDatabase);

    return JaversBuilder.javers()
            .registerJaversRepository(javersRepository)
            .withProperties(javersMongoProperties)
            .withObjectAccessHook(javersMongoProperties.createObjectAccessHookInstance())
            .build();
}
 

/** {@link ReferenceChange} example */
@Test
public void shouldDetectBossChange() {
  //given
  Javers javers = JaversBuilder.javers().build();

  Employee oldBoss = new Employee("Big Boss")
      .addSubordinates(
           new Employee("Manager One")
               .addSubordinate(new Employee("Great Developer")),
           new Employee("Manager Second"));

  Employee newBoss = new Employee("Big Boss")
      .addSubordinates(
           new Employee("Manager One"),
           new Employee("Manager Second")
               .addSubordinate(new Employee("Great Developer")));

  //when
  Diff diff = javers.compare(oldBoss, newBoss);

  //then
  ReferenceChange change = diff.getChangesByType(ReferenceChange.class).get(0);

  assertThat(change.getAffectedLocalId()).isEqualTo("Great Developer");
  assertThat(change.getLeft().value()).endsWith("Manager One");
  assertThat(change.getRight().value()).endsWith("Manager Second");

  System.out.println(diff);
}
 

/** {@link ValueChange} example */
@Test
public void shouldDetectSalaryChange(){
  //given
  Javers javers = JaversBuilder.javers().build();

  Employee oldBoss = new Employee("Big Boss")
          .addSubordinates(
                  new Employee("Noisy Manager"),
                  new Employee("Great Developer", 10000));

  Employee newBoss = new Employee("Big Boss")
          .addSubordinates(
                  new Employee("Noisy Manager"),
                  new Employee("Great Developer", 20000));

  //when
  Diff diff = javers.compare(oldBoss, newBoss);

  //then
  ValueChange change =  diff.getChangesByType(ValueChange.class).get(0);

  assertThat(change.getAffectedLocalId()).isEqualTo("Great Developer");
  assertThat(change.getPropertyName()).isEqualTo("salary");
  assertThat(change.getLeft()).isEqualTo(10000);
  assertThat(change.getRight()).isEqualTo(20000);

  System.out.println(diff);
}
 

/** {@link ObjectRemoved} example */
@Test
public void shouldDetectFired() {
  //given
  Javers javers = JaversBuilder.javers().build();

  Employee oldBoss = new Employee("Big Boss")
          .addSubordinates(
                  new Employee("Great Developer"),
                  new Employee("Team Lead").addSubordinates(
                          new Employee("Another Dev"),
                          new Employee("To Be Fired")
                  ));

  Employee newBoss = new Employee("Big Boss")
          .addSubordinates(
                  new Employee("Great Developer"),
                  new Employee("Team Lead").addSubordinates(
                          new Employee("Another Dev")
                  ));

  //when
  Diff diff = javers.compare(oldBoss, newBoss);

  //then
  assertThat(diff.getChangesByType(ObjectRemoved.class)).hasSize(1);

  System.out.println(diff);
}
 

/** {@link NewObject} example */
@Test
public void shouldDetectHired() {
  //given
  Javers javers = JaversBuilder.javers().build();

  Employee oldBoss = new Employee("Big Boss")
      .addSubordinates(
          new Employee("Great Developer"));

  Employee newBoss = new Employee("Big Boss")
      .addSubordinates(
          new Employee("Great Developer"),
          new Employee("Hired One"),
          new Employee("Hired Second"));

  //when
  Diff diff = javers.compare(oldBoss, newBoss);

  //then
  assertThat(diff.getObjectsByChangeType(NewObject.class))
      .hasSize(2)
      .containsOnly(new Employee("Hired One"),
                    new Employee("Hired Second"));

  System.out.println(diff);
}
 

public static void main(String[] args) {
    System.out.println(".. Starting javers-core runtime environment self test ...");

    System.out.println("java.runtime.name:          " + System.getProperty("java.runtime.name"));
    System.out.println("java.vendor:                " + System.getProperty("java.vendor"));
    System.out.println("java.runtime.version:       " + System.getProperty("java.runtime.version"));
    System.out.println("java.version:               " + System.getProperty("java.version"));
    System.out.println("java.home:                  " + System.getProperty("java.home"));
    System.out.println("os.name & ver:              " + System.getProperty("os.name")+" v."+System.getProperty("os.version"));

    System.out.println(".. building JaVers instance ...");

    try {
        Javers javers = JaversBuilder.javers().build();

        SampleValueObject left = new SampleValueObject("red");
        SampleValueObject right = new SampleValueObject("green");

        System.out.println(".. calculating diff for two simple ValueObjects...");
        Diff diff = javers.compare(left, right);

        conditionFulfilled(diff.getChanges().size() == 1, "assertion failed");
        conditionFulfilled(diff.getPropertyChanges("color").size() == 1, "assertion failed");

        System.out.println(".. self test PASSED ..");
    }catch(Throwable e) {
        System.out.println(e);
        e.printStackTrace();
        System.out.println(".. self test FAILED! ..");
    }
}
 

/**
 * throws RuntimeException if class is not found
 */
public static Class<?> classForName(String className) {
    try {
        return Class.forName(className, false, Javers.class.getClassLoader());
    }
    catch (ClassNotFoundException ex) {
        throw new JaversException(JaversExceptionCode.CLASS_NOT_FOUND, className);
    }
}
 

public static boolean isClassPresent(String className) {
    try {
        Class.forName(className, false, Javers.class.getClassLoader());
        return true;
    }
    catch (Throwable ex) {
        // Class or one of its dependencies is not present...
        return false;
    }
}
 

@Bean
public JaversAuditableAspect javersAuditableAspect(Javers javers) {
    return new JaversAuditableAspect(javers, authorProvider(), commitPropertiesProvider());
}
 

JaversTransactionalDecorator(Javers delegate, JaversSqlRepository javersSqlRepository, PlatformTransactionManager txManager) {
    Validate.argumentsAreNotNull(delegate, javersSqlRepository, txManager);
    this.delegate = delegate;
    this.javersSqlRepository = javersSqlRepository;
    this.txManager = txManager;
}
 

@Bean
public JaversSpringDataAuditableRepositoryAspect javersSpringDataAuditableAspect(Javers javers) {
    return new JaversSpringDataAuditableRepositoryAspect(javers, authorProvider(), commitPropertiesProvider());
}
 

public StoreController(StoreService customerService, Javers javers) {
    this.storeService = customerService;
    this.javers = javers;
}