Drop support for go 1.20

[btrtrc.git] / fs / torrentfs_test.go

diff --git a/fs/torrentfs_test.go b/fs/torrentfs_test.go
index c8cacc5d37b105d378a6907cb7145cc272e92053..097f1bb2377449d1c4300e4d8496a1f90806ad11 100644 (file)
--- a/fs/torrentfs_test.go
+++ b/fs/torrentfs_test.go
@@ -2,7 +2,6 @@ package torrentfs
 
 import (
        "context"
-       netContext "context"
        "fmt"
        "io/ioutil"
        "log"
@@ -13,10 +12,10 @@ import (
        "testing"
        "time"
 
-       "bazil.org/fuse"
-       fusefs "bazil.org/fuse/fs"
        _ "github.com/anacrolix/envpprof"
-       "github.com/anacrolix/missinggo"
+       "github.com/anacrolix/fuse"
+       fusefs "github.com/anacrolix/fuse/fs"
+       "github.com/anacrolix/missinggo/v2"
        "github.com/stretchr/testify/assert"
        "github.com/stretchr/testify/require"
 
@@ -63,15 +62,12 @@ func (tl *testLayout) Destroy() error {
        return os.RemoveAll(tl.BaseDir)
 }
 
-func newGreetingLayout() (tl testLayout, err error) {
-       tl.BaseDir, err = ioutil.TempDir("", "torrentfs")
-       if err != nil {
-               return
-       }
+func newGreetingLayout(t *testing.T) (tl testLayout, err error) {
+       tl.BaseDir = t.TempDir()
        tl.Completed = filepath.Join(tl.BaseDir, "completed")
-       os.Mkdir(tl.Completed, 0777)
+       os.Mkdir(tl.Completed, 0o777)
        tl.MountDir = filepath.Join(tl.BaseDir, "mnt")
-       os.Mkdir(tl.MountDir, 0777)
+       os.Mkdir(tl.MountDir, 0o777)
        testutil.CreateDummyTorrentData(tl.Completed)
        tl.Metainfo = testutil.GreetingMetaInfo()
        return
@@ -80,7 +76,7 @@ func newGreetingLayout() (tl testLayout, err error) {
 // Unmount without first killing the FUSE connection while there are FUSE
 // operations blocked inside the filesystem code.
 func TestUnmountWedged(t *testing.T) {
-       layout, err := newGreetingLayout()
+       layout, err := newGreetingLayout(t)
        require.NoError(t, err)
        defer func() {
                err := layout.Destroy()
@@ -88,13 +84,13 @@ func TestUnmountWedged(t *testing.T) {
                        t.Log(err)
                }
        }()
-       client, err := torrent.NewClient(&torrent.Config{
-               DataDir:         filepath.Join(layout.BaseDir, "incomplete"),
-               DisableTrackers: true,
-               NoDHT:           true,
-               DisableTCP:      true,
-               DisableUTP:      true,
-       })
+       cfg := torrent.NewDefaultClientConfig()
+       cfg.DataDir = filepath.Join(layout.BaseDir, "incomplete")
+       cfg.DisableTrackers = true
+       cfg.NoDHT = true
+       cfg.DisableTCP = true
+       cfg.DisableUTP = true
+       client, err := torrent.NewClient(cfg)
        require.NoError(t, err)
        defer client.Close()
        tt, err := client.AddTorrent(layout.Metainfo)
@@ -162,20 +158,20 @@ func TestUnmountWedged(t *testing.T) {
 }
 
 func TestDownloadOnDemand(t *testing.T) {
-       layout, err := newGreetingLayout()
+       layout, err := newGreetingLayout(t)
        require.NoError(t, err)
        defer layout.Destroy()
-       cfg := torrent.Config{
-               DataDir:         layout.Completed,
-               DisableTrackers: true,
-               NoDHT:           true,
-               Seed:            true,
-               ListenHost:      torrent.LoopbackListenHost,
-       }
-       seeder, err := torrent.NewClient(&cfg)
+       cfg := torrent.NewDefaultClientConfig()
+       cfg.DataDir = layout.Completed
+       cfg.DisableTrackers = true
+       cfg.NoDHT = true
+       cfg.Seed = true
+       cfg.ListenPort = 0
+       cfg.ListenHost = torrent.LoopbackListenHost
+       seeder, err := torrent.NewClient(cfg)
        require.NoError(t, err)
        defer seeder.Close()
-       testutil.ExportStatusWriter(seeder, "s")
+       defer testutil.ExportStatusWriter(seeder, "s", t)()
        // Just to mix things up, the seeder starts with the data, but the leecher
        // starts with the metainfo.
        seederTorrent, err := seeder.AddMagnet(fmt.Sprintf("magnet:?xt=urn:btih:%s", layout.Metainfo.HashInfoBytes().HexString()))
@@ -185,15 +181,16 @@ func TestDownloadOnDemand(t *testing.T) {
                <-seederTorrent.GotInfo()
                seederTorrent.VerifyData()
        }()
-       leecher, err := torrent.NewClient(&torrent.Config{
-               DisableTrackers: true,
-               NoDHT:           true,
-               DisableTCP:      true,
-               DefaultStorage:  storage.NewMMap(filepath.Join(layout.BaseDir, "download")),
-               ListenHost:      torrent.LoopbackListenHost,
-       })
+       cfg = torrent.NewDefaultClientConfig()
+       cfg.DisableTrackers = true
+       cfg.NoDHT = true
+       cfg.DisableTCP = true
+       cfg.DefaultStorage = storage.NewMMap(filepath.Join(layout.BaseDir, "download"))
+       cfg.ListenHost = torrent.LoopbackListenHost
+       cfg.ListenPort = 0
+       leecher, err := torrent.NewClient(cfg)
        require.NoError(t, err)
-       testutil.ExportStatusWriter(leecher, "l")
+       testutil.ExportStatusWriter(leecher, "l", t)()
        defer leecher.Close()
        leecherTorrent, err := leecher.AddTorrent(layout.Metainfo)
        require.NoError(t, err)
@@ -201,19 +198,28 @@ func TestDownloadOnDemand(t *testing.T) {
        fs := New(leecher)
        defer fs.Destroy()
        root, _ := fs.Root()
-       node, _ := root.(fusefs.NodeStringLookuper).Lookup(netContext.Background(), "greeting")
+       node, _ := root.(fusefs.NodeStringLookuper).Lookup(context.Background(), "greeting")
        var attr fuse.Attr
-       node.Attr(netContext.Background(), &attr)
+       node.Attr(context.Background(), &attr)
        size := attr.Size
-       resp := &fuse.ReadResponse{
-               Data: make([]byte, size),
-       }
+       data := make([]byte, size)
        h, err := node.(fusefs.NodeOpener).Open(context.TODO(), nil, nil)
        require.NoError(t, err)
-       h.(fusefs.HandleReader).Read(netContext.Background(), &fuse.ReadRequest{
-               Size: int(size),
-       }, resp)
-       assert.EqualValues(t, testutil.GreetingFileContents, resp.Data)
+
+       // torrent.Reader.Read no longer tries to fill the entire read buffer, so this is a ReadFull for
+       // fusefs.
+       var n int
+       for n < len(data) {
+               resp := fuse.ReadResponse{Data: data[n:]}
+               err := h.(fusefs.HandleReader).Read(context.Background(), &fuse.ReadRequest{
+                       Size:   int(size) - n,
+                       Offset: int64(n),
+               }, &resp)
+               assert.NoError(t, err)
+               n += len(resp.Data)
+       }
+
+       assert.EqualValues(t, testutil.GreetingFileContents, data)
 }
 
 func TestIsSubPath(t *testing.T) {