add test containers for SSH, PostgreSQL, MySQL, MongoDB, and LocalStack

Author: umputun

.github/workflows/ci.yml

@@ -14,7 +14,7 @@ jobs:
       - name: set up go 1.20
         uses: actions/setup-go@v4
         with:
-          go-version: "1.20"
+          go-version: "1.22"
         id: go
 
       - name: checkout

LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2023 go packages
+Copyright (c) 20235 Umputun
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

README.md

@@ -6,6 +6,83 @@ Package `testutils` provides useful test helpers.
 
 - `CaptureStdout`, `CaptureSterr` and `CaptureStdoutAndStderr`: capture stdout, stderr or both for testing purposes. All capture functions are not thread-safe if used in parallel tests, and usually it is better to pass a custom io.Writer to the function under test instead.
 
+- `containers`: provides test containers for integration testing:
+    - `SSHTestContainer`: SSH server container for testing SSH connections and operations
+    - `PostgresTestContainer`: PostgreSQL database container with automatic database creation
+    - `MySQLTestContainer`: MySQL database container with automatic database creation
+    - `MongoTestContainer`: MongoDB container with support for multiple versions (5, 6, 7)
+    - `LocalstackTestContainer`: LocalStack container with S3 service for AWS testing
+
 ## Install and update
 
 `go get -u github.com/go-pkgz/testutils`
+
+### Example usage:
+
+```go
+// PostgreSQL test container
+func TestWithPostgres(t *testing.T) {
+    ctx := context.Background()
+    pg := containers.NewPostgresTestContainer(ctx, t)
+    defer pg.Close(ctx)
+    
+    db, err := sql.Open("postgres", pg.ConnectionString())
+    require.NoError(t, err)
+    defer db.Close()
+    
+    // run your tests with the database
+}
+
+// MySQL test container
+func TestWithMySQL(t *testing.T) {
+    ctx := context.Background()
+    mysql := containers.NewMySQLTestContainer(ctx, t)
+    defer mysql.Close(ctx)
+    
+    db, err := sql.Open("mysql", mysql.DSN())
+    require.NoError(t, err)
+    defer db.Close()
+    
+    // run your tests with the database
+}
+
+// MongoDB test container
+func TestWithMongo(t *testing.T) {
+    ctx := context.Background()
+    mongo := containers.NewMongoTestContainer(ctx, t, 7) // version 7
+    defer mongo.Close(ctx)
+    
+    coll := mongo.Collection("test_db")
+    _, err := coll.InsertOne(ctx, bson.M{"test": "value"})
+    require.NoError(t, err)
+}
+
+// SSH test container
+func TestWithSSH(t *testing.T) {
+    ctx := context.Background()
+    ssh := containers.NewSSHTestContainer(ctx, t)
+    defer ssh.Close(ctx)
+    
+    // use ssh.Address() to get host:port
+    // default user is "test"
+    sshAddr := ssh.Address()
+}
+
+// Localstack (S3) test container
+func TestWithS3(t *testing.T) {
+    ctx := context.Background()
+    ls := containers.NewLocalstackTestContainer(ctx, t)
+    defer ls.Close(ctx)
+    
+    s3Client, bucketName := ls.MakeS3Connection(ctx, t)
+    
+    // put object example
+    _, err := s3Client.PutObject(ctx, &s3.PutObjectInput{
+        Bucket: aws.String(bucketName),
+        Key:    aws.String("test-key"),
+        Body:   strings.NewReader("test content"),
+    })
+    require.NoError(t, err)
+}
+```
+

capture.go

@@ -45,20 +45,20 @@ func CaptureStdoutAndStderr(t *testing.T, f func()) (o, e string) {
 	var wg sync.WaitGroup
 	wg.Add(2)
 
-	go func() {
+	go func() { //nolint
 		var buf bytes.Buffer
 		wg.Done()
 		if _, err := io.Copy(&buf, rOut); err != nil {
-			t.Fatal(err)
+			t.Fatal(err) //nolint
 		}
 		outCh <- buf.String()
 	}()
 
-	go func() {
+	go func() { //nolint
 		var buf bytes.Buffer
 		wg.Done()
 		if _, err := io.Copy(&buf, rErr); err != nil {
-			t.Fatal(err)
+			t.Fatal(err) //nolint
 		}
 		errCh <- buf.String()
 	}()
@@ -88,7 +88,7 @@ func capture(t *testing.T, out *os.File, f func()) string {
 
 	f()
 
-	w.Close()
+	_ = w.Close()
 
 	var buf bytes.Buffer
 	_, err = io.Copy(&buf, r)

containers/localstack.go

@@ -0,0 +1,85 @@
+package containers
+
+import (
+	"context"
+	"fmt"
+	"sync/atomic"
+	"testing"
+	"time"
+
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/config"
+	"github.com/aws/aws-sdk-go-v2/credentials"
+	"github.com/aws/aws-sdk-go-v2/service/s3"
+	"github.com/stretchr/testify/require"
+	"github.com/testcontainers/testcontainers-go"
+	"github.com/testcontainers/testcontainers-go/wait"
+)
+
+// LocalstackTestContainer is a wrapper around a testcontainers.Container that provides an S3 endpoint
+type LocalstackTestContainer struct {
+	Container testcontainers.Container
+	Endpoint  string
+	counter   atomic.Int64
+}
+
+// NewLocalstackTestContainer creates a new Localstack test container and returns a LocalstackTestContainer instance
+func NewLocalstackTestContainer(ctx context.Context, t *testing.T) *LocalstackTestContainer {
+	req := testcontainers.ContainerRequest{
+		Image:        "localstack/localstack:3.0.0",
+		ExposedPorts: []string{"4566/tcp"},
+		Env: map[string]string{
+			"SERVICES":              "s3",
+			"DEFAULT_REGION":        "us-east-1",
+			"AWS_ACCESS_KEY_ID":     "test",
+			"AWS_SECRET_ACCESS_KEY": "test",
+		},
+		WaitingFor: wait.ForAll(
+			wait.ForListeningPort("4566/tcp"),
+			wait.ForLog("Ready."),
+		).WithDeadline(time.Minute),
+	}
+
+	container, err := testcontainers.GenericContainer(ctx, testcontainers.GenericContainerRequest{
+		ContainerRequest: req,
+		Started:          true,
+	})
+	require.NoError(t, err)
+
+	host, err := container.Host(ctx)
+	require.NoError(t, err)
+
+	port, err := container.MappedPort(ctx, "4566")
+	require.NoError(t, err)
+
+	endpoint := fmt.Sprintf("http://%s:%s", host, port.Port())
+	return &LocalstackTestContainer{
+		Container: container,
+		Endpoint:  endpoint,
+	}
+}
+
+// MakeS3Connection creates a new S3 connection using the test container endpoint and returns the connection and a bucket name
+func (lc *LocalstackTestContainer) MakeS3Connection(ctx context.Context, t *testing.T) (client *s3.Client, bucketName string) {
+	cfg, err := config.LoadDefaultConfig(ctx,
+		config.WithRegion("us-east-1"),
+		config.WithCredentialsProvider(credentials.NewStaticCredentialsProvider("test", "test", "")),
+	)
+	require.NoError(t, err)
+
+	client = s3.NewFromConfig(cfg, func(o *s3.Options) {
+		o.BaseEndpoint = aws.String(lc.Endpoint)
+		o.UsePathStyle = true
+	})
+
+	bucketName = fmt.Sprintf("test-bucket-%d-%d", time.Now().UnixNano(), lc.counter.Add(1))
+	_, err = client.CreateBucket(ctx, &s3.CreateBucketInput{Bucket: aws.String(bucketName)})
+	require.NoError(t, err)
+
+	return client, bucketName
+}
+
+// Close terminates the container
+func (lc *LocalstackTestContainer) Close(ctx context.Context) error {
+	return lc.Container.Terminate(ctx)
+}

containers/localstack_test.go

@@ -0,0 +1,111 @@
+package containers
+
+import (
+	"context"
+	"io"
+	"strings"
+	"testing"
+
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/service/s3"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestLocalstackTestContainer(t *testing.T) {
+	ctx := context.Background()
+
+	t.Run("create and cleanup container", func(t *testing.T) {
+		ls := NewLocalstackTestContainer(ctx, t)
+		defer func() { require.NoError(t, ls.Close(ctx)) }()
+
+		assert.NotEmpty(t, ls.Endpoint)
+		assert.Contains(t, ls.Endpoint, "http://")
+	})
+
+	t.Run("make s3 connection", func(t *testing.T) {
+		ls := NewLocalstackTestContainer(ctx, t)
+		defer func() { require.NoError(t, ls.Close(ctx)) }()
+
+		client, bucketName := ls.MakeS3Connection(ctx, t)
+
+		// verify we can use the connection
+		buckets, err := client.ListBuckets(ctx, &s3.ListBucketsInput{})
+		require.NoError(t, err)
+		require.Len(t, buckets.Buckets, 1)
+		assert.Equal(t, bucketName, *buckets.Buckets[0].Name)
+	})
+
+	t.Run("s3 operations", func(t *testing.T) {
+		ls := NewLocalstackTestContainer(ctx, t)
+		defer func() { require.NoError(t, ls.Close(ctx)) }()
+
+		client, bucketName := ls.MakeS3Connection(ctx, t)
+
+		// test put object
+		_, err := client.PutObject(ctx, &s3.PutObjectInput{
+			Bucket: aws.String(bucketName),
+			Key:    aws.String("test-key"),
+			Body:   strings.NewReader("test content"),
+		})
+		require.NoError(t, err)
+
+		// test get object
+		result, err := client.GetObject(ctx, &s3.GetObjectInput{
+			Bucket: aws.String(bucketName),
+			Key:    aws.String("test-key"),
+		})
+		require.NoError(t, err)
+
+		content, err := io.ReadAll(result.Body)
+		require.NoError(t, err)
+		assert.Equal(t, "test content", string(content))
+	})
+
+	t.Run("multiple connections to same container", func(t *testing.T) {
+		ls := NewLocalstackTestContainer(ctx, t)
+		defer func() { require.NoError(t, ls.Close(ctx)) }()
+
+		client1, bucket1 := ls.MakeS3Connection(ctx, t)
+		client2, bucket2 := ls.MakeS3Connection(ctx, t)
+
+		// test operations with first client
+		_, err := client1.PutObject(ctx, &s3.PutObjectInput{
+			Bucket: aws.String(bucket1),
+			Key:    aws.String("test1"),
+			Body:   strings.NewReader("content1"),
+		})
+		require.NoError(t, err)
+
+		// test operations with second client
+		_, err = client2.PutObject(ctx, &s3.PutObjectInput{
+			Bucket: aws.String(bucket2),
+			Key:    aws.String("test2"),
+			Body:   strings.NewReader("content2"),
+		})
+		require.NoError(t, err)
+
+		// verify buckets are different
+		assert.NotEqual(t, bucket1, bucket2)
+
+		// verify first client can access its content
+		result1, err := client1.GetObject(ctx, &s3.GetObjectInput{
+			Bucket: aws.String(bucket1),
+			Key:    aws.String("test1"),
+		})
+		require.NoError(t, err)
+		content1, err := io.ReadAll(result1.Body)
+		require.NoError(t, err)
+		assert.Equal(t, "content1", string(content1))
+
+		// verify second client can access its content
+		result2, err := client2.GetObject(ctx, &s3.GetObjectInput{
+			Bucket: aws.String(bucket2),
+			Key:    aws.String("test2"),
+		})
+		require.NoError(t, err)
+		content2, err := io.ReadAll(result2.Body)
+		require.NoError(t, err)
+		assert.Equal(t, "content2", string(content2))
+	})
+}