test: integrate synctest

pkg/api/gsoc_test.go

@@ -104,6 +104,7 @@ func TestGsocWebsocketMultiHandler(t *testing.T) {
 // The test opens a websocket, keeps it alive for 500ms, then receives a GSOC message.
 func TestGsocPong(t *testing.T) {
 	t.Parallel()
+
 	id := make([]byte, 32)
 
 	var (

pkg/blocker/blocker_test.go

@@ -7,6 +7,7 @@ package blocker_test
 import (
 	"os"
 	"testing"
+	"testing/synctest"
 	"time"
 
 	"go.uber.org/goleak"
@@ -38,96 +39,102 @@ func TestMain(m *testing.M) {
 func TestBlocksAfterFlagTimeout(t *testing.T) {
 	t.Parallel()
 
-	addr := swarm.RandAddress(t)
-	blockedC := make(chan swarm.Address, 10)
+	synctest.Test(t, func(t *testing.T) {
+		addr := swarm.RandAddress(t)
+		blockedC := make(chan swarm.Address, 10)
 
-	mock := mockBlockLister(func(a swarm.Address, d time.Duration, r string) error {
-		blockedC <- a
+		mock := mockBlockLister(func(a swarm.Address, d time.Duration, r string) error {
+			blockedC <- a
 
-		if d != blockTime {
-			t.Fatalf("block time: want %v, got %v", blockTime, d)
-		}
+			if d != blockTime {
+				t.Fatalf("block time: want %v, got %v", blockTime, d)
+			}
 
-		return nil
-	})
+			return nil
+		})
 
-	b := blocker.New(mock, flagTime, blockTime, time.Millisecond, nil, log.Noop)
-	testutil.CleanupCloser(t, b)
+		b := blocker.New(mock, flagTime, blockTime, time.Millisecond, nil, log.Noop)
+		testutil.CleanupCloser(t, b)
 
-	// Flagging address shouldn't block it immediately
-	b.Flag(addr)
-	if len(blockedC) != 0 {
-		t.Fatal("blocker did not wait flag duration")
-	}
+		// Flagging address shouldn't block it immediately
+		b.Flag(addr)
+		if len(blockedC) != 0 {
+			t.Fatal("blocker did not wait flag duration")
+		}
 
-	time.Sleep(flagTime / 2)
-	b.Flag(addr) // check that this flag call does not override previous call
-	if len(blockedC) != 0 {
-		t.Fatal("blocker did not wait flag duration")
-	}
+		time.Sleep(flagTime / 2)
+		b.Flag(addr) // check that this flag call does not override previous call
+		if len(blockedC) != 0 {
+			t.Fatal("blocker did not wait flag duration")
+		}
 
-	// Suspending current goroutine and expect that in this interval
-	// block listener was called to block flagged address
-	time.Sleep(flagTime * 3)
+		// Suspending current goroutine and expect that in this interval
+		// block listener was called to block flagged address
+		time.Sleep(flagTime * 3)
 
-	if a := <-blockedC; !a.Equal(addr) {
-		t.Fatalf("expecting flagged address to be blocked")
-	}
-	if len(blockedC) != 0 {
-		t.Fatalf("address should only be blocked once")
-	}
+		if a := <-blockedC; !a.Equal(addr) {
+			t.Fatalf("expecting flagged address to be blocked")
+		}
+		if len(blockedC) != 0 {
+			t.Fatalf("address should only be blocked once")
+		}
+	})
 }
 
 func TestUnflagBeforeBlock(t *testing.T) {
 	t.Parallel()
 
-	addr := swarm.RandAddress(t)
-	mock := mockBlockLister(func(a swarm.Address, d time.Duration, r string) error {
-		t.Fatalf("address should not be blocked")
+	synctest.Test(t, func(t *testing.T) {
+		addr := swarm.RandAddress(t)
+		mock := mockBlockLister(func(a swarm.Address, d time.Duration, r string) error {
+			t.Fatalf("address should not be blocked")
 
-		return nil
-	})
+			return nil
+		})
 
-	b := blocker.New(mock, flagTime, blockTime, time.Millisecond, nil, log.Noop)
-	testutil.CleanupCloser(t, b)
+		b := blocker.New(mock, flagTime, blockTime, time.Millisecond, nil, log.Noop)
+		testutil.CleanupCloser(t, b)
 
-	// Flagging address shouldn't block it imidietly
-	b.Flag(addr)
+		// Flagging address shouldn't block it imidietly
+		b.Flag(addr)
 
-	time.Sleep(flagTime / 2)
-	b.Flag(addr) // check that this flag call does not override previous call
+		time.Sleep(flagTime / 2)
+		b.Flag(addr) // check that this flag call does not override previous call
 
-	b.Unflag(addr)
+		b.Unflag(addr)
 
-	// Suspending current goroutine and expect that in this interval
-	// block listener was not called to block flagged address
-	time.Sleep(flagTime * 3)
+		// Suspending current goroutine and expect that in this interval
+		// block listener was not called to block flagged address
+		time.Sleep(flagTime * 3)
+	})
 }
 
 func TestPruneBeforeBlock(t *testing.T) {
 	t.Parallel()
 
-	addr := swarm.RandAddress(t)
-	mock := mockBlockLister(func(a swarm.Address, d time.Duration, r string) error {
-		t.Fatalf("address should not be blocked")
+	synctest.Test(t, func(t *testing.T) {
+		addr := swarm.RandAddress(t)
+		mock := mockBlockLister(func(a swarm.Address, d time.Duration, r string) error {
+			t.Fatalf("address should not be blocked")
 
-		return nil
-	})
+			return nil
+		})
 
-	b := blocker.New(mock, flagTime, blockTime, time.Millisecond, nil, log.Noop)
-	testutil.CleanupCloser(t, b)
+		b := blocker.New(mock, flagTime, blockTime, time.Millisecond, nil, log.Noop)
+		testutil.CleanupCloser(t, b)
 
-	// Flagging address shouldn't block it imidietly
-	b.Flag(addr)
+		// Flagging address shouldn't block it imidietly
+		b.Flag(addr)
 
-	time.Sleep(flagTime / 2)
+		time.Sleep(flagTime / 2)
 
-	// communicate that we have seen no peers, resulting in the peer being removed
-	b.PruneUnseen([]swarm.Address{})
+		// communicate that we have seen no peers, resulting in the peer being removed
+		b.PruneUnseen([]swarm.Address{})
 
-	// Suspending current goroutine expect that in this interval
-	// block listener was not called to block flagged address
-	time.Sleep(flagTime * 3)
+		// Suspending current goroutine expect that in this interval
+		// block listener was not called to block flagged address
+		time.Sleep(flagTime * 3)
+	})
 }
 
 type blocklister struct {