Author: athimel Date: 2012-07-09 16:52:49 +0200 (Mon, 09 Jul 2012) New Revision: 2605 Url: http://nuiton.org/repositories/revision/topia/2605 Log: Add tests about association classes Added: trunk/topia-persistence-tck/src/test/java/org/nuiton/topia/tck/mapping/test14/ trunk/topia-persistence-tck/src/test/java/org/nuiton/topia/tck/mapping/test14/BidiAssociationClassTest.java trunk/topia-persistence-tck/src/test/java/org/nuiton/topia/tck/mapping/test14/ManyToManyAssociationClassTest.java trunk/topia-persistence-tck/src/test/java/org/nuiton/topia/tck/mapping/test14/OneToManyAssociationClassTest.java Added: trunk/topia-persistence-tck/src/test/java/org/nuiton/topia/tck/mapping/test14/BidiAssociationClassTest.java =================================================================== --- trunk/topia-persistence-tck/src/test/java/org/nuiton/topia/tck/mapping/test14/BidiAssociationClassTest.java (rev 0) +++ trunk/topia-persistence-tck/src/test/java/org/nuiton/topia/tck/mapping/test14/BidiAssociationClassTest.java 2012-07-09 14:52:49 UTC (rev 2605) @@ -0,0 +1,140 @@ +package org.nuiton.topia.tck.mapping.test14; + +import org.junit.Assert; +import org.junit.Before; +import org.junit.Ignore; +import org.junit.Test; +import org.nuiton.topia.TopiaContext; +import org.nuiton.topia.TopiaException; +import org.nuiton.topia.persistence.TopiaPersistenceException; +import org.nuiton.topia.tck.mapping.AbstractMappingTest; + +import java.util.List; + +/** + * @author Arnaud Thimel <thimel@codelutin.com> + */ +public class BidiAssociationClassTest extends AbstractMappingTest { + + protected TopiaContext tx; + + protected A14ADAO aDAO; + + protected B14ADAO bDAO; + + protected Assoc14ADAO assocDAO; + + @Before + public void before() throws TopiaException { + tx = db.beginTransaction(); + aDAO = getDAO(tx, A14A.class); + bDAO = getDAO(tx, B14A.class); + assocDAO = getDAO(tx, Assoc14A.class); + } + + @Test + public void testCreate() throws TopiaException { + + A14A a = aDAO.create(); + B14A b = bDAO.create(); + + Assoc14A assoc = assocDAO.create(Assoc14A.PROPERTY_A14_A, a, Assoc14A.PROPERTY_ROLE_B, b); + tx.commitTransaction(); + Assert.assertNotNull(assoc.getTopiaId()); + + Assoc14A assocFound = assocDAO.findByTopiaId(assoc.getTopiaId()); + A14A aFound = assocFound.getA14A(); + B14A bFound = assocFound.getRoleB(); + + Assert.assertNotNull(aFound); + Assert.assertEquals(a, aFound); + Assert.assertNotNull(bFound); + Assert.assertEquals(b, bFound); + } + + @Test(expected = TopiaPersistenceException.class) + public void testCreateWithNull() throws TopiaException { + + A14A a = aDAO.create(); + + Assert.assertNotNull(a.getTopiaId()); + + Assoc14A assoc = assocDAO.create(Assoc14A.PROPERTY_A14_A, a); + Assert.assertNotNull(assoc.getTopiaId()); + + // Will throw an exception because 'b' is mandatory + tx.commitTransaction(); + } + + @Test + public void testFindAll() throws TopiaException { + + A14A a1 = aDAO.create(); + A14A a2 = aDAO.create(); + B14A b = bDAO.create(); + + Assoc14A assoc = assocDAO.create(Assoc14A.PROPERTY_A14_A, a1, Assoc14A.PROPERTY_ROLE_B, b); + a1.setRoleB(assoc); + aDAO.update(a1); + b.setA14AAssoc14A(assoc); + bDAO.update(b); + + tx.commitTransaction(); + + A14A aFound = aDAO.findByAssoc14A(assoc); + Assert.assertEquals(a1, aFound); + + aFound = aDAO.findByRoleB(b); + Assert.assertEquals(a1, aFound); + + B14A bFound = bDAO.findByA14A(a1); + Assert.assertEquals(b, bFound); + + bFound = bDAO.findByA14A(a2); + Assert.assertNull(bFound); + + bFound = bDAO.findByAssoc14A(assoc); + Assert.assertEquals(b, bFound); + + } + + @Test + @Ignore //FIXME AThimel 09/07/2012 Test is ignored as cascade-delete does not work as expected + public void testDeleteCascade() throws TopiaException { + + A14A a1 = aDAO.create(); + A14A a2 = aDAO.create(); + B14A b1 = bDAO.create(); + B14A b2 = bDAO.create(); + + Assoc14A assoc11 = assocDAO.create(Assoc14A.PROPERTY_A14_A, a1, Assoc14A.PROPERTY_ROLE_B, b1); + Assoc14A assoc22 = assocDAO.create(Assoc14A.PROPERTY_A14_A, a2, Assoc14A.PROPERTY_ROLE_B, b2); + + a1.setRoleB(assoc11); + a2.setRoleB(assoc22); + b1.setA14AAssoc14A(assoc11); + b2.setA14AAssoc14A(assoc22); + + aDAO.update(a1); + aDAO.update(a2); + bDAO.update(b1); + bDAO.update(b2); + + tx.commitTransaction(); + + Assert.assertEquals(2, assocDAO.count()); + + aDAO.delete(a1); + + tx.commitTransaction(); + + Assert.assertEquals(1, assocDAO.count()); + + List<Assoc14A> all = assocDAO.findAll(); + Assert.assertEquals(1, all.size()); + Assoc14A first = all.iterator().next(); + Assert.assertEquals(a2, first.getA14A()); + Assert.assertEquals(b2, first.getRoleB()); + } + +} Added: trunk/topia-persistence-tck/src/test/java/org/nuiton/topia/tck/mapping/test14/ManyToManyAssociationClassTest.java =================================================================== --- trunk/topia-persistence-tck/src/test/java/org/nuiton/topia/tck/mapping/test14/ManyToManyAssociationClassTest.java (rev 0) +++ trunk/topia-persistence-tck/src/test/java/org/nuiton/topia/tck/mapping/test14/ManyToManyAssociationClassTest.java 2012-07-09 14:52:49 UTC (rev 2605) @@ -0,0 +1,139 @@ +package org.nuiton.topia.tck.mapping.test14; + +import org.junit.Assert; +import org.junit.Before; +import org.junit.Ignore; +import org.junit.Test; +import org.nuiton.topia.TopiaContext; +import org.nuiton.topia.TopiaException; +import org.nuiton.topia.tck.mapping.AbstractMappingTest; + +import java.util.List; + +/** + * @author Arnaud Thimel <thimel@codelutin.com> + */ +public class ManyToManyAssociationClassTest extends AbstractMappingTest { + + protected TopiaContext tx; + + protected A14DDAO aDAO; + + protected B14DDAO bDAO; + + protected Assoc14DDAO assocDAO; + + @Before + public void before() throws TopiaException { + tx = db.beginTransaction(); + aDAO = getDAO(tx, A14D.class); + bDAO = getDAO(tx, B14D.class); + assocDAO = getDAO(tx, Assoc14D.class); + } + + @Test + public void testCreate() throws TopiaException { + + A14D a = aDAO.create(); + B14D b = bDAO.create(); + + Assoc14D assoc = assocDAO.create(Assoc14D.PROPERTY_ROLE_A, a, Assoc14D.PROPERTY_B14_D, b); + a.addB14DAssoc14D(assoc); + b.addRoleA(assoc); + aDAO.update(a); + bDAO.update(b); + tx.commitTransaction(); + + + Assoc14D assocFound = assocDAO.findByTopiaId(assoc.getTopiaId()); + A14D aFound = assocFound.getRoleA(); + Assert.assertEquals(a, aFound); + B14D bFound = assocFound.getB14D(); + Assert.assertEquals(b, bFound); + + Assert.assertEquals(1, aFound.sizeB14DAssoc14D()); + Assert.assertEquals(1, bFound.sizeRoleA()); + + } + + + @Test + public void testFindAll() throws TopiaException { + + A14D a1 = aDAO.create(); + A14D a2 = aDAO.create(); + B14D b1 = bDAO.create(); + B14D b2 = bDAO.create(); + + Assoc14D assoc11 = assocDAO.create(Assoc14D.PROPERTY_ROLE_A, a1, Assoc14D.PROPERTY_B14_D, b1); + Assoc14D assoc12 = assocDAO.create(Assoc14D.PROPERTY_ROLE_A, a1, Assoc14D.PROPERTY_B14_D, b2); + Assoc14D assoc21 = assocDAO.create(Assoc14D.PROPERTY_ROLE_A, a2, Assoc14D.PROPERTY_B14_D, b1); + + a1.addB14DAssoc14D(assoc11); + a1.addB14DAssoc14D(assoc12); + a2.addB14DAssoc14D(assoc21); + b1.addRoleA(assoc11); + b1.addRoleA(assoc21); + b2.addRoleA(assoc12); + + aDAO.update(a1); + aDAO.update(a2); + bDAO.update(b1); + bDAO.update(b2); + + tx.commitTransaction(); + + Assert.assertEquals(3, assocDAO.count()); + + List<Assoc14D> allByB14D = assocDAO.findAllByB14D(b1); + Assert.assertEquals(2, allByB14D.size()); + + List<Assoc14D> allByRoleA = assocDAO.findAllByRoleA(a2); + Assert.assertEquals(1, allByRoleA.size()); + + } + + @Test + @Ignore + //FIXME AThimel 09/07/2012 Test is ignored as cascade-delete does not work as expected + public void testDeleteCascade() throws TopiaException { + + A14D a1 = aDAO.create(); + A14D a2 = aDAO.create(); + B14D b1 = bDAO.create(); + B14D b2 = bDAO.create(); + + Assoc14D assoc11 = assocDAO.create(Assoc14D.PROPERTY_ROLE_A, a1, Assoc14D.PROPERTY_B14_D, b1); + Assoc14D assoc12 = assocDAO.create(Assoc14D.PROPERTY_ROLE_A, a1, Assoc14D.PROPERTY_B14_D, b2); + Assoc14D assoc21 = assocDAO.create(Assoc14D.PROPERTY_ROLE_A, a2, Assoc14D.PROPERTY_B14_D, b1); + + a1.addB14DAssoc14D(assoc11); + a1.addB14DAssoc14D(assoc12); + a2.addB14DAssoc14D(assoc21); + b1.addRoleA(assoc11); + b1.addRoleA(assoc21); + b2.addRoleA(assoc12); + + aDAO.update(a1); + aDAO.update(a2); + bDAO.update(b1); + bDAO.update(b2); + + tx.commitTransaction(); + + Assert.assertEquals(3, assocDAO.count()); + + aDAO.delete(a1); + + tx.commitTransaction(); + + Assert.assertEquals(1, assocDAO.count()); + + List<Assoc14D> all = assocDAO.findAll(); + Assert.assertEquals(1, all.size()); + Assoc14D first = all.iterator().next(); + Assert.assertEquals(a2, first.getRoleA()); + Assert.assertEquals(b1, first.getB14D()); + } + +} Added: trunk/topia-persistence-tck/src/test/java/org/nuiton/topia/tck/mapping/test14/OneToManyAssociationClassTest.java =================================================================== --- trunk/topia-persistence-tck/src/test/java/org/nuiton/topia/tck/mapping/test14/OneToManyAssociationClassTest.java (rev 0) +++ trunk/topia-persistence-tck/src/test/java/org/nuiton/topia/tck/mapping/test14/OneToManyAssociationClassTest.java 2012-07-09 14:52:49 UTC (rev 2605) @@ -0,0 +1,101 @@ +package org.nuiton.topia.tck.mapping.test14; + +import org.junit.Assert; +import org.junit.Before; +import org.junit.Test; +import org.nuiton.topia.TopiaContext; +import org.nuiton.topia.TopiaException; +import org.nuiton.topia.tck.mapping.AbstractMappingTest; + +import java.util.List; + +/** + * @author Arnaud Thimel <thimel@codelutin.com> + */ +public class OneToManyAssociationClassTest extends AbstractMappingTest { + + protected TopiaContext tx; + + protected A14CDAO aDAO; + + protected B14CDAO bDAO; + + protected Assoc14CDAO assocDAO; + + @Before + public void before() throws TopiaException { + tx = db.beginTransaction(); + aDAO = getDAO(tx, A14C.class); + bDAO = getDAO(tx, B14C.class); + assocDAO = getDAO(tx, Assoc14C.class); + } + + @Test + public void testCreate() throws TopiaException { + + A14C a = aDAO.create(); + B14C b = bDAO.create(); + + Assoc14C assoc = assocDAO.create(Assoc14C.PROPERTY_A14_C, a, Assoc14C.PROPERTY_B14_C, b); + a.addB14CAssoc14C(assoc); + b.setA14CAssoc14C(assoc); + aDAO.update(a); + bDAO.update(b); + tx.commitTransaction(); + + + Assoc14C assocFound = assocDAO.findByTopiaId(assoc.getTopiaId()); + A14C aFound = assocFound.getA14C(); + Assert.assertEquals(a, aFound); + Assert.assertEquals(b, assocFound.getB14C()); + + Assert.assertEquals(1, aFound.sizeB14CAssoc14C()); + Assert.assertEquals(b, aFound.getB14CAssoc14C().iterator().next().getB14C()); + + } + + + @Test + public void testFindAll() throws TopiaException { + + A14C a = aDAO.create(); + B14C b1 = bDAO.create(); + B14C b2 = bDAO.create(); + + Assoc14C assoc1 = assocDAO.create(Assoc14C.PROPERTY_A14_C, a, Assoc14C.PROPERTY_B14_C, b1); + a.addB14CAssoc14C(assoc1); + b1.setA14CAssoc14C(assoc1); + aDAO.update(a); + bDAO.update(b1); + + tx.commitTransaction(); + + List<B14C> allByA14C = bDAO.findAllByA14C(a); + Assert.assertEquals(1, allByA14C.size()); + Assert.assertEquals(b1, allByA14C.iterator().next()); + + B14C bFound = bDAO.findByAssoc14C(assoc1); + Assert.assertEquals(b1, bFound); + + Assoc14C assoc2 = assocDAO.create(Assoc14C.PROPERTY_A14_C, a, Assoc14C.PROPERTY_B14_C, b2); + a.addB14CAssoc14C(assoc2); + b2.setA14CAssoc14C(assoc2); + + aDAO.update(a); + bDAO.update(b2); + + tx.commitTransaction(); + + bFound = bDAO.findByAssoc14C(assoc1); + Assert.assertEquals(b1, bFound); + bFound = bDAO.findByAssoc14C(assoc2); + Assert.assertEquals(b2, bFound); + + allByA14C = bDAO.findAllByA14C(a); + Assert.assertEquals(2, allByA14C.size()); + A14C aFound = allByA14C.iterator().next().getA14CAssoc14C().getA14C(); + Assert.assertEquals(2, aFound.sizeB14CAssoc14C()); + + } + +}