Add evm listener tests

Makefile

@@ -40,3 +40,4 @@ genmocks:
 	mockgen -source=chains/evm/transactor/signAndSend/signAndSend.go -destination=./mock/signAndSend.go -package mock
 	mockgen -source=./store/store.go -destination=./mock/store.go -package mock
 	mockgen -source=./relayer/message/handler.go -destination=./mock/message.go -package mock
+	mockgen -source=./chains/evm/listener/listener.go -destination=./mock/listener.go -package mock

chains/evm/listener/listener.go

@@ -8,8 +8,6 @@ import (
 	"math/big"
 	"time"
 
-	"github.com/ChainSafe/sygma-core/store"
-
 	"github.com/rs/zerolog"
 	"github.com/rs/zerolog/log"
 )
@@ -26,13 +24,17 @@ type BlockDeltaMeter interface {
 	TrackBlockDelta(domainID uint8, head *big.Int, current *big.Int)
 }
 
+type BlockStorer interface {
+	StoreBlock(block *big.Int, domainID uint8) error
+}
+
 type EVMListener struct {
 	client        ChainClient
 	eventHandlers []EventHandler
 	metrics       BlockDeltaMeter
+	blockstore    BlockStorer
 
 	domainID           uint8
-	blockstore         *store.BlockStore
 	blockRetryInterval time.Duration
 	blockConfirmations *big.Int
 	blockInterval      *big.Int
@@ -45,7 +47,7 @@ type EVMListener struct {
 func NewEVMListener(
 	client ChainClient,
 	eventHandlers []EventHandler,
-	blockstore *store.BlockStore,
+	blockstore BlockStorer,
 	metrics BlockDeltaMeter,
 	domainID uint8,
 	blockRetryInterval time.Duration,
@@ -69,6 +71,7 @@ func NewEVMListener(
 // configured for the listener.
 func (l *EVMListener) ListenToEvents(ctx context.Context, startBlock *big.Int) {
 	endBlock := big.NewInt(0)
+loop:
 	for {
 		select {
 		case <-ctx.Done():
@@ -98,7 +101,7 @@ func (l *EVMListener) ListenToEvents(ctx context.Context, startBlock *big.Int) {
 				err := handler.HandleEvents(startBlock, new(big.Int).Sub(endBlock, big.NewInt(1)))
 				if err != nil {
 					l.log.Error().Err(err).Msgf("Unable to handle events")
-					continue
+					continue loop
 				}
 			}
 

chains/evm/listener/listener_test.go

@@ -0,0 +1,158 @@
+package listener_test
+
+import (
+	"context"
+	"fmt"
+	"math/big"
+	"testing"
+	"time"
+
+	"github.com/ChainSafe/sygma-core/chains/evm/listener"
+	"github.com/ChainSafe/sygma-core/mock"
+	"github.com/stretchr/testify/suite"
+	"go.uber.org/mock/gomock"
+)
+
+type ListenerTestSuite struct {
+	suite.Suite
+	listener            *listener.EVMListener
+	mockClient          *mock.MockChainClient
+	mockEventHandler    *mock.MockEventHandler
+	mockBlockStorer     *mock.MockBlockStorer
+	mockBlockDeltaMeter *mock.MockBlockDeltaMeter
+	domainID            uint8
+}
+
+func TestRunTestSuite(t *testing.T) {
+	suite.Run(t, new(ListenerTestSuite))
+}
+
+func (s *ListenerTestSuite) SetupTest() {
+	ctrl := gomock.NewController(s.T())
+	s.domainID = 1
+	s.mockClient = mock.NewMockChainClient(ctrl)
+	s.mockEventHandler = mock.NewMockEventHandler(ctrl)
+	s.mockBlockStorer = mock.NewMockBlockStorer(ctrl)
+	s.mockBlockDeltaMeter = mock.NewMockBlockDeltaMeter(ctrl)
+	s.listener = listener.NewEVMListener(
+		s.mockClient,
+		[]listener.EventHandler{s.mockEventHandler, s.mockEventHandler},
+		s.mockBlockStorer,
+		s.mockBlockDeltaMeter,
+		s.domainID,
+		time.Millisecond*75,
+		big.NewInt(5),
+		big.NewInt(5))
+}
+
+func (s *ListenerTestSuite) Test_ListenToEvents_RetriesIfBlockUnavailable() {
+	s.mockClient.EXPECT().LatestBlock().Return(big.NewInt(0), fmt.Errorf("error"))
+
+	ctx, cancel := context.WithCancel(context.Background())
+	go s.listener.ListenToEvents(ctx, big.NewInt(100))
+
+	time.Sleep(time.Millisecond * 50)
+	cancel()
+}
+
+func (s *ListenerTestSuite) Test_ListenToEvents_SleepsIfBlockTooNew() {
+	s.mockClient.EXPECT().LatestBlock().Return(big.NewInt(109), nil)
+
+	ctx, cancel := context.WithCancel(context.Background())
+	go s.listener.ListenToEvents(ctx, big.NewInt(100))
+
+	time.Sleep(time.Millisecond * 50)
+	cancel()
+}
+
+func (s *ListenerTestSuite) Test_ListenToEvents_RetriesInCaseOfHandlerFailure() {
+	startBlock := big.NewInt(100)
+	endBlock := big.NewInt(105)
+	head := big.NewInt(110)
+
+	// First pass
+	s.mockClient.EXPECT().LatestBlock().Return(head, nil)
+	s.mockBlockDeltaMeter.EXPECT().TrackBlockDelta(uint8(1), head, endBlock)
+	s.mockEventHandler.EXPECT().HandleEvents(startBlock, new(big.Int).Sub(endBlock, big.NewInt(1))).Return(fmt.Errorf("error"))
+	// Second pass
+	s.mockClient.EXPECT().LatestBlock().Return(head, nil)
+	s.mockBlockDeltaMeter.EXPECT().TrackBlockDelta(uint8(1), head, endBlock)
+	s.mockEventHandler.EXPECT().HandleEvents(startBlock, new(big.Int).Sub(endBlock, big.NewInt(1))).Return(nil)
+	s.mockEventHandler.EXPECT().HandleEvents(startBlock, new(big.Int).Sub(endBlock, big.NewInt(1))).Return(nil)
+	s.mockBlockStorer.EXPECT().StoreBlock(endBlock, s.domainID).Return(nil)
+	// third pass
+	s.mockClient.EXPECT().LatestBlock().Return(head, nil)
+
+	ctx, cancel := context.WithCancel(context.Background())
+
+	go s.listener.ListenToEvents(ctx, big.NewInt(100))
+
+	time.Sleep(time.Millisecond * 50)
+	cancel()
+}
+
+func (s *ListenerTestSuite) Test_ListenToEvents_StoresBlockIfEventHandlingSuccessful() {
+	startBlock := big.NewInt(100)
+	endBlock := big.NewInt(105)
+	head := big.NewInt(110)
+
+	s.mockClient.EXPECT().LatestBlock().Return(head, nil)
+	// prevent infinite runs
+	s.mockClient.EXPECT().LatestBlock().Return(big.NewInt(95), nil)
+	s.mockBlockDeltaMeter.EXPECT().TrackBlockDelta(uint8(1), head, endBlock)
+	s.mockEventHandler.EXPECT().HandleEvents(startBlock, new(big.Int).Sub(endBlock, big.NewInt(1))).Return(nil)
+	s.mockEventHandler.EXPECT().HandleEvents(startBlock, new(big.Int).Sub(endBlock, big.NewInt(1))).Return(nil)
+	s.mockBlockStorer.EXPECT().StoreBlock(endBlock, s.domainID).Return(nil)
+
+	ctx, cancel := context.WithCancel(context.Background())
+
+	go s.listener.ListenToEvents(ctx, big.NewInt(100))
+
+	time.Sleep(time.Millisecond * 50)
+	cancel()
+}
+
+func (s *ListenerTestSuite) Test_ListenToEvents_IgnoresBlocStorerError() {
+	startBlock := big.NewInt(100)
+	endBlock := big.NewInt(105)
+	head := big.NewInt(110)
+
+	s.mockClient.EXPECT().LatestBlock().Return(head, nil)
+	// prevent infinite runs
+	s.mockClient.EXPECT().LatestBlock().Return(big.NewInt(95), nil)
+	s.mockBlockDeltaMeter.EXPECT().TrackBlockDelta(uint8(1), head, endBlock)
+	s.mockEventHandler.EXPECT().HandleEvents(startBlock, new(big.Int).Sub(endBlock, big.NewInt(1))).Return(nil)
+	s.mockEventHandler.EXPECT().HandleEvents(startBlock, new(big.Int).Sub(endBlock, big.NewInt(1))).Return(nil)
+	s.mockBlockStorer.EXPECT().StoreBlock(endBlock, s.domainID).Return(fmt.Errorf("error"))
+
+	ctx, cancel := context.WithCancel(context.Background())
+
+	go s.listener.ListenToEvents(ctx, big.NewInt(100))
+
+	time.Sleep(time.Millisecond * 50)
+	cancel()
+}
+
+func (s *ListenerTestSuite) Test_ListenToEvents_UsesHeadAsStartBlockIfNilPassed() {
+	startBlock := big.NewInt(110)
+	endBlock := big.NewInt(115)
+	oldHead := big.NewInt(110)
+	newHead := big.NewInt(120)
+
+	s.mockClient.EXPECT().LatestBlock().Return(oldHead, nil)
+	s.mockClient.EXPECT().LatestBlock().Return(newHead, nil)
+	s.mockClient.EXPECT().LatestBlock().Return(big.NewInt(65), nil)
+
+	s.mockBlockDeltaMeter.EXPECT().TrackBlockDelta(uint8(1), big.NewInt(120), endBlock)
+
+	s.mockEventHandler.EXPECT().HandleEvents(startBlock, new(big.Int).Sub(endBlock, big.NewInt(1))).Return(nil)
+	s.mockEventHandler.EXPECT().HandleEvents(startBlock, new(big.Int).Sub(endBlock, big.NewInt(1))).Return(nil)
+	s.mockBlockStorer.EXPECT().StoreBlock(endBlock, s.domainID).Return(nil)
+
+	ctx, cancel := context.WithCancel(context.Background())
+
+	go s.listener.ListenToEvents(ctx, nil)
+
+	time.Sleep(time.Millisecond * 100)
+	cancel()
+}