Fix integration test and mock implementations

Author: Jetlum

integration_test.go

@@ -8,7 +8,9 @@ import (
 
 	"github.com/Jetlum/WalletAlertService/mock"
 	"github.com/Jetlum/WalletAlertService/models"
+	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/crypto"
 	"github.com/stretchr/testify/assert"
 )
 
@@ -21,23 +23,6 @@ func TestIntegration(t *testing.T) {
 	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
 	defer cancel()
 
-	// Create test event
-	event := &models.Event{
-		TxHash:      "0xtest",
-		FromAddress: "0xfrom",
-		ToAddress:   "0xto",
-		Value:       "1000000000000000000", // 1 ETH
-		EventType:   "LARGE_TRANSFER",
-	}
-
-	// Setup mocks
-	mockEventRepo := &mock.MockEventRepository{
-		CreateFunc: func(e *models.Event) error {
-			assert.Equal(t, event.TxHash, e.TxHash)
-			return nil
-		},
-	}
-
 	userPref := models.UserPreference{
 		UserID:            "test@example.com",
 		WalletAddress:     "0xto",
@@ -47,40 +32,98 @@ func TestIntegration(t *testing.T) {
 
 	mockUserPrefRepo := &mock.MockUserPreferenceRepository{
 		GetMatchingPreferencesFunc: func(e *models.Event) ([]models.UserPreference, error) {
-			assert.Equal(t, event.ToAddress, e.ToAddress)
 			return []models.UserPreference{userPref}, nil
 		},
 	}
 
-	// Setup mock email notification
+	// Create mock Ethereum client
+	mockClient := mock.NewMockEthClient()
+
+	// Create and use fromAddress in assertions
+	privateKey, err := crypto.GenerateKey()
+	if err != nil {
+		t.Fatalf("Failed to generate private key: %v", err)
+	}
+	fromAddress := crypto.PubkeyToAddress(privateKey.PublicKey)
+
+	mockEventRepo := &mock.MockEventRepository{
+		CreateFunc: func(e *models.Event) error {
+			assert.Equal(t, fromAddress.Hex(), e.FromAddress, "From address should match")
+			return nil
+		},
+	}
+	// Create mock transaction (unsigned)
+	mockTx := types.NewTransaction(
+		0,
+		common.HexToAddress("0xto"),
+		big.NewInt(2000000000000000000), // 2 ETH (above threshold)
+		21000,
+		big.NewInt(1),
+		nil,
+	)
+
+	// Sign the transaction
+	chainID := big.NewInt(1) // Use the same chain ID in the mock client
+	signer := types.LatestSignerForChainID(chainID)
+	signedTx, err := types.SignTx(mockTx, signer, privateKey)
+	if err != nil {
+		t.Fatalf("Failed to sign transaction: %v", err)
+	}
+
+	// Update NetworkIDFunc to return the correct chain ID
+	mockClient.NetworkIDFunc = func(ctx context.Context) (*big.Int, error) {
+		return chainID, nil
+	}
+
+	// Fix block.WithBody call
+	mockClient.BlockByHashFunc = func(ctx context.Context, hash common.Hash) (*types.Block, error) {
+		header := &types.Header{
+			Number:     big.NewInt(1),
+			ParentHash: common.HexToHash("0x123"),
+			Time:       uint64(time.Now().Unix()),
+		}
+
+		block := types.NewBlockWithHeader(header)
+		return block.WithBody(types.Body{
+			Transactions: []*types.Transaction{signedTx},
+			Uncles:       []*types.Header{},
+		}), nil
+	}
+
+	// Use mock NFT detector
+	mockNFTDetector := &mock.MockNFTDetector{
+		IsNFTTransactionFunc: func(tx *types.Transaction) bool {
+			return false
+		},
+	}
+
 	emailSent := false
 	mockEmailNotification := &mock.MockEmailNotification{
-		SendFunc: func(e *models.Event, up *models.UserPreference) error {
+		SendFunc: func(event *models.Event, userPref *models.UserPreference) error {
 			emailSent = true
+			// Add assertions if needed
 			return nil
 		},
 	}
 
-	// Create mock block and header
+	// Create mock header
 	mockHeader := &types.Header{
 		Number: big.NewInt(1),
 	}
 
-	// Test full workflow
 	done := make(chan bool)
 	go func() {
 		processBlock(
-			nil,
+			mockClient,
 			mockHeader,
-			mock.NewMockNFTDetector(),
+			mockNFTDetector,
 			mockEmailNotification,
 			mockEventRepo,
 			mockUserPrefRepo,
 		)
 		done <- true
 	}()
 
-	// Wait for completion or timeout
 	select {
 	case <-ctx.Done():
 		t.Fatal("Test timed out")

main.go

@@ -87,7 +87,7 @@ func main() {
 }
 
 func processBlock(
-	client *ethclient.Client,
+	client mock.EthClient,
 	header *types.Header,
 	nftDetector nfts.INFTDetector,
 	emailNotification services.EmailNotifier,
@@ -124,14 +124,13 @@ func processBlock(
 	}
 }
 
-func createEvent(tx *types.Transaction, client *ethclient.Client) *models.Event {
+func createEvent(tx *types.Transaction, client mock.EthClient) *models.Event {
 	chainID, err := client.NetworkID(context.Background())
 	if err != nil {
 		log.Fatalf("Failed to get network ID: %v", err)
 	}
 
 	signer := types.NewEIP155Signer(chainID)
-
 	fromAddress, err := types.Sender(signer, tx)
 	if err != nil {
 		log.Fatalf("Failed to get sender address: %v", err)

mock/ethereum_mock.go

@@ -0,0 +1,71 @@
+package mock
+
+import (
+	"context"
+	"math/big"
+	"time"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/types"
+)
+
+// EthClient defines the interface for Ethereum client operations
+type EthClient interface {
+	BlockByHash(ctx context.Context, hash common.Hash) (*types.Block, error)
+	BlockNumber(ctx context.Context) (uint64, error)
+	HeaderByNumber(ctx context.Context, number *big.Int) (*types.Header, error)
+	NetworkID(ctx context.Context) (*big.Int, error)
+}
+
+type MockEthClient struct {
+	BlockByHashFunc    func(ctx context.Context, hash common.Hash) (*types.Block, error)
+	BlockNumberFunc    func(ctx context.Context) (uint64, error)
+	HeaderByNumberFunc func(ctx context.Context, number *big.Int) (*types.Header, error)
+	NetworkIDFunc      func(ctx context.Context) (*big.Int, error)
+}
+
+func NewMockEthClient() *MockEthClient {
+	return &MockEthClient{
+		BlockByHashFunc: func(ctx context.Context, hash common.Hash) (*types.Block, error) {
+			header := &types.Header{
+				Number:     big.NewInt(1),
+				ParentHash: common.HexToHash("0x123"),
+				Time:       uint64(time.Now().Unix()),
+			}
+
+			block := types.NewBlockWithHeader(header)
+			return block.WithBody(types.Body{
+				Transactions: make([]*types.Transaction, 0),
+				Uncles:       make([]*types.Header, 0),
+			}), nil
+		},
+		NetworkIDFunc: func(ctx context.Context) (*big.Int, error) {
+			return big.NewInt(1), nil
+		},
+	}
+}
+
+func (m *MockEthClient) BlockByHash(ctx context.Context, hash common.Hash) (*types.Block, error) {
+	return m.BlockByHashFunc(ctx, hash)
+}
+
+func (m *MockEthClient) BlockNumber(ctx context.Context) (uint64, error) {
+	if m.BlockNumberFunc != nil {
+		return m.BlockNumberFunc(ctx)
+	}
+	return 0, nil
+}
+
+func (m *MockEthClient) HeaderByNumber(ctx context.Context, number *big.Int) (*types.Header, error) {
+	if m.HeaderByNumberFunc != nil {
+		return m.HeaderByNumberFunc(ctx, number)
+	}
+	return nil, nil
+}
+
+func (m *MockEthClient) NetworkID(ctx context.Context) (*big.Int, error) {
+	if m.NetworkIDFunc != nil {
+		return m.NetworkIDFunc(ctx)
+	}
+	return big.NewInt(1), nil
+}

mock/nft_mock.go

@@ -1,15 +1,14 @@
 package mock
 
 import (
-	nfts "github.com/Jetlum/WalletAlertService/nft"
 	"github.com/ethereum/go-ethereum/core/types"
 )
 
 type MockNFTDetector struct {
 	IsNFTTransactionFunc func(tx *types.Transaction) bool
 }
 
-func NewMockNFTDetector() nfts.INFTDetector {
+func NewMockNFTDetector() *MockNFTDetector {
 	return &MockNFTDetector{
 		IsNFTTransactionFunc: func(tx *types.Transaction) bool {
 			return false