436 lines
12 KiB
Go
436 lines
12 KiB
Go
package blockchain
|
|
|
|
import (
|
|
"bytes"
|
|
"fmt"
|
|
"io/ioutil"
|
|
"runtime/debug"
|
|
"strings"
|
|
"testing"
|
|
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/require"
|
|
|
|
"github.com/tendermint/go-wire"
|
|
"github.com/tendermint/go-wire/data"
|
|
"github.com/tendermint/tendermint/types"
|
|
"github.com/tendermint/tmlibs/db"
|
|
)
|
|
|
|
func TestLoadBlockStoreStateJSON(t *testing.T) {
|
|
db := db.NewMemDB()
|
|
|
|
bsj := &BlockStoreStateJSON{Height: 1000}
|
|
bsj.Save(db)
|
|
|
|
retrBSJ := LoadBlockStoreStateJSON(db)
|
|
|
|
assert.Equal(t, *bsj, retrBSJ, "expected the retrieved DBs to match")
|
|
}
|
|
|
|
func TestNewBlockStore(t *testing.T) {
|
|
db := db.NewMemDB()
|
|
db.Set(blockStoreKey, []byte(`{"height": 10000}`))
|
|
bs := NewBlockStore(db)
|
|
assert.Equal(t, bs.Height(), 10000, "failed to properly parse blockstore")
|
|
|
|
panicCausers := []struct {
|
|
data []byte
|
|
wantErr string
|
|
}{
|
|
{[]byte("artful-doger"), "not unmarshal bytes"},
|
|
{[]byte(""), "unmarshal bytes"},
|
|
{[]byte(" "), "unmarshal bytes"},
|
|
}
|
|
|
|
for i, tt := range panicCausers {
|
|
// Expecting a panic here on trying to parse an invalid blockStore
|
|
_, _, panicErr := doFn(func() (interface{}, error) {
|
|
db.Set(blockStoreKey, tt.data)
|
|
_ = NewBlockStore(db)
|
|
return nil, nil
|
|
})
|
|
require.NotNil(t, panicErr, "#%d panicCauser: %q expected a panic", i, tt.data)
|
|
assert.Contains(t, panicErr.Error(), tt.wantErr, "#%d data: %q", i, tt.data)
|
|
}
|
|
|
|
db.Set(blockStoreKey, nil)
|
|
bs = NewBlockStore(db)
|
|
assert.Equal(t, bs.Height(), 0, "expecting nil bytes to be unmarshaled alright")
|
|
}
|
|
|
|
func TestBlockStoreGetReader(t *testing.T) {
|
|
db := db.NewMemDB()
|
|
// Initial setup
|
|
db.Set([]byte("Foo"), []byte("Bar"))
|
|
db.Set([]byte("Foo1"), nil)
|
|
|
|
bs := NewBlockStore(db)
|
|
|
|
tests := [...]struct {
|
|
key []byte
|
|
want []byte
|
|
}{
|
|
0: {key: []byte("Foo"), want: []byte("Bar")},
|
|
1: {key: []byte("KnoxNonExistent"), want: nil},
|
|
2: {key: []byte("Foo1"), want: nil},
|
|
}
|
|
|
|
for i, tt := range tests {
|
|
r := bs.GetReader(tt.key)
|
|
if r == nil {
|
|
assert.Nil(t, tt.want, "#%d: expected a non-nil reader", i)
|
|
continue
|
|
}
|
|
slurp, err := ioutil.ReadAll(r)
|
|
if err != nil {
|
|
t.Errorf("#%d: unexpected Read err: %v", i, err)
|
|
} else {
|
|
assert.Equal(t, slurp, tt.want, "#%d: mismatch", i)
|
|
}
|
|
}
|
|
}
|
|
|
|
func freshBlockStore() (*BlockStore, db.DB) {
|
|
db := db.NewMemDB()
|
|
return NewBlockStore(db), db
|
|
}
|
|
|
|
var (
|
|
// Setup, test data
|
|
// If needed, the parts' data can be generated by running
|
|
// the code at https://gist.github.com/odeke-em/9ffac2b5df44595fad7084ece4c9bd98
|
|
part1 = &types.Part{Index: 0, Bytes: data.Bytes([]byte{
|
|
0x01, 0x01, 0x01, 0x0a, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x74, 0x65,
|
|
0x73, 0x74, 0x01, 0x01, 0xa1, 0xb2, 0x03, 0xeb, 0x3d, 0x1f, 0x44, 0x40, 0x01, 0x64, 0x00,
|
|
})}
|
|
part2 = &types.Part{Index: 1, Bytes: data.Bytes([]byte{
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x00,
|
|
0x00, 0x01, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
})}
|
|
seenCommit1 = &types.Commit{Precommits: []*types.Vote{{Height: 10}}}
|
|
)
|
|
|
|
func TestBlockStoreSaveLoadBlock(t *testing.T) {
|
|
bs, _ := freshBlockStore()
|
|
noBlockHeights := []int{0, -1, 100, 1000, 2}
|
|
for i, height := range noBlockHeights {
|
|
if g := bs.LoadBlock(height); g != nil {
|
|
t.Errorf("#%d: height(%d) got a block; want nil", i, height)
|
|
}
|
|
}
|
|
validPartSet := types.NewPartSetFromHeader(types.PartSetHeader{Total: 2})
|
|
validPartSet.AddPart(part1, false)
|
|
validPartSet.AddPart(part2, false)
|
|
|
|
incompletePartSet := types.NewPartSetFromHeader(types.PartSetHeader{Total: 2})
|
|
|
|
uncontiguousPartSet := types.NewPartSetFromHeader(types.PartSetHeader{Total: 0})
|
|
uncontiguousPartSet.AddPart(part2, false)
|
|
|
|
header1 := types.Header{
|
|
Height: 1,
|
|
NumTxs: 100,
|
|
ChainID: "block_test",
|
|
}
|
|
header2 := header1
|
|
header2.Height = 4
|
|
|
|
// End of setup, test data
|
|
|
|
tuples := []struct {
|
|
block *types.Block
|
|
parts *types.PartSet
|
|
seenCommit *types.Commit
|
|
wantErr bool
|
|
wantPanic string
|
|
|
|
corruptBlockInDB bool
|
|
corruptCommitInDB bool
|
|
corruptSeenCommitInDB bool
|
|
eraseCommitInDB bool
|
|
eraseSeenCommitInDB bool
|
|
}{
|
|
{
|
|
block: &types.Block{
|
|
Header: &header1,
|
|
LastCommit: &types.Commit{Precommits: []*types.Vote{{Height: 10}}},
|
|
},
|
|
parts: validPartSet,
|
|
seenCommit: seenCommit1,
|
|
},
|
|
|
|
{
|
|
block: nil,
|
|
wantPanic: "only save a non-nil block",
|
|
},
|
|
|
|
{
|
|
block: &types.Block{
|
|
Header: &header2,
|
|
LastCommit: &types.Commit{Precommits: []*types.Vote{{Height: 10}}},
|
|
},
|
|
parts: uncontiguousPartSet,
|
|
wantPanic: "only save contiguous blocks", // and incomplete and uncontiguous parts
|
|
},
|
|
|
|
{
|
|
block: &types.Block{
|
|
Header: &header1,
|
|
LastCommit: &types.Commit{Precommits: []*types.Vote{{Height: 10}}},
|
|
},
|
|
parts: incompletePartSet,
|
|
wantPanic: "only save complete block", // incomplete parts
|
|
},
|
|
|
|
{
|
|
block: &types.Block{
|
|
Header: &header1,
|
|
LastCommit: &types.Commit{Precommits: []*types.Vote{{Height: 10}}},
|
|
},
|
|
parts: validPartSet,
|
|
seenCommit: seenCommit1,
|
|
corruptCommitInDB: true, // Corrupt the DB's commit entry
|
|
wantPanic: "rror reading commit",
|
|
},
|
|
|
|
{
|
|
block: &types.Block{
|
|
Header: &header1,
|
|
LastCommit: &types.Commit{Precommits: []*types.Vote{{Height: 10}}},
|
|
},
|
|
parts: validPartSet,
|
|
seenCommit: seenCommit1,
|
|
wantPanic: "rror reading block",
|
|
corruptBlockInDB: true, // Corrupt the DB's block entry
|
|
},
|
|
|
|
{
|
|
block: &types.Block{
|
|
Header: &header1,
|
|
LastCommit: &types.Commit{Precommits: []*types.Vote{{Height: 10}}},
|
|
},
|
|
parts: validPartSet,
|
|
seenCommit: seenCommit1,
|
|
|
|
// Expecting no error and we want a nil back
|
|
eraseSeenCommitInDB: true,
|
|
},
|
|
|
|
{
|
|
block: &types.Block{
|
|
Header: &header1,
|
|
LastCommit: &types.Commit{Precommits: []*types.Vote{{Height: 10}}},
|
|
},
|
|
parts: validPartSet,
|
|
seenCommit: seenCommit1,
|
|
|
|
corruptSeenCommitInDB: true,
|
|
wantPanic: "rror reading commit",
|
|
},
|
|
|
|
{
|
|
block: &types.Block{
|
|
Header: &header1,
|
|
LastCommit: &types.Commit{Precommits: []*types.Vote{{Height: 10}}},
|
|
},
|
|
parts: validPartSet,
|
|
seenCommit: seenCommit1,
|
|
|
|
// Expecting no error and we want a nil back
|
|
eraseCommitInDB: true,
|
|
},
|
|
}
|
|
|
|
type quad struct {
|
|
block *types.Block
|
|
commit *types.Commit
|
|
meta *types.BlockMeta
|
|
|
|
seenCommit *types.Commit
|
|
}
|
|
|
|
for i, tuple := range tuples {
|
|
bs, db := freshBlockStore()
|
|
// SaveBlock
|
|
res, err, panicErr := doFn(func() (interface{}, error) {
|
|
bs.SaveBlock(tuple.block, tuple.parts, tuple.seenCommit)
|
|
if tuple.block == nil {
|
|
return nil, nil
|
|
}
|
|
|
|
if tuple.corruptBlockInDB {
|
|
db.Set(calcBlockMetaKey(tuple.block.Height), []byte("block-bogus"))
|
|
}
|
|
bBlock := bs.LoadBlock(tuple.block.Height)
|
|
bBlockMeta := bs.LoadBlockMeta(tuple.block.Height)
|
|
|
|
if tuple.eraseSeenCommitInDB {
|
|
db.Delete(calcSeenCommitKey(tuple.block.Height))
|
|
}
|
|
if tuple.corruptSeenCommitInDB {
|
|
db.Set(calcSeenCommitKey(tuple.block.Height), []byte("bogus-seen-commit"))
|
|
}
|
|
bSeenCommit := bs.LoadSeenCommit(tuple.block.Height)
|
|
|
|
commitHeight := tuple.block.Height - 1
|
|
if tuple.eraseCommitInDB {
|
|
db.Delete(calcBlockCommitKey(commitHeight))
|
|
}
|
|
if tuple.corruptCommitInDB {
|
|
db.Set(calcBlockCommitKey(commitHeight), []byte("foo-bogus"))
|
|
}
|
|
bCommit := bs.LoadBlockCommit(commitHeight)
|
|
return &quad{block: bBlock, seenCommit: bSeenCommit, commit: bCommit, meta: bBlockMeta}, nil
|
|
})
|
|
|
|
if subStr := tuple.wantPanic; subStr != "" {
|
|
if panicErr == nil {
|
|
t.Errorf("#%d: want a non-nil panic", i)
|
|
} else if got := panicErr.Error(); !strings.Contains(got, subStr) {
|
|
t.Errorf("#%d:\n\tgotErr: %q\nwant substring: %q", i, got, subStr)
|
|
}
|
|
continue
|
|
}
|
|
|
|
if tuple.wantErr {
|
|
if err == nil {
|
|
t.Errorf("#%d: got nil error", i)
|
|
}
|
|
continue
|
|
}
|
|
|
|
assert.Nil(t, panicErr, "#%d: unexpected panic", i)
|
|
assert.Nil(t, err, "#%d: expecting a non-nil error", i)
|
|
qua, ok := res.(*quad)
|
|
if !ok || qua == nil {
|
|
t.Errorf("#%d: got nil quad back; gotType=%T", i, res)
|
|
continue
|
|
}
|
|
if tuple.eraseSeenCommitInDB {
|
|
assert.Nil(t, qua.seenCommit, "erased the seenCommit in the DB hence we should get back a nil seenCommit")
|
|
}
|
|
if tuple.eraseCommitInDB {
|
|
assert.Nil(t, qua.commit, "erased the commit in the DB hence we should get back a nil commit")
|
|
}
|
|
}
|
|
}
|
|
|
|
func binarySerializeIt(v interface{}) []byte {
|
|
var n int
|
|
var err error
|
|
buf := new(bytes.Buffer)
|
|
wire.WriteBinary(v, buf, &n, &err)
|
|
return buf.Bytes()
|
|
}
|
|
|
|
func TestLoadBlockPart(t *testing.T) {
|
|
bs, db := freshBlockStore()
|
|
height, index := 10, 1
|
|
loadPart := func() (interface{}, error) {
|
|
part := bs.LoadBlockPart(height, index)
|
|
return part, nil
|
|
}
|
|
|
|
// Initially no contents.
|
|
// 1. Requesting for a non-existent block shouldn't fail
|
|
res, _, panicErr := doFn(loadPart)
|
|
require.Nil(t, panicErr, "a non-existent block part shouldn't cause a panic")
|
|
require.Nil(t, res, "a non-existent block part should return nil")
|
|
|
|
// 2. Next save a corrupted block then try to load it
|
|
db.Set(calcBlockPartKey(height, index), []byte("Tendermint"))
|
|
res, _, panicErr = doFn(loadPart)
|
|
require.NotNil(t, panicErr, "expecting a non-nil panic")
|
|
require.Contains(t, panicErr.Error(), "Error reading block part")
|
|
|
|
// 3. A good block serialized and saved to the DB should be retrievable
|
|
db.Set(calcBlockPartKey(height, index), binarySerializeIt(part1))
|
|
gotPart, _, panicErr := doFn(loadPart)
|
|
require.Nil(t, panicErr, "an existent and proper block should not panic")
|
|
require.Nil(t, res, "a properly saved block should return a proper block")
|
|
require.Equal(t, gotPart.(*types.Part).Hash(), part1.Hash(), "expecting successful retrieval of previously saved block")
|
|
}
|
|
|
|
func TestLoadBlockMeta(t *testing.T) {
|
|
bs, db := freshBlockStore()
|
|
height := 10
|
|
loadMeta := func() (interface{}, error) {
|
|
meta := bs.LoadBlockMeta(height)
|
|
return meta, nil
|
|
}
|
|
|
|
// Initially no contents.
|
|
// 1. Requesting for a non-existent blockMeta shouldn't fail
|
|
res, _, panicErr := doFn(loadMeta)
|
|
require.Nil(t, panicErr, "a non-existent blockMeta shouldn't cause a panic")
|
|
require.Nil(t, res, "a non-existent blockMeta should return nil")
|
|
|
|
// 2. Next save a corrupted blockMeta then try to load it
|
|
db.Set(calcBlockMetaKey(height), []byte("Tendermint-Meta"))
|
|
res, _, panicErr = doFn(loadMeta)
|
|
require.NotNil(t, panicErr, "expecting a non-nil panic")
|
|
require.Contains(t, panicErr.Error(), "Error reading block meta")
|
|
|
|
// 3. A good blockMeta serialized and saved to the DB should be retrievable
|
|
meta := &types.BlockMeta{}
|
|
db.Set(calcBlockMetaKey(height), binarySerializeIt(meta))
|
|
gotMeta, _, panicErr := doFn(loadMeta)
|
|
require.Nil(t, panicErr, "an existent and proper block should not panic")
|
|
require.Nil(t, res, "a properly saved blockMeta should return a proper blocMeta ")
|
|
require.Equal(t, binarySerializeIt(meta), binarySerializeIt(gotMeta), "expecting successful retrieval of previously saved blockMeta")
|
|
}
|
|
|
|
func TestBlockFetchAtHeight(t *testing.T) {
|
|
bs, _ := freshBlockStore()
|
|
block := &types.Block{
|
|
Header: &types.Header{
|
|
Height: 1,
|
|
NumTxs: 100,
|
|
ChainID: "block_test",
|
|
},
|
|
LastCommit: &types.Commit{Precommits: []*types.Vote{{Height: 10}}},
|
|
}
|
|
seenCommit := seenCommit1
|
|
validPartSet := types.NewPartSetFromHeader(types.PartSetHeader{Total: 2})
|
|
validPartSet.AddPart(part1, false)
|
|
validPartSet.AddPart(part2, false)
|
|
parts := validPartSet
|
|
|
|
require.Equal(t, bs.Height(), 0, "initially the height should be zero")
|
|
require.NotEqual(t, bs.Height(), block.Header.Height, "expecting different heights initially")
|
|
|
|
bs.SaveBlock(block, parts, seenCommit)
|
|
require.Equal(t, bs.Height(), block.Header.Height, "expecting the new height to be changed")
|
|
|
|
blockAtHeight := bs.LoadBlock(bs.Height())
|
|
require.Equal(t, block.Hash(), blockAtHeight.Hash(), "expecting a successful load of the last saved block")
|
|
|
|
blockAtHeightPlus1 := bs.LoadBlock(bs.Height() + 1)
|
|
require.Nil(t, blockAtHeightPlus1, "expecting an unsuccessful load of Height()+1")
|
|
blockAtHeightPlus2 := bs.LoadBlock(bs.Height() + 2)
|
|
require.Nil(t, blockAtHeightPlus2, "expecting an unsuccessful load of Height()+2")
|
|
}
|
|
|
|
func doFn(fn func() (interface{}, error)) (res interface{}, err error, panicErr error) {
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
switch e := r.(type) {
|
|
case error:
|
|
panicErr = e
|
|
case string:
|
|
panicErr = fmt.Errorf("%s", e)
|
|
default:
|
|
if st, ok := r.(fmt.Stringer); ok {
|
|
panicErr = fmt.Errorf("%s", st)
|
|
} else {
|
|
panicErr = fmt.Errorf("%s", debug.Stack())
|
|
}
|
|
}
|
|
}
|
|
}()
|
|
|
|
res, err = fn()
|
|
return res, err, panicErr
|
|
}
|