From e3513f572e7714eaf23fa188bd54b09bd9652599 Mon Sep 17 00:00:00 2001
From: "M. J. Fromberger" <fromberger@interchain.io>
Date: Mon, 30 Aug 2021 12:19:56 -0700
Subject: [PATCH] Move order-dependent tests into subtests.

This test relies on block indexing to happen before event indexing.  That
worked, because the test harness executes test functions by default in the
order they are written in the file. However, that's not necessarily obvious to
the reader, and hides the intent.

To fix that, move these two tests into subtest functions. This does not change
the behaviour, but makes the ordering constraint more obvious.
---
 state/indexer/sink/psql/psql_test.go | 86 ++++++++++++++--------------
 1 file changed, 44 insertions(+), 42 deletions(-)

diff --git a/state/indexer/sink/psql/psql_test.go b/state/indexer/sink/psql/psql_test.go
index 1c477aba1..49cc81f90 100644
--- a/state/indexer/sink/psql/psql_test.go
+++ b/state/indexer/sink/psql/psql_test.go
@@ -140,58 +140,60 @@ func TestType(t *testing.T) {
 	assert.Equal(t, indexer.PSQL, psqlSink.Type())
 }
 
-func TestBlockFuncs(t *testing.T) {
-	indexer := &EventSink{store: testDB(), chainID: chainID}
-	require.NoError(t, indexer.IndexBlockEvents(newTestBlockHeader()))
+func TestIndexing(t *testing.T) {
+	t.Run("IndexBlockEvents", func(t *testing.T) {
+		indexer := &EventSink{store: testDB(), chainID: chainID}
+		require.NoError(t, indexer.IndexBlockEvents(newTestBlockHeader()))
 
-	verifyBlock(t, 1)
-	verifyBlock(t, 2)
+		verifyBlock(t, 1)
+		verifyBlock(t, 2)
 
-	verifyNotImplemented(t, "hasBlock", func() (bool, error) { return indexer.HasBlock(1) })
-	verifyNotImplemented(t, "hasBlock", func() (bool, error) { return indexer.HasBlock(2) })
+		verifyNotImplemented(t, "hasBlock", func() (bool, error) { return indexer.HasBlock(1) })
+		verifyNotImplemented(t, "hasBlock", func() (bool, error) { return indexer.HasBlock(2) })
 
-	verifyNotImplemented(t, "block search", func() (bool, error) {
-		v, err := indexer.SearchBlockEvents(context.Background(), nil)
-		return v != nil, err
+		verifyNotImplemented(t, "block search", func() (bool, error) {
+			v, err := indexer.SearchBlockEvents(context.Background(), nil)
+			return v != nil, err
+		})
+
+		require.NoError(t, verifyTimeStamp(tableBlocks))
+
+		// Attempting to reindex the same events should gracefully succeed.
+		require.NoError(t, indexer.IndexBlockEvents(newTestBlockHeader()))
 	})
 
-	require.NoError(t, verifyTimeStamp(tableBlocks))
+	t.Run("IndexTxEvents", func(t *testing.T) {
+		indexer := &EventSink{store: testDB(), chainID: chainID}
 
-	// Attempting to reindex the same events should gracefully succeed.
-	require.NoError(t, indexer.IndexBlockEvents(newTestBlockHeader()))
-}
+		txResult := txResultWithEvents([]abci.Event{
+			makeIndexedEvent("account.number", "1"),
+			makeIndexedEvent("account.owner", "Ivan"),
+			makeIndexedEvent("account.owner", "Yulieta"),
 
-func TestTxFuncs(t *testing.T) {
-	indexer := &EventSink{store: testDB(), chainID: chainID}
+			{Type: "", Attributes: []abci.EventAttribute{{Key: "not_allowed", Value: "Vlad", Index: true}}},
+		})
+		require.NoError(t, indexer.IndexTxEvents([]*abci.TxResult{txResult}))
 
-	txResult := txResultWithEvents([]abci.Event{
-		makeIndexedEvent("account.number", "1"),
-		makeIndexedEvent("account.owner", "Ivan"),
-		makeIndexedEvent("account.owner", "Yulieta"),
+		txr, err := loadTxResult(types.Tx(txResult.Tx).Hash())
+		require.NoError(t, err)
+		assert.Equal(t, txResult, txr)
 
-		{Type: "", Attributes: []abci.EventAttribute{{Key: "not_allowed", Value: "Vlad", Index: true}}},
+		require.NoError(t, verifyTimeStamp(tableTxResults))
+		require.NoError(t, verifyTimeStamp(viewTxEvents))
+
+		verifyNotImplemented(t, "getTxByHash", func() (bool, error) {
+			txr, err := indexer.GetTxByHash(types.Tx(txResult.Tx).Hash())
+			return txr != nil, err
+		})
+		verifyNotImplemented(t, "tx search", func() (bool, error) {
+			txr, err := indexer.SearchTxEvents(context.Background(), nil)
+			return txr != nil, err
+		})
+
+		// try to insert the duplicate tx events.
+		err = indexer.IndexTxEvents([]*abci.TxResult{txResult})
+		require.NoError(t, err)
 	})
-	require.NoError(t, indexer.IndexTxEvents([]*abci.TxResult{txResult}))
-
-	txr, err := loadTxResult(types.Tx(txResult.Tx).Hash())
-	require.NoError(t, err)
-	assert.Equal(t, txResult, txr)
-
-	require.NoError(t, verifyTimeStamp(tableTxResults))
-	require.NoError(t, verifyTimeStamp(viewTxEvents))
-
-	verifyNotImplemented(t, "getTxByHash", func() (bool, error) {
-		txr, err := indexer.GetTxByHash(types.Tx(txResult.Tx).Hash())
-		return txr != nil, err
-	})
-	verifyNotImplemented(t, "tx search", func() (bool, error) {
-		txr, err := indexer.SearchTxEvents(context.Background(), nil)
-		return txr != nil, err
-	})
-
-	// try to insert the duplicate tx events.
-	err = indexer.IndexTxEvents([]*abci.TxResult{txResult})
-	require.NoError(t, err)
 }
 
 func TestStop(t *testing.T) {