chore(meilisearch|memcached|milvus|minio|mockserver|mssql): use Run function (#3415)

* chore(meilisearch): use Run function

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <[email protected]>

* chore(memcached): use Run function

* chore(milvus): use Run function

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <[email protected]>

* fix(milvus): improve wait strategy to fix test flakiness

Add wait.ForListeningPort for both HTTP and gRPC ports in addition
to the HTTP health check. This ensures both services are fully ready
before the container is marked as ready, eliminating the race condition
where the health endpoint was ready but the gRPC proxy was not.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <[email protected]>

* chore(minio): use Run function

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <[email protected]>

* chore(mockserver): use Run function

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <[email protected]>

* chore(mssql): use Run function

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <[email protected]>

* chore(mssql): use built-in options

---------

Co-authored-by: Claude <[email protected]>

Author: mdelapenya

modules/meilisearch/meilisearch.go

@@ -6,6 +6,7 @@ import (
 	"fmt"
 	"io"
 	"net/http"
+	"strings"
 	"time"
 
 	"github.com/testcontainers/testcontainers-go"
@@ -31,70 +32,73 @@ func (c *MeilisearchContainer) MasterKey() string {
 
 // Run creates an instance of the Meilisearch container type
 func Run(ctx context.Context, img string, opts ...testcontainers.ContainerCustomizer) (*MeilisearchContainer, error) {
-	req := testcontainers.ContainerRequest{
-		Image:        img,
-		ExposedPorts: []string{defaultHTTPPort},
-		Env: map[string]string{
-			masterKeyEnvVar: defaultMasterKey,
-		},
-	}
-
-	genericContainerReq := testcontainers.GenericContainerRequest{
-		ContainerRequest: req,
-		Started:          true,
-	}
-
 	// Gather all config options (defaults and then apply provided options)
 	settings := defaultOptions()
 	for _, opt := range opts {
 		if apply, ok := opt.(Option); ok {
 			apply(settings)
 		}
-		if err := opt.Customize(&genericContainerReq); err != nil {
-			return nil, fmt.Errorf("customize: %w", err)
-		}
+	}
+
+	moduleOpts := []testcontainers.ContainerCustomizer{
+		testcontainers.WithExposedPorts(defaultHTTPPort),
+		testcontainers.WithEnv(map[string]string{
+			masterKeyEnvVar: defaultMasterKey,
+		}),
+		// the wait strategy does not support TLS at the moment,
+		// so we need to disable it in the strategy for now.
+		testcontainers.WithWaitStrategy(wait.ForHTTP("/health").
+			WithPort(defaultHTTPPort).
+			WithTLS(false).
+			WithStartupTimeout(120 * time.Second).
+			WithStatusCodeMatcher(func(status int) bool {
+				return status == http.StatusOK
+			}).
+			WithResponseMatcher(func(body io.Reader) bool {
+				decoder := json.NewDecoder(body)
+				r := struct {
+					Status string `json:"status"`
+				}{}
+				if err := decoder.Decode(&r); err != nil {
+					return false
+				}
+
+				return r.Status == "available"
+			}),
+		),
 	}
 
 	if settings.DumpDataFilePath != "" {
-		genericContainerReq.Files = []testcontainers.ContainerFile{
-			{
+		moduleOpts = append(moduleOpts,
+			testcontainers.WithFiles(testcontainers.ContainerFile{
 				HostFilePath:      settings.DumpDataFilePath,
 				ContainerFilePath: "/dumps/" + settings.DumpDataFileName,
 				FileMode:          0o755,
-			},
-		}
-		genericContainerReq.Cmd = []string{"meilisearch", "--import-dump", "/dumps/" + settings.DumpDataFileName}
+			}),
+			testcontainers.WithCmd("meilisearch", "--import-dump", "/dumps/"+settings.DumpDataFileName),
+		)
 	}
 
-	// the wait strategy does not support TLS at the moment,
-	// so we need to disable it in the strategy for now.
-	genericContainerReq.WaitingFor = wait.ForHTTP("/health").
-		WithPort(defaultHTTPPort).
-		WithTLS(false).
-		WithStartupTimeout(120 * time.Second).
-		WithStatusCodeMatcher(func(status int) bool {
-			return status == http.StatusOK
-		}).
-		WithResponseMatcher(func(body io.Reader) bool {
-			decoder := json.NewDecoder(body)
-			r := struct {
-				Status string `json:"status"`
-			}{}
-			if err := decoder.Decode(&r); err != nil {
-				return false
-			}
-
-			return r.Status == "available"
-		})
-
-	container, err := testcontainers.GenericContainer(ctx, genericContainerReq)
+	ctr, err := testcontainers.Run(ctx, img, append(moduleOpts, opts...)...)
 	var c *MeilisearchContainer
-	if container != nil {
-		c = &MeilisearchContainer{Container: container, masterKey: req.Env[masterKeyEnvVar]}
+	if ctr != nil {
+		c = &MeilisearchContainer{Container: ctr}
 	}
 
 	if err != nil {
-		return c, fmt.Errorf("generic container: %w", err)
+		return c, fmt.Errorf("run meilisearch: %w", err)
+	}
+
+	inspect, err := ctr.Inspect(ctx)
+	if err != nil {
+		return c, fmt.Errorf("inspect meilisearch: %w", err)
+	}
+
+	for _, env := range inspect.Config.Env {
+		if v, ok := strings.CutPrefix(env, masterKeyEnvVar+"="); ok {
+			c.masterKey = v
+			break
+		}
 	}
 
 	return c, nil

modules/memcached/memcached.go

@@ -19,31 +19,21 @@ type Container struct {
 
 // Run creates an instance of the Memcached container type
 func Run(ctx context.Context, img string, opts ...testcontainers.ContainerCustomizer) (*Container, error) {
-	req := testcontainers.ContainerRequest{
-		Image:        img,
-		ExposedPorts: []string{defaultPort},
-		WaitingFor:   wait.ForListeningPort(defaultPort),
+	moduleOpts := []testcontainers.ContainerCustomizer{
+		testcontainers.WithExposedPorts(defaultPort),
+		testcontainers.WithWaitStrategy(wait.ForListeningPort(defaultPort)),
 	}
 
-	genericContainerReq := testcontainers.GenericContainerRequest{
-		ContainerRequest: req,
-		Started:          true,
-	}
-
-	for _, opt := range opts {
-		if err := opt.Customize(&genericContainerReq); err != nil {
-			return nil, fmt.Errorf("customize: %w", err)
-		}
-	}
+	moduleOpts = append(moduleOpts, opts...)
 
-	container, err := testcontainers.GenericContainer(ctx, genericContainerReq)
+	ctr, err := testcontainers.Run(ctx, img, moduleOpts...)
 	var c *Container
-	if container != nil {
-		c = &Container{Container: container}
+	if ctr != nil {
+		c = &Container{Container: ctr}
 	}
 
 	if err != nil {
-		return c, fmt.Errorf("generic container: %w", err)
+		return c, fmt.Errorf("run memcached: %w", err)
 	}
 
 	return c, nil

modules/milvus/milvus.go

@@ -19,6 +19,8 @@ var embedEtcdConfigTpl string
 const (
 	embedEtcdContainerPath = "/milvus/configs/embedEtcd.yaml"
 	defaultClientPort      = 2379
+	etcdPort               = "2379/tcp"
+	httpPort               = "9091/tcp"
 	grpcPort               = "19530/tcp"
 )
 
@@ -47,45 +49,42 @@ func Run(ctx context.Context, img string, opts ...testcontainers.ContainerCustom
 	}
 
 	// Adapted from https://github.com/milvus-io/milvus/blob/v2.6.3/scripts/standalone_embed.sh
-	req := testcontainers.ContainerRequest{
-		Image:        img,
-		ExposedPorts: []string{"19530/tcp", "9091/tcp", "2379/tcp"},
-		Env: map[string]string{
+	moduleOpts := []testcontainers.ContainerCustomizer{
+		testcontainers.WithExposedPorts(grpcPort, httpPort, etcdPort),
+		testcontainers.WithEnv(map[string]string{
 			"ETCD_USE_EMBED":     "true",
 			"ETCD_DATA_DIR":      "/var/lib/milvus/etcd",
 			"ETCD_CONFIG_PATH":   embedEtcdContainerPath,
 			"COMMON_STORAGETYPE": "local",
 			"DEPLOY_MODE":        "STANDALONE",
-		},
-		Cmd: []string{"milvus", "run", "standalone"},
-		WaitingFor: wait.ForHTTP("/healthz").
-			WithPort("9091").
-			WithStartupTimeout(time.Minute).
-			WithPollInterval(time.Second),
-		Files: []testcontainers.ContainerFile{
-			{ContainerFilePath: embedEtcdContainerPath, Reader: config},
-		},
+		}),
+		testcontainers.WithCmd("milvus", "run", "standalone"),
+		testcontainers.WithWaitStrategy(wait.ForAll(
+			wait.ForHTTP("/healthz").
+				WithPort(httpPort).
+				WithStartupTimeout(time.Minute).
+				WithPollInterval(time.Second),
+			wait.ForListeningPort(httpPort).
+				WithStartupTimeout(time.Minute),
+			wait.ForListeningPort(grpcPort).
+				WithStartupTimeout(time.Minute),
+		)),
+		testcontainers.WithFiles(testcontainers.ContainerFile{
+			ContainerFilePath: embedEtcdContainerPath,
+			Reader:            config,
+		}),
 	}
 
-	genericContainerReq := testcontainers.GenericContainerRequest{
-		ContainerRequest: req,
-		Started:          true,
-	}
-
-	for _, opt := range opts {
-		if err := opt.Customize(&genericContainerReq); err != nil {
-			return nil, err
-		}
-	}
+	moduleOpts = append(moduleOpts, opts...)
 
-	container, err := testcontainers.GenericContainer(ctx, genericContainerReq)
+	ctr, err := testcontainers.Run(ctx, img, moduleOpts...)
 	var c *MilvusContainer
-	if container != nil {
-		c = &MilvusContainer{Container: container}
+	if ctr != nil {
+		c = &MilvusContainer{Container: ctr}
 	}
 
 	if err != nil {
-		return c, fmt.Errorf("generic container: %w", err)
+		return c, fmt.Errorf("run milvus: %w", err)
 	}
 
 	return c, nil

modules/minio/minio.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"strings"
 
 	"github.com/testcontainers/testcontainers-go"
 	"github.com/testcontainers/testcontainers-go/wait"
@@ -57,42 +58,58 @@ func RunContainer(ctx context.Context, opts ...testcontainers.ContainerCustomize
 
 // Run creates an instance of the Minio container type
 func Run(ctx context.Context, img string, opts ...testcontainers.ContainerCustomizer) (*MinioContainer, error) {
-	req := testcontainers.ContainerRequest{
-		Image:        img,
-		ExposedPorts: []string{"9000/tcp"},
-		WaitingFor:   wait.ForHTTP("/minio/health/live").WithPort("9000"),
-		Env: map[string]string{
+	moduleOpts := []testcontainers.ContainerCustomizer{
+		testcontainers.WithExposedPorts("9000/tcp"),
+		testcontainers.WithWaitStrategy(wait.ForHTTP("/minio/health/live").WithPort("9000")),
+		testcontainers.WithEnv(map[string]string{
 			"MINIO_ROOT_USER":     defaultUser,
 			"MINIO_ROOT_PASSWORD": defaultPassword,
-		},
-		Cmd: []string{"server", "/data"},
+		}),
+		testcontainers.WithCmd("server", "/data"),
 	}
 
-	genericContainerReq := testcontainers.GenericContainerRequest{
-		ContainerRequest: req,
-		Started:          true,
-	}
+	moduleOpts = append(moduleOpts, opts...)
 
-	for _, opt := range opts {
-		if err := opt.Customize(&genericContainerReq); err != nil {
-			return nil, err
+	// Validate credentials after applying user options
+	validateCreds := func(req *testcontainers.GenericContainerRequest) error {
+		username := req.Env["MINIO_ROOT_USER"]
+		password := req.Env["MINIO_ROOT_PASSWORD"]
+		if username == "" || password == "" {
+			return errors.New("username or password has not been set")
 		}
+		return nil
 	}
 
-	username := req.Env["MINIO_ROOT_USER"]
-	password := req.Env["MINIO_ROOT_PASSWORD"]
-	if username == "" || password == "" {
-		return nil, errors.New("username or password has not been set")
-	}
+	moduleOpts = append(moduleOpts, testcontainers.CustomizeRequestOption(validateCreds))
 
-	container, err := testcontainers.GenericContainer(ctx, genericContainerReq)
+	ctr, err := testcontainers.Run(ctx, img, moduleOpts...)
 	var c *MinioContainer
-	if container != nil {
-		c = &MinioContainer{Container: container, Username: username, Password: password}
+	if ctr != nil {
+		c = &MinioContainer{Container: ctr}
+	}
+
+	if err != nil {
+		return c, fmt.Errorf("run minio: %w", err)
 	}
 
+	// Retrieve credentials from container environment
+	inspect, err := ctr.Inspect(ctx)
 	if err != nil {
-		return c, fmt.Errorf("generic container: %w", err)
+		return c, fmt.Errorf("inspect minio: %w", err)
+	}
+
+	var foundUser, foundPass bool
+	for _, env := range inspect.Config.Env {
+		if v, ok := strings.CutPrefix(env, "MINIO_ROOT_USER="); ok {
+			c.Username, foundUser = v, true
+		}
+		if v, ok := strings.CutPrefix(env, "MINIO_ROOT_PASSWORD="); ok {
+			c.Password, foundPass = v, true
+		}
+
+		if foundUser && foundPass {
+			break
+		}
 	}
 
 	return c, nil

modules/mockserver/mockserver.go

@@ -21,34 +21,24 @@ func RunContainer(ctx context.Context, opts ...testcontainers.ContainerCustomize
 
 // Run creates an instance of the MockServer container type
 func Run(ctx context.Context, img string, opts ...testcontainers.ContainerCustomizer) (*MockServerContainer, error) {
-	req := testcontainers.ContainerRequest{
-		Image:        img,
-		ExposedPorts: []string{"1080/tcp"},
-		WaitingFor: wait.ForAll(
+	moduleOpts := []testcontainers.ContainerCustomizer{
+		testcontainers.WithExposedPorts("1080/tcp"),
+		testcontainers.WithWaitStrategy(wait.ForAll(
 			wait.ForLog("started on port: 1080"),
 			wait.ForListeningPort("1080/tcp").SkipInternalCheck(),
-		),
-		Env: map[string]string{},
+		)),
 	}
 
-	genericContainerReq := testcontainers.GenericContainerRequest{
-		ContainerRequest: req,
-		Started:          true,
-	}
-
-	for _, opt := range opts {
-		if err := opt.Customize(&genericContainerReq); err != nil {
-			return nil, err
-		}
-	}
+	moduleOpts = append(moduleOpts, opts...)
 
-	container, err := testcontainers.GenericContainer(ctx, genericContainerReq)
+	ctr, err := testcontainers.Run(ctx, img, moduleOpts...)
 	var c *MockServerContainer
-	if container != nil {
-		c = &MockServerContainer{Container: container}
+	if ctr != nil {
+		c = &MockServerContainer{Container: ctr}
 	}
+
 	if err != nil {
-		return c, fmt.Errorf("generic container: %w", err)
+		return c, fmt.Errorf("run mockserver: %w", err)
 	}
 
 	return c, nil