diff --git a/statediff/indexer/indexer_test.go b/statediff/indexer/indexer_test.go
index ddcb7c5c9..1a7c76763 100644
--- a/statediff/indexer/indexer_test.go
+++ b/statediff/indexer/indexer_test.go
@@ -24,8 +24,6 @@ import (
 	"github.com/ipfs/go-cid"
 	"github.com/ipfs/go-ipfs-blockstore"
 	"github.com/ipfs/go-ipfs-ds-help"
-	. "github.com/onsi/ginkgo"
-	. "github.com/onsi/gomega"
 
 	ind "github.com/ethereum/go-ethereum/statediff/indexer"
 	"github.com/ethereum/go-ethereum/statediff/indexer/mocks"
@@ -34,211 +32,261 @@ import (
 	"github.com/ethereum/go-ethereum/statediff/indexer/shared"
 )
 
-func TestShared(t *testing.T) {
-	RegisterFailHandler(Fail)
-	RunSpecs(t, "Indexer tests")
+var (
+	db        *postgres.DB
+	err       error
+	indexer   *ind.StateDiffIndexer
+	ipfsPgGet = `SELECT data FROM public.blocks
+					WHERE key = $1`
+)
+
+func expectTrue(t *testing.T, value bool) {
+	if !value {
+		t.Fatalf("Assertion failed")
+	}
 }
 
-var _ = Describe("PublishAndIndexer", func() {
-	var (
-		db        *postgres.DB
-		err       error
-		indexer   *ind.StateDiffIndexer
-		ipfsPgGet = `SELECT data FROM public.blocks
-					WHERE key = $1`
-	)
-	BeforeEach(func() {
-		db, err = shared.SetupDB()
-		Expect(err).ToNot(HaveOccurred())
-		indexer = ind.NewStateDiffIndexer(params.MainnetChainConfig, db)
-		var tx *ind.BlockTx
-		tx, err = indexer.PushBlock(
-			mocks.MockBlock,
-			mocks.MockReceipts,
-			mocks.MockBlock.Difficulty())
-		Expect(err).ToNot(HaveOccurred())
-		defer tx.Close()
-		for _, node := range mocks.StateDiffs {
-			err = indexer.PushStateNode(tx, node)
-			Expect(err).ToNot(HaveOccurred())
+func setup(t *testing.T) {
+	db, err = shared.SetupDB()
+	if err != nil {
+		t.Fatal(err)
+	}
+	indexer = ind.NewStateDiffIndexer(params.MainnetChainConfig, db)
+	var tx *ind.BlockTx
+	tx, err = indexer.PushBlock(
+		mocks.MockBlock,
+		mocks.MockReceipts,
+		mocks.MockBlock.Difficulty())
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer tx.Close()
+	for _, node := range mocks.StateDiffs {
+		err = indexer.PushStateNode(tx, node)
+		if err != nil {
+			t.Fatal(err)
 		}
-		Expect(tx.BlockNumber).To(Equal(mocks.BlockNumber.Uint64()))
-	})
-	AfterEach(func() {
-		ind.TearDownDB(db)
-	})
+	}
 
-	Describe("Publish", func() {
-		It("Publishes and indexes header IPLDs in a single tx", func() {
-			pgStr := `SELECT cid, td, reward, id
+	shared.ExpectEqual(t, tx.BlockNumber, mocks.BlockNumber.Uint64())
+}
+
+func tearDown(t *testing.T) {
+	ind.TearDownDB(t, db)
+}
+
+func TestPublishAndIndexer(t *testing.T) {
+	t.Run("Publish and index header IPLDs in a single tx", func(t *testing.T) {
+		setup(t)
+		defer tearDown(t)
+		pgStr := `SELECT cid, td, reward, id
 				FROM eth.header_cids
 				WHERE block_number = $1`
-			// check header was properly indexed
-			type res struct {
-				CID    string
-				TD     string
-				Reward string
-				ID     int
+		// check header was properly indexed
+		type res struct {
+			CID    string
+			TD     string
+			Reward string
+			ID     int
+		}
+		header := new(res)
+		err = db.QueryRowx(pgStr, 1).StructScan(header)
+		if err != nil {
+			t.Fatal(err)
+		}
+		shared.ExpectEqual(t, header.CID, mocks.HeaderCID.String())
+		shared.ExpectEqual(t, header.TD, mocks.MockBlock.Difficulty().String())
+		shared.ExpectEqual(t, header.Reward, "5000000000000011250")
+		dc, err := cid.Decode(header.CID)
+		if err != nil {
+			t.Fatal(err)
+		}
+		mhKey := dshelp.MultihashToDsKey(dc.Hash())
+		prefixedKey := blockstore.BlockPrefix.String() + mhKey.String()
+		var data []byte
+		err = db.Get(&data, ipfsPgGet, prefixedKey)
+		if err != nil {
+			t.Fatal(err)
+		}
+		shared.ExpectEqual(t, data, mocks.MockHeaderRlp)
+	})
+
+	t.Run("Publish and index transaction IPLDs in a single tx", func(t *testing.T) {
+		setup(t)
+		defer tearDown(t)
+		// check that txs were properly indexed
+		trxs := make([]string, 0)
+		pgStr := `SELECT transaction_cids.cid FROM eth.transaction_cids INNER JOIN eth.header_cids ON (transaction_cids.header_id = header_cids.id)
+				WHERE header_cids.block_number = $1`
+		err = db.Select(&trxs, pgStr, 1)
+		if err != nil {
+			t.Fatal(err)
+		}
+		shared.ExpectEqual(t, len(trxs), 3)
+		expectTrue(t, shared.ListContainsString(trxs, mocks.Trx1CID.String()))
+		expectTrue(t, shared.ListContainsString(trxs, mocks.Trx2CID.String()))
+		expectTrue(t, shared.ListContainsString(trxs, mocks.Trx3CID.String()))
+		// and published
+		for _, c := range trxs {
+			dc, err := cid.Decode(c)
+			if err != nil {
+				t.Fatal(err)
 			}
-			header := new(res)
-			err = db.QueryRowx(pgStr, 1).StructScan(header)
-			Expect(err).ToNot(HaveOccurred())
-			Expect(header.CID).To(Equal(mocks.HeaderCID.String()))
-			Expect(header.TD).To(Equal(mocks.MockBlock.Difficulty().String()))
-			Expect(header.Reward).To(Equal("5000000000000011250"))
-			dc, err := cid.Decode(header.CID)
-			Expect(err).ToNot(HaveOccurred())
 			mhKey := dshelp.MultihashToDsKey(dc.Hash())
 			prefixedKey := blockstore.BlockPrefix.String() + mhKey.String()
 			var data []byte
 			err = db.Get(&data, ipfsPgGet, prefixedKey)
-			Expect(err).ToNot(HaveOccurred())
-			Expect(data).To(Equal(mocks.MockHeaderRlp))
-		})
-
-		It("Publishes and indexes transaction IPLDs in a single tx", func() {
-			// check that txs were properly indexed
-			trxs := make([]string, 0)
-			pgStr := `SELECT transaction_cids.cid FROM eth.transaction_cids INNER JOIN eth.header_cids ON (transaction_cids.header_id = header_cids.id)
-				WHERE header_cids.block_number = $1`
-			err = db.Select(&trxs, pgStr, 1)
-			Expect(err).ToNot(HaveOccurred())
-			Expect(len(trxs)).To(Equal(3))
-			Expect(shared.ListContainsString(trxs, mocks.Trx1CID.String())).To(BeTrue())
-			Expect(shared.ListContainsString(trxs, mocks.Trx2CID.String())).To(BeTrue())
-			Expect(shared.ListContainsString(trxs, mocks.Trx3CID.String())).To(BeTrue())
-			// and published
-			for _, c := range trxs {
-				dc, err := cid.Decode(c)
-				Expect(err).ToNot(HaveOccurred())
-				mhKey := dshelp.MultihashToDsKey(dc.Hash())
-				prefixedKey := blockstore.BlockPrefix.String() + mhKey.String()
-				var data []byte
-				err = db.Get(&data, ipfsPgGet, prefixedKey)
-				Expect(err).ToNot(HaveOccurred())
-				switch c {
-				case mocks.Trx1CID.String():
-					Expect(data).To(Equal(mocks.MockTransactions.GetRlp(0)))
-				case mocks.Trx2CID.String():
-					Expect(data).To(Equal(mocks.MockTransactions.GetRlp(1)))
-				case mocks.Trx3CID.String():
-					Expect(data).To(Equal(mocks.MockTransactions.GetRlp(2)))
-				}
+			if err != nil {
+				t.Fatal(err)
 			}
-		})
+			switch c {
+			case mocks.Trx1CID.String():
+				shared.ExpectEqual(t, data, mocks.MockTransactions.GetRlp(0))
+			case mocks.Trx2CID.String():
+				shared.ExpectEqual(t, data, mocks.MockTransactions.GetRlp(1))
+			case mocks.Trx3CID.String():
+				shared.ExpectEqual(t, data, mocks.MockTransactions.GetRlp(2))
+			}
+		}
+	})
 
-		It("Publishes and indexes receipt IPLDs in a single tx", func() {
-			// check receipts were properly indexed
-			rcts := make([]string, 0)
-			pgStr := `SELECT receipt_cids.cid FROM eth.receipt_cids, eth.transaction_cids, eth.header_cids
+	t.Run("Publish and index receipt IPLDs in a single tx", func(t *testing.T) {
+		setup(t)
+		defer tearDown(t)
+		// check receipts were properly indexed
+		rcts := make([]string, 0)
+		pgStr := `SELECT receipt_cids.cid FROM eth.receipt_cids, eth.transaction_cids, eth.header_cids
 				WHERE receipt_cids.tx_id = transaction_cids.id
 				AND transaction_cids.header_id = header_cids.id
 				AND header_cids.block_number = $1`
-			err = db.Select(&rcts, pgStr, 1)
-			Expect(err).ToNot(HaveOccurred())
-			Expect(len(rcts)).To(Equal(3))
-			Expect(shared.ListContainsString(rcts, mocks.Rct1CID.String())).To(BeTrue())
-			Expect(shared.ListContainsString(rcts, mocks.Rct2CID.String())).To(BeTrue())
-			Expect(shared.ListContainsString(rcts, mocks.Rct3CID.String())).To(BeTrue())
-			// and published
-			for _, c := range rcts {
-				dc, err := cid.Decode(c)
-				Expect(err).ToNot(HaveOccurred())
-				mhKey := dshelp.MultihashToDsKey(dc.Hash())
-				prefixedKey := blockstore.BlockPrefix.String() + mhKey.String()
-				var data []byte
-				err = db.Get(&data, ipfsPgGet, prefixedKey)
-				Expect(err).ToNot(HaveOccurred())
-				switch c {
-				case mocks.Rct1CID.String():
-					Expect(data).To(Equal(mocks.MockReceipts.GetRlp(0)))
-				case mocks.Rct2CID.String():
-					Expect(data).To(Equal(mocks.MockReceipts.GetRlp(1)))
-				case mocks.Rct3CID.String():
-					Expect(data).To(Equal(mocks.MockReceipts.GetRlp(2)))
-				}
+		err = db.Select(&rcts, pgStr, 1)
+		if err != nil {
+			t.Fatal(err)
+		}
+		shared.ExpectEqual(t, len(rcts), 3)
+		expectTrue(t, shared.ListContainsString(rcts, mocks.Rct1CID.String()))
+		expectTrue(t, shared.ListContainsString(rcts, mocks.Rct2CID.String()))
+		expectTrue(t, shared.ListContainsString(rcts, mocks.Rct3CID.String()))
+		// and published
+		for _, c := range rcts {
+			dc, err := cid.Decode(c)
+			if err != nil {
+				t.Fatal(err)
 			}
-		})
+			mhKey := dshelp.MultihashToDsKey(dc.Hash())
+			prefixedKey := blockstore.BlockPrefix.String() + mhKey.String()
+			var data []byte
+			err = db.Get(&data, ipfsPgGet, prefixedKey)
+			if err != nil {
+				t.Fatal(err)
+			}
+			switch c {
+			case mocks.Rct1CID.String():
+				shared.ExpectEqual(t, data, mocks.MockReceipts.GetRlp(0))
+			case mocks.Rct2CID.String():
+				shared.ExpectEqual(t, data, mocks.MockReceipts.GetRlp(1))
+			case mocks.Rct3CID.String():
+				shared.ExpectEqual(t, data, mocks.MockReceipts.GetRlp(2))
+			}
+		}
+	})
 
-		It("Publishes and indexes state IPLDs in a single tx", func() {
-			// check that state nodes were properly indexed and published
-			stateNodes := make([]eth.StateNodeModel, 0)
-			pgStr := `SELECT state_cids.id, state_cids.cid, state_cids.state_leaf_key, state_cids.node_type, state_cids.state_path, state_cids.header_id
+	t.Run("Publish and index state IPLDs in a single tx", func(t *testing.T) {
+		setup(t)
+		defer tearDown(t)
+		// check that state nodes were properly indexed and published
+		stateNodes := make([]eth.StateNodeModel, 0)
+		pgStr := `SELECT state_cids.id, state_cids.cid, state_cids.state_leaf_key, state_cids.node_type, state_cids.state_path, state_cids.header_id
 				FROM eth.state_cids INNER JOIN eth.header_cids ON (state_cids.header_id = header_cids.id)
 				WHERE header_cids.block_number = $1`
-			err = db.Select(&stateNodes, pgStr, 1)
-			Expect(err).ToNot(HaveOccurred())
-			Expect(len(stateNodes)).To(Equal(2))
-			for _, stateNode := range stateNodes {
-				var data []byte
-				dc, err := cid.Decode(stateNode.CID)
-				Expect(err).ToNot(HaveOccurred())
-				mhKey := dshelp.MultihashToDsKey(dc.Hash())
-				prefixedKey := blockstore.BlockPrefix.String() + mhKey.String()
-				err = db.Get(&data, ipfsPgGet, prefixedKey)
-				Expect(err).ToNot(HaveOccurred())
-				pgStr = `SELECT * from eth.state_accounts WHERE state_id = $1`
-				var account eth.StateAccountModel
-				err = db.Get(&account, pgStr, stateNode.ID)
-				Expect(err).ToNot(HaveOccurred())
-				if stateNode.CID == mocks.State1CID.String() {
-					Expect(stateNode.NodeType).To(Equal(2))
-					Expect(stateNode.StateKey).To(Equal(common.BytesToHash(mocks.ContractLeafKey).Hex()))
-					Expect(stateNode.Path).To(Equal([]byte{'\x06'}))
-					Expect(data).To(Equal(mocks.ContractLeafNode))
-					Expect(account).To(Equal(eth.StateAccountModel{
-						ID:          account.ID,
-						StateID:     stateNode.ID,
-						Balance:     "0",
-						CodeHash:    mocks.ContractCodeHash.Bytes(),
-						StorageRoot: mocks.ContractRoot,
-						Nonce:       1,
-					}))
-				}
-				if stateNode.CID == mocks.State2CID.String() {
-					Expect(stateNode.NodeType).To(Equal(2))
-					Expect(stateNode.StateKey).To(Equal(common.BytesToHash(mocks.AccountLeafKey).Hex()))
-					Expect(stateNode.Path).To(Equal([]byte{'\x0c'}))
-					Expect(data).To(Equal(mocks.AccountLeafNode))
-					Expect(account).To(Equal(eth.StateAccountModel{
-						ID:          account.ID,
-						StateID:     stateNode.ID,
-						Balance:     "1000",
-						CodeHash:    mocks.AccountCodeHash.Bytes(),
-						StorageRoot: mocks.AccountRoot,
-						Nonce:       0,
-					}))
-				}
+		err = db.Select(&stateNodes, pgStr, 1)
+		if err != nil {
+			t.Fatal(err)
+		}
+		shared.ExpectEqual(t, len(stateNodes), 2)
+		for _, stateNode := range stateNodes {
+			var data []byte
+			dc, err := cid.Decode(stateNode.CID)
+			if err != nil {
+				t.Fatal(err)
+			}
+			mhKey := dshelp.MultihashToDsKey(dc.Hash())
+			prefixedKey := blockstore.BlockPrefix.String() + mhKey.String()
+			err = db.Get(&data, ipfsPgGet, prefixedKey)
+			if err != nil {
+				t.Fatal(err)
 			}
 			pgStr = `SELECT * from eth.state_accounts WHERE state_id = $1`
-		})
+			var account eth.StateAccountModel
+			err = db.Get(&account, pgStr, stateNode.ID)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if stateNode.CID == mocks.State1CID.String() {
+				shared.ExpectEqual(t, stateNode.NodeType, 2)
+				shared.ExpectEqual(t, stateNode.StateKey, common.BytesToHash(mocks.ContractLeafKey).Hex())
+				shared.ExpectEqual(t, stateNode.Path, []byte{'\x06'})
+				shared.ExpectEqual(t, data, mocks.ContractLeafNode)
+				shared.ExpectEqual(t, account, eth.StateAccountModel{
+					ID:          account.ID,
+					StateID:     stateNode.ID,
+					Balance:     "0",
+					CodeHash:    mocks.ContractCodeHash.Bytes(),
+					StorageRoot: mocks.ContractRoot,
+					Nonce:       1,
+				})
+			}
+			if stateNode.CID == mocks.State2CID.String() {
+				shared.ExpectEqual(t, stateNode.NodeType, 2)
+				shared.ExpectEqual(t, stateNode.StateKey, common.BytesToHash(mocks.AccountLeafKey).Hex())
+				shared.ExpectEqual(t, stateNode.Path, []byte{'\x0c'})
+				shared.ExpectEqual(t, data, mocks.AccountLeafNode)
+				shared.ExpectEqual(t, account, eth.StateAccountModel{
+					ID:          account.ID,
+					StateID:     stateNode.ID,
+					Balance:     "1000",
+					CodeHash:    mocks.AccountCodeHash.Bytes(),
+					StorageRoot: mocks.AccountRoot,
+					Nonce:       0,
+				})
+			}
+		}
+		pgStr = `SELECT * from eth.state_accounts WHERE state_id = $1`
+	})
 
-		It("Publishes and indexes storage IPLDs in a single tx", func() {
-			// check that storage nodes were properly indexed
-			storageNodes := make([]eth.StorageNodeWithStateKeyModel, 0)
-			pgStr := `SELECT storage_cids.cid, state_cids.state_leaf_key, storage_cids.storage_leaf_key, storage_cids.node_type, storage_cids.storage_path
+	t.Run("Publish and index storage IPLDs in a single tx", func(t *testing.T) {
+		setup(t)
+		defer tearDown(t)
+		// check that storage nodes were properly indexed
+		storageNodes := make([]eth.StorageNodeWithStateKeyModel, 0)
+		pgStr := `SELECT storage_cids.cid, state_cids.state_leaf_key, storage_cids.storage_leaf_key, storage_cids.node_type, storage_cids.storage_path
 				FROM eth.storage_cids, eth.state_cids, eth.header_cids
 				WHERE storage_cids.state_id = state_cids.id
 				AND state_cids.header_id = header_cids.id
 				AND header_cids.block_number = $1`
-			err = db.Select(&storageNodes, pgStr, 1)
-			Expect(err).ToNot(HaveOccurred())
-			Expect(len(storageNodes)).To(Equal(1))
-			Expect(storageNodes[0]).To(Equal(eth.StorageNodeWithStateKeyModel{
-				CID:        mocks.StorageCID.String(),
-				NodeType:   2,
-				StorageKey: common.BytesToHash(mocks.StorageLeafKey).Hex(),
-				StateKey:   common.BytesToHash(mocks.ContractLeafKey).Hex(),
-				Path:       []byte{},
-			}))
-			var data []byte
-			dc, err := cid.Decode(storageNodes[0].CID)
-			Expect(err).ToNot(HaveOccurred())
-			mhKey := dshelp.MultihashToDsKey(dc.Hash())
-			prefixedKey := blockstore.BlockPrefix.String() + mhKey.String()
-			err = db.Get(&data, ipfsPgGet, prefixedKey)
-			Expect(err).ToNot(HaveOccurred())
-			Expect(data).To(Equal(mocks.StorageLeafNode))
+		err = db.Select(&storageNodes, pgStr, 1)
+		if err != nil {
+			t.Fatal(err)
+		}
+		shared.ExpectEqual(t, len(storageNodes), 1)
+		shared.ExpectEqual(t, storageNodes[0], eth.StorageNodeWithStateKeyModel{
+			CID:        mocks.StorageCID.String(),
+			NodeType:   2,
+			StorageKey: common.BytesToHash(mocks.StorageLeafKey).Hex(),
+			StateKey:   common.BytesToHash(mocks.ContractLeafKey).Hex(),
+			Path:       []byte{},
 		})
+		var data []byte
+		dc, err := cid.Decode(storageNodes[0].CID)
+		if err != nil {
+			t.Fatal(err)
+		}
+		mhKey := dshelp.MultihashToDsKey(dc.Hash())
+		prefixedKey := blockstore.BlockPrefix.String() + mhKey.String()
+		err = db.Get(&data, ipfsPgGet, prefixedKey)
+		if err != nil {
+			t.Fatal(err)
+		}
+		shared.ExpectEqual(t, data, mocks.StorageLeafNode)
 	})
-})
+}
diff --git a/statediff/indexer/postgres/postgres_suite_test.go b/statediff/indexer/postgres/postgres_suite_test.go
index 740dd4d30..e11e9ea77 100644
--- a/statediff/indexer/postgres/postgres_suite_test.go
+++ b/statediff/indexer/postgres/postgres_suite_test.go
@@ -17,20 +17,9 @@
 package postgres_test
 
 import (
-	"io/ioutil"
-	"testing"
-
 	"github.com/ethereum/go-ethereum/log"
-
-	. "github.com/onsi/ginkgo"
-	. "github.com/onsi/gomega"
 )
 
 func init() {
 	log.Root().SetHandler(log.DiscardHandler())
 }
-
-func TestPostgres(t *testing.T) {
-	RegisterFailHandler(Fail)
-	RunSpecs(t, "Postgres Suite")
-}
diff --git a/statediff/indexer/postgres/postgres_test.go b/statediff/indexer/postgres/postgres_test.go
index fd4e01464..f86055352 100644
--- a/statediff/indexer/postgres/postgres_test.go
+++ b/statediff/indexer/postgres/postgres_test.go
@@ -19,34 +19,44 @@ package postgres_test
 import (
 	"fmt"
 	"strings"
+	"testing"
 
 	"math/big"
 
 	"github.com/jmoiron/sqlx"
 	_ "github.com/lib/pq"
-	. "github.com/onsi/ginkgo"
-	. "github.com/onsi/gomega"
 
-	"github.com/ethereum/go-ethereum/statediff/node"
-	"github.com/ethereum/go-ethereum/statediff/postgres"
+	"github.com/ethereum/go-ethereum/statediff/indexer/node"
+	"github.com/ethereum/go-ethereum/statediff/indexer/postgres"
+	"github.com/ethereum/go-ethereum/statediff/indexer/shared"
 )
 
-var DBConfig postgres.Config
+var DBParams postgres.ConnectionParams
 
-var _ = Describe("Postgres DB", func() {
+func expectContainsSubstring(t *testing.T, full string, sub string) {
+	if !strings.Contains(full, sub) {
+		t.Fatalf("Expected \"%v\" to contain substring \"%v\"\n", full, sub)
+	}
+}
+
+func TestPostgresDB(t *testing.T) {
 	var sqlxdb *sqlx.DB
 
-	It("connects to the database", func() {
+	t.Run("connects to the database", func(t *testing.T) {
 		var err error
-		pgConfig := postgres.DbConnectionString(DBConfig)
+		pgConfig := postgres.DbConnectionString(DBParams)
 
 		sqlxdb, err = sqlx.Connect("postgres", pgConfig)
 
-		Expect(err).Should(BeNil())
-		Expect(sqlxdb).ShouldNot(BeNil())
+		if err != nil {
+			t.Fatal(err)
+		}
+		if sqlxdb == nil {
+			t.Fatal("DB is nil")
+		}
 	})
 
-	It("serializes big.Int to db", func() {
+	t.Run("serializes big.Int to db", func(t *testing.T) {
 		// postgres driver doesn't support go big.Int type
 		// various casts in golang uint64, int64, overflow for
 		// transaction value (in wei) even though
@@ -54,51 +64,68 @@ var _ = Describe("Postgres DB", func() {
 		// sized int, so use string representation of big.Int
 		// and cast on insert
 
-		pgConnectString := postgres.DbConnectionString(DBConfig)
+		pgConnectString := postgres.DbConnectionString(DBParams)
 		db, err := sqlx.Connect("postgres", pgConnectString)
-		Expect(err).NotTo(HaveOccurred())
+		if err != nil {
+			t.Fatal(err)
+		}
+		if err != nil {
+			t.Fatal(err)
+		}
 
 		bi := new(big.Int)
 		bi.SetString("34940183920000000000", 10)
-		Expect(bi.String()).To(Equal("34940183920000000000"))
+		shared.ExpectEqual(t, bi.String(), "34940183920000000000")
 
 		defer db.Exec(`DROP TABLE IF EXISTS example`)
 		_, err = db.Exec("CREATE TABLE example ( id INTEGER, data NUMERIC )")
-		Expect(err).ToNot(HaveOccurred())
+		if err != nil {
+			t.Fatal(err)
+		}
 
 		sqlStatement := `  
 			INSERT INTO example (id, data)
 			VALUES (1, cast($1 AS NUMERIC))`
 		_, err = db.Exec(sqlStatement, bi.String())
-		Expect(err).ToNot(HaveOccurred())
+		if err != nil {
+			t.Fatal(err)
+		}
 
 		var data string
 		err = db.QueryRow(`SELECT data FROM example WHERE id = 1`).Scan(&data)
-		Expect(err).ToNot(HaveOccurred())
+		if err != nil {
+			t.Fatal(err)
+		}
 
-		Expect(bi.String()).To(Equal(data))
+		shared.ExpectEqual(t, bi.String(), data)
 		actual := new(big.Int)
 		actual.SetString(data, 10)
-		Expect(actual).To(Equal(bi))
+		shared.ExpectEqual(t, actual, bi)
 	})
 
-	It("throws error when can't connect to the database", func() {
-		invalidDatabase := postgres.Config{}
+	t.Run("throws error when can't connect to the database", func(t *testing.T) {
+		invalidDatabase := postgres.ConnectionParams{}
 		node := node.Info{GenesisBlock: "GENESIS", NetworkID: "1", ID: "x123", ClientName: "geth"}
 
-		_, err := postgres.NewDB(invalidDatabase, node)
+		_, err := postgres.NewDB(postgres.DbConnectionString(invalidDatabase),
+			postgres.ConnectionConfig{}, node)
 
-		Expect(err).To(HaveOccurred())
-		Expect(err.Error()).To(ContainSubstring(postgres.DbConnectionFailedMsg))
+		if err == nil {
+			t.Fatal("Expected an error")
+		}
+
+		expectContainsSubstring(t, err.Error(), postgres.DbConnectionFailedMsg)
 	})
 
-	It("throws error when can't create node", func() {
+	t.Run("throws error when can't create node", func(t *testing.T) {
 		badHash := fmt.Sprintf("x %s", strings.Repeat("1", 100))
 		node := node.Info{GenesisBlock: badHash, NetworkID: "1", ID: "x123", ClientName: "geth"}
 
-		_, err := postgres.NewDB(DBConfig, node)
+		_, err := postgres.NewDB(postgres.DbConnectionString(DBParams), postgres.ConnectionConfig{}, node)
 
-		Expect(err).To(HaveOccurred())
-		Expect(err.Error()).To(ContainSubstring(postgres.SettingNodeFailedMsg))
+		if err == nil {
+			t.Fatal("Expected an error")
+		}
+		expectContainsSubstring(t, err.Error(), postgres.SettingNodeFailedMsg)
 	})
-})
+}
diff --git a/statediff/indexer/shared/test_helpers.go b/statediff/indexer/shared/test_helpers.go
index e83bbc59a..17ccda02a 100644
--- a/statediff/indexer/shared/test_helpers.go
+++ b/statediff/indexer/shared/test_helpers.go
@@ -17,6 +17,9 @@
 package shared
 
 import (
+	"reflect"
+	"testing"
+
 	"github.com/ipfs/go-cid"
 	"github.com/multiformats/go-multihash"
 
@@ -24,6 +27,12 @@ import (
 	"github.com/ethereum/go-ethereum/statediff/indexer/postgres"
 )
 
+func ExpectEqual(t *testing.T, got interface{}, want interface{}) {
+	if !reflect.DeepEqual(got, want) {
+		t.Fatalf("Expected: %v\nActual: %v", want, got)
+	}
+}
+
 // SetupDB is use to setup a db for watcher tests
 func SetupDB() (*postgres.DB, error) {
 	uri := postgres.DbConnectionString(postgres.ConnectionParams{
diff --git a/statediff/indexer/test_helpers.go b/statediff/indexer/test_helpers.go
index 7a93e8e35..b1ee173db 100644
--- a/statediff/indexer/test_helpers.go
+++ b/statediff/indexer/test_helpers.go
@@ -17,32 +17,47 @@
 package indexer
 
 import (
-	. "github.com/onsi/gomega"
+	"testing"
 
 	"github.com/ethereum/go-ethereum/statediff/indexer/models"
 	"github.com/ethereum/go-ethereum/statediff/indexer/postgres"
 )
 
 // TearDownDB is used to tear down the watcher dbs after tests
-func TearDownDB(db *postgres.DB) {
+func TearDownDB(t *testing.T, db *postgres.DB) {
 	tx, err := db.Beginx()
-	Expect(err).NotTo(HaveOccurred())
+	if err != nil {
+		t.Fatal(err)
+	}
 
 	_, err = tx.Exec(`DELETE FROM eth.header_cids`)
-	Expect(err).NotTo(HaveOccurred())
+	if err != nil {
+		t.Fatal(err)
+	}
 	_, err = tx.Exec(`DELETE FROM eth.transaction_cids`)
-	Expect(err).NotTo(HaveOccurred())
+	if err != nil {
+		t.Fatal(err)
+	}
 	_, err = tx.Exec(`DELETE FROM eth.receipt_cids`)
-	Expect(err).NotTo(HaveOccurred())
+	if err != nil {
+		t.Fatal(err)
+	}
 	_, err = tx.Exec(`DELETE FROM eth.state_cids`)
-	Expect(err).NotTo(HaveOccurred())
+	if err != nil {
+		t.Fatal(err)
+	}
 	_, err = tx.Exec(`DELETE FROM eth.storage_cids`)
-	Expect(err).NotTo(HaveOccurred())
+	if err != nil {
+		t.Fatal(err)
+	}
 	_, err = tx.Exec(`DELETE FROM blocks`)
-	Expect(err).NotTo(HaveOccurred())
-
+	if err != nil {
+		t.Fatal(err)
+	}
 	err = tx.Commit()
-	Expect(err).NotTo(HaveOccurred())
+	if err != nil {
+		t.Fatal(err)
+	}
 }
 
 // TxModelsContainsCID used to check if a list of TxModels contains a specific cid string