jpatransactionmanagertests.java

struts+spring 源码 希望能给大家带来帮助

						}
					});
				}
			});
			fail("expected exception");
		}
		catch (RuntimeException e) {
			// okay
		}

		assertTrue("Hasn't thread pm", !TransactionSynchronizationManager.hasResource(factory));
		assertTrue("JTA synchronizations not active", !TransactionSynchronizationManager.isSynchronizationActive());

		factoryControl.verify();
		managerControl.verify();
		txControl.verify();
	}

	public void testParticipatingTransactionWithRollbackOnly() {
		managerControl.expectAndReturn(manager.getTransaction(), tx);
		managerControl.expectAndReturn(manager.getTransaction(), tx);
		managerControl.expectAndReturn(manager.getTransaction(), tx);
		managerControl.expectAndReturn(manager.getTransaction(), tx);
		manager.flush();

		factoryControl.replay();
		managerControl.replay();
		txControl.replay();

		final List<String> l = new ArrayList<String>();
		l.add("test");

		assertTrue("Hasn thread emf", !TransactionSynchronizationManager.hasResource(factory));
		assertTrue("JTA synchronizations is active", !TransactionSynchronizationManager.isSynchronizationActive());

		try {
			tt.execute(new TransactionCallback() {
				public Object doInTransaction(TransactionStatus status) {
					txControl.reset();
					txControl.expectAndReturn(tx.isActive(), true);
					txControl.expectAndReturn(tx.isActive(), true);
					tx.setRollbackOnly();
					txControl.expectAndReturn(tx.getRollbackOnly(), true);
					tx.commit();
					txControl.setThrowable(new RollbackException());
					txControl.replay();

					assertTrue("Has no thread em", TransactionSynchronizationManager.hasResource(factory));

					return tt.execute(new TransactionCallback() {
						public Object doInTransaction(TransactionStatus status) {

							template.execute(new JpaCallback() {
								public Object doInJpa(EntityManager em2) {
									em2.flush();
									return l;
								}
							});

							status.setRollbackOnly();
							return null;
						}
					});
				}
			});
			fail("expected exception");
		}
		catch (UnexpectedRollbackException ure) {
			// it's okay
			assertTrue(ure.getCause() instanceof RollbackException);
		}

		assertTrue("Hasn't thread pm", !TransactionSynchronizationManager.hasResource(factory));
		assertTrue("JTA synchronizations not active", !TransactionSynchronizationManager.isSynchronizationActive());

		factoryControl.verify();
		managerControl.verify();
		txControl.verify();
	}

	public void testParticipatingTransactionWithWithRequiresNew() {
		factoryControl.expectAndReturn(factory.createEntityManager(), manager);
		managerControl.expectAndReturn(manager.getTransaction(), tx);
		managerControl.expectAndReturn(manager.getTransaction(), tx);
		managerControl.expectAndReturn(manager.getTransaction(), tx);
		managerControl.expectAndReturn(manager.getTransaction(), tx);
		managerControl.expectAndReturn(manager.getTransaction(), tx);
		managerControl.expectAndReturn(manager.getTransaction(), tx);

		tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);
		manager.flush();
		manager.close();
		factoryControl.replay();
		managerControl.replay();
		txControl.replay();

		final List<String> l = new ArrayList<String>();
		l.add("test");

		assertTrue("Hasn thread emf", !TransactionSynchronizationManager.hasResource(factory));
		assertTrue("JTA synchronizations is active", !TransactionSynchronizationManager.isSynchronizationActive());

		Object result = tt.execute(new TransactionCallback() {
			public Object doInTransaction(TransactionStatus status) {
				txControl.verify();
				txControl.reset();
				txControl.expectAndReturn(tx.isActive(), true);

				tx.begin();
				txControl.expectAndReturn(tx.getRollbackOnly(), false);
				tx.commit();
				txControl.expectAndReturn(tx.getRollbackOnly(), false);
				tx.commit();

				txControl.replay();

				assertTrue("Has no thread em", TransactionSynchronizationManager.hasResource(factory));
				return tt.execute(new TransactionCallback() {
					public Object doInTransaction(TransactionStatus status) {
						return template.execute(new JpaCallback() {
							public Object doInJpa(EntityManager em2) {
								em2.flush();
								return l;
							}
						});
					}
				});
			}
		});

		assertSame("different lists", l, result);

		assertTrue("Hasn't thread pm", !TransactionSynchronizationManager.hasResource(factory));
		assertTrue("JTA synchronizations not active", !TransactionSynchronizationManager.isSynchronizationActive());

		factoryControl.verify();
		managerControl.verify();
		txControl.verify();
	}

	public void testParticipatingTransactionWithWithRequiresNewAndPrebound() {
		factoryControl.expectAndReturn(factory.createEntityManager(), manager);
		managerControl.expectAndReturn(manager.getTransaction(), tx);
		managerControl.expectAndReturn(manager.getTransaction(), tx);
		managerControl.expectAndReturn(manager.getTransaction(), tx);
		managerControl.expectAndReturn(manager.getTransaction(), tx);
		managerControl.expectAndReturn(manager.getTransaction(), tx);
		managerControl.expectAndReturn(manager.getTransaction(), tx);
		managerControl.expectAndReturn(manager.getTransaction(), tx);

		tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);
		txControl.expectAndReturn(tx.isActive(), true);
		manager.flush();
		manager.close();
		factoryControl.replay();
		managerControl.replay();
		txControl.replay();

		final List<String> l = new ArrayList<String>();
		l.add("test");

		assertTrue("JTA synchronizations is active", !TransactionSynchronizationManager.isSynchronizationActive());
		TransactionSynchronizationManager.bindResource(factory, new EntityManagerHolder(manager));
		assertTrue("Has no thread emf", TransactionSynchronizationManager.hasResource(factory));

		try {
			Object result = tt.execute(new TransactionCallback() {
				public Object doInTransaction(TransactionStatus status) {
					txControl.verify();
					txControl.reset();
					txControl.expectAndReturn(tx.isActive(), true);

					tx.begin();
					txControl.expectAndReturn(tx.getRollbackOnly(), false);
					tx.commit();
					txControl.expectAndReturn(tx.getRollbackOnly(), false);
					tx.commit();

					txControl.replay();

					JpaTemplate template2 = new JpaTemplate(factory);
					template2.execute(new JpaCallback() {

						public Object doInJpa(EntityManager em) throws PersistenceException {
							return null;
						}
					});

					assertTrue("Has no thread em", TransactionSynchronizationManager.hasResource(factory));
					return tt.execute(new TransactionCallback() {
						public Object doInTransaction(TransactionStatus status) {
							return template.execute(new JpaCallback() {
								public Object doInJpa(EntityManager em2) {
									em2.flush();
									return l;
								}
							});
						}
					});
				}
			});
			assertSame("different lists", l, result);
		}
		finally {
			TransactionSynchronizationManager.unbindResource(factory);
		}

		assertTrue("Hasn't thread pm", !TransactionSynchronizationManager.hasResource(factory));
		assertTrue("JTA synchronizations not active", !TransactionSynchronizationManager.isSynchronizationActive());

		factoryControl.verify();
		managerControl.verify();
		txControl.verify();
	}

	public void testTransactionCommitWithPropagationSupports() {
		managerControl.reset();
		txControl.reset();
		manager.flush();
		manager.close();

		factoryControl.replay();
		managerControl.replay();
		txControl.replay();

		final List<String> l = new ArrayList<String>();
		l.add("test");

		tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_SUPPORTS);

		assertTrue("Has thread emf", !TransactionSynchronizationManager.hasResource(factory));
		assertTrue("JTA synchronizations is active", !TransactionSynchronizationManager.isSynchronizationActive());

		Object result = tt.execute(new TransactionCallback() {
			public Object doInTransaction(TransactionStatus status) {
				assertTrue("Has thread emf", !TransactionSynchronizationManager.hasResource(factory));
				assertTrue("JTA synchronizations is not active",
						TransactionSynchronizationManager.isSynchronizationActive());
				assertTrue("Is not new transaction", !status.isNewTransaction());

				return template.execute(new JpaCallback() {
					public Object doInJpa(EntityManager em) {
						em.flush();
						return l;
					}
				});
			}
		});

		assertTrue("Correct result list", result == l);

		assertTrue("Hasn't thread pm", !TransactionSynchronizationManager.hasResource(factory));
		assertTrue("JTA synchronizations not active", !TransactionSynchronizationManager.isSynchronizationActive());

		factoryControl.verify();
		managerControl.verify();
		txControl.verify();
	}

	public void testInvalidIsolation() {
		tt.setIsolationLevel(TransactionDefinition.ISOLATION_SERIALIZABLE);
		txControl.reset();
		managerControl.reset();

		manager.close();

		factoryControl.replay();
		managerControl.replay();
		txControl.replay();

		try {
			tt.execute(new TransactionCallbackWithoutResult() {
				protected void doInTransactionWithoutResult(TransactionStatus status) {
				}
			});
			fail("Should have thrown InvalidIsolationLevelException");
		}
		catch (InvalidIsolationLevelException ex) {
			// expected
		}

		factoryControl.verify();
		managerControl.verify();
		txControl.verify();
	}

	public void testTransactionCommitWithPrebound() {
		factoryControl.reset();
		managerControl.reset();
		txControl.reset();
		
		managerControl.expectAndReturn(manager.getTransaction(), tx);
		txControl.expectAndReturn(tx.isActive(), true);
		manager.joinTransaction();
		
		factoryControl.replay();
		managerControl.replay();
		txControl.replay();

		final List<String> l = new ArrayList<String>();
		l.add("test");
		try {
			assertTrue("JTA synchronizations active", !TransactionSynchronizationManager.isSynchronizationActive());
			TransactionSynchronizationManager.bindResource(factory, new EntityManagerHolder(manager));
			assertTrue("Has no thread pm", TransactionSynchronizationManager.hasResource(factory));

			Object result = tt.execute(new TransactionCallback() {
				public Object doInTransaction(TransactionStatus status) {
					assertTrue("Has no thread pm", TransactionSynchronizationManager.hasResource(factory));
					return template.execute(new JpaCallback() {
						public Object doInJpa(EntityManager em) {
							return l;
						}
					});
				}
			});
			assertTrue("Correct result list", result == l);

			assertTrue("Has thread pm", TransactionSynchronizationManager.hasResource(factory));

		}
		finally {
			TransactionSynchronizationManager.unbindResource(factory);
		}
		assertTrue("JTA synchronizations not active", !TransactionSynchronizationManager.isSynchronizationActive());

		factoryControl.verify();
		managerControl.verify();
		txControl.verify();
	}

	public void testTransactionCommitWithDataSource() throws SQLException {
		MockControl dsControl = MockControl.createControl(DataSource.class);
		DataSource ds = (DataSource) dsControl.getMock();
		transactionManager.setDataSource(ds);
		
		managerControl.expectAndReturn(manager.getTransaction(), tx);
		managerControl.expectAndReturn(manager.getTransaction(), tx);
		txControl.expectAndReturn(tx.getRollbackOnly(), false);
		tx.commit();
		manager.flush();
		
		factoryControl.replay();
		managerControl.replay();
		txControl.replay();
		dsControl.replay();

		final List<String> l = new ArrayList<String>();
		l.add("test");

		assertTrue("Has thread emf", !TransactionSynchronizationManager.hasResource(factory));
		assertTrue("JTA synchronizations is active", !TransactionSynchronizationManager.isSynchronizationActive());

		Object result = tt.execute(new TransactionCallback() {
			public Object doInTransaction(TransactionStatus status) {
				assertTrue("Has no thread emf", TransactionSynchronizationManager.hasResource(factory));
				assertTrue("JTA synchronizations is not active",
						TransactionSynchronizationManager.isSynchronizationActive());
	
				return template.execute(new JpaCallback() {
					public Object doInJpa(EntityManager em) {
						em.flush();
						return l;
					}
				});
			}
		});
		
		assertTrue("Correct result list", result == l);

		assertTrue("Hasn't thread pm", !TransactionSynchronizationManager.hasResource(factory));
		assertTrue("JTA synchronizations not active", !TransactionSynchronizationManager.isSynchronizationActive());

		factoryControl.verify();
		managerControl.verify();
		txControl.verify();
		dsControl.verify();
	}

}