ipld-eth-server/core/blockchain_db_observer_test.go

181 lines
5.0 KiB
Go
Raw Normal View History

package core_test
import (
"fmt"
"github.com/8thlight/vulcanizedb/core"
"github.com/jmoiron/sqlx"
_ "github.com/lib/pq"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
)
const (
host = "localhost"
port = 5432
user = "postgres"
password = "postgres"
dbname = "vulcanize"
)
var _ = Describe("Saving blocks to the database", func() {
var db *sqlx.DB
var err error
2017-10-31 13:58:04 +00:00
pgConfig := fmt.Sprintf(
"host=%s port=%d user=%s password=%s dbname=%s sslmode=disable",
host, port, user, password, dbname)
BeforeEach(func() {
db, err = sqlx.Connect("postgres", pgConfig)
2017-10-31 13:58:04 +00:00
db.MustExec("DELETE FROM transactions")
db.MustExec("DELETE FROM blocks")
})
It("implements the observer interface", func() {
var observer core.BlockchainObserver = core.BlockchainDBObserver{Db: db}
Expect(observer).NotTo(BeNil())
})
It("connects to the database", func() {
Expect(err).Should(BeNil())
Expect(db).ShouldNot(BeNil())
})
It("starts with no blocks", func() {
var count int
queryError := db.Get(&count, "SELECT COUNT(*) FROM blocks")
Expect(queryError).Should(BeNil())
Expect(count).Should(Equal(0))
})
It("inserts a block", func() {
2017-10-27 20:29:55 +00:00
// setup a block in memory
blockNumber := int64(123)
gasLimit := int64(1000000)
gasUsed := int64(10)
blockTime := int64(1508981640)
block := core.Block{Number: blockNumber, GasLimit: gasLimit, GasUsed: gasUsed, Time: blockTime}
2017-10-27 20:29:55 +00:00
// save the block to the database
observer := core.BlockchainDBObserver{Db: db}
observer.NotifyBlockAdded(block)
2017-10-27 20:29:55 +00:00
// find the saved block
rows, err := db.Query("SELECT block_number, block_gaslimit, block_gasused, block_time FROM blocks")
Expect(err).To(BeNil())
2017-10-27 20:29:55 +00:00
var savedBlocks []core.Block
for rows.Next() {
2017-10-27 20:29:55 +00:00
var blockNumber int64
var blockTime float64
var gasLimit float64
var gasUsed float64
rows.Scan(&blockNumber, &gasLimit, &gasUsed, &blockTime)
savedBlock := core.Block{
GasLimit: int64(gasLimit),
GasUsed: int64(gasUsed),
Number: blockNumber,
Time: int64(blockTime),
2017-10-27 20:29:55 +00:00
}
savedBlocks = append(savedBlocks, savedBlock)
}
2017-10-27 20:29:55 +00:00
// assert against the attributes
Expect(len(savedBlocks)).To(Equal(1))
Expect(savedBlocks[0].Number).To(Equal(blockNumber))
Expect(savedBlocks[0].GasLimit).To(Equal(gasLimit))
Expect(savedBlocks[0].GasUsed).To(Equal(gasUsed))
2017-10-27 20:29:55 +00:00
Expect(savedBlocks[0].Time).To(Equal(blockTime))
})
2017-10-31 13:58:04 +00:00
var _ = Describe("Saving transactions to the database", func() {
It("inserts a transaction", func() {
gasLimit := int64(5000)
gasPrice := int64(3)
nonce := uint64(10000)
to := "1234567890"
value := int64(10)
txRecord := core.Transaction{
Hash: "x1234",
GasPrice: gasPrice,
GasLimit: gasLimit,
Nonce: nonce,
To: to,
Value: value,
}
block := core.Block{Transactions: []core.Transaction{txRecord}}
2017-10-31 13:58:04 +00:00
observer := core.BlockchainDBObserver{Db: db}
observer.NotifyBlockAdded(block)
rows, err := db.Query("SELECT tx_hash, tx_nonce, tx_to, tx_gaslimit, tx_gasprice, tx_value FROM transactions")
Expect(err).To(BeNil())
var savedTransactions []core.Transaction
for rows.Next() {
var dbHash string
var dbNonce uint64
var dbTo string
var dbGasLimit int64
var dbGasPrice int64
var dbValue int64
rows.Scan(&dbHash, &dbNonce, &dbTo, &dbGasLimit, &dbGasPrice, &dbValue)
savedTransaction := core.Transaction{
Hash: dbHash,
Nonce: dbNonce,
To: dbTo,
GasLimit: dbGasLimit,
GasPrice: dbGasPrice,
Value: dbValue,
}
savedTransactions = append(savedTransactions, savedTransaction)
}
Expect(len(savedTransactions)).To(Equal(1))
savedTransaction := savedTransactions[0]
Expect(savedTransaction.Hash).To(Equal(txRecord.Hash))
Expect(savedTransaction.To).To(Equal(to))
Expect(savedTransaction.Nonce).To(Equal(nonce))
Expect(savedTransaction.GasLimit).To(Equal(gasLimit))
Expect(savedTransaction.GasPrice).To(Equal(gasPrice))
Expect(savedTransaction.Value).To(Equal(value))
})
It("associates the transaction with the block", func() {
txRecord := core.Transaction{}
block := core.Block{
Transactions: []core.Transaction{txRecord},
}
observer := core.BlockchainDBObserver{Db: db}
observer.NotifyBlockAdded(block)
blockRows, err := db.Query("SELECT id FROM blocks")
Expect(err).To(BeNil())
var actualBlockIds []int64
for blockRows.Next() {
var actualBlockId int64
blockRows.Scan(&actualBlockId)
actualBlockIds = append(actualBlockIds, actualBlockId)
}
transactionRows, err := db.Query("SELECT block_id FROM transactions")
Expect(err).To(BeNil())
var transactionBlockIds []int64
for transactionRows.Next() {
var transactionBlockId int64
transactionRows.Scan(&transactionBlockId)
transactionBlockIds = append(transactionBlockIds, transactionBlockId)
}
Expect(len(actualBlockIds)).To(Equal(1))
Expect(len(transactionBlockIds)).To(Equal(1))
Expect(transactionBlockIds[0]).To(Equal(actualBlockIds[0]))
})
2017-10-31 13:58:04 +00:00
})
})