diff --git a/integration_test/omni_full_transformer.go b/integration_test/omni_full_transformer.go new file mode 100644 index 00000000..fcbfdde6 --- /dev/null +++ b/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()) + }) + }) +}) diff --git a/integration_test/omni_light_transformer.go b/integration_test/omni_light_transformer.go index 9391ef5b..5634ba14 100644 --- a/integration_test/omni_light_transformer.go +++ b/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() { diff --git a/pkg/fakes/mock_block_retriever.go b/pkg/fakes/mock_block_retriever.go deleted file mode 100644 index 407e7170..00000000 --- a/pkg/fakes/mock_block_retriever.go +++ /dev/null @@ -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 -} diff --git a/pkg/fakes/mock_filter_repository.go b/pkg/fakes/mock_filter_repository.go new file mode 100644 index 00000000..e6f160a8 --- /dev/null +++ b/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") +} diff --git a/pkg/fakes/mock_full_block_retriever.go b/pkg/fakes/mock_full_block_retriever.go new file mode 100644 index 00000000..c1fa67bc --- /dev/null +++ b/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 +} diff --git a/pkg/fakes/mock_light_block_retriever.go b/pkg/fakes/mock_light_block_retriever.go new file mode 100644 index 00000000..37c4c09c --- /dev/null +++ b/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 +} diff --git a/pkg/fakes/mock_light_header_repository.go b/pkg/fakes/mock_light_header_repository.go new file mode 100644 index 00000000..9e963a99 --- /dev/null +++ b/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") +} diff --git a/pkg/fakes/mock_parser.go b/pkg/fakes/mock_parser.go index e9cf3c87..cac8dd9c 100644 --- a/pkg/fakes/mock_parser.go +++ b/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 { - return map[string]types.Event{} +func (parser *MockParser) GetEvents(wanted []string) map[string]types.Event { + return map[string]types.Event{parser.EventName: parser.Event} } diff --git a/pkg/omni/full/transformer/transformer.go b/pkg/omni/full/transformer/transformer.go index 5c8a4337..c4f6cedf 100644 --- a/pkg/omni/full/transformer/transformer.go +++ b/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 { - return &transformer{ +func NewTransformer(network string, BC core.BlockChain, DB *postgres.DB) *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{} @@ -140,13 +140,14 @@ func (t *transformer) Init() error { // Aggregate info into contract object info := contract.Contract{ - Name: *name, - Network: t.Network, - Address: contractAddr, - Abi: t.Parser.Abi(), - ParsedAbi: t.Parser.ParsedAbi(), - StartingBlock: firstBlock, - LastBlock: lastBlock, + Name: *name, + Network: t.Network, + Address: contractAddr, + Abi: t.Parser.Abi(), + 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 } diff --git a/pkg/omni/full/transformer/transformer_test.go b/pkg/omni/full/transformer/transformer_test.go index 323a8e77..16632ada 100644 --- a/pkg/omni/full/transformer/transformer_test.go +++ b/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/datastore/postgres" - "github.com/vulcanize/vulcanizedb/pkg/datastore/postgres/repositories" + "github.com/vulcanize/vulcanizedb/pkg/fakes" + "github.com/vulcanize/vulcanizedb/pkg/omni/full/retriever" "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" + "github.com/vulcanize/vulcanizedb/pkg/omni/shared/contract" + "github.com/vulcanize/vulcanizedb/pkg/omni/shared/parser" + "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 err error - var blockChain core.BlockChain - var blockRepository repositories.BlockRepository - var ensAddr = strings.ToLower(constants.EnsContractAddress) - var tusdAddr = strings.ToLower(constants.TusdContractAddress) + var fakeAddress = "0x1234567890abcdef" 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.SetEvents(constants.TusdContractAddress, watchedEvents) - Expect(t.WatchedEvents[tusdAddr]).To(Equal(watchedEvents)) + t := getTransformer(&fakes.MockFullBlockRetriever{}, &fakes.MockParser{}, &fakes.MockPoller{}) + t.SetEvents(fakeAddress, 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.SetEventArgs(constants.TusdContractAddress, eventAddrs) - Expect(t.EventArgs[tusdAddr]).To(Equal(eventAddrs)) + t := getTransformer(&fakes.MockFullBlockRetriever{}, &fakes.MockParser{}, &fakes.MockPoller{}) + t.SetEventArgs(fakeAddress, 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.SetMethods(constants.TusdContractAddress, watchedMethods) - Expect(t.WantedMethods[tusdAddr]).To(Equal(watchedMethods)) + t := getTransformer(&fakes.MockFullBlockRetriever{}, &fakes.MockParser{}, &fakes.MockPoller{}) + t.SetMethods(fakeAddress, 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.SetMethodArgs(constants.TusdContractAddress, methodAddrs) - Expect(t.MethodArgs[tusdAddr]).To(Equal(methodAddrs)) + t := getTransformer(&fakes.MockFullBlockRetriever{}, &fakes.MockParser{}, &fakes.MockPoller{}) + t.SetMethodArgs(fakeAddress, 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.SetStartingBlock(constants.TusdContractAddress, 11) - Expect(t.ContractStart[tusdAddr]).To(Equal(int64(11))) + t := getTransformer(&fakes.MockFullBlockRetriever{}, &fakes.MockParser{}, &fakes.MockPoller{}) + t.SetStartingBlock(fakeAddress, 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.SetCreateAddrList(constants.TusdContractAddress, true) - Expect(t.CreateAddrList[tusdAddr]).To(Equal(true)) + t := getTransformer(&fakes.MockFullBlockRetriever{}, &fakes.MockParser{}, &fakes.MockPoller{}) + t.SetCreateAddrList(fakeAddress, 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.SetCreateHashList(constants.TusdContractAddress, true) - Expect(t.CreateHashList[tusdAddr]).To(Equal(true)) + t := getTransformer(&fakes.MockFullBlockRetriever{}, &fakes.MockParser{}, &fakes.MockPoller{}) + t.SetCreateHashList(fakeAddress, true) + Expect(t.CreateHashList[fakeAddress]).To(Equal(true)) }) }) 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() + blockRetriever := &fakes.MockFullBlockRetriever{} + firstBlock := int64(1) + mostRecentBlock := int64(2) + blockRetriever.FirstBlock = firstBlock + 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.LastBlock).To(Equal(int64(6194634))) - Expect(c.Abi).To(Equal(constants.TusdAbiString)) - Expect(c.Name).To(Equal("TrueUSD")) - Expect(c.Address).To(Equal(tusdAddr)) + Expect(c.StartingBlock).To(Equal(firstBlock)) + Expect(c.LastBlock).To(Equal(mostRecentBlock)) + Expect(c.Abi).To(Equal(fakeAbi)) + Expect(c.Name).To(Equal(fakeContractName)) + 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) - t.SetEvents(constants.TusdContractAddress, []string{"Transfer"}) - err = t.Init() + blockRetriever := &fakes.MockFullBlockRetriever{} + blockRetriever.FirstBlockErr = fakes.FakeError + 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) - blockRepository.CreateOrUpdateBlock(mocks.TransferBlock2) - t := transformer.NewTransformer("", blockChain, db) - err = t.Init() + t := getTransformer(&fakes.MockFullBlockRetriever{}, &fakes.MockParser{}, &fakes.MockPoller{}) + + 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{}, + } +} diff --git a/pkg/omni/light/transformer/transformer_test.go b/pkg/omni/light/transformer/transformer_test.go index 5b914b46..0cc44162 100644 --- a/pkg/omni/light/transformer/transformer_test.go +++ b/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() @@ -150,16 +150,17 @@ var _ = Describe("Transformer", func() { func getFakeTransformer(blockRetriever retriever.BlockRetriever, parsr parser.Parser, pollr poller.Poller) transformer.Transformer { return transformer.Transformer{ - 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{}, + Parser: parsr, + BlockRetriever: blockRetriever, + Poller: pollr, + HeaderRepository: &fakes.MockLightHeaderRepository{}, + 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{}, } }