improve tests

4 files changed, 97 insertions, 40 deletions

diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..3af0ccb
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1 @@
+/data
diff --git a/fs.go b/fs.go
index 864570b..8358b6a 100644
--- a/fs.go
+++ b/fs.go
@@ -55,25 +55,11 @@ func NewFs(endpoint, bucket, accessKeyID, secretAccessKey string, useSSL bool) (
 }
 
 func NewFsFromURL(url string) (*Fs, error) {
-	r, err := neturl.ParseRequestURI(url)
+	endpoint, bucket, accessKeyID, secretAccessKey, useSSL, err := parseUrl(url)
 	if err != nil {
 		return nil, fmt.Errorf("failed to parse url: %w", err)
 	}
-	useSSL := false
-	switch r.Scheme {
-	case "http":
-	case "https":
-		useSSL = true
-	default:
-		return nil, ErrInvalidProtocol
-
-	}
-
-	endpoint := r.Host
-	bucket := r.Path[1:]
-	accessKeyId := r.User.Username()
-	secretAccessKey, _ := r.User.Password()
-	return NewFs(endpoint, bucket, accessKeyId, secretAccessKey, useSSL)
+	return NewFs(endpoint, bucket, accessKeyID, secretAccessKey, useSSL)
 }
 
 // The name of this FileSystem
@@ -286,5 +272,25 @@ func (fs *Fs) readdir(directory string, count int, onlyDir bool) ([]os.FileInfo,
 }
 
 func isDirPath(p string) bool {
-	return strings.HasSuffix(p, "/")
+	return p == "" || strings.HasSuffix(p, "/")
+}
+
+func parseUrl(url string) (endpoint, bucket, accessKeyID, secretAccessKey string, useSSL bool, err error) {
+	var r *neturl.URL
+	if r, err = neturl.ParseRequestURI(url); err != nil {
+		return
+	}
+	switch r.Scheme {
+	case "http":
+	case "https":
+		useSSL = true
+	default:
+		err = ErrInvalidProtocol
+		return
+	}
+	endpoint = r.Host
+	bucket = r.Path[1:]
+	accessKeyID = r.User.Username()
+	secretAccessKey, _ = r.User.Password()
+	return
 }
diff --git a/fs_test.go b/fs_test.go
index 7752858..f86be50 100644
--- a/fs_test.go
+++ b/fs_test.go
@@ -79,7 +79,7 @@ func TestFsWriteFile(t *testing.T) {
 	afs, cleanup := newTestAfs()
 	defer cleanup()
 
-	err := afs.WriteFile("dir/file", testdata, 0)
+	err := afs.WriteFile("dir/file.txt", testdata, 0)
 	is.NoErr(err)
 }
 
@@ -88,13 +88,13 @@ func TestFsWriteError(t *testing.T) {
 	afs, cleanup := newTestAfs()
 	defer cleanup()
 
-	f, err := afs.Fs.Create("dir/file")
+	f, err := afs.Fs.Create("dir/file.txt")
 	is.NoErr(err)
 	_, err = f.Write(testdata)
 	is.NoErr(err)
 	err = f.(*File).CloseWriterWithError(errors.New("disk died"))
 	is.NoErr(err)
-	_, err = afs.Stat("dir/file")
+	_, err = afs.Stat("dir/file.txt")
 	is.Equal(err, os.ErrNotExist)
 }
 
@@ -103,14 +103,14 @@ func TestFsWrite17MB(t *testing.T) {
 	afs, cleanup := newTestAfs()
 	defer cleanup()
 
-	f, err := afs.Fs.Create("dir/file")
+	f, err := afs.Fs.Create("dir/file.txt")
 	is.NoErr(err)
 	r := io.LimitReader(cryptorand.Reader, 17*(1<<20))
 	_, err = io.Copy(f, r)
 	is.NoErr(err)
 	err = f.Close()
 	is.NoErr(err)
-	info, err := afs.Stat("dir/file")
+	info, err := afs.Stat("dir/file.txt")
 	is.NoErr(err)
 	is.Equal(info.Size(), int64(17*(1<<20)))
 }
@@ -121,11 +121,11 @@ func TestFsStat(t *testing.T) {
 	defer cleanup()
 
 	var err error
-	err = afs.WriteFile("dir/file", testdata, 0)
+	err = afs.WriteFile("dir/file.txt", testdata, 0)
 	is.NoErr(err)
-	info, err := afs.Stat("dir/file")
+	info, err := afs.Stat("dir/file.txt")
 	is.NoErr(err)
-	is.Equal(info.Name(), "file")
+	is.Equal(info.Name(), "file.txt")
 	is.Equal(info.Size(), int64(8))
 }
 
@@ -145,9 +145,9 @@ func TestFsReadFile(t *testing.T) {
 	defer cleanup()
 
 	var err error
-	err = afs.WriteFile("dir/file", testdata, 0)
+	err = afs.WriteFile("dir/file.txt", testdata, 0)
 	is.NoErr(err)
-	b, err := afs.ReadFile("dir/file")
+	b, err := afs.ReadFile("dir/file.txt")
 	is.NoErr(err)
 	is.Equal(b, testdata)
 }
@@ -167,8 +167,18 @@ func TestFsRemove(t *testing.T) {
 	afs, cleanup := newTestAfs()
 	defer cleanup()
 
-	err := afs.Remove("dir/file")
+	var err error
+	err = afs.WriteFile("dir/file.txt", testdata, 0)
+	is.NoErr(err)
+
+	_, err = afs.ReadFile("dir/file.txt")
+	is.NoErr(err)
+
+	err = afs.Remove("dir/file.txt")
 	is.NoErr(err)
+
+	_, err = afs.ReadFile("dir/file.txt")
+	is.Equal(err, afero.ErrFileNotFound)
 }
 
 func TestFsRemoveNoExist(t *testing.T) {
@@ -176,7 +186,11 @@ func TestFsRemoveNoExist(t *testing.T) {
 	afs, cleanup := newTestAfs()
 	defer cleanup()
 
-	err := afs.Remove("non-existent")
+	var err error
+	_, err = afs.ReadFile("non-existent")
+	is.Equal(err, afero.ErrFileNotFound)
+
+	err = afs.Remove("non-existent")
 	is.NoErr(err)
 }
 
@@ -247,17 +261,6 @@ func TestFsReadDir(t *testing.T) {
 	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, func() {
-		afs.RemoveAll("/")
-	}
-}
-
 func testListBuckets(fs *Fs) ([]string, error) {
 	ctx, cancel := fs.contextWithTimeout()
 	defer cancel()
diff --git a/util_test.go b/util_test.go
new file mode 100644
index 0000000..ff700be
--- /dev/null
+++ b/util_test.go
@@ -0,0 +1,47 @@
+package s3
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	"github.com/minio/minio-go/v7"
+	"github.com/minio/minio-go/v7/pkg/credentials"
+	"github.com/spf13/afero"
+)
+
+func newTestAfs() (*afero.Afero, func()) {
+	accessKeyID := "testuser"
+	secretAccessKey := "testsecret"
+	endpoint := "127.0.0.1:9000"
+	useSSL := false
+	bucket := "test-bucket"
+
+	client, err := minio.New(endpoint, &minio.Options{
+		Creds:  credentials.NewStaticV4(accessKeyID, secretAccessKey, ""),
+		Secure: useSSL,
+	})
+	if err != nil {
+		panic("unable connect")
+	}
+	ctx, cancel := context.WithTimeout(context.Background(), time.Second)
+	defer cancel()
+
+	if exists, err := client.BucketExists(ctx, bucket); err != nil {
+		panic("unable connect")
+	} else if !exists {
+		if err := client.MakeBucket(ctx, bucket, minio.MakeBucketOptions{}); err != nil {
+			panic("failed to seup a bucket")
+		}
+	}
+
+	url := fmt.Sprintf("http://%s:%s@%s/%s", accessKeyID, secretAccessKey, endpoint, bucket)
+	fs, err := NewFsFromURL(url)
+	if err != nil {
+		panic("unexpected error")
+	}
+	afs := &afero.Afero{Fs: fs}
+	return afs, func() {
+		afs.RemoveAll("")
+	}
+}