Skip to content

Commit 0c04675

Browse files
marten-seemannmarten-seemann
committed
stop using go-libp2p-testing peer ID generation functions
1 parent f087aac commit 0c04675

File tree

4 files changed

+117
-64
lines changed

4 files changed

+117
-64
lines changed

‎p2p/net/conn-security-multistream/ssms_test.go

+24-15
Original file line numberDiff line numberDiff line change
@@ -2,19 +2,28 @@ package csms
22

33
import (
44
"context"
5+
"crypto/rand"
56
"io"
67
"net"
78
"sync"
89
"testing"
910

10-
tnet "github.com/libp2p/go-libp2p-testing/net"
11+
"github.com/libp2p/go-libp2p/core/crypto"
1112
"github.com/libp2p/go-libp2p/core/peer"
1213
"github.com/libp2p/go-libp2p/core/sec"
1314
"github.com/libp2p/go-libp2p/core/sec/insecure"
1415

1516
"github.com/stretchr/testify/require"
1617
)
1718

19+
func newPeer(t *testing.T) (crypto.PrivKey, peer.ID) {
20+
priv, _, err := crypto.GenerateEd25519Key(rand.Reader)
21+
require.NoError(t, err)
22+
id, err := peer.IDFromPrivateKey(priv)
23+
require.NoError(t, err)
24+
return priv, id
25+
}
26+
1827
type TransportAdapter struct {
1928
mux *SSMuxer
2029
}
@@ -30,13 +39,13 @@ func (sm *TransportAdapter) SecureOutbound(ctx context.Context, insecure net.Con
3039
}
3140

3241
func TestCommonProto(t *testing.T) {
33-
idA := tnet.RandIdentityOrFatal(t)
34-
idB := tnet.RandIdentityOrFatal(t)
42+
privA, idA := newPeer(t)
43+
privB, idB := newPeer(t)
3544

3645
var at, bt SSMuxer
3746

38-
atInsecure := insecure.NewWithIdentity(idA.ID(), idA.PrivateKey())
39-
btInsecure := insecure.NewWithIdentity(idB.ID(), idB.PrivateKey())
47+
atInsecure := insecure.NewWithIdentity(idA, privA)
48+
btInsecure := insecure.NewWithIdentity(idB, privB)
4049
at.AddTransport("/plaintext/1.0.0", atInsecure)
4150
bt.AddTransport("/plaintext/1.1.0", btInsecure)
4251
bt.AddTransport("/plaintext/1.0.0", btInsecure)
@@ -48,7 +57,7 @@ func TestCommonProto(t *testing.T) {
4857
go func() {
4958
conn, err := ln.Accept()
5059
require.NoError(t, err)
51-
c, err := muxB.SecureInbound(context.Background(), conn, idA.ID())
60+
c, err := muxB.SecureInbound(context.Background(), conn, idA)
5261
require.NoError(t, err)
5362
connChan <- c
5463
}()
@@ -58,29 +67,29 @@ func TestCommonProto(t *testing.T) {
5867
cconn, err := net.Dial("tcp", ln.Addr().String())
5968
require.NoError(t, err)
6069

61-
cc, err := muxA.SecureOutbound(context.Background(), cconn, idB.ID())
70+
cc, err := muxA.SecureOutbound(context.Background(), cconn, idB)
6271
require.NoError(t, err)
63-
require.Equal(t, cc.LocalPeer(), idA.ID())
64-
require.Equal(t, cc.RemotePeer(), idB.ID())
72+
require.Equal(t, cc.LocalPeer(), idA)
73+
require.Equal(t, cc.RemotePeer(), idB)
6574
_, err = cc.Write([]byte("foobar"))
6675
require.NoError(t, err)
6776
require.NoError(t, cc.Close())
6877

6978
sc := <-connChan
70-
require.Equal(t, sc.LocalPeer(), idB.ID())
71-
require.Equal(t, sc.RemotePeer(), idA.ID())
79+
require.Equal(t, sc.LocalPeer(), idB)
80+
require.Equal(t, sc.RemotePeer(), idA)
7281
b, err := io.ReadAll(sc)
7382
require.NoError(t, err)
7483
require.Equal(t, "foobar", string(b))
7584
}
7685

7786
func TestNoCommonProto(t *testing.T) {
78-
idA := tnet.RandIdentityOrFatal(t)
79-
idB := tnet.RandIdentityOrFatal(t)
87+
privA, idA := newPeer(t)
88+
privB, idB := newPeer(t)
8089

8190
var at, bt SSMuxer
82-
atInsecure := insecure.NewWithIdentity(idA.ID(), idA.PrivateKey())
83-
btInsecure := insecure.NewWithIdentity(idB.ID(), idB.PrivateKey())
91+
atInsecure := insecure.NewWithIdentity(idA, privA)
92+
btInsecure := insecure.NewWithIdentity(idB, privB)
8493

8594
at.AddTransport("/plaintext/1.0.0", atInsecure)
8695
bt.AddTransport("/plaintext/1.1.0", btInsecure)

‎p2p/net/mock/mock_test.go

+53-14
Original file line numberDiff line numberDiff line change
@@ -3,48 +3,85 @@ package mocknet
33
import (
44
"bytes"
55
"context"
6+
"crypto/rand"
7+
"fmt"
68
"io"
79
"math"
810
"sync"
911
"testing"
1012
"time"
1113

14+
"github.com/libp2p/go-libp2p/core/crypto"
1215
"github.com/libp2p/go-libp2p/core/network"
1316
"github.com/libp2p/go-libp2p/core/peer"
1417
"github.com/libp2p/go-libp2p/core/protocol"
1518

1619
"github.com/libp2p/go-libp2p-testing/ci"
17-
tnet "github.com/libp2p/go-libp2p-testing/net"
20+
tetc "github.com/libp2p/go-libp2p-testing/etc"
1821
"github.com/libp2p/go-libp2p-testing/race"
22+
ma "github.com/multiformats/go-multiaddr"
23+
"github.com/stretchr/testify/require"
1924
)
2025

26+
var lastPort = struct {
27+
port int
28+
sync.Mutex
29+
}{}
30+
31+
// randLocalTCPAddress returns a random multiaddr. it suppresses errors
32+
// for nice composability-- do check the address isn't nil.
33+
//
34+
// NOTE: for real network tests, use a :0 address, so the kernel
35+
// assigns an unused TCP port. otherwise you may get clashes.
36+
func randLocalTCPAddress() ma.Multiaddr {
37+
// chances are it will work out, but it **might** fail if the port is in use
38+
// most ports above 10000 aren't in use by long running processes, so yay.
39+
// (maybe there should be a range of "loopback" ports that are guaranteed
40+
// to be open for the process, but naturally can only talk to self.)
41+
42+
lastPort.Lock()
43+
if lastPort.port == 0 {
44+
lastPort.port = 10000 + tetc.SeededRand.Intn(50000)
45+
}
46+
port := lastPort.port
47+
lastPort.port++
48+
lastPort.Unlock()
49+
50+
addr := fmt.Sprintf("/ip4/127.0.0.1/tcp/%d", port)
51+
maddr, _ := ma.NewMultiaddr(addr)
52+
return maddr
53+
}
54+
2155
func TestNetworkSetup(t *testing.T) {
2256
ctx := context.Background()
23-
id1 := tnet.RandIdentityOrFatal(t)
24-
id2 := tnet.RandIdentityOrFatal(t)
25-
id3 := tnet.RandIdentityOrFatal(t)
57+
priv1, _, err := crypto.GenerateEd25519Key(rand.Reader)
58+
require.NoError(t, err)
59+
priv2, _, err := crypto.GenerateEd25519Key(rand.Reader)
60+
require.NoError(t, err)
61+
priv3, _, err := crypto.GenerateEd25519Key(rand.Reader)
62+
require.NoError(t, err)
2663
mn := New()
2764
defer mn.Close()
2865

2966
// add peers to mock net
3067

31-
a1 := tnet.RandLocalTCPAddress()
32-
a2 := tnet.RandLocalTCPAddress()
33-
a3 := tnet.RandLocalTCPAddress()
68+
a1 := randLocalTCPAddress()
69+
a2 := randLocalTCPAddress()
70+
a3 := randLocalTCPAddress()
3471

35-
h1, err := mn.AddPeer(id1.PrivateKey(), a1)
72+
h1, err := mn.AddPeer(priv1, a1)
3673
if err != nil {
3774
t.Fatal(err)
3875
}
3976
p1 := h1.ID()
4077

41-
h2, err := mn.AddPeer(id2.PrivateKey(), a2)
78+
h2, err := mn.AddPeer(priv2, a2)
4279
if err != nil {
4380
t.Fatal(err)
4481
}
4582
p2 := h2.ID()
4683

47-
h3, err := mn.AddPeer(id3.PrivateKey(), a3)
84+
h3, err := mn.AddPeer(priv3, a3)
4885
if err != nil {
4986
t.Fatal(err)
5087
}
@@ -315,10 +352,12 @@ func TestAdding(t *testing.T) {
315352

316353
var peers []peer.ID
317354
for i := 0; i < 3; i++ {
318-
id := tnet.RandIdentityOrFatal(t)
319-
320-
a := tnet.RandLocalTCPAddress()
321-
h, err := mn.AddPeer(id.PrivateKey(), a)
355+
priv, _, err := crypto.GenerateEd25519Key(rand.Reader)
356+
if err != nil {
357+
t.Fatal(err)
358+
}
359+
a := randLocalTCPAddress()
360+
h, err := mn.AddPeer(priv, a)
322361
if err != nil {
323362
t.Fatal(err)
324363
}

‎p2p/net/swarm/dial_worker_test.go

+26-17
Original file line numberDiff line numberDiff line change
@@ -2,12 +2,15 @@ package swarm
22

33
import (
44
"context"
5+
"crypto/rand"
56
"errors"
67
"fmt"
78
"sync"
89
"testing"
910
"time"
1011

12+
"github.com/libp2p/go-libp2p/core/crypto"
13+
"github.com/libp2p/go-libp2p/core/peer"
1114
"github.com/libp2p/go-libp2p/core/peerstore"
1215
"github.com/libp2p/go-libp2p/core/sec/insecure"
1316
"github.com/libp2p/go-libp2p/core/transport"
@@ -19,22 +22,28 @@ import (
1922
quic "github.com/libp2p/go-libp2p/p2p/transport/quic"
2023
"github.com/libp2p/go-libp2p/p2p/transport/tcp"
2124

22-
tnet "github.com/libp2p/go-libp2p-testing/net"
23-
2425
ma "github.com/multiformats/go-multiaddr"
2526
"github.com/stretchr/testify/require"
2627
)
2728

29+
func newPeer(t *testing.T) (crypto.PrivKey, peer.ID) {
30+
priv, _, err := crypto.GenerateEd25519Key(rand.Reader)
31+
require.NoError(t, err)
32+
id, err := peer.IDFromPrivateKey(priv)
33+
require.NoError(t, err)
34+
return priv, id
35+
}
36+
2837
func makeSwarm(t *testing.T) *Swarm {
29-
p := tnet.RandPeerNetParamsOrFatal(t)
38+
priv, id := newPeer(t)
3039

3140
ps, err := pstoremem.NewPeerstore()
3241
require.NoError(t, err)
33-
ps.AddPubKey(p.ID, p.PubKey)
34-
ps.AddPrivKey(p.ID, p.PrivKey)
42+
ps.AddPubKey(id, priv.GetPublic())
43+
ps.AddPrivKey(id, priv)
3544
t.Cleanup(func() { ps.Close() })
3645

37-
s, err := NewSwarm(p.ID, ps, WithDialTimeout(time.Second))
46+
s, err := NewSwarm(id, ps, WithDialTimeout(time.Second))
3847
require.NoError(t, err)
3948

4049
upgrader := makeUpgrader(t, s)
@@ -46,11 +55,11 @@ func makeSwarm(t *testing.T) *Swarm {
4655
if err := s.AddTransport(tcpTransport); err != nil {
4756
t.Fatal(err)
4857
}
49-
if err := s.Listen(p.Addr); err != nil {
58+
if err := s.Listen(ma.StringCast("/ip4/0.0.0.0/tcp/0")); err != nil {
5059
t.Fatal(err)
5160
}
5261

53-
quicTransport, err := quic.NewTransport(p.PrivKey, nil, nil, nil)
62+
quicTransport, err := quic.NewTransport(priv, nil, nil, nil)
5463
if err != nil {
5564
t.Fatal(err)
5665
}
@@ -170,13 +179,13 @@ func TestDialWorkerLoopFailure(t *testing.T) {
170179
s1 := makeSwarm(t)
171180
defer s1.Close()
172181

173-
p2 := tnet.RandPeerNetParamsOrFatal(t)
182+
_, p2 := newPeer(t)
174183

175-
s1.Peerstore().AddAddrs(p2.ID, []ma.Multiaddr{ma.StringCast("/ip4/11.0.0.1/tcp/1234"), ma.StringCast("/ip4/11.0.0.1/udp/1234/quic")}, peerstore.PermanentAddrTTL)
184+
s1.Peerstore().AddAddrs(p2, []ma.Multiaddr{ma.StringCast("/ip4/11.0.0.1/tcp/1234"), ma.StringCast("/ip4/11.0.0.1/udp/1234/quic")}, peerstore.PermanentAddrTTL)
176185

177186
reqch := make(chan dialRequest)
178187
resch := make(chan dialResponse)
179-
worker := newDialWorker(s1, p2.ID, reqch)
188+
worker := newDialWorker(s1, p2, reqch)
180189
go worker.loop()
181190

182191
reqch <- dialRequest{ctx: context.Background(), resch: resch}
@@ -195,12 +204,12 @@ func TestDialWorkerLoopConcurrentFailure(t *testing.T) {
195204
s1 := makeSwarm(t)
196205
defer s1.Close()
197206

198-
p2 := tnet.RandPeerNetParamsOrFatal(t)
207+
_, p2 := newPeer(t)
199208

200-
s1.Peerstore().AddAddrs(p2.ID, []ma.Multiaddr{ma.StringCast("/ip4/11.0.0.1/tcp/1234"), ma.StringCast("/ip4/11.0.0.1/udp/1234/quic")}, peerstore.PermanentAddrTTL)
209+
s1.Peerstore().AddAddrs(p2, []ma.Multiaddr{ma.StringCast("/ip4/11.0.0.1/tcp/1234"), ma.StringCast("/ip4/11.0.0.1/udp/1234/quic")}, peerstore.PermanentAddrTTL)
201210

202211
reqch := make(chan dialRequest)
203-
worker := newDialWorker(s1, p2.ID, reqch)
212+
worker := newDialWorker(s1, p2, reqch)
204213
go worker.loop()
205214

206215
const dials = 100
@@ -285,16 +294,16 @@ func TestDialWorkerLoopConcurrentFailureStress(t *testing.T) {
285294
s1 := makeSwarm(t)
286295
defer s1.Close()
287296

288-
p2 := tnet.RandPeerNetParamsOrFatal(t)
297+
_, p2 := newPeer(t)
289298

290299
var addrs []ma.Multiaddr
291300
for i := 0; i < 16; i++ {
292301
addrs = append(addrs, ma.StringCast(fmt.Sprintf("/ip4/11.0.0.%d/tcp/%d", i%256, 1234+i)))
293302
}
294-
s1.Peerstore().AddAddrs(p2.ID, addrs, peerstore.PermanentAddrTTL)
303+
s1.Peerstore().AddAddrs(p2, addrs, peerstore.PermanentAddrTTL)
295304

296305
reqch := make(chan dialRequest)
297-
worker := newDialWorker(s1, p2.ID, reqch)
306+
worker := newDialWorker(s1, p2, reqch)
298307
go worker.loop()
299308

300309
const dials = 100

0 commit comments

Comments
 (0)