WIP update tests for aggregate fetching

libraries/shared/watcher.go

@@ -34,12 +34,12 @@ func NewWatcher(db postgres.DB, bc core.BlockChain) Watcher {
 	fetcher := shared.NewFetcher(bc)
 
 	return Watcher{
-		DB: db,
+		DB:         db,
 		Blockchain: bc,
-		Fetcher: fetcher,
-		Chunker: chunker,
-		Addresses: contractAddresses,
-		Topics: topic0s,
+		Fetcher:    fetcher,
+		Chunker:    chunker,
+		Addresses:  contractAddresses,
+		Topics:     topic0s,
 	}
 }
 

libraries/shared/watcher_test.go

@@ -2,33 +2,49 @@ package shared_test
 
 import (
 	"errors"
-
+	"github.com/ethereum/go-ethereum/core/types"
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
 	"github.com/vulcanize/vulcanizedb/libraries/shared"
 	"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"
 	shared2 "github.com/vulcanize/vulcanizedb/pkg/transformers/shared"
+	"github.com/vulcanize/vulcanizedb/test_config"
 )
 
 type MockTransformer struct {
 	executeWasCalled bool
 	executeError     error
+	passedLogs       []types.Log
+	passedHeader     core.Header
 }
 
-func (mh *MockTransformer) Execute() error {
+func (mh *MockTransformer) Execute(logs []types.Log, header core.Header) error {
 	if mh.executeError != nil {
 		return mh.executeError
 	}
 	mh.executeWasCalled = true
+	mh.passedLogs = logs
+	mh.passedHeader = header
 	return nil
 }
 
-func fakeTransformerInitializer(db *postgres.DB, blockchain core.BlockChain) shared2.Transformer {
+func (mh *MockTransformer) Name() string {
+	return "MockTransformer"
+}
+
+func fakeTransformerInitializer(db *postgres.DB) shared2.Transformer {
 	return &MockTransformer{}
 }
 
 var _ = Describe("Watcher", func() {
+	// TODO Add test for watcher setting the BC
+	// TODO Add tests for log chunk delegation
+	// TODO Add tests for aggregate fetching
+	// TODO Add tests for MissingHeaders
+
 	It("Adds transformers", func() {
 		watcher := shared.Watcher{}
 
@@ -47,24 +63,41 @@ var _ = Describe("Watcher", func() {
 		Expect(len(watcher.Transformers)).To(Equal(2))
 	})
 
-	It("Executes each transformer", func() {
-		watcher := shared.Watcher{}
-		fakeTransformer := &MockTransformer{}
-		watcher.Transformers = []shared2.Transformer{fakeTransformer}
+	Describe("with missing headers", func() {
+		var (
+			db               *postgres.DB
+			watcher          shared.Watcher
+			fakeTransformer  *MockTransformer
+			headerRepository repositories.HeaderRepository
+		)
 
-		watcher.Execute()
+		BeforeEach(func() {
+			db = test_config.NewTestDB(test_config.NewTestNode())
+			test_config.CleanTestDB(db)
+			watcher = shared.NewWatcher(*db, nil)
+			headerRepository = repositories.NewHeaderRepository(db)
+			_, err := headerRepository.CreateOrUpdateHeader(fakes.FakeHeader)
+			Expect(err).NotTo(HaveOccurred())
+		})
 
-		Expect(fakeTransformer.executeWasCalled).To(BeTrue())
-	})
+		It("executes each transformer", func() {
+			fakeTransformer = &MockTransformer{}
+			watcher.Transformers = []shared2.Transformer{fakeTransformer}
 
-	It("Returns an error if transformer returns an error", func() {
-		watcher := shared.Watcher{}
-		fakeTransformer := &MockTransformer{executeError: errors.New("Something bad happened")}
-		watcher.Transformers = []shared2.Transformer{fakeTransformer}
+			err := watcher.Execute()
 
-		err := watcher.Execute()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(fakeTransformer.executeWasCalled).To(BeTrue())
+		})
 
-		Expect(err).To(HaveOccurred())
-		Expect(fakeTransformer.executeWasCalled).To(BeFalse())
+		It("returns an error if transformer returns an error", func() {
+			fakeTransformer = &MockTransformer{executeError: errors.New("Something bad happened")}
+			watcher.Transformers = []shared2.Transformer{fakeTransformer}
+
+			err := watcher.Execute()
+
+			Expect(err).To(HaveOccurred())
+			Expect(fakeTransformer.executeWasCalled).To(BeFalse())
+		})
 	})
 })