Refactor tests to use shared MongoDB and CouchDB containers, simplify container setup logic, and consolidate state management methods.

Author: starichkov

.github/workflows/build.yml

@@ -2,7 +2,7 @@ name: Build and Test
 
 env:
   GO_LATEST: '1.24.8'
-  DOCKER_COMPOSE_VERSION: 'v2.39.2'
+  DOCKER_COMPOSE_VERSION: 'v2.39.4'
 
 on:
   push:

app_test.go

@@ -10,8 +10,6 @@ import (
 	"golang-simple-notes/model"
 	"golang-simple-notes/storage"
 
-	"github.com/testcontainers/testcontainers-go"
-	"github.com/testcontainers/testcontainers-go/modules/mongodb"
 	"go.mongodb.org/mongo-driver/mongo"
 	"go.mongodb.org/mongo-driver/mongo/options"
 )
@@ -47,18 +45,16 @@ func TestApp_Initialize(t *testing.T) {
 func TestApp_InitializeWithCouchDB(t *testing.T) {
 	ctx := context.Background()
 
-	// Start CouchDB container
-	couchContainer, couchURL, err := startCouchDBContainer(ctx)
-	if err != nil {
-		t.Fatalf("Failed to start CouchDB container: %v", err)
+	// Use the shared CouchDB container
+	couchURL := sharedCouchURL
+	if couchURL == "" {
+		t.Skip("Shared CouchDB container not available")
 	}
+
 	defer func() {
 		// Clean up: delete the notes database
 		req, _ := http.NewRequest(http.MethodDelete, couchURL+"/notes", nil)
 		http.DefaultClient.Do(req)
-		if err := couchContainer.Terminate(ctx); err != nil {
-			t.Fatalf("Failed to terminate CouchDB container: %v", err)
-		}
 	}()
 
 	// Create app with CouchDB config
@@ -71,7 +67,7 @@ func TestApp_InitializeWithCouchDB(t *testing.T) {
 	}
 
 	app := NewApp(config)
-	err = app.Initialize(ctx)
+	err := app.Initialize(ctx)
 	if err != nil {
 		t.Fatalf("Failed to initialize app: %v", err)
 	}
@@ -118,30 +114,21 @@ func TestApp_InitializeWithCouchDB(t *testing.T) {
 func TestApp_InitializeWithMongoDB(t *testing.T) {
 	ctx := context.Background()
 
-	// Start MongoDB container
-	mongoContainer, err := mongodb.RunContainer(ctx, testcontainers.WithImage("mongo:7.0.23-jammy"))
-	if err != nil {
-		t.Fatalf("Failed to start MongoDB container: %v", err)
+	// Use the shared MongoDB container
+	mongoURI := sharedMongoURI
+	if mongoURI == "" {
+		t.Skip("Shared MongoDB container not available")
 	}
+
 	defer func() {
 		// Clean up: drop the notes collection
-		mongoURI, _ := mongoContainer.ConnectionString(ctx)
 		client, err := mongo.Connect(ctx, options.Client().ApplyURI(mongoURI))
 		if err == nil {
 			_ = client.Database("notes").Collection("notes").Drop(ctx)
 			_ = client.Disconnect(ctx)
 		}
-		if err := mongoContainer.Terminate(ctx); err != nil {
-			t.Fatalf("Failed to terminate MongoDB container: %v", err)
-		}
 	}()
 
-	// Get MongoDB connection details
-	mongoURI, err := mongoContainer.ConnectionString(ctx)
-	if err != nil {
-		t.Fatalf("Failed to get MongoDB connection string: %v", err)
-	}
-
 	// Create app with MongoDB config
 	config := &Config{
 		StorageType:       "mongodb",
@@ -153,7 +140,7 @@ func TestApp_InitializeWithMongoDB(t *testing.T) {
 	}
 
 	app := NewApp(config)
-	err = app.Initialize(ctx)
+	err := app.Initialize(ctx)
 	if err != nil {
 		t.Fatalf("Failed to initialize app: %v", err)
 	}

main_test.go

@@ -2,15 +2,235 @@ package main
 
 import (
 	"context"
+	"encoding/json"
 	"fmt"
+	"log"
+	"os"
+	"path/filepath"
+	"testing"
+	"time"
 
 	"golang-simple-notes/model"
 	"golang-simple-notes/storage"
 
 	"github.com/testcontainers/testcontainers-go"
+	"github.com/testcontainers/testcontainers-go/modules/mongodb"
 	"github.com/testcontainers/testcontainers-go/wait"
 )
 
+var (
+	// Shared container instances for all tests in the main package
+	sharedMongoContainer    testcontainers.Container
+	sharedMongoURI          string
+	sharedCouchContainer    testcontainers.Container
+	sharedCouchURL          string
+	shouldCleanupContainers bool
+)
+
+// containerState holds the connection details for shared containers
+type containerState struct {
+	MongoURI string `json:"mongo_uri"`
+	CouchURL string `json:"couch_url"`
+	OwnerPID int    `json:"owner_pid"`
+}
+
+// getStateFilePath returns the path to the shared state file
+func getStateFilePath() string {
+	return filepath.Join(os.TempDir(), "testcontainers-shared-state.json")
+}
+
+// getLockFilePath returns the path to the lock file
+func getLockFilePath() string {
+	return filepath.Join(os.TempDir(), "testcontainers-shared-state.lock")
+}
+
+// acquireLock attempts to acquire a file-based lock
+func acquireLock() (*os.File, error) {
+	lockFile := getLockFilePath()
+	// Try to create lock file exclusively
+	for i := 0; i < 50; i++ {
+		f, err := os.OpenFile(lockFile, os.O_CREATE|os.O_EXCL|os.O_WRONLY, 0644)
+		if err == nil {
+			// Write our PID to the lock file
+			fmt.Fprintf(f, "%d", os.Getpid())
+			return f, nil
+		}
+		// Lock file exists, wait and retry
+		time.Sleep(100 * time.Millisecond)
+	}
+	return nil, fmt.Errorf("failed to acquire lock after 5 seconds")
+}
+
+// releaseLock releases the file-based lock
+func releaseLock(f *os.File) {
+	if f != nil {
+		f.Close()
+		os.Remove(getLockFilePath())
+	}
+}
+
+// loadContainerState loads the container state from file
+func loadContainerState() (*containerState, error) {
+	stateFile := getStateFilePath()
+	data, err := os.ReadFile(stateFile)
+	if err != nil {
+		return nil, err
+	}
+
+	var state containerState
+	if err := json.Unmarshal(data, &state); err != nil {
+		return nil, err
+	}
+
+	return &state, nil
+}
+
+// saveContainerState saves the container state to file
+func saveContainerState(state *containerState) error {
+	stateFile := getStateFilePath()
+	data, err := json.Marshal(state)
+	if err != nil {
+		return err
+	}
+
+	return os.WriteFile(stateFile, data, 0644)
+}
+
+// TestMain sets up shared test containers for the main package
+func TestMain(m *testing.M) {
+	ctx := context.Background()
+
+	// Acquire lock to prevent race condition with other packages
+	lock, err := acquireLock()
+	if err != nil {
+		log.Printf("Warning: Failed to acquire lock: %v. Tests may fail.", err)
+		os.Exit(1)
+	}
+
+	// Try to load existing container state
+	state, err := loadContainerState()
+	if err == nil && state != nil {
+		// Reuse existing containers from another package
+		log.Printf("Reusing existing MongoDB container at %s", state.MongoURI)
+		log.Printf("Reusing existing CouchDB container at %s", state.CouchURL)
+		sharedMongoURI = state.MongoURI
+		sharedCouchURL = state.CouchURL
+		shouldCleanupContainers = false
+		releaseLock(lock)
+	} else {
+		// Start new containers and save state
+		shouldCleanupContainers = true
+
+		// Start shared MongoDB container
+		if err := startSharedMongoDBContainer(ctx); err != nil {
+			log.Printf("Warning: Failed to start shared MongoDB container: %v. MongoDB tests may fail.", err)
+		}
+
+		// Start shared CouchDB container
+		if err := startSharedCouchDBContainer(ctx); err != nil {
+			log.Printf("Warning: Failed to start shared CouchDB container: %v. CouchDB tests may fail.", err)
+		}
+
+		// Save container state for other packages to reuse
+		if sharedMongoURI != "" && sharedCouchURL != "" {
+			state := &containerState{
+				MongoURI: sharedMongoURI,
+				CouchURL: sharedCouchURL,
+				OwnerPID: os.Getpid(),
+			}
+			if err := saveContainerState(state); err != nil {
+				log.Printf("Warning: Failed to save container state: %v", err)
+			}
+		}
+
+		releaseLock(lock)
+	}
+
+	// Run tests
+	code := m.Run()
+
+	// Cleanup containers only if we started them
+	if shouldCleanupContainers {
+		cleanupCtx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+		defer cancel()
+
+		if sharedMongoContainer != nil {
+			if err := sharedMongoContainer.Terminate(cleanupCtx); err != nil {
+				log.Printf("Failed to terminate MongoDB container: %v", err)
+			}
+		}
+
+		if sharedCouchContainer != nil {
+			if err := sharedCouchContainer.Terminate(cleanupCtx); err != nil {
+				log.Printf("Failed to terminate CouchDB container: %v", err)
+			}
+		}
+
+		// Clean up state file
+		os.Remove(getStateFilePath())
+	}
+
+	os.Exit(code)
+}
+
+func startSharedMongoDBContainer(ctx context.Context) error {
+	container, err := mongodb.RunContainer(ctx, testcontainers.WithImage("mongo:7.0.23-jammy"))
+	if err != nil {
+		return fmt.Errorf("failed to start MongoDB container: %w", err)
+	}
+
+	sharedMongoContainer = container
+
+	// Get connection string
+	mongoURI, err := container.ConnectionString(ctx)
+	if err != nil {
+		return fmt.Errorf("failed to get MongoDB connection string: %w", err)
+	}
+
+	sharedMongoURI = mongoURI
+
+	log.Printf("Started shared MongoDB container at %s", sharedMongoURI)
+	return nil
+}
+
+func startSharedCouchDBContainer(ctx context.Context) error {
+	req := testcontainers.ContainerRequest{
+		Image:        "couchdb:3.4.3",
+		ExposedPorts: []string{"5984/tcp"},
+		WaitingFor:   wait.ForListeningPort("5984/tcp"),
+		Env: map[string]string{
+			"COUCHDB_USER":     "admin",
+			"COUCHDB_PASSWORD": "password",
+		},
+	}
+
+	container, err := testcontainers.GenericContainer(ctx, testcontainers.GenericContainerRequest{
+		ContainerRequest: req,
+		Started:          true,
+	})
+	if err != nil {
+		return fmt.Errorf("failed to start CouchDB container: %w", err)
+	}
+
+	sharedCouchContainer = container
+
+	// Get connection details
+	host, err := container.Host(ctx)
+	if err != nil {
+		return fmt.Errorf("failed to get CouchDB container host: %w", err)
+	}
+
+	port, err := container.MappedPort(ctx, "5984")
+	if err != nil {
+		return fmt.Errorf("failed to get CouchDB container port: %w", err)
+	}
+
+	sharedCouchURL = fmt.Sprintf("http://admin:password@%s:%s", host, port.Port())
+
+	log.Printf("Started shared CouchDB container at %s", sharedCouchURL)
+	return nil
+}
+
 // MockStorage is a simple implementation of NoteStorage for testing
 type MockStorage struct {
 	notes []*model.Note