fix: Trying to migrate some tests to use synctest

Author: yhakbar

internal/cas/store_test.go

@@ -148,7 +148,7 @@ func TestStore_LockConcurrency(t *testing.T) {
 		acquired <- true
 
 		// Hold lock briefly.
-		//nolint:synctestcheck // TODO migrate to synctest
+		//nolint:synctestcheck // sync.Mutex.Lock is not durably blocking under synctest, so a bubble would deadlock here
 		time.Sleep(100 * time.Millisecond)
 
 		err = lock.Unlock()

internal/remotestate/backend/s3/counting_semaphore_test.go

@@ -6,6 +6,7 @@ import (
 	"sync"
 	"sync/atomic"
 	"testing"
+	"testing/synctest"
 	"time"
 
 	s3backend "github.com/gruntwork-io/terragrunt/internal/remotestate/backend/s3"
@@ -26,47 +27,50 @@ func TestAwsCountingSemaphoreHappyPath(t *testing.T) {
 func TestAwsCountingSemaphoreConcurrency(t *testing.T) {
 	t.Parallel()
 
-	permits := 10
-	goroutines := 100
-	semaphore := s3backend.NewCountingSemaphore(permits)
+	synctest.Test(t, func(t *testing.T) {
+		permits := 10
+		goroutines := 100
+		semaphore := s3backend.NewCountingSemaphore(permits)
 
-	var (
-		goRoutinesExecutingSimultaneously uint32
-		waitForAllGoRoutinesToFinish      sync.WaitGroup
-	)
+		var (
+			goRoutinesExecutingSimultaneously uint32
+			waitForAllGoRoutinesToFinish      sync.WaitGroup
+		)
 
-	endGoRoutine := func() {
-		// Decrement the number of running goroutines. Note that decrementing an unsigned int is a bit odd.
-		// This is copied from the docs: https://golang.org/pkg/sync/atomic/#AddUint32
-		atomic.AddUint32(&goRoutinesExecutingSimultaneously, ^uint32(0))
+		endGoRoutine := func() {
+			// Decrement the number of running goroutines. Note that decrementing an unsigned int is a bit odd.
+			// This is copied from the docs: https://golang.org/pkg/sync/atomic/#AddUint32
+			atomic.AddUint32(&goRoutinesExecutingSimultaneously, ^uint32(0))
 
-		semaphore.Release()
-		waitForAllGoRoutinesToFinish.Done()
-	}
+			semaphore.Release()
+			waitForAllGoRoutinesToFinish.Done()
+		}
 
-	runGoRoutine := func() {
-		defer endGoRoutine()
+		runGoRoutine := func() {
+			defer endGoRoutine()
 
-		semaphore.Acquire()
+			semaphore.Acquire()
 
-		// Increment the total number of running goroutines
-		totalGoRoutinesExecutingSimultaneously := atomic.AddUint32(&goRoutinesExecutingSimultaneously, 1)
+			// Increment the total number of running goroutines
+			totalGoRoutinesExecutingSimultaneously := atomic.AddUint32(&goRoutinesExecutingSimultaneously, 1)
 
-		if totalGoRoutinesExecutingSimultaneously > uint32(permits) {
-			t.Fatalf("The semaphore was only supposed to allow %d goroutines to run simultaneously, but has allowed %d", permits, totalGoRoutinesExecutingSimultaneously)
-		}
+			if totalGoRoutinesExecutingSimultaneously > uint32(permits) {
+				t.Fatalf("The semaphore was only supposed to allow %d goroutines to run simultaneously, but has allowed %d", permits, totalGoRoutinesExecutingSimultaneously)
+			}
 
-		// Sleep for a random amount of time to represent this goroutine doing work
-		randomSleepTime := rand.Intn(100)
-		time.Sleep(time.Duration(randomSleepTime) * time.Millisecond) //nolint:synctestcheck // TODO migrate to synctest
-	}
+			// Sleep for a random amount of time to represent this goroutine doing work.
+			// Under synctest the clock is fake, so this is deterministic and free.
+			randomSleepTime := rand.Intn(100)
+			time.Sleep(time.Duration(randomSleepTime) * time.Millisecond)
+		}
 
-	// Fire up a whole bunch of goroutines that will all try to acquire the semaphore at the same time
-	for range goroutines {
-		waitForAllGoRoutinesToFinish.Add(1)
+		// Fire up a whole bunch of goroutines that will all try to acquire the semaphore at the same time
+		for range goroutines {
+			waitForAllGoRoutinesToFinish.Add(1)
 
-		go runGoRoutine()
-	}
+			go runGoRoutine()
+		}
 
-	waitForAllGoRoutinesToFinish.Wait()
+		waitForAllGoRoutinesToFinish.Wait()
+	})
 }