fix: flaky test timing

internal/peertimeoutmanager/peertimeoutmanager_test.go

@@ -36,13 +36,13 @@ func TestPeerTimeoutManagerNoTimeout(t *testing.T) {
 	ctx := context.Background()
 	p := testutil.GeneratePeers(1)[0]
 	tr := timeoutRecorder{}
-	tctx, cancel := context.WithTimeout(ctx, 10*time.Millisecond)
+	tctx, cancel := context.WithTimeout(ctx, 20*time.Millisecond)
 	defer cancel()
-	ptm := newPeerTimeoutManager(tctx, tr.onTimeout, 5*time.Millisecond)
+	ptm := newPeerTimeoutManager(tctx, tr.onTimeout, 10*time.Millisecond)
 
 	// Response received within timeout
 	ptm.RequestSent(p)
-	time.Sleep(time.Millisecond)
+	time.Sleep(5 * time.Millisecond)
 	ptm.ResponseReceived(p)
 
 	<-tctx.Done()
@@ -56,9 +56,9 @@ func TestPeerTimeoutManagerWithTimeout(t *testing.T) {
 	ctx := context.Background()
 	p := testutil.GeneratePeers(1)[0]
 	tr := timeoutRecorder{}
-	tctx, cancel := context.WithTimeout(ctx, 10*time.Millisecond)
+	tctx, cancel := context.WithTimeout(ctx, 20*time.Millisecond)
 	defer cancel()
-	ptm := newPeerTimeoutManager(tctx, tr.onTimeout, 5*time.Millisecond)
+	ptm := newPeerTimeoutManager(tctx, tr.onTimeout, 10*time.Millisecond)
 
 	// No response received within timeout
 	ptm.RequestSent(p)
@@ -97,16 +97,16 @@ func TestPeerTimeoutManagerMultiRequestResponseWithTimeout(t *testing.T) {
 	ctx := context.Background()
 	p := testutil.GeneratePeers(1)[0]
 	tr := timeoutRecorder{}
-	tctx, cancel := context.WithTimeout(ctx, 10*time.Millisecond)
+	tctx, cancel := context.WithTimeout(ctx, 20*time.Millisecond)
 	defer cancel()
-	ptm := newPeerTimeoutManager(tctx, tr.onTimeout, 5*time.Millisecond)
+	ptm := newPeerTimeoutManager(tctx, tr.onTimeout, 10*time.Millisecond)
 
 	// Response received within timeout
 	ptm.RequestSent(p)
-	time.Sleep(time.Millisecond)
+	time.Sleep(3 * time.Millisecond)
 	ptm.ResponseReceived(p)
 
-	time.Sleep(time.Millisecond)
+	time.Sleep(3 * time.Millisecond)
 
 	// Another request sent but no response before timeout
 	ptm.RequestSent(p)
@@ -122,27 +122,19 @@ func TestPeerTimeoutManagerMultiRequestResponseNoTimeout(t *testing.T) {
 	ctx := context.Background()
 	p := testutil.GeneratePeers(1)[0]
 	tr := timeoutRecorder{}
-	tctx, cancel := context.WithTimeout(ctx, 10*time.Millisecond)
+	tctx, cancel := context.WithTimeout(ctx, 20*time.Millisecond)
 	defer cancel()
-	ptm := newPeerTimeoutManager(tctx, tr.onTimeout, 5*time.Millisecond)
+	ptm := newPeerTimeoutManager(tctx, tr.onTimeout, 10*time.Millisecond)
 
 	// Several requests and responses sent, all within timeout individually
 	// but combined time more than timeout
-	ptm.RequestSent(p)
-	time.Sleep(time.Millisecond) //     +1 = 1
-	ptm.ResponseReceived(p)
-
-	time.Sleep(2 * time.Millisecond) // +2 = 3
-
-	ptm.RequestSent(p)
-	time.Sleep(time.Millisecond) //     +1 = 4
-	ptm.ResponseReceived(p)
-
-	time.Sleep(2 * time.Millisecond) // +2 = 6
+	for i := 0; i < 7; i++ {
+		ptm.RequestSent(p)
+		time.Sleep(time.Millisecond) // +1ms
+		ptm.ResponseReceived(p)
 
-	ptm.RequestSent(p)
-	time.Sleep(time.Millisecond) //     +1 = 7
-	ptm.ResponseReceived(p)
+		time.Sleep(time.Millisecond) // +1ms
+	}
 
 	<-tctx.Done()
 
@@ -157,14 +149,14 @@ func TestPeerTimeoutManagerWithSomePeersTimeout(t *testing.T) {
 	p1 := peers[0]
 	p2 := peers[1]
 	tr := timeoutRecorder{}
-	tctx, cancel := context.WithTimeout(ctx, 10*time.Millisecond)
+	tctx, cancel := context.WithTimeout(ctx, 20*time.Millisecond)
 	defer cancel()
-	ptm := newPeerTimeoutManager(tctx, tr.onTimeout, 5*time.Millisecond)
+	ptm := newPeerTimeoutManager(tctx, tr.onTimeout, 10*time.Millisecond)
 
 	// Send request to p1 and p2 but only receive response from p1
 	ptm.RequestSent(p1)
 	ptm.RequestSent(p2)
-	time.Sleep(2 * time.Millisecond)
+	time.Sleep(5 * time.Millisecond)
 	ptm.ResponseReceived(p1)
 
 	<-tctx.Done()
@@ -205,9 +197,9 @@ func TestPeerTimeoutManagerWithManyRequests(t *testing.T) {
 	// GC mechanism kicks in
 	peers := testutil.GeneratePeers(requestGCCount * 3)
 
-	tctx, cancel := context.WithTimeout(ctx, 100*time.Millisecond)
+	tctx, cancel := context.WithTimeout(ctx, 200*time.Millisecond)
 	defer cancel()
-	ptm := newPeerTimeoutManager(tctx, tr.onTimeout, 50*time.Millisecond)
+	ptm := newPeerTimeoutManager(tctx, tr.onTimeout, 100*time.Millisecond)
 
 	// Make batches of 5 peers
 	expTimeout := int32(0)
@@ -261,7 +253,7 @@ func TestPeerTimeoutManagerWithManyRequests(t *testing.T) {
 	<-tctx.Done()
 
 	if tr.timedOutCount() != int(expTimeout) {
-		t.Fatal("Expected only some peer requests to time out", tr.timedOutCount(), expTimeout)
+		t.Fatal(fmt.Sprintf("Expected %d peer requests to time out, but %d timed out", expTimeout, tr.timedOutCount()))
 	}
 }