replace afero module

Signed-off-by: Dave Henderson <dhenderson@gmail.com>

1 files changed, 54 insertions, 41 deletions

diff --git a/template_test.go b/template_test.go
index 85a8ae90..fd6a387a 100644
--- a/template_test.go
+++ b/template_test.go
@@ -4,29 +4,33 @@ import (
 	"bytes"
 	"context"
 	"io"
+	"io/fs"
 	"net/url"
 	"os"
 	"testing"
 	"testing/fstest"
 	"text/template"
 
-	"github.com/hairyhenderson/go-fsimpl"
+	"github.com/hack-pad/hackpadfs"
+	"github.com/hack-pad/hackpadfs/mem"
 	"github.com/hairyhenderson/gomplate/v4/internal/config"
+	"github.com/hairyhenderson/gomplate/v4/internal/datafs"
 	"github.com/hairyhenderson/gomplate/v4/internal/iohelpers"
-	"github.com/spf13/afero"
 
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
 
 func TestOpenOutFile(t *testing.T) {
-	origfs := aferoFS
-	defer func() { aferoFS = origfs }()
-	aferoFS = afero.NewMemMapFs()
-	_ = aferoFS.Mkdir("/tmp", 0777)
+	memfs, _ := mem.NewFS()
+	fsys := datafs.WrapWdFS(memfs)
+
+	_ = hackpadfs.Mkdir(fsys, "/tmp", 0o777)
+
+	ctx := datafs.ContextWithFSProvider(context.Background(), datafs.WrappedFSProvider(fsys, "file"))
 
 	cfg := &config.Config{Stdout: &bytes.Buffer{}}
-	f, err := openOutFile("/tmp/foo", 0755, 0644, false, nil, false)
+	f, err := openOutFile(ctx, "/tmp/foo", 0o755, 0o644, false, nil, false)
 	require.NoError(t, err)
 
 	wc, ok := f.(io.WriteCloser)
@@ -34,28 +38,34 @@ func TestOpenOutFile(t *testing.T) {
 	err = wc.Close()
 	require.NoError(t, err)
 
-	i, err := aferoFS.Stat("/tmp/foo")
+	i, err := hackpadfs.Stat(fsys, "/tmp/foo")
 	require.NoError(t, err)
 	assert.Equal(t, iohelpers.NormalizeFileMode(0644), i.Mode())
 
 	out := &bytes.Buffer{}
 
-	f, err = openOutFile("-", 0755, 0644, false, out, false)
+	f, err = openOutFile(ctx, "-", 0755, 0644, false, out, false)
 	require.NoError(t, err)
 	assert.Equal(t, cfg.Stdout, f)
 }
 
 func TestGatherTemplates(t *testing.T) {
-	ctx := context.Background()
+	// chdir to root so we can use relative paths
+	wd, _ := os.Getwd()
+	t.Cleanup(func() {
+		_ = os.Chdir(wd)
+	})
+	_ = os.Chdir("/")
+
+	fsys, _ := mem.NewFS()
 
-	origfs := aferoFS
-	defer func() { aferoFS = origfs }()
-	aferoFS = afero.NewMemMapFs()
-	afero.WriteFile(aferoFS, "foo", []byte("bar"), 0600)
+	_ = hackpadfs.WriteFullFile(fsys, "foo", []byte("bar"), 0o600)
+	_ = hackpadfs.Mkdir(fsys, "in", 0o777)
+	_ = hackpadfs.WriteFullFile(fsys, "in/1", []byte("foo"), 0o644)
+	_ = hackpadfs.WriteFullFile(fsys, "in/2", []byte("bar"), 0o644)
+	_ = hackpadfs.WriteFullFile(fsys, "in/3", []byte("baz"), 0o644)
 
-	afero.WriteFile(aferoFS, "in/1", []byte("foo"), 0644)
-	afero.WriteFile(aferoFS, "in/2", []byte("bar"), 0644)
-	afero.WriteFile(aferoFS, "in/3", []byte("baz"), 0644)
+	ctx := datafs.ContextWithFSProvider(context.Background(), datafs.WrappedFSProvider(fsys, "file"))
 
 	cfg := &config.Config{
 		Stdin:  &bytes.Buffer{},
@@ -83,20 +93,18 @@ func TestGatherTemplates(t *testing.T) {
 	}, nil)
 	require.NoError(t, err)
 	assert.Len(t, templates, 1)
-	// assert.Equal(t, iohelpers.NormalizeFileMode(0644), templates[0].mode)
 
 	// out file is created only on demand
-	_, err = aferoFS.Stat("out")
-	assert.Error(t, err)
-	assert.True(t, os.IsNotExist(err))
+	_, err = hackpadfs.Stat(fsys, "out")
+	assert.ErrorIs(t, err, fs.ErrNotExist)
 
 	_, err = templates[0].Writer.Write([]byte("hello world"))
 	require.NoError(t, err)
 
-	info, err := aferoFS.Stat("out")
+	info, err := hackpadfs.Stat(fsys, "out")
 	require.NoError(t, err)
-	assert.Equal(t, iohelpers.NormalizeFileMode(0644), info.Mode())
-	aferoFS.Remove("out")
+	assert.Equal(t, iohelpers.NormalizeFileMode(0o644), info.Mode())
+	_ = hackpadfs.Remove(fsys, "out")
 
 	cfg = &config.Config{
 		InputFiles:  []string{"foo"},
@@ -113,10 +121,10 @@ func TestGatherTemplates(t *testing.T) {
 	_, err = templates[0].Writer.Write([]byte("hello world"))
 	require.NoError(t, err)
 
-	info, err = aferoFS.Stat("out")
+	info, err = hackpadfs.Stat(fsys, "out")
 	require.NoError(t, err)
 	assert.Equal(t, iohelpers.NormalizeFileMode(0600), info.Mode())
-	aferoFS.Remove("out")
+	hackpadfs.Remove(fsys, "out")
 
 	cfg = &config.Config{
 		InputFiles:  []string{"foo"},
@@ -134,44 +142,48 @@ func TestGatherTemplates(t *testing.T) {
 	_, err = templates[0].Writer.Write([]byte("hello world"))
 	require.NoError(t, err)
 
-	info, err = aferoFS.Stat("out")
+	info, err = hackpadfs.Stat(fsys, "out")
 	require.NoError(t, err)
 	assert.Equal(t, iohelpers.NormalizeFileMode(0755), info.Mode())
-	aferoFS.Remove("out")
+	hackpadfs.Remove(fsys, "out")
 
 	templates, err = gatherTemplates(ctx, &config.Config{
 		InputDir:  "in",
 		OutputDir: "out",
 	}, simpleNamer("out"))
 	require.NoError(t, err)
-	assert.Len(t, templates, 3)
+	require.Len(t, templates, 3)
 	assert.Equal(t, "foo", templates[0].Text)
-	aferoFS.Remove("out")
+	hackpadfs.Remove(fsys, "out")
 }
 
 func TestCreateOutFile(t *testing.T) {
-	origfs := aferoFS
-	defer func() { aferoFS = origfs }()
-	aferoFS = afero.NewMemMapFs()
-	_ = aferoFS.Mkdir("in", 0755)
+	fsys, _ := mem.NewFS()
+	_ = hackpadfs.Mkdir(fsys, "in", 0755)
+
+	ctx := datafs.ContextWithFSProvider(context.Background(), datafs.WrappedFSProvider(fsys, "file"))
 
-	_, err := createOutFile("in", 0755, 0644, false)
+	_, err := createOutFile(ctx, "in", 0755, 0644, false)
 	assert.Error(t, err)
-	assert.IsType(t, &os.PathError{}, err)
+	assert.IsType(t, &fs.PathError{}, err)
 }
 
 func TestParseNestedTemplates(t *testing.T) {
-	ctx := context.Background()
+	wd, _ := os.Getwd()
+	t.Cleanup(func() {
+		_ = os.Chdir(wd)
+	})
+	_ = os.Chdir("/")
 
 	// in-memory test filesystem
 	fsys := fstest.MapFS{
 		"foo.t": {Data: []byte("hello world"), Mode: 0o600},
 	}
-	fsp := fsimpl.WrappedFSProvider(fsys, "file")
-	ctx = ContextWithFSProvider(ctx, fsp)
+
+	ctx := datafs.ContextWithFSProvider(context.Background(), datafs.WrappedFSProvider(fsys, "file"))
 
 	// simple test with single template
-	u, _ := url.Parse("file:///foo.t")
+	u, _ := url.Parse("foo.t")
 	nested := config.Templates{"foo": {URL: u}}
 
 	tmpl, _ := template.New("root").Parse(`{{ template "foo" }}`)
@@ -185,10 +197,11 @@ func TestParseNestedTemplates(t *testing.T) {
 	assert.Equal(t, "hello world", out.String())
 
 	// test with directory of templates
+	fsys["dir/"] = &fstest.MapFile{Mode: 0o777 | os.ModeDir}
 	fsys["dir/foo.t"] = &fstest.MapFile{Data: []byte("foo"), Mode: 0o600}
 	fsys["dir/bar.t"] = &fstest.MapFile{Data: []byte("bar"), Mode: 0o600}
 
-	u, _ = url.Parse("file:///dir/")
+	u, _ = url.Parse("dir/")
 	nested["dir"] = config.DataSource{URL: u}
 
 	tmpl, _ = template.New("root").Parse(`{{ template "dir/foo.t" }} {{ template "dir/bar.t" }}`)