FEAT: Test block processor cache

Author: mariusmihaic

process/blockProcessor.go

@@ -57,7 +57,7 @@ func NewBlockProcessor(proc Processor) (*BlockProcessor, error) {
 func (bp *BlockProcessor) GetBlockByHash(shardID uint32, hash string, options common.BlockQueryOptions) (*data.BlockApiResponse, error) {
 	scope := fmt.Sprintf("block:shardID=%d", shardID)
 	if cached := getObjectFromCache[*data.BlockApiResponse](bp.cache, scope, hash, nil, options); cached != nil {
-		return *cached, nil
+		return cached, nil
 	}
 
 	observers, err := bp.getObserversOrFullHistoryNodes(shardID)
@@ -88,7 +88,7 @@ func (bp *BlockProcessor) GetBlockByHash(shardID uint32, hash string, options co
 func (bp *BlockProcessor) GetBlockByNonce(shardID uint32, nonce uint64, options common.BlockQueryOptions) (*data.BlockApiResponse, error) {
 	scope := fmt.Sprintf("block:shardID=%d", shardID)
 	if cached := getObjectFromCache[*data.BlockApiResponse](bp.cache, scope, "", &nonce, options); cached != nil {
-		return *cached, nil
+		return cached, nil
 	}
 
 	observers, err := bp.getObserversOrFullHistoryNodes(shardID)
@@ -126,7 +126,7 @@ func (bp *BlockProcessor) getObserversOrFullHistoryNodes(shardID uint32) ([]*dat
 // GetHyperBlockByHash returns the hyperblock by hash
 func (bp *BlockProcessor) GetHyperBlockByHash(hash string, options common.HyperblockQueryOptions) (*data.HyperblockApiResponse, error) {
 	if cached := getObjectFromCache[*data.HyperblockApiResponse](bp.cache, "hyperblock", hash, nil, options); cached != nil {
-		return *cached, nil
+		return cached, nil
 	}
 
 	builder := &hyperblockBuilder{}
@@ -200,7 +200,7 @@ func (bp *BlockProcessor) getAlteredAccountsIfNeeded(options common.HyperblockQu
 // GetHyperBlockByNonce returns the hyperblock by nonce
 func (bp *BlockProcessor) GetHyperBlockByNonce(nonce uint64, options common.HyperblockQueryOptions) (*data.HyperblockApiResponse, error) {
 	if cached := getObjectFromCache[*data.HyperblockApiResponse](bp.cache, "hyperblock", "", &nonce, options); cached != nil {
-		return *cached, nil
+		return cached, nil
 	}
 
 	builder := &hyperblockBuilder{}

process/blockProcessorCache.go

@@ -37,7 +37,9 @@ func (bp *BlockProcessor) cacheObject(obj cacheableBlock, scope string, opts int
 	bp.cache.Put(makeNonceCacheKey(scope, obj.Nonce(), opts), objKey, 0)
 }
 
-func getObjectFromCache[T cacheableBlock](c TimedCache, scope string, hash string, nonce *uint64, opts interface{}) *T {
+func getObjectFromCache[T cacheableBlock](c TimedCache, scope string, hash string, nonce *uint64, opts interface{}) T {
+	var retObj T
+
 	var key interface{}
 	if hash != "" {
 		key, _ = c.Get(makeHashCacheKey(scope, hash, opts))
@@ -48,8 +50,9 @@ func getObjectFromCache[T cacheableBlock](c TimedCache, scope string, hash strin
 	if key != nil {
 		val, ok := c.Get(key.([]byte))
 		if ok {
-			return val.(*T)
+			retObj = val.(T)
 		}
 	}
-	return nil
+
+	return retObj
 }

process/blockProcessorCache_test.go

@@ -0,0 +1,155 @@
+package process
+
+import (
+	"testing"
+
+	"github.com/multiversx/mx-chain-core-go/data/api"
+	"github.com/multiversx/mx-chain-proxy-go/common"
+	"github.com/multiversx/mx-chain-proxy-go/data"
+	"github.com/multiversx/mx-chain-proxy-go/process/mock"
+	"github.com/stretchr/testify/require"
+)
+
+func TestBlockProcessorCache(t *testing.T) {
+	t.Parallel()
+
+	bp, _ := NewBlockProcessor(&mock.ProcessorStub{})
+
+	nonceBlock1 := uint64(1)
+	nonceBlock2 := uint64(2)
+	hashBlock1 := "hashBlock1"
+	hashBlock2 := "hashBlock2"
+	scope1 := "block:shard=1"
+	scope2 := "block:shard=2"
+	opts1 := common.BlockQueryOptions{WithTransactions: true}
+	opts2 := common.BlockQueryOptions{WithLogs: true}
+
+	blockApi1 := &data.BlockApiResponse{
+		Data: data.BlockApiResponsePayload{
+			Block: api.Block{
+				Nonce: nonceBlock1,
+				Hash:  hashBlock1,
+			},
+		},
+	}
+	blockApi2 := &data.BlockApiResponse{
+		Data: data.BlockApiResponsePayload{
+			Block: api.Block{
+				Nonce: nonceBlock2,
+				Hash:  hashBlock2,
+			},
+		},
+	}
+
+	require.Nil(t, getObjectFromCache[*data.BlockApiResponse](
+		bp.cache,
+		scope1,
+		hashBlock1,
+		nil,
+		opts1,
+	))
+	require.Nil(t, getObjectFromCache[*data.BlockApiResponse](
+		bp.cache,
+		scope1,
+		"",
+		&nonceBlock1,
+		opts1,
+	))
+
+	bp.cacheObject(blockApi1, scope1, opts1)
+	require.Nil(t, getObjectFromCache[*data.BlockApiResponse](
+		bp.cache,
+		scope2,
+		hashBlock1,
+		nil,
+		opts1,
+	))
+	require.Nil(t, getObjectFromCache[*data.BlockApiResponse](
+		bp.cache,
+		scope1,
+		hashBlock1,
+		nil,
+		opts2,
+	))
+
+	require.Equal(t, blockApi1, getObjectFromCache[*data.BlockApiResponse](
+		bp.cache,
+		scope1,
+		hashBlock1,
+		nil,
+		opts1,
+	))
+	require.Equal(t, blockApi1, getObjectFromCache[*data.BlockApiResponse](
+		bp.cache,
+		scope1,
+		"",
+		&nonceBlock1,
+		opts1,
+	))
+
+	bp.cacheObject(blockApi2, scope2, opts2)
+	require.Nil(t, getObjectFromCache[*data.BlockApiResponse](
+		bp.cache,
+		scope2,
+		hashBlock2,
+		nil,
+		opts1,
+	))
+	require.Equal(t, blockApi2, getObjectFromCache[*data.BlockApiResponse](
+		bp.cache,
+		scope2,
+		hashBlock2,
+		nil,
+		opts2,
+	))
+	require.Equal(t, blockApi2, getObjectFromCache[*data.BlockApiResponse](
+		bp.cache,
+		scope2,
+		"",
+		&nonceBlock2,
+		opts2,
+	))
+
+	scopeHyperBlock := "hyperBlock"
+	hyperBlockNonce := uint64(4)
+	hyperBlockHash := "hyperBlockHash"
+	hyperBlock := &data.HyperblockApiResponse{
+		Data: data.HyperblockApiResponsePayload{
+			Hyperblock: api.Hyperblock{
+				Hash:  hyperBlockHash,
+				Nonce: hyperBlockNonce,
+			},
+		},
+	}
+
+	bp.cacheObject(hyperBlock, scopeHyperBlock, opts1)
+	bp.cacheObject(hyperBlock, scopeHyperBlock, opts2)
+	require.Equal(t, hyperBlock, getObjectFromCache[*data.HyperblockApiResponse](
+		bp.cache,
+		scopeHyperBlock,
+		hyperBlockHash,
+		nil,
+		opts2,
+	))
+	require.Equal(t, hyperBlock, getObjectFromCache[*data.HyperblockApiResponse](
+		bp.cache,
+		scopeHyperBlock,
+		"",
+		&hyperBlockNonce,
+		opts2,
+	))
+	require.Equal(t, hyperBlock, getObjectFromCache[*data.HyperblockApiResponse](
+		bp.cache,
+		scopeHyperBlock,
+		hyperBlockHash,
+		nil,
+		opts1,
+	))
+	require.Equal(t, hyperBlock, getObjectFromCache[*data.HyperblockApiResponse](
+		bp.cache,
+		scopeHyperBlock,
+		"",
+		&hyperBlockNonce,
+		opts1,
+	))
+}