From ebd0501c98a51b71d6d950acd30fbdc9eb5e004e Mon Sep 17 00:00:00 2001 From: "raju.gupta" Date: Sun, 12 Oct 2025 10:30:36 +0100 Subject: [PATCH 1/9] Fix resource leak in performQuery by using Consumer pattern - Changed performQuery method signature from returning ResultSet to accepting Consumer - Implemented proper resource management with try-with-resources for Connection, Statement, and ResultSet - Updated all test files across database modules to use new lambda-based pattern - Wrapped assertions in assertThatNoException().isThrownBy() blocks for proper exception handling This change ensures JDBC resources are properly closed after query execution, preventing resource leaks. Note: Additional resource leak fixes will follow in subsequent PRs. This PR focuses on the performQuery enhancement to facilitate easier review. --- .../clickhouse/ClickHouseContainerTest.java | 49 +++++-- .../clickhouse/SimpleClickhouseTest.java | 18 ++- .../cockroachdb/CockroachContainerTest.java | 70 +++++++--- .../junit/cratedb/SimpleCrateDBTest.java | 50 +++++-- .../databend/DatabendContainerTest.java | 34 +++-- .../testcontainers/db2/Db2ContainerTest.java | 34 +++-- .../db/AbstractContainerDatabaseTest.java | 25 ++-- .../mariadb/MariaDBContainerTest.java | 92 +++++++++---- .../mssqlserver/MSSQLServerContainerTest.java | 32 ++++- .../mysql/MultiVersionMySQLTest.java | 22 ++- .../mysql/MySQLContainerTest.java | 125 +++++++++++++----- .../oceanbase/SimpleOceanBaseCETest.java | 34 ++++- .../junit/oracle/SimpleOracleTest.java | 17 ++- .../junit/oracle/SimpleOracleTest.java | 17 ++- .../containers/TimescaleDBContainerTest.java | 63 ++++++--- .../postgresql/CompatibleImageTest.java | 47 +++++-- .../postgresql/PostgreSQLContainerTest.java | 90 ++++++++++--- .../junit/questdb/SimpleQuestDBTest.java | 18 ++- .../tidb/TiDBContainerTest.java | 34 +++-- .../timeplus/TimeplusContainerTest.java | 33 +++-- .../junit/yugabytedb/YugabyteDBYSQLTest.java | 91 ++++++++++--- 21 files changed, 744 insertions(+), 251 deletions(-) diff --git a/modules/clickhouse/src/test/java/org/testcontainers/clickhouse/ClickHouseContainerTest.java b/modules/clickhouse/src/test/java/org/testcontainers/clickhouse/ClickHouseContainerTest.java index 0f9eb3ef6a3..e2cc019687e 100644 --- a/modules/clickhouse/src/test/java/org/testcontainers/clickhouse/ClickHouseContainerTest.java +++ b/modules/clickhouse/src/test/java/org/testcontainers/clickhouse/ClickHouseContainerTest.java @@ -3,11 +3,11 @@ import com.clickhouse.client.api.Client; import com.clickhouse.client.api.data_formats.ClickHouseBinaryFormatReader; import com.clickhouse.client.api.query.QueryResponse; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; import org.testcontainers.ClickhouseTestImages; import org.testcontainers.db.AbstractContainerDatabaseTest; -import java.sql.ResultSet; import java.sql.SQLException; import java.util.concurrent.ExecutionException; import java.util.concurrent.TimeUnit; @@ -26,10 +26,18 @@ void testSimple() throws SQLException { ) { clickhouse.start(); - ResultSet resultSet = performQuery(clickhouse, "SELECT 1"); - - int resultSetInt = resultSet.getInt(1); - assertThat(resultSetInt).isEqualTo(1); + performQuery( + clickhouse, + "SELECT 1", + resultSet -> { + Assertions + .assertThatNoException() + .isThrownBy(() -> { + int resultSetInt = resultSet.getInt(1); + assertThat(resultSetInt).isEqualTo(1); + }); + } + ); } } @@ -45,13 +53,18 @@ void customCredentialsWithUrlParams() throws SQLException { ) { clickhouse.start(); - ResultSet resultSet = performQuery( + performQuery( clickhouse, - "SELECT value FROM system.settings where name='max_result_rows'" + "SELECT value FROM system.settings where name='max_result_rows'", + resultSet -> { + Assertions + .assertThatNoException() + .isThrownBy(() -> { + int resultSetInt = resultSet.getInt(1); + assertThat(resultSetInt).isEqualTo(5); + }); + } ); - - int resultSetInt = resultSet.getInt(1); - assertThat(resultSetInt).isEqualTo(5); } } @@ -60,10 +73,18 @@ void testNewAuth() throws SQLException { try (ClickHouseContainer clickhouse = new ClickHouseContainer(ClickhouseTestImages.CLICKHOUSE_24_12_IMAGE)) { clickhouse.start(); - ResultSet resultSet = performQuery(clickhouse, "SELECT 1"); - - int resultSetInt = resultSet.getInt(1); - assertThat(resultSetInt).isEqualTo(1); + performQuery( + clickhouse, + "SELECT 1", + resultSet -> { + Assertions + .assertThatNoException() + .isThrownBy(() -> { + int resultSetInt = resultSet.getInt(1); + assertThat(resultSetInt).isEqualTo(1); + }); + } + ); } } diff --git a/modules/clickhouse/src/test/java/org/testcontainers/junit/clickhouse/SimpleClickhouseTest.java b/modules/clickhouse/src/test/java/org/testcontainers/junit/clickhouse/SimpleClickhouseTest.java index c9bd9e917f5..e93de2e6dd0 100644 --- a/modules/clickhouse/src/test/java/org/testcontainers/junit/clickhouse/SimpleClickhouseTest.java +++ b/modules/clickhouse/src/test/java/org/testcontainers/junit/clickhouse/SimpleClickhouseTest.java @@ -1,11 +1,11 @@ package org.testcontainers.junit.clickhouse; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; import org.testcontainers.ClickhouseTestImages; import org.testcontainers.containers.ClickHouseContainer; import org.testcontainers.db.AbstractContainerDatabaseTest; -import java.sql.ResultSet; import java.sql.SQLException; import static org.assertj.core.api.Assertions.assertThat; @@ -17,10 +17,18 @@ public void testSimple() throws SQLException { try (ClickHouseContainer clickhouse = new ClickHouseContainer(ClickhouseTestImages.CLICKHOUSE_IMAGE)) { clickhouse.start(); - ResultSet resultSet = performQuery(clickhouse, "SELECT 1"); - - int resultSetInt = resultSet.getInt(1); - assertThat(resultSetInt).as("A basic SELECT query succeeds").isEqualTo(1); + performQuery( + clickhouse, + "SELECT 1", + resultSet -> { + Assertions + .assertThatNoException() + .isThrownBy(() -> { + int resultSetInt = resultSet.getInt(1); + assertThat(resultSetInt).as("A basic SELECT query succeeds").isEqualTo(1); + }); + } + ); } } } diff --git a/modules/cockroachdb/src/test/java/org/testcontainers/cockroachdb/CockroachContainerTest.java b/modules/cockroachdb/src/test/java/org/testcontainers/cockroachdb/CockroachContainerTest.java index 3aba3d2eefd..d05bb6a9150 100644 --- a/modules/cockroachdb/src/test/java/org/testcontainers/cockroachdb/CockroachContainerTest.java +++ b/modules/cockroachdb/src/test/java/org/testcontainers/cockroachdb/CockroachContainerTest.java @@ -1,11 +1,11 @@ package org.testcontainers.cockroachdb; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; import org.testcontainers.CockroachDBTestImages; import org.testcontainers.db.AbstractContainerDatabaseTest; import org.testcontainers.images.builder.Transferable; -import java.sql.ResultSet; import java.sql.SQLException; import java.util.logging.Level; import java.util.logging.LogManager; @@ -27,10 +27,18 @@ void testSimple() throws SQLException { ) { cockroach.start(); - ResultSet resultSet = performQuery(cockroach, "SELECT 1"); - - int resultSetInt = resultSet.getInt(1); - assertThat(resultSetInt).as("A basic SELECT query succeeds").isEqualTo(1); + performQuery( + cockroach, + "SELECT 1", + resultSet -> { + Assertions + .assertThatNoException() + .isThrownBy(() -> { + int resultSetInt = resultSet.getInt(1); + assertThat(resultSetInt).as("A basic SELECT query succeeds").isEqualTo(1); + }); + } + ); } } @@ -42,10 +50,20 @@ void testExplicitInitScript() throws SQLException { ) { // CockroachDB is expected to be compatible with Postgres cockroach.start(); - ResultSet resultSet = performQuery(cockroach, "SELECT foo FROM bar"); - - String firstColumnValue = resultSet.getString(1); - assertThat(firstColumnValue).as("Value from init script should equal real value").isEqualTo("hello world"); + performQuery( + cockroach, + "SELECT foo FROM bar", + resultSet -> { + Assertions + .assertThatNoException() + .isThrownBy(() -> { + String firstColumnValue = resultSet.getString(1); + assertThat(firstColumnValue) + .as("Value from init script should equal real value") + .isEqualTo("hello world"); + }); + } + ); } } @@ -80,10 +98,18 @@ void testWithUsernamePasswordDatabase() throws SQLException { ) { cockroach.start(); - ResultSet resultSet = performQuery(cockroach, "SELECT 1"); - - int resultSetInt = resultSet.getInt(1); - assertThat(resultSetInt).as("A basic SELECT query succeeds").isEqualTo(1); + performQuery( + cockroach, + "SELECT 1", + resultSet -> { + Assertions + .assertThatNoException() + .isThrownBy(() -> { + int resultSetInt = resultSet.getInt(1); + assertThat(resultSetInt).as("A basic SELECT query succeeds").isEqualTo(1); + }); + } + ); String jdbcUrl = cockroach.getJdbcUrl(); assertThat(jdbcUrl).contains("/" + "test_database"); @@ -123,10 +149,20 @@ void testInitializationScript() throws SQLException { ) { // CockroachDB is expected to be compatible with Postgres cockroach.start(); - ResultSet resultSet = performQuery(cockroach, "SELECT foo FROM bar"); - - String firstColumnValue = resultSet.getString(1); - assertThat(firstColumnValue).as("Value from init script should equal real value").isEqualTo("hello world"); + performQuery( + cockroach, + "SELECT foo FROM bar", + resultSet -> { + Assertions + .assertThatNoException() + .isThrownBy(() -> { + String firstColumnValue = resultSet.getString(1); + assertThat(firstColumnValue) + .as("Value from init script should equal real value") + .isEqualTo("hello world"); + }); + } + ); } } } diff --git a/modules/cratedb/src/test/java/org/testcontainers/junit/cratedb/SimpleCrateDBTest.java b/modules/cratedb/src/test/java/org/testcontainers/junit/cratedb/SimpleCrateDBTest.java index 803b9173218..24ce9c13df4 100644 --- a/modules/cratedb/src/test/java/org/testcontainers/junit/cratedb/SimpleCrateDBTest.java +++ b/modules/cratedb/src/test/java/org/testcontainers/junit/cratedb/SimpleCrateDBTest.java @@ -1,11 +1,11 @@ package org.testcontainers.junit.cratedb; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; import org.testcontainers.CrateDBTestImages; import org.testcontainers.cratedb.CrateDBContainer; import org.testcontainers.db.AbstractContainerDatabaseTest; -import java.sql.ResultSet; import java.sql.SQLException; import java.util.logging.Level; import java.util.logging.LogManager; @@ -26,9 +26,18 @@ void testSimple() throws SQLException { ) { cratedb.start(); - ResultSet resultSet = performQuery(cratedb, "SELECT 1"); - int resultSetInt = resultSet.getInt(1); - assertThat(resultSetInt).as("A basic SELECT query succeeds").isEqualTo(1); + performQuery( + cratedb, + "SELECT 1", + resultSet -> { + Assertions + .assertThatNoException() + .isThrownBy(() -> { + int resultSetInt = resultSet.getInt(1); + assertThat(resultSetInt).as("A basic SELECT query succeeds").isEqualTo(1); + }); + } + ); assertHasCorrectExposedAndLivenessCheckPorts(cratedb); } } @@ -41,9 +50,18 @@ void testCommandOverride() throws SQLException { ) { cratedb.start(); - ResultSet resultSet = performQuery(cratedb, "select name from sys.cluster"); - String result = resultSet.getString(1); - assertThat(result).as("cluster name should be overridden").isEqualTo("testcontainers"); + performQuery( + cratedb, + "select name from sys.cluster", + resultSet -> { + Assertions + .assertThatNoException() + .isThrownBy(() -> { + String result = resultSet.getString(1); + assertThat(result).as("cluster name should be overridden").isEqualTo("testcontainers"); + }); + } + ); } } @@ -55,10 +73,20 @@ void testExplicitInitScript() throws SQLException { ) { cratedb.start(); - ResultSet resultSet = performQuery(cratedb, "SELECT foo FROM bar"); - - String firstColumnValue = resultSet.getString(1); - assertThat(firstColumnValue).as("Value from init script should equal real value").isEqualTo("hello world"); + performQuery( + cratedb, + "SELECT foo FROM bar", + resultSet -> { + Assertions + .assertThatNoException() + .isThrownBy(() -> { + String firstColumnValue = resultSet.getString(1); + assertThat(firstColumnValue) + .as("Value from init script should equal real value") + .isEqualTo("hello world"); + }); + } + ); } } diff --git a/modules/databend/src/test/java/org/testcontainers/databend/DatabendContainerTest.java b/modules/databend/src/test/java/org/testcontainers/databend/DatabendContainerTest.java index 984f42979c4..5495335ede5 100644 --- a/modules/databend/src/test/java/org/testcontainers/databend/DatabendContainerTest.java +++ b/modules/databend/src/test/java/org/testcontainers/databend/DatabendContainerTest.java @@ -1,9 +1,9 @@ package org.testcontainers.databend; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; import org.testcontainers.db.AbstractContainerDatabaseTest; -import java.sql.ResultSet; import java.sql.SQLException; import static org.assertj.core.api.Assertions.assertThat; @@ -18,10 +18,18 @@ void testSimple() throws SQLException { ) { databend.start(); - ResultSet resultSet = performQuery(databend, "SELECT 1"); - - int resultSetInt = resultSet.getInt(1); - assertThat(resultSetInt).isEqualTo(1); + performQuery( + databend, + "SELECT 1", + resultSet -> { + Assertions + .assertThatNoException() + .isThrownBy(() -> { + int resultSetInt = resultSet.getInt(1); + assertThat(resultSetInt).isEqualTo(1); + }); + } + ); } } @@ -35,10 +43,18 @@ void customCredentialsWithUrlParams() throws SQLException { ) { databend.start(); - ResultSet resultSet = performQuery(databend, "SELECT 1;"); - - int resultSetInt = resultSet.getInt(1); - assertThat(resultSetInt).isEqualTo(1); + performQuery( + databend, + "SELECT 1;", + resultSet -> { + Assertions + .assertThatNoException() + .isThrownBy(() -> { + int resultSetInt = resultSet.getInt(1); + assertThat(resultSetInt).isEqualTo(1); + }); + } + ); } } } diff --git a/modules/db2/src/test/java/org/testcontainers/db2/Db2ContainerTest.java b/modules/db2/src/test/java/org/testcontainers/db2/Db2ContainerTest.java index 6b17d1583f7..3ed90b3fefd 100644 --- a/modules/db2/src/test/java/org/testcontainers/db2/Db2ContainerTest.java +++ b/modules/db2/src/test/java/org/testcontainers/db2/Db2ContainerTest.java @@ -1,10 +1,10 @@ package org.testcontainers.db2; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; import org.testcontainers.Db2TestImages; import org.testcontainers.db.AbstractContainerDatabaseTest; -import java.sql.ResultSet; import java.sql.SQLException; import static org.assertj.core.api.Assertions.assertThat; @@ -19,10 +19,18 @@ void testSimple() throws SQLException { ) { db2.start(); - ResultSet resultSet = performQuery(db2, "SELECT 1 FROM SYSIBM.SYSDUMMY1"); - - int resultSetInt = resultSet.getInt(1); - assertThat(resultSetInt).as("A basic SELECT query succeeds").isEqualTo(1); + performQuery( + db2, + "SELECT 1 FROM SYSIBM.SYSDUMMY1", + resultSet -> { + Assertions + .assertThatNoException() + .isThrownBy(() -> { + int resultSetInt = resultSet.getInt(1); + assertThat(resultSetInt).as("A basic SELECT query succeeds").isEqualTo(1); + }); + } + ); assertHasCorrectExposedAndLivenessCheckPorts(db2); } } @@ -32,10 +40,18 @@ void testSimpleWithNewImage() throws SQLException { try (Db2Container db2 = new Db2Container("icr.io/db2_community/db2:11.5.8.0").acceptLicense()) { db2.start(); - ResultSet resultSet = performQuery(db2, "SELECT 1 FROM SYSIBM.SYSDUMMY1"); - - int resultSetInt = resultSet.getInt(1); - assertThat(resultSetInt).as("A basic SELECT query succeeds").isEqualTo(1); + performQuery( + db2, + "SELECT 1 FROM SYSIBM.SYSDUMMY1", + resultSet -> { + Assertions + .assertThatNoException() + .isThrownBy(() -> { + int resultSetInt = resultSet.getInt(1); + assertThat(resultSetInt).as("A basic SELECT query succeeds").isEqualTo(1); + }); + } + ); assertHasCorrectExposedAndLivenessCheckPorts(db2); } } diff --git a/modules/jdbc-test/src/main/java/org/testcontainers/db/AbstractContainerDatabaseTest.java b/modules/jdbc-test/src/main/java/org/testcontainers/db/AbstractContainerDatabaseTest.java index 6d3080c7ee3..60289d9ca9b 100644 --- a/modules/jdbc-test/src/main/java/org/testcontainers/db/AbstractContainerDatabaseTest.java +++ b/modules/jdbc-test/src/main/java/org/testcontainers/db/AbstractContainerDatabaseTest.java @@ -4,25 +4,34 @@ import com.zaxxer.hikari.HikariDataSource; import org.testcontainers.containers.JdbcDatabaseContainer; +import java.sql.Connection; import java.sql.ResultSet; import java.sql.SQLException; import java.sql.Statement; +import java.util.function.Consumer; import javax.sql.DataSource; public abstract class AbstractContainerDatabaseTest { - protected ResultSet performQuery(JdbcDatabaseContainer container, String sql) throws SQLException { - DataSource ds = getDataSource(container); - Statement statement = ds.getConnection().createStatement(); - statement.execute(sql); - ResultSet resultSet = statement.getResultSet(); + protected void performQuery( + final JdbcDatabaseContainer container, + final String sql, + final Consumer consumer + ) throws SQLException { + final DataSource ds = getDataSource(container); - resultSet.next(); - return resultSet; + try ( + Connection connection = ds.getConnection(); + Statement statement = connection.createStatement(); + ResultSet resultSet = statement.executeQuery(sql) + ) { + resultSet.next(); + consumer.accept(resultSet); + } } - protected DataSource getDataSource(JdbcDatabaseContainer container) { + protected DataSource getDataSource(final JdbcDatabaseContainer container) { HikariConfig hikariConfig = new HikariConfig(); hikariConfig.setJdbcUrl(container.getJdbcUrl()); hikariConfig.setUsername(container.getUsername()); diff --git a/modules/mariadb/src/test/java/org/testcontainers/mariadb/MariaDBContainerTest.java b/modules/mariadb/src/test/java/org/testcontainers/mariadb/MariaDBContainerTest.java index 99348f9168d..37f0f233a80 100644 --- a/modules/mariadb/src/test/java/org/testcontainers/mariadb/MariaDBContainerTest.java +++ b/modules/mariadb/src/test/java/org/testcontainers/mariadb/MariaDBContainerTest.java @@ -1,6 +1,7 @@ package org.testcontainers.mariadb; import org.apache.commons.lang3.SystemUtils; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; import org.testcontainers.MariaDBTestImages; import org.testcontainers.db.AbstractContainerDatabaseTest; @@ -10,7 +11,6 @@ import java.nio.file.FileSystems; import java.nio.file.Files; import java.nio.file.attribute.PosixFilePermission; -import java.sql.ResultSet; import java.sql.SQLException; import java.util.Arrays; import java.util.HashSet; @@ -29,10 +29,18 @@ void testSimple() throws SQLException { ) { mariadb.start(); - ResultSet resultSet = performQuery(mariadb, "SELECT 1"); - int resultSetInt = resultSet.getInt(1); - - assertThat(resultSetInt).as("A basic SELECT query succeeds").isEqualTo(1); + performQuery( + mariadb, + "SELECT 1", + resultSet -> { + Assertions + .assertThatNoException() + .isThrownBy(() -> { + int resultSetInt = resultSet.getInt(1); + assertThat(resultSetInt).as("A basic SELECT query succeeds").isEqualTo(1); + }); + } + ); } } @@ -45,12 +53,20 @@ void testSpecificVersion() throws SQLException { ) { mariadbOldVersion.start(); - ResultSet resultSet = performQuery(mariadbOldVersion, "SELECT VERSION()"); - String resultSetString = resultSet.getString(1); - - assertThat(resultSetString) - .as("The database version can be set using a container rule parameter") - .startsWith("10.3.39"); + performQuery( + mariadbOldVersion, + "SELECT VERSION()", + resultSet -> { + Assertions + .assertThatNoException() + .isThrownBy(() -> { + String resultSetString = resultSet.getString(1); + assertThat(resultSetString) + .as("The database version can be set using a container rule parameter") + .startsWith("10.3.39"); + }); + } + ); } } @@ -77,10 +93,20 @@ void testMariaDBWithCommandOverride() throws SQLException { .withCommand("mysqld --auto_increment_increment=10") ) { mariadbCustomConfig.start(); - ResultSet resultSet = performQuery(mariadbCustomConfig, "show variables like 'auto_increment_increment'"); - String result = resultSet.getString("Value"); - - assertThat(result).as("Auto increment increment should be overridden by command line").isEqualTo("10"); + performQuery( + mariadbCustomConfig, + "show variables like 'auto_increment_increment'", + resultSet -> { + Assertions + .assertThatNoException() + .isThrownBy(() -> { + String result = resultSet.getString("Value"); + assertThat(result) + .as("Auto increment increment should be overridden by command line") + .isEqualTo("10"); + }); + } + ); } } @@ -138,19 +164,35 @@ void testEmptyPasswordWithRootUser() throws SQLException { try (MariaDBContainer mysql = new MariaDBContainer("mariadb:11.2.4").withUsername("root")) { mysql.start(); - ResultSet resultSet = performQuery(mysql, "SELECT 1"); - int resultSetInt = resultSet.getInt(1); - - assertThat(resultSetInt).isEqualTo(1); + performQuery( + mysql, + "SELECT 1", + resultSet -> { + Assertions + .assertThatNoException() + .isThrownBy(() -> { + int resultSetInt = resultSet.getInt(1); + assertThat(resultSetInt).isEqualTo(1); + }); + } + ); } } private void assertThatCustomIniFileWasUsed(MariaDBContainer mariadb) throws SQLException { - try (ResultSet resultSet = performQuery(mariadb, "SELECT @@GLOBAL.innodb_max_undo_log_size")) { - long result = resultSet.getLong(1); - assertThat(result) - .as("The InnoDB max undo log size has been set by the ini file content") - .isEqualTo(20000000); - } + performQuery( + mariadb, + "SELECT @@GLOBAL.innodb_max_undo_log_size", + resultSet -> { + Assertions + .assertThatNoException() + .isThrownBy(() -> { + long result = resultSet.getLong(1); + assertThat(result) + .as("The InnoDB max undo log size has been set by the ini file content") + .isEqualTo(20000000); + }); + } + ); } } diff --git a/modules/mssqlserver/src/test/java/org/testcontainers/mssqlserver/MSSQLServerContainerTest.java b/modules/mssqlserver/src/test/java/org/testcontainers/mssqlserver/MSSQLServerContainerTest.java index 52269f11b9e..9c07b011f98 100644 --- a/modules/mssqlserver/src/test/java/org/testcontainers/mssqlserver/MSSQLServerContainerTest.java +++ b/modules/mssqlserver/src/test/java/org/testcontainers/mssqlserver/MSSQLServerContainerTest.java @@ -1,5 +1,6 @@ package org.testcontainers.mssqlserver; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; import org.testcontainers.MSSQLServerTestImages; import org.testcontainers.db.AbstractContainerDatabaseTest; @@ -25,10 +26,18 @@ void testSimple() throws SQLException { // } ) { mssqlServer.start(); - ResultSet resultSet = performQuery(mssqlServer, "SELECT 1"); - - int resultSetInt = resultSet.getInt(1); - assertThat(resultSetInt).as("A basic SELECT query succeeds").isEqualTo(1); + performQuery( + mssqlServer, + "SELECT 1", + resultSet -> { + Assertions + .assertThatNoException() + .isThrownBy(() -> { + int resultSetInt = resultSet.getInt(1); + assertThat(resultSetInt).as("A basic SELECT query succeeds").isEqualTo(1); + }); + } + ); assertHasCorrectExposedAndLivenessCheckPorts(mssqlServer); } } @@ -78,9 +87,18 @@ void testSqlServerConnection() throws SQLException { ) { mssqlServerContainer.start(); - ResultSet resultSet = performQuery(mssqlServerContainer, mssqlServerContainer.getTestQueryString()); - int resultSetInt = resultSet.getInt(1); - assertThat(resultSetInt).as("A basic SELECT query succeeds").isEqualTo(1); + performQuery( + mssqlServerContainer, + mssqlServerContainer.getTestQueryString(), + resultSet -> { + Assertions + .assertThatNoException() + .isThrownBy(() -> { + int resultSetInt = resultSet.getInt(1); + assertThat(resultSetInt).as("A basic SELECT query succeeds").isEqualTo(1); + }); + } + ); } } diff --git a/modules/mysql/src/test/java/org/testcontainers/mysql/MultiVersionMySQLTest.java b/modules/mysql/src/test/java/org/testcontainers/mysql/MultiVersionMySQLTest.java index 8dc4454860b..4e260a05412 100644 --- a/modules/mysql/src/test/java/org/testcontainers/mysql/MultiVersionMySQLTest.java +++ b/modules/mysql/src/test/java/org/testcontainers/mysql/MultiVersionMySQLTest.java @@ -1,12 +1,12 @@ package org.testcontainers.mysql; +import org.assertj.core.api.Assertions; import org.junit.jupiter.params.ParameterizedTest; import org.junit.jupiter.params.provider.MethodSource; import org.testcontainers.MySQLTestImages; import org.testcontainers.db.AbstractContainerDatabaseTest; import org.testcontainers.utility.DockerImageName; -import java.sql.ResultSet; import java.sql.SQLException; import static org.assertj.core.api.Assertions.assertThat; @@ -27,12 +27,20 @@ public static DockerImageName[] params() { void versionCheckTest(DockerImageName dockerImageName) throws SQLException { try (MySQLContainer mysql = new MySQLContainer(dockerImageName)) { mysql.start(); - final ResultSet resultSet = performQuery(mysql, "SELECT VERSION()"); - final String resultSetString = resultSet.getString(1); - - assertThat(resultSetString) - .as("The database version can be set using a container rule parameter") - .isEqualTo(dockerImageName.getVersionPart()); + performQuery( + mysql, + "SELECT VERSION()", + resultSet -> { + Assertions + .assertThatNoException() + .isThrownBy(() -> { + final String resultSetString = resultSet.getString(1); + assertThat(resultSetString) + .as("The database version can be set using a container rule parameter") + .isEqualTo(dockerImageName.getVersionPart()); + }); + } + ); } } } diff --git a/modules/mysql/src/test/java/org/testcontainers/mysql/MySQLContainerTest.java b/modules/mysql/src/test/java/org/testcontainers/mysql/MySQLContainerTest.java index ad78781db5c..16d147a2d9b 100644 --- a/modules/mysql/src/test/java/org/testcontainers/mysql/MySQLContainerTest.java +++ b/modules/mysql/src/test/java/org/testcontainers/mysql/MySQLContainerTest.java @@ -1,5 +1,6 @@ package org.testcontainers.mysql; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -41,10 +42,18 @@ void testSimple() throws SQLException { ) { mysql.start(); - ResultSet resultSet = performQuery(mysql, "SELECT 1"); - int resultSetInt = resultSet.getInt(1); - - assertThat(resultSetInt).as("A basic SELECT query succeeds").isEqualTo(1); + performQuery( + mysql, + "SELECT 1", + resultSet -> { + Assertions + .assertThatNoException() + .isThrownBy(() -> { + int resultSetInt = resultSet.getInt(1); + assertThat(resultSetInt).as("A basic SELECT query succeeds").isEqualTo(1); + }); + } + ); assertHasCorrectExposedAndLivenessCheckPorts(mysql); } } @@ -58,12 +67,20 @@ void testSpecificVersion() throws SQLException { ) { mysqlOldVersion.start(); - ResultSet resultSet = performQuery(mysqlOldVersion, "SELECT VERSION()"); - String resultSetString = resultSet.getString(1); - - assertThat(resultSetString) - .as("The database version can be set using a container rule parameter") - .startsWith("8.0"); + performQuery( + mysqlOldVersion, + "SELECT VERSION()", + resultSet -> { + Assertions + .assertThatNoException() + .isThrownBy(() -> { + String resultSetString = resultSet.getString(1); + assertThat(resultSetString) + .as("The database version can be set using a container rule parameter") + .startsWith("8.0"); + }); + } + ); } } @@ -87,10 +104,20 @@ void testCommandOverride() throws SQLException { ) { mysqlCustomConfig.start(); - ResultSet resultSet = performQuery(mysqlCustomConfig, "show variables like 'auto_increment_increment'"); - String result = resultSet.getString("Value"); - - assertThat(result).as("Auto increment increment should be overridden by command line").isEqualTo("42"); + performQuery( + mysqlCustomConfig, + "show variables like 'auto_increment_increment'", + resultSet -> { + Assertions + .assertThatNoException() + .isThrownBy(() -> { + String result = resultSet.getString("Value"); + assertThat(result) + .as("Auto increment increment should be overridden by command line") + .isEqualTo("42"); + }); + } + ); } } @@ -103,10 +130,20 @@ void testExplicitInitScript() throws SQLException { ) { container.start(); - ResultSet resultSet = performQuery(container, "SELECT foo FROM bar"); - String firstColumnValue = resultSet.getString(1); - - assertThat(firstColumnValue).as("Value from init script should equal real value").isEqualTo("hello world"); + performQuery( + container, + "SELECT foo FROM bar", + resultSet -> { + Assertions + .assertThatNoException() + .isThrownBy(() -> { + String firstColumnValue = resultSet.getString(1); + assertThat(firstColumnValue) + .as("Value from init script should equal real value") + .isEqualTo("hello world"); + }); + } + ); } } @@ -137,10 +174,18 @@ void testEmptyPasswordWithRootUser() throws SQLException { ) { mysql.start(); - ResultSet resultSet = performQuery(mysql, "SELECT 1"); - int resultSetInt = resultSet.getInt(1); - - assertThat(resultSetInt).as("A basic SELECT query succeeds").isEqualTo(1); + performQuery( + mysql, + "SELECT 1", + resultSet -> { + Assertions + .assertThatNoException() + .isThrownBy(() -> { + int resultSetInt = resultSet.getInt(1); + assertThat(resultSetInt).as("A basic SELECT query succeeds").isEqualTo(1); + }); + } + ); } } @@ -263,10 +308,18 @@ void testCustom() throws SQLException { ) { mysql.start(); - ResultSet resultSet = performQuery(mysql, "SELECT 1"); - - int resultSetInt = resultSet.getInt(1); - assertThat(resultSetInt).as("A basic SELECT query succeeds").isEqualTo(1); + performQuery( + mysql, + "SELECT 1", + resultSet -> { + Assertions + .assertThatNoException() + .isThrownBy(() -> { + int resultSetInt = resultSet.getInt(1); + assertThat(resultSetInt).as("A basic SELECT query succeeds").isEqualTo(1); + }); + } + ); } } @@ -276,11 +329,19 @@ private void assertHasCorrectExposedAndLivenessCheckPorts(MySQLContainer mysql) } private void assertThatCustomIniFileWasUsed(MySQLContainer mysql) throws SQLException { - try (ResultSet resultSet = performQuery(mysql, "SELECT @@GLOBAL.innodb_max_undo_log_size")) { - long result = resultSet.getLong(1); - assertThat(result) - .as("The InnoDB max undo log size has been set by the ini file content") - .isEqualTo(20000000); - } + performQuery( + mysql, + "SELECT @@GLOBAL.innodb_max_undo_log_size", + resultSet -> { + Assertions + .assertThatNoException() + .isThrownBy(() -> { + long result = resultSet.getLong(1); + assertThat(result) + .as("The InnoDB max undo log size has been set by the ini file content") + .isEqualTo(20000000); + }); + } + ); } } diff --git a/modules/oceanbase/src/test/java/org/testcontainers/oceanbase/SimpleOceanBaseCETest.java b/modules/oceanbase/src/test/java/org/testcontainers/oceanbase/SimpleOceanBaseCETest.java index ee2d8196718..499af74c196 100644 --- a/modules/oceanbase/src/test/java/org/testcontainers/oceanbase/SimpleOceanBaseCETest.java +++ b/modules/oceanbase/src/test/java/org/testcontainers/oceanbase/SimpleOceanBaseCETest.java @@ -1,9 +1,9 @@ package org.testcontainers.oceanbase; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; import org.testcontainers.db.AbstractContainerDatabaseTest; -import java.sql.ResultSet; import java.sql.SQLException; import static org.assertj.core.api.Assertions.assertThat; @@ -22,9 +22,18 @@ void testSimple() throws SQLException { ) { oceanbase.start(); - ResultSet resultSet = performQuery(oceanbase, "SELECT 1"); - int resultSetInt = resultSet.getInt(1); - assertThat(resultSetInt).as("A basic SELECT query succeeds").isEqualTo(1); + performQuery( + oceanbase, + "SELECT 1", + resultSet -> { + Assertions + .assertThatNoException() + .isThrownBy(() -> { + int resultSetInt = resultSet.getInt(1); + assertThat(resultSetInt).as("A basic SELECT query succeeds").isEqualTo(1); + }); + } + ); assertHasCorrectExposedAndLivenessCheckPorts(oceanbase); } } @@ -34,9 +43,20 @@ void testExplicitInitScript() throws SQLException { try (OceanBaseCEContainer oceanbase = new OceanBaseCEContainer(IMAGE).withInitScript("init.sql")) { oceanbase.start(); - ResultSet resultSet = performQuery(oceanbase, "SELECT foo FROM bar"); - String firstColumnValue = resultSet.getString(1); - assertThat(firstColumnValue).as("Value from init script should equal real value").isEqualTo("hello world"); + performQuery( + oceanbase, + "SELECT foo FROM bar", + resultSet -> { + Assertions + .assertThatNoException() + .isThrownBy(() -> { + String firstColumnValue = resultSet.getString(1); + assertThat(firstColumnValue) + .as("Value from init script should equal real value") + .isEqualTo("hello world"); + }); + } + ); } } diff --git a/modules/oracle-free/src/test/java/org/testcontainers/junit/oracle/SimpleOracleTest.java b/modules/oracle-free/src/test/java/org/testcontainers/junit/oracle/SimpleOracleTest.java index f46539bac89..f2028cbc7b3 100644 --- a/modules/oracle-free/src/test/java/org/testcontainers/junit/oracle/SimpleOracleTest.java +++ b/modules/oracle-free/src/test/java/org/testcontainers/junit/oracle/SimpleOracleTest.java @@ -1,11 +1,11 @@ package org.testcontainers.junit.oracle; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; import org.testcontainers.db.AbstractContainerDatabaseTest; import org.testcontainers.oracle.OracleContainer; import org.testcontainers.utility.DockerImageName; -import java.sql.ResultSet; import java.sql.SQLException; import static org.assertj.core.api.Assertions.assertThat; @@ -26,9 +26,18 @@ private void runTest(OracleContainer container, String databaseName, String user //Test we can get a connection container.start(); - ResultSet resultSet = performQuery(container, "SELECT 1 FROM dual"); - int resultSetInt = resultSet.getInt(1); - assertThat(resultSetInt).as("A basic SELECT query succeeds").isEqualTo(1); + performQuery( + container, + "SELECT 1 FROM dual", + resultSet -> { + Assertions + .assertThatNoException() + .isThrownBy(() -> { + int resultSetInt = resultSet.getInt(1); + assertThat(resultSetInt).as("A basic SELECT query succeeds").isEqualTo(1); + }); + } + ); } @Test diff --git a/modules/oracle-xe/src/test/java/org/testcontainers/junit/oracle/SimpleOracleTest.java b/modules/oracle-xe/src/test/java/org/testcontainers/junit/oracle/SimpleOracleTest.java index 17ee85944a7..b0e40eb492e 100644 --- a/modules/oracle-xe/src/test/java/org/testcontainers/junit/oracle/SimpleOracleTest.java +++ b/modules/oracle-xe/src/test/java/org/testcontainers/junit/oracle/SimpleOracleTest.java @@ -1,11 +1,11 @@ package org.testcontainers.junit.oracle; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; import org.testcontainers.containers.OracleContainer; import org.testcontainers.db.AbstractContainerDatabaseTest; import org.testcontainers.utility.DockerImageName; -import java.sql.ResultSet; import java.sql.SQLException; import static org.assertj.core.api.Assertions.assertThat; @@ -26,9 +26,18 @@ private void runTest(OracleContainer container, String databaseName, String user //Test we can get a connection container.start(); - ResultSet resultSet = performQuery(container, "SELECT 1 FROM dual"); - int resultSetInt = resultSet.getInt(1); - assertThat(resultSetInt).as("A basic SELECT query succeeds").isEqualTo(1); + performQuery( + container, + "SELECT 1 FROM dual", + resultSet -> { + Assertions + .assertThatNoException() + .isThrownBy(() -> { + int resultSetInt = resultSet.getInt(1); + assertThat(resultSetInt).as("A basic SELECT query succeeds").isEqualTo(1); + }); + } + ); } @Test diff --git a/modules/postgresql/src/test/java/org/testcontainers/containers/TimescaleDBContainerTest.java b/modules/postgresql/src/test/java/org/testcontainers/containers/TimescaleDBContainerTest.java index 3991f4c2b1c..beb8c496106 100644 --- a/modules/postgresql/src/test/java/org/testcontainers/containers/TimescaleDBContainerTest.java +++ b/modules/postgresql/src/test/java/org/testcontainers/containers/TimescaleDBContainerTest.java @@ -1,9 +1,9 @@ package org.testcontainers.containers; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; import org.testcontainers.db.AbstractContainerDatabaseTest; -import java.sql.ResultSet; import java.sql.SQLException; import static org.assertj.core.api.Assertions.assertThat; @@ -15,9 +15,18 @@ void testSimple() throws SQLException { try (JdbcDatabaseContainer postgres = new TimescaleDBContainerProvider().newInstance()) { postgres.start(); - ResultSet resultSet = performQuery(postgres, "SELECT 1"); - int resultSetInt = resultSet.getInt(1); - assertThat(resultSetInt).as("A basic SELECT query succeeds").isEqualTo(1); + performQuery( + postgres, + "SELECT 1", + resultSet -> { + Assertions + .assertThatNoException() + .isThrownBy(() -> { + int resultSetInt = resultSet.getInt(1); + assertThat(resultSetInt).as("A basic SELECT query succeeds").isEqualTo(1); + }); + } + ); } } @@ -30,12 +39,18 @@ void testCommandOverride() throws SQLException { ) { postgres.start(); - ResultSet resultSet = performQuery( + performQuery( (JdbcDatabaseContainer) postgres, - "SELECT current_setting('max_connections')" + "SELECT current_setting('max_connections')", + resultSet -> { + Assertions + .assertThatNoException() + .isThrownBy(() -> { + String result = resultSet.getString(1); + assertThat(result).as("max_connections should be overridden").isEqualTo("42"); + }); + } ); - String result = resultSet.getString(1); - assertThat(result).as("max_connections should be overridden").isEqualTo("42"); } } @@ -49,12 +64,18 @@ void testUnsetCommand() throws SQLException { ) { postgres.start(); - ResultSet resultSet = performQuery( + performQuery( (JdbcDatabaseContainer) postgres, - "SELECT current_setting('max_connections')" + "SELECT current_setting('max_connections')", + resultSet -> { + Assertions + .assertThatNoException() + .isThrownBy(() -> { + String result = resultSet.getString(1); + assertThat(result).as("max_connections should not be overridden").isNotEqualTo("42"); + }); + } ); - String result = resultSet.getString(1); - assertThat(result).as("max_connections should not be overridden").isNotEqualTo("42"); } } @@ -67,10 +88,20 @@ void testExplicitInitScript() throws SQLException { ) { postgres.start(); - ResultSet resultSet = performQuery(postgres, "SELECT foo FROM bar"); - - String firstColumnValue = resultSet.getString(1); - assertThat(firstColumnValue).as("Value from init script should equal real value").isEqualTo("hello world"); + performQuery( + postgres, + "SELECT foo FROM bar", + resultSet -> { + Assertions + .assertThatNoException() + .isThrownBy(() -> { + String firstColumnValue = resultSet.getString(1); + assertThat(firstColumnValue) + .as("Value from init script should equal real value") + .isEqualTo("hello world"); + }); + } + ); } } } diff --git a/modules/postgresql/src/test/java/org/testcontainers/postgresql/CompatibleImageTest.java b/modules/postgresql/src/test/java/org/testcontainers/postgresql/CompatibleImageTest.java index bdad4fb6a5c..74c96bb8b71 100644 --- a/modules/postgresql/src/test/java/org/testcontainers/postgresql/CompatibleImageTest.java +++ b/modules/postgresql/src/test/java/org/testcontainers/postgresql/CompatibleImageTest.java @@ -1,10 +1,10 @@ package org.testcontainers.postgresql; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; import org.testcontainers.db.AbstractContainerDatabaseTest; import org.testcontainers.utility.DockerImageName; -import java.sql.ResultSet; import java.sql.SQLException; import static org.assertj.core.api.Assertions.assertThat; @@ -20,9 +20,18 @@ void pgvector() throws SQLException { ) { pgvector.start(); - ResultSet resultSet = performQuery(pgvector, "SELECT 1"); - int resultSetInt = resultSet.getInt(1); - assertThat(resultSetInt).as("A basic SELECT query succeeds").isEqualTo(1); + performQuery( + pgvector, + "SELECT 1", + resultSet -> { + Assertions + .assertThatNoException() + .isThrownBy(() -> { + int resultSetInt = resultSet.getInt(1); + assertThat(resultSetInt).as("A basic SELECT query succeeds").isEqualTo(1); + }); + } + ); } } @@ -37,9 +46,18 @@ void postgis() throws SQLException { ) { postgis.start(); - ResultSet resultSet = performQuery(postgis, "SELECT 1"); - int resultSetInt = resultSet.getInt(1); - assertThat(resultSetInt).as("A basic SELECT query succeeds").isEqualTo(1); + performQuery( + postgis, + "SELECT 1", + resultSet -> { + Assertions + .assertThatNoException() + .isThrownBy(() -> { + int resultSetInt = resultSet.getInt(1); + assertThat(resultSetInt).as("A basic SELECT query succeeds").isEqualTo(1); + }); + } + ); } } @@ -54,9 +72,18 @@ void timescaledb() throws SQLException { ) { timescaledb.start(); - ResultSet resultSet = performQuery(timescaledb, "SELECT 1"); - int resultSetInt = resultSet.getInt(1); - assertThat(resultSetInt).as("A basic SELECT query succeeds").isEqualTo(1); + performQuery( + timescaledb, + "SELECT 1", + resultSet -> { + Assertions + .assertThatNoException() + .isThrownBy(() -> { + int resultSetInt = resultSet.getInt(1); + assertThat(resultSetInt).as("A basic SELECT query succeeds").isEqualTo(1); + }); + } + ); } } } diff --git a/modules/postgresql/src/test/java/org/testcontainers/postgresql/PostgreSQLContainerTest.java b/modules/postgresql/src/test/java/org/testcontainers/postgresql/PostgreSQLContainerTest.java index beefa3776b1..0e54814e462 100644 --- a/modules/postgresql/src/test/java/org/testcontainers/postgresql/PostgreSQLContainerTest.java +++ b/modules/postgresql/src/test/java/org/testcontainers/postgresql/PostgreSQLContainerTest.java @@ -1,10 +1,10 @@ package org.testcontainers.postgresql; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; import org.testcontainers.PostgreSQLTestImages; import org.testcontainers.db.AbstractContainerDatabaseTest; -import java.sql.ResultSet; import java.sql.SQLException; import java.util.logging.Level; import java.util.logging.LogManager; @@ -26,9 +26,18 @@ void testSimple() throws SQLException { ) { postgres.start(); - ResultSet resultSet = performQuery(postgres, "SELECT 1"); - int resultSetInt = resultSet.getInt(1); - assertThat(resultSetInt).as("A basic SELECT query succeeds").isEqualTo(1); + performQuery( + postgres, + "SELECT 1", + resultSet -> { + Assertions + .assertThatNoException() + .isThrownBy(() -> { + int resultSetInt = resultSet.getInt(1); + assertThat(resultSetInt).as("A basic SELECT query succeeds").isEqualTo(1); + }); + } + ); assertHasCorrectExposedAndLivenessCheckPorts(postgres); } } @@ -41,9 +50,18 @@ void testCommandOverride() throws SQLException { ) { postgres.start(); - ResultSet resultSet = performQuery(postgres, "SELECT current_setting('max_connections')"); - String result = resultSet.getString(1); - assertThat(result).as("max_connections should be overridden").isEqualTo("42"); + performQuery( + postgres, + "SELECT current_setting('max_connections')", + resultSet -> { + Assertions + .assertThatNoException() + .isThrownBy(() -> { + String result = resultSet.getString(1); + assertThat(result).as("max_connections should be overridden").isEqualTo("42"); + }); + } + ); } } @@ -56,9 +74,18 @@ void testUnsetCommand() throws SQLException { ) { postgres.start(); - ResultSet resultSet = performQuery(postgres, "SELECT current_setting('max_connections')"); - String result = resultSet.getString(1); - assertThat(result).as("max_connections should not be overridden").isNotEqualTo("42"); + performQuery( + postgres, + "SELECT current_setting('max_connections')", + resultSet -> { + Assertions + .assertThatNoException() + .isThrownBy(() -> { + String result = resultSet.getString(1); + assertThat(result).as("max_connections should not be overridden").isNotEqualTo("42"); + }); + } + ); } } @@ -80,10 +107,20 @@ void testExplicitInitScript() throws SQLException { ) { postgres.start(); - ResultSet resultSet = performQuery(postgres, "SELECT foo FROM bar"); - - String firstColumnValue = resultSet.getString(1); - assertThat(firstColumnValue).as("Value from init script should equal real value").isEqualTo("hello world"); + performQuery( + postgres, + "SELECT foo FROM bar", + resultSet -> { + Assertions + .assertThatNoException() + .isThrownBy(() -> { + String firstColumnValue = resultSet.getString(1); + assertThat(firstColumnValue) + .as("Value from init script should equal real value") + .isEqualTo("hello world"); + }); + } + ); } } @@ -95,16 +132,25 @@ void testExplicitInitScripts() throws SQLException { ) { postgres.start(); - ResultSet resultSet = performQuery( + performQuery( postgres, - "SELECT foo AS value FROM bar UNION SELECT bar AS value FROM foo" + "SELECT foo AS value FROM bar UNION SELECT bar AS value FROM foo", + resultSet -> { + Assertions + .assertThatNoException() + .isThrownBy(() -> { + String columnValue1 = resultSet.getString(1); + resultSet.next(); + String columnValue2 = resultSet.getString(1); + assertThat(columnValue1) + .as("Value from init script 1 should equal real value") + .isEqualTo("hello world"); + assertThat(columnValue2) + .as("Value from init script 2 should equal real value") + .isEqualTo("hello world 2"); + }); + } ); - - String columnValue1 = resultSet.getString(1); - resultSet.next(); - String columnValue2 = resultSet.getString(1); - assertThat(columnValue1).as("Value from init script 1 should equal real value").isEqualTo("hello world"); - assertThat(columnValue2).as("Value from init script 2 should equal real value").isEqualTo("hello world 2"); } } diff --git a/modules/questdb/src/test/java/org/testcontainers/junit/questdb/SimpleQuestDBTest.java b/modules/questdb/src/test/java/org/testcontainers/junit/questdb/SimpleQuestDBTest.java index aad4df70c2c..a4dff68d6ec 100644 --- a/modules/questdb/src/test/java/org/testcontainers/junit/questdb/SimpleQuestDBTest.java +++ b/modules/questdb/src/test/java/org/testcontainers/junit/questdb/SimpleQuestDBTest.java @@ -6,6 +6,7 @@ import org.apache.http.impl.client.CloseableHttpClient; import org.apache.http.impl.client.HttpClientBuilder; import org.apache.http.util.EntityUtils; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; import org.testcontainers.QuestDBTestImages; import org.testcontainers.containers.QuestDBContainer; @@ -14,7 +15,6 @@ import java.io.IOException; import java.net.URLEncoder; import java.nio.charset.StandardCharsets; -import java.sql.ResultSet; import java.sql.SQLException; import static org.assertj.core.api.Assertions.assertThat; @@ -32,10 +32,18 @@ void testSimple() throws SQLException { ) { questDB.start(); - ResultSet resultSet = performQuery(questDB, questDB.getTestQueryString()); - - int resultSetInt = resultSet.getInt(1); - assertThat(resultSetInt).as("A basic SELECT query succeeds").isEqualTo(1); + performQuery( + questDB, + questDB.getTestQueryString(), + resultSet -> { + Assertions + .assertThatNoException() + .isThrownBy(() -> { + int resultSetInt = resultSet.getInt(1); + assertThat(resultSetInt).as("A basic SELECT query succeeds").isEqualTo(1); + }); + } + ); } } diff --git a/modules/tidb/src/test/java/org/testcontainers/tidb/TiDBContainerTest.java b/modules/tidb/src/test/java/org/testcontainers/tidb/TiDBContainerTest.java index 54ded93e69e..5897a624582 100644 --- a/modules/tidb/src/test/java/org/testcontainers/tidb/TiDBContainerTest.java +++ b/modules/tidb/src/test/java/org/testcontainers/tidb/TiDBContainerTest.java @@ -1,10 +1,10 @@ package org.testcontainers.tidb; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; import org.testcontainers.TiDBTestImages; import org.testcontainers.db.AbstractContainerDatabaseTest; -import java.sql.ResultSet; import java.sql.SQLException; import static org.assertj.core.api.Assertions.assertThat; @@ -19,10 +19,18 @@ void testSimple() throws SQLException { ) { tidb.start(); - ResultSet resultSet = performQuery(tidb, "SELECT 1"); - - int resultSetInt = resultSet.getInt(1); - assertThat(resultSetInt).isEqualTo(1); + performQuery( + tidb, + "SELECT 1", + resultSet -> { + Assertions + .assertThatNoException() + .isThrownBy(() -> { + int resultSetInt = resultSet.getInt(1); + assertThat(resultSetInt).isEqualTo(1); + }); + } + ); assertHasCorrectExposedAndLivenessCheckPorts(tidb); } } @@ -34,10 +42,18 @@ void testExplicitInitScript() throws SQLException { ) { // TiDB is expected to be compatible with MySQL tidb.start(); - ResultSet resultSet = performQuery(tidb, "SELECT foo FROM bar"); - - String firstColumnValue = resultSet.getString(1); - assertThat(firstColumnValue).isEqualTo("hello world"); + performQuery( + tidb, + "SELECT foo FROM bar", + resultSet -> { + Assertions + .assertThatNoException() + .isThrownBy(() -> { + String firstColumnValue = resultSet.getString(1); + assertThat(firstColumnValue).isEqualTo("hello world"); + }); + } + ); } } diff --git a/modules/timeplus/src/test/java/org/testcontainers/timeplus/TimeplusContainerTest.java b/modules/timeplus/src/test/java/org/testcontainers/timeplus/TimeplusContainerTest.java index 7ab38c03f87..b95f1839cd5 100644 --- a/modules/timeplus/src/test/java/org/testcontainers/timeplus/TimeplusContainerTest.java +++ b/modules/timeplus/src/test/java/org/testcontainers/timeplus/TimeplusContainerTest.java @@ -1,10 +1,10 @@ package org.testcontainers.timeplus; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; import org.testcontainers.TimeplusImages; import org.testcontainers.db.AbstractContainerDatabaseTest; -import java.sql.ResultSet; import java.sql.SQLException; import static org.assertj.core.api.Assertions.assertThat; @@ -19,10 +19,18 @@ void testSimple() throws SQLException { ) { timeplus.start(); - ResultSet resultSet = performQuery(timeplus, "SELECT 1"); - - int resultSetInt = resultSet.getInt(1); - assertThat(resultSetInt).isEqualTo(1); + performQuery( + timeplus, + "SELECT 1", + resultSet -> { + Assertions + .assertThatNoException() + .isThrownBy(() -> { + int resultSetInt = resultSet.getInt(1); + assertThat(resultSetInt).isEqualTo(1); + }); + } + ); } } @@ -37,13 +45,18 @@ void customCredentialsWithUrlParams() throws SQLException { ) { timeplus.start(); - ResultSet resultSet = performQuery( + performQuery( timeplus, - "SELECT to_int(value) FROM system.settings where name='interactive_delay'" + "SELECT to_int(value) FROM system.settings where name='interactive_delay'", + resultSet -> { + Assertions + .assertThatNoException() + .isThrownBy(() -> { + int resultSetInt = resultSet.getInt(1); + assertThat(resultSetInt).isEqualTo(5); + }); + } ); - - int resultSetInt = resultSet.getInt(1); - assertThat(resultSetInt).isEqualTo(5); } } } diff --git a/modules/yugabytedb/src/test/java/org/testcontainers/junit/yugabytedb/YugabyteDBYSQLTest.java b/modules/yugabytedb/src/test/java/org/testcontainers/junit/yugabytedb/YugabyteDBYSQLTest.java index 04d1448cfba..ea0e689f362 100644 --- a/modules/yugabytedb/src/test/java/org/testcontainers/junit/yugabytedb/YugabyteDBYSQLTest.java +++ b/modules/yugabytedb/src/test/java/org/testcontainers/junit/yugabytedb/YugabyteDBYSQLTest.java @@ -1,5 +1,6 @@ package org.testcontainers.junit.yugabytedb; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; import org.testcontainers.containers.YugabyteDBYSQLContainer; import org.testcontainers.db.AbstractContainerDatabaseTest; @@ -28,9 +29,17 @@ void testSmoke() throws SQLException { // } ) { ysqlContainer.start(); - assertThat(performQuery(ysqlContainer, "SELECT 1").getInt(1)) - .as("A sample test query succeeds") - .isEqualTo(1); + performQuery( + ysqlContainer, + "SELECT 1", + resultSet -> { + Assertions + .assertThatNoException() + .isThrownBy(() -> { + assertThat(resultSet.getInt(1)).as("A sample test query succeeds").isEqualTo(1); + }); + } + ); } } @@ -42,9 +51,19 @@ void testCustomDatabase() throws SQLException { .withDatabaseName(key) ) { ysqlContainer.start(); - assertThat(performQuery(ysqlContainer, "SELECT 1").getInt(1)) - .as("A test query on a custom database succeeds") - .isEqualTo(1); + performQuery( + ysqlContainer, + "SELECT 1", + resultSet -> { + Assertions + .assertThatNoException() + .isThrownBy(() -> { + assertThat(resultSet.getInt(1)) + .as("A test query on a custom database succeeds") + .isEqualTo(1); + }); + } + ); } } @@ -55,9 +74,17 @@ void testInitScript() throws SQLException { .withInitScript("init/init_yql.sql") ) { ysqlContainer.start(); - assertThat(performQuery(ysqlContainer, "SELECT greet FROM dsql").getString(1)) - .as("A record match succeeds") - .isEqualTo("Hello DSQL"); + performQuery( + ysqlContainer, + "SELECT greet FROM dsql", + resultSet -> { + Assertions + .assertThatNoException() + .isThrownBy(() -> { + assertThat(resultSet.getString(1)).as("A record match succeeds").isEqualTo("Hello DSQL"); + }); + } + ); } } @@ -88,9 +115,19 @@ void testWithCustomRole() throws SQLException { .withUsername("yugabyte") ) { ysqlContainer.start(); - assertThat(performQuery(ysqlContainer, "SELECT 1").getInt(1)) - .as("A sample test query with a custom role succeeds") - .isEqualTo(1); + performQuery( + ysqlContainer, + "SELECT 1", + resultSet -> { + Assertions + .assertThatNoException() + .isThrownBy(() -> { + assertThat(resultSet.getInt(1)) + .as("A sample test query with a custom role succeeds") + .isEqualTo(1); + }); + } + ); } } @@ -98,15 +135,29 @@ void testWithCustomRole() throws SQLException { void testWaitStrategy() throws SQLException { try (final YugabyteDBYSQLContainer ysqlContainer = new YugabyteDBYSQLContainer(YBDB_TEST_IMAGE)) { ysqlContainer.start(); - assertThat(performQuery(ysqlContainer, "SELECT 1").getInt(1)) - .as("A sample test query succeeds") - .isEqualTo(1); - boolean tableExists = performQuery( + performQuery( ysqlContainer, - "SELECT EXISTS (SELECT FROM pg_tables WHERE tablename = 'YB_SAMPLE')" - ) - .getBoolean(1); - assertThat(tableExists).as("yb_sample table does not exists").isFalse(); + "SELECT 1", + resultSet -> { + Assertions + .assertThatNoException() + .isThrownBy(() -> { + assertThat(resultSet.getInt(1)).as("A sample test query succeeds").isEqualTo(1); + }); + } + ); + performQuery( + ysqlContainer, + "SELECT EXISTS (SELECT FROM pg_tables WHERE tablename = 'YB_SAMPLE')", + resultSet -> { + Assertions + .assertThatNoException() + .isThrownBy(() -> { + boolean tableExists = resultSet.getBoolean(1); + assertThat(tableExists).as("yb_sample table does not exists").isFalse(); + }); + } + ); } } } From c8f91bf5fa47d03af9b2277e509b2a892800fe35 Mon Sep 17 00:00:00 2001 From: "raju.gupta" Date: Sun, 12 Oct 2025 17:27:25 +0100 Subject: [PATCH 2/9] Refactor query execution to use performSelectOneQuery method for consistency --- .../clickhouse/ClickHouseContainerTest.java | 26 +----------- .../clickhouse/SimpleClickhouseTest.java | 18 +------- .../cockroachdb/CockroachContainerTest.java | 27 +----------- .../junit/cratedb/SimpleCrateDBTest.java | 13 +----- .../databend/DatabendContainerTest.java | 29 +------------ .../db/AbstractContainerDatabaseTest.java | 16 +++++++ .../mariadb/MariaDBContainerTest.java | 26 +----------- .../mssqlserver/MSSQLServerContainerTest.java | 29 ++----------- .../mysql/MySQLContainerTest.java | 40 ++---------------- .../oceanbase/SimpleOceanBaseCETest.java | 14 +------ .../containers/TimescaleDBContainerTest.java | 2 + .../postgresql/CompatibleImageTest.java | 42 ++----------------- .../postgresql/PostgreSQLContainerTest.java | 14 +------ .../junit/questdb/SimpleQuestDBTest.java | 14 +------ .../tidb/TiDBContainerTest.java | 14 +------ .../timeplus/TimeplusContainerTest.java | 13 +----- .../junit/yugabytedb/YugabyteDBYSQLTest.java | 42 ++++--------------- 17 files changed, 55 insertions(+), 324 deletions(-) diff --git a/modules/clickhouse/src/test/java/org/testcontainers/clickhouse/ClickHouseContainerTest.java b/modules/clickhouse/src/test/java/org/testcontainers/clickhouse/ClickHouseContainerTest.java index e2cc019687e..7f08ae497a3 100644 --- a/modules/clickhouse/src/test/java/org/testcontainers/clickhouse/ClickHouseContainerTest.java +++ b/modules/clickhouse/src/test/java/org/testcontainers/clickhouse/ClickHouseContainerTest.java @@ -26,18 +26,7 @@ void testSimple() throws SQLException { ) { clickhouse.start(); - performQuery( - clickhouse, - "SELECT 1", - resultSet -> { - Assertions - .assertThatNoException() - .isThrownBy(() -> { - int resultSetInt = resultSet.getInt(1); - assertThat(resultSetInt).isEqualTo(1); - }); - } - ); + performSelectOneQuery(clickhouse); } } @@ -73,18 +62,7 @@ void testNewAuth() throws SQLException { try (ClickHouseContainer clickhouse = new ClickHouseContainer(ClickhouseTestImages.CLICKHOUSE_24_12_IMAGE)) { clickhouse.start(); - performQuery( - clickhouse, - "SELECT 1", - resultSet -> { - Assertions - .assertThatNoException() - .isThrownBy(() -> { - int resultSetInt = resultSet.getInt(1); - assertThat(resultSetInt).isEqualTo(1); - }); - } - ); + performSelectOneQuery(clickhouse); } } diff --git a/modules/clickhouse/src/test/java/org/testcontainers/junit/clickhouse/SimpleClickhouseTest.java b/modules/clickhouse/src/test/java/org/testcontainers/junit/clickhouse/SimpleClickhouseTest.java index e93de2e6dd0..2f42383d9a5 100644 --- a/modules/clickhouse/src/test/java/org/testcontainers/junit/clickhouse/SimpleClickhouseTest.java +++ b/modules/clickhouse/src/test/java/org/testcontainers/junit/clickhouse/SimpleClickhouseTest.java @@ -1,6 +1,5 @@ package org.testcontainers.junit.clickhouse; -import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; import org.testcontainers.ClickhouseTestImages; import org.testcontainers.containers.ClickHouseContainer; @@ -8,27 +7,14 @@ import java.sql.SQLException; -import static org.assertj.core.api.Assertions.assertThat; - class SimpleClickhouseTest extends AbstractContainerDatabaseTest { @Test - public void testSimple() throws SQLException { + void testSimple() throws SQLException { try (ClickHouseContainer clickhouse = new ClickHouseContainer(ClickhouseTestImages.CLICKHOUSE_IMAGE)) { clickhouse.start(); - performQuery( - clickhouse, - "SELECT 1", - resultSet -> { - Assertions - .assertThatNoException() - .isThrownBy(() -> { - int resultSetInt = resultSet.getInt(1); - assertThat(resultSetInt).as("A basic SELECT query succeeds").isEqualTo(1); - }); - } - ); + performSelectOneQuery(clickhouse); } } } diff --git a/modules/cockroachdb/src/test/java/org/testcontainers/cockroachdb/CockroachContainerTest.java b/modules/cockroachdb/src/test/java/org/testcontainers/cockroachdb/CockroachContainerTest.java index d05bb6a9150..4136c8eed3f 100644 --- a/modules/cockroachdb/src/test/java/org/testcontainers/cockroachdb/CockroachContainerTest.java +++ b/modules/cockroachdb/src/test/java/org/testcontainers/cockroachdb/CockroachContainerTest.java @@ -26,19 +26,7 @@ void testSimple() throws SQLException { // } ) { cockroach.start(); - - performQuery( - cockroach, - "SELECT 1", - resultSet -> { - Assertions - .assertThatNoException() - .isThrownBy(() -> { - int resultSetInt = resultSet.getInt(1); - assertThat(resultSetInt).as("A basic SELECT query succeeds").isEqualTo(1); - }); - } - ); + performSelectOneQuery(cockroach); } } @@ -98,18 +86,7 @@ void testWithUsernamePasswordDatabase() throws SQLException { ) { cockroach.start(); - performQuery( - cockroach, - "SELECT 1", - resultSet -> { - Assertions - .assertThatNoException() - .isThrownBy(() -> { - int resultSetInt = resultSet.getInt(1); - assertThat(resultSetInt).as("A basic SELECT query succeeds").isEqualTo(1); - }); - } - ); + performSelectOneQuery(cockroach); String jdbcUrl = cockroach.getJdbcUrl(); assertThat(jdbcUrl).contains("/" + "test_database"); diff --git a/modules/cratedb/src/test/java/org/testcontainers/junit/cratedb/SimpleCrateDBTest.java b/modules/cratedb/src/test/java/org/testcontainers/junit/cratedb/SimpleCrateDBTest.java index 24ce9c13df4..fbc5b78b67d 100644 --- a/modules/cratedb/src/test/java/org/testcontainers/junit/cratedb/SimpleCrateDBTest.java +++ b/modules/cratedb/src/test/java/org/testcontainers/junit/cratedb/SimpleCrateDBTest.java @@ -26,18 +26,7 @@ void testSimple() throws SQLException { ) { cratedb.start(); - performQuery( - cratedb, - "SELECT 1", - resultSet -> { - Assertions - .assertThatNoException() - .isThrownBy(() -> { - int resultSetInt = resultSet.getInt(1); - assertThat(resultSetInt).as("A basic SELECT query succeeds").isEqualTo(1); - }); - } - ); + performSelectOneQuery(cratedb); assertHasCorrectExposedAndLivenessCheckPorts(cratedb); } } diff --git a/modules/databend/src/test/java/org/testcontainers/databend/DatabendContainerTest.java b/modules/databend/src/test/java/org/testcontainers/databend/DatabendContainerTest.java index 5495335ede5..10befee7865 100644 --- a/modules/databend/src/test/java/org/testcontainers/databend/DatabendContainerTest.java +++ b/modules/databend/src/test/java/org/testcontainers/databend/DatabendContainerTest.java @@ -1,13 +1,10 @@ package org.testcontainers.databend; -import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; import org.testcontainers.db.AbstractContainerDatabaseTest; import java.sql.SQLException; -import static org.assertj.core.api.Assertions.assertThat; - class DatabendContainerTest extends AbstractContainerDatabaseTest { @Test @@ -18,18 +15,7 @@ void testSimple() throws SQLException { ) { databend.start(); - performQuery( - databend, - "SELECT 1", - resultSet -> { - Assertions - .assertThatNoException() - .isThrownBy(() -> { - int resultSetInt = resultSet.getInt(1); - assertThat(resultSetInt).isEqualTo(1); - }); - } - ); + performSelectOneQuery(databend); } } @@ -43,18 +29,7 @@ void customCredentialsWithUrlParams() throws SQLException { ) { databend.start(); - performQuery( - databend, - "SELECT 1;", - resultSet -> { - Assertions - .assertThatNoException() - .isThrownBy(() -> { - int resultSetInt = resultSet.getInt(1); - assertThat(resultSetInt).isEqualTo(1); - }); - } - ); + performSelectOneQuery(databend); } } } diff --git a/modules/jdbc-test/src/main/java/org/testcontainers/db/AbstractContainerDatabaseTest.java b/modules/jdbc-test/src/main/java/org/testcontainers/db/AbstractContainerDatabaseTest.java index 60289d9ca9b..3b0c4715225 100644 --- a/modules/jdbc-test/src/main/java/org/testcontainers/db/AbstractContainerDatabaseTest.java +++ b/modules/jdbc-test/src/main/java/org/testcontainers/db/AbstractContainerDatabaseTest.java @@ -2,6 +2,7 @@ import com.zaxxer.hikari.HikariConfig; import com.zaxxer.hikari.HikariDataSource; +import org.assertj.core.api.Assertions; import org.testcontainers.containers.JdbcDatabaseContainer; import java.sql.Connection; @@ -31,6 +32,21 @@ protected void performQuery( } } + protected void performSelectOneQuery(final JdbcDatabaseContainer container) throws SQLException { + performQuery( + container, + "SELECT 1", + resultSet -> { + Assertions + .assertThatNoException() + .isThrownBy(() -> { + int resultSetInt = resultSet.getInt(1); + Assertions.assertThat(resultSetInt).as("A basic SELECT query succeeds").isEqualTo(1); + }); + } + ); + } + protected DataSource getDataSource(final JdbcDatabaseContainer container) { HikariConfig hikariConfig = new HikariConfig(); hikariConfig.setJdbcUrl(container.getJdbcUrl()); diff --git a/modules/mariadb/src/test/java/org/testcontainers/mariadb/MariaDBContainerTest.java b/modules/mariadb/src/test/java/org/testcontainers/mariadb/MariaDBContainerTest.java index 37f0f233a80..f4b95c54a4a 100644 --- a/modules/mariadb/src/test/java/org/testcontainers/mariadb/MariaDBContainerTest.java +++ b/modules/mariadb/src/test/java/org/testcontainers/mariadb/MariaDBContainerTest.java @@ -29,18 +29,7 @@ void testSimple() throws SQLException { ) { mariadb.start(); - performQuery( - mariadb, - "SELECT 1", - resultSet -> { - Assertions - .assertThatNoException() - .isThrownBy(() -> { - int resultSetInt = resultSet.getInt(1); - assertThat(resultSetInt).as("A basic SELECT query succeeds").isEqualTo(1); - }); - } - ); + performSelectOneQuery(mariadb); } } @@ -164,18 +153,7 @@ void testEmptyPasswordWithRootUser() throws SQLException { try (MariaDBContainer mysql = new MariaDBContainer("mariadb:11.2.4").withUsername("root")) { mysql.start(); - performQuery( - mysql, - "SELECT 1", - resultSet -> { - Assertions - .assertThatNoException() - .isThrownBy(() -> { - int resultSetInt = resultSet.getInt(1); - assertThat(resultSetInt).isEqualTo(1); - }); - } - ); + performSelectOneQuery(mysql); } } diff --git a/modules/mssqlserver/src/test/java/org/testcontainers/mssqlserver/MSSQLServerContainerTest.java b/modules/mssqlserver/src/test/java/org/testcontainers/mssqlserver/MSSQLServerContainerTest.java index 9c07b011f98..b8d99904d91 100644 --- a/modules/mssqlserver/src/test/java/org/testcontainers/mssqlserver/MSSQLServerContainerTest.java +++ b/modules/mssqlserver/src/test/java/org/testcontainers/mssqlserver/MSSQLServerContainerTest.java @@ -1,6 +1,5 @@ package org.testcontainers.mssqlserver; -import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; import org.testcontainers.MSSQLServerTestImages; import org.testcontainers.db.AbstractContainerDatabaseTest; @@ -26,18 +25,9 @@ void testSimple() throws SQLException { // } ) { mssqlServer.start(); - performQuery( - mssqlServer, - "SELECT 1", - resultSet -> { - Assertions - .assertThatNoException() - .isThrownBy(() -> { - int resultSetInt = resultSet.getInt(1); - assertThat(resultSetInt).as("A basic SELECT query succeeds").isEqualTo(1); - }); - } - ); + + performSelectOneQuery(mssqlServer); + assertHasCorrectExposedAndLivenessCheckPorts(mssqlServer); } } @@ -87,18 +77,7 @@ void testSqlServerConnection() throws SQLException { ) { mssqlServerContainer.start(); - performQuery( - mssqlServerContainer, - mssqlServerContainer.getTestQueryString(), - resultSet -> { - Assertions - .assertThatNoException() - .isThrownBy(() -> { - int resultSetInt = resultSet.getInt(1); - assertThat(resultSetInt).as("A basic SELECT query succeeds").isEqualTo(1); - }); - } - ); + performSelectOneQuery(mssqlServerContainer); } } diff --git a/modules/mysql/src/test/java/org/testcontainers/mysql/MySQLContainerTest.java b/modules/mysql/src/test/java/org/testcontainers/mysql/MySQLContainerTest.java index 16d147a2d9b..e181726f392 100644 --- a/modules/mysql/src/test/java/org/testcontainers/mysql/MySQLContainerTest.java +++ b/modules/mysql/src/test/java/org/testcontainers/mysql/MySQLContainerTest.java @@ -42,18 +42,8 @@ void testSimple() throws SQLException { ) { mysql.start(); - performQuery( - mysql, - "SELECT 1", - resultSet -> { - Assertions - .assertThatNoException() - .isThrownBy(() -> { - int resultSetInt = resultSet.getInt(1); - assertThat(resultSetInt).as("A basic SELECT query succeeds").isEqualTo(1); - }); - } - ); + performSelectOneQuery(mysql); + assertHasCorrectExposedAndLivenessCheckPorts(mysql); } } @@ -174,18 +164,7 @@ void testEmptyPasswordWithRootUser() throws SQLException { ) { mysql.start(); - performQuery( - mysql, - "SELECT 1", - resultSet -> { - Assertions - .assertThatNoException() - .isThrownBy(() -> { - int resultSetInt = resultSet.getInt(1); - assertThat(resultSetInt).as("A basic SELECT query succeeds").isEqualTo(1); - }); - } - ); + performSelectOneQuery(mysql); } } @@ -308,18 +287,7 @@ void testCustom() throws SQLException { ) { mysql.start(); - performQuery( - mysql, - "SELECT 1", - resultSet -> { - Assertions - .assertThatNoException() - .isThrownBy(() -> { - int resultSetInt = resultSet.getInt(1); - assertThat(resultSetInt).as("A basic SELECT query succeeds").isEqualTo(1); - }); - } - ); + performSelectOneQuery(mysql); } } diff --git a/modules/oceanbase/src/test/java/org/testcontainers/oceanbase/SimpleOceanBaseCETest.java b/modules/oceanbase/src/test/java/org/testcontainers/oceanbase/SimpleOceanBaseCETest.java index 499af74c196..ee6e5cbdfd3 100644 --- a/modules/oceanbase/src/test/java/org/testcontainers/oceanbase/SimpleOceanBaseCETest.java +++ b/modules/oceanbase/src/test/java/org/testcontainers/oceanbase/SimpleOceanBaseCETest.java @@ -22,18 +22,8 @@ void testSimple() throws SQLException { ) { oceanbase.start(); - performQuery( - oceanbase, - "SELECT 1", - resultSet -> { - Assertions - .assertThatNoException() - .isThrownBy(() -> { - int resultSetInt = resultSet.getInt(1); - assertThat(resultSetInt).as("A basic SELECT query succeeds").isEqualTo(1); - }); - } - ); + performSelectOneQuery(oceanbase); + assertHasCorrectExposedAndLivenessCheckPorts(oceanbase); } } diff --git a/modules/postgresql/src/test/java/org/testcontainers/containers/TimescaleDBContainerTest.java b/modules/postgresql/src/test/java/org/testcontainers/containers/TimescaleDBContainerTest.java index beb8c496106..d14dacd19ef 100644 --- a/modules/postgresql/src/test/java/org/testcontainers/containers/TimescaleDBContainerTest.java +++ b/modules/postgresql/src/test/java/org/testcontainers/containers/TimescaleDBContainerTest.java @@ -15,6 +15,8 @@ void testSimple() throws SQLException { try (JdbcDatabaseContainer postgres = new TimescaleDBContainerProvider().newInstance()) { postgres.start(); + performSelectOneQuery(postgres); + performQuery( postgres, "SELECT 1", diff --git a/modules/postgresql/src/test/java/org/testcontainers/postgresql/CompatibleImageTest.java b/modules/postgresql/src/test/java/org/testcontainers/postgresql/CompatibleImageTest.java index 74c96bb8b71..a42cba21a38 100644 --- a/modules/postgresql/src/test/java/org/testcontainers/postgresql/CompatibleImageTest.java +++ b/modules/postgresql/src/test/java/org/testcontainers/postgresql/CompatibleImageTest.java @@ -1,14 +1,11 @@ package org.testcontainers.postgresql; -import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; import org.testcontainers.db.AbstractContainerDatabaseTest; import org.testcontainers.utility.DockerImageName; import java.sql.SQLException; -import static org.assertj.core.api.Assertions.assertThat; - class CompatibleImageTest extends AbstractContainerDatabaseTest { @Test @@ -20,18 +17,7 @@ void pgvector() throws SQLException { ) { pgvector.start(); - performQuery( - pgvector, - "SELECT 1", - resultSet -> { - Assertions - .assertThatNoException() - .isThrownBy(() -> { - int resultSetInt = resultSet.getInt(1); - assertThat(resultSetInt).as("A basic SELECT query succeeds").isEqualTo(1); - }); - } - ); + performSelectOneQuery(pgvector); } } @@ -46,18 +32,7 @@ void postgis() throws SQLException { ) { postgis.start(); - performQuery( - postgis, - "SELECT 1", - resultSet -> { - Assertions - .assertThatNoException() - .isThrownBy(() -> { - int resultSetInt = resultSet.getInt(1); - assertThat(resultSetInt).as("A basic SELECT query succeeds").isEqualTo(1); - }); - } - ); + performSelectOneQuery(postgis); } } @@ -72,18 +47,7 @@ void timescaledb() throws SQLException { ) { timescaledb.start(); - performQuery( - timescaledb, - "SELECT 1", - resultSet -> { - Assertions - .assertThatNoException() - .isThrownBy(() -> { - int resultSetInt = resultSet.getInt(1); - assertThat(resultSetInt).as("A basic SELECT query succeeds").isEqualTo(1); - }); - } - ); + performSelectOneQuery(timescaledb); } } } diff --git a/modules/postgresql/src/test/java/org/testcontainers/postgresql/PostgreSQLContainerTest.java b/modules/postgresql/src/test/java/org/testcontainers/postgresql/PostgreSQLContainerTest.java index 0e54814e462..602b477a780 100644 --- a/modules/postgresql/src/test/java/org/testcontainers/postgresql/PostgreSQLContainerTest.java +++ b/modules/postgresql/src/test/java/org/testcontainers/postgresql/PostgreSQLContainerTest.java @@ -26,18 +26,8 @@ void testSimple() throws SQLException { ) { postgres.start(); - performQuery( - postgres, - "SELECT 1", - resultSet -> { - Assertions - .assertThatNoException() - .isThrownBy(() -> { - int resultSetInt = resultSet.getInt(1); - assertThat(resultSetInt).as("A basic SELECT query succeeds").isEqualTo(1); - }); - } - ); + performSelectOneQuery(postgres); + assertHasCorrectExposedAndLivenessCheckPorts(postgres); } } diff --git a/modules/questdb/src/test/java/org/testcontainers/junit/questdb/SimpleQuestDBTest.java b/modules/questdb/src/test/java/org/testcontainers/junit/questdb/SimpleQuestDBTest.java index a4dff68d6ec..2b408a5303b 100644 --- a/modules/questdb/src/test/java/org/testcontainers/junit/questdb/SimpleQuestDBTest.java +++ b/modules/questdb/src/test/java/org/testcontainers/junit/questdb/SimpleQuestDBTest.java @@ -6,7 +6,6 @@ import org.apache.http.impl.client.CloseableHttpClient; import org.apache.http.impl.client.HttpClientBuilder; import org.apache.http.util.EntityUtils; -import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; import org.testcontainers.QuestDBTestImages; import org.testcontainers.containers.QuestDBContainer; @@ -32,18 +31,7 @@ void testSimple() throws SQLException { ) { questDB.start(); - performQuery( - questDB, - questDB.getTestQueryString(), - resultSet -> { - Assertions - .assertThatNoException() - .isThrownBy(() -> { - int resultSetInt = resultSet.getInt(1); - assertThat(resultSetInt).as("A basic SELECT query succeeds").isEqualTo(1); - }); - } - ); + performSelectOneQuery(questDB); } } diff --git a/modules/tidb/src/test/java/org/testcontainers/tidb/TiDBContainerTest.java b/modules/tidb/src/test/java/org/testcontainers/tidb/TiDBContainerTest.java index 5897a624582..806b3d9d7c2 100644 --- a/modules/tidb/src/test/java/org/testcontainers/tidb/TiDBContainerTest.java +++ b/modules/tidb/src/test/java/org/testcontainers/tidb/TiDBContainerTest.java @@ -19,18 +19,8 @@ void testSimple() throws SQLException { ) { tidb.start(); - performQuery( - tidb, - "SELECT 1", - resultSet -> { - Assertions - .assertThatNoException() - .isThrownBy(() -> { - int resultSetInt = resultSet.getInt(1); - assertThat(resultSetInt).isEqualTo(1); - }); - } - ); + performSelectOneQuery(tidb); + assertHasCorrectExposedAndLivenessCheckPorts(tidb); } } diff --git a/modules/timeplus/src/test/java/org/testcontainers/timeplus/TimeplusContainerTest.java b/modules/timeplus/src/test/java/org/testcontainers/timeplus/TimeplusContainerTest.java index b95f1839cd5..8c088626b71 100644 --- a/modules/timeplus/src/test/java/org/testcontainers/timeplus/TimeplusContainerTest.java +++ b/modules/timeplus/src/test/java/org/testcontainers/timeplus/TimeplusContainerTest.java @@ -19,18 +19,7 @@ void testSimple() throws SQLException { ) { timeplus.start(); - performQuery( - timeplus, - "SELECT 1", - resultSet -> { - Assertions - .assertThatNoException() - .isThrownBy(() -> { - int resultSetInt = resultSet.getInt(1); - assertThat(resultSetInt).isEqualTo(1); - }); - } - ); + performSelectOneQuery(timeplus); } } diff --git a/modules/yugabytedb/src/test/java/org/testcontainers/junit/yugabytedb/YugabyteDBYSQLTest.java b/modules/yugabytedb/src/test/java/org/testcontainers/junit/yugabytedb/YugabyteDBYSQLTest.java index ea0e689f362..dae1f0a6b2d 100644 --- a/modules/yugabytedb/src/test/java/org/testcontainers/junit/yugabytedb/YugabyteDBYSQLTest.java +++ b/modules/yugabytedb/src/test/java/org/testcontainers/junit/yugabytedb/YugabyteDBYSQLTest.java @@ -29,17 +29,8 @@ void testSmoke() throws SQLException { // } ) { ysqlContainer.start(); - performQuery( - ysqlContainer, - "SELECT 1", - resultSet -> { - Assertions - .assertThatNoException() - .isThrownBy(() -> { - assertThat(resultSet.getInt(1)).as("A sample test query succeeds").isEqualTo(1); - }); - } - ); + + performSelectOneQuery(ysqlContainer); } } @@ -51,19 +42,8 @@ void testCustomDatabase() throws SQLException { .withDatabaseName(key) ) { ysqlContainer.start(); - performQuery( - ysqlContainer, - "SELECT 1", - resultSet -> { - Assertions - .assertThatNoException() - .isThrownBy(() -> { - assertThat(resultSet.getInt(1)) - .as("A test query on a custom database succeeds") - .isEqualTo(1); - }); - } - ); + + performSelectOneQuery(ysqlContainer); } } @@ -135,17 +115,9 @@ void testWithCustomRole() throws SQLException { void testWaitStrategy() throws SQLException { try (final YugabyteDBYSQLContainer ysqlContainer = new YugabyteDBYSQLContainer(YBDB_TEST_IMAGE)) { ysqlContainer.start(); - performQuery( - ysqlContainer, - "SELECT 1", - resultSet -> { - Assertions - .assertThatNoException() - .isThrownBy(() -> { - assertThat(resultSet.getInt(1)).as("A sample test query succeeds").isEqualTo(1); - }); - } - ); + + performSelectOneQuery(ysqlContainer); + performQuery( ysqlContainer, "SELECT EXISTS (SELECT FROM pg_tables WHERE tablename = 'YB_SAMPLE')", From 45552380a79e717f6a3d31749503851a37136afe Mon Sep 17 00:00:00 2001 From: "raju.gupta" Date: Sun, 12 Oct 2025 17:37:13 +0100 Subject: [PATCH 3/9] Refactor query execution to use performSelectFooBarQuery method for consistency --- .../cockroachdb/CockroachContainerTest.java | 31 ++----------------- .../junit/cratedb/SimpleCrateDBTest.java | 15 +-------- .../db/AbstractContainerDatabaseTest.java | 18 +++++++++++ .../mysql/MySQLContainerTest.java | 15 +-------- .../oceanbase/SimpleOceanBaseCETest.java | 16 +--------- .../containers/TimescaleDBContainerTest.java | 28 +---------------- .../postgresql/PostgreSQLContainerTest.java | 15 +-------- .../tidb/TiDBContainerTest.java | 14 +-------- .../junit/yugabytedb/YugabyteDBYSQLTest.java | 15 ++------- 9 files changed, 28 insertions(+), 139 deletions(-) diff --git a/modules/cockroachdb/src/test/java/org/testcontainers/cockroachdb/CockroachContainerTest.java b/modules/cockroachdb/src/test/java/org/testcontainers/cockroachdb/CockroachContainerTest.java index 4136c8eed3f..d7c284d7896 100644 --- a/modules/cockroachdb/src/test/java/org/testcontainers/cockroachdb/CockroachContainerTest.java +++ b/modules/cockroachdb/src/test/java/org/testcontainers/cockroachdb/CockroachContainerTest.java @@ -1,6 +1,5 @@ package org.testcontainers.cockroachdb; -import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; import org.testcontainers.CockroachDBTestImages; import org.testcontainers.db.AbstractContainerDatabaseTest; @@ -38,20 +37,7 @@ void testExplicitInitScript() throws SQLException { ) { // CockroachDB is expected to be compatible with Postgres cockroach.start(); - performQuery( - cockroach, - "SELECT foo FROM bar", - resultSet -> { - Assertions - .assertThatNoException() - .isThrownBy(() -> { - String firstColumnValue = resultSet.getString(1); - assertThat(firstColumnValue) - .as("Value from init script should equal real value") - .isEqualTo("hello world"); - }); - } - ); + performSelectFooBarQuery(cockroach); } } @@ -126,20 +112,7 @@ void testInitializationScript() throws SQLException { ) { // CockroachDB is expected to be compatible with Postgres cockroach.start(); - performQuery( - cockroach, - "SELECT foo FROM bar", - resultSet -> { - Assertions - .assertThatNoException() - .isThrownBy(() -> { - String firstColumnValue = resultSet.getString(1); - assertThat(firstColumnValue) - .as("Value from init script should equal real value") - .isEqualTo("hello world"); - }); - } - ); + performSelectFooBarQuery(cockroach); } } } diff --git a/modules/cratedb/src/test/java/org/testcontainers/junit/cratedb/SimpleCrateDBTest.java b/modules/cratedb/src/test/java/org/testcontainers/junit/cratedb/SimpleCrateDBTest.java index fbc5b78b67d..8932027afa1 100644 --- a/modules/cratedb/src/test/java/org/testcontainers/junit/cratedb/SimpleCrateDBTest.java +++ b/modules/cratedb/src/test/java/org/testcontainers/junit/cratedb/SimpleCrateDBTest.java @@ -62,20 +62,7 @@ void testExplicitInitScript() throws SQLException { ) { cratedb.start(); - performQuery( - cratedb, - "SELECT foo FROM bar", - resultSet -> { - Assertions - .assertThatNoException() - .isThrownBy(() -> { - String firstColumnValue = resultSet.getString(1); - assertThat(firstColumnValue) - .as("Value from init script should equal real value") - .isEqualTo("hello world"); - }); - } - ); + performSelectFooBarQuery(cratedb); } } diff --git a/modules/jdbc-test/src/main/java/org/testcontainers/db/AbstractContainerDatabaseTest.java b/modules/jdbc-test/src/main/java/org/testcontainers/db/AbstractContainerDatabaseTest.java index 3b0c4715225..c47d90bf802 100644 --- a/modules/jdbc-test/src/main/java/org/testcontainers/db/AbstractContainerDatabaseTest.java +++ b/modules/jdbc-test/src/main/java/org/testcontainers/db/AbstractContainerDatabaseTest.java @@ -47,6 +47,24 @@ protected void performSelectOneQuery(final JdbcDatabaseContainer container) t ); } + protected void performSelectFooBarQuery(final JdbcDatabaseContainer container) throws SQLException { + performQuery( + container, + "SELECT foo FROM bar", + resultSet -> { + Assertions + .assertThatNoException() + .isThrownBy(() -> { + String firstColumnValue = resultSet.getString(1); + Assertions + .assertThat(firstColumnValue) + .as("Value from init script should equal real value") + .isEqualTo("hello world"); + }); + } + ); + } + protected DataSource getDataSource(final JdbcDatabaseContainer container) { HikariConfig hikariConfig = new HikariConfig(); hikariConfig.setJdbcUrl(container.getJdbcUrl()); diff --git a/modules/mysql/src/test/java/org/testcontainers/mysql/MySQLContainerTest.java b/modules/mysql/src/test/java/org/testcontainers/mysql/MySQLContainerTest.java index e181726f392..ed60b16eecf 100644 --- a/modules/mysql/src/test/java/org/testcontainers/mysql/MySQLContainerTest.java +++ b/modules/mysql/src/test/java/org/testcontainers/mysql/MySQLContainerTest.java @@ -120,20 +120,7 @@ void testExplicitInitScript() throws SQLException { ) { container.start(); - performQuery( - container, - "SELECT foo FROM bar", - resultSet -> { - Assertions - .assertThatNoException() - .isThrownBy(() -> { - String firstColumnValue = resultSet.getString(1); - assertThat(firstColumnValue) - .as("Value from init script should equal real value") - .isEqualTo("hello world"); - }); - } - ); + performSelectFooBarQuery(container); } } diff --git a/modules/oceanbase/src/test/java/org/testcontainers/oceanbase/SimpleOceanBaseCETest.java b/modules/oceanbase/src/test/java/org/testcontainers/oceanbase/SimpleOceanBaseCETest.java index ee6e5cbdfd3..5834ea9cc37 100644 --- a/modules/oceanbase/src/test/java/org/testcontainers/oceanbase/SimpleOceanBaseCETest.java +++ b/modules/oceanbase/src/test/java/org/testcontainers/oceanbase/SimpleOceanBaseCETest.java @@ -1,6 +1,5 @@ package org.testcontainers.oceanbase; -import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; import org.testcontainers.db.AbstractContainerDatabaseTest; @@ -33,20 +32,7 @@ void testExplicitInitScript() throws SQLException { try (OceanBaseCEContainer oceanbase = new OceanBaseCEContainer(IMAGE).withInitScript("init.sql")) { oceanbase.start(); - performQuery( - oceanbase, - "SELECT foo FROM bar", - resultSet -> { - Assertions - .assertThatNoException() - .isThrownBy(() -> { - String firstColumnValue = resultSet.getString(1); - assertThat(firstColumnValue) - .as("Value from init script should equal real value") - .isEqualTo("hello world"); - }); - } - ); + performSelectFooBarQuery(oceanbase); } } diff --git a/modules/postgresql/src/test/java/org/testcontainers/containers/TimescaleDBContainerTest.java b/modules/postgresql/src/test/java/org/testcontainers/containers/TimescaleDBContainerTest.java index d14dacd19ef..8cec48d0186 100644 --- a/modules/postgresql/src/test/java/org/testcontainers/containers/TimescaleDBContainerTest.java +++ b/modules/postgresql/src/test/java/org/testcontainers/containers/TimescaleDBContainerTest.java @@ -16,19 +16,6 @@ void testSimple() throws SQLException { postgres.start(); performSelectOneQuery(postgres); - - performQuery( - postgres, - "SELECT 1", - resultSet -> { - Assertions - .assertThatNoException() - .isThrownBy(() -> { - int resultSetInt = resultSet.getInt(1); - assertThat(resultSetInt).as("A basic SELECT query succeeds").isEqualTo(1); - }); - } - ); } } @@ -90,20 +77,7 @@ void testExplicitInitScript() throws SQLException { ) { postgres.start(); - performQuery( - postgres, - "SELECT foo FROM bar", - resultSet -> { - Assertions - .assertThatNoException() - .isThrownBy(() -> { - String firstColumnValue = resultSet.getString(1); - assertThat(firstColumnValue) - .as("Value from init script should equal real value") - .isEqualTo("hello world"); - }); - } - ); + performSelectFooBarQuery(postgres); } } } diff --git a/modules/postgresql/src/test/java/org/testcontainers/postgresql/PostgreSQLContainerTest.java b/modules/postgresql/src/test/java/org/testcontainers/postgresql/PostgreSQLContainerTest.java index 602b477a780..edf4316b6de 100644 --- a/modules/postgresql/src/test/java/org/testcontainers/postgresql/PostgreSQLContainerTest.java +++ b/modules/postgresql/src/test/java/org/testcontainers/postgresql/PostgreSQLContainerTest.java @@ -97,20 +97,7 @@ void testExplicitInitScript() throws SQLException { ) { postgres.start(); - performQuery( - postgres, - "SELECT foo FROM bar", - resultSet -> { - Assertions - .assertThatNoException() - .isThrownBy(() -> { - String firstColumnValue = resultSet.getString(1); - assertThat(firstColumnValue) - .as("Value from init script should equal real value") - .isEqualTo("hello world"); - }); - } - ); + performSelectFooBarQuery(postgres); } } diff --git a/modules/tidb/src/test/java/org/testcontainers/tidb/TiDBContainerTest.java b/modules/tidb/src/test/java/org/testcontainers/tidb/TiDBContainerTest.java index 806b3d9d7c2..74b9836b1f4 100644 --- a/modules/tidb/src/test/java/org/testcontainers/tidb/TiDBContainerTest.java +++ b/modules/tidb/src/test/java/org/testcontainers/tidb/TiDBContainerTest.java @@ -1,6 +1,5 @@ package org.testcontainers.tidb; -import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; import org.testcontainers.TiDBTestImages; import org.testcontainers.db.AbstractContainerDatabaseTest; @@ -32,18 +31,7 @@ void testExplicitInitScript() throws SQLException { ) { // TiDB is expected to be compatible with MySQL tidb.start(); - performQuery( - tidb, - "SELECT foo FROM bar", - resultSet -> { - Assertions - .assertThatNoException() - .isThrownBy(() -> { - String firstColumnValue = resultSet.getString(1); - assertThat(firstColumnValue).isEqualTo("hello world"); - }); - } - ); + performSelectFooBarQuery(tidb); } } diff --git a/modules/yugabytedb/src/test/java/org/testcontainers/junit/yugabytedb/YugabyteDBYSQLTest.java b/modules/yugabytedb/src/test/java/org/testcontainers/junit/yugabytedb/YugabyteDBYSQLTest.java index dae1f0a6b2d..844bf85eea0 100644 --- a/modules/yugabytedb/src/test/java/org/testcontainers/junit/yugabytedb/YugabyteDBYSQLTest.java +++ b/modules/yugabytedb/src/test/java/org/testcontainers/junit/yugabytedb/YugabyteDBYSQLTest.java @@ -95,19 +95,8 @@ void testWithCustomRole() throws SQLException { .withUsername("yugabyte") ) { ysqlContainer.start(); - performQuery( - ysqlContainer, - "SELECT 1", - resultSet -> { - Assertions - .assertThatNoException() - .isThrownBy(() -> { - assertThat(resultSet.getInt(1)) - .as("A sample test query with a custom role succeeds") - .isEqualTo(1); - }); - } - ); + + performSelectOneQuery(ysqlContainer); } } From 8a1316297d24e6ca36f752ee80a6e6ed41b4397f Mon Sep 17 00:00:00 2001 From: "raju.gupta" Date: Sun, 12 Oct 2025 17:46:22 +0100 Subject: [PATCH 4/9] Refactor query execution to use performSelectMaxConnectionsQuery method for consistency --- .../db/AbstractContainerDatabaseTest.java | 15 ++++++++++ .../containers/TimescaleDBContainerTest.java | 29 ++----------------- .../postgresql/PostgreSQLContainerTest.java | 26 ++--------------- 3 files changed, 19 insertions(+), 51 deletions(-) diff --git a/modules/jdbc-test/src/main/java/org/testcontainers/db/AbstractContainerDatabaseTest.java b/modules/jdbc-test/src/main/java/org/testcontainers/db/AbstractContainerDatabaseTest.java index c47d90bf802..0dc8a9092f9 100644 --- a/modules/jdbc-test/src/main/java/org/testcontainers/db/AbstractContainerDatabaseTest.java +++ b/modules/jdbc-test/src/main/java/org/testcontainers/db/AbstractContainerDatabaseTest.java @@ -65,6 +65,21 @@ protected void performSelectFooBarQuery(final JdbcDatabaseContainer container ); } + protected void performSelectMaxConnectionsQuery(final JdbcDatabaseContainer container) throws SQLException { + performQuery( + container, + "SELECT current_setting('max_connections')", + resultSet -> { + Assertions + .assertThatNoException() + .isThrownBy(() -> { + String result = resultSet.getString(1); + Assertions.assertThat(result).as("max_connections should be overridden").isEqualTo("42"); + }); + } + ); + } + protected DataSource getDataSource(final JdbcDatabaseContainer container) { HikariConfig hikariConfig = new HikariConfig(); hikariConfig.setJdbcUrl(container.getJdbcUrl()); diff --git a/modules/postgresql/src/test/java/org/testcontainers/containers/TimescaleDBContainerTest.java b/modules/postgresql/src/test/java/org/testcontainers/containers/TimescaleDBContainerTest.java index 8cec48d0186..4f43902db27 100644 --- a/modules/postgresql/src/test/java/org/testcontainers/containers/TimescaleDBContainerTest.java +++ b/modules/postgresql/src/test/java/org/testcontainers/containers/TimescaleDBContainerTest.java @@ -1,13 +1,10 @@ package org.testcontainers.containers; -import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; import org.testcontainers.db.AbstractContainerDatabaseTest; import java.sql.SQLException; -import static org.assertj.core.api.Assertions.assertThat; - class TimescaleDBContainerTest extends AbstractContainerDatabaseTest { @Test @@ -28,18 +25,7 @@ void testCommandOverride() throws SQLException { ) { postgres.start(); - performQuery( - (JdbcDatabaseContainer) postgres, - "SELECT current_setting('max_connections')", - resultSet -> { - Assertions - .assertThatNoException() - .isThrownBy(() -> { - String result = resultSet.getString(1); - assertThat(result).as("max_connections should be overridden").isEqualTo("42"); - }); - } - ); + performSelectMaxConnectionsQuery((JdbcDatabaseContainer) postgres); } } @@ -53,18 +39,7 @@ void testUnsetCommand() throws SQLException { ) { postgres.start(); - performQuery( - (JdbcDatabaseContainer) postgres, - "SELECT current_setting('max_connections')", - resultSet -> { - Assertions - .assertThatNoException() - .isThrownBy(() -> { - String result = resultSet.getString(1); - assertThat(result).as("max_connections should not be overridden").isNotEqualTo("42"); - }); - } - ); + performSelectMaxConnectionsQuery((JdbcDatabaseContainer) postgres); } } diff --git a/modules/postgresql/src/test/java/org/testcontainers/postgresql/PostgreSQLContainerTest.java b/modules/postgresql/src/test/java/org/testcontainers/postgresql/PostgreSQLContainerTest.java index edf4316b6de..1908c6913c9 100644 --- a/modules/postgresql/src/test/java/org/testcontainers/postgresql/PostgreSQLContainerTest.java +++ b/modules/postgresql/src/test/java/org/testcontainers/postgresql/PostgreSQLContainerTest.java @@ -40,18 +40,7 @@ void testCommandOverride() throws SQLException { ) { postgres.start(); - performQuery( - postgres, - "SELECT current_setting('max_connections')", - resultSet -> { - Assertions - .assertThatNoException() - .isThrownBy(() -> { - String result = resultSet.getString(1); - assertThat(result).as("max_connections should be overridden").isEqualTo("42"); - }); - } - ); + performSelectMaxConnectionsQuery(postgres); } } @@ -64,18 +53,7 @@ void testUnsetCommand() throws SQLException { ) { postgres.start(); - performQuery( - postgres, - "SELECT current_setting('max_connections')", - resultSet -> { - Assertions - .assertThatNoException() - .isThrownBy(() -> { - String result = resultSet.getString(1); - assertThat(result).as("max_connections should not be overridden").isNotEqualTo("42"); - }); - } - ); + performSelectMaxConnectionsQuery(postgres); } } From e94be983c46a9cb613da8a318103e3f6fc33b88a Mon Sep 17 00:00:00 2001 From: "raju.gupta" Date: Sun, 12 Oct 2025 17:50:32 +0100 Subject: [PATCH 5/9] Refactor query execution to use performSelectVersionQuery method for consistency --- .../db/AbstractContainerDatabaseTest.java | 18 ++++++++++++++++++ .../mariadb/MariaDBContainerTest.java | 15 +-------------- .../mysql/MultiVersionMySQLTest.java | 18 +----------------- .../mysql/MySQLContainerTest.java | 15 +-------------- 4 files changed, 21 insertions(+), 45 deletions(-) diff --git a/modules/jdbc-test/src/main/java/org/testcontainers/db/AbstractContainerDatabaseTest.java b/modules/jdbc-test/src/main/java/org/testcontainers/db/AbstractContainerDatabaseTest.java index 0dc8a9092f9..94bff78da69 100644 --- a/modules/jdbc-test/src/main/java/org/testcontainers/db/AbstractContainerDatabaseTest.java +++ b/modules/jdbc-test/src/main/java/org/testcontainers/db/AbstractContainerDatabaseTest.java @@ -80,6 +80,24 @@ protected void performSelectMaxConnectionsQuery(final JdbcDatabaseContainer c ); } + protected void performSelectVersionQuery(final JdbcDatabaseContainer container) throws SQLException { + performQuery( + container, + "SELECT VERSION()", + resultSet -> { + Assertions + .assertThatNoException() + .isThrownBy(() -> { + String resultSetString = resultSet.getString(1); + Assertions + .assertThat(resultSetString) + .as("The database version can be set using a container rule parameter") + .startsWith("10.3.39"); + }); + } + ); + } + protected DataSource getDataSource(final JdbcDatabaseContainer container) { HikariConfig hikariConfig = new HikariConfig(); hikariConfig.setJdbcUrl(container.getJdbcUrl()); diff --git a/modules/mariadb/src/test/java/org/testcontainers/mariadb/MariaDBContainerTest.java b/modules/mariadb/src/test/java/org/testcontainers/mariadb/MariaDBContainerTest.java index f4b95c54a4a..c5bd169ba80 100644 --- a/modules/mariadb/src/test/java/org/testcontainers/mariadb/MariaDBContainerTest.java +++ b/modules/mariadb/src/test/java/org/testcontainers/mariadb/MariaDBContainerTest.java @@ -42,20 +42,7 @@ void testSpecificVersion() throws SQLException { ) { mariadbOldVersion.start(); - performQuery( - mariadbOldVersion, - "SELECT VERSION()", - resultSet -> { - Assertions - .assertThatNoException() - .isThrownBy(() -> { - String resultSetString = resultSet.getString(1); - assertThat(resultSetString) - .as("The database version can be set using a container rule parameter") - .startsWith("10.3.39"); - }); - } - ); + performSelectOneQuery(mariadbOldVersion); } } diff --git a/modules/mysql/src/test/java/org/testcontainers/mysql/MultiVersionMySQLTest.java b/modules/mysql/src/test/java/org/testcontainers/mysql/MultiVersionMySQLTest.java index 4e260a05412..f7b4fe701dd 100644 --- a/modules/mysql/src/test/java/org/testcontainers/mysql/MultiVersionMySQLTest.java +++ b/modules/mysql/src/test/java/org/testcontainers/mysql/MultiVersionMySQLTest.java @@ -1,6 +1,5 @@ package org.testcontainers.mysql; -import org.assertj.core.api.Assertions; import org.junit.jupiter.params.ParameterizedTest; import org.junit.jupiter.params.provider.MethodSource; import org.testcontainers.MySQLTestImages; @@ -9,8 +8,6 @@ import java.sql.SQLException; -import static org.assertj.core.api.Assertions.assertThat; - class MultiVersionMySQLTest extends AbstractContainerDatabaseTest { public static DockerImageName[] params() { @@ -27,20 +24,7 @@ public static DockerImageName[] params() { void versionCheckTest(DockerImageName dockerImageName) throws SQLException { try (MySQLContainer mysql = new MySQLContainer(dockerImageName)) { mysql.start(); - performQuery( - mysql, - "SELECT VERSION()", - resultSet -> { - Assertions - .assertThatNoException() - .isThrownBy(() -> { - final String resultSetString = resultSet.getString(1); - assertThat(resultSetString) - .as("The database version can be set using a container rule parameter") - .isEqualTo(dockerImageName.getVersionPart()); - }); - } - ); + performSelectVersionQuery(mysql); } } } diff --git a/modules/mysql/src/test/java/org/testcontainers/mysql/MySQLContainerTest.java b/modules/mysql/src/test/java/org/testcontainers/mysql/MySQLContainerTest.java index ed60b16eecf..e05669ec54c 100644 --- a/modules/mysql/src/test/java/org/testcontainers/mysql/MySQLContainerTest.java +++ b/modules/mysql/src/test/java/org/testcontainers/mysql/MySQLContainerTest.java @@ -57,20 +57,7 @@ void testSpecificVersion() throws SQLException { ) { mysqlOldVersion.start(); - performQuery( - mysqlOldVersion, - "SELECT VERSION()", - resultSet -> { - Assertions - .assertThatNoException() - .isThrownBy(() -> { - String resultSetString = resultSet.getString(1); - assertThat(resultSetString) - .as("The database version can be set using a container rule parameter") - .startsWith("8.0"); - }); - } - ); + performSelectVersionQuery(mysqlOldVersion); } } From 26810068ad95cf4a3fc03cafc66a79c81fcb3a4a Mon Sep 17 00:00:00 2001 From: "raju.gupta" Date: Sun, 12 Oct 2025 18:52:54 +0100 Subject: [PATCH 6/9] Refactor performSelectMaxConnectionsQuery and performSelectVersionQuery to accept expected values for assertions --- .../db/AbstractContainerDatabaseTest.java | 15 +++++++++++---- .../mysql/MultiVersionMySQLTest.java | 2 +- .../testcontainers/mysql/MySQLContainerTest.java | 2 +- .../containers/TimescaleDBContainerTest.java | 4 ++-- .../postgresql/PostgreSQLContainerTest.java | 6 ++++-- 5 files changed, 19 insertions(+), 10 deletions(-) diff --git a/modules/jdbc-test/src/main/java/org/testcontainers/db/AbstractContainerDatabaseTest.java b/modules/jdbc-test/src/main/java/org/testcontainers/db/AbstractContainerDatabaseTest.java index 94bff78da69..8a89437a5a9 100644 --- a/modules/jdbc-test/src/main/java/org/testcontainers/db/AbstractContainerDatabaseTest.java +++ b/modules/jdbc-test/src/main/java/org/testcontainers/db/AbstractContainerDatabaseTest.java @@ -65,7 +65,10 @@ protected void performSelectFooBarQuery(final JdbcDatabaseContainer container ); } - protected void performSelectMaxConnectionsQuery(final JdbcDatabaseContainer container) throws SQLException { + protected void performSelectMaxConnectionsQuery( + final JdbcDatabaseContainer container, + final String expectedMaxConnections + ) throws SQLException { performQuery( container, "SELECT current_setting('max_connections')", @@ -74,13 +77,17 @@ protected void performSelectMaxConnectionsQuery(final JdbcDatabaseContainer c .assertThatNoException() .isThrownBy(() -> { String result = resultSet.getString(1); - Assertions.assertThat(result).as("max_connections should be overridden").isEqualTo("42"); + Assertions + .assertThat(result) + .as("max_connections should be overridden") + .isEqualTo(expectedMaxConnections); }); } ); } - protected void performSelectVersionQuery(final JdbcDatabaseContainer container) throws SQLException { + protected void performSelectVersionQuery(final JdbcDatabaseContainer container, final String expectedVersion) + throws SQLException { performQuery( container, "SELECT VERSION()", @@ -92,7 +99,7 @@ protected void performSelectVersionQuery(final JdbcDatabaseContainer containe Assertions .assertThat(resultSetString) .as("The database version can be set using a container rule parameter") - .startsWith("10.3.39"); + .startsWith(expectedVersion); }); } ); diff --git a/modules/mysql/src/test/java/org/testcontainers/mysql/MultiVersionMySQLTest.java b/modules/mysql/src/test/java/org/testcontainers/mysql/MultiVersionMySQLTest.java index f7b4fe701dd..92345064b3f 100644 --- a/modules/mysql/src/test/java/org/testcontainers/mysql/MultiVersionMySQLTest.java +++ b/modules/mysql/src/test/java/org/testcontainers/mysql/MultiVersionMySQLTest.java @@ -24,7 +24,7 @@ public static DockerImageName[] params() { void versionCheckTest(DockerImageName dockerImageName) throws SQLException { try (MySQLContainer mysql = new MySQLContainer(dockerImageName)) { mysql.start(); - performSelectVersionQuery(mysql); + performSelectVersionQuery(mysql, dockerImageName.getVersionPart()); } } } diff --git a/modules/mysql/src/test/java/org/testcontainers/mysql/MySQLContainerTest.java b/modules/mysql/src/test/java/org/testcontainers/mysql/MySQLContainerTest.java index e05669ec54c..a201f733bb4 100644 --- a/modules/mysql/src/test/java/org/testcontainers/mysql/MySQLContainerTest.java +++ b/modules/mysql/src/test/java/org/testcontainers/mysql/MySQLContainerTest.java @@ -57,7 +57,7 @@ void testSpecificVersion() throws SQLException { ) { mysqlOldVersion.start(); - performSelectVersionQuery(mysqlOldVersion); + performSelectVersionQuery(mysqlOldVersion, "8.0.36"); } } diff --git a/modules/postgresql/src/test/java/org/testcontainers/containers/TimescaleDBContainerTest.java b/modules/postgresql/src/test/java/org/testcontainers/containers/TimescaleDBContainerTest.java index 4f43902db27..7c70bf3b9a7 100644 --- a/modules/postgresql/src/test/java/org/testcontainers/containers/TimescaleDBContainerTest.java +++ b/modules/postgresql/src/test/java/org/testcontainers/containers/TimescaleDBContainerTest.java @@ -25,7 +25,7 @@ void testCommandOverride() throws SQLException { ) { postgres.start(); - performSelectMaxConnectionsQuery((JdbcDatabaseContainer) postgres); + performSelectMaxConnectionsQuery((JdbcDatabaseContainer) postgres, "42"); } } @@ -39,7 +39,7 @@ void testUnsetCommand() throws SQLException { ) { postgres.start(); - performSelectMaxConnectionsQuery((JdbcDatabaseContainer) postgres); + performSelectMaxConnectionsQuery((JdbcDatabaseContainer) postgres, "100"); } } diff --git a/modules/postgresql/src/test/java/org/testcontainers/postgresql/PostgreSQLContainerTest.java b/modules/postgresql/src/test/java/org/testcontainers/postgresql/PostgreSQLContainerTest.java index 1908c6913c9..c6b92a0437b 100644 --- a/modules/postgresql/src/test/java/org/testcontainers/postgresql/PostgreSQLContainerTest.java +++ b/modules/postgresql/src/test/java/org/testcontainers/postgresql/PostgreSQLContainerTest.java @@ -40,7 +40,7 @@ void testCommandOverride() throws SQLException { ) { postgres.start(); - performSelectMaxConnectionsQuery(postgres); + performSelectMaxConnectionsQuery(postgres, "42"); } } @@ -53,7 +53,9 @@ void testUnsetCommand() throws SQLException { ) { postgres.start(); - performSelectMaxConnectionsQuery(postgres); + // After unsetting the command, max_connections should be the default value (100), not 42 + + performSelectMaxConnectionsQuery(postgres, "100"); } } From 6079f9d1bdc5d2ea3caf9c3e2dab12889e622861 Mon Sep 17 00:00:00 2001 From: "raju.gupta" Date: Mon, 13 Oct 2025 00:22:30 +0100 Subject: [PATCH 7/9] Refactor query execution methods to use executeSelectOneQuery and executeQuery for consistency --- .../clickhouse/ClickHouseContainerTest.java | 6 ++-- .../clickhouse/SimpleClickhouseTest.java | 2 +- .../cockroachdb/CockroachContainerTest.java | 4 +-- .../junit/cratedb/SimpleCrateDBTest.java | 4 +-- .../databend/DatabendContainerTest.java | 4 +-- .../testcontainers/db2/Db2ContainerTest.java | 29 +++---------------- .../db/AbstractContainerDatabaseTest.java | 19 +++++++----- .../mariadb/MariaDBContainerTest.java | 10 +++---- .../mssqlserver/MSSQLServerContainerTest.java | 4 +-- .../mysql/MySQLContainerTest.java | 10 +++---- .../oceanbase/SimpleOceanBaseCETest.java | 2 +- .../junit/oracle/SimpleOracleTest.java | 15 ++-------- .../junit/oracle/SimpleOracleTest.java | 15 ++-------- .../containers/TimescaleDBContainerTest.java | 2 +- .../postgresql/CompatibleImageTest.java | 6 ++-- .../postgresql/PostgreSQLContainerTest.java | 4 +-- .../junit/questdb/SimpleQuestDBTest.java | 2 +- .../tidb/TiDBContainerTest.java | 2 +- .../timeplus/TimeplusContainerTest.java | 4 +-- .../junit/yugabytedb/YugabyteDBYSQLTest.java | 12 ++++---- 20 files changed, 59 insertions(+), 97 deletions(-) diff --git a/modules/clickhouse/src/test/java/org/testcontainers/clickhouse/ClickHouseContainerTest.java b/modules/clickhouse/src/test/java/org/testcontainers/clickhouse/ClickHouseContainerTest.java index 7f08ae497a3..e4903e4fae7 100644 --- a/modules/clickhouse/src/test/java/org/testcontainers/clickhouse/ClickHouseContainerTest.java +++ b/modules/clickhouse/src/test/java/org/testcontainers/clickhouse/ClickHouseContainerTest.java @@ -26,7 +26,7 @@ void testSimple() throws SQLException { ) { clickhouse.start(); - performSelectOneQuery(clickhouse); + executeSelectOneQuery(clickhouse); } } @@ -42,7 +42,7 @@ void customCredentialsWithUrlParams() throws SQLException { ) { clickhouse.start(); - performQuery( + executeQuery( clickhouse, "SELECT value FROM system.settings where name='max_result_rows'", resultSet -> { @@ -62,7 +62,7 @@ void testNewAuth() throws SQLException { try (ClickHouseContainer clickhouse = new ClickHouseContainer(ClickhouseTestImages.CLICKHOUSE_24_12_IMAGE)) { clickhouse.start(); - performSelectOneQuery(clickhouse); + executeSelectOneQuery(clickhouse); } } diff --git a/modules/clickhouse/src/test/java/org/testcontainers/junit/clickhouse/SimpleClickhouseTest.java b/modules/clickhouse/src/test/java/org/testcontainers/junit/clickhouse/SimpleClickhouseTest.java index 2f42383d9a5..9cf20b8ade9 100644 --- a/modules/clickhouse/src/test/java/org/testcontainers/junit/clickhouse/SimpleClickhouseTest.java +++ b/modules/clickhouse/src/test/java/org/testcontainers/junit/clickhouse/SimpleClickhouseTest.java @@ -14,7 +14,7 @@ void testSimple() throws SQLException { try (ClickHouseContainer clickhouse = new ClickHouseContainer(ClickhouseTestImages.CLICKHOUSE_IMAGE)) { clickhouse.start(); - performSelectOneQuery(clickhouse); + executeSelectOneQuery(clickhouse); } } } diff --git a/modules/cockroachdb/src/test/java/org/testcontainers/cockroachdb/CockroachContainerTest.java b/modules/cockroachdb/src/test/java/org/testcontainers/cockroachdb/CockroachContainerTest.java index d7c284d7896..5cc0b75636d 100644 --- a/modules/cockroachdb/src/test/java/org/testcontainers/cockroachdb/CockroachContainerTest.java +++ b/modules/cockroachdb/src/test/java/org/testcontainers/cockroachdb/CockroachContainerTest.java @@ -25,7 +25,7 @@ void testSimple() throws SQLException { // } ) { cockroach.start(); - performSelectOneQuery(cockroach); + executeSelectOneQuery(cockroach); } } @@ -72,7 +72,7 @@ void testWithUsernamePasswordDatabase() throws SQLException { ) { cockroach.start(); - performSelectOneQuery(cockroach); + executeSelectOneQuery(cockroach); String jdbcUrl = cockroach.getJdbcUrl(); assertThat(jdbcUrl).contains("/" + "test_database"); diff --git a/modules/cratedb/src/test/java/org/testcontainers/junit/cratedb/SimpleCrateDBTest.java b/modules/cratedb/src/test/java/org/testcontainers/junit/cratedb/SimpleCrateDBTest.java index 8932027afa1..aaa52e6268c 100644 --- a/modules/cratedb/src/test/java/org/testcontainers/junit/cratedb/SimpleCrateDBTest.java +++ b/modules/cratedb/src/test/java/org/testcontainers/junit/cratedb/SimpleCrateDBTest.java @@ -26,7 +26,7 @@ void testSimple() throws SQLException { ) { cratedb.start(); - performSelectOneQuery(cratedb); + executeSelectOneQuery(cratedb); assertHasCorrectExposedAndLivenessCheckPorts(cratedb); } } @@ -39,7 +39,7 @@ void testCommandOverride() throws SQLException { ) { cratedb.start(); - performQuery( + executeQuery( cratedb, "select name from sys.cluster", resultSet -> { diff --git a/modules/databend/src/test/java/org/testcontainers/databend/DatabendContainerTest.java b/modules/databend/src/test/java/org/testcontainers/databend/DatabendContainerTest.java index 10befee7865..ee0761d3e92 100644 --- a/modules/databend/src/test/java/org/testcontainers/databend/DatabendContainerTest.java +++ b/modules/databend/src/test/java/org/testcontainers/databend/DatabendContainerTest.java @@ -15,7 +15,7 @@ void testSimple() throws SQLException { ) { databend.start(); - performSelectOneQuery(databend); + executeSelectOneQuery(databend); } } @@ -29,7 +29,7 @@ void customCredentialsWithUrlParams() throws SQLException { ) { databend.start(); - performSelectOneQuery(databend); + executeSelectOneQuery(databend); } } } diff --git a/modules/db2/src/test/java/org/testcontainers/db2/Db2ContainerTest.java b/modules/db2/src/test/java/org/testcontainers/db2/Db2ContainerTest.java index 3ed90b3fefd..67cfdb1956a 100644 --- a/modules/db2/src/test/java/org/testcontainers/db2/Db2ContainerTest.java +++ b/modules/db2/src/test/java/org/testcontainers/db2/Db2ContainerTest.java @@ -1,6 +1,5 @@ package org.testcontainers.db2; -import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; import org.testcontainers.Db2TestImages; import org.testcontainers.db.AbstractContainerDatabaseTest; @@ -19,18 +18,8 @@ void testSimple() throws SQLException { ) { db2.start(); - performQuery( - db2, - "SELECT 1 FROM SYSIBM.SYSDUMMY1", - resultSet -> { - Assertions - .assertThatNoException() - .isThrownBy(() -> { - int resultSetInt = resultSet.getInt(1); - assertThat(resultSetInt).as("A basic SELECT query succeeds").isEqualTo(1); - }); - } - ); + executeSelectOneQuery(db2, "SELECT 1 FROM SYSIBM.SYSDUMMY1"); + assertHasCorrectExposedAndLivenessCheckPorts(db2); } } @@ -40,18 +29,8 @@ void testSimpleWithNewImage() throws SQLException { try (Db2Container db2 = new Db2Container("icr.io/db2_community/db2:11.5.8.0").acceptLicense()) { db2.start(); - performQuery( - db2, - "SELECT 1 FROM SYSIBM.SYSDUMMY1", - resultSet -> { - Assertions - .assertThatNoException() - .isThrownBy(() -> { - int resultSetInt = resultSet.getInt(1); - assertThat(resultSetInt).as("A basic SELECT query succeeds").isEqualTo(1); - }); - } - ); + executeSelectOneQuery(db2, "SELECT 1 FROM SYSIBM.SYSDUMMY1"); + assertHasCorrectExposedAndLivenessCheckPorts(db2); } } diff --git a/modules/jdbc-test/src/main/java/org/testcontainers/db/AbstractContainerDatabaseTest.java b/modules/jdbc-test/src/main/java/org/testcontainers/db/AbstractContainerDatabaseTest.java index 8a89437a5a9..729779c8280 100644 --- a/modules/jdbc-test/src/main/java/org/testcontainers/db/AbstractContainerDatabaseTest.java +++ b/modules/jdbc-test/src/main/java/org/testcontainers/db/AbstractContainerDatabaseTest.java @@ -15,7 +15,7 @@ public abstract class AbstractContainerDatabaseTest { - protected void performQuery( + protected void executeQuery( final JdbcDatabaseContainer container, final String sql, final Consumer consumer @@ -32,10 +32,15 @@ protected void performQuery( } } - protected void performSelectOneQuery(final JdbcDatabaseContainer container) throws SQLException { - performQuery( + protected void executeSelectOneQuery(final JdbcDatabaseContainer container) throws SQLException { + executeSelectOneQuery(container, "SELECT 1"); + } + + protected void executeSelectOneQuery(final JdbcDatabaseContainer container, final String sql) + throws SQLException { + executeQuery( container, - "SELECT 1", + sql, resultSet -> { Assertions .assertThatNoException() @@ -48,7 +53,7 @@ protected void performSelectOneQuery(final JdbcDatabaseContainer container) t } protected void performSelectFooBarQuery(final JdbcDatabaseContainer container) throws SQLException { - performQuery( + executeQuery( container, "SELECT foo FROM bar", resultSet -> { @@ -69,7 +74,7 @@ protected void performSelectMaxConnectionsQuery( final JdbcDatabaseContainer container, final String expectedMaxConnections ) throws SQLException { - performQuery( + executeQuery( container, "SELECT current_setting('max_connections')", resultSet -> { @@ -88,7 +93,7 @@ protected void performSelectMaxConnectionsQuery( protected void performSelectVersionQuery(final JdbcDatabaseContainer container, final String expectedVersion) throws SQLException { - performQuery( + executeQuery( container, "SELECT VERSION()", resultSet -> { diff --git a/modules/mariadb/src/test/java/org/testcontainers/mariadb/MariaDBContainerTest.java b/modules/mariadb/src/test/java/org/testcontainers/mariadb/MariaDBContainerTest.java index c5bd169ba80..809f0594ef1 100644 --- a/modules/mariadb/src/test/java/org/testcontainers/mariadb/MariaDBContainerTest.java +++ b/modules/mariadb/src/test/java/org/testcontainers/mariadb/MariaDBContainerTest.java @@ -29,7 +29,7 @@ void testSimple() throws SQLException { ) { mariadb.start(); - performSelectOneQuery(mariadb); + executeSelectOneQuery(mariadb); } } @@ -42,7 +42,7 @@ void testSpecificVersion() throws SQLException { ) { mariadbOldVersion.start(); - performSelectOneQuery(mariadbOldVersion); + executeSelectOneQuery(mariadbOldVersion); } } @@ -69,7 +69,7 @@ void testMariaDBWithCommandOverride() throws SQLException { .withCommand("mysqld --auto_increment_increment=10") ) { mariadbCustomConfig.start(); - performQuery( + executeQuery( mariadbCustomConfig, "show variables like 'auto_increment_increment'", resultSet -> { @@ -140,12 +140,12 @@ void testEmptyPasswordWithRootUser() throws SQLException { try (MariaDBContainer mysql = new MariaDBContainer("mariadb:11.2.4").withUsername("root")) { mysql.start(); - performSelectOneQuery(mysql); + executeSelectOneQuery(mysql); } } private void assertThatCustomIniFileWasUsed(MariaDBContainer mariadb) throws SQLException { - performQuery( + executeQuery( mariadb, "SELECT @@GLOBAL.innodb_max_undo_log_size", resultSet -> { diff --git a/modules/mssqlserver/src/test/java/org/testcontainers/mssqlserver/MSSQLServerContainerTest.java b/modules/mssqlserver/src/test/java/org/testcontainers/mssqlserver/MSSQLServerContainerTest.java index b8d99904d91..6d3794e1e2c 100644 --- a/modules/mssqlserver/src/test/java/org/testcontainers/mssqlserver/MSSQLServerContainerTest.java +++ b/modules/mssqlserver/src/test/java/org/testcontainers/mssqlserver/MSSQLServerContainerTest.java @@ -26,7 +26,7 @@ void testSimple() throws SQLException { ) { mssqlServer.start(); - performSelectOneQuery(mssqlServer); + executeSelectOneQuery(mssqlServer); assertHasCorrectExposedAndLivenessCheckPorts(mssqlServer); } @@ -77,7 +77,7 @@ void testSqlServerConnection() throws SQLException { ) { mssqlServerContainer.start(); - performSelectOneQuery(mssqlServerContainer); + executeSelectOneQuery(mssqlServerContainer); } } diff --git a/modules/mysql/src/test/java/org/testcontainers/mysql/MySQLContainerTest.java b/modules/mysql/src/test/java/org/testcontainers/mysql/MySQLContainerTest.java index a201f733bb4..1d01c7a73dc 100644 --- a/modules/mysql/src/test/java/org/testcontainers/mysql/MySQLContainerTest.java +++ b/modules/mysql/src/test/java/org/testcontainers/mysql/MySQLContainerTest.java @@ -42,7 +42,7 @@ void testSimple() throws SQLException { ) { mysql.start(); - performSelectOneQuery(mysql); + executeSelectOneQuery(mysql); assertHasCorrectExposedAndLivenessCheckPorts(mysql); } @@ -81,7 +81,7 @@ void testCommandOverride() throws SQLException { ) { mysqlCustomConfig.start(); - performQuery( + executeQuery( mysqlCustomConfig, "show variables like 'auto_increment_increment'", resultSet -> { @@ -138,7 +138,7 @@ void testEmptyPasswordWithRootUser() throws SQLException { ) { mysql.start(); - performSelectOneQuery(mysql); + executeSelectOneQuery(mysql); } } @@ -261,7 +261,7 @@ void testCustom() throws SQLException { ) { mysql.start(); - performSelectOneQuery(mysql); + executeSelectOneQuery(mysql); } } @@ -271,7 +271,7 @@ private void assertHasCorrectExposedAndLivenessCheckPorts(MySQLContainer mysql) } private void assertThatCustomIniFileWasUsed(MySQLContainer mysql) throws SQLException { - performQuery( + executeQuery( mysql, "SELECT @@GLOBAL.innodb_max_undo_log_size", resultSet -> { diff --git a/modules/oceanbase/src/test/java/org/testcontainers/oceanbase/SimpleOceanBaseCETest.java b/modules/oceanbase/src/test/java/org/testcontainers/oceanbase/SimpleOceanBaseCETest.java index 5834ea9cc37..bbae547772d 100644 --- a/modules/oceanbase/src/test/java/org/testcontainers/oceanbase/SimpleOceanBaseCETest.java +++ b/modules/oceanbase/src/test/java/org/testcontainers/oceanbase/SimpleOceanBaseCETest.java @@ -21,7 +21,7 @@ void testSimple() throws SQLException { ) { oceanbase.start(); - performSelectOneQuery(oceanbase); + executeSelectOneQuery(oceanbase); assertHasCorrectExposedAndLivenessCheckPorts(oceanbase); } diff --git a/modules/oracle-free/src/test/java/org/testcontainers/junit/oracle/SimpleOracleTest.java b/modules/oracle-free/src/test/java/org/testcontainers/junit/oracle/SimpleOracleTest.java index f2028cbc7b3..c1102c4ca2b 100644 --- a/modules/oracle-free/src/test/java/org/testcontainers/junit/oracle/SimpleOracleTest.java +++ b/modules/oracle-free/src/test/java/org/testcontainers/junit/oracle/SimpleOracleTest.java @@ -1,6 +1,5 @@ package org.testcontainers.junit.oracle; -import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; import org.testcontainers.db.AbstractContainerDatabaseTest; import org.testcontainers.oracle.OracleContainer; @@ -26,18 +25,8 @@ private void runTest(OracleContainer container, String databaseName, String user //Test we can get a connection container.start(); - performQuery( - container, - "SELECT 1 FROM dual", - resultSet -> { - Assertions - .assertThatNoException() - .isThrownBy(() -> { - int resultSetInt = resultSet.getInt(1); - assertThat(resultSetInt).as("A basic SELECT query succeeds").isEqualTo(1); - }); - } - ); + + executeSelectOneQuery(container, "SELECT 1 FROM dual"); } @Test diff --git a/modules/oracle-xe/src/test/java/org/testcontainers/junit/oracle/SimpleOracleTest.java b/modules/oracle-xe/src/test/java/org/testcontainers/junit/oracle/SimpleOracleTest.java index b0e40eb492e..22c32204c74 100644 --- a/modules/oracle-xe/src/test/java/org/testcontainers/junit/oracle/SimpleOracleTest.java +++ b/modules/oracle-xe/src/test/java/org/testcontainers/junit/oracle/SimpleOracleTest.java @@ -1,6 +1,5 @@ package org.testcontainers.junit.oracle; -import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; import org.testcontainers.containers.OracleContainer; import org.testcontainers.db.AbstractContainerDatabaseTest; @@ -26,18 +25,8 @@ private void runTest(OracleContainer container, String databaseName, String user //Test we can get a connection container.start(); - performQuery( - container, - "SELECT 1 FROM dual", - resultSet -> { - Assertions - .assertThatNoException() - .isThrownBy(() -> { - int resultSetInt = resultSet.getInt(1); - assertThat(resultSetInt).as("A basic SELECT query succeeds").isEqualTo(1); - }); - } - ); + + executeSelectOneQuery(container, "SELECT 1 FROM dual"); } @Test diff --git a/modules/postgresql/src/test/java/org/testcontainers/containers/TimescaleDBContainerTest.java b/modules/postgresql/src/test/java/org/testcontainers/containers/TimescaleDBContainerTest.java index 7c70bf3b9a7..6d9f5eec0a6 100644 --- a/modules/postgresql/src/test/java/org/testcontainers/containers/TimescaleDBContainerTest.java +++ b/modules/postgresql/src/test/java/org/testcontainers/containers/TimescaleDBContainerTest.java @@ -12,7 +12,7 @@ void testSimple() throws SQLException { try (JdbcDatabaseContainer postgres = new TimescaleDBContainerProvider().newInstance()) { postgres.start(); - performSelectOneQuery(postgres); + executeSelectOneQuery(postgres); } } diff --git a/modules/postgresql/src/test/java/org/testcontainers/postgresql/CompatibleImageTest.java b/modules/postgresql/src/test/java/org/testcontainers/postgresql/CompatibleImageTest.java index a42cba21a38..39df23a7c8a 100644 --- a/modules/postgresql/src/test/java/org/testcontainers/postgresql/CompatibleImageTest.java +++ b/modules/postgresql/src/test/java/org/testcontainers/postgresql/CompatibleImageTest.java @@ -17,7 +17,7 @@ void pgvector() throws SQLException { ) { pgvector.start(); - performSelectOneQuery(pgvector); + executeSelectOneQuery(pgvector); } } @@ -32,7 +32,7 @@ void postgis() throws SQLException { ) { postgis.start(); - performSelectOneQuery(postgis); + executeSelectOneQuery(postgis); } } @@ -47,7 +47,7 @@ void timescaledb() throws SQLException { ) { timescaledb.start(); - performSelectOneQuery(timescaledb); + executeSelectOneQuery(timescaledb); } } } diff --git a/modules/postgresql/src/test/java/org/testcontainers/postgresql/PostgreSQLContainerTest.java b/modules/postgresql/src/test/java/org/testcontainers/postgresql/PostgreSQLContainerTest.java index c6b92a0437b..5e640ca3838 100644 --- a/modules/postgresql/src/test/java/org/testcontainers/postgresql/PostgreSQLContainerTest.java +++ b/modules/postgresql/src/test/java/org/testcontainers/postgresql/PostgreSQLContainerTest.java @@ -26,7 +26,7 @@ void testSimple() throws SQLException { ) { postgres.start(); - performSelectOneQuery(postgres); + executeSelectOneQuery(postgres); assertHasCorrectExposedAndLivenessCheckPorts(postgres); } @@ -89,7 +89,7 @@ void testExplicitInitScripts() throws SQLException { ) { postgres.start(); - performQuery( + executeQuery( postgres, "SELECT foo AS value FROM bar UNION SELECT bar AS value FROM foo", resultSet -> { diff --git a/modules/questdb/src/test/java/org/testcontainers/junit/questdb/SimpleQuestDBTest.java b/modules/questdb/src/test/java/org/testcontainers/junit/questdb/SimpleQuestDBTest.java index 2b408a5303b..9119ae1c9fe 100644 --- a/modules/questdb/src/test/java/org/testcontainers/junit/questdb/SimpleQuestDBTest.java +++ b/modules/questdb/src/test/java/org/testcontainers/junit/questdb/SimpleQuestDBTest.java @@ -31,7 +31,7 @@ void testSimple() throws SQLException { ) { questDB.start(); - performSelectOneQuery(questDB); + executeSelectOneQuery(questDB); } } diff --git a/modules/tidb/src/test/java/org/testcontainers/tidb/TiDBContainerTest.java b/modules/tidb/src/test/java/org/testcontainers/tidb/TiDBContainerTest.java index 74b9836b1f4..96d570e2086 100644 --- a/modules/tidb/src/test/java/org/testcontainers/tidb/TiDBContainerTest.java +++ b/modules/tidb/src/test/java/org/testcontainers/tidb/TiDBContainerTest.java @@ -18,7 +18,7 @@ void testSimple() throws SQLException { ) { tidb.start(); - performSelectOneQuery(tidb); + executeSelectOneQuery(tidb); assertHasCorrectExposedAndLivenessCheckPorts(tidb); } diff --git a/modules/timeplus/src/test/java/org/testcontainers/timeplus/TimeplusContainerTest.java b/modules/timeplus/src/test/java/org/testcontainers/timeplus/TimeplusContainerTest.java index 8c088626b71..7515f03a8f7 100644 --- a/modules/timeplus/src/test/java/org/testcontainers/timeplus/TimeplusContainerTest.java +++ b/modules/timeplus/src/test/java/org/testcontainers/timeplus/TimeplusContainerTest.java @@ -19,7 +19,7 @@ void testSimple() throws SQLException { ) { timeplus.start(); - performSelectOneQuery(timeplus); + executeSelectOneQuery(timeplus); } } @@ -34,7 +34,7 @@ void customCredentialsWithUrlParams() throws SQLException { ) { timeplus.start(); - performQuery( + executeQuery( timeplus, "SELECT to_int(value) FROM system.settings where name='interactive_delay'", resultSet -> { diff --git a/modules/yugabytedb/src/test/java/org/testcontainers/junit/yugabytedb/YugabyteDBYSQLTest.java b/modules/yugabytedb/src/test/java/org/testcontainers/junit/yugabytedb/YugabyteDBYSQLTest.java index 844bf85eea0..da6e2d9ba41 100644 --- a/modules/yugabytedb/src/test/java/org/testcontainers/junit/yugabytedb/YugabyteDBYSQLTest.java +++ b/modules/yugabytedb/src/test/java/org/testcontainers/junit/yugabytedb/YugabyteDBYSQLTest.java @@ -30,7 +30,7 @@ void testSmoke() throws SQLException { ) { ysqlContainer.start(); - performSelectOneQuery(ysqlContainer); + executeSelectOneQuery(ysqlContainer); } } @@ -43,7 +43,7 @@ void testCustomDatabase() throws SQLException { ) { ysqlContainer.start(); - performSelectOneQuery(ysqlContainer); + executeSelectOneQuery(ysqlContainer); } } @@ -54,7 +54,7 @@ void testInitScript() throws SQLException { .withInitScript("init/init_yql.sql") ) { ysqlContainer.start(); - performQuery( + executeQuery( ysqlContainer, "SELECT greet FROM dsql", resultSet -> { @@ -96,7 +96,7 @@ void testWithCustomRole() throws SQLException { ) { ysqlContainer.start(); - performSelectOneQuery(ysqlContainer); + executeSelectOneQuery(ysqlContainer); } } @@ -105,9 +105,9 @@ void testWaitStrategy() throws SQLException { try (final YugabyteDBYSQLContainer ysqlContainer = new YugabyteDBYSQLContainer(YBDB_TEST_IMAGE)) { ysqlContainer.start(); - performSelectOneQuery(ysqlContainer); + executeSelectOneQuery(ysqlContainer); - performQuery( + executeQuery( ysqlContainer, "SELECT EXISTS (SELECT FROM pg_tables WHERE tablename = 'YB_SAMPLE')", resultSet -> { From 6d8e8d3cd9c04de3322c12bf35bc6228bbfd3e61 Mon Sep 17 00:00:00 2001 From: "raju.gupta" Date: Mon, 13 Oct 2025 00:26:36 +0100 Subject: [PATCH 8/9] Refactor query execution methods to use executeSelectOneQuery and executeQuery for consistency --- .../testcontainers/cockroachdb/CockroachContainerTest.java | 4 ++-- .../org/testcontainers/junit/cratedb/SimpleCrateDBTest.java | 2 +- .../testcontainers/db/AbstractContainerDatabaseTest.java | 6 +++--- .../org/testcontainers/mysql/MultiVersionMySQLTest.java | 2 +- .../java/org/testcontainers/mysql/MySQLContainerTest.java | 4 ++-- .../org/testcontainers/oceanbase/SimpleOceanBaseCETest.java | 2 +- .../testcontainers/containers/TimescaleDBContainerTest.java | 6 +++--- .../testcontainers/postgresql/PostgreSQLContainerTest.java | 6 +++--- .../java/org/testcontainers/tidb/TiDBContainerTest.java | 2 +- 9 files changed, 17 insertions(+), 17 deletions(-) diff --git a/modules/cockroachdb/src/test/java/org/testcontainers/cockroachdb/CockroachContainerTest.java b/modules/cockroachdb/src/test/java/org/testcontainers/cockroachdb/CockroachContainerTest.java index 5cc0b75636d..a25964a8644 100644 --- a/modules/cockroachdb/src/test/java/org/testcontainers/cockroachdb/CockroachContainerTest.java +++ b/modules/cockroachdb/src/test/java/org/testcontainers/cockroachdb/CockroachContainerTest.java @@ -37,7 +37,7 @@ void testExplicitInitScript() throws SQLException { ) { // CockroachDB is expected to be compatible with Postgres cockroach.start(); - performSelectFooBarQuery(cockroach); + executeSelectFooBarQuery(cockroach); } } @@ -112,7 +112,7 @@ void testInitializationScript() throws SQLException { ) { // CockroachDB is expected to be compatible with Postgres cockroach.start(); - performSelectFooBarQuery(cockroach); + executeSelectFooBarQuery(cockroach); } } } diff --git a/modules/cratedb/src/test/java/org/testcontainers/junit/cratedb/SimpleCrateDBTest.java b/modules/cratedb/src/test/java/org/testcontainers/junit/cratedb/SimpleCrateDBTest.java index aaa52e6268c..4a106949213 100644 --- a/modules/cratedb/src/test/java/org/testcontainers/junit/cratedb/SimpleCrateDBTest.java +++ b/modules/cratedb/src/test/java/org/testcontainers/junit/cratedb/SimpleCrateDBTest.java @@ -62,7 +62,7 @@ void testExplicitInitScript() throws SQLException { ) { cratedb.start(); - performSelectFooBarQuery(cratedb); + executeSelectFooBarQuery(cratedb); } } diff --git a/modules/jdbc-test/src/main/java/org/testcontainers/db/AbstractContainerDatabaseTest.java b/modules/jdbc-test/src/main/java/org/testcontainers/db/AbstractContainerDatabaseTest.java index 729779c8280..ae6905d535a 100644 --- a/modules/jdbc-test/src/main/java/org/testcontainers/db/AbstractContainerDatabaseTest.java +++ b/modules/jdbc-test/src/main/java/org/testcontainers/db/AbstractContainerDatabaseTest.java @@ -52,7 +52,7 @@ protected void executeSelectOneQuery(final JdbcDatabaseContainer container, f ); } - protected void performSelectFooBarQuery(final JdbcDatabaseContainer container) throws SQLException { + protected void executeSelectFooBarQuery(final JdbcDatabaseContainer container) throws SQLException { executeQuery( container, "SELECT foo FROM bar", @@ -70,7 +70,7 @@ protected void performSelectFooBarQuery(final JdbcDatabaseContainer container ); } - protected void performSelectMaxConnectionsQuery( + protected void executeSelectMaxConnectionsQuery( final JdbcDatabaseContainer container, final String expectedMaxConnections ) throws SQLException { @@ -91,7 +91,7 @@ protected void performSelectMaxConnectionsQuery( ); } - protected void performSelectVersionQuery(final JdbcDatabaseContainer container, final String expectedVersion) + protected void executeSelectVersionQuery(final JdbcDatabaseContainer container, final String expectedVersion) throws SQLException { executeQuery( container, diff --git a/modules/mysql/src/test/java/org/testcontainers/mysql/MultiVersionMySQLTest.java b/modules/mysql/src/test/java/org/testcontainers/mysql/MultiVersionMySQLTest.java index 92345064b3f..4f1d9229e03 100644 --- a/modules/mysql/src/test/java/org/testcontainers/mysql/MultiVersionMySQLTest.java +++ b/modules/mysql/src/test/java/org/testcontainers/mysql/MultiVersionMySQLTest.java @@ -24,7 +24,7 @@ public static DockerImageName[] params() { void versionCheckTest(DockerImageName dockerImageName) throws SQLException { try (MySQLContainer mysql = new MySQLContainer(dockerImageName)) { mysql.start(); - performSelectVersionQuery(mysql, dockerImageName.getVersionPart()); + executeSelectVersionQuery(mysql, dockerImageName.getVersionPart()); } } } diff --git a/modules/mysql/src/test/java/org/testcontainers/mysql/MySQLContainerTest.java b/modules/mysql/src/test/java/org/testcontainers/mysql/MySQLContainerTest.java index 1d01c7a73dc..512b22438db 100644 --- a/modules/mysql/src/test/java/org/testcontainers/mysql/MySQLContainerTest.java +++ b/modules/mysql/src/test/java/org/testcontainers/mysql/MySQLContainerTest.java @@ -57,7 +57,7 @@ void testSpecificVersion() throws SQLException { ) { mysqlOldVersion.start(); - performSelectVersionQuery(mysqlOldVersion, "8.0.36"); + executeSelectVersionQuery(mysqlOldVersion, "8.0.36"); } } @@ -107,7 +107,7 @@ void testExplicitInitScript() throws SQLException { ) { container.start(); - performSelectFooBarQuery(container); + executeSelectFooBarQuery(container); } } diff --git a/modules/oceanbase/src/test/java/org/testcontainers/oceanbase/SimpleOceanBaseCETest.java b/modules/oceanbase/src/test/java/org/testcontainers/oceanbase/SimpleOceanBaseCETest.java index bbae547772d..49cfdc03067 100644 --- a/modules/oceanbase/src/test/java/org/testcontainers/oceanbase/SimpleOceanBaseCETest.java +++ b/modules/oceanbase/src/test/java/org/testcontainers/oceanbase/SimpleOceanBaseCETest.java @@ -32,7 +32,7 @@ void testExplicitInitScript() throws SQLException { try (OceanBaseCEContainer oceanbase = new OceanBaseCEContainer(IMAGE).withInitScript("init.sql")) { oceanbase.start(); - performSelectFooBarQuery(oceanbase); + executeSelectFooBarQuery(oceanbase); } } diff --git a/modules/postgresql/src/test/java/org/testcontainers/containers/TimescaleDBContainerTest.java b/modules/postgresql/src/test/java/org/testcontainers/containers/TimescaleDBContainerTest.java index 6d9f5eec0a6..63c1fc5e060 100644 --- a/modules/postgresql/src/test/java/org/testcontainers/containers/TimescaleDBContainerTest.java +++ b/modules/postgresql/src/test/java/org/testcontainers/containers/TimescaleDBContainerTest.java @@ -25,7 +25,7 @@ void testCommandOverride() throws SQLException { ) { postgres.start(); - performSelectMaxConnectionsQuery((JdbcDatabaseContainer) postgres, "42"); + executeSelectMaxConnectionsQuery((JdbcDatabaseContainer) postgres, "42"); } } @@ -39,7 +39,7 @@ void testUnsetCommand() throws SQLException { ) { postgres.start(); - performSelectMaxConnectionsQuery((JdbcDatabaseContainer) postgres, "100"); + executeSelectMaxConnectionsQuery((JdbcDatabaseContainer) postgres, "100"); } } @@ -52,7 +52,7 @@ void testExplicitInitScript() throws SQLException { ) { postgres.start(); - performSelectFooBarQuery(postgres); + executeSelectFooBarQuery(postgres); } } } diff --git a/modules/postgresql/src/test/java/org/testcontainers/postgresql/PostgreSQLContainerTest.java b/modules/postgresql/src/test/java/org/testcontainers/postgresql/PostgreSQLContainerTest.java index 5e640ca3838..1eb8a339108 100644 --- a/modules/postgresql/src/test/java/org/testcontainers/postgresql/PostgreSQLContainerTest.java +++ b/modules/postgresql/src/test/java/org/testcontainers/postgresql/PostgreSQLContainerTest.java @@ -40,7 +40,7 @@ void testCommandOverride() throws SQLException { ) { postgres.start(); - performSelectMaxConnectionsQuery(postgres, "42"); + executeSelectMaxConnectionsQuery(postgres, "42"); } } @@ -55,7 +55,7 @@ void testUnsetCommand() throws SQLException { // After unsetting the command, max_connections should be the default value (100), not 42 - performSelectMaxConnectionsQuery(postgres, "100"); + executeSelectMaxConnectionsQuery(postgres, "100"); } } @@ -77,7 +77,7 @@ void testExplicitInitScript() throws SQLException { ) { postgres.start(); - performSelectFooBarQuery(postgres); + executeSelectFooBarQuery(postgres); } } diff --git a/modules/tidb/src/test/java/org/testcontainers/tidb/TiDBContainerTest.java b/modules/tidb/src/test/java/org/testcontainers/tidb/TiDBContainerTest.java index 96d570e2086..8cf5c749a8b 100644 --- a/modules/tidb/src/test/java/org/testcontainers/tidb/TiDBContainerTest.java +++ b/modules/tidb/src/test/java/org/testcontainers/tidb/TiDBContainerTest.java @@ -31,7 +31,7 @@ void testExplicitInitScript() throws SQLException { ) { // TiDB is expected to be compatible with MySQL tidb.start(); - performSelectFooBarQuery(tidb); + executeSelectFooBarQuery(tidb); } } From 51568cda3449260923c8fba81bc10329c69012b3 Mon Sep 17 00:00:00 2001 From: "raju.gupta" Date: Mon, 13 Oct 2025 10:19:36 +0100 Subject: [PATCH 9/9] Refactor MariaDBContainerTest to use executeSelectVersionQuery with expected version --- .../java/org/testcontainers/mariadb/MariaDBContainerTest.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/modules/mariadb/src/test/java/org/testcontainers/mariadb/MariaDBContainerTest.java b/modules/mariadb/src/test/java/org/testcontainers/mariadb/MariaDBContainerTest.java index 809f0594ef1..c06e0b3ef61 100644 --- a/modules/mariadb/src/test/java/org/testcontainers/mariadb/MariaDBContainerTest.java +++ b/modules/mariadb/src/test/java/org/testcontainers/mariadb/MariaDBContainerTest.java @@ -42,7 +42,7 @@ void testSpecificVersion() throws SQLException { ) { mariadbOldVersion.start(); - executeSelectOneQuery(mariadbOldVersion); + executeSelectVersionQuery(mariadbOldVersion, "10.3.39"); } }