Skip to content

Commit

Permalink
TestDiscovery_ConnectedPopulatesRoutingTable fix (#1745)
Browse files Browse the repository at this point in the history
  • Loading branch information
@igorcrevar
igorcrevar committed Jul 25, 2023
1 parent 2d3e101 commit bbbe3ab
Show file tree
Hide file tree
Showing 2 changed files with 40 additions and 63 deletions.
99 changes: 38 additions & 61 deletions network/discovery_e2e_test.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -6,6 +6,7 @@ import (
"time"

"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)

func discoveryConfig(c *Config) {
Expand All @@ -18,21 +19,23 @@ func discoveryConfig(c *Config) {
func TestDiscovery_ConnectedPopulatesRoutingTable(t *testing.T) {
// when two nodes connect, they populate their kademlia routing tables
servers, createErr := createServers(2, nil)
if createErr != nil {
t.Fatalf("Unable to create servers, %v", createErr)
}
require.NoError(t, createErr)

ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)

t.Cleanup(func() {
cancel()
closeTestServers(t, servers)
})

joinErr := JoinAndWait(servers[0], servers[1], DefaultBufferTimeout, DefaultJoinTimeout)
if joinErr != nil {
t.Fatalf("Unable to join peers, %v", joinErr)
}
require.NoError(t, JoinAndWait(servers[0], servers[1], DefaultBufferTimeout, DefaultJoinTimeout))

// make sure each routing table has peer
_, err := WaitUntilRoutingTableIsFilled(ctx, servers[0], 1)
require.NoError(t, err, "server 0 should add a peer to routing table but didn't, peer=%s", servers[1].host.ID())

assert.Equal(t, servers[0].discovery.RoutingTableSize(), 1)
assert.Equal(t, servers[1].discovery.RoutingTableSize(), 1)
_, err = WaitUntilRoutingTableIsFilled(ctx, servers[1], 1)
require.NoError(t, err, "server 1 should add a peer to routing table but didn't, peer=%s", servers[0].host.ID())
}

func TestRoutingTable_Connected(t *testing.T) {
Expand All @@ -48,17 +51,13 @@ func TestRoutingTable_Connected(t *testing.T) {
}

servers, createErr := createServers(2, paramsMap)
if createErr != nil {
t.Fatalf("Unable to create servers, %v", createErr)
}
require.NoError(t, createErr)

t.Cleanup(func() {
closeTestServers(t, servers)
})

if joinErr := JoinAndWait(servers[0], servers[1], DefaultBufferTimeout, DefaultJoinTimeout); joinErr != nil {
t.Fatalf("Unable to join peers, %v", joinErr)
}
require.NoError(t, JoinAndWait(servers[0], servers[1], DefaultBufferTimeout, DefaultJoinTimeout))

// make sure each routing table has peer
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
Expand All @@ -67,13 +66,11 @@ func TestRoutingTable_Connected(t *testing.T) {
cancel()
})

if _, err := WaitUntilRoutingTableToBeFilled(ctx, servers[0], 1); err != nil {
t.Fatalf("server 0 should add a peer to routing table but didn't, peer=%s", servers[1].host.ID())
}
_, err := WaitUntilRoutingTableIsFilled(ctx, servers[0], 1)
require.NoError(t, err, "server 0 should add a peer to routing table but didn't, peer=%s", servers[1].host.ID())

if _, err := WaitUntilRoutingTableToBeFilled(ctx, servers[1], 1); err != nil {
t.Fatalf("server 1 should add a peer to routing table but didn't, peer=%s", servers[0].host.ID())
}
_, err = WaitUntilRoutingTableIsFilled(ctx, servers[1], 1)
require.NoError(t, err, "server 1 should add a peer to routing table but didn't, peer=%s", servers[0].host.ID())

assert.Contains(t, servers[0].discovery.RoutingTablePeers(), servers[1].AddrInfo().ID)
assert.Contains(t, servers[1].discovery.RoutingTablePeers(), servers[0].AddrInfo().ID)
Expand All @@ -92,18 +89,14 @@ func TestRoutingTable_Disconnected(t *testing.T) {
}

servers, createErr := createServers(2, paramsMap)
if createErr != nil {
t.Fatalf("Unable to create servers, %v", createErr)
}
require.NoError(t, createErr)

t.Cleanup(func() {
closeTestServers(t, servers[1:])
})

// connect to peer and make sure peer is in routing table
if joinErr := JoinAndWait(servers[0], servers[1], DefaultBufferTimeout, DefaultJoinTimeout); joinErr != nil {
t.Fatalf("Unable to join peers, %v", joinErr)
}
require.NoError(t, JoinAndWait(servers[0], servers[1], DefaultBufferTimeout, DefaultJoinTimeout))

// make sure each routing table has peer
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
Expand All @@ -112,18 +105,14 @@ func TestRoutingTable_Disconnected(t *testing.T) {
cancel()
})

if _, err := WaitUntilRoutingTableToBeFilled(ctx, servers[0], 1); err != nil {
t.Fatalf("server 0 should add a peer to routing table but didn't, peer=%s", servers[1].host.ID())
}
_, err := WaitUntilRoutingTableIsFilled(ctx, servers[0], 1)
require.NoError(t, err, "server 0 should add a peer to routing table but didn't, peer=%s", servers[1].host.ID())

if _, err := WaitUntilRoutingTableToBeFilled(ctx, servers[1], 1); err != nil {
t.Fatalf("server 1 should add a peer to routing table but didn't, peer=%s", servers[0].host.ID())
}
_, err = WaitUntilRoutingTableIsFilled(ctx, servers[1], 1)
require.NoError(t, err, "server 1 should add a peer to routing table but didn't, peer=%s", servers[0].host.ID())

// disconnect the servers by closing server 0 to stop auto-reconnection
if closeErr := servers[0].Close(); closeErr != nil {
t.Fatalf("Unable to close server 0, %v", closeErr)
}
require.NoError(t, servers[0].Close())

// make sure each routing table remove a peer
ctx2, cancel2 := context.WithTimeout(context.Background(), 15*time.Second)
Expand All @@ -132,9 +121,9 @@ func TestRoutingTable_Disconnected(t *testing.T) {
cancel2()
})

if _, err := WaitUntilRoutingTableToBeFilled(ctx2, servers[1], 0); err != nil {
t.Fatalf("server 1 should remove a peer from routing table but didn't, peer=%s", servers[0].host.ID())
}
_, err = WaitUntilRoutingTableIsFilled(ctx2, servers[1], 0)
require.NoError(t, err, "server 1 should remove a peer from routing table but didn't, peer=%s",
servers[0].host.ID())
}

func TestRoutingTable_ConnectionFailure(t *testing.T) {
Expand All @@ -150,25 +139,20 @@ func TestRoutingTable_ConnectionFailure(t *testing.T) {
}

servers, createErr := createServers(3, paramsMap)
if createErr != nil {
t.Fatalf("Unable to create servers, %v", createErr)
}
require.NoError(t, createErr)

t.Cleanup(func() {
// close only servers[0] because servers[1] has closed already
closeTestServers(t, servers[:1])
})

// close before dialing
if err := servers[1].Close(); err != nil {
t.Fatal(err)
}
require.NoError(t, servers[1].Close())

// Set a small join timeout, no need to wait ~40s for the connection to fail
smallTimeout := time.Second * 10
if joinErr := JoinAndWait(servers[0], servers[1], smallTimeout+time.Second*5, smallTimeout); joinErr == nil {
t.Fatalf("should fail to connect to server[1], but connected")
}

require.Error(t, JoinAndWait(servers[0], servers[1], smallTimeout+time.Second*5, smallTimeout))

// routing tables should be empty
for _, srv := range servers {
Expand All @@ -187,37 +171,30 @@ func TestDiscovery_FullNetwork(t *testing.T) {
}

servers, createErr := createServers(3, paramsMap)
if createErr != nil {
t.Fatalf("Unable to create servers, %v", createErr)
}
require.NoError(t, createErr)

t.Cleanup(func() {
closeTestServers(t, servers)
})

// Server 0 -> Server 1
if joinErr := JoinAndWait(servers[0], servers[1], DefaultBufferTimeout, DefaultJoinTimeout); joinErr != nil {
t.Fatalf("Unable to join peers, %v", joinErr)
}
require.NoError(t, JoinAndWait(servers[0], servers[1], DefaultBufferTimeout, DefaultJoinTimeout))

// Server 1 -> Server 2
if joinErr := JoinAndWait(servers[1], servers[2], DefaultBufferTimeout, DefaultJoinTimeout); joinErr != nil {
t.Fatalf("Unable to join peers, %v", joinErr)
}
require.NoError(t, JoinAndWait(servers[1], servers[2], DefaultBufferTimeout, DefaultJoinTimeout))

// Wait until Server 0 connects to Server 2 by discovery
discoveryTimeout := time.Second * 25

connectCtx, connectFn := context.WithTimeout(context.Background(), discoveryTimeout)
defer connectFn()

if _, connectErr := WaitUntilPeerConnectsTo(
_, connectErr := WaitUntilPeerConnectsTo(
connectCtx,
servers[0],
servers[2].AddrInfo().ID,
); connectErr != nil {
t.Fatalf("Unable to connect to peer, %v", connectErr)
}
)
require.NoError(t, connectErr)

// Check that all peers are connected to each other
for _, server := range servers {
Expand Down
4 changes: 2 additions & 2 deletions network/e2e_testing.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -174,8 +174,8 @@ func WaitUntilPeerDisconnectsFrom(ctx context.Context, srv *Server, ids ...peer.
return resVal, nil
}

// WaitUntilRoutingTableToBeAdded check routing table has given ids and retry by timeout
func WaitUntilRoutingTableToBeFilled(ctx context.Context, srv *Server, size int) (bool, error) {
// WaitUntilRoutingTableIsFilled check routing table has given ids and retry by timeout
func WaitUntilRoutingTableIsFilled(ctx context.Context, srv *Server, size int) (bool, error) {
res, err := tests.RetryUntilTimeout(ctx, func() (interface{}, bool) {
if size == srv.discovery.RoutingTableSize() {
return true, false
Expand Down

0 comments on commit bbbe3ab

Please sign in to comment.