JUnit + Derby + Spring: drop in-memory db after every test

Question

In my unit tests I autowired some DataSources, which use URLs like

jdbc:derby:memory:mydb;create=true

to create an in-memory DBs.

To drop an in-memory Derby db you have to connect with:

jdbc:derby:memory:mydb;drop=true

I would like this to happen after every test and start with a fresh db. How can I do this using Spring?

Answer 1

How to shutdown Derby in-memory database Properly

gave me a hint to a solution:

    mydb.drop.url = jdbc:derby:memory:mydb;drop=true

    ...

    <bean id="mydbDropUrl" class="java.lang.String">
    <constructor-arg value="${mydb.drop.url}" />
</bean>

    ...

    @Resource
private String mydbDropUrl;        

    @After
public void tearDown() {
    try {
        DriverManager.getConnection(mydbDropUrl);
    } catch (SQLException e) {
        // ignore
    }
}

A downside is the use of the String constructor which accepts a String (an immutable String object around an immutable String object). I read that there is a @Value annotation in Spring 3, which might help here, but I'm using Spring 2.5.

Please let me know if you have a nicer solution.

Answer 2

There is a database-agnostic way to do this if you are using Spring together with Hibernate.

Make sure the application context will be created / destroyed before / after every test method:

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration({"classpath*:application-context-test.xml"})
@TestExecutionListeners({DirtiesContextTestExecutionListener.class, 
    DependencyInjectionTestExecutionListener.class})
@DirtiesContext(classMode = ClassMode.AFTER_EACH_TEST_METHOD)
public abstract class AbstractTest {

}

Instruct Hibernate to auto create the schema on startup and to drop the schema on shutdown:

hibernate.hbm2ddl.auto = create-drop

Now before every test

• the application context is created and the required spring beans are injected (spring)
• the database structures are created (hibernate)
• the import.sql is executed if present (hibernate)

and after every test

• the application context is destroyed (spring)
• the database schema is dropped (hibernate).

If you are using transactions, you may want to add the TransactionalTestExecutionListener.

Answer 3

After spring test 3, you can use annotations to inject configurations:

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("/spring-test.xml")
public class MyTest {
}

Answer 4

If you use the spring-test.jar library, you can do something like this:

public class MyDataSourceSpringTest extends
AbstractTransactionalDataSourceSpringContextTests {

    @Override
    protected String[] getConfigLocations() {
        return new String[]{"classpath:test-context.xml"};
    }

    @Override
    protected void onSetUpInTransaction() throws Exception {
        super.deleteFromTables(new String[]{"myTable"});
        super.executeSqlScript("file:db/load_data.sql", true);
    }
}

And an updated version based on latest comment, that drops db and recreates tables before every test:

public class MyDataSourceSpringTest extends
    AbstractTransactionalDataSourceSpringContextTests {

        @Override
        protected String[] getConfigLocations() {
            return new String[]{"classpath:test-context.xml"};
        }

        @Override
        protected void onSetUpInTransaction() throws Exception {
            super.executeSqlScript("file:db/recreate_tables.sql", true);
        }
}

Answer 5

Just do something like:

public class DatabaseTest implements ApplicationContextAware {
    private ApplicationContext context;
    private DataSource source;

    public void setApplicationContext(ApplicationContext applicationContext) {
        this.context = applicationContext;
    }

    @Before
    public void before() {
        source = (DataSource) dataSource.getBean("dataSource", DataSource.class);
    }

    @After
    public void after() {
        source = null;
    }
}

Make your bean have a scope of prototype (scope="prototype"). This will get a new instance of the data source before every test.

Answer 6

This is what we do at the start of every test.

1. Drop all Previous Objects.

2. Create all tables mentioned in the create_table.sql

3. Insert values onto the created tables based on what you want to test.

     @Before
     public void initialInMemoryDatabase() throws IOException, FileNotFoundException {
   
     inMemoryDerbyDatabase.dropAllObjects();
     inMemoryDerbyDatabase.executeSqlFile("/create_table_policy_version_manager.sql");
     inMemoryDerbyDatabase.executeSqlFile("/insert_table_policy_version_manager.sql");
   
     }
   

Works like a charm!