diff --git a/src/adapter/outbound/persistence-jpa/src/postgresqlIntegrationTest/java/dev/caskeleton/adapter/outbound/persistence/platform/JpaPlatformContractSupport.java b/src/adapter/outbound/persistence-jpa/src/postgresqlIntegrationTest/java/dev/caskeleton/adapter/outbound/persistence/platform/JpaPlatformContractSupport.java index 1a730490..788a978f 100644 --- a/src/adapter/outbound/persistence-jpa/src/postgresqlIntegrationTest/java/dev/caskeleton/adapter/outbound/persistence/platform/JpaPlatformContractSupport.java +++ b/src/adapter/outbound/persistence-jpa/src/postgresqlIntegrationTest/java/dev/caskeleton/adapter/outbound/persistence/platform/JpaPlatformContractSupport.java @@ -5,7 +5,10 @@ import com.zaxxer.hikari.HikariDataSource; import dev.caskeleton.adapter.outbound.persistence.testkit.postgresql.PostgreSqlContainerFactory; import dev.caskeleton.adapter.outbound.persistence.testkit.postgresql.PostgreSqlVersion; import java.sql.Connection; +import java.sql.DriverManager; import java.sql.SQLException; +import java.sql.Statement; +import java.util.EnumMap; import java.util.LinkedHashMap; import java.util.List; import java.util.Map; @@ -17,9 +20,16 @@ import org.testcontainers.postgresql.PostgreSQLContainer; /** * Starts one PostgreSQL per selected Stable version and hands out data sources (design §40). * - *

The containers are shared for the JVM: the contracts verify server behaviour, which does not + *

The servers are shared for the JVM: the contracts verify server behaviour, which does not * change between test classes, and starting a server per class turns a three-version matrix into - * minutes of container startup. + * minutes of container startup. Each support gets a database of its own on that server, created by + * {@code start} and dropped by {@code close}, so tables, schemas and Flyway history do not cross + * classes. What the server holds for every database — roles — does: a contract that creates a role + * owns that name for the whole lane. + * + *

Until 2026-11-12 every {@code start} started a server of its own although this comment said + * they were shared: 75 servers in the platform contract lane and 36 in the migration lane, 181 and + * 71 seconds of container start (desktop, 2026-11-12), on the build's one real-server slot. * *

Docker absence throws rather than skipping. A skipped contract reports success for a database * nobody tested, and CI inherits that silence. @@ -30,8 +40,16 @@ public final class JpaPlatformContractSupport implements AutoCloseable { private static final java.security.SecureRandom PASSWORD_SOURCE = new java.security.SecureRandom(); + /** One server per Stable version, started on first use and stopped when the JVM exits. */ + private static final Map SERVERS = + new EnumMap<>(PostgreSqlVersion.class); + + /** Names each support's database; the server outlives every support, so names never repeat. */ + private static final AtomicInteger DATABASES = new AtomicInteger(); + private final PostgreSqlVersion version; private final PostgreSQLContainer container; + private final String database; /** * The pools this support owns, closed before the container stops. @@ -48,9 +66,11 @@ public final class JpaPlatformContractSupport implements AutoCloseable { private final AtomicInteger poolSequence = new AtomicInteger(); - private JpaPlatformContractSupport(PostgreSqlVersion version, PostgreSQLContainer container) { + private JpaPlatformContractSupport( + PostgreSqlVersion version, PostgreSQLContainer container, String database) { this.version = version; this.container = container; + this.database = database; } /** @@ -85,12 +105,47 @@ public final class JpaPlatformContractSupport implements AutoCloseable { return start(selected.get(0)); } - /** Starts one specific Stable version. */ + /** A fresh database on the shared server of one specific Stable version. */ public static JpaPlatformContractSupport start(PostgreSqlVersion version) { Objects.requireNonNull(version, "version"); - PostgreSQLContainer container = PostgreSqlContainerFactory.create(version); - container.start(); - return new JpaPlatformContractSupport(version, container); + PostgreSQLContainer server = server(version); + String database = "contract_" + DATABASES.incrementAndGet(); + administer(server, "create database " + database); + return new JpaPlatformContractSupport(version, server, database); + } + + private static synchronized PostgreSQLContainer server(PostgreSqlVersion version) { + PostgreSQLContainer server = SERVERS.get(version); + if (server == null) { + if (SERVERS.isEmpty()) { + // Testcontainers' reaper would remove the containers too, but it is the part a remote + // Docker host cannot always reach; stopping them here does not depend on it. + Runtime.getRuntime() + .addShutdownHook( + new Thread(JpaPlatformContractSupport::stopServers, "jpa-contract-servers")); + } + server = PostgreSqlContainerFactory.create(version); + server.start(); + SERVERS.put(version, server); + } + return server; + } + + private static synchronized void stopServers() { + SERVERS.values().forEach(PostgreSQLContainer::stop); + SERVERS.clear(); + } + + /** Runs one statement as the server's owning role, connected to the server's own database. */ + private static void administer(PostgreSQLContainer server, String sql) { + try (Connection connection = + DriverManager.getConnection( + server.getJdbcUrl(), server.getUsername(), server.getPassword()); + Statement statement = connection.createStatement()) { + statement.execute(sql); + } catch (SQLException failure) { + throw new IllegalStateException("PostgreSQL contract server refused: " + sql, failure); + } } /** The versions this run was asked to cover. */ @@ -132,7 +187,7 @@ public final class JpaPlatformContractSupport implements AutoCloseable { private HikariDataSource pool(String role, String username, String password, int maximumSize) { HikariConfig config = new HikariConfig(); - config.setJdbcUrl(container.getJdbcUrl()); + config.setJdbcUrl(jdbcUrl()); config.setUsername(username); config.setPassword(password); config.setMaximumPoolSize(maximumSize); @@ -148,9 +203,14 @@ public final class JpaPlatformContractSupport implements AutoCloseable { return dataSource().getConnection(); } - /** The running server's JDBC URL, for contracts that build their own pools. */ + /** This support's database on the running server, for contracts that build their own pools. */ public String jdbcUrl() { - return container.getJdbcUrl(); + return "jdbc:postgresql://" + + container.getHost() + + ":" + + container.getMappedPort(PostgreSQLContainer.POSTGRESQL_PORT) + + "/" + + database; } /** The container's owning role. */ @@ -192,9 +252,10 @@ public final class JpaPlatformContractSupport implements AutoCloseable { @Override public synchronized void close() { - // Pools first, container last. Stopping the server while a pool is still open leaves that - // pool retrying against an address nobody is listening on, and its housekeeping thread outlives - // the test that created it. + // Pools first, database last. Dropping the database under an open pool leaves that pool + // retrying against a database that is gone, and its housekeeping thread outlives the test that + // created it. `with (force)` ends a connection a contract opened outside the pools. The server + // stays for the next class. RuntimeException firstFailure = null; for (HikariDataSource pool : pools.values()) { try { @@ -208,7 +269,15 @@ public final class JpaPlatformContractSupport implements AutoCloseable { } } pools.clear(); - container.stop(); + try { + administer(container, "drop database if exists " + database + " with (force)"); + } catch (RuntimeException failure) { + if (firstFailure == null) { + firstFailure = failure; + } else { + firstFailure.addSuppressed(failure); + } + } if (firstFailure != null) { throw firstFailure; } diff --git a/src/adapter/outbound/persistence-jpa/src/postgresqlIntegrationTest/java/dev/caskeleton/adapter/outbound/persistence/platform/JpaPlatformContractSupportOwnershipTest.java b/src/adapter/outbound/persistence-jpa/src/postgresqlIntegrationTest/java/dev/caskeleton/adapter/outbound/persistence/platform/JpaPlatformContractSupportOwnershipTest.java index 19a98a05..37247114 100644 --- a/src/adapter/outbound/persistence-jpa/src/postgresqlIntegrationTest/java/dev/caskeleton/adapter/outbound/persistence/platform/JpaPlatformContractSupportOwnershipTest.java +++ b/src/adapter/outbound/persistence-jpa/src/postgresqlIntegrationTest/java/dev/caskeleton/adapter/outbound/persistence/platform/JpaPlatformContractSupportOwnershipTest.java @@ -4,6 +4,10 @@ import static org.assertj.core.api.Assertions.assertThat; import com.zaxxer.hikari.HikariDataSource; import java.sql.Connection; +import java.sql.PreparedStatement; +import java.sql.ResultSet; +import java.sql.SQLException; +import java.util.List; import javax.sql.DataSource; import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Tag; @@ -66,8 +70,7 @@ class JpaPlatformContractSupportOwnershipTest { } @Test - @DisplayName("close shuts every pool before the container stops") - void closeShutsEveryPoolBeforeTheContainerStops() { + void closeShutsEveryPoolBeforeItsDatabaseIsDropped() { HikariDataSource owned; try (JpaPlatformContractSupport support = JpaPlatformContractSupport.start()) { owned = (HikariDataSource) support.dataSource(); @@ -75,10 +78,65 @@ class JpaPlatformContractSupportOwnershipTest { } assertThat(owned.isClosed()) - .as("stopping the container first leaves a live pool retrying against nothing") + .as("dropping the database first leaves a live pool retrying against nothing") .isTrue(); } + @Test + void aSecondSupportSharesTheServerButNotTheDatabase() { + // given + String first; + try (JpaPlatformContractSupport support = JpaPlatformContractSupport.start()) { + first = support.jdbcUrl(); + } + + // when + String second; + try (JpaPlatformContractSupport support = JpaPlatformContractSupport.start()) { + second = support.jdbcUrl(); + } + + // then + assertThat(List.of(serverOf(second), databaseOf(second).equals(databaseOf(first)))) + .as("one server per version for the JVM, a database of its own per support") + .containsExactly(serverOf(first), false); + } + + @Test + void closeDropsTheSupportsDatabase() throws SQLException { + // given + String closed; + try (JpaPlatformContractSupport support = JpaPlatformContractSupport.start()) { + closed = databaseOf(support.jdbcUrl()); + } + + // when + Boolean exists; + try (JpaPlatformContractSupport support = JpaPlatformContractSupport.start(); + Connection connection = support.connection(); + PreparedStatement statement = + connection.prepareStatement( + "select exists(select 1 from pg_database where datname = ?)")) { + statement.setString(1, closed); + try (ResultSet row = statement.executeQuery()) { + exists = row.next() ? row.getBoolean(1) : null; + } + } + + // then + assertThat(exists) + .as("a database left behind is one class's tables in the next class's server") + .isFalse(); + } + + private static String serverOf(String jdbcUrl) { + return jdbcUrl.substring(0, jdbcUrl.lastIndexOf('/')); + } + + private static String databaseOf(String jdbcUrl) { + return jdbcUrl.substring(jdbcUrl.lastIndexOf('/') + 1); + } + @Test @DisplayName("pools carry an identifiable name") void poolsCarryAnIdentifiableName() {