org.springframework.test.context.transaction.AfterTransaction Java Examples

@AfterTransaction
public void afterTransaction() {
	String method = testName.getMethodName();
	switch (method) {
		case "commitTxAndStartNewTx":
		case "commitTxButDoNotStartNewTx": {
			assertUsers("Dogbert");
			break;
		}
		case "rollbackTxAndStartNewTx":
		case "rollbackTxButDoNotStartNewTx":
		case "startTxWithExistingTransaction": {
			assertUsers("Dilbert");
			break;
		}
		case "rollbackTxAndStartNewTxWithDefaultCommitSemantics": {
			assertUsers("Dilbert", "Dogbert");
			break;
		}
		default: {
			fail("missing 'after transaction' assertion for test method: " + method);
		}
	}
}
 

/**
 * Overrides {@code afterTransaction()} in order to assert a different result.
 *
 * <p>See in-line comments for details.
 *
 * @see AbstractTransactionalAnnotatedConfigClassTests#afterTransaction()
 * @see AbstractTransactionalAnnotatedConfigClassTests#modifyTestDataWithinTransaction()
 */
@AfterTransaction
@Override
public void afterTransaction() {
	assertEquals("Deleting yoda", 1, deletePerson(YODA));

	// NOTE: We would actually expect that there are now ZERO entries in the
	// person table, since the transaction is rolled back by the framework;
	// however, since our JdbcTemplate and the transaction manager used by
	// the Spring TestContext Framework use two different DataSource
	// instances, our insert statements were executed in transactions that
	// are not controlled by the test framework. Consequently, there was no
	// rollback for the two insert statements in
	// modifyTestDataWithinTransaction().
	//
	assertNumRowsInPersonTable(2, "after a transactional test method");
}
 

/**
 * Overrides {@code afterTransaction()} in order to assert a different result.
 *
 * <p>See in-line comments for details.
 *
 * @see AbstractTransactionalAnnotatedConfigClassTests#afterTransaction()
 * @see AbstractTransactionalAnnotatedConfigClassTests#modifyTestDataWithinTransaction()
 */
@AfterTransaction
@Override
public void afterTransaction() {
	assertEquals("Deleting yoda", 1, deletePerson(YODA));

	// NOTE: We would actually expect that there are now ZERO entries in the
	// person table, since the transaction is rolled back by the framework;
	// however, since our JdbcTemplate and the transaction manager used by
	// the Spring TestContext Framework use two different DataSource
	// instances, our insert statements were executed in transactions that
	// are not controlled by the test framework. Consequently, there was no
	// rollback for the two insert statements in
	// modifyTestDataWithinTransaction().
	//
	assertNumRowsInPersonTable(2, "after a transactional test method");
}
 

@AfterTransaction
public void afterTransaction() {
	String method = testName.getMethodName();
	switch (method) {
		case "commitTxAndStartNewTx":
		case "commitTxButDoNotStartNewTx": {
			assertUsers("Dogbert");
			break;
		}
		case "rollbackTxAndStartNewTx":
		case "rollbackTxButDoNotStartNewTx":
		case "startTxWithExistingTransaction": {
			assertUsers("Dilbert");
			break;
		}
		case "rollbackTxAndStartNewTxWithDefaultCommitSemantics": {
			assertUsers("Dilbert", "Dogbert");
			break;
		}
		default: {
			fail("missing 'after transaction' assertion for test method: " + method);
		}
	}
}
 

@AfterTransaction
public void afterTransaction() {
	String method = testName.getMethodName();
	switch (method) {
		case "commitTxAndStartNewTx":
		case "commitTxButDoNotStartNewTx": {
			assertUsers("Dogbert");
			break;
		}
		case "rollbackTxAndStartNewTx":
		case "rollbackTxButDoNotStartNewTx":
		case "startTxWithExistingTransaction": {
			assertUsers("Dilbert");
			break;
		}
		case "rollbackTxAndStartNewTxWithDefaultCommitSemantics": {
			assertUsers("Dilbert", "Dogbert");
			break;
		}
		default: {
			fail("missing 'after transaction' assertion for test method: " + method);
		}
	}
}
 

@AfterTransaction
public void afterTransaction() {
	switch (method) {
		case "commitTxAndStartNewTx":
		case "commitTxButDoNotStartNewTx": {
			assertUsers("Dogbert");
			break;
		}
		case "rollbackTxAndStartNewTx":
		case "rollbackTxButDoNotStartNewTx":
		case "startTxWithExistingTransaction": {
			assertUsers("Dilbert");
			break;
		}
		case "rollbackTxAndStartNewTxWithDefaultCommitSemantics": {
			assertUsers("Dilbert", "Dogbert");
			break;
		}
		default: {
			fail("missing 'after transaction' assertion for test method: " + method);
		}
	}
}
 

@AfterTransaction
public void afterTransaction() {
	switch (method) {
		case "commitTxAndStartNewTx":
		case "commitTxButDoNotStartNewTx": {
			assertUsers("Dogbert");
			break;
		}
		case "rollbackTxAndStartNewTx":
		case "rollbackTxButDoNotStartNewTx":
		case "startTxWithExistingTransaction": {
			assertUsers("Dilbert");
			break;
		}
		case "rollbackTxAndStartNewTxWithDefaultCommitSemantics": {
			assertUsers("Dilbert", "Dogbert");
			break;
		}
		default: {
			fail("missing 'after transaction' assertion for test method: " + method);
		}
	}
}
 

/**
 * Overrides {@code afterTransaction()} in order to assert a different result.
 *
 * <p>See in-line comments for details.
 *
 * @see AbstractTransactionalAnnotatedConfigClassTests#afterTransaction()
 * @see AbstractTransactionalAnnotatedConfigClassTests#modifyTestDataWithinTransaction()
 */
@AfterTransaction
@Override
public void afterTransaction() {
	assertEquals("Deleting yoda", 1, deletePerson(YODA));

	// NOTE: We would actually expect that there are now ZERO entries in the
	// person table, since the transaction is rolled back by the framework;
	// however, since our JdbcTemplate and the transaction manager used by
	// the Spring TestContext Framework use two different DataSource
	// instances, our insert statements were executed in transactions that
	// are not controlled by the test framework. Consequently, there was no
	// rollback for the two insert statements in
	// modifyTestDataWithinTransaction().
	//
	assertNumRowsInPersonTable(2, "after a transactional test method");
}
 

@AfterTransaction
public void afterTransaction() {
	switch (method) {
		case "commitTxAndStartNewTx":
		case "commitTxButDoNotStartNewTx": {
			assertUsers("Dogbert");
			break;
		}
		case "rollbackTxAndStartNewTx":
		case "rollbackTxButDoNotStartNewTx":
		case "startTxWithExistingTransaction": {
			assertUsers("Dilbert");
			break;
		}
		case "rollbackTxAndStartNewTxWithDefaultCommitSemantics": {
			assertUsers("Dilbert", "Dogbert");
			break;
		}
		default: {
			fail("missing 'after transaction' assertion for test method: " + method);
		}
	}
}
 

@AfterTransaction
public void afterTransaction() {
	assertEquals(1, txManager1.begun);
	assertEquals(0, txManager1.inflight);
	assertEquals(0, txManager1.commits);
	assertEquals(1, txManager1.rollbacks);
}
 

@AfterTransaction
public void afterTransaction() {
	assertEquals(1, txManager1.begun);
	assertEquals(0, txManager1.inflight);
	assertEquals(0, txManager1.commits);
	assertEquals(1, txManager1.rollbacks);

	assertEquals(0, txManager2.begun);
	assertEquals(0, txManager2.inflight);
	assertEquals(0, txManager2.commits);
	assertEquals(0, txManager2.rollbacks);
}
 

@AfterTransaction
public void afterTransaction() {
	if ("test01".equals(testName.getMethodName())) {
		try {
			assertNumUsers(99);
			fail("Should throw a BadSqlGrammarException after test01, assuming 'drop-schema.sql' was executed");
		}
		catch (BadSqlGrammarException e) {
			/* expected */
		}
	}
}
 

@AfterTransaction
public void afterTransaction() {
	assertEquals(1, txManager1.begun);
	assertEquals(0, txManager1.inflight);
	assertEquals(0, txManager1.commits);
	assertEquals(1, txManager1.rollbacks);
}
 

@AfterTransaction
public void afterTransaction() {
	assertEquals(1, txManager1.begun);
	assertEquals(0, txManager1.inflight);
	assertEquals(0, txManager1.commits);
	assertEquals(1, txManager1.rollbacks);
}
 

@AfterTransaction
void afterTransaction() {
	assertInTransaction(false);
	this.inTransaction = false;
	BeforeAndAfterTransactionAnnotationTests.numAfterTransactionCalls++;
	assertEquals("Deleting yoda", 1, deletePerson(jdbcTemplate, YODA));
	assertEquals("Verifying the number of rows in the person table after a transactional test method.", 0,
		countRowsInPersonTable(jdbcTemplate));
}
 

@AfterTransaction
public void afterTransaction() {
	assertEquals(1, txManager.begun);
	assertEquals(0, txManager.inflight);
	assertEquals(0, txManager.commits);
	assertEquals(1, txManager.rollbacks);
}
 

@AfterTransaction
public void afterTransaction() {
	assertEquals(1, txManager1.begun);
	assertEquals(0, txManager1.inflight);
	assertEquals(0, txManager1.commits);
	assertEquals(1, txManager1.rollbacks);

	assertEquals(0, txManager2.begun);
	assertEquals(0, txManager2.inflight);
	assertEquals(0, txManager2.commits);
	assertEquals(0, txManager2.rollbacks);
}
 

@AfterTransaction
public void afterTransaction() {
	assertEquals(1, txManager1.begun);
	assertEquals(0, txManager1.inflight);
	assertEquals(0, txManager1.commits);
	assertEquals(1, txManager1.rollbacks);
}
 

@AfterTransaction
public void afterTransaction() {
	if ("test01".equals(testName.getMethodName())) {
		try {
			assertNumUsers(99);
			fail("Should throw a BadSqlGrammarException after test01, assuming 'drop-schema.sql' was executed");
		}
		catch (BadSqlGrammarException e) {
			/* expected */
		}
	}
}
 

@AfterTransaction
public void destroy() {
    for (String jobName : ImmutableList.of(JOB1, JOB2, JOB3)) {
        JobInterface job = jobDao.findJob(jobName);
        jobDao.updateJobFinished(job);
        jobDao.deleteJob(job);
    }
}
 

@AfterTransaction
public void verifyFinalDatabaseState() {
  Assert.assertEquals(0, appRepository.count());
  Assert.assertEquals(7, appNamespaceRepository.count());
  Assert.assertEquals(0, namespaceRepository.count());
  Assert.assertEquals(0, clusterRepository.count());
}
 

@AfterTransaction
public void afterTransaction() {
	assertInTransaction(false);
	this.inTransaction = false;
	BeforeAndAfterTransactionAnnotationTests.numAfterTransactionCalls++;
	assertEquals("Deleting yoda", 1, deletePerson(jdbcTemplate, YODA));
	assertEquals("Verifying the number of rows in the person table after a transactional test method.", 0,
		countRowsInPersonTable(jdbcTemplate));
}
 

@AfterTransaction
public void afterTransaction() {
	assertEquals(1, txManager1.begun);
	assertEquals(0, txManager1.inflight);
	assertEquals(0, txManager1.commits);
	assertEquals(1, txManager1.rollbacks);

	assertEquals(0, txManager2.begun);
	assertEquals(0, txManager2.inflight);
	assertEquals(0, txManager2.commits);
	assertEquals(0, txManager2.rollbacks);
}
 

@AfterTransaction
public void afterTransaction() {
	assertEquals(1, txManager1.begun);
	assertEquals(0, txManager1.inflight);
	assertEquals(0, txManager1.commits);
	assertEquals(1, txManager1.rollbacks);
}
 

@AfterTransaction
public void afterTransaction() {
	assertEquals(1, txManager1.begun);
	assertEquals(0, txManager1.inflight);
	assertEquals(0, txManager1.commits);
	assertEquals(1, txManager1.rollbacks);
}
 

@AfterTransaction
public void afterTransaction() {
	assertEquals(1, txManager1.begun);
	assertEquals(0, txManager1.inflight);
	assertEquals(0, txManager1.commits);
	assertEquals(1, txManager1.rollbacks);
}
 

@AfterTransaction
public void afterTransaction() {
	assertEquals(1, txManager.begun);
	assertEquals(0, txManager.inflight);
	assertEquals(0, txManager.commits);
	assertEquals(1, txManager.rollbacks);
}
 

@AfterTransaction
public void afterTransaction() {
	assertEquals(1, txManager1.begun);
	assertEquals(0, txManager1.inflight);
	assertEquals(0, txManager1.commits);
	assertEquals(1, txManager1.rollbacks);
}
 

@AfterTransaction
public void afterTransaction() {
	if ("test01".equals(testName.getMethodName())) {
		try {
			assertNumUsers(99);
			fail("Should throw a BadSqlGrammarException after test01, assuming 'drop-schema.sql' was executed");
		}
		catch (BadSqlGrammarException e) {
			/* expected */
		}
	}
}
 

@AfterTransaction
public void assertAfterTransaction() {
    if (nonNull(afterTransactionAssertion)) {
        final RedisConnection connection = connectionFactory.getConnection();
        afterTransactionAssertion.assertAfterTransaction(connection);
        connection.close();
    }
}