netsync/consensusmgr/block_fetcher_test.go

   1 package consensusmgr
   2
   3 import (
   4         "testing"
   5         "time"
   6
   7         "github.com/vapor/netsync/peers"
   8         "github.com/vapor/protocol/bc"
   9         "github.com/vapor/protocol/bc/types"
  10 )
  11
  12 type peerMgr struct {
  13 }
  14
  15 func (pm *peerMgr) IsBanned(ip string, level byte, reason string) bool {
  16         return false
  17 }
  18
  19 func (pm *peerMgr) StopPeerGracefully(string) {
  20         return
  21 }
  22
  23 type chain struct {
  24         blocks []uint64
  25 }
  26
  27 func newChain() *chain {
  28         blocks := make([]uint64, 1, 1)
  29         blocks[0] = 99
  30         return &chain{
  31                 blocks: blocks,
  32         }
  33 }
  34
  35 func (c *chain) BestBlockHeight() uint64 {
  36         return c.blocks[len(c.blocks)-1]
  37 }
  38
  39 func (c *chain) GetHeaderByHash(*bc.Hash) (*types.BlockHeader, error) {
  40         return nil, nil
  41 }
  42
  43 func (c *chain) ProcessBlock(block *types.Block) (bool, error) {
  44         c.blocks = append(c.blocks, block.Height)
  45         return false, nil
  46 }
  47
  48 func (c *chain) ProcessBlockSignature(signature, pubkey []byte, blockHash *bc.Hash) error {
  49         return nil
  50 }
  51
  52 func TestBlockFetcher(t *testing.T) {
  53         peers := peers.NewPeerSet(&peerMgr{})
  54         testCase := []struct {
  55                 blockMsg *blockMsg
  56                 height   uint64
  57         }{
  58                 {
  59                         blockMsg: &blockMsg{
  60                                 block: &types.Block{
  61                                         BlockHeader: types.BlockHeader{
  62                                                 Height: 100,
  63                                         },
  64                                 },
  65                         },
  66                         height: 100,
  67                 },
  68                 {
  69                         blockMsg: &blockMsg{
  70                                 block: &types.Block{
  71                                         BlockHeader: types.BlockHeader{
  72                                                 Height: 101,
  73                                         },
  74                                 },
  75                         },
  76                         height: 101,
  77                 },
  78                 {
  79                         blockMsg: &blockMsg{
  80                                 block: &types.Block{
  81                                         BlockHeader: types.BlockHeader{
  82                                                 Height: 105,
  83                                         },
  84                                 },
  85                         },
  86                         height: 101,
  87                 },
  88                 {
  89                         blockMsg: &blockMsg{
  90                                 block: &types.Block{
  91                                         BlockHeader: types.BlockHeader{
  92                                                 Height: 200,
  93                                         },
  94                                 },
  95                         },
  96                         height: 101,
  97                 },
  98                 {
  99                         blockMsg: &blockMsg{
 100                                 block: &types.Block{
 101                                         BlockHeader: types.BlockHeader{
 102                                                 Height: 104,
 103                                         },
 104                                 },
 105                         },
 106                         height: 101,
 107                 },
 108                 {
 109                         blockMsg: &blockMsg{
 110                                 block: &types.Block{
 111                                         BlockHeader: types.BlockHeader{
 112                                                 Height: 103,
 113                                         },
 114                                 },
 115                         },
 116                         height: 101,
 117                 },
 118                 {
 119                         blockMsg: &blockMsg{
 120                                 block: &types.Block{
 121                                         BlockHeader: types.BlockHeader{
 122                                                 Height: 102,
 123                                         },
 124                                 },
 125                         },
 126                         height: 105,
 127                 },
 128         }
 129         fetcher := newBlockFetcher(newChain(), peers)
 130         go fetcher.blockProcessorLoop()
 131         for i, c := range testCase {
 132                 fetcher.processNewBlock(c.blockMsg)
 133                 time.Sleep(10 * time.Millisecond)
 134                 chainHeight := fetcher.chain.BestBlockHeight()
 135                 if chainHeight != c.height {
 136                         t.Fatalf("test block fetcher error. index %d expected chain height %d but got %d", i, chainHeight, c.height)
 137                 }
 138         }
 139 }
 140
 141 func TestAddBlockMsg(t *testing.T) {
 142         peers := peers.NewPeerSet(&peerMgr{})
 143         testPeer := "peer1"
 144         testCase := []struct {
 145                 blocksMsg  []*blockMsg
 146                 limit      int
 147                 queueSize  int
 148                 msgSetSize int
 149                 msgCounter int
 150         }{
 151                 //normal test
 152                 {
 153                         blocksMsg: []*blockMsg{
 154                                 {
 155                                         block: &types.Block{
 156                                                 BlockHeader: types.BlockHeader{
 157                                                         Height: 100,
 158                                                 },
 159                                         },
 160                                         peerID: testPeer,
 161                                 },
 162                                 {
 163                                         block: &types.Block{
 164                                                 BlockHeader: types.BlockHeader{
 165                                                         Height: 101,
 166                                                 },
 167                                         },
 168                                         peerID: testPeer,
 169                                 },
 170                                 {
 171                                         block: &types.Block{
 172                                                 BlockHeader: types.BlockHeader{
 173                                                         Height: 102,
 174                                                 },
 175                                         },
 176                                         peerID: testPeer,
 177                                 },
 178                         },
 179                         limit:      5,
 180                         queueSize:  3,
 181                         msgSetSize: 3,
 182                         msgCounter: 3,
 183                 },
 184                 // test DOS
 185                 {
 186                         blocksMsg: []*blockMsg{
 187                                 {
 188                                         block: &types.Block{
 189                                                 BlockHeader: types.BlockHeader{
 190                                                         Version: 1,
 191                                                         Height:  100,
 192                                                 },
 193                                         },
 194                                         peerID: testPeer,
 195                                 },
 196                                 {
 197                                         block: &types.Block{
 198                                                 BlockHeader: types.BlockHeader{
 199                                                         Version: 2,
 200                                                         Height:  100,
 201                                                 },
 202                                         },
 203                                         peerID: testPeer,
 204                                 },
 205                                 {
 206                                         block: &types.Block{
 207                                                 BlockHeader: types.BlockHeader{
 208                                                         Version: 3,
 209                                                         Height:  100,
 210                                                 },
 211                                         },
 212                                         peerID: testPeer,
 213                                 },
 214                                 {
 215                                         block: &types.Block{
 216                                                 BlockHeader: types.BlockHeader{
 217                                                         Version: 4,
 218                                                         Height:  100,
 219                                                 },
 220                                         },
 221                                         peerID: testPeer,
 222                                 },
 223                         },
 224                         limit:      3,
 225                         queueSize:  3,
 226                         msgSetSize: 3,
 227                         msgCounter: 3,
 228                 },
 229
 230                 // test msg height does not meet the requirements
 231                 {
 232                         blocksMsg: []*blockMsg{
 233                                 {
 234                                         block: &types.Block{
 235                                                 BlockHeader: types.BlockHeader{
 236                                                         Version: 1,
 237                                                         Height:  98,
 238                                                 },
 239                                         },
 240                                         peerID: testPeer,
 241                                 },
 242                                 {
 243                                         block: &types.Block{
 244                                                 BlockHeader: types.BlockHeader{
 245                                                         Version: 2,
 246                                                         Height:  97,
 247                                                 },
 248                                         },
 249                                         peerID: testPeer,
 250                                 },
 251                                 {
 252                                         block: &types.Block{
 253                                                 BlockHeader: types.BlockHeader{
 254                                                         Version: 3,
 255                                                         Height:  164,
 256                                                 },
 257                                         },
 258                                         peerID: testPeer,
 259                                 },
 260                                 {
 261                                         block: &types.Block{
 262                                                 BlockHeader: types.BlockHeader{
 263                                                         Version: 4,
 264                                                         Height:  165,
 265                                                 },
 266                                         },
 267                                         peerID: testPeer,
 268                                 },
 269                         },
 270                         limit:      5,
 271                         queueSize:  0,
 272                         msgSetSize: 0,
 273                         msgCounter: 0,
 274                 },
 275         }
 276
 277         for i, c := range testCase {
 278                 fetcher := newBlockFetcher(newChain(), peers)
 279                 for _, msg := range c.blocksMsg {
 280                         fetcher.add(msg, c.limit)
 281                 }
 282
 283                 if fetcher.queue.Size() != c.queueSize {
 284                         t.Fatalf("index: %d queue size err got %d: want %d", i, fetcher.queue.Size(), c.queueSize)
 285                 }
 286
 287                 if len(fetcher.msgSet) != c.msgSetSize {
 288                         t.Fatalf("index: %d msg set size err got %d: want %d", i, len(fetcher.msgSet), c.msgSetSize)
 289                 }
 290
 291                 if fetcher.msgCounter[testPeer] != c.msgCounter {
 292                         t.Fatalf("index: %d peer msg counter err got %d: want %d", i, fetcher.msgCounter[testPeer], c.msgCounter)
 293                 }
 294         }
 295 }