perf(database): Cache and reuse IDatabaseConnection across tests

CLAUDE.md

@@ -147,7 +147,7 @@ Integration tests use `DatabaseEnvironment` to bootstrap the target database fro
   - Adhere strictly to de facto standard Git commit message formatting.
   - Use Conventional Commits format.
   - **Commit Types:** `feat:`, `fix:`, `docs:`, `refactor:`, `test:`, `build:`, `ci:`, `perf:`
-  - **Scopes:** any of the database names, `assertion`, `pom`, `log`, `docker`, `database`, `dataset`, `metadata`, `resultset`, `scripts`, `site`, `statement`, `search`
+  - **Scopes:** any of the database names, `assertion`, `pom`, `log`, `docker`, `database`, `dataset`, `metadata`, `resultset`, `scripts`, `site`, `statement`, `search`, `util`, `ant`, `operation`
   - Capitalize the first word after the type and scope.
   - You may suggest additional CC commit types and scopes when encountering situations where the changes do not fit into the approved lists above.
   - Reference GitHub issues in the commit footer with `Refs: <issue-number>` (e.g. `Refs: 123`).  Do not use a # before the number.

pom.xml

@@ -4,7 +4,7 @@
 
   <groupId>org.dbunit</groupId>
   <artifactId>dbunit</artifactId>
-  <version>3.3.1-SNAPSHOT</version>
+  <version>3.4.0-SNAPSHOT</version>
   <packaging>jar</packaging>
   <name>dbUnit Extension</name>
   <url>https://github.com/dbunit/dbunit-extension</url>
@@ -47,8 +47,6 @@
     <logbackClassicVersion>1.5.38</logbackClassicVersion>
     <mockitoVersion>5.23.0</mockitoVersion>
     <poiVersion>5.2.5</poiVersion>
-    <slf4jVersion>1.7.25</slf4jVersion>
-    <snakeYamlVersion>2.2</snakeYamlVersion>
     <xmlparserv2Version>23.26.2.0.0</xmlparserv2Version>
 
     <!-- Database driver versions -->
@@ -1039,8 +1037,6 @@
           </parameter>
         </configuration>
         <reportSets>
-<!--
-enable when new snapshot version set
           <reportSet>
             <id>3.3.0-to-snapshot</id>
             <reports>
@@ -1065,7 +1061,6 @@ enable when new snapshot version set
               </newVersion>
             </configuration>
           </reportSet>
--->
           <reportSet>
             <id>3.2.0-to-3.3.0</id>
             <reports>

src/main/java/org/dbunit/DataSourceDatabaseTester.java

@@ -25,6 +25,7 @@
 
 import javax.sql.DataSource;
 
+import org.dbunit.database.CachingConnectionProvider;
 import org.dbunit.database.DatabaseConnection;
 import org.dbunit.database.IDatabaseConnection;
 
@@ -45,6 +46,7 @@ public class DataSourceDatabaseTester extends AbstractDatabaseTester
 	 */
 	private static final Logger logger = LoggerFactory.getLogger(DataSourceDatabaseTester.class);
 
+	private final CachingConnectionProvider connectionProvider;
 	private DataSource dataSource;
 
 	/**
@@ -54,13 +56,7 @@ public class DataSourceDatabaseTester extends AbstractDatabaseTester
 	 */
 	public DataSourceDatabaseTester( DataSource dataSource )
 	{
-		super();
-
-        if (dataSource == null) {
-            throw new NullPointerException(
-                    "The parameter 'dataSource' must not be null");
-        }
-		this.dataSource = dataSource;
+		this(dataSource, null, null);
 	}
 
 	/**
@@ -69,22 +65,54 @@ public DataSourceDatabaseTester( DataSource dataSource )
 	 * @param schema The schema name to be used for new dbunit connections
 	 * @since 2.4.5
 	 */
-	public DataSourceDatabaseTester(DataSource dataSource, String schema) 
+	public DataSourceDatabaseTester(DataSource dataSource, String schema)
 	{
+        this(dataSource, schema, null);
+    }
+
+    /**
+     * Creates a new DataSourceDatabaseTester with the specified DataSource and schema name,
+     * reusing one {@link IDatabaseConnection} across calls via the given
+     * {@link CachingConnectionProvider} instead of creating a new one on every call.<br>
+     * Share the same <code>connectionProvider</code> instance across the testers created for
+     * each test to get reuse across test methods; pair it with
+     * {@link IOperationListener#NO_OP_OPERATION_LISTENER} (or an equivalent non-closing
+     * listener) so the cached connection is not closed after every {@link #onSetup()}/
+     * {@link #onTearDown()} call.
+     *
+     * @param dataSource the DataSource to pull connections from
+     * @param schema The schema name to be used for new dbunit connections - can be <code>null</code>
+     * @param connectionProvider caches and validates the connection across calls - can be
+     *            <code>null</code>, in which case a new connection is created on every call as before
+     * @since 3.4.0
+     */
+    public DataSourceDatabaseTester(DataSource dataSource, String schema,
+            CachingConnectionProvider connectionProvider)
+    {
         super(schema);
-        
+
         if (dataSource == null) {
             throw new NullPointerException(
                     "The parameter 'dataSource' must not be null");
         }
         this.dataSource = dataSource;
+        this.connectionProvider = connectionProvider;
     }
 
     public IDatabaseConnection getConnection() throws Exception
 	{
 		logger.debug("getConnection() - start");
 
 		assertTrue( "DataSource is not set", dataSource!=null );
+		if (connectionProvider != null)
+		{
+			return connectionProvider.getConnection(this::createConnection);
+		}
+		return createConnection();
+	}
+
+	private IDatabaseConnection createConnection() throws Exception
+	{
 		return new DatabaseConnection( dataSource.getConnection(), getSchema() );
 	}
 }

src/main/java/org/dbunit/DatabaseTestCase.java

@@ -159,17 +159,62 @@ protected void tearDown() throws Exception
         logger.debug("tearDown() - start");
 
         try {
-            final IDatabaseTester databaseTester = getDatabaseTester();
-            assertNotNull(databaseTester, "DatabaseTester is not set");
-            databaseTester.setTearDownOperation(getTearDownOperation());
-            databaseTester.setDataSet(getDataSet());
-            databaseTester.setOperationListener(getOperationListener());
-            databaseTester.onTearDown();
+            runTearDownOperation();
         } finally {
             tester = null;
         }
     }
 
+    /**
+     * Runs tear down the same as {@link #tearDown()}, for use when a test
+     * failure is already in flight (e.g. calling this from a catch/finally
+     * around the test body). A tear-down failure never replaces the given
+     * testFailure; it is instead attached via {@link Throwable#addSuppressed}
+     * so the original failure remains the one reported, with the tear-down
+     * failure still visible alongside it.
+     *
+     * @param testFailure
+     *            The throwable already in flight from the test body, or
+     *            <code>null</code> if there is none, in which case this
+     *            behaves the same as {@link #tearDown()}.
+     * @throws Throwable
+     *             testFailure, if not <code>null</code>; otherwise a
+     *             tear-down failure, if one occurred.
+     * @since 3.4.0
+     */
+    protected void tearDown(final Throwable testFailure) throws Throwable
+    {
+        logger.debug("tearDown(testFailure={}) - start", testFailure);
+
+        if (testFailure == null)
+        {
+            tearDown();
+            return;
+        }
+
+        try {
+            try {
+                runTearDownOperation();
+            } finally {
+                tester = null;
+            }
+        } catch (final Throwable tearDownFailure) {
+            testFailure.addSuppressed(tearDownFailure);
+        }
+
+        throw testFailure;
+    }
+
+    private void runTearDownOperation() throws Exception
+    {
+        final IDatabaseTester databaseTester = getDatabaseTester();
+        assertNotNull(databaseTester, "DatabaseTester is not set");
+        databaseTester.setTearDownOperation(getTearDownOperation());
+        databaseTester.setDataSet(getDataSet());
+        databaseTester.setOperationListener(getOperationListener());
+        databaseTester.onTearDown();
+    }
+
     /**
      * @return The {@link IOperationListener} to be used by the {@link IDatabaseTester}.
      * @since 2.4.4

src/main/java/org/dbunit/DefaultDatabaseTester.java

@@ -20,6 +20,9 @@
  */
 package org.dbunit;
 
+import java.util.concurrent.Callable;
+
+import org.dbunit.database.CachingConnectionProvider;
 import org.dbunit.database.IDatabaseConnection;
 
 /**
@@ -30,20 +33,69 @@
  * @version $Revision$
  * @since 2.2
  */
+public class DefaultDatabaseTester extends AbstractDatabaseTester
+{
+    private final IDatabaseConnection connection;
+    private final CachingConnectionProvider connectionProvider;
+    private final Callable<IDatabaseConnection> connectionFactory;
 
-public class DefaultDatabaseTester extends AbstractDatabaseTester {
-
-  final IDatabaseConnection connection;
-
-  /**
-   * Creates a new DefaultDatabaseTester with the supplied connection.
-   */
-  public DefaultDatabaseTester( final IDatabaseConnection connection ) {
-    this.connection = connection;
-  }
+    /**
+     * Creates a new DefaultDatabaseTester with the supplied connection.<br>
+     * The same connection instance is returned by every {@link #getConnection()}
+     * call, with no liveness check. Pair this with a non-closing
+     * {@link IOperationListener} (e.g. {@link IOperationListener#NO_OP_OPERATION_LISTENER})
+     * to keep it open across test methods.
+     *
+     * @param connection the connection to return from every {@link #getConnection()} call
+     */
+    public DefaultDatabaseTester(final IDatabaseConnection connection)
+    {
+        this.connection = connection;
+        this.connectionProvider = null;
+        this.connectionFactory = null;
+    }
 
-  public IDatabaseConnection getConnection() throws Exception {
-    return this.connection;
-  }
+    /**
+     * Creates a new DefaultDatabaseTester that reuses one connection - created
+     * with the given factory - across calls via the given
+     * {@link CachingConnectionProvider}, transparently replacing it if it is no
+     * longer alive.<br>
+     * Share the same <code>connectionProvider</code> instance across the testers
+     * created for each test to get reuse across test methods; pair it with
+     * {@link IOperationListener#NO_OP_OPERATION_LISTENER} (or an equivalent
+     * non-closing listener) so the cached connection is not closed after every
+     * {@link #onSetup()}/{@link #onTearDown()} call.
+     *
+     * @param connectionProvider caches and validates the connection across calls
+     * @param connectionFactory creates a new connection; only invoked by
+     *            <code>connectionProvider</code> when there is no live cached
+     *            connection to reuse
+     * @since 3.4.0
+     */
+    public DefaultDatabaseTester(final CachingConnectionProvider connectionProvider,
+            final Callable<IDatabaseConnection> connectionFactory)
+    {
+        if (connectionProvider == null)
+        {
+            throw new NullPointerException(
+                    "The parameter 'connectionProvider' must not be null");
+        }
+        if (connectionFactory == null)
+        {
+            throw new NullPointerException(
+                    "The parameter 'connectionFactory' must not be null");
+        }
+        this.connection = null;
+        this.connectionProvider = connectionProvider;
+        this.connectionFactory = connectionFactory;
+    }
 
+    public IDatabaseConnection getConnection() throws Exception
+    {
+        if (connectionProvider != null)
+        {
+            return connectionProvider.getConnection(connectionFactory);
+        }
+        return this.connection;
+    }
 }