neutrino: mock block and filter header stores

Author: mohamedawnallah

blockmanager_test.go

@@ -798,8 +798,11 @@ func TestBlockManagerDetectBadPeers(t *testing.T) {
 	for _, test := range testCases {
 		// Create a mock block header store. We only need to be able to
 		// serve a header for the target index.
-		blockHeaders := newMockBlockHeaderStore()
-		blockHeaders.heights[targetIndex] = blockHeader
+		mBlockHeaderStore := &headerfs.MockBlockHeaderStore{}
+
+		mBlockHeaderStore.On("FetchHeaderByHeight", targetIndex).Return(
+			&blockHeader, nil,
+		)
 
 		// We set up the mock queryAllPeers to only respond according to
 		// the active testcase.
@@ -851,7 +854,7 @@ func TestBlockManagerDetectBadPeers(t *testing.T) {
 
 		bm := &blockManager{
 			cfg: &blockManagerCfg{
-				BlockHeaders:  blockHeaders,
+				BlockHeaders:  mBlockHeaderStore,
 				queryAllPeers: queryAllPeers,
 			},
 		}

headerfs/store_mock.go

@@ -0,0 +1,154 @@
+package headerfs
+
+import (
+	"github.com/btcsuite/btcd/blockchain"
+	"github.com/btcsuite/btcd/chaincfg/chainhash"
+	"github.com/btcsuite/btcd/wire"
+	"github.com/stretchr/testify/mock"
+)
+
+// MockBlockHeaderStore is a mock implementation of the BlockHeaderStore.
+type MockBlockHeaderStore struct {
+	mock.Mock
+}
+
+// ChainTip returns the current chain tip for the mock block header store.
+func (m *MockBlockHeaderStore) ChainTip() (*wire.BlockHeader, uint32, error) {
+	args := m.Called()
+	return args.Get(0).(*wire.BlockHeader),
+		args.Get(1).(uint32),
+		args.Error(2)
+}
+
+// LatestBlockLocator returns the latest block locator for the mock block header
+// store.
+//
+//nolint:lll
+func (m *MockBlockHeaderStore) LatestBlockLocator() (blockchain.BlockLocator, error) {
+	args := m.Called()
+	return args.Get(0).(blockchain.BlockLocator), args.Error(1)
+}
+
+// FetchHeaderByHeight fetches a block header by height for the mock block
+// header store.
+func (m *MockBlockHeaderStore) FetchHeaderByHeight(
+	height uint32) (*wire.BlockHeader, error) {
+
+	args := m.Called(height)
+	if args.Get(0) == nil {
+		return nil, args.Error(1)
+	}
+	return args.Get(0).(*wire.BlockHeader), args.Error(1)
+}
+
+// FetchHeaderAncestors fetches block header ancestors for the mock block header
+// store.
+func (m *MockBlockHeaderStore) FetchHeaderAncestors(numHeaders uint32,
+	stopHash *chainhash.Hash) ([]wire.BlockHeader, uint32, error) {
+
+	args := m.Called(numHeaders, stopHash)
+	return args.Get(0).([]wire.BlockHeader),
+		args.Get(1).(uint32),
+		args.Error(2)
+}
+
+// HeightFromHash returns the height from a hash for the mock block header
+// store.
+func (m *MockBlockHeaderStore) HeightFromHash(
+	hash *chainhash.Hash) (uint32, error) {
+
+	args := m.Called(hash)
+	return args.Get(0).(uint32), args.Error(1)
+}
+
+// FetchHeader fetches a block header by hash for the mock block header store.
+func (m *MockBlockHeaderStore) FetchHeader(
+	hash *chainhash.Hash) (*wire.BlockHeader, uint32, error) {
+
+	args := m.Called(hash)
+	if args.Get(0) == nil {
+		return nil, args.Get(1).(uint32), args.Error(2)
+	}
+	return args.Get(0).(*wire.BlockHeader),
+		args.Get(1).(uint32),
+		args.Error(2)
+}
+
+// WriteHeaders writes block headers to the mock block header store.
+func (m *MockBlockHeaderStore) WriteHeaders(hdrs ...BlockHeader) error {
+	args := m.Called(hdrs)
+	return args.Error(0)
+}
+
+// RollbackLastBlock rolls back the last block in the mock block header store.
+func (m *MockBlockHeaderStore) RollbackLastBlock() (*BlockStamp, error) {
+	args := m.Called()
+	if args.Get(0) == nil {
+		return nil, args.Error(1)
+	}
+	return args.Get(0).(*BlockStamp), args.Error(1)
+}
+
+// MockFilterHeaderStore is a mock implementation of the FilterHeaderStore.
+type MockFilterHeaderStore struct {
+	mock.Mock
+}
+
+// ChainTip returns the current chain tip for the mock filter header store.
+func (m *MockFilterHeaderStore) ChainTip() (*chainhash.Hash, uint32, error) {
+	args := m.Called()
+	return args.Get(0).(*chainhash.Hash),
+		args.Get(1).(uint32),
+		args.Error(2)
+}
+
+// FetchHeader fetches a filter header by hash for the mock filter header store.
+func (m *MockFilterHeaderStore) FetchHeader(
+	hash *chainhash.Hash) (*chainhash.Hash, error) {
+
+	args := m.Called(hash)
+	if args.Get(0) == nil {
+		return nil, args.Error(1)
+	}
+	return args.Get(0).(*chainhash.Hash), args.Error(1)
+}
+
+// FetchHeaderAncestors fetches filter header ancestors for the mock filter
+// header store.
+func (m *MockFilterHeaderStore) FetchHeaderAncestors(numHeaders uint32,
+	stopHash *chainhash.Hash) ([]chainhash.Hash, uint32, error) {
+
+	args := m.Called(numHeaders, stopHash)
+	return args.Get(0).([]chainhash.Hash),
+		args.Get(1).(uint32),
+		args.Error(2)
+}
+
+// FetchHeaderByHeight fetches a filter header by height for the mock filter
+// header store.
+func (m *MockFilterHeaderStore) FetchHeaderByHeight(
+	height uint32) (*chainhash.Hash, error) {
+
+	args := m.Called(height)
+	if args.Get(0) == nil {
+		return nil, args.Error(1)
+	}
+	return args.Get(0).(*chainhash.Hash), args.Error(1)
+}
+
+// WriteHeaders writes filter headers to the mock filter header store.
+func (m *MockFilterHeaderStore) WriteHeaders(headers ...FilterHeader) error {
+	args := m.Called(headers)
+	return args.Error(0)
+}
+
+// RollbackLastBlock rolls back the last block in the mock filter header store.
+func (m *MockFilterHeaderStore) RollbackLastBlock(
+	newTip *chainhash.Hash) (*BlockStamp, error) {
+
+	args := m.Called(newTip)
+	if args.Get(0) == nil {
+		return nil, args.Error(1)
+	}
+	return args.Get(0).(*BlockStamp), args.Error(1)
+}

mock_store.go

@@ -254,23 +254,20 @@ func TestBlockCache(t *testing.T) {
 
 	// Load the first 255 blocks from disk.
 	blocks, err := loadBlocks(t, blockDataFile, blockDataNet)
-	if err != nil {
-		t.Fatalf("loadBlocks: Unexpected error: %v", err)
-	}
+	require.NoError(t, err)
 
 	// We'll use a simple mock header store since the GetBlocks method
 	// assumes we only query for blocks with an already known header.
-	headers := newMockBlockHeaderStore()
+	mBlockHeaderStore := &headerfs.MockBlockHeaderStore{}
 
 	// Iterate through the blocks, calculating the size of half of them,
 	// and writing them to the header store.
 	var size uint64
 	for i, b := range blocks {
-		header := headerfs.BlockHeader{
-			BlockHeader: &b.MsgBlock().Header,
-			Height:      uint32(i),
-		}
-		headers.WriteHeaders(header)
+		blkHeader := &b.MsgBlock().Header
+		mBlockHeaderStore.On("FetchHeader", b.Hash()).Return(
+			blkHeader, uint32(i), nil,
+		)
 
 		sz, _ := (&CacheableBlock{Block: b}).Size()
 		if i < len(blocks)/2 {
@@ -284,7 +281,7 @@ func TestBlockCache(t *testing.T) {
 		BlockCache: lru.NewCache[wire.InvVect, *CacheableBlock](
 			size,
 		),
-		BlockHeaders: headers,
+		BlockHeaders: mBlockHeaderStore,
 		chainParams: chaincfg.Params{
 			PowLimit: maxPowLimit,
 		},
@@ -317,7 +314,9 @@ func TestBlockCache(t *testing.T) {
 				continue
 			}
 
-			header, _, err := headers.FetchHeader(b.Hash())
+			header, _, err := mBlockHeaderStore.FetchHeader(
+				b.Hash(),
+			)
 			require.NoError(t, err)
 
 			resp := &wire.MsgBlock{
@@ -333,13 +332,16 @@ func TestBlockCache(t *testing.T) {
 			select {
 			case queries <- inv.Hash:
 			case <-time.After(1 * time.Second):
-				t.Fatalf("query was not handled")
+				require.Fail(t, "query was not handled")
 			}
 
 			return errChan
 		}
 
-		t.Fatalf("queried for unknown block: %v", inv.Hash)
+		require.Failf(
+			t, "Test Failed Due to Unknown Block",
+			"queried for unknown block: %v", inv.Hash,
+		)
 
 		return errChan
 	}