From a4124b4743fefc0e755c9def9d6171cac17722bd Mon Sep 17 00:00:00 2001 From: Jeremy Bauer Date: Wed, 25 Mar 2009 21:43:57 +0000 Subject: [PATCH] OPENJPA-885 Committing additional detach tests contributed by Dianne Richards git-svn-id: https://svn.apache.org/repos/asf/openjpa/trunk@758442 13f79535-47bb-0310-9956-ffa450edef68 --- .../openjpa/persistence/detach/EntityA.java | 156 +++++++++++++++ .../openjpa/persistence/detach/EntityB.java | 57 ++++++ .../openjpa/persistence/detach/EntityC.java | 57 ++++++ .../openjpa/persistence/detach/EntityD.java | 57 ++++++ .../openjpa/persistence/detach/EntityE.java | 57 ++++++ .../detach/TestDetachStateCascade.java | 189 ++++++++++++++++++ 6 files changed, 573 insertions(+) create mode 100644 openjpa-persistence-jdbc/src/test/java/org/apache/openjpa/persistence/detach/EntityA.java create mode 100644 openjpa-persistence-jdbc/src/test/java/org/apache/openjpa/persistence/detach/EntityB.java create mode 100644 openjpa-persistence-jdbc/src/test/java/org/apache/openjpa/persistence/detach/EntityC.java create mode 100644 openjpa-persistence-jdbc/src/test/java/org/apache/openjpa/persistence/detach/EntityD.java create mode 100644 openjpa-persistence-jdbc/src/test/java/org/apache/openjpa/persistence/detach/EntityE.java create mode 100644 openjpa-persistence-jdbc/src/test/java/org/apache/openjpa/persistence/detach/TestDetachStateCascade.java diff --git a/openjpa-persistence-jdbc/src/test/java/org/apache/openjpa/persistence/detach/EntityA.java b/openjpa-persistence-jdbc/src/test/java/org/apache/openjpa/persistence/detach/EntityA.java new file mode 100644 index 000000000..085e3943f --- /dev/null +++ b/openjpa-persistence-jdbc/src/test/java/org/apache/openjpa/persistence/detach/EntityA.java @@ -0,0 +1,156 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ +package org.apache.openjpa.persistence.detach; + +import javax.persistence.Basic; +import javax.persistence.CascadeType; +import javax.persistence.Entity; +import javax.persistence.FetchType; +import javax.persistence.Id; +import javax.persistence.OneToOne; +import javax.persistence.Table; + +import org.apache.openjpa.persistence.FetchAttribute; +import org.apache.openjpa.persistence.FetchGroup; +import org.apache.openjpa.persistence.FetchGroups; + +@Entity +@Table(name="EntityA_detach") +@FetchGroups({ + @FetchGroup(name = "loadD", attributes = { + @FetchAttribute(name = "entityD", recursionDepth = 0) + }) + }) +public class EntityA { + @Id + private long id; + + private String name; + + @Basic(fetch=FetchType.LAZY) + private String description; + + @OneToOne(cascade=(CascadeType.ALL)) + EntityB entityB; + + @OneToOne(cascade=(CascadeType.PERSIST)) + EntityC entityC; + + @OneToOne(cascade=(CascadeType.ALL), fetch=FetchType.LAZY) + EntityD entityD; + + @OneToOne(cascade=(CascadeType.PERSIST), fetch=FetchType.LAZY) + EntityE entityE; + + public EntityA() { + } + + public EntityA(long id, String name, String description) { + this.id = id; + this.name = name; + this.description = description; + } + + public long getId() { + return id; + } + + public void setId(long id) { + this.id = id; + } + + public String getName() { + return name; + } + + public void setName(String name) { + this.name = name; + } + + /** + * @return the description + */ + public String getDescription() { + return description; + } + + /** + * @param description the description to set + */ + public void setDescription(String description) { + this.description = description; + } + + /** + * @return the entityB + */ + public EntityB getEntityB() { + return entityB; + } + + /** + * @param entityB the entityB to set + */ + public void setEntityB(EntityB entityB) { + this.entityB = entityB; + } + + /** + * @return the entityC + */ + public EntityC getEntityC() { + return entityC; + } + + /** + * @param entityC the entityC to set + */ + public void setEntityC(EntityC entityC) { + this.entityC = entityC; + } + + /** + * @return the entityD + */ + public EntityD getEntityD() { + return entityD; + } + + /** + * @param entityD the entityD to set + */ + public void setEntityD(EntityD entityD) { + this.entityD = entityD; + } + + /** + * @return the entityE + */ + public EntityE getEntityE() { + return entityE; + } + + /** + * @param entityE the entityE to set + */ + public void setEntityE(EntityE entityE) { + this.entityE = entityE; + } + +} diff --git a/openjpa-persistence-jdbc/src/test/java/org/apache/openjpa/persistence/detach/EntityB.java b/openjpa-persistence-jdbc/src/test/java/org/apache/openjpa/persistence/detach/EntityB.java new file mode 100644 index 000000000..84eaafe9c --- /dev/null +++ b/openjpa-persistence-jdbc/src/test/java/org/apache/openjpa/persistence/detach/EntityB.java @@ -0,0 +1,57 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ +package org.apache.openjpa.persistence.detach; + +import javax.persistence.Entity; +import javax.persistence.Id; +import javax.persistence.Table; + +@Entity +@Table(name="EntityB_detach") +public class EntityB { + @Id + private long id; + + private String name; + + public EntityB() { + } + + public EntityB(long id, String name) { + this.id = id; + this.name = name; + } + + public long getId() { + return id; + } + + public void setId(long id) { + this.id = id; + } + + public String getName() { + return name; + } + + public void setName(String name) { + this.name = name; + } + +} diff --git a/openjpa-persistence-jdbc/src/test/java/org/apache/openjpa/persistence/detach/EntityC.java b/openjpa-persistence-jdbc/src/test/java/org/apache/openjpa/persistence/detach/EntityC.java new file mode 100644 index 000000000..5a56fdc04 --- /dev/null +++ b/openjpa-persistence-jdbc/src/test/java/org/apache/openjpa/persistence/detach/EntityC.java @@ -0,0 +1,57 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ +package org.apache.openjpa.persistence.detach; + +import javax.persistence.Entity; +import javax.persistence.Id; +import javax.persistence.Table; + +@Entity +@Table(name="EntityC_detach") +public class EntityC { + @Id + private long id; + + private String name; + + public EntityC() { + } + + public EntityC(long id, String name) { + this.id = id; + this.name = name; + } + + public long getId() { + return id; + } + + public void setId(long id) { + this.id = id; + } + + public String getName() { + return name; + } + + public void setName(String name) { + this.name = name; + } + +} diff --git a/openjpa-persistence-jdbc/src/test/java/org/apache/openjpa/persistence/detach/EntityD.java b/openjpa-persistence-jdbc/src/test/java/org/apache/openjpa/persistence/detach/EntityD.java new file mode 100644 index 000000000..0e8e343a6 --- /dev/null +++ b/openjpa-persistence-jdbc/src/test/java/org/apache/openjpa/persistence/detach/EntityD.java @@ -0,0 +1,57 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ +package org.apache.openjpa.persistence.detach; + +import javax.persistence.Entity; +import javax.persistence.Id; +import javax.persistence.Table; + +@Entity +@Table(name="EntityD_detach") +public class EntityD { + @Id + private long id; + + private String name; + + public EntityD() { + } + + public EntityD(long id, String name) { + this.id = id; + this.name = name; + } + + public long getId() { + return id; + } + + public void setId(long id) { + this.id = id; + } + + public String getName() { + return name; + } + + public void setName(String name) { + this.name = name; + } + +} diff --git a/openjpa-persistence-jdbc/src/test/java/org/apache/openjpa/persistence/detach/EntityE.java b/openjpa-persistence-jdbc/src/test/java/org/apache/openjpa/persistence/detach/EntityE.java new file mode 100644 index 000000000..97afff365 --- /dev/null +++ b/openjpa-persistence-jdbc/src/test/java/org/apache/openjpa/persistence/detach/EntityE.java @@ -0,0 +1,57 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ +package org.apache.openjpa.persistence.detach; + +import javax.persistence.Entity; +import javax.persistence.Id; +import javax.persistence.Table; + +@Entity +@Table(name="EntityE_detach") +public class EntityE { + @Id + private long id; + + private String name; + + public EntityE() { + } + + public EntityE(long id, String name) { + this.id = id; + this.name = name; + } + + public long getId() { + return id; + } + + public void setId(long id) { + this.id = id; + } + + public String getName() { + return name; + } + + public void setName(String name) { + this.name = name; + } + +} diff --git a/openjpa-persistence-jdbc/src/test/java/org/apache/openjpa/persistence/detach/TestDetachStateCascade.java b/openjpa-persistence-jdbc/src/test/java/org/apache/openjpa/persistence/detach/TestDetachStateCascade.java new file mode 100644 index 000000000..a71b4fb3d --- /dev/null +++ b/openjpa-persistence-jdbc/src/test/java/org/apache/openjpa/persistence/detach/TestDetachStateCascade.java @@ -0,0 +1,189 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ +package org.apache.openjpa.persistence.detach; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.HashSet; +import java.util.List; + +import org.apache.openjpa.conf.Compatibility; +import org.apache.openjpa.persistence.DetachStateType; +import org.apache.openjpa.persistence.OpenJPAEntityManager; +import org.apache.openjpa.persistence.test.SingleEMFTestCase; + +/** + * Test the various options for openjpa.DetachState with the new DETACH + * cascade option. + * + * @author dianner + * @since 2.0.0 + * + */ +public class TestDetachStateCascade extends SingleEMFTestCase { + OpenJPAEntityManager em; + int id = 0; + Compatibility compat; + + EntityA entityA; + EntityB entityB; + EntityC entityC; + EntityD entityD; + EntityE entityE; + + List list = new ArrayList(); + + Collection allEntities = new HashSet(); + + public void setUp() throws Exception { + setUp(org.apache.openjpa.persistence.detach.EntityA.class, + org.apache.openjpa.persistence.detach.EntityB.class, + org.apache.openjpa.persistence.detach.EntityC.class, + org.apache.openjpa.persistence.detach.EntityD.class, + org.apache.openjpa.persistence.detach.EntityE.class); + assertNotNull(emf); + em = emf.createEntityManager(); + assertNotNull(em); + compat = emf.getConfiguration().getCompatibilityInstance(); + assertNotNull(compat); + id++; + create(id); + + em.getTransaction().begin(); + em.persist(entityA); + em.getTransaction().commit(); + } + + private void create(int id) { + entityA = new EntityA(id, "entityA", "top level class"); + entityB = new EntityB(id, "entityB"); + entityC = new EntityC(id, "entityC"); + entityD = new EntityD(id, "entityD"); + entityE = new EntityE(id, "entityE"); + + entityA.setEntityB(entityB); + entityA.setEntityC(entityC); + entityA.setEntityD(entityD); + entityA.setEntityE(entityE); + } + + + + /** + * The default DetachState of LOADED is tested. In this scenario: + * A is the main entity to be detached + * B is loaded and DETACH cascade is specified + * C is loaded but DETACH cascade is NOT specified + * D is not loaded and DETACH cascade is specified + * E is not loaded but DETACH cascade is NOT specified + */ + public void testLoaded() { + em.getTransaction().begin(); + // Clear the persistence context so we start fresh + em.persist(entityA); + em.clear(); + EntityA eA = em.find(EntityA.class, id); // Loads B and C by default + assertTrue(em.contains(eA)); + EntityD eD = em.find(EntityD.class, id); // Load independently + assertTrue(em.contains(eD)); + EntityE eE = em.find(EntityE.class, id); // Load independently + assertTrue(em.contains(eE)); + EntityA entityADet = em.detach(eA); + assertEquals(id, entityADet.getId()); + assertEquals("entityA", entityADet.getName()); + assertNull(entityADet.getDescription()); // should not be loaded + assertNotNull(entityADet.getEntityB()); + assertNotNull(entityADet.getEntityC()); + assertNull(entityADet.getEntityD()); + assertNull(entityADet.getEntityE()); + assertTrue(em.isDetached(eA)); + assertTrue(em.isDetached(entityADet.getEntityB())); + assertFalse(em.isDetached(entityADet.getEntityC())); + assertFalse(em.isDetached(eD)); + assertFalse(em.isDetached(eE)); + em.getTransaction().commit(); + } + + /** + * The DetachState of ALL is tested. In this scenario: + * A is the main entity to be detached. + * B, C, D, and E are all loaded + * DETACH cascade is specified for B and D + * DETACH cascade is NOT specified for C and E + */ + public void testDetachStateAll() { + em.setDetachState(DetachStateType.ALL); + em.getTransaction().begin(); + // Clear the persistence context so we start fresh + em.persist(entityA); + em.clear(); + EntityA eA = em.find(EntityA.class, id); + assertTrue(em.contains(eA)); + EntityA entityADet = em.detach(eA); + assertEquals(id, entityADet.getId()); + assertEquals("entityA", entityADet.getName()); + assertNotNull(entityADet.getDescription()); + assertNotNull(entityADet.getEntityB()); + assertNotNull(entityADet.getEntityC()); + assertNotNull(entityADet.getEntityD()); + assertNotNull(entityADet.getEntityE()); + assertTrue(em.isDetached(eA)); + assertTrue(em.isDetached(entityADet.getEntityB())); + assertFalse(em.isDetached(entityADet.getEntityC())); + assertTrue(em.isDetached(entityADet.getEntityD())); + assertFalse(em.isDetached(entityADet.getEntityE())); + em.getTransaction().commit(); + } + + /** + * The default DetachState of LOADED is tested. In this scenario: + * A is the main entity to be detached + * B is loaded by default and DETACH cascade is specified + * C is loaded by default but DETACH cascade is NOT specified + * D is loaded by fetch plan and DETACH cascade is specified + * E is not loaded but DETACH cascade is NOT specified + */ + public void testDetachStateFetchGroup() { + em.setDetachState(DetachStateType.FETCH_GROUPS); + em.getFetchPlan().addFetchGroup("loadD"); + em.getTransaction().begin(); + // Clear the persistence context so we start fresh + em.persist(entityA); + em.clear(); + EntityA eA = em.find(EntityA.class, id); + assertTrue(em.contains(eA)); + EntityE eE = em.find(EntityE.class, id); // Load independently + assertTrue(em.contains(eE)); + EntityA entityADet = em.detach(eA); + assertEquals(id, entityADet.getId()); + assertEquals("entityA", entityADet.getName()); + assertNull(entityADet.getDescription()); + assertNotNull(entityADet.getEntityB()); + assertNotNull(entityADet.getEntityC()); + assertNotNull(entityADet.getEntityD()); + assertNull(entityADet.getEntityE()); + assertTrue(em.isDetached(eA)); + assertTrue(em.isDetached(entityADet.getEntityB())); + assertFalse(em.isDetached(entityADet.getEntityC())); + assertTrue(em.isDetached(entityADet.getEntityD())); + assertFalse(em.isDetached(eE)); + em.getTransaction().commit(); + } + +}