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..e4903e4fae7 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,7 @@ void testSimple() throws SQLException { ) { clickhouse.start(); - ResultSet resultSet = performQuery(clickhouse, "SELECT 1"); - - int resultSetInt = resultSet.getInt(1); - assertThat(resultSetInt).isEqualTo(1); + executeSelectOneQuery(clickhouse); } } @@ -45,13 +42,18 @@ void customCredentialsWithUrlParams() throws SQLException { ) { clickhouse.start(); - ResultSet resultSet = performQuery( + executeQuery( 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 +62,7 @@ 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); + 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 c9bd9e917f5..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 @@ -5,22 +5,16 @@ 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; - class SimpleClickhouseTest extends AbstractContainerDatabaseTest { @Test - public void testSimple() throws SQLException { + 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); + 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 3aba3d2eefd..a25964a8644 100644 --- a/modules/cockroachdb/src/test/java/org/testcontainers/cockroachdb/CockroachContainerTest.java +++ b/modules/cockroachdb/src/test/java/org/testcontainers/cockroachdb/CockroachContainerTest.java @@ -5,7 +5,6 @@ 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; @@ -26,11 +25,7 @@ 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); + executeSelectOneQuery(cockroach); } } @@ -42,10 +37,7 @@ 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"); + executeSelectFooBarQuery(cockroach); } } @@ -80,10 +72,7 @@ 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); + executeSelectOneQuery(cockroach); String jdbcUrl = cockroach.getJdbcUrl(); assertThat(jdbcUrl).contains("/" + "test_database"); @@ -123,10 +112,7 @@ 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"); + 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 803b9173218..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 @@ -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,7 @@ 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); + executeSelectOneQuery(cratedb); assertHasCorrectExposedAndLivenessCheckPorts(cratedb); } } @@ -41,9 +39,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"); + executeQuery( + 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 +62,7 @@ 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"); + executeSelectFooBarQuery(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 984f42979c4..ee0761d3e92 100644 --- a/modules/databend/src/test/java/org/testcontainers/databend/DatabendContainerTest.java +++ b/modules/databend/src/test/java/org/testcontainers/databend/DatabendContainerTest.java @@ -3,11 +3,8 @@ 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; - class DatabendContainerTest extends AbstractContainerDatabaseTest { @Test @@ -18,10 +15,7 @@ void testSimple() throws SQLException { ) { databend.start(); - ResultSet resultSet = performQuery(databend, "SELECT 1"); - - int resultSetInt = resultSet.getInt(1); - assertThat(resultSetInt).isEqualTo(1); + executeSelectOneQuery(databend); } } @@ -35,10 +29,7 @@ void customCredentialsWithUrlParams() throws SQLException { ) { databend.start(); - ResultSet resultSet = performQuery(databend, "SELECT 1;"); - - int resultSetInt = resultSet.getInt(1); - assertThat(resultSetInt).isEqualTo(1); + 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 6b17d1583f7..67cfdb1956a 100644 --- a/modules/db2/src/test/java/org/testcontainers/db2/Db2ContainerTest.java +++ b/modules/db2/src/test/java/org/testcontainers/db2/Db2ContainerTest.java @@ -4,7 +4,6 @@ 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 +18,8 @@ void testSimple() throws SQLException { ) { db2.start(); - ResultSet resultSet = performQuery(db2, "SELECT 1 FROM SYSIBM.SYSDUMMY1"); + executeSelectOneQuery(db2, "SELECT 1 FROM SYSIBM.SYSDUMMY1"); - int resultSetInt = resultSet.getInt(1); - assertThat(resultSetInt).as("A basic SELECT query succeeds").isEqualTo(1); assertHasCorrectExposedAndLivenessCheckPorts(db2); } } @@ -32,10 +29,8 @@ 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"); + executeSelectOneQuery(db2, "SELECT 1 FROM SYSIBM.SYSDUMMY1"); - 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..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 @@ -2,27 +2,115 @@ 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; 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 executeQuery( + 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 void executeSelectOneQuery(final JdbcDatabaseContainer container) throws SQLException { + executeSelectOneQuery(container, "SELECT 1"); + } + + protected void executeSelectOneQuery(final JdbcDatabaseContainer container, final String sql) + throws SQLException { + executeQuery( + container, + sql, + resultSet -> { + Assertions + .assertThatNoException() + .isThrownBy(() -> { + int resultSetInt = resultSet.getInt(1); + Assertions.assertThat(resultSetInt).as("A basic SELECT query succeeds").isEqualTo(1); + }); + } + ); + } + + protected void executeSelectFooBarQuery(final JdbcDatabaseContainer container) throws SQLException { + executeQuery( + 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 void executeSelectMaxConnectionsQuery( + final JdbcDatabaseContainer container, + final String expectedMaxConnections + ) throws SQLException { + executeQuery( + 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(expectedMaxConnections); + }); + } + ); + } + + protected void executeSelectVersionQuery(final JdbcDatabaseContainer container, final String expectedVersion) + throws SQLException { + executeQuery( + 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(expectedVersion); + }); + } + ); + } + + 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..c06e0b3ef61 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,7 @@ 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); + executeSelectOneQuery(mariadb); } } @@ -45,12 +42,7 @@ 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"); + executeSelectVersionQuery(mariadbOldVersion, "10.3.39"); } } @@ -77,10 +69,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"); + executeQuery( + 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 +140,24 @@ 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); + executeSelectOneQuery(mysql); } } 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); - } + executeQuery( + 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..6d3794e1e2c 100644 --- a/modules/mssqlserver/src/test/java/org/testcontainers/mssqlserver/MSSQLServerContainerTest.java +++ b/modules/mssqlserver/src/test/java/org/testcontainers/mssqlserver/MSSQLServerContainerTest.java @@ -25,10 +25,9 @@ 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); + executeSelectOneQuery(mssqlServer); + assertHasCorrectExposedAndLivenessCheckPorts(mssqlServer); } } @@ -78,9 +77,7 @@ 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); + executeSelectOneQuery(mssqlServerContainer); } } 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..4f1d9229e03 100644 --- a/modules/mysql/src/test/java/org/testcontainers/mysql/MultiVersionMySQLTest.java +++ b/modules/mysql/src/test/java/org/testcontainers/mysql/MultiVersionMySQLTest.java @@ -6,11 +6,8 @@ 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; - class MultiVersionMySQLTest extends AbstractContainerDatabaseTest { public static DockerImageName[] params() { @@ -27,12 +24,7 @@ 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()); + 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 ad78781db5c..512b22438db 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,8 @@ void testSimple() throws SQLException { ) { mysql.start(); - ResultSet resultSet = performQuery(mysql, "SELECT 1"); - int resultSetInt = resultSet.getInt(1); + executeSelectOneQuery(mysql); - assertThat(resultSetInt).as("A basic SELECT query succeeds").isEqualTo(1); assertHasCorrectExposedAndLivenessCheckPorts(mysql); } } @@ -58,12 +57,7 @@ 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"); + executeSelectVersionQuery(mysqlOldVersion, "8.0.36"); } } @@ -87,10 +81,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"); + executeQuery( + 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 +107,7 @@ 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"); + executeSelectFooBarQuery(container); } } @@ -137,10 +138,7 @@ 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); + executeSelectOneQuery(mysql); } } @@ -263,10 +261,7 @@ 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); + executeSelectOneQuery(mysql); } } @@ -276,11 +271,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); - } + executeQuery( + 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..49cfdc03067 100644 --- a/modules/oceanbase/src/test/java/org/testcontainers/oceanbase/SimpleOceanBaseCETest.java +++ b/modules/oceanbase/src/test/java/org/testcontainers/oceanbase/SimpleOceanBaseCETest.java @@ -3,7 +3,6 @@ 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 +21,8 @@ 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); + executeSelectOneQuery(oceanbase); + assertHasCorrectExposedAndLivenessCheckPorts(oceanbase); } } @@ -34,9 +32,7 @@ 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"); + executeSelectFooBarQuery(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 f46539bac89..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 @@ -5,7 +5,6 @@ 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 +25,8 @@ 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); + + 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 17ee85944a7..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 @@ -5,7 +5,6 @@ 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 +25,8 @@ 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); + + 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 3991f4c2b1c..63c1fc5e060 100644 --- a/modules/postgresql/src/test/java/org/testcontainers/containers/TimescaleDBContainerTest.java +++ b/modules/postgresql/src/test/java/org/testcontainers/containers/TimescaleDBContainerTest.java @@ -3,11 +3,8 @@ 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; - class TimescaleDBContainerTest extends AbstractContainerDatabaseTest { @Test @@ -15,9 +12,7 @@ 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); + executeSelectOneQuery(postgres); } } @@ -30,12 +25,7 @@ void testCommandOverride() throws SQLException { ) { postgres.start(); - ResultSet resultSet = performQuery( - (JdbcDatabaseContainer) postgres, - "SELECT current_setting('max_connections')" - ); - String result = resultSet.getString(1); - assertThat(result).as("max_connections should be overridden").isEqualTo("42"); + executeSelectMaxConnectionsQuery((JdbcDatabaseContainer) postgres, "42"); } } @@ -49,12 +39,7 @@ void testUnsetCommand() throws SQLException { ) { postgres.start(); - ResultSet resultSet = performQuery( - (JdbcDatabaseContainer) postgres, - "SELECT current_setting('max_connections')" - ); - String result = resultSet.getString(1); - assertThat(result).as("max_connections should not be overridden").isNotEqualTo("42"); + executeSelectMaxConnectionsQuery((JdbcDatabaseContainer) postgres, "100"); } } @@ -67,10 +52,7 @@ 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"); + executeSelectFooBarQuery(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 bdad4fb6a5c..39df23a7c8a 100644 --- a/modules/postgresql/src/test/java/org/testcontainers/postgresql/CompatibleImageTest.java +++ b/modules/postgresql/src/test/java/org/testcontainers/postgresql/CompatibleImageTest.java @@ -4,11 +4,8 @@ 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; - class CompatibleImageTest extends AbstractContainerDatabaseTest { @Test @@ -20,9 +17,7 @@ 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); + executeSelectOneQuery(pgvector); } } @@ -37,9 +32,7 @@ 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); + executeSelectOneQuery(postgis); } } @@ -54,9 +47,7 @@ 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); + 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 beefa3776b1..1eb8a339108 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,8 @@ 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); + executeSelectOneQuery(postgres); + assertHasCorrectExposedAndLivenessCheckPorts(postgres); } } @@ -41,9 +40,7 @@ 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"); + executeSelectMaxConnectionsQuery(postgres, "42"); } } @@ -56,9 +53,9 @@ 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"); + // After unsetting the command, max_connections should be the default value (100), not 42 + + executeSelectMaxConnectionsQuery(postgres, "100"); } } @@ -80,10 +77,7 @@ 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"); + executeSelectFooBarQuery(postgres); } } @@ -95,16 +89,25 @@ void testExplicitInitScripts() throws SQLException { ) { postgres.start(); - ResultSet resultSet = performQuery( + executeQuery( 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..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 @@ -14,7 +14,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 +31,7 @@ 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); + 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 54ded93e69e..8cf5c749a8b 100644 --- a/modules/tidb/src/test/java/org/testcontainers/tidb/TiDBContainerTest.java +++ b/modules/tidb/src/test/java/org/testcontainers/tidb/TiDBContainerTest.java @@ -4,7 +4,6 @@ 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 +18,8 @@ void testSimple() throws SQLException { ) { tidb.start(); - ResultSet resultSet = performQuery(tidb, "SELECT 1"); + executeSelectOneQuery(tidb); - int resultSetInt = resultSet.getInt(1); - assertThat(resultSetInt).isEqualTo(1); assertHasCorrectExposedAndLivenessCheckPorts(tidb); } } @@ -34,10 +31,7 @@ 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"); + executeSelectFooBarQuery(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 7ab38c03f87..7515f03a8f7 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,7 @@ void testSimple() throws SQLException { ) { timeplus.start(); - ResultSet resultSet = performQuery(timeplus, "SELECT 1"); - - int resultSetInt = resultSet.getInt(1); - assertThat(resultSetInt).isEqualTo(1); + executeSelectOneQuery(timeplus); } } @@ -37,13 +34,18 @@ void customCredentialsWithUrlParams() throws SQLException { ) { timeplus.start(); - ResultSet resultSet = performQuery( + executeQuery( 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..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 @@ -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,8 @@ void testSmoke() throws SQLException { // } ) { ysqlContainer.start(); - assertThat(performQuery(ysqlContainer, "SELECT 1").getInt(1)) - .as("A sample test query succeeds") - .isEqualTo(1); + + executeSelectOneQuery(ysqlContainer); } } @@ -42,9 +42,8 @@ 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); + + executeSelectOneQuery(ysqlContainer); } } @@ -55,9 +54,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"); + executeQuery( + ysqlContainer, + "SELECT greet FROM dsql", + resultSet -> { + Assertions + .assertThatNoException() + .isThrownBy(() -> { + assertThat(resultSet.getString(1)).as("A record match succeeds").isEqualTo("Hello DSQL"); + }); + } + ); } } @@ -88,9 +95,8 @@ 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); + + executeSelectOneQuery(ysqlContainer); } } @@ -98,15 +104,21 @@ 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( + + executeSelectOneQuery(ysqlContainer); + + executeQuery( ysqlContainer, - "SELECT EXISTS (SELECT FROM pg_tables WHERE tablename = 'YB_SAMPLE')" - ) - .getBoolean(1); - assertThat(tableExists).as("yb_sample table does not exists").isFalse(); + "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(); + }); + } + ); } } }