Extract shared repository tests to helper

This commit is contained in:
Eric Meyer 2017-11-13 15:39:44 -06:00
parent 2a947add95
commit 9b4e170e14
2 changed files with 252 additions and 246 deletions

View File

@ -16,251 +16,8 @@ import (
var _ = Describe("Repositories", func() {
AssertRepositoryBehavior := func(buildRepository func() repositories.Repository) {
var repository repositories.Repository
BeforeEach(func() {
repository = buildRepository()
})
Describe("Saving blocks", func() {
It("starts with no blocks", func() {
count := repository.BlockCount()
Expect(count).Should(Equal(0))
})
It("increments the block count", func() {
block := core.Block{Number: 123}
repository.CreateBlock(block)
Expect(repository.BlockCount()).To(Equal(1))
})
It("saves the attributes of the block", func() {
blockNumber := int64(123)
gasLimit := int64(1000000)
gasUsed := int64(10)
blockHash := "x123"
blockParentHash := "x456"
blockNonce := "0x881db2ca900682e9a9"
blockTime := int64(1508981640)
uncleHash := "x789"
blockSize := int64(1000)
difficulty := int64(10)
block := core.Block{
Difficulty: difficulty,
GasLimit: gasLimit,
GasUsed: gasUsed,
Hash: blockHash,
Nonce: blockNonce,
Number: blockNumber,
ParentHash: blockParentHash,
Size: blockSize,
Time: blockTime,
UncleHash: uncleHash,
}
repository.CreateBlock(block)
savedBlock := repository.FindBlockByNumber(blockNumber)
Expect(savedBlock.Difficulty).To(Equal(difficulty))
Expect(savedBlock.GasLimit).To(Equal(gasLimit))
Expect(savedBlock.GasUsed).To(Equal(gasUsed))
Expect(savedBlock.Hash).To(Equal(blockHash))
Expect(savedBlock.Nonce).To(Equal(blockNonce))
Expect(savedBlock.Number).To(Equal(blockNumber))
Expect(savedBlock.ParentHash).To(Equal(blockParentHash))
Expect(savedBlock.Size).To(Equal(blockSize))
Expect(savedBlock.Time).To(Equal(blockTime))
Expect(savedBlock.UncleHash).To(Equal(uncleHash))
})
It("does not find a block when searching for a number that does not exist", func() {
savedBlock := repository.FindBlockByNumber(111)
Expect(savedBlock).To(BeNil())
})
It("saves one transaction associated to the block", func() {
block := core.Block{
Number: 123,
Transactions: []core.Transaction{{}},
}
repository.CreateBlock(block)
savedBlock := repository.FindBlockByNumber(123)
Expect(len(savedBlock.Transactions)).To(Equal(1))
})
It("saves two transactions associated to the block", func() {
block := core.Block{
Number: 123,
Transactions: []core.Transaction{{}, {}},
}
repository.CreateBlock(block)
savedBlock := repository.FindBlockByNumber(123)
Expect(len(savedBlock.Transactions)).To(Equal(2))
})
It("saves the attributes associated to a transaction", func() {
gasLimit := int64(5000)
gasPrice := int64(3)
nonce := uint64(10000)
to := "1234567890"
from := "0987654321"
value := int64(10)
transaction := core.Transaction{
Hash: "x1234",
GasPrice: gasPrice,
GasLimit: gasLimit,
Nonce: nonce,
To: to,
From: from,
Value: value,
}
block := core.Block{
Number: 123,
Transactions: []core.Transaction{transaction},
}
repository.CreateBlock(block)
savedBlock := repository.FindBlockByNumber(123)
Expect(len(savedBlock.Transactions)).To(Equal(1))
savedTransaction := savedBlock.Transactions[0]
Expect(savedTransaction.Hash).To(Equal(transaction.Hash))
Expect(savedTransaction.To).To(Equal(to))
Expect(savedTransaction.From).To(Equal(from))
Expect(savedTransaction.Nonce).To(Equal(nonce))
Expect(savedTransaction.GasLimit).To(Equal(gasLimit))
Expect(savedTransaction.GasPrice).To(Equal(gasPrice))
Expect(savedTransaction.Value).To(Equal(value))
})
})
Describe("The missing block numbers", func() {
It("is empty the starting block number is the highest known block number", func() {
repository.CreateBlock(core.Block{Number: 1})
Expect(len(repository.MissingBlockNumbers(1, 1))).To(Equal(0))
})
It("is the only missing block number", func() {
repository.CreateBlock(core.Block{Number: 2})
Expect(repository.MissingBlockNumbers(1, 2)).To(Equal([]int64{1}))
})
It("is both missing block numbers", func() {
repository.CreateBlock(core.Block{Number: 3})
Expect(repository.MissingBlockNumbers(1, 3)).To(Equal([]int64{1, 2}))
})
It("goes back to the starting block number", func() {
repository.CreateBlock(core.Block{Number: 6})
Expect(repository.MissingBlockNumbers(4, 6)).To(Equal([]int64{4, 5}))
})
It("only includes missing block numbers", func() {
repository.CreateBlock(core.Block{Number: 4})
repository.CreateBlock(core.Block{Number: 6})
Expect(repository.MissingBlockNumbers(4, 6)).To(Equal([]int64{5}))
})
It("is a list with multiple gaps", func() {
repository.CreateBlock(core.Block{Number: 4})
repository.CreateBlock(core.Block{Number: 5})
repository.CreateBlock(core.Block{Number: 8})
repository.CreateBlock(core.Block{Number: 10})
Expect(repository.MissingBlockNumbers(3, 10)).To(Equal([]int64{3, 6, 7, 9}))
})
It("returns empty array when lower bound exceeds upper bound", func() {
Expect(repository.MissingBlockNumbers(10000, 1)).To(Equal([]int64{}))
})
It("only returns requested range even when other gaps exist", func() {
repository.CreateBlock(core.Block{Number: 3})
repository.CreateBlock(core.Block{Number: 8})
Expect(repository.MissingBlockNumbers(1, 5)).To(Equal([]int64{1, 2, 4, 5}))
})
})
Describe("The max block numbers", func() {
It("returns the block number when a single block", func() {
repository.CreateBlock(core.Block{Number: 1})
Expect(repository.MaxBlockNumber()).To(Equal(int64(1)))
})
It("returns highest known block number when multiple blocks", func() {
repository.CreateBlock(core.Block{Number: 1})
repository.CreateBlock(core.Block{Number: 10})
Expect(repository.MaxBlockNumber()).To(Equal(int64(10)))
})
})
Describe("Creating watched contracts", func() {
It("returns the watched contract when it exists", func() {
repository.CreateWatchedContract(core.WatchedContract{Hash: "x123"})
watchedContract := repository.FindWatchedContract("x123")
Expect(watchedContract).NotTo(BeNil())
Expect(watchedContract.Hash).To(Equal("x123"))
Expect(repository.IsWatchedContract("x123")).To(BeTrue())
Expect(repository.IsWatchedContract("x456")).To(BeFalse())
})
It("returns nil if contract does not exist", func() {
watchedContract := repository.FindWatchedContract("x123")
Expect(watchedContract).To(BeNil())
})
It("returns empty array when no transactions 'To' a watched contract", func() {
repository.CreateWatchedContract(core.WatchedContract{Hash: "x123"})
watchedContract := repository.FindWatchedContract("x123")
Expect(watchedContract).ToNot(BeNil())
Expect(watchedContract.Transactions).To(BeEmpty())
})
It("returns transactions 'To' a watched contract", func() {
block := core.Block{
Number: 123,
Transactions: []core.Transaction{
{Hash: "TRANSACTION1", To: "x123"},
{Hash: "TRANSACTION2", To: "x345"},
{Hash: "TRANSACTION3", To: "x123"},
},
}
repository.CreateBlock(block)
repository.CreateWatchedContract(core.WatchedContract{Hash: "x123"})
watchedContract := repository.FindWatchedContract("x123")
Expect(watchedContract).ToNot(BeNil())
Expect(watchedContract.Transactions).To(
Equal([]core.Transaction{
{Hash: "TRANSACTION1", To: "x123"},
{Hash: "TRANSACTION3", To: "x123"},
}))
})
})
}
Describe("In memory repository", func() {
AssertRepositoryBehavior(func() repositories.Repository {
testing.AssertRepositoryBehavior(func() repositories.Repository {
return repositories.NewInMemory()
})
})
@ -310,7 +67,7 @@ var _ = Describe("Repositories", func() {
Expect(savedBlock).To(BeNil())
})
AssertRepositoryBehavior(func() repositories.Repository {
testing.AssertRepositoryBehavior(func() repositories.Repository {
cfg, _ := config.NewConfig("private")
repository := repositories.NewPostgres(cfg.Database)
testing.ClearData(repository)

View File

@ -1,9 +1,258 @@
package testing
import "github.com/8thlight/vulcanizedb/pkg/repositories"
import (
"github.com/8thlight/vulcanizedb/pkg/core"
"github.com/8thlight/vulcanizedb/pkg/repositories"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
)
func ClearData(postgres repositories.Postgres) {
postgres.Db.MustExec("DELETE FROM watched_contracts")
postgres.Db.MustExec("DELETE FROM transactions")
postgres.Db.MustExec("DELETE FROM blocks")
}
func AssertRepositoryBehavior(buildRepository func() repositories.Repository) {
var repository repositories.Repository
BeforeEach(func() {
repository = buildRepository()
})
Describe("Saving blocks", func() {
It("starts with no blocks", func() {
count := repository.BlockCount()
Expect(count).Should(Equal(0))
})
It("increments the block count", func() {
block := core.Block{Number: 123}
repository.CreateBlock(block)
Expect(repository.BlockCount()).To(Equal(1))
})
It("saves the attributes of the block", func() {
blockNumber := int64(123)
gasLimit := int64(1000000)
gasUsed := int64(10)
blockHash := "x123"
blockParentHash := "x456"
blockNonce := "0x881db2ca900682e9a9"
blockTime := int64(1508981640)
uncleHash := "x789"
blockSize := int64(1000)
difficulty := int64(10)
block := core.Block{
Difficulty: difficulty,
GasLimit: gasLimit,
GasUsed: gasUsed,
Hash: blockHash,
Nonce: blockNonce,
Number: blockNumber,
ParentHash: blockParentHash,
Size: blockSize,
Time: blockTime,
UncleHash: uncleHash,
}
repository.CreateBlock(block)
savedBlock := repository.FindBlockByNumber(blockNumber)
Expect(savedBlock.Difficulty).To(Equal(difficulty))
Expect(savedBlock.GasLimit).To(Equal(gasLimit))
Expect(savedBlock.GasUsed).To(Equal(gasUsed))
Expect(savedBlock.Hash).To(Equal(blockHash))
Expect(savedBlock.Nonce).To(Equal(blockNonce))
Expect(savedBlock.Number).To(Equal(blockNumber))
Expect(savedBlock.ParentHash).To(Equal(blockParentHash))
Expect(savedBlock.Size).To(Equal(blockSize))
Expect(savedBlock.Time).To(Equal(blockTime))
Expect(savedBlock.UncleHash).To(Equal(uncleHash))
})
It("does not find a block when searching for a number that does not exist", func() {
savedBlock := repository.FindBlockByNumber(111)
Expect(savedBlock).To(BeNil())
})
It("saves one transaction associated to the block", func() {
block := core.Block{
Number: 123,
Transactions: []core.Transaction{{}},
}
repository.CreateBlock(block)
savedBlock := repository.FindBlockByNumber(123)
Expect(len(savedBlock.Transactions)).To(Equal(1))
})
It("saves two transactions associated to the block", func() {
block := core.Block{
Number: 123,
Transactions: []core.Transaction{{}, {}},
}
repository.CreateBlock(block)
savedBlock := repository.FindBlockByNumber(123)
Expect(len(savedBlock.Transactions)).To(Equal(2))
})
It("saves the attributes associated to a transaction", func() {
gasLimit := int64(5000)
gasPrice := int64(3)
nonce := uint64(10000)
to := "1234567890"
from := "0987654321"
value := int64(10)
transaction := core.Transaction{
Hash: "x1234",
GasPrice: gasPrice,
GasLimit: gasLimit,
Nonce: nonce,
To: to,
From: from,
Value: value,
}
block := core.Block{
Number: 123,
Transactions: []core.Transaction{transaction},
}
repository.CreateBlock(block)
savedBlock := repository.FindBlockByNumber(123)
Expect(len(savedBlock.Transactions)).To(Equal(1))
savedTransaction := savedBlock.Transactions[0]
Expect(savedTransaction.Hash).To(Equal(transaction.Hash))
Expect(savedTransaction.To).To(Equal(to))
Expect(savedTransaction.From).To(Equal(from))
Expect(savedTransaction.Nonce).To(Equal(nonce))
Expect(savedTransaction.GasLimit).To(Equal(gasLimit))
Expect(savedTransaction.GasPrice).To(Equal(gasPrice))
Expect(savedTransaction.Value).To(Equal(value))
})
})
Describe("The missing block numbers", func() {
It("is empty the starting block number is the highest known block number", func() {
repository.CreateBlock(core.Block{Number: 1})
Expect(len(repository.MissingBlockNumbers(1, 1))).To(Equal(0))
})
It("is the only missing block number", func() {
repository.CreateBlock(core.Block{Number: 2})
Expect(repository.MissingBlockNumbers(1, 2)).To(Equal([]int64{1}))
})
It("is both missing block numbers", func() {
repository.CreateBlock(core.Block{Number: 3})
Expect(repository.MissingBlockNumbers(1, 3)).To(Equal([]int64{1, 2}))
})
It("goes back to the starting block number", func() {
repository.CreateBlock(core.Block{Number: 6})
Expect(repository.MissingBlockNumbers(4, 6)).To(Equal([]int64{4, 5}))
})
It("only includes missing block numbers", func() {
repository.CreateBlock(core.Block{Number: 4})
repository.CreateBlock(core.Block{Number: 6})
Expect(repository.MissingBlockNumbers(4, 6)).To(Equal([]int64{5}))
})
It("is a list with multiple gaps", func() {
repository.CreateBlock(core.Block{Number: 4})
repository.CreateBlock(core.Block{Number: 5})
repository.CreateBlock(core.Block{Number: 8})
repository.CreateBlock(core.Block{Number: 10})
Expect(repository.MissingBlockNumbers(3, 10)).To(Equal([]int64{3, 6, 7, 9}))
})
It("returns empty array when lower bound exceeds upper bound", func() {
Expect(repository.MissingBlockNumbers(10000, 1)).To(Equal([]int64{}))
})
It("only returns requested range even when other gaps exist", func() {
repository.CreateBlock(core.Block{Number: 3})
repository.CreateBlock(core.Block{Number: 8})
Expect(repository.MissingBlockNumbers(1, 5)).To(Equal([]int64{1, 2, 4, 5}))
})
})
Describe("The max block numbers", func() {
It("returns the block number when a single block", func() {
repository.CreateBlock(core.Block{Number: 1})
Expect(repository.MaxBlockNumber()).To(Equal(int64(1)))
})
It("returns highest known block number when multiple blocks", func() {
repository.CreateBlock(core.Block{Number: 1})
repository.CreateBlock(core.Block{Number: 10})
Expect(repository.MaxBlockNumber()).To(Equal(int64(10)))
})
})
Describe("Creating watched contracts", func() {
It("returns the watched contract when it exists", func() {
repository.CreateWatchedContract(core.WatchedContract{Hash: "x123"})
watchedContract := repository.FindWatchedContract("x123")
Expect(watchedContract).NotTo(BeNil())
Expect(watchedContract.Hash).To(Equal("x123"))
Expect(repository.IsWatchedContract("x123")).To(BeTrue())
Expect(repository.IsWatchedContract("x456")).To(BeFalse())
})
It("returns nil if contract does not exist", func() {
watchedContract := repository.FindWatchedContract("x123")
Expect(watchedContract).To(BeNil())
})
It("returns empty array when no transactions 'To' a watched contract", func() {
repository.CreateWatchedContract(core.WatchedContract{Hash: "x123"})
watchedContract := repository.FindWatchedContract("x123")
Expect(watchedContract).ToNot(BeNil())
Expect(watchedContract.Transactions).To(BeEmpty())
})
It("returns transactions 'To' a watched contract", func() {
block := core.Block{
Number: 123,
Transactions: []core.Transaction{
{Hash: "TRANSACTION1", To: "x123"},
{Hash: "TRANSACTION2", To: "x345"},
{Hash: "TRANSACTION3", To: "x123"},
},
}
repository.CreateBlock(block)
repository.CreateWatchedContract(core.WatchedContract{Hash: "x123"})
watchedContract := repository.FindWatchedContract("x123")
Expect(watchedContract).ToNot(BeNil())
Expect(watchedContract.Transactions).To(
Equal([]core.Transaction{
{Hash: "TRANSACTION1", To: "x123"},
{Hash: "TRANSACTION3", To: "x123"},
}))
})
})
}