mirror of
https://source.quilibrium.com/quilibrium/ceremonyclient.git
synced 2024-12-25 16:15:17 +00:00
359 lines
9.8 KiB
Go
359 lines
9.8 KiB
Go
package libp2p
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"regexp"
|
|
"strings"
|
|
"testing"
|
|
|
|
"github.com/libp2p/go-libp2p/core/connmgr"
|
|
"github.com/libp2p/go-libp2p/core/crypto"
|
|
"github.com/libp2p/go-libp2p/core/host"
|
|
"github.com/libp2p/go-libp2p/core/peer"
|
|
"github.com/libp2p/go-libp2p/core/transport"
|
|
"github.com/libp2p/go-libp2p/p2p/net/swarm"
|
|
"github.com/libp2p/go-libp2p/p2p/security/noise"
|
|
tls "github.com/libp2p/go-libp2p/p2p/security/tls"
|
|
quic "github.com/libp2p/go-libp2p/p2p/transport/quic"
|
|
"github.com/libp2p/go-libp2p/p2p/transport/tcp"
|
|
webtransport "github.com/libp2p/go-libp2p/p2p/transport/webtransport"
|
|
|
|
ma "github.com/multiformats/go-multiaddr"
|
|
"github.com/stretchr/testify/require"
|
|
)
|
|
|
|
func TestNewHost(t *testing.T) {
|
|
h, err := makeRandomHost(t, 9000)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
h.Close()
|
|
}
|
|
|
|
func TestBadTransportConstructor(t *testing.T) {
|
|
h, err := New(Transport(func() {}))
|
|
if err == nil {
|
|
h.Close()
|
|
t.Fatal("expected an error")
|
|
}
|
|
if !strings.Contains(err.Error(), "libp2p_test.go") {
|
|
t.Error("expected error to contain debugging info")
|
|
}
|
|
}
|
|
|
|
func TestTransportConstructor(t *testing.T) {
|
|
ctor := func(
|
|
h host.Host,
|
|
_ connmgr.ConnectionGater,
|
|
upgrader transport.Upgrader,
|
|
) transport.Transport {
|
|
tpt, err := tcp.NewTCPTransport(upgrader, nil)
|
|
require.NoError(t, err)
|
|
return tpt
|
|
}
|
|
h, err := New(Transport(ctor))
|
|
require.NoError(t, err)
|
|
h.Close()
|
|
}
|
|
|
|
func TestNoListenAddrs(t *testing.T) {
|
|
h, err := New(NoListenAddrs)
|
|
require.NoError(t, err)
|
|
defer h.Close()
|
|
if len(h.Addrs()) != 0 {
|
|
t.Fatal("expected no addresses")
|
|
}
|
|
}
|
|
|
|
func TestNoTransports(t *testing.T) {
|
|
ctx := context.Background()
|
|
a, err := New(NoTransports)
|
|
require.NoError(t, err)
|
|
defer a.Close()
|
|
|
|
b, err := New(ListenAddrStrings("/ip4/127.0.0.1/tcp/0"))
|
|
require.NoError(t, err)
|
|
defer b.Close()
|
|
|
|
err = a.Connect(ctx, peer.AddrInfo{
|
|
ID: b.ID(),
|
|
Addrs: b.Addrs(),
|
|
})
|
|
if err == nil {
|
|
t.Error("dial should have failed as no transports have been configured")
|
|
}
|
|
}
|
|
|
|
func TestInsecure(t *testing.T) {
|
|
h, err := New(NoSecurity)
|
|
require.NoError(t, err)
|
|
h.Close()
|
|
}
|
|
|
|
func TestAutoNATService(t *testing.T) {
|
|
h, err := New(EnableNATService())
|
|
require.NoError(t, err)
|
|
h.Close()
|
|
}
|
|
|
|
func TestDefaultListenAddrs(t *testing.T) {
|
|
reTCP := regexp.MustCompile("/(ip)[4|6]/((0.0.0.0)|(::))/tcp/")
|
|
reQUIC := regexp.MustCompile("/(ip)[4|6]/((0.0.0.0)|(::))/udp/([0-9]*)/quic")
|
|
reCircuit := regexp.MustCompile("/p2p-circuit")
|
|
|
|
// Test 1: Setting the correct listen addresses if userDefined.Transport == nil && userDefined.ListenAddrs == nil
|
|
h, err := New()
|
|
require.NoError(t, err)
|
|
for _, addr := range h.Network().ListenAddresses() {
|
|
if reTCP.FindStringSubmatchIndex(addr.String()) == nil &&
|
|
reQUIC.FindStringSubmatchIndex(addr.String()) == nil &&
|
|
reCircuit.FindStringSubmatchIndex(addr.String()) == nil {
|
|
t.Error("expected ip4 or ip6 or relay interface")
|
|
}
|
|
}
|
|
|
|
h.Close()
|
|
|
|
// Test 2: Listen addr only include relay if user defined transport is passed.
|
|
h, err = New(Transport(tcp.NewTCPTransport))
|
|
require.NoError(t, err)
|
|
|
|
if len(h.Network().ListenAddresses()) != 1 {
|
|
t.Error("expected one listen addr with user defined transport")
|
|
}
|
|
if reCircuit.FindStringSubmatchIndex(h.Network().ListenAddresses()[0].String()) == nil {
|
|
t.Error("expected relay address")
|
|
}
|
|
h.Close()
|
|
}
|
|
|
|
func makeRandomHost(t *testing.T, port int) (host.Host, error) {
|
|
priv, _, err := crypto.GenerateKeyPair(crypto.RSA, 2048)
|
|
require.NoError(t, err)
|
|
|
|
return New([]Option{
|
|
ListenAddrStrings(fmt.Sprintf("/ip4/127.0.0.1/tcp/%d", port)),
|
|
Identity(priv),
|
|
DefaultTransports,
|
|
DefaultMuxers,
|
|
DefaultSecurity,
|
|
NATPortMap(),
|
|
}...)
|
|
}
|
|
|
|
func TestChainOptions(t *testing.T) {
|
|
var cfg Config
|
|
var optsRun []int
|
|
optcount := 0
|
|
newOpt := func() Option {
|
|
index := optcount
|
|
optcount++
|
|
return func(c *Config) error {
|
|
optsRun = append(optsRun, index)
|
|
return nil
|
|
}
|
|
}
|
|
|
|
if err := cfg.Apply(newOpt(), nil, ChainOptions(newOpt(), newOpt(), ChainOptions(), ChainOptions(nil, newOpt()))); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
// Make sure we ran all options.
|
|
if optcount != 4 {
|
|
t.Errorf("expected to have handled %d options, handled %d", optcount, len(optsRun))
|
|
}
|
|
|
|
// Make sure we ran the options in-order.
|
|
for i, x := range optsRun {
|
|
if i != x {
|
|
t.Errorf("expected opt %d, got opt %d", i, x)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestTransportConstructorTCP(t *testing.T) {
|
|
h, err := New(
|
|
Transport(tcp.NewTCPTransport, tcp.DisableReuseport()),
|
|
DisableRelay(),
|
|
)
|
|
require.NoError(t, err)
|
|
defer h.Close()
|
|
require.NoError(t, h.Network().Listen(ma.StringCast("/ip4/127.0.0.1/tcp/0")))
|
|
err = h.Network().Listen(ma.StringCast("/ip4/127.0.0.1/udp/0/quic"))
|
|
require.Error(t, err)
|
|
require.Contains(t, err.Error(), swarm.ErrNoTransport.Error())
|
|
}
|
|
|
|
func TestTransportConstructorQUIC(t *testing.T) {
|
|
h, err := New(
|
|
Transport(quic.NewTransport),
|
|
DisableRelay(),
|
|
)
|
|
require.NoError(t, err)
|
|
defer h.Close()
|
|
require.NoError(t, h.Network().Listen(ma.StringCast("/ip4/127.0.0.1/udp/0/quic")))
|
|
err = h.Network().Listen(ma.StringCast("/ip4/127.0.0.1/tcp/0"))
|
|
require.Error(t, err)
|
|
require.Contains(t, err.Error(), swarm.ErrNoTransport.Error())
|
|
}
|
|
|
|
type mockTransport struct{}
|
|
|
|
func (m mockTransport) Dial(context.Context, ma.Multiaddr, peer.ID) (transport.CapableConn, error) {
|
|
panic("implement me")
|
|
}
|
|
|
|
func (m mockTransport) CanDial(ma.Multiaddr) bool { panic("implement me") }
|
|
func (m mockTransport) Listen(ma.Multiaddr) (transport.Listener, error) { panic("implement me") }
|
|
func (m mockTransport) Protocols() []int { return []int{1337} }
|
|
func (m mockTransport) Proxy() bool { panic("implement me") }
|
|
|
|
var _ transport.Transport = &mockTransport{}
|
|
|
|
func TestTransportConstructorWithoutOpts(t *testing.T) {
|
|
t.Run("successful", func(t *testing.T) {
|
|
var called bool
|
|
constructor := func() transport.Transport {
|
|
called = true
|
|
return &mockTransport{}
|
|
}
|
|
|
|
h, err := New(
|
|
Transport(constructor),
|
|
DisableRelay(),
|
|
)
|
|
require.NoError(t, err)
|
|
require.True(t, called, "expected constructor to be called")
|
|
defer h.Close()
|
|
})
|
|
|
|
t.Run("with options", func(t *testing.T) {
|
|
var called bool
|
|
constructor := func() transport.Transport {
|
|
called = true
|
|
return &mockTransport{}
|
|
}
|
|
|
|
_, err := New(
|
|
Transport(constructor, tcp.DisableReuseport()),
|
|
DisableRelay(),
|
|
)
|
|
require.EqualError(t, err, "transport constructor doesn't take any options")
|
|
require.False(t, called, "didn't expected constructor to be called")
|
|
})
|
|
}
|
|
|
|
func TestTransportConstructorWithWrongOpts(t *testing.T) {
|
|
_, err := New(
|
|
Transport(quic.NewTransport, tcp.DisableReuseport()),
|
|
DisableRelay(),
|
|
)
|
|
require.EqualError(t, err, "transport constructor doesn't take any options")
|
|
}
|
|
|
|
func TestSecurityConstructor(t *testing.T) {
|
|
h, err := New(
|
|
Transport(tcp.NewTCPTransport),
|
|
Security("/noisy", noise.New),
|
|
Security("/tls", tls.New),
|
|
DefaultListenAddrs,
|
|
DisableRelay(),
|
|
)
|
|
require.NoError(t, err)
|
|
defer h.Close()
|
|
|
|
h1, err := New(
|
|
NoListenAddrs,
|
|
Transport(tcp.NewTCPTransport),
|
|
Security("/noise", noise.New), // different name
|
|
DisableRelay(),
|
|
)
|
|
require.NoError(t, err)
|
|
defer h1.Close()
|
|
|
|
h2, err := New(
|
|
NoListenAddrs,
|
|
Transport(tcp.NewTCPTransport),
|
|
Security("/noisy", noise.New),
|
|
DisableRelay(),
|
|
)
|
|
require.NoError(t, err)
|
|
defer h2.Close()
|
|
|
|
ai := peer.AddrInfo{
|
|
ID: h.ID(),
|
|
Addrs: h.Addrs(),
|
|
}
|
|
err = h1.Connect(context.Background(), ai)
|
|
require.Error(t, err)
|
|
require.Contains(t, err.Error(), "failed to negotiate security protocol")
|
|
require.NoError(t, h2.Connect(context.Background(), ai))
|
|
}
|
|
|
|
func TestTransportConstructorWebTransport(t *testing.T) {
|
|
h, err := New(
|
|
Transport(webtransport.New),
|
|
DisableRelay(),
|
|
)
|
|
require.NoError(t, err)
|
|
defer h.Close()
|
|
require.NoError(t, h.Network().Listen(ma.StringCast("/ip4/127.0.0.1/udp/0/quic-v1/webtransport")))
|
|
err = h.Network().Listen(ma.StringCast("/ip4/127.0.0.1/udp/0/quic-v1/"))
|
|
require.Error(t, err)
|
|
require.Contains(t, err.Error(), swarm.ErrNoTransport.Error())
|
|
}
|
|
|
|
func TestTransportCustomAddressWebTransport(t *testing.T) {
|
|
customAddr, err := ma.NewMultiaddr("/ip4/127.0.0.1/udp/0/quic-v1/webtransport")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
h, err := New(
|
|
Transport(webtransport.New),
|
|
ListenAddrs(customAddr),
|
|
DisableRelay(),
|
|
AddrsFactory(func(multiaddrs []ma.Multiaddr) []ma.Multiaddr {
|
|
return []ma.Multiaddr{customAddr}
|
|
}),
|
|
)
|
|
require.NoError(t, err)
|
|
defer h.Close()
|
|
require.NoError(t, h.Network().Listen(ma.StringCast("/ip4/127.0.0.1/udp/0/quic-v1/webtransport")))
|
|
addrs := h.Addrs()
|
|
require.Len(t, addrs, 1)
|
|
require.NotEqual(t, addrs[0], customAddr)
|
|
restOfAddr, lastComp := ma.SplitLast(addrs[0])
|
|
restOfAddr, secondToLastComp := ma.SplitLast(restOfAddr)
|
|
require.Equal(t, lastComp.Protocol().Code, ma.P_CERTHASH)
|
|
require.Equal(t, secondToLastComp.Protocol().Code, ma.P_CERTHASH)
|
|
require.True(t, restOfAddr.Equal(customAddr))
|
|
}
|
|
|
|
// TestTransportCustomAddressWebTransportDoesNotStall tests that if the user
|
|
// manually returns a webtransport address from AddrsFactory, but we aren't
|
|
// listening on a webtranport address, we don't stall.
|
|
func TestTransportCustomAddressWebTransportDoesNotStall(t *testing.T) {
|
|
customAddr, err := ma.NewMultiaddr("/ip4/127.0.0.1/udp/0/quic-v1/webtransport")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
h, err := New(
|
|
Transport(webtransport.New),
|
|
// Purposely not listening on the custom address so that we make sure the node doesn't stall if it fails to add a certhash to the multiaddr
|
|
// ListenAddrs(customAddr),
|
|
DisableRelay(),
|
|
AddrsFactory(func(multiaddrs []ma.Multiaddr) []ma.Multiaddr {
|
|
return []ma.Multiaddr{customAddr}
|
|
}),
|
|
)
|
|
require.NoError(t, err)
|
|
defer h.Close()
|
|
addrs := h.Addrs()
|
|
require.Len(t, addrs, 1)
|
|
_, lastComp := ma.SplitLast(addrs[0])
|
|
require.NotEqual(t, lastComp.Protocol().Code, ma.P_CERTHASH)
|
|
// We did not add the certhash to the multiaddr
|
|
require.Equal(t, addrs[0], customAddr)
|
|
}
|