Fid ReadDir and improve tests

1 files changed, 107 insertions, 42 deletions

diff --git a/fs_test.go b/fs_test.go
index cbee404..2f670cf 100644
--- a/fs_test.go
+++ b/fs_test.go
@@ -9,10 +9,16 @@ import (
 	"github.com/spf13/afero"
 )
 
+var (
+	testdata = []byte("testdata")
+)
+
 func TestFsListBuckets(t *testing.T) {
 	is := is.New(t)
-	afs, err := newTestAfs()
-	is.NoErr(err)
+	afs, cleanup := newTestAfs()
+	defer cleanup()
+
+	var err error
 	buckets, err := testListBuckets(afs.Fs.(*Fs))
 	is.NoErr(err)
 	is.Equal(len(buckets), 1)
@@ -20,40 +26,46 @@ func TestFsListBuckets(t *testing.T) {
 
 func TestFsMkdir(t *testing.T) {
 	is := is.New(t)
-	afs, err := newTestAfs()
-	is.NoErr(err)
-	err = afs.Mkdir("test", 0o644)
+	afs, cleanup := newTestAfs()
+	defer cleanup()
+
+	err := afs.Mkdir("test", 0o644)
 	is.Equal(err, ErrUnsupported)
 }
 
 func TestFsMkdirAll(t *testing.T) {
 	is := is.New(t)
-	afs, err := newTestAfs()
-	is.NoErr(err)
-	err = afs.MkdirAll("test1/test2", 0o644)
+	afs, cleanup := newTestAfs()
+	defer cleanup()
+
+	err := afs.MkdirAll("test1/test2", 0o644)
 	is.Equal(err, ErrUnsupported)
 }
 
 func TestFsChmod(t *testing.T) {
 	is := is.New(t)
-	afs, err := newTestAfs()
-	is.NoErr(err)
-	err = afs.Chmod("test", 0o644)
+	afs, cleanup := newTestAfs()
+	defer cleanup()
+
+	err := afs.Chmod("test", 0o644)
 	is.Equal(err, ErrUnsupported)
 }
 
 func TestFsChown(t *testing.T) {
 	is := is.New(t)
-	afs, err := newTestAfs()
-	is.NoErr(err)
-	err = afs.Chown("test", 1000, 1000)
+	afs, cleanup := newTestAfs()
+	defer cleanup()
+
+	err := afs.Chown("test", 1000, 1000)
 	is.Equal(err, ErrUnsupported)
 }
 
 func TestFsChtimes(t *testing.T) {
 	is := is.New(t)
-	afs, err := newTestAfs()
-	is.NoErr(err)
+	afs, cleanup := newTestAfs()
+	defer cleanup()
+
+	var err error
 	now := time.Now()
 	err = afs.Chtimes("test", now, now)
 	is.Equal(err, ErrUnsupported)
@@ -61,15 +73,20 @@ func TestFsChtimes(t *testing.T) {
 
 func TestFsWriteFile(t *testing.T) {
 	is := is.New(t)
-	afs, err := newTestAfs()
-	is.NoErr(err)
-	err = afs.WriteFile("dir/file", []byte("testdata"), 0)
+	afs, cleanup := newTestAfs()
+	defer cleanup()
+
+	err := afs.WriteFile("dir/file", testdata, 0)
 	is.NoErr(err)
 }
 
 func TestFsStat(t *testing.T) {
 	is := is.New(t)
-	afs, err := newTestAfs()
+	afs, cleanup := newTestAfs()
+	defer cleanup()
+
+	var err error
+	err = afs.WriteFile("dir/file", testdata, 0)
 	is.NoErr(err)
 	info, err := afs.Stat("dir/file")
 	is.NoErr(err)
@@ -79,54 +96,66 @@ func TestFsStat(t *testing.T) {
 
 func TestFsStatNoExist(t *testing.T) {
 	is := is.New(t)
-	afs, err := newTestAfs()
-	is.NoErr(err)
+	afs, cleanup := newTestAfs()
+	defer cleanup()
+
+	var err error
 	_, err = afs.Stat("dir/non-existent")
 	is.Equal(err, afero.ErrFileNotFound)
 }
 
 func TestFsReadFile(t *testing.T) {
 	is := is.New(t)
-	afs, err := newTestAfs()
+	afs, cleanup := newTestAfs()
+	defer cleanup()
+
+	var err error
+	err = afs.WriteFile("dir/file", testdata, 0)
 	is.NoErr(err)
 	b, err := afs.ReadFile("dir/file")
 	is.NoErr(err)
-	is.Equal(b, []byte("testdata"))
+	is.Equal(b, testdata)
 }
 
 func TestFsReadNoExist(t *testing.T) {
 	is := is.New(t)
-	afs, err := newTestAfs()
-	is.NoErr(err)
+	afs, cleanup := newTestAfs()
+	defer cleanup()
+
+	var err error
 	_, err = afs.ReadFile("non-existent")
 	is.Equal(err, afero.ErrFileNotFound)
 }
 
 func TestFsRemove(t *testing.T) {
 	is := is.New(t)
-	afs, err := newTestAfs()
-	is.NoErr(err)
-	err = afs.Remove("dir/file")
+	afs, cleanup := newTestAfs()
+	defer cleanup()
+
+	err := afs.Remove("dir/file")
 	is.NoErr(err)
 }
 
 func TestFsRemoveNoExist(t *testing.T) {
 	is := is.New(t)
-	afs, err := newTestAfs()
-	is.NoErr(err)
-	err = afs.Remove("non-existent")
+	afs, cleanup := newTestAfs()
+	defer cleanup()
+
+	err := afs.Remove("non-existent")
 	is.NoErr(err)
 }
 
 func TestFsRemoveAll(t *testing.T) {
 	is := is.New(t)
-	afs, err := newTestAfs()
-	is.NoErr(err)
-	err = afs.WriteFile("dir/file1", []byte("testdata"), 0)
+	afs, cleanup := newTestAfs()
+	defer cleanup()
+
+	var err error
+	err = afs.WriteFile("dir/file1", testdata, 0)
 	is.NoErr(err)
-	err = afs.WriteFile("dir/file2", []byte("testdata"), 0)
+	err = afs.WriteFile("dir/file2", testdata, 0)
 	is.NoErr(err)
-	err = afs.WriteFile("persist/file0", []byte("testdata"), 0)
+	err = afs.WriteFile("persist/file0", testdata, 0)
 	is.NoErr(err)
 	err = afs.RemoveAll("dir/")
 	is.NoErr(err)
@@ -138,9 +167,11 @@ func TestFsRemoveAll(t *testing.T) {
 
 func TestFsRename(t *testing.T) {
 	is := is.New(t)
-	afs, err := newTestAfs()
-	is.NoErr(err)
-	err = afs.WriteFile("dir/file", []byte("testdata"), 0)
+	afs, cleanup := newTestAfs()
+	defer cleanup()
+
+	var err error
+	err = afs.WriteFile("dir/file", testdata, 0)
 	is.NoErr(err)
 	err = afs.Rename("dir/file", "dir/file2")
 	is.NoErr(err)
@@ -152,10 +183,44 @@ func TestFsRename(t *testing.T) {
 	is.NoErr(err)
 }
 
-func newTestAfs() (*afero.Afero, error) {
+func TestFsReadDir(t *testing.T) {
+	is := is.New(t)
+	afs, cleanup := newTestAfs()
+	defer cleanup()
+
+	var err error
+	err = afs.WriteFile("dir/file1", []byte(""), 0)
+	is.NoErr(err)
+	err = afs.WriteFile("dir/file2", []byte(""), 0)
+	is.NoErr(err)
+	err = afs.WriteFile("dir/subdir/file3", []byte(""), 0)
+	is.NoErr(err)
+	defer afs.RemoveAll("/")
+
+	infos, err := afs.ReadDir("dir/")
+	is.NoErr(err)
+	is.Equal(len(infos), 3)
+	is.Equal(infos[0].Name(), "file1")
+	is.Equal(infos[1].Name(), "file2")
+	is.Equal(infos[2].IsDir(), true)
+	is.Equal(infos[2].Name(), "subdir/")
+
+	f, err := afs.Open("dir/")
+	is.NoErr(err)
+	names, err := f.Readdirnames(-1)
+	is.NoErr(err)
+	is.Equal(names, []string{"subdir/"})
+}
+
+func newTestAfs() (*afero.Afero, func()) {
 	fs, err := NewFsFromURL("http://testuser:[email protected]:9000/test-bucket")
+	if err != nil {
+		panic("unexpected error")
+	}
 	afs := &afero.Afero{Fs: fs}
-	return afs, err
+	return afs, func() {
+		afs.RemoveAll("/")
+	}
 }
 
 func testListBuckets(fs *Fs) ([]string, error) {