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