Updated JdbcDatabaseContainerExtension

Author: sksamuel

README.md

@@ -18,6 +18,7 @@ Please create issues on the main kotest [board](https://github.com/kotest/kotest
 
 * Deprecated older extensions and introduced `JdbcDatabaseContainerExtension` and `ContainerExtension` extensions
 * Deprecated Kafka extensions in favour of the `kotest-extensions-testcontainers-kafka` module
+* Added `DockerComposeContainerExtension` for executing test containers from docker compose files.
 * Added `kotest-extensions-testcontainers-elastic` and `kotest-extensions-testcontainers-localstack`
 * Deprecated per-test lifecycle modes
 * Deprecated custom SQL runner in favour of Flyway or another widely used db migration framework.

kotest-extensions-testcontainers-localstack/build.gradle.kts

@@ -10,7 +10,6 @@ pluginManagement {
 include(
    ":kotest-extensions-testcontainers-kafka",
    ":kotest-extensions-testcontainers-elastic",
-   ":kotest-extensions-testcontainers-localstack",
 )
 
 enableFeaturePreview("STABLE_CONFIGURATION_CACHE")

kotest-extensions-testcontainers-localstack/src/main/kotlin/io/kotest/extensions/testcontainers/localstack/LocalStackContainerExtension.kt

@@ -27,11 +27,6 @@ import org.testcontainers.containers.GenericContainer
  * @param mode determines if the container is shutdown after the test suite (project) or after the installed spec
  *             The default is after the test suite.
  *
- * @param beforeSpec a beforeSpec callback
- * @param afterSpec an afterSpec callback
- * @param beforeTest a beforeTest callback
- * @param afterTest a afterTest callback
- *
  * @param beforeStart a callback that is invoked only once, just before the container is started.
  * If the container is never started, this callback will not be invoked.
  * This callback can be useful instead of the installation callback as it will only
@@ -40,6 +35,18 @@ import org.testcontainers.containers.GenericContainer
  * @param afterStart a callback that is invoked only once, just after the container is started.
  * If the container is never started, this callback will not be invoked.
  *
+ * @param beforeSpec a beforeSpec callback.
+ * If the container is never started, this callback will not be invoked.
+ *
+ * @param afterSpec an afterSpec callback
+ * If the container is never started, this callback will not be invoked.
+ *
+ * @param beforeTest a beforeTest callback
+ * If the container is never started, this callback will not be invoked.
+ *
+ * @param afterTest a afterTest callback
+ * If the container is never started, this callback will not be invoked.
+ *
  * @param beforeShutdown a callback that is invoked only once, just before the container is stopped.
  * If the container is never started, this callback will not be invoked.
  *
@@ -49,14 +56,14 @@ import org.testcontainers.containers.GenericContainer
 class ContainerExtension<T : GenericContainer<T>>(
    private val container: T,
    private val mode: ContainerLifecycleMode = ContainerLifecycleMode.Project,
-   private val beforeStart: (T) -> Unit = {},
-   private val afterStart: (T) -> Unit = {},
-   private val beforeTest: suspend (TestCase, T) -> Unit = { _, _ -> },
-   private val afterTest: suspend (TestCase, T) -> Unit = { _, _ -> },
-   private val beforeSpec: suspend (Spec, T) -> Unit = { _, _ -> },
-   private val afterSpec: suspend (Spec, T) -> Unit = { _, _ -> },
-   private val beforeShutdown: (T) -> Unit = {},
-   private val afterShutdown: (T) -> Unit = {},
+   private val beforeStart: () -> Unit = {},
+   private val afterStart: () -> Unit = {},
+   private val beforeTest: suspend (TestCase) -> Unit = { _ -> },
+   private val afterTest: suspend (TestCase) -> Unit = { _ -> },
+   private val beforeSpec: suspend (Spec) -> Unit = { _ -> },
+   private val afterSpec: suspend (Spec) -> Unit = { _ -> },
+   private val beforeShutdown: () -> Unit = {},
+   private val afterShutdown: () -> Unit = {},
 ) : MountableExtension<T, T>,
    AfterProjectListener,
    BeforeTestListener,
@@ -70,28 +77,28 @@ class ContainerExtension<T : GenericContainer<T>>(
     */
    override fun mount(configure: T.() -> Unit): T {
       if (!container.isRunning) {
-         beforeStart(container)
+         beforeStart()
          container.start()
-         afterStart(container)
+         afterStart()
       }
       container.configure()
       return container
    }
 
    override suspend fun beforeTest(testCase: TestCase) {
-      beforeTest(testCase, container)
+      beforeTest(testCase)
    }
 
    override suspend fun afterTest(testCase: TestCase, result: TestResult) {
-      afterTest(testCase, container)
+      afterTest(testCase)
    }
 
    override suspend fun beforeSpec(spec: Spec) {
-      beforeSpec(spec, container)
+      beforeSpec(spec)
    }
 
    override suspend fun afterSpec(spec: Spec) {
-      afterSpec(spec, container)
+      afterSpec(spec)
       if (mode == ContainerLifecycleMode.Spec && container.isRunning) close()
    }
 
@@ -101,9 +108,9 @@ class ContainerExtension<T : GenericContainer<T>>(
 
    private suspend fun close() {
       withContext(Dispatchers.IO) {
-         beforeShutdown(container)
+         beforeShutdown()
          container.stop()
-         afterShutdown(container)
+         afterShutdown()
       }
    }
 }

settings.gradle.kts

@@ -1,30 +1,40 @@
 package io.kotest.extensions.testcontainers
 
+import com.zaxxer.hikari.HikariConfig
 import com.zaxxer.hikari.HikariDataSource
 import io.kotest.core.extensions.MountableExtension
 import io.kotest.core.listeners.AfterProjectListener
 import io.kotest.core.listeners.AfterSpecListener
 import io.kotest.core.listeners.AfterTestListener
 import io.kotest.core.listeners.BeforeSpecListener
 import io.kotest.core.listeners.BeforeTestListener
+import io.kotest.core.spec.Spec
+import io.kotest.core.test.TestCase
+import io.kotest.core.test.TestResult
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.withContext
 import org.testcontainers.containers.JdbcDatabaseContainer
 
 /**
- * A Kotest [MountableExtension] for [JdbcDatabaseContainer]s that are started the first time they are
- * installed in a spec.
+ * A Kotest [MountableExtension] for [JdbcDatabaseContainer]s which is started the first time they are
+ * installed in a spec. Upon installation, this extension returns an initialized [HikariDataSource]
+ * connected to the database.
  *
  * If no spec is executed that installs a particular container,
  * then that container is never started.
  *
- * Once mounted in a spec, the return value from the installation point is a configured HikariDataSource.
- *
  * @param container the specific database test container type
  * @param beforeSpec a beforeSpec callback
+ * If the container is never started, this callback will not be invoked.
+ *
  * @param afterSpec an afterSpec callback
+ * If the container is never started, this callback will not be invoked.
+ *
  * @param beforeTest a beforeTest callback
+ * If the container is never started, this callback will not be invoked.
+ *
  * @param afterTest a afterTest callback
+ * If the container is never started, this callback will not be invoked.
  *
  * @param beforeStart a callback that is invoked only once, just before the container is started.
  * If the container is never started, this callback will not be invoked.
@@ -42,48 +52,88 @@ import org.testcontainers.containers.JdbcDatabaseContainer
  */
 class JdbcDatabaseContainerExtension(
    private val container: JdbcDatabaseContainer<*>,
-   private val beforeStart: (JdbcDatabaseContainer<*>) -> Unit = {},
-   private val afterStart: (JdbcDatabaseContainer<*>) -> Unit = {},
-   private val beforeShutdown: (JdbcDatabaseContainer<*>) -> Unit = {},
-   private val beforeTest: suspend (HikariDataSource) -> Unit = {},
-   private val afterTest: suspend (HikariDataSource) -> Unit = {},
-   private val beforeSpec: suspend (HikariDataSource) -> Unit = {},
-   private val afterSpec: suspend (HikariDataSource) -> Unit = {},
-   private val afterShutdown: (HikariDataSource) -> Unit = {},
-) : MountableExtension<TestContainerHikariConfig, HikariDataSource>,
+   private val mode: ContainerLifecycleMode = ContainerLifecycleMode.Project,
+   private val beforeStart: () -> Unit = {},
+   private val afterStart: () -> Unit = {},
+   private val beforeTest: suspend (TestCase, HikariDataSource) -> Unit = { _, _ -> },
+   private val afterTest: suspend (TestCase, HikariDataSource) -> Unit = { _, _ -> },
+   private val beforeSpec: suspend (Spec) -> Unit = { _ -> },
+   private val afterSpec: suspend (Spec, HikariDataSource) -> Unit = { _, _ -> },
+   private val beforeShutdown: (HikariDataSource) -> Unit = {},
+   private val afterShutdown: () -> Unit = { },
+) : MountableExtension<HikariDataSource, HikariDataSource>,
    AfterProjectListener,
    BeforeTestListener,
    BeforeSpecListener,
    AfterTestListener,
    AfterSpecListener {
 
+   private var dataSource: HikariDataSource? = null
+
    /**
     * Mounts the container, starting it if necessary. The [configure] block will be invoked
     * every time the container is mounted, and after the container has started.
+    *
+    * This will return an initialized [HikariDataSource].
+    * The datasource will be closed in accordance with the provided [ContainerLifecycleMode].
+    *
+    * The datasource will be created with default options. If you wish to customize the datasource,
+    * then ignore this returned value, and instead use the extension function [toDataSource] on the
+    * container instance.
     */
-   override fun mount(configure: TestContainerHikariConfig.() -> Unit): HikariDataSource {
+   override fun mount(configure: HikariDataSource.() -> Unit): HikariDataSource {
       if (!container.isRunning) {
-         beforeStart(container)
+         beforeStart()
          container.start()
-         afterStart(container)
+         dataSource = container.toDataSource()
+         afterStart()
       }
-      return createDataSource(configure)
+      dataSource?.configure()
+      return dataSource ?: error("Datasource not initialized")
+   }
+
+   override suspend fun beforeTest(testCase: TestCase) {
+      beforeTest(testCase, dataSource ?: error("Datasource not initialized"))
+   }
+
+   override suspend fun afterTest(testCase: TestCase, result: TestResult) {
+      afterTest(testCase, dataSource ?: error("Datasource not initialized"))
+   }
+
+   override suspend fun beforeSpec(spec: Spec) {
+      beforeSpec(spec)
+   }
+
+   override suspend fun afterSpec(spec: Spec) {
+      afterSpec(spec, dataSource ?: error("Datasource not initialized"))
+      if (mode == ContainerLifecycleMode.Spec && container.isRunning) close()
    }
 
    override suspend fun afterProject() {
-      if (container.isRunning) withContext(Dispatchers.IO) {
-         beforeShutdown(container)
+      if (container.isRunning) close()
+   }
+
+   private suspend fun close() {
+      withContext(Dispatchers.IO) {
+         beforeShutdown(dataSource ?: error("Datasource not initialized"))
+         dataSource?.close()
          container.stop()
+         afterShutdown()
       }
    }
+}
 
-   private fun createDataSource(configure: TestContainerHikariConfig.() -> Unit): HikariDataSource {
-      val config = TestContainerHikariConfig()
-      config.jdbcUrl = container.jdbcUrl
-      config.username = container.username
-      config.password = container.password
-      config.configure()
-      //      runInitScripts(ds.connection, config.dbInitScripts)
-      return HikariDataSource(config)
-   }
+/**
+ * Returns an initialized [HikariDataSource] connected to this [JdbcDatabaseContainer].
+ *
+ * @param configure a thunk to configure the [HikariConfig] used to create the datasource.
+ */
+fun JdbcDatabaseContainer<*>.toDataSource(configure: HikariConfig.() -> Unit = {}): HikariDataSource {
+   val config = HikariConfig()
+   config.jdbcUrl = jdbcUrl
+   config.username = username
+   config.password = password
+   config.minimumIdle = 0
+   config.configure()
+   return HikariDataSource(config)
 }