1. Java Unit Testing
2. A Simple Unit Test
3. Assert Methods
4. Matchers
5. Testing for Exceptions
6. Stub, Mock and Proxy Testing
7. Subclass Mock Objects
8. Mock Testing isn't Always Enough
9. IO Testing
10. Servlet Unit Testing
11. Unit Testing with Dependency Injection Containers
12. Database Unit Testing - Rollback Transactions
13. Database Unit Testing - CRUD Testing
14. Database Unit Testing - Test Data Creation
15. Running Unit Tests With Ant
16. Running Unit Tests With Maven
17. Running Unit Tests Inside IntelliJ IDEA
18. Code Coverage
19. Design for Testability
20. Test First Development

If you are testing a component that uses a database, e.g. a DAO class, you may want to test that the component really inserts data into the database, updates it etc.

When testing if database components work correctly, you often have to insert a lot of data into the database, so the components have some data to work on. Unfortunately, this also means that you have to clean up all that data, when the unit test finishes, in order not to disturb other unit tests that setup data too.

A smart way to achieve this is by running the unit test inside a transaction. All data is inserted, read etc. inside the same transaction. When the unit test finishes, you can just rollback the transaction, and all the inserted data will be gone.

Here is a simple template showing you how to do this:

@Test
public void testIt() throws Exception {

  Connection connection = getConnection();
  connection.setAutoCommit(false);    //begin transaction

  MyDao      myDao      = new MyDaoImpl(connection);

  try{
    
    myDao.insertABC("1");
    myDao.insertABC("2");

    assertEquals("1", myDao.readABC("1"));
    assertEquals("2", myDao.readABC("2"));

  } finally {
    connection.rollback();
    connection.close();
  }  
}

It is possible that your persistence technology does not allow you to access the database connection directly. But, usually you can still control the underlying transaction, and thus start and rollback a transaction.