p2p/peer_test.go

   1 // +build !network
   2
   3 package p2p
   4
   5 import (
   6         "net"
   7         "testing"
   8         "time"
   9
  10         log "github.com/sirupsen/logrus"
  11         "github.com/stretchr/testify/assert"
  12         "github.com/stretchr/testify/require"
  13         crypto "github.com/tendermint/go-crypto"
  14
  15         cfg "github.com/bytom/config"
  16 )
  17
  18 func TestPeerBasic(t *testing.T) {
  19         assert, require := assert.New(t), require.New(t)
  20
  21         // simulate remote peer
  22         rp := &remotePeer{PrivKey: crypto.GenPrivKeyEd25519(), Config: DefaultPeerConfig(cfg.DefaultP2PConfig())}
  23         rp.Start()
  24         defer rp.Stop()
  25
  26         p, err := createOutboundPeerAndPerformHandshake(rp.Addr(), DefaultPeerConfig(cfg.DefaultP2PConfig()))
  27         require.Nil(err)
  28
  29         p.Start()
  30         defer p.Stop()
  31
  32         assert.True(p.IsRunning())
  33         assert.True(p.IsOutbound())
  34         assert.False(p.IsPersistent())
  35         p.makePersistent()
  36         assert.True(p.IsPersistent())
  37         assert.Equal(rp.Addr().String(), p.Addr().String())
  38         assert.Equal(rp.PubKey(), p.PubKey())
  39 }
  40
  41 func TestPeerWithoutAuthEnc(t *testing.T) {
  42         assert, require := assert.New(t), require.New(t)
  43
  44         config := DefaultPeerConfig(cfg.DefaultP2PConfig())
  45         config.AuthEnc = false
  46
  47         // simulate remote peer
  48         rp := &remotePeer{PrivKey: crypto.GenPrivKeyEd25519(), Config: config}
  49         rp.Start()
  50         defer rp.Stop()
  51
  52         p, err := createOutboundPeerAndPerformHandshake(rp.Addr(), config)
  53         require.Nil(err)
  54
  55         p.Start()
  56         defer p.Stop()
  57
  58         assert.True(p.IsRunning())
  59 }
  60
  61 func TestPeerSend(t *testing.T) {
  62         assert, require := assert.New(t), require.New(t)
  63
  64         config := DefaultPeerConfig(cfg.DefaultP2PConfig())
  65         config.AuthEnc = false
  66
  67         // simulate remote peer
  68         rp := &remotePeer{PrivKey: crypto.GenPrivKeyEd25519(), Config: config}
  69         rp.Start()
  70         defer rp.Stop()
  71
  72         p, err := createOutboundPeerAndPerformHandshake(rp.Addr(), config)
  73         require.Nil(err)
  74
  75         p.Start()
  76         defer p.Stop()
  77
  78         assert.True(p.CanSend(0x01))
  79         assert.True(p.Send(0x01, "Asylum"))
  80 }
  81
  82 func createOutboundPeerAndPerformHandshake(addr *NetAddress, config *PeerConfig) (*Peer, error) {
  83         chDescs := []*ChannelDescriptor{
  84                 &ChannelDescriptor{ID: 0x01, Priority: 1},
  85         }
  86         reactorsByCh := map[byte]Reactor{0x01: NewTestReactor(chDescs, true)}
  87         pk := crypto.GenPrivKeyEd25519()
  88         p, err := newOutboundPeerWithConfig(addr, reactorsByCh, chDescs, func(p *Peer, r interface{}) {}, pk, config)
  89         if err != nil {
  90                 return nil, err
  91         }
  92         err = p.HandshakeTimeout(&NodeInfo{
  93                 PubKey:  pk.PubKey().Unwrap().(crypto.PubKeyEd25519),
  94                 Moniker: "host_peer",
  95                 Network: "testing",
  96                 Version: "123.123.123",
  97         }, 1*time.Second)
  98         if err != nil {
  99                 return nil, err
 100         }
 101         return p, nil
 102 }
 103
 104 type remotePeer struct {
 105         PrivKey crypto.PrivKeyEd25519
 106         Config  *PeerConfig
 107         addr    *NetAddress
 108         quit    chan struct{}
 109 }
 110
 111 func (p *remotePeer) Addr() *NetAddress {
 112         return p.addr
 113 }
 114
 115 func (p *remotePeer) PubKey() crypto.PubKeyEd25519 {
 116         return p.PrivKey.PubKey().Unwrap().(crypto.PubKeyEd25519)
 117 }
 118
 119 func (p *remotePeer) Start() {
 120         l, e := net.Listen("tcp", "127.0.0.1:0") // any available address
 121         if e != nil {
 122                 log.Fatalf("net.Listen tcp :0: %+v", e)
 123         }
 124         p.addr = NewNetAddress(l.Addr())
 125         p.quit = make(chan struct{})
 126         go p.accept(l)
 127 }
 128
 129 func (p *remotePeer) Stop() {
 130         close(p.quit)
 131 }
 132
 133 func (p *remotePeer) accept(l net.Listener) {
 134         for {
 135                 conn, err := l.Accept()
 136                 if err != nil {
 137                         log.Fatalf("Failed to accept conn: %+v", err)
 138                 }
 139                 peer, err := newInboundPeerWithConfig(conn, make(map[byte]Reactor), make([]*ChannelDescriptor, 0), func(p *Peer, r interface{}) {}, p.PrivKey, p.Config)
 140                 if err != nil {
 141                         log.Fatalf("Failed to create a peer: %+v", err)
 142                 }
 143                 err = peer.HandshakeTimeout(&NodeInfo{
 144                         PubKey:  p.PrivKey.PubKey().Unwrap().(crypto.PubKeyEd25519),
 145                         Moniker: "remote_peer",
 146                         Network: "testing",
 147                         Version: "123.123.123",
 148                 }, 1*time.Second)
 149                 if err != nil {
 150                         log.Fatalf("Failed to perform handshake: %+v", err)
 151                 }
 152                 select {
 153                 case <-p.quit:
 154                         conn.Close()
 155                         return
 156                 default:
 157                 }
 158         }
 159 }