16 "github.com/anacrolix/dht"
17 _ "github.com/anacrolix/envpprof"
18 "github.com/anacrolix/missinggo"
19 "github.com/anacrolix/missinggo/filecache"
20 "github.com/bradfitz/iter"
21 "github.com/stretchr/testify/assert"
22 "github.com/stretchr/testify/require"
23 "golang.org/x/time/rate"
25 "github.com/anacrolix/torrent/bencode"
26 "github.com/anacrolix/torrent/internal/testutil"
27 "github.com/anacrolix/torrent/iplist"
28 "github.com/anacrolix/torrent/metainfo"
29 "github.com/anacrolix/torrent/storage"
32 func TestingConfig() *Config {
34 ListenHost: LoopbackListenHost,
37 DisableTrackers: true,
38 NoDefaultPortForwarding: true,
43 func TestClientDefault(t *testing.T) {
44 cl, err := NewClient(TestingConfig())
45 require.NoError(t, err)
49 func TestClientNilConfig(t *testing.T) {
50 cl, err := NewClient(nil)
51 require.NoError(t, err)
55 func TestBoltPieceCompletionClosedWhenClientClosed(t *testing.T) {
56 cfg := TestingConfig()
57 pc, err := storage.NewBoltPieceCompletion(cfg.DataDir)
58 require.NoError(t, err)
59 ci := storage.NewFileWithCompletion(cfg.DataDir, pc)
61 cfg.DefaultStorage = ci
62 cl, err := NewClient(cfg)
63 require.NoError(t, err)
65 // And again, https://github.com/anacrolix/torrent/issues/158
66 cl, err = NewClient(cfg)
67 require.NoError(t, err)
71 func TestAddDropTorrent(t *testing.T) {
72 cl, err := NewClient(TestingConfig())
73 require.NoError(t, err)
75 dir, mi := testutil.GreetingTestTorrent()
76 defer os.RemoveAll(dir)
77 tt, new, err := cl.AddTorrentSpec(TorrentSpecFromMetaInfo(mi))
78 require.NoError(t, err)
80 tt.SetMaxEstablishedConns(0)
81 tt.SetMaxEstablishedConns(1)
85 func TestAddTorrentNoSupportedTrackerSchemes(t *testing.T) {
90 func TestAddTorrentNoUsableURLs(t *testing.T) {
95 func TestAddPeersToUnknownTorrent(t *testing.T) {
100 func TestPieceHashSize(t *testing.T) {
101 assert.Equal(t, 20, pieceHash.Size())
104 func TestTorrentInitialState(t *testing.T) {
105 dir, mi := testutil.GreetingTestTorrent()
106 defer os.RemoveAll(dir)
109 tor := cl.newTorrent(
111 storage.NewFileWithCompletion(tempDir(), storage.NewMapPieceCompletion()),
115 err := tor.setInfoBytes(mi.InfoBytes)
117 require.NoError(t, err)
118 require.Len(t, tor.pieces, 3)
119 tor.pendAllChunkSpecs(0)
121 assert.EqualValues(t, 3, tor.pieceNumPendingChunks(0))
123 assert.EqualValues(t, chunkSpec{4, 1}, chunkIndexSpec(2, tor.pieceLength(0), tor.chunkSize))
126 func TestUnmarshalPEXMsg(t *testing.T) {
127 var m peerExchangeMessage
128 if err := bencode.Unmarshal([]byte("d5:added12:\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0ce"), &m); err != nil {
131 if len(m.Added) != 2 {
134 if m.Added[0].Port != 0x506 {
139 func TestReducedDialTimeout(t *testing.T) {
142 for _, _case := range []struct {
146 ExpectedReduced time.Duration
148 {cfg.NominalDialTimeout, 40, 0, cfg.NominalDialTimeout},
149 {cfg.NominalDialTimeout, 40, 1, cfg.NominalDialTimeout},
150 {cfg.NominalDialTimeout, 40, 39, cfg.NominalDialTimeout},
151 {cfg.NominalDialTimeout, 40, 40, cfg.NominalDialTimeout / 2},
152 {cfg.NominalDialTimeout, 40, 80, cfg.NominalDialTimeout / 3},
153 {cfg.NominalDialTimeout, 40, 4000, cfg.NominalDialTimeout / 101},
155 reduced := reducedDialTimeout(cfg.MinDialTimeout, _case.Max, _case.HalfOpenLimit, _case.PendingPeers)
156 expected := _case.ExpectedReduced
157 if expected < cfg.MinDialTimeout {
158 expected = cfg.MinDialTimeout
160 if reduced != expected {
161 t.Fatalf("expected %s, got %s", _case.ExpectedReduced, reduced)
166 func TestUTPRawConn(t *testing.T) {
167 l, err := NewUtpSocket("udp", "")
168 require.NoError(t, err)
178 // Connect a UTP peer to see if the RawConn will still work.
179 s, err := NewUtpSocket("udp", "")
180 require.NoError(t, err)
182 utpPeer, err := s.DialContext(context.Background(), "", fmt.Sprintf("localhost:%d", missinggo.AddrPort(l.Addr())))
183 require.NoError(t, err)
184 defer utpPeer.Close()
185 peer, err := net.ListenPacket("udp", ":0")
186 require.NoError(t, err)
190 // How many messages to send. I've set this to double the channel buffer
191 // size in the raw packetConn.
193 readerStopped := make(chan struct{})
194 // The reader goroutine.
196 defer close(readerStopped)
197 b := make([]byte, 500)
198 for i := 0; i < N; i++ {
199 n, _, err := l.ReadFrom(b)
200 require.NoError(t, err)
203 fmt.Sscan(string(b[:n]), &d)
204 assert.Equal(t, i, d)
207 udpAddr, err := net.ResolveUDPAddr("udp", fmt.Sprintf("localhost:%d", missinggo.AddrPort(l.Addr())))
208 require.NoError(t, err)
209 for i := 0; i < N; i++ {
210 _, err := peer.WriteTo([]byte(fmt.Sprintf("%d", i)), udpAddr)
211 require.NoError(t, err)
212 time.Sleep(time.Millisecond)
215 case <-readerStopped:
216 case <-time.After(time.Second):
217 t.Fatal("reader timed out")
219 if msgsReceived != N {
220 t.Fatalf("messages received: %d", msgsReceived)
224 func TestAddDropManyTorrents(t *testing.T) {
225 cl, err := NewClient(TestingConfig())
226 require.NoError(t, err)
228 for i := range iter.N(1000) {
230 binary.PutVarint(spec.InfoHash[:], int64(i))
231 tt, new, err := cl.AddTorrentSpec(&spec)
232 assert.NoError(t, err)
238 type FileCacheClientStorageFactoryParams struct {
241 Wrapper func(*filecache.Cache) storage.ClientImpl
244 func NewFileCacheClientStorageFactory(ps FileCacheClientStorageFactoryParams) storageFactory {
245 return func(dataDir string) storage.ClientImpl {
246 fc, err := filecache.NewCache(dataDir)
251 fc.SetCapacity(ps.Capacity)
253 return ps.Wrapper(fc)
257 type storageFactory func(string) storage.ClientImpl
259 func TestClientTransferDefault(t *testing.T) {
260 testClientTransfer(t, testClientTransferParams{
261 ExportClientStatus: true,
262 LeecherStorage: NewFileCacheClientStorageFactory(FileCacheClientStorageFactoryParams{
263 Wrapper: fileCachePieceResourceStorage,
268 func TestClientTransferRateLimitedUpload(t *testing.T) {
269 started := time.Now()
270 testClientTransfer(t, testClientTransferParams{
271 // We are uploading 13 bytes (the length of the greeting torrent). The
272 // chunks are 2 bytes in length. Then the smallest burst we can run
273 // with is 2. Time taken is (13-burst)/rate.
274 SeederUploadRateLimiter: rate.NewLimiter(11, 2),
275 ExportClientStatus: true,
277 require.True(t, time.Since(started) > time.Second)
280 func TestClientTransferRateLimitedDownload(t *testing.T) {
281 testClientTransfer(t, testClientTransferParams{
282 LeecherDownloadRateLimiter: rate.NewLimiter(512, 512),
286 func fileCachePieceResourceStorage(fc *filecache.Cache) storage.ClientImpl {
287 return storage.NewResourcePieces(fc.AsResourceProvider())
290 func TestClientTransferSmallCache(t *testing.T) {
291 testClientTransfer(t, testClientTransferParams{
292 LeecherStorage: NewFileCacheClientStorageFactory(FileCacheClientStorageFactoryParams{
294 // Going below the piece length means it can't complete a piece so
295 // that it can be hashed.
297 Wrapper: fileCachePieceResourceStorage,
300 // Can't readahead too far or the cache will thrash and drop data we
303 ExportClientStatus: true,
307 func TestClientTransferVarious(t *testing.T) {
309 for _, ls := range []storageFactory{
310 NewFileCacheClientStorageFactory(FileCacheClientStorageFactoryParams{
311 Wrapper: fileCachePieceResourceStorage,
316 for _, ss := range []func(string) storage.ClientImpl{
320 for _, responsive := range []bool{false, true} {
321 testClientTransfer(t, testClientTransferParams{
322 Responsive: responsive,
326 for _, readahead := range []int64{-1, 0, 1, 2, 3, 4, 5, 6, 9, 10, 11, 12, 13, 14, 15, 20} {
327 testClientTransfer(t, testClientTransferParams{
329 Responsive: responsive,
331 Readahead: readahead,
340 type testClientTransferParams struct {
344 ExportClientStatus bool
345 LeecherStorage func(string) storage.ClientImpl
346 SeederStorage func(string) storage.ClientImpl
347 SeederUploadRateLimiter *rate.Limiter
348 LeecherDownloadRateLimiter *rate.Limiter
351 // Creates a seeder and a leecher, and ensures the data transfers when a read
352 // is attempted on the leecher.
353 func testClientTransfer(t *testing.T, ps testClientTransferParams) {
354 greetingTempDir, mi := testutil.GreetingTestTorrent()
355 defer os.RemoveAll(greetingTempDir)
356 // Create seeder and a Torrent.
357 cfg := TestingConfig()
359 cfg.UploadRateLimiter = ps.SeederUploadRateLimiter
360 // cfg.ListenAddr = "localhost:4000"
361 if ps.SeederStorage != nil {
362 cfg.DefaultStorage = ps.SeederStorage(greetingTempDir)
363 defer cfg.DefaultStorage.Close()
365 cfg.DataDir = greetingTempDir
367 seeder, err := NewClient(cfg)
368 require.NoError(t, err)
369 if ps.ExportClientStatus {
370 testutil.ExportStatusWriter(seeder, "s")
372 seederTorrent, _, _ := seeder.AddTorrentSpec(TorrentSpecFromMetaInfo(mi))
373 // Run a Stats right after Closing the Client. This will trigger the Stats
374 // panic in #214 caused by RemoteAddr on Closed uTP sockets.
375 defer seederTorrent.Stats()
377 seederTorrent.VerifyData()
378 // Create leecher and a Torrent.
379 leecherDataDir, err := ioutil.TempDir("", "")
380 require.NoError(t, err)
381 defer os.RemoveAll(leecherDataDir)
382 if ps.LeecherStorage == nil {
383 cfg.DataDir = leecherDataDir
385 cfg.DefaultStorage = ps.LeecherStorage(leecherDataDir)
387 cfg.DownloadRateLimiter = ps.LeecherDownloadRateLimiter
389 leecher, err := NewClient(cfg)
390 require.NoError(t, err)
391 defer leecher.Close()
392 if ps.ExportClientStatus {
393 testutil.ExportStatusWriter(leecher, "l")
395 leecherTorrent, new, err := leecher.AddTorrentSpec(func() (ret *TorrentSpec) {
396 ret = TorrentSpecFromMetaInfo(mi)
400 require.NoError(t, err)
402 // Now do some things with leecher and seeder.
403 leecherTorrent.AddClientPeer(seeder)
404 // The Torrent should not be interested in obtaining peers, so the one we
405 // just added should be the only one.
406 assert.False(t, leecherTorrent.Seeding())
407 assert.EqualValues(t, 1, leecherTorrent.Stats().PendingPeers)
408 r := leecherTorrent.NewReader()
414 r.SetReadahead(ps.Readahead)
416 assertReadAllGreeting(t, r)
417 assert.True(t, 13 <= seederTorrent.Stats().BytesWrittenData)
418 assert.True(t, 8 <= seederTorrent.Stats().ChunksWritten)
419 assert.True(t, 13 <= leecherTorrent.Stats().BytesReadData)
420 assert.True(t, 8 <= leecherTorrent.Stats().ChunksRead)
421 // Try reading through again for the cases where the torrent data size
422 // exceeds the size of the cache.
423 assertReadAllGreeting(t, r)
426 func assertReadAllGreeting(t *testing.T, r io.ReadSeeker) {
427 pos, err := r.Seek(0, io.SeekStart)
428 assert.NoError(t, err)
429 assert.EqualValues(t, 0, pos)
430 _greeting, err := ioutil.ReadAll(r)
431 assert.NoError(t, err)
432 assert.EqualValues(t, testutil.GreetingFileContents, _greeting)
435 // Check that after completing leeching, a leecher transitions to a seeding
436 // correctly. Connected in a chain like so: Seeder <-> Leecher <-> LeecherLeecher.
437 func TestSeedAfterDownloading(t *testing.T) {
438 greetingTempDir, mi := testutil.GreetingTestTorrent()
439 defer os.RemoveAll(greetingTempDir)
440 cfg := TestingConfig()
442 cfg.DataDir = greetingTempDir
443 seeder, err := NewClient(cfg)
444 require.NoError(t, err)
446 testutil.ExportStatusWriter(seeder, "s")
447 seederTorrent, _, _ := seeder.AddTorrentSpec(TorrentSpecFromMetaInfo(mi))
448 seederTorrent.VerifyData()
449 cfg.DataDir, err = ioutil.TempDir("", "")
450 require.NoError(t, err)
451 defer os.RemoveAll(cfg.DataDir)
452 leecher, err := NewClient(cfg)
453 require.NoError(t, err)
454 defer leecher.Close()
455 testutil.ExportStatusWriter(leecher, "l")
457 cfg.DataDir, err = ioutil.TempDir("", "")
458 require.NoError(t, err)
459 defer os.RemoveAll(cfg.DataDir)
460 leecherLeecher, _ := NewClient(cfg)
461 require.NoError(t, err)
462 defer leecherLeecher.Close()
463 testutil.ExportStatusWriter(leecherLeecher, "ll")
464 leecherGreeting, _, _ := leecher.AddTorrentSpec(func() (ret *TorrentSpec) {
465 ret = TorrentSpecFromMetaInfo(mi)
469 llg, _, _ := leecherLeecher.AddTorrentSpec(func() (ret *TorrentSpec) {
470 ret = TorrentSpecFromMetaInfo(mi)
474 // Simultaneously DownloadAll in Leecher, and read the contents
475 // consecutively in LeecherLeecher. This non-deterministically triggered a
476 // case where the leecher wouldn't unchoke the LeecherLeecher.
477 var wg sync.WaitGroup
483 b, err := ioutil.ReadAll(r)
484 require.NoError(t, err)
485 assert.EqualValues(t, testutil.GreetingFileContents, b)
487 leecherGreeting.AddClientPeer(seeder)
488 leecherGreeting.AddClientPeer(leecherLeecher)
492 leecherGreeting.DownloadAll()
498 func TestMergingTrackersByAddingSpecs(t *testing.T) {
499 cl, err := NewClient(TestingConfig())
500 require.NoError(t, err)
502 spec := TorrentSpec{}
503 T, new, _ := cl.AddTorrentSpec(&spec)
507 spec.Trackers = [][]string{{"http://a"}, {"udp://b"}}
508 _, new, _ = cl.AddTorrentSpec(&spec)
510 assert.EqualValues(t, [][]string{{"http://a"}, {"udp://b"}}, T.metainfo.AnnounceList)
511 // Because trackers are disabled in TestingConfig.
512 assert.EqualValues(t, 0, len(T.trackerAnnouncers))
515 // We read from a piece which is marked completed, but is missing data.
516 func TestCompletedPieceWrongSize(t *testing.T) {
517 cfg := TestingConfig()
518 cfg.DefaultStorage = badStorage{}
519 cl, err := NewClient(cfg)
520 require.NoError(t, err)
522 info := metainfo.Info{
524 Pieces: make([]byte, 20),
525 Files: []metainfo.FileInfo{
526 {Path: []string{"greeting"}, Length: 13},
529 b, err := bencode.Marshal(info)
530 require.NoError(t, err)
531 tt, new, err := cl.AddTorrentSpec(&TorrentSpec{
533 InfoHash: metainfo.HashBytes(b),
535 require.NoError(t, err)
540 b, err = ioutil.ReadAll(r)
542 assert.NoError(t, err)
545 func BenchmarkAddLargeTorrent(b *testing.B) {
546 cfg := TestingConfig()
547 cfg.DisableTCP = true
548 cfg.DisableUTP = true
549 cfg.ListenHost = func(string) string { return "redonk" }
550 cl, err := NewClient(cfg)
551 require.NoError(b, err)
553 for range iter.N(b.N) {
554 t, err := cl.AddTorrentFromFile("testdata/bootstrap.dat.torrent")
562 func TestResponsive(t *testing.T) {
563 seederDataDir, mi := testutil.GreetingTestTorrent()
564 defer os.RemoveAll(seederDataDir)
565 cfg := TestingConfig()
567 cfg.DataDir = seederDataDir
568 seeder, err := NewClient(cfg)
571 seederTorrent, _, _ := seeder.AddTorrentSpec(TorrentSpecFromMetaInfo(mi))
572 seederTorrent.VerifyData()
573 leecherDataDir, err := ioutil.TempDir("", "")
575 defer os.RemoveAll(leecherDataDir)
576 cfg = TestingConfig()
577 cfg.DataDir = leecherDataDir
578 leecher, err := NewClient(cfg)
580 defer leecher.Close()
581 leecherTorrent, _, _ := leecher.AddTorrentSpec(func() (ret *TorrentSpec) {
582 ret = TorrentSpecFromMetaInfo(mi)
586 leecherTorrent.AddClientPeer(seeder)
587 reader := leecherTorrent.NewReader()
589 reader.SetReadahead(0)
590 reader.SetResponsive()
592 _, err = reader.Seek(3, io.SeekStart)
593 require.NoError(t, err)
594 _, err = io.ReadFull(reader, b)
596 assert.EqualValues(t, "lo", string(b))
597 _, err = reader.Seek(11, io.SeekStart)
598 require.NoError(t, err)
599 n, err := io.ReadFull(reader, b)
601 assert.EqualValues(t, 2, n)
602 assert.EqualValues(t, "d\n", string(b))
605 func TestTorrentDroppedDuringResponsiveRead(t *testing.T) {
606 seederDataDir, mi := testutil.GreetingTestTorrent()
607 defer os.RemoveAll(seederDataDir)
608 cfg := TestingConfig()
610 cfg.DataDir = seederDataDir
611 seeder, err := NewClient(cfg)
614 seederTorrent, _, _ := seeder.AddTorrentSpec(TorrentSpecFromMetaInfo(mi))
615 seederTorrent.VerifyData()
616 leecherDataDir, err := ioutil.TempDir("", "")
618 defer os.RemoveAll(leecherDataDir)
619 cfg = TestingConfig()
620 cfg.DataDir = leecherDataDir
621 leecher, err := NewClient(cfg)
623 defer leecher.Close()
624 leecherTorrent, _, _ := leecher.AddTorrentSpec(func() (ret *TorrentSpec) {
625 ret = TorrentSpecFromMetaInfo(mi)
629 leecherTorrent.AddClientPeer(seeder)
630 reader := leecherTorrent.NewReader()
632 reader.SetReadahead(0)
633 reader.SetResponsive()
635 _, err = reader.Seek(3, io.SeekStart)
636 require.NoError(t, err)
637 _, err = io.ReadFull(reader, b)
639 assert.EqualValues(t, "lo", string(b))
640 go leecherTorrent.Drop()
641 _, err = reader.Seek(11, io.SeekStart)
642 require.NoError(t, err)
643 n, err := reader.Read(b)
644 assert.EqualError(t, err, "torrent closed")
645 assert.EqualValues(t, 0, n)
648 func TestDHTInheritBlocklist(t *testing.T) {
649 ipl := iplist.New(nil)
650 require.NotNil(t, ipl)
651 cfg := TestingConfig()
652 cfg.IPBlocklist = ipl
654 cl, err := NewClient(cfg)
655 require.NoError(t, err)
658 cl.eachDhtServer(func(s *dht.Server) {
659 assert.Equal(t, ipl, s.IPBlocklist())
662 assert.EqualValues(t, 2, numServers)
665 // Check that stuff is merged in subsequent AddTorrentSpec for the same
667 func TestAddTorrentSpecMerging(t *testing.T) {
668 cl, err := NewClient(TestingConfig())
669 require.NoError(t, err)
671 dir, mi := testutil.GreetingTestTorrent()
672 defer os.RemoveAll(dir)
673 tt, new, err := cl.AddTorrentSpec(&TorrentSpec{
674 InfoHash: mi.HashInfoBytes(),
676 require.NoError(t, err)
678 require.Nil(t, tt.Info())
679 _, new, err = cl.AddTorrentSpec(TorrentSpecFromMetaInfo(mi))
680 require.NoError(t, err)
681 require.False(t, new)
682 require.NotNil(t, tt.Info())
685 func TestTorrentDroppedBeforeGotInfo(t *testing.T) {
686 dir, mi := testutil.GreetingTestTorrent()
688 cl, _ := NewClient(TestingConfig())
690 tt, _, _ := cl.AddTorrentSpec(&TorrentSpec{
691 InfoHash: mi.HashInfoBytes(),
694 assert.EqualValues(t, 0, len(cl.Torrents()))
702 func writeTorrentData(ts *storage.Torrent, info metainfo.Info, b []byte) {
703 for i := range iter.N(info.NumPieces()) {
705 ts.Piece(p).WriteAt(b[p.Offset():p.Offset()+p.Length()], 0)
709 func testAddTorrentPriorPieceCompletion(t *testing.T, alreadyCompleted bool, csf func(*filecache.Cache) storage.ClientImpl) {
710 fileCacheDir, err := ioutil.TempDir("", "")
711 require.NoError(t, err)
712 defer os.RemoveAll(fileCacheDir)
713 fileCache, err := filecache.NewCache(fileCacheDir)
714 require.NoError(t, err)
715 greetingDataTempDir, greetingMetainfo := testutil.GreetingTestTorrent()
716 defer os.RemoveAll(greetingDataTempDir)
717 filePieceStore := csf(fileCache)
718 defer filePieceStore.Close()
719 info, err := greetingMetainfo.UnmarshalInfo()
720 require.NoError(t, err)
721 ih := greetingMetainfo.HashInfoBytes()
722 greetingData, err := storage.NewClient(filePieceStore).OpenTorrent(&info, ih)
723 require.NoError(t, err)
724 writeTorrentData(greetingData, info, []byte(testutil.GreetingFileContents))
725 // require.Equal(t, len(testutil.GreetingFileContents), written)
726 // require.NoError(t, err)
727 for i := 0; i < info.NumPieces(); i++ {
729 if alreadyCompleted {
730 require.NoError(t, greetingData.Piece(p).MarkComplete())
733 cfg := TestingConfig()
734 // TODO: Disable network option?
735 cfg.DisableTCP = true
736 cfg.DisableUTP = true
737 cfg.DefaultStorage = filePieceStore
738 cl, err := NewClient(cfg)
739 require.NoError(t, err)
741 tt, err := cl.AddTorrent(greetingMetainfo)
742 require.NoError(t, err)
743 psrs := tt.PieceStateRuns()
744 assert.Len(t, psrs, 1)
745 assert.EqualValues(t, 3, psrs[0].Length)
746 assert.Equal(t, alreadyCompleted, psrs[0].Complete)
747 if alreadyCompleted {
749 b, err := ioutil.ReadAll(r)
750 assert.NoError(t, err)
751 assert.EqualValues(t, testutil.GreetingFileContents, b)
755 func TestAddTorrentPiecesAlreadyCompleted(t *testing.T) {
756 testAddTorrentPriorPieceCompletion(t, true, fileCachePieceResourceStorage)
759 func TestAddTorrentPiecesNotAlreadyCompleted(t *testing.T) {
760 testAddTorrentPriorPieceCompletion(t, false, fileCachePieceResourceStorage)
763 func TestAddMetainfoWithNodes(t *testing.T) {
764 cfg := TestingConfig()
765 cfg.ListenHost = func(string) string { return "" }
767 cfg.DhtStartingNodes = func() ([]dht.Addr, error) { return nil, nil }
768 // For now, we want to just jam the nodes into the table, without
769 // verifying them first. Also the DHT code doesn't support mixing secure
770 // and insecure nodes if security is enabled (yet).
771 // cfg.DHTConfig.NoSecurity = true
772 cl, err := NewClient(cfg)
773 require.NoError(t, err)
775 sum := func() (ret int64) {
776 cl.eachDhtServer(func(s *dht.Server) {
777 ret += s.Stats().OutboundQueriesAttempted
781 assert.EqualValues(t, 0, sum())
782 tt, err := cl.AddTorrentFromFile("metainfo/testdata/issue_65a.torrent")
783 require.NoError(t, err)
784 // Nodes are not added or exposed in Torrent's metainfo. We just randomly
785 // check if the announce-list is here instead. TODO: Add nodes.
786 assert.Len(t, tt.metainfo.AnnounceList, 5)
787 // There are 6 nodes in the torrent file.
788 assert.EqualValues(t, 6*len(cl.dhtServers), sum())
791 type testDownloadCancelParams struct {
792 ExportClientStatus bool
793 SetLeecherStorageCapacity bool
794 LeecherStorageCapacity int64
798 func testDownloadCancel(t *testing.T, ps testDownloadCancelParams) {
799 greetingTempDir, mi := testutil.GreetingTestTorrent()
800 defer os.RemoveAll(greetingTempDir)
801 cfg := TestingConfig()
803 cfg.DataDir = greetingTempDir
804 seeder, err := NewClient(cfg)
805 require.NoError(t, err)
807 if ps.ExportClientStatus {
808 testutil.ExportStatusWriter(seeder, "s")
810 seederTorrent, _, _ := seeder.AddTorrentSpec(TorrentSpecFromMetaInfo(mi))
811 seederTorrent.VerifyData()
812 leecherDataDir, err := ioutil.TempDir("", "")
813 require.NoError(t, err)
814 defer os.RemoveAll(leecherDataDir)
815 fc, err := filecache.NewCache(leecherDataDir)
816 require.NoError(t, err)
817 if ps.SetLeecherStorageCapacity {
818 fc.SetCapacity(ps.LeecherStorageCapacity)
820 cfg.DefaultStorage = storage.NewResourcePieces(fc.AsResourceProvider())
821 cfg.DataDir = leecherDataDir
822 leecher, _ := NewClient(cfg)
823 defer leecher.Close()
824 if ps.ExportClientStatus {
825 testutil.ExportStatusWriter(leecher, "l")
827 leecherGreeting, new, err := leecher.AddTorrentSpec(func() (ret *TorrentSpec) {
828 ret = TorrentSpecFromMetaInfo(mi)
832 require.NoError(t, err)
834 psc := leecherGreeting.SubscribePieceStateChanges()
837 leecherGreeting.cl.mu.Lock()
838 leecherGreeting.downloadPiecesLocked(0, leecherGreeting.numPieces())
840 leecherGreeting.cancelPiecesLocked(0, leecherGreeting.NumPieces())
842 leecherGreeting.cl.mu.Unlock()
844 leecherGreeting.AddClientPeer(seeder)
845 completes := make(map[int]bool, 3)
848 // started := time.Now()
850 case _v := <-psc.Values:
851 // log.Print(time.Since(started))
852 v := _v.(PieceStateChange)
853 completes[v.Index] = v.Complete
854 case <-time.After(100 * time.Millisecond):
859 assert.EqualValues(t, map[int]bool{0: false, 1: false, 2: false}, completes)
861 assert.EqualValues(t, map[int]bool{0: true, 1: true, 2: true}, completes)
866 func TestTorrentDownloadAll(t *testing.T) {
867 testDownloadCancel(t, testDownloadCancelParams{})
870 func TestTorrentDownloadAllThenCancel(t *testing.T) {
871 testDownloadCancel(t, testDownloadCancelParams{
876 // Ensure that it's an error for a peer to send an invalid have message.
877 func TestPeerInvalidHave(t *testing.T) {
878 cl, err := NewClient(TestingConfig())
879 require.NoError(t, err)
881 info := metainfo.Info{
883 Pieces: make([]byte, 20),
884 Files: []metainfo.FileInfo{{Length: 1}},
886 infoBytes, err := bencode.Marshal(info)
887 require.NoError(t, err)
888 tt, _new, err := cl.AddTorrentSpec(&TorrentSpec{
889 InfoBytes: infoBytes,
890 InfoHash: metainfo.HashBytes(infoBytes),
891 Storage: badStorage{},
893 require.NoError(t, err)
899 assert.NoError(t, cn.peerSentHave(0))
900 assert.Error(t, cn.peerSentHave(1))
903 func TestPieceCompletedInStorageButNotClient(t *testing.T) {
904 greetingTempDir, greetingMetainfo := testutil.GreetingTestTorrent()
905 defer os.RemoveAll(greetingTempDir)
906 cfg := TestingConfig()
907 cfg.DataDir = greetingTempDir
908 seeder, err := NewClient(TestingConfig())
909 require.NoError(t, err)
910 seeder.AddTorrentSpec(&TorrentSpec{
911 InfoBytes: greetingMetainfo.InfoBytes,
915 // Check that when the listen port is 0, all the protocols listened on have
916 // the same port, and it isn't zero.
917 func TestClientDynamicListenPortAllProtocols(t *testing.T) {
918 cl, err := NewClient(TestingConfig())
919 require.NoError(t, err)
921 port := cl.LocalPort()
922 assert.NotEqual(t, 0, port)
923 cl.eachListener(func(s socket) bool {
924 assert.Equal(t, port, missinggo.AddrPort(s.Addr()))
929 func TestClientDynamicListenTCPOnly(t *testing.T) {
930 cfg := TestingConfig()
931 cfg.DisableUTP = true
932 cl, err := NewClient(cfg)
933 require.NoError(t, err)
935 assert.NotEqual(t, 0, cl.LocalPort())
936 cl.eachListener(func(s socket) bool {
937 assert.True(t, isTcpNetwork(s.Addr().Network()))
942 func TestClientDynamicListenUTPOnly(t *testing.T) {
943 cfg := TestingConfig()
944 cfg.DisableTCP = true
945 cl, err := NewClient(cfg)
946 require.NoError(t, err)
948 assert.NotEqual(t, 0, cl.LocalPort())
949 cl.eachListener(func(s socket) bool {
950 assert.True(t, isUtpNetwork(s.Addr().Network()))
955 func TestClientDynamicListenPortNoProtocols(t *testing.T) {
956 cfg := TestingConfig()
957 cfg.DisableTCP = true
958 cfg.DisableUTP = true
959 cl, err := NewClient(cfg)
960 require.NoError(t, err)
962 assert.Equal(t, 0, cl.LocalPort())
965 func totalConns(tts []*Torrent) (ret int) {
966 for _, tt := range tts {
974 func TestSetMaxEstablishedConn(t *testing.T) {
975 ss := testutil.NewStatusServer(t)
978 ih := testutil.GreetingMetaInfo().HashInfoBytes()
979 for i := range iter.N(3) {
980 cl, err := NewClient(TestingConfig())
981 require.NoError(t, err)
983 tt, _ := cl.AddTorrentInfoHash(ih)
984 tt.SetMaxEstablishedConns(2)
985 ss.HandleStatusWriter(cl, fmt.Sprintf("/%d", i))
986 tts = append(tts, tt)
989 for _, tt := range tts {
990 for _, _tt := range tts {
992 tt.AddClientPeer(_tt.cl)
997 waitTotalConns := func(num int) {
998 for totalConns(tts) != num {
1000 time.Sleep(time.Millisecond)
1005 tts[0].SetMaxEstablishedConns(1)
1007 tts[0].SetMaxEstablishedConns(0)
1009 tts[0].SetMaxEstablishedConns(1)
1012 tts[0].SetMaxEstablishedConns(2)
1017 func makeMagnet(t *testing.T, cl *Client, dir string, name string) string {
1018 os.MkdirAll(dir, 0770)
1019 file, err := os.Create(filepath.Join(dir, name))
1020 require.NoError(t, err)
1021 file.Write([]byte(name))
1023 mi := metainfo.MetaInfo{}
1025 info := metainfo.Info{PieceLength: 256 * 1024}
1026 err = info.BuildFromFilePath(filepath.Join(dir, name))
1027 require.NoError(t, err)
1028 mi.InfoBytes, err = bencode.Marshal(info)
1029 require.NoError(t, err)
1030 magnet := mi.Magnet(name, mi.HashInfoBytes()).String()
1031 tr, err := cl.AddTorrent(&mi)
1032 require.NoError(t, err)
1033 require.True(t, tr.Seeding())
1038 // https://github.com/anacrolix/torrent/issues/114
1039 func TestMultipleTorrentsWithEncryption(t *testing.T) {
1040 cfg := TestingConfig()
1041 cfg.DisableUTP = true
1043 cfg.DataDir = filepath.Join(cfg.DataDir, "server")
1044 cfg.ForceEncryption = true
1045 os.Mkdir(cfg.DataDir, 0755)
1046 server, err := NewClient(cfg)
1047 require.NoError(t, err)
1048 defer server.Close()
1049 testutil.ExportStatusWriter(server, "s")
1050 magnet1 := makeMagnet(t, server, cfg.DataDir, "test1")
1051 makeMagnet(t, server, cfg.DataDir, "test2")
1052 cfg = TestingConfig()
1053 cfg.DisableUTP = true
1054 cfg.DataDir = filepath.Join(cfg.DataDir, "client")
1055 cfg.ForceEncryption = true
1056 client, err := NewClient(cfg)
1057 require.NoError(t, err)
1058 defer client.Close()
1059 testutil.ExportStatusWriter(client, "c")
1060 tr, err := client.AddMagnet(magnet1)
1061 require.NoError(t, err)
1062 tr.AddClientPeer(server)
1068 func TestClientAddressInUse(t *testing.T) {
1069 s, _ := NewUtpSocket("udp", ":50007")
1073 cfg := TestingConfig().SetListenAddr(":50007")
1074 cl, err := NewClient(cfg)
1075 require.Error(t, err)