test(storage-incentives): add synctest to TestAgent (#5250)

Author: akrem-chabchoub

pkg/storageincentives/agent_test.go

@@ -10,6 +10,7 @@ import (
 	"math/big"
 	"sync"
 	"testing"
+	"testing/synctest"
 	"time"
 
 	"github.com/ethereum/go-ethereum/common"
@@ -95,66 +96,66 @@ func TestAgent(t *testing.T) {
 
 	for _, tc := range tests {
 		t.Run(tc.name, func(t *testing.T) {
-			t.Parallel()
+			synctest.Test(t, func(t *testing.T) {
+				wait := make(chan struct{}, 1)
+				addr := swarm.RandAddress(t)
+
+				backend := &mockchainBackend{
+					limit: tc.limit,
+					limitCallback: func() {
+						wait <- struct{}{}
+					},
+					incrementBy: tc.incrementBy,
+					block:       tc.blocksPerRound,
+					balance:     tc.balance,
+				}
 
-			wait := make(chan struct{})
-			addr := swarm.RandAddress(t)
+				var radius uint8 = 8
 
-			backend := &mockchainBackend{
-				limit: tc.limit,
-				limitCallback: func() {
-					select {
-					case wait <- struct{}{}:
-					default:
-					}
-				},
-				incrementBy: tc.incrementBy,
-				block:       tc.blocksPerRound,
-				balance:     tc.balance,
-			}
+				contract := &mockContract{t: t, expectedRadius: radius + tc.doubling}
 
-			var radius uint8 = 8
+				service, _ := createService(t, addr, backend, contract, tc.blocksPerRound, tc.blocksPerPhase, radius, tc.doubling)
+				testutil.CleanupCloser(t, service)
 
-			contract := &mockContract{t: t, expectedRadius: radius + tc.doubling}
+				<-wait
 
-			service, _ := createService(t, addr, backend, contract, tc.blocksPerRound, tc.blocksPerPhase, radius, tc.doubling)
-			testutil.CleanupCloser(t, service)
+				synctest.Wait()
 
-			<-wait
+				calls := contract.getCalls()
 
-			if !tc.expectedCalls {
-				if len(contract.callsList) > 0 {
-					t.Fatal("got unexpected calls")
-				} else {
+				if !tc.expectedCalls {
+					if len(calls) > 0 {
+						t.Fatal("got unexpected calls")
+					}
 					return
 				}
-			}
 
-			assertOrder := func(t *testing.T, want, got contractCall) {
-				t.Helper()
-				if want != got {
-					t.Fatalf("expected call %s, got %s", want, got)
+				if len(calls) == 0 {
+					t.Fatal("expected calls but got none")
 				}
-			}
 
-			contract.mtx.Lock()
-			defer contract.mtx.Unlock()
+				assertOrder := func(t *testing.T, want, got contractCall) {
+					t.Helper()
+					if want != got {
+						t.Fatalf("expected call %s, got %s", want, got)
+					}
+				}
 
-			prevCall := contract.callsList[0]
+				prevCall := calls[0]
 
-			for i := 1; i < len(contract.callsList); i++ {
+				for i := 1; i < len(calls); i++ {
+					switch calls[i] {
+					case isWinnerCall:
+						assertOrder(t, revealCall, prevCall)
+					case revealCall:
+						assertOrder(t, commitCall, prevCall)
+					case commitCall:
+						assertOrder(t, isWinnerCall, prevCall)
+					}
 
-				switch contract.callsList[i] {
-				case isWinnerCall:
-					assertOrder(t, revealCall, prevCall)
-				case revealCall:
-					assertOrder(t, commitCall, prevCall)
-				case commitCall:
-					assertOrder(t, isWinnerCall, prevCall)
+					prevCall = calls[i]
 				}
-
-				prevCall = contract.callsList[i]
-			}
+			})
 		})
 	}
 }
@@ -276,6 +277,18 @@ type mockContract struct {
 	t              *testing.T
 }
 
+// getCalls returns a snapshot of the calls list
+// even after synctest.Wait() all goroutines are blocked, we still should use locking
+// for defensive programming.
+func (m *mockContract) getCalls() []contractCall {
+	m.mtx.Lock()
+	defer m.mtx.Unlock()
+	// return a copy to avoid external modifications
+	calls := make([]contractCall, len(m.callsList))
+	copy(calls, m.callsList)
+	return calls
+}
+
 func (m *mockContract) ReserveSalt(context.Context) ([]byte, error) {
 	return nil, nil
 }