8 "github.com/stretchr/testify/assert"
9 "github.com/stretchr/testify/require"
11 log "github.com/sirupsen/logrus"
12 crypto "github.com/tendermint/go-crypto"
15 func TestPeerBasic(t *testing.T) {
16 assert, require := assert.New(t), require.New(t)
18 // simulate remote peer
19 rp := &remotePeer{PrivKey: crypto.GenPrivKeyEd25519(), Config: DefaultPeerConfig()}
23 p, err := createOutboundPeerAndPerformHandshake(rp.Addr(), DefaultPeerConfig())
29 assert.True(p.IsRunning())
30 assert.True(p.IsOutbound())
31 assert.False(p.IsPersistent())
33 assert.True(p.IsPersistent())
34 assert.Equal(rp.Addr().String(), p.Addr().String())
35 assert.Equal(rp.PubKey(), p.PubKey())
38 func TestPeerWithoutAuthEnc(t *testing.T) {
39 assert, require := assert.New(t), require.New(t)
41 config := DefaultPeerConfig()
42 config.AuthEnc = false
44 // simulate remote peer
45 rp := &remotePeer{PrivKey: crypto.GenPrivKeyEd25519(), Config: config}
49 p, err := createOutboundPeerAndPerformHandshake(rp.Addr(), config)
55 assert.True(p.IsRunning())
58 func TestPeerSend(t *testing.T) {
59 assert, require := assert.New(t), require.New(t)
61 config := DefaultPeerConfig()
62 config.AuthEnc = false
64 // simulate remote peer
65 rp := &remotePeer{PrivKey: crypto.GenPrivKeyEd25519(), Config: config}
69 p, err := createOutboundPeerAndPerformHandshake(rp.Addr(), config)
75 assert.True(p.CanSend(0x01))
76 assert.True(p.Send(0x01, "Asylum"))
79 func createOutboundPeerAndPerformHandshake(addr *NetAddress, config *PeerConfig) (*Peer, error) {
80 chDescs := []*ChannelDescriptor{
81 &ChannelDescriptor{ID: 0x01, Priority: 1},
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)
89 err = p.HandshakeTimeout(&NodeInfo{
90 PubKey: pk.PubKey().Unwrap().(crypto.PubKeyEd25519),
93 Version: "123.123.123",
101 type remotePeer struct {
102 PrivKey crypto.PrivKeyEd25519
108 func (p *remotePeer) Addr() *NetAddress {
112 func (p *remotePeer) PubKey() crypto.PubKeyEd25519 {
113 return p.PrivKey.PubKey().Unwrap().(crypto.PubKeyEd25519)
116 func (p *remotePeer) Start() {
117 l, e := net.Listen("tcp", "127.0.0.1:0") // any available address
119 log.Fatalf("net.Listen tcp :0: %+v", e)
121 p.addr = NewNetAddress(l.Addr())
122 p.quit = make(chan struct{})
126 func (p *remotePeer) Stop() {
130 func (p *remotePeer) accept(l net.Listener) {
132 conn, err := l.Accept()
134 log.Fatalf("Failed to accept conn: %+v", err)
136 peer, err := newInboundPeerWithConfig(conn, make(map[byte]Reactor), make([]*ChannelDescriptor, 0), func(p *Peer, r interface{}) {}, p.PrivKey, p.Config)
138 log.Fatalf("Failed to create a peer: %+v", err)
140 err = peer.HandshakeTimeout(&NodeInfo{
141 PubKey: p.PrivKey.PubKey().Unwrap().(crypto.PubKeyEd25519),
142 Moniker: "remote_peer",
144 Version: "123.123.123",
147 log.Fatalf("Failed to perform handshake: %+v", err)