deep-stack/ipld-eth-server
4
0
Fork 0
forked from cerc-io/ipld-eth-server
Code Pull Requests Activity

Vdb 207 the rest of the repos (#111)

Browse Source 
* Use shared repository test examples for frob

* Use shared repository methods for frob

* Use shared repository test examples for flop kick

* Use shared repository methods for flop kick

* Use shared repository test examples for flip kick

* Use shared repository methods for flip kick

* Use shared repository test examples for bite

* Use shared repository methods for bite

* Alphabetize check headers constants
This commit is contained in:
Elizabeth
2018-11-12 10:50:51 -06:00
committed by GitHub
parent 4f295b9aec
commit 6a43cd4287
9 changed files with 156 additions and 754 deletions
Download Patch File Download Diff File Expand all files Collapse all files
pkg/transformers/flip_kick/repository.go
+5 -29
View File
@@ -19,6 +19,8 @@ import (
"github.com/vulcanize/vulcanizedb/pkg/core"
"github.com/vulcanize/vulcanizedb/pkg/datastore/postgres"
"github.com/vulcanize/vulcanizedb/pkg/transformers/shared"
"github.com/vulcanize/vulcanizedb/pkg/transformers/shared/constants"
)
type FlipKickRepository struct {
@@ -45,10 +47,7 @@ func (fkr FlipKickRepository) Create(headerId int64, models []interface{}) error
return err
}
}
_, err = tx.Exec(`INSERT INTO public.checked_headers (header_id, flip_kick_checked)
VALUES ($1, $2)
ON CONFLICT (header_id) DO
UPDATE SET flip_kick_checked = $2`, headerId, true)
err = shared.MarkHeaderCheckedInTransaction(headerId, tx, constants.FlipKickChecked)
if err != nil {
tx.Rollback()
return err
@@ -57,34 +56,11 @@ func (fkr FlipKickRepository) Create(headerId int64, models []interface{}) error
}
func (fkr FlipKickRepository) MarkHeaderChecked(headerId int64) error {
_, err := fkr.db.Exec(`INSERT INTO public.checked_headers (header_id, flip_kick_checked)
VALUES ($1, $2)
ON CONFLICT (header_id) DO
UPDATE SET flip_kick_checked = $2`, headerId, true)
return err
return shared.MarkHeaderChecked(headerId, fkr.db, constants.FlipKickChecked)
}
func (fkr FlipKickRepository) MissingHeaders(startingBlockNumber, endingBlockNumber int64) ([]core.Header, error) {
var result []core.Header
err := fkr.db.Select(
&result,
`SELECT headers.id, headers.block_number FROM headers
LEFT JOIN checked_headers on headers.id = header_id
WHERE (header_id ISNULL OR flip_kick_checked IS FALSE)
AND headers.block_number >= $1
AND headers.block_number <= $2
AND headers.eth_node_fingerprint = $3`,
startingBlockNumber,
endingBlockNumber,
fkr.db.Node.ID,
)
if err != nil {
fmt.Println("Error:", err)
return result, err
}
return result, nil
return shared.MissingHeaders(startingBlockNumber, endingBlockNumber, fkr.db, constants.FlipKickChecked)
}
func (fkr *FlipKickRepository) SetDB(db *postgres.DB) {
pkg/transformers/flip_kick/repository_test.go
+39 -161
View File
@@ -18,42 +18,46 @@ import (
. "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/transformers/flip_kick"
"github.com/vulcanize/vulcanizedb/pkg/transformers/shared/constants"
"github.com/vulcanize/vulcanizedb/pkg/transformers/test_data"
"github.com/vulcanize/vulcanizedb/pkg/transformers/test_data/shared_behaviors"
"github.com/vulcanize/vulcanizedb/test_config"
)
var _ = Describe("FlipKick Repository", func() {
var db *postgres.DB
var flipKickRepository flip_kick.FlipKickRepository
var headerId int64
var blockNumber int64
var flipKick = test_data.FlipKickModel
BeforeEach(func() {
db = test_config.NewTestDB(test_config.NewTestNode())
test_config.CleanTestDB(db)
flipKickRepository = flip_kick.FlipKickRepository{}
flipKickRepository.SetDB(db)
blockNumber = GinkgoRandomSeed()
headerId = createHeader(db, blockNumber)
_, err := db.Exec(`DELETE from maker.flip_kick;`)
Expect(err).NotTo(HaveOccurred())
})
Describe("Create", func() {
AfterEach(func() {
_, err := db.Exec(`DELETE from headers`)
Expect(err).NotTo(HaveOccurred())
})
modelWithDifferentLogIdx := test_data.FlipKickModel
modelWithDifferentLogIdx.LogIndex++
inputs := shared_behaviors.CreateBehaviorInputs{
CheckedHeaderColumnName: constants.FlipKickChecked,
LogEventTableName: "maker.flip_kick",
TestModel: test_data.FlipKickModel,
ModelWithDifferentLogIdx: modelWithDifferentLogIdx,
Repository: &flipKickRepository,
}
shared_behaviors.SharedRepositoryCreateBehaviors(&inputs)
It("persists flip_kick records", func() {
err := flipKickRepository.Create(headerId, []interface{}{flipKick})
headerRepository := repositories.NewHeaderRepository(db)
headerId, err := headerRepository.CreateOrUpdateHeader(fakes.FakeHeader)
Expect(err).NotTo(HaveOccurred())
err = flipKickRepository.Create(headerId, []interface{}{test_data.FlipKickModel})
Expect(err).NotTo(HaveOccurred())
assertDBRecordCount(db, "maker.flip_kick", 1)
@@ -62,150 +66,35 @@ var _ = Describe("FlipKick Repository", func() {
err = db.QueryRowx(`SELECT * FROM maker.flip_kick`).StructScan(&dbResult)
Expect(err).NotTo(HaveOccurred())
Expect(dbResult.HeaderId).To(Equal(headerId))
Expect(dbResult.BidId).To(Equal(flipKick.BidId))
Expect(dbResult.Lot).To(Equal(flipKick.Lot))
Expect(dbResult.Bid).To(Equal(flipKick.Bid))
Expect(dbResult.Gal).To(Equal(flipKick.Gal))
Expect(dbResult.End.Equal(flipKick.End)).To(BeTrue())
Expect(dbResult.Urn).To(Equal(flipKick.Urn))
Expect(dbResult.Tab).To(Equal(flipKick.Tab))
Expect(dbResult.TransactionIndex).To(Equal(flipKick.TransactionIndex))
Expect(dbResult.LogIndex).To(Equal(flipKick.LogIndex))
Expect(dbResult.Raw).To(MatchJSON(flipKick.Raw))
})
It("marks header checked", func() {
err := flipKickRepository.Create(headerId, []interface{}{flipKick})
Expect(err).NotTo(HaveOccurred())
var headerChecked bool
err = db.Get(&headerChecked, `SELECT flip_kick_checked FROM public.checked_headers WHERE header_id = $1`, headerId)
Expect(err).NotTo(HaveOccurred())
Expect(headerChecked).To(BeTrue())
})
It("updates the header to checked if checked headers row already exists", func() {
_, err := db.Exec(`INSERT INTO public.checked_headers (header_id) VALUES ($1)`, headerId)
Expect(err).NotTo(HaveOccurred())
err = flipKickRepository.Create(headerId, []interface{}{flipKick})
Expect(err).NotTo(HaveOccurred())
var headerChecked bool
err = db.Get(&headerChecked, `SELECT flip_kick_checked FROM public.checked_headers WHERE header_id = $1`, headerId)
Expect(err).NotTo(HaveOccurred())
Expect(headerChecked).To(BeTrue())
})
It("returns an error if inserting the flip_kick record fails", func() {
err := flipKickRepository.Create(headerId, []interface{}{flipKick})
Expect(err).NotTo(HaveOccurred())
err = flipKickRepository.Create(headerId, []interface{}{flipKick})
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("pq: duplicate key value violates unique constraint"))
})
It("allows for multiple flip kick events in one transaction if they have different log indexes", func() {
newFlipKick := test_data.FlipKickModel
newFlipKick.LogIndex = newFlipKick.LogIndex + 1
err := flipKickRepository.Create(headerId, []interface{}{newFlipKick})
Expect(err).NotTo(HaveOccurred())
})
It("deletes the flip_kick records if its corresponding header record is deleted", func() {
err := flipKickRepository.Create(headerId, []interface{}{flipKick})
Expect(err).NotTo(HaveOccurred())
assertDBRecordCount(db, "maker.flip_kick", 1)
assertDBRecordCount(db, "headers", 1)
_, err = db.Exec(`DELETE FROM headers where id = $1`, headerId)
Expect(err).NotTo(HaveOccurred())
assertDBRecordCount(db, "headers", 0)
assertDBRecordCount(db, "maker.flip_kick", 0)
})
It("returns an error if the wrong model type is passed in", func() {
err := flipKickRepository.Create(headerId, []interface{}{test_data.WrongModel{}})
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("model of type"))
Expect(dbResult.BidId).To(Equal(test_data.FlipKickModel.BidId))
Expect(dbResult.Lot).To(Equal(test_data.FlipKickModel.Lot))
Expect(dbResult.Bid).To(Equal(test_data.FlipKickModel.Bid))
Expect(dbResult.Gal).To(Equal(test_data.FlipKickModel.Gal))
Expect(dbResult.End.Equal(test_data.FlipKickModel.End)).To(BeTrue())
Expect(dbResult.Urn).To(Equal(test_data.FlipKickModel.Urn))
Expect(dbResult.Tab).To(Equal(test_data.FlipKickModel.Tab))
Expect(dbResult.TransactionIndex).To(Equal(test_data.FlipKickModel.TransactionIndex))
Expect(dbResult.LogIndex).To(Equal(test_data.FlipKickModel.LogIndex))
Expect(dbResult.Raw).To(MatchJSON(test_data.FlipKickModel.Raw))
})
})
Describe("MarkHeaderChecked", func() {
It("creates a row for a new headerID", func() {
err := flipKickRepository.MarkHeaderChecked(headerId)
inputs := shared_behaviors.MarkedHeaderCheckedBehaviorInputs{
CheckedHeaderColumnName: constants.FlipKickChecked,
Repository: &flipKickRepository,
}
Expect(err).NotTo(HaveOccurred())
var headerChecked bool
err = db.Get(&headerChecked, `SELECT flip_kick_checked FROM public.checked_headers WHERE header_id = $1`, headerId)
Expect(err).NotTo(HaveOccurred())
Expect(headerChecked).To(BeTrue())
})
It("updates row when headerID already exists", func() {
_, err := db.Exec(`INSERT INTO public.checked_headers (header_id) VALUES ($1)`, headerId)
Expect(err).NotTo(HaveOccurred())
err = flipKickRepository.MarkHeaderChecked(headerId)
Expect(err).NotTo(HaveOccurred())
var headerChecked bool
err = db.Get(&headerChecked, `SELECT flip_kick_checked FROM public.checked_headers WHERE header_id = $1`, headerId)
Expect(err).NotTo(HaveOccurred())
Expect(headerChecked).To(BeTrue())
})
shared_behaviors.SharedRepositoryMarkHeaderCheckedBehaviors(&inputs)
})
Describe("When there are multiple nodes", func() {
var db2 *postgres.DB
var flipKickRepository2 flip_kick.FlipKickRepository
Describe("missing headers", func() {
inputs := shared_behaviors.MissingHeadersBehaviorInputs{
Repository: &flipKickRepository,
RepositoryTwo: &flip_kick.FlipKickRepository{},
}
BeforeEach(func() {
//create database for the second node
node2 := core.Node{
GenesisBlock: "GENESIS",
NetworkID: 1,
ID: "node2",
ClientName: "Geth/v1.7.2-stable-1db4ecdc/darwin-amd64/go1.9",
}
db2 = test_config.NewTestDB(node2)
flipKickRepository2 = flip_kick.FlipKickRepository{}
flipKickRepository2.SetDB(db2)
createHeader(db2, blockNumber)
_, err := db2.Exec(`DELETE from maker.flip_kick;`)
Expect(err).NotTo(HaveOccurred())
})
It("only includes missing headers for the current node", func() {
node1missingHeaders, err := flipKickRepository.MissingHeaders(blockNumber, blockNumber)
Expect(err).NotTo(HaveOccurred())
Expect(len(node1missingHeaders)).To(Equal(1))
node2MissingHeaders, err := flipKickRepository2.MissingHeaders(blockNumber, blockNumber)
Expect(err).NotTo(HaveOccurred())
Expect(len(node2MissingHeaders)).To(Equal(1))
})
})
Describe("MissingHeaders", func() {
It("returns headers that haven't been marked as checked", func() {
startingBlock := blockNumber - 3
endingBlock := blockNumber + 3
err := flipKickRepository.MarkHeaderChecked(headerId)
Expect(err).NotTo(HaveOccurred())
newBlockNumber := blockNumber + 3
newHeaderId := createHeader(db, newBlockNumber)
createHeader(db, blockNumber+10) //this one is out of the block range and shouldn't be included
headers, err := flipKickRepository.MissingHeaders(startingBlock, endingBlock)
Expect(len(headers)).To(Equal(1))
Expect(headers[0].Id).To(Equal(newHeaderId))
Expect(headers[0].BlockNumber).To(Equal(newBlockNumber))
})
shared_behaviors.SharedRepositoryMissingHeadersBehaviors(&inputs)
})
})
@@ -216,14 +105,3 @@ func assertDBRecordCount(db *postgres.DB, dbTable string, expectedCount int) {
Expect(err).NotTo(HaveOccurred())
Expect(count).To(Equal(expectedCount))
}
func createHeader(db *postgres.DB, blockNumber int64) (headerId int64) {
headerRepository := repositories.NewHeaderRepository(db)
_, err := headerRepository.CreateOrUpdateHeader(fakes.GetFakeHeader(blockNumber))
Expect(err).NotTo(HaveOccurred())
var dbHeader core.Header
err = db.Get(&dbHeader, `SELECT id, block_number, hash, raw FROM public.headers WHERE block_number = $1 AND eth_node_id = $2`, blockNumber, db.NodeID)
Expect(err).NotTo(HaveOccurred())
return dbHeader.Id
}