@Configuration
@Validated
public class DbUnitConfiguration
{
    /**
     * Extend DefaultPrepAndExpectedTestCase to customize DatabaseConfig.
     */
    private class MyPrepAndExpectedTestCase
            extends DefaultPrepAndExpectedTestCase
    {
        public MyPrepAndExpectedTestCase(
                final DataFileLoader dataFileLoader,
                final IDatabaseTester databaseTester)
        {
            super(dataFileLoader, databaseTester);
        }

        @Override
        protected void setUpDatabaseConfig(final DatabaseConfig config)
        {
            // set properties as needed

            config.setProperty(DatabaseConfig.FEATURE_BATCHED_STATEMENTS, true);

            // set the specific IDataTypeFactory if needed
            config.setProperty(DatabaseConfig.PROPERTY_DATATYPE_FACTORY, new XxxDataTypeFactory());
        }
    }

    /**
     * Create dbUnit {@link PrepAndExpectedTestCase} for running dbUnit database
     * tests.
     *
     * @param dataFileLoader
     *            The {@link DataFileLoader} used to load the test's specified
     *            data files.
     * @param databaseTester
     *            The {@link IDatabaseTester} used to run the tests against the
     *            database.
     * @return Configured dbUnit {@link PrepAndExpectedTestCase} for running
     *         dbUnit database tests.
     */
    @Bean
    public PrepAndExpectedTestCase prepAndExpectedTestCase(
            final DataFileLoader dataFileLoader,
            final IDatabaseTester databaseTester)
    {
        return new MyPrepAndExpectedTestCase(dataFileLoader, databaseTester);
    }

    /**
     * Create dbUnit {@link DataFileLoader} for loading the test's dbUnit data
     * files.
     *
     * @param ddr
     *            Your local class containing the replacement definitions.
     * @return Configured dbUnit {@link DataFileLoader} for loading the test's
     *         dbUnit data files.
     */
    @Bean
    public DataFileLoader dataFileLoader(final DbunitDataReplacement ddr)
    {
        final Map<String, Object> replacementObjects = ddr.getReplacementObjects();
        final Map<String, Object> replacementSubstrings = ddr.getReplacementSubstrings();
        return new FlatXmlDataFileLoader(replacementObjects, replacementSubstrings);
    }

    /**
     * Create dbUnit {@link IDatabaseTester}.
     * 
     * @param dataSource
     *            The {@link DataSource} for the dbUnit test to use.
     * @return Configured dbUnit {@link IDatabaseTester}.
     */
    @Bean
    public IDatabaseTester databaseTester(final DataSource dataSource)
    {
        final DataSource dataSourceProxy = new TransactionAwareDataSourceProxy(dataSource);

        final IDatabaseTester databaseTester = new DataSourceDatabaseTester(dataSourceProxy);
        databaseTester.setTearDownOperation(DatabaseOperation.DELETE_ALL);

        return databaseTester;
    }
}

/**
 * Class containing replacement objects and replacement substrings for
 * substitution in dbUnit datasets.
 */
@Component
public class DbUnitDataReplacement
{
    private final Map<String, Object> replacementObjects = new HashMap<>();
    private final Map<String, Object> replacementSubstrings = new HashMap<>();

    public DbUnitDataReplacement()
    {
        populateReplacementObjects();
        populateReplacementSubstrings();
    }

    /**
     * Make replacement objects and populate the map with them.
     */
    private void populateReplacementObjects()
    {
        replacementObjects.put("[IGNORE]", null);
        replacementObjects.put("[NULL]", null);
        replacementObjects.put("[TIMESTAMP_TODAY]", TestDatabaseDates.TIMESTAMP_TODAY);
        replacementObjects.put("[TIMESTAMP_TOMORROW]", TestDatabaseDates.TIMESTAMP_TOMORROW);
        replacementObjects.put("[TIMESTAMP_YESTERDAY]", TestDatabaseDates.TIMESTAMP_YESTERDAY);
    }

    /**
     * Make replacement substrings and populate the map with them.
     */
    private void populateReplacementSubstrings()
    {
    }

    public Map<String, Object> getReplacementObjects()
    {
        return replacementObjects;
    }

    public Map<String, Object> getReplacementSubstrings()
    {
        return replacementSubstrings;
    }
}

/**
 * Dates for testing with database dates.
 */
@Component
public class TestDatabaseDates
{
    public static final Period ONE_DAY = Period.ofDays(1);

    public static final Instant NOW = Instant.now();

    public static final Timestamp TIMESTAMP_TODAY = asTimestamp(NOW);
    public static final Timestamp TIMESTAMP_TOMORROW = asTimestamp(NOW.plus(ONE_DAY));
    public static final Timestamp TIMESTAMP_YESTERDAY = asTimestamp(NOW.minus(ONE_DAY));

    public static Timestamp asTimestamp(final Instant instant)
    {
        return Timestamp.from(instant);
    }
}

@Inject
private PrepAndExpectedTestCase testCase;

@Test
public void testExample() throws Exception
{
    final VerifyTableDefinition[] verifyTables = {}; // define tables to verify
    final String[] prepDataFiles = {}; // define prep files
    final String[] expectedDataFiles = {}; // define expected files
    final PrepAndExpectedTestCaseSteps testSteps = () -> {
        // execute test steps that exercise production code
        // e.g. call repository/DAO, call REST service

        // assert responses or other values

        // after this method exits, dbUnit will:
        //  * verify configured tables
        //  * cleanup tables as configured

        return null; // or an object for use/assert outside the Steps
    };

    testCase.runTest(verifyTables, prepDataFiles, expectedDataFiles, testSteps);
}

@Inject
private PrepAndExpectedTestCase testCase;

@Test
public void testExample() throws Exception
{
    try
    {
        final VerifyTableDefinition[] verifyTables = {}; // define tables to verify
        final String[] prepDataFiles = {}; // define prep files
        final String[] expectedDataFiles = {}; // define expected files

        testCase.preTest(verifyTables, prepDataFiles, expectedDataFiles);

        // execute test steps that exercise production code
        // e.g. call repository/DAO, call REST service

        // assert responses or other values
    } catch (Exception e)
    {
        log.error("Test error.", e);
        throw e;
    } finally
    {
        // verify configured tables and cleanup tables as configured
        testCase.postTest();
    }
}