15 "github.com/anacrolix/dht"
16 _ "github.com/anacrolix/envpprof"
17 "github.com/anacrolix/missinggo"
18 "github.com/anacrolix/missinggo/filecache"
19 "github.com/anacrolix/torrent/bencode"
20 "github.com/anacrolix/torrent/internal/testutil"
21 "github.com/anacrolix/torrent/iplist"
22 "github.com/anacrolix/torrent/metainfo"
23 "github.com/anacrolix/torrent/storage"
24 "github.com/bradfitz/iter"
25 "github.com/stretchr/testify/assert"
26 "github.com/stretchr/testify/require"
27 "golang.org/x/time/rate"
30 func TestingConfig() *ClientConfig {
31 cfg := NewDefaultClientConfig()
32 cfg.ListenHost = LoopbackListenHost
34 cfg.DataDir = tempDir()
35 cfg.DisableTrackers = true
36 cfg.NoDefaultPortForwarding = true
37 cfg.DisableAcceptRateLimiting = true
41 func TestClientDefault(t *testing.T) {
42 cl, err := NewClient(TestingConfig())
43 require.NoError(t, err)
47 func TestClientNilConfig(t *testing.T) {
48 cl, err := NewClient(nil)
49 require.NoError(t, err)
53 func TestBoltPieceCompletionClosedWhenClientClosed(t *testing.T) {
54 cfg := TestingConfig()
55 pc, err := storage.NewBoltPieceCompletion(cfg.DataDir)
56 require.NoError(t, err)
57 ci := storage.NewFileWithCompletion(cfg.DataDir, pc)
59 cfg.DefaultStorage = ci
60 cl, err := NewClient(cfg)
61 require.NoError(t, err)
63 // And again, https://github.com/anacrolix/torrent/issues/158
64 cl, err = NewClient(cfg)
65 require.NoError(t, err)
69 func TestAddDropTorrent(t *testing.T) {
70 cl, err := NewClient(TestingConfig())
71 require.NoError(t, err)
73 dir, mi := testutil.GreetingTestTorrent()
74 defer os.RemoveAll(dir)
75 tt, new, err := cl.AddTorrentSpec(TorrentSpecFromMetaInfo(mi))
76 require.NoError(t, err)
78 tt.SetMaxEstablishedConns(0)
79 tt.SetMaxEstablishedConns(1)
83 func TestAddTorrentNoSupportedTrackerSchemes(t *testing.T) {
88 func TestAddTorrentNoUsableURLs(t *testing.T) {
93 func TestAddPeersToUnknownTorrent(t *testing.T) {
98 func TestPieceHashSize(t *testing.T) {
99 assert.Equal(t, 20, pieceHash.Size())
102 func TestTorrentInitialState(t *testing.T) {
103 dir, mi := testutil.GreetingTestTorrent()
104 defer os.RemoveAll(dir)
106 config: &ClientConfig{},
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 TestReducedDialTimeout(t *testing.T) {
127 cfg := NewDefaultClientConfig()
128 for _, _case := range []struct {
132 ExpectedReduced time.Duration
134 {cfg.NominalDialTimeout, 40, 0, cfg.NominalDialTimeout},
135 {cfg.NominalDialTimeout, 40, 1, cfg.NominalDialTimeout},
136 {cfg.NominalDialTimeout, 40, 39, cfg.NominalDialTimeout},
137 {cfg.NominalDialTimeout, 40, 40, cfg.NominalDialTimeout / 2},
138 {cfg.NominalDialTimeout, 40, 80, cfg.NominalDialTimeout / 3},
139 {cfg.NominalDialTimeout, 40, 4000, cfg.NominalDialTimeout / 101},
141 reduced := reducedDialTimeout(cfg.MinDialTimeout, _case.Max, _case.HalfOpenLimit, _case.PendingPeers)
142 expected := _case.ExpectedReduced
143 if expected < cfg.MinDialTimeout {
144 expected = cfg.MinDialTimeout
146 if reduced != expected {
147 t.Fatalf("expected %s, got %s", _case.ExpectedReduced, reduced)
152 func TestAddDropManyTorrents(t *testing.T) {
153 cl, err := NewClient(TestingConfig())
154 require.NoError(t, err)
156 for i := range iter.N(1000) {
158 binary.PutVarint(spec.InfoHash[:], int64(i))
159 tt, new, err := cl.AddTorrentSpec(&spec)
160 assert.NoError(t, err)
166 type FileCacheClientStorageFactoryParams struct {
169 Wrapper func(*filecache.Cache) storage.ClientImpl
172 func NewFileCacheClientStorageFactory(ps FileCacheClientStorageFactoryParams) storageFactory {
173 return func(dataDir string) storage.ClientImpl {
174 fc, err := filecache.NewCache(dataDir)
179 fc.SetCapacity(ps.Capacity)
181 return ps.Wrapper(fc)
185 type storageFactory func(string) storage.ClientImpl
187 func TestClientTransferDefault(t *testing.T) {
188 testClientTransfer(t, testClientTransferParams{
189 ExportClientStatus: true,
190 LeecherStorage: NewFileCacheClientStorageFactory(FileCacheClientStorageFactoryParams{
191 Wrapper: fileCachePieceResourceStorage,
196 func TestClientTransferRateLimitedUpload(t *testing.T) {
197 started := time.Now()
198 testClientTransfer(t, testClientTransferParams{
199 // We are uploading 13 bytes (the length of the greeting torrent). The
200 // chunks are 2 bytes in length. Then the smallest burst we can run
201 // with is 2. Time taken is (13-burst)/rate.
202 SeederUploadRateLimiter: rate.NewLimiter(11, 2),
203 ExportClientStatus: true,
205 require.True(t, time.Since(started) > time.Second)
208 func TestClientTransferRateLimitedDownload(t *testing.T) {
209 testClientTransfer(t, testClientTransferParams{
210 LeecherDownloadRateLimiter: rate.NewLimiter(512, 512),
214 func fileCachePieceResourceStorage(fc *filecache.Cache) storage.ClientImpl {
215 return storage.NewResourcePieces(fc.AsResourceProvider())
218 func TestClientTransferSmallCache(t *testing.T) {
219 testClientTransfer(t, testClientTransferParams{
220 LeecherStorage: NewFileCacheClientStorageFactory(FileCacheClientStorageFactoryParams{
222 // Going below the piece length means it can't complete a piece so
223 // that it can be hashed.
225 Wrapper: fileCachePieceResourceStorage,
228 // Can't readahead too far or the cache will thrash and drop data we
231 ExportClientStatus: true,
235 func TestClientTransferVarious(t *testing.T) {
237 for _, ls := range []storageFactory{
238 NewFileCacheClientStorageFactory(FileCacheClientStorageFactoryParams{
239 Wrapper: fileCachePieceResourceStorage,
244 for _, ss := range []func(string) storage.ClientImpl{
248 for _, responsive := range []bool{false, true} {
249 testClientTransfer(t, testClientTransferParams{
250 Responsive: responsive,
254 for _, readahead := range []int64{-1, 0, 1, 2, 3, 4, 5, 6, 9, 10, 11, 12, 13, 14, 15, 20} {
255 testClientTransfer(t, testClientTransferParams{
257 Responsive: responsive,
259 Readahead: readahead,
268 type testClientTransferParams struct {
272 ExportClientStatus bool
273 LeecherStorage func(string) storage.ClientImpl
274 SeederStorage func(string) storage.ClientImpl
275 SeederUploadRateLimiter *rate.Limiter
276 LeecherDownloadRateLimiter *rate.Limiter
279 // Creates a seeder and a leecher, and ensures the data transfers when a read
280 // is attempted on the leecher.
281 func testClientTransfer(t *testing.T, ps testClientTransferParams) {
282 greetingTempDir, mi := testutil.GreetingTestTorrent()
283 defer os.RemoveAll(greetingTempDir)
284 // Create seeder and a Torrent.
285 cfg := TestingConfig()
287 if ps.SeederUploadRateLimiter != nil {
288 cfg.UploadRateLimiter = ps.SeederUploadRateLimiter
290 // cfg.ListenAddr = "localhost:4000"
291 if ps.SeederStorage != nil {
292 cfg.DefaultStorage = ps.SeederStorage(greetingTempDir)
293 defer cfg.DefaultStorage.Close()
295 cfg.DataDir = greetingTempDir
297 seeder, err := NewClient(cfg)
298 require.NoError(t, err)
299 if ps.ExportClientStatus {
300 defer testutil.ExportStatusWriter(seeder, "s")()
302 seederTorrent, _, _ := seeder.AddTorrentSpec(TorrentSpecFromMetaInfo(mi))
303 // Run a Stats right after Closing the Client. This will trigger the Stats
304 // panic in #214 caused by RemoteAddr on Closed uTP sockets.
305 defer seederTorrent.Stats()
307 seederTorrent.VerifyData()
308 // Create leecher and a Torrent.
309 leecherDataDir, err := ioutil.TempDir("", "")
310 require.NoError(t, err)
311 defer os.RemoveAll(leecherDataDir)
312 cfg = TestingConfig()
313 if ps.LeecherStorage == nil {
314 cfg.DataDir = leecherDataDir
316 cfg.DefaultStorage = ps.LeecherStorage(leecherDataDir)
318 if ps.LeecherDownloadRateLimiter != nil {
319 cfg.DownloadRateLimiter = ps.LeecherDownloadRateLimiter
322 leecher, err := NewClient(cfg)
323 require.NoError(t, err)
324 defer leecher.Close()
325 if ps.ExportClientStatus {
326 defer testutil.ExportStatusWriter(leecher, "l")()
328 leecherTorrent, new, err := leecher.AddTorrentSpec(func() (ret *TorrentSpec) {
329 ret = TorrentSpecFromMetaInfo(mi)
333 require.NoError(t, err)
335 // Now do some things with leecher and seeder.
336 leecherTorrent.AddClientPeer(seeder)
337 // The Torrent should not be interested in obtaining peers, so the one we
338 // just added should be the only one.
339 assert.False(t, leecherTorrent.Seeding())
340 assert.EqualValues(t, 1, leecherTorrent.Stats().PendingPeers)
341 r := leecherTorrent.NewReader()
347 r.SetReadahead(ps.Readahead)
349 assertReadAllGreeting(t, r)
351 seederStats := seederTorrent.Stats()
352 assert.True(t, 13 <= seederStats.BytesWrittenData.Int64())
353 assert.True(t, 8 <= seederStats.ChunksWritten.Int64())
355 leecherStats := leecherTorrent.Stats()
356 assert.True(t, 13 <= leecherStats.BytesReadData.Int64())
357 assert.True(t, 8 <= leecherStats.ChunksRead.Int64())
359 // Try reading through again for the cases where the torrent data size
360 // exceeds the size of the cache.
361 assertReadAllGreeting(t, r)
364 func assertReadAllGreeting(t *testing.T, r io.ReadSeeker) {
365 pos, err := r.Seek(0, io.SeekStart)
366 assert.NoError(t, err)
367 assert.EqualValues(t, 0, pos)
368 _greeting, err := ioutil.ReadAll(r)
369 assert.NoError(t, err)
370 assert.EqualValues(t, testutil.GreetingFileContents, _greeting)
373 // Check that after completing leeching, a leecher transitions to a seeding
374 // correctly. Connected in a chain like so: Seeder <-> Leecher <-> LeecherLeecher.
375 func TestSeedAfterDownloading(t *testing.T) {
376 greetingTempDir, mi := testutil.GreetingTestTorrent()
377 defer os.RemoveAll(greetingTempDir)
379 cfg := TestingConfig()
381 cfg.DataDir = greetingTempDir
382 seeder, err := NewClient(cfg)
383 require.NoError(t, err)
385 defer testutil.ExportStatusWriter(seeder, "s")()
386 seederTorrent, ok, err := seeder.AddTorrentSpec(TorrentSpecFromMetaInfo(mi))
387 require.NoError(t, err)
389 seederTorrent.VerifyData()
391 cfg = TestingConfig()
393 cfg.DataDir, err = ioutil.TempDir("", "")
394 require.NoError(t, err)
395 defer os.RemoveAll(cfg.DataDir)
396 leecher, err := NewClient(cfg)
397 require.NoError(t, err)
398 defer leecher.Close()
399 defer testutil.ExportStatusWriter(leecher, "l")()
401 cfg = TestingConfig()
403 cfg.DataDir, err = ioutil.TempDir("", "")
404 require.NoError(t, err)
405 defer os.RemoveAll(cfg.DataDir)
406 leecherLeecher, _ := NewClient(cfg)
407 require.NoError(t, err)
408 defer leecherLeecher.Close()
409 defer testutil.ExportStatusWriter(leecherLeecher, "ll")()
410 leecherGreeting, ok, err := leecher.AddTorrentSpec(func() (ret *TorrentSpec) {
411 ret = TorrentSpecFromMetaInfo(mi)
415 require.NoError(t, err)
417 llg, ok, err := leecherLeecher.AddTorrentSpec(func() (ret *TorrentSpec) {
418 ret = TorrentSpecFromMetaInfo(mi)
422 require.NoError(t, err)
424 // Simultaneously DownloadAll in Leecher, and read the contents
425 // consecutively in LeecherLeecher. This non-deterministically triggered a
426 // case where the leecher wouldn't unchoke the LeecherLeecher.
427 var wg sync.WaitGroup
433 b, err := ioutil.ReadAll(r)
434 require.NoError(t, err)
435 assert.EqualValues(t, testutil.GreetingFileContents, b)
437 done := make(chan struct{})
439 go leecherGreeting.AddClientPeer(seeder)
440 go leecherGreeting.AddClientPeer(leecherLeecher)
444 leecherGreeting.DownloadAll()
450 func TestMergingTrackersByAddingSpecs(t *testing.T) {
451 cl, err := NewClient(TestingConfig())
452 require.NoError(t, err)
454 spec := TorrentSpec{}
455 T, new, _ := cl.AddTorrentSpec(&spec)
459 spec.Trackers = [][]string{{"http://a"}, {"udp://b"}}
460 _, new, _ = cl.AddTorrentSpec(&spec)
462 assert.EqualValues(t, [][]string{{"http://a"}, {"udp://b"}}, T.metainfo.AnnounceList)
463 // Because trackers are disabled in TestingConfig.
464 assert.EqualValues(t, 0, len(T.trackerAnnouncers))
467 // We read from a piece which is marked completed, but is missing data.
468 func TestCompletedPieceWrongSize(t *testing.T) {
469 cfg := TestingConfig()
470 cfg.DefaultStorage = badStorage{}
471 cl, err := NewClient(cfg)
472 require.NoError(t, err)
474 info := metainfo.Info{
476 Pieces: make([]byte, 20),
477 Files: []metainfo.FileInfo{
478 {Path: []string{"greeting"}, Length: 13},
481 b, err := bencode.Marshal(info)
482 require.NoError(t, err)
483 tt, new, err := cl.AddTorrentSpec(&TorrentSpec{
485 InfoHash: metainfo.HashBytes(b),
487 require.NoError(t, err)
492 b, err = ioutil.ReadAll(r)
494 assert.NoError(t, err)
497 func BenchmarkAddLargeTorrent(b *testing.B) {
498 cfg := TestingConfig()
499 cfg.DisableTCP = true
500 cfg.DisableUTP = true
501 cl, err := NewClient(cfg)
502 require.NoError(b, err)
504 for range iter.N(b.N) {
505 t, err := cl.AddTorrentFromFile("testdata/bootstrap.dat.torrent")
513 func TestResponsive(t *testing.T) {
514 seederDataDir, mi := testutil.GreetingTestTorrent()
515 defer os.RemoveAll(seederDataDir)
516 cfg := TestingConfig()
518 cfg.DataDir = seederDataDir
519 seeder, err := NewClient(cfg)
522 seederTorrent, _, _ := seeder.AddTorrentSpec(TorrentSpecFromMetaInfo(mi))
523 seederTorrent.VerifyData()
524 leecherDataDir, err := ioutil.TempDir("", "")
526 defer os.RemoveAll(leecherDataDir)
527 cfg = TestingConfig()
528 cfg.DataDir = leecherDataDir
529 leecher, err := NewClient(cfg)
531 defer leecher.Close()
532 leecherTorrent, _, _ := leecher.AddTorrentSpec(func() (ret *TorrentSpec) {
533 ret = TorrentSpecFromMetaInfo(mi)
537 leecherTorrent.AddClientPeer(seeder)
538 reader := leecherTorrent.NewReader()
540 reader.SetReadahead(0)
541 reader.SetResponsive()
543 _, err = reader.Seek(3, io.SeekStart)
544 require.NoError(t, err)
545 _, err = io.ReadFull(reader, b)
547 assert.EqualValues(t, "lo", string(b))
548 _, err = reader.Seek(11, io.SeekStart)
549 require.NoError(t, err)
550 n, err := io.ReadFull(reader, b)
552 assert.EqualValues(t, 2, n)
553 assert.EqualValues(t, "d\n", string(b))
556 func TestTorrentDroppedDuringResponsiveRead(t *testing.T) {
557 seederDataDir, mi := testutil.GreetingTestTorrent()
558 defer os.RemoveAll(seederDataDir)
559 cfg := TestingConfig()
561 cfg.DataDir = seederDataDir
562 seeder, err := NewClient(cfg)
565 seederTorrent, _, _ := seeder.AddTorrentSpec(TorrentSpecFromMetaInfo(mi))
566 seederTorrent.VerifyData()
567 leecherDataDir, err := ioutil.TempDir("", "")
569 defer os.RemoveAll(leecherDataDir)
570 cfg = TestingConfig()
571 cfg.DataDir = leecherDataDir
572 leecher, err := NewClient(cfg)
574 defer leecher.Close()
575 leecherTorrent, _, _ := leecher.AddTorrentSpec(func() (ret *TorrentSpec) {
576 ret = TorrentSpecFromMetaInfo(mi)
580 leecherTorrent.AddClientPeer(seeder)
581 reader := leecherTorrent.NewReader()
583 reader.SetReadahead(0)
584 reader.SetResponsive()
586 _, err = reader.Seek(3, io.SeekStart)
587 require.NoError(t, err)
588 _, err = io.ReadFull(reader, b)
590 assert.EqualValues(t, "lo", string(b))
591 go leecherTorrent.Drop()
592 _, err = reader.Seek(11, io.SeekStart)
593 require.NoError(t, err)
594 n, err := reader.Read(b)
595 assert.EqualError(t, err, "torrent closed")
596 assert.EqualValues(t, 0, n)
599 func TestDHTInheritBlocklist(t *testing.T) {
600 ipl := iplist.New(nil)
601 require.NotNil(t, ipl)
602 cfg := TestingConfig()
603 cfg.IPBlocklist = ipl
605 cl, err := NewClient(cfg)
606 require.NoError(t, err)
609 cl.eachDhtServer(func(s *dht.Server) {
610 assert.Equal(t, ipl, s.IPBlocklist())
613 assert.EqualValues(t, 2, numServers)
616 // Check that stuff is merged in subsequent AddTorrentSpec for the same
618 func TestAddTorrentSpecMerging(t *testing.T) {
619 cl, err := NewClient(TestingConfig())
620 require.NoError(t, err)
622 dir, mi := testutil.GreetingTestTorrent()
623 defer os.RemoveAll(dir)
624 tt, new, err := cl.AddTorrentSpec(&TorrentSpec{
625 InfoHash: mi.HashInfoBytes(),
627 require.NoError(t, err)
629 require.Nil(t, tt.Info())
630 _, new, err = cl.AddTorrentSpec(TorrentSpecFromMetaInfo(mi))
631 require.NoError(t, err)
632 require.False(t, new)
633 require.NotNil(t, tt.Info())
636 func TestTorrentDroppedBeforeGotInfo(t *testing.T) {
637 dir, mi := testutil.GreetingTestTorrent()
639 cl, _ := NewClient(TestingConfig())
641 tt, _, _ := cl.AddTorrentSpec(&TorrentSpec{
642 InfoHash: mi.HashInfoBytes(),
645 assert.EqualValues(t, 0, len(cl.Torrents()))
653 func writeTorrentData(ts *storage.Torrent, info metainfo.Info, b []byte) {
654 for i := range iter.N(info.NumPieces()) {
656 ts.Piece(p).WriteAt(b[p.Offset():p.Offset()+p.Length()], 0)
660 func testAddTorrentPriorPieceCompletion(t *testing.T, alreadyCompleted bool, csf func(*filecache.Cache) storage.ClientImpl) {
661 fileCacheDir, err := ioutil.TempDir("", "")
662 require.NoError(t, err)
663 defer os.RemoveAll(fileCacheDir)
664 fileCache, err := filecache.NewCache(fileCacheDir)
665 require.NoError(t, err)
666 greetingDataTempDir, greetingMetainfo := testutil.GreetingTestTorrent()
667 defer os.RemoveAll(greetingDataTempDir)
668 filePieceStore := csf(fileCache)
669 defer filePieceStore.Close()
670 info, err := greetingMetainfo.UnmarshalInfo()
671 require.NoError(t, err)
672 ih := greetingMetainfo.HashInfoBytes()
673 greetingData, err := storage.NewClient(filePieceStore).OpenTorrent(&info, ih)
674 require.NoError(t, err)
675 writeTorrentData(greetingData, info, []byte(testutil.GreetingFileContents))
676 // require.Equal(t, len(testutil.GreetingFileContents), written)
677 // require.NoError(t, err)
678 for i := 0; i < info.NumPieces(); i++ {
680 if alreadyCompleted {
681 require.NoError(t, greetingData.Piece(p).MarkComplete())
684 cfg := TestingConfig()
685 // TODO: Disable network option?
686 cfg.DisableTCP = true
687 cfg.DisableUTP = true
688 cfg.DefaultStorage = filePieceStore
689 cl, err := NewClient(cfg)
690 require.NoError(t, err)
692 tt, err := cl.AddTorrent(greetingMetainfo)
693 require.NoError(t, err)
694 psrs := tt.PieceStateRuns()
695 assert.Len(t, psrs, 1)
696 assert.EqualValues(t, 3, psrs[0].Length)
697 assert.Equal(t, alreadyCompleted, psrs[0].Complete)
698 if alreadyCompleted {
700 b, err := ioutil.ReadAll(r)
701 assert.NoError(t, err)
702 assert.EqualValues(t, testutil.GreetingFileContents, b)
706 func TestAddTorrentPiecesAlreadyCompleted(t *testing.T) {
707 testAddTorrentPriorPieceCompletion(t, true, fileCachePieceResourceStorage)
710 func TestAddTorrentPiecesNotAlreadyCompleted(t *testing.T) {
711 testAddTorrentPriorPieceCompletion(t, false, fileCachePieceResourceStorage)
714 func TestAddMetainfoWithNodes(t *testing.T) {
715 cfg := TestingConfig()
716 cfg.ListenHost = func(string) string { return "" }
718 cfg.DhtStartingNodes = func() ([]dht.Addr, error) { return nil, nil }
719 // For now, we want to just jam the nodes into the table, without
720 // verifying them first. Also the DHT code doesn't support mixing secure
721 // and insecure nodes if security is enabled (yet).
722 // cfg.DHTConfig.NoSecurity = true
723 cl, err := NewClient(cfg)
724 require.NoError(t, err)
726 sum := func() (ret int64) {
727 cl.eachDhtServer(func(s *dht.Server) {
728 ret += s.Stats().OutboundQueriesAttempted
732 assert.EqualValues(t, 0, sum())
733 tt, err := cl.AddTorrentFromFile("metainfo/testdata/issue_65a.torrent")
734 require.NoError(t, err)
735 // Nodes are not added or exposed in Torrent's metainfo. We just randomly
736 // check if the announce-list is here instead. TODO: Add nodes.
737 assert.Len(t, tt.metainfo.AnnounceList, 5)
738 // There are 6 nodes in the torrent file.
739 for sum() != int64(6*len(cl.dhtServers)) {
740 time.Sleep(time.Millisecond)
744 type testDownloadCancelParams struct {
745 SetLeecherStorageCapacity bool
746 LeecherStorageCapacity int64
750 func testDownloadCancel(t *testing.T, ps testDownloadCancelParams) {
751 greetingTempDir, mi := testutil.GreetingTestTorrent()
752 defer os.RemoveAll(greetingTempDir)
753 cfg := TestingConfig()
755 cfg.DataDir = greetingTempDir
756 seeder, err := NewClient(cfg)
757 require.NoError(t, err)
759 defer testutil.ExportStatusWriter(seeder, "s")()
760 seederTorrent, _, _ := seeder.AddTorrentSpec(TorrentSpecFromMetaInfo(mi))
761 seederTorrent.VerifyData()
762 leecherDataDir, err := ioutil.TempDir("", "")
763 require.NoError(t, err)
764 defer os.RemoveAll(leecherDataDir)
765 fc, err := filecache.NewCache(leecherDataDir)
766 require.NoError(t, err)
767 if ps.SetLeecherStorageCapacity {
768 fc.SetCapacity(ps.LeecherStorageCapacity)
770 cfg.DefaultStorage = storage.NewResourcePieces(fc.AsResourceProvider())
771 cfg.DataDir = leecherDataDir
772 leecher, _ := NewClient(cfg)
773 defer leecher.Close()
774 defer testutil.ExportStatusWriter(leecher, "l")()
775 leecherGreeting, new, err := leecher.AddTorrentSpec(func() (ret *TorrentSpec) {
776 ret = TorrentSpecFromMetaInfo(mi)
780 require.NoError(t, err)
782 psc := leecherGreeting.SubscribePieceStateChanges()
785 leecherGreeting.cl.lock()
786 leecherGreeting.downloadPiecesLocked(0, leecherGreeting.numPieces())
788 leecherGreeting.cancelPiecesLocked(0, leecherGreeting.NumPieces())
790 leecherGreeting.cl.unlock()
791 done := make(chan struct{})
793 go leecherGreeting.AddClientPeer(seeder)
794 completes := make(map[int]bool, 3)
795 expected := func() map[int]bool {
797 return map[int]bool{0: false, 1: false, 2: false}
799 return map[int]bool{0: true, 1: true, 2: true}
802 for !reflect.DeepEqual(completes, expected) {
804 v := _v.(PieceStateChange)
805 completes[v.Index] = v.Complete
809 func TestTorrentDownloadAll(t *testing.T) {
810 testDownloadCancel(t, testDownloadCancelParams{})
813 func TestTorrentDownloadAllThenCancel(t *testing.T) {
814 testDownloadCancel(t, testDownloadCancelParams{
819 // Ensure that it's an error for a peer to send an invalid have message.
820 func TestPeerInvalidHave(t *testing.T) {
821 cl, err := NewClient(TestingConfig())
822 require.NoError(t, err)
824 info := metainfo.Info{
826 Pieces: make([]byte, 20),
827 Files: []metainfo.FileInfo{{Length: 1}},
829 infoBytes, err := bencode.Marshal(info)
830 require.NoError(t, err)
831 tt, _new, err := cl.AddTorrentSpec(&TorrentSpec{
832 InfoBytes: infoBytes,
833 InfoHash: metainfo.HashBytes(infoBytes),
834 Storage: badStorage{},
836 require.NoError(t, err)
842 assert.NoError(t, cn.peerSentHave(0))
843 assert.Error(t, cn.peerSentHave(1))
846 func TestPieceCompletedInStorageButNotClient(t *testing.T) {
847 greetingTempDir, greetingMetainfo := testutil.GreetingTestTorrent()
848 defer os.RemoveAll(greetingTempDir)
849 cfg := TestingConfig()
850 cfg.DataDir = greetingTempDir
851 seeder, err := NewClient(TestingConfig())
852 require.NoError(t, err)
853 seeder.AddTorrentSpec(&TorrentSpec{
854 InfoBytes: greetingMetainfo.InfoBytes,
858 // Check that when the listen port is 0, all the protocols listened on have
859 // the same port, and it isn't zero.
860 func TestClientDynamicListenPortAllProtocols(t *testing.T) {
861 cl, err := NewClient(TestingConfig())
862 require.NoError(t, err)
864 port := cl.LocalPort()
865 assert.NotEqual(t, 0, port)
866 cl.eachListener(func(s socket) bool {
867 assert.Equal(t, port, missinggo.AddrPort(s.Addr()))
872 func TestClientDynamicListenTCPOnly(t *testing.T) {
873 cfg := TestingConfig()
874 cfg.DisableUTP = true
875 cfg.DisableTCP = false
876 cl, err := NewClient(cfg)
877 require.NoError(t, err)
879 assert.NotEqual(t, 0, cl.LocalPort())
882 func TestClientDynamicListenUTPOnly(t *testing.T) {
883 cfg := TestingConfig()
884 cfg.DisableTCP = true
885 cfg.DisableUTP = false
886 cl, err := NewClient(cfg)
887 require.NoError(t, err)
889 assert.NotEqual(t, 0, cl.LocalPort())
892 func totalConns(tts []*Torrent) (ret int) {
893 for _, tt := range tts {
901 func TestSetMaxEstablishedConn(t *testing.T) {
903 ih := testutil.GreetingMetaInfo().HashInfoBytes()
904 cfg := TestingConfig()
905 cfg.DisableAcceptRateLimiting = true
906 cfg.dropDuplicatePeerIds = true
907 for i := range iter.N(3) {
908 cl, err := NewClient(cfg)
909 require.NoError(t, err)
911 tt, _ := cl.AddTorrentInfoHash(ih)
912 tt.SetMaxEstablishedConns(2)
913 defer testutil.ExportStatusWriter(cl, fmt.Sprintf("%d", i))()
914 tts = append(tts, tt)
917 for _, tt := range tts {
918 for _, _tt := range tts {
920 tt.AddClientPeer(_tt.cl)
925 waitTotalConns := func(num int) {
926 for totalConns(tts) != num {
928 time.Sleep(time.Millisecond)
933 tts[0].SetMaxEstablishedConns(1)
935 tts[0].SetMaxEstablishedConns(0)
937 tts[0].SetMaxEstablishedConns(1)
940 tts[0].SetMaxEstablishedConns(2)
945 func makeMagnet(t *testing.T, cl *Client, dir string, name string) string {
946 os.MkdirAll(dir, 0770)
947 file, err := os.Create(filepath.Join(dir, name))
948 require.NoError(t, err)
949 file.Write([]byte(name))
951 mi := metainfo.MetaInfo{}
953 info := metainfo.Info{PieceLength: 256 * 1024}
954 err = info.BuildFromFilePath(filepath.Join(dir, name))
955 require.NoError(t, err)
956 mi.InfoBytes, err = bencode.Marshal(info)
957 require.NoError(t, err)
958 magnet := mi.Magnet(name, mi.HashInfoBytes()).String()
959 tr, err := cl.AddTorrent(&mi)
960 require.NoError(t, err)
961 require.True(t, tr.Seeding())
966 // https://github.com/anacrolix/torrent/issues/114
967 func TestMultipleTorrentsWithEncryption(t *testing.T) {
968 cfg := TestingConfig()
969 cfg.DisableUTP = true
971 cfg.DataDir = filepath.Join(cfg.DataDir, "server")
972 cfg.ForceEncryption = true
973 os.Mkdir(cfg.DataDir, 0755)
974 server, err := NewClient(cfg)
975 require.NoError(t, err)
977 defer testutil.ExportStatusWriter(server, "s")()
978 magnet1 := makeMagnet(t, server, cfg.DataDir, "test1")
979 makeMagnet(t, server, cfg.DataDir, "test2")
980 cfg = TestingConfig()
981 cfg.DisableUTP = true
982 cfg.DataDir = filepath.Join(cfg.DataDir, "client")
983 cfg.ForceEncryption = true
984 client, err := NewClient(cfg)
985 require.NoError(t, err)
987 defer testutil.ExportStatusWriter(client, "c")()
988 tr, err := client.AddMagnet(magnet1)
989 require.NoError(t, err)
990 tr.AddClientPeer(server)
996 func TestClientAddressInUse(t *testing.T) {
997 s, _ := NewUtpSocket("udp", ":50007", nil)
1001 cfg := TestingConfig().SetListenAddr(":50007")
1002 cl, err := NewClient(cfg)
1003 require.Error(t, err)
1007 func TestClientHasDhtServersWhenUtpDisabled(t *testing.T) {
1008 cc := TestingConfig()
1009 cc.DisableUTP = true
1011 cl, err := NewClient(cc)
1012 require.NoError(t, err)
1014 assert.NotEmpty(t, cl.DhtServers())