| /* |
| * Copyright (c) 2005, 2021 Oracle and/or its affiliates. All rights reserved. |
| * Copyright (c) 2005, 2015 SAP. All rights reserved. |
| * |
| * This program and the accompanying materials are made available under the |
| * terms of the Eclipse Public License v. 2.0 which is available at |
| * http://www.eclipse.org/legal/epl-2.0, |
| * or the Eclipse Distribution License v. 1.0 which is available at |
| * http://www.eclipse.org/org/documents/edl-v10.php. |
| * |
| * SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause |
| */ |
| |
| // Contributors: |
| // SAP - initial API and implementation |
| |
| package org.eclipse.persistence.testing.tests.wdf.jpa1.entitymanager; |
| |
| import java.io.IOException; |
| import java.sql.Date; |
| import java.util.Collection; |
| import java.util.HashSet; |
| import java.util.List; |
| import java.util.Set; |
| |
| import jakarta.persistence.EntityManager; |
| import jakarta.persistence.PersistenceException; |
| import jakarta.persistence.TransactionRequiredException; |
| |
| import org.junit.Assert; |
| |
| import org.eclipse.persistence.testing.framework.wdf.AbstractBaseTest; |
| import org.eclipse.persistence.testing.framework.wdf.JPAEnvironment; |
| import org.eclipse.persistence.testing.framework.wdf.ToBeInvestigated; |
| import org.eclipse.persistence.testing.models.wdf.jpa1.employee.Department; |
| import org.eclipse.persistence.testing.models.wdf.jpa1.employee.Employee; |
| import org.eclipse.persistence.testing.models.wdf.jpa1.employee.Hobby; |
| import org.eclipse.persistence.testing.models.wdf.jpa1.employee.Review; |
| import org.eclipse.persistence.testing.models.wdf.jpa1.timestamp.Nasty; |
| import org.eclipse.persistence.testing.models.wdf.jpa1.timestamp.Timestamp; |
| import org.eclipse.persistence.testing.tests.wdf.jpa1.JPA1Base; |
| import org.junit.Ignore; |
| import org.junit.Test; |
| |
| public class TestMerge extends JPA1Base { |
| |
| @Test |
| public void testMergeNew() { |
| /* |
| * If X is a new entity instance, a new managed entity instance X' is created and the state of X is copied into the new |
| * managed entity instance X'. |
| */ |
| final JPAEnvironment env = getEnvironment(); |
| final EntityManager em = env.getEntityManager(); |
| env.evictAll(em); |
| try { |
| Department dep = new Department(1, "NEW"); |
| env.beginTransaction(em); |
| Department dep2 = em.merge(dep); |
| checkDepartment(dep2, 1, "NEW"); |
| env.commitTransactionAndClear(em); |
| verify(!em.contains(dep), "entity manager contains department -> it cannot be detached"); |
| verify(!em.contains(dep2), "entity manager contains department -> it cannot be detached"); |
| verifyExistence(em, 1, "NEW"); |
| } finally { |
| closeEntityManager(em); |
| } |
| } |
| |
| private void checkDepartment(Department department, int id, String name) { |
| verify(department != null, "department is null"); |
| verify(id == department.getId(), "department has wrong id: " + department.getId()); |
| verify(name.equals(department.getName()), "department has wrong name: " + department.getName()); |
| } |
| |
| @Test |
| @ToBeInvestigated |
| public void testMergeDetachedWithRelation() { |
| final JPAEnvironment env = getEnvironment(); |
| final EntityManager em = env.getEntityManager(); |
| try { |
| Department dep = new Department(101, "Aztec gods"); |
| Employee empDetached = new Employee(102, "Huitzil", "Opochtli", dep); |
| Review revManaged = new Review(103, Date.valueOf("2006-01-01"), "managed"); |
| Review revDetached = new Review(104, Date.valueOf("2006-01-02"), "detached/in PC"); |
| Review revDetachedNotInPC = new Review(105, Date.valueOf("2006-01-03"), "detached/not in PC"); |
| Review revNew = new Review(106, Date.valueOf("2006-01-04"), "new"); |
| Review revAddedInManagedEmp = new Review(107, Date.valueOf("2006-01-05"), "added in managed emp"); |
| Hobby hobbyManaged = new Hobby("managed"); |
| Hobby hobbyDetached = new Hobby("detached/in PC"); |
| Hobby hobbyDetachedNotInPC = new Hobby("detached/not in PC"); |
| Hobby hobbyNew = new Hobby("new"); |
| Hobby hobbyAddedInManagedEmp = new Hobby("added in managed emp"); |
| env.beginTransaction(em); |
| em.persist(dep); |
| em.persist(empDetached); |
| em.persist(revManaged); |
| em.persist(revDetached); |
| em.persist(revDetachedNotInPC); |
| em.persist(revAddedInManagedEmp); |
| em.persist(hobbyManaged); |
| em.persist(hobbyDetached); |
| em.persist(hobbyDetachedNotInPC); |
| em.persist(hobbyAddedInManagedEmp); |
| env.commitTransactionAndClear(em); |
| env.beginTransaction(em); |
| // relations of the managed employee |
| Employee empManaged = em.find(Employee.class, empDetached.getId()); |
| empManaged.setFirstName("Adrian"); |
| revManaged = em.find(Review.class, revManaged.getId()); |
| Review revSamePKAsDetached = em.find(Review.class, revDetached.getId()); |
| revSamePKAsDetached.setReviewText("same PK as detached review"); |
| revAddedInManagedEmp = em.find(Review.class, revAddedInManagedEmp.getId()); |
| em.persist(revAddedInManagedEmp); |
| empManaged.addReview(revManaged); |
| empManaged.addReview(revSamePKAsDetached); |
| empManaged.addReview(revAddedInManagedEmp); |
| hobbyManaged = em.find(Hobby.class, hobbyManaged.getId()); |
| Hobby hobbySamePKAsDetached = em.find(Hobby.class, hobbyDetached.getId()); |
| hobbySamePKAsDetached.setDescription("same PK as detached hobby"); |
| hobbyAddedInManagedEmp = em.find(Hobby.class, hobbyAddedInManagedEmp.getId()); |
| em.persist(hobbyAddedInManagedEmp); |
| empManaged.addHobby(hobbyManaged); |
| empManaged.addHobby(hobbySamePKAsDetached); |
| empManaged.addHobby(hobbyAddedInManagedEmp); |
| // relations of the detached employee |
| empDetached.addReview(revManaged); |
| empDetached.addReview(revDetached); |
| empDetached.addReview(revDetachedNotInPC); |
| empDetached.addReview(revNew); |
| empDetached.addHobby(hobbyManaged); |
| empDetached.addHobby(hobbyDetached); |
| empDetached.addHobby(hobbyDetachedNotInPC); |
| empDetached.addHobby(hobbyNew); |
| Employee empAfterMerge = em.merge(empDetached); |
| Set<Review> reviews = empAfterMerge.getReviews(); |
| List<Hobby> hobbies = empAfterMerge.getHobbies(); |
| verify(empAfterMerge == empManaged, "entity manager changed identity of managed object"); |
| verify(reviews.size() == 4, "Merged employee has " + reviews.size() + " reviews, expected 4"); |
| verify(hobbies.size() == 4, "Merged employee has " + hobbies.size() + " hobbies, expected 4"); |
| verify(empAfterMerge.getFirstName().equals(empDetached.getFirstName()), "First name not merged correctly"); |
| verify(containsIdentical(reviews, revManaged), "Merged employee does not contain revManaged"); |
| verify(containsIdentical(hobbies, hobbyManaged), "Merged employee does not contain hobbyManaged"); |
| verify(containsIdentical(reviews, revSamePKAsDetached), "Merged employee does not contain revSamePKAsDetached"); |
| verify(containsIdentical(hobbies, hobbySamePKAsDetached), "Merged employee does not contain hobbySamePKAsDetached"); |
| verify("same PK as detached review".equals(revSamePKAsDetached.getReviewText()), |
| "Text of revSamePKAsDetached changed"); |
| verify("same PK as detached hobby".equals(hobbySamePKAsDetached.getDescription()), |
| "Text of hobbySamePKAsDetached changed"); |
| verify(containsIdentical(reviews, revNew), "Merged employee does not contain revNew"); |
| verify(containsIdentical(hobbies, hobbyNew), "Merged employee does not contain hobbyNew"); |
| verify(!em.contains(revNew), "revNew is managed"); |
| verify(!em.contains(hobbyNew), "hobbyNew is managed"); |
| verify(!containsIdentical(reviews, revAddedInManagedEmp), "Merged employee contains revAddedInManagedEmp"); |
| verify(!containsIdentical(hobbies, hobbyAddedInManagedEmp), "Merged employee contains hobbyAddedInManagedEmp"); |
| verify(em.contains(revAddedInManagedEmp), "revAddedInManagedEmp is not managed"); |
| verify(em.contains(hobbyAddedInManagedEmp), "hobbyAddedInManagedEmp is not managed"); |
| int pk = revDetachedNotInPC.getId(); |
| Review revSamePK = null; |
| for (Review rev : reviews) { |
| if (rev.getId() == pk) { |
| revSamePK = rev; |
| break; |
| } |
| } |
| verify(revSamePK != null, "Merged employee does not contain review with id " + pk); |
| verify(em.contains(revSamePK), "Review " + pk + " is not managed"); |
| String hobbyId = hobbyDetachedNotInPC.getId(); |
| Hobby hobbySamePK = null; |
| for (Hobby hobby : hobbies) { |
| if (hobby.getId().equals(hobbyId)) { |
| hobbySamePK = hobby; |
| break; |
| } |
| } |
| verify(hobbySamePK != null, "Merged employee does not contain hobby with id " + pk); |
| verify(em.contains(hobbySamePK), "Hobby " + pk + " is not managed"); |
| // commit should fail because empAfterMerge has a relation to a new review/hobby |
| boolean commitFailed = false; |
| try { |
| env.commitTransactionAndClear(em); |
| } catch (RuntimeException e) { |
| if (!checkForIllegalStateException(e)) { |
| throw e; |
| } |
| commitFailed = true; |
| } |
| verify(commitFailed, "Commit succeeded although employee had a relation to a new review"); |
| } finally { |
| closeEntityManager(em); |
| } |
| } |
| |
| @Test |
| public void testMergeManaged() { |
| /* |
| * If X is a managed entity, it is ignored by the merge operation, however, the merge operation is cascaded to entities |
| * referenced by relationships from X if these relationships have been annotated with the cascade element value |
| * cascade=MERGE or cascade=ALL annotation. |
| */ |
| final JPAEnvironment env = getEnvironment(); |
| final EntityManager em = env.getEntityManager(); |
| try { |
| // case 1: object is managed and in state NEW |
| int id = 11; |
| Department dep = new Department(id, "MANAGED_NEW"); |
| env.beginTransaction(em); |
| em.persist(dep); // object is now in state NEW |
| verify(em.contains(dep), "entity manager does not contain object"); |
| Department mergeResult = em.merge(dep); // this should be ignored |
| checkDepartment(mergeResult, id, "MANAGED_NEW"); |
| verify(mergeResult == dep, "merge operation has changed identity of a managed object"); |
| env.commitTransactionAndClear(em); |
| // case 2: object is managed and in state MANAGED |
| id = 12; |
| dep = new Department(id, "MANAGED"); |
| env.beginTransaction(em); |
| em.persist(dep); |
| env.commitTransactionAndClear(em); |
| env.beginTransaction(em); |
| dep = em.find(Department.class, id); // object is now in state MANAGED |
| checkDepartment(dep, id, "MANAGED"); |
| verify(em.contains(dep), "entity manager does not contain object"); |
| mergeResult = em.merge(dep); // this should be ignored |
| checkDepartment(mergeResult, id, "MANAGED"); |
| verify(mergeResult == dep, "merge operation has changed identity of a managed object"); |
| env.commitTransactionAndClear(em); |
| } finally { |
| closeEntityManager(em); |
| } |
| } |
| |
| @Test |
| @ToBeInvestigated |
| public void testMergeRemoved() { |
| /* |
| * If X is a removed entity instance, an IllegalArgumentException will be thrown by the merge operation (or the |
| * transaction commit will fail). |
| */ |
| final JPAEnvironment env = getEnvironment(); |
| final EntityManager em = env.getEntityManager(); |
| try { |
| // 1. find an existing department, remove it and call merge |
| int id1 = 21; |
| Department dep = new Department(id1, "REMOVE"); |
| env.beginTransaction(em); |
| em.persist(dep); |
| env.commitTransactionAndClear(em); |
| env.beginTransaction(em); |
| dep = em.find(Department.class, id1); |
| em.remove(dep); |
| // now the entity should be REMOVED |
| boolean failed = false; |
| try { |
| em.merge(dep); |
| } catch (IllegalArgumentException ex) { |
| failed = true; |
| env.rollbackTransactionAndClear(em); |
| } |
| try { |
| if (env.isTransactionActive(em)) { |
| env.commitTransactionAndClear(em); |
| } |
| } catch (PersistenceException ex) { |
| failed = true; |
| } |
| verify(failed, "merge did succeed on a removed instance."); |
| // 2. remove managed-new object |
| // what happens is undefined by the spec. Consequently, we don't check anything. |
| // 3. find an existing department, remove it and call merge on a different object with same primary key |
| // (so the object we pass in is actually detached, but the object under control of entity manager |
| // is in state REMOVED) |
| int id = 23; |
| Department depEM = new Department(id, "REMOVE"); |
| Department depClient = new Department(id, "NEW_NAME"); |
| env.beginTransaction(em); |
| em.persist(depEM); |
| env.commitTransactionAndClear(em); |
| env.beginTransaction(em); |
| depEM = em.find(Department.class, id); |
| checkDepartment(depEM, id, "REMOVE"); |
| em.remove(depEM); // this is now in state REMOVED |
| failed = false; |
| try { |
| em.merge(depClient); |
| } catch (IllegalArgumentException ex) { |
| failed = true; |
| env.rollbackTransactionAndClear(em); |
| } |
| try { |
| if (env.isTransactionActive(em)) { |
| env.commitTransactionAndClear(em); |
| } |
| } catch (PersistenceException ex) { |
| failed = true; |
| } |
| verify(failed, "merge did succeed on a removed instance."); |
| // 4. find an existing department, remove it, flush, and call merge |
| id1 = 24; |
| dep = new Department(id1, "REMOVE"); |
| env.beginTransaction(em); |
| em.persist(dep); |
| env.commitTransactionAndClear(em); |
| env.beginTransaction(em); |
| dep = em.find(Department.class, id1); |
| em.remove(dep); |
| em.flush(); |
| // now the entity should be in state DELETE_EXECUTED |
| failed = false; |
| try { |
| em.merge(dep); |
| } catch (IllegalArgumentException ex) { |
| failed = true; |
| env.rollbackTransactionAndClear(em); |
| } |
| try { |
| if (env.isTransactionActive(em)) { |
| env.commitTransactionAndClear(em); |
| } |
| } catch (PersistenceException ex) { |
| failed = true; |
| } |
| verify(failed, "merge did succeed on a removed instance."); |
| } finally { |
| closeEntityManager(em); |
| } |
| } |
| |
| @Test |
| public void testMergeDetached() { |
| /* |
| * If X is a detached entity, it is copied onto a pre-existing managed entity instance X' of the same identity or a new |
| * managed copy of X is created. |
| */ |
| final JPAEnvironment env = getEnvironment(); |
| final EntityManager em = env.getEntityManager(); |
| int id; |
| try { |
| // case 1: entity exists on DB, but not contained in persistence context |
| id = 31; |
| Department dep = new Department(id, "DETACHED"); |
| // firstly, we create a department on the database |
| env.beginTransaction(em); |
| em.persist(dep); |
| env.commitTransactionAndClear(em); |
| verify(!em.contains(dep), "entity manager contains department -> it cannot be detached"); |
| dep.setName("NEW_NAME"); |
| env.beginTransaction(em); |
| Department dep2 = em.merge(dep); |
| checkDepartment(dep2, id, "NEW_NAME"); |
| verify(em.contains(dep2), "entity manager does not contain department -> it cannot be merged"); |
| env.commitTransactionAndClear(em); |
| verifyExistence(em, id, "NEW_NAME"); |
| // case 2: entity is contained in persistence context, but object to be merged has different object identity |
| Department depEM; |
| Department depClient; |
| Department mergeResult; |
| // case 2a: state of known object: FOR_INSERT |
| id = 32; |
| depEM = new Department(id, "ORIGINAL"); |
| depClient = new Department(id, "NEW_NAME"); |
| env.beginTransaction(em); |
| em.persist(depEM); // this is now in state new |
| checkDepartment(depEM, id, "ORIGINAL"); |
| verify(em.contains(depEM), "entity manager does not contain department -> it cannot be merged"); |
| mergeResult = em.merge(depClient); |
| checkDepartment(mergeResult, id, "NEW_NAME"); |
| verify(em.contains(mergeResult), "entity manager does not contain merged department"); |
| verify(mergeResult == depEM, "entity manager changed identity of managed object"); |
| env.commitTransactionAndClear(em); |
| verifyExistence(em, id, "NEW_NAME"); |
| // case 2b: state of known object: FOR_UPDATE |
| id = 33; |
| depEM = new Department(id, "ORIGINAL"); |
| env.beginTransaction(em); |
| em.persist(depEM); |
| env.commitTransactionAndClear(em); |
| env.beginTransaction(em); |
| depClient = em.find(Department.class, id); |
| env.commitTransactionAndClear(em); |
| env.beginTransaction(em); |
| depClient.setName(("NEW_NAME")); |
| depEM = em.find(Department.class, id); // this is now in state managed |
| checkDepartment(depEM, id, "ORIGINAL"); |
| verify(em.contains(depEM), "entity manager does not contain department -> it cannot be merged"); |
| mergeResult = em.merge(depClient); |
| checkDepartment(mergeResult, id, "NEW_NAME"); |
| verify(em.contains(mergeResult), "entity manager does not contain merged department"); |
| verify(mergeResult == depEM, "entity manager changed identity of managed object"); |
| env.commitTransactionAndClear(em); |
| verifyExistence(em, id, "NEW_NAME"); |
| } finally { |
| closeEntityManager(em); |
| } |
| } |
| |
| private void verifyExistence(final EntityManager em, int id, String name) { |
| Department dep; |
| dep = em.find(Department.class, id); |
| verify(dep != null, "department not found"); |
| verify(name.equals(dep.getName()), "department has wrong name: " + dep.getName()); |
| } |
| |
| /* |
| * throws IllegalArgumentException, if instance is not an entity |
| */ |
| @Test |
| public void testNotAnEntity() { |
| final JPAEnvironment env = getEnvironment(); |
| final EntityManager em = env.getEntityManager(); |
| try { |
| env.beginTransaction(em); |
| try { |
| em.merge("Hutzliputz"); |
| flop("no IllegalArgumentException "); |
| } catch (IllegalArgumentException e) { |
| verify(true, ""); |
| } finally { |
| env.rollbackTransactionAndClear(em); |
| } |
| env.beginTransaction(em); |
| try { |
| em.merge(null); |
| flop("no IllegalArgumentException "); |
| } catch (IllegalArgumentException e) { |
| verify(true, ""); |
| } finally { |
| env.rollbackTransactionAndClear(em); |
| } |
| } finally { |
| closeEntityManager(em); |
| } |
| } |
| |
| @Test |
| @ToBeInvestigated |
| public void testMergeNewWithRelation() { |
| final JPAEnvironment env = getEnvironment(); |
| final EntityManager em = env.getEntityManager(); |
| try { |
| Department dep = new Department(201, "Aztec gods"); |
| Employee empNew = new Employee(202, "Huitzil", "Opochtli", dep); |
| Review revManaged = new Review(203, Date.valueOf("2006-01-01"), "managed"); |
| Review revDetached = new Review(204, Date.valueOf("2006-01-02"), "detached/in PC"); |
| Review revDetachedNotInPC = new Review(205, Date.valueOf("2006-01-03"), "detached/not in PC"); |
| Review revNew = new Review(206, Date.valueOf("2006-01-04"), "new"); |
| Hobby hobbyManaged = new Hobby("managed"); |
| Hobby hobbyDetached = new Hobby("detached/in PC"); |
| Hobby hobbyDetachedNotInPC = new Hobby("detached/not in PC"); |
| Hobby hobbyNew = new Hobby("new"); |
| env.beginTransaction(em); |
| em.persist(dep); |
| em.persist(revManaged); |
| em.persist(revDetached); |
| em.persist(revDetachedNotInPC); |
| em.persist(hobbyManaged); |
| em.persist(hobbyDetached); |
| em.persist(hobbyDetachedNotInPC); |
| env.commitTransactionAndClear(em); |
| env.beginTransaction(em); |
| revManaged = em.find(Review.class, revManaged.getId()); |
| Review revSamePKAsDetached = em.find(Review.class, revDetached.getId()); |
| revSamePKAsDetached.setReviewText("same PK as detached review"); |
| empNew.addReview(revManaged); |
| empNew.addReview(revDetached); |
| empNew.addReview(revDetachedNotInPC); |
| empNew.addReview(revNew); |
| hobbyManaged = em.find(Hobby.class, hobbyManaged.getId()); |
| Hobby hobbySamePKAsDetached = em.find(Hobby.class, hobbyDetached.getId()); |
| hobbySamePKAsDetached.setDescription("same PK as detached hobby"); |
| empNew.addHobby(hobbyManaged); |
| empNew.addHobby(hobbyDetached); |
| empNew.addHobby(hobbyDetachedNotInPC); |
| empNew.addHobby(hobbyNew); |
| Employee empAfterMerge = em.merge(empNew); |
| Set<Review> reviews = empAfterMerge.getReviews(); |
| List<Hobby> hobbies = empAfterMerge.getHobbies(); |
| verify(em.contains(empAfterMerge), "Merged employee not managed"); |
| verify(empAfterMerge != empNew, "Merge did not copy new entity"); |
| verify(reviews.size() == 4, "Merged employee has " + reviews.size() + " reviews, expected 4"); |
| verify(hobbies.size() == 4, "Merged employee has " + hobbies.size() + " hobbies, expected 4"); |
| verify(containsIdentical(reviews, revManaged), "Merged employee does not contain revManaged"); |
| verify(containsIdentical(hobbies, hobbyManaged), "Merged employee does not contain hobbyManaged"); |
| verify(containsIdentical(reviews, revSamePKAsDetached), "Merged employee does not contain revSamePKAsDetached"); |
| verify(containsIdentical(hobbies, hobbySamePKAsDetached), "Merged employee does not contain hobbySamePKAsDetached"); |
| verify("same PK as detached review".equals(revSamePKAsDetached.getReviewText()), |
| "Text of revSamePKAsDetached changed"); |
| verify("same PK as detached hobby".equals(hobbySamePKAsDetached.getDescription()), |
| "Text of hobbySamePKAsDetached changed"); |
| verify(containsIdentical(reviews, revNew), "Merged employee does not contain revNew"); |
| verify(containsIdentical(hobbies, hobbyNew), "Merged employee does not contain hobbyNew"); |
| verify(!em.contains(revNew), "revNew is managed"); |
| verify(!em.contains(hobbyNew), "hobbyNew is managed"); |
| int pk = revDetachedNotInPC.getId(); |
| Review revSamePK = null; |
| for (Review rev : reviews) { |
| if (rev.getId() == pk) { |
| revSamePK = rev; |
| break; |
| } |
| } |
| verify(revSamePK != null, "Merged employee does not contain review with id " + pk); |
| verify(em.contains(revSamePK), "Review " + pk + " is not managed"); |
| String hobbyId = hobbyDetachedNotInPC.getId(); |
| Hobby hobbySamePK = null; |
| for (Hobby hobby : hobbies) { |
| if (hobby.getId().equals(hobbyId)) { |
| hobbySamePK = hobby; |
| break; |
| } |
| } |
| verify(hobbySamePK != null, "Merged employee does not contain hobby with id " + pk); |
| verify(em.contains(hobbySamePK), "Hobby " + pk + " is not managed"); |
| // commit should fail because empAfterMerge has a relation to a new review/hobby |
| boolean commitFailed = false; |
| try { |
| env.commitTransactionAndClear(em); |
| } catch (RuntimeException e) { |
| if (!checkForIllegalStateException(e)) { |
| throw e; |
| } |
| commitFailed = true; |
| } |
| verify(commitFailed, "Commit succeeded although employee had a relation to a new review"); |
| } finally { |
| closeEntityManager(em); |
| } |
| } |
| |
| @Test |
| public void testWithLazyRelationPending() { |
| final JPAEnvironment env = getEnvironment(); |
| final EntityManager em = env.getEntityManager(); |
| try { |
| // Case 1: Change observer pending in both detached and managed object |
| Department dep = new Department(301, "Merge test department"); |
| Employee emp = new Employee(302, "Detached", "Employee", dep); |
| Review rev1 = new Review(303, Date.valueOf("2006-01-01"), "one"); |
| Review rev2 = new Review(304, Date.valueOf("2006-01-02"), "two"); |
| Hobby hobby1 = new Hobby("counting beans"); |
| Hobby hobby2 = new Hobby("writing SDDs"); |
| emp.addReview(rev1); |
| emp.addReview(rev2); |
| emp.addHobby(hobby1); |
| emp.addHobby(hobby2); |
| env.beginTransaction(em); |
| em.persist(dep); |
| em.persist(emp); |
| em.persist(rev1); |
| em.persist(rev2); |
| em.persist(hobby1); |
| em.persist(hobby2); |
| env.commitTransactionAndClear(em); |
| env.beginTransaction(em); |
| Employee empDetached = em.find(Employee.class, emp.getId()); |
| env.commitTransactionAndClear(em); |
| env.beginTransaction(em); |
| emp = em.find(Employee.class, emp.getId()); |
| emp.setFirstName("Managed"); |
| emp = em.merge(empDetached); |
| verify(empDetached.getFirstName().equals(emp.getFirstName()), "Merged employee has wrong first name"); |
| verify(emp.getReviews().size() == 2, "Merged employee has " + emp.getReviews().size() + " reviews, expected 2"); |
| verify(emp.getHobbies().size() == 2, "Merged employee has " + emp.getHobbies().size() + " hobbies, expected 2"); |
| env.commitTransactionAndClear(em); |
| // Case 2: Change observer pending in detached object and loaded but unchanged in managed object |
| env.beginTransaction(em); |
| empDetached = em.find(Employee.class, emp.getId()); |
| emp.setFirstName("Detached"); |
| env.commitTransactionAndClear(em); |
| env.beginTransaction(em); |
| emp = em.find(Employee.class, emp.getId()); |
| emp.setFirstName("Managed"); |
| Set<Review> reviews = emp.getReviews(); |
| verify(reviews.size() == 2, "Employee has " + reviews.size() + " reviews, expected 2"); |
| List<Hobby> hobbies = emp.getHobbies(); |
| verify(hobbies.size() == 2, "Employee has " + hobbies.size() + " hobbies, expected 2"); |
| emp = em.merge(empDetached); |
| env.commitTransactionAndClear(em); |
| verify(empDetached.getFirstName().equals(emp.getFirstName()), "Merged employee has wrong first name"); |
| reviews = emp.getReviews(); |
| verify(reviews.size() == 2, "Merged employee has " + reviews.size() + " reviews, expected 2"); |
| hobbies = emp.getHobbies(); |
| verify(hobbies.size() == 2, "Merged employee has " + hobbies.size() + " hobbies, expected 2"); |
| } finally { |
| closeEntityManager(em); |
| } |
| } |
| |
| @SuppressWarnings("boxing") |
| @Test |
| @ToBeInvestigated |
| public void testIlegalArgumentWithLazyRelationPending() { |
| final JPAEnvironment env = getEnvironment(); |
| final EntityManager em = env.getEntityManager(); |
| try { |
| // case 1: relationship to be merged has wrong owner |
| Employee e1 = new Employee(401, "Detached", "Employee", null); |
| Employee e2 = new Employee(402, "Detached", "Employee", null); |
| Review review = new Review(403, Date.valueOf("2006-03-15"), "abc"); |
| e1.addReview(review); |
| env.beginTransaction(em); |
| em.persist(e1); |
| em.persist(e2); |
| em.persist(review); |
| env.commitTransaction(em); |
| em.clear(); |
| Employee detached1 = em.find(Employee.class, 401); |
| Employee detached2 = em.find(Employee.class, 402); |
| detached2.setReviews(detached1.getReviews()); |
| em.clear(); |
| env.beginTransaction(em); |
| try { |
| em.merge(detached2); |
| flop("missing illegalArgumentException"); |
| } catch (IllegalArgumentException ex) { |
| Assert.assertTrue(true); |
| } finally { |
| env.rollbackTransaction(em); |
| em.clear(); |
| } |
| // case 2: target relationship is pending but has wrong owner |
| e1 = new Employee(411, "Detached", "Employee", null); |
| e2 = new Employee(412, "Detached", "Employee", null); |
| review = new Review(413, Date.valueOf("2006-03-15"), "abc"); |
| e1.addReview(review); |
| env.beginTransaction(em); |
| em.persist(e1); |
| em.persist(e2); |
| em.persist(review); |
| env.commitTransaction(em); |
| em.clear(); |
| detached1 = em.find(Employee.class, 411); |
| detached2 = em.find(Employee.class, 412); |
| em.clear(); |
| env.beginTransaction(em); |
| try { |
| e1 = em.find(Employee.class, 411); |
| e2 = em.find(Employee.class, 412); |
| e2.setReviews(e1.getReviews()); |
| em.merge(detached2); |
| flop("missing illegalArgumentException"); |
| } catch (IllegalArgumentException ex) { |
| Assert.assertTrue(true); |
| } finally { |
| env.rollbackTransaction(em); |
| em.clear(); |
| } |
| // case 3: target relationship is no change observer |
| e1 = new Employee(421, "Detached", "Employee", null); |
| env.beginTransaction(em); |
| em.persist(e1); |
| env.commitTransaction(em); |
| em.clear(); |
| detached1 = em.find(Employee.class, 421); |
| em.clear(); |
| env.beginTransaction(em); |
| try { |
| e1 = em.find(Employee.class, 421); |
| e1.setReviews(new HashSet<Review>()); |
| em.merge(detached1); |
| flop("missing illegalArgumentException"); |
| } catch (IllegalArgumentException ex) { |
| Assert.assertTrue(true); |
| } finally { |
| env.rollbackTransaction(em); |
| em.clear(); |
| } |
| } finally { |
| closeEntityManager(em); |
| } |
| } |
| |
| @SuppressWarnings("boxing") |
| @Test |
| @ToBeInvestigated |
| public void testIlegalArgumentWithDeserializedEntity() throws IOException, ClassNotFoundException { |
| final JPAEnvironment env = getEnvironment(); |
| final EntityManager em = env.getEntityManager(); |
| try { |
| // case 1: relationship to be merged has wrong owner |
| Employee e1 = new Employee(501, "Detached", "Employee", null); |
| Employee e2 = new Employee(502, "Detached", "Employee", null); |
| Review review = new Review(503, Date.valueOf("2006-03-15"), "abc"); |
| e1.addReview(review); |
| env.beginTransaction(em); |
| em.persist(e1); |
| em.persist(e2); |
| em.persist(review); |
| env.commitTransaction(em); |
| em.clear(); |
| Employee detached1 = AbstractBaseTest.serializeDeserialize(em.find(Employee.class, 501)); |
| Employee detached2 = AbstractBaseTest.serializeDeserialize(em.find(Employee.class, 502)); |
| detached2.setReviews(detached1.getReviews()); |
| em.clear(); |
| env.beginTransaction(em); |
| try { |
| em.merge(detached2); |
| flop("missing illegalArgumentException"); |
| } catch (IllegalArgumentException ex) { |
| Assert.assertTrue(true); |
| } finally { |
| env.rollbackTransaction(em); |
| em.clear(); |
| } |
| // case 2: target relationship is pending but has wrong owner |
| e1 = new Employee(511, "Detached", "Employee", null); |
| e2 = new Employee(512, "Detached", "Employee", null); |
| review = new Review(513, Date.valueOf("2006-03-15"), "abc"); |
| e1.addReview(review); |
| env.beginTransaction(em); |
| em.persist(e1); |
| em.persist(e2); |
| em.persist(review); |
| env.commitTransaction(em); |
| em.clear(); |
| detached1 = AbstractBaseTest.serializeDeserialize(em.find(Employee.class, 511)); |
| detached2 = AbstractBaseTest.serializeDeserialize(em.find(Employee.class, 512)); |
| em.clear(); |
| env.beginTransaction(em); |
| try { |
| e1 = em.find(Employee.class, 511); |
| e2 = em.find(Employee.class, 512); |
| e2.setReviews(e1.getReviews()); |
| em.merge(detached2); |
| flop("missing illegalArgumentException"); |
| } catch (IllegalArgumentException ex) { |
| Assert.assertTrue(true); |
| } finally { |
| env.rollbackTransaction(em); |
| em.clear(); |
| } |
| // case 3: target relationship is no change observer |
| e1 = new Employee(521, "Detached", "Employee", null); |
| env.beginTransaction(em); |
| em.persist(e1); |
| env.commitTransaction(em); |
| em.clear(); |
| detached1 = AbstractBaseTest.serializeDeserialize(em.find(Employee.class, 521)); |
| em.clear(); |
| env.beginTransaction(em); |
| try { |
| e1 = em.find(Employee.class, 521); |
| e1.setReviews(new HashSet<Review>()); |
| em.merge(detached1); |
| flop("missing illegalArgumentException"); |
| } catch (IllegalArgumentException ex) { |
| Assert.assertTrue(true); |
| } finally { |
| env.rollbackTransaction(em); |
| em.clear(); |
| } |
| } finally { |
| closeEntityManager(em); |
| } |
| } |
| |
| /** |
| * Checks whether the collection contains an entry identical to the given object. The method uses object identity for |
| * comparison (not the object's <code>equals</code> method |
| * |
| * @param collection |
| * the collection |
| * @param o |
| * the object to search for in the set |
| * @return <code>true</code> if the set contains o (and o is not <code>null</code>), <code>false</code> otherwise |
| */ |
| private boolean containsIdentical(Collection<?> collection, Object o) { |
| boolean contains = false; |
| if (o != null) { |
| for (Object entry : collection) { |
| if (entry == o) { |
| contains = true; |
| break; |
| } |
| } |
| } |
| return contains; |
| } |
| |
| @Ignore // @TestProperties(unsupportedEnvironments={JTANonSharedPCEnvironment.class, ResourceLocalEnvironment.class}) |
| public void testNoTransaction() { |
| final JPAEnvironment env = getEnvironment(); |
| final EntityManager em = env.getEntityManager(); |
| Department dep = new Department(600, "dep600"); |
| try { |
| em.merge(dep); |
| flop("exception not thrown as expected"); |
| } catch (TransactionRequiredException e) { |
| // $JL-EXC$ expected behavior |
| } finally { |
| closeEntityManager(em); |
| } |
| } |
| |
| @Test |
| public void testTransactionMarkedForRollback() { |
| final JPAEnvironment env = getEnvironment(); |
| final EntityManager em = env.getEntityManager(); |
| try { |
| // case 1: persistence context already available when tx marked for rollback |
| Department dep = new Department(601, "dep601"); |
| env.beginTransaction(em); |
| verify(!em.contains(dep), "entity contained in persistence context"); // this ensures that the pc is |
| // available |
| env.markTransactionForRollback(em); |
| dep = em.merge(dep); |
| verify(em.contains(dep), "entity not contained in persistence context"); |
| env.rollbackTransaction(em); |
| // case 2: persistence context not yet available when tx marked for rollback |
| // will throw an exception in the container-managed JTA case |
| // if (!(env instanceof JTASharedPCEnvironment)) { |
| { |
| dep = new Department(602, "dep602"); |
| env.beginTransaction(em); |
| env.markTransactionForRollback(em); |
| dep = em.merge(dep); |
| verify(em.contains(dep), "entity not contained in persistence context"); |
| env.rollbackTransaction(em); |
| } |
| } finally { |
| closeEntityManager(em); |
| } |
| } |
| |
| private void verifyMergeNewEntityWithIdSetInPrePersist(Timestamp t1) { |
| /* |
| * If X is a new entity instance, a new managed entity instance X' is created and the state of X is copied into the new |
| * managed entity instance X'. |
| */ |
| final JPAEnvironment env = getEnvironment(); |
| final EntityManager em = env.getEntityManager(); |
| try { |
| env.beginTransaction(em); |
| Timestamp t2 = em.merge(t1); |
| verify(t2 != null, "merged timestamp is null"); |
| verify(t2.getId() != null && t2.getId() != Long.valueOf(0), "unexpected id: " + t2.getId()); |
| verify(em.contains(t2), "not contained"); |
| env.commitTransactionAndClear(em); |
| verify(!em.contains(t1), "entity manager contains timestamp -> it cannot be detached"); |
| verify(!em.contains(t2), "entity manager contains timestamp -> it cannot be detached"); |
| Timestamp t3 = em.find(Timestamp.class, t2.getId()); |
| verify(t3 != null, "not found"); |
| verify(t3.getId().equals(t2.getId()), "unexpected id: " + t3.getId()); |
| } finally { |
| closeEntityManager(em); |
| } |
| } |
| |
| @Test |
| public void testMergeNewEntityWithIdSetInPrePersist() { |
| // initial object |
| verifyMergeNewEntityWithIdSetInPrePersist(new Timestamp()); |
| try { |
| Thread.sleep(10); // make sure next entity gets new ID |
| } catch (InterruptedException e) { |
| // $JL-EXC$ |
| } |
| Timestamp t = new Timestamp(); |
| t.setId(1L); |
| // |
| verifyMergeNewEntityWithIdSetInPrePersist(t); |
| } |
| |
| @Test |
| public void testNastyTimestampTwice() { |
| final JPAEnvironment env = getEnvironment(); |
| final EntityManager em = env.getEntityManager(); |
| try { |
| Nasty nasty = new Nasty(); |
| verify(nasty.getId() == null, "id is not null"); |
| env.beginTransaction(em); |
| em.persist(nasty); |
| Long value = nasty.getId(); |
| verify(value != null, "id is null"); |
| try { |
| em.merge(new Nasty()); |
| env.commitTransaction(em); |
| flop("persisting second nasty timestamp succeeded"); |
| } catch (PersistenceException ex) { |
| Assert.assertTrue(true); |
| } |
| if (env.isTransactionActive(em)) { |
| env.rollbackTransactionAndClear(em); |
| } |
| } finally { |
| closeEntityManager(em); |
| } |
| } |
| |
| @Test |
| public void testNastyTimestampTwiceNotInitial() { |
| final JPAEnvironment env = getEnvironment(); |
| final EntityManager em = env.getEntityManager(); |
| try { |
| Nasty nasty = new Nasty(); |
| verify(nasty.getId() == null, "id is not null"); |
| env.beginTransaction(em); |
| em.persist(nasty); |
| Long value = nasty.getId(); |
| verify(value != null, "id is null"); |
| try { |
| Nasty n2 = new Nasty(); |
| n2.setId(2000L); |
| em.merge(n2); |
| env.commitTransaction(em); |
| flop("persisting second nasty timestamp succeeded"); |
| } catch (PersistenceException ex) { |
| Assert.assertTrue(true); |
| } |
| if (env.isTransactionActive(em)) { |
| env.rollbackTransactionAndClear(em); |
| } |
| } finally { |
| closeEntityManager(em); |
| } |
| } |
| } |
