@Override public void joinTransaction() { em.joinTransaction(); }
@Override public void joinTransaction() { if (this.em == null) { return; } if (this.isJTA) { this.em.joinTransaction(); } }
public void joinTransaction() { if (this.em == null) { return; } this.em.joinTransaction(); }
@Override public void joinTransaction() { em().joinTransaction(); }
@Test public void testEntityManagerProxyAcceptsProgrammaticTxJoining() { EntityManager em = entityManagerFactory.createEntityManager(); em.joinTransaction(); }
this.target.joinTransaction(); logger.debug("Joined JTA transaction");
@Test public void testInstantiateAndSave() { EntityManager em = entityManagerFactory.createEntityManager(); em.joinTransaction(); doInstantiateAndSave(em); }
@Test(expected = TransactionRequiredException.class) public void transactionRequiredExceptionOnJoinTransaction() { EntityManagerFactory emf = mock(EntityManagerFactory.class); EntityManager em = SharedEntityManagerCreator.createSharedEntityManager(emf); em.joinTransaction(); }
@Test public void testContainerEntityManagerProxyAllowsJoinTransactionInTransaction() { createContainerManagedEntityManager().joinTransaction(); }
@Test public void testTransactionCommitWithSharedEntityManagerUnsynchronizedJoined() { given(manager.getTransaction()).willReturn(tx); tt.execute(status -> { bean.sharedEntityManagerUnsynchronized.joinTransaction(); bean.sharedEntityManagerUnsynchronized.flush(); return null; }); verify(tx).commit(); verify(manager).flush(); verify(manager, times(2)).close(); }
@Test public void testTransactionCommitWithExtendedEntityManagerUnsynchronizedJoined() { given(manager.getTransaction()).willReturn(tx); tt.execute(status -> { bean.extendedEntityManagerUnsynchronized.joinTransaction(); bean.extendedEntityManagerUnsynchronized.flush(); return null; }); verify(tx, times(2)).commit(); verify(manager).flush(); verify(manager).close(); }
@Test public void testTransactionCommitWithExtendedEntityManagerUnsynchronizedJoinedAndPropagationSupports() { given(manager.isOpen()).willReturn(true); tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_SUPPORTS); tt.execute(status -> { bean.extendedEntityManagerUnsynchronized.joinTransaction(); bean.extendedEntityManagerUnsynchronized.flush(); return null; }); verify(manager).flush(); }
@Test public void testRollbackOccurs() { EntityManager em = entityManagerFactory.createEntityManager(); em.joinTransaction(); doInstantiateAndSave(em); endTransaction(); // Should rollback assertEquals("Tx must have been rolled back", 0, countRowsInTable(em, "person")); }
@Test public void testContainerEntityManagerProxyRejectsJoinTransactionWithoutTransaction() { endTransaction(); try { createContainerManagedEntityManager().joinTransaction(); fail("Should have thrown a TransactionRequiredException"); } catch (TransactionRequiredException ex) { // expected } }
@Test public void testCommitOccurs() { EntityManager em = entityManagerFactory.createEntityManager(); em.joinTransaction(); doInstantiateAndSave(em); setComplete(); endTransaction(); // Should rollback assertEquals("Tx must have committed back", 1, countRowsInTable(em, "person")); // Now clean up the database deleteFromTables("person"); }
@Test public void testReuseInNewTransaction() { EntityManager em = entityManagerFactory.createEntityManager(); em.joinTransaction(); doInstantiateAndSave(em); endTransaction(); assertFalse(em.getTransaction().isActive()); startNewTransaction(); // Call any method: should cause automatic tx invocation assertFalse(em.contains(new Person())); assertFalse(em.getTransaction().isActive()); em.joinTransaction(); assertTrue(em.getTransaction().isActive()); doInstantiateAndSave(em); setComplete(); endTransaction(); // Should rollback assertEquals("Tx must have committed back", 1, countRowsInTable(em, "person")); // Now clean up the database startNewTransaction(); em.joinTransaction(); deleteAllPeopleUsingEntityManager(em); assertEquals("People have been killed", 0, countRowsInTable(em, "person")); setComplete(); }
@Test public void testEnversCompatibility() throws Exception { // revision 1 userTransaction.begin(); entityManager.joinTransaction(); AuditedEntity entity = new AuditedEntity( 1, "Marco Polo" ); entityManager.persist( entity ); userTransaction.commit(); // revision 2 userTransaction.begin(); entityManager.joinTransaction(); entity.setName( "George Washington" ); entityManager.merge( entity ); userTransaction.commit(); entityManager.clear(); // verify audit history revision counts userTransaction.begin(); final AuditReader auditReader = AuditReaderFactory.get( entityManager ); assertEquals( Arrays.asList( 1, 2 ), auditReader.getRevisions( AuditedEntity.class, 1 ) ); userTransaction.commit(); } }
@Test public void testApplicationManagedEntityManagerWithJtaTransaction() throws Exception { Object testEntity = new Object(); // This one's for the tx (shared) EntityManager sharedEm = mock(EntityManager.class); given(sharedEm.getTransaction()).willReturn(new NoOpEntityTransaction()); // This is the application-specific one EntityManager mockEm = mock(EntityManager.class); given(mockEmf.createEntityManager()).willReturn(sharedEm, mockEm); LocalContainerEntityManagerFactoryBean cefb = parseValidPersistenceUnit(); MutablePersistenceUnitInfo pui = ((MutablePersistenceUnitInfo) cefb.getPersistenceUnitInfo()); pui.setTransactionType(PersistenceUnitTransactionType.JTA); JpaTransactionManager jpatm = new JpaTransactionManager(); jpatm.setEntityManagerFactory(cefb.getObject()); TransactionStatus txStatus = jpatm.getTransaction(new DefaultTransactionAttribute()); EntityManagerFactory emf = cefb.getObject(); assertSame("EntityManagerFactory reference must be cached after init", emf, cefb.getObject()); assertNotSame("EMF must be proxied", mockEmf, emf); EntityManager em = emf.createEntityManager(); em.joinTransaction(); assertFalse(em.contains(testEntity)); jpatm.commit(txStatus); cefb.destroy(); verify(mockEm).joinTransaction(); verify(mockEm).contains(testEntity); verify(mockEmf).close(); }
@Test public void testApplicationManagedEntityManagerWithTransaction() throws Exception { Object testEntity = new Object(); EntityTransaction mockTx = mock(EntityTransaction.class); // This one's for the tx (shared) EntityManager sharedEm = mock(EntityManager.class); given(sharedEm.getTransaction()).willReturn(new NoOpEntityTransaction()); // This is the application-specific one EntityManager mockEm = mock(EntityManager.class); given(mockEm.getTransaction()).willReturn(mockTx); given(mockEmf.createEntityManager()).willReturn(sharedEm, mockEm); LocalContainerEntityManagerFactoryBean cefb = parseValidPersistenceUnit(); JpaTransactionManager jpatm = new JpaTransactionManager(); jpatm.setEntityManagerFactory(cefb.getObject()); TransactionStatus txStatus = jpatm.getTransaction(new DefaultTransactionAttribute()); EntityManagerFactory emf = cefb.getObject(); assertSame("EntityManagerFactory reference must be cached after init", emf, cefb.getObject()); assertNotSame("EMF must be proxied", mockEmf, emf); EntityManager em = emf.createEntityManager(); em.joinTransaction(); assertFalse(em.contains(testEntity)); jpatm.commit(txStatus); cefb.destroy(); verify(mockTx).begin(); verify(mockTx).commit(); verify(mockEm).contains(testEntity); verify(mockEmf).close(); }
em.joinTransaction(); assertFalse(em.contains(testEntity));