migrate to standard Go tests, stop using Ginkgo

go.mod

@@ -14,9 +14,8 @@ require (
 	github.com/minio/sha256-simd v0.1.1
 	github.com/multiformats/go-multiaddr v0.3.1
 	github.com/multiformats/go-multiaddr-fmt v0.1.0
-	github.com/onsi/ginkgo v1.16.4
-	github.com/onsi/gomega v1.13.0
 	github.com/prometheus/client_golang v1.9.0
+	github.com/stretchr/testify v1.7.0
 	golang.org/x/crypto v0.0.0-20210506145944-38f3c27a63bf
 	golang.org/x/sync v0.0.0-20210220032951-036812b2e83c
 )

listener_test.go

@@ -9,131 +9,106 @@ import (
 	"fmt"
 	"io"
 	"net"
-	"syscall"
+	"testing"
+	"time"
 
 	ic "github.com/libp2p/go-libp2p-core/crypto"
 	tpt "github.com/libp2p/go-libp2p-core/transport"
-	"github.com/lucas-clemente/quic-go"
 
+	"github.com/lucas-clemente/quic-go"
 	ma "github.com/multiformats/go-multiaddr"
-	. "github.com/onsi/ginkgo"
-	. "github.com/onsi/gomega"
+	"github.com/stretchr/testify/require"
 )
 
-// interface containing some methods defined on the net.UDPConn, but not the net.PacketConn
-type udpConn interface {
-	ReadFromUDP(b []byte) (int, *net.UDPAddr, error)
-	SetReadBuffer(bytes int) error
-	SyscallConn() (syscall.RawConn, error)
+func newTransport(t *testing.T) tpt.Transport {
+	rsaKey, err := rsa.GenerateKey(rand.Reader, 2048)
+	require.NoError(t, err)
+	key, err := ic.UnmarshalRsaPrivateKey(x509.MarshalPKCS1PrivateKey(rsaKey))
+	require.NoError(t, err)
+	tr, err := NewTransport(key, nil, nil)
+	require.NoError(t, err)
+	return tr
 }
 
-var _ = Describe("Listener", func() {
-	var t tpt.Transport
-
-	BeforeEach(func() {
-		rsaKey, err := rsa.GenerateKey(rand.Reader, 2048)
-		Expect(err).ToNot(HaveOccurred())
-		key, err := ic.UnmarshalRsaPrivateKey(x509.MarshalPKCS1PrivateKey(rsaKey))
-		Expect(err).ToNot(HaveOccurred())
-		t, err = NewTransport(key, nil, nil)
-		Expect(err).ToNot(HaveOccurred())
-	})
-
-	AfterEach(func() {
-		Expect(t.(io.Closer).Close()).To(Succeed())
-	})
-
-	It("uses a conn that can interface assert to a UDPConn for listening", func() {
-		origQuicListen := quicListen
-		defer func() { quicListen = origQuicListen }()
+// The conn passed to quic-go should be a conn that quic-go can be
+// type-asserted to a UDPConn. That way, it can use all kinds of optimizations.
+func TestConnUsedForListening(t *testing.T) {
+	origQuicListen := quicListen
+	t.Cleanup(func() { quicListen = origQuicListen })
+
+	var conn net.PacketConn
+	quicListen = func(c net.PacketConn, _ *tls.Config, _ *quic.Config) (quic.Listener, error) {
+		conn = c
+		return nil, errors.New("listen error")
+	}
+	localAddr, err := ma.NewMultiaddr("/ip4/127.0.0.1/udp/0/quic")
+	require.NoError(t, err)
+
+	tr := newTransport(t)
+	defer tr.(io.Closer).Close()
+	_, err = tr.Listen(localAddr)
+	require.EqualError(t, err, "listen error")
+	require.NotNil(t, conn)
+	defer conn.Close()
+	_, ok := conn.(quic.OOBCapablePacketConn)
+	require.True(t, ok)
+}
 
-		var conn net.PacketConn
-		quicListen = func(c net.PacketConn, _ *tls.Config, _ *quic.Config) (quic.Listener, error) {
-			conn = c
-			return nil, errors.New("listen error")
-		}
-		localAddr, err := ma.NewMultiaddr("/ip4/127.0.0.1/udp/0/quic")
-		Expect(err).ToNot(HaveOccurred())
-		_, err = t.Listen(localAddr)
-		Expect(err).To(MatchError("listen error"))
-		Expect(conn).ToNot(BeNil())
-		defer conn.Close()
-		_, ok := conn.(udpConn)
-		Expect(ok).To(BeTrue())
+func TestListenAddr(t *testing.T) {
+	tr := newTransport(t)
+	defer tr.(io.Closer).Close()
+
+	t.Run("for IPv4", func(t *testing.T) {
+		localAddr := ma.StringCast("/ip4/127.0.0.1/udp/0/quic")
+		ln, err := tr.Listen(localAddr)
+		require.NoError(t, err)
+		defer ln.Close()
+		port := ln.Addr().(*net.UDPAddr).Port
+		require.NotZero(t, port)
+		require.Equal(t, ln.Multiaddr().String(), fmt.Sprintf("/ip4/127.0.0.1/udp/%d/quic", port))
 	})
 
-	Context("listening on the right address", func() {
-		It("returns the address it is listening on", func() {
-			localAddr, err := ma.NewMultiaddr("/ip4/127.0.0.1/udp/0/quic")
-			Expect(err).ToNot(HaveOccurred())
-			ln, err := t.Listen(localAddr)
-			Expect(err).ToNot(HaveOccurred())
-			defer ln.Close()
-			netAddr := ln.Addr()
-			Expect(netAddr).To(BeAssignableToTypeOf(&net.UDPAddr{}))
-			port := netAddr.(*net.UDPAddr).Port
-			Expect(port).ToNot(BeZero())
-			Expect(ln.Multiaddr().String()).To(Equal(fmt.Sprintf("/ip4/127.0.0.1/udp/%d/quic", port)))
-		})
-
-		It("returns the address it is listening on, for listening on IPv4", func() {
-			localAddr, err := ma.NewMultiaddr("/ip4/0.0.0.0/udp/0/quic")
-			Expect(err).ToNot(HaveOccurred())
-			ln, err := t.Listen(localAddr)
-			Expect(err).ToNot(HaveOccurred())
-			defer ln.Close()
-			netAddr := ln.Addr()
-			Expect(netAddr).To(BeAssignableToTypeOf(&net.UDPAddr{}))
-			port := netAddr.(*net.UDPAddr).Port
-			Expect(port).ToNot(BeZero())
-			Expect(ln.Multiaddr().String()).To(Equal(fmt.Sprintf("/ip4/0.0.0.0/udp/%d/quic", port)))
-		})
-
-		It("returns the address it is listening on, for listening on IPv6", func() {
-			localAddr, err := ma.NewMultiaddr("/ip6/::/udp/0/quic")
-			Expect(err).ToNot(HaveOccurred())
-			ln, err := t.Listen(localAddr)
-			Expect(err).ToNot(HaveOccurred())
-			defer ln.Close()
-			netAddr := ln.Addr()
-			Expect(netAddr).To(BeAssignableToTypeOf(&net.UDPAddr{}))
-			port := netAddr.(*net.UDPAddr).Port
-			Expect(port).ToNot(BeZero())
-			Expect(ln.Multiaddr().String()).To(Equal(fmt.Sprintf("/ip6/::/udp/%d/quic", port)))
-		})
+	t.Run("for IPv6", func(t *testing.T) {
+		localAddr := ma.StringCast("/ip6/::/udp/0/quic")
+		ln, err := tr.Listen(localAddr)
+		require.NoError(t, err)
+		defer ln.Close()
+		port := ln.Addr().(*net.UDPAddr).Port
+		require.NotZero(t, port)
+		require.Equal(t, ln.Multiaddr().String(), fmt.Sprintf("/ip6/::/udp/%d/quic", port))
 	})
+}
 
-	Context("accepting connections", func() {
-		var localAddr ma.Multiaddr
-
-		BeforeEach(func() {
-			var err error
-			localAddr, err = ma.NewMultiaddr("/ip4/127.0.0.1/udp/0/quic")
-			Expect(err).ToNot(HaveOccurred())
-		})
-
-		It("returns Accept when it is closed", func() {
-			addr, err := ma.NewMultiaddr("/ip4/127.0.0.1/udp/0/quic")
-			Expect(err).ToNot(HaveOccurred())
-			ln, err := t.Listen(addr)
-			Expect(err).ToNot(HaveOccurred())
-			done := make(chan struct{})
-			go func() {
-				defer GinkgoRecover()
-				ln.Accept()
-				close(done)
-			}()
-			Consistently(done).ShouldNot(BeClosed())
-			Expect(ln.Close()).To(Succeed())
-			Eventually(done).Should(BeClosed())
-		})
+func TestAccepting(t *testing.T) {
+	tr := newTransport(t)
+	defer tr.(io.Closer).Close()
+	ln, err := tr.Listen(ma.StringCast("/ip4/127.0.0.1/udp/0/quic"))
+	require.NoError(t, err)
+	done := make(chan struct{})
+	go func() {
+		ln.Accept()
+		close(done)
+	}()
+	time.Sleep(100 * time.Millisecond)
+	select {
+	case <-done:
+		t.Fatal("Accept didn't block")
+	default:
+	}
+	require.NoError(t, ln.Close())
+	select {
+	case <-done:
+	case <-time.After(100 * time.Millisecond):
+		t.Fatal("Accept didn't return after the listener was closed")
+	}
+}
 
-		It("doesn't accept Accept calls after it is closed", func() {
-			ln, err := t.Listen(localAddr)
-			Expect(err).ToNot(HaveOccurred())
-			Expect(ln.Close()).To(Succeed())
-			_, err = ln.Accept()
-			Expect(err).To(HaveOccurred())
-		})
-	})
-})
+func TestAcceptAfterClose(t *testing.T) {
+	tr := newTransport(t)
+	defer tr.(io.Closer).Close()
+	ln, err := tr.Listen(ma.StringCast("/ip4/127.0.0.1/udp/0/quic"))
+	require.NoError(t, err)
+	require.NoError(t, ln.Close())
+	_, err = ln.Accept()
+	require.Error(t, err)
+}

quic_multiaddr_test.go

@@ -2,29 +2,26 @@ package libp2pquic
 
 import (
 	"net"
+	"testing"
 
 	ma "github.com/multiformats/go-multiaddr"
-
-	. "github.com/onsi/ginkgo"
-	. "github.com/onsi/gomega"
+	"github.com/stretchr/testify/require"
 )
 
-var _ = Describe("QUIC Multiaddr", func() {
-	It("converts a net.Addr to a QUIC Multiaddr", func() {
-		addr := &net.UDPAddr{IP: net.IPv4(192, 168, 0, 42), Port: 1337}
-		maddr, err := toQuicMultiaddr(addr)
-		Expect(err).ToNot(HaveOccurred())
-		Expect(maddr.String()).To(Equal("/ip4/192.168.0.42/udp/1337/quic"))
-	})
+func TestConvertToQuicMultiaddr(t *testing.T) {
+	addr := &net.UDPAddr{IP: net.IPv4(192, 168, 0, 42), Port: 1337}
+	maddr, err := toQuicMultiaddr(addr)
+	require.NoError(t, err)
+	require.Equal(t, maddr.String(), "/ip4/192.168.0.42/udp/1337/quic")
+}
 
-	It("converts a QUIC Multiaddr to a net.Addr", func() {
-		maddr, err := ma.NewMultiaddr("/ip4/192.168.0.42/udp/1337/quic")
-		Expect(err).ToNot(HaveOccurred())
-		addr, err := fromQuicMultiaddr(maddr)
-		Expect(err).ToNot(HaveOccurred())
-		Expect(addr).To(BeAssignableToTypeOf(&net.UDPAddr{}))
-		udpAddr := addr.(*net.UDPAddr)
-		Expect(udpAddr.IP).To(Equal(net.IPv4(192, 168, 0, 42)))
-		Expect(udpAddr.Port).To(Equal(1337))
-	})
-})
+func TestConvertFromQuicMultiaddr(t *testing.T) {
+	maddr, err := ma.NewMultiaddr("/ip4/192.168.0.42/udp/1337/quic")
+	require.NoError(t, err)
+	addr, err := fromQuicMultiaddr(maddr)
+	require.NoError(t, err)
+	udpAddr, ok := addr.(*net.UDPAddr)
+	require.True(t, ok)
+	require.Equal(t, udpAddr.IP, net.IPv4(192, 168, 0, 42))
+	require.Equal(t, udpAddr.Port, 1337)
+}