Merge branch 'main' into feature/reusable-couchbase-containers

mdelapenya · mdelapenya · commit 593e3cd59bb8 · 2025-05-15T23:07:21.000+02:00
* main: feat: support adding wait strategies as functional option (testcontainers#3161) fix(etcd): expose ports for the etcd nodes (testcontainers#3162) fix(wait): no port to wait for (testcontainers#3158) feat: add more functional options for customising containers (testcontainers#3156) docs(redpanda): update sasl authentication option to use scram sha 256 (testcontainers#3126)
diff --git a/docs/features/common_functional_options.md b/docs/features/common_functional_options.md
@@ -188,6 +188,12 @@ func (g *TestLogConsumer) Accept(l Log) {
 }
 ```
 
+#### WithLogConsumerConfig
+
+- Not available until the next release of testcontainers-go <a href="https://github.com/testcontainers/testcontainers-go"><span class="tc-version">:material-tag: main</span></a>
+
+If you need to set the log consumer config for the container, you can use `testcontainers.WithLogConsumerConfig`. This option completely replaces the existing log consumer config, including the log consumers and the log production options.
+
 #### WithLogger
 
 - Since testcontainers-go <a href="https://github.com/testcontainers/testcontainers-go/releases/tag/v0.29.0"><span class="tc-version">:material-tag: v0.29.0</span></a>
@@ -214,14 +220,36 @@ func TestHandler(t *testing.T) {
 
 Please read the [Following Container Logs](/features/follow_logs) documentation for more information about creating log consumers.
 
+#### WithAlwaysPull
+
+- Not available until the next release of testcontainers-go <a href="https://github.com/testcontainers/testcontainers-go"><span class="tc-version">:material-tag: main</span></a>
+
+If you need to pull the image before starting the container, you can use `testcontainers.WithAlwaysPull()`.
+
+#### WithImagePlatform
+
+- Not available until the next release of testcontainers-go <a href="https://github.com/testcontainers/testcontainers-go"><span class="tc-version">:material-tag: main</span></a>
+
+If you need to set the platform for a container, you can use `testcontainers.WithImagePlatform(platform string)`.
+
+#### LifecycleHooks
+
+- Not available until the next release of testcontainers-go <a href="https://github.com/testcontainers/testcontainers-go"><span class="tc-version">:material-tag: main</span></a>
+
+If you need to set the lifecycle hooks for the container, you can use `testcontainers.WithLifecycleHooks`, which replaces the existing lifecycle hooks with the new ones.
+
+You can also use `testcontainers.WithAdditionalLifecycleHooks`, which appends the new lifecycle hooks to the existing ones.
+
 #### Wait Strategies
 
-If you need to set a different wait strategy for the container, you can use `testcontainers.WithWaitStrategy` with a valid wait strategy.
+If you need to set a different wait strategy for the container, replacing the existing one, you can use `testcontainers.WithWaitStrategy` with a valid wait strategy.
 
 !!!info
     The default deadline for the wait strategy is 60 seconds.
 
-At the same time, it's possible to set a wait strategy and a custom deadline with `testcontainers.WithWaitStrategyAndDeadline`.
+At the same time, it's possible to replace the wait strategy with a new one and a custom deadline, using `testcontainers.WithWaitStrategyAndDeadline`.
+
+Finally, you can also append a wait strategy to the existing wait strategy, using `testcontainers.WithAdditionalWaitStrategy` and `testcontainers.WithAdditionalWaitStrategyAndDeadline`.
 
 #### Startup Commands
 
@@ -282,6 +310,24 @@ In the case you need to retrieve the network name, you can simply read it from t
 !!!warning
     This option is not checking whether the network exists or not. If you use a network that doesn't exist, the container will start in the default Docker network, as in the default behavior.
 
+#### WithNetworkByName
+
+- Not available until the next release of testcontainers-go <a href="https://github.com/testcontainers/testcontainers-go"><span class="tc-version">:material-tag: main</span></a>
+
+If you want to attach your containers to an already existing Docker network by its name, you can use the `network.WithNetworkName(aliases []string, networkName string)` option, which receives an alias as parameter and the network name, attaching the container to it, and setting the network alias for that network.
+
+!!!warning
+    In case the network name is `bridge`, no aliases are set. This is because network-scoped alias is supported only for containers in user defined networks.
+
+#### WithBridgeNetwork
+
+- Not available until the next release of testcontainers-go <a href="https://github.com/testcontainers/testcontainers-go"><span class="tc-version">:material-tag: main</span></a>
+
+If you want to attach your containers to the `bridge` network, you can use the `network.WithBridgeNetwork()` option.
+
+!!!warning
+    The `bridge` network is the default network for Docker. It's not a user defined network, so it doesn't support network-scoped aliases.
+
 #### WithNewNetwork
 
 - Since testcontainers-go <a href="https://github.com/testcontainers/testcontainers-go/releases/tag/v0.27.0"><span class="tc-version">:material-tag: v0.27.0</span></a>
@@ -335,3 +381,27 @@ ctr, err := mymodule.Run(ctx, "docker.io/myservice:1.2.3",
 
 !!!warning
     Reusing a container is experimental and the API is subject to change for a more robust implementation that is not based on container names.
+
+#### WithName
+
+- Not available until the next release of testcontainers-go <a href="https://github.com/testcontainers/testcontainers-go"><span class="tc-version">:material-tag: main</span></a>
+
+If you need to set the name of the container, you can use the `testcontainers.WithName` option.
+
+```golang
+ctr, err := mymodule.Run(ctx, "docker.io/myservice:1.2.3", 
+    testcontainers.WithName("my-container-name"),
+)
+```
+
+!!!warning
+    This option is not checking whether the container name is already in use. If you use a name that is already in use, an error is returned.
+    At the same time, we discourage using this option as it might lead to unexpected behavior, but we understand that in some cases it might be useful.
+
+#### WithNoStart
+
+- Not available until the next release of testcontainers-go <a href="https://github.com/testcontainers/testcontainers-go"><span class="tc-version">:material-tag: main</span></a>
+
+If you need to prevent the container from being started after creation, you can use the `testcontainers.WithNoStart` option.
+
+
diff --git a/docs/modules/index.md b/docs/modules/index.md
@@ -204,9 +204,16 @@ In order to simplify the creation of the container for a given module, `Testcont
 - `testcontainers.WithTmpfs`: a function that adds tmpfs mounts to the container.
 - `testcontainers.WithHostPortAccess`: a function that enables the container to access a port that is already running in the host.
 - `testcontainers.WithLogConsumers`: a function that sets the log consumers for the container request.
+- `testcontainers.WithLogConsumerConfig`: a function that sets the log consumer config for the container request.
 - `testcontainers.WithLogger`: a function that sets the logger for the container request.
-- `testcontainers.WithWaitStrategy`: a function that sets the wait strategy for the container request.
-- `testcontainers.WithWaitStrategyAndDeadline`: a function that sets the wait strategy for the container request with a deadline.
+- `testcontainers.WithLifecycleHooks`: a function that sets the lifecycle hooks for the container request.
+- `testcontainers.WithAdditionalLifecycleHooks`: a function that appends lifecycle hooks to the existing ones for the container request.
+- `testcontainers.WithAlwaysPull`: a function that pulls the image before starting the container.
+- `testcontainers.WithImagePlatform`: a function that sets the image platform for the container request.
+- `testcontainers.WithWaitStrategy`: a function that replaces the wait strategy for the container request.
+- `testcontainers.WithAdditionalWaitStrategy`: a function that appends the wait strategy for the container request.
+- `testcontainers.WithWaitStrategyAndDeadline`: a function that replaces the wait strategy for the container request with a deadline.
+- `testcontainers.WithAdditionalWaitStrategyAndDeadline`: a function that appends the wait strategy for the container request with a deadline.
 - `testcontainers.WithStartupCommand`: a function that sets the execution of a command when the container starts.
 - `testcontainers.WithAfterReadyCommand`: a function that sets the execution of a command right after the container is ready (its wait strategy is satisfied).
 - `testcontainers.WithDockerfile`: a function that sets the build from a Dockerfile for the container request.
@@ -217,6 +224,12 @@ In order to simplify the creation of the container for a given module, `Testcont
 - `testcontainers.WithEndpointSettingsModifier`: a function that sets the endpoint settings Docker type for the container request. Please see [Advanced Settings](../features/creating_container.md#advanced-settings) for more information.
 - `testcontainers.CustomizeRequest`: a function that merges the default options with the ones provided by the user. Recommended for completely customizing the container request.
 - `testcontainers.WithReuseByName`: a function that marks a container to be reused if it exists or create a new one if it doesn't.
+- `testcontainers.WithName`: a function that sets the name of the container.
+- `testcontainers.WithNoStart`: a function that prevents the container from being started after creation, so it must be started manually.
+- `network.WithNetwork`: a function that sets the network and the network aliases for the container request, reusing an already existing network.
+- `network.WithNetworkName`: a function that sets the network aliases for an already existing network, by its name.
+- `network.WithBridgeNetwork`: a function that sets the container to be attached to the `bridge` network.
+- `network.WithNewNetwork`: a function that sets the network aliases for a throw-away network for the container request.
 
 ### Update Go dependencies in the modules
 
diff --git a/docs/modules/redpanda.md b/docs/modules/redpanda.md
@@ -99,7 +99,7 @@ E.g. `WithSuperusers("superuser-1", "superuser-2")`.
 
 - Since testcontainers-go <a href="https://github.com/testcontainers/testcontainers-go/releases/tag/v0.20.0"><span class="tc-version">:material-tag: v0.20.0</span></a>
 
-The `WithEnableSASL()` option enables SASL scram sha authentication. By default, no authentication (plaintext) is used.
+The `WithEnableSASL()` option enables SASL scram sha 256 authentication. By default, no authentication (plaintext) is used.
 When setting an authentication method, make sure to add users as well and authorize them using the `WithSuperusers()` option.
 
 #### WithEnableKafkaAuthorization
diff --git a/modules/etcd/etcd.go b/modules/etcd/etcd.go
@@ -60,8 +60,9 @@ func (c *EtcdContainer) Terminate(ctx context.Context, opts ...testcontainers.Te
 // Run creates an instance of the etcd container type
 func Run(ctx context.Context, img string, opts ...testcontainers.ContainerCustomizer) (*EtcdContainer, error) {
 	req := testcontainers.ContainerRequest{
-		Image: img,
-		Cmd:   []string{},
+		Image:        img,
+		ExposedPorts: []string{clientPort, peerPort},
+		Cmd:          []string{},
 	}
 
 	genericContainerReq := testcontainers.GenericContainerRequest{
diff --git a/modules/k3s/k3s_test.go b/modules/k3s/k3s_test.go
@@ -146,7 +146,7 @@ func Test_WithManifestOption(t *testing.T) {
 	k3sContainer, err := k3s.Run(ctx,
 		"rancher/k3s:v1.27.1-k3s1",
 		k3s.WithManifest("nginx-manifest.yaml"),
-		testcontainers.WithWaitStrategy(wait.ForExec([]string{"kubectl", "wait", "pod", "nginx", "--for=condition=Ready"})),
+		testcontainers.WithAdditionalWaitStrategy(wait.ForExec([]string{"kubectl", "wait", "pod", "nginx", "--for=condition=Ready"})),
 	)
 	testcontainers.CleanupContainer(t, k3sContainer)
 	require.NoError(t, err)
diff --git a/modules/localstack/examples_test.go b/modules/localstack/examples_test.go
@@ -101,7 +101,7 @@ func ExampleRun_legacyMode() {
 		ctx,
 		"localstack/localstack:0.10.0",
 		testcontainers.WithEnv(map[string]string{"SERVICES": "s3,sqs"}),
-		testcontainers.WithWaitStrategy(wait.ForLog("Ready.").WithStartupTimeout(5*time.Minute).WithOccurrence(1)),
+		testcontainers.WithAdditionalWaitStrategy(wait.ForLog("Ready.").WithStartupTimeout(5*time.Minute).WithOccurrence(1)),
 	)
 	defer func() {
 		if err := testcontainers.TerminateContainer(ctr); err != nil {
diff --git a/modules/mongodb/examples_test.go b/modules/mongodb/examples_test.go
@@ -11,7 +11,6 @@ import (
 
 	"github.com/testcontainers/testcontainers-go"
 	"github.com/testcontainers/testcontainers-go/modules/mongodb"
-	"github.com/testcontainers/testcontainers-go/wait"
 )
 
 func ExampleRun() {
@@ -89,7 +88,6 @@ func ExampleRun_withCredentials() {
 		"mongo:6",
 		mongodb.WithUsername("root"),
 		mongodb.WithPassword("password"),
-		testcontainers.WithWaitStrategy(wait.ForLog("Waiting for connections")),
 	)
 	defer func() {
 		if err := testcontainers.TerminateContainer(ctr); err != nil {
diff --git a/modules/mssql/mssql_test.go b/modules/mssql/mssql_test.go
@@ -50,7 +50,7 @@ func TestMSSQLServerWithMissingEulaOption(t *testing.T) {
 	t.Run("empty", func(t *testing.T) {
 		ctr, err := mssql.Run(ctx,
 			"mcr.microsoft.com/mssql/server:2022-CU14-ubuntu-22.04",
-			testcontainers.WithWaitStrategy(
+			testcontainers.WithAdditionalWaitStrategy(
 				wait.ForLog("The SQL Server End-User License Agreement (EULA) must be accepted")),
 		)
 		testcontainers.CleanupContainer(t, ctr)
@@ -61,7 +61,7 @@ func TestMSSQLServerWithMissingEulaOption(t *testing.T) {
 		ctr, err := mssql.Run(ctx,
 			"mcr.microsoft.com/mssql/server:2022-CU14-ubuntu-22.04",
 			testcontainers.WithEnv(map[string]string{"ACCEPT_EULA": "yes"}),
-			testcontainers.WithWaitStrategy(
+			testcontainers.WithAdditionalWaitStrategy(
 				wait.ForLog("The SQL Server End-User License Agreement (EULA) must be accepted")),
 		)
 		testcontainers.CleanupContainer(t, ctr)
diff --git a/modules/postgres/examples_test.go b/modules/postgres/examples_test.go
@@ -5,11 +5,9 @@ import (
 	"fmt"
 	"log"
 	"path/filepath"
-	"time"
 
 	"github.com/testcontainers/testcontainers-go"
 	"github.com/testcontainers/testcontainers-go/modules/postgres"
-	"github.com/testcontainers/testcontainers-go/wait"
 )
 
 func ExampleRun() {
@@ -27,10 +25,7 @@ func ExampleRun() {
 		postgres.WithDatabase(dbName),
 		postgres.WithUsername(dbUser),
 		postgres.WithPassword(dbPassword),
-		testcontainers.WithWaitStrategy(
-			wait.ForLog("database system is ready to accept connections").
-				WithOccurrence(2).
-				WithStartupTimeout(5*time.Second)),
+		postgres.BasicWaitStrategies(),
 	)
 	defer func() {
 		if err := testcontainers.TerminateContainer(postgresContainer); err != nil {
diff --git a/modules/postgres/postgres_test.go b/modules/postgres/postgres_test.go
@@ -155,7 +155,7 @@ func TestContainerWithWaitForSQL(t *testing.T) {
 			postgres.WithDatabase(dbname),
 			postgres.WithUsername(user),
 			postgres.WithPassword(password),
-			testcontainers.WithWaitStrategy(wait.ForSQL(nat.Port(port), "postgres", dbURL)),
+			testcontainers.WithAdditionalWaitStrategy(wait.ForSQL(nat.Port(port), "postgres", dbURL)),
 		)
 		testcontainers.CleanupContainer(t, ctr)
 		require.NoError(t, err)
@@ -168,7 +168,7 @@ func TestContainerWithWaitForSQL(t *testing.T) {
 			postgres.WithDatabase(dbname),
 			postgres.WithUsername(user),
 			postgres.WithPassword(password),
-			testcontainers.WithWaitStrategy(wait.ForSQL(nat.Port(port), "postgres", dbURL).WithStartupTimeout(time.Second*5).WithQuery("SELECT 10")),
+			testcontainers.WithAdditionalWaitStrategy(wait.ForSQL(nat.Port(port), "postgres", dbURL).WithStartupTimeout(time.Second*5).WithQuery("SELECT 10")),
 		)
 		testcontainers.CleanupContainer(t, ctr)
 		require.NoError(t, err)
@@ -181,7 +181,7 @@ func TestContainerWithWaitForSQL(t *testing.T) {
 			postgres.WithDatabase(dbname),
 			postgres.WithUsername(user),
 			postgres.WithPassword(password),
-			testcontainers.WithWaitStrategy(wait.ForSQL(nat.Port(port), "postgres", dbURL).WithStartupTimeout(time.Second*5).WithQuery("SELECT 'a' from b")),
+			testcontainers.WithAdditionalWaitStrategy(wait.ForSQL(nat.Port(port), "postgres", dbURL).WithStartupTimeout(time.Second*5).WithQuery("SELECT 'a' from b")),
 		)
 		testcontainers.CleanupContainer(t, ctr)
 		require.Error(t, err)
@@ -225,7 +225,7 @@ func TestWithSSL(t *testing.T) {
 		postgres.WithDatabase(dbname),
 		postgres.WithUsername(user),
 		postgres.WithPassword(password),
-		testcontainers.WithWaitStrategy(wait.ForLog("database system is ready to accept connections").WithOccurrence(2).WithStartupTimeout(5*time.Second)),
+		testcontainers.WithAdditionalWaitStrategy(wait.ForLog("database system is ready to accept connections").WithOccurrence(2).WithStartupTimeout(5*time.Second)),
 		postgres.WithSSLCert(caCert.CertPath, serverCerts.CertPath, serverCerts.KeyPath),
 	)
 
@@ -255,7 +255,7 @@ func TestSSLValidatesKeyMaterialPath(t *testing.T) {
 		postgres.WithDatabase(dbname),
 		postgres.WithUsername(user),
 		postgres.WithPassword(password),
-		testcontainers.WithWaitStrategy(wait.ForLog("database system is ready to accept connections").WithOccurrence(2).WithStartupTimeout(5*time.Second)),
+		testcontainers.WithAdditionalWaitStrategy(wait.ForLog("database system is ready to accept connections").WithOccurrence(2).WithStartupTimeout(5*time.Second)),
 		postgres.WithSSLCert("", "", ""),
 	)
 
diff --git a/modules/postgres/wait_strategies.go b/modules/postgres/wait_strategies.go
@@ -14,7 +14,7 @@ import (
 //     Without this, the tests will be flaky on those OSes!
 func BasicWaitStrategies() testcontainers.CustomizeRequestOption {
 	// waitStrategy {
-	return testcontainers.WithWaitStrategy(
+	return testcontainers.WithAdditionalWaitStrategy(
 		// First, we wait for the container to log readiness twice.
 		// This is because it will restart itself after the first startup.
 		wait.ForLog("database system is ready to accept connections").WithOccurrence(2),
diff --git a/modules/redpanda/options.go b/modules/redpanda/options.go
@@ -15,7 +15,7 @@ type options struct {
 	KafkaEnableAuthorization bool
 
 	// KafkaAuthenticationMethod is either "none" for plaintext or "sasl"
-	// for SASL (scram) authentication.
+	// for SASL (scram sha 256) authentication.
 	KafkaAuthenticationMethod string
 
 	// SchemaRegistryAuthenticationMethod is either "none" for no authentication
@@ -78,6 +78,9 @@ func (o Option) Customize(*testcontainers.GenericContainerRequest) error {
 	return nil
 }
 
+// WithNewServiceAccount includes a new user with username (key) and password (value)
+// that shall be created, so that you can use these to authenticate against
+// Redpanda (either for the Kafka API or Schema Registry HTTP access).
 func WithNewServiceAccount(username, password string) Option {
 	return func(o *options) {
 		o.ServiceAccounts[username] = password
@@ -92,7 +95,7 @@ func WithSuperusers(superusers ...string) Option {
 	}
 }
 
-// WithEnableSASL enables SASL scram sha authentication.
+// WithEnableSASL enables SASL scram sha 256 authentication.
 // By default, no authentication (plaintext) is used.
 // When setting an authentication method, make sure to add users
 // as well as authorize them using the WithSuperusers() option.
diff --git a/network/network.go b/network/network.go
@@ -2,6 +2,7 @@ package network
 
 import (
 	"context"
+	"errors"
 	"fmt"
 
 	"github.com/docker/docker/api/types/network"
@@ -137,8 +138,18 @@ func WithIPAM(ipam *network.IPAM) CustomizeNetworkOption {
 // WithNetwork reuses an already existing network, attaching the container to it.
 // Finally it sets the network alias on that network to the given alias.
 func WithNetwork(aliases []string, nw *testcontainers.DockerNetwork) testcontainers.CustomizeRequestOption {
+	return WithNetworkName(aliases, nw.Name)
+}
+
+// WithNetworkName attachs a container to an already existing network, by its name.
+// If the network is not "bridge", it sets the network alias on that network
+// to the given alias, else, it returns an error. This is because network-scoped alias
+// is supported only for containers in user defined networks.
+func WithNetworkName(aliases []string, networkName string) testcontainers.CustomizeRequestOption {
 	return func(req *testcontainers.GenericContainerRequest) error {
-		networkName := nw.Name
+		if networkName == "bridge" {
+			return errors.New("network-scoped aliases are supported only for containers in user defined networks")
+		}
 
 		// attaching to the network because it was created with success or it already existed.
 		req.Networks = append(req.Networks, networkName)
@@ -152,6 +163,15 @@ func WithNetwork(aliases []string, nw *testcontainers.DockerNetwork) testcontain
 	}
 }
 
+// WithBridgeNetwork attachs a container to the "bridge" network.
+// There is no need to set the network alias, as it is not supported for the "bridge" network.
+func WithBridgeNetwork() testcontainers.CustomizeRequestOption {
+	return func(req *testcontainers.GenericContainerRequest) error {
+		req.Networks = append(req.Networks, "bridge")
+		return nil
+	}
+}
+
 // WithNewNetwork creates a new network with random name and customizers, and attaches the container to it.
 // Finally it sets the network alias on that network to the given alias.
 func WithNewNetwork(ctx context.Context, aliases []string, opts ...NetworkCustomizer) testcontainers.CustomizeRequestOption {
diff --git a/network/network_test.go b/network/network_test.go
diff --git a/options.go b/options.go
diff --git a/options_test.go b/options_test.go
diff --git a/wait/host_port.go b/wait/host_port.go
diff --git a/wait/host_port_test.go b/wait/host_port_test.go

Original file line number	Diff line number	Diff line change
`@@ -146,7 +146,7 @@ func Test_WithManifestOption(t *testing.T) {`
`146`	`146`	`k3sContainer, err := k3s.Run(ctx,`
`147`	`147`	`"rancher/k3s:v1.27.1-k3s1",`
`148`	`148`	`k3s.WithManifest("nginx-manifest.yaml"),`
`149`		`- testcontainers.WithWaitStrategy(wait.ForExec([]string{"kubectl", "wait", "pod", "nginx", "--for=condition=Ready"})),`
	`149`	`+ testcontainers.WithAdditionalWaitStrategy(wait.ForExec([]string{"kubectl", "wait", "pod", "nginx", "--for=condition=Ready"})),`
`150`	`150`	`)`
`151`	`151`	`testcontainers.CleanupContainer(t, k3sContainer)`
`152`	`152`	`require.NoError(t, err)`
Original file line number	Diff line number	Diff line change
`@@ -101,7 +101,7 @@ func ExampleRun_legacyMode() {`
`101`	`101`	`ctx,`
`102`	`102`	`"localstack/localstack:0.10.0",`
`103`	`103`	`testcontainers.WithEnv(map[string]string{"SERVICES": "s3,sqs"}),`
`104`		`- testcontainers.WithWaitStrategy(wait.ForLog("Ready.").WithStartupTimeout(5*time.Minute).WithOccurrence(1)),`
	`104`	`+ testcontainers.WithAdditionalWaitStrategy(wait.ForLog("Ready.").WithStartupTimeout(5*time.Minute).WithOccurrence(1)),`
`105`	`105`	`)`
`106`	`106`	`defer func() {`
`107`	`107`	`if err := testcontainers.TerminateContainer(ctr); err != nil {`
Original file line number	Diff line number	Diff line change
`@@ -11,7 +11,6 @@ import (`
`11`	`11`
`12`	`12`	`"github.com/testcontainers/testcontainers-go"`
`13`	`13`	`"github.com/testcontainers/testcontainers-go/modules/mongodb"`
`14`		`- "github.com/testcontainers/testcontainers-go/wait"`
`15`	`14`	`)`
`16`	`15`
`17`	`16`	`func ExampleRun() {`
`@@ -89,7 +88,6 @@ func ExampleRun_withCredentials() {`
`89`	`88`	`"mongo:6",`
`90`	`89`	`mongodb.WithUsername("root"),`
`91`	`90`	`mongodb.WithPassword("password"),`
`92`		`- testcontainers.WithWaitStrategy(wait.ForLog("Waiting for connections")),`
`93`	`91`	`)`
`94`	`92`	`defer func() {`
`95`	`93`	`if err := testcontainers.TerminateContainer(ctr); err != nil {`