✨ feat: upgrade to testcontainers v2

build.sbt

@@ -89,7 +89,6 @@ lazy val root = (project in file("."))
     moduleCockroachdb,
     moduleCouchbase,
     moduleDb2,
-    moduleDynalite,
     moduleElasticsearch,
     moduleInfluxdb,
     moduleLocalstack,
@@ -323,7 +322,8 @@ lazy val moduleKafka = (project in file("modules/kafka"))
   .settings(commonSettings)
   .settings(
     name := "testcontainers-scala-kafka",
-    libraryDependencies ++= Dependencies.moduleKafka.value
+    libraryDependencies ++= Dependencies.moduleKafka.value,
+    resolvers += "Confluent" at "https://packages.confluent.io/maven"
   )
 
 lazy val moduleVault = (project in file("modules/vault"))
@@ -374,14 +374,6 @@ lazy val moduleDb2 = (project in file("modules/db2"))
     libraryDependencies ++= Dependencies.moduleDb2.value
   )
 
-lazy val moduleDynalite = (project in file("modules/dynalite"))
-  .dependsOn(core % "compile->compile;test->test;provided->provided")
-  .settings(commonSettings)
-  .settings(
-    name := "testcontainers-scala-dynalite",
-    libraryDependencies ++= Dependencies.moduleDynalite.value
-  )
-
 lazy val moduleElasticsearch = (project in file("modules/elasticsearch"))
   .dependsOn(core % "compile->compile;test->test;provided->provided")
   .settings(commonSettings)

core/src/main/scala/com/dimafeng/testcontainers/Container.scala

@@ -1,44 +1,31 @@
 package com.dimafeng.testcontainers
 
-import java.io.InputStream
-import java.nio.charset.Charset
-import java.util.function.Consumer
-
 import com.dimafeng.testcontainers.lifecycle.Stoppable
 import com.github.dockerjava.api.DockerClient
 import com.github.dockerjava.api.command.InspectContainerResponse
-import com.github.dockerjava.api.model.{Bind, Info, VolumesFrom}
-import org.junit.runner.Description
+import com.github.dockerjava.api.model.{Bind, VolumesFrom}
 import org.testcontainers.containers.output.OutputFrame
 import org.testcontainers.containers.startupcheck.StartupCheckStrategy
 import org.testcontainers.containers.traits.LinkableContainer
-import org.testcontainers.containers.{FailureDetectingExternalResource, Network, TestContainerAccessor}
-import org.testcontainers.containers.{GenericContainer => JavaGenericContainer, Container => JavaContainer}
+import org.testcontainers.containers.{Network, Container => JavaContainer, GenericContainer => JavaGenericContainer}
 import org.testcontainers.core.CreateContainerCmdModifier
 import org.testcontainers.images.builder.Transferable
 import org.testcontainers.lifecycle.Startable
 import org.testcontainers.utility.{MountableFile, ThrowingFunction}
 
-import scala.collection.JavaConverters._
+import java.io.InputStream
+import java.nio.charset.Charset
+import java.util.function.Consumer
 import scala.concurrent.{Future, blocking}
 
+import scala.collection.JavaConverters._
+
 @deprecated("For internal usage only. Will be deleted.", "v0.34.0")
-trait TestContainerProxy[T <: FailureDetectingExternalResource] extends Container {
+trait TestContainerProxy[T] extends Container {
 
   @deprecated("Please use reflective methods from the wrapper and `configure` method for creation", "v0.17.0")
   implicit def container: T
-
-  @deprecated("Use `stop` instead", "v0.27.0")
-  override def finished()(implicit description: Description): Unit = TestContainerAccessor.finished(description)
-
-  @deprecated("Use `stop` and/or `TestLifecycleAware.afterTest` instead", "v0.27.0")
-  override def succeeded()(implicit description: Description): Unit = TestContainerAccessor.succeeded(description)
-
-  @deprecated("Use `start` instead", "v0.27.0")
-  override def starting()(implicit description: Description): Unit = TestContainerAccessor.starting(description)
-
-  @deprecated("Use `stop` and/or `TestLifecycleAware.afterTest` instead", "v0.27.0")
-  override def failed(e: Throwable)(implicit description: Description): Unit = TestContainerAccessor.failed(e, description)
+
 }
 
 abstract class SingleContainer[T <: JavaGenericContainer[?]] extends TestContainerProxy[T] {
@@ -165,15 +152,4 @@ abstract class SingleContainer[T <: JavaGenericContainer[?]] extends TestContain
 
 trait Container extends Startable with Stoppable {
 
-  @deprecated("Use `stop` instead", "v0.29.0")
-  def finished()(implicit description: Description): Unit = stop()
-
-  @deprecated("Use `stop` and/or `TestLifecycleAware.afterTest` instead", "v0.29.0")
-  def failed(e: Throwable)(implicit description: Description): Unit = {}
-
-  @deprecated("Use `start` instead", "v0.29.0")
-  def starting()(implicit description: Description): Unit = start()
-
-  @deprecated("Use `stop` and/or `TestLifecycleAware.afterTest` instead", "v0.29.0")
-  def succeeded()(implicit description: Description): Unit = {}
 }

core/src/main/scala/com/dimafeng/testcontainers/DockerComposeContainer.scala

@@ -3,12 +3,11 @@ package com.dimafeng.testcontainers
 import java.io.File
 import java.util
 import java.util.function.Consumer
-
 import com.dimafeng.testcontainers.DockerComposeContainer.ComposeFile
 import org.testcontainers.containers.output.OutputFrame
 import org.testcontainers.containers.wait.strategy.{Wait, WaitStrategy}
 import org.testcontainers.containers.{ContainerState, ComposeContainer => JavaDockerComposeContainer}
-import org.testcontainers.utility.Base58
+import org.testcontainers.utility.{Base58, DockerImageName}
 
 import scala.collection.JavaConverters._
 
@@ -50,53 +49,41 @@ object DockerComposeContainer {
 
   def randomIdentifier: String = Base58.randomString(DockerComposeContainer.ID_LENGTH).toLowerCase()
 
-  @deprecated("Please use expanded `apply` method", "v0.19.0")
-  def apply(composeFiles: ComposeFile,
-            exposedService: Map[String, Int],
-            identifier: String): DockerComposeContainer =
-    apply(composeFiles, exposedService, identifier)
-
-
-  @deprecated("Please use expanded `apply` method", "v0.19.0")
-  def apply(composeFiles: ComposeFile,
-            exposedService: Map[String, Int]): DockerComposeContainer =
-    new DockerComposeContainer(composeFiles, exposedService)
-
   def apply(composeFiles: ComposeFile,
             exposedServices: Seq[ExposedService] = Seq.empty,
             identifier: String = DockerComposeContainer.randomIdentifier,
             scaledServices: Seq[ScaledService] = Seq.empty,
             pull: Boolean = true,
-            localCompose: Boolean = true,
             env: Map[String, String] = Map.empty,
             tailChildContainers: Boolean = false,
             logConsumers: Seq[ServiceLogConsumer] = Seq.empty,
             waitingFor: Option[WaitingForService] = None,
-            services: Services = Services.All): DockerComposeContainer =
+            services: Services = Services.All,
+            image: DockerImageName = DockerImageName.parse("docker")): DockerComposeContainer =
     new DockerComposeContainer(composeFiles,
       exposedServices,
       identifier,
       scaledServices,
       pull,
-      localCompose,
       env,
       tailChildContainers,
       logConsumers,
       waitingFor,
-      services)
+      services,
+      image)
 
   case class Def(
                   composeFiles: ComposeFile,
                   exposedServices: Seq[ExposedService] = Seq.empty,
                   identifier: String = DockerComposeContainer.randomIdentifier,
                   scaledServices: Seq[ScaledService] = Seq.empty,
                   pull: Boolean = true,
-                  localCompose: Boolean = true,
                   env: Map[String, String] = Map.empty,
                   tailChildContainers: Boolean = false,
                   logConsumers: Seq[ServiceLogConsumer] = Seq.empty,
                   waitingFor: Option[WaitingForService] = None,
-                  services: Services = Services.All
+                  services: Services = Services.All,
+                  image: DockerImageName = DockerImageName.parse("docker")
                 ) extends ContainerDef {
 
     override type Container = DockerComposeContainer
@@ -108,12 +95,12 @@ object DockerComposeContainer {
         identifier,
         scaledServices,
         pull,
-        localCompose,
         env,
         tailChildContainers,
         logConsumers,
         waitingFor,
-        services
+        services,
+        image
       )
     }
   }
@@ -125,16 +112,16 @@ class DockerComposeContainer(composeFiles: ComposeFile,
                              identifier: String = DockerComposeContainer.randomIdentifier,
                              scaledServices: Seq[ScaledService] = Seq.empty,
                              pull: Boolean = true,
-                             localCompose: Boolean = true,
                              env: Map[String, String] = Map.empty,
                              tailChildContainers: Boolean = false,
                              logConsumers: Seq[ServiceLogConsumer] = Seq.empty,
                              waitingFor: Option[WaitingForService] = None,
-                             services: Services = Services.All)
+                             services: Services = Services.All,
+                             image: DockerImageName = DockerImageName.parse("docker"))
   extends TestContainerProxy[JavaDockerComposeContainer] {
 
   override val container: JavaDockerComposeContainer = {
-    val container: JavaDockerComposeContainer = new JavaDockerComposeContainer(identifier, composeFiles match {
+    val container: JavaDockerComposeContainer = new JavaDockerComposeContainer(image, identifier, composeFiles match {
       case ComposeFile(Left(f)) => util.Arrays.asList(f)
       case ComposeFile(Right(files)) => files.asJava
     })
@@ -161,7 +148,6 @@ class DockerComposeContainer(composeFiles: ComposeFile,
     )
 
     container.withPull(pull)
-    container.withLocalCompose(localCompose)
     container.withEnv(env.asJava)
     container.withTailChildContainers(tailChildContainers)
 

core/src/main/scala/com/dimafeng/testcontainers/MultipleContainers.scala

@@ -1,25 +1,12 @@
 package com.dimafeng.testcontainers
 
 import com.dimafeng.testcontainers.lifecycle.TestLifecycleAware
-import org.junit.runner.Description
 import org.testcontainers.lifecycle.TestDescription
 
 import scala.language.implicitConversions
 
 class MultipleContainers private(containers: Seq[LazyContainer[?]]) extends Container with TestLifecycleAware {
 
-  @deprecated("Use `stop` instead", "v0.27.0")
-  override def finished()(implicit description: Description): Unit = containers.foreach(_.finished()(description))
-
-  @deprecated("Use `stop` and/or `TestLifecycleAware.afterTest` instead", "v0.27.0")
-  override def succeeded()(implicit description: Description): Unit = containers.foreach(_.succeeded()(description))
-
-  @deprecated("Use `start` instead", "v0.27.0")
-  override def starting()(implicit description: Description): Unit = containers.foreach(_.starting()(description))
-
-  @deprecated("Use `stop` and/or `TestLifecycleAware.afterTest` instead", "v0.27.0")
-  override def failed(e: Throwable)(implicit description: Description): Unit = containers.foreach(_.failed(e)(description))
-
   override def beforeTest(description: TestDescription): Unit = {
     containers.foreach(_.beforeTest(description))
   }
@@ -68,18 +55,6 @@ object MultipleContainers {
 class LazyContainer[T <: Container](factory: => T) extends Container with TestLifecycleAware {
   lazy val container: T = factory
 
-  @deprecated("Use `stop` instead", "v0.27.0")
-  override def finished()(implicit description: Description): Unit = container.finished()
-
-  @deprecated("Use `stop` and/or `TestLifecycleAware.afterTest` instead", "v0.27.0")
-  override def failed(e: Throwable)(implicit description: Description): Unit = container.failed(e)
-
-  @deprecated("Use `start` instead", "v0.27.0")
-  override def starting()(implicit description: Description): Unit = container.starting()
-
-  @deprecated("Use `stop` and/or `TestLifecycleAware.afterTest` instead", "v0.27.0")
-  override def succeeded()(implicit description: Description): Unit = container.succeeded()
-
   override def beforeTest(description: TestDescription): Unit = {
     container match {
       case c: TestLifecycleAware => c.beforeTest(description)

modules/cassandra/src/main/scala/com/dimafeng/testcontainers/CassandraContainer.scala

@@ -1,29 +1,18 @@
 package com.dimafeng.testcontainers
 
-import com.datastax.driver.core.Cluster
-import org.testcontainers.containers.{CassandraContainer => JavaCassandraContainer}
+import org.testcontainers.cassandra.{CassandraContainer => JavaCassandraContainer}
 import org.testcontainers.utility.DockerImageName
 
-class CassandraContainer(dockerImageNameOverride: Option[DockerImageName] = None,
+class CassandraContainer(image: DockerImageName = DockerImageName.parse(CassandraContainer.defaultDockerImageName),
                          configurationOverride: Option[String] = None,
-                         initScript: Option[String] = None,
-                         jmxReporting: Boolean = false) extends SingleContainer[JavaCassandraContainer[?]] {
+                         initScript: Option[String] = None) extends SingleContainer[JavaCassandraContainer] {
 
-  val cassandraContainer: JavaCassandraContainer[?] = {
-    if (dockerImageNameOverride.isEmpty) {
-      new JavaCassandraContainer()
-    } else {
-      new JavaCassandraContainer(dockerImageNameOverride.get)
-    }
-  }
+  val cassandraContainer: JavaCassandraContainer = new JavaCassandraContainer(image)
 
   if (configurationOverride.isDefined) cassandraContainer.withConfigurationOverride(configurationOverride.get)
   if (initScript.isDefined) cassandraContainer.withInitScript(initScript.get)
-  if (jmxReporting) cassandraContainer.withJmxReporting(jmxReporting)
-
-  override val container: JavaCassandraContainer[?] = cassandraContainer
 
-  def cluster: Cluster = cassandraContainer.getCluster
+  override val container: JavaCassandraContainer = cassandraContainer
 
   def username: String = cassandraContainer.getUsername
 
@@ -35,31 +24,27 @@ object CassandraContainer {
 
   val defaultDockerImageName = "cassandra:3.11.2"
 
-  def apply(dockerImageNameOverride: DockerImageName = null,
+  def apply(image: DockerImageName = DockerImageName.parse(defaultDockerImageName),
             configurationOverride: String = null,
-            initScript: String = null,
-            jmxReporting: Boolean = false): CassandraContainer = new CassandraContainer(
-    Option(dockerImageNameOverride),
+            initScript: String = null): CassandraContainer = new CassandraContainer(
+    image,
     Option(configurationOverride),
-    Option(initScript),
-    jmxReporting
+    Option(initScript)
   )
 
   case class Def(
     dockerImageName: DockerImageName = DockerImageName.parse(defaultDockerImageName),
     configurationOverride: Option[String] = None,
-    initScript: Option[String] = None,
-    jmxReporting: Boolean = false
+    initScript: Option[String] = None
   ) extends ContainerDef {
 
     override type Container = CassandraContainer
 
     override def createContainer(): CassandraContainer = {
       new CassandraContainer(
-        dockerImageNameOverride = Some(dockerImageName),
+        image = dockerImageName,
         configurationOverride = configurationOverride,
-        initScript = initScript,
-        jmxReporting = jmxReporting
+        initScript = initScript
       )
     }
   }

modules/cockroachdb/src/main/scala/com/dimafeng/testcontainers/CockroachContainer.scala

@@ -1,6 +1,6 @@
 package com.dimafeng.testcontainers
 
-import org.testcontainers.containers.{CockroachContainer => JavaCockroachContainer}
+import org.testcontainers.cockroachdb.{CockroachContainer => JavaCockroachContainer}
 import org.testcontainers.utility.DockerImageName
 
 case class CockroachContainer(
@@ -26,7 +26,7 @@ case class CockroachContainer(
 
 object CockroachContainer {
 
-  val defaultDockerImageName = s"${JavaCockroachContainer.IMAGE}:${JavaCockroachContainer.IMAGE_TAG}"
+  val defaultDockerImageName = "cockroachdb/cockroach"
 
   case class Def(
     dockerImageName: DockerImageName = DockerImageName.parse(CockroachContainer.defaultDockerImageName),

modules/db2/src/main/scala/com/dimafeng/testcontainers/Db2Container.scala

@@ -1,6 +1,6 @@
 package com.dimafeng.testcontainers
 
-import org.testcontainers.containers.{Db2Container => JavaDb2Container}
+import org.testcontainers.db2.{Db2Container => JavaDb2Container}
 import org.testcontainers.utility.DockerImageName
 
 case class Db2Container(
@@ -32,7 +32,7 @@ case class Db2Container(
 
 object Db2Container {
 
-  val defaultDockerImageName = s"${JavaDb2Container.DEFAULT_DB2_IMAGE_NAME}:${JavaDb2Container.DEFAULT_TAG}"
+  val defaultDockerImageName = "icr.io/db2_community/db2"
   val defaultDatabaseName = "test"
   val defaultUsername = "db2inst1"
   val defaultPassword = "foobar1234"