netsync/peers/peer_test.go

   1 package peers
   2
   3 import (
   4         "net"
   5         "reflect"
   6         "testing"
   7
   8         "github.com/davecgh/go-spew/spew"
   9         "github.com/tendermint/tmlibs/flowrate"
  10         "github.com/bytom/vapor/consensus"
  11         "github.com/bytom/vapor/p2p/security"
  12         "github.com/bytom/vapor/protocol/bc"
  13         "github.com/bytom/vapor/protocol/bc/types"
  14 )
  15
  16 var (
  17         peer1ID = "PEER1"
  18         peer2ID = "PEER2"
  19         peer3ID = "PEER3"
  20         peer4ID = "PEER4"
  21
  22         block1000Hash = bc.NewHash([32]byte{0x01, 0x02})
  23         block2000Hash = bc.NewHash([32]byte{0x02, 0x03})
  24         block3000Hash = bc.NewHash([32]byte{0x03, 0x04})
  25 )
  26
  27 type basePeer struct {
  28         id          string
  29         serviceFlag consensus.ServiceFlag
  30         isLan       bool
  31 }
  32
  33 func (bp *basePeer) Addr() net.Addr {
  34         return nil
  35 }
  36
  37 func (bp *basePeer) ID() string {
  38         return bp.id
  39 }
  40
  41 func (bp *basePeer) Moniker() string {
  42         return ""
  43 }
  44
  45 func (bp *basePeer) RemoteAddrHost() string {
  46         switch bp.ID() {
  47         case peer1ID:
  48                 return peer1ID
  49         case peer2ID:
  50                 return peer2ID
  51         case peer3ID:
  52                 return peer3ID
  53         case peer4ID:
  54                 return peer4ID
  55         }
  56         return ""
  57 }
  58
  59 func (bp *basePeer) ServiceFlag() consensus.ServiceFlag {
  60         return bp.serviceFlag
  61 }
  62
  63 func (bp *basePeer) TrafficStatus() (*flowrate.Status, *flowrate.Status) {
  64         return nil, nil
  65 }
  66
  67 func (bp *basePeer) TrySend(byte, interface{}) bool {
  68         return true
  69 }
  70
  71 func (bp *basePeer) IsLAN() bool {
  72         return bp.isLan
  73 }
  74
  75 func TestSetPeerStatus(t *testing.T) {
  76         peer := newPeer(&basePeer{})
  77         height := uint64(100)
  78         hash := bc.NewHash([32]byte{0x1, 0x2})
  79         peer.SetBestStatus(height, &hash)
  80         if peer.Height() != height {
  81                 t.Fatalf("test set best status err. got %d want %d", peer.Height(), height)
  82         }
  83 }
  84
  85 func TestSetIrreversibleStatus(t *testing.T) {
  86         peer := newPeer(&basePeer{})
  87         height := uint64(100)
  88         hash := bc.NewHash([32]byte{0x1, 0x2})
  89         peer.SetIrreversibleStatus(height, &hash)
  90         if peer.IrreversibleHeight() != height {
  91                 t.Fatalf("test set Irreversible status err. got %d want %d", peer.Height(), height)
  92         }
  93 }
  94
  95 func TestAddFilterAddresses(t *testing.T) {
  96         peer := newPeer(&basePeer{})
  97         tx := types.NewTx(types.TxData{
  98                 Inputs: []*types.TxInput{
  99                         types.NewSpendInput(nil, bc.Hash{}, bc.NewAssetID([32]byte{1}), 5, 1, []byte("spendProgram")),
 100                 },
 101                 Outputs: []*types.TxOutput{
 102                         types.NewIntraChainOutput(bc.NewAssetID([32]byte{3}), 8, []byte("outProgram")),
 103                 },
 104         })
 105
 106         peer.AddFilterAddresses([][]byte{[]byte("spendProgram")})
 107         if !peer.isRelatedTx(tx) {
 108                 t.Fatal("test filter addresses error.")
 109         }
 110
 111         peer.AddFilterAddresses([][]byte{[]byte("testProgram")})
 112         if peer.isRelatedTx(tx) {
 113                 t.Fatal("test filter addresses error.")
 114         }
 115 }
 116
 117 func TestFilterClear(t *testing.T) {
 118         peer := newPeer(&basePeer{})
 119         tx := types.NewTx(types.TxData{
 120                 Inputs: []*types.TxInput{
 121                         types.NewSpendInput(nil, bc.Hash{}, bc.NewAssetID([32]byte{1}), 5, 1, []byte("spendProgram")),
 122                 },
 123                 Outputs: []*types.TxOutput{
 124                         types.NewIntraChainOutput(bc.NewAssetID([32]byte{3}), 8, []byte("outProgram")),
 125                 },
 126         })
 127
 128         peer.AddFilterAddresses([][]byte{[]byte("spendProgram")})
 129         if !peer.isRelatedTx(tx) {
 130                 t.Fatal("test filter addresses error.")
 131         }
 132
 133         peer.FilterClear()
 134         if peer.isRelatedTx(tx) {
 135                 t.Fatal("test filter addresses error.")
 136         }
 137 }
 138
 139 func TestGetRelatedTxAndStatus(t *testing.T) {
 140         peer := newPeer(&basePeer{})
 141         txs := []*types.Tx{
 142                 types.NewTx(types.TxData{
 143                         Inputs: []*types.TxInput{
 144                                 types.NewSpendInput(nil, bc.Hash{}, bc.NewAssetID([32]byte{1}), 5, 1, []byte("spendProgram1")),
 145                         },
 146                         Outputs: []*types.TxOutput{
 147                                 types.NewIntraChainOutput(bc.NewAssetID([32]byte{3}), 8, []byte("outProgram1")),
 148                         },
 149                 }),
 150                 types.NewTx(types.TxData{
 151                         Inputs: []*types.TxInput{
 152                                 types.NewSpendInput(nil, bc.Hash{}, bc.NewAssetID([32]byte{1}), 5, 1, []byte("spendProgram2")),
 153                         },
 154                         Outputs: []*types.TxOutput{
 155                                 types.NewIntraChainOutput(bc.NewAssetID([32]byte{3}), 8, []byte("outProgram2")),
 156                         },
 157                 }),
 158                 types.NewTx(types.TxData{
 159                         Inputs: []*types.TxInput{
 160                                 types.NewSpendInput(nil, bc.Hash{}, bc.NewAssetID([32]byte{1}), 5, 1, []byte("spendProgram3")),
 161                         },
 162                         Outputs: []*types.TxOutput{
 163                                 types.NewIntraChainOutput(bc.NewAssetID([32]byte{3}), 8, []byte("outProgram3")),
 164                         },
 165                 }),
 166         }
 167         txStatuses := &bc.TransactionStatus{
 168                 VerifyStatus: []*bc.TxVerifyResult{{StatusFail: true}, {StatusFail: false}, {StatusFail: false}},
 169         }
 170         peer.AddFilterAddresses([][]byte{[]byte("spendProgram1"), []byte("outProgram3")})
 171         gotTxs, gotStatus := peer.getRelatedTxAndStatus(txs, txStatuses)
 172         if len(gotTxs) != 2 {
 173                 t.Error("TestGetRelatedTxAndStatus txs size error")
 174         }
 175
 176         if !reflect.DeepEqual(*gotTxs[0].Tx, *txs[0].Tx) {
 177                 t.Errorf("txs msg test err: got %s\nwant %s", spew.Sdump(gotTxs[0].Tx), spew.Sdump(txs[0].Tx))
 178         }
 179
 180         if !reflect.DeepEqual(*gotTxs[1].Tx, *txs[2].Tx) {
 181                 t.Errorf("txs msg test err: got %s\nwant %s", spew.Sdump(gotTxs[1].Tx), spew.Sdump(txs[2].Tx))
 182         }
 183
 184         if gotStatus[0].StatusFail != true || gotStatus[1].StatusFail != false {
 185                 t.Error("TestGetRelatedTxAndStatus txs status error")
 186         }
 187 }
 188
 189 type basePeerSet struct {
 190 }
 191
 192 func (bp *basePeerSet) StopPeerGracefully(string) {
 193
 194 }
 195
 196 func (bp *basePeerSet) IsBanned(ip string, level byte, reason string) bool {
 197         switch ip {
 198         case peer1ID:
 199                 return true
 200         case peer2ID:
 201                 return false
 202         case peer3ID:
 203                 return true
 204         case peer4ID:
 205                 return false
 206         }
 207         return false
 208 }
 209
 210 func TestMarkBlock(t *testing.T) {
 211         ps := NewPeerSet(&basePeerSet{})
 212         ps.AddPeer(&basePeer{id: peer1ID})
 213         ps.AddPeer(&basePeer{id: peer2ID})
 214         ps.AddPeer(&basePeer{id: peer3ID})
 215
 216         blockHash := bc.NewHash([32]byte{0x01, 0x02})
 217         ps.MarkBlock(peer1ID, &blockHash)
 218         targetPeers := []string{peer2ID, peer3ID}
 219
 220         peers := ps.PeersWithoutBlock(blockHash)
 221         if len(peers) != len(targetPeers) {
 222                 t.Fatalf("test mark block err. Number of target peers %d got %d", 1, len(peers))
 223         }
 224
 225         for _, targetPeer := range targetPeers {
 226                 flag := false
 227                 for _, gotPeer := range peers {
 228                         if gotPeer == targetPeer {
 229                                 flag = true
 230                                 break
 231                         }
 232                 }
 233                 if !flag {
 234                         t.Errorf("test mark block err. can't found target peer %s ", targetPeer)
 235                 }
 236         }
 237 }
 238
 239 func TestMarkStatus(t *testing.T) {
 240         ps := NewPeerSet(&basePeerSet{})
 241         ps.AddPeer(&basePeer{id: peer1ID})
 242         ps.AddPeer(&basePeer{id: peer2ID})
 243         ps.AddPeer(&basePeer{id: peer3ID})
 244
 245         height := uint64(1024)
 246         ps.MarkStatus(peer1ID, height)
 247         targetPeers := []string{peer2ID, peer3ID}
 248
 249         peers := ps.peersWithoutNewStatus(height)
 250         if len(peers) != len(targetPeers) {
 251                 t.Fatalf("test mark status err. Number of target peers %d got %d", 1, len(peers))
 252         }
 253
 254         for _, targetPeer := range targetPeers {
 255                 flag := false
 256                 for _, gotPeer := range peers {
 257                         if gotPeer.ID() == targetPeer {
 258                                 flag = true
 259                                 break
 260                         }
 261                 }
 262                 if !flag {
 263                         t.Errorf("test mark status err. can't found target peer %s ", targetPeer)
 264                 }
 265         }
 266 }
 267
 268 func TestMarkBlockSignature(t *testing.T) {
 269         ps := NewPeerSet(&basePeerSet{})
 270         ps.AddPeer(&basePeer{id: peer1ID})
 271         ps.AddPeer(&basePeer{id: peer2ID})
 272         ps.AddPeer(&basePeer{id: peer3ID})
 273
 274         signature := []byte{0x01, 0x02}
 275         ps.MarkBlockSignature(peer1ID, signature)
 276         targetPeers := []string{peer2ID, peer3ID}
 277
 278         peers := ps.PeersWithoutSignature(signature)
 279         if len(peers) != len(targetPeers) {
 280                 t.Fatalf("test mark block signature err. Number of target peers %d got %d", 1, len(peers))
 281         }
 282
 283         for _, targetPeer := range targetPeers {
 284                 flag := false
 285                 for _, gotPeer := range peers {
 286                         if gotPeer == targetPeer {
 287                                 flag = true
 288                                 break
 289                         }
 290                 }
 291                 if !flag {
 292                         t.Errorf("test mark block signature err. can't found target peer %s ", targetPeer)
 293                 }
 294         }
 295 }
 296
 297 func TestMarkTx(t *testing.T) {
 298         ps := NewPeerSet(&basePeerSet{})
 299         ps.AddPeer(&basePeer{id: peer1ID})
 300         ps.AddPeer(&basePeer{id: peer2ID})
 301         ps.AddPeer(&basePeer{id: peer3ID})
 302
 303         txHash := bc.NewHash([32]byte{0x01, 0x02})
 304         ps.MarkTx(peer1ID, txHash)
 305         peers := ps.peersWithoutTx(&txHash)
 306         targetPeers := []string{peer2ID, peer3ID}
 307         if len(peers) != len(targetPeers) {
 308                 t.Fatalf("test mark tx err. Number of target peers %d got %d", 1, len(peers))
 309         }
 310
 311         for _, targetPeer := range targetPeers {
 312                 flag := false
 313                 for _, gotPeer := range peers {
 314                         if gotPeer.ID() == targetPeer {
 315                                 flag = true
 316                                 break
 317                         }
 318                 }
 319                 if !flag {
 320                         t.Errorf("test mark tx err. can't found target peer %s ", targetPeer)
 321                 }
 322         }
 323 }
 324
 325 func TestSetStatus(t *testing.T) {
 326         ps := NewPeerSet(&basePeerSet{})
 327         ps.AddPeer(&basePeer{id: peer1ID, serviceFlag: consensus.SFFullNode})
 328         ps.AddPeer(&basePeer{id: peer2ID, serviceFlag: consensus.SFFullNode})
 329         ps.AddPeer(&basePeer{id: peer3ID, serviceFlag: consensus.SFFastSync})
 330         ps.AddPeer(&basePeer{id: peer4ID, serviceFlag: consensus.SFFullNode, isLan: true})
 331         ps.SetStatus(peer1ID, 1000, &block1000Hash)
 332         ps.SetStatus(peer2ID, 2000, &block2000Hash)
 333         ps.SetStatus(peer3ID, 3000, &block3000Hash)
 334         ps.SetStatus(peer4ID, 2000, &block2000Hash)
 335         targetPeer := peer4ID
 336
 337         peer := ps.BestPeer(consensus.SFFullNode)
 338
 339         if peer.ID() != targetPeer {
 340                 t.Fatalf("test set status err. Name of target peer %s got %s", peer4ID, peer.ID())
 341         }
 342 }
 343
 344 func TestIrreversibleStatus(t *testing.T) {
 345         ps := NewPeerSet(&basePeerSet{})
 346         ps.AddPeer(&basePeer{id: peer1ID, serviceFlag: consensus.SFFullNode})
 347         ps.AddPeer(&basePeer{id: peer2ID, serviceFlag: consensus.SFFullNode})
 348         ps.AddPeer(&basePeer{id: peer3ID, serviceFlag: consensus.SFFastSync})
 349         ps.AddPeer(&basePeer{id: peer4ID, serviceFlag: consensus.SFFastSync, isLan: true})
 350         ps.SetIrreversibleStatus(peer1ID, 1000, &block1000Hash)
 351         ps.SetIrreversibleStatus(peer2ID, 2000, &block2000Hash)
 352         ps.SetIrreversibleStatus(peer3ID, 3000, &block3000Hash)
 353         ps.SetIrreversibleStatus(peer4ID, 3000, &block3000Hash)
 354         targetPeer := peer4ID
 355         peer := ps.BestIrreversiblePeer(consensus.SFFastSync)
 356
 357         if peer.ID() != targetPeer {
 358                 t.Fatalf("test set status err. Name of target peer %s got %s", peer4ID, peer.ID())
 359         }
 360 }
 361
 362 func TestGetPeersByHeight(t *testing.T) {
 363         ps := NewPeerSet(&basePeerSet{})
 364         ps.AddPeer(&basePeer{id: peer1ID, serviceFlag: consensus.SFFullNode})
 365         ps.AddPeer(&basePeer{id: peer2ID, serviceFlag: consensus.SFFullNode})
 366         ps.AddPeer(&basePeer{id: peer3ID, serviceFlag: consensus.SFFastSync})
 367         ps.AddPeer(&basePeer{id: peer4ID, serviceFlag: consensus.SFFullNode, isLan: true})
 368         ps.SetStatus(peer1ID, 1000, &block1000Hash)
 369         ps.SetStatus(peer2ID, 2000, &block2000Hash)
 370         ps.SetStatus(peer3ID, 3000, &block3000Hash)
 371         ps.SetStatus(peer4ID, 2000, &block2000Hash)
 372         peers := ps.GetPeersByHeight(2000)
 373         targetPeers := []string{peer2ID, peer3ID, peer4ID}
 374         if len(peers) != len(targetPeers) {
 375                 t.Fatalf("test get peers by height err. Number of target peers %d got %d", 3, len(peers))
 376         }
 377
 378         for _, targetPeer := range targetPeers {
 379                 flag := false
 380                 for _, gotPeer := range peers {
 381                         if gotPeer.ID() == targetPeer {
 382                                 flag = true
 383                                 break
 384                         }
 385                 }
 386                 if !flag {
 387                         t.Errorf("test get peers by height err. can't found target peer %s ", targetPeer)
 388                 }
 389         }
 390 }
 391
 392 func TestRemovePeer(t *testing.T) {
 393         ps := NewPeerSet(&basePeerSet{})
 394         ps.AddPeer(&basePeer{id: peer1ID})
 395         ps.AddPeer(&basePeer{id: peer2ID})
 396
 397         ps.RemovePeer(peer1ID)
 398         if peer := ps.GetPeer(peer1ID); peer != nil {
 399                 t.Fatalf("remove peer %s err", peer1ID)
 400         }
 401
 402         if peer := ps.GetPeer(peer2ID); peer == nil {
 403                 t.Fatalf("Error remove peer %s err", peer2ID)
 404         }
 405 }
 406
 407 func TestProcessIllegal(t *testing.T) {
 408         ps := NewPeerSet(&basePeerSet{})
 409         ps.AddPeer(&basePeer{id: peer1ID})
 410         ps.AddPeer(&basePeer{id: peer2ID})
 411
 412         ps.ProcessIllegal(peer1ID, security.LevelMsgIllegal, "test")
 413         if peer := ps.GetPeer(peer1ID); peer != nil {
 414                 t.Fatalf("remove peer %s err", peer1ID)
 415         }
 416
 417         ps.ProcessIllegal(peer2ID, security.LevelMsgIllegal, "test")
 418         if peer := ps.GetPeer(peer2ID); peer == nil {
 419                 t.Fatalf("Error remove peer %s err", peer2ID)
 420         }
 421 }