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