"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"
- netContext "golang.org/x/net/context"
"github.com/anacrolix/torrent"
"github.com/anacrolix/torrent/internal/testutil"
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
// 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()
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)
fuseConn, err := fuse.Mount(layout.MountDir)
if err != nil {
switch err.Error() {
- case "cannot locate OSXFUSE",
- "fusermount: exit status 1":
+ case "cannot locate OSXFUSE":
+ fallthrough
+ case "fusermount: exit status 1":
t.Skip(err)
}
t.Fatal(err)
go func() {
defer cancel()
_, err := ioutil.ReadFile(filepath.Join(layout.MountDir, tt.Info().Name))
- if err == nil {
- t.Fatal("expected error reading greeting")
- }
+ require.Error(t, err)
}()
// Wait until the read has blocked inside the filesystem code.
}
err = fuseConn.Close()
- if err != nil {
- t.Fatalf("error closing fuse conn: %s", err)
- }
+ assert.NoError(t, err)
}
func TestDownloadOnDemand(t *testing.T) {
- layout, err := newGreetingLayout()
+ layout, err := newGreetingLayout(t)
require.NoError(t, err)
defer layout.Destroy()
- seeder, err := torrent.NewClient(&torrent.Config{
- DataDir: layout.Completed,
- DisableTrackers: true,
- NoDHT: true,
- ListenAddr: "localhost:0",
- Seed: true,
- })
+ 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")
- _, err = seeder.AddMagnet(fmt.Sprintf("magnet:?xt=urn:btih:%s", layout.Metainfo.HashInfoBytes().HexString()))
+ 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()))
require.NoError(t, err)
- leecher, err := torrent.NewClient(&torrent.Config{
- DisableTrackers: true,
- NoDHT: true,
- ListenAddr: "localhost:0",
- DisableTCP: true,
- DefaultStorage: storage.NewMMap(filepath.Join(layout.BaseDir, "download")),
- // This can be used to check if clients can connect to other clients
- // with the same ID.
- // PeerID: seeder.PeerID(),
- })
+ go func() {
+ // Wait until we get the metainfo, then check for the data.
+ <-seederTorrent.GotInfo()
+ seederTorrent.VerifyData()
+ }()
+ 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, _ := leecher.AddTorrent(layout.Metainfo)
- leecherTorrent.AddPeers([]torrent.Peer{
- {
- IP: missinggo.AddrIP(seeder.ListenAddr()),
- Port: missinggo.AddrPort(seeder.ListenAddr()),
- },
- })
+ leecherTorrent, err := leecher.AddTorrent(layout.Metainfo)
+ require.NoError(t, err)
+ leecherTorrent.AddClientPeer(seeder)
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),
- }
- h, err := node.(fusefs.NodeOpener).Open(nil, nil, nil)
+ 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) {