Package org.dbunit

Class DefaultPrepAndExpectedTestCase

java.lang.Object
org.dbunit.DatabaseTestCase
org.dbunit.DBTestCase
org.dbunit.DefaultPrepAndExpectedTestCase
All Implemented Interfaces:
PrepAndExpectedTestCase, org.junit.jupiter.api.extension.Extension, org.junit.jupiter.api.extension.InvocationInterceptor, org.junit.jupiter.api.extension.TestInstantiationAwareExtension
public class DefaultPrepAndExpectedTestCase extends DBTestCase implements PrepAndExpectedTestCase
Test case base class supporting prep data and expected data. Prep data is the data needed for the test to run. Expected data is the data needed to compare if the test ran successfully.

configureTest(), setupData(), verifyData(), and cleanupData() share one IDatabaseConnection for a test's lifecycle, acquired lazily on first use and closed once by cleanupData(), instead of each acquiring (and often closing) its own. Calling any of those methods without an eventual cleanupData() call - e.g. testing them individually rather than through preTest()/postTest() - leaves that connection open.

If databaseTester is configured with a CachingConnectionProvider shared across test methods, set setCloseConnectionAfterTest(boolean) to false so cleanupData() does not close a connection other tests still expect to reuse; the provider's owner is then responsible for closing it once, itself, when the whole run finishes. Leaving the connection open, which a no-op listener on the databaseTester does too, requires a databaseTester that hands out the same connection on repeated calls, as one over a CachingConnectionProvider or over one fixed connection does. With one that hands out a new connection each time, such as a JdbcDatabaseTester without a CachingConnectionProvider or a DataSourceDatabaseTester over a connection pool, nothing closes the connection left open. An instance used for one test leaves one open after it. An instance reused across tests keeps one for its next test and leaves another open each time a step fails, because a failing step makes this class forget the connection so that the next step acquires another. This class logs a warning when it detects a JdbcDatabaseTester without a CachingConnectionProvider in that situation.

The databaseTester's own IOperationListener is told about the connection each of setupData()'s and cleanupData()'s operations retrieves, through IOperationListener.connectionRetrieved(org.dbunit.database.IDatabaseConnection), so a listener that configures every connection runs here as it does when the tester drives onSetup() and onTearDown() itself. It is never told the operations finished, as this class decides when the shared connection closes.

The connection must be in autocommit mode. The setup and teardown operations run here (CLEAN_INSERT, DELETE_ALL, ...) do not manage a transaction of their own, and TransactionOperation refuses a connection whose autocommit is already off, so on a non-autocommit connection the prep and teardown writes are never committed: invisible to any other connection, and - with setCloseConnectionAfterTest(boolean) false - held as locks on a connection the database's idle-in-transaction timeout may terminate mid-run. This class logs a warning when it detects such a connection.

The verifyData() method hands assertion failures to DefaultFailureHandler by default, which throws on the first mismatch found. Set setFailureHandler(FailureHandler) to, for example, a DiffCollectingFailureHandler to collect every Difference instead; that is not the default since most tests want to keep failing fast.

Not thread-safe. An instance holds the state of one test at a time: its datasets, verify table definitions, shared connection and row count baseline. Use one instance per concurrently running test, for example a Spring prototype bean, or turn off parallel execution for tests that share an instance, such as one in a static @DbUnitTestCase field. Otherwise concurrent tests overwrite each other's datasets and close each other's connection.

Since:
2.4.8
Version:
$Revision$ $Date$
Author:
Jeff Jensen jeffjensen AT users.sourceforge.net, Last changed by: $Author$
See Also:
  • "org.dbunit.DefaultPrepAndExpectedTestCaseDiIT, a composition-based (DI) usage example in the test sources"
  • "org.dbunit.DefaultPrepAndExpectedTestCaseExtIT, an inheritance-based usage example in the test sources"

  • Field Details

    • TEST_ERROR_MSG

      public static final String TEST_ERROR_MSG
      Message prefix used for wrapped test failures.
      See Also:

  • Constructor Details

    • DefaultPrepAndExpectedTestCase

      public DefaultPrepAndExpectedTestCase()
      Create new instance.

    • DefaultPrepAndExpectedTestCase

      public DefaultPrepAndExpectedTestCase(DataFileLoader dataFileLoader, IDatabaseTester databaseTester)
      Create new instance with specified dataFileLoader and databaseTester.
      Parameters:
      dataFileLoader - Load to use for loading the data files.
      databaseTester - Tester to use for database manipulation.

    • DefaultPrepAndExpectedTestCase

      public DefaultPrepAndExpectedTestCase(DataFileLoader dataFileLoader, IDatabaseTester databaseTester, boolean closeConnectionAfterTest)
      Create new instance with specified dataFileLoader and databaseTester.
      Parameters:
      dataFileLoader - Load to use for loading the data files.
      databaseTester - Tester to use for database manipulation.
      closeConnectionAfterTest - Whether or not to close the database connection after each test.
      Since:
      3.4.0

    • DefaultPrepAndExpectedTestCase

      public DefaultPrepAndExpectedTestCase(String name)
      Create new instance with specified test case name.
      Parameters:
      name - The test case name.

  • Method Details

    • newDatabaseTester

      public IDatabaseTester newDatabaseTester() throws Exception
      Creates a new IDatabaseTester. Default implementation returns a PropertiesBasedJdbcDatabaseTester. This implementation returns the databaseTester set by the test.
      Overrides:
      newDatabaseTester in class DBTestCase
      Returns:
      the newly created database tester.
      Throws:
      Exception - if the database tester cannot be created.

    • getDataSet

      public IDataSet getDataSet() throws Exception
      Returns the test dataset. Returns the prep dataset.
      Specified by:
      getDataSet in class DatabaseTestCase
      Returns:
      the test dataset.
      Throws:
      Exception - if the dataset cannot be retrieved or created.

    • configureTest

      public void configureTest(VerifyTableDefinition[] verifyTableDefinitions, String[] prepDataFiles, String[] expectedDataFiles) throws Exception
      Configure the test. Call this method before performing the test steps.

      Executes against the connection shared with setupData(), verifyData() and cleanupData() for this test's lifecycle rather than a fresh one, and leaves it open; cleanupData() closes it. See #800.

      A null argument means none. When this fails, for example because a data file is missing or invalid, this instance is left with no prep data, expected data or verify table definitions, so a cleanupData() that follows cleans nothing left over from an earlier test. The shared connection it acquired is released too; one the caller had already resolved, for example by injecting it into a test method parameter, is left open for the caller.

      Specified by:
      configureTest in interface PrepAndExpectedTestCase
      Parameters:
      verifyTableDefinitions - Table definitions to verify after test execution; null means none.
      prepDataFiles - The prep data files (as classpath resources) to load and insert contents into the database as seed data; null means none.
      expectedDataFiles - The expected data files (as classpath resources) to load as expected data and verify actual data matches at test end; null means none.
      Throws:
      Exception - if the test cannot be configured.

    • setUpDatabaseConfig

      protected void setUpDatabaseConfig(DatabaseConfig config)
      Designed to be overridden by subclasses in order to set additional configuration parameters for the IDatabaseConnection. Applies databaseConfigProperties, when set - the composition-based equivalent of overriding this method, for a caller that cannot subclass to do so directly (e.g. org.dbunit.annotation's @DbUnitProperty). The values replaced are put back when this test's lifecycle ends - see cleanupData().

      The lifecycle retrieves its connection several times, and each retrieval calls this method. The values are applied once per DatabaseConfig until they are put back, and a later call does nothing, so a property set on the DatabaseConfig directly in between is not overwritten. The exception is a database tester with an operation listener of its own, which may change any of the values at each set up and tear down operation: the values are applied again directly after it, so they still win.

      Note: a subclass overriding this method must call super.setUpDatabaseConfig(config) to keep setDatabaseConfigProperties(java.util.Properties) - and therefore @DbUnitProperty on the annotation-driven path - working.

      Overrides:
      setUpDatabaseConfig in class DatabaseTestCase
      Parameters:
      config - The settings of the current IDatabaseConnection to be configured
      Throws:
      IllegalStateException - If a property value is invalid for its target DatabaseConfig entry.

    • getReusableConnection

      public IDatabaseConnection getReusableConnection() throws Exception
      Return the connection shared by lookupFeatureValue(), setupData(), verifyData() and cleanupData() for the current test's lifecycle, acquiring it on first use instead of a fresh connection at each step.

      When closeConnectionAfterTest is false this connection is kept across test methods, where the connection pool or the database server can close it between tests - a pool max-lifetime or reap, a bounced application context, a CachingConnectionProvider.close(). A closed one is discarded before it is handed back, so the next call re-acquires from databaseTester - letting a CachingConnectionProvider behind it supply a live replacement - rather than this instance reusing a connection every later lifecycle step would only fail on.

      Specified by:
      getReusableConnection in interface PrepAndExpectedTestCase
      Returns:
      The shared connection.
      Throws:
      Exception - On dbUnit errors.
      Since:
      3.4.0

    • preTest

      public void preTest() throws Exception
      Execute pre-test steps. Call this method before performing the test steps.

      Captures the row count check baseline, if enabled, before setting up the prep data - see RowCountCheck.capture(IDatabaseConnection).

      Specified by:
      preTest in interface PrepAndExpectedTestCase
      Throws:
      Exception - if the pre-test steps fail.

    • preTest

      public void preTest(VerifyTableDefinition[] tables, String[] prepDataFiles, String[] expectedDataFiles) throws Exception
      Convenience method to call configureTest() and preTest().
      Specified by:
      preTest in interface PrepAndExpectedTestCase
      Parameters:
      tables - Table definitions to verify after test execution.
      prepDataFiles - The prep data files (as classpath resources) to load and insert contents into the database as seed data.
      expectedDataFiles - The expected data files (as classpath resources) to load as expected data and verify actual data matches at test end.
      Throws:
      Exception - if the pre-test steps fail.

    • runTest

      public Object runTest(VerifyTableDefinition[] verifyTables, String[] prepDataFiles, String[] expectedDataFiles, PrepAndExpectedTestCaseSteps testSteps) throws Exception
      Run the DbUnit test.
      Specified by:
      runTest in interface PrepAndExpectedTestCase
      Parameters:
      verifyTables - Table definitions to verify after test execution.
      prepDataFiles - The prep data files (as classpath resources) to load and insert contents into the database as seed data.
      expectedDataFiles - The expected data files (as classpath resources) to load as expected data and verify actual data matches at test end.
      testSteps - The test steps to run.
      Returns:
      User defined object from running the test steps.
      Throws:
      Exception - if the test steps fail.

    • runTestSteps

      protected Object runTestSteps(PrepAndExpectedTestCaseSteps testSteps) throws Exception
      Run the provided test steps. Override as necessary for custom logic.
      Parameters:
      testSteps - The test steps to run.
      Returns:
      the user-defined object returned by the test steps.
      Throws:
      Exception - if the test steps fail.

    • postTest

      public void postTest() throws Exception
      Execute all post-test steps. Call this method after performing the test steps.
      Specified by:
      postTest in interface PrepAndExpectedTestCase
      Throws:
      Exception - if the post-test steps fail.

    • postTest

      public void postTest(boolean verifyData) throws Exception
      Execute post-test steps. Call this method after performing the test steps.

      When verifyData is false - the test steps already failed - discards any captured row count check baseline, so cleanupData() skips that check too: the database is in an unknown state, so a count difference would be noise around the real failure, not a finding worth its own report. A verification failure discards it the same way, so cleanupData() does not throw a row count difference in its place: the comparison failure names what differs and is the one to fix first, while a cleanup failure still shadows it as before.

      Specified by:
      postTest in interface PrepAndExpectedTestCase
      Parameters:
      verifyData - Specify true to perform verify data steps, false to not. Useful to specify false when test has failure in progress (e.g. an exception) and verifying data would fail, masking original test failure.
      Throws:
      Exception - if the post-test steps fail.

    • cleanupData

      public void cleanupData() throws Exception
      Cleanup tables specified in prep and expected datasets, using the provided databaseTester. See IDatabaseTester.onTearDown().

      Runs the tear down operation against the connection shared with setupData() and verifyData() for this test's lifecycle, then closes it. See #800.

      Specified by:
      cleanupData in interface PrepAndExpectedTestCase
      Throws:
      Exception - if cleaning up the data fails.

    • setUp

      protected void setUp() throws Exception
      Legacy JUnit-3-era set-up hook. Not invoked automatically under JUnit 5; kept for subclasses that drive the lifecycle manually. Runs setupData() on the connection shared with the rest of this test's lifecycle, leaving the databaseTester's dataset and operation listener as the caller set them.
      Overrides:
      setUp in class DatabaseTestCase
      Throws:
      Exception - if the setup operation fails.

    • tearDown

      protected void tearDown() throws Exception
      Legacy JUnit-3-era tear-down hook. Not invoked automatically under JUnit 5; kept for subclasses that drive the lifecycle manually. Runs cleanupData(), which tears down the prep and expected tables once and releases the shared connection. Calling it after a full runTest(org.dbunit.VerifyTableDefinition[], java.lang.String[], java.lang.String[], org.dbunit.PrepAndExpectedTestCaseSteps) or postTest() cycle cleans up a second time, as both already ran cleanupData().
      Overrides:
      tearDown in class DatabaseTestCase
      Throws:
      Exception - if the tear-down operation fails.

    • tearDown

      protected void tearDown(Throwable testFailure) throws Throwable
      Legacy JUnit-3-era tear-down hook for a test whose failure is already in flight. Runs cleanupData() the same way as tearDown(), and throws testFailure afterward, with any clean up failure attached to it as suppressed rather than replacing it.
      Overrides:
      tearDown in class DatabaseTestCase
      Parameters:
      testFailure - The throwable already in flight from the test body, or null if there is none, in which case this behaves the same as tearDown().
      Throws:
      Throwable - The testFailure, if not null; otherwise a clean up failure, if one occurred.

    • setupData

      public void setupData() throws Exception
      Use the provided databaseTester to prep the database with the provided prep dataset. See IDatabaseTester.onSetup().

      Executes against the connection shared with verifyData() and cleanupData() for this test's lifecycle rather than a fresh one, and leaves it open; cleanupData() closes it. See #800.

      Throws:
      Exception - if preparing the data fails.

    • getSetUpOperation

      protected DatabaseOperation getSetUpOperation() throws Exception
      Description copied from class: DatabaseTestCase
      Returns the database operation executed in test setup.
      Overrides:
      getSetUpOperation in class DatabaseTestCase
      Returns:
      the database operation executed in test setup.
      Throws:
      Exception - if the operation cannot be determined.

    • getTearDownOperation

      protected DatabaseOperation getTearDownOperation() throws Exception
      Description copied from class: DatabaseTestCase
      Returns the database operation executed in test cleanup.
      Overrides:
      getTearDownOperation in class DatabaseTestCase
      Returns:
      the database operation executed in test cleanup.
      Throws:
      Exception - if the operation cannot be determined.

    • verifyData

      public void verifyData() throws Exception
      For the provided VerifyTableDefinitions, verify each table's actual results are as expected. Uses the connection from the provided databaseTester, shared with setupData() and cleanupData() for this test's lifecycle. Left open on return; cleanupData() closes it. See #800.
      Specified by:
      verifyData in interface PrepAndExpectedTestCase
      Throws:
      Exception - if verifying the data fails.

    • verifyData

      protected void verifyData(IDatabaseConnection connection, VerifyTableDefinition verifyTableDefinition) throws Exception
      Verifies a single table's actual data against its expected data.
      Parameters:
      connection - the database connection to load the actual data from.
      verifyTableDefinition - the table definition to verify.
      Throws:
      Exception - if verifying the table fails.

    • loadTableDataFromDataSet

      public ITable loadTableDataFromDataSet(String tableName) throws DataSetException
      Loads the given table's expected data from the expected dataset.
      Parameters:
      tableName - the name of the table to load.
      Returns:
      the table's expected data.
      Throws:
      DataSetException - if loading the table fails.

    • loadTableDataFromDatabase

      public ITable loadTableDataFromDatabase(String tableName, IDatabaseConnection connection) throws Exception
      Loads the given table's actual data from the database.
      Parameters:
      tableName - the name of the table to load.
      connection - the database connection to load the data from.
      Returns:
      the table's actual data.
      Throws:
      Exception - if loading the table fails.

    • verifyData

      protected void verifyData(ITable expectedTable, ITable actualTable, String[] excludeColumns, String[] includeColumns, ValueComparer defaultValueComparer, Map<String,ValueComparer> columnValueComparers) throws DatabaseUnitException
      For the specified expected and actual tables (and excluding and including the specified columns), verify the actual data is as expected.
      Parameters:
      expectedTable - The expected table to compare the actual table to.
      actualTable - The actual table to compare to the expected table.
      excludeColumns - The column names to exclude from comparison. See DefaultColumnFilter.excludeColumn(String) .
      includeColumns - The column names to only include in comparison. See DefaultColumnFilter.includeColumn(String) .
      defaultValueComparer - ValueComparer to use with column value comparisons when the column name for the table is not in the columnValueComparers Map. Can be null and will default.
      columnValueComparers - Map of ValueComparers to use for specific columns. Key is column name, value is the ValueComparer. Can be null and will default to defaultValueComparer for all columns in all tables.
      Throws:
      DatabaseUnitException - if the tables' row counts, columns, or data do not match.
      See Also:

    • verifyData

      protected void verifyData(ITable expectedTable, ITable actualTable, String[] excludeColumns, String[] includeColumns, ValueComparer defaultValueComparer, Map<String,ValueComparer> columnValueComparers, boolean sortOnFilteredColumnsOnly) throws DatabaseUnitException
      For the specified expected and actual tables (and excluding and including the specified columns), verify the actual data is as expected.
      Parameters:
      expectedTable - The expected table to compare the actual table to.
      actualTable - The actual table to compare to the expected table.
      excludeColumns - The column names to exclude from comparison. See DefaultColumnFilter.excludeColumn(String) .
      includeColumns - The column names to only include in comparison. See DefaultColumnFilter.includeColumn(String) .
      defaultValueComparer - ValueComparer to use with column value comparisons when the column name for the table is not in the columnValueComparers Map. Can be null and will default.
      columnValueComparers - Map of ValueComparers to use for specific columns. Key is column name, value is the ValueComparer. Can be null and will default to defaultValueComparer for all columns in all tables.
      sortOnFilteredColumnsOnly - True to sort the expected and actual tables by only the columns that survive excludeColumns/includeColumns, instead of by all of the actual table's native columns; see VerifyTableDefinition.isSortOnFilteredColumnsOnly(). When false and the expected table omits columns of the actual table, so the two sort by different columns, a failed comparison that passes when sorted by only the filtered columns carries a suppressed exception naming this as the remedy.
      Throws:
      DatabaseUnitException - if the tables' row counts, columns, or data do not match.
      Since:
      3.5.0

    • compareData

      protected void compareData(ITable expectedTable, ITable actualTable, Column[] additionalColumnInfo, ValueComparer defaultValueComparer, Map<String,ValueComparer> columnValueComparers) throws DatabaseUnitException
      Compare the tables, enables easy overriding.

      Uses failureHandler when set; otherwise defers to Assertion.assertWithValueComparer(ITable, ITable, Column[], ValueComparer, Map)'s own DefaultFailureHandler, configured with additionalColumnInfo.

      Parameters:
      expectedTable - the table containing all expected results.
      actualTable - the table containing all actual results.
      additionalColumnInfo - the additional columns to include in failure messages.
      defaultValueComparer - the value comparer used when no more specific comparer is configured.
      columnValueComparers - the per-column value comparers to use.
      Throws:
      DatabaseUnitException - if the tables' row counts, columns, or data do not match.

    • makeAdditionalColumnInfo

      protected Column[] makeAdditionalColumnInfo(ITable expectedTable, String[] excludeColumns) throws DataSetException
      Don't add excluded columns to additionalColumnInfo as they are not compared. The verification then drops, from what this returns, the columns the actual table does not have, for example one that was not loaded from the database, as the fail message would show a not found message for them.
      Parameters:
      expectedTable - Not null.
      excludeColumns - Nullable.
      Returns:
      the additional column info, excluding excludeColumns.
      Throws:
      DataSetException - if the expected table's columns cannot be retrieved.

    • makeAdditionalColumnInfo

      protected Column[] makeAdditionalColumnInfo(String[] excludeColumns, Column[] allColumns)
      Don't add excluded columns to additionalColumnInfo as they are not compared. The exclude patterns match the way the column filters applied to the compared tables do: without regard to case, and with DefaultColumnFilter's wildcard support. The verification then drops, from what this returns, the columns the actual table does not have, for example one that was not loaded from the database, as the fail message would show a not found message for them.
      Parameters:
      excludeColumns - Not null.
      allColumns - Not null.
      Returns:
      the additional column info, excluding excludeColumns.

    • makeCompositeDataSet

      public IDataSet makeCompositeDataSet(String[] dataFiles, String dataFilesName) throws DataSetException
      Make a IDataSet from the specified files with case sensitive table names as false.
      Parameters:
      dataFiles - Represents the array of dbUnit data files.
      dataFilesName - Concept name of the data files, e.g. prep, expected.
      Returns:
      The composite dataset.
      Throws:
      DataSetException - On dbUnit errors.

    • makeCompositeDataSet

      public IDataSet makeCompositeDataSet(String[] dataFiles, String dataFilesName, boolean isCaseSensitiveTableNames) throws DataSetException
      Make a IDataSet from the specified files.
      Parameters:
      dataFiles - Represents the array of dbUnit data files; null is treated as none.
      dataFilesName - Concept name of the data files, e.g. prep, expected.
      isCaseSensitiveTableNames - true if case sensitive table names is on.
      Returns:
      The composite dataset.
      Throws:
      DataSetException - On dbUnit errors.

    • applyColumnFilters

      public ITable applyColumnFilters(ITable table, String[] excludeColumns, String[] includeColumns) throws DataSetException
      Apply the specified exclude and include column filters to the specified table.
      Parameters:
      table - The table to apply the filters to.
      excludeColumns - The exclude filters; use null or empty array to mean exclude none.
      includeColumns - The include filters; use null or empty array to mean include all.
      Returns:
      The filtered table.
      Throws:
      DataSetException - if applying the filters fails.

    • getPrepDataset

      public IDataSet getPrepDataset()
      Get the prep dataset, created from the prepDataFiles.
      Specified by:
      getPrepDataset in interface PrepAndExpectedTestCase
      Returns:
      The prep dataset.

    • getExpectedDataset

      public IDataSet getExpectedDataset()
      Get the expected dataset, created from the expectedDataFiles.
      Specified by:
      getExpectedDataset in interface PrepAndExpectedTestCase
      Returns:
      The expected dataset.

    • getDatabaseTester

      public IDatabaseTester getDatabaseTester()
      Get the databaseTester.
      Specified by:
      getDatabaseTester in interface PrepAndExpectedTestCase
      Overrides:
      getDatabaseTester in class DatabaseTestCase
      Returns:
      The databaseTester.
      See Also:
      • databaseTester

    • setDatabaseTester

      public void setDatabaseTester(IDatabaseTester databaseTester)
      Set the databaseTester. Replacing a different one first releases the shared connection acquired from it, closing it only when cleanupData() would, and forgets what was resolved from it, so the next step acquires its connection and case sensitivity setting from the new one.
      Specified by:
      setDatabaseTester in interface PrepAndExpectedTestCase
      Parameters:
      databaseTester - The databaseTester to set.
      See Also:
      • databaseTester

    • isCloseConnectionAfterTest

      public boolean isCloseConnectionAfterTest()
      Get whether the connection lookupFeatureValue() and cleanupData() are done with is closed.
      Specified by:
      isCloseConnectionAfterTest in interface PrepAndExpectedTestCase
      Returns:
      True if it is closed, false if not.
      Since:
      3.4.0
      See Also:
      • closeConnectionAfterTest

    • setCloseConnectionAfterTest

      public void setCloseConnectionAfterTest(boolean closeConnectionAfterTest)
      Set whether the connection lookupFeatureValue() and cleanupData() are done with is closed. Default is true. Set to false when databaseTester shares a CachingConnectionProvider across test methods, so this instance does not close a connection other tests still expect to reuse. False requires a databaseTester that hands out the same connection on repeated calls: with one that hands out a new connection each time, nothing closes the connection left open after a test, and a step that fails leaves open the connection this instance forgets. A warning is logged when databaseTester is a JdbcDatabaseTester without a CachingConnectionProvider.
      Specified by:
      setCloseConnectionAfterTest in interface PrepAndExpectedTestCase
      Parameters:
      closeConnectionAfterTest - True to close it, false to leave it open.
      Since:
      3.4.0
      See Also:
      • closeConnectionAfterTest

    • getDataFileLoader

      public DataFileLoader getDataFileLoader()
      Get the dataFileLoader.
      Specified by:
      getDataFileLoader in interface PrepAndExpectedTestCase
      Returns:
      The dataFileLoader.
      See Also:
      • dataFileLoader

    • setDataFileLoader

      public void setDataFileLoader(DataFileLoader dataFileLoader)
      Set the dataFileLoader.
      Specified by:
      setDataFileLoader in interface PrepAndExpectedTestCase
      Parameters:
      dataFileLoader - The dataFileLoader to set.
      See Also:
      • dataFileLoader

    • setPrepDs

      public void setPrepDs(IDataSet prepDataSet)
      Set the prepDs.
      Parameters:
      prepDataSet - The prepDs to set.
      See Also:
      • prepDataSet

    • setExpectedDs

      public void setExpectedDs(IDataSet expectedDataSet)
      Set the expectedDs.
      Parameters:
      expectedDataSet - The expectedDs to set.
      See Also:
      • expectedDataSet

    • getVerifyTableDefs

      public VerifyTableDefinition[] getVerifyTableDefs()
      Get the tableDefs.
      Returns:
      The tableDefs.
      See Also:
      • verifyTableDefs

    • setVerifyTableDefs

      public void setVerifyTableDefs(VerifyTableDefinition[] verifyTableDefs)
      Set the tableDefs.
      Parameters:
      verifyTableDefs - The tableDefs to set.
      See Also:
      • verifyTableDefs

    • getExpectedDataSetAndVerifyTableDefinitionVerifier

      public ExpectedDataSetAndVerifyTableDefinitionVerifier getExpectedDataSetAndVerifyTableDefinitionVerifier()
      Returns the verifier used to check that verify table definitions and the expected dataset agree.
      Returns:
      the verifier used to check that verify table definitions and the expected dataset agree.

    • setExpectedDataSetAndVerifyTableDefinitionVerifier

      public void setExpectedDataSetAndVerifyTableDefinitionVerifier(ExpectedDataSetAndVerifyTableDefinitionVerifier expectedDataSetAndVerifyTableDefinitionVerifier)
      Sets the verifier used to check that verify table definitions and the expected dataset agree.
      Parameters:
      expectedDataSetAndVerifyTableDefinitionVerifier - the verifier to use.

    • getFailureHandler

      public FailureHandler getFailureHandler()
      Get the failureHandler.
      Specified by:
      getFailureHandler in interface PrepAndExpectedTestCase
      Returns:
      The failureHandler.
      Since:
      3.5.0
      See Also:
      • failureHandler

    • setFailureHandler

      public void setFailureHandler(FailureHandler failureHandler)
      Set the failureHandler.
      Specified by:
      setFailureHandler in interface PrepAndExpectedTestCase
      Parameters:
      failureHandler - The failureHandler to set.
      Since:
      3.5.0
      See Also:
      • failureHandler

    • getRowCountCheck

      public RowCountCheck getRowCountCheck()
      Get the RowCountCheck in use.
      Returns:
      The RowCountCheck, or null if none has been resolved or set yet.
      Since:
      3.6.0
      See Also:
      • rowCountChecker

    • setRowCountCheck

      public void setRowCountCheck(RowCountCheck rowCountCheck)
      Set the RowCountCheck, overriding the one otherwise lazily built from the shared connection's DatabaseConfig.
      Parameters:
      rowCountCheck - The RowCountCheck to use.
      Since:
      3.6.0
      See Also:
      • rowCountChecker

    • setRowCountCheckOverride

      public void setRowCountCheckOverride(boolean enabled, String[] exclude)
      Set the enabled flag and excluded table patterns to resolve a RowCountCheck from, instead of the shared connection's DatabaseConfig - the values an annotation such as @DbUnitRowCountCheck declares.
      Specified by:
      setRowCountCheckOverride in interface PrepAndExpectedTestCase
      Parameters:
      enabled - Whether the check is enabled.
      exclude - The excluded table patterns; null is treated as empty (excludes none).
      Since:
      3.6.0
      See Also:
      • rowCountChecker

    • clearRowCountCheckOverride

      public void clearRowCountCheckOverride()
      Clear a previously set enabled flag and excluded table patterns override, returning to resolving a RowCountCheck from the shared connection's DatabaseConfig.

      A caller reusing one instance across several tests - e.g. one held by a @DbUnitTestCase static field - must call this once a test that set an override is over, so that test's override does not silently carry over onto the next one.

      Specified by:
      clearRowCountCheckOverride in interface PrepAndExpectedTestCase
      Since:
      3.6.0
      See Also:
      • rowCountChecker

    • getDatabaseConfigProperties

      public Properties getDatabaseConfigProperties()
      Get the DatabaseConfig property name/value pairs applied to the connection shared by setupData(), verifyData() and cleanupData().
      Specified by:
      getDatabaseConfigProperties in interface PrepAndExpectedTestCase
      Returns:
      A copy of the properties, or null if none are set.
      Since:
      3.6.0
      See Also:

    • setDatabaseConfigProperties

      public void setDatabaseConfigProperties(Properties databaseConfigProperties)
      Set DatabaseConfig property name/value pairs to apply to the connection shared by setupData(), verifyData() and cleanupData(), every time DBTestCase.getConnection() resolves it.

      Puts back, first, whatever the previous properties replaced, so that changing them - as the annotation runtime does to restore an injected instance's own properties after a test - leaves nothing of the old values on a connection kept open.

      Specified by:
      setDatabaseConfigProperties in interface PrepAndExpectedTestCase
      Parameters:
      databaseConfigProperties - The properties to apply; null or empty applies none.
      Since:
      3.6.0
      See Also:
      • databaseConfigProperties