From 08312927ee8e707290181abc7db7ad4a334b38a8 Mon Sep 17 00:00:00 2001 From: Sorin Stanculeanu Date: Wed, 3 May 2023 15:43:48 +0300 Subject: [PATCH 1/4] increased code coverage on dataRetriever package --- dataRetriever/blockchain/blockchain_test.go | 12 + dataRetriever/blockchain/metachain_test.go | 11 + dataRetriever/chainStorer_test.go | 3 + dataRetriever/dataPool/dataPool_test.go | 1 + .../dataPool/headersCache/headersCache.go | 2 +- .../dataPool/headersCache/headersPool_test.go | 71 +- .../metaResolversContainerFactory_test.go | 24 + .../shardResolversContainerFactory_test.go | 24 + dataRetriever/provider/miniBlocks_test.go | 14 +- .../requestHandlers/requestHandler_test.go | 1956 +++++++++++------ .../requesters/requesters_test.go | 2 + .../disabled/disabledEpochProvider_test.go | 19 + .../resolvers/headerResolver_test.go | 161 ++ .../resolvers/messageProcessor_test.go | 10 + .../resolvers/miniblockResolver_test.go | 203 ++ .../peerAuthenticationResolver_test.go | 42 +- .../resolvers/transactionResolver_test.go | 122 + .../resolvers/trieNodeResolver_test.go | 43 + .../resolvers/validatorInfoResolver_test.go | 34 + dataRetriever/shardedData/shardedData_test.go | 53 +- .../storageRequesters/headerRequester_test.go | 83 +- .../storageRequesters/sliceRequester_test.go | 62 +- .../trieNodeRequester_test.go | 59 + .../topicSender/diffPeerListCreator_test.go | 18 + dataRetriever/txpool/shardedTxPool_test.go | 25 + dataRetriever/unitType_test.go | 68 + testscommon/storageManagerStub.go | 4 + 27 files changed, 2393 insertions(+), 733 deletions(-) create mode 100644 dataRetriever/resolvers/epochproviders/disabled/disabledEpochProvider_test.go create mode 100644 dataRetriever/unitType_test.go diff --git a/dataRetriever/blockchain/blockchain_test.go b/dataRetriever/blockchain/blockchain_test.go index 3980d2723f7..212d2755adc 100644 --- a/dataRetriever/blockchain/blockchain_test.go +++ b/dataRetriever/blockchain/blockchain_test.go @@ -5,6 +5,7 @@ import ( "testing" "github.com/multiversx/mx-chain-core-go/core/check" + "github.com/multiversx/mx-chain-core-go/data" "github.com/multiversx/mx-chain-core-go/data/block" "github.com/multiversx/mx-chain-core-go/data/mock" "github.com/stretchr/testify/assert" @@ -81,3 +82,14 @@ func TestBlockChain_SettersAndGettersNilValues(t *testing.T) { assert.Nil(t, bc.GetCurrentBlockHeader()) assert.Empty(t, bc.GetCurrentBlockRootHash()) } + +func TestBlockChain_SettersInvalidValues(t *testing.T) { + t.Parallel() + + bc, _ := NewBlockChain(&mock.AppStatusHandlerStub{}) + err := bc.SetGenesisHeader(&block.MetaBlock{}) + assert.Equal(t, err, data.ErrInvalidHeaderType) + + err = bc.SetCurrentBlockHeaderAndRootHash(&block.MetaBlock{}, []byte("root hash")) + assert.Equal(t, err, data.ErrInvalidHeaderType) +} diff --git a/dataRetriever/blockchain/metachain_test.go b/dataRetriever/blockchain/metachain_test.go index eb0f589f899..684aa95477c 100644 --- a/dataRetriever/blockchain/metachain_test.go +++ b/dataRetriever/blockchain/metachain_test.go @@ -82,3 +82,14 @@ func TestMetaChain_SettersAndGettersNilValues(t *testing.T) { assert.Nil(t, mc.GetCurrentBlockHeader()) assert.Empty(t, mc.GetCurrentBlockRootHash()) } + +func TestMetaChain_SettersInvalidValues(t *testing.T) { + t.Parallel() + + bc, _ := NewMetaChain(&mock.AppStatusHandlerStub{}) + err := bc.SetGenesisHeader(&block.Header{}) + assert.Equal(t, err, ErrWrongTypeInSet) + + err = bc.SetCurrentBlockHeaderAndRootHash(&block.Header{}, []byte("root hash")) + assert.Equal(t, err, ErrWrongTypeInSet) +} diff --git a/dataRetriever/chainStorer_test.go b/dataRetriever/chainStorer_test.go index 3b4373641af..73093ccde7e 100644 --- a/dataRetriever/chainStorer_test.go +++ b/dataRetriever/chainStorer_test.go @@ -239,6 +239,9 @@ func TestBlockChain_GetStorer(t *testing.T) { assert.True(t, peerBlockUnit == storer) storer, _ = b.GetStorer(4) assert.True(t, headerUnit == storer) + storer, err := b.GetStorer(5) + assert.True(t, errors.Is(err, dataRetriever.ErrStorerNotFound)) + assert.Nil(t, storer) } func TestBlockChain_GetAllStorers(t *testing.T) { diff --git a/dataRetriever/dataPool/dataPool_test.go b/dataRetriever/dataPool/dataPool_test.go index 2eb98aee5a6..11a94c5e488 100644 --- a/dataRetriever/dataPool/dataPool_test.go +++ b/dataRetriever/dataPool/dataPool_test.go @@ -209,6 +209,7 @@ func TestNewDataPool_OkValsShouldWork(t *testing.T) { assert.True(t, args.SmartContracts == tdp.SmartContracts()) assert.True(t, args.PeerAuthentications == tdp.PeerAuthentications()) assert.True(t, args.Heartbeats == tdp.Heartbeats()) + assert.True(t, args.ValidatorsInfo == tdp.ValidatorsInfo()) } func TestNewDataPool_Close(t *testing.T) { diff --git a/dataRetriever/dataPool/headersCache/headersCache.go b/dataRetriever/dataPool/headersCache/headersCache.go index bba024f30db..4b1ef31d8d9 100644 --- a/dataRetriever/dataPool/headersCache/headersCache.go +++ b/dataRetriever/dataPool/headersCache/headersCache.go @@ -53,7 +53,7 @@ func (cache *headersCache) addHeader(headerHash []byte, header data.HeaderHandle return true } -//tryToDoEviction will check if pool is full and if it is will do eviction +// tryToDoEviction will check if pool is full and if so, it will do the eviction func (cache *headersCache) tryToDoEviction(shardId uint32) { numHeaders := cache.getNumHeaders(shardId) if int(numHeaders) >= cache.maxHeadersPerShard { diff --git a/dataRetriever/dataPool/headersCache/headersPool_test.go b/dataRetriever/dataPool/headersCache/headersPool_test.go index 3865c6b9c47..2b2fb4cf3c6 100644 --- a/dataRetriever/dataPool/headersCache/headersPool_test.go +++ b/dataRetriever/dataPool/headersCache/headersPool_test.go @@ -1,6 +1,7 @@ package headersCache_test import ( + "errors" "fmt" "sort" "sync" @@ -16,6 +17,45 @@ import ( "github.com/stretchr/testify/require" ) +func TestNewHeadersCacher(t *testing.T) { + t.Parallel() + + t.Run("invalid MaxHeadersPerShard should error", testNewHeadersCacher( + config.HeadersPoolConfig{ + MaxHeadersPerShard: 0, + })) + t.Run("invalid NumElementsToRemoveOnEviction should error", testNewHeadersCacher( + config.HeadersPoolConfig{ + MaxHeadersPerShard: 1, + NumElementsToRemoveOnEviction: 0, + })) + t.Run("invalid config should error", testNewHeadersCacher( + config.HeadersPoolConfig{ + MaxHeadersPerShard: 1, + NumElementsToRemoveOnEviction: 3, + })) + t.Run("should work", func(t *testing.T) { + t.Parallel() + + headersCacher, err := headersCache.NewHeadersPool(config.HeadersPoolConfig{ + MaxHeadersPerShard: 2, + NumElementsToRemoveOnEviction: 1, + }) + require.NoError(t, err) + require.NotNil(t, headersCacher) + }) +} + +func testNewHeadersCacher(cfg config.HeadersPoolConfig) func(t *testing.T) { + return func(t *testing.T) { + t.Parallel() + + headersCacher, err := headersCache.NewHeadersPool(cfg) + require.True(t, errors.Is(err, headersCache.ErrInvalidHeadersCacheParameter)) + require.Nil(t, headersCacher) + } +} + func TestNewHeadersCacher_AddHeadersInCache(t *testing.T) { t.Parallel() @@ -28,11 +68,16 @@ func TestNewHeadersCacher_AddHeadersInCache(t *testing.T) { nonce := uint64(1) shardId := uint32(0) + headers, _, err := headersCacher.GetHeadersByNonceAndShardId(nonce, shardId) + require.Equal(t, headersCache.ErrHeaderNotFound, err) + require.Nil(t, headers) + headerHash1 := []byte("hash1") headerHash2 := []byte("hash2") testHdr1 := &block.Header{Nonce: nonce, ShardID: shardId} testHdr2 := &block.Header{Nonce: nonce, ShardID: shardId, Round: 100} + headersCacher.AddHeader([]byte("nil header hash"), nil) // coverage headersCacher.AddHeader(headerHash1, testHdr1) headersCacher.AddHeader(headerHash2, testHdr2) @@ -45,7 +90,7 @@ func TestNewHeadersCacher_AddHeadersInCache(t *testing.T) { require.Equal(t, testHdr2, header) expectedHeaders := []data.HeaderHandler{testHdr1, testHdr2} - headers, _, err := headersCacher.GetHeadersByNonceAndShardId(nonce, shardId) + headers, _, err = headersCacher.GetHeadersByNonceAndShardId(nonce, shardId) require.Nil(t, err) require.Equal(t, expectedHeaders, headers) } @@ -70,6 +115,8 @@ func Test_RemoveHeaderByHash(t *testing.T) { headersCacher.AddHeader(headerHash1, testHdr1) headersCacher.AddHeader(headerHash2, testHdr2) + headersCacher.RemoveHeaderByHash([]byte("")) + headersCacher.RemoveHeaderByHash([]byte("missing hash")) headersCacher.RemoveHeaderByHash(headerHash1) header, err := headersCacher.GetHeaderByHash(headerHash1) require.Nil(t, header) @@ -101,6 +148,8 @@ func TestHeadersCacher_AddHeadersInCacheAndRemoveByNonceAndShardId(t *testing.T) headersCacher.AddHeader(headerHash1, testHdr1) headersCacher.AddHeader(headerHash2, testHdr2) + headersCacher.RemoveHeaderByNonceAndShardId(nonce, 100) + headersCacher.RemoveHeaderByNonceAndShardId(100, shardId) headersCacher.RemoveHeaderByNonceAndShardId(nonce, shardId) header, err := headersCacher.GetHeaderByHash(headerHash1) require.Nil(t, header) @@ -577,6 +626,7 @@ func TestHeadersPool_RegisterHandler(t *testing.T) { wasCalled = true wg.Done() } + headersCacher.RegisterHandler(nil) headersCacher.RegisterHandler(handler) header, hash := createASliceOfHeaders(1, 0) headersCacher.AddHeader(hash[0], &header[0]) @@ -603,6 +653,25 @@ func TestHeadersPool_Clear(t *testing.T) { require.Equal(t, 0, headersCacher.GetNumHeaders(0)) } +func TestHeadersPool_IsInterfaceNil(t *testing.T) { + t.Parallel() + + headersCacher, _ := headersCache.NewHeadersPool( + config.HeadersPoolConfig{ + MaxHeadersPerShard: 0, + }, + ) + require.True(t, headersCacher.IsInterfaceNil()) + + headersCacher, _ = headersCache.NewHeadersPool( + config.HeadersPoolConfig{ + MaxHeadersPerShard: 1000, + NumElementsToRemoveOnEviction: 10, + }, + ) + require.False(t, headersCacher.IsInterfaceNil()) +} + func createASliceOfHeaders(numHeaders int, shardId uint32) ([]block.Header, [][]byte) { headers := make([]block.Header, 0) headersHashes := make([][]byte, 0) diff --git a/dataRetriever/factory/resolverscontainer/metaResolversContainerFactory_test.go b/dataRetriever/factory/resolverscontainer/metaResolversContainerFactory_test.go index 3c7c8ee020d..f332cc8e9f7 100644 --- a/dataRetriever/factory/resolverscontainer/metaResolversContainerFactory_test.go +++ b/dataRetriever/factory/resolverscontainer/metaResolversContainerFactory_test.go @@ -5,6 +5,7 @@ import ( "strings" "testing" + "github.com/multiversx/mx-chain-core-go/core" "github.com/multiversx/mx-chain-go/common" "github.com/multiversx/mx-chain-go/dataRetriever" "github.com/multiversx/mx-chain-go/dataRetriever/factory/resolverscontainer" @@ -89,6 +90,17 @@ func createTriesHolderForMeta() common.TriesHolder { // ------- NewResolversContainerFactory +func TestNewMetaResolversContainerFactory_NewNumGoRoutinesThrottlerFailsShouldErr(t *testing.T) { + t.Parallel() + + args := getArgumentsMeta() + args.NumConcurrentResolvingJobs = 0 + rcf, err := resolverscontainer.NewMetaResolversContainerFactory(args) + + assert.Nil(t, rcf) + assert.Equal(t, core.ErrNotPositiveValue, err) +} + func TestNewMetaResolversContainerFactory_NilShardCoordinatorShouldErr(t *testing.T) { t.Parallel() @@ -281,6 +293,18 @@ func TestMetaResolversContainerFactory_With4ShardsShouldWork(t *testing.T) { assert.Equal(t, totalResolvers+noOfShards, container.Len()) } +func TestMetaResolversContainerFactory_IsInterfaceNil(t *testing.T) { + t.Parallel() + + args := getArgumentsMeta() + args.ShardCoordinator = nil + rcf, _ := resolverscontainer.NewMetaResolversContainerFactory(args) + assert.True(t, rcf.IsInterfaceNil()) + + rcf, _ = resolverscontainer.NewMetaResolversContainerFactory(getArgumentsMeta()) + assert.False(t, rcf.IsInterfaceNil()) +} + func getArgumentsMeta() resolverscontainer.FactoryArgs { return resolverscontainer.FactoryArgs{ ShardCoordinator: mock.NewOneShardCoordinatorMock(), diff --git a/dataRetriever/factory/resolverscontainer/shardResolversContainerFactory_test.go b/dataRetriever/factory/resolverscontainer/shardResolversContainerFactory_test.go index f55fe63774e..06e7bfd8147 100644 --- a/dataRetriever/factory/resolverscontainer/shardResolversContainerFactory_test.go +++ b/dataRetriever/factory/resolverscontainer/shardResolversContainerFactory_test.go @@ -5,6 +5,7 @@ import ( "strings" "testing" + "github.com/multiversx/mx-chain-core-go/core" "github.com/multiversx/mx-chain-go/common" "github.com/multiversx/mx-chain-go/dataRetriever" "github.com/multiversx/mx-chain-go/dataRetriever/factory/resolverscontainer" @@ -95,6 +96,17 @@ func createTriesHolderForShard() common.TriesHolder { // ------- NewResolversContainerFactory +func TestNewShardResolversContainerFactory_NewNumGoRoutinesThrottlerFailsShouldErr(t *testing.T) { + t.Parallel() + + args := getArgumentsShard() + args.NumConcurrentResolvingJobs = 0 + rcf, err := resolverscontainer.NewShardResolversContainerFactory(args) + + assert.Nil(t, rcf) + assert.Equal(t, core.ErrNotPositiveValue, err) +} + func TestNewShardResolversContainerFactory_NilShardCoordinatorShouldErr(t *testing.T) { t.Parallel() @@ -337,6 +349,18 @@ func TestShardResolversContainerFactory_With4ShardsShouldWork(t *testing.T) { assert.Equal(t, totalResolvers, container.Len()) } +func TestShardResolversContainerFactory_IsInterfaceNil(t *testing.T) { + t.Parallel() + + args := getArgumentsShard() + args.ShardCoordinator = nil + rcf, _ := resolverscontainer.NewShardResolversContainerFactory(args) + assert.True(t, rcf.IsInterfaceNil()) + + rcf, _ = resolverscontainer.NewShardResolversContainerFactory(getArgumentsMeta()) + assert.False(t, rcf.IsInterfaceNil()) +} + func getArgumentsShard() resolverscontainer.FactoryArgs { return resolverscontainer.FactoryArgs{ ShardCoordinator: mock.NewOneShardCoordinatorMock(), diff --git a/dataRetriever/provider/miniBlocks_test.go b/dataRetriever/provider/miniBlocks_test.go index c935345363d..3ccbeba3490 100644 --- a/dataRetriever/provider/miniBlocks_test.go +++ b/dataRetriever/provider/miniBlocks_test.go @@ -2,6 +2,7 @@ package provider_test import ( "bytes" + "errors" "fmt" "testing" @@ -240,13 +241,24 @@ func TestMiniBlockProvider_GetMiniBlocksFromStorerShouldBeFoundInStorage(t *test existingHashes := [][]byte{ []byte("hash1"), []byte("hash2"), + []byte("hash3"), } requestedHashes := existingHashes + cnt := 0 arg := createMockMiniblockProviderArgs(nil, existingHashes) + arg.Marshalizer = &testscommon.MarshalizerStub{ + UnmarshalCalled: func(obj interface{}, buff []byte) error { + cnt++ + if cnt == 1 { + return errors.New("unmarshal fails for coverage") + } + return nil + }, + } mbp, _ := provider.NewMiniBlockProvider(arg) miniBlocksAndHashes, missingHashes := mbp.GetMiniBlocksFromStorer(requestedHashes) assert.Equal(t, 2, len(miniBlocksAndHashes)) - assert.Equal(t, 0, len(missingHashes)) + assert.Equal(t, 1, len(missingHashes)) } diff --git a/dataRetriever/requestHandlers/requestHandler_test.go b/dataRetriever/requestHandlers/requestHandler_test.go index 0c9abb97036..48d27f46217 100644 --- a/dataRetriever/requestHandlers/requestHandler_test.go +++ b/dataRetriever/requestHandlers/requestHandler_test.go @@ -37,711 +37,909 @@ func createRequestersFinderStubThatShouldNotBeCalled(tb testing.TB) *dataRetriev } } -func TestNewResolverRequestHandlerNilFinder(t *testing.T) { +func TestNewResolverRequestHandler(t *testing.T) { t.Parallel() - rrh, err := NewResolverRequestHandler( - nil, - &mock.RequestedItemsHandlerStub{}, - &mock.WhiteListHandlerStub{}, - 1, - 0, - time.Second, - ) + t.Run("nil finder should error", func(t *testing.T) { + t.Parallel() - assert.Nil(t, rrh) - assert.Equal(t, dataRetriever.ErrNilRequestersFinder, err) -} + rrh, err := NewResolverRequestHandler( + nil, + &mock.RequestedItemsHandlerStub{}, + &mock.WhiteListHandlerStub{}, + 1, + 0, + time.Second, + ) -func TestNewResolverRequestHandlerNilRequestedItemsHandler(t *testing.T) { - t.Parallel() + assert.Nil(t, rrh) + assert.Equal(t, dataRetriever.ErrNilRequestersFinder, err) + }) + t.Run("nil requested items handler should error", func(t *testing.T) { + t.Parallel() - rrh, err := NewResolverRequestHandler( - &dataRetrieverMocks.RequestersFinderStub{}, - nil, - &mock.WhiteListHandlerStub{}, - 1, - 0, - time.Second, - ) + rrh, err := NewResolverRequestHandler( + &dataRetrieverMocks.RequestersFinderStub{}, + nil, + &mock.WhiteListHandlerStub{}, + 1, + 0, + time.Second, + ) - assert.Nil(t, rrh) - assert.Equal(t, dataRetriever.ErrNilRequestedItemsHandler, err) -} + assert.Nil(t, rrh) + assert.Equal(t, dataRetriever.ErrNilRequestedItemsHandler, err) + }) + t.Run("nil whitelist handler should error", func(t *testing.T) { + t.Parallel() -func TestNewResolverRequestHandlerMaxTxRequestTooSmall(t *testing.T) { - t.Parallel() + rrh, err := NewResolverRequestHandler( + &dataRetrieverMocks.RequestersFinderStub{}, + &mock.RequestedItemsHandlerStub{}, + nil, + 1, + 0, + time.Second, + ) - rrh, err := NewResolverRequestHandler( - &dataRetrieverMocks.RequestersFinderStub{}, - &mock.RequestedItemsHandlerStub{}, - &mock.WhiteListHandlerStub{}, - 0, - 0, - time.Second, - ) + assert.Nil(t, rrh) + assert.Equal(t, dataRetriever.ErrNilWhiteListHandler, err) + }) + t.Run("invalid max txs to request should error", func(t *testing.T) { + t.Parallel() - assert.Nil(t, rrh) - assert.Equal(t, dataRetriever.ErrInvalidMaxTxRequest, err) -} + rrh, err := NewResolverRequestHandler( + &dataRetrieverMocks.RequestersFinderStub{}, + &mock.RequestedItemsHandlerStub{}, + &mock.WhiteListHandlerStub{}, + 0, + 0, + time.Second, + ) -func TestNewResolverRequestHandler(t *testing.T) { - t.Parallel() + assert.Nil(t, rrh) + assert.Equal(t, dataRetriever.ErrInvalidMaxTxRequest, err) + }) + t.Run("invalid request interval should error", func(t *testing.T) { + t.Parallel() - rrh, err := NewResolverRequestHandler( - &dataRetrieverMocks.RequestersFinderStub{}, - &mock.RequestedItemsHandlerStub{}, - &mock.WhiteListHandlerStub{}, - 1, - 0, - time.Second, - ) + rrh, err := NewResolverRequestHandler( + &dataRetrieverMocks.RequestersFinderStub{}, + &mock.RequestedItemsHandlerStub{}, + &mock.WhiteListHandlerStub{}, + 1, + 0, + time.Millisecond-time.Nanosecond, + ) + + assert.Nil(t, rrh) + assert.True(t, errors.Is(err, dataRetriever.ErrRequestIntervalTooSmall)) + }) + t.Run("should work", func(t *testing.T) { + t.Parallel() + + rrh, err := NewResolverRequestHandler( + &dataRetrieverMocks.RequestersFinderStub{}, + &mock.RequestedItemsHandlerStub{}, + &mock.WhiteListHandlerStub{}, + 1, + 0, + time.Second, + ) - assert.Nil(t, err) - assert.NotNil(t, rrh) + assert.Nil(t, err) + assert.NotNil(t, rrh) + }) } -func TestResolverRequestHandler_RequestTransactionErrorWhenGettingCrossShardRequesterShouldNotPanic(t *testing.T) { +func TestResolverRequestHandler_RequestTransaction(t *testing.T) { t.Parallel() - defer func() { - r := recover() - if r != nil { - assert.Fail(t, "should not panic") - } - }() + t.Run("no hash should not panic", func(t *testing.T) { + t.Parallel() - rrh, _ := NewResolverRequestHandler( - &dataRetrieverMocks.RequestersFinderStub{ - CrossShardRequesterCalled: func(baseTopic string, crossShard uint32) (requester dataRetriever.Requester, e error) { - return nil, errExpected + defer func() { + r := recover() + if r != nil { + assert.Fail(t, "should not panic") + } + }() + + rrh, _ := NewResolverRequestHandler( + &dataRetrieverMocks.RequestersFinderStub{ + CrossShardRequesterCalled: func(baseTopic string, crossShard uint32) (requester dataRetriever.Requester, e error) { + require.Fail(t, "should have not been called") + return nil, nil + }, }, - }, - &mock.RequestedItemsHandlerStub{}, - &mock.WhiteListHandlerStub{}, - 1, - 0, - time.Second, - ) + &mock.RequestedItemsHandlerStub{}, + &mock.WhiteListHandlerStub{}, + 1, + 0, + time.Second, + ) - rrh.RequestTransaction(0, make([][]byte, 0)) -} + rrh.RequestTransaction(0, make([][]byte, 0)) + }) + t.Run("error when getting cross shard requester should not panic", func(t *testing.T) { + t.Parallel() -func TestResolverRequestHandler_RequestTransactionWrongResolverShouldNotPanic(t *testing.T) { - t.Parallel() + defer func() { + r := recover() + if r != nil { + assert.Fail(t, "should not panic") + } + }() - defer func() { - r := recover() - if r != nil { - assert.Fail(t, "should not panic") - } - }() + rrh, _ := NewResolverRequestHandler( + &dataRetrieverMocks.RequestersFinderStub{ + CrossShardRequesterCalled: func(baseTopic string, crossShard uint32) (requester dataRetriever.Requester, e error) { + return nil, errExpected + }, + }, + &mock.RequestedItemsHandlerStub{}, + &mock.WhiteListHandlerStub{}, + 1, + 0, + time.Second, + ) - wrongTxRequester := &dataRetrieverMocks.NonceRequesterStub{} + rrh.RequestTransaction(0, [][]byte{[]byte("txHash")}) + }) + t.Run("uncastable requester should not panic", func(t *testing.T) { + t.Parallel() - rrh, _ := NewResolverRequestHandler( - &dataRetrieverMocks.RequestersFinderStub{ - CrossShardRequesterCalled: func(baseTopic string, crossShard uint32) (requester dataRetriever.Requester, e error) { - return wrongTxRequester, nil + defer func() { + r := recover() + if r != nil { + assert.Fail(t, "should not panic") + } + }() + + wrongTxRequester := &dataRetrieverMocks.NonceRequesterStub{} + + rrh, _ := NewResolverRequestHandler( + &dataRetrieverMocks.RequestersFinderStub{ + CrossShardRequesterCalled: func(baseTopic string, crossShard uint32) (requester dataRetriever.Requester, e error) { + return wrongTxRequester, nil + }, }, - }, - &mock.RequestedItemsHandlerStub{}, - &mock.WhiteListHandlerStub{}, - 1, - 0, - time.Second, - ) + &mock.RequestedItemsHandlerStub{}, + &mock.WhiteListHandlerStub{}, + 1, + 0, + time.Second, + ) - rrh.RequestTransaction(0, make([][]byte, 0)) -} + rrh.RequestTransaction(0, [][]byte{[]byte("txHash")}) + }) + t.Run("should request", func(t *testing.T) { + t.Parallel() -func TestResolverRequestHandler_RequestTransactionShouldRequestTransactions(t *testing.T) { - t.Parallel() + chTxRequested := make(chan struct{}) + txRequester := &dataRetrieverMocks.HashSliceRequesterStub{ + RequestDataFromHashArrayCalled: func(hashes [][]byte, epoch uint32) error { + chTxRequested <- struct{}{} + return nil + }, + } - chTxRequested := make(chan struct{}) - txRequester := &dataRetrieverMocks.HashSliceRequesterStub{ - RequestDataFromHashArrayCalled: func(hashes [][]byte, epoch uint32) error { - chTxRequested <- struct{}{} - return nil - }, - } + rrh, _ := NewResolverRequestHandler( + &dataRetrieverMocks.RequestersFinderStub{ + CrossShardRequesterCalled: func(baseTopic string, crossShard uint32) (requester dataRetriever.Requester, e error) { + return txRequester, nil + }, + }, + &mock.RequestedItemsHandlerStub{}, + &mock.WhiteListHandlerStub{}, + 1, + 0, + time.Second, + ) - rrh, _ := NewResolverRequestHandler( - &dataRetrieverMocks.RequestersFinderStub{ - CrossShardRequesterCalled: func(baseTopic string, crossShard uint32) (requester dataRetriever.Requester, e error) { - return txRequester, nil + rrh.RequestTransaction(0, [][]byte{[]byte("txHash")}) + + select { + case <-chTxRequested: + case <-time.After(timeoutSendRequests): + assert.Fail(t, "timeout while waiting to call RequestDataFromHashArray") + } + + time.Sleep(time.Second) + }) + t.Run("should request 4 times if different shards", func(t *testing.T) { + t.Parallel() + + numRequests := uint32(0) + txRequester := &dataRetrieverMocks.HashSliceRequesterStub{ + RequestDataFromHashArrayCalled: func(hashes [][]byte, epoch uint32) error { + atomic.AddUint32(&numRequests, 1) + return nil }, - }, - &mock.RequestedItemsHandlerStub{}, - &mock.WhiteListHandlerStub{}, - 1, - 0, - time.Second, - ) + } - rrh.RequestTransaction(0, [][]byte{[]byte("txHash")}) + timeSpan := time.Second + timeCache := cache.NewTimeCache(timeSpan) + rrh, _ := NewResolverRequestHandler( + &dataRetrieverMocks.RequestersFinderStub{ + CrossShardRequesterCalled: func(baseTopic string, crossShard uint32) (requester dataRetriever.Requester, e error) { + return txRequester, nil + }, + }, + timeCache, + &mock.WhiteListHandlerStub{}, + 1, + 0, + time.Second, + ) - select { - case <-chTxRequested: - case <-time.After(timeoutSendRequests): - assert.Fail(t, "timeout while waiting to call RequestDataFromHashArray") - } + rrh.RequestTransaction(0, [][]byte{[]byte("txHash")}) + rrh.RequestTransaction(1, [][]byte{[]byte("txHash")}) + rrh.RequestTransaction(0, [][]byte{[]byte("txHash")}) + rrh.RequestTransaction(1, [][]byte{[]byte("txHash")}) - time.Sleep(time.Second) -} + time.Sleep(time.Second) // let the go routines finish + assert.Equal(t, uint32(2), atomic.LoadUint32(&numRequests)) + time.Sleep(time.Second) // sweep will take effect -func TestResolverRequestHandler_RequestTransactionShouldRequest4TimesIfDifferentShardsAndEnoughTime(t *testing.T) { - t.Parallel() + rrh.RequestTransaction(0, [][]byte{[]byte("txHash")}) + rrh.RequestTransaction(1, [][]byte{[]byte("txHash")}) + rrh.RequestTransaction(0, [][]byte{[]byte("txHash")}) + rrh.RequestTransaction(1, [][]byte{[]byte("txHash")}) - numRequests := uint32(0) - txRequester := &dataRetrieverMocks.HashSliceRequesterStub{ - RequestDataFromHashArrayCalled: func(hashes [][]byte, epoch uint32) error { - atomic.AddUint32(&numRequests, 1) - return nil - }, - } + time.Sleep(time.Second) // let the go routines finish + assert.Equal(t, uint32(4), atomic.LoadUint32(&numRequests)) + }) + t.Run("errors on request should not panic", func(t *testing.T) { + t.Parallel() - timeSpan := time.Second - timeCache := cache.NewTimeCache(timeSpan) - rrh, _ := NewResolverRequestHandler( - &dataRetrieverMocks.RequestersFinderStub{ - CrossShardRequesterCalled: func(baseTopic string, crossShard uint32) (requester dataRetriever.Requester, e error) { - return txRequester, nil + defer func() { + r := recover() + if r != nil { + assert.Fail(t, "should not panic") + } + }() + + chTxRequested := make(chan struct{}) + txRequester := &dataRetrieverMocks.HashSliceRequesterStub{ + RequestDataFromHashArrayCalled: func(hashes [][]byte, epoch uint32) error { + chTxRequested <- struct{}{} + return errExpected }, - }, - timeCache, - &mock.WhiteListHandlerStub{}, - 1, - 0, - time.Second, - ) + } - rrh.RequestTransaction(0, [][]byte{[]byte("txHash")}) - rrh.RequestTransaction(1, [][]byte{[]byte("txHash")}) - rrh.RequestTransaction(0, [][]byte{[]byte("txHash")}) - rrh.RequestTransaction(1, [][]byte{[]byte("txHash")}) + rrh, _ := NewResolverRequestHandler( + &dataRetrieverMocks.RequestersFinderStub{ + CrossShardRequesterCalled: func(baseTopic string, crossShard uint32) (requester dataRetriever.Requester, e error) { + return txRequester, nil + }, + }, + &mock.RequestedItemsHandlerStub{}, + &mock.WhiteListHandlerStub{}, + 1, + 0, + time.Second, + ) - time.Sleep(time.Second) // let the go routines finish - assert.Equal(t, uint32(2), atomic.LoadUint32(&numRequests)) - time.Sleep(time.Second) // sweep will take effect + rrh.RequestTransaction(0, [][]byte{[]byte("txHash")}) - rrh.RequestTransaction(0, [][]byte{[]byte("txHash")}) - rrh.RequestTransaction(1, [][]byte{[]byte("txHash")}) - rrh.RequestTransaction(0, [][]byte{[]byte("txHash")}) - rrh.RequestTransaction(1, [][]byte{[]byte("txHash")}) + select { + case <-chTxRequested: + case <-time.After(timeoutSendRequests): + assert.Fail(t, "timeout while waiting to call RequestDataFromHashArray") + } - time.Sleep(time.Second) // let the go routines finish - assert.Equal(t, uint32(4), atomic.LoadUint32(&numRequests)) + time.Sleep(time.Second) + }) } -func TestResolverRequestHandler_RequestTransactionErrorsOnRequestShouldNotPanic(t *testing.T) { +func TestResolverRequestHandler_RequestMiniBlock(t *testing.T) { t.Parallel() - defer func() { - r := recover() - if r != nil { - assert.Fail(t, "should not panic") - } - }() + t.Run("hash already requested", func(t *testing.T) { + t.Parallel() - chTxRequested := make(chan struct{}) - txRequester := &dataRetrieverMocks.HashSliceRequesterStub{ - RequestDataFromHashArrayCalled: func(hashes [][]byte, epoch uint32) error { - chTxRequested <- struct{}{} - return errExpected - }, - } + defer func() { + r := recover() + if r != nil { + assert.Fail(t, "should not panic") + } + }() - rrh, _ := NewResolverRequestHandler( - &dataRetrieverMocks.RequestersFinderStub{ - CrossShardRequesterCalled: func(baseTopic string, crossShard uint32) (requester dataRetriever.Requester, e error) { - return txRequester, nil + rrh, _ := NewResolverRequestHandler( + &dataRetrieverMocks.RequestersFinderStub{ + CrossShardRequesterCalled: func(baseTopic string, crossShard uint32) (requester dataRetriever.Requester, e error) { + require.Fail(t, "should not have been called") + return nil, nil + }, }, - }, - &mock.RequestedItemsHandlerStub{}, - &mock.WhiteListHandlerStub{}, - 1, - 0, - time.Second, - ) + &mock.RequestedItemsHandlerStub{ + HasCalled: func(key string) bool { + return true + }, + }, + &mock.WhiteListHandlerStub{}, + 1, + 0, + time.Second, + ) - rrh.RequestTransaction(0, [][]byte{[]byte("txHash")}) + rrh.RequestMiniBlock(0, make([]byte, 0)) + }) + t.Run("CrossShardRequester returns error", func(t *testing.T) { + t.Parallel() - select { - case <-chTxRequested: - case <-time.After(timeoutSendRequests): - assert.Fail(t, "timeout while waiting to call RequestDataFromHashArray") - } + defer func() { + r := recover() + if r != nil { + assert.Fail(t, "should not panic") + } + }() - time.Sleep(time.Second) -} + rrh, _ := NewResolverRequestHandler( + &dataRetrieverMocks.RequestersFinderStub{ + CrossShardRequesterCalled: func(baseTopic string, crossShard uint32) (requester dataRetriever.Requester, e error) { + return nil, errExpected + }, + }, + &mock.RequestedItemsHandlerStub{}, + &mock.WhiteListHandlerStub{}, + 1, + 0, + time.Second, + ) -func TestResolverRequestHandler_RequestMiniBlockErrorWhenGettingCrossShardRequesterShouldNotPanic(t *testing.T) { - t.Parallel() + rrh.RequestMiniBlock(0, make([]byte, 0)) + }) + t.Run("RequestDataFromHash error", func(t *testing.T) { + t.Parallel() - defer func() { - r := recover() - if r != nil { - assert.Fail(t, "should not panic") + defer func() { + r := recover() + if r != nil { + assert.Fail(t, "should not panic") + } + }() + + mbRequester := &dataRetrieverMocks.RequesterStub{ + RequestDataFromHashCalled: func(hash []byte, epoch uint32) error { + return errExpected + }, + } + + rrh, _ := NewResolverRequestHandler( + &dataRetrieverMocks.RequestersFinderStub{ + CrossShardRequesterCalled: func(baseTopic string, crossShard uint32) (requester dataRetriever.Requester, e error) { + return mbRequester, nil + }, + }, + &mock.RequestedItemsHandlerStub{}, + &mock.WhiteListHandlerStub{}, + 1, + 0, + time.Second, + ) + + rrh.RequestMiniBlock(0, []byte("mbHash")) + }) + t.Run("should request", func(t *testing.T) { + t.Parallel() + + wasCalled := false + mbRequester := &dataRetrieverMocks.RequesterStub{ + RequestDataFromHashCalled: func(hash []byte, epoch uint32) error { + wasCalled = true + return nil + }, } - }() - rrh, _ := NewResolverRequestHandler( - &dataRetrieverMocks.RequestersFinderStub{ - CrossShardRequesterCalled: func(baseTopic string, crossShard uint32) (requester dataRetriever.Requester, e error) { - return nil, errExpected + rrh, _ := NewResolverRequestHandler( + &dataRetrieverMocks.RequestersFinderStub{ + CrossShardRequesterCalled: func(baseTopic string, crossShard uint32) (requester dataRetriever.Requester, e error) { + return mbRequester, nil + }, }, - }, - &mock.RequestedItemsHandlerStub{}, - &mock.WhiteListHandlerStub{}, - 1, - 0, - time.Second, - ) + &mock.RequestedItemsHandlerStub{}, + &mock.WhiteListHandlerStub{}, + 1, + 0, + time.Second, + ) - rrh.RequestMiniBlock(0, make([]byte, 0)) -} + rrh.RequestMiniBlock(0, []byte("mbHash")) -func TestResolverRequestHandler_RequestMiniBlockErrorsOnRequestShouldNotPanic(t *testing.T) { - t.Parallel() + assert.True(t, wasCalled) + }) + t.Run("should call with the correct epoch", func(t *testing.T) { + t.Parallel() - defer func() { - r := recover() - if r != nil { - assert.Fail(t, "should not panic") + expectedEpoch := uint32(7) + mbRequester := &dataRetrieverMocks.RequesterStub{ + RequestDataFromHashCalled: func(hash []byte, epoch uint32) error { + assert.Equal(t, expectedEpoch, epoch) + return nil + }, } - }() - - mbRequester := &dataRetrieverMocks.RequesterStub{ - RequestDataFromHashCalled: func(hash []byte, epoch uint32) error { - return errExpected - }, - } - rrh, _ := NewResolverRequestHandler( - &dataRetrieverMocks.RequestersFinderStub{ - CrossShardRequesterCalled: func(baseTopic string, crossShard uint32) (requester dataRetriever.Requester, e error) { - return mbRequester, nil + rrh, _ := NewResolverRequestHandler( + &dataRetrieverMocks.RequestersFinderStub{ + CrossShardRequesterCalled: func(baseTopic string, crossShard uint32) (requester dataRetriever.Requester, e error) { + return mbRequester, nil + }, }, - }, - &mock.RequestedItemsHandlerStub{}, - &mock.WhiteListHandlerStub{}, - 1, - 0, - time.Second, - ) + &mock.RequestedItemsHandlerStub{}, + &mock.WhiteListHandlerStub{}, + 1, + 0, + time.Second, + ) + + rrh.SetEpoch(expectedEpoch) - rrh.RequestMiniBlock(0, []byte("mbHash")) + rrh.RequestMiniBlock(0, []byte("mbHash")) + }) } -func TestResolverRequestHandler_RequestMiniBlockShouldCallRequestOnResolver(t *testing.T) { +func TestResolverRequestHandler_RequestShardHeader(t *testing.T) { t.Parallel() - wasCalled := false - mbRequester := &dataRetrieverMocks.RequesterStub{ - RequestDataFromHashCalled: func(hash []byte, epoch uint32) error { - wasCalled = true - return nil - }, - } + t.Run("hash already requested should work", func(t *testing.T) { + t.Parallel() - rrh, _ := NewResolverRequestHandler( - &dataRetrieverMocks.RequestersFinderStub{ - CrossShardRequesterCalled: func(baseTopic string, crossShard uint32) (requester dataRetriever.Requester, e error) { - return mbRequester, nil + rrh, _ := NewResolverRequestHandler( + createRequestersFinderStubThatShouldNotBeCalled(t), + &mock.RequestedItemsHandlerStub{ + HasCalled: func(key string) bool { + return true + }, }, - }, - &mock.RequestedItemsHandlerStub{}, - &mock.WhiteListHandlerStub{}, - 1, - 0, - time.Second, - ) - - rrh.RequestMiniBlock(0, []byte("mbHash")) + &mock.WhiteListHandlerStub{}, + 1, + 0, + time.Second, + ) - assert.True(t, wasCalled) -} + rrh.RequestShardHeader(0, make([]byte, 0)) + }) + t.Run("no hash should work", func(t *testing.T) { + t.Parallel() -func TestResolverRequestHandler_RequestMiniBlockShouldCallWithTheCorrectEpoch(t *testing.T) { - t.Parallel() + rrh, _ := NewResolverRequestHandler( + createRequestersFinderStubThatShouldNotBeCalled(t), + &mock.RequestedItemsHandlerStub{}, + &mock.WhiteListHandlerStub{}, + 1, + 0, + time.Second, + ) - expectedEpoch := uint32(7) - mbRequester := &dataRetrieverMocks.RequesterStub{ - RequestDataFromHashCalled: func(hash []byte, epoch uint32) error { - assert.Equal(t, expectedEpoch, epoch) - return nil - }, - } + rrh.RequestShardHeader(1, make([]byte, 0)) + }) + t.Run("RequestDataFromHash returns error should work", func(t *testing.T) { + t.Parallel() - rrh, _ := NewResolverRequestHandler( - &dataRetrieverMocks.RequestersFinderStub{ - CrossShardRequesterCalled: func(baseTopic string, crossShard uint32) (requester dataRetriever.Requester, e error) { - return mbRequester, nil + mbRequester := &dataRetrieverMocks.RequesterStub{ + RequestDataFromHashCalled: func(hash []byte, epoch uint32) error { + return errExpected }, - }, - &mock.RequestedItemsHandlerStub{}, - &mock.WhiteListHandlerStub{}, - 1, - 0, - time.Second, - ) + } - rrh.SetEpoch(expectedEpoch) + rrh, _ := NewResolverRequestHandler( + &dataRetrieverMocks.RequestersFinderStub{ + CrossShardRequesterCalled: func(baseTopic string, crossShard uint32) (requester dataRetriever.Requester, e error) { + return mbRequester, nil + }, + }, + &mock.RequestedItemsHandlerStub{}, + &mock.WhiteListHandlerStub{}, + 1, + 0, + time.Second, + ) - rrh.RequestMiniBlock(0, []byte("mbHash")) -} + rrh.RequestShardHeader(0, []byte("hdrHash")) + }) + t.Run("should call request", func(t *testing.T) { + t.Parallel() -func TestResolverRequestHandler_RequestShardHeaderHashAlreadyRequestedShouldNotRequest(t *testing.T) { - t.Parallel() + wasCalled := false + mbRequester := &dataRetrieverMocks.RequesterStub{ + RequestDataFromHashCalled: func(hash []byte, epoch uint32) error { + wasCalled = true + return nil + }, + } - rrh, _ := NewResolverRequestHandler( - createRequestersFinderStubThatShouldNotBeCalled(t), - &mock.RequestedItemsHandlerStub{ - HasCalled: func(key string) bool { - return true + rrh, _ := NewResolverRequestHandler( + &dataRetrieverMocks.RequestersFinderStub{ + CrossShardRequesterCalled: func(baseTopic string, crossShard uint32) (requester dataRetriever.Requester, e error) { + return mbRequester, nil + }, }, - }, - &mock.WhiteListHandlerStub{}, - 1, - 0, - time.Second, - ) + &mock.RequestedItemsHandlerStub{}, + &mock.WhiteListHandlerStub{}, + 1, + 0, + time.Second, + ) - rrh.RequestShardHeader(0, make([]byte, 0)) + rrh.RequestShardHeader(0, []byte("hdrHash")) + + assert.True(t, wasCalled) + }) } -func TestResolverRequestHandler_RequestShardHeaderHashBadRequest(t *testing.T) { +func TestResolverRequestHandler_RequestMetaHeader(t *testing.T) { t.Parallel() - rrh, _ := NewResolverRequestHandler( - createRequestersFinderStubThatShouldNotBeCalled(t), - &mock.RequestedItemsHandlerStub{}, - &mock.WhiteListHandlerStub{}, - 1, - 0, - time.Second, - ) + t.Run("header already requested should work", func(t *testing.T) { + t.Parallel() - rrh.RequestShardHeader(1, make([]byte, 0)) -} + rrh, _ := NewResolverRequestHandler( + &dataRetrieverMocks.RequestersFinderStub{}, + &mock.RequestedItemsHandlerStub{ + HasCalled: func(key string) bool { + return true + }, + }, + &mock.WhiteListHandlerStub{}, + 1, + 0, + time.Second, + ) -func TestResolverRequestHandler_RequestShardHeaderShouldCallRequestOnResolver(t *testing.T) { - t.Parallel() + rrh.RequestMetaHeader([]byte("hdrHash")) + }) + t.Run("cast fail should work", func(t *testing.T) { + t.Parallel() - wasCalled := false - mbRequester := &dataRetrieverMocks.RequesterStub{ - RequestDataFromHashCalled: func(hash []byte, epoch uint32) error { - wasCalled = true - return nil - }, - } + req := &dataRetrieverMocks.RequesterStub{ + RequestDataFromHashCalled: func(hash []byte, epoch uint32) error { + require.Fail(t, "should have not been called") + return nil + }, + } - rrh, _ := NewResolverRequestHandler( - &dataRetrieverMocks.RequestersFinderStub{ - CrossShardRequesterCalled: func(baseTopic string, crossShard uint32) (requester dataRetriever.Requester, e error) { - return mbRequester, nil + rrh, _ := NewResolverRequestHandler( + &dataRetrieverMocks.RequestersFinderStub{ + MetaChainRequesterCalled: func(baseTopic string) (requester dataRetriever.Requester, e error) { + return req, nil + }, }, - }, - &mock.RequestedItemsHandlerStub{}, - &mock.WhiteListHandlerStub{}, - 1, - 0, - time.Second, - ) + &mock.RequestedItemsHandlerStub{}, + &mock.WhiteListHandlerStub{}, + 1, + 0, + time.Second, + ) - rrh.RequestShardHeader(0, []byte("hdrHash")) + rrh.RequestMetaHeader([]byte("hdrHash")) + }) + t.Run("MetaChainRequester returns error should work", func(t *testing.T) { + t.Parallel() - assert.True(t, wasCalled) -} + rrh, _ := NewResolverRequestHandler( + &dataRetrieverMocks.RequestersFinderStub{ + MetaChainRequesterCalled: func(baseTopic string) (requester dataRetriever.Requester, e error) { + return nil, errExpected + }, + }, + &mock.RequestedItemsHandlerStub{}, + &mock.WhiteListHandlerStub{}, + 1, + 0, + time.Second, + ) -func TestResolverRequestHandler_RequestMetadHeaderHashAlreadyRequestedShouldNotRequest(t *testing.T) { - t.Parallel() + rrh.RequestMetaHeader([]byte("hdrHash")) + }) + t.Run("RequestDataFromHash returns error should work", func(t *testing.T) { + t.Parallel() - rrh, _ := NewResolverRequestHandler( - createRequestersFinderStubThatShouldNotBeCalled(t), - &mock.RequestedItemsHandlerStub{ - HasCalled: func(key string) bool { - return true + req := &dataRetrieverMocks.HeaderRequesterStub{ + RequestDataFromHashCalled: func(hash []byte, epoch uint32) error { + return errExpected }, - }, - &mock.WhiteListHandlerStub{}, - 1, - 0, - time.Second, - ) + } - rrh.RequestMetaHeader(make([]byte, 0)) -} + rrh, _ := NewResolverRequestHandler( + &dataRetrieverMocks.RequestersFinderStub{ + MetaChainRequesterCalled: func(baseTopic string) (requester dataRetriever.Requester, e error) { + return req, nil + }, + }, + &mock.RequestedItemsHandlerStub{}, + &mock.WhiteListHandlerStub{}, + 1, + 0, + time.Second, + ) -func TestResolverRequestHandler_RequestMetadHeaderHashNotHeaderResolverShouldNotRequest(t *testing.T) { - t.Parallel() + rrh.RequestMetaHeader([]byte("hdrHash")) + }) + t.Run("should work", func(t *testing.T) { + t.Parallel() - wasCalled := false - mbRequester := &dataRetrieverMocks.RequesterStub{ - RequestDataFromHashCalled: func(hash []byte, epoch uint32) error { - wasCalled = true - return nil - }, - } + wasCalled := false + mbRequester := &dataRetrieverMocks.HeaderRequesterStub{ + RequestDataFromHashCalled: func(hash []byte, epoch uint32) error { + wasCalled = true + return nil + }, + } - rrh, _ := NewResolverRequestHandler( - &dataRetrieverMocks.RequestersFinderStub{ - MetaChainRequesterCalled: func(baseTopic string) (requester dataRetriever.Requester, e error) { - return mbRequester, nil + rrh, _ := NewResolverRequestHandler( + &dataRetrieverMocks.RequestersFinderStub{ + MetaChainRequesterCalled: func(baseTopic string) (requester dataRetriever.Requester, e error) { + return mbRequester, nil + }, }, - }, - &mock.RequestedItemsHandlerStub{}, - &mock.WhiteListHandlerStub{}, - 1, - 0, - time.Second, - ) + &mock.RequestedItemsHandlerStub{}, + &mock.WhiteListHandlerStub{}, + 1, + 0, + time.Second, + ) - rrh.RequestMetaHeader([]byte("hdrHash")) + rrh.RequestMetaHeader([]byte("hdrHash")) - assert.False(t, wasCalled) + assert.True(t, wasCalled) + }) } -func TestResolverRequestHandler_RequestMetaHeaderShouldCallRequestOnResolver(t *testing.T) { +func TestResolverRequestHandler_RequestShardHeaderByNonce(t *testing.T) { t.Parallel() - wasCalled := false - mbRequester := &dataRetrieverMocks.HeaderRequesterStub{ - RequestDataFromHashCalled: func(hash []byte, epoch uint32) error { - wasCalled = true - return nil - }, - } + t.Run("nonce already requested should work", func(t *testing.T) { + t.Parallel() - rrh, _ := NewResolverRequestHandler( - &dataRetrieverMocks.RequestersFinderStub{ - MetaChainRequesterCalled: func(baseTopic string) (requester dataRetriever.Requester, e error) { - return mbRequester, nil + called := false + rrh, _ := NewResolverRequestHandler( + createRequestersFinderStubThatShouldNotBeCalled(t), + &mock.RequestedItemsHandlerStub{ + HasCalled: func(key string) bool { + called = true + return true + }, }, - }, - &mock.RequestedItemsHandlerStub{}, - &mock.WhiteListHandlerStub{}, - 1, - 0, - time.Second, - ) - - rrh.RequestMetaHeader([]byte("hdrHash")) - - assert.True(t, wasCalled) -} + &mock.WhiteListHandlerStub{}, + 1, + 0, + time.Second, + ) -func TestResolverRequestHandler_RequestShardHeaderByNonceAlreadyRequestedShouldNotRequest(t *testing.T) { - t.Parallel() + rrh.RequestShardHeaderByNonce(0, 0) + require.True(t, called) + }) + t.Run("invalid nonce should work", func(t *testing.T) { + t.Parallel() - called := false - rrh, _ := NewResolverRequestHandler( - createRequestersFinderStubThatShouldNotBeCalled(t), - &mock.RequestedItemsHandlerStub{ - HasCalled: func(key string) bool { - called = true - return true + called := false + rrh, _ := NewResolverRequestHandler( + &dataRetrieverMocks.RequestersFinderStub{ + CrossShardRequesterCalled: func(baseTopic string, crossShard uint32) (requester dataRetriever.Requester, err error) { + called = true + return nil, errExpected + }, }, - }, - &mock.WhiteListHandlerStub{}, - 1, - 0, - time.Second, - ) + &mock.RequestedItemsHandlerStub{}, + &mock.WhiteListHandlerStub{}, + 1, + core.MetachainShardId, + time.Second, + ) - rrh.RequestShardHeaderByNonce(0, 0) - require.True(t, called) -} + rrh.RequestShardHeaderByNonce(1, 0) + require.True(t, called) + }) + t.Run("finder returns error should work and not panic", func(t *testing.T) { + t.Parallel() -func TestResolverRequestHandler_RequestShardHeaderByNonceBadRequest(t *testing.T) { - t.Parallel() + defer func() { + r := recover() + if r != nil { + assert.Fail(t, "should not panic") + } + }() - localErr := errors.New("err") - called := false - rrh, _ := NewResolverRequestHandler( - &dataRetrieverMocks.RequestersFinderStub{ - CrossShardRequesterCalled: func(baseTopic string, crossShard uint32) (requester dataRetriever.Requester, err error) { - called = true - return nil, localErr + rrh, _ := NewResolverRequestHandler( + &dataRetrieverMocks.RequestersFinderStub{ + CrossShardRequesterCalled: func(baseTopic string, shardID uint32) (requester dataRetriever.Requester, e error) { + return nil, errExpected + }, }, - }, - &mock.RequestedItemsHandlerStub{}, - &mock.WhiteListHandlerStub{}, - 1, - core.MetachainShardId, - time.Second, - ) + &mock.RequestedItemsHandlerStub{}, + &mock.WhiteListHandlerStub{}, + 1, + 0, + time.Second, + ) - rrh.RequestShardHeaderByNonce(1, 0) - require.True(t, called) -} + rrh.RequestShardHeaderByNonce(0, 0) + }) + t.Run("cast fails should work and not panic", func(t *testing.T) { + t.Parallel() -func TestResolverRequestHandler_RequestShardHeaderByNonceFinderReturnsErrorShouldNotPanic(t *testing.T) { - t.Parallel() + defer func() { + r := recover() + if r != nil { + assert.Fail(t, "should not panic") + } + }() - defer func() { - r := recover() - if r != nil { - assert.Fail(t, "should not panic") - } - }() + hdrRequester := &dataRetrieverMocks.RequesterStub{} - rrh, _ := NewResolverRequestHandler( - &dataRetrieverMocks.RequestersFinderStub{ - CrossShardRequesterCalled: func(baseTopic string, shardID uint32) (requester dataRetriever.Requester, e error) { - return nil, errExpected + rrh, _ := NewResolverRequestHandler( + &dataRetrieverMocks.RequestersFinderStub{ + CrossShardRequesterCalled: func(baseTopic string, shardID uint32) (requester dataRetriever.Requester, e error) { + return hdrRequester, nil + }, }, - }, - &mock.RequestedItemsHandlerStub{}, - &mock.WhiteListHandlerStub{}, - 1, - 0, - time.Second, - ) + &mock.RequestedItemsHandlerStub{}, + &mock.WhiteListHandlerStub{}, + 1, + 0, + time.Second, + ) - rrh.RequestShardHeaderByNonce(0, 0) -} + rrh.RequestShardHeaderByNonce(0, 0) + }) + t.Run("resolver fails should work and not panic", func(t *testing.T) { + t.Parallel() -func TestResolverRequestHandler_RequestShardHeaderByNonceFinderReturnsAWrongResolverShouldNotPanic(t *testing.T) { - t.Parallel() + defer func() { + r := recover() + if r != nil { + assert.Fail(t, "should not panic") + } + }() - defer func() { - r := recover() - if r != nil { - assert.Fail(t, "should not panic") + hdrRequester := &dataRetrieverMocks.NonceRequesterStub{ + RequestDataFromNonceCalled: func(nonce uint64, epoch uint32) error { + return errExpected + }, } - }() - - hdrRequester := &dataRetrieverMocks.RequesterStub{ - RequestDataFromHashCalled: func(hash []byte, epoch uint32) error { - return errExpected - }, - } - rrh, _ := NewResolverRequestHandler( - &dataRetrieverMocks.RequestersFinderStub{ - CrossShardRequesterCalled: func(baseTopic string, shardID uint32) (requester dataRetriever.Requester, e error) { - return hdrRequester, nil + rrh, _ := NewResolverRequestHandler( + &dataRetrieverMocks.RequestersFinderStub{ + CrossShardRequesterCalled: func(baseTopic string, shardID uint32) (requester dataRetriever.Requester, e error) { + return hdrRequester, nil + }, }, - }, - &mock.RequestedItemsHandlerStub{}, - &mock.WhiteListHandlerStub{}, - 1, - 0, - time.Second, - ) - - rrh.RequestShardHeaderByNonce(0, 0) -} + &mock.RequestedItemsHandlerStub{}, + &mock.WhiteListHandlerStub{}, + 1, + 0, + time.Second, + ) -func TestResolverRequestHandler_RequestShardHeaderByNonceResolverFailsShouldNotPanic(t *testing.T) { - t.Parallel() + rrh.RequestShardHeaderByNonce(0, 0) + }) + t.Run("should work", func(t *testing.T) { + t.Parallel() - defer func() { - r := recover() - if r != nil { - assert.Fail(t, "should not panic") + wasCalled := false + hdrRequester := &dataRetrieverMocks.NonceRequesterStub{ + RequestDataFromNonceCalled: func(nonce uint64, epoch uint32) error { + wasCalled = true + return nil + }, } - }() - - hdrRequester := &dataRetrieverMocks.RequesterStub{ - RequestDataFromHashCalled: func(hash []byte, epoch uint32) error { - return errExpected - }, - } - rrh, _ := NewResolverRequestHandler( - &dataRetrieverMocks.RequestersFinderStub{ - CrossShardRequesterCalled: func(baseTopic string, shardID uint32) (requester dataRetriever.Requester, e error) { - return hdrRequester, nil + rrh, _ := NewResolverRequestHandler( + &dataRetrieverMocks.RequestersFinderStub{ + CrossShardRequesterCalled: func(baseTopic string, shardID uint32) (requester dataRetriever.Requester, e error) { + return hdrRequester, nil + }, }, - }, - &mock.RequestedItemsHandlerStub{}, - &mock.WhiteListHandlerStub{}, - 1, - 0, - time.Second, - ) + &mock.RequestedItemsHandlerStub{}, + &mock.WhiteListHandlerStub{}, + 1, + 0, + time.Second, + ) + + rrh.RequestShardHeaderByNonce(0, 0) - rrh.RequestShardHeaderByNonce(0, 0) + assert.True(t, wasCalled) + }) } -func TestResolverRequestHandler_RequestShardHeaderByNonceShouldRequest(t *testing.T) { +func TestResolverRequestHandler_RequestMetaHeaderByNonce(t *testing.T) { t.Parallel() - wasCalled := false - hdrRequester := &dataRetrieverMocks.NonceRequesterStub{ - RequestDataFromNonceCalled: func(nonce uint64, epoch uint32) error { - wasCalled = true - return nil - }, - } + t.Run("nonce already requested should work", func(t *testing.T) { + t.Parallel() - rrh, _ := NewResolverRequestHandler( - &dataRetrieverMocks.RequestersFinderStub{ - CrossShardRequesterCalled: func(baseTopic string, shardID uint32) (requester dataRetriever.Requester, e error) { - return hdrRequester, nil + rrh, _ := NewResolverRequestHandler( + createRequestersFinderStubThatShouldNotBeCalled(t), + &mock.RequestedItemsHandlerStub{ + HasCalled: func(key string) bool { + return true + }, }, - }, - &mock.RequestedItemsHandlerStub{}, - &mock.WhiteListHandlerStub{}, - 1, - 0, - time.Second, - ) + &mock.WhiteListHandlerStub{}, + 1, + 0, + time.Second, + ) - rrh.RequestShardHeaderByNonce(0, 0) + rrh.RequestMetaHeaderByNonce(0) + }) + t.Run("MetaChainRequester returns error should work", func(t *testing.T) { + t.Parallel() - assert.True(t, wasCalled) -} + rrh, _ := NewResolverRequestHandler( + &dataRetrieverMocks.RequestersFinderStub{ + MetaChainRequesterCalled: func(baseTopic string) (requester dataRetriever.Requester, e error) { + return nil, errExpected + }, + }, + &mock.RequestedItemsHandlerStub{}, + &mock.WhiteListHandlerStub{ + AddCalled: func(keys [][]byte) { + require.Fail(t, "should not have been called") + }, + }, + 100, + 0, + time.Second, + ) -func TestResolverRequestHandler_RequestMetaHeaderHashAlreadyRequestedShouldNotRequest(t *testing.T) { - t.Parallel() + rrh.RequestMetaHeaderByNonce(0) + }) + t.Run("RequestDataFromNonce returns error should work", func(t *testing.T) { + t.Parallel() - rrh, _ := NewResolverRequestHandler( - createRequestersFinderStubThatShouldNotBeCalled(t), - &mock.RequestedItemsHandlerStub{ - HasCalled: func(key string) bool { - return true + hdrRequester := &dataRetrieverMocks.HeaderRequesterStub{ + RequestDataFromNonceCalled: func(nonce uint64, epoch uint32) error { + return errExpected }, - }, - &mock.WhiteListHandlerStub{}, - 1, - 0, - time.Second, - ) + } - rrh.RequestMetaHeaderByNonce(0) -} + rrh, _ := NewResolverRequestHandler( + &dataRetrieverMocks.RequestersFinderStub{ + MetaChainRequesterCalled: func(baseTopic string) (requester dataRetriever.Requester, e error) { + return hdrRequester, nil + }, + }, + &mock.RequestedItemsHandlerStub{}, + &mock.WhiteListHandlerStub{}, + 100, + 0, + time.Second, + ) -func TestResolverRequestHandler_RequestMetaHeaderByNonceShouldRequest(t *testing.T) { - t.Parallel() + rrh.RequestMetaHeaderByNonce(0) + }) + t.Run("should work", func(t *testing.T) { + t.Parallel() - wasCalled := false - hdrRequester := &dataRetrieverMocks.HeaderRequesterStub{ - RequestDataFromNonceCalled: func(nonce uint64, epoch uint32) error { - wasCalled = true - return nil - }, - } + wasCalled := false + hdrRequester := &dataRetrieverMocks.HeaderRequesterStub{ + RequestDataFromNonceCalled: func(nonce uint64, epoch uint32) error { + wasCalled = true + return nil + }, + } - rrh, _ := NewResolverRequestHandler( - &dataRetrieverMocks.RequestersFinderStub{ - MetaChainRequesterCalled: func(baseTopic string) (requester dataRetriever.Requester, e error) { - return hdrRequester, nil + rrh, _ := NewResolverRequestHandler( + &dataRetrieverMocks.RequestersFinderStub{ + MetaChainRequesterCalled: func(baseTopic string) (requester dataRetriever.Requester, e error) { + return hdrRequester, nil + }, }, - }, - &mock.RequestedItemsHandlerStub{}, - &mock.WhiteListHandlerStub{}, - 100, - 0, - time.Second, - ) + &mock.RequestedItemsHandlerStub{}, + &mock.WhiteListHandlerStub{}, + 100, + 0, + time.Second, + ) - rrh.RequestMetaHeaderByNonce(0) + rrh.RequestMetaHeaderByNonce(0) - assert.True(t, wasCalled) + assert.True(t, wasCalled) + }) } func TestResolverRequestHandler_RequestScrErrorWhenGettingCrossShardRequesterShouldNotPanic(t *testing.T) { @@ -910,168 +1108,211 @@ func TestResolverRequestHandler_RequestRewardShouldRequestReward(t *testing.T) { time.Sleep(time.Second) } -func TestRequestTrieNodes_ShouldWork(t *testing.T) { +func TestRequestTrieNodes(t *testing.T) { t.Parallel() - chTxRequested := make(chan struct{}) - requesterMock := &dataRetrieverMocks.HashSliceRequesterStub{ - RequestDataFromHashArrayCalled: func(hash [][]byte, epoch uint32) error { - chTxRequested <- struct{}{} - return nil - }, - } + t.Run("should work", func(t *testing.T) { + t.Parallel() - rrh, _ := NewResolverRequestHandler( - &dataRetrieverMocks.RequestersFinderStub{ - MetaCrossShardRequesterCalled: func(baseTopic string, crossShard uint32) (dataRetriever.Requester, error) { - return requesterMock, nil + chTxRequested := make(chan struct{}) + requesterMock := &dataRetrieverMocks.HashSliceRequesterStub{ + RequestDataFromHashArrayCalled: func(hash [][]byte, epoch uint32) error { + chTxRequested <- struct{}{} + return nil }, - }, - &mock.RequestedItemsHandlerStub{}, - &mock.WhiteListHandlerStub{}, - 1, - 0, - time.Second, - ) + } - rrh.RequestTrieNodes(0, [][]byte{[]byte("hash")}, "topic") - select { - case <-chTxRequested: - case <-time.After(timeoutSendRequests): - assert.Fail(t, "timeout while waiting to call RequestDataFromHashArray") - } + rrh, _ := NewResolverRequestHandler( + &dataRetrieverMocks.RequestersFinderStub{ + MetaCrossShardRequesterCalled: func(baseTopic string, crossShard uint32) (dataRetriever.Requester, error) { + return requesterMock, nil + }, + }, + &mock.RequestedItemsHandlerStub{}, + &mock.WhiteListHandlerStub{}, + 1, + 0, + time.Second, + ) - time.Sleep(time.Second) -} + rrh.RequestTrieNodes(0, [][]byte{[]byte("hash")}, "topic") + select { + case <-chTxRequested: + case <-time.After(timeoutSendRequests): + assert.Fail(t, "timeout while waiting to call RequestDataFromHashArray") + } -func TestRequestTrieNodes_NilResolver(t *testing.T) { - t.Parallel() + time.Sleep(time.Second) + }) + t.Run("nil resolver", func(t *testing.T) { + t.Parallel() - localError := errors.New("test error") - called := false - rrh, _ := NewResolverRequestHandler( - &dataRetrieverMocks.RequestersFinderStub{ - MetaCrossShardRequesterCalled: func(baseTopic string, shId uint32) (requester dataRetriever.Requester, err error) { - called = true - return nil, localError + localError := errors.New("test error") + called := false + rrh, _ := NewResolverRequestHandler( + &dataRetrieverMocks.RequestersFinderStub{ + MetaCrossShardRequesterCalled: func(baseTopic string, shId uint32) (requester dataRetriever.Requester, err error) { + called = true + return nil, localError + }, }, - }, - &mock.RequestedItemsHandlerStub{}, - &mock.WhiteListHandlerStub{}, - 1, - 0, - time.Second, - ) - - rrh.RequestTrieNodes(core.MetachainShardId, [][]byte{[]byte("hash")}, "topic") - assert.True(t, called) -} + &mock.RequestedItemsHandlerStub{}, + &mock.WhiteListHandlerStub{}, + 1, + 0, + time.Second, + ) -func TestRequestStartOfEpochMetaBlock_MissingResolver(t *testing.T) { - t.Parallel() + rrh.RequestTrieNodes(core.MetachainShardId, [][]byte{[]byte("hash")}, "topic") + assert.True(t, called) + }) + t.Run("no hash", func(t *testing.T) { + t.Parallel() - called := false - localError := errors.New("test error") - rrh, _ := NewResolverRequestHandler( - &dataRetrieverMocks.RequestersFinderStub{ - MetaChainRequesterCalled: func(baseTopic string) (requester dataRetriever.Requester, err error) { - called = true - return nil, localError + rrh, _ := NewResolverRequestHandler( + &dataRetrieverMocks.RequestersFinderStub{ + MetaCrossShardRequesterCalled: func(baseTopic string, shId uint32) (requester dataRetriever.Requester, err error) { + require.Fail(t, "should have not been called") + return nil, nil + }, }, - }, - &mock.RequestedItemsHandlerStub{}, - &mock.WhiteListHandlerStub{}, - 1, - 0, - time.Second, - ) + &mock.RequestedItemsHandlerStub{}, + &mock.WhiteListHandlerStub{}, + 1, + 0, + time.Second, + ) - rrh.RequestStartOfEpochMetaBlock(0) - assert.True(t, called) + rrh.RequestTrieNodes(core.MetachainShardId, [][]byte{}, "topic") + }) } -func TestRequestStartOfEpochMetaBlock_WrongResolver(t *testing.T) { +func TestResolverRequestHandler_RequestStartOfEpochMetaBlock(t *testing.T) { t.Parallel() - called := false - rrh, _ := NewResolverRequestHandler( - &dataRetrieverMocks.RequestersFinderStub{ - MetaChainRequesterCalled: func(baseTopic string) (requester dataRetriever.Requester, err error) { - called = true - return &dataRetrieverMocks.RequesterStub{}, nil + t.Run("epoch already requested", func(t *testing.T) { + t.Parallel() + + rrh, _ := NewResolverRequestHandler( + &dataRetrieverMocks.RequestersFinderStub{ + MetaChainRequesterCalled: func(baseTopic string) (requester dataRetriever.Requester, err error) { + require.Fail(t, "should not have been called") + return nil, nil + }, }, - }, - &mock.RequestedItemsHandlerStub{}, - &mock.WhiteListHandlerStub{}, - 1, - 0, - time.Second, - ) + &mock.RequestedItemsHandlerStub{ + HasCalled: func(key string) bool { + return true + }, + }, + &mock.WhiteListHandlerStub{}, + 1, + 0, + time.Second, + ) - rrh.RequestStartOfEpochMetaBlock(0) - assert.True(t, called) -} + rrh.RequestStartOfEpochMetaBlock(0) + }) + t.Run("missing resolver", func(t *testing.T) { + t.Parallel() -func TestRequestStartOfEpochMetaBlock_RequestDataFromEpochError(t *testing.T) { - t.Parallel() + called := false + rrh, _ := NewResolverRequestHandler( + &dataRetrieverMocks.RequestersFinderStub{ + MetaChainRequesterCalled: func(baseTopic string) (requester dataRetriever.Requester, err error) { + called = true + return nil, errExpected + }, + }, + &mock.RequestedItemsHandlerStub{}, + &mock.WhiteListHandlerStub{}, + 1, + 0, + time.Second, + ) - called := false - localError := errors.New("test error") - requesterMock := &dataRetrieverMocks.EpochRequesterStub{ - RequestDataFromEpochCalled: func(identifier []byte) error { - called = true - return localError - }, - } + rrh.RequestStartOfEpochMetaBlock(0) + assert.True(t, called) + }) + t.Run("wrong resolver", func(t *testing.T) { + t.Parallel() - rrh, _ := NewResolverRequestHandler( - &dataRetrieverMocks.RequestersFinderStub{ - MetaChainRequesterCalled: func(baseTopic string) (requester dataRetriever.Requester, err error) { - return requesterMock, nil + called := false + rrh, _ := NewResolverRequestHandler( + &dataRetrieverMocks.RequestersFinderStub{ + MetaChainRequesterCalled: func(baseTopic string) (requester dataRetriever.Requester, err error) { + called = true + return &dataRetrieverMocks.RequesterStub{}, nil + }, }, - }, - &mock.RequestedItemsHandlerStub{}, - &mock.WhiteListHandlerStub{}, - 1, - 0, - time.Second, - ) + &mock.RequestedItemsHandlerStub{}, + &mock.WhiteListHandlerStub{}, + 1, + 0, + time.Second, + ) - rrh.RequestStartOfEpochMetaBlock(0) - assert.True(t, called) -} + rrh.RequestStartOfEpochMetaBlock(0) + assert.True(t, called) + }) + t.Run("RequestDataFromEpoch fails", func(t *testing.T) { + t.Parallel() -func TestRequestStartOfEpochMetaBlock_AddError(t *testing.T) { - t.Parallel() + called := false + requesterMock := &dataRetrieverMocks.EpochRequesterStub{ + RequestDataFromEpochCalled: func(identifier []byte) error { + called = true + return errExpected + }, + } - called := false - localError := errors.New("test error") - requesterMock := &dataRetrieverMocks.EpochRequesterStub{ - RequestDataFromEpochCalled: func(identifier []byte) error { - return nil - }, - } + rrh, _ := NewResolverRequestHandler( + &dataRetrieverMocks.RequestersFinderStub{ + MetaChainRequesterCalled: func(baseTopic string) (requester dataRetriever.Requester, err error) { + return requesterMock, nil + }, + }, + &mock.RequestedItemsHandlerStub{}, + &mock.WhiteListHandlerStub{}, + 1, + 0, + time.Second, + ) - rrh, _ := NewResolverRequestHandler( - &dataRetrieverMocks.RequestersFinderStub{ - MetaChainRequesterCalled: func(baseTopic string) (requester dataRetriever.Requester, err error) { - return requesterMock, nil + rrh.RequestStartOfEpochMetaBlock(0) + assert.True(t, called) + }) + t.Run("add error", func(t *testing.T) { + t.Parallel() + + called := false + requesterMock := &dataRetrieverMocks.EpochRequesterStub{ + RequestDataFromEpochCalled: func(identifier []byte) error { + return nil }, - }, - &mock.RequestedItemsHandlerStub{ - AddCalled: func(key string) error { - called = true - return localError + } + + rrh, _ := NewResolverRequestHandler( + &dataRetrieverMocks.RequestersFinderStub{ + MetaChainRequesterCalled: func(baseTopic string) (requester dataRetriever.Requester, err error) { + return requesterMock, nil + }, }, - }, - &mock.WhiteListHandlerStub{}, - 1, - 0, - time.Second, - ) + &mock.RequestedItemsHandlerStub{ + AddCalled: func(key string) error { + called = true + return errExpected + }, + }, + &mock.WhiteListHandlerStub{}, + 1, + 0, + time.Second, + ) - rrh.RequestStartOfEpochMetaBlock(0) - assert.True(t, called) + rrh.RequestStartOfEpochMetaBlock(0) + assert.True(t, called) + }) } func TestResolverRequestHandler_RequestTrieNodeRequestFails(t *testing.T) { @@ -1182,14 +1423,12 @@ func TestResolverRequestHandler_RequestTrieNodeNotAValidResolver(t *testing.T) { assert.True(t, called) } -//------- RequestPeerAuthentications - func TestResolverRequestHandler_RequestPeerAuthenticationsByHashes(t *testing.T) { t.Parallel() providedHashes := [][]byte{[]byte("h1"), []byte("h2")} providedShardId := uint32(15) - t.Run("CrossShardRequester returns error", func(t *testing.T) { + t.Run("MetaChainRequester returns error", func(t *testing.T) { t.Parallel() wasCalled := false @@ -1219,18 +1458,12 @@ func TestResolverRequestHandler_RequestPeerAuthenticationsByHashes(t *testing.T) t.Run("cast fails", func(t *testing.T) { t.Parallel() - wasCalled := false - mbRequester := &dataRetrieverMocks.RequesterStub{ - RequestDataFromHashCalled: func(hash []byte, epoch uint32) error { - wasCalled = true - return nil - }, - } + req := &dataRetrieverMocks.NonceRequesterStub{} rrh, _ := NewResolverRequestHandler( &dataRetrieverMocks.RequestersFinderStub{ MetaChainRequesterCalled: func(baseTopic string) (dataRetriever.Requester, error) { assert.Equal(t, common.PeerAuthenticationTopic, baseTopic) - return mbRequester, errExpected + return req, nil }, }, &mock.RequestedItemsHandlerStub{}, @@ -1241,7 +1474,6 @@ func TestResolverRequestHandler_RequestPeerAuthenticationsByHashes(t *testing.T) ) rrh.RequestPeerAuthenticationsByHashes(providedShardId, providedHashes) - assert.False(t, wasCalled) }) t.Run("RequestDataFromHashArray returns error", func(t *testing.T) { t.Parallel() @@ -1261,7 +1493,12 @@ func TestResolverRequestHandler_RequestPeerAuthenticationsByHashes(t *testing.T) return paRequester, nil }, }, - &mock.RequestedItemsHandlerStub{}, + &mock.RequestedItemsHandlerStub{ + AddCalled: func(key string) error { + require.Fail(t, "should not have been called") + return nil + }, + }, &mock.WhiteListHandlerStub{}, 1, 0, @@ -1311,7 +1548,33 @@ func TestResolverRequestHandler_RequestPeerAuthenticationsByHashes(t *testing.T) func TestResolverRequestHandler_RequestValidatorInfo(t *testing.T) { t.Parallel() + t.Run("hash already requested should work", func(t *testing.T) { + t.Parallel() + + providedHash := []byte("provided hash") + rrh, _ := NewResolverRequestHandler( + &dataRetrieverMocks.RequestersFinderStub{ + MetaChainRequesterCalled: func(baseTopic string) (requester dataRetriever.Requester, e error) { + require.Fail(t, "should not have been called") + return nil, nil + }, + }, + &mock.RequestedItemsHandlerStub{ + HasCalled: func(key string) bool { + return true + }, + }, + &mock.WhiteListHandlerStub{}, + 100, + 0, + time.Second, + ) + + rrh.RequestValidatorInfo(providedHash) + }) t.Run("MetaChainRequester returns error", func(t *testing.T) { + t.Parallel() + providedHash := []byte("provided hash") wasCalled := false res := &dataRetrieverMocks.RequesterStub{ @@ -1324,7 +1587,7 @@ func TestResolverRequestHandler_RequestValidatorInfo(t *testing.T) { rrh, _ := NewResolverRequestHandler( &dataRetrieverMocks.RequestersFinderStub{ MetaChainRequesterCalled: func(baseTopic string) (requester dataRetriever.Requester, e error) { - return res, errors.New("provided err") + return res, errExpected }, }, &mock.RequestedItemsHandlerStub{}, @@ -1337,7 +1600,39 @@ func TestResolverRequestHandler_RequestValidatorInfo(t *testing.T) { rrh.RequestValidatorInfo(providedHash) assert.False(t, wasCalled) }) + t.Run("RequestDataFromHash returns error", func(t *testing.T) { + t.Parallel() + + providedHash := []byte("provided hash") + res := &dataRetrieverMocks.RequesterStub{ + RequestDataFromHashCalled: func(hash []byte, epoch uint32) error { + return errExpected + }, + } + + rrh, _ := NewResolverRequestHandler( + &dataRetrieverMocks.RequestersFinderStub{ + MetaChainRequesterCalled: func(baseTopic string) (requester dataRetriever.Requester, e error) { + return res, nil + }, + }, + &mock.RequestedItemsHandlerStub{ + AddCalled: func(key string) error { + require.Fail(t, "should not have been called") + return nil + }, + }, + &mock.WhiteListHandlerStub{}, + 100, + 0, + time.Second, + ) + + rrh.RequestValidatorInfo(providedHash) + }) t.Run("should work", func(t *testing.T) { + t.Parallel() + providedHash := []byte("provided hash") wasCalled := false res := &dataRetrieverMocks.RequesterStub{ @@ -1370,7 +1665,28 @@ func TestResolverRequestHandler_RequestValidatorInfo(t *testing.T) { func TestResolverRequestHandler_RequestValidatorsInfo(t *testing.T) { t.Parallel() + t.Run("no hash", func(t *testing.T) { + t.Parallel() + + rrh, _ := NewResolverRequestHandler( + &dataRetrieverMocks.RequestersFinderStub{ + MetaChainRequesterCalled: func(baseTopic string) (requester dataRetriever.Requester, e error) { + require.Fail(t, "should not have been called") + return nil, nil + }, + }, + &mock.RequestedItemsHandlerStub{}, + &mock.WhiteListHandlerStub{}, + 100, + 0, + time.Second, + ) + + rrh.RequestValidatorsInfo([][]byte{}) + }) t.Run("MetaChainRequester returns error", func(t *testing.T) { + t.Parallel() + providedHash := []byte("provided hash") wasCalled := false res := &dataRetrieverMocks.RequesterStub{ @@ -1383,7 +1699,7 @@ func TestResolverRequestHandler_RequestValidatorsInfo(t *testing.T) { rrh, _ := NewResolverRequestHandler( &dataRetrieverMocks.RequestersFinderStub{ MetaChainRequesterCalled: func(baseTopic string) (requester dataRetriever.Requester, e error) { - return res, errors.New("provided err") + return res, errExpected }, }, &mock.RequestedItemsHandlerStub{}, @@ -1396,7 +1712,39 @@ func TestResolverRequestHandler_RequestValidatorsInfo(t *testing.T) { rrh.RequestValidatorsInfo([][]byte{providedHash}) assert.False(t, wasCalled) }) + t.Run("RequestDataFromHashArray returns error", func(t *testing.T) { + t.Parallel() + + providedHash := []byte("provided hash") + res := &dataRetrieverMocks.HashSliceRequesterStub{ + RequestDataFromHashArrayCalled: func(hashes [][]byte, epoch uint32) error { + return errExpected + }, + } + + rrh, _ := NewResolverRequestHandler( + &dataRetrieverMocks.RequestersFinderStub{ + MetaChainRequesterCalled: func(baseTopic string) (requester dataRetriever.Requester, e error) { + return res, nil + }, + }, + &mock.RequestedItemsHandlerStub{ + AddCalled: func(key string) error { + require.Fail(t, "should not have been called") + return nil + }, + }, + &mock.WhiteListHandlerStub{}, + 100, + 0, + time.Second, + ) + + rrh.RequestValidatorsInfo([][]byte{providedHash}) + }) t.Run("cast fails", func(t *testing.T) { + t.Parallel() + providedHash := []byte("provided hash") mbRequester := &dataRetrieverMocks.NonceRequesterStub{} // uncastable to HashSliceRequester wasCalled := false @@ -1421,6 +1769,8 @@ func TestResolverRequestHandler_RequestValidatorsInfo(t *testing.T) { assert.False(t, wasCalled) }) t.Run("should work", func(t *testing.T) { + t.Parallel() + providedHashes := [][]byte{[]byte("provided hash 1"), []byte("provided hash 2")} wasCalled := false res := &dataRetrieverMocks.HashSliceRequesterStub{ @@ -1449,3 +1799,201 @@ func TestResolverRequestHandler_RequestValidatorsInfo(t *testing.T) { assert.True(t, wasCalled) }) } + +func TestResolverRequestHandler_RequestMiniblocks(t *testing.T) { + t.Parallel() + + t.Run("no hash should work", func(t *testing.T) { + t.Parallel() + + rrh, _ := NewResolverRequestHandler( + &dataRetrieverMocks.RequestersFinderStub{ + CrossShardRequesterCalled: func(baseTopic string, crossShard uint32) (dataRetriever.Requester, error) { + require.Fail(t, "should have not been called") + return nil, nil + }, + }, + &mock.RequestedItemsHandlerStub{}, + &mock.WhiteListHandlerStub{}, + 100, + 0, + time.Second, + ) + + rrh.RequestMiniBlocks(0, [][]byte{}) + }) + t.Run("CrossShardRequester fails should work", func(t *testing.T) { + t.Parallel() + + rrh, _ := NewResolverRequestHandler( + &dataRetrieverMocks.RequestersFinderStub{ + CrossShardRequesterCalled: func(baseTopic string, crossShard uint32) (dataRetriever.Requester, error) { + return nil, errExpected + }, + }, + &mock.RequestedItemsHandlerStub{}, + &mock.WhiteListHandlerStub{}, + 100, + 0, + time.Second, + ) + + rrh.RequestMiniBlocks(0, [][]byte{[]byte("mbHash")}) + }) + t.Run("cast fails should work", func(t *testing.T) { + t.Parallel() + + nonceRequester := &dataRetrieverMocks.NonceRequesterStub{} // uncastable to HashSliceRequester + rrh, _ := NewResolverRequestHandler( + &dataRetrieverMocks.RequestersFinderStub{ + CrossShardRequesterCalled: func(baseTopic string, crossShard uint32) (dataRetriever.Requester, error) { + return nonceRequester, nil + }, + }, + &mock.RequestedItemsHandlerStub{}, + &mock.WhiteListHandlerStub{ + AddCalled: func(keys [][]byte) { + require.Fail(t, "should have not been called") + }, + }, + 100, + 0, + time.Second, + ) + + rrh.RequestMiniBlocks(0, [][]byte{[]byte("mbHash")}) + }) + t.Run("request data fails should work", func(t *testing.T) { + t.Parallel() + + mbRequester := &dataRetrieverMocks.HashSliceRequesterStub{ + RequestDataFromHashArrayCalled: func(hashes [][]byte, epoch uint32) error { + return errExpected + }, + } + rrh, _ := NewResolverRequestHandler( + &dataRetrieverMocks.RequestersFinderStub{ + CrossShardRequesterCalled: func(baseTopic string, crossShard uint32) (dataRetriever.Requester, error) { + return mbRequester, nil + }, + }, + &mock.RequestedItemsHandlerStub{}, + &mock.WhiteListHandlerStub{}, + 100, + 0, + time.Second, + ) + + rrh.RequestMiniBlocks(0, [][]byte{[]byte("mbHash")}) + }) + t.Run("should work", func(t *testing.T) { + t.Parallel() + + rrh, _ := NewResolverRequestHandler( + &dataRetrieverMocks.RequestersFinderStub{ + CrossShardRequesterCalled: func(baseTopic string, crossShard uint32) (dataRetriever.Requester, error) { + return &dataRetrieverMocks.HashSliceRequesterStub{}, nil + }, + }, + &mock.RequestedItemsHandlerStub{}, + &mock.WhiteListHandlerStub{}, + 100, + 0, + time.Second, + ) + + rrh.RequestMiniBlocks(0, [][]byte{[]byte("mbHash")}) + }) +} + +func TestResolverRequestHandler_RequestInterval(t *testing.T) { + t.Parallel() + + rrh, _ := NewResolverRequestHandler( + &dataRetrieverMocks.RequestersFinderStub{}, + &mock.RequestedItemsHandlerStub{}, + &mock.WhiteListHandlerStub{}, + 100, + 0, + time.Second, + ) + require.Equal(t, time.Second, rrh.RequestInterval()) +} + +func TestResolverRequestHandler_NumPeersToQuery(t *testing.T) { + t.Parallel() + + t.Run("get returns error", func(t *testing.T) { + t.Parallel() + + rrh, _ := NewResolverRequestHandler( + &dataRetrieverMocks.RequestersFinderStub{ + GetCalled: func(key string) (dataRetriever.Requester, error) { + return nil, errExpected + }, + }, + &mock.RequestedItemsHandlerStub{}, + &mock.WhiteListHandlerStub{}, + 100, + 0, + time.Second, + ) + + _, _, err := rrh.GetNumPeersToQuery("key") + require.Equal(t, errExpected, err) + + err = rrh.SetNumPeersToQuery("key", 1, 1) + require.Equal(t, errExpected, err) + }) + t.Run("should work", func(t *testing.T) { + t.Parallel() + + req := &dataRetrieverMocks.RequesterStub{ + SetNumPeersToQueryCalled: func(intra int, cross int) { + require.Equal(t, 1, intra) + require.Equal(t, 1, cross) + }, + NumPeersToQueryCalled: func() (int, int) { + return 10, 10 + }, + } + + rrh, _ := NewResolverRequestHandler( + &dataRetrieverMocks.RequestersFinderStub{ + GetCalled: func(key string) (dataRetriever.Requester, error) { + return req, nil + }, + }, + &mock.RequestedItemsHandlerStub{}, + &mock.WhiteListHandlerStub{}, + 100, + 0, + time.Second, + ) + + intra, cross, err := rrh.GetNumPeersToQuery("key") + require.NoError(t, err) + require.Equal(t, 10, intra) + require.Equal(t, 10, cross) + + err = rrh.SetNumPeersToQuery("key", 1, 1) + require.NoError(t, err) + }) +} + +func TestResolverRequestHandler_IsInterfaceNil(t *testing.T) { + t.Parallel() + + var rrh *resolverRequestHandler + require.True(t, rrh.IsInterfaceNil()) + + rrh, _ = NewResolverRequestHandler( + &dataRetrieverMocks.RequestersFinderStub{}, + &mock.RequestedItemsHandlerStub{}, + &mock.WhiteListHandlerStub{}, + 100, + 0, + time.Second, + ) + require.False(t, rrh.IsInterfaceNil()) +} diff --git a/dataRetriever/requestHandlers/requesters/requesters_test.go b/dataRetriever/requestHandlers/requesters/requesters_test.go index 4ec7ec9a74e..a0029d755ae 100644 --- a/dataRetriever/requestHandlers/requesters/requesters_test.go +++ b/dataRetriever/requestHandlers/requesters/requesters_test.go @@ -10,6 +10,7 @@ import ( "github.com/multiversx/mx-chain-go/dataRetriever/mock" "github.com/multiversx/mx-chain-go/dataRetriever/requestHandlers" dataRetrieverStub "github.com/multiversx/mx-chain-go/testscommon/dataRetriever" + logger "github.com/multiversx/mx-chain-logger-go" "github.com/stretchr/testify/assert" ) @@ -81,6 +82,7 @@ func testRequestDataFromHashArray(t *testing.T, requesterType requestHandlerType t.Run("should work", func(t *testing.T) { t.Parallel() + _ = logger.SetLogLevel("*:TRACE") // coverage providedEpoch := uint32(1234) providedHashes := [][]byte{[]byte("hash 1"), []byte("hash 2"), []byte("hash 3")} args := createMockArgBaseRequester() diff --git a/dataRetriever/resolvers/epochproviders/disabled/disabledEpochProvider_test.go b/dataRetriever/resolvers/epochproviders/disabled/disabledEpochProvider_test.go new file mode 100644 index 00000000000..b4b5fb95fac --- /dev/null +++ b/dataRetriever/resolvers/epochproviders/disabled/disabledEpochProvider_test.go @@ -0,0 +1,19 @@ +package disabled + +import ( + "testing" + + "github.com/stretchr/testify/require" +) + +func TestEpochProvider(t *testing.T) { + t.Parallel() + + var ep *epochProvider + require.True(t, ep.IsInterfaceNil()) + + ep = NewEpochProvider() + require.False(t, ep.IsInterfaceNil()) + require.True(t, ep.EpochIsActiveInNetwork(1)) + ep.EpochConfirmed(0, 0) +} diff --git a/dataRetriever/resolvers/headerResolver_test.go b/dataRetriever/resolvers/headerResolver_test.go index 9b36dc5d0c7..e71fff039bd 100644 --- a/dataRetriever/resolvers/headerResolver_test.go +++ b/dataRetriever/resolvers/headerResolver_test.go @@ -3,6 +3,8 @@ package resolvers_test import ( "bytes" "errors" + "fmt" + "math" "sync" "testing" @@ -194,6 +196,32 @@ func TestHeaderResolver_ProcessReceivedMessage_WrongIdentifierStartBlock(t *test assert.True(t, arg.Throttler.(*mock.ThrottlerStub).EndWasCalled()) } +func TestHeaderResolver_ProcessReceivedMessageEpochTypeUnknownEpochShouldWork(t *testing.T) { + t.Parallel() + + arg := createMockArgHeaderResolver() + arg.HdrStorage = &storageStubs.StorerStub{ + SearchFirstCalled: func(key []byte) (i []byte, e error) { + return []byte("hash"), nil + }, + } + wasSent := false + arg.SenderResolver = &mock.TopicResolverSenderStub{ + SendCalled: func(buff []byte, peer core.PeerID) error { + wasSent = true + return nil + }, + } + hdrRes, _ := resolvers.NewHeaderResolver(arg) + + requestedData := []byte(fmt.Sprintf("epoch_%d", math.MaxUint32)) + err := hdrRes.ProcessReceivedMessage(createRequestMsg(dataRetriever.EpochType, requestedData), "") + assert.NoError(t, err) + assert.True(t, wasSent) + assert.True(t, arg.Throttler.(*mock.ThrottlerStub).StartWasCalled()) + assert.True(t, arg.Throttler.(*mock.ThrottlerStub).EndWasCalled()) +} + func TestHeaderResolver_ProcessReceivedMessage_Ok(t *testing.T) { t.Parallel() @@ -260,6 +288,43 @@ func TestHeaderResolver_ValidateRequestHashTypeFoundInHdrPoolShouldSearchAndSend assert.True(t, arg.Throttler.(*mock.ThrottlerStub).EndWasCalled()) } +func TestHeaderResolver_ValidateRequestHashTypeFoundInHdrPoolShouldSearchAndSendFullHistory(t *testing.T) { + t.Parallel() + + requestedData := []byte("aaaa") + + searchWasCalled := false + sendWasCalled := false + + headers := &mock.HeadersCacherStub{} + + headers.GetHeaderByHashCalled = func(hash []byte) (handler data.HeaderHandler, e error) { + if bytes.Equal(requestedData, hash) { + searchWasCalled = true + return &block.Header{}, nil + } + return nil, errors.New("0") + } + + arg := createMockArgHeaderResolver() + arg.IsFullHistoryNode = true + arg.SenderResolver = &mock.TopicResolverSenderStub{ + SendCalled: func(buff []byte, peer core.PeerID) error { + sendWasCalled = true + return nil + }, + } + arg.Headers = headers + hdrRes, _ := resolvers.NewHeaderResolver(arg) + + err := hdrRes.ProcessReceivedMessage(createRequestMsg(dataRetriever.HashType, requestedData), fromConnectedPeerId) + assert.Nil(t, err) + assert.True(t, searchWasCalled) + assert.True(t, sendWasCalled) + assert.True(t, arg.Throttler.(*mock.ThrottlerStub).StartWasCalled()) + assert.True(t, arg.Throttler.(*mock.ThrottlerStub).EndWasCalled()) +} + func TestHeaderResolver_ProcessReceivedMessageRequestHashTypeFoundInHdrPoolMarshalizerFailsShouldErr(t *testing.T) { t.Parallel() @@ -542,6 +607,102 @@ func TestHeaderResolver_ProcessReceivedMessageRequestNonceTypeFoundInHdrNoncePoo assert.True(t, arg.Throttler.(*mock.ThrottlerStub).EndWasCalled()) } +func TestHeaderResolver_ProcessReceivedMessageRequestNonceTypeFoundInHdrNoncePoolButMarshalFailsShouldError(t *testing.T) { + t.Parallel() + + requestedNonce := uint64(67) + targetShardId := uint32(9) + wasResolved := false + + headers := &mock.HeadersCacherStub{} + headers.GetHeaderByHashCalled = func(hash []byte) (handler data.HeaderHandler, e error) { + return nil, errors.New("err") + } + headers.GetHeaderByNonceAndShardIdCalled = func(hdrNonce uint64, shardId uint32) (handlers []data.HeaderHandler, i [][]byte, e error) { + wasResolved = true + return []data.HeaderHandler{&block.Header{}, &block.Header{}}, [][]byte{[]byte("1"), []byte("2")}, nil + } + + arg := createMockArgHeaderResolver() + arg.SenderResolver = &mock.TopicResolverSenderStub{ + SendCalled: func(buff []byte, peer core.PeerID) error { + assert.Fail(t, "should not have been called") + return nil + }, + TargetShardIDCalled: func() uint32 { + return targetShardId + }, + } + arg.Headers = headers + arg.HeadersNoncesStorage = &storageStubs.StorerStub{ + GetFromEpochCalled: func(key []byte, epoch uint32) ([]byte, error) { + return nil, errKeyNotFound + }, + SearchFirstCalled: func(key []byte) (i []byte, e error) { + return nil, errKeyNotFound + }, + } + initialMarshaller := arg.Marshaller + arg.Marshaller = &mock.MarshalizerStub{ + UnmarshalCalled: initialMarshaller.Unmarshal, + MarshalCalled: func(obj interface{}) ([]byte, error) { + return nil, expectedErr + }, + } + hdrRes, _ := resolvers.NewHeaderResolver(arg) + + err := hdrRes.ProcessReceivedMessage( + createRequestMsg(dataRetriever.NonceType, arg.NonceConverter.ToByteSlice(requestedNonce)), + fromConnectedPeerId, + ) + + assert.True(t, errors.Is(err, expectedErr)) + assert.True(t, wasResolved) + assert.True(t, arg.Throttler.(*mock.ThrottlerStub).StartWasCalled()) + assert.True(t, arg.Throttler.(*mock.ThrottlerStub).EndWasCalled()) +} + +func TestHeaderResolver_ProcessReceivedMessageRequestNonceTypeNotFoundInHdrNoncePoolShouldRetFromPoolAndSend(t *testing.T) { + t.Parallel() + + requestedNonce := uint64(67) + wasSend := false + hash := []byte("aaaa") + + headers := &mock.HeadersCacherStub{} + headers.GetHeaderByHashCalled = func(hash []byte) (handler data.HeaderHandler, e error) { + return &block.Header{}, nil + } + headers.GetHeaderByNonceAndShardIdCalled = func(hdrNonce uint64, shardId uint32) (handlers []data.HeaderHandler, i [][]byte, e error) { + assert.Fail(t, "should not have been called") + return nil, nil, nil + } + arg := createMockArgHeaderResolver() + arg.SenderResolver = &mock.TopicResolverSenderStub{ + SendCalled: func(buff []byte, peer core.PeerID) error { + wasSend = true + return nil + }, + } + arg.Headers = headers + arg.HeadersNoncesStorage = &storageStubs.StorerStub{ + SearchFirstCalled: func(key []byte) (i []byte, e error) { + return hash, nil + }, + } + hdrRes, _ := resolvers.NewHeaderResolver(arg) + + err := hdrRes.ProcessReceivedMessage( + createRequestMsg(dataRetriever.NonceType, arg.NonceConverter.ToByteSlice(requestedNonce)), + fromConnectedPeerId, + ) + + assert.Nil(t, err) + assert.True(t, wasSend) + assert.True(t, arg.Throttler.(*mock.ThrottlerStub).StartWasCalled()) + assert.True(t, arg.Throttler.(*mock.ThrottlerStub).EndWasCalled()) +} + func TestHeaderResolver_ProcessReceivedMessageRequestNonceTypeFoundInHdrNoncePoolCheckRetErr(t *testing.T) { t.Parallel() diff --git a/dataRetriever/resolvers/messageProcessor_test.go b/dataRetriever/resolvers/messageProcessor_test.go index b4a10bc24b0..05fb0dcd127 100644 --- a/dataRetriever/resolvers/messageProcessor_test.go +++ b/dataRetriever/resolvers/messageProcessor_test.go @@ -18,6 +18,16 @@ const fromConnectedPeer = core.PeerID("from connected peer") //------- canProcessMessage +func TestMessageProcessor_CanProcessNilMessageShouldErr(t *testing.T) { + t.Parallel() + + mp := &messageProcessor{} + + err := mp.canProcessMessage(nil, "") + + assert.True(t, errors.Is(err, dataRetriever.ErrNilMessage)) +} + func TestMessageProcessor_CanProcessErrorsShouldErr(t *testing.T) { t.Parallel() diff --git a/dataRetriever/resolvers/miniblockResolver_test.go b/dataRetriever/resolvers/miniblockResolver_test.go index 94d82e2bf92..1b336c50396 100644 --- a/dataRetriever/resolvers/miniblockResolver_test.go +++ b/dataRetriever/resolvers/miniblockResolver_test.go @@ -95,6 +95,17 @@ func TestNewMiniblockResolver_NilThrottlerShouldErr(t *testing.T) { assert.True(t, check.IfNil(mbRes)) } +func TestNewMiniblockResolver_NilDataPackerShouldErr(t *testing.T) { + t.Parallel() + + arg := createMockArgMiniblockResolver() + arg.DataPacker = nil + mbRes, err := resolvers.NewMiniblockResolver(arg) + + assert.Equal(t, dataRetriever.ErrNilDataPacker, err) + assert.True(t, check.IfNil(mbRes)) +} + func TestNewMiniblockResolver_OkValsShouldWork(t *testing.T) { t.Parallel() @@ -250,6 +261,147 @@ func TestMiniblockResolver_ProcessReceivedMessageFoundInPoolMarshalizerFailShoul assert.True(t, arg.Throttler.(*mock.ThrottlerStub).EndWasCalled()) } +func TestMiniblockResolver_ProcessReceivedMessageUnmarshalFails(t *testing.T) { + t.Parallel() + + goodMarshalizer := &mock.MarshalizerMock{} + cnt := 0 + marshalizer := &mock.MarshalizerStub{ + MarshalCalled: goodMarshalizer.Marshal, + UnmarshalCalled: func(obj interface{}, buff []byte) error { + cnt++ + if cnt > 1 { + return expectedErr + } + return goodMarshalizer.Unmarshal(obj, buff) + }, + } + mbHash := []byte("aaa") + miniBlockList := make([][]byte, 0) + miniBlockList = append(miniBlockList, mbHash) + requestedBuff, merr := goodMarshalizer.Marshal(&batch.Batch{Data: miniBlockList}) + + assert.Nil(t, merr) + + cache := testscommon.NewCacherStub() + cache.PeekCalled = func(key []byte) (value interface{}, ok bool) { + return nil, false + } + + arg := createMockArgMiniblockResolver() + arg.MiniBlockPool = cache + arg.MiniBlockStorage = &storageStubs.StorerStub{ + GetCalled: func(key []byte) (i []byte, e error) { + body := block.MiniBlock{} + buff, _ := goodMarshalizer.Marshal(&body) + return buff, nil + }, + } + arg.Marshaller = marshalizer + arg.DataPacker = &mock.DataPackerStub{ + PackDataInChunksCalled: func(data [][]byte, limit int) ([][]byte, error) { + assert.Fail(t, "should not have been called") + return nil, nil + }, + } + mbRes, _ := resolvers.NewMiniblockResolver(arg) + + err := mbRes.ProcessReceivedMessage( + createRequestMsg(dataRetriever.HashArrayType, requestedBuff), + fromConnectedPeerId, + ) + + assert.True(t, errors.Is(err, expectedErr)) + assert.True(t, arg.Throttler.(*mock.ThrottlerStub).StartWasCalled()) + assert.True(t, arg.Throttler.(*mock.ThrottlerStub).EndWasCalled()) +} + +func TestMiniblockResolver_ProcessReceivedMessagePackDataInChunksFails(t *testing.T) { + t.Parallel() + + goodMarshalizer := &mock.MarshalizerMock{} + mbHash := []byte("aaa") + miniBlockList := make([][]byte, 0) + miniBlockList = append(miniBlockList, mbHash) + requestedBuff, merr := goodMarshalizer.Marshal(&batch.Batch{Data: miniBlockList}) + + assert.Nil(t, merr) + + cache := testscommon.NewCacherStub() + cache.PeekCalled = func(key []byte) (value interface{}, ok bool) { + return nil, false + } + + arg := createMockArgMiniblockResolver() + arg.MiniBlockPool = cache + arg.MiniBlockStorage = &storageStubs.StorerStub{ + GetCalled: func(key []byte) (i []byte, e error) { + body := block.MiniBlock{} + buff, _ := goodMarshalizer.Marshal(&body) + return buff, nil + }, + } + arg.Marshaller = goodMarshalizer + arg.DataPacker = &mock.DataPackerStub{ + PackDataInChunksCalled: func(data [][]byte, limit int) ([][]byte, error) { + return nil, expectedErr + }, + } + mbRes, _ := resolvers.NewMiniblockResolver(arg) + + err := mbRes.ProcessReceivedMessage( + createRequestMsg(dataRetriever.HashArrayType, requestedBuff), + fromConnectedPeerId, + ) + + assert.True(t, errors.Is(err, expectedErr)) + assert.True(t, arg.Throttler.(*mock.ThrottlerStub).StartWasCalled()) + assert.True(t, arg.Throttler.(*mock.ThrottlerStub).EndWasCalled()) +} + +func TestMiniblockResolver_ProcessReceivedMessageSendFails(t *testing.T) { + t.Parallel() + + goodMarshalizer := &mock.MarshalizerMock{} + mbHash := []byte("aaa") + miniBlockList := make([][]byte, 0) + miniBlockList = append(miniBlockList, mbHash) + requestedBuff, merr := goodMarshalizer.Marshal(&batch.Batch{Data: miniBlockList}) + + assert.Nil(t, merr) + + cache := testscommon.NewCacherStub() + cache.PeekCalled = func(key []byte) (value interface{}, ok bool) { + return nil, false + } + + arg := createMockArgMiniblockResolver() + arg.MiniBlockPool = cache + arg.MiniBlockStorage = &storageStubs.StorerStub{ + GetCalled: func(key []byte) (i []byte, e error) { + body := block.MiniBlock{} + buff, _ := goodMarshalizer.Marshal(&body) + return buff, nil + }, + } + arg.Marshaller = goodMarshalizer + arg.SenderResolver = &mock.TopicResolverSenderStub{ + SendCalled: func(buff []byte, peer core.PeerID) error { + return expectedErr + }, + } + mbRes, _ := resolvers.NewMiniblockResolver(arg) + + err := mbRes.ProcessReceivedMessage( + createRequestMsg(dataRetriever.HashArrayType, requestedBuff), + fromConnectedPeerId, + ) + + assert.True(t, errors.Is(err, expectedErr)) + assert.True(t, arg.Throttler.(*mock.ThrottlerStub).StartWasCalled()) + assert.True(t, arg.Throttler.(*mock.ThrottlerStub).EndWasCalled()) +} + func TestMiniblockResolver_ProcessReceivedMessageNotFoundInPoolShouldRetFromStorageAndSend(t *testing.T) { t.Parallel() @@ -297,6 +449,57 @@ func TestMiniblockResolver_ProcessReceivedMessageNotFoundInPoolShouldRetFromStor assert.True(t, arg.Throttler.(*mock.ThrottlerStub).EndWasCalled()) } +func TestMiniblockResolver_ProcessReceivedMessageMarshalFails(t *testing.T) { + t.Parallel() + + mbHash := []byte("aaa") + marshalizer := &mock.MarshalizerMock{} + miniBlockList := make([][]byte, 0) + miniBlockList = append(miniBlockList, mbHash) + requestedBuff, _ := marshalizer.Marshal(&batch.Batch{Data: miniBlockList}) + + wasResolved := false + + cache := testscommon.NewCacherStub() + cache.PeekCalled = func(key []byte) (value interface{}, ok bool) { + return nil, false + } + + store := &storageStubs.StorerStub{} + store.SearchFirstCalled = func(key []byte) (i []byte, e error) { + wasResolved = true + mb, _ := marshalizer.Marshal(&block.MiniBlock{}) + return mb, nil + } + + arg := createMockArgMiniblockResolver() + arg.SenderResolver = &mock.TopicResolverSenderStub{ + SendCalled: func(buff []byte, peer core.PeerID) error { + assert.Fail(t, "should have not been called") + return nil + }, + } + arg.MiniBlockPool = cache + arg.MiniBlockStorage = store + arg.Marshaller = &mock.MarshalizerStub{ + UnmarshalCalled: marshalizer.Unmarshal, + MarshalCalled: func(obj interface{}) ([]byte, error) { + return nil, expectedErr + }, + } + mbRes, _ := resolvers.NewMiniblockResolver(arg) + + err := mbRes.ProcessReceivedMessage( + createRequestMsg(dataRetriever.HashType, requestedBuff), + fromConnectedPeerId, + ) + + assert.True(t, errors.Is(err, expectedErr)) + assert.True(t, wasResolved) + assert.True(t, arg.Throttler.(*mock.ThrottlerStub).StartWasCalled()) + assert.True(t, arg.Throttler.(*mock.ThrottlerStub).EndWasCalled()) +} + func TestMiniblockResolver_ProcessReceivedMessageMissingDataShouldNotSend(t *testing.T) { t.Parallel() diff --git a/dataRetriever/resolvers/peerAuthenticationResolver_test.go b/dataRetriever/resolvers/peerAuthenticationResolver_test.go index 22b75093a4a..962d50be2ec 100644 --- a/dataRetriever/resolvers/peerAuthenticationResolver_test.go +++ b/dataRetriever/resolvers/peerAuthenticationResolver_test.go @@ -331,16 +331,20 @@ func TestPeerAuthenticationResolver_ProcessReceivedMessage(t *testing.T) { pk1 := "pk01" pk2 := "pk02" + pk3 := "pk03" providedKeys := make(map[string]interface{}) providedKeys[pk1] = createMockPeerAuthenticationObject() providedKeys[pk2] = createMockPeerAuthenticationObject() + providedKeys[pk3] = createMockPeerAuthenticationObject() pks := make([][]byte, 0) pks = append(pks, []byte(pk1)) pks = append(pks, []byte(pk2)) + pks = append(pks, []byte(pk3)) hashes := make([][]byte, 0) hashes = append(hashes, []byte("pk01")) // exists in cache hashes = append(hashes, []byte("pk1")) // no entries + hashes = append(hashes, []byte("pk03")) // unmarshal fails providedHashes, err := arg.Marshaller.Marshal(batch.Batch{Data: hashes}) assert.Nil(t, err) @@ -366,7 +370,18 @@ func TestPeerAuthenticationResolver_ProcessReceivedMessage(t *testing.T) { }, } arg.DataPacker, _ = partitioning.NewSizeDataPacker(arg.Marshaller) - + initialMarshaller := arg.Marshaller + cnt := 0 + arg.Marshaller = &mock.MarshalizerStub{ + MarshalCalled: initialMarshaller.Marshal, + UnmarshalCalled: func(obj interface{}, buff []byte) error { + cnt++ + if cnt == 4 { // pk03 + return expectedErr + } + return initialMarshaller.Unmarshal(obj, buff) + }, + } res, err := resolvers.NewPeerAuthenticationResolver(arg) assert.Nil(t, err) assert.False(t, res.IsInterfaceNil()) @@ -375,6 +390,31 @@ func TestPeerAuthenticationResolver_ProcessReceivedMessage(t *testing.T) { assert.Nil(t, err) assert.True(t, wasSent) }) + t.Run("resolveMultipleHashesRequest: PackDataInChunks returns error", func(t *testing.T) { + t.Parallel() + + cache := testscommon.NewCacherStub() + cache.PeekCalled = func(key []byte) (value interface{}, ok bool) { + return createMockPeerAuthenticationObject(), true + } + + arg := createMockArgPeerAuthenticationResolver() + arg.PeerAuthenticationPool = cache + arg.DataPacker = &mock.DataPackerStub{ + PackDataInChunksCalled: func(data [][]byte, limit int) ([][]byte, error) { + return nil, expectedErr + }, + } + res, err := resolvers.NewPeerAuthenticationResolver(arg) + assert.Nil(t, err) + assert.False(t, res.IsInterfaceNil()) + + hashes := getKeysSlice() + providedHashes, err := arg.Marshaller.Marshal(batch.Batch{Data: hashes}) + assert.Nil(t, err) + err = res.ProcessReceivedMessage(createRequestMsg(dataRetriever.HashArrayType, providedHashes), fromConnectedPeer) + assert.True(t, errors.Is(err, expectedErr)) + }) t.Run("resolveMultipleHashesRequest: Send returns error", func(t *testing.T) { t.Parallel() diff --git a/dataRetriever/resolvers/transactionResolver_test.go b/dataRetriever/resolvers/transactionResolver_test.go index 13d1323c68c..d75d2192789 100644 --- a/dataRetriever/resolvers/transactionResolver_test.go +++ b/dataRetriever/resolvers/transactionResolver_test.go @@ -269,6 +269,51 @@ func TestTxResolver_ProcessReceivedMessageFoundInTxPoolMarshalizerFailShouldRetN assert.True(t, arg.Throttler.(*mock.ThrottlerStub).EndWasCalled()) } +func TestTxResolver_ProcessReceivedMessageBatchMarshalFailShouldRetNilAndErr(t *testing.T) { + t.Parallel() + + marshalizerMock := &mock.MarshalizerMock{} + cnt := 0 + marshalizerStub := &mock.MarshalizerStub{ + MarshalCalled: func(obj interface{}) (i []byte, e error) { + cnt++ + if cnt > 1 { + return nil, expectedErr + } + return marshalizerMock.Marshal(obj) + }, + UnmarshalCalled: func(obj interface{}, buff []byte) error { + return marshalizerMock.Unmarshal(obj, buff) + }, + } + txReturned := &transaction.Transaction{ + Nonce: 10, + } + txPool := testscommon.NewShardedDataStub() + txPool.SearchFirstDataCalled = func(key []byte) (value interface{}, ok bool) { + if bytes.Equal([]byte("aaa"), key) { + return txReturned, true + } + + return nil, false + } + + arg := createMockArgTxResolver() + arg.TxPool = txPool + arg.Marshaller = marshalizerStub + txRes, _ := resolvers.NewTxResolver(arg) + + data, _ := marshalizerMock.Marshal(&dataRetriever.RequestData{Type: dataRetriever.HashType, Value: []byte("aaa")}) + + msg := &p2pmocks.P2PMessageMock{DataField: data} + + err := txRes.ProcessReceivedMessage(msg, connectedPeerId) + + assert.True(t, errors.Is(err, expectedErr)) + assert.True(t, arg.Throttler.(*mock.ThrottlerStub).StartWasCalled()) + assert.True(t, arg.Throttler.(*mock.ThrottlerStub).EndWasCalled()) +} + func TestTxResolver_ProcessReceivedMessageFoundInTxStorageShouldRetValAndSend(t *testing.T) { t.Parallel() @@ -480,6 +525,83 @@ func TestTxResolver_ProcessReceivedMessageRequestedTwoSmallTransactionsFoundOnly assert.True(t, arg.Throttler.(*mock.ThrottlerStub).EndWasCalled()) } +func TestTxResolver_ProcessReceivedMessageHashArrayUnmarshalFails(t *testing.T) { + t.Parallel() + + arg := createMockArgTxResolver() + marshalizer := arg.Marshaller + cnt := 0 + arg.Marshaller = &mock.MarshalizerStub{ + UnmarshalCalled: func(obj interface{}, buff []byte) error { + cnt++ + if cnt > 1 { + return expectedErr + } + return marshalizer.Unmarshal(obj, buff) + }, + } + txRes, _ := resolvers.NewTxResolver(arg) + + data, _ := marshalizer.Marshal(&dataRetriever.RequestData{Type: dataRetriever.HashArrayType, Value: []byte("buff")}) + msg := &p2pmocks.P2PMessageMock{DataField: data} + + err := txRes.ProcessReceivedMessage(msg, connectedPeerId) + + assert.True(t, errors.Is(err, expectedErr)) + assert.True(t, arg.Throttler.(*mock.ThrottlerStub).StartWasCalled()) + assert.True(t, arg.Throttler.(*mock.ThrottlerStub).EndWasCalled()) +} + +func TestTxResolver_ProcessReceivedMessageHashArrayPackDataInChunksFails(t *testing.T) { + t.Parallel() + + txHash1 := []byte("txHash1") + txHash2 := []byte("txHash2") + + arg := createMockArgTxResolver() + arg.DataPacker = &mock.DataPackerStub{ + PackDataInChunksCalled: func(data [][]byte, limit int) ([][]byte, error) { + return nil, expectedErr + }, + } + txRes, _ := resolvers.NewTxResolver(arg) + + buff, _ := arg.Marshaller.Marshal(&batch.Batch{Data: [][]byte{txHash1, txHash2}}) + data, _ := arg.Marshaller.Marshal(&dataRetriever.RequestData{Type: dataRetriever.HashArrayType, Value: buff}) + msg := &p2pmocks.P2PMessageMock{DataField: data} + + err := txRes.ProcessReceivedMessage(msg, connectedPeerId) + + assert.True(t, errors.Is(err, expectedErr)) + assert.True(t, arg.Throttler.(*mock.ThrottlerStub).StartWasCalled()) + assert.True(t, arg.Throttler.(*mock.ThrottlerStub).EndWasCalled()) +} + +func TestTxResolver_ProcessReceivedMessageHashArraySendFails(t *testing.T) { + t.Parallel() + + txHash1 := []byte("txHash1") + txHash2 := []byte("txHash2") + + arg := createMockArgTxResolver() + arg.SenderResolver = &mock.TopicResolverSenderStub{ + SendCalled: func(buff []byte, peer core.PeerID) error { + return expectedErr + }, + } + txRes, _ := resolvers.NewTxResolver(arg) + + buff, _ := arg.Marshaller.Marshal(&batch.Batch{Data: [][]byte{txHash1, txHash2}}) + data, _ := arg.Marshaller.Marshal(&dataRetriever.RequestData{Type: dataRetriever.HashArrayType, Value: buff}) + msg := &p2pmocks.P2PMessageMock{DataField: data} + + err := txRes.ProcessReceivedMessage(msg, connectedPeerId) + + assert.True(t, errors.Is(err, expectedErr)) + assert.True(t, arg.Throttler.(*mock.ThrottlerStub).StartWasCalled()) + assert.True(t, arg.Throttler.(*mock.ThrottlerStub).EndWasCalled()) +} + func TestTxResolver_Close(t *testing.T) { t.Parallel() diff --git a/dataRetriever/resolvers/trieNodeResolver_test.go b/dataRetriever/resolvers/trieNodeResolver_test.go index e3281c9139e..dd7325d533b 100644 --- a/dataRetriever/resolvers/trieNodeResolver_test.go +++ b/dataRetriever/resolvers/trieNodeResolver_test.go @@ -249,6 +249,49 @@ func TestTrieNodeResolver_ProcessReceivedMessageTrieErrorsShouldErr(t *testing.T assert.True(t, arg.Throttler.(*mock.ThrottlerStub).EndWasCalled()) } +func TestTrieNodeResolver_ProcessReceivedMessageMultipleHashesUnmarshalFails(t *testing.T) { + t.Parallel() + + arg := createMockArgTrieNodeResolver() + initialMarshaller := arg.Marshaller + cnt := 0 + arg.Marshaller = &mock.MarshalizerStub{ + MarshalCalled: initialMarshaller.Marshal, + UnmarshalCalled: func(obj interface{}, buff []byte) error { + cnt++ + if cnt > 1 { + return expectedErr + } + return initialMarshaller.Unmarshal(obj, buff) + }, + } + arg.TrieDataGetter = &trieMock.TrieStub{ + GetSerializedNodeCalled: func(_ []byte) ([]byte, error) { + assert.Fail(t, "should have not called send") + return nil, nil + }, + } + tnRes, _ := resolvers.NewTrieNodeResolver(arg) + + b := &batch.Batch{ + Data: [][]byte{[]byte("hash1")}, + } + buffBatch, _ := arg.Marshaller.Marshal(b) + + data, _ := arg.Marshaller.Marshal( + &dataRetriever.RequestData{ + Type: dataRetriever.HashArrayType, + Value: buffBatch, + }, + ) + msg := &p2pmocks.P2PMessageMock{DataField: data} + + err := tnRes.ProcessReceivedMessage(msg, fromConnectedPeer) + assert.Equal(t, expectedErr, err) + assert.True(t, arg.Throttler.(*mock.ThrottlerStub).StartWasCalled()) + assert.True(t, arg.Throttler.(*mock.ThrottlerStub).EndWasCalled()) +} + func TestTrieNodeResolver_ProcessReceivedMessageMultipleHashesGetSerializedNodeErrorsShouldNotSend(t *testing.T) { t.Parallel() diff --git a/dataRetriever/resolvers/validatorInfoResolver_test.go b/dataRetriever/resolvers/validatorInfoResolver_test.go index 88d115de3cb..92a9420cb54 100644 --- a/dataRetriever/resolvers/validatorInfoResolver_test.go +++ b/dataRetriever/resolvers/validatorInfoResolver_test.go @@ -408,6 +408,40 @@ func TestValidatorInfoResolver_ProcessReceivedMessage(t *testing.T) { err := res.ProcessReceivedMessage(createRequestMsg(dataRetriever.HashArrayType, buff), fromConnectedPeer) assert.Equal(t, expectedErr, err) }) + t.Run("send returns error", func(t *testing.T) { + t.Parallel() + + numOfProvidedData := 3 + providedHashes := make([][]byte, 0) + providedData := make([]state.ValidatorInfo, 0) + for i := 0; i < numOfProvidedData; i++ { + hashStr := fmt.Sprintf("hash%d", i) + providedHashes = append(providedHashes, []byte(hashStr)) + pkStr := fmt.Sprintf("pk%d", i) + providedData = append(providedData, createMockValidatorInfo([]byte(pkStr))) + } + args := createMockArgValidatorInfoResolver() + numOfCalls := 0 + args.ValidatorInfoPool = &testscommon.ShardedDataStub{ + SearchFirstDataCalled: func(key []byte) (value interface{}, ok bool) { + val := providedData[numOfCalls] + numOfCalls++ + return val, true + }, + } + args.SenderResolver = &mock.TopicResolverSenderStub{ + SendCalled: func(buff []byte, peer core.PeerID) error { + return expectedErr + }, + } + args.DataPacker, _ = partitioning.NewSimpleDataPacker(args.Marshaller) + res, _ := resolvers.NewValidatorInfoResolver(args) + require.False(t, check.IfNil(res)) + + buff, _ := args.Marshaller.Marshal(&batch.Batch{Data: providedHashes}) + err := res.ProcessReceivedMessage(createRequestMsg(dataRetriever.HashArrayType, buff), fromConnectedPeer) + assert.Equal(t, expectedErr, err) + }) t.Run("all hashes in one chunk should work", func(t *testing.T) { t.Parallel() diff --git a/dataRetriever/shardedData/shardedData_test.go b/dataRetriever/shardedData/shardedData_test.go index d00e7939535..071b0c00356 100644 --- a/dataRetriever/shardedData/shardedData_test.go +++ b/dataRetriever/shardedData/shardedData_test.go @@ -124,6 +124,8 @@ func TestShardedData_RemoveData(t *testing.T) { sd, _ := NewShardedData("", defaultTestConfig) + sd.RemoveData([]byte{}, "missing_cache_id") // coverage + sd.AddData([]byte("tx_hash1"), &transaction.Transaction{Nonce: 1}, 0, "1") assert.Equal(t, 1, sd.ShardDataStore("1").Len(), "AddData failed, length should be 1") @@ -146,11 +148,13 @@ func TestShardedData_RemoveData(t *testing.T) { "FindAndRemoveData failed, length should be 1 in shard 2") } -func TestShardedData_Clear(t *testing.T) { +func TestShardedData_ClearShardStore(t *testing.T) { t.Parallel() sd, _ := NewShardedData("", defaultTestConfig) + sd.ClearShardStore("missing_cache_id") // coverage + sd.AddData([]byte("tx_hash1"), &transaction.Transaction{Nonce: 1}, 0, "1") sd.AddData([]byte("tx_hash2"), &transaction.Transaction{Nonce: 2}, 0, "2") sd.AddData([]byte("tx_hash1"), &transaction.Transaction{Nonce: 1}, 0, "2") @@ -308,3 +312,50 @@ func TestShardedData_SearchFirstDataFoundShouldRetResults(t *testing.T) { } // TODO: Add high load test, reach maximum capacity and inspect RAM usage. EN-6735. + +func TestShardedData_RemoveSetOfDataFromPool(t *testing.T) { + t.Parallel() + + sd, _ := NewShardedData("", defaultTestConfig) + + sd.RemoveSetOfDataFromPool([][]byte{}, "missing_cache_id") // coverage + + sd.AddData([]byte("aaa"), "a1", 2, "0") + _, ok := sd.SearchFirstData([]byte("aaa")) + assert.True(t, ok) + sd.RemoveSetOfDataFromPool([][]byte{[]byte("aaa")}, "0") + _, ok = sd.SearchFirstData([]byte("aaa")) + assert.False(t, ok) +} + +func TestShardedData_ImmunizeSetOfDataAgainstEviction(t *testing.T) { + t.Parallel() + + sd, _ := NewShardedData("", defaultTestConfig) + sd.ImmunizeSetOfDataAgainstEviction([][]byte{[]byte("aaa")}, "0") +} + +func TestShardedData_GetCounts(t *testing.T) { + t.Parallel() + + sd, _ := NewShardedData("", defaultTestConfig) + + sd.RemoveSetOfDataFromPool([][]byte{}, "missing_cache_id") // coverage + + sd.AddData([]byte("aaa"), "a1", 2, "0") + sd.AddData([]byte("bbb"), "b1", 2, "0") + counts := sd.GetCounts() + assert.Equal(t, int64(2), counts.GetTotal()) +} + +func TestShardedData_Diagnose(t *testing.T) { + t.Parallel() + + sd, _ := NewShardedData("", defaultTestConfig) + + sd.RemoveSetOfDataFromPool([][]byte{}, "missing_cache_id") // coverage + + sd.AddData([]byte("aaa"), "a1", 2, "0") + sd.AddData([]byte("bbb"), "b1", 2, "0") + sd.Diagnose(true) +} diff --git a/dataRetriever/storageRequesters/headerRequester_test.go b/dataRetriever/storageRequesters/headerRequester_test.go index 82724e0e705..f73f81f6b74 100644 --- a/dataRetriever/storageRequesters/headerRequester_test.go +++ b/dataRetriever/storageRequesters/headerRequester_test.go @@ -324,32 +324,73 @@ func TestHeaderRequester_RequestDataFromNonceShouldWork(t *testing.T) { assert.True(t, sendCalled) } -func TestHeaderRequester_RequestDataFromEpochShouldWork(t *testing.T) { +func TestHeaderRequester_RequestDataFromEpoch(t *testing.T) { t.Parallel() - sendCalled := false - epochIdentifier := []byte(core.EpochStartIdentifier(math.MaxUint32)) - arg := createMockHeaderRequesterArg() - arg.HdrStorage = &storageStubs.StorerStub{ - SearchFirstCalled: func(key []byte) ([]byte, error) { - assert.Equal(t, epochIdentifier, key) - return make([]byte, 0), nil - }, - } - arg.ManualEpochStartNotifier = &mock.ManualEpochStartNotifierStub{} - arg.Messenger = &p2pmocks.MessengerStub{ - SendToConnectedPeerCalled: func(topic string, buff []byte, peerID core.PeerID) error { - sendCalled = true + t.Run("unknown epoch should error", func(t *testing.T) { + t.Parallel() - return nil - }, - } - hdReq, _ := NewHeaderRequester(arg) + epochIdentifier := []byte("unknown epoch") + arg := createMockHeaderRequesterArg() + arg.HdrStorage = &storageStubs.StorerStub{ + SearchFirstCalled: func(key []byte) ([]byte, error) { + assert.Fail(t, "should not have been called") + return make([]byte, 0), nil + }, + } + hdReq, _ := NewHeaderRequester(arg) + + err := hdReq.RequestDataFromEpoch(epochIdentifier) + assert.Equal(t, core.ErrInvalidIdentifierForEpochStartBlockRequest, err) + }) + t.Run("identifier not found should error should error", func(t *testing.T) { + t.Parallel() + + expectedErr := errors.New("expected error") + epochIdentifier := []byte(core.EpochStartIdentifier(100)) + arg := createMockHeaderRequesterArg() + arg.HdrStorage = &storageStubs.StorerStub{ + SearchFirstCalled: func(key []byte) ([]byte, error) { + return make([]byte, 0), expectedErr + }, + } + arg.Messenger = &p2pmocks.MessengerStub{ + SendToConnectedPeerCalled: func(topic string, buff []byte, peerID core.PeerID) error { + assert.Fail(t, "should not have been called") + return nil + }, + } + hdReq, _ := NewHeaderRequester(arg) + + err := hdReq.RequestDataFromEpoch(epochIdentifier) + assert.Equal(t, expectedErr, err) + }) + t.Run("should work", func(t *testing.T) { + t.Parallel() + + sendCalled := false + epochIdentifier := []byte(core.EpochStartIdentifier(math.MaxUint32)) + arg := createMockHeaderRequesterArg() + arg.HdrStorage = &storageStubs.StorerStub{ + SearchFirstCalled: func(key []byte) ([]byte, error) { + assert.Equal(t, epochIdentifier, key) + return make([]byte, 0), nil + }, + } + arg.Messenger = &p2pmocks.MessengerStub{ + SendToConnectedPeerCalled: func(topic string, buff []byte, peerID core.PeerID) error { + sendCalled = true - err := hdReq.RequestDataFromEpoch(epochIdentifier) + return nil + }, + } + hdReq, _ := NewHeaderRequester(arg) - assert.Nil(t, err) - assert.True(t, sendCalled) + err := hdReq.RequestDataFromEpoch(epochIdentifier) + + assert.Nil(t, err) + assert.True(t, sendCalled) + }) } func TestHeaderRequester_Close(t *testing.T) { diff --git a/dataRetriever/storageRequesters/sliceRequester_test.go b/dataRetriever/storageRequesters/sliceRequester_test.go index 75f3232b388..0693257464b 100644 --- a/dataRetriever/storageRequesters/sliceRequester_test.go +++ b/dataRetriever/storageRequesters/sliceRequester_test.go @@ -17,6 +17,8 @@ import ( "github.com/stretchr/testify/assert" ) +var expectedErr = errors.New("expected err") + func createMockSliceRequesterArg() ArgSliceRequester { return ArgSliceRequester{ Messenger: &mock.MessageHandlerStub{}, @@ -108,7 +110,6 @@ func TestNewSliceRequester_ShouldWork(t *testing.T) { func TestSliceRequester_RequestDataFromHashNotFoundShouldErr(t *testing.T) { t.Parallel() - expectedErr := errors.New("expected error") sendWasCalled := false arg := createMockSliceRequesterArg() arg.Storage = &storageStubs.StorerStub{ @@ -140,6 +141,32 @@ func TestSliceRequester_RequestDataFromHashNotFoundShouldErr(t *testing.T) { } } +func TestSliceRequester_RequestDataFromHashMarshalFails(t *testing.T) { + t.Parallel() + + arg := createMockSliceRequesterArg() + arg.Marshalizer = &mock.MarshalizerStub{ + MarshalCalled: func(obj interface{}) ([]byte, error) { + return nil, expectedErr + }, + } + arg.Storage = &storageStubs.StorerStub{ + GetCalled: func(key []byte) ([]byte, error) { + return make([]byte, 0), nil + }, + } + arg.Messenger = &p2pmocks.MessengerStub{ + SendToConnectedPeerCalled: func(topic string, buff []byte, peerID core.PeerID) error { + assert.Fail(t, "should not have been called") + return nil + }, + } + sr, _ := NewSliceRequester(arg) + + err := sr.RequestDataFromHash([]byte("hash"), 0) + assert.Equal(t, expectedErr, err) +} + func TestSliceRequester_RequestDataFromHashShouldWork(t *testing.T) { t.Parallel() @@ -164,6 +191,37 @@ func TestSliceRequester_RequestDataFromHashShouldWork(t *testing.T) { assert.True(t, sendWasCalled) } +func TestSliceRequester_RequestDataFromHashesPackDataInChunksFails(t *testing.T) { + t.Parallel() + + numGetCalled := 0 + arg := createMockSliceRequesterArg() + arg.Storage = &storageStubs.StorerStub{ + GetCalled: func(key []byte) ([]byte, error) { + numGetCalled++ + return make([]byte, 0), nil + }, + } + arg.Messenger = &p2pmocks.MessengerStub{ + SendToConnectedPeerCalled: func(topic string, buff []byte, peerID core.PeerID) error { + assert.Fail(t, "should not have been called") + return nil + }, + } + arg.DataPacker = &mock.DataPackerStub{ + PackDataInChunksCalled: func(data [][]byte, limit int) ([][]byte, error) { + return nil, expectedErr + }, + } + sr, _ := NewSliceRequester(arg) + + hashes := [][]byte{[]byte("hash1"), []byte("hash2")} + err := sr.RequestDataFromHashArray(hashes, 0) + + assert.Equal(t, expectedErr, err) + assert.Equal(t, len(hashes), numGetCalled) +} + func TestSliceRequester_RequestDataFromHashesShouldWork(t *testing.T) { t.Parallel() @@ -197,7 +255,6 @@ func TestSliceRequester_GetErroredShouldReturnErr(t *testing.T) { numSendCalled := 0 numGetCalled := 0 - expectedErr := errors.New("expected err") arg := createMockSliceRequesterArg() arg.Storage = &storageStubs.StorerStub{ GetCalled: func(key []byte) ([]byte, error) { @@ -240,7 +297,6 @@ func TestSliceRequester_SendErroredShouldReturnErr(t *testing.T) { numSendCalled := 0 numGetCalled := 0 - expectedErr := errors.New("expected err") arg := createMockSliceRequesterArg() arg.Storage = &storageStubs.StorerStub{ GetCalled: func(key []byte) ([]byte, error) { diff --git a/dataRetriever/storageRequesters/trieNodeRequester_test.go b/dataRetriever/storageRequesters/trieNodeRequester_test.go index 042c1390826..6b22579b730 100644 --- a/dataRetriever/storageRequesters/trieNodeRequester_test.go +++ b/dataRetriever/storageRequesters/trieNodeRequester_test.go @@ -127,6 +127,38 @@ func TestTrieNodeRequester_RequestDataFromHashShouldWork(t *testing.T) { assert.Equal(t, uint32(1), atomic.LoadUint32(&numSendToConnectedPeerCalled)) } +func TestTrieNodeRequester_RequestDataFromHashArrayMarshalFails(t *testing.T) { + t.Parallel() + + args := createMockTrieRequesterArguments() + buff := []byte("data") + args.TrieDataGetter = &trieMock.TrieStub{ + GetSerializedNodesCalled: func(bytes []byte, u uint64) ([][]byte, uint64, error) { + return [][]byte{buff}, 1, nil + }, + } + args.Messenger = &p2pmocks.MessengerStub{ + SendToConnectedPeerCalled: func(topic string, buff []byte, peerID core.PeerID) error { + assert.Fail(t, "should not have been called") + return nil + }, + } + args.Marshalizer = &mock.MarshalizerStub{ + MarshalCalled: func(obj interface{}) ([]byte, error) { + return nil, expectedErr + }, + } + tnr, _ := NewTrieNodeRequester(args) + + err := tnr.RequestDataFromHashArray( + [][]byte{ + []byte("hash1"), + []byte("hash2"), + }, 0) + assert.Equal(t, expectedErr, err) + assert.Equal(t, 0, len(args.ChanGracefullyClose)) +} + func TestTrieNodeRequester_RequestDataFromHashArrayShouldWork(t *testing.T) { t.Parallel() @@ -159,3 +191,30 @@ func TestTrieNodeRequester_RequestDataFromHashArrayShouldWork(t *testing.T) { assert.Equal(t, uint32(1), atomic.LoadUint32(&numSendToConnectedPeerCalled)) assert.Equal(t, uint32(2), atomic.LoadUint32(&numGetSerializedNodesCalled)) } + +func TestTrieNodeRequester_Close(t *testing.T) { + t.Parallel() + + t.Run("trieStorageManager.Close error should error", func(t *testing.T) { + t.Parallel() + + args := createMockTrieRequesterArguments() + args.TrieStorageManager = &testscommon.StorageManagerStub{ + CloseCalled: func() error { + return expectedErr + }, + } + tnr, _ := NewTrieNodeRequester(args) + + err := tnr.Close() + assert.Equal(t, expectedErr, err) + }) + t.Run("should work", func(t *testing.T) { + t.Parallel() + + tnr, _ := NewTrieNodeRequester(createMockTrieRequesterArguments()) + + err := tnr.Close() + assert.NoError(t, err) + }) +} diff --git a/dataRetriever/topicSender/diffPeerListCreator_test.go b/dataRetriever/topicSender/diffPeerListCreator_test.go index be87e933ca4..73b1a63b418 100644 --- a/dataRetriever/topicSender/diffPeerListCreator_test.go +++ b/dataRetriever/topicSender/diffPeerListCreator_test.go @@ -240,3 +240,21 @@ func TestDiffPeerListCreator_IntraShardPeersList(t *testing.T) { assert.Equal(t, peerList, dplc.IntraShardPeerList()) } + +func TestDiffPeerListCreator_FullHistoryList(t *testing.T) { + t.Parallel() + + peerList := []core.PeerID{"pid1", "pid2"} + dplc, _ := topicsender.NewDiffPeerListCreator( + &mock.MessageHandlerStub{ + ConnectedFullHistoryPeersOnTopicCalled: func(topic string) []core.PeerID { + return peerList + }, + }, + mainTopic, + intraTopic, + excludedTopic, + ) + + assert.Equal(t, peerList, dplc.FullHistoryList()) +} diff --git a/dataRetriever/txpool/shardedTxPool_test.go b/dataRetriever/txpool/shardedTxPool_test.go index b08ab8daa76..4f80506c304 100644 --- a/dataRetriever/txpool/shardedTxPool_test.go +++ b/dataRetriever/txpool/shardedTxPool_test.go @@ -76,6 +76,13 @@ func Test_NewShardedTxPool_WhenBadConfig(t *testing.T) { require.NotNil(t, err) require.Errorf(t, err, dataRetriever.ErrCacheConfigInvalidShards.Error()) + args = goodArgs + args.TxGasHandler = nil + pool, err = NewShardedTxPool(args) + require.Nil(t, pool) + require.NotNil(t, err) + require.Errorf(t, err, dataRetriever.ErrNilTxGasHandler.Error()) + args = goodArgs args.TxGasHandler = &txcachemocks.TxGasHandlerMock{ MinimumGasMove: 50000, @@ -167,6 +174,7 @@ func Test_AddData(t *testing.T) { pool := poolAsInterface.(*shardedTxPool) cache := pool.getTxCache("0") + pool.AddData([]byte("hash-invalid-cache"), createTx("alice", 0), 0, "invalid-cache-id") pool.AddData([]byte("hash-x"), createTx("alice", 42), 0, "0") pool.AddData([]byte("hash-y"), createTx("alice", 43), 0, "0") require.Equal(t, 2, cache.Len()) @@ -346,6 +354,23 @@ func Test_Keys(t *testing.T) { require.ElementsMatch(t, txsHashes, pool.Keys()) } +func TestShardedTxPool_Diagnose(t *testing.T) { + t.Parallel() + + poolAsInterface, _ := newTxPoolToTest() + pool := poolAsInterface.(*shardedTxPool) + pool.AddData([]byte("hash"), createTx("alice", 10), 0, "0") + pool.Diagnose(true) +} + +func TestShardedTxPool_ImmunizeSetOfDataAgainstEviction(t *testing.T) { + t.Parallel() + + poolAsInterface, _ := newTxPoolToTest() + pool := poolAsInterface.(*shardedTxPool) + pool.ImmunizeSetOfDataAgainstEviction([][]byte{[]byte("hash")}, "0") +} + func Test_IsInterfaceNil(t *testing.T) { poolAsInterface, _ := newTxPoolToTest() require.False(t, check.IfNil(poolAsInterface)) diff --git a/dataRetriever/unitType_test.go b/dataRetriever/unitType_test.go new file mode 100644 index 00000000000..83c4381a3b9 --- /dev/null +++ b/dataRetriever/unitType_test.go @@ -0,0 +1,68 @@ +package dataRetriever + +import ( + "testing" + + "github.com/stretchr/testify/require" +) + +func TestUnitType_String(t *testing.T) { + t.Parallel() + + ut := TransactionUnit + require.Equal(t, "TransactionUnit", ut.String()) + ut = MiniBlockUnit + require.Equal(t, "MiniBlockUnit", ut.String()) + ut = PeerChangesUnit + require.Equal(t, "PeerChangesUnit", ut.String()) + ut = BlockHeaderUnit + require.Equal(t, "BlockHeaderUnit", ut.String()) + ut = MetaBlockUnit + require.Equal(t, "MetaBlockUnit", ut.String()) + ut = UnsignedTransactionUnit + require.Equal(t, "UnsignedTransactionUnit", ut.String()) + ut = RewardTransactionUnit + require.Equal(t, "RewardTransactionUnit", ut.String()) + ut = MetaHdrNonceHashDataUnit + require.Equal(t, "MetaHdrNonceHashDataUnit", ut.String()) + ut = HeartbeatUnit + require.Equal(t, "HeartbeatUnit", ut.String()) + ut = BootstrapUnit + require.Equal(t, "BootstrapUnit", ut.String()) + ut = StatusMetricsUnit + require.Equal(t, "StatusMetricsUnit", ut.String()) + ut = TxLogsUnit + require.Equal(t, "TxLogsUnit", ut.String()) + ut = MiniblocksMetadataUnit + require.Equal(t, "MiniblocksMetadataUnit", ut.String()) + ut = EpochByHashUnit + require.Equal(t, "EpochByHashUnit", ut.String()) + ut = MiniblockHashByTxHashUnit + require.Equal(t, "MiniblockHashByTxHashUnit", ut.String()) + ut = ReceiptsUnit + require.Equal(t, "ReceiptsUnit", ut.String()) + ut = ResultsHashesByTxHashUnit + require.Equal(t, "ResultsHashesByTxHashUnit", ut.String()) + ut = TrieEpochRootHashUnit + require.Equal(t, "TrieEpochRootHashUnit", ut.String()) + ut = ESDTSuppliesUnit + require.Equal(t, "ESDTSuppliesUnit", ut.String()) + ut = RoundHdrHashDataUnit + require.Equal(t, "RoundHdrHashDataUnit", ut.String()) + ut = UserAccountsUnit + require.Equal(t, "UserAccountsUnit", ut.String()) + ut = UserAccountsCheckpointsUnit + require.Equal(t, "UserAccountsCheckpointsUnit", ut.String()) + ut = PeerAccountsUnit + require.Equal(t, "PeerAccountsUnit", ut.String()) + ut = PeerAccountsCheckpointsUnit + require.Equal(t, "PeerAccountsCheckpointsUnit", ut.String()) + ut = ScheduledSCRsUnit + require.Equal(t, "ScheduledSCRsUnit", ut.String()) + + ut = 200 + require.Equal(t, "ShardHdrNonceHashDataUnit100", ut.String()) + + ut = 99 + require.Equal(t, "unknown type 99", ut.String()) +} diff --git a/testscommon/storageManagerStub.go b/testscommon/storageManagerStub.go index b7673a4b4cd..825a118722b 100644 --- a/testscommon/storageManagerStub.go +++ b/testscommon/storageManagerStub.go @@ -28,6 +28,7 @@ type StorageManagerStub struct { IsClosedCalled func() bool RemoveFromCheckpointHashesHolderCalled func([]byte) GetBaseTrieStorageManagerCalled func() common.StorageManager + CloseCalled func() error } // Put - @@ -186,6 +187,9 @@ func (sms *StorageManagerStub) GetLatestStorageEpoch() (uint32, error) { // Close - func (sms *StorageManagerStub) Close() error { + if sms.CloseCalled != nil { + return sms.CloseCalled() + } return nil } From a3b1530899f23a1e06b7b5359079390b280bd1e2 Mon Sep 17 00:00:00 2001 From: Sorin Stanculeanu Date: Thu, 4 May 2023 12:05:32 +0300 Subject: [PATCH 2/4] fix after review --- dataRetriever/requestHandlers/requesters/requesters_test.go | 2 -- dataRetriever/shardedData/shardedData_test.go | 2 -- dataRetriever/txpool/shardedTxPool_test.go | 2 -- 3 files changed, 6 deletions(-) diff --git a/dataRetriever/requestHandlers/requesters/requesters_test.go b/dataRetriever/requestHandlers/requesters/requesters_test.go index a0029d755ae..4ec7ec9a74e 100644 --- a/dataRetriever/requestHandlers/requesters/requesters_test.go +++ b/dataRetriever/requestHandlers/requesters/requesters_test.go @@ -10,7 +10,6 @@ import ( "github.com/multiversx/mx-chain-go/dataRetriever/mock" "github.com/multiversx/mx-chain-go/dataRetriever/requestHandlers" dataRetrieverStub "github.com/multiversx/mx-chain-go/testscommon/dataRetriever" - logger "github.com/multiversx/mx-chain-logger-go" "github.com/stretchr/testify/assert" ) @@ -82,7 +81,6 @@ func testRequestDataFromHashArray(t *testing.T, requesterType requestHandlerType t.Run("should work", func(t *testing.T) { t.Parallel() - _ = logger.SetLogLevel("*:TRACE") // coverage providedEpoch := uint32(1234) providedHashes := [][]byte{[]byte("hash 1"), []byte("hash 2"), []byte("hash 3")} args := createMockArgBaseRequester() diff --git a/dataRetriever/shardedData/shardedData_test.go b/dataRetriever/shardedData/shardedData_test.go index 071b0c00356..7ca7c379c17 100644 --- a/dataRetriever/shardedData/shardedData_test.go +++ b/dataRetriever/shardedData/shardedData_test.go @@ -311,8 +311,6 @@ func TestShardedData_SearchFirstDataFoundShouldRetResults(t *testing.T) { assert.True(t, ok) } -// TODO: Add high load test, reach maximum capacity and inspect RAM usage. EN-6735. - func TestShardedData_RemoveSetOfDataFromPool(t *testing.T) { t.Parallel() diff --git a/dataRetriever/txpool/shardedTxPool_test.go b/dataRetriever/txpool/shardedTxPool_test.go index 4f80506c304..6fdaa4676ad 100644 --- a/dataRetriever/txpool/shardedTxPool_test.go +++ b/dataRetriever/txpool/shardedTxPool_test.go @@ -446,5 +446,3 @@ func newTxPoolToTest() (dataRetriever.ShardedDataCacherNotifier, error) { } return NewShardedTxPool(args) } - -// TODO: Add high load test, reach maximum capacity and inspect RAM usage. EN-6735. From 8ace67f064664b8c2cbdb4301aed4a11a54eeb49 Mon Sep 17 00:00:00 2001 From: Sorin Stanculeanu Date: Tue, 9 May 2023 16:55:34 +0300 Subject: [PATCH 3/4] fixes after review --- .../factory/containers/resolversContainer_test.go | 6 +++--- .../epochProviders/currentEpochProvidersFactory_test.go | 2 +- dataRetriever/interface.go | 2 +- dataRetriever/mock/marshalizerMock.go | 2 +- dataRetriever/resolvers/validatorInfoResolver_test.go | 2 +- dataRetriever/shardedData/shardedData_test.go | 4 ++-- dataRetriever/storageRequesters/headerRequester_test.go | 7 +------ dataRetriever/topicSender/diffPeerListCreator_test.go | 2 +- 8 files changed, 11 insertions(+), 16 deletions(-) diff --git a/dataRetriever/factory/containers/resolversContainer_test.go b/dataRetriever/factory/containers/resolversContainer_test.go index 969a93d6034..cf3dcfbe8d8 100644 --- a/dataRetriever/factory/containers/resolversContainer_test.go +++ b/dataRetriever/factory/containers/resolversContainer_test.go @@ -251,7 +251,7 @@ func TestResolversContainer_IterateNilHandlerShouldNotPanic(t *testing.T) { defer func() { r := recover() if r != nil { - assert.Fail(t, "should not have paniced") + assert.Fail(t, "should not have panicked") } }() @@ -269,7 +269,7 @@ func TestResolversContainer_IterateNotAValidKeyShouldWorkAndNotPanic(t *testing. defer func() { r := recover() if r != nil { - assert.Fail(t, "should not have paniced") + assert.Fail(t, "should not have panicked") } }() @@ -292,7 +292,7 @@ func TestResolversContainer_IterateNotAValidValueShouldWorkAndNotPanic(t *testin defer func() { r := recover() if r != nil { - assert.Fail(t, "should not have paniced") + assert.Fail(t, "should not have panicked") } }() diff --git a/dataRetriever/factory/epochProviders/currentEpochProvidersFactory_test.go b/dataRetriever/factory/epochProviders/currentEpochProvidersFactory_test.go index 236c47e4c35..7335f591826 100644 --- a/dataRetriever/factory/epochProviders/currentEpochProvidersFactory_test.go +++ b/dataRetriever/factory/epochProviders/currentEpochProvidersFactory_test.go @@ -25,7 +25,7 @@ func TestCreateCurrentEpochProvider_NilCurrentEpochProvider(t *testing.T) { assert.IsType(t, disabled.NewEpochProvider(), cnep) } -func TestCreateCurrentEpochProvider_ArithemticEpochProvider(t *testing.T) { +func TestCreateCurrentEpochProvider_ArithmeticEpochProvider(t *testing.T) { t.Parallel() cnep, err := CreateCurrentEpochProvider( diff --git a/dataRetriever/interface.go b/dataRetriever/interface.go index 88ba134aa6c..77f59710677 100644 --- a/dataRetriever/interface.go +++ b/dataRetriever/interface.go @@ -316,7 +316,7 @@ type WhiteListHandler interface { IsInterfaceNil() bool } -// DebugHandler defines an interface for debugging the reqested-resolved data +// DebugHandler defines an interface for debugging the requested-resolved data type DebugHandler interface { LogRequestedData(topic string, hashes [][]byte, numReqIntra int, numReqCross int) LogFailedToResolveData(topic string, hash []byte, err error) diff --git a/dataRetriever/mock/marshalizerMock.go b/dataRetriever/mock/marshalizerMock.go index 5299a5bb257..550359b01ca 100644 --- a/dataRetriever/mock/marshalizerMock.go +++ b/dataRetriever/mock/marshalizerMock.go @@ -32,7 +32,7 @@ func (mm *MarshalizerMock) Unmarshal(obj interface{}, buff []byte) error { } if obj == nil { - return errors.New("nil object to serilize to") + return errors.New("nil object to serialize to") } if buff == nil { diff --git a/dataRetriever/resolvers/validatorInfoResolver_test.go b/dataRetriever/resolvers/validatorInfoResolver_test.go index 92a9420cb54..0d5916c710e 100644 --- a/dataRetriever/resolvers/validatorInfoResolver_test.go +++ b/dataRetriever/resolvers/validatorInfoResolver_test.go @@ -379,7 +379,7 @@ func TestValidatorInfoResolver_ProcessReceivedMessage(t *testing.T) { require.NotNil(t, err) assert.True(t, strings.Contains(err.Error(), dataRetriever.ErrValidatorInfoNotFound.Error())) }) - t.Run("pack data in chuncks returns error", func(t *testing.T) { + t.Run("pack data in chunks returns error", func(t *testing.T) { t.Parallel() args := createMockArgValidatorInfoResolver() diff --git a/dataRetriever/shardedData/shardedData_test.go b/dataRetriever/shardedData/shardedData_test.go index 7ca7c379c17..d9ab827df10 100644 --- a/dataRetriever/shardedData/shardedData_test.go +++ b/dataRetriever/shardedData/shardedData_test.go @@ -78,7 +78,7 @@ func TestShardedData_StorageEvictsData(t *testing.T) { } assert.Less(t, sd.ShardDataStore("1").Len(), int(defaultTestConfig.Capacity), - "Transaction pool entries excedes the maximum configured number") + "Transaction pool entries exceeds the maximum configured number") } func TestShardedData_NoDuplicates(t *testing.T) { @@ -228,7 +228,7 @@ func TestShardedData_RegisterAddedDataHandlerShouldWork(t *testing.T) { } } -func TestShardedData_RegisterAddedDataHandlerReallyAddsAhandler(t *testing.T) { +func TestShardedData_RegisterAddedDataHandlerReallyAddsHandler(t *testing.T) { t.Parallel() f := func(key []byte, value interface{}) { diff --git a/dataRetriever/storageRequesters/headerRequester_test.go b/dataRetriever/storageRequesters/headerRequester_test.go index f73f81f6b74..73e54a96e4c 100644 --- a/dataRetriever/storageRequesters/headerRequester_test.go +++ b/dataRetriever/storageRequesters/headerRequester_test.go @@ -1,7 +1,6 @@ package storagerequesters import ( - "errors" "math" "testing" "time" @@ -140,7 +139,6 @@ func TestHeaderRequester_SetEpochHandlerShouldWork(t *testing.T) { func TestHeaderRequester_RequestDataFromHashNotFoundNotBufferedChannelShouldErr(t *testing.T) { t.Parallel() - expectedErr := errors.New("expected error") newEpochCalled := false sendCalled := false arg := createMockHeaderRequesterArg() @@ -173,7 +171,6 @@ func TestHeaderRequester_RequestDataFromHashNotFoundNotBufferedChannelShouldErr( func TestHeaderRequester_RequestDataFromHashNotFoundShouldErr(t *testing.T) { t.Parallel() - expectedErr := errors.New("expected error") newEpochCalled := false sendCalled := false arg := createMockHeaderRequesterArg() @@ -248,7 +245,6 @@ func TestHeaderRequester_RequestDataFromHashShouldWork(t *testing.T) { func TestHeaderRequester_RequestDataFromNonceNotFoundShouldErr(t *testing.T) { t.Parallel() - expectedErr := errors.New("expected error") newEpochCalled := false sendCalled := false arg := createMockHeaderRequesterArg() @@ -343,10 +339,9 @@ func TestHeaderRequester_RequestDataFromEpoch(t *testing.T) { err := hdReq.RequestDataFromEpoch(epochIdentifier) assert.Equal(t, core.ErrInvalidIdentifierForEpochStartBlockRequest, err) }) - t.Run("identifier not found should error should error", func(t *testing.T) { + t.Run("identifier not found should error", func(t *testing.T) { t.Parallel() - expectedErr := errors.New("expected error") epochIdentifier := []byte(core.EpochStartIdentifier(100)) arg := createMockHeaderRequesterArg() arg.HdrStorage = &storageStubs.StorerStub{ diff --git a/dataRetriever/topicSender/diffPeerListCreator_test.go b/dataRetriever/topicSender/diffPeerListCreator_test.go index 73b1a63b418..4b63b757608 100644 --- a/dataRetriever/topicSender/diffPeerListCreator_test.go +++ b/dataRetriever/topicSender/diffPeerListCreator_test.go @@ -75,7 +75,7 @@ func TestNewDiffPeerListCreator_ShouldWork(t *testing.T) { assert.Equal(t, excludedTopic, dplc.ExcludedPeersOnTopic()) } -func TestMakeDiffList_EmptyExcludedShoudRetAllPeersList(t *testing.T) { +func TestMakeDiffList_EmptyExcludedShouldRetAllPeersList(t *testing.T) { t.Parallel() allPeers := []core.PeerID{core.PeerID("peer1"), core.PeerID("peer2")} From 0a981e6258ceffa667d0f19966ea1408a9f5817c Mon Sep 17 00:00:00 2001 From: Sorin Stanculeanu Date: Thu, 25 May 2023 17:33:39 +0300 Subject: [PATCH 4/4] fix after merge --- dataRetriever/storageRequesters/trieNodeRequester_test.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/dataRetriever/storageRequesters/trieNodeRequester_test.go b/dataRetriever/storageRequesters/trieNodeRequester_test.go index 8bbf0fc4f3a..7fd87cf6dc2 100644 --- a/dataRetriever/storageRequesters/trieNodeRequester_test.go +++ b/dataRetriever/storageRequesters/trieNodeRequester_test.go @@ -199,7 +199,7 @@ func TestTrieNodeRequester_Close(t *testing.T) { t.Parallel() args := createMockTrieRequesterArguments() - args.TrieStorageManager = &testscommon.StorageManagerStub{ + args.TrieStorageManager = &storageManager.StorageManagerStub{ CloseCalled: func() error { return expectedErr },