Merge pull request #78 from libp2p/update-deps

chore: update deps

go.mod

@@ -5,9 +5,9 @@ go 1.15
 require (
 	github.com/ipfs/go-log v1.0.4
 	github.com/jbenet/go-temp-err-catcher v0.1.0
-	github.com/libp2p/go-libp2p-core v0.8.2
+	github.com/libp2p/go-libp2p-core v0.9.0
 	github.com/libp2p/go-libp2p-mplex v0.4.1
 	github.com/libp2p/go-libp2p-pnet v0.2.0
-	github.com/multiformats/go-multiaddr v0.3.1
+	github.com/multiformats/go-multiaddr v0.4.0
 	github.com/stretchr/testify v1.4.0
 )

go.sum

@@ -75,8 +75,8 @@ github.com/libp2p/go-flow-metrics v0.0.3/go.mod h1:HeoSNUrOJVK1jEpDqVEiUOIXqhbnS
 github.com/libp2p/go-libp2p-core v0.3.0/go.mod h1:ACp3DmS3/N64c2jDzcV429ukDpicbL6+TrrxANBjPGw=
 github.com/libp2p/go-libp2p-core v0.5.0/go.mod h1:49XGI+kc38oGVwqSBhDEwytaAxgZasHhFfQKibzTls0=
 github.com/libp2p/go-libp2p-core v0.8.0/go.mod h1:FfewUH/YpvWbEB+ZY9AQRQ4TAD8sJBt/G1rVvhz5XT8=
-github.com/libp2p/go-libp2p-core v0.8.2 h1:/eaSZACWftJZYm07S0nRxdI84v1hSmgnCXrGOvJdpNQ=
-github.com/libp2p/go-libp2p-core v0.8.2/go.mod h1:FfewUH/YpvWbEB+ZY9AQRQ4TAD8sJBt/G1rVvhz5XT8=
+github.com/libp2p/go-libp2p-core v0.9.0 h1:t97Mv0LIBZlP2FXVRNKKVzHJCIjbIWGxYptGId4+htU=
+github.com/libp2p/go-libp2p-core v0.9.0/go.mod h1:ESsbz31oC3C1AvMJoGx26RTuCkNhmkSRCqZ0kQtJ2/8=
 github.com/libp2p/go-libp2p-mplex v0.4.1 h1:/pyhkP1nLwjG3OM+VuaNJkQT/Pqq73WzB3aDN3Fx1sc=
 github.com/libp2p/go-libp2p-mplex v0.4.1/go.mod h1:cmy+3GfqfM1PceHTLL7zQzAAYaryDu6iPSC+CIb094g=
 github.com/libp2p/go-libp2p-pnet v0.2.0 h1:J6htxttBipJujEjz1y0a5+eYoiPcFHhSYHH6na5f0/k=
@@ -115,8 +115,9 @@ github.com/multiformats/go-multiaddr v0.2.0/go.mod h1:0nO36NvPpyV4QzvTLi/lafl2y9
 github.com/multiformats/go-multiaddr v0.2.1/go.mod h1:s/Apk6IyxfvMjDafnhJgJ3/46z7tZ04iMk5wP4QMGGE=
 github.com/multiformats/go-multiaddr v0.2.2/go.mod h1:NtfXiOtHvghW9KojvtySjH5y0u0xW5UouOmQQrn6a3Y=
 github.com/multiformats/go-multiaddr v0.3.0/go.mod h1:dF9kph9wfJ+3VLAaeBqo9Of8x4fJxp6ggJGteB8HQTI=
-github.com/multiformats/go-multiaddr v0.3.1 h1:1bxa+W7j9wZKTZREySx1vPMs2TqrYWjVZ7zE6/XLG1I=
 github.com/multiformats/go-multiaddr v0.3.1/go.mod h1:uPbspcUPd5AfaP6ql3ujFY+QWzmBD8uLLL4bXW0XfGc=
+github.com/multiformats/go-multiaddr v0.4.0 h1:hL/K4ZJhJ5PTw3nwylq9lGU5yArzcAroZmex1ghSEkQ=
+github.com/multiformats/go-multiaddr v0.4.0/go.mod h1:YcpyLH8ZPudLxQlemYBPhSm0/oCXAT8Z4mzFpyoPyRc=
 github.com/multiformats/go-multiaddr-net v0.2.0/go.mod h1:gGdH3UXny6U3cKKYCvpXI5rnK7YaOIEOPVDI9tsJbEA=
 github.com/multiformats/go-multibase v0.0.1/go.mod h1:bja2MqRZ3ggyXtZSEDKpl0uO/gviWFaSteVbWT51qgs=
 github.com/multiformats/go-multibase v0.0.3 h1:l/B6bJDQjvQ5G52jw4QGSYeOTZoAwIO77RblWplfIqk=

listener_test.go

@@ -2,7 +2,6 @@ package stream_test
 
 import (
 	"context"
-	"fmt"
 	"io"
 	"net"
 	"sync"
@@ -11,9 +10,7 @@ import (
 
 	"github.com/libp2p/go-libp2p-core/peer"
 	"github.com/libp2p/go-libp2p-core/sec"
-	"github.com/libp2p/go-libp2p-core/sec/insecure"
 	"github.com/libp2p/go-libp2p-core/transport"
-
 	st "github.com/libp2p/go-libp2p-transport-upgrader"
 	ma "github.com/multiformats/go-multiaddr"
 	manet "github.com/multiformats/go-multiaddr/net"
@@ -41,24 +38,21 @@ func (mux *MuxAdapter) SecureOutbound(ctx context.Context, insecure net.Conn, p
 
 func createListener(t *testing.T, upgrader *st.Upgrader) transport.Listener {
 	t.Helper()
-	require := require.New(t)
-
 	addr, err := ma.NewMultiaddr("/ip4/127.0.0.1/tcp/0")
-	require.NoError(err)
-
+	require.NoError(t, err)
 	ln, err := manet.Listen(addr)
-	require.NoError(err)
-
+	require.NoError(t, err)
 	return upgrader.UpgradeListener(nil, ln)
 }
 
 func TestAcceptSingleConn(t *testing.T) {
 	require := require.New(t)
 
-	ln := createListener(t, defaultUpgrader)
+	id, upgrader := createUpgrader(t)
+	ln := createListener(t, upgrader)
 	defer ln.Close()
 
-	cconn, err := dial(t, defaultUpgrader, ln.Multiaddr(), peer.ID("1"))
+	cconn, err := dial(t, upgrader, ln.Multiaddr(), id)
 	require.NoError(err)
 
 	sconn, err := ln.Accept()
@@ -70,7 +64,8 @@ func TestAcceptSingleConn(t *testing.T) {
 func TestAcceptMultipleConns(t *testing.T) {
 	require := require.New(t)
 
-	ln := createListener(t, defaultUpgrader)
+	id, upgrader := createUpgrader(t)
+	ln := createListener(t, upgrader)
 	defer ln.Close()
 
 	var toClose []io.Closer
@@ -81,7 +76,7 @@ func TestAcceptMultipleConns(t *testing.T) {
 	}()
 
 	for i := 0; i < 10; i++ {
-		cconn, err := dial(t, defaultUpgrader, ln.Multiaddr(), peer.ID("1"))
+		cconn, err := dial(t, upgrader, ln.Multiaddr(), id)
 		require.NoError(err)
 		toClose = append(toClose, cconn)
 
@@ -100,10 +95,11 @@ func TestConnectionsClosedIfNotAccepted(t *testing.T) {
 	transport.AcceptTimeout = timeout
 	defer func() { transport.AcceptTimeout = 1 * time.Hour }()
 
-	ln := createListener(t, defaultUpgrader)
+	id, upgrader := createUpgrader(t)
+	ln := createListener(t, upgrader)
 	defer ln.Close()
 
-	conn, err := dial(t, defaultUpgrader, ln.Multiaddr(), peer.ID("2"))
+	conn, err := dial(t, upgrader, ln.Multiaddr(), id)
 	require.NoError(err)
 
 	errCh := make(chan error)
@@ -133,11 +129,8 @@ func TestConnectionsClosedIfNotAccepted(t *testing.T) {
 func TestFailedUpgradeOnListen(t *testing.T) {
 	require := require.New(t)
 
-	upgrader := &st.Upgrader{
-		Secure: &MuxAdapter{tpt: insecure.New(peer.ID("1"))},
-		Muxer:  &errorMuxer{},
-	}
-
+	id, upgrader := createUpgrader(t)
+	upgrader.Muxer = &errorMuxer{}
 	ln := createListener(t, upgrader)
 	defer ln.Close()
 
@@ -147,7 +140,7 @@ func TestFailedUpgradeOnListen(t *testing.T) {
 		errCh <- err
 	}()
 
-	_, err := dial(t, defaultUpgrader, ln.Multiaddr(), peer.ID("2"))
+	_, err := dial(t, upgrader, ln.Multiaddr(), id)
 	require.Error(err)
 
 	// close the listener.
@@ -158,7 +151,8 @@ func TestFailedUpgradeOnListen(t *testing.T) {
 func TestListenerClose(t *testing.T) {
 	require := require.New(t)
 
-	ln := createListener(t, defaultUpgrader)
+	_, upgrader := createUpgrader(t)
+	ln := createListener(t, upgrader)
 
 	errCh := make(chan error)
 	go func() {
@@ -181,18 +175,19 @@ func TestListenerClose(t *testing.T) {
 	require.Contains(err.Error(), "use of closed network connection")
 
 	// doesn't accept new connections when it is closed
-	_, err = dial(t, defaultUpgrader, ln.Multiaddr(), peer.ID("1"))
+	_, err = dial(t, upgrader, ln.Multiaddr(), peer.ID("1"))
 	require.Error(err)
 }
 
 func TestListenerCloseClosesQueued(t *testing.T) {
 	require := require.New(t)
 
-	ln := createListener(t, defaultUpgrader)
+	id, upgrader := createUpgrader(t)
+	ln := createListener(t, upgrader)
 
 	var conns []transport.CapableConn
 	for i := 0; i < 10; i++ {
-		conn, err := dial(t, defaultUpgrader, ln.Multiaddr(), peer.ID(fmt.Sprintf("%d", i)))
+		conn, err := dial(t, upgrader, ln.Multiaddr(), id)
 		require.NoError(err)
 		conns = append(conns, conn)
 	}
@@ -225,15 +220,11 @@ func TestListenerCloseClosesQueued(t *testing.T) {
 }
 
 func TestConcurrentAccept(t *testing.T) {
-	var (
-		require       = require.New(t)
-		num           = 3 * st.AcceptQueueLength
-		blockingMuxer = newBlockingMuxer()
-		upgrader      = &st.Upgrader{
-			Secure: &MuxAdapter{tpt: insecure.New(peer.ID("1"))},
-			Muxer:  blockingMuxer,
-		}
-	)
+	var num = 3 * st.AcceptQueueLength
+
+	id, upgrader := createUpgrader(t)
+	blockingMuxer := newBlockingMuxer()
+	upgrader.Muxer = blockingMuxer
 
 	ln := createListener(t, upgrader)
 	defer ln.Close()
@@ -258,7 +249,7 @@ func TestConcurrentAccept(t *testing.T) {
 		go func() {
 			defer wg.Done()
 
-			conn, err := dial(t, defaultUpgrader, ln.Multiaddr(), peer.ID("2"))
+			conn, err := dial(t, upgrader, ln.Multiaddr(), id)
 			if err != nil {
 				errCh <- err
 				return
@@ -272,22 +263,23 @@ func TestConcurrentAccept(t *testing.T) {
 
 	time.Sleep(200 * time.Millisecond)
 	// the dials are still blocked, so we shouldn't have any connection available yet
-	require.Empty(accepted)
+	require.Empty(t, accepted)
 	blockingMuxer.Unblock() // make all dials succeed
-	require.Eventually(func() bool { return len(accepted) == num }, 3*time.Second, 100*time.Millisecond)
+	require.Eventually(t, func() bool { return len(accepted) == num }, 3*time.Second, 100*time.Millisecond)
 	wg.Wait()
 }
 
 func TestAcceptQueueBacklogged(t *testing.T) {
 	require := require.New(t)
 
-	ln := createListener(t, defaultUpgrader)
+	id, upgrader := createUpgrader(t)
+	ln := createListener(t, upgrader)
 	defer ln.Close()
 
 	// setup AcceptQueueLength connections, but don't accept any of them
 	errCh := make(chan error, st.AcceptQueueLength+1)
 	doDial := func() {
-		conn, err := dial(t, defaultUpgrader, ln.Multiaddr(), peer.ID("2"))
+		conn, err := dial(t, upgrader, ln.Multiaddr(), id)
 		errCh <- err
 		if conn != nil {
 			_ = conn.Close()
@@ -318,43 +310,43 @@ func TestListenerConnectionGater(t *testing.T) {
 	require := require.New(t)
 
 	testGater := &testGater{}
-	upgrader := *defaultUpgrader
+	id, upgrader := createUpgrader(t)
 	upgrader.ConnGater = testGater
 
-	ln := createListener(t, &upgrader)
+	ln := createListener(t, upgrader)
 	defer ln.Close()
 
 	// no gating.
-	conn, err := dial(t, defaultUpgrader, ln.Multiaddr(), peer.ID("0"))
+	conn, err := dial(t, upgrader, ln.Multiaddr(), id)
 	require.NoError(err)
 	require.False(conn.IsClosed())
 	_ = conn.Close()
 
 	// rejecting after handshake.
 	testGater.BlockSecured(true)
 	testGater.BlockAccept(false)
-	conn, err = dial(t, defaultUpgrader, ln.Multiaddr(), peer.ID("0"))
+	conn, err = dial(t, upgrader, ln.Multiaddr(), peer.ID("invalid"))
 	require.Error(err)
 	require.Nil(conn)
 
 	// rejecting on accept will trigger first.
 	testGater.BlockSecured(true)
 	testGater.BlockAccept(true)
-	conn, err = dial(t, defaultUpgrader, ln.Multiaddr(), peer.ID("0"))
+	conn, err = dial(t, upgrader, ln.Multiaddr(), peer.ID("invalid"))
 	require.Error(err)
 	require.Nil(conn)
 
 	// rejecting only on acceptance.
 	testGater.BlockSecured(false)
 	testGater.BlockAccept(true)
-	conn, err = dial(t, defaultUpgrader, ln.Multiaddr(), peer.ID("0"))
+	conn, err = dial(t, upgrader, ln.Multiaddr(), peer.ID("invalid"))
 	require.Error(err)
 	require.Nil(conn)
 
 	// back to normal
 	testGater.BlockSecured(false)
 	testGater.BlockAccept(false)
-	conn, err = dial(t, defaultUpgrader, ln.Multiaddr(), peer.ID("0"))
+	conn, err = dial(t, upgrader, ln.Multiaddr(), id)
 	require.NoError(err)
 	require.False(conn.IsClosed())
 	_ = conn.Close()

upgrader_test.go

@@ -6,26 +6,30 @@ import (
 	"net"
 	"testing"
 
+	"github.com/libp2p/go-libp2p-core/crypto"
 	"github.com/libp2p/go-libp2p-core/mux"
 	"github.com/libp2p/go-libp2p-core/peer"
 	"github.com/libp2p/go-libp2p-core/sec/insecure"
+	"github.com/libp2p/go-libp2p-core/test"
 	"github.com/libp2p/go-libp2p-core/transport"
-
 	mplex "github.com/libp2p/go-libp2p-mplex"
+	st "github.com/libp2p/go-libp2p-transport-upgrader"
 	ma "github.com/multiformats/go-multiaddr"
 	manet "github.com/multiformats/go-multiaddr/net"
 
-	st "github.com/libp2p/go-libp2p-transport-upgrader"
-
 	"github.com/stretchr/testify/require"
 )
 
-var (
-	defaultUpgrader = &st.Upgrader{
-		Secure: &MuxAdapter{tpt: insecure.New(peer.ID("1"))},
+func createUpgrader(t *testing.T) (peer.ID, *st.Upgrader) {
+	priv, _, err := test.RandTestKeyPair(crypto.Ed25519, 256)
+	require.NoError(t, err)
+	id, err := peer.IDFromPrivateKey(priv)
+	require.NoError(t, err)
+	return id, &st.Upgrader{
+		Secure: &MuxAdapter{tpt: insecure.NewWithIdentity(id, priv)},
 		Muxer:  &negotiatingMuxer{},
 	}
-)
+}
 
 // negotiatingMuxer sets up a new mplex connection
 // It makes sure that this happens at the same time for client and server.
@@ -106,28 +110,28 @@ func dial(t *testing.T, upgrader *st.Upgrader, raddr ma.Multiaddr, p peer.ID) (t
 func TestOutboundConnectionGating(t *testing.T) {
 	require := require.New(t)
 
-	ln := createListener(t, defaultUpgrader)
+	id, upgrader := createUpgrader(t)
+	ln := createListener(t, upgrader)
 	defer ln.Close()
 
 	testGater := &testGater{}
-	upgrader := *defaultUpgrader
-	upgrader.ConnGater = testGater
-
-	conn, err := dial(t, &upgrader, ln.Multiaddr(), peer.ID("2"))
+	_, dialUpgrader := createUpgrader(t)
+	dialUpgrader.ConnGater = testGater
+	conn, err := dial(t, dialUpgrader, ln.Multiaddr(), id)
 	require.NoError(err)
 	require.NotNil(conn)
 	_ = conn.Close()
 
 	// blocking accepts doesn't affect the dialling side, only the listener.
 	testGater.BlockAccept(true)
-	conn, err = dial(t, &upgrader, ln.Multiaddr(), peer.ID("2"))
+	conn, err = dial(t, dialUpgrader, ln.Multiaddr(), id)
 	require.NoError(err)
 	require.NotNil(conn)
 	_ = conn.Close()
 
 	// now let's block all connections after being secured.
 	testGater.BlockSecured(true)
-	conn, err = dial(t, &upgrader, ln.Multiaddr(), peer.ID("2"))
+	conn, err = dial(t, dialUpgrader, ln.Multiaddr(), id)
 	require.Error(err)
 	require.Contains(err.Error(), "gater rejected connection")
 	require.Nil(conn)