netsync/consensusmgr/handle_test.go

   1 package consensusmgr
   2
   3 import (
   4         "math/rand"
   5         "net"
   6         "reflect"
   7         "testing"
   8         "time"
   9
  10         "github.com/tendermint/tmlibs/flowrate"
  11
  12         "github.com/bytom/vapor/consensus"
  13         "github.com/bytom/vapor/event"
  14         "github.com/bytom/vapor/netsync/peers"
  15         "github.com/bytom/vapor/p2p"
  16         "github.com/bytom/vapor/protocol/bc"
  17         "github.com/bytom/vapor/protocol/bc/types"
  18 )
  19
  20 type p2peer struct {
  21 }
  22
  23 func (p *p2peer) Addr() net.Addr {
  24         return nil
  25 }
  26
  27 func (p *p2peer) ID() string {
  28         return ""
  29 }
  30
  31 func (p *p2peer) Moniker() string {
  32         return ""
  33 }
  34
  35 func (p *p2peer) RemoteAddrHost() string {
  36         return ""
  37 }
  38 func (p *p2peer) ServiceFlag() consensus.ServiceFlag {
  39         return 0
  40 }
  41 func (p *p2peer) TrafficStatus() (*flowrate.Status, *flowrate.Status) {
  42         return nil, nil
  43 }
  44 func (p *p2peer) TrySend(byte, interface{}) bool {
  45         return true
  46 }
  47 func (p *p2peer) IsLAN() bool {
  48         return false
  49 }
  50
  51 func mockBlocks(startBlock *types.Block, height uint64) []*types.Block {
  52         blocks := []*types.Block{}
  53         indexBlock := &types.Block{}
  54         if startBlock == nil {
  55                 indexBlock = &types.Block{BlockHeader: types.BlockHeader{Version: uint64(rand.Uint32())}}
  56                 blocks = append(blocks, indexBlock)
  57         } else {
  58                 indexBlock = startBlock
  59         }
  60
  61         for indexBlock.Height < height {
  62                 block := &types.Block{
  63                         BlockHeader: types.BlockHeader{
  64                                 Height:            indexBlock.Height + 1,
  65                                 PreviousBlockHash: indexBlock.Hash(),
  66                                 Version:           uint64(rand.Uint32()),
  67                         },
  68                 }
  69                 blocks = append(blocks, block)
  70                 indexBlock = block
  71         }
  72         return blocks
  73 }
  74
  75 type mockSW struct {
  76 }
  77
  78 func (s *mockSW) AddReactor(name string, reactor p2p.Reactor) p2p.Reactor {
  79         return nil
  80 }
  81
  82 type mockChain struct {
  83 }
  84
  85 func (c *mockChain) BestBlockHeight() uint64 {
  86         return 0
  87 }
  88
  89 func (c *mockChain) GetHeaderByHash(*bc.Hash) (*types.BlockHeader, error) {
  90         return nil, nil
  91 }
  92
  93 func (c *mockChain) ProcessBlock(*types.Block) (bool, error) {
  94         return false, nil
  95 }
  96
  97 func (c *mockChain) ProcessBlockSignature(signature, pubkey []byte, blockHash *bc.Hash) error {
  98         return nil
  99 }
 100
 101 type mockPeers struct {
 102         msgCount       *int
 103         knownBlock     *bc.Hash
 104         blockHeight    *uint64
 105         knownSignature *[]byte
 106 }
 107
 108 func newMockPeers(msgCount *int, knownBlock *bc.Hash, blockHeight *uint64, signature *[]byte) *mockPeers {
 109         return &mockPeers{
 110                 msgCount:       msgCount,
 111                 knownBlock:     knownBlock,
 112                 blockHeight:    blockHeight,
 113                 knownSignature: signature,
 114         }
 115 }
 116
 117 func (ps *mockPeers) AddPeer(peer peers.BasePeer) {
 118
 119 }
 120
 121 func (ps *mockPeers) BroadcastMsg(bm peers.BroadcastMsg) error {
 122         *ps.msgCount++
 123         return nil
 124 }
 125 func (ps *mockPeers) GetPeer(id string) *peers.Peer {
 126         return &peers.Peer{BasePeer: &p2peer{}}
 127 }
 128 func (ps *mockPeers) MarkBlock(peerID string, hash *bc.Hash) {
 129         *ps.knownBlock = *hash
 130 }
 131
 132 func (ps *mockPeers) MarkBlockSignature(peerID string, signature []byte) {
 133         *ps.knownSignature = append(*ps.knownSignature, signature...)
 134 }
 135
 136 func (ps *mockPeers) ProcessIllegal(peerID string, level byte, reason string) {
 137
 138 }
 139 func (p *mockPeers) RemovePeer(peerID string) {
 140
 141 }
 142 func (ps *mockPeers) SetStatus(peerID string, height uint64, hash *bc.Hash) {
 143         *ps.blockHeight = height
 144 }
 145
 146 func TestBlockProposeMsgBroadcastLoop(t *testing.T) {
 147         dispatcher := event.NewDispatcher()
 148         msgCount := 0
 149         blockHeight := 100
 150         mgr := NewManager(&mockSW{}, &mockChain{}, newMockPeers(&msgCount, nil, nil, nil), dispatcher)
 151         blocks := mockBlocks(nil, uint64(blockHeight))
 152
 153         mgr.Start()
 154         defer mgr.Stop()
 155         time.Sleep(10 * time.Millisecond)
 156         for _, block := range blocks {
 157                 mgr.eventDispatcher.Post(event.NewProposedBlockEvent{Block: *block})
 158         }
 159         time.Sleep(10 * time.Millisecond)
 160         if msgCount != blockHeight+1 {
 161                 t.Fatalf("broad propose block msg err. got:%d\n want:%d", msgCount, blockHeight+1)
 162         }
 163 }
 164
 165 func TestBlockSignatureMsgBroadcastLoop(t *testing.T) {
 166         dispatcher := event.NewDispatcher()
 167         msgCount := 0
 168         blockHeight := 100
 169         mgr := NewManager(&mockSW{}, &mockChain{}, newMockPeers(&msgCount, nil, nil, nil), dispatcher)
 170         blocks := mockBlocks(nil, uint64(blockHeight))
 171
 172         mgr.Start()
 173         defer mgr.Stop()
 174         time.Sleep(10 * time.Millisecond)
 175         for _, block := range blocks {
 176                 mgr.eventDispatcher.Post(event.BlockSignatureEvent{BlockHash: block.Hash(), Signature: []byte{0x1, 0x2}, XPub: []byte{0x011, 0x022}})
 177         }
 178         time.Sleep(10 * time.Millisecond)
 179         if msgCount != blockHeight+1 {
 180                 t.Fatalf("broad propose block msg err. got:%d\n want:%d", msgCount, blockHeight+1)
 181         }
 182 }
 183
 184 func TestProcessBlockProposeMsg(t *testing.T) {
 185         dispatcher := event.NewDispatcher()
 186         msgCount := 0
 187         var knownBlock bc.Hash
 188         blockHeight := uint64(0)
 189         peerID := "Peer1"
 190         mgr := NewManager(&mockSW{}, &mockChain{}, newMockPeers(&msgCount, &knownBlock, &blockHeight, nil), dispatcher)
 191         block := &types.Block{
 192                 BlockHeader: types.BlockHeader{
 193                         Height:            100,
 194                         PreviousBlockHash: bc.NewHash([32]byte{0x1}),
 195                         Version:           uint64(rand.Uint32()),
 196                 },
 197         }
 198         msg, err := NewBlockProposeMsg(block)
 199         if err != nil {
 200                 t.Fatal("create new block propose msg err", err)
 201         }
 202
 203         mgr.processMsg(peerID, 0, msg)
 204         if knownBlock != block.Hash() {
 205                 t.Fatalf("mark propose block msg err. got:%d\n want:%d", knownBlock, block.Hash())
 206         }
 207
 208         if blockHeight != block.Height {
 209                 t.Fatalf("set peer status err. got:%d\n want:%d", blockHeight, block.Height)
 210         }
 211 }
 212
 213 func TestProcessBlockSignatureMsg(t *testing.T) {
 214         dispatcher := event.NewDispatcher()
 215         msgCount := 0
 216         knownSignature := []byte{}
 217         peerID := "Peer1"
 218         mgr := NewManager(&mockSW{}, &mockChain{}, newMockPeers(&msgCount, nil, nil, &knownSignature), dispatcher)
 219         block := &types.Block{
 220                 BlockHeader: types.BlockHeader{
 221                         Height:            100,
 222                         PreviousBlockHash: bc.NewHash([32]byte{0x1}),
 223                         Version:           uint64(rand.Uint32()),
 224                 },
 225         }
 226
 227         signature := []byte{0x01, 0x02}
 228         msg := NewBlockSignatureMsg(block.Hash(), signature, []byte{0x03, 0x04})
 229
 230         mgr.processMsg(peerID, 0, msg)
 231
 232         if !reflect.DeepEqual(knownSignature, signature) {
 233                 t.Fatalf("set peer status err. got:%d\n want:%d", knownSignature, signature)
 234         }
 235 }