e2e test scaffolding (manages system lifecycle). Use testify/require over testify/assert

indexer/e2e_test/e2e_test.go

+package integration_tests
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestE2E(t *testing.T) {
+	testSuite := createE2ETestSuite(t)
+	t.Run("indexes block headers", func(t *testing.T) {
+		// L1
+		latestL1Header, err := testSuite.DB.Blocks.LatestL1BlockHeader()
+		require.NoError(t, err)
+		require.NotNil(t, latestL1Header)
+		require.True(t, latestL1Header.Number.Int.Uint64() >= 9)
+
+		// L1
+		latestL2Header, err := testSuite.DB.Blocks.LatestL2BlockHeader()
+		require.NoError(t, err)
+		require.NotNil(t, latestL2Header)
+		require.True(t, latestL2Header.Number.Int.Uint64() >= 9)
+	})
+
+	t.Run("indexes l2 checkpoints", func(t *testing.T) {
+		latestOutput, err := testSuite.DB.Blocks.LatestCheckpointedOutput()
+		require.NoError(t, err)
+		require.NotNil(t, latestOutput)
+		require.True(t, latestOutput.L2BlockNumber.Int.Uint64() >= 9)
+	})
+}

indexer/e2e_test/setup.go

+package integration_tests
+
+import (
+	"context"
+	"database/sql"
+	"fmt"
+	"io/fs"
+	"os"
+	"path/filepath"
+	"testing"
+	"time"
+
+	"github.com/ethereum-optimism/optimism/indexer"
+	"github.com/ethereum-optimism/optimism/indexer/config"
+	"github.com/ethereum-optimism/optimism/indexer/database"
+	op_e2e "github.com/ethereum-optimism/optimism/op-e2e"
+	"github.com/ethereum-optimism/optimism/op-node/testlog"
+	"github.com/ethereum/go-ethereum/log"
+
+	_ "github.com/jackc/pgx/v5/stdlib"
+	"github.com/stretchr/testify/require"
+)
+
+type E2ETestSuite struct {
+	t *testing.T
+
+	// Indexer
+	DB      *database.DB
+	Indexer *indexer.Indexer
+
+	// Rollup
+	OpSys *op_e2e.System
+}
+
+func createE2ETestSuite(t *testing.T) E2ETestSuite {
+	dbName := setupTestDatabase(t)
+
+	// Replace the handler of the global logger with the testlog
+	logger := testlog.Logger(t, log.LvlInfo)
+	log.Root().SetHandler(logger.GetHandler())
+
+	// Rollup System Configuration and Start
+	opCfg := op_e2e.DefaultSystemConfig(t)
+	opCfg.DeployConfig.FinalizationPeriodSeconds = 2
+	opSys, err := opCfg.Start()
+	require.NoError(t, err)
+
+	// Indexer Configuration and Start
+	indexerCfg := config.Config{
+		DB: config.DBConfig{
+			Host: "127.0.0.1",
+			Port: 5432,
+			Name: dbName,
+		},
+		RPCs: config.RPCsConfig{
+			L1RPC: opSys.Nodes["l1"].HTTPEndpoint(),
+			L2RPC: opSys.Nodes["sequencer"].HTTPEndpoint(),
+		},
+		Logger: logger,
+	}
+
+	db, err := database.NewDB(fmt.Sprintf("database=%s", dbName))
+	require.NoError(t, err)
+	indexer, err := indexer.NewIndexer(indexerCfg)
+	require.NoError(t, err)
+
+	indexerCtx, indexerStop := context.WithCancel(context.Background())
+	go func() {
+		err := indexer.Run(indexerCtx)
+		require.NoError(t, err)
+
+		indexer.Cleanup()
+	}()
+
+	t.Cleanup(func() {
+		indexerStop()
+
+		// wait a second for the stop signal to be received
+		time.Sleep(1 * time.Second)
+		indexer.Cleanup()
+
+		db.Close()
+		opSys.Close()
+	})
+
+	return E2ETestSuite{
+		t:       t,
+		DB:      db,
+		Indexer: indexer,
+		OpSys:   opSys,
+	}
+}
+
+func setupTestDatabase(t *testing.T) string {
+	pg, err := sql.Open("pgx", "database=postgres")
+	require.NoError(t, err)
+	require.NoError(t, pg.Ping())
+
+	// create database
+	dbName := fmt.Sprintf("indexer_test_%d", time.Now().Unix())
+	_, err = pg.Exec("CREATE DATABASE " + dbName)
+	require.NoError(t, err)
+	t.Cleanup(func() {
+		_, err := pg.Exec("DROP DATABASE " + dbName)
+		require.NoError(t, err)
+		pg.Close()
+	})
+
+	// setup schema, migration files ware walked in lexical order
+	t.Logf("created database %s", dbName)
+	db, err := sql.Open("pgx", fmt.Sprintf("database=%s", dbName))
+	require.NoError(t, err)
+	require.NoError(t, db.Ping())
+	defer db.Close()
+
+	t.Logf("running schema migrations...")
+	require.NoError(t, filepath.Walk("../migrations", func(path string, info fs.FileInfo, err error) error {
+		if err != nil {
+			return err
+		} else if info.IsDir() {
+			return nil
+		}
+
+		t.Logf("running schema migration: %s", path)
+		data, err := os.ReadFile(path)
+		if err != nil {
+			return err
+		}
+
+		_, err = db.Exec(string(data))
+		return err
+	}))
+
+	t.Logf("schema loaded")
+	return dbName
+}

indexer/node/header_traversal_test.go

@@ -4,8 +4,8 @@ import (
 	"math/big"
 	"testing"
 
-	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/mock"
+	"github.com/stretchr/testify/require"
 
 	"github.com/ethereum/go-ethereum/core/types"
 )
@@ -43,8 +43,8 @@ func TestHeaderTraversalNextFinalizedHeadersNoOp(t *testing.T) {
 	// no new headers when matched with head
 	client.On("FinalizedBlockHeight").Return(big.NewInt(10), nil)
 	headers, err := headerTraversal.NextFinalizedHeaders(100)
-	assert.NoError(t, err)
-	assert.Empty(t, headers)
+	require.NoError(t, err)
+	require.Empty(t, headers)
 }
 
 func TestHeaderTraversalNextFinalizedHeadersCursored(t *testing.T) {
@@ -58,16 +58,16 @@ func TestHeaderTraversalNextFinalizedHeadersCursored(t *testing.T) {
 	client.On("FinalizedBlockHeight").Return(big.NewInt(4), nil).Times(1) // Times so that we can override next
 	client.On("BlockHeadersByRange", mock.MatchedBy(bigIntMatcher(0)), mock.MatchedBy(bigIntMatcher(4))).Return(headers, nil)
 	headers, err := headerTraversal.NextFinalizedHeaders(5)
-	assert.NoError(t, err)
-	assert.Len(t, headers, 5)
+	require.NoError(t, err)
+	require.Len(t, headers, 5)
 
 	// blocks [5..9]
 	headers = makeHeaders(5, headers[len(headers)-1])
 	client.On("FinalizedBlockHeight").Return(big.NewInt(9), nil)
 	client.On("BlockHeadersByRange", mock.MatchedBy(bigIntMatcher(5)), mock.MatchedBy(bigIntMatcher(9))).Return(headers, nil)
 	headers, err = headerTraversal.NextFinalizedHeaders(5)
-	assert.NoError(t, err)
-	assert.Len(t, headers, 5)
+	require.NoError(t, err)
+	require.Len(t, headers, 5)
 }
 
 func TestHeaderTraversalNextFinalizedHeadersMaxSize(t *testing.T) {
@@ -83,15 +83,15 @@ func TestHeaderTraversalNextFinalizedHeadersMaxSize(t *testing.T) {
 	headers := makeHeaders(5, nil)
 	client.On("BlockHeadersByRange", mock.MatchedBy(bigIntMatcher(0)), mock.MatchedBy(bigIntMatcher(4))).Return(headers, nil)
 	headers, err := headerTraversal.NextFinalizedHeaders(5)
-	assert.NoError(t, err)
-	assert.Len(t, headers, 5)
+	require.NoError(t, err)
+	require.Len(t, headers, 5)
 
 	// clamped by the supplied size. FinalizedHeight == 100
 	headers = makeHeaders(10, headers[len(headers)-1])
 	client.On("BlockHeadersByRange", mock.MatchedBy(bigIntMatcher(5)), mock.MatchedBy(bigIntMatcher(14))).Return(headers, nil)
 	headers, err = headerTraversal.NextFinalizedHeaders(10)
-	assert.NoError(t, err)
-	assert.Len(t, headers, 10)
+	require.NoError(t, err)
+	require.Len(t, headers, 10)
 }
 
 func TestHeaderTraversalMismatchedProviderStateError(t *testing.T) {
@@ -105,14 +105,14 @@ func TestHeaderTraversalMismatchedProviderStateError(t *testing.T) {
 	client.On("FinalizedBlockHeight").Return(big.NewInt(4), nil).Times(1) // Times so that we can override next
 	client.On("BlockHeadersByRange", mock.MatchedBy(bigIntMatcher(0)), mock.MatchedBy(bigIntMatcher(4))).Return(headers, nil)
 	headers, err := headerTraversal.NextFinalizedHeaders(5)
-	assert.NoError(t, err)
-	assert.Len(t, headers, 5)
+	require.NoError(t, err)
+	require.Len(t, headers, 5)
 
 	// blocks [5..9]. Next batch is not chained correctly (starts again from genesis)
 	headers = makeHeaders(5, nil)
 	client.On("FinalizedBlockHeight").Return(big.NewInt(9), nil)
 	client.On("BlockHeadersByRange", mock.MatchedBy(bigIntMatcher(5)), mock.MatchedBy(bigIntMatcher(9))).Return(headers, nil)
 	headers, err = headerTraversal.NextFinalizedHeaders(5)
-	assert.Nil(t, headers)
-	assert.Equal(t, ErrHeaderTraversalAndProviderMismatchedState, err)
+	require.Nil(t, headers)
+	require.Equal(t, ErrHeaderTraversalAndProviderMismatchedState, err)
 }