lbcd/blockchain/chainview_test.go

// Copyright (c) 2017 The btcsuite developers
// Use of this source code is governed by an ISC
// license that can be found in the LICENSE file.

package blockchain

import (
	"fmt"
	"math/rand"
	"reflect"
	"testing"

	"github.com/roasbeef/btcd/wire"
)

// testNoncePrng provides a deterministic prng for the nonce in generated fake
// nodes.  The ensures that the node have unique hashes.
var testNoncePrng = rand.New(rand.NewSource(0))

// chainedNodes returns the specified number of nodes constructed such that each
// subsequent node points to the previous one to create a chain.  The first node
// will point to the passed parent which can be nil if desired.
func chainedNodes(parent *blockNode, numNodes int) []*blockNode {
	nodes := make([]*blockNode, numNodes)
	tip := parent
	for i := 0; i < numNodes; i++ {
		// This is invalid, but all that is needed is enough to get the
		// synthetic tests to work.
		header := wire.BlockHeader{Nonce: testNoncePrng.Uint32()}
		if tip != nil {
			header.PrevBlock = tip.hash
		}
		nodes[i] = newBlockNode(&header, tip)
		tip = nodes[i]
	}
	return nodes
}

// String returns the block node as a human-readable name.
func (node blockNode) String() string {
	return fmt.Sprintf("%s(%d)", node.hash, node.height)
}

// tstTip is a convenience function to grab the tip of a chain of block nodes
// created via chainedNodes.
func tstTip(nodes []*blockNode) *blockNode {
	return nodes[len(nodes)-1]
}

// locatorHashes is a convenience function that returns the hashes for all of
// the passed indexes of the provided nodes.  It is used to construct expected
// block locators in the tests.
func locatorHashes(nodes []*blockNode, indexes ...int) BlockLocator {
	hashes := make(BlockLocator, 0, len(indexes))
	for _, idx := range indexes {
		hashes = append(hashes, &nodes[idx].hash)
	}
	return hashes
}

// zipLocators is a convenience function that returns a single block locator
// given a variable number of them and is used in the tests.
func zipLocators(locators ...BlockLocator) BlockLocator {
	var hashes BlockLocator
	for _, locator := range locators {
		hashes = append(hashes, locator...)
	}
	return hashes
}

// TestChainView ensures all of the exported functionality of chain views works
// as intended with the exception of some special cases which are handled in
// other tests.
func TestChainView(t *testing.T) {
	// Construct a synthetic block index consisting of the following
	// structure.
	// 0 -> 1 -> 2  -> 3  -> 4
	//       \-> 2a -> 3a -> 4a  -> 5a -> 6a -> 7a -> ... -> 26a
	//             \-> 3a'-> 4a' -> 5a'
	branch0Nodes := chainedNodes(nil, 5)
	branch1Nodes := chainedNodes(branch0Nodes[1], 25)
	branch2Nodes := chainedNodes(branch1Nodes[0], 3)

	tip := tstTip
	tests := []struct {
		name       string
		view       *chainView   // active view
		genesis    *blockNode   // expected genesis block of active view
		tip        *blockNode   // expected tip of active view
		side       *chainView   // side chain view
		sideTip    *blockNode   // expected tip of side chain view
		fork       *blockNode   // expected fork node
		contains   []*blockNode // expected nodes in active view
		noContains []*blockNode // expected nodes NOT in active view
		equal      *chainView   // view expected equal to active view
		unequal    *chainView   // view expected NOT equal to active
		locator    BlockLocator // expected locator for active view tip
	}{
		{
			// Create a view for branch 0 as the active chain and
			// another view for branch 1 as the side chain.
			name:       "chain0-chain1",
			view:       newChainView(tip(branch0Nodes)),
			genesis:    branch0Nodes[0],
			tip:        tip(branch0Nodes),
			side:       newChainView(tip(branch1Nodes)),
			sideTip:    tip(branch1Nodes),
			fork:       branch0Nodes[1],
			contains:   branch0Nodes,
			noContains: branch1Nodes,
			equal:      newChainView(tip(branch0Nodes)),
			unequal:    newChainView(tip(branch1Nodes)),
			locator:    locatorHashes(branch0Nodes, 4, 3, 2, 1, 0),
		},
		{
			// Create a view for branch 1 as the active chain and
			// another view for branch 2 as the side chain.
			name:       "chain1-chain2",
			view:       newChainView(tip(branch1Nodes)),
			genesis:    branch0Nodes[0],
			tip:        tip(branch1Nodes),
			side:       newChainView(tip(branch2Nodes)),
			sideTip:    tip(branch2Nodes),
			fork:       branch1Nodes[0],
			contains:   branch1Nodes,
			noContains: branch2Nodes,
			equal:      newChainView(tip(branch1Nodes)),
			unequal:    newChainView(tip(branch2Nodes)),
			locator: zipLocators(
				locatorHashes(branch1Nodes, 24, 23, 22, 21, 20,
					19, 18, 17, 16, 15, 14, 13, 11, 7),
				locatorHashes(branch0Nodes, 1, 0)),
		},
		{
			// Create a view for branch 2 as the active chain and
			// another view for branch 0 as the side chain.
			name:       "chain2-chain0",
			view:       newChainView(tip(branch2Nodes)),
			genesis:    branch0Nodes[0],
			tip:        tip(branch2Nodes),
			side:       newChainView(tip(branch0Nodes)),
			sideTip:    tip(branch0Nodes),
			fork:       branch0Nodes[1],
			contains:   branch2Nodes,
			noContains: branch0Nodes[2:],
			equal:      newChainView(tip(branch2Nodes)),
			unequal:    newChainView(tip(branch0Nodes)),
			locator: zipLocators(
				locatorHashes(branch2Nodes, 2, 1, 0),
				locatorHashes(branch1Nodes, 0),
				locatorHashes(branch0Nodes, 1, 0)),
		},
	}
testLoop:
	for _, test := range tests {
		// Ensure the active and side chain heights are the expected
		// values.
		if test.view.Height() != test.tip.height {
			t.Errorf("%s: unexpected active view height -- got "+
				"%d, want %d", test.name, test.view.Height(),
				test.tip.height)
			continue
		}
		if test.side.Height() != test.sideTip.height {
			t.Errorf("%s: unexpected side view height -- got %d, "+
				"want %d", test.name, test.side.Height(),
				test.sideTip.height)
			continue
		}

		// Ensure the active and side chain genesis block is the
		// expected value.
		if test.view.Genesis() != test.genesis {
			t.Errorf("%s: unexpected active view genesis -- got "+
				"%v, want %v", test.name, test.view.Genesis(),
				test.genesis)
			continue
		}
		if test.side.Genesis() != test.genesis {
			t.Errorf("%s: unexpected side view genesis -- got %v, "+
				"want %v", test.name, test.view.Genesis(),
				test.genesis)
			continue
		}

		// Ensure the active and side chain tips are the expected nodes.
		if test.view.Tip() != test.tip {
			t.Errorf("%s: unexpected active view tip -- got %v, "+
				"want %v", test.name, test.view.Tip(), test.tip)
			continue
		}
		if test.side.Tip() != test.sideTip {
			t.Errorf("%s: unexpected active view tip -- got %v, "+
				"want %v", test.name, test.side.Tip(),
				test.sideTip)
			continue
		}

		// Ensure that regardless of the order the two chains are
		// compared they both return the expected fork point.
		forkNode := test.view.FindFork(test.side.Tip())
		if forkNode != test.fork {
			t.Errorf("%s: unexpected fork node (view, side) -- "+
				"got %v, want %v", test.name, forkNode,
				test.fork)
			continue
		}
		forkNode = test.side.FindFork(test.view.Tip())
		if forkNode != test.fork {
			t.Errorf("%s: unexpected fork node (side, view) -- "+
				"got %v, want %v", test.name, forkNode,
				test.fork)
			continue
		}

		// Ensure that the fork point for a node that is already part
		// of the chain view is the node itself.
		forkNode = test.view.FindFork(test.view.Tip())
		if forkNode != test.view.Tip() {
			t.Errorf("%s: unexpected fork node (view, tip) -- "+
				"got %v, want %v", test.name, forkNode,
				test.view.Tip())
			continue
		}

		// Ensure all expected nodes are contained in the active view.
		for _, node := range test.contains {
			if !test.view.Contains(node) {
				t.Errorf("%s: expected %v in active view",
					test.name, node)
				continue testLoop
			}
		}

		// Ensure all nodes from side chain view are NOT contained in
		// the active view.
		for _, node := range test.noContains {
			if test.view.Contains(node) {
				t.Errorf("%s: unexpected %v in active view",
					test.name, node)
				continue testLoop
			}
		}

		// Ensure equality of different views into the same chain works
		// as intended.
		if !test.view.Equals(test.equal) {
			t.Errorf("%s: unexpected unequal views", test.name)
			continue
		}
		if test.view.Equals(test.unequal) {
			t.Errorf("%s: unexpected equal views", test.name)
			continue
		}

		// Ensure all nodes contained in the view return the expected
		// next node.
		for i, node := range test.contains {
			// Final node expects nil for the next node.
			var expected *blockNode
			if i < len(test.contains)-1 {
				expected = test.contains[i+1]
			}
			if next := test.view.Next(node); next != expected {
				t.Errorf("%s: unexpected next node -- got %v, "+
					"want %v", test.name, next, expected)
				continue testLoop
			}
		}

		// Ensure nodes that are not contained in the view do not
		// produce a successor node.
		for _, node := range test.noContains {
			if next := test.view.Next(node); next != nil {
				t.Errorf("%s: unexpected next node -- got %v, "+
					"want nil", test.name, next)
				continue testLoop
			}
		}

		// Ensure all nodes contained in the view can be retrieved by
		// height.
		for _, wantNode := range test.contains {
			node := test.view.NodeByHeight(wantNode.height)
			if node != wantNode {
				t.Errorf("%s: unexpected node for height %d -- "+
					"got %v, want %v", test.name,
					wantNode.height, node, wantNode)
				continue testLoop
			}
		}

		// Ensure the block locator for the tip of the active view
		// consists of the expected hashes.
		locator := test.view.BlockLocator(test.view.tip())
		if !reflect.DeepEqual(locator, test.locator) {
			t.Errorf("%s: unexpected locator -- got %v, want %v",
				test.name, locator, test.locator)
			continue
		}
	}
}

// TestChainViewForkCorners ensures that finding the fork between two chains
// works in some corner cases such as when the two chains have completely
// unrelated histories.
func TestChainViewForkCorners(t *testing.T) {
	// Construct two unrelated single branch synthetic block indexes.
	branchNodes := chainedNodes(nil, 5)
	unrelatedBranchNodes := chainedNodes(nil, 7)

	// Create chain views for the two unrelated histories.
	view1 := newChainView(tstTip(branchNodes))
	view2 := newChainView(tstTip(unrelatedBranchNodes))

	// Ensure attempting to find a fork point with a node that doesn't exist
	// doesn't produce a node.
	if fork := view1.FindFork(nil); fork != nil {
		t.Fatalf("FindFork: unexpected fork -- got %v, want nil", fork)
	}

	// Ensure attempting to find a fork point in two chain views with
	// totally unrelated histories doesn't produce a node.
	for _, node := range branchNodes {
		if fork := view2.FindFork(node); fork != nil {
			t.Fatalf("FindFork: unexpected fork -- got %v, want nil",
				fork)
		}
	}
	for _, node := range unrelatedBranchNodes {
		if fork := view1.FindFork(node); fork != nil {
			t.Fatalf("FindFork: unexpected fork -- got %v, want nil",
				fork)
		}
	}
}

// TestChainViewSetTip ensures changing the tip works as intended including
// capacity changes.
func TestChainViewSetTip(t *testing.T) {
	// Construct a synthetic block index consisting of the following
	// structure.
	// 0 -> 1 -> 2  -> 3  -> 4
	//       \-> 2a -> 3a -> 4a  -> 5a -> 6a -> 7a -> ... -> 26a
	branch0Nodes := chainedNodes(nil, 5)
	branch1Nodes := chainedNodes(branch0Nodes[1], 25)

	tip := tstTip
	tests := []struct {
		name     string
		view     *chainView     // active view
		tips     []*blockNode   // tips to set
		contains [][]*blockNode // expected nodes in view for each tip
	}{
		{
			// Create an empty view and set the tip to increasingly
			// longer chains.
			name:     "increasing",
			view:     newChainView(nil),
			tips:     []*blockNode{tip(branch0Nodes), tip(branch1Nodes)},
			contains: [][]*blockNode{branch0Nodes, branch1Nodes},
		},
		{
			// Create a view with a longer chain and set the tip to
			// increasingly shorter chains.
			name:     "decreasing",
			view:     newChainView(tip(branch1Nodes)),
			tips:     []*blockNode{tip(branch0Nodes), nil},
			contains: [][]*blockNode{branch0Nodes, nil},
		},
		{
			// Create a view with a shorter chain and set the tip to
			// a longer chain followed by setting it back to the
			// shorter chain.
			name:     "small-large-small",
			view:     newChainView(tip(branch0Nodes)),
			tips:     []*blockNode{tip(branch1Nodes), tip(branch0Nodes)},
			contains: [][]*blockNode{branch1Nodes, branch0Nodes},
		},
		{
			// Create a view with a longer chain and set the tip to
			// a smaller chain followed by setting it back to the
			// longer chain.
			name:     "large-small-large",
			view:     newChainView(tip(branch1Nodes)),
			tips:     []*blockNode{tip(branch0Nodes), tip(branch1Nodes)},
			contains: [][]*blockNode{branch0Nodes, branch1Nodes},
		},
	}

testLoop:
	for _, test := range tests {
		for i, tip := range test.tips {
			// Ensure the view tip is the expected node.
			test.view.SetTip(tip)
			if test.view.Tip() != tip {
				t.Errorf("%s: unexpected view tip -- got %v, "+
					"want %v", test.name, test.view.Tip(),
					tip)
				continue testLoop
			}

			// Ensure all expected nodes are contained in the view.
			for _, node := range test.contains[i] {
				if !test.view.Contains(node) {
					t.Errorf("%s: expected %v in active view",
						test.name, node)
					continue testLoop
				}
			}

		}
	}
}

// TestChainViewNil ensures that creating and accessing a nil chain view behaves
// as expected.
func TestChainViewNil(t *testing.T) {
	// Ensure two unininitialized views are considered equal.
	view := newChainView(nil)
	if !view.Equals(newChainView(nil)) {
		t.Fatal("uninitialized nil views unequal")
	}

	// Ensure the genesis of an uninitialized view does not produce a node.
	if genesis := view.Genesis(); genesis != nil {
		t.Fatalf("Genesis: unexpected genesis -- got %v, want nil",
			genesis)
	}

	// Ensure the tip of an uninitialized view does not produce a node.
	if tip := view.Tip(); tip != nil {
		t.Fatalf("Tip: unexpected tip -- got %v, want nil", tip)
	}

	// Ensure the height of an uninitialized view is the expected value.
	if height := view.Height(); height != -1 {
		t.Fatalf("Height: unexpected height -- got %d, want -1", height)
	}

	// Ensure attempting to get a node for a height that does not exist does
	// not produce a node.
	if node := view.NodeByHeight(10); node != nil {
		t.Fatalf("NodeByHeight: unexpected node -- got %v, want nil", node)
	}

	// Ensure an uninitialized view does not report it contains nodes.
	fakeNode := chainedNodes(nil, 1)[0]
	if view.Contains(fakeNode) {
		t.Fatalf("Contains: view claims it contains node %v", fakeNode)
	}

	// Ensure the next node for a node that does not exist does not produce
	// a node.
	if next := view.Next(nil); next != nil {
		t.Fatalf("Next: unexpected next node -- got %v, want nil", next)
	}

	// Ensure the next node for a node that exists does not produce a node.
	if next := view.Next(fakeNode); next != nil {
		t.Fatalf("Next: unexpected next node -- got %v, want nil", next)
	}

	// Ensure attempting to find a fork point with a node that doesn't exist
	// doesn't produce a node.
	if fork := view.FindFork(nil); fork != nil {
		t.Fatalf("FindFork: unexpected fork -- got %v, want nil", fork)
	}

	// Ensure attempting to get a block locator for the tip doesn't produce
	// one since the tip is nil.
	if locator := view.BlockLocator(nil); locator != nil {
		t.Fatalf("BlockLocator: unexpected locator -- got %v, want nil",
			locator)
	}

	// Ensure attempting to get a block locator for a node that exists still
	// works as intended.
	branchNodes := chainedNodes(nil, 50)
	wantLocator := locatorHashes(branchNodes, 49, 48, 47, 46, 45, 44, 43,
		42, 41, 40, 39, 38, 36, 32, 24, 8, 0)
	locator := view.BlockLocator(tstTip(branchNodes))
	if !reflect.DeepEqual(locator, wantLocator) {
		t.Fatalf("BlockLocator: unexpected locator -- got %v, want %v",
			locator, wantLocator)
	}
}