You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
691 lines
21 KiB
691 lines
21 KiB
package v1
|
|
|
|
import (
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/stretchr/testify/assert"
|
|
|
|
"github.com/tendermint/tendermint/libs/log"
|
|
"github.com/tendermint/tendermint/p2p"
|
|
"github.com/tendermint/tendermint/types"
|
|
)
|
|
|
|
type testPeer struct {
|
|
id p2p.ID
|
|
base int64
|
|
height int64
|
|
}
|
|
|
|
type testBcR struct {
|
|
logger log.Logger
|
|
}
|
|
|
|
type testValues struct {
|
|
numRequestsSent int
|
|
}
|
|
|
|
var testResults testValues
|
|
|
|
func resetPoolTestResults() {
|
|
testResults.numRequestsSent = 0
|
|
}
|
|
|
|
func (testR *testBcR) sendPeerError(err error, peerID p2p.ID) {
|
|
}
|
|
|
|
func (testR *testBcR) sendStatusRequest() {
|
|
}
|
|
|
|
func (testR *testBcR) sendBlockRequest(peerID p2p.ID, height int64) error {
|
|
testResults.numRequestsSent++
|
|
return nil
|
|
}
|
|
|
|
func (testR *testBcR) resetStateTimer(name string, timer **time.Timer, timeout time.Duration) {
|
|
}
|
|
|
|
func (testR *testBcR) switchToConsensus() {
|
|
|
|
}
|
|
|
|
func newTestBcR() *testBcR {
|
|
testBcR := &testBcR{logger: log.TestingLogger()}
|
|
return testBcR
|
|
}
|
|
|
|
type tPBlocks struct {
|
|
id p2p.ID
|
|
create bool
|
|
}
|
|
|
|
// Makes a block pool with specified current height, list of peers, block requests and block responses
|
|
func makeBlockPool(bcr *testBcR, height int64, peers []BpPeer, blocks map[int64]tPBlocks) *BlockPool {
|
|
bPool := NewBlockPool(height, bcr)
|
|
bPool.SetLogger(bcr.logger)
|
|
|
|
txs := []types.Tx{types.Tx("foo"), types.Tx("bar")}
|
|
|
|
var maxH int64
|
|
for _, p := range peers {
|
|
if p.Height > maxH {
|
|
maxH = p.Height
|
|
}
|
|
bPool.peers[p.ID] = NewBpPeer(p.ID, p.Base, p.Height, bcr.sendPeerError, nil)
|
|
bPool.peers[p.ID].SetLogger(bcr.logger)
|
|
|
|
}
|
|
bPool.MaxPeerHeight = maxH
|
|
for h, p := range blocks {
|
|
bPool.blocks[h] = p.id
|
|
bPool.peers[p.id].RequestSent(h)
|
|
if p.create {
|
|
// simulate that a block at height h has been received
|
|
_ = bPool.peers[p.id].AddBlock(types.MakeBlock(h, txs, nil, nil), 100)
|
|
}
|
|
}
|
|
return bPool
|
|
}
|
|
|
|
func assertPeerSetsEquivalent(t *testing.T, set1 map[p2p.ID]*BpPeer, set2 map[p2p.ID]*BpPeer) {
|
|
assert.Equal(t, len(set1), len(set2))
|
|
for peerID, peer1 := range set1 {
|
|
peer2 := set2[peerID]
|
|
assert.NotNil(t, peer2)
|
|
assert.Equal(t, peer1.NumPendingBlockRequests, peer2.NumPendingBlockRequests)
|
|
assert.Equal(t, peer1.Height, peer2.Height)
|
|
assert.Equal(t, peer1.Base, peer2.Base)
|
|
assert.Equal(t, len(peer1.blocks), len(peer2.blocks))
|
|
for h, block1 := range peer1.blocks {
|
|
block2 := peer2.blocks[h]
|
|
// block1 and block2 could be nil if a request was made but no block was received
|
|
assert.Equal(t, block1, block2)
|
|
}
|
|
}
|
|
}
|
|
|
|
func assertBlockPoolEquivalent(t *testing.T, poolWanted, pool *BlockPool) {
|
|
assert.Equal(t, poolWanted.blocks, pool.blocks)
|
|
assertPeerSetsEquivalent(t, poolWanted.peers, pool.peers)
|
|
assert.Equal(t, poolWanted.MaxPeerHeight, pool.MaxPeerHeight)
|
|
assert.Equal(t, poolWanted.Height, pool.Height)
|
|
|
|
}
|
|
|
|
func TestBlockPoolUpdatePeer(t *testing.T) {
|
|
testBcR := newTestBcR()
|
|
|
|
tests := []struct {
|
|
name string
|
|
pool *BlockPool
|
|
args testPeer
|
|
poolWanted *BlockPool
|
|
errWanted error
|
|
}{
|
|
{
|
|
name: "add a first short peer",
|
|
pool: makeBlockPool(testBcR, 100, []BpPeer{}, map[int64]tPBlocks{}),
|
|
args: testPeer{"P1", 0, 50},
|
|
errWanted: errPeerTooShort,
|
|
poolWanted: makeBlockPool(testBcR, 100, []BpPeer{}, map[int64]tPBlocks{}),
|
|
},
|
|
{
|
|
name: "add a first good peer",
|
|
pool: makeBlockPool(testBcR, 100, []BpPeer{}, map[int64]tPBlocks{}),
|
|
args: testPeer{"P1", 0, 101},
|
|
poolWanted: makeBlockPool(testBcR, 100, []BpPeer{{ID: "P1", Height: 101}}, map[int64]tPBlocks{}),
|
|
},
|
|
{
|
|
name: "add a first good peer with base",
|
|
pool: makeBlockPool(testBcR, 100, []BpPeer{}, map[int64]tPBlocks{}),
|
|
args: testPeer{"P1", 10, 101},
|
|
poolWanted: makeBlockPool(testBcR, 100, []BpPeer{{ID: "P1", Base: 10, Height: 101}}, map[int64]tPBlocks{}),
|
|
},
|
|
{
|
|
name: "increase the height of P1 from 120 to 123",
|
|
pool: makeBlockPool(testBcR, 100, []BpPeer{{ID: "P1", Height: 120}}, map[int64]tPBlocks{}),
|
|
args: testPeer{"P1", 0, 123},
|
|
poolWanted: makeBlockPool(testBcR, 100, []BpPeer{{ID: "P1", Height: 123}}, map[int64]tPBlocks{}),
|
|
},
|
|
{
|
|
name: "decrease the height of P1 from 120 to 110",
|
|
pool: makeBlockPool(testBcR, 100, []BpPeer{{ID: "P1", Height: 120}}, map[int64]tPBlocks{}),
|
|
args: testPeer{"P1", 0, 110},
|
|
errWanted: errPeerLowersItsHeight,
|
|
poolWanted: makeBlockPool(testBcR, 100, []BpPeer{}, map[int64]tPBlocks{}),
|
|
},
|
|
{
|
|
name: "decrease the height of P1 from 105 to 102 with blocks",
|
|
pool: makeBlockPool(testBcR, 100, []BpPeer{{ID: "P1", Height: 105}},
|
|
map[int64]tPBlocks{
|
|
100: {"P1", true}, 101: {"P1", true}, 102: {"P1", true}}),
|
|
args: testPeer{"P1", 0, 102},
|
|
errWanted: errPeerLowersItsHeight,
|
|
poolWanted: makeBlockPool(testBcR, 100, []BpPeer{},
|
|
map[int64]tPBlocks{}),
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
tt := tt
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
pool := tt.pool
|
|
err := pool.UpdatePeer(tt.args.id, tt.args.base, tt.args.height)
|
|
assert.Equal(t, tt.errWanted, err)
|
|
assert.Equal(t, tt.poolWanted.blocks, tt.pool.blocks)
|
|
assertPeerSetsEquivalent(t, tt.poolWanted.peers, tt.pool.peers)
|
|
assert.Equal(t, tt.poolWanted.MaxPeerHeight, tt.pool.MaxPeerHeight)
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestBlockPoolRemovePeer(t *testing.T) {
|
|
testBcR := newTestBcR()
|
|
|
|
type args struct {
|
|
peerID p2p.ID
|
|
err error
|
|
}
|
|
|
|
tests := []struct {
|
|
name string
|
|
pool *BlockPool
|
|
args args
|
|
poolWanted *BlockPool
|
|
}{
|
|
{
|
|
name: "attempt to delete non-existing peer",
|
|
pool: makeBlockPool(testBcR, 100, []BpPeer{{ID: "P1", Height: 120}}, map[int64]tPBlocks{}),
|
|
args: args{"P99", nil},
|
|
poolWanted: makeBlockPool(testBcR, 100, []BpPeer{{ID: "P1", Height: 120}}, map[int64]tPBlocks{}),
|
|
},
|
|
{
|
|
name: "delete the only peer without blocks",
|
|
pool: makeBlockPool(testBcR, 100, []BpPeer{{ID: "P1", Height: 120}}, map[int64]tPBlocks{}),
|
|
args: args{"P1", nil},
|
|
poolWanted: makeBlockPool(testBcR, 100, []BpPeer{}, map[int64]tPBlocks{}),
|
|
},
|
|
{
|
|
name: "delete the shortest of two peers without blocks",
|
|
pool: makeBlockPool(
|
|
testBcR,
|
|
100,
|
|
[]BpPeer{{ID: "P1", Height: 100}, {ID: "P2", Height: 120}},
|
|
map[int64]tPBlocks{}),
|
|
args: args{"P1", nil},
|
|
poolWanted: makeBlockPool(testBcR, 100, []BpPeer{{ID: "P2", Height: 120}}, map[int64]tPBlocks{}),
|
|
},
|
|
{
|
|
name: "delete the tallest of two peers without blocks",
|
|
pool: makeBlockPool(
|
|
testBcR,
|
|
100,
|
|
[]BpPeer{{ID: "P1", Height: 100}, {ID: "P2", Height: 120}},
|
|
map[int64]tPBlocks{}),
|
|
args: args{"P2", nil},
|
|
poolWanted: makeBlockPool(testBcR, 100, []BpPeer{{ID: "P1", Height: 100}}, map[int64]tPBlocks{}),
|
|
},
|
|
{
|
|
name: "delete the only peer with block requests sent and blocks received",
|
|
pool: makeBlockPool(testBcR, 100, []BpPeer{{ID: "P1", Height: 120}},
|
|
map[int64]tPBlocks{100: {"P1", true}, 101: {"P1", false}}),
|
|
args: args{"P1", nil},
|
|
poolWanted: makeBlockPool(testBcR, 100, []BpPeer{}, map[int64]tPBlocks{}),
|
|
},
|
|
{
|
|
name: "delete the shortest of two peers with block requests sent and blocks received",
|
|
pool: makeBlockPool(testBcR, 100, []BpPeer{{ID: "P1", Height: 120}, {ID: "P2", Height: 200}},
|
|
map[int64]tPBlocks{100: {"P1", true}, 101: {"P1", false}}),
|
|
args: args{"P1", nil},
|
|
poolWanted: makeBlockPool(testBcR, 100, []BpPeer{{ID: "P2", Height: 200}}, map[int64]tPBlocks{}),
|
|
},
|
|
{
|
|
name: "delete the tallest of two peers with block requests sent and blocks received",
|
|
pool: makeBlockPool(testBcR, 100, []BpPeer{{ID: "P1", Height: 120}, {ID: "P2", Height: 110}},
|
|
map[int64]tPBlocks{100: {"P1", true}, 101: {"P1", false}}),
|
|
args: args{"P1", nil},
|
|
poolWanted: makeBlockPool(testBcR, 100, []BpPeer{{ID: "P2", Height: 110}}, map[int64]tPBlocks{}),
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
tt := tt
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
tt.pool.RemovePeer(tt.args.peerID, tt.args.err)
|
|
assertBlockPoolEquivalent(t, tt.poolWanted, tt.pool)
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestBlockPoolRemoveShortPeers(t *testing.T) {
|
|
testBcR := newTestBcR()
|
|
|
|
tests := []struct {
|
|
name string
|
|
pool *BlockPool
|
|
poolWanted *BlockPool
|
|
}{
|
|
{
|
|
name: "no short peers",
|
|
pool: makeBlockPool(testBcR, 100,
|
|
[]BpPeer{{ID: "P1", Height: 100}, {ID: "P2", Height: 110}, {ID: "P3", Height: 120}}, map[int64]tPBlocks{}),
|
|
poolWanted: makeBlockPool(testBcR, 100,
|
|
[]BpPeer{{ID: "P1", Height: 100}, {ID: "P2", Height: 110}, {ID: "P3", Height: 120}}, map[int64]tPBlocks{}),
|
|
},
|
|
|
|
{
|
|
name: "one short peer",
|
|
pool: makeBlockPool(testBcR, 100,
|
|
[]BpPeer{{ID: "P1", Height: 100}, {ID: "P2", Height: 90}, {ID: "P3", Height: 120}}, map[int64]tPBlocks{}),
|
|
poolWanted: makeBlockPool(testBcR, 100,
|
|
[]BpPeer{{ID: "P1", Height: 100}, {ID: "P3", Height: 120}}, map[int64]tPBlocks{}),
|
|
},
|
|
|
|
{
|
|
name: "all short peers",
|
|
pool: makeBlockPool(testBcR, 100,
|
|
[]BpPeer{{ID: "P1", Height: 90}, {ID: "P2", Height: 91}, {ID: "P3", Height: 92}}, map[int64]tPBlocks{}),
|
|
poolWanted: makeBlockPool(testBcR, 100, []BpPeer{}, map[int64]tPBlocks{}),
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
tt := tt
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
pool := tt.pool
|
|
pool.removeShortPeers()
|
|
assertBlockPoolEquivalent(t, tt.poolWanted, tt.pool)
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestBlockPoolSendRequestBatch(t *testing.T) {
|
|
type testPeerResult struct {
|
|
id p2p.ID
|
|
numPendingBlockRequests int
|
|
}
|
|
|
|
testBcR := newTestBcR()
|
|
|
|
tests := []struct {
|
|
name string
|
|
pool *BlockPool
|
|
maxRequestsPerPeer int
|
|
expRequests map[int64]bool
|
|
expRequestsSent int
|
|
expPeerResults []testPeerResult
|
|
}{
|
|
{
|
|
name: "one peer - send up to maxRequestsPerPeer block requests",
|
|
pool: makeBlockPool(testBcR, 10, []BpPeer{{ID: "P1", Height: 100}}, map[int64]tPBlocks{}),
|
|
maxRequestsPerPeer: 2,
|
|
expRequests: map[int64]bool{10: true, 11: true},
|
|
expRequestsSent: 2,
|
|
expPeerResults: []testPeerResult{{id: "P1", numPendingBlockRequests: 2}},
|
|
},
|
|
{
|
|
name: "multiple peers - stops at gap between height and base",
|
|
pool: makeBlockPool(testBcR, 10, []BpPeer{
|
|
{ID: "P1", Base: 1, Height: 12},
|
|
{ID: "P2", Base: 15, Height: 100},
|
|
}, map[int64]tPBlocks{}),
|
|
maxRequestsPerPeer: 10,
|
|
expRequests: map[int64]bool{10: true, 11: true, 12: true},
|
|
expRequestsSent: 3,
|
|
expPeerResults: []testPeerResult{
|
|
{id: "P1", numPendingBlockRequests: 3},
|
|
{id: "P2", numPendingBlockRequests: 0},
|
|
},
|
|
},
|
|
{
|
|
name: "n peers - send n*maxRequestsPerPeer block requests",
|
|
pool: makeBlockPool(
|
|
testBcR,
|
|
10,
|
|
[]BpPeer{{ID: "P1", Height: 100}, {ID: "P2", Height: 100}},
|
|
map[int64]tPBlocks{}),
|
|
maxRequestsPerPeer: 2,
|
|
expRequests: map[int64]bool{10: true, 11: true},
|
|
expRequestsSent: 4,
|
|
expPeerResults: []testPeerResult{
|
|
{id: "P1", numPendingBlockRequests: 2},
|
|
{id: "P2", numPendingBlockRequests: 2}},
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
tt := tt
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
resetPoolTestResults()
|
|
|
|
var pool = tt.pool
|
|
maxRequestsPerPeer = tt.maxRequestsPerPeer
|
|
pool.MakeNextRequests(10)
|
|
|
|
assert.Equal(t, tt.expRequestsSent, testResults.numRequestsSent)
|
|
for _, tPeer := range tt.expPeerResults {
|
|
var peer = pool.peers[tPeer.id]
|
|
assert.NotNil(t, peer)
|
|
assert.Equal(t, tPeer.numPendingBlockRequests, peer.NumPendingBlockRequests)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestBlockPoolAddBlock(t *testing.T) {
|
|
testBcR := newTestBcR()
|
|
txs := []types.Tx{types.Tx("foo"), types.Tx("bar")}
|
|
|
|
type args struct {
|
|
peerID p2p.ID
|
|
block *types.Block
|
|
blockSize int
|
|
}
|
|
tests := []struct {
|
|
name string
|
|
pool *BlockPool
|
|
args args
|
|
poolWanted *BlockPool
|
|
errWanted error
|
|
}{
|
|
{name: "block from unknown peer",
|
|
pool: makeBlockPool(testBcR, 10, []BpPeer{{ID: "P1", Height: 100}}, map[int64]tPBlocks{}),
|
|
args: args{
|
|
peerID: "P2",
|
|
block: types.MakeBlock(int64(10), txs, nil, nil),
|
|
blockSize: 100,
|
|
},
|
|
poolWanted: makeBlockPool(testBcR, 10, []BpPeer{{ID: "P1", Height: 100}}, map[int64]tPBlocks{}),
|
|
errWanted: errBadDataFromPeer,
|
|
},
|
|
{name: "unexpected block 11 from known peer - waiting for 10",
|
|
pool: makeBlockPool(testBcR, 10,
|
|
[]BpPeer{{ID: "P1", Height: 100}},
|
|
map[int64]tPBlocks{10: {"P1", false}}),
|
|
args: args{
|
|
peerID: "P1",
|
|
block: types.MakeBlock(int64(11), txs, nil, nil),
|
|
blockSize: 100,
|
|
},
|
|
poolWanted: makeBlockPool(testBcR, 10,
|
|
[]BpPeer{{ID: "P1", Height: 100}},
|
|
map[int64]tPBlocks{10: {"P1", false}}),
|
|
errWanted: errMissingBlock,
|
|
},
|
|
{name: "unexpected block 10 from known peer - already have 10",
|
|
pool: makeBlockPool(testBcR, 10,
|
|
[]BpPeer{{ID: "P1", Height: 100}},
|
|
map[int64]tPBlocks{10: {"P1", true}, 11: {"P1", false}}),
|
|
args: args{
|
|
peerID: "P1",
|
|
block: types.MakeBlock(int64(10), txs, nil, nil),
|
|
blockSize: 100,
|
|
},
|
|
poolWanted: makeBlockPool(testBcR, 10,
|
|
[]BpPeer{{ID: "P1", Height: 100}},
|
|
map[int64]tPBlocks{10: {"P1", true}, 11: {"P1", false}}),
|
|
errWanted: errDuplicateBlock,
|
|
},
|
|
{name: "unexpected block 10 from known peer P2 - expected 10 to come from P1",
|
|
pool: makeBlockPool(testBcR, 10,
|
|
[]BpPeer{{ID: "P1", Height: 100}, {ID: "P2", Height: 100}},
|
|
map[int64]tPBlocks{10: {"P1", false}}),
|
|
args: args{
|
|
peerID: "P2",
|
|
block: types.MakeBlock(int64(10), txs, nil, nil),
|
|
blockSize: 100,
|
|
},
|
|
poolWanted: makeBlockPool(testBcR, 10,
|
|
[]BpPeer{{ID: "P1", Height: 100}, {ID: "P2", Height: 100}},
|
|
map[int64]tPBlocks{10: {"P1", false}}),
|
|
errWanted: errBadDataFromPeer,
|
|
},
|
|
{name: "expected block from known peer",
|
|
pool: makeBlockPool(testBcR, 10,
|
|
[]BpPeer{{ID: "P1", Height: 100}},
|
|
map[int64]tPBlocks{10: {"P1", false}}),
|
|
args: args{
|
|
peerID: "P1",
|
|
block: types.MakeBlock(int64(10), txs, nil, nil),
|
|
blockSize: 100,
|
|
},
|
|
poolWanted: makeBlockPool(testBcR, 10,
|
|
[]BpPeer{{ID: "P1", Height: 100}},
|
|
map[int64]tPBlocks{10: {"P1", true}}),
|
|
errWanted: nil,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
tt := tt
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
err := tt.pool.AddBlock(tt.args.peerID, tt.args.block, tt.args.blockSize)
|
|
assert.Equal(t, tt.errWanted, err)
|
|
assertBlockPoolEquivalent(t, tt.poolWanted, tt.pool)
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestBlockPoolFirstTwoBlocksAndPeers(t *testing.T) {
|
|
testBcR := newTestBcR()
|
|
|
|
tests := []struct {
|
|
name string
|
|
pool *BlockPool
|
|
firstWanted int64
|
|
secondWanted int64
|
|
errWanted error
|
|
}{
|
|
{
|
|
name: "both blocks missing",
|
|
pool: makeBlockPool(testBcR, 10,
|
|
[]BpPeer{{ID: "P1", Height: 100}, {ID: "P2", Height: 100}},
|
|
map[int64]tPBlocks{15: {"P1", true}, 16: {"P2", true}}),
|
|
errWanted: errMissingBlock,
|
|
},
|
|
{
|
|
name: "second block missing",
|
|
pool: makeBlockPool(testBcR, 15,
|
|
[]BpPeer{{ID: "P1", Height: 100}, {ID: "P2", Height: 100}},
|
|
map[int64]tPBlocks{15: {"P1", true}, 18: {"P2", true}}),
|
|
firstWanted: 15,
|
|
errWanted: errMissingBlock,
|
|
},
|
|
{
|
|
name: "first block missing",
|
|
pool: makeBlockPool(testBcR, 15,
|
|
[]BpPeer{{ID: "P1", Height: 100}, {ID: "P2", Height: 100}},
|
|
map[int64]tPBlocks{16: {"P2", true}, 18: {"P2", true}}),
|
|
secondWanted: 16,
|
|
errWanted: errMissingBlock,
|
|
},
|
|
{
|
|
name: "both blocks present",
|
|
pool: makeBlockPool(testBcR, 10,
|
|
[]BpPeer{{ID: "P1", Height: 100}, {ID: "P2", Height: 100}},
|
|
map[int64]tPBlocks{10: {"P1", true}, 11: {"P2", true}}),
|
|
firstWanted: 10,
|
|
secondWanted: 11,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
tt := tt
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
pool := tt.pool
|
|
gotFirst, gotSecond, err := pool.FirstTwoBlocksAndPeers()
|
|
assert.Equal(t, tt.errWanted, err)
|
|
|
|
if tt.firstWanted != 0 {
|
|
peer := pool.blocks[tt.firstWanted]
|
|
block := pool.peers[peer].blocks[tt.firstWanted]
|
|
assert.Equal(t, block, gotFirst.block,
|
|
"BlockPool.FirstTwoBlocksAndPeers() gotFirst = %v, want %v",
|
|
tt.firstWanted, gotFirst.block.Height)
|
|
}
|
|
|
|
if tt.secondWanted != 0 {
|
|
peer := pool.blocks[tt.secondWanted]
|
|
block := pool.peers[peer].blocks[tt.secondWanted]
|
|
assert.Equal(t, block, gotSecond.block,
|
|
"BlockPool.FirstTwoBlocksAndPeers() gotFirst = %v, want %v",
|
|
tt.secondWanted, gotSecond.block.Height)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestBlockPoolInvalidateFirstTwoBlocks(t *testing.T) {
|
|
testBcR := newTestBcR()
|
|
|
|
tests := []struct {
|
|
name string
|
|
pool *BlockPool
|
|
poolWanted *BlockPool
|
|
}{
|
|
{
|
|
name: "both blocks missing",
|
|
pool: makeBlockPool(testBcR, 10,
|
|
[]BpPeer{{ID: "P1", Height: 100}, {ID: "P2", Height: 100}},
|
|
map[int64]tPBlocks{15: {"P1", true}, 16: {"P2", true}}),
|
|
poolWanted: makeBlockPool(testBcR, 10,
|
|
[]BpPeer{{ID: "P1", Height: 100}, {ID: "P2", Height: 100}},
|
|
map[int64]tPBlocks{15: {"P1", true}, 16: {"P2", true}}),
|
|
},
|
|
{
|
|
name: "second block missing",
|
|
pool: makeBlockPool(testBcR, 15,
|
|
[]BpPeer{{ID: "P1", Height: 100}, {ID: "P2", Height: 100}},
|
|
map[int64]tPBlocks{15: {"P1", true}, 18: {"P2", true}}),
|
|
poolWanted: makeBlockPool(testBcR, 15,
|
|
[]BpPeer{{ID: "P2", Height: 100}},
|
|
map[int64]tPBlocks{18: {"P2", true}}),
|
|
},
|
|
{
|
|
name: "first block missing",
|
|
pool: makeBlockPool(testBcR, 15,
|
|
[]BpPeer{{ID: "P1", Height: 100}, {ID: "P2", Height: 100}},
|
|
map[int64]tPBlocks{18: {"P1", true}, 16: {"P2", true}}),
|
|
poolWanted: makeBlockPool(testBcR, 15,
|
|
[]BpPeer{{ID: "P1", Height: 100}},
|
|
map[int64]tPBlocks{18: {"P1", true}}),
|
|
},
|
|
{
|
|
name: "both blocks present",
|
|
pool: makeBlockPool(testBcR, 10,
|
|
[]BpPeer{{ID: "P1", Height: 100}, {ID: "P2", Height: 100}},
|
|
map[int64]tPBlocks{10: {"P1", true}, 11: {"P2", true}}),
|
|
poolWanted: makeBlockPool(testBcR, 10,
|
|
[]BpPeer{},
|
|
map[int64]tPBlocks{}),
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
tt := tt
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
tt.pool.InvalidateFirstTwoBlocks(errNoPeerResponse)
|
|
assertBlockPoolEquivalent(t, tt.poolWanted, tt.pool)
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestProcessedCurrentHeightBlock(t *testing.T) {
|
|
testBcR := newTestBcR()
|
|
|
|
tests := []struct {
|
|
name string
|
|
pool *BlockPool
|
|
poolWanted *BlockPool
|
|
}{
|
|
{
|
|
name: "one peer",
|
|
pool: makeBlockPool(testBcR, 100, []BpPeer{{ID: "P1", Height: 120}},
|
|
map[int64]tPBlocks{100: {"P1", true}, 101: {"P1", true}}),
|
|
poolWanted: makeBlockPool(testBcR, 101, []BpPeer{{ID: "P1", Height: 120}},
|
|
map[int64]tPBlocks{101: {"P1", true}}),
|
|
},
|
|
{
|
|
name: "multiple peers",
|
|
pool: makeBlockPool(testBcR, 100,
|
|
[]BpPeer{{ID: "P1", Height: 120}, {ID: "P2", Height: 120}, {ID: "P3", Height: 130}},
|
|
map[int64]tPBlocks{
|
|
100: {"P1", true}, 104: {"P1", true}, 105: {"P1", false},
|
|
101: {"P2", true}, 103: {"P2", false},
|
|
102: {"P3", true}, 106: {"P3", true}}),
|
|
poolWanted: makeBlockPool(testBcR, 101,
|
|
[]BpPeer{{ID: "P1", Height: 120}, {ID: "P2", Height: 120}, {ID: "P3", Height: 130}},
|
|
map[int64]tPBlocks{
|
|
104: {"P1", true}, 105: {"P1", false},
|
|
101: {"P2", true}, 103: {"P2", false},
|
|
102: {"P3", true}, 106: {"P3", true}}),
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
tt := tt
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
tt.pool.ProcessedCurrentHeightBlock()
|
|
assertBlockPoolEquivalent(t, tt.poolWanted, tt.pool)
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestRemovePeerAtCurrentHeight(t *testing.T) {
|
|
testBcR := newTestBcR()
|
|
|
|
tests := []struct {
|
|
name string
|
|
pool *BlockPool
|
|
poolWanted *BlockPool
|
|
}{
|
|
{
|
|
name: "one peer, remove peer for block at H",
|
|
pool: makeBlockPool(testBcR, 100, []BpPeer{{ID: "P1", Height: 120}},
|
|
map[int64]tPBlocks{100: {"P1", false}, 101: {"P1", true}}),
|
|
poolWanted: makeBlockPool(testBcR, 100, []BpPeer{}, map[int64]tPBlocks{}),
|
|
},
|
|
{
|
|
name: "one peer, remove peer for block at H+1",
|
|
pool: makeBlockPool(testBcR, 100, []BpPeer{{ID: "P1", Height: 120}},
|
|
map[int64]tPBlocks{100: {"P1", true}, 101: {"P1", false}}),
|
|
poolWanted: makeBlockPool(testBcR, 100, []BpPeer{}, map[int64]tPBlocks{}),
|
|
},
|
|
{
|
|
name: "multiple peers, remove peer for block at H",
|
|
pool: makeBlockPool(testBcR, 100,
|
|
[]BpPeer{{ID: "P1", Height: 120}, {ID: "P2", Height: 120}, {ID: "P3", Height: 130}},
|
|
map[int64]tPBlocks{
|
|
100: {"P1", false}, 104: {"P1", true}, 105: {"P1", false},
|
|
101: {"P2", true}, 103: {"P2", false},
|
|
102: {"P3", true}, 106: {"P3", true}}),
|
|
poolWanted: makeBlockPool(testBcR, 100,
|
|
[]BpPeer{{ID: "P2", Height: 120}, {ID: "P3", Height: 130}},
|
|
map[int64]tPBlocks{
|
|
101: {"P2", true}, 103: {"P2", false},
|
|
102: {"P3", true}, 106: {"P3", true}}),
|
|
},
|
|
{
|
|
name: "multiple peers, remove peer for block at H+1",
|
|
pool: makeBlockPool(testBcR, 100,
|
|
[]BpPeer{{ID: "P1", Height: 120}, {ID: "P2", Height: 120}, {ID: "P3", Height: 130}},
|
|
map[int64]tPBlocks{
|
|
100: {"P1", true}, 104: {"P1", true}, 105: {"P1", false},
|
|
101: {"P2", false}, 103: {"P2", false},
|
|
102: {"P3", true}, 106: {"P3", true}}),
|
|
poolWanted: makeBlockPool(testBcR, 100,
|
|
[]BpPeer{{ID: "P1", Height: 120}, {ID: "P3", Height: 130}},
|
|
map[int64]tPBlocks{
|
|
100: {"P1", true}, 104: {"P1", true}, 105: {"P1", false},
|
|
102: {"P3", true}, 106: {"P3", true}}),
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
tt := tt
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
tt.pool.RemovePeerAtCurrentHeights(errNoPeerResponse)
|
|
assertBlockPoolEquivalent(t, tt.poolWanted, tt.pool)
|
|
})
|
|
}
|
|
}
|