Integration tests

integrationTests/peerDisconnecting/peerDisconnecting_test.go

@@ -0,0 +1,158 @@
+package peerDisconnecting
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/ElrondNetwork/elrond-go-p2p"
+	"github.com/ElrondNetwork/elrond-go-p2p/config"
+	"github.com/ElrondNetwork/elrond-go-p2p/integrationTests"
+	"github.com/ElrondNetwork/elrond-go-p2p/libp2p"
+	"github.com/ElrondNetwork/elrond-go-p2p/mock"
+	"github.com/libp2p/go-libp2p-core/peer"
+	mocknet "github.com/libp2p/go-libp2p/p2p/net/mock"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func createDefaultConfig() config.P2PConfig {
+	return config.P2PConfig{
+		Node: config.NodeConfig{},
+		KadDhtPeerDiscovery: config.KadDhtPeerDiscoveryConfig{
+			Enabled:                          true,
+			Type:                             "optimized",
+			RefreshIntervalInSec:             1,
+			RoutingTableRefreshIntervalInSec: 1,
+			ProtocolID:                       "/erd/kad/1.0.0",
+			InitialPeerList:                  nil,
+			BucketSize:                       100,
+		},
+	}
+}
+
+func TestPeerDisconnectionWithOneAdvertiserWithShardingWithLists(t *testing.T) {
+	p2pCfg := createDefaultConfig()
+	p2pCfg.Sharding = config.ShardingConfig{
+		TargetPeerCount:         100,
+		MaxIntraShardValidators: 40,
+		MaxCrossShardValidators: 40,
+		MaxIntraShardObservers:  1,
+		MaxCrossShardObservers:  1,
+		MaxSeeders:              1,
+		Type:                    p2p.ListsSharder,
+		AdditionalConnections: config.AdditionalConnectionsConfig{
+			MaxFullHistoryObservers: 1,
+		},
+	}
+	p2pCfg.Node.ThresholdMinConnectedPeers = 3
+
+	testPeerDisconnectionWithOneAdvertiser(t, p2pCfg)
+}
+
+func testPeerDisconnectionWithOneAdvertiser(t *testing.T, p2pConfig config.P2PConfig) {
+	if testing.Short() {
+		t.Skip("this is not a short test")
+	}
+
+	numOfPeers := 20
+	netw := mocknet.New()
+
+	p2pConfigSeeder := p2pConfig
+	argSeeder := libp2p.ArgsNetworkMessenger{
+		ListenAddress:         libp2p.ListenLocalhostAddrWithIp4AndTcp,
+		P2pConfig:             p2pConfigSeeder,
+		PreferredPeersHolder:  &mock.PeersHolderStub{},
+		NodeOperationMode:     p2p.NormalOperation,
+		Marshalizer:           &mock.MarshallerMock{},
+		SyncTimer:             &mock.SyncTimerStub{},
+		PeersRatingHandler:    &mock.PeersRatingHandlerStub{},
+		ConnectionWatcherType: p2p.ConnectionWatcherTypePrint,
+	}
+	// Step 1. Create advertiser
+	advertiser, err := libp2p.NewMockMessenger(argSeeder, netw)
+	require.Nil(t, err)
+	p2pConfig.KadDhtPeerDiscovery.InitialPeerList = []string{integrationTests.GetConnectableAddress(advertiser)}
+
+	// Step 2. Create noOfPeers instances of messenger type and call bootstrap
+	peers := make([]p2p.Messenger, numOfPeers)
+	for i := 0; i < numOfPeers; i++ {
+		arg := libp2p.ArgsNetworkMessenger{
+			ListenAddress:         libp2p.ListenLocalhostAddrWithIp4AndTcp,
+			P2pConfig:             p2pConfig,
+			PreferredPeersHolder:  &mock.PeersHolderStub{},
+			NodeOperationMode:     p2p.NormalOperation,
+			Marshalizer:           &mock.MarshallerMock{},
+			SyncTimer:             &mock.SyncTimerStub{},
+			PeersRatingHandler:    &mock.PeersRatingHandlerStub{},
+			ConnectionWatcherType: p2p.ConnectionWatcherTypePrint,
+		}
+		node, errCreate := libp2p.NewMockMessenger(arg, netw)
+		require.Nil(t, errCreate)
+		peers[i] = node
+	}
+
+	// cleanup function that closes all messengers
+	defer func() {
+		for i := 0; i < numOfPeers; i++ {
+			if peers[i] != nil {
+				_ = peers[i].Close()
+			}
+		}
+
+		if advertiser != nil {
+			_ = advertiser.Close()
+		}
+	}()
+
+	// link all peers so they can connect to each other
+	_ = netw.LinkAll()
+
+	// Step 3. Call bootstrap on all peers
+	_ = advertiser.Bootstrap()
+	for _, p := range peers {
+		_ = p.Bootstrap()
+	}
+	integrationTests.WaitForBootstrapAndShowConnected(peers, integrationTests.P2pBootstrapDelay)
+
+	// Step 4. Disconnect one peer
+	disconnectedPeer := peers[5]
+	fmt.Printf("--- Diconnecting peer: %v ---\n", disconnectedPeer.ID().Pretty())
+	_ = netw.UnlinkPeers(getPeerId(advertiser), getPeerId(disconnectedPeer))
+	_ = netw.DisconnectPeers(getPeerId(advertiser), getPeerId(disconnectedPeer))
+	_ = netw.DisconnectPeers(getPeerId(disconnectedPeer), getPeerId(advertiser))
+	for _, p := range peers {
+		if p != disconnectedPeer {
+			_ = netw.UnlinkPeers(getPeerId(p), getPeerId(disconnectedPeer))
+			_ = netw.DisconnectPeers(getPeerId(p), getPeerId(disconnectedPeer))
+			_ = netw.DisconnectPeers(getPeerId(disconnectedPeer), getPeerId(p))
+		}
+	}
+	for i := 0; i < 5; i++ {
+		integrationTests.WaitForBootstrapAndShowConnected(peers, integrationTests.P2pBootstrapDelay)
+	}
+
+	// Step 4.1. Test that the peer is disconnected
+	for _, p := range peers {
+		if p != disconnectedPeer {
+			assert.Equal(t, numOfPeers-1, len(p.ConnectedPeers()))
+		} else {
+			assert.Equal(t, 0, len(p.ConnectedPeers()))
+		}
+	}
+
+	// Step 5. Re-link and test connections
+	fmt.Println("--- Re-linking ---")
+	_ = netw.LinkAll()
+	for i := 0; i < 5; i++ {
+		integrationTests.WaitForBootstrapAndShowConnected(peers, integrationTests.P2pBootstrapDelay)
+	}
+
+	// Step 5.1. Test that the peer is reconnected
+	for _, p := range peers {
+		assert.Equal(t, numOfPeers, len(p.ConnectedPeers()))
+	}
+}
+
+func getPeerId(netMessenger p2p.Messenger) peer.ID {
+	return peer.ID(netMessenger.ID().Bytes())
+}

integrationTests/peerDisconnecting/seedersDisconnecting_test.go

@@ -0,0 +1,173 @@
+package peerDisconnecting
+
+import (
+	"testing"
+
+	logger "github.com/ElrondNetwork/elrond-go-logger"
+	p2p "github.com/ElrondNetwork/elrond-go-p2p"
+	"github.com/ElrondNetwork/elrond-go-p2p/config"
+	"github.com/ElrondNetwork/elrond-go-p2p/integrationTests"
+	"github.com/ElrondNetwork/elrond-go-p2p/libp2p"
+	"github.com/ElrondNetwork/elrond-go-p2p/mock"
+	mocknet "github.com/libp2p/go-libp2p/p2p/net/mock"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+var log = logger.GetOrCreate("integrationtests/p2p/peerdisconnecting")
+
+func TestSeedersDisconnectionWith2AdvertiserAnd3Peers(t *testing.T) {
+	if testing.Short() {
+		t.Skip("this is not a short test")
+	}
+
+	netw := mocknet.New()
+	p2pCfg := createDefaultConfig()
+	p2pCfg.KadDhtPeerDiscovery.RefreshIntervalInSec = 1
+
+	p2pCfg.Sharding = config.ShardingConfig{
+		TargetPeerCount:         100,
+		MaxIntraShardValidators: 40,
+		MaxCrossShardValidators: 40,
+		MaxIntraShardObservers:  1,
+		MaxCrossShardObservers:  1,
+		MaxSeeders:              3,
+		Type:                    p2p.ListsSharder,
+		AdditionalConnections: config.AdditionalConnectionsConfig{
+			MaxFullHistoryObservers: 0,
+		},
+	}
+	p2pCfg.Node.ThresholdMinConnectedPeers = 3
+
+	numOfPeers := 3
+	seeders, seedersList := createBootstrappedSeeders(p2pCfg, 2, netw)
+
+	integrationTests.WaitForBootstrapAndShowConnected(seeders, integrationTests.P2pBootstrapDelay)
+
+	// Step 2. Create noOfPeers instances of messenger type and call bootstrap
+	p2pCfg.KadDhtPeerDiscovery.InitialPeerList = seedersList
+	peers := make([]p2p.Messenger, numOfPeers)
+	for i := 0; i < numOfPeers; i++ {
+		arg := libp2p.ArgsNetworkMessenger{
+			ListenAddress:         libp2p.ListenLocalhostAddrWithIp4AndTcp,
+			P2pConfig:             p2pCfg,
+			PreferredPeersHolder:  &mock.PeersHolderStub{},
+			NodeOperationMode:     p2p.NormalOperation,
+			Marshalizer:           &mock.MarshallerMock{},
+			SyncTimer:             &mock.SyncTimerStub{},
+			PeersRatingHandler:    &mock.PeersRatingHandlerStub{},
+			ConnectionWatcherType: p2p.ConnectionWatcherTypePrint,
+		}
+		node, err := libp2p.NewMockMessenger(arg, netw)
+		require.Nil(t, err)
+		peers[i] = node
+	}
+
+	// cleanup function that closes all messengers
+	defer func() {
+		for i := 0; i < numOfPeers; i++ {
+			if peers[i] != nil {
+				_ = peers[i].Close()
+			}
+		}
+
+		for i := 0; i < len(seeders); i++ {
+			if seeders[i] != nil {
+				_ = seeders[i].Close()
+			}
+		}
+	}()
+
+	// link all peers so they can connect to each other
+	_ = netw.LinkAll()
+
+	// Step 3. Call bootstrap on all peers
+	for _, p := range peers {
+		_ = p.Bootstrap()
+	}
+	integrationTests.WaitForBootstrapAndShowConnected(append(seeders, peers...), integrationTests.P2pBootstrapDelay)
+
+	// Step 4. Disconnect the seeders
+	log.Info("--- Disconnecting seeders: %v ---\n", seeders)
+	disconnectSeedersFromPeers(seeders, peers, netw)
+
+	for i := 0; i < 2; i++ {
+		integrationTests.WaitForBootstrapAndShowConnected(append(seeders, peers...), integrationTests.P2pBootstrapDelay)
+	}
+
+	// Step 4.1. Test that the peers are disconnected
+	for _, p := range peers {
+		assert.Equal(t, numOfPeers-1, len(p.ConnectedPeers()))
+	}
+
+	for _, s := range seeders {
+		assert.Equal(t, len(seeders)-1, len(s.ConnectedPeers()))
+	}
+
+	// Step 5. Re-link and test connections
+	log.Info("--- Re-linking ---")
+	_ = netw.LinkAll()
+	for i := 0; i < 2; i++ {
+		integrationTests.WaitForBootstrapAndShowConnected(append(seeders, peers...), integrationTests.P2pBootstrapDelay)
+	}
+
+	// Step 5.1. Test that the peers got reconnected
+	for _, p := range append(peers, seeders...) {
+		assert.Equal(t, numOfPeers+len(seeders)-1, len(p.ConnectedPeers()))
+	}
+}
+
+func createBootstrappedSeeders(baseP2PConfig config.P2PConfig, numSeeders int, netw mocknet.Mocknet) ([]p2p.Messenger, []string) {
+	seeders := make([]p2p.Messenger, numSeeders)
+	seedersAddresses := make([]string, numSeeders)
+
+	p2pConfigSeeder := baseP2PConfig
+	argSeeder := libp2p.ArgsNetworkMessenger{
+		ListenAddress:         libp2p.ListenLocalhostAddrWithIp4AndTcp,
+		P2pConfig:             p2pConfigSeeder,
+		PreferredPeersHolder:  &mock.PeersHolderStub{},
+		NodeOperationMode:     p2p.NormalOperation,
+		Marshalizer:           &mock.MarshallerMock{},
+		SyncTimer:             &mock.SyncTimerStub{},
+		PeersRatingHandler:    &mock.PeersRatingHandlerStub{},
+		ConnectionWatcherType: p2p.ConnectionWatcherTypePrint,
+	}
+	seeders[0], _ = libp2p.NewMockMessenger(argSeeder, netw)
+	_ = seeders[0].Bootstrap()
+	seedersAddresses[0] = integrationTests.GetConnectableAddress(seeders[0])
+
+	for i := 1; i < numSeeders; i++ {
+		p2pConfigSeeder = baseP2PConfig
+		p2pConfigSeeder.KadDhtPeerDiscovery.InitialPeerList = []string{integrationTests.GetConnectableAddress(seeders[0])}
+		argSeeder = libp2p.ArgsNetworkMessenger{
+			ListenAddress:         libp2p.ListenLocalhostAddrWithIp4AndTcp,
+			P2pConfig:             p2pConfigSeeder,
+			PreferredPeersHolder:  &mock.PeersHolderStub{},
+			NodeOperationMode:     p2p.NormalOperation,
+			Marshalizer:           &mock.MarshallerMock{},
+			SyncTimer:             &mock.SyncTimerStub{},
+			PeersRatingHandler:    &mock.PeersRatingHandlerStub{},
+			ConnectionWatcherType: p2p.ConnectionWatcherTypePrint,
+		}
+		seeders[i], _ = libp2p.NewMockMessenger(argSeeder, netw)
+		_ = netw.LinkAll()
+		_ = seeders[i].Bootstrap()
+		seedersAddresses[i] = integrationTests.GetConnectableAddress(seeders[i])
+	}
+
+	return seeders, seedersAddresses
+}
+
+func disconnectSeedersFromPeers(seeders []p2p.Messenger, peers []p2p.Messenger, netw mocknet.Mocknet) {
+	for _, p := range peers {
+		for _, s := range seeders {
+			disconnectPeers(p, s, netw)
+		}
+	}
+}
+
+func disconnectPeers(peer1 p2p.Messenger, peer2 p2p.Messenger, netw mocknet.Mocknet) {
+	_ = netw.UnlinkPeers(getPeerId(peer1), getPeerId(peer2))
+	_ = netw.DisconnectPeers(getPeerId(peer1), getPeerId(peer2))
+	_ = netw.DisconnectPeers(getPeerId(peer2), getPeerId(peer1))
+}