diff --git a/build.sbt b/build.sbt index 901b81fc..dacf0bcd 100644 --- a/build.sbt +++ b/build.sbt @@ -86,7 +86,6 @@ lazy val root = (project in file(".")) moduleCockroachdb, moduleCouchbase, moduleDb2, - moduleDynalite, moduleElasticsearch, moduleInfluxdb, moduleLocalstack, @@ -320,7 +319,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")) @@ -371,14 +371,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) diff --git a/core/src/main/scala/com/dimafeng/testcontainers/Container.scala b/core/src/main/scala/com/dimafeng/testcontainers/Container.scala index 4ca5ccc9..c7585432 100644 --- a/core/src/main/scala/com/dimafeng/testcontainers/Container.scala +++ b/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 = {} } diff --git a/core/src/main/scala/com/dimafeng/testcontainers/DockerComposeContainer.scala b/core/src/main/scala/com/dimafeng/testcontainers/DockerComposeContainer.scala index 52ccbf92..2ceb6fc8 100644 --- a/core/src/main/scala/com/dimafeng/testcontainers/DockerComposeContainer.scala +++ b/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,40 +49,28 @@ 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, @@ -91,12 +78,12 @@ object DockerComposeContainer { 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) diff --git a/core/src/main/scala/com/dimafeng/testcontainers/MultipleContainers.scala b/core/src/main/scala/com/dimafeng/testcontainers/MultipleContainers.scala index f03cd727..2bca2861 100644 --- a/core/src/main/scala/com/dimafeng/testcontainers/MultipleContainers.scala +++ b/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) diff --git a/core/src/main/scala/org/testcontainers/containers/TestContainerAccessor.scala b/core/src/main/scala/org/testcontainers/containers/TestContainerAccessor.scala deleted file mode 100644 index 1c641a21..00000000 --- a/core/src/main/scala/org/testcontainers/containers/TestContainerAccessor.scala +++ /dev/null @@ -1,18 +0,0 @@ -package org.testcontainers.containers - -import org.junit.runner.Description - -@deprecated("Should be replaced by lifecycle methods", "v0.27.0") -object TestContainerAccessor { - def finished[T <:FailureDetectingExternalResource](description: Description)(implicit container: T): Unit = - container.finished(description) - - def failed[T <:FailureDetectingExternalResource](e: Throwable, description: Description)(implicit container: T): Unit = - container.failed(e, description) - - def starting[T <:FailureDetectingExternalResource](description: Description)(implicit container: T): Unit = - container.starting(description) - - def succeeded[T <:FailureDetectingExternalResource](description: Description)(implicit container: T): Unit = - container.succeeded(description) -} diff --git a/modules/cassandra/src/main/scala/com/dimafeng/testcontainers/CassandraContainer.scala b/modules/cassandra/src/main/scala/com/dimafeng/testcontainers/CassandraContainer.scala index 64adfe52..76b8e97c 100644 --- a/modules/cassandra/src/main/scala/com/dimafeng/testcontainers/CassandraContainer.scala +++ b/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 ) } } diff --git a/modules/cockroachdb/src/main/scala/com/dimafeng/testcontainers/CockroachContainer.scala b/modules/cockroachdb/src/main/scala/com/dimafeng/testcontainers/CockroachContainer.scala index 37adb046..335a58cc 100644 --- a/modules/cockroachdb/src/main/scala/com/dimafeng/testcontainers/CockroachContainer.scala +++ b/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), diff --git a/modules/db2/src/main/scala/com/dimafeng/testcontainers/Db2Container.scala b/modules/db2/src/main/scala/com/dimafeng/testcontainers/Db2Container.scala index 1196ae3d..5a5df6e7 100644 --- a/modules/db2/src/main/scala/com/dimafeng/testcontainers/Db2Container.scala +++ b/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" diff --git a/modules/dynalite/src/main/scala/com/dimafeng/testcontainers/DynaliteContainer.scala b/modules/dynalite/src/main/scala/com/dimafeng/testcontainers/DynaliteContainer.scala deleted file mode 100644 index b37a6429..00000000 --- a/modules/dynalite/src/main/scala/com/dimafeng/testcontainers/DynaliteContainer.scala +++ /dev/null @@ -1,42 +0,0 @@ -package com.dimafeng.testcontainers - -import com.amazonaws.auth.AWSCredentialsProvider -import com.amazonaws.client.builder.AwsClientBuilder -import com.amazonaws.services.dynamodbv2.AmazonDynamoDB -import org.testcontainers.dynamodb.{DynaliteContainer => JavaDynaliteContainer} -import org.testcontainers.utility.DockerImageName - -case class DynaliteContainer( - dockerImageName: DockerImageName = DockerImageName.parse(DynaliteContainer.defaultDockerImageName) -) extends SingleContainer[JavaDynaliteContainer] { - - override val container: JavaDynaliteContainer = { - val c = new JavaDynaliteContainer(dockerImageName) - c.withExposedPorts(4567) - c - } - - def client: AmazonDynamoDB = container.getClient - - def endpointConfiguration: AwsClientBuilder.EndpointConfiguration = container.getEndpointConfiguration - - def credentials: AWSCredentialsProvider = container.getCredentials -} - -object DynaliteContainer { - - val defaultDockerImageName = "quay.io/testcontainers/dynalite:v1.2.1-1" - - case class Def( - dockerImageName: DockerImageName = DockerImageName.parse(DynaliteContainer.defaultDockerImageName) - ) extends ContainerDef { - - override type Container = DynaliteContainer - - override def createContainer(): DynaliteContainer = { - new DynaliteContainer( - dockerImageName - ) - } - } -} diff --git a/modules/kafka/src/main/scala/com/dimafeng/testcontainers/ConfluentKafkaContainer.scala b/modules/kafka/src/main/scala/com/dimafeng/testcontainers/ConfluentKafkaContainer.scala new file mode 100644 index 00000000..6ca0bba1 --- /dev/null +++ b/modules/kafka/src/main/scala/com/dimafeng/testcontainers/ConfluentKafkaContainer.scala @@ -0,0 +1,29 @@ +package com.dimafeng.testcontainers + +import org.testcontainers.kafka.{ConfluentKafkaContainer => JavaConfluentKafkaContainer} +import org.testcontainers.utility.DockerImageName + +case class ConfluentKafkaContainer(dockerImageName: DockerImageName = DockerImageName.parse(ConfluentKafkaContainer.defaultDockerImageName) + ) extends SingleContainer[JavaConfluentKafkaContainer] { + + override val container: JavaConfluentKafkaContainer = new JavaConfluentKafkaContainer(dockerImageName) + + def bootstrapServers: String = container.getBootstrapServers +} + +object ConfluentKafkaContainer { + + val defaultImage = "confluentinc/cp-kafka" + val defaultTag = "8.1.0" + val defaultDockerImageName = s"$defaultImage:$defaultTag" + + case class Def(dockerImageName: DockerImageName = DockerImageName.parse(defaultDockerImageName) + ) extends ContainerDef { + + override type Container = ConfluentKafkaContainer + + override def createContainer(): ConfluentKafkaContainer = { + new ConfluentKafkaContainer(dockerImageName) + } + } +} diff --git a/modules/kafka/src/main/scala/com/dimafeng/testcontainers/KafkaContainer.scala b/modules/kafka/src/main/scala/com/dimafeng/testcontainers/KafkaContainer.scala index ae3d7090..f0f0e929 100644 --- a/modules/kafka/src/main/scala/com/dimafeng/testcontainers/KafkaContainer.scala +++ b/modules/kafka/src/main/scala/com/dimafeng/testcontainers/KafkaContainer.scala @@ -1,6 +1,6 @@ package com.dimafeng.testcontainers -import org.testcontainers.containers.{KafkaContainer => JavaKafkaContainer} +import org.testcontainers.kafka.{KafkaContainer => JavaKafkaContainer} import org.testcontainers.utility.DockerImageName case class KafkaContainer(dockerImageName: DockerImageName = DockerImageName.parse(KafkaContainer.defaultDockerImageName) @@ -13,11 +13,9 @@ case class KafkaContainer(dockerImageName: DockerImageName = DockerImageName.par object KafkaContainer { - val defaultImage = "confluentinc/cp-kafka" - val defaultTag = "7.6.1" - val defaultDockerImageName = s"$defaultImage:$defaultTag" + val defaultDockerImageName = "apache/kafka" - case class Def(dockerImageName: DockerImageName = DockerImageName.parse(KafkaContainer.defaultDockerImageName) + case class Def(dockerImageName: DockerImageName = DockerImageName.parse(defaultDockerImageName) ) extends ContainerDef { override type Container = KafkaContainer diff --git a/modules/kafka/src/main/scala/com/dimafeng/testcontainers/SchemaRegistryContainer.scala b/modules/kafka/src/main/scala/com/dimafeng/testcontainers/SchemaRegistryContainer.scala index 2c7965da..75e52316 100644 --- a/modules/kafka/src/main/scala/com/dimafeng/testcontainers/SchemaRegistryContainer.scala +++ b/modules/kafka/src/main/scala/com/dimafeng/testcontainers/SchemaRegistryContainer.scala @@ -15,7 +15,7 @@ class SchemaRegistryContainer(network: Network, kafkaHost: String, confluentPlat container.setEnv( List( s"SCHEMA_REGISTRY_HOST_NAME=${container.getHost}", - s"SCHEMA_REGISTRY_KAFKASTORE_BOOTSTRAP_SERVERS=$kafkaHost:9092" + s"SCHEMA_REGISTRY_KAFKASTORE_BOOTSTRAP_SERVERS=$kafkaHost:9093" ).asJava ) @@ -31,7 +31,7 @@ object SchemaRegistryContainer { def apply( network: Network, kafkaHost: String, - confluentPlatformVersion: String = KafkaContainer.defaultTag, + confluentPlatformVersion: String = ConfluentKafkaContainer.defaultTag, schemaPort: Int = defaultSchemaPort ): SchemaRegistryContainer = new SchemaRegistryContainer(network, kafkaHost, confluentPlatformVersion, schemaPort) @@ -39,7 +39,7 @@ object SchemaRegistryContainer { case class Def( network: Network, kafkaHost: String, - confluentPlatformVersion: String = KafkaContainer.defaultTag, + confluentPlatformVersion: String = ConfluentKafkaContainer.defaultTag, schemaPort: Int = defaultSchemaPort ) extends ContainerDef { diff --git a/modules/kafka/src/test/scala/com/dimafeng/testcontainers/integration/ConfluentKafkaSpec.scala b/modules/kafka/src/test/scala/com/dimafeng/testcontainers/integration/ConfluentKafkaSpec.scala new file mode 100644 index 00000000..48980c30 --- /dev/null +++ b/modules/kafka/src/test/scala/com/dimafeng/testcontainers/integration/ConfluentKafkaSpec.scala @@ -0,0 +1,28 @@ +package com.dimafeng.testcontainers.integration + +import java.util.Properties +import com.dimafeng.testcontainers.{ForAllTestContainer, ConfluentKafkaContainer} +import org.apache.kafka.clients.consumer.KafkaConsumer +import org.apache.kafka.common.serialization.StringDeserializer +import org.scalatest.flatspec.AnyFlatSpec +import org.scalatest.matchers.should.Matchers + +class ConfluentKafkaSpec extends AnyFlatSpec with ForAllTestContainer with Matchers { + + override val container: ConfluentKafkaContainer = ConfluentKafkaContainer() + + "Confluent Kafka container" should "be started" in { + + val properties = new Properties() + properties.put("bootstrap.servers", container.bootstrapServers) + properties.put("group.id", "consumer-tutorial") + properties.put("key.deserializer", classOf[StringDeserializer]) + properties.put("value.deserializer", classOf[StringDeserializer]) + + val kafkaConsumer = new KafkaConsumer[String, String](properties) + val topics = kafkaConsumer.listTopics() + + assert(topics.size() >= 0) + } + +} diff --git a/modules/kafka/src/test/scala/com/dimafeng/testcontainers/integration/KafkaSpec.scala b/modules/kafka/src/test/scala/com/dimafeng/testcontainers/integration/KafkaSpec.scala index b10fe9b0..4a37fc04 100644 --- a/modules/kafka/src/test/scala/com/dimafeng/testcontainers/integration/KafkaSpec.scala +++ b/modules/kafka/src/test/scala/com/dimafeng/testcontainers/integration/KafkaSpec.scala @@ -1,12 +1,13 @@ package com.dimafeng.testcontainers.integration -import java.util.Properties import com.dimafeng.testcontainers.{ForAllTestContainer, KafkaContainer} import org.apache.kafka.clients.consumer.KafkaConsumer import org.apache.kafka.common.serialization.StringDeserializer import org.scalatest.flatspec.AnyFlatSpec import org.scalatest.matchers.should.Matchers +import java.util.Properties + class KafkaSpec extends AnyFlatSpec with ForAllTestContainer with Matchers { override val container: KafkaContainer = KafkaContainer() diff --git a/modules/kafka/src/test/scala/com/dimafeng/testcontainers/integration/SchemaRegistrySpec.scala b/modules/kafka/src/test/scala/com/dimafeng/testcontainers/integration/SchemaRegistrySpec.scala index 17f78167..cfb47a3c 100644 --- a/modules/kafka/src/test/scala/com/dimafeng/testcontainers/integration/SchemaRegistrySpec.scala +++ b/modules/kafka/src/test/scala/com/dimafeng/testcontainers/integration/SchemaRegistrySpec.scala @@ -1,6 +1,8 @@ package com.dimafeng.testcontainers.integration -import com.dimafeng.testcontainers.{ForAllTestContainer, GenericContainer, KafkaContainer, MultipleContainers, SchemaRegistryContainer} +import com.dimafeng.testcontainers.{ConfluentKafkaContainer, ForAllTestContainer, GenericContainer, MultipleContainers, SchemaRegistryContainer} +import io.confluent.kafka.schemaregistry.ParsedSchema +import io.confluent.kafka.schemaregistry.avro.AvroSchema import org.apache.kafka.clients.admin.{AdminClient, AdminClientConfig, NewTopic} import org.apache.kafka.clients.consumer.KafkaConsumer import org.apache.kafka.common.serialization.StringDeserializer @@ -8,6 +10,9 @@ import org.scalatest.flatspec.AnyFlatSpec import org.scalatest.matchers.should.Matchers import org.testcontainers.containers.Network import org.testcontainers.utility.DockerImageName +import io.confluent.kafka.schemaregistry.client.CachedSchemaRegistryClient +import io.confluent.kafka.schemaregistry.client.SchemaRegistryClient +import org.apache.avro.Schema import java.util.Properties import scala.collection.JavaConverters._ @@ -15,7 +20,7 @@ import scala.collection.JavaConverters._ class SchemaRegistrySpec extends AnyFlatSpec with ForAllTestContainer with Matchers { //this should be the same version that your lib is using under the hood - val kafkaVersion = "6.1.1" + val kafkaVersion = "8.1.0" //these are the default kafka host name but because that may change //we need to ensure that these are the values for container network, kafka and the schema registry @@ -27,8 +32,8 @@ class SchemaRegistrySpec extends AnyFlatSpec with ForAllTestContainer with Match //a way to communicate containers val network: Network = Network.newNetwork() - val kafkaContainer: KafkaContainer = KafkaContainer.Def(DockerImageName.parse(s"confluentinc/cp-kafka:$kafkaVersion")).createContainer() - val schemaRegistryContainer: GenericContainer = SchemaRegistryContainer.Def(network, hostName, kafkaVersion).createContainer() + val kafkaContainer: ConfluentKafkaContainer = ConfluentKafkaContainer.Def(DockerImageName.parse(s"confluentinc/cp-kafka:$kafkaVersion")).createContainer() + val schemaRegistryContainer: SchemaRegistryContainer = SchemaRegistryContainer.Def(network, hostName, kafkaVersion).createContainer() kafkaContainer.container .withNetwork(network) @@ -45,18 +50,26 @@ class SchemaRegistrySpec extends AnyFlatSpec with ForAllTestContainer with Match def getKafkaAddress: String = kafkaContainer.bootstrapServers - def getSchemaRegistryAddress: String = - s"http://${schemaRegistryContainer.container.getHost}:${schemaRegistryContainer.container.getMappedPort(SchemaRegistryContainer.defaultSchemaPort)}" + def getSchemaRegistryAddress: String = schemaRegistryContainer.schemaUrl "Schema registry container" should "be started" in { val adminProperties = new Properties() adminProperties.put(AdminClientConfig.BOOTSTRAP_SERVERS_CONFIG, getKafkaAddress) - val adminClient = AdminClient.create(adminProperties) - val createTopicResult = adminClient.createTopics(List(new NewTopic(topicName, 1, 1)).asJava) + + // Create a topic + val createTopicResult = adminClient.createTopics(List(new NewTopic(topicName, 1, 1.toShort)).asJava) createTopicResult.values().get(topicName).get() + + val registryUrl = getSchemaRegistryAddress + val schemaRegistryClient: SchemaRegistryClient = new CachedSchemaRegistryClient(registryUrl, 10); + + // Explicitly create a schema in the registry + val schema: Schema = Schema.create(Schema.Type.STRING) + val parsedSchema: ParsedSchema = new AvroSchema(schema) + val schemaId = schemaRegistryClient.register("my-topic-value", parsedSchema) val properties = new Properties() properties.put("bootstrap.servers", getKafkaAddress) @@ -64,11 +77,17 @@ class SchemaRegistrySpec extends AnyFlatSpec with ForAllTestContainer with Match properties.put("key.deserializer", classOf[StringDeserializer]) properties.put("value.deserializer", classOf[StringDeserializer]) + // List topics val kafkaConsumer = new KafkaConsumer[String, String](properties) val topics = kafkaConsumer.listTopics() + // Check the topic we created + the one storing schemas exist assert(topics.containsKey(topicName)) assert(topics.containsKey("_schemas")) + + // Check the schema exists + assert(schemaRegistryClient.getSchemaById(schemaId) != null) + } } diff --git a/modules/mariadb/src/main/scala/com/dimafeng/testcontainers/MariaDBContainer.scala b/modules/mariadb/src/main/scala/com/dimafeng/testcontainers/MariaDBContainer.scala index 67460e28..5335d771 100644 --- a/modules/mariadb/src/main/scala/com/dimafeng/testcontainers/MariaDBContainer.scala +++ b/modules/mariadb/src/main/scala/com/dimafeng/testcontainers/MariaDBContainer.scala @@ -1,6 +1,6 @@ package com.dimafeng.testcontainers -import org.testcontainers.containers.{MariaDBContainer => JavaMariaDBContainer} +import org.testcontainers.mariadb.{MariaDBContainer => JavaMariaDBContainer} import org.testcontainers.utility.DockerImageName case class MariaDBContainer( @@ -11,10 +11,10 @@ case class MariaDBContainer( configurationOverride: Option[String] = None, urlParams: Map[String, String] = Map.empty, commonJdbcParams: JdbcDatabaseContainer.CommonParams = JdbcDatabaseContainer.CommonParams() -) extends SingleContainer[JavaMariaDBContainer[?]] with JdbcDatabaseContainer { +) extends SingleContainer[JavaMariaDBContainer] with JdbcDatabaseContainer { - override val container: JavaMariaDBContainer[?] = { - val c: JavaMariaDBContainer[?] = new JavaMariaDBContainer(dockerImageName) + override val container: JavaMariaDBContainer = { + val c: JavaMariaDBContainer = new JavaMariaDBContainer(dockerImageName) c.withDatabaseName(dbName) c.withUsername(dbUsername) @@ -34,7 +34,7 @@ case class MariaDBContainer( object MariaDBContainer { - val defaultDockerImageName = s"${JavaMariaDBContainer.IMAGE}:${JavaMariaDBContainer.DEFAULT_TAG}" + val defaultDockerImageName = "mariadb" val defaultDatabaseName = "test" val defaultUsername = "test" val defaultPassword = "test" diff --git a/modules/mockserver/src/main/scala/com/dimafeng/testcontainers/MockServerContainer.scala b/modules/mockserver/src/main/scala/com/dimafeng/testcontainers/MockServerContainer.scala index 0ffdf273..f5ece264 100644 --- a/modules/mockserver/src/main/scala/com/dimafeng/testcontainers/MockServerContainer.scala +++ b/modules/mockserver/src/main/scala/com/dimafeng/testcontainers/MockServerContainer.scala @@ -1,6 +1,6 @@ package com.dimafeng.testcontainers -import org.testcontainers.containers.{MockServerContainer => JavaMockServerContainer} +import org.testcontainers.mockserver.{MockServerContainer => JavaMockServerContainer} import org.testcontainers.utility.DockerImageName case class MockServerContainer( diff --git a/modules/mongodb/src/main/scala/com/dimafeng/testcontainers/MongoDBContainer.scala b/modules/mongodb/src/main/scala/com/dimafeng/testcontainers/MongoDBContainer.scala index 6209b274..81eb924d 100644 --- a/modules/mongodb/src/main/scala/com/dimafeng/testcontainers/MongoDBContainer.scala +++ b/modules/mongodb/src/main/scala/com/dimafeng/testcontainers/MongoDBContainer.scala @@ -1,30 +1,29 @@ package com.dimafeng.testcontainers -import org.testcontainers.containers.{MongoDBContainer => JavaMongoDBContainer} +import org.testcontainers.mongodb.{MongoDBContainer => JavaMongoDBContainer} import org.testcontainers.utility.DockerImageName case class MongoDBContainer( - tag: Option[DockerImageName] = None + tag: DockerImageName = DockerImageName.parse(MongoDBContainer.defaultImageName) ) extends SingleContainer[JavaMongoDBContainer] { - override val container: JavaMongoDBContainer = tag match { - case Some(tag) => new JavaMongoDBContainer(tag) - case None => new JavaMongoDBContainer() - } + override val container: JavaMongoDBContainer = new JavaMongoDBContainer(tag) def replicaSetUrl: String = container.getReplicaSetUrl } object MongoDBContainer { - def apply(tag: DockerImageName): MongoDBContainer = new MongoDBContainer(Option(tag)) + val defaultImageName = "mongo" + + def apply(tag: DockerImageName = DockerImageName.parse(MongoDBContainer.defaultImageName)): MongoDBContainer = new MongoDBContainer(tag) case class Def( - tag: DockerImageName = null + tag: DockerImageName = DockerImageName.parse(MongoDBContainer.defaultImageName) ) extends ContainerDef { override type Container = MongoDBContainer - override def createContainer(): MongoDBContainer = new MongoDBContainer(Option(tag)) + override def createContainer(): MongoDBContainer = new MongoDBContainer(tag) } } diff --git a/modules/mongodb/src/test/scala/com/dimafeng/testcontainers/integration/MongoSpec.scala b/modules/mongodb/src/test/scala/com/dimafeng/testcontainers/integration/MongoSpec.scala index efd0c4ed..f3323df3 100644 --- a/modules/mongodb/src/test/scala/com/dimafeng/testcontainers/integration/MongoSpec.scala +++ b/modules/mongodb/src/test/scala/com/dimafeng/testcontainers/integration/MongoSpec.scala @@ -3,11 +3,12 @@ package com.dimafeng.testcontainers.integration import com.dimafeng.testcontainers.{Container, ForAllTestContainer, MongoDBContainer, MultipleContainers} import org.scalatest.flatspec.AnyFlatSpec import org.scalatest.matchers.should.Matchers +import org.testcontainers.utility.DockerImageName class MongoSpec extends AnyFlatSpec with ForAllTestContainer with Matchers { private val mongoDefault = MongoDBContainer() - private val mongo = MongoDBContainer("mongo:4.0.10") + private val mongo = MongoDBContainer(DockerImageName.parse("mongo:4.0.10")) override val container: Container = MultipleContainers( mongoDefault, mongo diff --git a/modules/mssqlserver/src/main/scala/com/dimafeng/testcontainers/MSSQLServerContainer.scala b/modules/mssqlserver/src/main/scala/com/dimafeng/testcontainers/MSSQLServerContainer.scala index f8e02902..b475f759 100644 --- a/modules/mssqlserver/src/main/scala/com/dimafeng/testcontainers/MSSQLServerContainer.scala +++ b/modules/mssqlserver/src/main/scala/com/dimafeng/testcontainers/MSSQLServerContainer.scala @@ -1,6 +1,6 @@ package com.dimafeng.testcontainers -import org.testcontainers.containers.{MSSQLServerContainer => JavaMSSQLServerContainer} +import org.testcontainers.mssqlserver.{MSSQLServerContainer => JavaMSSQLServerContainer} import org.testcontainers.utility.DockerImageName import scala.concurrent.duration._ @@ -10,10 +10,10 @@ case class MSSQLServerContainer( dbPassword: String = MSSQLServerContainer.defaultPassword, urlParams: Map[String, String] = Map.empty, commonJdbcParams: JdbcDatabaseContainer.CommonParams = MSSQLServerContainer.defaultCommonJdbcParams -) extends SingleContainer[JavaMSSQLServerContainer[?]] with JdbcDatabaseContainer { +) extends SingleContainer[JavaMSSQLServerContainer] with JdbcDatabaseContainer { - override val container: JavaMSSQLServerContainer[?] = { - val c: JavaMSSQLServerContainer[?] = new JavaMSSQLServerContainer(dockerImageName) + override val container: JavaMSSQLServerContainer = { + val c: JavaMSSQLServerContainer = new JavaMSSQLServerContainer(dockerImageName) c.withPassword(dbPassword) urlParams.foreach { case (key, value) => @@ -29,7 +29,7 @@ case class MSSQLServerContainer( object MSSQLServerContainer { - val defaultDockerImageName = s"${JavaMSSQLServerContainer.IMAGE}:${JavaMSSQLServerContainer.DEFAULT_TAG}" + val defaultDockerImageName = "mcr.microsoft.com/mssql/server" val defaultPassword = "A_Str0ng_Required_Password" val defaultCommonJdbcParams: JdbcDatabaseContainer.CommonParams = JdbcDatabaseContainer.CommonParams().copy( startupTimeout = 240.seconds, diff --git a/modules/mysql/src/main/scala/com/dimafeng/testcontainers/MySQLContainer.scala b/modules/mysql/src/main/scala/com/dimafeng/testcontainers/MySQLContainer.scala index bc05566c..51d79987 100644 --- a/modules/mysql/src/main/scala/com/dimafeng/testcontainers/MySQLContainer.scala +++ b/modules/mysql/src/main/scala/com/dimafeng/testcontainers/MySQLContainer.scala @@ -1,6 +1,6 @@ package com.dimafeng.testcontainers -import org.testcontainers.containers.{MySQLContainer => JavaMySQLContainer} +import org.testcontainers.mysql.{MySQLContainer => JavaMySQLContainer} import org.testcontainers.utility.DockerImageName class MySQLContainer( @@ -11,10 +11,10 @@ class MySQLContainer( mysqlPassword: Option[String] = None, urlParams: Map[String, String] = Map.empty, commonJdbcParams: JdbcDatabaseContainer.CommonParams = JdbcDatabaseContainer.CommonParams() -) extends SingleContainer[JavaMySQLContainer[?]] with JdbcDatabaseContainer { +) extends SingleContainer[JavaMySQLContainer] with JdbcDatabaseContainer { - override val container: JavaMySQLContainer[?] = { - val c: JavaMySQLContainer[?] = mysqlImageVersion + override val container: JavaMySQLContainer = { + val c: JavaMySQLContainer = mysqlImageVersion .map(new JavaMySQLContainer(_)) .getOrElse(new JavaMySQLContainer(MySQLContainer.DEFAULT_MYSQL_VERSION)) @@ -38,7 +38,7 @@ class MySQLContainer( object MySQLContainer { - val defaultDockerImageName = s"${JavaMySQLContainer.IMAGE}:${JavaMySQLContainer.DEFAULT_TAG}" + val defaultDockerImageName = "mysql" val defaultDatabaseName = "test" val defaultUsername = "test" val defaultPassword = "test" diff --git a/modules/neo4j/src/main/scala/com/dimafeng/testcontainers/Neo4jContainer.scala b/modules/neo4j/src/main/scala/com/dimafeng/testcontainers/Neo4jContainer.scala index 606420b9..7537027a 100644 --- a/modules/neo4j/src/main/scala/com/dimafeng/testcontainers/Neo4jContainer.scala +++ b/modules/neo4j/src/main/scala/com/dimafeng/testcontainers/Neo4jContainer.scala @@ -1,14 +1,14 @@ package com.dimafeng.testcontainers -import org.testcontainers.containers.{Neo4jContainer => JavaNeo4jContainer} +import org.testcontainers.neo4j.{Neo4jContainer => JavaNeo4jContainer} import org.testcontainers.utility.DockerImageName class Neo4jContainer(configurationOverride: Option[String] = None, neo4jImageVersion: Option[DockerImageName] = None, neo4jPassword: Option[String] = None) - extends SingleContainer[JavaNeo4jContainer[?]] { + extends SingleContainer[JavaNeo4jContainer] { - override val container: JavaNeo4jContainer[?] = neo4jImageVersion + override val container: JavaNeo4jContainer = neo4jImageVersion .map(new JavaNeo4jContainer(_)) .getOrElse(new JavaNeo4jContainer(Neo4jContainer.DEFAULT_NEO4J_VERSION)) diff --git a/modules/nginx/src/main/scala/com/dimafeng/testcontainers/NginxContainer.scala b/modules/nginx/src/main/scala/com/dimafeng/testcontainers/NginxContainer.scala index 4869a9b0..3ea9d6d0 100644 --- a/modules/nginx/src/main/scala/com/dimafeng/testcontainers/NginxContainer.scala +++ b/modules/nginx/src/main/scala/com/dimafeng/testcontainers/NginxContainer.scala @@ -1,18 +1,14 @@ package com.dimafeng.testcontainers import java.net.URL - -import org.testcontainers.containers.{NginxContainer => JavaNginxContainer} +import org.testcontainers.nginx.{NginxContainer => JavaNginxContainer} +import org.testcontainers.utility.DockerImageName case class NginxContainer( - customContent: Option[String] = None -) extends SingleContainer[JavaNginxContainer[?]] { + tag: DockerImageName, +) extends SingleContainer[JavaNginxContainer] { - override val container: JavaNginxContainer[?] = { - val c: JavaNginxContainer[?] = new JavaNginxContainer() - customContent.foreach(c.withCustomContent) - c - } + override val container: JavaNginxContainer = new JavaNginxContainer(tag) def baseUrl(scheme: String, port: Int): URL = container.getBaseUrl(scheme, port) } @@ -20,14 +16,14 @@ case class NginxContainer( object NginxContainer { case class Def( - customContent: Option[String] = None + tag: DockerImageName ) extends ContainerDef { override type Container = NginxContainer override def createContainer(): NginxContainer = { new NginxContainer( - customContent + tag ) } } diff --git a/modules/orientdb/src/main/scala/com/dimafeng/testcontainers/OrientDBContainer.scala b/modules/orientdb/src/main/scala/com/dimafeng/testcontainers/OrientDBContainer.scala index 20391b76..1950150d 100644 --- a/modules/orientdb/src/main/scala/com/dimafeng/testcontainers/OrientDBContainer.scala +++ b/modules/orientdb/src/main/scala/com/dimafeng/testcontainers/OrientDBContainer.scala @@ -1,14 +1,14 @@ package com.dimafeng.testcontainers -import com.orientechnologies.orient.core.db.{ODatabaseSession, OrientDB} -import org.testcontainers.containers.{OrientDBContainer => JavaOrientDBContainer} +import org.testcontainers.images.builder.Transferable +import org.testcontainers.orientdb.{OrientDBContainer => JavaOrientDBContainer} import org.testcontainers.utility.DockerImageName case class OrientDBContainer( dockerImageName: DockerImageName = DockerImageName.parse(OrientDBContainer.defaultDockerImageName), databaseName: String = OrientDBContainer.defaultDatabaseName, serverPassword: String = OrientDBContainer.defaultServerPassword, - scriptPath: Option[String] = None + scriptPath: Option[Transferable] = None ) extends SingleContainer[JavaOrientDBContainer] { override val container: JavaOrientDBContainer = { @@ -19,17 +19,10 @@ case class OrientDBContainer( c } - def testQueryString: String = container.getTestQueryString - - def orientDB: OrientDB = container.getOrientDB - def serverUrl: String = container.getServerUrl def dbUrl: String = container.getDbUrl - - def session: ODatabaseSession = container.getSession - - def session(username: String, password: String): ODatabaseSession = container.getSession(username, password) + } object OrientDBContainer { @@ -42,7 +35,7 @@ object OrientDBContainer { dockerImageName: DockerImageName = DockerImageName.parse(OrientDBContainer.defaultDockerImageName), databaseName: String = OrientDBContainer.defaultDatabaseName, serverPassword: String = OrientDBContainer.defaultServerPassword, - scriptPath: Option[String] = None + scriptPath: Option[Transferable] = None ) extends ContainerDef { override type Container = OrientDBContainer diff --git a/modules/postgres/src/main/scala/com/dimafeng/testcontainers/PostgreSQLContainer.scala b/modules/postgres/src/main/scala/com/dimafeng/testcontainers/PostgreSQLContainer.scala index d6244120..e7e4e529 100644 --- a/modules/postgres/src/main/scala/com/dimafeng/testcontainers/PostgreSQLContainer.scala +++ b/modules/postgres/src/main/scala/com/dimafeng/testcontainers/PostgreSQLContainer.scala @@ -1,6 +1,6 @@ package com.dimafeng.testcontainers -import org.testcontainers.containers.{PostgreSQLContainer => JavaPostgreSQLContainer} +import org.testcontainers.postgresql.{PostgreSQLContainer => JavaPostgreSQLContainer} import org.testcontainers.utility.DockerImageName class PostgreSQLContainer( @@ -11,13 +11,13 @@ class PostgreSQLContainer( mountPostgresDataToTmpfs: Boolean = false, urlParams: Map[String, String] = Map.empty, commonJdbcParams: JdbcDatabaseContainer.CommonParams = JdbcDatabaseContainer.CommonParams() -) extends SingleContainer[JavaPostgreSQLContainer[?]] with JdbcDatabaseContainer { +) extends SingleContainer[JavaPostgreSQLContainer] with JdbcDatabaseContainer { import PostgreSQLContainer._ - override val container: JavaPostgreSQLContainer[?] = { + override val container: JavaPostgreSQLContainer = { val dockerImageName = dockerImageNameOverride.getOrElse(parsedDockerImageName) - val c: JavaPostgreSQLContainer[?] = new JavaPostgreSQLContainer(dockerImageName) + val c: JavaPostgreSQLContainer = new JavaPostgreSQLContainer(dockerImageName) databaseName.foreach(c.withDatabaseName) pgUsername.foreach(c.withUsername) diff --git a/modules/pulsar/src/main/scala/com/dimafeng/testcontainers/PulsarContainer.scala b/modules/pulsar/src/main/scala/com/dimafeng/testcontainers/PulsarContainer.scala index 2a7dcb30..d80be02b 100644 --- a/modules/pulsar/src/main/scala/com/dimafeng/testcontainers/PulsarContainer.scala +++ b/modules/pulsar/src/main/scala/com/dimafeng/testcontainers/PulsarContainer.scala @@ -1,6 +1,6 @@ package com.dimafeng.testcontainers -import org.testcontainers.containers.{PulsarContainer => JavaPulsarContainer} +import org.testcontainers.pulsar.{PulsarContainer => JavaPulsarContainer} case class PulsarContainer( tag: String = PulsarContainer.defaultTag diff --git a/modules/rabbitmq/src/main/scala/com/dimafeng/testcontainers/RabbitMQContainer.scala b/modules/rabbitmq/src/main/scala/com/dimafeng/testcontainers/RabbitMQContainer.scala index ec75a727..b4de84d9 100644 --- a/modules/rabbitmq/src/main/scala/com/dimafeng/testcontainers/RabbitMQContainer.scala +++ b/modules/rabbitmq/src/main/scala/com/dimafeng/testcontainers/RabbitMQContainer.scala @@ -1,23 +1,11 @@ package com.dimafeng.testcontainers -import org.testcontainers.containers.{RabbitMQContainer => JavaRabbitMQContainer} +import org.testcontainers.rabbitmq.{RabbitMQContainer => JavaRabbitMQContainer} import org.testcontainers.utility.{DockerImageName, MountableFile} case class RabbitMQContainer( dockerImageName: DockerImageName = DockerImageName.parse(RabbitMQContainer.defaultDockerImageName), adminPassword: String = RabbitMQContainer.defaultAdminPassword, - queues: Seq[RabbitMQContainer.Queue] = Seq.empty, - exchanges: Seq[RabbitMQContainer.Exchange] = Seq.empty, - bindings: Seq[RabbitMQContainer.Binding] = Seq.empty, - users: Seq[RabbitMQContainer.User] = Seq.empty, - vhosts: Seq[RabbitMQContainer.VHost] = Seq.empty, - vhostsLimits: Seq[RabbitMQContainer.VHostLimit] = Seq.empty, - operatorPolicies: Seq[RabbitMQContainer.OperatorPolicy] = Seq.empty, - policies: Seq[RabbitMQContainer.Policy] = Seq.empty, - parameters: Seq[RabbitMQContainer.Parameter] = Seq.empty, - permissions: Seq[RabbitMQContainer.Permission] = Seq.empty, - pluginsEnabled: Seq[String] = Seq.empty, - ssl: Option[RabbitMQContainer.SslConfig] = None, rabbitMqConfig: Option[MountableFile] = None, rabbitMqConfigErlang: Option[MountableFile] = None, rabbitMqConfigSysctl: Option[MountableFile] = None @@ -30,64 +18,6 @@ case class RabbitMQContainer( c.withAdminPassword(adminPassword) - vhosts.foreach { - case RabbitMQContainer.VHost(name, Some(tracing)) => c.withVhost(name, tracing) - case RabbitMQContainer.VHost(name, None) => c.withVhost(name) - } - - vhostsLimits.foreach { x => - c.withVhostLimit(x.vhost, x.name, x.value) - } - - queues.foreach { x => - c.withQueue(x.name, x.autoDelete, x.durable, toJavaArguments(x.arguments)) - } - - exchanges.foreach { x => - x.vhost match { - case Some(vhost) => - c.withExchange(vhost, x.name, x.exchangeType, x.autoDelete, x.internal, x.durable, toJavaArguments(x.arguments)) - case None => - c.withExchange(x.name, x.exchangeType, x.autoDelete, x.internal, x.durable, toJavaArguments(x.arguments)) - } - } - - bindings.foreach { x => - c.withBinding(x.source, x.destination, toJavaArguments(x.arguments), x.routingKey, x.destinationType) - } - - users.foreach { x => - if (x.tags.isEmpty) c.withUser(x.name, x.password) else c.withUser(x.name, x.password, x.tags.asJava) - } - - operatorPolicies.foreach { x => - c.withOperatorPolicy(x.name, x.pattern, toJavaArguments(x.definition), x.priority, x.applyTo) - } - - policies.foreach { x => - c.withPolicy(x.name, x.pattern, toJavaArguments(x.definition), x.priority, x.applyTo) - } - - parameters.foreach { x => - c.withParameter(x.component, x.name, x.value) - } - - permissions.foreach { x => - c.withPermission(x.vhost, x.user, x.configure, x.write, x.read) - } - - if (pluginsEnabled.nonEmpty) c.withPluginsEnabled(pluginsEnabled: _*) - - ssl.foreach { x => - c.withSSL(x.keyFile, x.certFile, x.caFile, x.verify) - x.failIfNoCert.foreach { xx => - c.withEnv("RABBITMQ_SSL_FAIL_IF_NO_PEER_CERT", String.valueOf(xx)) - } - x.verificationDepth foreach { xx => - c.withEnv("RABBITMQ_SSL_DEPTH", String.valueOf(xx)) - } - } - rabbitMqConfig.foreach(c.withRabbitMQConfig) rabbitMqConfigErlang.foreach(c.withRabbitMQConfigErlang) rabbitMqConfigSysctl.foreach(c.withRabbitMQConfigSysctl) @@ -119,104 +49,9 @@ object RabbitMQContainer { val defaultDockerImageName = s"$defaultImage:$defaultTag" val defaultAdminPassword = "guest" - type SslVerification = JavaRabbitMQContainer.SslVerification - - case class Queue( - name: String, - autoDelete: Boolean = false, - durable: Boolean = true, - arguments: Map[String, String] = Map.empty - ) - - case class Exchange( - name: String, - exchangeType: String, - autoDelete: Boolean = false, - internal: Boolean = false, - durable: Boolean = true, - arguments: Map[String, String] = Map.empty, - vhost: Option[String] = None - ) - - case class Binding( - source: String, - destination: String, - routingKey: String = "", - destinationType: String = "queue", - arguments: Map[String, String] = Map.empty - ) - - case class OperatorPolicy( - name: String, - pattern: String, - definition: Map[String, String], - priority: Int = 0, - applyTo: String = "" - ) - - case class Policy( - name: String, - pattern: String, - definition: Map[String, String], - priority: Int = 0, - applyTo: String = "" - ) - - case class Parameter( - component: String, - name: String, - value: String - ) - - case class Permission( - vhost: String, - user: String, - configure: String, - write: String, - read: String - ) - - case class User( - name: String, - password: String, - tags: Set[String] = Set.empty - ) - - case class VHost( - name: String, - tracing: Option[Boolean] = None - ) - - case class VHostLimit( - vhost: String, - name: String, - value: Int - ) - - case class SslConfig( - keyFile: MountableFile, - certFile: MountableFile, - caFile: MountableFile, - verify: RabbitMQContainer.SslVerification, - failIfNoCert: Option[Boolean] = None, - verificationDepth: Option[Int] = None - ) - case class Def( dockerImageName: DockerImageName = DockerImageName.parse(RabbitMQContainer.defaultDockerImageName), adminPassword: String = RabbitMQContainer.defaultAdminPassword, - queues: Seq[RabbitMQContainer.Queue] = Seq.empty, - exchanges: Seq[RabbitMQContainer.Exchange] = Seq.empty, - bindings: Seq[RabbitMQContainer.Binding] = Seq.empty, - users: Seq[RabbitMQContainer.User] = Seq.empty, - vhosts: Seq[RabbitMQContainer.VHost] = Seq.empty, - vhostsLimits: Seq[RabbitMQContainer.VHostLimit] = Seq.empty, - operatorPolicies: Seq[RabbitMQContainer.OperatorPolicy] = Seq.empty, - policies: Seq[RabbitMQContainer.Policy] = Seq.empty, - parameters: Seq[RabbitMQContainer.Parameter] = Seq.empty, - permissions: Seq[RabbitMQContainer.Permission] = Seq.empty, - pluginsEnabled: Seq[String] = Seq.empty, - ssl: Option[RabbitMQContainer.SslConfig] = None, rabbitMqConfig: Option[MountableFile] = None, rabbitMqConfigErlang: Option[MountableFile] = None, rabbitMqConfigSysctl: Option[MountableFile] = None @@ -228,18 +63,6 @@ object RabbitMQContainer { new RabbitMQContainer( dockerImageName, adminPassword, - queues, - exchanges, - bindings, - users, - vhosts, - vhostsLimits, - operatorPolicies, - policies, - parameters, - permissions, - pluginsEnabled, - ssl, rabbitMqConfig, rabbitMqConfigErlang, rabbitMqConfigSysctl diff --git a/modules/rabbitmq/src/test/scala/com/dimafeng/testcontainers/RabbitMQSpec.scala b/modules/rabbitmq/src/test/scala/com/dimafeng/testcontainers/RabbitMQSpec.scala index 333482c3..cffcaea0 100644 --- a/modules/rabbitmq/src/test/scala/com/dimafeng/testcontainers/RabbitMQSpec.scala +++ b/modules/rabbitmq/src/test/scala/com/dimafeng/testcontainers/RabbitMQSpec.scala @@ -1,20 +1,14 @@ package com.dimafeng.testcontainers -import com.dimafeng.testcontainers.RabbitMQContainer.{Exchange, Permission, User, VHost} import org.scalatest.flatspec.AnyFlatSpec import org.scalatest.matchers.should.Matchers -import org.testcontainers.utility.DockerImageName import sttp.client3.{HttpURLConnectionBackend, UriContext, basicRequest} -import scala.util.Either - class RabbitMQSpec extends AnyFlatSpec with ForAllTestContainer with Matchers { import RabbitMQSpec._ override val container: Container = MultipleContainers( defaultRabbitContainer, - customRabbitContainer, - customRabbitContainerViaDef ) "Default Rabbit container" should "start" in { @@ -34,130 +28,13 @@ class RabbitMQSpec extends AnyFlatSpec with ForAllTestContainer with Matchers { } - "Custom Rabbit container" should "start and load exchanges config" in { - val baseUri = customRabbitContainer.httpUrl - val request = - basicRequest - .auth.basic(testUsername, testPassword) - .get(uri"$baseUri/api/exchanges") - - val eitherExchangeWasLoaded = - request.send(httpClientBackend).body match { - case Right(v) => Right(v.contains(testExchange)) - case e@Left(_) => e - } - - assertResult(Right(true))(eitherExchangeWasLoaded) - } - - "Custom Rabbit container" should "start and load users config" in { - val baseUri = customRabbitContainer.httpUrl - val request = - basicRequest - .auth.basic(testUsername, testPassword) - .get(uri"$baseUri/api/users") - - val eitherUserWasLoaded = - request.send(httpClientBackend).body match { - case Right(v) => Right(v.contains(testUsername)) - case e@Left(_) => e - } - - assertResult(Right(true))(eitherUserWasLoaded) - } - - "Custom Rabbit container" should "start and load users config (Via .Def)" in { - val baseUri = customRabbitContainerViaDef.httpUrl - val request = - basicRequest - .auth.basic(testUsername, testPassword) - .get(uri"$baseUri/api/users") - - val eitherUserWasLoaded = - request.send(httpClientBackend).body match { - case Right(v) => Right(v.contains(testUsername)) - case e@Left(_) => e - } - - assertResult(Right(true))(eitherUserWasLoaded) - } } object RabbitMQSpec { - val testExchange = "test-exchange" - val testUsername = "test-user" - val testPassword = "test-password" - val httpClientBackend = HttpURLConnectionBackend() + private val testExchange = "test-exchange" + private val testUsername = "test-user" + private val testPassword = "test-password" + private val httpClientBackend = HttpURLConnectionBackend() - val defaultRabbitContainer: RabbitMQContainer = RabbitMQContainer() - val customRabbitContainer: RabbitMQContainer = RabbitMQContainer( - dockerImageName = DockerImageName.parse(RabbitMQContainer.defaultDockerImageName), - adminPassword = RabbitMQContainer.defaultAdminPassword, - queues = Seq.empty, - exchanges = Seq( - Exchange( - name = testExchange, - exchangeType = "direct", - arguments = Map.empty, - vhost = Some("test-vhost") - ) - ), - bindings = Seq.empty, - users = Seq( - User( - name = testUsername, - password = testPassword, - tags = Set("administrator") - ) - ), - vhosts = Seq(VHost(name = "test-vhost")), - vhostsLimits = Seq.empty, - operatorPolicies = Seq.empty, - policies = Seq.empty, - parameters = Seq.empty, - permissions = Seq( - Permission( - vhost = "test-vhost", - user = testUsername, - configure = ".*", - write = ".*", - read = ".*" - ) - ) - ) - val customRabbitContainerViaDef = RabbitMQContainer.Def( - dockerImageName = DockerImageName.parse(RabbitMQContainer.defaultDockerImageName), - adminPassword = RabbitMQContainer.defaultAdminPassword, - queues = Seq.empty, - exchanges = Seq( - Exchange( - name = testExchange, - exchangeType = "direct", - arguments = Map.empty, - vhost = Some("test-vhost") - ) - ), - bindings = Seq.empty, - users = Seq( - User( - name = testUsername, - password = testPassword, - tags = Set("administrator") - ) - ), - vhosts = Seq(VHost(name = "test-vhost")), - vhostsLimits = Seq.empty, - operatorPolicies = Seq.empty, - policies = Seq.empty, - parameters = Seq.empty, - permissions = Seq( - Permission( - vhost = "test-vhost", - user = testUsername, - configure = ".*", - write = ".*", - read = ".*" - ) - ) - ).createContainer() + private val defaultRabbitContainer: RabbitMQContainer = RabbitMQContainer() } diff --git a/modules/solr/src/main/scala/com/dimafeng/testcontainers/SolrContainer.scala b/modules/solr/src/main/scala/com/dimafeng/testcontainers/SolrContainer.scala index 5bd3b1a5..5d70d685 100644 --- a/modules/solr/src/main/scala/com/dimafeng/testcontainers/SolrContainer.scala +++ b/modules/solr/src/main/scala/com/dimafeng/testcontainers/SolrContainer.scala @@ -2,7 +2,8 @@ package com.dimafeng.testcontainers import java.net.URL -import org.testcontainers.containers.{SolrContainerConfiguration, SolrContainer => JavaSolrContainer} +import org.testcontainers.containers.SolrContainerConfiguration +import org.testcontainers.solr.{SolrContainer => JavaSolrContainer} import org.testcontainers.utility.DockerImageName case class SolrContainer( diff --git a/modules/toxiproxy/src/main/scala/com/dimafeng/testcontainers/ToxiproxyContainer.scala b/modules/toxiproxy/src/main/scala/com/dimafeng/testcontainers/ToxiproxyContainer.scala index b2896d3e..e071fa43 100644 --- a/modules/toxiproxy/src/main/scala/com/dimafeng/testcontainers/ToxiproxyContainer.scala +++ b/modules/toxiproxy/src/main/scala/com/dimafeng/testcontainers/ToxiproxyContainer.scala @@ -1,27 +1,20 @@ package com.dimafeng.testcontainers -import org.testcontainers.containers.{ToxiproxyContainer => JavaToxiproxyContainer} +import org.testcontainers.toxiproxy.{ToxiproxyContainer => JavaToxiproxyContainer} import org.testcontainers.utility.DockerImageName case class ToxiproxyContainer( dockerImageName: DockerImageName = DockerImageName.parse(ToxiproxyContainer.defaultDockerImageName) ) extends SingleContainer[JavaToxiproxyContainer] { - import ToxiproxyContainer._ - override val container: JavaToxiproxyContainer = new JavaToxiproxyContainer(dockerImageName) - def proxy(hostname: String, port: Int): ContainerProxy = container.getProxy(hostname, port) - - def proxy(container: SingleContainer[?], port: Int): ContainerProxy = proxy(container.networkAliases.head, port) } object ToxiproxyContainer { val defaultDockerImageName = "shopify/toxiproxy:2.1.4" - type ContainerProxy = JavaToxiproxyContainer.ContainerProxy - case class Def( dockerImageName: DockerImageName = DockerImageName.parse(ToxiproxyContainer.defaultDockerImageName) ) extends ContainerDef { diff --git a/modules/toxiproxy/src/test/scala/com/dimafeng/testcontainers/ToxiproxySpec.scala b/modules/toxiproxy/src/test/scala/com/dimafeng/testcontainers/ToxiproxySpec.scala index 59339f81..c3f8a0fc 100644 --- a/modules/toxiproxy/src/test/scala/com/dimafeng/testcontainers/ToxiproxySpec.scala +++ b/modules/toxiproxy/src/test/scala/com/dimafeng/testcontainers/ToxiproxySpec.scala @@ -9,8 +9,6 @@ class ToxiproxySpec extends AnyFlatSpec with ForAllTestContainer { "Toxiproxy container" should "be started" in { assert(container.container.isRunning) assert(container.container.getExposedPorts.size > 0) - val proxy = container.proxy("127.0.0.1", 0) - assert(proxy.getProxyPort > 0) } } diff --git a/modules/trino/src/main/scala/com/dimafeng/testcontainers/TrinoContainer.scala b/modules/trino/src/main/scala/com/dimafeng/testcontainers/TrinoContainer.scala index b22a16e7..124db8d6 100644 --- a/modules/trino/src/main/scala/com/dimafeng/testcontainers/TrinoContainer.scala +++ b/modules/trino/src/main/scala/com/dimafeng/testcontainers/TrinoContainer.scala @@ -2,7 +2,7 @@ package com.dimafeng.testcontainers import java.sql.Connection -import org.testcontainers.containers.{TrinoContainer => JavaTrinoContainer} +import org.testcontainers.trino.{TrinoContainer => JavaTrinoContainer} import org.testcontainers.utility.DockerImageName case class TrinoContainer( diff --git a/project/Dependencies.scala b/project/Dependencies.scala index 468c8505..f6017dcc 100644 --- a/project/Dependencies.scala +++ b/project/Dependencies.scala @@ -12,14 +12,13 @@ object Dependencies { scope.map(s => modules.map(_ % s)).getOrElse(modules) } - private val testcontainersVersion = "1.21.1" + private val testcontainersVersion = "2.0.2" private val seleniumVersion = "2.53.1" private val slf4jVersion = "2.0.17" private val scalaTestVersion = "3.2.9" private val scalaTestMockitoVersion = "3.2.9.0" private val scalaTestSeleniumVersion_scala2 = "3.2.2.0" private val scalaTestSeleniumVersion_scala3 = "3.2.9.0" - private val junitVersion = "4.13.2" private val munitVersion = "1.1.1" private val specs2Version = Def.setting { @@ -33,7 +32,7 @@ object Dependencies { private val oracleDriverVersion = "21.18.0.0" private val cassandraDriverVersion = "4.0.1" private val postgresqlDriverVersion = "42.7.7" - private val kafkaDriverVersion = "2.2.0" + private val kafkaDriverVersion = "4.1.0" private val mockitoVersion = "3.12.4" private val restAssuredVersion = "4.0.0" private val groovyVersion = "2.5.16" @@ -64,14 +63,13 @@ object Dependencies { ) ++ PROVIDED( "org.slf4j" % "slf4j-simple" % slf4jVersion ) ++ TEST( - "junit" % "junit" % junitVersion, "org.scalatest" %% "scalatest" % scalaTestVersion, "org.scalatestplus" %% "mockito-3-4" % scalaTestMockitoVersion, "org.scalatestplus" %% "selenium-3-141" % (CrossVersion.partialVersion(scalaVersion.value) match { case Some((2, _)) => scalaTestSeleniumVersion_scala2 case _ => scalaTestSeleniumVersion_scala3 }), - "org.testcontainers" % "selenium" % testcontainersVersion, + "org.testcontainers" % "testcontainers-selenium" % testcontainersVersion, "org.postgresql" % "postgresql" % postgresqlDriverVersion, "org.mockito" % "mockito-core" % mockitoVersion ) @@ -99,20 +97,20 @@ object Dependencies { val scalatestSelenium = Def.setting( COMPILE( - "org.testcontainers" % "selenium" % testcontainersVersion, + "org.testcontainers" % "testcontainers-selenium" % testcontainersVersion, "org.seleniumhq.selenium" % "selenium-java" % seleniumVersion ) ) val jdbc = Def.setting( COMPILE( - "org.testcontainers" % "jdbc" % testcontainersVersion + "org.testcontainers" % "testcontainers-jdbc" % testcontainersVersion ) ) val moduleMysql = Def.setting( COMPILE( - "org.testcontainers" % "mysql" % testcontainersVersion + "org.testcontainers" % "testcontainers-mysql" % testcontainersVersion ) ++ TEST( "mysql" % "mysql-connector-java" % mysqlConnectorVersion ) @@ -120,14 +118,14 @@ object Dependencies { val moduleNeo4j = Def.setting( COMPILE( - "org.testcontainers" % "neo4j" % testcontainersVersion + "org.testcontainers" % "testcontainers-neo4j" % testcontainersVersion ) ++ TEST( "org.neo4j.driver" % "neo4j-java-driver" % neo4jConnectorVersion ) ) val modulePostgres = Def.setting( COMPILE( - "org.testcontainers" % "postgresql" % testcontainersVersion + "org.testcontainers" % "testcontainers-postgresql" % testcontainersVersion ) ++ TEST( "org.postgresql" % "postgresql" % postgresqlDriverVersion ) @@ -135,7 +133,7 @@ object Dependencies { val moduleOracle = Def.setting( COMPILE( - "org.testcontainers" % "oracle-xe" % testcontainersVersion + "org.testcontainers" % "testcontainers-oracle-xe" % testcontainersVersion ) ++ TEST( "com.oracle.database.jdbc" % "ojdbc8" % oracleDriverVersion ) @@ -143,7 +141,7 @@ object Dependencies { val moduleCassandra = Def.setting( COMPILE( - "org.testcontainers" % "cassandra" % testcontainersVersion + "org.testcontainers" % "testcontainers-cassandra" % testcontainersVersion ) ++ TEST( "com.datastax.oss" % "java-driver-core" % cassandraDriverVersion ) @@ -151,15 +149,16 @@ object Dependencies { val moduleKafka = Def.setting( COMPILE( - "org.testcontainers" % "kafka" % testcontainersVersion + "org.testcontainers" % "testcontainers-kafka" % testcontainersVersion ) ++ TEST( - "org.apache.kafka" % "kafka-clients" % kafkaDriverVersion + "org.apache.kafka" % "kafka-clients" % kafkaDriverVersion, + "io.confluent" % "kafka-schema-registry-client" % "8.0.0" ) ) val moduleVault = Def.setting( COMPILE( - "org.testcontainers" % "vault" % testcontainersVersion + "org.testcontainers" % "testcontainers-vault" % testcontainersVersion ) ++ TEST( ("io.rest-assured" % "scala-support" % restAssuredVersion) .exclude("org.codehaus.groovy", "groovy"), @@ -169,13 +168,13 @@ object Dependencies { val moduleMssqlserver = Def.setting( COMPILE( - "org.testcontainers" % "mssqlserver" % testcontainersVersion + "org.testcontainers" % "testcontainers-mssqlserver" % testcontainersVersion ) ) val moduleClickhouse = Def.setting( COMPILE( - "org.testcontainers" % "clickhouse" % testcontainersVersion + "org.testcontainers" % "testcontainers-clickhouse" % testcontainersVersion ) ++ TEST( "ru.yandex.clickhouse" % "clickhouse-jdbc" % "0.3.2", ) @@ -183,39 +182,31 @@ object Dependencies { val moduleCockroachdb = Def.setting( COMPILE( - "org.testcontainers" % "cockroachdb" % testcontainersVersion + "org.testcontainers" % "testcontainers-cockroachdb" % testcontainersVersion ) ) val moduleCouchbase = Def.setting( COMPILE( - "org.testcontainers" % "couchbase" % testcontainersVersion + "org.testcontainers" % "testcontainers-couchbase" % testcontainersVersion ) ) val moduleDb2 = Def.setting( COMPILE( - "org.testcontainers" % "db2" % testcontainersVersion - ) - ) - - val moduleDynalite = Def.setting( - COMPILE( - "org.testcontainers" % "dynalite" % testcontainersVersion - ) ++ PROVIDED( - "com.amazonaws" % "aws-java-sdk-dynamodb" % awsV1Version + "org.testcontainers" % "testcontainers-db2" % testcontainersVersion ) ) val moduleElasticsearch = Def.setting( COMPILE( - "org.testcontainers" % "elasticsearch" % testcontainersVersion + "org.testcontainers" % "testcontainers-elasticsearch" % testcontainersVersion ) ) val moduleInfluxdb = Def.setting( COMPILE( - "org.testcontainers" % "influxdb" % testcontainersVersion + "org.testcontainers" % "testcontainers-influxdb" % testcontainersVersion ) ++ PROVIDED( "org.influxdb" % "influxdb-java" % "2.24" ) @@ -223,7 +214,7 @@ object Dependencies { val moduleLocalstack = Def.setting( COMPILE( - "org.testcontainers" % "localstack" % testcontainersVersion + "org.testcontainers" % "testcontainers-localstack" % testcontainersVersion ) ++ PROVIDED( "com.amazonaws" % "aws-java-sdk-s3" % awsV1Version, "com.amazonaws" % "aws-java-sdk-sqs" % awsV1Version @@ -232,7 +223,7 @@ object Dependencies { val moduleLocalstackV2 = Def.setting( COMPILE( - "org.testcontainers" % "localstack" % testcontainersVersion + "org.testcontainers" % "testcontainers-localstack" % testcontainersVersion ) ++ PROVIDED( "software.amazon.awssdk" % "s3" % awsV2Version, "software.amazon.awssdk" % "sqs" % awsV2Version @@ -241,13 +232,13 @@ object Dependencies { val moduleMariadb = Def.setting( COMPILE( - "org.testcontainers" % "mariadb" % testcontainersVersion + "org.testcontainers" % "testcontainers-mariadb" % testcontainersVersion ) ) val moduleMilvus = Def.setting( COMPILE( - "org.testcontainers" % "milvus" % testcontainersVersion + "org.testcontainers" % "testcontainers-milvus" % testcontainersVersion ) ++ TEST( "io.milvus" % "milvus-sdk-java" % milvusSdkVersion ) @@ -255,7 +246,7 @@ object Dependencies { val moduleMockserver = Def.setting( COMPILE( - "org.testcontainers" % "mockserver" % testcontainersVersion + "org.testcontainers" % "testcontainers-mockserver" % testcontainersVersion ) ++ TEST( "com.softwaremill.sttp.client3" %% "core" % sttpVersion, "org.mock-server" % "mockserver-client-java" % "5.13.2" @@ -264,19 +255,19 @@ object Dependencies { val moduleNginx = Def.setting( COMPILE( - "org.testcontainers" % "nginx" % testcontainersVersion + "org.testcontainers" % "testcontainers-nginx" % testcontainersVersion ) ) val modulePulsar = Def.setting( COMPILE( - "org.testcontainers" % "pulsar" % testcontainersVersion + "org.testcontainers" % "testcontainers-pulsar" % testcontainersVersion ) ) val moduleQuadrant = Def.setting( COMPILE( - "org.testcontainers" % "qdrant" % testcontainersVersion + "org.testcontainers" % "testcontainers-qdrant" % testcontainersVersion ) ++ TEST( "io.qdrant" % "client" % quadrantClientVersion ) @@ -284,7 +275,7 @@ object Dependencies { val moduleRabbitmq = Def.setting( COMPILE( - "org.testcontainers" % "rabbitmq" % testcontainersVersion + "org.testcontainers" % "testcontainers-rabbitmq" % testcontainersVersion ) ++ TEST( "org.scalatest" %% "scalatest" % scalaTestVersion ) ++ PROVIDED( @@ -303,43 +294,43 @@ object Dependencies { val moduleToxiproxy = Def.setting( COMPILE( - "org.testcontainers" % "toxiproxy" % testcontainersVersion + "org.testcontainers" % "testcontainers-toxiproxy" % testcontainersVersion ) ) val moduleOrientdb = Def.setting( COMPILE( - "org.testcontainers" % "orientdb" % testcontainersVersion + "org.testcontainers" % "testcontainers-orientdb" % testcontainersVersion ) ) val modulePresto = Def.setting( COMPILE( - "org.testcontainers" % "presto" % testcontainersVersion + "org.testcontainers" % "testcontainers-presto" % testcontainersVersion ) ) val moduleTrino = Def.setting( COMPILE( - "org.testcontainers" % "trino" % testcontainersVersion + "org.testcontainers" % "testcontainers-trino" % testcontainersVersion ) ) val moduleMongodb = Def.setting( COMPILE( - "org.testcontainers" % "mongodb" % testcontainersVersion + "org.testcontainers" % "testcontainers-mongodb" % testcontainersVersion ) ) val moduleSolr = Def.setting( COMPILE( - "org.testcontainers" % "solr" % testcontainersVersion + "org.testcontainers" % "testcontainers-solr" % testcontainersVersion ) ) val moduleGcloud = Def.setting( COMPILE( - "org.testcontainers" % "gcloud" % testcontainersVersion + "org.testcontainers" % "testcontainers-gcloud" % testcontainersVersion ) ++ PROVIDED( "com.google.cloud" % "google-cloud-firestore" % firestoreConnectorVersion, @@ -350,7 +341,7 @@ object Dependencies { val moduleRedpanda = Def.setting( COMPILE( - "org.testcontainers" % "redpanda" % testcontainersVersion + "org.testcontainers" % "testcontainers-redpanda" % testcontainersVersion ) ++ TEST( "org.apache.kafka" % "kafka-clients" % kafkaDriverVersion ) @@ -358,7 +349,7 @@ object Dependencies { val moduleMinIO = Def.setting( COMPILE( - "org.testcontainers" % "minio" % testcontainersVersion + "org.testcontainers" % "testcontainers-minio" % testcontainersVersion ) ) @@ -372,7 +363,7 @@ object Dependencies { val moduleYugabytedb = Def.setting( COMPILE( - "org.testcontainers" % "yugabytedb" % testcontainersVersion + "org.testcontainers" % "testcontainers-yugabytedb" % testcontainersVersion ) ++ TEST( "com.yugabyte" % "jdbc-yugabytedb" % yugabyteJdbcVersion, "com.yugabyte" % "java-driver-core" % yugabyteJavaDriverVersion @@ -390,7 +381,7 @@ object Dependencies { val moduleK3s = Def.setting( COMPILE( - "org.testcontainers" % "k3s" % testcontainersVersion + "org.testcontainers" % "testcontainers-k3s" % testcontainersVersion ) ) } diff --git a/project/Plugins.sbt b/project/Plugins.sbt index c8f7ddfa..f7d0f91c 100644 --- a/project/Plugins.sbt +++ b/project/Plugins.sbt @@ -5,4 +5,4 @@ addSbtPlugin("com.github.sbt" % "sbt-ci-release" % "1.11.0") // Publishing. addSbtPlugin("com.github.sbt" % "sbt-pgp" % "2.3.1") -addSbtPlugin("com.github.sbt" % "sbt-release" % "1.4.0") \ No newline at end of file +addSbtPlugin("com.github.sbt" % "sbt-release" % "1.4.0") diff --git a/test-framework/munit/src/main/scala/com/dimafeng/testcontainers/munit/TestContainersSuite.scala b/test-framework/munit/src/main/scala/com/dimafeng/testcontainers/munit/TestContainersSuite.scala index ea601a07..d026c08b 100644 --- a/test-framework/munit/src/main/scala/com/dimafeng/testcontainers/munit/TestContainersSuite.scala +++ b/test-framework/munit/src/main/scala/com/dimafeng/testcontainers/munit/TestContainersSuite.scala @@ -4,7 +4,6 @@ import com.dimafeng.testcontainers.implicits.DockerImageNameConverters import com.dimafeng.testcontainers.lifecycle.{Andable, TestLifecycleAware} import com.dimafeng.testcontainers.munit.TestContainersSuite.IllegalWithContainersCall import munit.Suite -import org.junit.runner.{Description => JunitDescription} import org.testcontainers.lifecycle.TestDescription trait TestContainersSuite extends DockerImageNameConverters { self: Suite => @@ -117,16 +116,9 @@ object TestContainersSuite { ) def createDescription(suite: Suite): TestDescription = { - val description = JunitDescription.createSuiteDescription(suite.getClass) - // If we don't add the testNames and nested suites in, we get - // Unrooted Tests show up in Eclipse - for (name <- suite.munitTests()) { - description.addChild(JunitDescription.createTestDescription(suite.getClass, name.name)) - } - new TestDescription { - override def getTestId: String = description.getDisplayName - override def getFilesystemFriendlyName: String = s"${description.getClassName}-${description.getMethodName}" + override def getTestId: String = suite.getClass.getName + override def getFilesystemFriendlyName: String = suite.getClass.getName } } } \ No newline at end of file diff --git a/test-framework/scalatest/src/main/scala/com/dimafeng/testcontainers/ForAllTestContainer.scala b/test-framework/scalatest/src/main/scala/com/dimafeng/testcontainers/ForAllTestContainer.scala index fa0bd047..69b754de 100644 --- a/test-framework/scalatest/src/main/scala/com/dimafeng/testcontainers/ForAllTestContainer.scala +++ b/test-framework/scalatest/src/main/scala/com/dimafeng/testcontainers/ForAllTestContainer.scala @@ -1,7 +1,6 @@ package com.dimafeng.testcontainers import com.dimafeng.testcontainers.TestContainers.TestContainersSuite -import org.junit.runner.Description import org.scalatest._ /** diff --git a/test-framework/scalatest/src/main/scala/com/dimafeng/testcontainers/ForEachTestContainer.scala b/test-framework/scalatest/src/main/scala/com/dimafeng/testcontainers/ForEachTestContainer.scala index 889972e4..e7d5d3e1 100644 --- a/test-framework/scalatest/src/main/scala/com/dimafeng/testcontainers/ForEachTestContainer.scala +++ b/test-framework/scalatest/src/main/scala/com/dimafeng/testcontainers/ForEachTestContainer.scala @@ -1,7 +1,6 @@ package com.dimafeng.testcontainers import com.dimafeng.testcontainers.TestContainers.TestContainersSuite -import org.junit.runner.Description import org.scalatest._ /** diff --git a/test-framework/scalatest/src/main/scala/com/dimafeng/testcontainers/TestContainers.scala b/test-framework/scalatest/src/main/scala/com/dimafeng/testcontainers/TestContainers.scala index 540e5115..7fc94a2d 100644 --- a/test-framework/scalatest/src/main/scala/com/dimafeng/testcontainers/TestContainers.scala +++ b/test-framework/scalatest/src/main/scala/com/dimafeng/testcontainers/TestContainers.scala @@ -2,33 +2,18 @@ package com.dimafeng.testcontainers import com.dimafeng.testcontainers.implicits.DockerImageNameConverters import com.dimafeng.testcontainers.lifecycle.TestLifecycleAware -import org.junit.runner.{Description => JunitDescription} import org.scalatest._ import org.testcontainers.lifecycle.TestDescription private[testcontainers] object TestContainers { - implicit def junit2testContainersDescription(junit: JunitDescription): TestDescription = { + def createDescription(suite: Suite): TestDescription = { new TestDescription { - override def getTestId: String = junit.getDisplayName - override def getFilesystemFriendlyName: String = s"${junit.getClassName}-${junit.getMethodName}" + override def getTestId: String = suite.getClass.getName + override def getFilesystemFriendlyName: String = suite.getClass.getName } } - // Copy-pasted from `org.scalatest.junit.JUnitRunner.createDescription` - def createDescription(suite: Suite): JunitDescription = { - val description = JunitDescription.createSuiteDescription(suite.getClass) - // If we don't add the testNames and nested suites in, we get - // Unrooted Tests show up in Eclipse - for (name <- suite.testNames) { - description.addChild(JunitDescription.createTestDescription(suite.getClass, name)) - } - for (nestedSuite <- suite.nestedSuites) { - description.addChild(createDescription(nestedSuite)) - } - description - } - trait TestContainersSuite extends SuiteMixin with DockerImageNameConverters { self: Suite => def container: Container @@ -37,7 +22,7 @@ private[testcontainers] object TestContainers { def beforeStop(): Unit = {} - private val suiteDescription = createDescription(self) + private val suiteDescription: TestDescription = createDescription(self) private[testcontainers] def beforeTest(): Unit = { container match { diff --git a/test-framework/specs2/src/main/scala/com/dimafeng/testcontainers/specs2/TestContainersSuite.scala b/test-framework/specs2/src/main/scala/com/dimafeng/testcontainers/specs2/TestContainersSuite.scala index 13ad858d..2a1daa1b 100644 --- a/test-framework/specs2/src/main/scala/com/dimafeng/testcontainers/specs2/TestContainersSuite.scala +++ b/test-framework/specs2/src/main/scala/com/dimafeng/testcontainers/specs2/TestContainersSuite.scala @@ -3,7 +3,6 @@ package com.dimafeng.testcontainers.specs2 import com.dimafeng.testcontainers.implicits.DockerImageNameConverters import com.dimafeng.testcontainers.lifecycle.{Andable, TestLifecycleAware} import org.specs2.specification.core.SpecificationStructure -import org.junit.runner.{Description => JunitDescription} import org.testcontainers.lifecycle.TestDescription trait TestContainersSuite extends DockerImageNameConverters { self: SpecificationStructure => @@ -25,10 +24,9 @@ trait TestContainersSuite extends DockerImageNameConverters { self: Specificatio @volatile private[testcontainers] var startedContainers: Option[Containers] = None private[testcontainers] val suiteDescription: TestDescription = { - val description = JunitDescription.createSuiteDescription(self.getClass) new TestDescription { - override def getTestId: String = description.getDisplayName - override def getFilesystemFriendlyName: String = s"${description.getClassName}-${description.getMethodName}" + override def getTestId: String = self.getClass.getName + override def getFilesystemFriendlyName: String = self.getClass.getName } }