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