chore(etcd)!: use Run function (#3409)

* chore(etcd): use Run function

* chore(etcd)!: make options return errors

Author: mdelapenya

modules/etcd/etcd.go

@@ -7,6 +7,7 @@ import (
 	"strings"
 
 	"github.com/testcontainers/testcontainers-go"
+	tcexec "github.com/testcontainers/testcontainers-go/exec"
 	tcnetwork "github.com/testcontainers/testcontainers-go/network"
 )
 
@@ -59,24 +60,18 @@ 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,
-		ExposedPorts: []string{clientPort, peerPort},
-		Cmd:          []string{},
+	moduleOpts := []testcontainers.ContainerCustomizer{
+		testcontainers.WithExposedPorts(clientPort, peerPort),
 	}
 
-	genericContainerReq := testcontainers.GenericContainerRequest{
-		ContainerRequest: req,
-		Started:          true,
-	}
+	moduleOpts = append(moduleOpts, opts...)
 
-	settings := defaultOptions(&req)
+	settings := defaultOptions()
 	for _, opt := range opts {
 		if apply, ok := opt.(Option); ok {
-			apply(&settings)
-		}
-		if err := opt.Customize(&genericContainerReq); err != nil {
-			return nil, err
+			if err := apply(&settings); err != nil {
+				return nil, fmt.Errorf("apply option: %w", err)
+			}
 		}
 	}
 
@@ -86,7 +81,7 @@ func Run(ctx context.Context, img string, opts ...testcontainers.ContainerCustom
 	}
 
 	// configure CMD with the nodes
-	genericContainerReq.Cmd = configureCMD(settings)
+	moduleOpts = append(moduleOpts, testcontainers.WithCmd(configureCMD(settings)...))
 
 	// Initialise the etcd container with the current settings.
 	// The cluster network, if needed, is already part of the settings,
@@ -96,21 +91,33 @@ func Run(ctx context.Context, img string, opts ...testcontainers.ContainerCustom
 
 	if settings.clusterNetwork != nil {
 		// apply the network to the current node
-		err := tcnetwork.WithNetwork([]string{settings.nodeNames[settings.currentNode]}, settings.clusterNetwork)(&genericContainerReq)
-		if err != nil {
-			return c, fmt.Errorf("with network: %w", err)
-		}
+		moduleOpts = append(moduleOpts, tcnetwork.WithNetwork([]string{settings.nodeNames[settings.currentNode]}, settings.clusterNetwork))
+	}
+
+	if settings.mountDataDir {
+		moduleOpts = append(moduleOpts, testcontainers.WithAdditionalLifecycleHooks(testcontainers.ContainerLifecycleHooks{
+			PostStarts: []testcontainers.ContainerHook{
+				func(ctx context.Context, c testcontainers.Container) error {
+					_, _, err := c.Exec(ctx, []string{"chmod", "o+rwx", "-R", dataDir}, tcexec.Multiplexed())
+					if err != nil {
+						return fmt.Errorf("chmod etcd data dir: %w", err)
+					}
+
+					return nil
+				},
+			},
+		}))
 	}
 
-	if c.Container, err = testcontainers.GenericContainer(ctx, genericContainerReq); err != nil {
-		return c, fmt.Errorf("generic container: %w", err)
+	if c.Container, err = testcontainers.Run(ctx, img, moduleOpts...); err != nil {
+		return c, fmt.Errorf("run etcd: %w", err)
 	}
 
 	// only the first node creates the cluster
 	if settings.currentNode == 0 {
 		for i := 1; i < len(settings.nodeNames); i++ {
 			// move to the next node
-			childNode, err := Run(ctx, req.Image, append(clusterOpts, withCurrentNode(i))...)
+			childNode, err := Run(ctx, img, append(clusterOpts, withCurrentNode(i))...)
 			if err != nil {
 				// return the parent cluster node and the error, so the caller can clean up.
 				return c, fmt.Errorf("run cluster node: %w", err)

modules/etcd/etcd_test.go

@@ -30,6 +30,22 @@ func TestRun(t *testing.T) {
 	require.Contains(t, string(output), "default")
 }
 
+func TestRunWithDataDir(t *testing.T) {
+	ctx := context.Background()
+
+	ctr, err := etcd.Run(ctx, "gcr.io/etcd-development/etcd:v3.5.14", etcd.WithDataDir())
+	testcontainers.CleanupContainer(t, ctr)
+	require.NoError(t, err)
+
+	c, r, err := ctr.Exec(ctx, []string{"etcdctl", "member", "list"}, tcexec.Multiplexed())
+	require.NoError(t, err)
+	require.Zero(t, c)
+
+	output, err := io.ReadAll(r)
+	require.NoError(t, err)
+	require.Contains(t, string(output), "default")
+}
+
 func TestPutGet(t *testing.T) {
 	t.Run("single_node", func(t *testing.T) {
 		ctr, err := etcd.Run(context.Background(), "gcr.io/etcd-development/etcd:v3.5.14")

modules/etcd/options.go

@@ -1,35 +1,31 @@
 package etcd
 
 import (
-	"context"
 	"fmt"
 
 	"github.com/testcontainers/testcontainers-go"
-	tcexec "github.com/testcontainers/testcontainers-go/exec"
 )
 
 type options struct {
-	currentNode      int
-	clusterNetwork   *testcontainers.DockerNetwork
-	nodeNames        []string
-	clusterToken     string
-	additionalArgs   []string
-	mountDataDir     bool // flag needed to avoid extra calculations with the lifecycle hooks
-	containerRequest *testcontainers.ContainerRequest
+	currentNode    int
+	clusterNetwork *testcontainers.DockerNetwork
+	nodeNames      []string
+	clusterToken   string
+	additionalArgs []string
+	mountDataDir   bool // flag needed to avoid extra calculations with the lifecycle hooks
 }
 
-func defaultOptions(req *testcontainers.ContainerRequest) options {
+func defaultOptions() options {
 	return options{
-		clusterToken:     defaultClusterToken,
-		containerRequest: req,
+		clusterToken: defaultClusterToken,
 	}
 }
 
 // Compiler check to ensure that Option implements the testcontainers.ContainerCustomizer interface.
 var _ testcontainers.ContainerCustomizer = (Option)(nil)
 
 // Option is an option for the Etcd container.
-type Option func(*options)
+type Option func(*options) error
 
 // Customize is a NOOP. It's defined to satisfy the testcontainers.ContainerCustomizer interface.
 func (o Option) Customize(*testcontainers.GenericContainerRequest) error {
@@ -40,68 +36,64 @@ func (o Option) Customize(*testcontainers.GenericContainerRequest) error {
 // WithAdditionalArgs is an option to pass additional arguments to the etcd container.
 // They will be appended last to the command line.
 func WithAdditionalArgs(args ...string) Option {
-	return func(o *options) {
+	return func(o *options) error {
 		o.additionalArgs = args
+		return nil
 	}
 }
 
 // WithDataDir is an option to mount the data directory, which is located at /data.etcd.
 // The option will add a lifecycle hook to the container to change the permissions of the data directory.
 func WithDataDir() Option {
-	return func(o *options) {
+	return func(o *options) error {
 		// Avoid extra calculations with the lifecycle hooks
 		o.mountDataDir = true
-
-		o.containerRequest.LifecycleHooks = append(o.containerRequest.LifecycleHooks, testcontainers.ContainerLifecycleHooks{
-			PostStarts: []testcontainers.ContainerHook{
-				func(ctx context.Context, c testcontainers.Container) error {
-					_, _, err := c.Exec(ctx, []string{"chmod", "o+rwx", "-R", dataDir}, tcexec.Multiplexed())
-					if err != nil {
-						return fmt.Errorf("chmod etcd data dir: %w", err)
-					}
-
-					return nil
-				},
-			},
-		})
+		return nil
 	}
 }
 
 // WithNodes is an option to set the nodes of the etcd cluster.
 // It should be used to create a cluster with more than one node.
 func WithNodes(node1 string, node2 string, nodes ...string) Option {
-	return func(o *options) {
+	return func(o *options) error {
 		o.nodeNames = append([]string{node1, node2}, nodes...)
+		return nil
 	}
 }
 
 // withCurrentNode is an option to set the current node index.
 // It's an internal option and should not be used by the user.
 func withCurrentNode(i int) Option {
-	return func(o *options) {
+	return func(o *options) error {
 		o.currentNode = i
+		return nil
 	}
 }
 
 // withClusterNetwork is an option to set the cluster network.
 // It's an internal option and should not be used by the user.
 func withClusterNetwork(n *testcontainers.DockerNetwork) Option {
-	return func(o *options) {
+	return func(o *options) error {
 		o.clusterNetwork = n
+		return nil
 	}
 }
 
 // WithClusterToken is an option to set the cluster token.
 func WithClusterToken(token string) Option {
-	return func(o *options) {
+	return func(o *options) error {
 		o.clusterToken = token
+		return nil
 	}
 }
 
 func withClusterOptions(opts []Option) Option {
-	return func(o *options) {
+	return func(o *options) error {
 		for _, opt := range opts {
-			opt(o)
+			if err := opt(o); err != nil {
+				return fmt.Errorf("with cluster options: %w", err)
+			}
 		}
+		return nil
 	}
 }