[hibernate-commits] Hibernate SVN: r18225 - in core/trunk/envers: src/main/java/org/hibernate/envers/event and 3 other directories.
hibernate-commits at lists.jboss.org
hibernate-commits at lists.jboss.org
Tue Dec 15 07:27:01 EST 2009
Author: adamw
Date: 2009-12-15 07:27:01 -0500 (Tue, 15 Dec 2009)
New Revision: 18225
Added:
core/trunk/envers/src/test/java/org/hibernate/envers/test/entities/onetomany/detached/DoubleListJoinColumnBidirectionalRefEdEntity1.java
core/trunk/envers/src/test/java/org/hibernate/envers/test/entities/onetomany/detached/DoubleListJoinColumnBidirectionalRefEdEntity2.java
core/trunk/envers/src/test/java/org/hibernate/envers/test/entities/onetomany/detached/DoubleListJoinColumnBidirectionalRefIngEntity.java
core/trunk/envers/src/test/java/org/hibernate/envers/test/integration/onetomany/detached/DoubleJoinColumnBidirectionalList.java
Modified:
core/trunk/envers/pom.xml
core/trunk/envers/src/main/java/org/hibernate/envers/event/AuditEventListener.java
core/trunk/envers/src/main/java/org/hibernate/envers/synchronization/work/FakeBidirectionalRelationWorkUnit.java
Log:
HHH-4694:
- adding support for multiple "fake" bidirectional relations
- downgrading testng back to 5.8 as using 5.10 was OOMing the tests
- updating h2 dependency to a newer version
Modified: core/trunk/envers/pom.xml
===================================================================
--- core/trunk/envers/pom.xml 2009-12-15 10:50:11 UTC (rev 18224)
+++ core/trunk/envers/pom.xml 2009-12-15 12:27:01 UTC (rev 18225)
@@ -95,14 +95,14 @@
<dependency>
<groupId>org.testng</groupId>
<artifactId>testng</artifactId>
- <version>5.10</version>
+ <version>5.8</version>
<classifier>jdk15</classifier>
<scope>test</scope>
</dependency>
<dependency>
<groupId>com.h2database</groupId>
<artifactId>h2</artifactId>
- <version>1.0.79</version>
+ <version>1.2.125</version>
<scope>test</scope>
</dependency>
<dependency>
Modified: core/trunk/envers/src/main/java/org/hibernate/envers/event/AuditEventListener.java
===================================================================
--- core/trunk/envers/src/main/java/org/hibernate/envers/event/AuditEventListener.java 2009-12-15 10:50:11 UTC (rev 18224)
+++ core/trunk/envers/src/main/java/org/hibernate/envers/event/AuditEventListener.java 2009-12-15 12:27:01 UTC (rev 18225)
@@ -229,7 +229,7 @@
relatedId, relatedObj);
verSync.addWorkUnit(new FakeBidirectionalRelationWorkUnit(event.getSession(), relatedEntityName, verCfg,
- relatedId, event.getAffectedOwnerOrNull(), rd, revType, nestedWorkUnit));
+ relatedId, referencingPropertyName, event.getAffectedOwnerOrNull(), rd, revType, nestedWorkUnit));
}
// We also have to generate a collection change work unit for the owning entity.
Modified: core/trunk/envers/src/main/java/org/hibernate/envers/synchronization/work/FakeBidirectionalRelationWorkUnit.java
===================================================================
--- core/trunk/envers/src/main/java/org/hibernate/envers/synchronization/work/FakeBidirectionalRelationWorkUnit.java 2009-12-15 10:50:11 UTC (rev 18224)
+++ core/trunk/envers/src/main/java/org/hibernate/envers/synchronization/work/FakeBidirectionalRelationWorkUnit.java 2009-12-15 12:27:01 UTC (rev 18225)
@@ -8,6 +8,8 @@
import java.io.Serializable;
import java.util.Map;
import java.util.HashMap;
+import java.util.Set;
+import java.util.HashSet;
/**
* A work unit that handles "fake" bidirectional one-to-many relations (mapped with {@code @OneToMany+ at JoinColumn} and
@@ -15,44 +17,49 @@
* @author Adam Warski (adam at warski dot org)
*/
public class FakeBidirectionalRelationWorkUnit extends AbstractAuditWorkUnit implements AuditWorkUnit {
- private final Object owningEntity;
- private final RelationDescription rd;
- private final RevisionType revisionType;
+ private final Map<String, FakeRelationChange> fakeRelationChanges;
/*
* The work unit responsible for generating the "raw" entity data to be saved.
*/
private final AuditWorkUnit nestedWorkUnit;
-
public FakeBidirectionalRelationWorkUnit(SessionImplementor sessionImplementor, String entityName,
- AuditConfiguration verCfg, Serializable id, Object owningEntity,
+ AuditConfiguration verCfg, Serializable id,
+ String referencingPropertyName, Object owningEntity,
RelationDescription rd, RevisionType revisionType,
AuditWorkUnit nestedWorkUnit) {
super(sessionImplementor, entityName, verCfg, id);
+ this.nestedWorkUnit = nestedWorkUnit;
+ // Adding the change for the relation.
+ fakeRelationChanges = new HashMap<String, FakeRelationChange>();
+ fakeRelationChanges.put(referencingPropertyName, new FakeRelationChange(owningEntity, rd, revisionType));
+ }
- this.owningEntity = owningEntity;
- this.rd = rd;
- this.revisionType = revisionType;
+ public FakeBidirectionalRelationWorkUnit(FakeBidirectionalRelationWorkUnit original,
+ Map<String, FakeRelationChange> fakeRelationChanges,
+ AuditWorkUnit nestedWorkUnit) {
+ super(original.sessionImplementor, original.entityName, original.verCfg, original.id);
+
+ this.fakeRelationChanges = fakeRelationChanges;
this.nestedWorkUnit = nestedWorkUnit;
}
public FakeBidirectionalRelationWorkUnit(FakeBidirectionalRelationWorkUnit original, AuditWorkUnit nestedWorkUnit) {
super(original.sessionImplementor, original.entityName, original.verCfg, original.id);
- this.owningEntity = original.owningEntity;
- this.rd = original.rd;
- this.revisionType = original.revisionType;
this.nestedWorkUnit = nestedWorkUnit;
+
+ fakeRelationChanges = new HashMap<String, FakeRelationChange>(original.getFakeRelationChanges());
}
public AuditWorkUnit getNestedWorkUnit() {
return nestedWorkUnit;
}
- public RevisionType getRevisionType() {
- return revisionType;
+ public Map<String, FakeRelationChange> getFakeRelationChanges() {
+ return fakeRelationChanges;
}
public boolean containsWork() {
@@ -64,11 +71,10 @@
// Making a defensive copy not to modify the data held by the nested work unit.
Map<String, Object> nestedData = new HashMap<String, Object>(nestedWorkUnit.generateData(revisionData));
- // Now adding data for the fake relation.
- // If the revision type is "DEL", it means that the object is removed from the collection. Then the
- // new owner will in fact be null.
- rd.getFakeBidirectionalRelationMapper().mapToMapFromEntity(sessionImplementor, nestedData,
- revisionType == RevisionType.DEL ? null : owningEntity, null);
+ // Now adding data for all fake relations.
+ for (FakeRelationChange fakeRelationChange : fakeRelationChanges.values()) {
+ fakeRelationChange.generateData(sessionImplementor, nestedData);
+ }
return nestedData;
}
@@ -90,19 +96,23 @@
}
public AuditWorkUnit merge(FakeBidirectionalRelationWorkUnit second) {
- /*
- * The merging rules are the following (revision types of the first and second work units):
- * - DEL, DEL - return any (the work units are the same)
- * - DEL, ADD - return ADD (points to new owner)
- * - ADD, DEL - return ADD (points to new owner)
- * - ADD, ADD - return second (points to newer owner)
- */
+ // First merging the nested work units.
+ AuditWorkUnit mergedNested = second.getNestedWorkUnit().dispatch(nestedWorkUnit);
- if (revisionType == RevisionType.DEL || second.getRevisionType() == RevisionType.ADD) {
- return second;
+ // Now merging the fake relation changes from both work units.
+ Map<String, FakeRelationChange> secondFakeRelationChanges = second.getFakeRelationChanges();
+ Map<String, FakeRelationChange> mergedFakeRelationChanges = new HashMap<String, FakeRelationChange>();
+ Set<String> allPropertyNames = new HashSet<String>(fakeRelationChanges.keySet());
+ allPropertyNames.addAll(secondFakeRelationChanges.keySet());
+
+ for (String propertyName : allPropertyNames) {
+ mergedFakeRelationChanges.put(propertyName,
+ FakeRelationChange.merge(
+ fakeRelationChanges.get(propertyName),
+ secondFakeRelationChanges.get(propertyName)));
}
- return this;
+ return new FakeBidirectionalRelationWorkUnit(this, mergedFakeRelationChanges, mergedNested);
}
public AuditWorkUnit dispatch(WorkUnitMergeVisitor first) {
@@ -116,4 +126,48 @@
// Creating a new fake relation work unit with the nested merged data
return new FakeBidirectionalRelationWorkUnit(frwu, nestedMerged);
}
+
+ /**
+ * Describes a change to a single fake bidirectional relation.
+ */
+ private static class FakeRelationChange {
+ private final Object owningEntity;
+ private final RelationDescription rd;
+ private final RevisionType revisionType;
+
+ public FakeRelationChange(Object owningEntity, RelationDescription rd, RevisionType revisionType) {
+ this.owningEntity = owningEntity;
+ this.rd = rd;
+ this.revisionType = revisionType;
+ }
+
+ public RevisionType getRevisionType() {
+ return revisionType;
+ }
+
+ public void generateData(SessionImplementor sessionImplementor, Map<String, Object> data) {
+ // If the revision type is "DEL", it means that the object is removed from the collection. Then the
+ // new owner will in fact be null.
+ rd.getFakeBidirectionalRelationMapper().mapToMapFromEntity(sessionImplementor, data,
+ revisionType == RevisionType.DEL ? null : owningEntity, null);
+ }
+
+ public static FakeRelationChange merge(FakeRelationChange first, FakeRelationChange second) {
+ if (first == null) { return second; }
+ if (second == null) { return first; }
+
+ /*
+ * The merging rules are the following (revision types of the first and second changes):
+ * - DEL, DEL - return any (the work units are the same)
+ * - DEL, ADD - return ADD (points to new owner)
+ * - ADD, DEL - return ADD (points to new owner)
+ * - ADD, ADD - return second (points to newer owner)
+ */
+ if (first.getRevisionType() == RevisionType.DEL || second.getRevisionType() == RevisionType.ADD) {
+ return second;
+ } else {
+ return first;
+ }
+ }
+ }
}
Copied: core/trunk/envers/src/test/java/org/hibernate/envers/test/entities/onetomany/detached/DoubleListJoinColumnBidirectionalRefEdEntity1.java (from rev 18224, core/trunk/envers/src/test/java/org/hibernate/envers/test/entities/onetomany/detached/ListJoinColumnBidirectionalRefEdEntity.java)
===================================================================
--- core/trunk/envers/src/test/java/org/hibernate/envers/test/entities/onetomany/detached/DoubleListJoinColumnBidirectionalRefEdEntity1.java (rev 0)
+++ core/trunk/envers/src/test/java/org/hibernate/envers/test/entities/onetomany/detached/DoubleListJoinColumnBidirectionalRefEdEntity1.java 2009-12-15 12:27:01 UTC (rev 18225)
@@ -0,0 +1,85 @@
+package org.hibernate.envers.test.entities.onetomany.detached;
+
+import org.hibernate.envers.Audited;
+
+import javax.persistence.*;
+
+/**
+ * Entity for {@link org.hibernate.envers.test.integration.onetomany.detached.DoubleJoinColumnBidirectionalList} test.
+ * Owned side of the first relation.
+ * @author Adam Warski (adam at warski dot org)
+ */
+ at Entity
+ at Audited
+public class DoubleListJoinColumnBidirectionalRefEdEntity1 {
+ @Id
+ @GeneratedValue
+ private Integer id;
+
+ private String data;
+
+ @ManyToOne
+ @JoinColumn(name = "some_join_column_1", insertable = false, updatable = false)
+ private DoubleListJoinColumnBidirectionalRefIngEntity owner;
+
+ public DoubleListJoinColumnBidirectionalRefEdEntity1() { }
+
+ public DoubleListJoinColumnBidirectionalRefEdEntity1(Integer id, String data, DoubleListJoinColumnBidirectionalRefIngEntity owner) {
+ this.id = id;
+ this.data = data;
+ this.owner = owner;
+ }
+
+ public DoubleListJoinColumnBidirectionalRefEdEntity1(String data, DoubleListJoinColumnBidirectionalRefIngEntity owner) {
+ this.data = data;
+ this.owner = owner;
+ }
+
+ public Integer getId() {
+ return id;
+ }
+
+ public void setId(Integer id) {
+ this.id = id;
+ }
+
+ public String getData() {
+ return data;
+ }
+
+ public void setData(String data) {
+ this.data = data;
+ }
+
+ public DoubleListJoinColumnBidirectionalRefIngEntity getOwner() {
+ return owner;
+ }
+
+ public void setOwner(DoubleListJoinColumnBidirectionalRefIngEntity owner) {
+ this.owner = owner;
+ }
+
+ public boolean equals(Object o) {
+ if (this == o) return true;
+ if (!(o instanceof DoubleListJoinColumnBidirectionalRefEdEntity1)) return false;
+
+ DoubleListJoinColumnBidirectionalRefEdEntity1 that = (DoubleListJoinColumnBidirectionalRefEdEntity1) o;
+
+ if (data != null ? !data.equals(that.data) : that.data != null) return false;
+ //noinspection RedundantIfStatement
+ if (id != null ? !id.equals(that.id) : that.id != null) return false;
+
+ return true;
+ }
+
+ public int hashCode() {
+ int result;
+ result = (id != null ? id.hashCode() : 0);
+ result = 31 * result + (data != null ? data.hashCode() : 0);
+ return result;
+ }
+
+ public String toString() {
+ return "DoubleListJoinColumnBidirectionalRefIngEntity1(id = " + id + ", data = " + data + ")";
+ }
+}
\ No newline at end of file
Added: core/trunk/envers/src/test/java/org/hibernate/envers/test/entities/onetomany/detached/DoubleListJoinColumnBidirectionalRefEdEntity2.java
===================================================================
--- core/trunk/envers/src/test/java/org/hibernate/envers/test/entities/onetomany/detached/DoubleListJoinColumnBidirectionalRefEdEntity2.java (rev 0)
+++ core/trunk/envers/src/test/java/org/hibernate/envers/test/entities/onetomany/detached/DoubleListJoinColumnBidirectionalRefEdEntity2.java 2009-12-15 12:27:01 UTC (rev 18225)
@@ -0,0 +1,85 @@
+package org.hibernate.envers.test.entities.onetomany.detached;
+
+import org.hibernate.envers.Audited;
+
+import javax.persistence.*;
+
+/**
+ * Entity for {@link org.hibernate.envers.test.integration.onetomany.detached.DoubleJoinColumnBidirectionalList} test.
+ * Owned side of the second relation.
+ * @author Adam Warski (adam at warski dot org)
+ */
+ at Entity
+ at Audited
+public class DoubleListJoinColumnBidirectionalRefEdEntity2 {
+ @Id
+ @GeneratedValue
+ private Integer id;
+
+ private String data;
+
+ @ManyToOne
+ @JoinColumn(name = "some_join_column_2", insertable = false, updatable = false)
+ private DoubleListJoinColumnBidirectionalRefIngEntity owner;
+
+ public DoubleListJoinColumnBidirectionalRefEdEntity2() { }
+
+ public DoubleListJoinColumnBidirectionalRefEdEntity2(Integer id, String data, DoubleListJoinColumnBidirectionalRefIngEntity owner) {
+ this.id = id;
+ this.data = data;
+ this.owner = owner;
+ }
+
+ public DoubleListJoinColumnBidirectionalRefEdEntity2(String data, DoubleListJoinColumnBidirectionalRefIngEntity owner) {
+ this.data = data;
+ this.owner = owner;
+ }
+
+ public Integer getId() {
+ return id;
+ }
+
+ public void setId(Integer id) {
+ this.id = id;
+ }
+
+ public String getData() {
+ return data;
+ }
+
+ public void setData(String data) {
+ this.data = data;
+ }
+
+ public DoubleListJoinColumnBidirectionalRefIngEntity getOwner() {
+ return owner;
+ }
+
+ public void setOwner(DoubleListJoinColumnBidirectionalRefIngEntity owner) {
+ this.owner = owner;
+ }
+
+ public boolean equals(Object o) {
+ if (this == o) return true;
+ if (!(o instanceof DoubleListJoinColumnBidirectionalRefEdEntity2)) return false;
+
+ DoubleListJoinColumnBidirectionalRefEdEntity2 that = (DoubleListJoinColumnBidirectionalRefEdEntity2) o;
+
+ if (data != null ? !data.equals(that.data) : that.data != null) return false;
+ //noinspection RedundantIfStatement
+ if (id != null ? !id.equals(that.id) : that.id != null) return false;
+
+ return true;
+ }
+
+ public int hashCode() {
+ int result;
+ result = (id != null ? id.hashCode() : 0);
+ result = 31 * result + (data != null ? data.hashCode() : 0);
+ return result;
+ }
+
+ public String toString() {
+ return "DoubleListJoinColumnBidirectionalRefIngEntity2(id = " + id + ", data = " + data + ")";
+ }
+}
\ No newline at end of file
Copied: core/trunk/envers/src/test/java/org/hibernate/envers/test/entities/onetomany/detached/DoubleListJoinColumnBidirectionalRefIngEntity.java (from rev 18224, core/trunk/envers/src/test/java/org/hibernate/envers/test/entities/onetomany/detached/ListJoinColumnBidirectionalRefIngEntity.java)
===================================================================
--- core/trunk/envers/src/test/java/org/hibernate/envers/test/entities/onetomany/detached/DoubleListJoinColumnBidirectionalRefIngEntity.java (rev 0)
+++ core/trunk/envers/src/test/java/org/hibernate/envers/test/entities/onetomany/detached/DoubleListJoinColumnBidirectionalRefIngEntity.java 2009-12-15 12:27:01 UTC (rev 18225)
@@ -0,0 +1,100 @@
+package org.hibernate.envers.test.entities.onetomany.detached;
+
+import org.hibernate.envers.AuditMappedBy;
+import org.hibernate.envers.Audited;
+
+import javax.persistence.*;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Entity for {@link org.hibernate.envers.test.integration.onetomany.detached.DoubleJoinColumnBidirectionalList} test.
+ * Owning side of the relations.
+ * @author Adam Warski (adam at warski dot org)
+ */
+ at Entity
+ at Audited
+public class DoubleListJoinColumnBidirectionalRefIngEntity {
+ @Id
+ @GeneratedValue
+ private Integer id;
+
+ private String data;
+
+ @OneToMany
+ @JoinColumn(name = "some_join_column_1")
+ @AuditMappedBy(mappedBy = "owner")
+ private List<DoubleListJoinColumnBidirectionalRefEdEntity1> references1 = new ArrayList<DoubleListJoinColumnBidirectionalRefEdEntity1>();
+
+ @OneToMany
+ @JoinColumn(name = "some_join_column_2")
+ @AuditMappedBy(mappedBy = "owner")
+ private List<DoubleListJoinColumnBidirectionalRefEdEntity2> references2 = new ArrayList<DoubleListJoinColumnBidirectionalRefEdEntity2>();
+
+ public DoubleListJoinColumnBidirectionalRefIngEntity() { }
+
+ public DoubleListJoinColumnBidirectionalRefIngEntity(Integer id, String data) {
+ this.id = id;
+ this.data = data;
+ }
+
+ public DoubleListJoinColumnBidirectionalRefIngEntity(String data) {
+ this(null, data);
+ }
+
+ public Integer getId() {
+ return id;
+ }
+
+ public void setId(Integer id) {
+ this.id = id;
+ }
+
+ public String getData() {
+ return data;
+ }
+
+ public void setData(String data) {
+ this.data = data;
+ }
+
+ public List<DoubleListJoinColumnBidirectionalRefEdEntity1> getReferences1() {
+ return references1;
+ }
+
+ public void setReferences1(List<DoubleListJoinColumnBidirectionalRefEdEntity1> references1) {
+ this.references1 = references1;
+ }
+
+ public List<DoubleListJoinColumnBidirectionalRefEdEntity2> getReferences2() {
+ return references2;
+ }
+
+ public void setReferences2(List<DoubleListJoinColumnBidirectionalRefEdEntity2> references2) {
+ this.references2 = references2;
+ }
+
+ public boolean equals(Object o) {
+ if (this == o) return true;
+ if (!(o instanceof DoubleListJoinColumnBidirectionalRefIngEntity)) return false;
+
+ DoubleListJoinColumnBidirectionalRefIngEntity that = (DoubleListJoinColumnBidirectionalRefIngEntity) o;
+
+ if (data != null ? !data.equals(that.data) : that.data != null) return false;
+ //noinspection RedundantIfStatement
+ if (id != null ? !id.equals(that.id) : that.id != null) return false;
+
+ return true;
+ }
+
+ public int hashCode() {
+ int result;
+ result = (id != null ? id.hashCode() : 0);
+ result = 31 * result + (data != null ? data.hashCode() : 0);
+ return result;
+ }
+
+ public String toString() {
+ return "DoubleListJoinColumnBidirectionalRefIngEntity(id = " + id + ", data = " + data + ")";
+ }
+}
\ No newline at end of file
Copied: core/trunk/envers/src/test/java/org/hibernate/envers/test/integration/onetomany/detached/DoubleJoinColumnBidirectionalList.java (from rev 18224, core/trunk/envers/src/test/java/org/hibernate/envers/test/integration/onetomany/detached/JoinColumnBidirectionalList.java)
===================================================================
--- core/trunk/envers/src/test/java/org/hibernate/envers/test/integration/onetomany/detached/DoubleJoinColumnBidirectionalList.java (rev 0)
+++ core/trunk/envers/src/test/java/org/hibernate/envers/test/integration/onetomany/detached/DoubleJoinColumnBidirectionalList.java 2009-12-15 12:27:01 UTC (rev 18225)
@@ -0,0 +1,299 @@
+/*
+ * Hibernate, Relational Persistence for Idiomatic Java
+ *
+ * Copyright (c) 2008, Red Hat Middleware LLC or third-party contributors as
+ * indicated by the @author tags or express copyright attribution
+ * statements applied by the authors. All third-party contributions are
+ * distributed under license by Red Hat Middleware LLC.
+ *
+ * This copyrighted material is made available to anyone wishing to use, modify,
+ * copy, or redistribute it subject to the terms and conditions of the GNU
+ * Lesser General Public License, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
+ * for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this distribution; if not, write to:
+ * Free Software Foundation, Inc.
+ * 51 Franklin Street, Fifth Floor
+ * Boston, MA 02110-1301 USA
+ */
+package org.hibernate.envers.test.integration.onetomany.detached;
+
+import org.hibernate.ejb.Ejb3Configuration;
+import org.hibernate.envers.test.AbstractEntityTest;
+import org.hibernate.envers.test.entities.onetomany.detached.DoubleListJoinColumnBidirectionalRefEdEntity1;
+import org.hibernate.envers.test.entities.onetomany.detached.DoubleListJoinColumnBidirectionalRefEdEntity2;
+import org.hibernate.envers.test.entities.onetomany.detached.DoubleListJoinColumnBidirectionalRefIngEntity;
+import static org.hibernate.envers.test.tools.TestTools.checkList;
+import static org.testng.Assert.assertEquals;
+import static org.testng.Assert.assertTrue;
+import org.testng.annotations.Test;
+
+import javax.persistence.EntityManager;
+import java.util.Arrays;
+
+/**
+ * Test for a double "fake" bidirectional mapping where one side uses @OneToMany+ at JoinColumn
+ * (and thus owns the relation), and the other uses a @ManyToOne(insertable=false, updatable=false).
+ * @author Adam Warski (adam at warski dot org)
+ */
+public class DoubleJoinColumnBidirectionalList extends AbstractEntityTest {
+ private Integer ed1_1_id;
+ private Integer ed2_1_id;
+ private Integer ed1_2_id;
+ private Integer ed2_2_id;
+
+ private Integer ing1_id;
+ private Integer ing2_id;
+
+ public void configure(Ejb3Configuration cfg) {
+ cfg.addAnnotatedClass(DoubleListJoinColumnBidirectionalRefIngEntity.class);
+ cfg.addAnnotatedClass(DoubleListJoinColumnBidirectionalRefEdEntity1.class);
+ cfg.addAnnotatedClass(DoubleListJoinColumnBidirectionalRefEdEntity2.class);
+ }
+
+ @Test(enabled = true)
+ public void createData() {
+ EntityManager em = getEntityManager();
+
+ DoubleListJoinColumnBidirectionalRefEdEntity1 ed1_1 = new DoubleListJoinColumnBidirectionalRefEdEntity1("ed1_1", null);
+ DoubleListJoinColumnBidirectionalRefEdEntity1 ed1_2 = new DoubleListJoinColumnBidirectionalRefEdEntity1("ed1_2", null);
+
+ DoubleListJoinColumnBidirectionalRefEdEntity2 ed2_1 = new DoubleListJoinColumnBidirectionalRefEdEntity2("ed2_1", null);
+ DoubleListJoinColumnBidirectionalRefEdEntity2 ed2_2 = new DoubleListJoinColumnBidirectionalRefEdEntity2("ed2_2", null);
+
+ DoubleListJoinColumnBidirectionalRefIngEntity ing1 = new DoubleListJoinColumnBidirectionalRefIngEntity("coll1");
+ DoubleListJoinColumnBidirectionalRefIngEntity ing2 = new DoubleListJoinColumnBidirectionalRefIngEntity("coll2");
+
+ // Revision 1 (ing1: ed1_1, ed2_1, ing2: ed1_2, ed2_2)
+ em.getTransaction().begin();
+
+ ing1.getReferences1().add(ed1_1);
+ ing1.getReferences2().add(ed2_1);
+
+ ing2.getReferences1().add(ed1_2);
+ ing2.getReferences2().add(ed2_2);
+
+ em.persist(ed1_1);
+ em.persist(ed1_2);
+ em.persist(ed2_1);
+ em.persist(ed2_2);
+ em.persist(ing1);
+ em.persist(ing2);
+
+ em.getTransaction().commit();
+
+ // Revision 2 (ing1: ed1_1, ed1_2, ed2_1, ed2_2)
+ em.getTransaction().begin();
+
+ ing1 = em.find(DoubleListJoinColumnBidirectionalRefIngEntity.class, ing1.getId());
+ ing2 = em.find(DoubleListJoinColumnBidirectionalRefIngEntity.class, ing2.getId());
+ ed1_1 = em.find(DoubleListJoinColumnBidirectionalRefEdEntity1.class, ed1_1.getId());
+ ed1_2 = em.find(DoubleListJoinColumnBidirectionalRefEdEntity1.class, ed1_2.getId());
+ ed2_1 = em.find(DoubleListJoinColumnBidirectionalRefEdEntity2.class, ed2_1.getId());
+ ed2_2 = em.find(DoubleListJoinColumnBidirectionalRefEdEntity2.class, ed2_2.getId());
+
+ ing2.getReferences1().clear();
+ ing2.getReferences2().clear();
+
+ ing1.getReferences1().add(ed1_2);
+ ing1.getReferences2().add(ed2_2);
+
+ em.getTransaction().commit();
+ em.clear();
+
+ // Revision 3 (ing1: ed1_1, ed1_2, ed2_1, ed2_2)
+ em.getTransaction().begin();
+
+ ing1 = em.find(DoubleListJoinColumnBidirectionalRefIngEntity.class, ing1.getId());
+ ing2 = em.find(DoubleListJoinColumnBidirectionalRefIngEntity.class, ing2.getId());
+ ed1_1 = em.find(DoubleListJoinColumnBidirectionalRefEdEntity1.class, ed1_1.getId());
+ ed1_2 = em.find(DoubleListJoinColumnBidirectionalRefEdEntity1.class, ed1_2.getId());
+ ed2_1 = em.find(DoubleListJoinColumnBidirectionalRefEdEntity2.class, ed2_1.getId());
+ ed2_2 = em.find(DoubleListJoinColumnBidirectionalRefEdEntity2.class, ed2_2.getId());
+
+ ed1_1.setData("ed1_1 bis");
+ ed2_2.setData("ed2_2 bis");
+
+ em.getTransaction().commit();
+ em.clear();
+
+ // Revision 4 (ing1: ed2_2, ing2: ed2_1, ed1_1, ed1_2)
+ em.getTransaction().begin();
+
+ ing1 = em.find(DoubleListJoinColumnBidirectionalRefIngEntity.class, ing1.getId());
+ ing2 = em.find(DoubleListJoinColumnBidirectionalRefIngEntity.class, ing2.getId());
+ ed1_1 = em.find(DoubleListJoinColumnBidirectionalRefEdEntity1.class, ed1_1.getId());
+ ed1_2 = em.find(DoubleListJoinColumnBidirectionalRefEdEntity1.class, ed1_2.getId());
+ ed2_1 = em.find(DoubleListJoinColumnBidirectionalRefEdEntity2.class, ed2_1.getId());
+ ed2_2 = em.find(DoubleListJoinColumnBidirectionalRefEdEntity2.class, ed2_2.getId());
+
+ ing1.getReferences1().clear();
+ ing2.getReferences1().add(ed1_1);
+ ing2.getReferences1().add(ed1_2);
+
+ ing1.getReferences2().remove(ed2_1);
+ ing2.getReferences2().add(ed2_1);
+
+ em.getTransaction().commit();
+ em.clear();
+
+ //
+
+ ing1_id = ing1.getId();
+ ing2_id = ing2.getId();
+
+ ed1_1_id = ed1_1.getId();
+ ed1_2_id = ed1_2.getId();
+ ed2_1_id = ed2_1.getId();
+ ed2_2_id = ed2_2.getId();
+ }
+
+ @Test(enabled = true, dependsOnMethods = "createData")
+ public void testRevisionsCounts() {
+ assertEquals(Arrays.asList(1, 2, 4), getAuditReader().getRevisions(DoubleListJoinColumnBidirectionalRefIngEntity.class, ing1_id));
+ assertEquals(Arrays.asList(1, 2, 4), getAuditReader().getRevisions(DoubleListJoinColumnBidirectionalRefIngEntity.class, ing2_id));
+
+ assertEquals(Arrays.asList(1, 3, 4), getAuditReader().getRevisions(DoubleListJoinColumnBidirectionalRefEdEntity1.class, ed1_1_id));
+ assertEquals(Arrays.asList(1, 2, 4), getAuditReader().getRevisions(DoubleListJoinColumnBidirectionalRefEdEntity1.class, ed1_2_id));
+
+ assertEquals(Arrays.asList(1, 4), getAuditReader().getRevisions(DoubleListJoinColumnBidirectionalRefEdEntity2.class, ed2_1_id));
+ assertEquals(Arrays.asList(1, 2, 3), getAuditReader().getRevisions(DoubleListJoinColumnBidirectionalRefEdEntity2.class, ed2_2_id));
+ }
+
+ @Test(enabled = true, dependsOnMethods = "createData")
+ public void testHistoryOfIng1() {
+ DoubleListJoinColumnBidirectionalRefEdEntity1 ed1_1_fromRev1 = new DoubleListJoinColumnBidirectionalRefEdEntity1(ed1_1_id, "ed1_1", null);
+ DoubleListJoinColumnBidirectionalRefEdEntity1 ed1_1_fromRev3 = new DoubleListJoinColumnBidirectionalRefEdEntity1(ed1_1_id, "ed1_1 bis", null);
+ DoubleListJoinColumnBidirectionalRefEdEntity1 ed1_2 = getEntityManager().find(DoubleListJoinColumnBidirectionalRefEdEntity1.class, ed1_2_id);
+ DoubleListJoinColumnBidirectionalRefEdEntity2 ed2_1 = getEntityManager().find(DoubleListJoinColumnBidirectionalRefEdEntity2.class, ed2_1_id);
+ DoubleListJoinColumnBidirectionalRefEdEntity2 ed2_2_fromRev1 = new DoubleListJoinColumnBidirectionalRefEdEntity2(ed2_2_id, "ed2_2", null);
+ DoubleListJoinColumnBidirectionalRefEdEntity2 ed2_2_fromRev3 = new DoubleListJoinColumnBidirectionalRefEdEntity2(ed2_2_id, "ed2_2 bis", null);
+
+ DoubleListJoinColumnBidirectionalRefIngEntity rev1 = getAuditReader().find(DoubleListJoinColumnBidirectionalRefIngEntity.class, ing1_id, 1);
+ DoubleListJoinColumnBidirectionalRefIngEntity rev2 = getAuditReader().find(DoubleListJoinColumnBidirectionalRefIngEntity.class, ing1_id, 2);
+ DoubleListJoinColumnBidirectionalRefIngEntity rev3 = getAuditReader().find(DoubleListJoinColumnBidirectionalRefIngEntity.class, ing1_id, 3);
+ DoubleListJoinColumnBidirectionalRefIngEntity rev4 = getAuditReader().find(DoubleListJoinColumnBidirectionalRefIngEntity.class, ing1_id, 4);
+
+ assertTrue(checkList(rev1.getReferences1(), ed1_1_fromRev1));
+ assertTrue(checkList(rev2.getReferences1(), ed1_1_fromRev1, ed1_2));
+ assertTrue(checkList(rev3.getReferences1(), ed1_1_fromRev3, ed1_2));
+ assertTrue(checkList(rev4.getReferences1()));
+
+ assertTrue(checkList(rev1.getReferences2(), ed2_1));
+ assertTrue(checkList(rev2.getReferences2(), ed2_1, ed2_2_fromRev1));
+ assertTrue(checkList(rev3.getReferences2(), ed2_1, ed2_2_fromRev3));
+ assertTrue(checkList(rev4.getReferences2(), ed2_2_fromRev3));
+ }
+
+ @Test(enabled = true, dependsOnMethods = "createData")
+ public void testHistoryOfIng2() {
+ DoubleListJoinColumnBidirectionalRefEdEntity1 ed1_1_fromRev3 = new DoubleListJoinColumnBidirectionalRefEdEntity1(ed1_1_id, "ed1_1 bis", null);
+ DoubleListJoinColumnBidirectionalRefEdEntity1 ed1_2 = getEntityManager().find(DoubleListJoinColumnBidirectionalRefEdEntity1.class, ed1_2_id);
+ DoubleListJoinColumnBidirectionalRefEdEntity2 ed2_1 = getEntityManager().find(DoubleListJoinColumnBidirectionalRefEdEntity2.class, ed2_1_id);
+ DoubleListJoinColumnBidirectionalRefEdEntity2 ed2_2_fromRev1 = new DoubleListJoinColumnBidirectionalRefEdEntity2(ed2_2_id, "ed2_2", null);
+
+ DoubleListJoinColumnBidirectionalRefIngEntity rev1 = getAuditReader().find(DoubleListJoinColumnBidirectionalRefIngEntity.class, ing2_id, 1);
+ DoubleListJoinColumnBidirectionalRefIngEntity rev2 = getAuditReader().find(DoubleListJoinColumnBidirectionalRefIngEntity.class, ing2_id, 2);
+ DoubleListJoinColumnBidirectionalRefIngEntity rev3 = getAuditReader().find(DoubleListJoinColumnBidirectionalRefIngEntity.class, ing2_id, 3);
+ DoubleListJoinColumnBidirectionalRefIngEntity rev4 = getAuditReader().find(DoubleListJoinColumnBidirectionalRefIngEntity.class, ing2_id, 4);
+
+ assertTrue(checkList(rev1.getReferences1(), ed1_2));
+ assertTrue(checkList(rev2.getReferences1()));
+ assertTrue(checkList(rev3.getReferences1()));
+ assertTrue(checkList(rev4.getReferences1(), ed1_1_fromRev3, ed1_2));
+
+ assertTrue(checkList(rev1.getReferences2(), ed2_2_fromRev1));
+ assertTrue(checkList(rev2.getReferences2()));
+ assertTrue(checkList(rev3.getReferences2()));
+ assertTrue(checkList(rev4.getReferences2(), ed2_1));
+ }
+
+ @Test(enabled = true, dependsOnMethods = "createData")
+ public void testHistoryOfEd1_1() {
+ DoubleListJoinColumnBidirectionalRefIngEntity ing1 = getEntityManager().find(DoubleListJoinColumnBidirectionalRefIngEntity.class, ing1_id);
+ DoubleListJoinColumnBidirectionalRefIngEntity ing2 = getEntityManager().find(DoubleListJoinColumnBidirectionalRefIngEntity.class, ing2_id);
+
+ DoubleListJoinColumnBidirectionalRefEdEntity1 rev1 = getAuditReader().find(DoubleListJoinColumnBidirectionalRefEdEntity1.class, ed1_1_id, 1);
+ DoubleListJoinColumnBidirectionalRefEdEntity1 rev2 = getAuditReader().find(DoubleListJoinColumnBidirectionalRefEdEntity1.class, ed1_1_id, 2);
+ DoubleListJoinColumnBidirectionalRefEdEntity1 rev3 = getAuditReader().find(DoubleListJoinColumnBidirectionalRefEdEntity1.class, ed1_1_id, 3);
+ DoubleListJoinColumnBidirectionalRefEdEntity1 rev4 = getAuditReader().find(DoubleListJoinColumnBidirectionalRefEdEntity1.class, ed1_1_id, 4);
+
+ assertTrue(rev1.getOwner().equals(ing1));
+ assertTrue(rev2.getOwner().equals(ing1));
+ assertTrue(rev3.getOwner().equals(ing1));
+ assertTrue(rev4.getOwner().equals(ing2));
+
+ assertEquals(rev1.getData(), "ed1_1");
+ assertEquals(rev2.getData(), "ed1_1");
+ assertEquals(rev3.getData(), "ed1_1 bis");
+ assertEquals(rev4.getData(), "ed1_1 bis");
+ }
+
+ @Test(enabled = true, dependsOnMethods = "createData")
+ public void testHistoryOfEd1_2() {
+ DoubleListJoinColumnBidirectionalRefIngEntity ing1 = getEntityManager().find(DoubleListJoinColumnBidirectionalRefIngEntity.class, ing1_id);
+ DoubleListJoinColumnBidirectionalRefIngEntity ing2 = getEntityManager().find(DoubleListJoinColumnBidirectionalRefIngEntity.class, ing2_id);
+
+ DoubleListJoinColumnBidirectionalRefEdEntity1 rev1 = getAuditReader().find(DoubleListJoinColumnBidirectionalRefEdEntity1.class, ed1_2_id, 1);
+ DoubleListJoinColumnBidirectionalRefEdEntity1 rev2 = getAuditReader().find(DoubleListJoinColumnBidirectionalRefEdEntity1.class, ed1_2_id, 2);
+ DoubleListJoinColumnBidirectionalRefEdEntity1 rev3 = getAuditReader().find(DoubleListJoinColumnBidirectionalRefEdEntity1.class, ed1_2_id, 3);
+ DoubleListJoinColumnBidirectionalRefEdEntity1 rev4 = getAuditReader().find(DoubleListJoinColumnBidirectionalRefEdEntity1.class, ed1_2_id, 4);
+
+ assertTrue(rev1.getOwner().equals(ing2));
+ assertTrue(rev2.getOwner().equals(ing1));
+ assertTrue(rev3.getOwner().equals(ing1));
+ assertTrue(rev4.getOwner().equals(ing2));
+
+ assertEquals(rev1.getData(), "ed1_2");
+ assertEquals(rev2.getData(), "ed1_2");
+ assertEquals(rev3.getData(), "ed1_2");
+ assertEquals(rev4.getData(), "ed1_2");
+ }
+
+ @Test(enabled = true, dependsOnMethods = "createData")
+ public void testHistoryOfEd2_1() {
+ DoubleListJoinColumnBidirectionalRefIngEntity ing1 = getEntityManager().find(DoubleListJoinColumnBidirectionalRefIngEntity.class, ing1_id);
+ DoubleListJoinColumnBidirectionalRefIngEntity ing2 = getEntityManager().find(DoubleListJoinColumnBidirectionalRefIngEntity.class, ing2_id);
+
+ DoubleListJoinColumnBidirectionalRefEdEntity2 rev1 = getAuditReader().find(DoubleListJoinColumnBidirectionalRefEdEntity2.class, ed2_1_id, 1);
+ DoubleListJoinColumnBidirectionalRefEdEntity2 rev2 = getAuditReader().find(DoubleListJoinColumnBidirectionalRefEdEntity2.class, ed2_1_id, 2);
+ DoubleListJoinColumnBidirectionalRefEdEntity2 rev3 = getAuditReader().find(DoubleListJoinColumnBidirectionalRefEdEntity2.class, ed2_1_id, 3);
+ DoubleListJoinColumnBidirectionalRefEdEntity2 rev4 = getAuditReader().find(DoubleListJoinColumnBidirectionalRefEdEntity2.class, ed2_1_id, 4);
+
+ assertTrue(rev1.getOwner().equals(ing1));
+ assertTrue(rev2.getOwner().equals(ing1));
+ assertTrue(rev3.getOwner().equals(ing1));
+ assertTrue(rev4.getOwner().equals(ing2));
+
+ assertEquals(rev1.getData(), "ed2_1");
+ assertEquals(rev2.getData(), "ed2_1");
+ assertEquals(rev3.getData(), "ed2_1");
+ assertEquals(rev4.getData(), "ed2_1");
+ }
+
+ @Test(enabled = true, dependsOnMethods = "createData")
+ public void testHistoryOfEd2_2() {
+ DoubleListJoinColumnBidirectionalRefIngEntity ing1 = getEntityManager().find(DoubleListJoinColumnBidirectionalRefIngEntity.class, ing1_id);
+ DoubleListJoinColumnBidirectionalRefIngEntity ing2 = getEntityManager().find(DoubleListJoinColumnBidirectionalRefIngEntity.class, ing2_id);
+
+ DoubleListJoinColumnBidirectionalRefEdEntity2 rev1 = getAuditReader().find(DoubleListJoinColumnBidirectionalRefEdEntity2.class, ed2_2_id, 1);
+ DoubleListJoinColumnBidirectionalRefEdEntity2 rev2 = getAuditReader().find(DoubleListJoinColumnBidirectionalRefEdEntity2.class, ed2_2_id, 2);
+ DoubleListJoinColumnBidirectionalRefEdEntity2 rev3 = getAuditReader().find(DoubleListJoinColumnBidirectionalRefEdEntity2.class, ed2_2_id, 3);
+ DoubleListJoinColumnBidirectionalRefEdEntity2 rev4 = getAuditReader().find(DoubleListJoinColumnBidirectionalRefEdEntity2.class, ed2_2_id, 4);
+
+ assertTrue(rev1.getOwner().equals(ing2));
+ assertTrue(rev2.getOwner().equals(ing1));
+ assertTrue(rev3.getOwner().equals(ing1));
+ assertTrue(rev4.getOwner().equals(ing1));
+
+ assertEquals(rev1.getData(), "ed2_2");
+ assertEquals(rev2.getData(), "ed2_2");
+ assertEquals(rev3.getData(), "ed2_2 bis");
+ assertEquals(rev4.getData(), "ed2_2 bis");
+ }
+}
\ No newline at end of file
More information about the hibernate-commits
mailing list