p2p/peer_test.go

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