mirror of
https://github.com/nspcc-dev/neo-go.git
synced 2024-12-25 03:56:34 +00:00
fc0031e5aa
Simplify Blockchain and associated functions, deduplicate code, fix Get() and Seek() implementations.
156 lines
4 KiB
Go
156 lines
4 KiB
Go
package core
|
|
|
|
import (
|
|
"context"
|
|
"testing"
|
|
|
|
"github.com/CityOfZion/neo-go/pkg/core/storage"
|
|
"github.com/CityOfZion/neo-go/pkg/io"
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/require"
|
|
)
|
|
|
|
func TestAddHeaders(t *testing.T) {
|
|
bc := newTestChain(t)
|
|
h1 := newBlock(1).Header()
|
|
h2 := newBlock(2).Header()
|
|
h3 := newBlock(3).Header()
|
|
|
|
if err := bc.AddHeaders(h1, h2, h3); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
assert.Equal(t, h3.Index, bc.HeaderHeight())
|
|
assert.Equal(t, uint32(0), bc.BlockHeight())
|
|
assert.Equal(t, h3.Hash(), bc.CurrentHeaderHash())
|
|
|
|
// Add them again, they should not be added.
|
|
if err := bc.AddHeaders(h3, h2, h1); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
assert.Equal(t, h3.Index, bc.HeaderHeight())
|
|
assert.Equal(t, uint32(0), bc.BlockHeight())
|
|
assert.Equal(t, h3.Hash(), bc.CurrentHeaderHash())
|
|
}
|
|
|
|
func TestAddBlock(t *testing.T) {
|
|
bc := newTestChain(t)
|
|
blocks := []*Block{
|
|
newBlock(1, newMinerTX()),
|
|
newBlock(2, newMinerTX()),
|
|
newBlock(3, newMinerTX()),
|
|
}
|
|
|
|
for i := 0; i < len(blocks); i++ {
|
|
if err := bc.AddBlock(blocks[i]); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
|
|
lastBlock := blocks[len(blocks)-1]
|
|
assert.Equal(t, lastBlock.Index, bc.HeaderHeight())
|
|
assert.Equal(t, lastBlock.Hash(), bc.CurrentHeaderHash())
|
|
|
|
// This one tests persisting blocks, so it does need to persist()
|
|
require.NoError(t, bc.persist(context.Background()))
|
|
|
|
for _, block := range blocks {
|
|
key := storage.AppendPrefix(storage.DataBlock, block.Hash().BytesReverse())
|
|
if _, err := bc.store.Get(key); err != nil {
|
|
t.Fatalf("block %s not persisted", block.Hash())
|
|
}
|
|
}
|
|
|
|
assert.Equal(t, lastBlock.Index, bc.BlockHeight())
|
|
assert.Equal(t, lastBlock.Hash(), bc.CurrentHeaderHash())
|
|
}
|
|
|
|
func TestGetHeader(t *testing.T) {
|
|
bc := newTestChain(t)
|
|
block := newBlock(1, newMinerTX())
|
|
err := bc.AddBlock(block)
|
|
assert.Nil(t, err)
|
|
|
|
// Test unpersisted and persisted access
|
|
for i := 0; i < 2; i++ {
|
|
hash := block.Hash()
|
|
header, err := bc.GetHeader(hash)
|
|
require.NoError(t, err)
|
|
assert.Equal(t, block.Header(), header)
|
|
|
|
b2 := newBlock(2)
|
|
_, err = bc.GetHeader(b2.Hash())
|
|
assert.Error(t, err)
|
|
assert.NoError(t, bc.persist(context.Background()))
|
|
}
|
|
}
|
|
|
|
func TestGetBlock(t *testing.T) {
|
|
bc := newTestChain(t)
|
|
blocks := makeBlocks(100)
|
|
|
|
for i := 0; i < len(blocks); i++ {
|
|
if err := bc.AddBlock(blocks[i]); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
|
|
// Test unpersisted and persisted access
|
|
for j := 0; j < 2; j++ {
|
|
for i := 0; i < len(blocks); i++ {
|
|
block, err := bc.GetBlock(blocks[i].Hash())
|
|
if err != nil {
|
|
t.Fatalf("can't get block %d: %s, attempt %d", i, err, j)
|
|
}
|
|
assert.Equal(t, blocks[i].Index, block.Index)
|
|
assert.Equal(t, blocks[i].Hash(), block.Hash())
|
|
}
|
|
assert.NoError(t, bc.persist(context.Background()))
|
|
}
|
|
}
|
|
|
|
func TestHasBlock(t *testing.T) {
|
|
bc := newTestChain(t)
|
|
blocks := makeBlocks(50)
|
|
|
|
for i := 0; i < len(blocks); i++ {
|
|
if err := bc.AddBlock(blocks[i]); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
|
|
// Test unpersisted and persisted access
|
|
for j := 0; j < 2; j++ {
|
|
for i := 0; i < len(blocks); i++ {
|
|
assert.True(t, bc.HasBlock(blocks[i].Hash()))
|
|
}
|
|
newBlock := newBlock(51)
|
|
assert.False(t, bc.HasBlock(newBlock.Hash()))
|
|
assert.NoError(t, bc.persist(context.Background()))
|
|
}
|
|
}
|
|
|
|
func TestGetTransaction(t *testing.T) {
|
|
b1 := getDecodedBlock(t, 1)
|
|
block := getDecodedBlock(t, 2)
|
|
bc := newTestChain(t)
|
|
|
|
// These are from some kind of different chain, so can't be added via AddBlock().
|
|
assert.Nil(t, bc.storeBlock(b1))
|
|
assert.Nil(t, bc.storeBlock(block))
|
|
|
|
// Test unpersisted and persisted access
|
|
for j := 0; j < 2; j++ {
|
|
tx, height, err := bc.GetTransaction(block.Transactions[0].Hash())
|
|
require.Nil(t, err)
|
|
assert.Equal(t, block.Index, height)
|
|
assert.Equal(t, block.Transactions[0], tx)
|
|
assert.Equal(t, 10, io.GetVarSize(tx))
|
|
assert.Equal(t, 1, io.GetVarSize(tx.Attributes))
|
|
assert.Equal(t, 1, io.GetVarSize(tx.Inputs))
|
|
assert.Equal(t, 1, io.GetVarSize(tx.Outputs))
|
|
assert.Equal(t, 1, io.GetVarSize(tx.Scripts))
|
|
assert.NoError(t, bc.persist(context.Background()))
|
|
}
|
|
}
|