testing: add lock/locktesting

Author: mfridman

internal/testing/integration/locking/postgres_table_locking_test.go

@@ -9,9 +9,9 @@ import (
 	"time"
 
 	"github.com/pressly/goose/v3"
-	"github.com/pressly/goose/v3/internal/testing/locktest"
 	"github.com/pressly/goose/v3/internal/testing/testdb"
 	"github.com/pressly/goose/v3/lock"
+	"github.com/pressly/goose/v3/lock/locktesting"
 	"github.com/pressly/goose/v3/testdata"
 	"github.com/stretchr/testify/require"
 )
@@ -43,7 +43,7 @@ func TestConcurrentTableLocking(t *testing.T) {
 		return locker
 	}
 
-	locktest.TestConcurrentLocking(t, db, newLocker, 1*time.Second)
+	locktesting.TestConcurrentLocking(t, db, newLocker, 1*time.Second)
 }
 
 func TestSequentialTableLocking(t *testing.T) {
@@ -119,7 +119,7 @@ func TestLockerImplementations(t *testing.T) {
 		// Use the same lock ID for all providers so they compete for the same table row
 		sharedLockID := rand.Int64()
 
-		locktest.TestProviderLocking(t, func(t *testing.T) *goose.Provider {
+		locktesting.TestProviderLocking(t, func(t *testing.T) *goose.Provider {
 			t.Helper()
 
 			// Create a UNIQUE table-based locker instance per provider, but same lock ID
@@ -153,7 +153,7 @@ func TestLockerImplementations(t *testing.T) {
 		)
 		require.NoError(t, err)
 
-		locktest.TestProviderLocking(t, func(t *testing.T) *goose.Provider {
+		locktesting.TestProviderLocking(t, func(t *testing.T) *goose.Provider {
 			t.Helper()
 
 			p, err := goose.NewProvider(
@@ -176,7 +176,7 @@ func TestLockerImplementations(t *testing.T) {
 		// Use the same lock ID for all providers so they compete for the same advisory lock
 		sharedLockID := rand.Int64()
 
-		locktest.TestProviderLocking(t, func(t *testing.T) *goose.Provider {
+		locktesting.TestProviderLocking(t, func(t *testing.T) *goose.Provider {
 			t.Helper()
 
 			// Each provider gets a UNIQUE session locker instance, but same lock ID
@@ -211,7 +211,7 @@ func TestLockerImplementations(t *testing.T) {
 		)
 		require.NoError(t, err)
 
-		locktest.TestProviderLocking(t, func(t *testing.T) *goose.Provider {
+		locktesting.TestProviderLocking(t, func(t *testing.T) *goose.Provider {
 			t.Helper()
 
 			p, err := goose.NewProvider(

internal/testing/locktest/locktest.go lock/locktesting/locktesting.gointernal/testing/locktest/locktest.go renamed to lock/locktesting/locktesting.go

@@ -1,10 +1,9 @@
-package locktest
+package locktesting
 
 import (
 	"context"
 	"database/sql"
 	"fmt"
-	"log/slog"
 	"sync"
 	"testing"
 	"time"
@@ -56,7 +55,7 @@ func TestProviderLocking(
 
 	for i := range count {
 		g.Go(func() error {
-			ctx := t.Context()
+			ctx := context.Background()
 			migrationResults, err := providers[i].Up(ctx)
 			if err != nil {
 				return err
@@ -123,13 +122,14 @@ func TestConcurrentLocking(
 	lockTimeout time.Duration,
 ) {
 	t.Helper()
+	ctx := context.Background()
 
 	// TODO(mf): I wonder if there's a better way to do logging in tests that conditionally enables
 	// it. Maybe using testing.T.Log? But that doesn't have levels. Maybe use a global flag to
 	// enable debug logging in tests?
 
 	// logger := slog.New(slog.NewTextHandler(os.Stderr, &slog.HandlerOptions{Level: slog.LevelDebug}))
-	logger := slog.New(slog.DiscardHandler)
+	// logger := slog.New(slog.DiscardHandler)
 
 	// Number of concurrent lockers to test
 	const count = 5
@@ -149,27 +149,27 @@ func TestConcurrentLocking(
 		go func() {
 			defer wg.Done()
 
-			ctx, cancel := context.WithTimeout(t.Context(), lockTimeout)
+			ctx, cancel := context.WithTimeout(ctx, lockTimeout)
 			defer cancel()
 
 			// Try to acquire the lock
 			if err := lockers[i].Lock(ctx, db); err != nil {
-				logger.Debug("Locker failed to acquire lock", slog.Int("locker", i), slog.String("error", err.Error()))
+				// logger.Debug("Locker failed to acquire lock", slog.Int("locker", i), slog.String("error", err.Error()))
 				return
 			}
 
 			successCh <- i
-			logger.Debug("Locker acquired lock", slog.Int("locker", i))
+			// logger.Debug("Locker acquired lock", slog.Int("locker", i))
 
 			// Hold the lock long enough for all other goroutines to exhaust their retries. This
 			// ensures only ONE locker succeeds in the concurrent test
 			time.Sleep(lockTimeout * 2)
 
 			// Release the lock
-			if err := lockers[i].Unlock(t.Context(), db); err != nil {
+			if err := lockers[i].Unlock(ctx, db); err != nil {
 				t.Errorf("Locker %d failed to release lock: %v", i, err)
 			} else {
-				logger.Debug("Locker released lock", slog.Int("locker", i))
+				// logger.Debug("Locker released lock", slog.Int("locker", i))
 			}
 		}()
 	}
@@ -195,5 +195,5 @@ func TestConcurrentLocking(
 	}
 
 	require.Equal(t, 1, len(successful), "Exactly one locker should acquire the lock")
-	logger.Debug("Concurrent locking test passed", slog.Int("winning_locker", successful[0]))
+	// logger.Debug("Concurrent locking test passed", slog.Int("winning_locker", successful[0]))
 }