fix(network): make test more reliable

Account for times that routing table is not setup when provide is called

Author: hannahhoward

benchmarks_test.go

@@ -157,21 +157,27 @@ func BenchmarkDupsManyNodesRealWorldNetwork(b *testing.B) {
 
 func BenchmarkDupsManyNodesRealWorldNetworkWithRealDHT(b *testing.B) {
 	benchmarkLog = nil
+	benchmarkSeed, err := strconv.ParseInt(os.Getenv("BENCHMARK_SEED"), 10, 64)
+	var randomGen *rand.Rand = nil
+	if err == nil {
+		randomGen = rand.New(rand.NewSource(benchmarkSeed))
+	}
+
 	fastNetworkDelayGenerator := tn.InternetLatencyDelayGenerator(
 		mediumSpeed-fastSpeed, slowSpeed-fastSpeed,
-		0.0, 0.0, distribution, nil)
+		0.0, 0.0, distribution, randomGen)
 	fastNetworkDelay := delay.Delay(fastSpeed, fastNetworkDelayGenerator)
-	fastBandwidthGenerator := tn.VariableRateLimitGenerator(fastBandwidth, fastBandwidthDeviation, nil)
+	fastBandwidthGenerator := tn.VariableRateLimitGenerator(fastBandwidth, fastBandwidthDeviation, randomGen)
 	averageNetworkDelayGenerator := tn.InternetLatencyDelayGenerator(
 		mediumSpeed-fastSpeed, slowSpeed-fastSpeed,
-		0.3, 0.3, distribution, nil)
+		0.3, 0.3, distribution, randomGen)
 	averageNetworkDelay := delay.Delay(fastSpeed, averageNetworkDelayGenerator)
-	averageBandwidthGenerator := tn.VariableRateLimitGenerator(mediumBandwidth, mediumBandwidthDeviation, nil)
+	averageBandwidthGenerator := tn.VariableRateLimitGenerator(mediumBandwidth, mediumBandwidthDeviation, randomGen)
 	slowNetworkDelayGenerator := tn.InternetLatencyDelayGenerator(
 		mediumSpeed-fastSpeed, superSlowSpeed-fastSpeed,
-		0.3, 0.3, distribution, nil)
+		0.3, 0.3, distribution, randomGen)
 	slowNetworkDelay := delay.Delay(fastSpeed, slowNetworkDelayGenerator)
-	slowBandwidthGenerator := tn.VariableRateLimitGenerator(slowBandwidth, slowBandwidthDeviation, nil)
+	slowBandwidthGenerator := tn.VariableRateLimitGenerator(slowBandwidth, slowBandwidthDeviation, randomGen)
 
 	b.Run("10Nodes-RandomRandom-BigBatch-FastNetwork", func(b *testing.B) {
 		subtestDistributeAndFetchWithRealDHT(b, 20, 10, fastNetworkDelay, fastBandwidthGenerator, stdBlockSize, starPattern, randomRandom, batchFetchAll)
@@ -219,40 +225,42 @@ func subtestDistributeAndFetchRateLimited(b *testing.B, numnodes, numblks int, d
 }
 
 func subtestDistributeAndFetchWithRealDHT(b *testing.B, numnodes, numblks int, d delay.D, rateLimitGenerator tn.RateLimitGenerator, blockSize int64, tf topologyFunc, df distFunc, ff fetchFunc) {
-	start := time.Now()
-	ctx := context.Background()
-	mn := mocknet.New(ctx)
-	routing := tn.NewDHTServer()
-	net, err := tn.StreamNet(ctx, mn, routing)
-	if err != nil {
-		b.Fatal("Unable to initialize mocknet")
-	}
+	for i := 0; i < b.N; i++ {
+		start := time.Now()
+		ctx := context.Background()
+		mn := mocknet.New(ctx)
+		routing := tn.NewDHTServer()
+		net, err := tn.StreamNet(ctx, mn, routing)
+		if err != nil {
+			b.Fatal("Unable to initialize mocknet")
+		}
 
-	ig := testinstance.NewTestInstanceGenerator(net)
-	defer ig.Close()
+		ig := testinstance.NewTestInstanceGenerator(net)
+		defer ig.Close()
 
-	var instances []testinstance.Instance
-	for j := 0; j < numnodes; j++ {
-		inst := ig.Next()
-		instances = append(instances, inst)
-	}
-	mn.LinkAll()
-	for i, inst := range instances {
-		// rate limit and delate connections
-		for j := i + 1; j < len(instances); j++ {
-			oinst := instances[j]
-			links := mn.LinksBetweenPeers(inst.Peer, oinst.Peer)
-			for _, link := range links {
-				link.SetOptions(mocknet.LinkOptions{Latency: d.NextWaitTime(), Bandwidth: rateLimitGenerator.NextRateLimit()})
+		var instances []testinstance.Instance
+		for j := 0; j < numnodes; j++ {
+			inst := ig.Next()
+			instances = append(instances, inst)
+		}
+		mn.LinkAll()
+		for i, inst := range instances {
+			// rate limit and delate connections
+			for j := i + 1; j < len(instances); j++ {
+				oinst := instances[j]
+				links := mn.LinksBetweenPeers(inst.Peer, oinst.Peer)
+				for _, link := range links {
+					link.SetOptions(mocknet.LinkOptions{Latency: d.NextWaitTime(), Bandwidth: rateLimitGenerator.NextRateLimit()})
+				}
 			}
 		}
-	}
 
-	tf(b, instances)
+		tf(b, instances)
 
-	blocks := testutil.GenerateBlocksOfSize(numblks, blockSize)
+		blocks := testutil.GenerateBlocksOfSize(numblks, blockSize)
 
-	runDistribution(b, instances, blocks, df, ff, start)
+		runDistribution(b, instances, blocks, df, ff, start)
+	}
 }
 
 func runDistribution(b *testing.B, instances []testinstance.Instance, blocks []blocks.Block, df distFunc, ff fetchFunc, start time.Time) {

network/ipfs_impl_test.go

@@ -10,7 +10,7 @@ import (
 	blocksutil "github.com/ipfs/go-ipfs-blocksutil"
 
 	"github.com/libp2p/go-libp2p-core/peer"
-	"github.com/libp2p/go-libp2p-testing/net"
+	tnet "github.com/libp2p/go-libp2p-testing/net"
 	mocknet "github.com/libp2p/go-libp2p/p2p/net/mock"
 )
 
@@ -196,7 +196,6 @@ func TestRealProviding(t *testing.T) {
 		t.Fatal("did not connect peer")
 	case <-r1.connectionEvent:
 	}
-	bsnet2.ConnectTo(ctx, p1.ID())
 	select {
 	case <-ctx.Done():
 		t.Fatal("did not connect peer")
@@ -208,7 +207,6 @@ func TestRealProviding(t *testing.T) {
 		t.Fatal("did not connect peer")
 	case <-r2.connectionEvent:
 	}
-	bsnet3.ConnectTo(ctx, p2.ID())
 	select {
 	case <-ctx.Done():
 		t.Fatal("did not connect peer")
@@ -229,9 +227,19 @@ func TestRealProviding(t *testing.T) {
 	blockGenerator := blocksutil.NewBlockGenerator()
 	block1 := blockGenerator.Next()
 	// provide on node 3
-	err = bsnet3.Provide(ctx, block1.Cid())
+	// DHT can setup routing table in seperate thread,
+	// meaning it's not finished even bitswap peers are connected
+	// so attempt a few times with delay
+provideLoop:
+	for i := 0; i < 5; i++ {
+		err = bsnet3.Provide(ctx, block1.Cid())
+		if err == nil {
+			break provideLoop
+		}
+		time.Sleep(10 * time.Millisecond)
+	}
 	if err != nil {
-		t.Fatal("Unable to provide node")
+		t.Fatalf("Unable to provide node: %s", err)
 	}
 	incomingProvders := bsnet1.FindProvidersAsync(ctx, block1.Cid(), 1)
 	select {