/**
* Copyright (C) 2001-2004 France Telecom R&D
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library 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 library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
package org.objectweb.speedo.runtime.ref;
import javax.jdo.JDOUserException;
import javax.jdo.PersistenceManager;
import junit.framework.Assert;
import org.objectweb.speedo.SpeedoTestHelper;
import org.objectweb.speedo.pobjects.ref.Group;
import org.objectweb.speedo.pobjects.ref.Meeting;
import org.objectweb.speedo.pobjects.ref.Member;
import org.objectweb.speedo.pobjects.ref.President;
/**
*
* @author S.Col
*/
public class TestCascadeDeleteSimpleRef extends SpeedoTestHelper {
public TestCascadeDeleteSimpleRef(String s) {
super(s);
}
protected String getLoggerName() {
return LOG_NAME + "rt.ref.CascadeDeleteSimpleRef";
}
/**
* This method is responsible for the test of the delete of an object that has one-one and one-to-many
* relationships with other classes, but these relationships are empty.
*/
public void testCascadeDeleteOneToNone() {
PersistenceManager pm = pmf.getPersistenceManager();
// We create a group. A group can have a president and many members, but not this one.
String gName = "SpeedoCascade";
Group grp = new Group(gName);
// We make the group persistant
pm.makePersistent(grp);
// Get the id
Object gId = pm.getObjectId(grp);
pm.close();
grp = null;
// Check the creation of the group
pm = pmf.getPersistenceManager();
grp = (Group) pm.getObjectById(gId, true);
Assert.assertNotNull("null instance returned for group", grp);
Assert.assertEquals("Bad group name", gName, grp.getName());
/* Delete the group.
*/
pm.currentTransaction().begin();
pm.deletePersistent(grp);
pm.currentTransaction().commit();
pm.close();
// Check that the group has been deleted
pm = pmf.getPersistenceManager();
try {
grp = (Group) pm.getObjectById(gId, true);
Assert.fail("Should have thrown a JDOUserException : the group has not been deleted");
}
catch (JDOUserException jdoEx) {
// The test has passed
Assert.assertTrue(true);
}
pm.close();
}
/**
* This method is responsible for the test of the cascade delete of a simple reference. A group has a president and if we delete the group,
* the president should be deleted too.
*/
public void testCascadeDeleteOneToOne() {
PersistenceManager pm = pmf.getPersistenceManager();
// A president
String pName = "Boss";
President pres = new President(pName);
// A group
String gName = "SpeedoCascade";
Group grp = new Group(gName, pres);
pres.setGroup(grp);
// We make the group persistant
pm.makePersistent(grp);
// Get the ids
Object gId = pm.getObjectId(grp);
Object pId = pm.getObjectId(grp.getPresident());
pm.close();
grp = null;
pres = null;
// Check the creation of the group and its president
pm = pmf.getPersistenceManager();
grp = (Group) pm.getObjectById(gId, true);
pres = (President) pm.getObjectById(pId, true);
Assert.assertNotNull("null instance returned for group", grp);
Assert.assertEquals("Bad group name", gName, grp.getName());
Assert.assertNotNull("null instance returned for president", pres);
Assert.assertEquals("Bad president name", pName, pres.getName());
/* Delete the group :
* this should delete the president.
*/
pm.currentTransaction().begin();
pm.deletePersistent(grp);
pm.currentTransaction().commit();
pm.close();
// Check that the president has been deleted
pm = pmf.getPersistenceManager();
try {
pres = (President) pm.getObjectById(pId, true);
Assert.fail("Should have thrown a JDOUserException : the president has not been deleted");
}
catch (JDOUserException jdoEx) {
// The test has passed
Assert.assertTrue(true);
}
pm.close();
}
/**
* This method is responsible for the test of the cascade delete of a simple reference. The group has 2 members.
*/
public void testCascadeDeleteOneToTwo() {
PersistenceManager pm = pmf.getPersistenceManager();
// A group
String gName = "SpeedoCascade";
Group grp = new Group(gName);
// Two members
String m1Name = "Jean";
String m2Name = "Sophie";
Member mem1 = new Member(m1Name, grp);
Member mem2 = new Member(m2Name, grp);
// We make the members persistant
pm.makePersistent(mem1);
pm.makePersistent(mem2);
// Get the ids
Object m1Id = pm.getObjectId(mem1);
Object m2Id = pm.getObjectId(mem2);
Object gId = pm.getObjectId(grp);
pm.close();
mem1 = null;
mem2 = null;
grp = null;
// Check the creation of the group and its members
pm = pmf.getPersistenceManager();
mem1 = (Member) pm.getObjectById(m1Id, true);
mem2 = (Member) pm.getObjectById(m2Id, true);
grp = (Group) pm.getObjectById(gId, true);
Assert.assertNotNull("null instance for the member 1", mem1);
Assert.assertEquals("Bad member 1 name", m1Name, mem1.getName());
Assert.assertNotNull("null instance for the member 2", mem2);
Assert.assertEquals("Bad member 2 name", m2Name, mem2.getName());
Assert.assertNotNull("null instance returned for group", grp);
Assert.assertEquals("Bad group name", gName, grp.getName());
/* Delete the group :
* this should delete both members.
*/
pm.currentTransaction().begin();
pm.deletePersistent(grp);
pm.currentTransaction().commit();
pm.close();
// Check that the members have been deleted
pm = pmf.getPersistenceManager();
try {
mem1 = (Member) pm.getObjectById(m1Id, true);
// Delete both members
pm.currentTransaction().begin();
pm.deletePersistent(mem1);
pm.deletePersistent(mem2);
pm.currentTransaction().commit();
Assert.fail("Should have thrown a JDOUserException : member 1 has not been deleted");
}
catch (JDOUserException jdoEx) {
// The test has passed
Assert.assertTrue(true);
}
try {
mem2 = (Member) pm.getObjectById(m2Id, true);
Assert.fail("Should have thrown a JDOUserException : member 2 has not been deleted");
}
catch (JDOUserException jdoEx) {
// The test has passed
Assert.assertTrue(true);
}
pm.close();
}
/**
* This method is responsible for the test of the cascade delete of a simple reference. A group with 10 members.
*/
public void testCascadeDeleteOneToMany() {
PersistenceManager pm = pmf.getPersistenceManager();
// A group
String gName = "SpeedoCascade";
Group grp = new Group(gName);
// Two members
String m1Name = "Jean";
String m2Name = "Sophie";
String m3Name = "Alain";
String m4Name = "Sylvie";
String m5Name = "Jeanne";
String m6Name = "Rose";
String m7Name = "Baptiste";
String m8Name = "Alexandre";
String m9Name = "Noemie";
String m10Name = "Eve";
Member mem1 = new Member(m1Name, grp);
Member mem2 = new Member(m2Name, grp);
Member mem3 = new Member(m3Name, grp);
Member mem4 = new Member(m4Name, grp);
Member mem5 = new Member(m5Name, grp);
Member mem6 = new Member(m6Name, grp);
Member mem7 = new Member(m7Name, grp);
Member mem8 = new Member(m8Name, grp);
Member mem9 = new Member(m9Name, grp);
Member mem10 = new Member(m10Name, grp);
// We make the members persistant
pm.makePersistent(mem1);
pm.makePersistent(mem2);
pm.makePersistent(mem3);
pm.makePersistent(mem4);
pm.makePersistent(mem5);
pm.makePersistent(mem6);
pm.makePersistent(mem7);
pm.makePersistent(mem8);
pm.makePersistent(mem9);
pm.makePersistent(mem10);
// Get the ids
Object m1Id = pm.getObjectId(mem1);
Object m2Id = pm.getObjectId(mem2);
Object m3Id = pm.getObjectId(mem3);
Object m4Id = pm.getObjectId(mem4);
Object m5Id = pm.getObjectId(mem5);
Object m6Id = pm.getObjectId(mem6);
Object m7Id = pm.getObjectId(mem7);
Object m8Id = pm.getObjectId(mem8);
Object m9Id = pm.getObjectId(mem9);
Object m10Id = pm.getObjectId(mem10);
Object gId = pm.getObjectId(grp);
pm.close();
mem1 = null;
mem2 = null;
mem3 = null;
mem4 = null;
mem5 = null;
mem6 = null;
mem7 = null;
mem8 = null;
mem9 = null;
mem10 = null;
grp = null;
// Check the creation of the employee and the department
pm = pmf.getPersistenceManager();
mem1 = (Member) pm.getObjectById(m1Id, true);
mem2 = (Member) pm.getObjectById(m2Id, true);
mem3 = (Member) pm.getObjectById(m3Id, true);
mem4 = (Member) pm.getObjectById(m4Id, true);
mem5 = (Member) pm.getObjectById(m5Id, true);
mem6 = (Member) pm.getObjectById(m6Id, true);
mem7 = (Member) pm.getObjectById(m7Id, true);
mem8 = (Member) pm.getObjectById(m8Id, true);
mem9 = (Member) pm.getObjectById(m9Id, true);
mem10 = (Member) pm.getObjectById(m10Id, true);
grp = (Group) pm.getObjectById(gId, true);
Assert.assertNotNull("null instance for the member 1", mem1);
Assert.assertEquals("Bad member 1 name", m1Name, mem1.getName());
Assert.assertNotNull("null instance for the member 2", mem2);
Assert.assertEquals("Bad member 2 name", m2Name, mem2.getName());
Assert.assertNotNull("null instance for the member 3", mem3);
Assert.assertEquals("Bad member 3 name", m3Name, mem3.getName());
Assert.assertNotNull("null instance for the member 4", mem4);
Assert.assertEquals("Bad member 4 name", m4Name, mem4.getName());
Assert.assertNotNull("null instance for the member 5", mem5);
Assert.assertEquals("Bad member 5 name", m5Name, mem5.getName());
Assert.assertNotNull("null instance for the member 6", mem6);
Assert.assertEquals("Bad member 6 name", m6Name, mem6.getName());
Assert.assertNotNull("null instance for the member 7", mem7);
Assert.assertEquals("Bad member 7 name", m7Name, mem7.getName());
Assert.assertNotNull("null instance for the member 8", mem8);
Assert.assertEquals("Bad member 8 name", m8Name, mem8.getName());
Assert.assertNotNull("null instance for the member 9", mem9);
Assert.assertEquals("Bad member 9 name", m9Name, mem9.getName());
Assert.assertNotNull("null instance for the member 10", mem10);
Assert.assertEquals("Bad member 10 name", m10Name, mem10.getName());
Assert.assertNotNull("null instance returned for group", grp);
Assert.assertEquals("Bad group name", gName, grp.getName());
/* Delete the group :
* this should delete its members too.
*/
pm.currentTransaction().begin();
pm.deletePersistent(grp);
pm.currentTransaction().commit();
pm.close();
// Check that the members have been deleted too
pm = pmf.getPersistenceManager();
try {
mem1 = (Member) pm.getObjectById(m1Id, true);
// Delete all members
pm.currentTransaction().begin();
pm.deletePersistent(mem1);
pm.deletePersistent(mem2);
pm.deletePersistent(mem3);
pm.deletePersistent(mem4);
pm.deletePersistent(mem5);
pm.deletePersistent(mem6);
pm.deletePersistent(mem7);
pm.deletePersistent(mem8);
pm.deletePersistent(mem9);
pm.deletePersistent(mem10);
pm.currentTransaction().commit();
Assert.fail("Should have thrown a JDOUserException : member 1 has not been deleted");
}
catch (JDOUserException jdoEx) {
// The test has passed
}
// Check that the members have been deleted too
try {
mem2 = (Member) pm.getObjectById(m2Id, true);
// Delete all members
pm.currentTransaction().begin();
pm.deletePersistent(mem2);
pm.deletePersistent(mem3);
pm.deletePersistent(mem4);
pm.deletePersistent(mem5);
pm.deletePersistent(mem6);
pm.deletePersistent(mem7);
pm.deletePersistent(mem8);
pm.deletePersistent(mem9);
pm.deletePersistent(mem10);
pm.currentTransaction().commit();
Assert.fail("Should have thrown a JDOUserException : member 2 has not been deleted");
}
catch (JDOUserException jdoEx) {
// The test has passed
}
// Check that the members have been deleted too
try {
mem3 = (Member) pm.getObjectById(m3Id, true);
// Delete all members
pm.currentTransaction().begin();
pm.deletePersistent(mem3);
pm.deletePersistent(mem4);
pm.deletePersistent(mem5);
pm.deletePersistent(mem6);
pm.deletePersistent(mem7);
pm.deletePersistent(mem8);
pm.deletePersistent(mem9);
pm.deletePersistent(mem10);
pm.currentTransaction().commit();
Assert.fail("Should have thrown a JDOUserException : member 3 has not been deleted");
}
catch (JDOUserException jdoEx) {
// The test has passed
}
// Check that the members have been deleted too
try {
mem4 = (Member) pm.getObjectById(m4Id, true);
// Delete all members
pm.currentTransaction().begin();
pm.deletePersistent(mem4);
pm.deletePersistent(mem5);
pm.deletePersistent(mem6);
pm.deletePersistent(mem7);
pm.deletePersistent(mem8);
pm.deletePersistent(mem9);
pm.deletePersistent(mem10);
pm.currentTransaction().commit();
Assert.fail("Should have thrown a JDOUserException : member 4 has not been deleted");
}
catch (JDOUserException jdoEx) {
// The test has passed
}
// Check that the members have been deleted too
try {
mem5 = (Member) pm.getObjectById(m5Id, true);
// Delete all members
pm.currentTransaction().begin();
pm.deletePersistent(mem5);
pm.deletePersistent(mem6);
pm.deletePersistent(mem7);
pm.deletePersistent(mem8);
pm.deletePersistent(mem9);
pm.deletePersistent(mem10);
pm.currentTransaction().commit();
Assert.fail("Should have thrown a JDOUserException : member 5 has not been deleted");
}
catch (JDOUserException jdoEx) {
// The test has passed
}
// Check that the members have been deleted too
try {
mem6 = (Member) pm.getObjectById(m6Id, true);
// Delete all members
pm.currentTransaction().begin();
pm.deletePersistent(mem6);
pm.deletePersistent(mem7);
pm.deletePersistent(mem8);
pm.deletePersistent(mem9);
pm.deletePersistent(mem10);
pm.currentTransaction().commit();
Assert.fail("Should have thrown a JDOUserException : member 6 has not been deleted");
}
catch (JDOUserException jdoEx) {
// The test has passed
}
// Check that the members have been deleted too
try {
mem7 = (Member) pm.getObjectById(m7Id, true);
// Delete all members
pm.currentTransaction().begin();
pm.deletePersistent(mem7);
pm.deletePersistent(mem8);
pm.deletePersistent(mem9);
pm.deletePersistent(mem10);
pm.currentTransaction().commit();
Assert.fail("Should have thrown a JDOUserException : member 7 has not been deleted");
}
catch (JDOUserException jdoEx) {
// The test has passed
}
// Check that the members have been deleted too
try {
mem8 = (Member) pm.getObjectById(m8Id, true);
// Delete all members
pm.currentTransaction().begin();
pm.deletePersistent(mem8);
pm.deletePersistent(mem9);
pm.deletePersistent(mem10);
pm.currentTransaction().commit();
Assert.fail("Should have thrown a JDOUserException : member 8 has not been deleted");
}
catch (JDOUserException jdoEx) {
// The test has passed
}
// Check that the members have been deleted too
try {
mem9 = (Member) pm.getObjectById(m9Id, true);
// Delete all members
pm.currentTransaction().begin();
pm.deletePersistent(mem9);
pm.deletePersistent(mem10);
pm.currentTransaction().commit();
Assert.fail("Should have thrown a JDOUserException : member 9 has not been deleted");
}
catch (JDOUserException jdoEx) {
// The test has passed
}
// Check that the members have been deleted too
try {
mem10 = (Member) pm.getObjectById(m10Id, true);
// Delete all members
pm.currentTransaction().begin();
pm.deletePersistent(mem10);
pm.currentTransaction().commit();
Assert.fail("Should have thrown a JDOUserException : member 10 has not been deleted");
}
catch (JDOUserException jdoEx) {
// The test has passed
Assert.assertTrue(true);
}
pm.close();
}
/**
* This method is responsible for the test of the cascade delete of a simple reference: a map. A group with 5 meetings.
*/
public void testCascadeDeleteMap() {
PersistenceManager pm = pmf.getPersistenceManager();
// A group
String gName = "SpeedoCascade";
Group grp = new Group(gName);
// Five members
Meeting m1 = new Meeting("Meeting1", "Topic1");
Meeting m2 = new Meeting("Meeting2", "Topic2");
Meeting m3 = new Meeting("Meeting3", "Topic3");
Meeting m4 = new Meeting("Meeting4", "Topic4");
Meeting m5 = new Meeting("Meeting5", "Topic5");
// Add four meetings to the group
grp.addMeeting(m1);
grp.addMeeting(m2);
grp.addMeeting(m3);
grp.addMeeting(m4);
//make the group persistent
pm.makePersistent(grp);
pm.makePersistent(m5);
Object m1Id = pm.getObjectId(m1);
Object m2Id = pm.getObjectId(m2);
Object m3Id = pm.getObjectId(m3);
Object m4Id = pm.getObjectId(m4);
Object m5Id = pm.getObjectId(m5);
Object gId = pm.getObjectId(grp);
pm.close();
m1 = null;
m2 = null;
m3 = null;
m4 = null;
m5 = null;
grp = null;
pm = pmf.getPersistenceManager();
// Check the creation of the meetings
m1 = (Meeting) pm.getObjectById(m1Id, true);
m2 = (Meeting) pm.getObjectById(m2Id, true);
m3 = (Meeting) pm.getObjectById(m3Id, true);
m4 = (Meeting) pm.getObjectById(m4Id, true);
m5 = (Meeting) pm.getObjectById(m5Id, true);
grp = (Group) pm.getObjectById(gId, true);
Assert.assertNotNull("null instance for the meeting 1", m1);
Assert.assertNotNull("null instance for the meeting 2", m2);
Assert.assertNotNull("null instance for the meeting 3", m3);
Assert.assertNotNull("null instance for the meeting 4", m4);
Assert.assertNotNull("null instance for the meeting 5", m5);
Assert.assertNotNull("null instance returned for group", grp);
Assert.assertEquals("Bad group name", gName, grp.getName());
/* Delete the group :
* this should delete its meetings too.
*/
pm.currentTransaction().begin();
pm.deletePersistent(grp);
pm.currentTransaction().commit();
pm.close();
// Check that the meetings have been deleted too
//excepting the fifth one, that was not part of the group
pm = pmf.getPersistenceManager();
try {
m1 = (Meeting) pm.getObjectById(m1Id, true);
// Delete all meetings => throw an exception
pm.currentTransaction().begin();
pm.deletePersistent(m1);
pm.deletePersistent(m2);
pm.deletePersistent(m3);
pm.deletePersistent(m4);
pm.deletePersistent(m5);
pm.currentTransaction().commit();
Assert.fail("Should have thrown a JDOUserException : member 1 has not been deleted");
}
catch (JDOUserException jdoEx) {
// The test has passed
}
try {
m2 = (Meeting) pm.getObjectById(m2Id, true);
// Delete all meetings => throw an exception
pm.currentTransaction().begin();
pm.deletePersistent(m2);
pm.deletePersistent(m3);
pm.deletePersistent(m4);
pm.deletePersistent(m5);
pm.currentTransaction().commit();
Assert.fail("Should have thrown a JDOUserException : member 2 has not been deleted");
}
catch (JDOUserException jdoEx) {
// The test has passed
}
try {
m3 = (Meeting) pm.getObjectById(m3Id, true);
// Delete all meetings => throw an exception
pm.currentTransaction().begin();
pm.deletePersistent(m3);
pm.deletePersistent(m4);
pm.deletePersistent(m5);
pm.currentTransaction().commit();
Assert.fail("Should have thrown a JDOUserException : member 3 has not been deleted");
}
catch (JDOUserException jdoEx) {
// The test has passed
}
try {
m4 = (Meeting) pm.getObjectById(m4Id, true);
// Delete all meetings => throw an exception
pm.currentTransaction().begin();
pm.deletePersistent(m4);
pm.deletePersistent(m5);
pm.currentTransaction().commit();
Assert.fail("Should have thrown a JDOUserException : member 4 has not been deleted");
}
catch (JDOUserException jdoEx) {
// The test has passed
}
try {
m5 = (Meeting) pm.getObjectById(m5Id, true);
Assert.assertNotNull("null instance for the meeting 5", m5);
// Delete all meetings => throw an exception
pm.currentTransaction().begin();
pm.deletePersistent(m5);
pm.currentTransaction().commit();
}
catch (JDOUserException jdoEx) {
Assert.fail("Deletion of meeting 5 should not be a problem.");
}
pm.close();
}
}