PeerSelector and Catchup service tests

catchup/peerSelector.go

@@ -164,7 +164,7 @@ func (hs *historicStats) updateRequestPenalty(counter uint64) float64 {
 
 // resetRequestPenalty removes steps least recent gaps and recomputes the new penalty.
 // Returns the new rank calculated with the new penalty.
-// If steps it 0, it is a full reset i.e. drops or gap values. 
+// If steps is 0, it is a full reset i.e. drops all gap values. 
 func (hs *historicStats) resetRequestPenalty(steps int, initialRank int, class peerClass) (rank int) {
 	if len(hs.requestGaps) == 0 {
 		return initialRank

catchup/peerSelector_test.go

@@ -157,7 +157,7 @@ func TestPeerSelector(t *testing.T) {
 	require.Nil(t, peer)
 
 	r1, r2 = peerSelector.RankPeer(nil, 10)
-	require.False(t, r1 != r2 )
+	require.False(t, r1 != r2)
 	r2, r2 = peerSelector.RankPeer(&mockHTTPPeer{address: "abc123"}, 10)
 	require.False(t, r1 != r2)
 
@@ -430,3 +430,71 @@ func TestPenalty(t *testing.T) {
 	require.Equal(t, counters[3], 0)
 	require.Equal(t, counters[4], 0)
 }
+
+// TestPeerDownloadDurationToRank tests all the cases handled by PeerDownloadDurationToRank
+func TestPeerDownloadDurationToRank(t *testing.T) {
+
+	peers1 := []network.Peer{&mockHTTPPeer{address: "a1"}, &mockHTTPPeer{address: "a2"}, &mockHTTPPeer{address: "a3"}}
+	peers2 := []network.Peer{&mockHTTPPeer{address: "b1"}, &mockHTTPPeer{address: "b2"}}
+	peers3 := []network.Peer{&mockHTTPPeer{address: "c1"}, &mockHTTPPeer{address: "c2"}}
+	peers4 := []network.Peer{&mockHTTPPeer{address: "d1"}, &mockHTTPPeer{address: "d2"}}
+
+	peerSelector := makePeerSelector(
+		makePeersRetrieverStub(func(options ...network.PeerOption) (peers []network.Peer) {
+			for _, opt := range options {
+				if opt == network.PeersPhonebookArchivers {
+					peers = append(peers, peers1...)
+				} else if opt == network.PeersPhonebookRelays {
+					peers = append(peers, peers2...)
+				} else if opt == network.PeersConnectedOut {
+					peers = append(peers, peers3...)
+				} else {
+					peers = append(peers, peers4...)
+				}
+			}
+			return
+		}), []peerClass{{initialRank: peerRankInitialFirstPriority, peerClass: network.PeersPhonebookArchivers},
+			{initialRank: peerRankInitialSecondPriority, peerClass: network.PeersPhonebookRelays},
+			{initialRank: peerRankInitialThirdPriority, peerClass: network.PeersConnectedOut},
+			{initialRank: peerRankInitialFourthPriority, peerClass: network.PeersConnectedIn}},
+	)
+
+	_, err := peerSelector.GetNextPeer()
+	require.NoError(t, err)
+
+	require.Equal(t, downloadDurationToRank(500*time.Millisecond, lowBlockDownloadThreshold, highBlockDownloadThreshold, peerRank0LowBlockTime, peerRank0HighBlockTime),
+		peerSelector.PeerDownloadDurationToRank(peers1[0], 500*time.Millisecond))
+	require.Equal(t, downloadDurationToRank(500*time.Millisecond, lowBlockDownloadThreshold, highBlockDownloadThreshold, peerRank1LowBlockTime, peerRank1HighBlockTime),
+		peerSelector.PeerDownloadDurationToRank(peers2[0], 500*time.Millisecond))
+	require.Equal(t, downloadDurationToRank(500*time.Millisecond, lowBlockDownloadThreshold, highBlockDownloadThreshold, peerRank2LowBlockTime, peerRank2HighBlockTime),
+		peerSelector.PeerDownloadDurationToRank(peers3[0], 500*time.Millisecond))
+	require.Equal(t, downloadDurationToRank(500*time.Millisecond, lowBlockDownloadThreshold, highBlockDownloadThreshold, peerRank3LowBlockTime, peerRank3HighBlockTime),
+		peerSelector.PeerDownloadDurationToRank(peers4[0], 500*time.Millisecond))
+}
+
+func TestLowerUpperBounds(t *testing.T) {
+	classes := []peerClass{{initialRank: peerRankInitialFirstPriority, peerClass: network.PeersPhonebookArchivers},
+		{initialRank: peerRankInitialSecondPriority, peerClass: network.PeersPhonebookRelays},
+		{initialRank: peerRankInitialThirdPriority, peerClass: network.PeersConnectedOut},
+		{initialRank: peerRankInitialFourthPriority, peerClass: network.PeersConnectedIn}}
+
+	require.Equal(t, peerRank0LowBlockTime, lowerBound(classes[0]))
+	require.Equal(t, peerRank1LowBlockTime, lowerBound(classes[1]))
+	require.Equal(t, peerRank2LowBlockTime, lowerBound(classes[2]))
+	require.Equal(t, peerRank3LowBlockTime, lowerBound(classes[3]))
+
+	require.Equal(t, peerRank0HighBlockTime, upperBound(classes[0]))
+	require.Equal(t, peerRank1HighBlockTime, upperBound(classes[1]))
+	require.Equal(t, peerRank2HighBlockTime, upperBound(classes[2]))
+	require.Equal(t, peerRank3HighBlockTime, upperBound(classes[3]))
+}
+
+func TestFullResetRequestPenalty(t *testing.T) {
+	class := peerClass{initialRank: 10, peerClass: network.PeersPhonebookArchivers}
+	hs := makeHistoricStatus(10)
+	hs.push(5, 1, class)
+	require.Equal(t, 1, len(hs.requestGaps))
+
+	hs.resetRequestPenalty(0, 0, class)
+	require.Equal(t, 0, len(hs.requestGaps))
+}

catchup/service_test.go

@@ -21,6 +21,7 @@ import (
 	"errors"
 	"math/rand"
 	"sync"
+	"sync/atomic"
 	"testing"
 	"time"
 
@@ -768,3 +769,150 @@ func TestCatchupUnmatchedCertificate(t *testing.T) {
 		s.syncCert(pc)
 	}
 }
+
+// TestCreatePeerSelector tests if the correct peer selector coonfigurations are prepared
+func TestCreatePeerSelector(t *testing.T) {
+	// Make Service
+	cfg := defaultConfig
+
+	cfg.EnableCatchupFromArchiveServers = true
+
+	cfg.NetAddress = "someAddress"
+	s := MakeService(logging.Base(), cfg, &httpTestPeerSource{}, new(mockedLedger), &mockedAuthenticator{errorRound: int(0 + 1)}, nil, nil)
+	ps := s.createPeerSelector(true)
+	require.Equal(t, 4, len(ps.peerClasses))
+	require.Equal(t, peerRankInitialFirstPriority, ps.peerClasses[0].initialRank)
+	require.Equal(t, peerRankInitialSecondPriority, ps.peerClasses[1].initialRank)
+	require.Equal(t, peerRankInitialThirdPriority, ps.peerClasses[2].initialRank)
+	require.Equal(t, peerRankInitialFourthPriority, ps.peerClasses[3].initialRank)
+
+	require.Equal(t, network.PeersConnectedOut, ps.peerClasses[0].peerClass)
+	require.Equal(t, network.PeersPhonebookArchivers, ps.peerClasses[1].peerClass)
+	require.Equal(t, network.PeersPhonebookRelays, ps.peerClasses[2].peerClass)
+	require.Equal(t, network.PeersConnectedIn, ps.peerClasses[3].peerClass)
+
+	// cfg.EnableCatchupFromArchiveServers = true; cfg.NetAddress == ""; pipelineFetch = true;
+	cfg.EnableCatchupFromArchiveServers = true
+	cfg.NetAddress = ""
+	s = MakeService(logging.Base(), cfg, &httpTestPeerSource{}, new(mockedLedger), &mockedAuthenticator{errorRound: int(0 + 1)}, nil, nil)
+	ps = s.createPeerSelector(true)
+	require.Equal(t, 3, len(ps.peerClasses))
+	require.Equal(t, peerRankInitialFirstPriority, ps.peerClasses[0].initialRank)
+	require.Equal(t, peerRankInitialSecondPriority, ps.peerClasses[1].initialRank)
+	require.Equal(t, peerRankInitialThirdPriority, ps.peerClasses[2].initialRank)
+
+	require.Equal(t, network.PeersPhonebookArchivers, ps.peerClasses[0].peerClass)
+	require.Equal(t, network.PeersConnectedOut, ps.peerClasses[1].peerClass)
+	require.Equal(t, network.PeersPhonebookRelays, ps.peerClasses[2].peerClass)
+
+
+	// cfg.EnableCatchupFromArchiveServers = true;  cfg.NetAddress != ""; pipelineFetch = false
+	cfg.EnableCatchupFromArchiveServers = true
+	cfg.NetAddress = "someAddress"
+	s = MakeService(logging.Base(), cfg, &httpTestPeerSource{}, new(mockedLedger), &mockedAuthenticator{errorRound: int(0 + 1)}, nil, nil)
+	ps = s.createPeerSelector(false)
+
+	require.Equal(t, 4, len(ps.peerClasses))
+	require.Equal(t, peerRankInitialFirstPriority, ps.peerClasses[0].initialRank)
+	require.Equal(t, peerRankInitialSecondPriority, ps.peerClasses[1].initialRank)
+	require.Equal(t, peerRankInitialThirdPriority, ps.peerClasses[2].initialRank)
+	require.Equal(t, peerRankInitialFourthPriority, ps.peerClasses[3].initialRank)
+
+	require.Equal(t, network.PeersConnectedOut, ps.peerClasses[0].peerClass)
+	require.Equal(t, network.PeersConnectedIn, ps.peerClasses[1].peerClass)
+	require.Equal(t, network.PeersPhonebookRelays, ps.peerClasses[2].peerClass)
+	require.Equal(t, network.PeersPhonebookArchivers, ps.peerClasses[3].peerClass)
+
+	// cfg.EnableCatchupFromArchiveServers = true; cfg.NetAddress == ""; pipelineFetch = false
+	cfg.EnableCatchupFromArchiveServers = true
+	cfg.NetAddress = ""
+	s = MakeService(logging.Base(), cfg, &httpTestPeerSource{}, new(mockedLedger), &mockedAuthenticator{errorRound: int(0 + 1)}, nil, nil)
+	ps = s.createPeerSelector(false)
+
+	require.Equal(t, 3, len(ps.peerClasses))
+	require.Equal(t, peerRankInitialFirstPriority, ps.peerClasses[0].initialRank)
+	require.Equal(t, peerRankInitialSecondPriority, ps.peerClasses[1].initialRank)
+	require.Equal(t, peerRankInitialThirdPriority, ps.peerClasses[2].initialRank)
+
+	require.Equal(t, network.PeersConnectedOut, ps.peerClasses[0].peerClass)
+	require.Equal(t, network.PeersPhonebookRelays, ps.peerClasses[1].peerClass)
+	require.Equal(t, network.PeersPhonebookArchivers, ps.peerClasses[2].peerClass)
+
+	// cfg.EnableCatchupFromArchiveServers = false; cfg.NetAddress != ""; pipelineFetch = true
+	cfg.EnableCatchupFromArchiveServers = false
+	cfg.NetAddress = "someAddress"
+	s = MakeService(logging.Base(), cfg, &httpTestPeerSource{}, new(mockedLedger), &mockedAuthenticator{errorRound: int(0 + 1)}, nil, nil)
+	ps = s.createPeerSelector(true)
+
+	require.Equal(t, 3, len(ps.peerClasses))
+	require.Equal(t, peerRankInitialFirstPriority, ps.peerClasses[0].initialRank)
+	require.Equal(t, peerRankInitialSecondPriority, ps.peerClasses[1].initialRank)
+	require.Equal(t, peerRankInitialThirdPriority, ps.peerClasses[2].initialRank)
+
+	require.Equal(t, network.PeersConnectedOut, ps.peerClasses[0].peerClass)
+	require.Equal(t, network.PeersPhonebookRelays, ps.peerClasses[1].peerClass)
+	require.Equal(t, network.PeersConnectedIn, ps.peerClasses[2].peerClass)
+
+	// cfg.EnableCatchupFromArchiveServers = false; cfg.NetAddress == ""; pipelineFetch = true
+	cfg.EnableCatchupFromArchiveServers = false
+	cfg.NetAddress = ""
+	s = MakeService(logging.Base(), cfg, &httpTestPeerSource{}, new(mockedLedger), &mockedAuthenticator{errorRound: int(0 + 1)}, nil, nil)
+	ps = s.createPeerSelector(true)
+
+	require.Equal(t, 2, len(ps.peerClasses))
+	require.Equal(t, peerRankInitialFirstPriority, ps.peerClasses[0].initialRank)
+	require.Equal(t, peerRankInitialSecondPriority, ps.peerClasses[1].initialRank)
+
+	require.Equal(t, network.PeersConnectedOut, ps.peerClasses[0].peerClass)
+	require.Equal(t, network.PeersPhonebookRelays, ps.peerClasses[1].peerClass)
+
+	// cfg.EnableCatchupFromArchiveServers = false; cfg.NetAddress != ""; pipelineFetch = false
+	cfg.EnableCatchupFromArchiveServers = false
+	cfg.NetAddress = "someAddress"
+	s = MakeService(logging.Base(), cfg, &httpTestPeerSource{}, new(mockedLedger), &mockedAuthenticator{errorRound: int(0 + 1)}, nil, nil)
+	ps = s.createPeerSelector(false)
+
+	require.Equal(t, 3, len(ps.peerClasses))
+	require.Equal(t, peerRankInitialFirstPriority, ps.peerClasses[0].initialRank)
+	require.Equal(t, peerRankInitialSecondPriority, ps.peerClasses[1].initialRank)
+	require.Equal(t, peerRankInitialThirdPriority, ps.peerClasses[2].initialRank)
+
+	require.Equal(t, network.PeersConnectedOut, ps.peerClasses[0].peerClass)
+	require.Equal(t, network.PeersConnectedIn, ps.peerClasses[1].peerClass)
+	require.Equal(t, network.PeersPhonebookRelays, ps.peerClasses[2].peerClass)
+
+	// cfg.EnableCatchupFromArchiveServers = false; cfg.NetAddress == ""; pipelineFetch = false
+	cfg.EnableCatchupFromArchiveServers = false
+	cfg.NetAddress = ""
+	s = MakeService(logging.Base(), cfg, &httpTestPeerSource{}, new(mockedLedger), &mockedAuthenticator{errorRound: int(0 + 1)}, nil, nil)
+	ps = s.createPeerSelector(false)
+
+	require.Equal(t, 2, len(ps.peerClasses))
+	require.Equal(t, peerRankInitialFirstPriority, ps.peerClasses[0].initialRank)
+	require.Equal(t, peerRankInitialSecondPriority, ps.peerClasses[1].initialRank)
+
+	require.Equal(t, network.PeersConnectedOut, ps.peerClasses[0].peerClass)
+	require.Equal(t, network.PeersPhonebookRelays, ps.peerClasses[1].peerClass)
+}
+
+func TestServiceStartStop(t *testing.T) {
+	cfg := defaultConfig
+	ledger := new(mockedLedger)
+	ledger.blocks = append(ledger.blocks, bookkeeping.Block{})
+	s := MakeService(logging.Base(), cfg, &httpTestPeerSource{}, ledger, &mockedAuthenticator{errorRound: int(0 + 1)}, nil, nil)
+	s.Start()
+	s.Stop()
+	_, ok := (<-s.done)
+	require.False(t, ok)	
+}
+
+func TestSynchronizingTime(t *testing.T) {
+	cfg := defaultConfig
+	ledger := new(mockedLedger)
+	ledger.blocks = append(ledger.blocks, bookkeeping.Block{})
+	s := MakeService(logging.Base(), cfg, &httpTestPeerSource{}, ledger, &mockedAuthenticator{errorRound: int(0 + 1)}, nil, nil)
+
+	require.Equal(t, time.Duration(0), s.SynchronizingTime())
+	atomic.StoreInt64(&s.syncStartNS, 1000000)
+	require.NotEqual(t, time.Duration(0), s.SynchronizingTime())
+}