Skip to content
This repository was archived by the owner on May 26, 2022. It is now read-only.

Commit d9162d8

Browse files
marten-seemannmarten-seemann
committed
speed up the dial tests
1 parent a89449e commit d9162d8

File tree

4 files changed

+62
-119
lines changed

4 files changed

+62
-119
lines changed

‎dial_test.go

+36-80
Original file line numberDiff line numberDiff line change
@@ -24,8 +24,10 @@ import (
2424
"github.com/stretchr/testify/require"
2525
)
2626

27-
func init() {
28-
transport.DialTimeout = time.Second
27+
func setDialTimeout(t time.Duration) (reset func()) {
28+
orig := transport.DialTimeout
29+
transport.DialTimeout = t
30+
return func() { transport.DialTimeout = orig }
2931
}
3032

3133
func closeSwarms(swarms []*Swarm) {
@@ -87,11 +89,11 @@ func acceptAndHang(l net.Listener) {
8789
}
8890

8991
func TestSimultDials(t *testing.T) {
90-
// t.Skip("skipping for another test")
9192
t.Parallel()
9293

9394
ctx := context.Background()
9495
swarms := makeSwarms(t, 2, swarmt.OptDisableReuseport)
96+
defer closeSwarms(swarms)
9597

9698
// connect everyone
9799
{
@@ -133,10 +135,6 @@ func TestSimultDials(t *testing.T) {
133135
if c10l > 2 {
134136
t.Error("1->0 has", c10l)
135137
}
136-
137-
for _, s := range swarms {
138-
s.Close()
139-
}
140138
}
141139

142140
func newSilentPeer(t *testing.T) (peer.ID, ma.Multiaddr, net.Listener) {
@@ -159,7 +157,8 @@ func newSilentPeer(t *testing.T) (peer.ID, ma.Multiaddr, net.Listener) {
159157
}
160158

161159
func TestDialWait(t *testing.T) {
162-
t.Parallel()
160+
reset := setDialTimeout(250 * time.Millisecond)
161+
defer reset()
163162

164163
ctx := context.Background()
165164
swarms := makeSwarms(t, 1)
@@ -194,7 +193,6 @@ func TestDialWait(t *testing.T) {
194193
}
195194

196195
func TestDialBackoff(t *testing.T) {
197-
// t.Skip("skipping for another test")
198196
if ci.IsRunning() {
199197
t.Skip("travis will never have fun with this test")
200198
}
@@ -203,10 +201,9 @@ func TestDialBackoff(t *testing.T) {
203201

204202
ctx := context.Background()
205203
swarms := makeSwarms(t, 2)
204+
defer closeSwarms(swarms)
206205
s1 := swarms[0]
207206
s2 := swarms[1]
208-
defer s1.Close()
209-
defer s2.Close()
210207

211208
s2addrs, err := s2.InterfaceListenAddresses()
212209
if err != nil {
@@ -405,15 +402,13 @@ func TestDialBackoff(t *testing.T) {
405402
}
406403

407404
func TestDialBackoffClears(t *testing.T) {
408-
// t.Skip("skipping for another test")
409-
t.Parallel()
405+
reset := setDialTimeout(250 * time.Millisecond)
406+
defer reset()
410407

411-
ctx := context.Background()
412408
swarms := makeSwarms(t, 2)
409+
defer closeSwarms(swarms)
413410
s1 := swarms[0]
414411
s2 := swarms[1]
415-
defer s1.Close()
416-
defer s2.Close()
417412

418413
// use another address first, that accept and hang on conns
419414
_, s2bad, s2l := newSilentPeer(t)
@@ -424,13 +419,8 @@ func TestDialBackoffClears(t *testing.T) {
424419
s1.Peerstore().AddAddr(s2.LocalPeer(), s2bad, peerstore.PermanentAddrTTL)
425420

426421
before := time.Now()
427-
c, err := s1.DialPeer(ctx, s2.LocalPeer())
428-
if err == nil {
429-
defer c.Close()
430-
t.Fatal("dialing to broken addr worked...", err)
431-
} else {
432-
t.Log("correctly got error:", err)
433-
}
422+
_, err := s1.DialPeer(context.Background(), s2.LocalPeer())
423+
require.Error(t, err, "dialing to broken addr worked...")
434424
duration := time.Since(before)
435425

436426
if duration < transport.DialTimeout*DialAttempts {
@@ -439,39 +429,18 @@ func TestDialBackoffClears(t *testing.T) {
439429
if duration > 2*transport.DialTimeout*DialAttempts {
440430
t.Error("> 2*transport.DialTimeout * DialAttempts not being respected", duration, 2*transport.DialTimeout*DialAttempts)
441431
}
442-
443-
if !s1.Backoff().Backoff(s2.LocalPeer(), s2bad) {
444-
t.Error("s2 should now be on backoff")
445-
} else {
446-
t.Log("correctly added to backoff")
447-
}
432+
require.True(t, s1.Backoff().Backoff(s2.LocalPeer(), s2bad), "s2 should now be on backoff")
448433

449434
// phase 2 -- add the working address. dial should succeed.
450-
ifaceAddrs1, err := swarms[1].InterfaceListenAddresses()
451-
if err != nil {
452-
t.Fatal(err)
453-
}
435+
ifaceAddrs1, err := s2.InterfaceListenAddresses()
436+
require.NoError(t, err)
454437
s1.Peerstore().AddAddrs(s2.LocalPeer(), ifaceAddrs1, peerstore.PermanentAddrTTL)
455438

456-
if c, err := s1.DialPeer(ctx, s2.LocalPeer()); err == nil {
457-
c.Close()
458-
t.Log("backoffs are per address, not peer")
459-
}
460-
461-
time.Sleep(BackoffBase)
462-
463-
if c, err := s1.DialPeer(ctx, s2.LocalPeer()); err != nil {
464-
t.Fatal(err)
465-
} else {
466-
c.Close()
467-
t.Log("correctly connected")
468-
}
469-
470-
if s1.Backoff().Backoff(s2.LocalPeer(), s2bad) {
471-
t.Error("s2 should no longer be on backoff")
472-
} else {
473-
t.Log("correctly cleared backoff")
474-
}
439+
// backoffs are per address, not peer
440+
c, err := s1.DialPeer(context.Background(), s2.LocalPeer())
441+
require.NoError(t, err)
442+
defer c.Close()
443+
require.False(t, s1.Backoff().Backoff(s2.LocalPeer(), s2bad), "s2 should no longer be on backoff")
475444
}
476445

477446
func TestDialPeerFailed(t *testing.T) {
@@ -515,28 +484,20 @@ func TestDialPeerFailed(t *testing.T) {
515484
}
516485

517486
func TestDialExistingConnection(t *testing.T) {
518-
ctx := context.Background()
519-
520487
swarms := makeSwarms(t, 2)
521488
defer closeSwarms(swarms)
522489
s1 := swarms[0]
523490
s2 := swarms[1]
524491

525492
s1.Peerstore().AddAddrs(s2.LocalPeer(), s2.ListenAddresses(), peerstore.PermanentAddrTTL)
526493

527-
c1, err := s1.DialPeer(ctx, s2.LocalPeer())
528-
if err != nil {
529-
t.Fatal(err)
530-
}
494+
c1, err := s1.DialPeer(context.Background(), s2.LocalPeer())
495+
require.NoError(t, err)
531496

532-
c2, err := s1.DialPeer(ctx, s2.LocalPeer())
533-
if err != nil {
534-
t.Fatal(err)
535-
}
497+
c2, err := s1.DialPeer(context.Background(), s2.LocalPeer())
498+
require.NoError(t, err)
536499

537-
if c1 != c2 {
538-
t.Fatal("expecting the same connection from both dials")
539-
}
500+
require.Equal(t, c1, c2, "expecting the same connection from both dials")
540501
}
541502

542503
func newSilentListener(t *testing.T) ([]ma.Multiaddr, net.Listener) {
@@ -558,14 +519,13 @@ func newSilentListener(t *testing.T) ([]ma.Multiaddr, net.Listener) {
558519
}
559520

560521
func TestDialSimultaneousJoin(t *testing.T) {
561-
ctx, cancel := context.WithCancel(context.Background())
562-
defer cancel()
522+
reset := setDialTimeout(250 * time.Millisecond)
523+
defer reset()
563524

564525
swarms := makeSwarms(t, 2)
526+
defer closeSwarms(swarms)
565527
s1 := swarms[0]
566528
s2 := swarms[1]
567-
defer s1.Close()
568-
defer s2.Close()
569529

570530
s2silentAddrs, s2silentListener := newSilentListener(t)
571531
go acceptAndHang(s2silentListener)
@@ -577,7 +537,7 @@ func TestDialSimultaneousJoin(t *testing.T) {
577537
go func() {
578538
s1.Peerstore().AddAddrs(s2.LocalPeer(), s2silentAddrs, peerstore.PermanentAddrTTL)
579539

580-
c, err := s1.DialPeer(ctx, s2.LocalPeer())
540+
c, err := s1.DialPeer(context.Background(), s2.LocalPeer())
581541
if err != nil {
582542
errs <- err
583543
connch <- nil
@@ -602,7 +562,7 @@ func TestDialSimultaneousJoin(t *testing.T) {
602562
}
603563
s1.Peerstore().AddAddrs(s2.LocalPeer(), s2addrs[:1], peerstore.PermanentAddrTTL)
604564

605-
c, err := s1.DialPeer(ctx, s2.LocalPeer())
565+
c, err := s1.DialPeer(context.Background(), s2.LocalPeer())
606566
if err != nil {
607567
errs <- err
608568
connch <- nil
@@ -620,7 +580,7 @@ func TestDialSimultaneousJoin(t *testing.T) {
620580

621581
// start a third dial to s2, this should get the existing connection from the successful dial
622582
go func() {
623-
c, err := s1.DialPeer(ctx, s2.LocalPeer())
583+
c, err := s1.DialPeer(context.Background(), s2.LocalPeer())
624584
if err != nil {
625585
errs <- err
626586
connch <- nil
@@ -637,10 +597,7 @@ func TestDialSimultaneousJoin(t *testing.T) {
637597

638598
// raise any errors from the previous goroutines
639599
for i := 0; i < 3; i++ {
640-
err := <-errs
641-
if err != nil {
642-
t.Fatal(err)
643-
}
600+
require.NoError(t, <-errs)
644601
}
645602

646603
if c2 != c3 {
@@ -660,13 +617,12 @@ func TestDialSimultaneousJoin(t *testing.T) {
660617
}
661618

662619
func TestDialSelf(t *testing.T) {
663-
ctx, cancel := context.WithCancel(context.Background())
664-
defer cancel()
620+
t.Parallel()
665621

666622
swarms := makeSwarms(t, 2)
623+
defer closeSwarms(swarms)
667624
s1 := swarms[0]
668-
defer s1.Close()
669625

670-
_, err := s1.DialPeer(ctx, s1.LocalPeer())
626+
_, err := s1.DialPeer(context.Background(), s1.LocalPeer())
671627
require.ErrorIs(t, err, ErrDialToSelf, "expected error from self dial")
672628
}

‎limiter_test.go

+21-22
Original file line numberDiff line numberDiff line change
@@ -18,16 +18,14 @@ import (
1818
mafmt "github.com/multiformats/go-multiaddr-fmt"
1919
)
2020

21-
func mustAddr(t *testing.T, s string) ma.Multiaddr {
22-
a, err := ma.NewMultiaddr(s)
23-
if err != nil {
24-
t.Fatal(err)
25-
}
26-
return a
21+
func setDialTimeout(t time.Duration) (reset func()) {
22+
orig := transport.DialTimeout
23+
transport.DialTimeout = t
24+
return func() { transport.DialTimeout = orig }
2725
}
2826

29-
func addrWithPort(t *testing.T, p int) ma.Multiaddr {
30-
return mustAddr(t, fmt.Sprintf("/ip4/127.0.0.1/tcp/%d", p))
27+
func addrWithPort(p int) ma.Multiaddr {
28+
return ma.StringCast(fmt.Sprintf("/ip4/127.0.0.1/tcp/%d", p))
3129
}
3230

3331
// in these tests I use addresses with tcp ports over a certain number to
@@ -84,8 +82,8 @@ func TestLimiterBasicDials(t *testing.T) {
8482

8583
l := newDialLimiterWithParams(hangDialFunc(hang), ConcurrentFdDials, 4)
8684

87-
bads := []ma.Multiaddr{addrWithPort(t, 1), addrWithPort(t, 2), addrWithPort(t, 3), addrWithPort(t, 4)}
88-
good := addrWithPort(t, 20)
85+
bads := []ma.Multiaddr{addrWithPort(1), addrWithPort(2), addrWithPort(3), addrWithPort(4)}
86+
good := addrWithPort(20)
8987

9088
resch := make(chan dialResult)
9189
pid := peer.ID("testpeer")
@@ -133,9 +131,9 @@ func TestFDLimiting(t *testing.T) {
133131
defer close(hang)
134132
l := newDialLimiterWithParams(hangDialFunc(hang), 16, 5)
135133

136-
bads := []ma.Multiaddr{addrWithPort(t, 1), addrWithPort(t, 2), addrWithPort(t, 3), addrWithPort(t, 4)}
134+
bads := []ma.Multiaddr{addrWithPort(1), addrWithPort(2), addrWithPort(3), addrWithPort(4)}
137135
pids := []peer.ID{"testpeer1", "testpeer2", "testpeer3", "testpeer4"}
138-
goodTCP := addrWithPort(t, 20)
136+
goodTCP := addrWithPort(20)
139137

140138
ctx := context.Background()
141139
resch := make(chan dialResult)
@@ -163,7 +161,7 @@ func TestFDLimiting(t *testing.T) {
163161
}
164162

165163
pid5 := peer.ID("testpeer5")
166-
utpaddr := mustAddr(t, "/ip4/127.0.0.1/udp/7777/utp")
164+
utpaddr := ma.StringCast("/ip4/127.0.0.1/udp/7777/utp")
167165

168166
// This should complete immediately since utp addresses arent blocked by fd rate limiting
169167
l.AddDialJob(&dialJob{ctx: ctx, peer: pid5, addr: utpaddr, resp: resch})
@@ -180,7 +178,7 @@ func TestFDLimiting(t *testing.T) {
180178
// A relay address with tcp transport will complete because we do not consume fds for dials
181179
// with relay addresses as the fd will be consumed when we actually dial the relay server.
182180
pid6 := test.RandPeerIDFatal(t)
183-
relayAddr := mustAddr(t, fmt.Sprintf("/ip4/127.0.0.1/tcp/20/p2p-circuit/p2p/%s", pid6))
181+
relayAddr := ma.StringCast(fmt.Sprintf("/ip4/127.0.0.1/tcp/20/p2p-circuit/p2p/%s", pid6))
184182
l.AddDialJob(&dialJob{ctx: ctx, peer: pid6, addr: relayAddr, resp: resch})
185183

186184
select {
@@ -209,7 +207,7 @@ func TestTokenRedistribution(t *testing.T) {
209207
}
210208
l := newDialLimiterWithParams(df, 8, 4)
211209

212-
bads := []ma.Multiaddr{addrWithPort(t, 1), addrWithPort(t, 2), addrWithPort(t, 3), addrWithPort(t, 4)}
210+
bads := []ma.Multiaddr{addrWithPort(1), addrWithPort(2), addrWithPort(3), addrWithPort(4)}
213211
pids := []peer.ID{"testpeer1", "testpeer2"}
214212

215213
ctx := context.Background()
@@ -224,13 +222,11 @@ func TestTokenRedistribution(t *testing.T) {
224222
tryDialAddrs(ctx, l, pid, bads, resch)
225223
}
226224

227-
good := mustAddr(t, "/ip4/127.0.0.1/tcp/1001")
228-
229225
// add a good dial job for peer 1
230226
l.AddDialJob(&dialJob{
231227
ctx: ctx,
232228
peer: pids[1],
233-
addr: good,
229+
addr: ma.StringCast("/ip4/127.0.0.1/tcp/1001"),
234230
resp: resch,
235231
})
236232

@@ -263,7 +259,7 @@ func TestTokenRedistribution(t *testing.T) {
263259
l.AddDialJob(&dialJob{
264260
ctx: ctx,
265261
peer: pids[0],
266-
addr: addrWithPort(t, 7),
262+
addr: addrWithPort(7),
267263
resp: resch,
268264
})
269265

@@ -304,10 +300,10 @@ func TestStressLimiter(t *testing.T) {
304300

305301
var bads []ma.Multiaddr
306302
for i := 0; i < 100; i++ {
307-
bads = append(bads, addrWithPort(t, i))
303+
bads = append(bads, addrWithPort(i))
308304
}
309305

310-
addresses := append(bads, addrWithPort(t, 2000))
306+
addresses := append(bads, addrWithPort(2000))
311307
success := make(chan struct{})
312308

313309
for i := 0; i < 20; i++ {
@@ -345,6 +341,9 @@ func TestStressLimiter(t *testing.T) {
345341
}
346342

347343
func TestFDLimitUnderflow(t *testing.T) {
344+
reset := setDialTimeout(250 * time.Millisecond)
345+
defer reset()
346+
348347
df := func(ctx context.Context, p peer.ID, addr ma.Multiaddr) (transport.CapableConn, error) {
349348
select {
350349
case <-ctx.Done():
@@ -358,7 +357,7 @@ func TestFDLimitUnderflow(t *testing.T) {
358357

359358
var addrs []ma.Multiaddr
360359
for i := 0; i <= 1000; i++ {
361-
addrs = append(addrs, addrWithPort(t, i))
360+
addrs = append(addrs, addrWithPort(i))
362361
}
363362

364363
wg := sync.WaitGroup{}

0 commit comments

Comments
 (0)