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

Commit 3338d5f

Browse files
marten-seemannmarten-seemann
committed
speed up the dial tests
1 parent 69f15a7 commit 3338d5f

File tree

4 files changed

+56
-127
lines changed

4 files changed

+56
-127
lines changed

‎dial_test.go

+30-88
Original file line numberDiff line numberDiff line change
@@ -82,11 +82,11 @@ func acceptAndHang(l net.Listener) {
8282
}
8383

8484
func TestSimultDials(t *testing.T) {
85-
// t.Skip("skipping for another test")
8685
t.Parallel()
8786

8887
ctx := context.Background()
8988
swarms := makeSwarms(t, 2, swarmt.OptDisableReuseport)
89+
defer closeSwarms(swarms)
9090

9191
// connect everyone
9292
{
@@ -128,10 +128,6 @@ func TestSimultDials(t *testing.T) {
128128
if c10l > 2 {
129129
t.Error("1->0 has", c10l)
130130
}
131-
132-
for _, s := range swarms {
133-
s.Close()
134-
}
135131
}
136132

137133
func newSilentPeer(t *testing.T) (peer.ID, ma.Multiaddr, net.Listener) {
@@ -154,8 +150,6 @@ func newSilentPeer(t *testing.T) (peer.ID, ma.Multiaddr, net.Listener) {
154150
}
155151

156152
func TestDialWait(t *testing.T) {
157-
t.Parallel()
158-
159153
const dialTimeout = 250 * time.Millisecond
160154

161155
swarms := makeSwarms(t, 1, swarmt.DialTimeout(dialTimeout))
@@ -193,22 +187,18 @@ func TestDialBackoff(t *testing.T) {
193187
if ci.IsRunning() {
194188
t.Skip("travis will never have fun with this test")
195189
}
196-
197190
t.Parallel()
198191

199192
const dialTimeout = 250 * time.Millisecond
200193

201194
ctx := context.Background()
202195
swarms := makeSwarms(t, 2, swarmt.DialTimeout(dialTimeout))
196+
defer closeSwarms(swarms)
203197
s1 := swarms[0]
204198
s2 := swarms[1]
205-
defer s1.Close()
206-
defer s2.Close()
207199

208200
s2addrs, err := s2.InterfaceListenAddresses()
209-
if err != nil {
210-
t.Fatal(err)
211-
}
201+
require.NoError(t, err)
212202
s1.Peerstore().AddAddrs(s2.LocalPeer(), s2addrs, peerstore.PermanentAddrTTL)
213203

214204
// dial to a non-existent peer.
@@ -405,13 +395,10 @@ func TestDialBackoffClears(t *testing.T) {
405395
t.Parallel()
406396

407397
const dialTimeout = 250 * time.Millisecond
408-
409-
ctx := context.Background()
410398
swarms := makeSwarms(t, 2, swarmt.DialTimeout(dialTimeout))
399+
defer closeSwarms(swarms)
411400
s1 := swarms[0]
412401
s2 := swarms[1]
413-
defer s1.Close()
414-
defer s2.Close()
415402

416403
// use another address first, that accept and hang on conns
417404
_, s2bad, s2l := newSilentPeer(t)
@@ -422,13 +409,8 @@ func TestDialBackoffClears(t *testing.T) {
422409
s1.Peerstore().AddAddr(s2.LocalPeer(), s2bad, peerstore.PermanentAddrTTL)
423410

424411
before := time.Now()
425-
c, err := s1.DialPeer(ctx, s2.LocalPeer())
426-
if err == nil {
427-
defer c.Close()
428-
t.Fatal("dialing to broken addr worked...", err)
429-
} else {
430-
t.Log("correctly got error:", err)
431-
}
412+
_, err := s1.DialPeer(context.Background(), s2.LocalPeer())
413+
require.Error(t, err, "dialing to broken addr worked...")
432414
duration := time.Since(before)
433415

434416
if duration < dialTimeout*DialAttempts {
@@ -437,46 +419,24 @@ func TestDialBackoffClears(t *testing.T) {
437419
if duration > 2*dialTimeout*DialAttempts {
438420
t.Error("> 2*dialTimeout * DialAttempts not being respected", duration, 2*dialTimeout*DialAttempts)
439421
}
440-
441-
if !s1.Backoff().Backoff(s2.LocalPeer(), s2bad) {
442-
t.Error("s2 should now be on backoff")
443-
} else {
444-
t.Log("correctly added to backoff")
445-
}
422+
require.True(t, s1.Backoff().Backoff(s2.LocalPeer(), s2bad), "s2 should now be on backoff")
446423

447424
// phase 2 -- add the working address. dial should succeed.
448-
ifaceAddrs1, err := swarms[1].InterfaceListenAddresses()
449-
if err != nil {
450-
t.Fatal(err)
451-
}
425+
ifaceAddrs1, err := s2.InterfaceListenAddresses()
426+
require.NoError(t, err)
452427
s1.Peerstore().AddAddrs(s2.LocalPeer(), ifaceAddrs1, peerstore.PermanentAddrTTL)
453428

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

475436
func TestDialPeerFailed(t *testing.T) {
476437
t.Parallel()
477-
ctx := context.Background()
478438

479-
swarms := makeSwarms(t, 2)
439+
swarms := makeSwarms(t, 2, swarmt.DialTimeout(250*time.Millisecond))
480440
defer closeSwarms(swarms)
481441
testedSwarm, targetSwarm := swarms[0], swarms[1]
482442

@@ -492,10 +452,8 @@ func TestDialPeerFailed(t *testing.T) {
492452
peerstore.PermanentAddrTTL)
493453
}
494454

495-
_, err := testedSwarm.DialPeer(ctx, targetSwarm.LocalPeer())
496-
if err == nil {
497-
t.Fatal(err)
498-
}
455+
_, err := testedSwarm.DialPeer(context.Background(), targetSwarm.LocalPeer())
456+
require.NoError(t, err)
499457

500458
// dial_test.go:508: correctly get a combined error: failed to dial PEER: all dials failed
501459
// * [/ip4/127.0.0.1/tcp/46485] failed to negotiate security protocol: context deadline exceeded
@@ -513,28 +471,20 @@ func TestDialPeerFailed(t *testing.T) {
513471
}
514472

515473
func TestDialExistingConnection(t *testing.T) {
516-
ctx := context.Background()
517-
518474
swarms := makeSwarms(t, 2)
519475
defer closeSwarms(swarms)
520476
s1 := swarms[0]
521477
s2 := swarms[1]
522478

523479
s1.Peerstore().AddAddrs(s2.LocalPeer(), s2.ListenAddresses(), peerstore.PermanentAddrTTL)
524480

525-
c1, err := s1.DialPeer(ctx, s2.LocalPeer())
526-
if err != nil {
527-
t.Fatal(err)
528-
}
481+
c1, err := s1.DialPeer(context.Background(), s2.LocalPeer())
482+
require.NoError(t, err)
529483

530-
c2, err := s1.DialPeer(ctx, s2.LocalPeer())
531-
if err != nil {
532-
t.Fatal(err)
533-
}
484+
c2, err := s1.DialPeer(context.Background(), s2.LocalPeer())
485+
require.NoError(t, err)
534486

535-
if c1 != c2 {
536-
t.Fatal("expecting the same connection from both dials")
537-
}
487+
require.Equal(t, c1, c2, "expecting the same connection from both dials")
538488
}
539489

540490
func newSilentListener(t *testing.T) ([]ma.Multiaddr, net.Listener) {
@@ -556,16 +506,12 @@ func newSilentListener(t *testing.T) ([]ma.Multiaddr, net.Listener) {
556506
}
557507

558508
func TestDialSimultaneousJoin(t *testing.T) {
559-
ctx, cancel := context.WithCancel(context.Background())
560-
defer cancel()
561-
562509
const dialTimeout = 250 * time.Millisecond
563510

564511
swarms := makeSwarms(t, 2, swarmt.DialTimeout(dialTimeout))
512+
defer closeSwarms(swarms)
565513
s1 := swarms[0]
566514
s2 := swarms[1]
567-
defer s1.Close()
568-
defer s2.Close()
569515

570516
s2silentAddrs, s2silentListener := newSilentListener(t)
571517
go acceptAndHang(s2silentListener)
@@ -577,7 +523,7 @@ func TestDialSimultaneousJoin(t *testing.T) {
577523
go func() {
578524
s1.Peerstore().AddAddrs(s2.LocalPeer(), s2silentAddrs, peerstore.PermanentAddrTTL)
579525

580-
c, err := s1.DialPeer(ctx, s2.LocalPeer())
526+
c, err := s1.DialPeer(context.Background(), s2.LocalPeer())
581527
if err != nil {
582528
errs <- err
583529
connch <- nil
@@ -602,7 +548,7 @@ func TestDialSimultaneousJoin(t *testing.T) {
602548
}
603549
s1.Peerstore().AddAddrs(s2.LocalPeer(), s2addrs[:1], peerstore.PermanentAddrTTL)
604550

605-
c, err := s1.DialPeer(ctx, s2.LocalPeer())
551+
c, err := s1.DialPeer(context.Background(), s2.LocalPeer())
606552
if err != nil {
607553
errs <- err
608554
connch <- nil
@@ -620,7 +566,7 @@ func TestDialSimultaneousJoin(t *testing.T) {
620566

621567
// start a third dial to s2, this should get the existing connection from the successful dial
622568
go func() {
623-
c, err := s1.DialPeer(ctx, s2.LocalPeer())
569+
c, err := s1.DialPeer(context.Background(), s2.LocalPeer())
624570
if err != nil {
625571
errs <- err
626572
connch <- nil
@@ -637,10 +583,7 @@ func TestDialSimultaneousJoin(t *testing.T) {
637583

638584
// raise any errors from the previous goroutines
639585
for i := 0; i < 3; i++ {
640-
err := <-errs
641-
if err != nil {
642-
t.Fatal(err)
643-
}
586+
require.NoError(t, <-errs)
644587
}
645588

646589
if c2 != c3 {
@@ -660,13 +603,12 @@ func TestDialSimultaneousJoin(t *testing.T) {
660603
}
661604

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

666608
swarms := makeSwarms(t, 2)
609+
defer closeSwarms(swarms)
667610
s1 := swarms[0]
668-
defer s1.Close()
669611

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

‎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)