bd4e64d1d4
This is mostly a backport of some of the same modifications made in Decred along with a few additional things cleaned up. In particular, this updates the code to make use of the new chainhash package. Also, since this required API changes anyways and the hash algorithm is no longer tied specifically to SHA, all other functions throughout the code base which had "Sha" in their name have been changed to Hash so they are not incorrectly implying the hash algorithm. The following is an overview of the changes: - Remove the wire.ShaHash type - Update all references to wire.ShaHash to the new chainhash.Hash type - Rename the following functions and update all references: - wire.BlockHeader.BlockSha -> BlockHash - wire.MsgBlock.BlockSha -> BlockHash - wire.MsgBlock.TxShas -> TxHashes - wire.MsgTx.TxSha -> TxHash - blockchain.ShaHashToBig -> HashToBig - peer.ShaFunc -> peer.HashFunc - Rename all variables that included sha in their name to include hash instead - Update for function name changes in other dependent packages such as btcutil - Update copyright dates on all modified files - Update glide.lock file to use the required version of btcutil
2324 lines
64 KiB
Go
2324 lines
64 KiB
Go
// Copyright (c) 2015-2016 The btcsuite developers
|
|
// Use of this source code is governed by an ISC
|
|
// license that can be found in the LICENSE file.
|
|
|
|
// This file intended to be copied into each backend driver directory. Each
|
|
// driver should have their own driver_test.go file which creates a database and
|
|
// invokes the testInterface function in this file to ensure the driver properly
|
|
// implements the interface.
|
|
//
|
|
// NOTE: When copying this file into the backend driver folder, the package name
|
|
// will need to be changed accordingly.
|
|
|
|
package ffldb_test
|
|
|
|
import (
|
|
"bytes"
|
|
"compress/bzip2"
|
|
"encoding/binary"
|
|
"fmt"
|
|
"io"
|
|
"os"
|
|
"path/filepath"
|
|
"reflect"
|
|
"sync/atomic"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/btcsuite/btcd/chaincfg"
|
|
"github.com/btcsuite/btcd/chaincfg/chainhash"
|
|
"github.com/btcsuite/btcd/database"
|
|
"github.com/btcsuite/btcd/wire"
|
|
"github.com/btcsuite/btcutil"
|
|
)
|
|
|
|
var (
|
|
// blockDataNet is the expected network in the test block data.
|
|
blockDataNet = wire.MainNet
|
|
|
|
// blockDataFile is the path to a file containing the first 256 blocks
|
|
// of the block chain.
|
|
blockDataFile = filepath.Join("..", "testdata", "blocks1-256.bz2")
|
|
|
|
// errSubTestFail is used to signal that a sub test returned false.
|
|
errSubTestFail = fmt.Errorf("sub test failure")
|
|
)
|
|
|
|
// loadBlocks loads the blocks contained in the testdata directory and returns
|
|
// a slice of them.
|
|
func loadBlocks(t *testing.T, dataFile string, network wire.BitcoinNet) ([]*btcutil.Block, error) {
|
|
// Open the file that contains the blocks for reading.
|
|
fi, err := os.Open(dataFile)
|
|
if err != nil {
|
|
t.Errorf("failed to open file %v, err %v", dataFile, err)
|
|
return nil, err
|
|
}
|
|
defer func() {
|
|
if err := fi.Close(); err != nil {
|
|
t.Errorf("failed to close file %v %v", dataFile,
|
|
err)
|
|
}
|
|
}()
|
|
dr := bzip2.NewReader(fi)
|
|
|
|
// Set the first block as the genesis block.
|
|
blocks := make([]*btcutil.Block, 0, 256)
|
|
genesis := btcutil.NewBlock(chaincfg.MainNetParams.GenesisBlock)
|
|
blocks = append(blocks, genesis)
|
|
|
|
// Load the remaining blocks.
|
|
for height := 1; ; height++ {
|
|
var net uint32
|
|
err := binary.Read(dr, binary.LittleEndian, &net)
|
|
if err == io.EOF {
|
|
// Hit end of file at the expected offset. No error.
|
|
break
|
|
}
|
|
if err != nil {
|
|
t.Errorf("Failed to load network type for block %d: %v",
|
|
height, err)
|
|
return nil, err
|
|
}
|
|
if net != uint32(network) {
|
|
t.Errorf("Block doesn't match network: %v expects %v",
|
|
net, network)
|
|
return nil, err
|
|
}
|
|
|
|
var blockLen uint32
|
|
err = binary.Read(dr, binary.LittleEndian, &blockLen)
|
|
if err != nil {
|
|
t.Errorf("Failed to load block size for block %d: %v",
|
|
height, err)
|
|
return nil, err
|
|
}
|
|
|
|
// Read the block.
|
|
blockBytes := make([]byte, blockLen)
|
|
_, err = io.ReadFull(dr, blockBytes)
|
|
if err != nil {
|
|
t.Errorf("Failed to load block %d: %v", height, err)
|
|
return nil, err
|
|
}
|
|
|
|
// Deserialize and store the block.
|
|
block, err := btcutil.NewBlockFromBytes(blockBytes)
|
|
if err != nil {
|
|
t.Errorf("Failed to parse block %v: %v", height, err)
|
|
return nil, err
|
|
}
|
|
blocks = append(blocks, block)
|
|
}
|
|
|
|
return blocks, nil
|
|
}
|
|
|
|
// checkDbError ensures the passed error is a database.Error with an error code
|
|
// that matches the passed error code.
|
|
func checkDbError(t *testing.T, testName string, gotErr error, wantErrCode database.ErrorCode) bool {
|
|
dbErr, ok := gotErr.(database.Error)
|
|
if !ok {
|
|
t.Errorf("%s: unexpected error type - got %T, want %T",
|
|
testName, gotErr, database.Error{})
|
|
return false
|
|
}
|
|
if dbErr.ErrorCode != wantErrCode {
|
|
t.Errorf("%s: unexpected error code - got %s (%s), want %s",
|
|
testName, dbErr.ErrorCode, dbErr.Description,
|
|
wantErrCode)
|
|
return false
|
|
}
|
|
|
|
return true
|
|
}
|
|
|
|
// testContext is used to store context information about a running test which
|
|
// is passed into helper functions.
|
|
type testContext struct {
|
|
t *testing.T
|
|
db database.DB
|
|
bucketDepth int
|
|
isWritable bool
|
|
blocks []*btcutil.Block
|
|
}
|
|
|
|
// keyPair houses a key/value pair. It is used over maps so ordering can be
|
|
// maintained.
|
|
type keyPair struct {
|
|
key []byte
|
|
value []byte
|
|
}
|
|
|
|
// lookupKey is a convenience method to lookup the requested key from the
|
|
// provided keypair slice along with whether or not the key was found.
|
|
func lookupKey(key []byte, values []keyPair) ([]byte, bool) {
|
|
for _, item := range values {
|
|
if bytes.Equal(item.key, key) {
|
|
return item.value, true
|
|
}
|
|
}
|
|
|
|
return nil, false
|
|
}
|
|
|
|
// toGetValues returns a copy of the provided keypairs with all of the nil
|
|
// values set to an empty byte slice. This is used to ensure that keys set to
|
|
// nil values result in empty byte slices when retrieved instead of nil.
|
|
func toGetValues(values []keyPair) []keyPair {
|
|
ret := make([]keyPair, len(values))
|
|
copy(ret, values)
|
|
for i := range ret {
|
|
if ret[i].value == nil {
|
|
ret[i].value = make([]byte, 0)
|
|
}
|
|
}
|
|
return ret
|
|
}
|
|
|
|
// rollbackValues returns a copy of the provided keypairs with all values set to
|
|
// nil. This is used to test that values are properly rolled back.
|
|
func rollbackValues(values []keyPair) []keyPair {
|
|
ret := make([]keyPair, len(values))
|
|
copy(ret, values)
|
|
for i := range ret {
|
|
ret[i].value = nil
|
|
}
|
|
return ret
|
|
}
|
|
|
|
// testCursorKeyPair checks that the provide key and value match the expected
|
|
// keypair at the provided index. It also ensures the index is in range for the
|
|
// provided slice of expected keypairs.
|
|
func testCursorKeyPair(tc *testContext, k, v []byte, index int, values []keyPair) bool {
|
|
if index >= len(values) || index < 0 {
|
|
tc.t.Errorf("Cursor: exceeded the expected range of values - "+
|
|
"index %d, num values %d", index, len(values))
|
|
return false
|
|
}
|
|
|
|
pair := &values[index]
|
|
if !bytes.Equal(k, pair.key) {
|
|
tc.t.Errorf("Mismatched cursor key: index %d does not match "+
|
|
"the expected key - got %q, want %q", index, k,
|
|
pair.key)
|
|
return false
|
|
}
|
|
if !bytes.Equal(v, pair.value) {
|
|
tc.t.Errorf("Mismatched cursor value: index %d does not match "+
|
|
"the expected value - got %q, want %q", index, v,
|
|
pair.value)
|
|
return false
|
|
}
|
|
|
|
return true
|
|
}
|
|
|
|
// testGetValues checks that all of the provided key/value pairs can be
|
|
// retrieved from the database and the retrieved values match the provided
|
|
// values.
|
|
func testGetValues(tc *testContext, bucket database.Bucket, values []keyPair) bool {
|
|
for _, item := range values {
|
|
gotValue := bucket.Get(item.key)
|
|
if !reflect.DeepEqual(gotValue, item.value) {
|
|
tc.t.Errorf("Get: unexpected value for %q - got %q, "+
|
|
"want %q", item.key, gotValue, item.value)
|
|
return false
|
|
}
|
|
}
|
|
|
|
return true
|
|
}
|
|
|
|
// testPutValues stores all of the provided key/value pairs in the provided
|
|
// bucket while checking for errors.
|
|
func testPutValues(tc *testContext, bucket database.Bucket, values []keyPair) bool {
|
|
for _, item := range values {
|
|
if err := bucket.Put(item.key, item.value); err != nil {
|
|
tc.t.Errorf("Put: unexpected error: %v", err)
|
|
return false
|
|
}
|
|
}
|
|
|
|
return true
|
|
}
|
|
|
|
// testDeleteValues removes all of the provided key/value pairs from the
|
|
// provided bucket.
|
|
func testDeleteValues(tc *testContext, bucket database.Bucket, values []keyPair) bool {
|
|
for _, item := range values {
|
|
if err := bucket.Delete(item.key); err != nil {
|
|
tc.t.Errorf("Delete: unexpected error: %v", err)
|
|
return false
|
|
}
|
|
}
|
|
|
|
return true
|
|
}
|
|
|
|
// testCursorInterface ensures the cursor itnerface is working properly by
|
|
// exercising all of its functions on the passed bucket.
|
|
func testCursorInterface(tc *testContext, bucket database.Bucket) bool {
|
|
// Ensure a cursor can be obtained for the bucket.
|
|
cursor := bucket.Cursor()
|
|
if cursor == nil {
|
|
tc.t.Error("Bucket.Cursor: unexpected nil cursor returned")
|
|
return false
|
|
}
|
|
|
|
// Ensure the cursor returns the same bucket it was created for.
|
|
if cursor.Bucket() != bucket {
|
|
tc.t.Error("Cursor.Bucket: does not match the bucket it was " +
|
|
"created for")
|
|
return false
|
|
}
|
|
|
|
if tc.isWritable {
|
|
unsortedValues := []keyPair{
|
|
{[]byte("cursor"), []byte("val1")},
|
|
{[]byte("abcd"), []byte("val2")},
|
|
{[]byte("bcd"), []byte("val3")},
|
|
{[]byte("defg"), nil},
|
|
}
|
|
sortedValues := []keyPair{
|
|
{[]byte("abcd"), []byte("val2")},
|
|
{[]byte("bcd"), []byte("val3")},
|
|
{[]byte("cursor"), []byte("val1")},
|
|
{[]byte("defg"), nil},
|
|
}
|
|
|
|
// Store the values to be used in the cursor tests in unsorted
|
|
// order and ensure they were actually stored.
|
|
if !testPutValues(tc, bucket, unsortedValues) {
|
|
return false
|
|
}
|
|
if !testGetValues(tc, bucket, toGetValues(unsortedValues)) {
|
|
return false
|
|
}
|
|
|
|
// Ensure the cursor returns all items in byte-sorted order when
|
|
// iterating forward.
|
|
curIdx := 0
|
|
for ok := cursor.First(); ok; ok = cursor.Next() {
|
|
k, v := cursor.Key(), cursor.Value()
|
|
if !testCursorKeyPair(tc, k, v, curIdx, sortedValues) {
|
|
return false
|
|
}
|
|
curIdx++
|
|
}
|
|
if curIdx != len(unsortedValues) {
|
|
tc.t.Errorf("Cursor: expected to iterate %d values, "+
|
|
"but only iterated %d", len(unsortedValues),
|
|
curIdx)
|
|
return false
|
|
}
|
|
|
|
// Ensure the cursor returns all items in reverse byte-sorted
|
|
// order when iterating in reverse.
|
|
curIdx = len(sortedValues) - 1
|
|
for ok := cursor.Last(); ok; ok = cursor.Prev() {
|
|
k, v := cursor.Key(), cursor.Value()
|
|
if !testCursorKeyPair(tc, k, v, curIdx, sortedValues) {
|
|
return false
|
|
}
|
|
curIdx--
|
|
}
|
|
if curIdx > -1 {
|
|
tc.t.Errorf("Reverse cursor: expected to iterate %d "+
|
|
"values, but only iterated %d",
|
|
len(sortedValues), len(sortedValues)-(curIdx+1))
|
|
return false
|
|
}
|
|
|
|
// Ensure forward iteration works as expected after seeking.
|
|
middleIdx := (len(sortedValues) - 1) / 2
|
|
seekKey := sortedValues[middleIdx].key
|
|
curIdx = middleIdx
|
|
for ok := cursor.Seek(seekKey); ok; ok = cursor.Next() {
|
|
k, v := cursor.Key(), cursor.Value()
|
|
if !testCursorKeyPair(tc, k, v, curIdx, sortedValues) {
|
|
return false
|
|
}
|
|
curIdx++
|
|
}
|
|
if curIdx != len(sortedValues) {
|
|
tc.t.Errorf("Cursor after seek: expected to iterate "+
|
|
"%d values, but only iterated %d",
|
|
len(sortedValues)-middleIdx, curIdx-middleIdx)
|
|
return false
|
|
}
|
|
|
|
// Ensure reverse iteration works as expected after seeking.
|
|
curIdx = middleIdx
|
|
for ok := cursor.Seek(seekKey); ok; ok = cursor.Prev() {
|
|
k, v := cursor.Key(), cursor.Value()
|
|
if !testCursorKeyPair(tc, k, v, curIdx, sortedValues) {
|
|
return false
|
|
}
|
|
curIdx--
|
|
}
|
|
if curIdx > -1 {
|
|
tc.t.Errorf("Reverse cursor after seek: expected to "+
|
|
"iterate %d values, but only iterated %d",
|
|
len(sortedValues)-middleIdx, middleIdx-curIdx)
|
|
return false
|
|
}
|
|
|
|
// Ensure the cursor deletes items properly.
|
|
if !cursor.First() {
|
|
tc.t.Errorf("Cursor.First: no value")
|
|
return false
|
|
}
|
|
k := cursor.Key()
|
|
if err := cursor.Delete(); err != nil {
|
|
tc.t.Errorf("Cursor.Delete: unexpected error: %v", err)
|
|
return false
|
|
}
|
|
if val := bucket.Get(k); val != nil {
|
|
tc.t.Errorf("Cursor.Delete: value for key %q was not "+
|
|
"deleted", k)
|
|
return false
|
|
}
|
|
}
|
|
|
|
return true
|
|
}
|
|
|
|
// testNestedBucket reruns the testBucketInterface against a nested bucket along
|
|
// with a counter to only test a couple of level deep.
|
|
func testNestedBucket(tc *testContext, testBucket database.Bucket) bool {
|
|
// Don't go more than 2 nested levels deep.
|
|
if tc.bucketDepth > 1 {
|
|
return true
|
|
}
|
|
|
|
tc.bucketDepth++
|
|
defer func() {
|
|
tc.bucketDepth--
|
|
}()
|
|
if !testBucketInterface(tc, testBucket) {
|
|
return false
|
|
}
|
|
|
|
return true
|
|
}
|
|
|
|
// testBucketInterface ensures the bucket interface is working properly by
|
|
// exercising all of its functions. This includes the cursor interface for the
|
|
// cursor returned from the bucket.
|
|
func testBucketInterface(tc *testContext, bucket database.Bucket) bool {
|
|
if bucket.Writable() != tc.isWritable {
|
|
tc.t.Errorf("Bucket writable state does not match.")
|
|
return false
|
|
}
|
|
|
|
if tc.isWritable {
|
|
// keyValues holds the keys and values to use when putting
|
|
// values into the bucket.
|
|
keyValues := []keyPair{
|
|
{[]byte("bucketkey1"), []byte("foo1")},
|
|
{[]byte("bucketkey2"), []byte("foo2")},
|
|
{[]byte("bucketkey3"), []byte("foo3")},
|
|
{[]byte("bucketkey4"), nil},
|
|
}
|
|
expectedKeyValues := toGetValues(keyValues)
|
|
if !testPutValues(tc, bucket, keyValues) {
|
|
return false
|
|
}
|
|
|
|
if !testGetValues(tc, bucket, expectedKeyValues) {
|
|
return false
|
|
}
|
|
|
|
// Ensure errors returned from the user-supplied ForEach
|
|
// function are returned.
|
|
forEachError := fmt.Errorf("example foreach error")
|
|
err := bucket.ForEach(func(k, v []byte) error {
|
|
return forEachError
|
|
})
|
|
if err != forEachError {
|
|
tc.t.Errorf("ForEach: inner function error not "+
|
|
"returned - got %v, want %v", err, forEachError)
|
|
return false
|
|
}
|
|
|
|
// Iterate all of the keys using ForEach while making sure the
|
|
// stored values are the expected values.
|
|
keysFound := make(map[string]struct{}, len(keyValues))
|
|
err = bucket.ForEach(func(k, v []byte) error {
|
|
wantV, found := lookupKey(k, expectedKeyValues)
|
|
if !found {
|
|
return fmt.Errorf("ForEach: key '%s' should "+
|
|
"exist", k)
|
|
}
|
|
|
|
if !reflect.DeepEqual(v, wantV) {
|
|
return fmt.Errorf("ForEach: value for key '%s' "+
|
|
"does not match - got %s, want %s", k,
|
|
v, wantV)
|
|
}
|
|
|
|
keysFound[string(k)] = struct{}{}
|
|
return nil
|
|
})
|
|
if err != nil {
|
|
tc.t.Errorf("%v", err)
|
|
return false
|
|
}
|
|
|
|
// Ensure all keys were iterated.
|
|
for _, item := range keyValues {
|
|
if _, ok := keysFound[string(item.key)]; !ok {
|
|
tc.t.Errorf("ForEach: key '%s' was not iterated "+
|
|
"when it should have been", item.key)
|
|
return false
|
|
}
|
|
}
|
|
|
|
// Delete the keys and ensure they were deleted.
|
|
if !testDeleteValues(tc, bucket, keyValues) {
|
|
return false
|
|
}
|
|
if !testGetValues(tc, bucket, rollbackValues(keyValues)) {
|
|
return false
|
|
}
|
|
|
|
// Ensure creating a new bucket works as expected.
|
|
testBucketName := []byte("testbucket")
|
|
testBucket, err := bucket.CreateBucket(testBucketName)
|
|
if err != nil {
|
|
tc.t.Errorf("CreateBucket: unexpected error: %v", err)
|
|
return false
|
|
}
|
|
if !testNestedBucket(tc, testBucket) {
|
|
return false
|
|
}
|
|
|
|
// Ensure errors returned from the user-supplied ForEachBucket
|
|
// function are returned.
|
|
err = bucket.ForEachBucket(func(k []byte) error {
|
|
return forEachError
|
|
})
|
|
if err != forEachError {
|
|
tc.t.Errorf("ForEachBucket: inner function error not "+
|
|
"returned - got %v, want %v", err, forEachError)
|
|
return false
|
|
}
|
|
|
|
// Ensure creating a bucket that already exists fails with the
|
|
// expected error.
|
|
wantErrCode := database.ErrBucketExists
|
|
_, err = bucket.CreateBucket(testBucketName)
|
|
if !checkDbError(tc.t, "CreateBucket", err, wantErrCode) {
|
|
return false
|
|
}
|
|
|
|
// Ensure CreateBucketIfNotExists returns an existing bucket.
|
|
testBucket, err = bucket.CreateBucketIfNotExists(testBucketName)
|
|
if err != nil {
|
|
tc.t.Errorf("CreateBucketIfNotExists: unexpected "+
|
|
"error: %v", err)
|
|
return false
|
|
}
|
|
if !testNestedBucket(tc, testBucket) {
|
|
return false
|
|
}
|
|
|
|
// Ensure retrieving an existing bucket works as expected.
|
|
testBucket = bucket.Bucket(testBucketName)
|
|
if !testNestedBucket(tc, testBucket) {
|
|
return false
|
|
}
|
|
|
|
// Ensure deleting a bucket works as intended.
|
|
if err := bucket.DeleteBucket(testBucketName); err != nil {
|
|
tc.t.Errorf("DeleteBucket: unexpected error: %v", err)
|
|
return false
|
|
}
|
|
if b := bucket.Bucket(testBucketName); b != nil {
|
|
tc.t.Errorf("DeleteBucket: bucket '%s' still exists",
|
|
testBucketName)
|
|
return false
|
|
}
|
|
|
|
// Ensure deleting a bucket that doesn't exist returns the
|
|
// expected error.
|
|
wantErrCode = database.ErrBucketNotFound
|
|
err = bucket.DeleteBucket(testBucketName)
|
|
if !checkDbError(tc.t, "DeleteBucket", err, wantErrCode) {
|
|
return false
|
|
}
|
|
|
|
// Ensure CreateBucketIfNotExists creates a new bucket when
|
|
// it doesn't already exist.
|
|
testBucket, err = bucket.CreateBucketIfNotExists(testBucketName)
|
|
if err != nil {
|
|
tc.t.Errorf("CreateBucketIfNotExists: unexpected "+
|
|
"error: %v", err)
|
|
return false
|
|
}
|
|
if !testNestedBucket(tc, testBucket) {
|
|
return false
|
|
}
|
|
|
|
// Ensure the cursor interface works as expected.
|
|
if !testCursorInterface(tc, testBucket) {
|
|
return false
|
|
}
|
|
|
|
// Delete the test bucket to avoid leaving it around for future
|
|
// calls.
|
|
if err := bucket.DeleteBucket(testBucketName); err != nil {
|
|
tc.t.Errorf("DeleteBucket: unexpected error: %v", err)
|
|
return false
|
|
}
|
|
if b := bucket.Bucket(testBucketName); b != nil {
|
|
tc.t.Errorf("DeleteBucket: bucket '%s' still exists",
|
|
testBucketName)
|
|
return false
|
|
}
|
|
} else {
|
|
// Put should fail with bucket that is not writable.
|
|
testName := "unwritable tx put"
|
|
wantErrCode := database.ErrTxNotWritable
|
|
failBytes := []byte("fail")
|
|
err := bucket.Put(failBytes, failBytes)
|
|
if !checkDbError(tc.t, testName, err, wantErrCode) {
|
|
return false
|
|
}
|
|
|
|
// Delete should fail with bucket that is not writable.
|
|
testName = "unwritable tx delete"
|
|
err = bucket.Delete(failBytes)
|
|
if !checkDbError(tc.t, testName, err, wantErrCode) {
|
|
return false
|
|
}
|
|
|
|
// CreateBucket should fail with bucket that is not writable.
|
|
testName = "unwritable tx create bucket"
|
|
_, err = bucket.CreateBucket(failBytes)
|
|
if !checkDbError(tc.t, testName, err, wantErrCode) {
|
|
return false
|
|
}
|
|
|
|
// CreateBucketIfNotExists should fail with bucket that is not
|
|
// writable.
|
|
testName = "unwritable tx create bucket if not exists"
|
|
_, err = bucket.CreateBucketIfNotExists(failBytes)
|
|
if !checkDbError(tc.t, testName, err, wantErrCode) {
|
|
return false
|
|
}
|
|
|
|
// DeleteBucket should fail with bucket that is not writable.
|
|
testName = "unwritable tx delete bucket"
|
|
err = bucket.DeleteBucket(failBytes)
|
|
if !checkDbError(tc.t, testName, err, wantErrCode) {
|
|
return false
|
|
}
|
|
|
|
// Ensure the cursor interface works as expected with read-only
|
|
// buckets.
|
|
if !testCursorInterface(tc, bucket) {
|
|
return false
|
|
}
|
|
}
|
|
|
|
return true
|
|
}
|
|
|
|
// rollbackOnPanic rolls the passed transaction back if the code in the calling
|
|
// function panics. This is useful in case the tests unexpectedly panic which
|
|
// would leave any manually created transactions with the database mutex locked
|
|
// thereby leading to a deadlock and masking the real reason for the panic. It
|
|
// also logs a test error and repanics so the original panic can be traced.
|
|
func rollbackOnPanic(t *testing.T, tx database.Tx) {
|
|
if err := recover(); err != nil {
|
|
t.Errorf("Unexpected panic: %v", err)
|
|
_ = tx.Rollback()
|
|
panic(err)
|
|
}
|
|
}
|
|
|
|
// testMetadataManualTxInterface ensures that the manual transactions metadata
|
|
// interface works as expected.
|
|
func testMetadataManualTxInterface(tc *testContext) bool {
|
|
// populateValues tests that populating values works as expected.
|
|
//
|
|
// When the writable flag is false, a read-only tranasction is created,
|
|
// standard bucket tests for read-only transactions are performed, and
|
|
// the Commit function is checked to ensure it fails as expected.
|
|
//
|
|
// Otherwise, a read-write transaction is created, the values are
|
|
// written, standard bucket tests for read-write transactions are
|
|
// performed, and then the transaction is either committed or rolled
|
|
// back depending on the flag.
|
|
bucket1Name := []byte("bucket1")
|
|
populateValues := func(writable, rollback bool, putValues []keyPair) bool {
|
|
tx, err := tc.db.Begin(writable)
|
|
if err != nil {
|
|
tc.t.Errorf("Begin: unexpected error %v", err)
|
|
return false
|
|
}
|
|
defer rollbackOnPanic(tc.t, tx)
|
|
|
|
metadataBucket := tx.Metadata()
|
|
if metadataBucket == nil {
|
|
tc.t.Errorf("Metadata: unexpected nil bucket")
|
|
_ = tx.Rollback()
|
|
return false
|
|
}
|
|
|
|
bucket1 := metadataBucket.Bucket(bucket1Name)
|
|
if bucket1 == nil {
|
|
tc.t.Errorf("Bucket1: unexpected nil bucket")
|
|
return false
|
|
}
|
|
|
|
tc.isWritable = writable
|
|
if !testBucketInterface(tc, bucket1) {
|
|
_ = tx.Rollback()
|
|
return false
|
|
}
|
|
|
|
if !writable {
|
|
// The transaction is not writable, so it should fail
|
|
// the commit.
|
|
testName := "unwritable tx commit"
|
|
wantErrCode := database.ErrTxNotWritable
|
|
err := tx.Commit()
|
|
if !checkDbError(tc.t, testName, err, wantErrCode) {
|
|
_ = tx.Rollback()
|
|
return false
|
|
}
|
|
} else {
|
|
if !testPutValues(tc, bucket1, putValues) {
|
|
return false
|
|
}
|
|
|
|
if rollback {
|
|
// Rollback the transaction.
|
|
if err := tx.Rollback(); err != nil {
|
|
tc.t.Errorf("Rollback: unexpected "+
|
|
"error %v", err)
|
|
return false
|
|
}
|
|
} else {
|
|
// The commit should succeed.
|
|
if err := tx.Commit(); err != nil {
|
|
tc.t.Errorf("Commit: unexpected error "+
|
|
"%v", err)
|
|
return false
|
|
}
|
|
}
|
|
}
|
|
|
|
return true
|
|
}
|
|
|
|
// checkValues starts a read-only transaction and checks that all of
|
|
// the key/value pairs specified in the expectedValues parameter match
|
|
// what's in the database.
|
|
checkValues := func(expectedValues []keyPair) bool {
|
|
tx, err := tc.db.Begin(false)
|
|
if err != nil {
|
|
tc.t.Errorf("Begin: unexpected error %v", err)
|
|
return false
|
|
}
|
|
defer rollbackOnPanic(tc.t, tx)
|
|
|
|
metadataBucket := tx.Metadata()
|
|
if metadataBucket == nil {
|
|
tc.t.Errorf("Metadata: unexpected nil bucket")
|
|
_ = tx.Rollback()
|
|
return false
|
|
}
|
|
|
|
bucket1 := metadataBucket.Bucket(bucket1Name)
|
|
if bucket1 == nil {
|
|
tc.t.Errorf("Bucket1: unexpected nil bucket")
|
|
return false
|
|
}
|
|
|
|
if !testGetValues(tc, bucket1, expectedValues) {
|
|
_ = tx.Rollback()
|
|
return false
|
|
}
|
|
|
|
// Rollback the read-only transaction.
|
|
if err := tx.Rollback(); err != nil {
|
|
tc.t.Errorf("Commit: unexpected error %v", err)
|
|
return false
|
|
}
|
|
|
|
return true
|
|
}
|
|
|
|
// deleteValues starts a read-write transaction and deletes the keys
|
|
// in the passed key/value pairs.
|
|
deleteValues := func(values []keyPair) bool {
|
|
tx, err := tc.db.Begin(true)
|
|
if err != nil {
|
|
|
|
}
|
|
defer rollbackOnPanic(tc.t, tx)
|
|
|
|
metadataBucket := tx.Metadata()
|
|
if metadataBucket == nil {
|
|
tc.t.Errorf("Metadata: unexpected nil bucket")
|
|
_ = tx.Rollback()
|
|
return false
|
|
}
|
|
|
|
bucket1 := metadataBucket.Bucket(bucket1Name)
|
|
if bucket1 == nil {
|
|
tc.t.Errorf("Bucket1: unexpected nil bucket")
|
|
return false
|
|
}
|
|
|
|
// Delete the keys and ensure they were deleted.
|
|
if !testDeleteValues(tc, bucket1, values) {
|
|
_ = tx.Rollback()
|
|
return false
|
|
}
|
|
if !testGetValues(tc, bucket1, rollbackValues(values)) {
|
|
_ = tx.Rollback()
|
|
return false
|
|
}
|
|
|
|
// Commit the changes and ensure it was successful.
|
|
if err := tx.Commit(); err != nil {
|
|
tc.t.Errorf("Commit: unexpected error %v", err)
|
|
return false
|
|
}
|
|
|
|
return true
|
|
}
|
|
|
|
// keyValues holds the keys and values to use when putting values into a
|
|
// bucket.
|
|
var keyValues = []keyPair{
|
|
{[]byte("umtxkey1"), []byte("foo1")},
|
|
{[]byte("umtxkey2"), []byte("foo2")},
|
|
{[]byte("umtxkey3"), []byte("foo3")},
|
|
{[]byte("umtxkey4"), nil},
|
|
}
|
|
|
|
// Ensure that attempting populating the values using a read-only
|
|
// transaction fails as expected.
|
|
if !populateValues(false, true, keyValues) {
|
|
return false
|
|
}
|
|
if !checkValues(rollbackValues(keyValues)) {
|
|
return false
|
|
}
|
|
|
|
// Ensure that attempting populating the values using a read-write
|
|
// transaction and then rolling it back yields the expected values.
|
|
if !populateValues(true, true, keyValues) {
|
|
return false
|
|
}
|
|
if !checkValues(rollbackValues(keyValues)) {
|
|
return false
|
|
}
|
|
|
|
// Ensure that attempting populating the values using a read-write
|
|
// transaction and then committing it stores the expected values.
|
|
if !populateValues(true, false, keyValues) {
|
|
return false
|
|
}
|
|
if !checkValues(toGetValues(keyValues)) {
|
|
return false
|
|
}
|
|
|
|
// Clean up the keys.
|
|
if !deleteValues(keyValues) {
|
|
return false
|
|
}
|
|
|
|
return true
|
|
}
|
|
|
|
// testManagedTxPanics ensures calling Rollback of Commit inside a managed
|
|
// transaction panics.
|
|
func testManagedTxPanics(tc *testContext) bool {
|
|
testPanic := func(fn func()) (paniced bool) {
|
|
// Setup a defer to catch the expected panic and update the
|
|
// return variable.
|
|
defer func() {
|
|
if err := recover(); err != nil {
|
|
paniced = true
|
|
}
|
|
}()
|
|
|
|
fn()
|
|
return false
|
|
}
|
|
|
|
// Ensure calling Commit on a managed read-only transaction panics.
|
|
paniced := testPanic(func() {
|
|
tc.db.View(func(tx database.Tx) error {
|
|
tx.Commit()
|
|
return nil
|
|
})
|
|
})
|
|
if !paniced {
|
|
tc.t.Error("Commit called inside View did not panic")
|
|
return false
|
|
}
|
|
|
|
// Ensure calling Rollback on a managed read-only transaction panics.
|
|
paniced = testPanic(func() {
|
|
tc.db.View(func(tx database.Tx) error {
|
|
tx.Rollback()
|
|
return nil
|
|
})
|
|
})
|
|
if !paniced {
|
|
tc.t.Error("Rollback called inside View did not panic")
|
|
return false
|
|
}
|
|
|
|
// Ensure calling Commit on a managed read-write transaction panics.
|
|
paniced = testPanic(func() {
|
|
tc.db.Update(func(tx database.Tx) error {
|
|
tx.Commit()
|
|
return nil
|
|
})
|
|
})
|
|
if !paniced {
|
|
tc.t.Error("Commit called inside Update did not panic")
|
|
return false
|
|
}
|
|
|
|
// Ensure calling Rollback on a managed read-write transaction panics.
|
|
paniced = testPanic(func() {
|
|
tc.db.Update(func(tx database.Tx) error {
|
|
tx.Rollback()
|
|
return nil
|
|
})
|
|
})
|
|
if !paniced {
|
|
tc.t.Error("Rollback called inside Update did not panic")
|
|
return false
|
|
}
|
|
|
|
return true
|
|
}
|
|
|
|
// testMetadataTxInterface tests all facets of the managed read/write and
|
|
// manual transaction metadata interfaces as well as the bucket interfaces under
|
|
// them.
|
|
func testMetadataTxInterface(tc *testContext) bool {
|
|
if !testManagedTxPanics(tc) {
|
|
return false
|
|
}
|
|
|
|
bucket1Name := []byte("bucket1")
|
|
err := tc.db.Update(func(tx database.Tx) error {
|
|
_, err := tx.Metadata().CreateBucket(bucket1Name)
|
|
return err
|
|
})
|
|
if err != nil {
|
|
tc.t.Errorf("Update: unexpected error creating bucket: %v", err)
|
|
return false
|
|
}
|
|
|
|
if !testMetadataManualTxInterface(tc) {
|
|
return false
|
|
}
|
|
|
|
// keyValues holds the keys and values to use when putting values
|
|
// into a bucket.
|
|
keyValues := []keyPair{
|
|
{[]byte("mtxkey1"), []byte("foo1")},
|
|
{[]byte("mtxkey2"), []byte("foo2")},
|
|
{[]byte("mtxkey3"), []byte("foo3")},
|
|
{[]byte("mtxkey4"), nil},
|
|
}
|
|
|
|
// Test the bucket interface via a managed read-only transaction.
|
|
err = tc.db.View(func(tx database.Tx) error {
|
|
metadataBucket := tx.Metadata()
|
|
if metadataBucket == nil {
|
|
return fmt.Errorf("Metadata: unexpected nil bucket")
|
|
}
|
|
|
|
bucket1 := metadataBucket.Bucket(bucket1Name)
|
|
if bucket1 == nil {
|
|
return fmt.Errorf("Bucket1: unexpected nil bucket")
|
|
}
|
|
|
|
tc.isWritable = false
|
|
if !testBucketInterface(tc, bucket1) {
|
|
return errSubTestFail
|
|
}
|
|
|
|
return nil
|
|
})
|
|
if err != nil {
|
|
if err != errSubTestFail {
|
|
tc.t.Errorf("%v", err)
|
|
}
|
|
return false
|
|
}
|
|
|
|
// Ensure errors returned from the user-supplied View function are
|
|
// returned.
|
|
viewError := fmt.Errorf("example view error")
|
|
err = tc.db.View(func(tx database.Tx) error {
|
|
return viewError
|
|
})
|
|
if err != viewError {
|
|
tc.t.Errorf("View: inner function error not returned - got "+
|
|
"%v, want %v", err, viewError)
|
|
return false
|
|
}
|
|
|
|
// Test the bucket interface via a managed read-write transaction.
|
|
// Also, put a series of values and force a rollback so the following
|
|
// code can ensure the values were not stored.
|
|
forceRollbackError := fmt.Errorf("force rollback")
|
|
err = tc.db.Update(func(tx database.Tx) error {
|
|
metadataBucket := tx.Metadata()
|
|
if metadataBucket == nil {
|
|
return fmt.Errorf("Metadata: unexpected nil bucket")
|
|
}
|
|
|
|
bucket1 := metadataBucket.Bucket(bucket1Name)
|
|
if bucket1 == nil {
|
|
return fmt.Errorf("Bucket1: unexpected nil bucket")
|
|
}
|
|
|
|
tc.isWritable = true
|
|
if !testBucketInterface(tc, bucket1) {
|
|
return errSubTestFail
|
|
}
|
|
|
|
if !testPutValues(tc, bucket1, keyValues) {
|
|
return errSubTestFail
|
|
}
|
|
|
|
// Return an error to force a rollback.
|
|
return forceRollbackError
|
|
})
|
|
if err != forceRollbackError {
|
|
if err == errSubTestFail {
|
|
return false
|
|
}
|
|
|
|
tc.t.Errorf("Update: inner function error not returned - got "+
|
|
"%v, want %v", err, forceRollbackError)
|
|
return false
|
|
}
|
|
|
|
// Ensure the values that should not have been stored due to the forced
|
|
// rollback above were not actually stored.
|
|
err = tc.db.View(func(tx database.Tx) error {
|
|
metadataBucket := tx.Metadata()
|
|
if metadataBucket == nil {
|
|
return fmt.Errorf("Metadata: unexpected nil bucket")
|
|
}
|
|
|
|
if !testGetValues(tc, metadataBucket, rollbackValues(keyValues)) {
|
|
return errSubTestFail
|
|
}
|
|
|
|
return nil
|
|
})
|
|
if err != nil {
|
|
if err != errSubTestFail {
|
|
tc.t.Errorf("%v", err)
|
|
}
|
|
return false
|
|
}
|
|
|
|
// Store a series of values via a managed read-write transaction.
|
|
err = tc.db.Update(func(tx database.Tx) error {
|
|
metadataBucket := tx.Metadata()
|
|
if metadataBucket == nil {
|
|
return fmt.Errorf("Metadata: unexpected nil bucket")
|
|
}
|
|
|
|
bucket1 := metadataBucket.Bucket(bucket1Name)
|
|
if bucket1 == nil {
|
|
return fmt.Errorf("Bucket1: unexpected nil bucket")
|
|
}
|
|
|
|
if !testPutValues(tc, bucket1, keyValues) {
|
|
return errSubTestFail
|
|
}
|
|
|
|
return nil
|
|
})
|
|
if err != nil {
|
|
if err != errSubTestFail {
|
|
tc.t.Errorf("%v", err)
|
|
}
|
|
return false
|
|
}
|
|
|
|
// Ensure the values stored above were committed as expected.
|
|
err = tc.db.View(func(tx database.Tx) error {
|
|
metadataBucket := tx.Metadata()
|
|
if metadataBucket == nil {
|
|
return fmt.Errorf("Metadata: unexpected nil bucket")
|
|
}
|
|
|
|
bucket1 := metadataBucket.Bucket(bucket1Name)
|
|
if bucket1 == nil {
|
|
return fmt.Errorf("Bucket1: unexpected nil bucket")
|
|
}
|
|
|
|
if !testGetValues(tc, bucket1, toGetValues(keyValues)) {
|
|
return errSubTestFail
|
|
}
|
|
|
|
return nil
|
|
})
|
|
if err != nil {
|
|
if err != errSubTestFail {
|
|
tc.t.Errorf("%v", err)
|
|
}
|
|
return false
|
|
}
|
|
|
|
// Clean up the values stored above in a managed read-write transaction.
|
|
err = tc.db.Update(func(tx database.Tx) error {
|
|
metadataBucket := tx.Metadata()
|
|
if metadataBucket == nil {
|
|
return fmt.Errorf("Metadata: unexpected nil bucket")
|
|
}
|
|
|
|
bucket1 := metadataBucket.Bucket(bucket1Name)
|
|
if bucket1 == nil {
|
|
return fmt.Errorf("Bucket1: unexpected nil bucket")
|
|
}
|
|
|
|
if !testDeleteValues(tc, bucket1, keyValues) {
|
|
return errSubTestFail
|
|
}
|
|
|
|
return nil
|
|
})
|
|
if err != nil {
|
|
if err != errSubTestFail {
|
|
tc.t.Errorf("%v", err)
|
|
}
|
|
return false
|
|
}
|
|
|
|
return true
|
|
}
|
|
|
|
// testFetchBlockIOMissing ensures that all of the block retrieval API functions
|
|
// work as expected when requesting blocks that don't exist.
|
|
func testFetchBlockIOMissing(tc *testContext, tx database.Tx) bool {
|
|
wantErrCode := database.ErrBlockNotFound
|
|
|
|
// ---------------------
|
|
// Non-bulk Block IO API
|
|
// ---------------------
|
|
|
|
// Test the individual block APIs one block at a time to ensure they
|
|
// return the expected error. Also, build the data needed to test the
|
|
// bulk APIs below while looping.
|
|
allBlockHashes := make([]chainhash.Hash, len(tc.blocks))
|
|
allBlockRegions := make([]database.BlockRegion, len(tc.blocks))
|
|
for i, block := range tc.blocks {
|
|
blockHash := block.Hash()
|
|
allBlockHashes[i] = *blockHash
|
|
|
|
txLocs, err := block.TxLoc()
|
|
if err != nil {
|
|
tc.t.Errorf("block.TxLoc(%d): unexpected error: %v", i,
|
|
err)
|
|
return false
|
|
}
|
|
|
|
// Ensure FetchBlock returns expected error.
|
|
testName := fmt.Sprintf("FetchBlock #%d on missing block", i)
|
|
_, err = tx.FetchBlock(blockHash)
|
|
if !checkDbError(tc.t, testName, err, wantErrCode) {
|
|
return false
|
|
}
|
|
|
|
// Ensure FetchBlockHeader returns expected error.
|
|
testName = fmt.Sprintf("FetchBlockHeader #%d on missing block",
|
|
i)
|
|
_, err = tx.FetchBlockHeader(blockHash)
|
|
if !checkDbError(tc.t, testName, err, wantErrCode) {
|
|
return false
|
|
}
|
|
|
|
// Ensure the first transaction fetched as a block region from
|
|
// the database returns the expected error.
|
|
region := database.BlockRegion{
|
|
Hash: blockHash,
|
|
Offset: uint32(txLocs[0].TxStart),
|
|
Len: uint32(txLocs[0].TxLen),
|
|
}
|
|
allBlockRegions[i] = region
|
|
_, err = tx.FetchBlockRegion(®ion)
|
|
if !checkDbError(tc.t, testName, err, wantErrCode) {
|
|
return false
|
|
}
|
|
|
|
// Ensure HasBlock returns false.
|
|
hasBlock, err := tx.HasBlock(blockHash)
|
|
if err != nil {
|
|
tc.t.Errorf("HasBlock #%d: unexpected err: %v", i, err)
|
|
return false
|
|
}
|
|
if hasBlock {
|
|
tc.t.Errorf("HasBlock #%d: should not have block", i)
|
|
return false
|
|
}
|
|
}
|
|
|
|
// -----------------
|
|
// Bulk Block IO API
|
|
// -----------------
|
|
|
|
// Ensure FetchBlocks returns expected error.
|
|
testName := "FetchBlocks on missing blocks"
|
|
_, err := tx.FetchBlocks(allBlockHashes)
|
|
if !checkDbError(tc.t, testName, err, wantErrCode) {
|
|
return false
|
|
}
|
|
|
|
// Ensure FetchBlockHeaders returns expected error.
|
|
testName = "FetchBlockHeaders on missing blocks"
|
|
_, err = tx.FetchBlockHeaders(allBlockHashes)
|
|
if !checkDbError(tc.t, testName, err, wantErrCode) {
|
|
return false
|
|
}
|
|
|
|
// Ensure FetchBlockRegions returns expected error.
|
|
testName = "FetchBlockRegions on missing blocks"
|
|
_, err = tx.FetchBlockRegions(allBlockRegions)
|
|
if !checkDbError(tc.t, testName, err, wantErrCode) {
|
|
return false
|
|
}
|
|
|
|
// Ensure HasBlocks returns false for all blocks.
|
|
hasBlocks, err := tx.HasBlocks(allBlockHashes)
|
|
if err != nil {
|
|
tc.t.Errorf("HasBlocks: unexpected err: %v", err)
|
|
}
|
|
for i, hasBlock := range hasBlocks {
|
|
if hasBlock {
|
|
tc.t.Errorf("HasBlocks #%d: should not have block", i)
|
|
return false
|
|
}
|
|
}
|
|
|
|
return true
|
|
}
|
|
|
|
// testFetchBlockIO ensures all of the block retrieval API functions work as
|
|
// expected for the provide set of blocks. The blocks must already be stored in
|
|
// the database, or at least stored into the the passed transaction. It also
|
|
// tests several error conditions such as ensuring the expected errors are
|
|
// returned when fetching blocks, headers, and regions that don't exist.
|
|
func testFetchBlockIO(tc *testContext, tx database.Tx) bool {
|
|
// ---------------------
|
|
// Non-bulk Block IO API
|
|
// ---------------------
|
|
|
|
// Test the individual block APIs one block at a time. Also, build the
|
|
// data needed to test the bulk APIs below while looping.
|
|
allBlockHashes := make([]chainhash.Hash, len(tc.blocks))
|
|
allBlockBytes := make([][]byte, len(tc.blocks))
|
|
allBlockTxLocs := make([][]wire.TxLoc, len(tc.blocks))
|
|
allBlockRegions := make([]database.BlockRegion, len(tc.blocks))
|
|
for i, block := range tc.blocks {
|
|
blockHash := block.Hash()
|
|
allBlockHashes[i] = *blockHash
|
|
|
|
blockBytes, err := block.Bytes()
|
|
if err != nil {
|
|
tc.t.Errorf("block.Bytes(%d): unexpected error: %v", i,
|
|
err)
|
|
return false
|
|
}
|
|
allBlockBytes[i] = blockBytes
|
|
|
|
txLocs, err := block.TxLoc()
|
|
if err != nil {
|
|
tc.t.Errorf("block.TxLoc(%d): unexpected error: %v", i,
|
|
err)
|
|
return false
|
|
}
|
|
allBlockTxLocs[i] = txLocs
|
|
|
|
// Ensure the block data fetched from the database matches the
|
|
// expected bytes.
|
|
gotBlockBytes, err := tx.FetchBlock(blockHash)
|
|
if err != nil {
|
|
tc.t.Errorf("FetchBlock(%s): unexpected error: %v",
|
|
blockHash, err)
|
|
return false
|
|
}
|
|
if !bytes.Equal(gotBlockBytes, blockBytes) {
|
|
tc.t.Errorf("FetchBlock(%s): bytes mismatch: got %x, "+
|
|
"want %x", blockHash, gotBlockBytes, blockBytes)
|
|
return false
|
|
}
|
|
|
|
// Ensure the block header fetched from the database matches the
|
|
// expected bytes.
|
|
wantHeaderBytes := blockBytes[0:wire.MaxBlockHeaderPayload]
|
|
gotHeaderBytes, err := tx.FetchBlockHeader(blockHash)
|
|
if err != nil {
|
|
tc.t.Errorf("FetchBlockHeader(%s): unexpected error: %v",
|
|
blockHash, err)
|
|
return false
|
|
}
|
|
if !bytes.Equal(gotHeaderBytes, wantHeaderBytes) {
|
|
tc.t.Errorf("FetchBlockHeader(%s): bytes mismatch: "+
|
|
"got %x, want %x", blockHash, gotHeaderBytes,
|
|
wantHeaderBytes)
|
|
return false
|
|
}
|
|
|
|
// Ensure the first transaction fetched as a block region from
|
|
// the database matches the expected bytes.
|
|
region := database.BlockRegion{
|
|
Hash: blockHash,
|
|
Offset: uint32(txLocs[0].TxStart),
|
|
Len: uint32(txLocs[0].TxLen),
|
|
}
|
|
allBlockRegions[i] = region
|
|
endRegionOffset := region.Offset + region.Len
|
|
wantRegionBytes := blockBytes[region.Offset:endRegionOffset]
|
|
gotRegionBytes, err := tx.FetchBlockRegion(®ion)
|
|
if err != nil {
|
|
tc.t.Errorf("FetchBlockRegion(%s): unexpected error: %v",
|
|
blockHash, err)
|
|
return false
|
|
}
|
|
if !bytes.Equal(gotRegionBytes, wantRegionBytes) {
|
|
tc.t.Errorf("FetchBlockRegion(%s): bytes mismatch: "+
|
|
"got %x, want %x", blockHash, gotRegionBytes,
|
|
wantRegionBytes)
|
|
return false
|
|
}
|
|
|
|
// Ensure the block header fetched from the database matches the
|
|
// expected bytes.
|
|
hasBlock, err := tx.HasBlock(blockHash)
|
|
if err != nil {
|
|
tc.t.Errorf("HasBlock(%s): unexpected error: %v",
|
|
blockHash, err)
|
|
return false
|
|
}
|
|
if !hasBlock {
|
|
tc.t.Errorf("HasBlock(%s): database claims it doesn't "+
|
|
"have the block when it should", blockHash)
|
|
return false
|
|
}
|
|
|
|
// -----------------------
|
|
// Invalid blocks/regions.
|
|
// -----------------------
|
|
|
|
// Ensure fetching a block that doesn't exist returns the
|
|
// expected error.
|
|
badBlockHash := &chainhash.Hash{}
|
|
testName := fmt.Sprintf("FetchBlock(%s) invalid block",
|
|
badBlockHash)
|
|
wantErrCode := database.ErrBlockNotFound
|
|
_, err = tx.FetchBlock(badBlockHash)
|
|
if !checkDbError(tc.t, testName, err, wantErrCode) {
|
|
return false
|
|
}
|
|
|
|
// Ensure fetching a block header that doesn't exist returns
|
|
// the expected error.
|
|
testName = fmt.Sprintf("FetchBlockHeader(%s) invalid block",
|
|
badBlockHash)
|
|
_, err = tx.FetchBlockHeader(badBlockHash)
|
|
if !checkDbError(tc.t, testName, err, wantErrCode) {
|
|
return false
|
|
}
|
|
|
|
// Ensure fetching a block region in a block that doesn't exist
|
|
// return the expected error.
|
|
testName = fmt.Sprintf("FetchBlockRegion(%s) invalid hash",
|
|
badBlockHash)
|
|
wantErrCode = database.ErrBlockNotFound
|
|
region.Hash = badBlockHash
|
|
region.Offset = ^uint32(0)
|
|
_, err = tx.FetchBlockRegion(®ion)
|
|
if !checkDbError(tc.t, testName, err, wantErrCode) {
|
|
return false
|
|
}
|
|
|
|
// Ensure fetching a block region that is out of bounds returns
|
|
// the expected error.
|
|
testName = fmt.Sprintf("FetchBlockRegion(%s) invalid region",
|
|
blockHash)
|
|
wantErrCode = database.ErrBlockRegionInvalid
|
|
region.Hash = blockHash
|
|
region.Offset = ^uint32(0)
|
|
_, err = tx.FetchBlockRegion(®ion)
|
|
if !checkDbError(tc.t, testName, err, wantErrCode) {
|
|
return false
|
|
}
|
|
}
|
|
|
|
// -----------------
|
|
// Bulk Block IO API
|
|
// -----------------
|
|
|
|
// Ensure the bulk block data fetched from the database matches the
|
|
// expected bytes.
|
|
blockData, err := tx.FetchBlocks(allBlockHashes)
|
|
if err != nil {
|
|
tc.t.Errorf("FetchBlocks: unexpected error: %v", err)
|
|
return false
|
|
}
|
|
if len(blockData) != len(allBlockBytes) {
|
|
tc.t.Errorf("FetchBlocks: unexpected number of results - got "+
|
|
"%d, want %d", len(blockData), len(allBlockBytes))
|
|
return false
|
|
}
|
|
for i := 0; i < len(blockData); i++ {
|
|
blockHash := allBlockHashes[i]
|
|
wantBlockBytes := allBlockBytes[i]
|
|
gotBlockBytes := blockData[i]
|
|
if !bytes.Equal(gotBlockBytes, wantBlockBytes) {
|
|
tc.t.Errorf("FetchBlocks(%s): bytes mismatch: got %x, "+
|
|
"want %x", blockHash, gotBlockBytes,
|
|
wantBlockBytes)
|
|
return false
|
|
}
|
|
}
|
|
|
|
// Ensure the bulk block headers fetched from the database match the
|
|
// expected bytes.
|
|
blockHeaderData, err := tx.FetchBlockHeaders(allBlockHashes)
|
|
if err != nil {
|
|
tc.t.Errorf("FetchBlockHeaders: unexpected error: %v", err)
|
|
return false
|
|
}
|
|
if len(blockHeaderData) != len(allBlockBytes) {
|
|
tc.t.Errorf("FetchBlockHeaders: unexpected number of results "+
|
|
"- got %d, want %d", len(blockHeaderData),
|
|
len(allBlockBytes))
|
|
return false
|
|
}
|
|
for i := 0; i < len(blockHeaderData); i++ {
|
|
blockHash := allBlockHashes[i]
|
|
wantHeaderBytes := allBlockBytes[i][0:wire.MaxBlockHeaderPayload]
|
|
gotHeaderBytes := blockHeaderData[i]
|
|
if !bytes.Equal(gotHeaderBytes, wantHeaderBytes) {
|
|
tc.t.Errorf("FetchBlockHeaders(%s): bytes mismatch: "+
|
|
"got %x, want %x", blockHash, gotHeaderBytes,
|
|
wantHeaderBytes)
|
|
return false
|
|
}
|
|
}
|
|
|
|
// Ensure the first transaction of every block fetched in bulk block
|
|
// regions from the database matches the expected bytes.
|
|
allRegionBytes, err := tx.FetchBlockRegions(allBlockRegions)
|
|
if err != nil {
|
|
tc.t.Errorf("FetchBlockRegions: unexpected error: %v", err)
|
|
return false
|
|
|
|
}
|
|
if len(allRegionBytes) != len(allBlockRegions) {
|
|
tc.t.Errorf("FetchBlockRegions: unexpected number of results "+
|
|
"- got %d, want %d", len(allRegionBytes),
|
|
len(allBlockRegions))
|
|
return false
|
|
}
|
|
for i, gotRegionBytes := range allRegionBytes {
|
|
region := &allBlockRegions[i]
|
|
endRegionOffset := region.Offset + region.Len
|
|
wantRegionBytes := blockData[i][region.Offset:endRegionOffset]
|
|
if !bytes.Equal(gotRegionBytes, wantRegionBytes) {
|
|
tc.t.Errorf("FetchBlockRegions(%d): bytes mismatch: "+
|
|
"got %x, want %x", i, gotRegionBytes,
|
|
wantRegionBytes)
|
|
return false
|
|
}
|
|
}
|
|
|
|
// Ensure the bulk determination of whether a set of block hashes are in
|
|
// the database returns true for all loaded blocks.
|
|
hasBlocks, err := tx.HasBlocks(allBlockHashes)
|
|
if err != nil {
|
|
tc.t.Errorf("HasBlocks: unexpected error: %v", err)
|
|
return false
|
|
}
|
|
for i, hasBlock := range hasBlocks {
|
|
if !hasBlock {
|
|
tc.t.Errorf("HasBlocks(%d): should have block", i)
|
|
return false
|
|
}
|
|
}
|
|
|
|
// -----------------------
|
|
// Invalid blocks/regions.
|
|
// -----------------------
|
|
|
|
// Ensure fetching blocks for which one doesn't exist returns the
|
|
// expected error.
|
|
testName := "FetchBlocks invalid hash"
|
|
badBlockHashes := make([]chainhash.Hash, len(allBlockHashes)+1)
|
|
copy(badBlockHashes, allBlockHashes)
|
|
badBlockHashes[len(badBlockHashes)-1] = chainhash.Hash{}
|
|
wantErrCode := database.ErrBlockNotFound
|
|
_, err = tx.FetchBlocks(badBlockHashes)
|
|
if !checkDbError(tc.t, testName, err, wantErrCode) {
|
|
return false
|
|
}
|
|
|
|
// Ensure fetching block headers for which one doesn't exist returns the
|
|
// expected error.
|
|
testName = "FetchBlockHeaders invalid hash"
|
|
_, err = tx.FetchBlockHeaders(badBlockHashes)
|
|
if !checkDbError(tc.t, testName, err, wantErrCode) {
|
|
return false
|
|
}
|
|
|
|
// Ensure fetching block regions for which one of blocks doesn't exist
|
|
// returns expected error.
|
|
testName = "FetchBlockRegions invalid hash"
|
|
badBlockRegions := make([]database.BlockRegion, len(allBlockRegions)+1)
|
|
copy(badBlockRegions, allBlockRegions)
|
|
badBlockRegions[len(badBlockRegions)-1].Hash = &chainhash.Hash{}
|
|
wantErrCode = database.ErrBlockNotFound
|
|
_, err = tx.FetchBlockRegions(badBlockRegions)
|
|
if !checkDbError(tc.t, testName, err, wantErrCode) {
|
|
return false
|
|
}
|
|
|
|
// Ensure fetching block regions that are out of bounds returns the
|
|
// expected error.
|
|
testName = "FetchBlockRegions invalid regions"
|
|
badBlockRegions = badBlockRegions[:len(badBlockRegions)-1]
|
|
for i := range badBlockRegions {
|
|
badBlockRegions[i].Offset = ^uint32(0)
|
|
}
|
|
wantErrCode = database.ErrBlockRegionInvalid
|
|
_, err = tx.FetchBlockRegions(badBlockRegions)
|
|
if !checkDbError(tc.t, testName, err, wantErrCode) {
|
|
return false
|
|
}
|
|
|
|
return true
|
|
}
|
|
|
|
// testBlockIOTxInterface ensures that the block IO interface works as expected
|
|
// for both managed read/write and manual transactions. This function leaves
|
|
// all of the stored blocks in the database.
|
|
func testBlockIOTxInterface(tc *testContext) bool {
|
|
// Ensure attempting to store a block with a read-only transaction fails
|
|
// with the expected error.
|
|
err := tc.db.View(func(tx database.Tx) error {
|
|
wantErrCode := database.ErrTxNotWritable
|
|
for i, block := range tc.blocks {
|
|
testName := fmt.Sprintf("StoreBlock(%d) on ro tx", i)
|
|
err := tx.StoreBlock(block)
|
|
if !checkDbError(tc.t, testName, err, wantErrCode) {
|
|
return errSubTestFail
|
|
}
|
|
}
|
|
|
|
return nil
|
|
})
|
|
if err != nil {
|
|
if err != errSubTestFail {
|
|
tc.t.Errorf("%v", err)
|
|
}
|
|
return false
|
|
}
|
|
|
|
// Populate the database with loaded blocks and ensure all of the data
|
|
// fetching APIs work properly on them within the transaction before a
|
|
// commit or rollback. Then, force a rollback so the code below can
|
|
// ensure none of the data actually gets stored.
|
|
forceRollbackError := fmt.Errorf("force rollback")
|
|
err = tc.db.Update(func(tx database.Tx) error {
|
|
// Store all blocks in the same transaction.
|
|
for i, block := range tc.blocks {
|
|
err := tx.StoreBlock(block)
|
|
if err != nil {
|
|
tc.t.Errorf("StoreBlock #%d: unexpected error: "+
|
|
"%v", i, err)
|
|
return errSubTestFail
|
|
}
|
|
}
|
|
|
|
// Ensure attempting to store the same block again, before the
|
|
// transaction has been committed, returns the expected error.
|
|
wantErrCode := database.ErrBlockExists
|
|
for i, block := range tc.blocks {
|
|
testName := fmt.Sprintf("duplicate block entry #%d "+
|
|
"(before commit)", i)
|
|
err := tx.StoreBlock(block)
|
|
if !checkDbError(tc.t, testName, err, wantErrCode) {
|
|
return errSubTestFail
|
|
}
|
|
}
|
|
|
|
// Ensure that all data fetches from the stored blocks before
|
|
// the transaction has been committed work as expected.
|
|
if !testFetchBlockIO(tc, tx) {
|
|
return errSubTestFail
|
|
}
|
|
|
|
return forceRollbackError
|
|
})
|
|
if err != forceRollbackError {
|
|
if err == errSubTestFail {
|
|
return false
|
|
}
|
|
|
|
tc.t.Errorf("Update: inner function error not returned - got "+
|
|
"%v, want %v", err, forceRollbackError)
|
|
return false
|
|
}
|
|
|
|
// Ensure rollback was successful
|
|
err = tc.db.View(func(tx database.Tx) error {
|
|
if !testFetchBlockIOMissing(tc, tx) {
|
|
return errSubTestFail
|
|
}
|
|
return nil
|
|
})
|
|
if err != nil {
|
|
if err != errSubTestFail {
|
|
tc.t.Errorf("%v", err)
|
|
}
|
|
return false
|
|
}
|
|
|
|
// Populate the database with loaded blocks and ensure all of the data
|
|
// fetching APIs work properly.
|
|
err = tc.db.Update(func(tx database.Tx) error {
|
|
// Store a bunch of blocks in the same transaction.
|
|
for i, block := range tc.blocks {
|
|
err := tx.StoreBlock(block)
|
|
if err != nil {
|
|
tc.t.Errorf("StoreBlock #%d: unexpected error: "+
|
|
"%v", i, err)
|
|
return errSubTestFail
|
|
}
|
|
}
|
|
|
|
// Ensure attempting to store the same block again while in the
|
|
// same transaction, but before it has been committed, returns
|
|
// the expected error.
|
|
for i, block := range tc.blocks {
|
|
testName := fmt.Sprintf("duplicate block entry #%d "+
|
|
"(before commit)", i)
|
|
wantErrCode := database.ErrBlockExists
|
|
err := tx.StoreBlock(block)
|
|
if !checkDbError(tc.t, testName, err, wantErrCode) {
|
|
return errSubTestFail
|
|
}
|
|
}
|
|
|
|
// Ensure that all data fetches from the stored blocks before
|
|
// the transaction has been committed work as expected.
|
|
if !testFetchBlockIO(tc, tx) {
|
|
return errSubTestFail
|
|
}
|
|
|
|
return nil
|
|
})
|
|
if err != nil {
|
|
if err != errSubTestFail {
|
|
tc.t.Errorf("%v", err)
|
|
}
|
|
return false
|
|
}
|
|
|
|
// Ensure all data fetch tests work as expected using a managed
|
|
// read-only transaction after the data was successfully committed
|
|
// above.
|
|
err = tc.db.View(func(tx database.Tx) error {
|
|
if !testFetchBlockIO(tc, tx) {
|
|
return errSubTestFail
|
|
}
|
|
|
|
return nil
|
|
})
|
|
if err != nil {
|
|
if err != errSubTestFail {
|
|
tc.t.Errorf("%v", err)
|
|
}
|
|
return false
|
|
}
|
|
|
|
// Ensure all data fetch tests work as expected using a managed
|
|
// read-write transaction after the data was successfully committed
|
|
// above.
|
|
err = tc.db.Update(func(tx database.Tx) error {
|
|
if !testFetchBlockIO(tc, tx) {
|
|
return errSubTestFail
|
|
}
|
|
|
|
// Ensure attempting to store existing blocks again returns the
|
|
// expected error. Note that this is different from the
|
|
// previous version since this is a new transaction after the
|
|
// blocks have been committed.
|
|
wantErrCode := database.ErrBlockExists
|
|
for i, block := range tc.blocks {
|
|
testName := fmt.Sprintf("duplicate block entry #%d "+
|
|
"(before commit)", i)
|
|
err := tx.StoreBlock(block)
|
|
if !checkDbError(tc.t, testName, err, wantErrCode) {
|
|
return errSubTestFail
|
|
}
|
|
}
|
|
|
|
return nil
|
|
})
|
|
if err != nil {
|
|
if err != errSubTestFail {
|
|
tc.t.Errorf("%v", err)
|
|
}
|
|
return false
|
|
}
|
|
|
|
return true
|
|
}
|
|
|
|
// testClosedTxInterface ensures that both the metadata and block IO API
|
|
// functions behave as expected when attempted against a closed transaction.
|
|
func testClosedTxInterface(tc *testContext, tx database.Tx) bool {
|
|
wantErrCode := database.ErrTxClosed
|
|
bucket := tx.Metadata()
|
|
cursor := tx.Metadata().Cursor()
|
|
bucketName := []byte("closedtxbucket")
|
|
keyName := []byte("closedtxkey")
|
|
|
|
// ------------
|
|
// Metadata API
|
|
// ------------
|
|
|
|
// Ensure that attempting to get an existing bucket returns nil when the
|
|
// transaction is closed.
|
|
if b := bucket.Bucket(bucketName); b != nil {
|
|
tc.t.Errorf("Bucket: did not return nil on closed tx")
|
|
return false
|
|
}
|
|
|
|
// Ensure CreateBucket returns expected error.
|
|
testName := "CreateBucket on closed tx"
|
|
_, err := bucket.CreateBucket(bucketName)
|
|
if !checkDbError(tc.t, testName, err, wantErrCode) {
|
|
return false
|
|
}
|
|
|
|
// Ensure CreateBucketIfNotExists returns expected error.
|
|
testName = "CreateBucketIfNotExists on closed tx"
|
|
_, err = bucket.CreateBucketIfNotExists(bucketName)
|
|
if !checkDbError(tc.t, testName, err, wantErrCode) {
|
|
return false
|
|
}
|
|
|
|
// Ensure Delete returns expected error.
|
|
testName = "Delete on closed tx"
|
|
err = bucket.Delete(keyName)
|
|
if !checkDbError(tc.t, testName, err, wantErrCode) {
|
|
return false
|
|
}
|
|
|
|
// Ensure DeleteBucket returns expected error.
|
|
testName = "DeleteBucket on closed tx"
|
|
err = bucket.DeleteBucket(bucketName)
|
|
if !checkDbError(tc.t, testName, err, wantErrCode) {
|
|
return false
|
|
}
|
|
|
|
// Ensure ForEach returns expected error.
|
|
testName = "ForEach on closed tx"
|
|
err = bucket.ForEach(nil)
|
|
if !checkDbError(tc.t, testName, err, wantErrCode) {
|
|
return false
|
|
}
|
|
|
|
// Ensure ForEachBucket returns expected error.
|
|
testName = "ForEachBucket on closed tx"
|
|
err = bucket.ForEachBucket(nil)
|
|
if !checkDbError(tc.t, testName, err, wantErrCode) {
|
|
return false
|
|
}
|
|
|
|
// Ensure Get returns expected error.
|
|
testName = "Get on closed tx"
|
|
if k := bucket.Get(keyName); k != nil {
|
|
tc.t.Errorf("Get: did not return nil on closed tx")
|
|
return false
|
|
}
|
|
|
|
// Ensure Put returns expected error.
|
|
testName = "Put on closed tx"
|
|
err = bucket.Put(keyName, []byte("test"))
|
|
if !checkDbError(tc.t, testName, err, wantErrCode) {
|
|
return false
|
|
}
|
|
|
|
// -------------------
|
|
// Metadata Cursor API
|
|
// -------------------
|
|
|
|
// Ensure attempting to get a bucket from a cursor on a closed tx gives
|
|
// back nil.
|
|
if b := cursor.Bucket(); b != nil {
|
|
tc.t.Error("Cursor.Bucket: returned non-nil on closed tx")
|
|
return false
|
|
}
|
|
|
|
// Ensure Cursor.Delete returns expected error.
|
|
testName = "Cursor.Delete on closed tx"
|
|
err = cursor.Delete()
|
|
if !checkDbError(tc.t, testName, err, wantErrCode) {
|
|
return false
|
|
}
|
|
|
|
// Ensure Cursor.First on a closed tx returns false and nil key/value.
|
|
if cursor.First() {
|
|
tc.t.Error("Cursor.First: claims ok on closed tx")
|
|
return false
|
|
}
|
|
if cursor.Key() != nil || cursor.Value() != nil {
|
|
tc.t.Error("Cursor.First: key and/or value are not nil on " +
|
|
"closed tx")
|
|
return false
|
|
}
|
|
|
|
// Ensure Cursor.Last on a closed tx returns false and nil key/value.
|
|
if cursor.Last() {
|
|
tc.t.Error("Cursor.Last: claims ok on closed tx")
|
|
return false
|
|
}
|
|
if cursor.Key() != nil || cursor.Value() != nil {
|
|
tc.t.Error("Cursor.Last: key and/or value are not nil on " +
|
|
"closed tx")
|
|
return false
|
|
}
|
|
|
|
// Ensure Cursor.Next on a closed tx returns false and nil key/value.
|
|
if cursor.Next() {
|
|
tc.t.Error("Cursor.Next: claims ok on closed tx")
|
|
return false
|
|
}
|
|
if cursor.Key() != nil || cursor.Value() != nil {
|
|
tc.t.Error("Cursor.Next: key and/or value are not nil on " +
|
|
"closed tx")
|
|
return false
|
|
}
|
|
|
|
// Ensure Cursor.Prev on a closed tx returns false and nil key/value.
|
|
if cursor.Prev() {
|
|
tc.t.Error("Cursor.Prev: claims ok on closed tx")
|
|
return false
|
|
}
|
|
if cursor.Key() != nil || cursor.Value() != nil {
|
|
tc.t.Error("Cursor.Prev: key and/or value are not nil on " +
|
|
"closed tx")
|
|
return false
|
|
}
|
|
|
|
// Ensure Cursor.Seek on a closed tx returns false and nil key/value.
|
|
if cursor.Seek([]byte{}) {
|
|
tc.t.Error("Cursor.Seek: claims ok on closed tx")
|
|
return false
|
|
}
|
|
if cursor.Key() != nil || cursor.Value() != nil {
|
|
tc.t.Error("Cursor.Seek: key and/or value are not nil on " +
|
|
"closed tx")
|
|
return false
|
|
}
|
|
|
|
// ---------------------
|
|
// Non-bulk Block IO API
|
|
// ---------------------
|
|
|
|
// Test the individual block APIs one block at a time to ensure they
|
|
// return the expected error. Also, build the data needed to test the
|
|
// bulk APIs below while looping.
|
|
allBlockHashes := make([]chainhash.Hash, len(tc.blocks))
|
|
allBlockRegions := make([]database.BlockRegion, len(tc.blocks))
|
|
for i, block := range tc.blocks {
|
|
blockHash := block.Hash()
|
|
allBlockHashes[i] = *blockHash
|
|
|
|
txLocs, err := block.TxLoc()
|
|
if err != nil {
|
|
tc.t.Errorf("block.TxLoc(%d): unexpected error: %v", i,
|
|
err)
|
|
return false
|
|
}
|
|
|
|
// Ensure StoreBlock returns expected error.
|
|
testName = "StoreBlock on closed tx"
|
|
err = tx.StoreBlock(block)
|
|
if !checkDbError(tc.t, testName, err, wantErrCode) {
|
|
return false
|
|
}
|
|
|
|
// Ensure FetchBlock returns expected error.
|
|
testName = fmt.Sprintf("FetchBlock #%d on closed tx", i)
|
|
_, err = tx.FetchBlock(blockHash)
|
|
if !checkDbError(tc.t, testName, err, wantErrCode) {
|
|
return false
|
|
}
|
|
|
|
// Ensure FetchBlockHeader returns expected error.
|
|
testName = fmt.Sprintf("FetchBlockHeader #%d on closed tx", i)
|
|
_, err = tx.FetchBlockHeader(blockHash)
|
|
if !checkDbError(tc.t, testName, err, wantErrCode) {
|
|
return false
|
|
}
|
|
|
|
// Ensure the first transaction fetched as a block region from
|
|
// the database returns the expected error.
|
|
region := database.BlockRegion{
|
|
Hash: blockHash,
|
|
Offset: uint32(txLocs[0].TxStart),
|
|
Len: uint32(txLocs[0].TxLen),
|
|
}
|
|
allBlockRegions[i] = region
|
|
_, err = tx.FetchBlockRegion(®ion)
|
|
if !checkDbError(tc.t, testName, err, wantErrCode) {
|
|
return false
|
|
}
|
|
|
|
// Ensure HasBlock returns expected error.
|
|
testName = fmt.Sprintf("HasBlock #%d on closed tx", i)
|
|
_, err = tx.HasBlock(blockHash)
|
|
if !checkDbError(tc.t, testName, err, wantErrCode) {
|
|
return false
|
|
}
|
|
}
|
|
|
|
// -----------------
|
|
// Bulk Block IO API
|
|
// -----------------
|
|
|
|
// Ensure FetchBlocks returns expected error.
|
|
testName = "FetchBlocks on closed tx"
|
|
_, err = tx.FetchBlocks(allBlockHashes)
|
|
if !checkDbError(tc.t, testName, err, wantErrCode) {
|
|
return false
|
|
}
|
|
|
|
// Ensure FetchBlockHeaders returns expected error.
|
|
testName = "FetchBlockHeaders on closed tx"
|
|
_, err = tx.FetchBlockHeaders(allBlockHashes)
|
|
if !checkDbError(tc.t, testName, err, wantErrCode) {
|
|
return false
|
|
}
|
|
|
|
// Ensure FetchBlockRegions returns expected error.
|
|
testName = "FetchBlockRegions on closed tx"
|
|
_, err = tx.FetchBlockRegions(allBlockRegions)
|
|
if !checkDbError(tc.t, testName, err, wantErrCode) {
|
|
return false
|
|
}
|
|
|
|
// Ensure HasBlocks returns expected error.
|
|
testName = "HasBlocks on closed tx"
|
|
_, err = tx.HasBlocks(allBlockHashes)
|
|
if !checkDbError(tc.t, testName, err, wantErrCode) {
|
|
return false
|
|
}
|
|
|
|
// ---------------
|
|
// Commit/Rollback
|
|
// ---------------
|
|
|
|
// Ensure that attempting to rollback or commit a transaction that is
|
|
// already closed returns the expected error.
|
|
err = tx.Rollback()
|
|
if !checkDbError(tc.t, "closed tx rollback", err, wantErrCode) {
|
|
return false
|
|
}
|
|
err = tx.Commit()
|
|
if !checkDbError(tc.t, "closed tx commit", err, wantErrCode) {
|
|
return false
|
|
}
|
|
|
|
return true
|
|
}
|
|
|
|
// testTxClosed ensures that both the metadata and block IO API functions behave
|
|
// as expected when attempted against both read-only and read-write
|
|
// transactions.
|
|
func testTxClosed(tc *testContext) bool {
|
|
bucketName := []byte("closedtxbucket")
|
|
keyName := []byte("closedtxkey")
|
|
|
|
// Start a transaction, create a bucket and key used for testing, and
|
|
// immediately perform a commit on it so it is closed.
|
|
tx, err := tc.db.Begin(true)
|
|
if err != nil {
|
|
tc.t.Errorf("Begin(true): unexpected error: %v", err)
|
|
return false
|
|
}
|
|
defer rollbackOnPanic(tc.t, tx)
|
|
if _, err := tx.Metadata().CreateBucket(bucketName); err != nil {
|
|
tc.t.Errorf("CreateBucket: unexpected error: %v", err)
|
|
return false
|
|
}
|
|
if err := tx.Metadata().Put(keyName, []byte("test")); err != nil {
|
|
tc.t.Errorf("Put: unexpected error: %v", err)
|
|
return false
|
|
}
|
|
if err := tx.Commit(); err != nil {
|
|
tc.t.Errorf("Commit: unexpected error: %v", err)
|
|
return false
|
|
}
|
|
|
|
// Ensure invoking all of the functions on the closed read-write
|
|
// transaction behave as expected.
|
|
if !testClosedTxInterface(tc, tx) {
|
|
return false
|
|
}
|
|
|
|
// Repeat the tests with a rolled-back read-only transaction.
|
|
tx, err = tc.db.Begin(false)
|
|
if err != nil {
|
|
tc.t.Errorf("Begin(false): unexpected error: %v", err)
|
|
return false
|
|
}
|
|
defer rollbackOnPanic(tc.t, tx)
|
|
if err := tx.Rollback(); err != nil {
|
|
tc.t.Errorf("Rollback: unexpected error: %v", err)
|
|
return false
|
|
}
|
|
|
|
// Ensure invoking all of the functions on the closed read-only
|
|
// transaction behave as expected.
|
|
return testClosedTxInterface(tc, tx)
|
|
}
|
|
|
|
// testConcurrecy ensure the database properly supports concurrent readers and
|
|
// only a single writer. It also ensures views act as snapshots at the time
|
|
// they are acquired.
|
|
func testConcurrecy(tc *testContext) bool {
|
|
// sleepTime is how long each of the concurrent readers should sleep to
|
|
// aid in detection of whether or not the data is actually being read
|
|
// concurrently. It starts with a sane lower bound.
|
|
var sleepTime = time.Millisecond * 250
|
|
|
|
// Determine about how long it takes for a single block read. When it's
|
|
// longer than the default minimum sleep time, adjust the sleep time to
|
|
// help prevent durations that are too short which would cause erroneous
|
|
// test failures on slower systems.
|
|
startTime := time.Now()
|
|
err := tc.db.View(func(tx database.Tx) error {
|
|
_, err := tx.FetchBlock(tc.blocks[0].Hash())
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
})
|
|
if err != nil {
|
|
tc.t.Errorf("Unexpected error in view: %v", err)
|
|
return false
|
|
}
|
|
elapsed := time.Now().Sub(startTime)
|
|
if sleepTime < elapsed {
|
|
sleepTime = elapsed
|
|
}
|
|
tc.t.Logf("Time to load block 0: %v, using sleep time: %v", elapsed,
|
|
sleepTime)
|
|
|
|
// reader takes a block number to load and channel to return the result
|
|
// of the operation on. It is used below to launch multiple concurrent
|
|
// readers.
|
|
numReaders := len(tc.blocks)
|
|
resultChan := make(chan bool, numReaders)
|
|
reader := func(blockNum int) {
|
|
err := tc.db.View(func(tx database.Tx) error {
|
|
time.Sleep(sleepTime)
|
|
_, err := tx.FetchBlock(tc.blocks[blockNum].Hash())
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
})
|
|
if err != nil {
|
|
tc.t.Errorf("Unexpected error in concurrent view: %v",
|
|
err)
|
|
resultChan <- false
|
|
}
|
|
resultChan <- true
|
|
}
|
|
|
|
// Start up several concurrent readers for the same block and wait for
|
|
// the results.
|
|
startTime = time.Now()
|
|
for i := 0; i < numReaders; i++ {
|
|
go reader(0)
|
|
}
|
|
for i := 0; i < numReaders; i++ {
|
|
if result := <-resultChan; !result {
|
|
return false
|
|
}
|
|
}
|
|
elapsed = time.Now().Sub(startTime)
|
|
tc.t.Logf("%d concurrent reads of same block elapsed: %v", numReaders,
|
|
elapsed)
|
|
|
|
// Consider it a failure if it took longer than half the time it would
|
|
// take with no concurrency.
|
|
if elapsed > sleepTime*time.Duration(numReaders/2) {
|
|
tc.t.Errorf("Concurrent views for same block did not appear to "+
|
|
"run simultaneously: elapsed %v", elapsed)
|
|
return false
|
|
}
|
|
|
|
// Start up several concurrent readers for different blocks and wait for
|
|
// the results.
|
|
startTime = time.Now()
|
|
for i := 0; i < numReaders; i++ {
|
|
go reader(i)
|
|
}
|
|
for i := 0; i < numReaders; i++ {
|
|
if result := <-resultChan; !result {
|
|
return false
|
|
}
|
|
}
|
|
elapsed = time.Now().Sub(startTime)
|
|
tc.t.Logf("%d concurrent reads of different blocks elapsed: %v",
|
|
numReaders, elapsed)
|
|
|
|
// Consider it a failure if it took longer than half the time it would
|
|
// take with no concurrency.
|
|
if elapsed > sleepTime*time.Duration(numReaders/2) {
|
|
tc.t.Errorf("Concurrent views for different blocks did not "+
|
|
"appear to run simultaneously: elapsed %v", elapsed)
|
|
return false
|
|
}
|
|
|
|
// Start up a few readers and wait for them to acquire views. Each
|
|
// reader waits for a signal from the writer to be finished to ensure
|
|
// that the data written by the writer is not seen by the view since it
|
|
// was started before the data was set.
|
|
concurrentKey := []byte("notthere")
|
|
concurrentVal := []byte("someval")
|
|
started := make(chan struct{})
|
|
writeComplete := make(chan struct{})
|
|
reader = func(blockNum int) {
|
|
err := tc.db.View(func(tx database.Tx) error {
|
|
started <- struct{}{}
|
|
|
|
// Wait for the writer to complete.
|
|
<-writeComplete
|
|
|
|
// Since this reader was created before the write took
|
|
// place, the data it added should not be visible.
|
|
val := tx.Metadata().Get(concurrentKey)
|
|
if val != nil {
|
|
return fmt.Errorf("%s should not be visible",
|
|
concurrentKey)
|
|
}
|
|
return nil
|
|
})
|
|
if err != nil {
|
|
tc.t.Errorf("Unexpected error in concurrent view: %v",
|
|
err)
|
|
resultChan <- false
|
|
}
|
|
resultChan <- true
|
|
}
|
|
for i := 0; i < numReaders; i++ {
|
|
go reader(0)
|
|
}
|
|
for i := 0; i < numReaders; i++ {
|
|
<-started
|
|
}
|
|
|
|
// All readers are started and waiting for completion of the writer.
|
|
// Set some data the readers are expecting to not find and signal the
|
|
// readers the write is done by closing the writeComplete channel.
|
|
err = tc.db.Update(func(tx database.Tx) error {
|
|
err := tx.Metadata().Put(concurrentKey, concurrentVal)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
})
|
|
if err != nil {
|
|
tc.t.Errorf("Unexpected error in update: %v", err)
|
|
return false
|
|
}
|
|
close(writeComplete)
|
|
|
|
// Wait for reader results.
|
|
for i := 0; i < numReaders; i++ {
|
|
if result := <-resultChan; !result {
|
|
return false
|
|
}
|
|
}
|
|
|
|
// Start a few writers and ensure the total time is at least the
|
|
// writeSleepTime * numWriters. This ensures only one write transaction
|
|
// can be active at a time.
|
|
writeSleepTime := time.Millisecond * 250
|
|
writer := func() {
|
|
err := tc.db.Update(func(tx database.Tx) error {
|
|
time.Sleep(writeSleepTime)
|
|
return nil
|
|
})
|
|
if err != nil {
|
|
tc.t.Errorf("Unexpected error in concurrent view: %v",
|
|
err)
|
|
resultChan <- false
|
|
}
|
|
resultChan <- true
|
|
}
|
|
numWriters := 3
|
|
startTime = time.Now()
|
|
for i := 0; i < numWriters; i++ {
|
|
go writer()
|
|
}
|
|
for i := 0; i < numWriters; i++ {
|
|
if result := <-resultChan; !result {
|
|
return false
|
|
}
|
|
}
|
|
elapsed = time.Now().Sub(startTime)
|
|
tc.t.Logf("%d concurrent writers elapsed using sleep time %v: %v",
|
|
numWriters, writeSleepTime, elapsed)
|
|
|
|
// The total time must have been at least the sum of all sleeps if the
|
|
// writes blocked properly.
|
|
if elapsed < writeSleepTime*time.Duration(numWriters) {
|
|
tc.t.Errorf("Concurrent writes appeared to run simultaneously: "+
|
|
"elapsed %v", elapsed)
|
|
return false
|
|
}
|
|
|
|
return true
|
|
}
|
|
|
|
// testConcurrentClose ensures that closing the database with open transactions
|
|
// blocks until the transactions are finished.
|
|
//
|
|
// The database will be closed upon returning from this function.
|
|
func testConcurrentClose(tc *testContext) bool {
|
|
// Start up a few readers and wait for them to acquire views. Each
|
|
// reader waits for a signal to complete to ensure the transactions stay
|
|
// open until they are explicitly signalled to be closed.
|
|
var activeReaders int32
|
|
numReaders := 3
|
|
started := make(chan struct{})
|
|
finishReaders := make(chan struct{})
|
|
resultChan := make(chan bool, numReaders+1)
|
|
reader := func() {
|
|
err := tc.db.View(func(tx database.Tx) error {
|
|
atomic.AddInt32(&activeReaders, 1)
|
|
started <- struct{}{}
|
|
<-finishReaders
|
|
atomic.AddInt32(&activeReaders, -1)
|
|
return nil
|
|
})
|
|
if err != nil {
|
|
tc.t.Errorf("Unexpected error in concurrent view: %v",
|
|
err)
|
|
resultChan <- false
|
|
}
|
|
resultChan <- true
|
|
}
|
|
for i := 0; i < numReaders; i++ {
|
|
go reader()
|
|
}
|
|
for i := 0; i < numReaders; i++ {
|
|
<-started
|
|
}
|
|
|
|
// Close the database in a separate goroutine. This should block until
|
|
// the transactions are finished. Once the close has taken place, the
|
|
// dbClosed channel is closed to signal the main goroutine below.
|
|
dbClosed := make(chan struct{})
|
|
go func() {
|
|
started <- struct{}{}
|
|
err := tc.db.Close()
|
|
if err != nil {
|
|
tc.t.Errorf("Unexpected error in concurrent view: %v",
|
|
err)
|
|
resultChan <- false
|
|
}
|
|
close(dbClosed)
|
|
resultChan <- true
|
|
}()
|
|
<-started
|
|
|
|
// Wait a short period and then signal the reader transactions to
|
|
// finish. When the db closed channel is received, ensure there are no
|
|
// active readers open.
|
|
time.AfterFunc(time.Millisecond*250, func() { close(finishReaders) })
|
|
<-dbClosed
|
|
if nr := atomic.LoadInt32(&activeReaders); nr != 0 {
|
|
tc.t.Errorf("Close did not appear to block with active "+
|
|
"readers: %d active", nr)
|
|
return false
|
|
}
|
|
|
|
// Wait for all results.
|
|
for i := 0; i < numReaders+1; i++ {
|
|
if result := <-resultChan; !result {
|
|
return false
|
|
}
|
|
}
|
|
|
|
return true
|
|
}
|
|
|
|
// testInterface tests performs tests for the various interfaces of the database
|
|
// package which require state in the database for the given database type.
|
|
func testInterface(t *testing.T, db database.DB) {
|
|
// Create a test context to pass around.
|
|
context := testContext{t: t, db: db}
|
|
|
|
// Load the test blocks and store in the test context for use throughout
|
|
// the tests.
|
|
blocks, err := loadBlocks(t, blockDataFile, blockDataNet)
|
|
if err != nil {
|
|
t.Errorf("loadBlocks: Unexpected error: %v", err)
|
|
return
|
|
}
|
|
context.blocks = blocks
|
|
|
|
// Test the transaction metadata interface including managed and manual
|
|
// transactions as well as buckets.
|
|
if !testMetadataTxInterface(&context) {
|
|
return
|
|
}
|
|
|
|
// Test the transaction block IO interface using managed and manual
|
|
// transactions. This function leaves all of the stored blocks in the
|
|
// database since they're used later.
|
|
if !testBlockIOTxInterface(&context) {
|
|
return
|
|
}
|
|
|
|
// Test all of the transaction interface functions against a closed
|
|
// transaction work as expected.
|
|
if !testTxClosed(&context) {
|
|
return
|
|
}
|
|
|
|
// Test the database properly supports concurrency.
|
|
if !testConcurrecy(&context) {
|
|
return
|
|
}
|
|
|
|
// Test that closing the database with open transactions blocks until
|
|
// the transactions are finished.
|
|
//
|
|
// The database will be closed upon returning from this function, so it
|
|
// must be the last thing called.
|
|
testConcurrentClose(&context)
|
|
}
|