Extract slow tests from omni full transformer

integration_test/omni_full_transformer.go

@@ -0,0 +1,273 @@
+package integration
+
+import (
+	"fmt"
+	"github.com/ethereum/go-ethereum/common"
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+	"github.com/vulcanize/vulcanizedb/pkg/core"
+	"github.com/vulcanize/vulcanizedb/pkg/datastore/postgres"
+	"github.com/vulcanize/vulcanizedb/pkg/datastore/postgres/repositories"
+	"github.com/vulcanize/vulcanizedb/pkg/omni/full/transformer"
+	"github.com/vulcanize/vulcanizedb/pkg/omni/shared/constants"
+	"github.com/vulcanize/vulcanizedb/pkg/omni/shared/helpers/test_helpers"
+	"github.com/vulcanize/vulcanizedb/pkg/omni/shared/helpers/test_helpers/mocks"
+	"math/rand"
+	"strings"
+	"time"
+)
+
+var _ = Describe("Omni full transformer", func() {
+	var db *postgres.DB
+	var err error
+	var blockChain core.BlockChain
+	var blockRepository repositories.BlockRepository
+	var ensAddr = strings.ToLower(constants.EnsContractAddress)
+	var tusdAddr = strings.ToLower(constants.TusdContractAddress)
+	rand.Seed(time.Now().UnixNano())
+
+	BeforeEach(func() {
+		db, blockChain = test_helpers.SetupDBandBC()
+		blockRepository = *repositories.NewBlockRepository(db)
+	})
+
+	AfterEach(func() {
+		test_helpers.TearDown(db)
+	})
+
+	Describe("Init", func() {
+		It("Initializes transformer's contract objects", func() {
+			blockRepository.CreateOrUpdateBlock(mocks.TransferBlock1)
+			blockRepository.CreateOrUpdateBlock(mocks.TransferBlock2)
+			t := transformer.NewTransformer("", blockChain, db)
+			t.SetEvents(constants.TusdContractAddress, []string{"Transfer"})
+			err = t.Init()
+			Expect(err).ToNot(HaveOccurred())
+
+			c, ok := t.Contracts[tusdAddr]
+			Expect(ok).To(Equal(true))
+
+			Expect(c.StartingBlock).To(Equal(int64(6194633)))
+			Expect(c.LastBlock).To(Equal(int64(6194634)))
+			Expect(c.Abi).To(Equal(constants.TusdAbiString))
+			Expect(c.Name).To(Equal("TrueUSD"))
+			Expect(c.Address).To(Equal(tusdAddr))
+		})
+	})
+
+	Describe("Execute", func() {
+		BeforeEach(func() {
+			blockRepository.CreateOrUpdateBlock(mocks.TransferBlock1)
+			blockRepository.CreateOrUpdateBlock(mocks.TransferBlock2)
+		})
+
+		It("Transforms watched contract data into custom repositories", func() {
+			t := transformer.NewTransformer("", blockChain, db)
+			t.SetEvents(constants.TusdContractAddress, []string{"Transfer"})
+			t.SetMethods(constants.TusdContractAddress, nil)
+			err = t.Init()
+			Expect(err).ToNot(HaveOccurred())
+
+			err = t.Execute()
+			Expect(err).ToNot(HaveOccurred())
+
+			log := test_helpers.TransferLog{}
+			err = db.QueryRowx(fmt.Sprintf("SELECT * FROM full_%s.transfer_event WHERE block = 6194634", tusdAddr)).StructScan(&log)
+
+			// We don't know vulcID, so compare individual fields instead of complete structures
+			Expect(log.Tx).To(Equal("0x135391a0962a63944e5908e6fedfff90fb4be3e3290a21017861099bad654eee"))
+			Expect(log.Block).To(Equal(int64(6194634)))
+			Expect(log.From).To(Equal("0x000000000000000000000000000000000000Af21"))
+			Expect(log.To).To(Equal("0x09BbBBE21a5975cAc061D82f7b843bCE061BA391"))
+			Expect(log.Value).To(Equal("1097077688018008265106216665536940668749033598146"))
+		})
+
+		It("Keeps track of contract-related addresses while transforming event data if they need to be used for later method polling", func() {
+			t := transformer.NewTransformer("", blockChain, db)
+			t.SetEvents(constants.TusdContractAddress, []string{"Transfer"})
+			t.SetMethods(constants.TusdContractAddress, []string{"balanceOf"})
+			err = t.Init()
+			Expect(err).ToNot(HaveOccurred())
+
+			c, ok := t.Contracts[tusdAddr]
+			Expect(ok).To(Equal(true))
+
+			err = t.Execute()
+			Expect(err).ToNot(HaveOccurred())
+
+			b, ok := c.EmittedAddrs[common.HexToAddress("0x000000000000000000000000000000000000Af21")]
+			Expect(ok).To(Equal(true))
+			Expect(b).To(Equal(true))
+
+			b, ok = c.EmittedAddrs[common.HexToAddress("0x09BbBBE21a5975cAc061D82f7b843bCE061BA391")]
+			Expect(ok).To(Equal(true))
+			Expect(b).To(Equal(true))
+
+			_, ok = c.EmittedAddrs[common.HexToAddress("0x09BbBBE21a5975cAc061D82f7b843b1234567890")]
+			Expect(ok).To(Equal(false))
+
+			_, ok = c.EmittedAddrs[common.HexToAddress("0x")]
+			Expect(ok).To(Equal(false))
+
+			_, ok = c.EmittedAddrs[""]
+			Expect(ok).To(Equal(false))
+
+			_, ok = c.EmittedAddrs[common.HexToAddress("0x09THISE21a5IS5cFAKE1D82fAND43bCE06MADEUP")]
+			Expect(ok).To(Equal(false))
+		})
+
+		It("Polls given methods using generated token holder address", func() {
+			t := transformer.NewTransformer("", blockChain, db)
+			t.SetEvents(constants.TusdContractAddress, []string{"Transfer"})
+			t.SetMethods(constants.TusdContractAddress, []string{"balanceOf"})
+			err = t.Init()
+			Expect(err).ToNot(HaveOccurred())
+
+			err = t.Execute()
+			Expect(err).ToNot(HaveOccurred())
+
+			res := test_helpers.BalanceOf{}
+
+			err = db.QueryRowx(fmt.Sprintf("SELECT * FROM full_%s.balanceof_method WHERE who_ = '0x000000000000000000000000000000000000Af21' AND block = '6194634'", tusdAddr)).StructScan(&res)
+			Expect(err).ToNot(HaveOccurred())
+			Expect(res.Balance).To(Equal("0"))
+			Expect(res.TokenName).To(Equal("TrueUSD"))
+
+			err = db.QueryRowx(fmt.Sprintf("SELECT * FROM full_%s.balanceof_method WHERE who_ = '0x09BbBBE21a5975cAc061D82f7b843bCE061BA391' AND block = '6194634'", tusdAddr)).StructScan(&res)
+			Expect(err).ToNot(HaveOccurred())
+			Expect(res.Balance).To(Equal("0"))
+			Expect(res.TokenName).To(Equal("TrueUSD"))
+
+			err = db.QueryRowx(fmt.Sprintf("SELECT * FROM full_%s.balanceof_method WHERE who_ = '0xfE9e8709d3215310075d67E3ed32A380CCf451C8' AND block = '6194634'", tusdAddr)).StructScan(&res)
+			Expect(err).To(HaveOccurred())
+		})
+
+		It("Fails if initialization has not been done", func() {
+			t := transformer.NewTransformer("", blockChain, db)
+			t.SetEvents(constants.TusdContractAddress, []string{"Transfer"})
+			t.SetMethods(constants.TusdContractAddress, nil)
+
+			err = t.Execute()
+			Expect(err).To(HaveOccurred())
+		})
+	})
+
+	Describe("Execute- against ENS registry contract", func() {
+		BeforeEach(func() {
+			blockRepository.CreateOrUpdateBlock(mocks.NewOwnerBlock1)
+			blockRepository.CreateOrUpdateBlock(mocks.NewOwnerBlock2)
+		})
+
+		It("Transforms watched contract data into custom repositories", func() {
+			t := transformer.NewTransformer("", blockChain, db)
+			t.SetEvents(constants.EnsContractAddress, []string{"NewOwner"})
+			t.SetMethods(constants.EnsContractAddress, nil)
+
+			err = t.Init()
+			Expect(err).ToNot(HaveOccurred())
+
+			err = t.Execute()
+			Expect(err).ToNot(HaveOccurred())
+
+			log := test_helpers.NewOwnerLog{}
+			err = db.QueryRowx(fmt.Sprintf("SELECT * FROM full_%s.newowner_event", ensAddr)).StructScan(&log)
+
+			// We don't know vulcID, so compare individual fields instead of complete structures
+			Expect(log.Tx).To(Equal("0x135391a0962a63944e5908e6fedfff90fb4be3e3290a21017861099bad654bbb"))
+			Expect(log.Block).To(Equal(int64(6194635)))
+			Expect(log.Node).To(Equal("0x0000000000000000000000000000000000000000000000000000c02aaa39b223"))
+			Expect(log.Label).To(Equal("0x9dd48110dcc444fdc242510c09bbbbe21a5975cac061d82f7b843bce061ba391"))
+			Expect(log.Owner).To(Equal("0x000000000000000000000000000000000000Af21"))
+		})
+
+		It("Keeps track of contract-related hashes while transforming event data if they need to be used for later method polling", func() {
+			t := transformer.NewTransformer("", blockChain, db)
+			t.SetEvents(constants.EnsContractAddress, []string{"NewOwner"})
+			t.SetMethods(constants.EnsContractAddress, []string{"owner"})
+			err = t.Init()
+			Expect(err).ToNot(HaveOccurred())
+
+			c, ok := t.Contracts[ensAddr]
+			Expect(ok).To(Equal(true))
+
+			err = t.Execute()
+			Expect(err).ToNot(HaveOccurred())
+			Expect(len(c.EmittedHashes)).To(Equal(3))
+
+			b, ok := c.EmittedHashes[common.HexToHash("0x0000000000000000000000000000000000000000000000000000c02aaa39b223")]
+			Expect(ok).To(Equal(true))
+			Expect(b).To(Equal(true))
+
+			b, ok = c.EmittedHashes[common.HexToHash("0x9dd48110dcc444fdc242510c09bbbbe21a5975cac061d82f7b843bce061ba391")]
+			Expect(ok).To(Equal(true))
+			Expect(b).To(Equal(true))
+
+			// Doesn't keep track of address since it wouldn't be used in calling the 'owner' method
+			_, ok = c.EmittedAddrs[common.HexToAddress("0x000000000000000000000000000000000000Af21")]
+			Expect(ok).To(Equal(false))
+		})
+
+		It("Polls given methods using generated token holder address", func() {
+			t := transformer.NewTransformer("", blockChain, db)
+			t.SetEvents(constants.EnsContractAddress, []string{"NewOwner"})
+			t.SetMethods(constants.EnsContractAddress, []string{"owner"})
+			err = t.Init()
+			Expect(err).ToNot(HaveOccurred())
+
+			err = t.Execute()
+			Expect(err).ToNot(HaveOccurred())
+
+			res := test_helpers.Owner{}
+			err = db.QueryRowx(fmt.Sprintf("SELECT * FROM full_%s.owner_method WHERE node_ = '0x0000000000000000000000000000000000000000000000000000c02aaa39b223' AND block = '6194636'", ensAddr)).StructScan(&res)
+			Expect(err).ToNot(HaveOccurred())
+			Expect(res.Address).To(Equal("0x0000000000000000000000000000000000000000"))
+			Expect(res.TokenName).To(Equal(""))
+
+			err = db.QueryRowx(fmt.Sprintf("SELECT * FROM full_%s.owner_method WHERE node_ = '0x9dd48110dcc444fdc242510c09bbbbe21a5975cac061d82f7b843bce061ba391' AND block = '6194636'", ensAddr)).StructScan(&res)
+			Expect(err).ToNot(HaveOccurred())
+			Expect(res.Address).To(Equal("0x0000000000000000000000000000000000000000"))
+			Expect(res.TokenName).To(Equal(""))
+
+			err = db.QueryRowx(fmt.Sprintf("SELECT * FROM full_%s.owner_method WHERE node_ = '0x9THIS110dcc444fIS242510c09bbAbe21aFAKEcacNODE82f7b843HASH61ba391' AND block = '6194636'", ensAddr)).StructScan(&res)
+			Expect(err).To(HaveOccurred())
+		})
+
+		It("It does not perist events if they do not pass the emitted arg filter", func() {
+			t := transformer.NewTransformer("", blockChain, db)
+			t.SetEvents(constants.EnsContractAddress, []string{"NewOwner"})
+			t.SetMethods(constants.EnsContractAddress, nil)
+			t.SetEventArgs(constants.EnsContractAddress, []string{"fake_filter_value"})
+
+			err = t.Init()
+			Expect(err).ToNot(HaveOccurred())
+
+			err = t.Execute()
+			Expect(err).ToNot(HaveOccurred())
+
+			log := test_helpers.LightNewOwnerLog{}
+			err = db.QueryRowx(fmt.Sprintf("SELECT * FROM full_%s.newowner_event", ensAddr)).StructScan(&log)
+			Expect(err).To(HaveOccurred())
+		})
+
+		It("If a method arg filter is applied, only those arguments are used in polling", func() {
+			t := transformer.NewTransformer("", blockChain, db)
+			t.SetEvents(constants.EnsContractAddress, []string{"NewOwner"})
+			t.SetMethods(constants.EnsContractAddress, []string{"owner"})
+			t.SetMethodArgs(constants.EnsContractAddress, []string{"0x0000000000000000000000000000000000000000000000000000c02aaa39b223"})
+			err = t.Init()
+			Expect(err).ToNot(HaveOccurred())
+
+			err = t.Execute()
+			Expect(err).ToNot(HaveOccurred())
+
+			res := test_helpers.Owner{}
+			err = db.QueryRowx(fmt.Sprintf("SELECT * FROM full_%s.owner_method WHERE node_ = '0x0000000000000000000000000000000000000000000000000000c02aaa39b223' AND block = '6194636'", ensAddr)).StructScan(&res)
+			Expect(err).ToNot(HaveOccurred())
+			Expect(res.Address).To(Equal("0x0000000000000000000000000000000000000000"))
+			Expect(res.TokenName).To(Equal(""))
+
+			err = db.QueryRowx(fmt.Sprintf("SELECT * FROM full_%s.owner_method WHERE node_ = '0x9dd48110dcc444fdc242510c09bbbbe21a5975cac061d82f7b843bce061ba391' AND block = '6194636'", ensAddr)).StructScan(&res)
+			Expect(err).To(HaveOccurred())
+		})
+	})
+})

integration_test/omni_light_transformer.go

@@ -2,9 +2,12 @@ package integration
 
 import (
 	"fmt"
+	"strings"
+
 	"github.com/ethereum/go-ethereum/common"
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
+
 	"github.com/vulcanize/vulcanizedb/pkg/core"
 	"github.com/vulcanize/vulcanizedb/pkg/datastore/postgres"
 	"github.com/vulcanize/vulcanizedb/pkg/datastore/postgres/repositories"
@@ -12,7 +15,6 @@ import (
 	"github.com/vulcanize/vulcanizedb/pkg/omni/shared/constants"
 	"github.com/vulcanize/vulcanizedb/pkg/omni/shared/helpers/test_helpers"
 	"github.com/vulcanize/vulcanizedb/pkg/omni/shared/helpers/test_helpers/mocks"
-	"strings"
 )
 
 var _ = Describe("Omnit light transformer", func() {

pkg/fakes/mock_block_retriever.go

@@ -1,14 +0,0 @@
-package fakes
-
-type MockBlockRetriever struct {
-	FirstBlock    int64
-	FirstBlockErr error
-}
-
-func (retriever *MockBlockRetriever) RetrieveFirstBlock() (int64, error) {
-	return retriever.FirstBlock, retriever.FirstBlockErr
-}
-
-func (retriever *MockBlockRetriever) RetrieveMostRecentBlock() (int64, error) {
-	return 0, nil
-}

pkg/fakes/mock_filter_repository.go

@@ -0,0 +1,14 @@
+package fakes
+
+import "github.com/vulcanize/vulcanizedb/pkg/filters"
+
+type MockFilterRepository struct {
+}
+
+func (*MockFilterRepository) CreateFilter(filter filters.LogFilter) error {
+	return nil
+}
+
+func (*MockFilterRepository) GetFilter(name string) (filters.LogFilter, error) {
+	panic("implement me")
+}

pkg/fakes/mock_full_block_retriever.go

@@ -0,0 +1,15 @@
+package fakes
+
+type MockFullBlockRetriever struct {
+	FirstBlock      int64
+	FirstBlockErr   error
+	MostRecentBlock int64
+}
+
+func (retriever *MockFullBlockRetriever) RetrieveFirstBlock(contractAddr string) (int64, error) {
+	return retriever.FirstBlock, retriever.FirstBlockErr
+}
+
+func (retriever *MockFullBlockRetriever) RetrieveMostRecentBlock() (int64, error) {
+	return retriever.MostRecentBlock, nil
+}

pkg/fakes/mock_light_block_retriever.go

@@ -0,0 +1,14 @@
+package fakes
+
+type MockLightBlockRetriever struct {
+	FirstBlock    int64
+	FirstBlockErr error
+}
+
+func (retriever *MockLightBlockRetriever) RetrieveFirstBlock() (int64, error) {
+	return retriever.FirstBlock, retriever.FirstBlockErr
+}
+
+func (retriever *MockLightBlockRetriever) RetrieveMostRecentBlock() (int64, error) {
+	return 0, nil
+}

pkg/fakes/mock_light_header_repository.go

@@ -0,0 +1,42 @@
+package fakes
+
+import "github.com/vulcanize/vulcanizedb/pkg/core"
+
+type MockLightHeaderRepository struct {
+}
+
+func (*MockLightHeaderRepository) AddCheckColumn(id string) error {
+	return nil
+}
+
+func (*MockLightHeaderRepository) AddCheckColumns(ids []string) error {
+	panic("implement me")
+}
+
+func (*MockLightHeaderRepository) MarkHeaderChecked(headerID int64, eventID string) error {
+	panic("implement me")
+}
+
+func (*MockLightHeaderRepository) MarkHeaderCheckedForAll(headerID int64, ids []string) error {
+	panic("implement me")
+}
+
+func (*MockLightHeaderRepository) MarkHeadersCheckedForAll(headers []core.Header, ids []string) error {
+	panic("implement me")
+}
+
+func (*MockLightHeaderRepository) MissingHeaders(startingBlockNumber int64, endingBlockNumber int64, eventID string) ([]core.Header, error) {
+	panic("implement me")
+}
+
+func (*MockLightHeaderRepository) MissingMethodsCheckedEventsIntersection(startingBlockNumber, endingBlockNumber int64, methodIds, eventIds []string) ([]core.Header, error) {
+	panic("implement me")
+}
+
+func (*MockLightHeaderRepository) MissingHeadersForAll(startingBlockNumber, endingBlockNumber int64, ids []string) ([]core.Header, error) {
+	panic("implement me")
+}
+
+func (*MockLightHeaderRepository) CheckCache(key string) (interface{}, bool) {
+	panic("implement me")
+}

pkg/fakes/mock_parser.go

@@ -7,6 +7,8 @@ import (
 
 type MockParser struct {
 	AbiToReturn string
+	EventName   string
+	Event       types.Event
 }
 
 func (*MockParser) Parse(contractAddr string) error {
@@ -33,6 +35,6 @@ func (*MockParser) GetSelectMethods(wanted []string) []types.Method {
 	return []types.Method{}
 }
 
-func (*MockParser) GetEvents(wanted []string) map[string]types.Event {
+func (parser *MockParser) GetEvents(wanted []string) map[string]types.Event {
-	return map[string]types.Event{}
+	return map[string]types.Event{parser.EventName: parser.Event}
 }

pkg/omni/full/transformer/transformer.go

@@ -34,7 +34,7 @@ import (
 )
 
 // Requires a fully synced vDB and a running eth node (or infura)
-type transformer struct {
+type Transformer struct {
 	// Database interfaces
 	datastore.FilterRepository       // Log filters repo; accepts filters generated by Contract.GenerateFilters()
 	datastore.WatchedEventRepository // Watched event log views, created by the log filters
@@ -76,8 +76,8 @@ type transformer struct {
 }
 
 // Transformer takes in config for blockchain, database, and network id
-func NewTransformer(network string, BC core.BlockChain, DB *postgres.DB) *transformer {
+func NewTransformer(network string, BC core.BlockChain, DB *postgres.DB) *Transformer {
-	return &transformer{
+	return &Transformer{
 		Poller:                 poller.NewPoller(BC, DB, types.FullSync),
 		Parser:                 parser.NewParser(network),
 		BlockRetriever:         retriever.NewBlockRetriever(DB),
@@ -101,7 +101,7 @@ func NewTransformer(network string, BC core.BlockChain, DB *postgres.DB) *transf
 // Loops over all of the addr => filter sets
 // Uses parser to pull event info from abi
 // Use this info to generate event filters
-func (t *transformer) Init() error {
+func (t *Transformer) Init() error {
 	for contractAddr, subset := range t.WatchedEvents {
 		// Get Abi
 		err := t.Parser.Parse(contractAddr)
@@ -126,7 +126,7 @@ func (t *transformer) Init() error {
 
 		// Get contract name if it has one
 		var name = new(string)
-		t.FetchContractData(t.Abi(), contractAddr, "name", nil, &name, lastBlock)
+		t.Poller.FetchContractData(t.Abi(), contractAddr, "name", nil, name, lastBlock)
 
 		// Remove any potential accidental duplicate inputs in arg filter values
 		eventArgs := map[string]bool{}
@@ -147,6 +147,7 @@ func (t *transformer) Init() error {
 			ParsedAbi:     t.Parser.ParsedAbi(),
 			StartingBlock: firstBlock,
 			LastBlock:     lastBlock,
+			// TODO: consider whether this duplicated knowledge from t.WatchedEvents
 			Events:         t.Parser.GetEvents(subset),
 			Methods:        t.Parser.GetSelectMethods(t.WantedMethods[contractAddr]),
 			FilterArgs:     eventArgs,
@@ -164,7 +165,7 @@ func (t *transformer) Init() error {
 
 		// Iterate over filters and push them to the repo using filter repository interface
 		for _, filter := range info.Filters {
-			err = t.CreateFilter(filter)
+			err = t.FilterRepository.CreateFilter(filter)
 			if err != nil {
 				return err
 			}
@@ -182,7 +183,7 @@ func (t *transformer) Init() error {
 // Uses converter to convert logs into custom log type
 // Persists converted logs into custuom postgres tables
 // Calls selected methods, using token holder address generated during event log conversion
-func (tr transformer) Execute() error {
+func (tr Transformer) Execute() error {
 	if len(tr.Contracts) == 0 {
 		return errors.New("error: transformer has no initialized contracts to work with")
 	}
@@ -231,41 +232,41 @@ func (tr transformer) Execute() error {
 }
 
 // Used to set which contract addresses and which of their events to watch
-func (tr *transformer) SetEvents(contractAddr string, filterSet []string) {
+func (tr *Transformer) SetEvents(contractAddr string, filterSet []string) {
 	tr.WatchedEvents[strings.ToLower(contractAddr)] = filterSet
 }
 
 // Used to set subset of account addresses to watch events for
-func (tr *transformer) SetEventArgs(contractAddr string, filterSet []string) {
+func (tr *Transformer) SetEventArgs(contractAddr string, filterSet []string) {
 	tr.EventArgs[strings.ToLower(contractAddr)] = filterSet
 }
 
 // Used to set which contract addresses and which of their methods to call
-func (tr *transformer) SetMethods(contractAddr string, filterSet []string) {
+func (tr *Transformer) SetMethods(contractAddr string, filterSet []string) {
 	tr.WantedMethods[strings.ToLower(contractAddr)] = filterSet
 }
 
 // Used to set subset of account addresses to poll methods on
-func (tr *transformer) SetMethodArgs(contractAddr string, filterSet []string) {
+func (tr *Transformer) SetMethodArgs(contractAddr string, filterSet []string) {
 	tr.MethodArgs[strings.ToLower(contractAddr)] = filterSet
 }
 
 // Used to set the block range to watch for a given address
-func (tr *transformer) SetStartingBlock(contractAddr string, start int64) {
+func (tr *Transformer) SetStartingBlock(contractAddr string, start int64) {
 	tr.ContractStart[strings.ToLower(contractAddr)] = start
 }
 
 // Used to set whether or not to persist an account address list
-func (tr *transformer) SetCreateAddrList(contractAddr string, on bool) {
+func (tr *Transformer) SetCreateAddrList(contractAddr string, on bool) {
 	tr.CreateAddrList[strings.ToLower(contractAddr)] = on
 }
 
 // Used to set whether or not to persist an hash list
-func (tr *transformer) SetCreateHashList(contractAddr string, on bool) {
+func (tr *Transformer) SetCreateHashList(contractAddr string, on bool) {
 	tr.CreateHashList[strings.ToLower(contractAddr)] = on
 }
 
 // Used to turn method piping on for a contract
-func (tr *transformer) SetPiping(contractAddr string, on bool) {
+func (tr *Transformer) SetPiping(contractAddr string, on bool) {
 	tr.Piping[strings.ToLower(contractAddr)] = on
 }

pkg/omni/full/transformer/transformer_test.go

@@ -17,353 +17,160 @@
 package transformer_test
 
 import (
-	"fmt"
 	"math/rand"
-	"strings"
 	"time"
 
-	"github.com/ethereum/go-ethereum/common"
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
 
-	"github.com/vulcanize/vulcanizedb/pkg/core"
+	"github.com/vulcanize/vulcanizedb/pkg/fakes"
-	"github.com/vulcanize/vulcanizedb/pkg/datastore/postgres"
+	"github.com/vulcanize/vulcanizedb/pkg/omni/full/retriever"
-	"github.com/vulcanize/vulcanizedb/pkg/datastore/postgres/repositories"
 	"github.com/vulcanize/vulcanizedb/pkg/omni/full/transformer"
-	"github.com/vulcanize/vulcanizedb/pkg/omni/shared/constants"
+	"github.com/vulcanize/vulcanizedb/pkg/omni/shared/contract"
-	"github.com/vulcanize/vulcanizedb/pkg/omni/shared/helpers/test_helpers"
+	"github.com/vulcanize/vulcanizedb/pkg/omni/shared/parser"
-	"github.com/vulcanize/vulcanizedb/pkg/omni/shared/helpers/test_helpers/mocks"
+	"github.com/vulcanize/vulcanizedb/pkg/omni/shared/poller"
+	"github.com/vulcanize/vulcanizedb/pkg/omni/shared/types"
 )
 
 var _ = Describe("Transformer", func() {
-	var db *postgres.DB
+	var fakeAddress = "0x1234567890abcdef"
-	var err error
-	var blockChain core.BlockChain
-	var blockRepository repositories.BlockRepository
-	var ensAddr = strings.ToLower(constants.EnsContractAddress)
-	var tusdAddr = strings.ToLower(constants.TusdContractAddress)
 	rand.Seed(time.Now().UnixNano())
 
-	BeforeEach(func() {
-		db, blockChain = test_helpers.SetupDBandBC()
-		blockRepository = *repositories.NewBlockRepository(db)
-	})
-
-	AfterEach(func() {
-		test_helpers.TearDown(db)
-	})
-
 	Describe("SetEvents", func() {
 		It("Sets which events to watch from the given contract address", func() {
 			watchedEvents := []string{"Transfer", "Mint"}
-			t := transformer.NewTransformer("", blockChain, db)
+			t := getTransformer(&fakes.MockFullBlockRetriever{}, &fakes.MockParser{}, &fakes.MockPoller{})
-			t.SetEvents(constants.TusdContractAddress, watchedEvents)
+			t.SetEvents(fakeAddress, watchedEvents)
-			Expect(t.WatchedEvents[tusdAddr]).To(Equal(watchedEvents))
+			Expect(t.WatchedEvents[fakeAddress]).To(Equal(watchedEvents))
 		})
 	})
 
 	Describe("SetEventAddrs", func() {
 		It("Sets which account addresses to watch events for", func() {
 			eventAddrs := []string{"test1", "test2"}
-			t := transformer.NewTransformer("", blockChain, db)
+			t := getTransformer(&fakes.MockFullBlockRetriever{}, &fakes.MockParser{}, &fakes.MockPoller{})
-			t.SetEventArgs(constants.TusdContractAddress, eventAddrs)
+			t.SetEventArgs(fakeAddress, eventAddrs)
-			Expect(t.EventArgs[tusdAddr]).To(Equal(eventAddrs))
+			Expect(t.EventArgs[fakeAddress]).To(Equal(eventAddrs))
 		})
 	})
 
 	Describe("SetMethods", func() {
 		It("Sets which methods to poll at the given contract address", func() {
 			watchedMethods := []string{"balanceOf", "totalSupply"}
-			t := transformer.NewTransformer("", blockChain, db)
+			t := getTransformer(&fakes.MockFullBlockRetriever{}, &fakes.MockParser{}, &fakes.MockPoller{})
-			t.SetMethods(constants.TusdContractAddress, watchedMethods)
+			t.SetMethods(fakeAddress, watchedMethods)
-			Expect(t.WantedMethods[tusdAddr]).To(Equal(watchedMethods))
+			Expect(t.WantedMethods[fakeAddress]).To(Equal(watchedMethods))
 		})
 	})
 
 	Describe("SetMethodAddrs", func() {
 		It("Sets which account addresses to poll methods against", func() {
 			methodAddrs := []string{"test1", "test2"}
-			t := transformer.NewTransformer("", blockChain, db)
+			t := getTransformer(&fakes.MockFullBlockRetriever{}, &fakes.MockParser{}, &fakes.MockPoller{})
-			t.SetMethodArgs(constants.TusdContractAddress, methodAddrs)
+			t.SetMethodArgs(fakeAddress, methodAddrs)
-			Expect(t.MethodArgs[tusdAddr]).To(Equal(methodAddrs))
+			Expect(t.MethodArgs[fakeAddress]).To(Equal(methodAddrs))
 		})
 	})
 
 	Describe("SetStartingBlock", func() {
 		It("Sets the block range that the contract should be watched within", func() {
-			t := transformer.NewTransformer("", blockChain, db)
+			t := getTransformer(&fakes.MockFullBlockRetriever{}, &fakes.MockParser{}, &fakes.MockPoller{})
-			t.SetStartingBlock(constants.TusdContractAddress, 11)
+			t.SetStartingBlock(fakeAddress, 11)
-			Expect(t.ContractStart[tusdAddr]).To(Equal(int64(11)))
+			Expect(t.ContractStart[fakeAddress]).To(Equal(int64(11)))
 		})
 	})
 
 	Describe("SetCreateAddrList", func() {
 		It("Sets the block range that the contract should be watched within", func() {
-			t := transformer.NewTransformer("", blockChain, db)
+			t := getTransformer(&fakes.MockFullBlockRetriever{}, &fakes.MockParser{}, &fakes.MockPoller{})
-			t.SetCreateAddrList(constants.TusdContractAddress, true)
+			t.SetCreateAddrList(fakeAddress, true)
-			Expect(t.CreateAddrList[tusdAddr]).To(Equal(true))
+			Expect(t.CreateAddrList[fakeAddress]).To(Equal(true))
 		})
 	})
 
 	Describe("SetCreateHashList", func() {
 		It("Sets the block range that the contract should be watched within", func() {
-			t := transformer.NewTransformer("", blockChain, db)
+			t := getTransformer(&fakes.MockFullBlockRetriever{}, &fakes.MockParser{}, &fakes.MockPoller{})
-			t.SetCreateHashList(constants.TusdContractAddress, true)
+			t.SetCreateHashList(fakeAddress, true)
-			Expect(t.CreateHashList[tusdAddr]).To(Equal(true))
+			Expect(t.CreateHashList[fakeAddress]).To(Equal(true))
 		})
 	})
 
 	Describe("Init", func() {
 		It("Initializes transformer's contract objects", func() {
-			blockRepository.CreateOrUpdateBlock(mocks.TransferBlock1)
+			blockRetriever := &fakes.MockFullBlockRetriever{}
-			blockRepository.CreateOrUpdateBlock(mocks.TransferBlock2)
+			firstBlock := int64(1)
-			t := transformer.NewTransformer("", blockChain, db)
+			mostRecentBlock := int64(2)
-			t.SetEvents(constants.TusdContractAddress, []string{"Transfer"})
+			blockRetriever.FirstBlock = firstBlock
-			err = t.Init()
+			blockRetriever.MostRecentBlock = mostRecentBlock
+
+			parsr := &fakes.MockParser{}
+			fakeAbi := "fake_abi"
+			eventName := "Transfer"
+			event := types.Event{}
+			parsr.AbiToReturn = fakeAbi
+			parsr.EventName = eventName
+			parsr.Event = event
+
+			pollr := &fakes.MockPoller{}
+			fakeContractName := "fake_contract_name"
+			pollr.ContractName = fakeContractName
+
+			t := getTransformer(blockRetriever, parsr, pollr)
+			t.SetEvents(fakeAddress, []string{"Transfer"})
+
+			err := t.Init()
+
 			Expect(err).ToNot(HaveOccurred())
 
-			c, ok := t.Contracts[tusdAddr]
+			c, ok := t.Contracts[fakeAddress]
 			Expect(ok).To(Equal(true))
 
-			Expect(c.StartingBlock).To(Equal(int64(6194633)))
+			Expect(c.StartingBlock).To(Equal(firstBlock))
-			Expect(c.LastBlock).To(Equal(int64(6194634)))
+			Expect(c.LastBlock).To(Equal(mostRecentBlock))
-			Expect(c.Abi).To(Equal(constants.TusdAbiString))
+			Expect(c.Abi).To(Equal(fakeAbi))
-			Expect(c.Name).To(Equal("TrueUSD"))
+			Expect(c.Name).To(Equal(fakeContractName))
-			Expect(c.Address).To(Equal(tusdAddr))
+			Expect(c.Address).To(Equal(fakeAddress))
 		})
 
 		It("Fails to initialize if first and most recent blocks cannot be fetched from vDB", func() {
-			t := transformer.NewTransformer("", blockChain, db)
+			blockRetriever := &fakes.MockFullBlockRetriever{}
-			t.SetEvents(constants.TusdContractAddress, []string{"Transfer"})
+			blockRetriever.FirstBlockErr = fakes.FakeError
-			err = t.Init()
+			t := getTransformer(blockRetriever, &fakes.MockParser{}, &fakes.MockPoller{})
+			t.SetEvents(fakeAddress, []string{"Transfer"})
+
+			err := t.Init()
+
 			Expect(err).To(HaveOccurred())
+			Expect(err).To(MatchError(fakes.FakeError))
 		})
 
 		It("Does nothing if watched events are unset", func() {
-			blockRepository.CreateOrUpdateBlock(mocks.TransferBlock1)
+			t := getTransformer(&fakes.MockFullBlockRetriever{}, &fakes.MockParser{}, &fakes.MockPoller{})
-			blockRepository.CreateOrUpdateBlock(mocks.TransferBlock2)
+
-			t := transformer.NewTransformer("", blockChain, db)
+			err := t.Init()
-			err = t.Init()
+
 			Expect(err).ToNot(HaveOccurred())
 
-			_, ok := t.Contracts[tusdAddr]
+			_, ok := t.Contracts[fakeAddress]
 			Expect(ok).To(Equal(false))
 		})
 	})
-
-	Describe("Execute", func() {
-		BeforeEach(func() {
-			blockRepository.CreateOrUpdateBlock(mocks.TransferBlock1)
-			blockRepository.CreateOrUpdateBlock(mocks.TransferBlock2)
-		})
-
-		It("Transforms watched contract data into custom repositories", func() {
-			t := transformer.NewTransformer("", blockChain, db)
-			t.SetEvents(constants.TusdContractAddress, []string{"Transfer"})
-			t.SetMethods(constants.TusdContractAddress, nil)
-			err = t.Init()
-			Expect(err).ToNot(HaveOccurred())
-
-			err = t.Execute()
-			Expect(err).ToNot(HaveOccurred())
-
-			log := test_helpers.TransferLog{}
-			err = db.QueryRowx(fmt.Sprintf("SELECT * FROM full_%s.transfer_event WHERE block = 6194634", tusdAddr)).StructScan(&log)
-
-			// We don't know vulcID, so compare individual fields instead of complete structures
-			Expect(log.Tx).To(Equal("0x135391a0962a63944e5908e6fedfff90fb4be3e3290a21017861099bad654eee"))
-			Expect(log.Block).To(Equal(int64(6194634)))
-			Expect(log.From).To(Equal("0x000000000000000000000000000000000000Af21"))
-			Expect(log.To).To(Equal("0x09BbBBE21a5975cAc061D82f7b843bCE061BA391"))
-			Expect(log.Value).To(Equal("1097077688018008265106216665536940668749033598146"))
-		})
-
-		It("Keeps track of contract-related addresses while transforming event data if they need to be used for later method polling", func() {
-			t := transformer.NewTransformer("", blockChain, db)
-			t.SetEvents(constants.TusdContractAddress, []string{"Transfer"})
-			t.SetMethods(constants.TusdContractAddress, []string{"balanceOf"})
-			err = t.Init()
-			Expect(err).ToNot(HaveOccurred())
-
-			c, ok := t.Contracts[tusdAddr]
-			Expect(ok).To(Equal(true))
-
-			err = t.Execute()
-			Expect(err).ToNot(HaveOccurred())
-
-			b, ok := c.EmittedAddrs[common.HexToAddress("0x000000000000000000000000000000000000Af21")]
-			Expect(ok).To(Equal(true))
-			Expect(b).To(Equal(true))
-
-			b, ok = c.EmittedAddrs[common.HexToAddress("0x09BbBBE21a5975cAc061D82f7b843bCE061BA391")]
-			Expect(ok).To(Equal(true))
-			Expect(b).To(Equal(true))
-
-			_, ok = c.EmittedAddrs[common.HexToAddress("0x09BbBBE21a5975cAc061D82f7b843b1234567890")]
-			Expect(ok).To(Equal(false))
-
-			_, ok = c.EmittedAddrs[common.HexToAddress("0x")]
-			Expect(ok).To(Equal(false))
-
-			_, ok = c.EmittedAddrs[""]
-			Expect(ok).To(Equal(false))
-
-			_, ok = c.EmittedAddrs[common.HexToAddress("0x09THISE21a5IS5cFAKE1D82fAND43bCE06MADEUP")]
-			Expect(ok).To(Equal(false))
-		})
-
-		It("Polls given methods using generated token holder address", func() {
-			t := transformer.NewTransformer("", blockChain, db)
-			t.SetEvents(constants.TusdContractAddress, []string{"Transfer"})
-			t.SetMethods(constants.TusdContractAddress, []string{"balanceOf"})
-			err = t.Init()
-			Expect(err).ToNot(HaveOccurred())
-
-			err = t.Execute()
-			Expect(err).ToNot(HaveOccurred())
-
-			res := test_helpers.BalanceOf{}
-
-			err = db.QueryRowx(fmt.Sprintf("SELECT * FROM full_%s.balanceof_method WHERE who_ = '0x000000000000000000000000000000000000Af21' AND block = '6194634'", tusdAddr)).StructScan(&res)
-			Expect(err).ToNot(HaveOccurred())
-			Expect(res.Balance).To(Equal("0"))
-			Expect(res.TokenName).To(Equal("TrueUSD"))
-
-			err = db.QueryRowx(fmt.Sprintf("SELECT * FROM full_%s.balanceof_method WHERE who_ = '0x09BbBBE21a5975cAc061D82f7b843bCE061BA391' AND block = '6194634'", tusdAddr)).StructScan(&res)
-			Expect(err).ToNot(HaveOccurred())
-			Expect(res.Balance).To(Equal("0"))
-			Expect(res.TokenName).To(Equal("TrueUSD"))
-
-			err = db.QueryRowx(fmt.Sprintf("SELECT * FROM full_%s.balanceof_method WHERE who_ = '0xfE9e8709d3215310075d67E3ed32A380CCf451C8' AND block = '6194634'", tusdAddr)).StructScan(&res)
-			Expect(err).To(HaveOccurred())
-		})
-
-		It("Fails if initialization has not been done", func() {
-			t := transformer.NewTransformer("", blockChain, db)
-			t.SetEvents(constants.TusdContractAddress, []string{"Transfer"})
-			t.SetMethods(constants.TusdContractAddress, nil)
-
-			err = t.Execute()
-			Expect(err).To(HaveOccurred())
-		})
-	})
-
-	Describe("Execute- against ENS registry contract", func() {
-		BeforeEach(func() {
-			blockRepository.CreateOrUpdateBlock(mocks.NewOwnerBlock1)
-			blockRepository.CreateOrUpdateBlock(mocks.NewOwnerBlock2)
-		})
-
-		It("Transforms watched contract data into custom repositories", func() {
-			t := transformer.NewTransformer("", blockChain, db)
-			t.SetEvents(constants.EnsContractAddress, []string{"NewOwner"})
-			t.SetMethods(constants.EnsContractAddress, nil)
-
-			err = t.Init()
-			Expect(err).ToNot(HaveOccurred())
-
-			err = t.Execute()
-			Expect(err).ToNot(HaveOccurred())
-
-			log := test_helpers.NewOwnerLog{}
-			err = db.QueryRowx(fmt.Sprintf("SELECT * FROM full_%s.newowner_event", ensAddr)).StructScan(&log)
-
-			// We don't know vulcID, so compare individual fields instead of complete structures
-			Expect(log.Tx).To(Equal("0x135391a0962a63944e5908e6fedfff90fb4be3e3290a21017861099bad654bbb"))
-			Expect(log.Block).To(Equal(int64(6194635)))
-			Expect(log.Node).To(Equal("0x0000000000000000000000000000000000000000000000000000c02aaa39b223"))
-			Expect(log.Label).To(Equal("0x9dd48110dcc444fdc242510c09bbbbe21a5975cac061d82f7b843bce061ba391"))
-			Expect(log.Owner).To(Equal("0x000000000000000000000000000000000000Af21"))
-		})
-
-		It("Keeps track of contract-related hashes while transforming event data if they need to be used for later method polling", func() {
-			t := transformer.NewTransformer("", blockChain, db)
-			t.SetEvents(constants.EnsContractAddress, []string{"NewOwner"})
-			t.SetMethods(constants.EnsContractAddress, []string{"owner"})
-			err = t.Init()
-			Expect(err).ToNot(HaveOccurred())
-
-			c, ok := t.Contracts[ensAddr]
-			Expect(ok).To(Equal(true))
-
-			err = t.Execute()
-			Expect(err).ToNot(HaveOccurred())
-			Expect(len(c.EmittedHashes)).To(Equal(3))
-
-			b, ok := c.EmittedHashes[common.HexToHash("0x0000000000000000000000000000000000000000000000000000c02aaa39b223")]
-			Expect(ok).To(Equal(true))
-			Expect(b).To(Equal(true))
-
-			b, ok = c.EmittedHashes[common.HexToHash("0x9dd48110dcc444fdc242510c09bbbbe21a5975cac061d82f7b843bce061ba391")]
-			Expect(ok).To(Equal(true))
-			Expect(b).To(Equal(true))
-
-			// Doesn't keep track of address since it wouldn't be used in calling the 'owner' method
-			_, ok = c.EmittedAddrs[common.HexToAddress("0x000000000000000000000000000000000000Af21")]
-			Expect(ok).To(Equal(false))
-		})
-
-		It("Polls given methods using generated token holder address", func() {
-			t := transformer.NewTransformer("", blockChain, db)
-			t.SetEvents(constants.EnsContractAddress, []string{"NewOwner"})
-			t.SetMethods(constants.EnsContractAddress, []string{"owner"})
-			err = t.Init()
-			Expect(err).ToNot(HaveOccurred())
-
-			err = t.Execute()
-			Expect(err).ToNot(HaveOccurred())
-
-			res := test_helpers.Owner{}
-			err = db.QueryRowx(fmt.Sprintf("SELECT * FROM full_%s.owner_method WHERE node_ = '0x0000000000000000000000000000000000000000000000000000c02aaa39b223' AND block = '6194636'", ensAddr)).StructScan(&res)
-			Expect(err).ToNot(HaveOccurred())
-			Expect(res.Address).To(Equal("0x0000000000000000000000000000000000000000"))
-			Expect(res.TokenName).To(Equal(""))
-
-			err = db.QueryRowx(fmt.Sprintf("SELECT * FROM full_%s.owner_method WHERE node_ = '0x9dd48110dcc444fdc242510c09bbbbe21a5975cac061d82f7b843bce061ba391' AND block = '6194636'", ensAddr)).StructScan(&res)
-			Expect(err).ToNot(HaveOccurred())
-			Expect(res.Address).To(Equal("0x0000000000000000000000000000000000000000"))
-			Expect(res.TokenName).To(Equal(""))
-
-			err = db.QueryRowx(fmt.Sprintf("SELECT * FROM full_%s.owner_method WHERE node_ = '0x9THIS110dcc444fIS242510c09bbAbe21aFAKEcacNODE82f7b843HASH61ba391' AND block = '6194636'", ensAddr)).StructScan(&res)
-			Expect(err).To(HaveOccurred())
-		})
-
-		It("It does not perist events if they do not pass the emitted arg filter", func() {
-			t := transformer.NewTransformer("", blockChain, db)
-			t.SetEvents(constants.EnsContractAddress, []string{"NewOwner"})
-			t.SetMethods(constants.EnsContractAddress, nil)
-			t.SetEventArgs(constants.EnsContractAddress, []string{"fake_filter_value"})
-
-			err = t.Init()
-			Expect(err).ToNot(HaveOccurred())
-
-			err = t.Execute()
-			Expect(err).ToNot(HaveOccurred())
-
-			log := test_helpers.LightNewOwnerLog{}
-			err = db.QueryRowx(fmt.Sprintf("SELECT * FROM full_%s.newowner_event", ensAddr)).StructScan(&log)
-			Expect(err).To(HaveOccurred())
-		})
-
-		It("If a method arg filter is applied, only those arguments are used in polling", func() {
-			t := transformer.NewTransformer("", blockChain, db)
-			t.SetEvents(constants.EnsContractAddress, []string{"NewOwner"})
-			t.SetMethods(constants.EnsContractAddress, []string{"owner"})
-			t.SetMethodArgs(constants.EnsContractAddress, []string{"0x0000000000000000000000000000000000000000000000000000c02aaa39b223"})
-			err = t.Init()
-			Expect(err).ToNot(HaveOccurred())
-
-			err = t.Execute()
-			Expect(err).ToNot(HaveOccurred())
-
-			res := test_helpers.Owner{}
-			err = db.QueryRowx(fmt.Sprintf("SELECT * FROM full_%s.owner_method WHERE node_ = '0x0000000000000000000000000000000000000000000000000000c02aaa39b223' AND block = '6194636'", ensAddr)).StructScan(&res)
-			Expect(err).ToNot(HaveOccurred())
-			Expect(res.Address).To(Equal("0x0000000000000000000000000000000000000000"))
-			Expect(res.TokenName).To(Equal(""))
-
-			err = db.QueryRowx(fmt.Sprintf("SELECT * FROM full_%s.owner_method WHERE node_ = '0x9dd48110dcc444fdc242510c09bbbbe21a5975cac061d82f7b843bce061ba391' AND block = '6194636'", ensAddr)).StructScan(&res)
-			Expect(err).To(HaveOccurred())
-		})
-	})
 })
+
+func getTransformer(blockRetriever retriever.BlockRetriever, parsr parser.Parser, pollr poller.Poller) transformer.Transformer {
+	return transformer.Transformer{
+		FilterRepository: &fakes.MockFilterRepository{},
+		Parser:           parsr,
+		BlockRetriever:   blockRetriever,
+		Poller:           pollr,
+		Contracts:        map[string]*contract.Contract{},
+		WatchedEvents:    map[string][]string{},
+		WantedMethods:    map[string][]string{},
+		ContractStart:    map[string]int64{},
+		EventArgs:        map[string][]string{},
+		MethodArgs:       map[string][]string{},
+		CreateAddrList:   map[string]bool{},
+		CreateHashList:   map[string]bool{},
+	}
+}

pkg/omni/light/transformer/transformer_test.go

@@ -34,7 +34,7 @@ var _ = Describe("Transformer", func() {
 	Describe("SetEvents", func() {
 		It("Sets which events to watch from the given contract address", func() {
 			watchedEvents := []string{"Transfer", "Mint"}
-			t := getFakeTransformer(&fakes.MockBlockRetriever{}, &fakes.MockParser{}, &fakes.MockPoller{})
+			t := getFakeTransformer(&fakes.MockLightBlockRetriever{}, &fakes.MockParser{}, &fakes.MockPoller{})
 			t.SetEvents(fakeAddress, watchedEvents)
 			Expect(t.WatchedEvents[fakeAddress]).To(Equal(watchedEvents))
 		})
@@ -43,7 +43,7 @@ var _ = Describe("Transformer", func() {
 	Describe("SetEventAddrs", func() {
 		It("Sets which account addresses to watch events for", func() {
 			eventAddrs := []string{"test1", "test2"}
-			t := getFakeTransformer(&fakes.MockBlockRetriever{}, &fakes.MockParser{}, &fakes.MockPoller{})
+			t := getFakeTransformer(&fakes.MockLightBlockRetriever{}, &fakes.MockParser{}, &fakes.MockPoller{})
 			t.SetEventArgs(fakeAddress, eventAddrs)
 			Expect(t.EventArgs[fakeAddress]).To(Equal(eventAddrs))
 		})
@@ -52,7 +52,7 @@ var _ = Describe("Transformer", func() {
 	Describe("SetMethods", func() {
 		It("Sets which methods to poll at the given contract address", func() {
 			watchedMethods := []string{"balanceOf", "totalSupply"}
-			t := getFakeTransformer(&fakes.MockBlockRetriever{}, &fakes.MockParser{}, &fakes.MockPoller{})
+			t := getFakeTransformer(&fakes.MockLightBlockRetriever{}, &fakes.MockParser{}, &fakes.MockPoller{})
 			t.SetMethods(fakeAddress, watchedMethods)
 			Expect(t.WantedMethods[fakeAddress]).To(Equal(watchedMethods))
 		})
@@ -61,7 +61,7 @@ var _ = Describe("Transformer", func() {
 	Describe("SetMethodAddrs", func() {
 		It("Sets which account addresses to poll methods against", func() {
 			methodAddrs := []string{"test1", "test2"}
-			t := getFakeTransformer(&fakes.MockBlockRetriever{}, &fakes.MockParser{}, &fakes.MockPoller{})
+			t := getFakeTransformer(&fakes.MockLightBlockRetriever{}, &fakes.MockParser{}, &fakes.MockPoller{})
 			t.SetMethodArgs(fakeAddress, methodAddrs)
 			Expect(t.MethodArgs[fakeAddress]).To(Equal(methodAddrs))
 		})
@@ -69,7 +69,7 @@ var _ = Describe("Transformer", func() {
 
 	Describe("SetStartingBlock", func() {
 		It("Sets the block range that the contract should be watched within", func() {
-			t := getFakeTransformer(&fakes.MockBlockRetriever{}, &fakes.MockParser{}, &fakes.MockPoller{})
+			t := getFakeTransformer(&fakes.MockLightBlockRetriever{}, &fakes.MockParser{}, &fakes.MockPoller{})
 			t.SetStartingBlock(fakeAddress, 11)
 			Expect(t.ContractStart[fakeAddress]).To(Equal(int64(11)))
 		})
@@ -77,7 +77,7 @@ var _ = Describe("Transformer", func() {
 
 	Describe("SetCreateAddrList", func() {
 		It("Sets the block range that the contract should be watched within", func() {
-			t := getFakeTransformer(&fakes.MockBlockRetriever{}, &fakes.MockParser{}, &fakes.MockPoller{})
+			t := getFakeTransformer(&fakes.MockLightBlockRetriever{}, &fakes.MockParser{}, &fakes.MockPoller{})
 			t.SetCreateAddrList(fakeAddress, true)
 			Expect(t.CreateAddrList[fakeAddress]).To(Equal(true))
 		})
@@ -85,7 +85,7 @@ var _ = Describe("Transformer", func() {
 
 	Describe("SetCreateHashList", func() {
 		It("Sets the block range that the contract should be watched within", func() {
-			t := getFakeTransformer(&fakes.MockBlockRetriever{}, &fakes.MockParser{}, &fakes.MockPoller{})
+			t := getFakeTransformer(&fakes.MockLightBlockRetriever{}, &fakes.MockParser{}, &fakes.MockPoller{})
 			t.SetCreateHashList(fakeAddress, true)
 			Expect(t.CreateHashList[fakeAddress]).To(Equal(true))
 		})
@@ -93,7 +93,7 @@ var _ = Describe("Transformer", func() {
 
 	Describe("Init", func() {
 		It("Initializes transformer's contract objects", func() {
-			blockRetriever := &fakes.MockBlockRetriever{}
+			blockRetriever := &fakes.MockLightBlockRetriever{}
 			firstBlock := int64(1)
 			blockRetriever.FirstBlock = firstBlock
 
@@ -123,7 +123,7 @@ var _ = Describe("Transformer", func() {
 		})
 
 		It("Fails to initialize if first and most recent block numbers cannot be fetched from vDB headers table", func() {
-			blockRetriever := &fakes.MockBlockRetriever{}
+			blockRetriever := &fakes.MockLightBlockRetriever{}
 			blockRetriever.FirstBlockErr = fakes.FakeError
 			t := getFakeTransformer(blockRetriever, &fakes.MockParser{}, &fakes.MockPoller{})
 			t.SetEvents(fakeAddress, []string{"Transfer"})
@@ -135,7 +135,7 @@ var _ = Describe("Transformer", func() {
 		})
 
 		It("Does nothing if watched events are unset", func() {
-			t := getFakeTransformer(&fakes.MockBlockRetriever{}, &fakes.MockParser{}, &fakes.MockPoller{})
+			t := getFakeTransformer(&fakes.MockLightBlockRetriever{}, &fakes.MockParser{}, &fakes.MockPoller{})
 
 			err := t.Init()
 
@@ -153,6 +153,7 @@ func getFakeTransformer(blockRetriever retriever.BlockRetriever, parsr parser.Pa
 		Parser:           parsr,
 		BlockRetriever:   blockRetriever,
 		Poller:           pollr,
+		HeaderRepository: &fakes.MockLightHeaderRepository{},
 		Contracts:        map[string]*contract.Contract{},
 		WatchedEvents:    map[string][]string{},
 		WantedMethods:    map[string][]string{},