diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml index 5e1e048..5e46d34 100644 --- a/.github/workflows/test.yml +++ b/.github/workflows/test.yml @@ -21,5 +21,10 @@ jobs: uses: actions/setup-go@v5 with: go-version: ${{ matrix.go-version }} + + - name: Validate + if: matrix.platform == 'ubuntu-latest' + run: make validate + - name: Test run: make test diff --git a/.gitignore b/.gitignore index 7aeb466..0159b57 100644 --- a/.gitignore +++ b/.gitignore @@ -1,4 +1,3 @@ /coverage.txt /vendor -Gopkg.lock -Gopkg.toml +/build/ diff --git a/.golangci.yaml b/.golangci.yaml new file mode 100644 index 0000000..f21ef5b --- /dev/null +++ b/.golangci.yaml @@ -0,0 +1,57 @@ +linters: + disable-all: true + enable: + - asasalint + - asciicheck + - bidichk + - bodyclose + - containedctx + - contextcheck + - decorder + - dogsled + - dupl + - dupword + - durationcheck + - errcheck + - errchkjson + - errname + - errorlint + - exhaustive + - ginkgolinter + - gocheckcompilerdirectives + - gochecknoinits + - gochecksumtype + - goheader + - goimports + - gomodguard + - goprintffuncname + - gosimple + - gosmopolitan + - govet + - grouper + - importas + - ineffassign + - loggercheck + - makezero + - mirror + - misspell + - noctx + - nosprintfhostport + - promlinter + - reassign + - revive + - rowserrcheck + - sloglint + - spancheck + - sqlclosecheck + - tagalign + - tagliatelle + - tenv + - testableexamples + - typecheck + - unconvert + - unused + - usestdlibvars + - wastedassign + - whitespace + - zerologlint diff --git a/Makefile b/Makefile index 3c95dde..9178b97 100644 --- a/Makefile +++ b/Makefile @@ -3,6 +3,15 @@ GOCMD = go GOTEST = $(GOCMD) test WASIRUN_WRAPPER := $(CURDIR)/scripts/wasirun-wrapper +GOLANGCI_VERSION ?= v1.63.4 +TOOLS_BIN := $(shell mkdir -p build/tools && realpath build/tools) + +GOLANGCI = $(TOOLS_BIN)/golangci-lint-$(GOLANGCI_VERSION) +$(GOLANGCI): + rm -f $(TOOLS_BIN)/golangci-lint* + curl -sSfL https://raw.githubusercontent.com/golangci/golangci-lint/$(GOLANGCI_VERSION)/install.sh | sh -s -- -b $(TOOLS_BIN) $(GOLANGCI_VERSION) + mv $(TOOLS_BIN)/golangci-lint $(TOOLS_BIN)/golangci-lint-$(GOLANGCI_VERSION) + .PHONY: test test: $(GOTEST) -race ./... @@ -16,3 +25,24 @@ wasitest: export GOARCH=wasm wasitest: export GOOS=wasip1 wasitest: $(GOTEST) -exec $(WASIRUN_WRAPPER) ./... + +validate: validate-lint validate-dirty ## Run validation checks. + +validate-lint: $(GOLANGCI) + $(GOLANGCI) run + +define go-install-tool +@[ -f $(1) ] || { \ +set -e ;\ +echo "Downloading $(2)" ;\ +GOBIN=$(TOOLS_BIN) go install $(2) ;\ +} +endef + +validate-dirty: +ifneq ($(shell git status --porcelain --untracked-files=no),) + @echo worktree is dirty + @git --no-pager status + @git --no-pager diff + @exit 1 +endif diff --git a/fs_test.go b/fs_test.go index ecd78c6..fc99062 100644 --- a/fs_test.go +++ b/fs_test.go @@ -3,7 +3,7 @@ package billy_test import ( "testing" - . "github.com/go-git/go-billy/v6" + . "github.com/go-git/go-billy/v6" //nolint "github.com/go-git/go-billy/v6/internal/test" "github.com/stretchr/testify/assert" ) diff --git a/helper/chroot/chroot.go b/helper/chroot/chroot.go index 0ea7710..eca8791 100644 --- a/helper/chroot/chroot.go +++ b/helper/chroot/chroot.go @@ -11,7 +11,7 @@ import ( ) // ChrootHelper is a helper to implement billy.Chroot. -type ChrootHelper struct { +type ChrootHelper struct { //nolint underlying billy.Filesystem base string } diff --git a/helper/chroot/chroot_test.go b/helper/chroot/chroot_test.go index ba4bd52..cd7bb6b 100644 --- a/helper/chroot/chroot_test.go +++ b/helper/chroot/chroot_test.go @@ -8,6 +8,7 @@ import ( "github.com/go-git/go-billy/v6" "github.com/go-git/go-billy/v6/internal/test" "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" ) func TestCreate(t *testing.T) { @@ -15,7 +16,7 @@ func TestCreate(t *testing.T) { fs := New(m, "/foo") f, err := fs.Create("bar/qux") - assert.NoError(t, err) + require.NoError(t, err) assert.Equal(t, f.Name(), filepath.Join("bar", "qux")) assert.Len(t, m.CreateArgs, 1) @@ -35,7 +36,7 @@ func TestLeadingPeriodsPathNotCrossedBoundary(t *testing.T) { fs := New(m, "/foo") f, err := fs.Create("..foo") - assert.NoError(t, err) + require.NoError(t, err) assert.Equal(t, f.Name(), "..foo") } @@ -44,7 +45,7 @@ func TestOpen(t *testing.T) { fs := New(m, "/foo") f, err := fs.Open("bar/qux") - assert.NoError(t, err) + require.NoError(t, err) assert.Equal(t, f.Name(), filepath.Join("bar", "qux")) assert.Len(t, m.OpenArgs, 1) @@ -56,7 +57,7 @@ func TestChroot(t *testing.T) { fs, _ := New(m, "/foo").Chroot("baz") f, err := fs.Open("bar/qux") - assert.NoError(t, err) + require.NoError(t, err) assert.Equal(t, f.Name(), filepath.Join("bar", "qux")) assert.Len(t, m.OpenArgs, 1) @@ -84,7 +85,7 @@ func TestOpenFile(t *testing.T) { fs := New(m, "/foo") f, err := fs.OpenFile("bar/qux", 42, 0777) - assert.NoError(t, err) + require.NoError(t, err) assert.Equal(t, f.Name(), filepath.Join("bar", "qux")) assert.Len(t, m.OpenFileArgs, 1) @@ -104,7 +105,7 @@ func TestStat(t *testing.T) { fs := New(m, "/foo") _, err := fs.Stat("bar/qux") - assert.NoError(t, err) + require.NoError(t, err) assert.Len(t, m.StatArgs, 1) assert.Equal(t, m.StatArgs[0], "/foo/bar/qux") @@ -123,7 +124,7 @@ func TestRename(t *testing.T) { fs := New(m, "/foo") err := fs.Rename("bar/qux", "qux/bar") - assert.NoError(t, err) + require.NoError(t, err) assert.Len(t, m.RenameArgs, 1) assert.Equal(t, m.RenameArgs[0], [2]string{"/foo/bar/qux", "/foo/qux/bar"}) @@ -145,7 +146,7 @@ func TestRemove(t *testing.T) { fs := New(m, "/foo") err := fs.Remove("bar/qux") - assert.NoError(t, err) + require.NoError(t, err) assert.Len(t, m.RemoveArgs, 1) assert.Equal(t, m.RemoveArgs[0], "/foo/bar/qux") @@ -164,7 +165,7 @@ func TestTempFile(t *testing.T) { fs := New(m, "/foo") _, err := fs.TempFile("bar", "qux") - assert.NoError(t, err) + require.NoError(t, err) assert.Len(t, m.TempFileArgs, 1) assert.Equal(t, m.TempFileArgs[0], [2]string{"/foo/bar", "qux"}) @@ -191,7 +192,7 @@ func TestReadDir(t *testing.T) { fs := New(m, "/foo") _, err := fs.ReadDir("bar") - assert.NoError(t, err) + require.NoError(t, err) assert.Len(t, m.ReadDirArgs, 1) assert.Equal(t, m.ReadDirArgs[0], "/foo/bar") @@ -218,7 +219,7 @@ func TestMkDirAll(t *testing.T) { fs := New(m, "/foo") err := fs.MkdirAll("bar", 0777) - assert.NoError(t, err) + require.NoError(t, err) assert.Len(t, m.MkdirAllArgs, 1) assert.Equal(t, m.MkdirAllArgs[0], [2]interface{}{"/foo/bar", os.FileMode(0777)}) @@ -245,7 +246,7 @@ func TestLstat(t *testing.T) { fs := New(m, "/foo") _, err := fs.Lstat("qux") - assert.NoError(t, err) + require.NoError(t, err) assert.Len(t, m.LstatArgs, 1) assert.Equal(t, m.LstatArgs[0], "/foo/qux") @@ -272,7 +273,7 @@ func TestSymlink(t *testing.T) { fs := New(m, "/foo") err := fs.Symlink("../baz", "qux/bar") - assert.NoError(t, err) + require.NoError(t, err) assert.Len(t, m.SymlinkArgs, 1) assert.Equal(t, m.SymlinkArgs[0], [2]string{filepath.FromSlash("../baz"), "/foo/qux/bar"}) @@ -283,7 +284,7 @@ func TestSymlinkWithAbsoluteTarget(t *testing.T) { fs := New(m, "/foo") err := fs.Symlink("/bar", "qux/baz") - assert.NoError(t, err) + require.NoError(t, err) assert.Len(t, m.SymlinkArgs, 1) assert.Equal(t, m.SymlinkArgs[0], [2]string{filepath.FromSlash("/foo/bar"), "/foo/qux/baz"}) @@ -310,7 +311,7 @@ func TestReadlink(t *testing.T) { fs := New(m, "/foo") link, err := fs.Readlink("/qux") - assert.NoError(t, err) + require.NoError(t, err) assert.Equal(t, link, filepath.FromSlash("/qux")) assert.Len(t, m.ReadlinkArgs, 1) @@ -322,7 +323,7 @@ func TestReadlinkWithRelative(t *testing.T) { fs := New(m, "/foo") link, err := fs.Readlink("qux/bar") - assert.NoError(t, err) + require.NoError(t, err) assert.Equal(t, link, filepath.FromSlash("/qux/bar")) assert.Len(t, m.ReadlinkArgs, 1) diff --git a/helper/iofs/iofs_test.go b/helper/iofs/iofs_test.go index ec9c519..fe536cb 100644 --- a/helper/iofs/iofs_test.go +++ b/helper/iofs/iofs_test.go @@ -17,10 +17,6 @@ type errorList interface { Unwrap() []error } -type wrappedError interface { - Unwrap() error -} - // TestWithFSTest leverages the packaged Go fstest package, which seems comprehensive. func TestWithFSTest(t *testing.T) { t.Parallel() @@ -32,17 +28,17 @@ func TestWithFSTest(t *testing.T) { "bar.txt": "goodbye, world", filepath.Join("dir", "baz.txt"): "こんにちわ, world", } - created_files := make([]string, 0, len(files)) + createdFiles := make([]string, 0, len(files)) for filename, contents := range files { makeFile(memfs, t, filename, contents) - created_files = append(created_files, filename) + createdFiles = append(createdFiles, filename) } if runtime.GOOS == "windows" { t.Skip("fstest.TestFS is not yet windows path aware") } - err := fstest.TestFS(iofs, created_files...) + err := fstest.TestFS(iofs, createdFiles...) if err != nil { checkFsTestError(t, err, files) } @@ -101,7 +97,6 @@ func checkFsTestError(t *testing.T, err error, files map[string]string) { // has nicely-Joined wrapped errors. Try that first. if errs, ok := err.(errorList); ok { for _, e := range errs.Unwrap() { - if strings.Contains(e.Error(), "ModTime") { // Memfs returns the current time for Stat().ModTime(), which triggers // a diff complaint in fstest. We can ignore this, or store modtimes @@ -129,10 +124,10 @@ func checkFsTestError(t *testing.T, err error, files map[string]string) { // We filter on "empty line" or "ModTime" or "$filename: mismatch" to ignore these. lines := strings.Split(err.Error(), "\n") filtered := make([]string, 0, len(lines)) - filename_mismatches := make(map[string]struct{}, len(files)*2) + mismatches := make(map[string]struct{}, len(files)*2) for name := range files { for dirname := name; dirname != "."; dirname = filepath.Dir(dirname) { - filename_mismatches[dirname+": mismatch:"] = struct{}{} + mismatches[dirname+": mismatch:"] = struct{}{} } } if strings.TrimSpace(lines[0]) == "TestFS found errors:" { @@ -144,7 +139,7 @@ func checkFsTestError(t *testing.T, err error, files map[string]string) { continue } - if _, ok := filename_mismatches[trimmed]; ok { + if _, ok := mismatches[trimmed]; ok { continue } filtered = append(filtered, line) diff --git a/helper/mount/mount.go b/helper/mount/mount.go index a3d58d9..1343794 100644 --- a/helper/mount/mount.go +++ b/helper/mount/mount.go @@ -169,40 +169,40 @@ func (h *Mount) Underlying() billy.Basic { } // Capabilities implements the Capable interface. -func (fs *Mount) Capabilities() billy.Capability { - return billy.Capabilities(fs.underlying) & billy.Capabilities(fs.source) +func (h *Mount) Capabilities() billy.Capability { + return billy.Capabilities(h.underlying) & billy.Capabilities(h.source) } -func (fs *Mount) getBasicAndPath(path string) (billy.Basic, string) { +func (h *Mount) getBasicAndPath(path string) (billy.Basic, string) { path = cleanPath(path) - if !fs.isMountpoint(path) { - return fs.underlying, path + if !h.isMountpoint(path) { + return h.underlying, path } - return fs.source, fs.mustRelToMountpoint(path) + return h.source, h.mustRelToMountpoint(path) } -func (fs *Mount) getDirAndPath(path string) (billy.Dir, string, error) { +func (h *Mount) getDirAndPath(path string) (billy.Dir, string, error) { path = cleanPath(path) - if !fs.isMountpoint(path) { - return fs.underlying.(billy.Dir), path, nil + if !h.isMountpoint(path) { + return h.underlying.(billy.Dir), path, nil } - return fs.source.(billy.Dir), fs.mustRelToMountpoint(path), nil + return h.source.(billy.Dir), h.mustRelToMountpoint(path), nil } -func (fs *Mount) getSymlinkAndPath(path string) (billy.Symlink, string, error) { +func (h *Mount) getSymlinkAndPath(path string) (billy.Symlink, string, error) { path = cleanPath(path) - if !fs.isMountpoint(path) { - return fs.underlying.(billy.Symlink), path, nil + if !h.isMountpoint(path) { + return h.underlying.(billy.Symlink), path, nil } - return fs.source.(billy.Symlink), fs.mustRelToMountpoint(path), nil + return h.source.(billy.Symlink), h.mustRelToMountpoint(path), nil } -func (fs *Mount) mustRelToMountpoint(path string) string { +func (h *Mount) mustRelToMountpoint(path string) string { path = cleanPath(path) - fullpath, err := filepath.Rel(fs.mountpoint, path) + fullpath, err := filepath.Rel(h.mountpoint, path) if err != nil { panic(err) } @@ -210,9 +210,9 @@ func (fs *Mount) mustRelToMountpoint(path string) string { return fullpath } -func (fs *Mount) isMountpoint(path string) bool { +func (h *Mount) isMountpoint(path string) bool { path = cleanPath(path) - return strings.HasPrefix(path, fs.mountpoint) + return strings.HasPrefix(path, h.mountpoint) } func cleanPath(path string) string { diff --git a/helper/mount/mount_test.go b/helper/mount/mount_test.go index e4ac2e1..aa6ff41 100644 --- a/helper/mount/mount_test.go +++ b/helper/mount/mount_test.go @@ -10,6 +10,7 @@ import ( "github.com/go-git/go-billy/v6/memfs" "github.com/go-git/go-billy/v6/util" "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" ) type mock struct { @@ -38,12 +39,12 @@ func setup() (helper *Mount, underlying *mock, source *mock) { func TestCreate(t *testing.T) { helper, underlying, source := setup() f, err := helper.Create("bar/qux") - assert.NoError(t, err) + require.NoError(t, err) assert.Equal(t, filepath.Join("bar", "qux"), f.Name()) assert.Len(t, underlying.CreateArgs, 1) assert.Equal(t, filepath.Join("bar", "qux"), underlying.CreateArgs[0]) - assert.Len(t, source.CreateArgs, 0) + assert.Empty(t, source.CreateArgs) } func TestCreateMountPoint(t *testing.T) { @@ -56,10 +57,10 @@ func TestCreateMountPoint(t *testing.T) { func TestCreateInMount(t *testing.T) { helper, underlying, source := setup() f, err := helper.Create("foo/bar/qux") - assert.NoError(t, err) + require.NoError(t, err) assert.Equal(t, filepath.Join("foo", "bar", "qux"), f.Name()) - assert.Len(t, underlying.CreateArgs, 0) + assert.Empty(t, underlying.CreateArgs) assert.Len(t, source.CreateArgs, 1) assert.Equal(t, filepath.Join("bar", "qux"), source.CreateArgs[0]) } @@ -67,12 +68,12 @@ func TestCreateInMount(t *testing.T) { func TestOpen(t *testing.T) { helper, underlying, source := setup() f, err := helper.Open("bar/qux") - assert.NoError(t, err) + require.NoError(t, err) assert.Equal(t, filepath.Join("bar", "qux"), f.Name()) assert.Len(t, underlying.OpenArgs, 1) assert.Equal(t, filepath.Join("bar", "qux"), underlying.OpenArgs[0]) - assert.Len(t, source.OpenArgs, 0) + assert.Empty(t, source.OpenArgs) } func TestOpenMountPoint(t *testing.T) { @@ -85,10 +86,10 @@ func TestOpenMountPoint(t *testing.T) { func TestOpenInMount(t *testing.T) { helper, underlying, source := setup() f, err := helper.Open("foo/bar/qux") - assert.NoError(t, err) + require.NoError(t, err) assert.Equal(t, filepath.Join("foo", "bar", "qux"), f.Name()) - assert.Len(t, underlying.OpenArgs, 0) + assert.Empty(t, underlying.OpenArgs) assert.Len(t, source.OpenArgs, 1) assert.Equal(t, source.OpenArgs[0], filepath.Join("bar", "qux")) } @@ -96,13 +97,13 @@ func TestOpenInMount(t *testing.T) { func TestOpenFile(t *testing.T) { helper, underlying, source := setup() f, err := helper.OpenFile("bar/qux", 42, 0777) - assert.NoError(t, err) + require.NoError(t, err) assert.Equal(t, filepath.Join("bar", "qux"), f.Name()) assert.Len(t, underlying.OpenFileArgs, 1) assert.Equal(t, underlying.OpenFileArgs[0], [3]interface{}{filepath.Join("bar", "qux"), 42, os.FileMode(0777)}) - assert.Len(t, source.OpenFileArgs, 0) + assert.Empty(t, source.OpenFileArgs) } func TestOpenFileMountPoint(t *testing.T) { @@ -115,10 +116,10 @@ func TestOpenFileMountPoint(t *testing.T) { func TestOpenFileInMount(t *testing.T) { helper, underlying, source := setup() f, err := helper.OpenFile("foo/bar/qux", 42, 0777) - assert.NoError(t, err) + require.NoError(t, err) assert.Equal(t, filepath.Join("foo", "bar", "qux"), f.Name()) - assert.Len(t, underlying.OpenFileArgs, 0) + assert.Empty(t, underlying.OpenFileArgs) assert.Len(t, source.OpenFileArgs, 1) assert.Equal(t, source.OpenFileArgs[0], [3]interface{}{filepath.Join("bar", "qux"), 42, os.FileMode(0777)}) @@ -127,19 +128,19 @@ func TestOpenFileInMount(t *testing.T) { func TestStat(t *testing.T) { helper, underlying, source := setup() _, err := helper.Stat("bar/qux") - assert.NoError(t, err) + require.NoError(t, err) assert.Len(t, underlying.StatArgs, 1) assert.Equal(t, underlying.StatArgs[0], filepath.Join("bar", "qux")) - assert.Len(t, source.StatArgs, 0) + assert.Empty(t, source.StatArgs) } func TestStatInMount(t *testing.T) { helper, underlying, source := setup() _, err := helper.Stat("foo/bar/qux") - assert.NoError(t, err) + require.NoError(t, err) - assert.Len(t, underlying.StatArgs, 0) + assert.Empty(t, underlying.StatArgs) assert.Len(t, source.StatArgs, 1) assert.Equal(t, source.StatArgs[0], filepath.Join("bar", "qux")) } @@ -147,19 +148,19 @@ func TestStatInMount(t *testing.T) { func TestRename(t *testing.T) { helper, underlying, source := setup() err := helper.Rename("bar/qux", "qux") - assert.NoError(t, err) + require.NoError(t, err) assert.Len(t, underlying.RenameArgs, 1) assert.Equal(t, underlying.RenameArgs[0], [2]string{"bar/qux", "qux"}) - assert.Len(t, source.RenameArgs, 0) + assert.Empty(t, source.RenameArgs) } func TestRenameInMount(t *testing.T) { helper, underlying, source := setup() err := helper.Rename("foo/bar/qux", "foo/qux") - assert.NoError(t, err) + require.NoError(t, err) - assert.Len(t, underlying.RenameArgs, 0) + assert.Empty(t, underlying.RenameArgs) assert.Len(t, source.RenameArgs, 1) assert.Equal(t, source.RenameArgs[0], [2]string{filepath.Join("bar", "qux"), "qux"}) @@ -169,23 +170,24 @@ func TestRenameCross(t *testing.T) { underlying := memfs.New() source := memfs.New() - util.WriteFile(underlying, "file", []byte("foo"), 0777) + err := util.WriteFile(underlying, "file", []byte("foo"), 0777) + require.NoError(t, err) fs := New(underlying, "/foo", source) - err := fs.Rename("file", "foo/file") - assert.NoError(t, err) + err = fs.Rename("file", "foo/file") + require.NoError(t, err) _, err = underlying.Stat("file") assert.Equal(t, err, os.ErrNotExist) _, err = source.Stat("file") - assert.NoError(t, err) + require.NoError(t, err) err = fs.Rename("foo/file", "file") - assert.NoError(t, err) + require.NoError(t, err) _, err = underlying.Stat("file") - assert.NoError(t, err) + require.NoError(t, err) _, err = source.Stat("file") assert.Equal(t, err, os.ErrNotExist) @@ -194,11 +196,11 @@ func TestRenameCross(t *testing.T) { func TestRemove(t *testing.T) { helper, underlying, source := setup() err := helper.Remove("bar/qux") - assert.NoError(t, err) + require.NoError(t, err) assert.Len(t, underlying.RemoveArgs, 1) assert.Equal(t, underlying.RemoveArgs[0], filepath.Join("bar", "qux")) - assert.Len(t, source.RemoveArgs, 0) + assert.Empty(t, source.RemoveArgs) } func TestRemoveMountPoint(t *testing.T) { @@ -210,9 +212,9 @@ func TestRemoveMountPoint(t *testing.T) { func TestRemoveInMount(t *testing.T) { helper, underlying, source := setup() err := helper.Remove("foo/bar/qux") - assert.NoError(t, err) + require.NoError(t, err) - assert.Len(t, underlying.RemoveArgs, 0) + assert.Empty(t, underlying.RemoveArgs) assert.Len(t, source.RemoveArgs, 1) assert.Equal(t, source.RemoveArgs[0], filepath.Join("bar", "qux")) } @@ -220,11 +222,11 @@ func TestRemoveInMount(t *testing.T) { func TestReadDir(t *testing.T) { helper, underlying, source := setup() _, err := helper.ReadDir("bar/qux") - assert.NoError(t, err) + require.NoError(t, err) assert.Len(t, underlying.ReadDirArgs, 1) assert.Equal(t, underlying.ReadDirArgs[0], filepath.Join("bar", "qux")) - assert.Len(t, source.ReadDirArgs, 0) + assert.Empty(t, source.ReadDirArgs) } func TestJoin(t *testing.T) { @@ -233,15 +235,15 @@ func TestJoin(t *testing.T) { assert.Len(t, underlying.JoinArgs, 1) assert.Equal(t, underlying.JoinArgs[0], []string{"foo", "bar"}) - assert.Len(t, source.JoinArgs, 0) + assert.Empty(t, source.JoinArgs) } func TestReadDirInMount(t *testing.T) { helper, underlying, source := setup() _, err := helper.ReadDir("foo/bar/qux") - assert.NoError(t, err) + require.NoError(t, err) - assert.Len(t, underlying.ReadDirArgs, 0) + assert.Empty(t, underlying.ReadDirArgs) assert.Len(t, source.ReadDirArgs, 1) assert.Equal(t, source.ReadDirArgs[0], filepath.Join("bar", "qux")) } @@ -249,20 +251,20 @@ func TestReadDirInMount(t *testing.T) { func TestMkdirAll(t *testing.T) { helper, underlying, source := setup() err := helper.MkdirAll("bar/qux", 0777) - assert.NoError(t, err) + require.NoError(t, err) assert.Len(t, underlying.MkdirAllArgs, 1) assert.Equal(t, underlying.MkdirAllArgs[0], [2]interface{}{filepath.Join("bar", "qux"), os.FileMode(0777)}) - assert.Len(t, source.MkdirAllArgs, 0) + assert.Empty(t, source.MkdirAllArgs) } func TestMkdirAllInMount(t *testing.T) { helper, underlying, source := setup() err := helper.MkdirAll("foo/bar/qux", 0777) - assert.NoError(t, err) + require.NoError(t, err) - assert.Len(t, underlying.MkdirAllArgs, 0) + assert.Empty(t, underlying.MkdirAllArgs) assert.Len(t, source.MkdirAllArgs, 1) assert.Equal(t, source.MkdirAllArgs[0], [2]interface{}{filepath.Join("bar", "qux"), os.FileMode(0777)}) @@ -271,19 +273,19 @@ func TestMkdirAllInMount(t *testing.T) { func TestLstat(t *testing.T) { helper, underlying, source := setup() _, err := helper.Lstat("bar/qux") - assert.NoError(t, err) + require.NoError(t, err) assert.Len(t, underlying.LstatArgs, 1) assert.Equal(t, underlying.LstatArgs[0], filepath.Join("bar", "qux")) - assert.Len(t, source.LstatArgs, 0) + assert.Empty(t, source.LstatArgs) } func TestLstatInMount(t *testing.T) { helper, underlying, source := setup() _, err := helper.Lstat("foo/bar/qux") - assert.NoError(t, err) + require.NoError(t, err) - assert.Len(t, underlying.LstatArgs, 0) + assert.Empty(t, underlying.LstatArgs) assert.Len(t, source.LstatArgs, 1) assert.Equal(t, source.LstatArgs[0], filepath.Join("bar", "qux")) } @@ -291,12 +293,12 @@ func TestLstatInMount(t *testing.T) { func TestSymlink(t *testing.T) { helper, underlying, source := setup() err := helper.Symlink("../baz", "bar/qux") - assert.NoError(t, err) + require.NoError(t, err) assert.Len(t, underlying.SymlinkArgs, 1) assert.Equal(t, underlying.SymlinkArgs[0], [2]string{"../baz", filepath.Join("bar", "qux")}) - assert.Len(t, source.SymlinkArgs, 0) + assert.Empty(t, source.SymlinkArgs) } func TestSymlinkCrossMount(t *testing.T) { @@ -317,9 +319,9 @@ func TestSymlinkCrossMount(t *testing.T) { func TestSymlinkInMount(t *testing.T) { helper, underlying, source := setup() err := helper.Symlink("../baz", "foo/bar/qux") - assert.NoError(t, err) + require.NoError(t, err) - assert.Len(t, underlying.SymlinkArgs, 0) + assert.Empty(t, underlying.SymlinkArgs) assert.Len(t, source.SymlinkArgs, 1) assert.Equal(t, source.SymlinkArgs[0], [2]string{"../baz", filepath.Join("bar", "qux")}) @@ -328,19 +330,19 @@ func TestSymlinkInMount(t *testing.T) { func TestRadlink(t *testing.T) { helper, underlying, source := setup() _, err := helper.Readlink("bar/qux") - assert.NoError(t, err) + require.NoError(t, err) assert.Len(t, underlying.ReadlinkArgs, 1) assert.Equal(t, underlying.ReadlinkArgs[0], filepath.Join("bar", "qux")) - assert.Len(t, source.ReadlinkArgs, 0) + assert.Empty(t, source.ReadlinkArgs) } func TestReadlinkInMount(t *testing.T) { helper, underlying, source := setup() _, err := helper.Readlink("foo/bar/qux") - assert.NoError(t, err) + require.NoError(t, err) - assert.Len(t, underlying.ReadlinkArgs, 0) + assert.Empty(t, underlying.ReadlinkArgs) assert.Len(t, source.ReadlinkArgs, 1) assert.Equal(t, source.ReadlinkArgs[0], filepath.Join("bar", "qux")) } diff --git a/helper/temporal/temporal_test.go b/helper/temporal/temporal_test.go index 1fbb68f..6859e83 100644 --- a/helper/temporal/temporal_test.go +++ b/helper/temporal/temporal_test.go @@ -6,14 +6,15 @@ import ( "github.com/go-git/go-billy/v6/memfs" "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" ) func TestTempFileDefaultPath(t *testing.T) { fs := New(memfs.New(), "foo") f, err := fs.TempFile("", "bar") - assert.NoError(t, err) - assert.NoError(t, f.Close()) + require.NoError(t, err) + require.NoError(t, f.Close()) assert.True(t, strings.HasPrefix(f.Name(), fs.Join("foo", "bar"))) } diff --git a/internal/test/mock.go b/internal/test/mock.go index 70d9436..a7bd7c0 100644 --- a/internal/test/mock.go +++ b/internal/test/mock.go @@ -112,15 +112,15 @@ func (f *FileMock) Name() string { return f.name } -func (*FileMock) ReadAt(b []byte, off int64) (int, error) { +func (*FileMock) ReadAt(_ []byte, _ int64) (int, error) { return 0, nil } -func (*FileMock) WriteAt(b []byte, off int64) (int, error) { +func (*FileMock) WriteAt(_ []byte, _ int64) (int, error) { return 0, nil } -func (*FileMock) Seek(offset int64, whence int) (int64, error) { +func (*FileMock) Seek(_ int64, _ int) (int64, error) { return 0, nil } @@ -140,7 +140,7 @@ func (*FileMock) Stat() (fs.FileInfo, error) { return nil, nil } -func (*FileMock) Truncate(size int64) error { +func (*FileMock) Truncate(_ int64) error { return nil } diff --git a/memfs/memory.go b/memfs/memory.go index 2885324..2f70e96 100644 --- a/memfs/memory.go +++ b/memfs/memory.go @@ -6,6 +6,7 @@ import ( "fmt" "io" "io/fs" + "log" "os" "path/filepath" "sort" @@ -20,19 +21,18 @@ import ( const separator = filepath.Separator -var errNotLink = errors.New("not a link") - // Memory a very convenient filesystem based on memory files. type Memory struct { s *storage - - tempCount int } // New returns a new Memory filesystem. func New() billy.Filesystem { fs := &Memory{s: newStorage()} - fs.s.New("/", 0755|os.ModeDir, 0) + _, err := fs.s.New("/", 0755|os.ModeDir, 0) + if err != nil { + log.Printf("failed to create root dir: %v", err) + } return chroot.New(fs, string(separator)) } @@ -164,12 +164,6 @@ func (fs *Memory) TempFile(dir, prefix string) (billy.File, error) { return util.TempFile(fs, dir, prefix) } -func (fs *Memory) getTempFilename(dir, prefix string) string { - fs.tempCount++ - filename := fmt.Sprintf("%s_%d_%d", prefix, fs.tempCount, time.Now().UnixNano()) - return fs.Join(dir, filename) -} - func (fs *Memory) Rename(from, to string) error { return fs.s.Rename(from, to) } @@ -320,7 +314,7 @@ func (f *file) Truncate(size int64) error { } func (f *file) Duplicate(filename string, mode fs.FileMode, flag int) billy.File { - new := &file{ + nf := &file{ name: filename, content: f.content, mode: mode, @@ -329,14 +323,14 @@ func (f *file) Duplicate(filename string, mode fs.FileMode, flag int) billy.File } if isTruncate(flag) { - new.content.Truncate() + nf.content.Truncate() } if isAppend(flag) { - new.position = int64(new.content.Len()) + nf.position = int64(nf.content.Len()) } - return new + return nf } func (f *file) Stat() (os.FileInfo, error) { diff --git a/memfs/memory_test.go b/memfs/memory_test.go index d953d45..75157ab 100644 --- a/memfs/memory_test.go +++ b/memfs/memory_test.go @@ -20,7 +20,7 @@ var _ fs.File = &file{} func TestRootExists(t *testing.T) { fs := New() f, err := fs.Stat("/") - assert.NoError(t, err) + require.NoError(t, err) assert.True(t, f.IsDir()) } @@ -69,14 +69,14 @@ func TestModTime(t *testing.T) { func TestNegativeOffsets(t *testing.T) { fs := New() f, err := fs.Create("negative") - assert.NoError(t, err) + require.NoError(t, err) buf := make([]byte, 100) _, err = f.ReadAt(buf, -100) assert.ErrorContains(t, err, "readat negative: negative offset") _, err = f.Seek(-100, io.SeekCurrent) - assert.NoError(t, err) + require.NoError(t, err) _, err = f.Write(buf) assert.ErrorContains(t, err, "writeat negative: negative offset") } @@ -84,12 +84,12 @@ func TestNegativeOffsets(t *testing.T) { func TestExclusive(t *testing.T) { fs := New() f, err := fs.OpenFile("exclusive", os.O_CREATE|os.O_EXCL|os.O_RDWR, 0666) - assert.NoError(t, err) + require.NoError(t, err) fmt.Fprint(f, "mememememe") err = f.Close() - assert.NoError(t, err) + require.NoError(t, err) _, err = fs.OpenFile("exclusive", os.O_CREATE|os.O_EXCL|os.O_RDWR, 0666) assert.ErrorContains(t, err, os.ErrExist.Error()) @@ -106,13 +106,13 @@ func TestOrder(t *testing.T) { fs := New() for _, f := range files { _, err = fs.Create(f) - assert.NoError(t, err) + require.NoError(t, err) } attempts := 30 for n := 0; n < attempts; n++ { actual, err := fs.ReadDir("") - assert.NoError(t, err) + require.NoError(t, err) for i, f := range files { assert.Equal(t, actual[i].Name(), f) @@ -130,20 +130,20 @@ func TestNotFound(t *testing.T) { func TestTruncateAppend(t *testing.T) { fs := New() err := util.WriteFile(fs, "truncate_append", []byte("file-content"), 0666) - assert.NoError(t, err) + require.NoError(t, err) f, err := fs.OpenFile("truncate_append", os.O_WRONLY|os.O_TRUNC|os.O_APPEND, 0666) - assert.NoError(t, err) + require.NoError(t, err) n, err := f.Write([]byte("replace")) - assert.NoError(t, err) + require.NoError(t, err) assert.Equal(t, n, len("replace")) err = f.Close() - assert.NoError(t, err) + require.NoError(t, err) data, err := util.ReadFile(fs, "truncate_append") - assert.NoError(t, err) + require.NoError(t, err) assert.Equal(t, string(data), "replace") } @@ -191,17 +191,17 @@ func TestReadlink(t *testing.T) { fs := New() // arrange fs for tests. - assert.NoError(t, fs.Symlink("/self", "/self")) - assert.NoError(t, fs.Symlink("/foo", "/bar")) - assert.NoError(t, fs.Symlink("c:\\test\\123", "/win")) - assert.NoError(t, fs.Symlink("\\test\\123", "/net")) + require.NoError(t, fs.Symlink("/self", "/self")) + require.NoError(t, fs.Symlink("/foo", "/bar")) + require.NoError(t, fs.Symlink("c:\\test\\123", "/win")) + require.NoError(t, fs.Symlink("\\test\\123", "/net")) for _, tc := range tests { t.Run(tc.name, func(t *testing.T) { got, err := fs.Readlink(tc.link) if tc.wantErr == nil { - assert.NoError(t, err) + require.NoError(t, err) assert.Equal(t, tc.want, got) } else { assert.ErrorIs(t, err, *tc.wantErr) @@ -288,9 +288,9 @@ func TestSymlink2(t *testing.T) { // arrange fs for tests. err := fs.MkdirAll("/dir", 0o600) - assert.NoError(t, err) + require.NoError(t, err) _, err = fs.Create("/file") - assert.NoError(t, err) + require.NoError(t, err) for _, tc := range tests { t.Run(tc.name, func(t *testing.T) { @@ -298,7 +298,7 @@ func TestSymlink2(t *testing.T) { if tc.wantErr == "" { got, err := fs.Readlink(tc.link) - assert.NoError(t, err) + require.NoError(t, err) assert.Equal(t, tc.want, got) } else { assert.ErrorContains(t, err, tc.wantErr) @@ -347,13 +347,13 @@ func TestJoin(t *testing.T) { func TestSymlink(t *testing.T) { fs := New() err := fs.Symlink("test", "test") - assert.NoError(t, err) + require.NoError(t, err) f, err := fs.Open("test") - assert.NoError(t, err) + require.NoError(t, err) assert.NotNil(t, f) fi, err := fs.ReadDir("test") - assert.NoError(t, err) + require.NoError(t, err) assert.Nil(t, fi) } diff --git a/memfs/storage.go b/memfs/storage.go index 5dccbad..c0830e5 100644 --- a/memfs/storage.go +++ b/memfs/storage.go @@ -52,7 +52,11 @@ func (s *storage) New(path string, mode fs.FileMode, flag int) (*file, error) { } s.files[path] = f - s.createParent(path, mode, f) + err := s.createParent(path, mode, f) + if err != nil { + return nil, fmt.Errorf("failed to create parent: %w", err) + } + return f, nil } diff --git a/osfs/os_bound.go b/osfs/os_bound.go index 97112e4..8cdade5 100644 --- a/osfs/os_bound.go +++ b/osfs/os_bound.go @@ -259,7 +259,7 @@ func (fs *BoundOS) abs(filename string) (string, error) { path, err := securejoin.SecureJoin(fs.baseDir, filename) if err != nil { - return "", nil + return "", err } if fs.deduplicatePath { @@ -272,18 +272,6 @@ func (fs *BoundOS) abs(filename string) (string, error) { return path, nil } -// insideBaseDir checks whether filename is located within -// the fs.baseDir. -func (fs *BoundOS) insideBaseDir(filename string) (bool, error) { - if filename == fs.baseDir { - return true, nil - } - if !strings.HasPrefix(filename, fs.baseDir+string(filepath.Separator)) { - return false, fmt.Errorf("path outside base dir") - } - return true, nil -} - // insideBaseDirEval checks whether filename is contained within // a dir that is within the fs.baseDir, by first evaluating any symlinks // that either filename or fs.baseDir may contain. diff --git a/osfs/os_bound_test.go b/osfs/os_bound_test.go index 43febe5..29539bd 100644 --- a/osfs/os_bound_test.go +++ b/osfs/os_bound_test.go @@ -29,6 +29,7 @@ import ( "github.com/go-git/go-billy/v6" "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" ) func TestOpen(t *testing.T) { @@ -42,7 +43,8 @@ func TestOpen(t *testing.T) { { name: "file: rel same dir", before: func(dir string) billy.Filesystem { - os.WriteFile(filepath.Join(dir, "test-file"), []byte("anything"), 0o600) + err := os.WriteFile(filepath.Join(dir, "test-file"), []byte("anything"), 0o600) + require.NoError(t, err) return newBoundOS(dir, true) }, filename: "test-file", @@ -50,7 +52,8 @@ func TestOpen(t *testing.T) { { name: "file: dot rel same dir", before: func(dir string) billy.Filesystem { - os.WriteFile(filepath.Join(dir, "test-file"), []byte("anything"), 0o600) + err := os.WriteFile(filepath.Join(dir, "test-file"), []byte("anything"), 0o600) + require.NoError(t, err) return newBoundOS(dir, true) }, filename: "./test-file", @@ -58,7 +61,8 @@ func TestOpen(t *testing.T) { { name: "file: rel path to above cwd", before: func(dir string) billy.Filesystem { - os.WriteFile(filepath.Join(dir, "rel-above-cwd"), []byte("anything"), 0o600) + err := os.WriteFile(filepath.Join(dir, "rel-above-cwd"), []byte("anything"), 0o600) + require.NoError(t, err) return newBoundOS(dir, true) }, filename: "../../rel-above-cwd", @@ -66,8 +70,10 @@ func TestOpen(t *testing.T) { { name: "file: rel path to below cwd", before: func(dir string) billy.Filesystem { - os.Mkdir(filepath.Join(dir, "sub"), 0o700) - os.WriteFile(filepath.Join(dir, "sub/rel-below-cwd"), []byte("anything"), 0o600) + err := os.Mkdir(filepath.Join(dir, "sub"), 0o700) + require.NoError(t, err) + err = os.WriteFile(filepath.Join(dir, "sub/rel-below-cwd"), []byte("anything"), 0o600) + require.NoError(t, err) return newBoundOS(dir, true) }, filename: "sub/rel-below-cwd", @@ -75,7 +81,8 @@ func TestOpen(t *testing.T) { { name: "file: abs inside cwd", before: func(dir string) billy.Filesystem { - os.WriteFile(filepath.Join(dir, "abs-test-file"), []byte("anything"), 0o600) + err := os.WriteFile(filepath.Join(dir, "abs-test-file"), []byte("anything"), 0o600) + require.NoError(t, err) return newBoundOS(dir, true) }, filename: "abs-test-file", @@ -93,8 +100,10 @@ func TestOpen(t *testing.T) { name: "symlink: same dir", before: func(dir string) billy.Filesystem { target := filepath.Join(dir, "target-file") - os.WriteFile(target, []byte("anything"), 0o600) - os.Symlink(target, filepath.Join(dir, "symlink")) + err := os.WriteFile(target, []byte("anything"), 0o600) + require.NoError(t, err) + err = os.Symlink(target, filepath.Join(dir, "symlink")) + require.NoError(t, err) return newBoundOS(dir, true) }, filename: "symlink", @@ -102,7 +111,8 @@ func TestOpen(t *testing.T) { { name: "symlink: rel outside cwd", before: func(dir string) billy.Filesystem { - os.Symlink("../../../../../../outside/cwd", filepath.Join(dir, "symlink")) + err := os.Symlink("../../../../../../outside/cwd", filepath.Join(dir, "symlink")) + require.NoError(t, err) return newBoundOS(dir, true) }, filename: "symlink", @@ -112,7 +122,8 @@ func TestOpen(t *testing.T) { { name: "symlink: abs outside cwd", before: func(dir string) billy.Filesystem { - os.Symlink("/some/path/outside/cwd", filepath.Join(dir, "symlink")) + err := os.Symlink("/some/path/outside/cwd", filepath.Join(dir, "symlink")) + require.NoError(t, err) return newBoundOS(dir, true) }, filename: "symlink", @@ -137,12 +148,12 @@ func TestOpen(t *testing.T) { fi, err := fs.Open(filename) if tt.wantErr != "" { - assert.ErrorContains(err, tt.wantErr) + require.ErrorContains(t, err, tt.wantErr) assert.Nil(fi) } else { - assert.NoError(err) + require.NoError(t, err) assert.NotNil(fi) - assert.NoError(fi.Close()) + require.NoError(t, fi.Close()) } }) } @@ -196,7 +207,8 @@ func Test_Symlink(t *testing.T) { name: "keep dir filemode if exists", link: "new-dir/symlink", before: func(dir string) billy.Filesystem { - os.Mkdir(filepath.Join(dir, "new-dir"), 0o701) + err := os.Mkdir(filepath.Join(dir, "new-dir"), 0o701) + require.NoError(t, err) return newBoundOS(dir, true) }, target: filepath.FromSlash("../../../some/random/path"), @@ -215,29 +227,29 @@ func Test_Symlink(t *testing.T) { // Even if CWD is changed outside of the fs instance, // the base dir must still be observed. err := os.Chdir(os.TempDir()) - assert.NoError(err) + require.NoError(t, err) link := filepath.Join(dir, tt.link) diBefore, _ := os.Lstat(filepath.Dir(link)) err = fs.Symlink(tt.target, tt.link) - assert.NoError(err) + require.NoError(t, err) fi, err := os.Lstat(link) if tt.wantStatErr != "" { - assert.ErrorContains(err, tt.wantStatErr) + require.ErrorContains(t, err, tt.wantStatErr) } else { - assert.NoError(err) + require.NoError(t, err) assert.NotNil(fi) } got, err := os.Readlink(link) - assert.NoError(err) + require.NoError(t, err) assert.Equal(tt.target, got) diAfter, err := os.Lstat(filepath.Dir(link)) - assert.NoError(err) + require.NoError(t, err) if diBefore != nil { assert.Equal(diBefore.Mode(), diAfter.Mode()) @@ -252,13 +264,13 @@ func TestTempFile(t *testing.T) { fs := newBoundOS(dir, true) f, err := fs.TempFile("", "prefix") - assert.NoError(err) + require.NoError(t, err) assert.NotNil(f) assert.Contains(f.Name(), os.TempDir()) - assert.NoError(f.Close()) + require.NoError(t, f.Close()) f, err = fs.TempFile("/above/cwd", "prefix") - assert.ErrorContains(err, fmt.Sprint(dir, filepath.FromSlash("/above/cwd/prefix"))) + require.ErrorContains(t, err, fmt.Sprint(dir, filepath.FromSlash("/above/cwd/prefix"))) assert.Nil(f) tempDir := os.TempDir() @@ -268,7 +280,7 @@ func TestTempFile(t *testing.T) { } f, err = fs.TempFile(tempDir, "prefix") - assert.ErrorContains(err, filepath.Join(dir, tempDir, "prefix")) + require.ErrorContains(t, err, filepath.Join(dir, tempDir, "prefix")) assert.Nil(f) } @@ -278,10 +290,10 @@ func TestChroot(t *testing.T) { fs := newBoundOS(tmp, true) f, err := fs.Chroot("test") - assert.NoError(err) + require.NoError(t, err) assert.NotNil(f) assert.Equal(filepath.Join(tmp, "test"), f.Root()) - assert.IsType(f, &BoundOS{}) + assert.IsType(&BoundOS{}, f) } func TestRoot(t *testing.T) { @@ -306,7 +318,8 @@ func TestReadLink(t *testing.T) { { name: "symlink: pointing to abs outside cwd", before: func(dir string) billy.Filesystem { - os.Symlink("/etc/passwd", filepath.Join(dir, "symlink")) + err := os.Symlink("/etc/passwd", filepath.Join(dir, "symlink")) + require.NoError(t, err) return newBoundOS(dir, true) }, filename: "symlink", @@ -320,7 +333,8 @@ func TestReadLink(t *testing.T) { { name: "symlink: abs symlink pointing outside cwd", before: func(dir string) billy.Filesystem { - os.Symlink("/etc/passwd", filepath.Join(dir, "symlink")) + err := os.Symlink("/etc/passwd", filepath.Join(dir, "symlink")) + require.NoError(t, err) return newBoundOS(dir, true) }, filename: "symlink", @@ -333,11 +347,15 @@ func TestReadLink(t *testing.T) { cwd := filepath.Join(dir, "current-dir") outside := filepath.Join(dir, "outside-cwd") - os.Mkdir(cwd, 0o700) - os.Mkdir(outside, 0o700) + err := os.Mkdir(cwd, 0o700) + require.NoError(t, err) + err = os.Mkdir(outside, 0o700) + require.NoError(t, err) - os.Symlink(outside, filepath.Join(cwd, "symlink")) - os.WriteFile(filepath.Join(outside, "file"), []byte("anything"), 0o600) + err = os.Symlink(outside, filepath.Join(cwd, "symlink")) + require.NoError(t, err) + err = os.WriteFile(filepath.Join(outside, "file"), []byte("anything"), 0o600) + require.NoError(t, err) return newBoundOS(cwd, true) }, @@ -352,12 +370,17 @@ func TestReadLink(t *testing.T) { cwdAlt := filepath.Join(dir, "symlink-altdir") cwdTarget := filepath.Join(dir, "cwd-target") - os.MkdirAll(cwdTarget, 0o700) - - os.WriteFile(filepath.Join(cwdTarget, "file"), []byte{}, 0o600) - os.Symlink(cwdTarget, cwd) - os.Symlink(cwdTarget, cwdAlt) - os.Symlink(filepath.Join(cwdTarget, "file"), filepath.Join(cwdAlt, "symlink-file")) + err := os.MkdirAll(cwdTarget, 0o700) + require.NoError(t, err) + + err = os.WriteFile(filepath.Join(cwdTarget, "file"), []byte{}, 0o600) + require.NoError(t, err) + err = os.Symlink(cwdTarget, cwd) + require.NoError(t, err) + err = os.Symlink(cwdTarget, cwdAlt) + require.NoError(t, err) + err = os.Symlink(filepath.Join(cwdTarget, "file"), filepath.Join(cwdAlt, "symlink-file")) + require.NoError(t, err) return newBoundOS(cwd, true) }, filename: "symlink-file", @@ -366,19 +389,25 @@ func TestReadLink(t *testing.T) { }, { name: "symlink: outside cwd + baseDir symlink", - before: func(dir string) billy.Filesystem { + before: func(dir string) billy.Filesystem { //nolint cwd := filepath.Join(dir, "symlink-dir") outside := filepath.Join(cwd, "symlink-outside") cwdTarget := filepath.Join(dir, "cwd-target") outsideDir := filepath.Join(dir, "outside") - os.Mkdir(cwdTarget, 0o700) - os.Mkdir(outsideDir, 0o700) - - os.WriteFile(filepath.Join(cwdTarget, "file"), []byte{}, 0o600) - os.Symlink(cwdTarget, cwd) - os.Symlink(outsideDir, outside) - os.Symlink(filepath.Join(cwdTarget, "file"), filepath.Join(outside, "symlink-file")) + err := os.Mkdir(cwdTarget, 0o700) + require.NoError(t, err) + err = os.Mkdir(outsideDir, 0o700) + require.NoError(t, err) + + err = os.WriteFile(filepath.Join(cwdTarget, "file"), []byte{}, 0o600) + require.NoError(t, err) + err = os.Symlink(cwdTarget, cwd) + require.NoError(t, err) + err = os.Symlink(outsideDir, outside) + require.NoError(t, err) + err = os.Symlink(filepath.Join(cwdTarget, "file"), filepath.Join(outside, "symlink-file")) + require.NoError(t, err) return newBoundOS(cwd, true) }, filename: "symlink-outside/symlink-file", @@ -407,10 +436,10 @@ func TestReadLink(t *testing.T) { got, err := fs.Readlink(filename) if tt.wantErr != "" { - assert.ErrorContains(err, tt.wantErr) + require.ErrorContains(t, err, tt.wantErr) assert.Empty(got) } else { - assert.Nil(err) + require.NoError(t, err) assert.Equal(expected, got) } }) @@ -428,7 +457,8 @@ func TestLstat(t *testing.T) { { name: "rel symlink: pointing to abs outside cwd", before: func(dir string) billy.Filesystem { - os.Symlink("/etc/passwd", filepath.Join(dir, "symlink")) + err := os.Symlink("/etc/passwd", filepath.Join(dir, "symlink")) + require.NoError(t, err) return newBoundOS(dir, true) }, filename: "symlink", @@ -436,7 +466,8 @@ func TestLstat(t *testing.T) { { name: "rel symlink: pointing to rel path above cwd", before: func(dir string) billy.Filesystem { - os.Symlink("../../../../../../../../etc/passwd", filepath.Join(dir, "symlink")) + err := os.Symlink("../../../../../../../../etc/passwd", filepath.Join(dir, "symlink")) + require.NoError(t, err) return newBoundOS(dir, true) }, filename: "symlink", @@ -444,7 +475,8 @@ func TestLstat(t *testing.T) { { name: "abs symlink: pointing to abs outside cwd", before: func(dir string) billy.Filesystem { - os.Symlink("/etc/passwd", filepath.Join(dir, "symlink")) + err := os.Symlink("/etc/passwd", filepath.Join(dir, "symlink")) + require.NoError(t, err) return newBoundOS(dir, true) }, filename: "symlink", @@ -453,7 +485,8 @@ func TestLstat(t *testing.T) { { name: "abs symlink: pointing to rel outside cwd", before: func(dir string) billy.Filesystem { - os.Symlink("../../../../../../../../etc/passwd", filepath.Join(dir, "symlink")) + err := os.Symlink("../../../../../../../../etc/passwd", filepath.Join(dir, "symlink")) + require.NoError(t, err) return newBoundOS(dir, true) }, filename: "symlink", @@ -466,12 +499,17 @@ func TestLstat(t *testing.T) { cwdAlt := filepath.Join(dir, "symlink-altdir") cwdTarget := filepath.Join(dir, "cwd-target") - os.MkdirAll(cwdTarget, 0o700) - - os.WriteFile(filepath.Join(cwdTarget, "file"), []byte{}, 0o600) - os.Symlink(cwdTarget, cwd) - os.Symlink(cwdTarget, cwdAlt) - os.Symlink(filepath.Join(cwdTarget, "file"), filepath.Join(cwdAlt, "symlink-file")) + err := os.MkdirAll(cwdTarget, 0o700) + require.NoError(t, err) + + err = os.WriteFile(filepath.Join(cwdTarget, "file"), []byte{}, 0o600) + require.NoError(t, err) + err = os.Symlink(cwdTarget, cwd) + require.NoError(t, err) + err = os.Symlink(cwdTarget, cwdAlt) + require.NoError(t, err) + err = os.Symlink(filepath.Join(cwdTarget, "file"), filepath.Join(cwdAlt, "symlink-file")) + require.NoError(t, err) return newBoundOS(cwd, true) }, filename: "symlink-file", @@ -479,19 +517,26 @@ func TestLstat(t *testing.T) { }, { name: "symlink: outside cwd + baseDir symlink", - before: func(dir string) billy.Filesystem { + before: func(dir string) billy.Filesystem { //nolint cwd := filepath.Join(dir, "symlink-dir") outside := filepath.Join(cwd, "symlink-outside") cwdTarget := filepath.Join(dir, "cwd-target") outsideDir := filepath.Join(dir, "outside") - os.Mkdir(cwdTarget, 0o700) - os.Mkdir(outsideDir, 0o700) + err := os.Mkdir(cwdTarget, 0o700) + require.NoError(t, err) + err = os.Mkdir(outsideDir, 0o700) + require.NoError(t, err) + + err = os.WriteFile(filepath.Join(cwdTarget, "file"), []byte{}, 0o600) + require.NoError(t, err) + err = os.Symlink(cwdTarget, cwd) + require.NoError(t, err) + err = os.Symlink(outsideDir, outside) + require.NoError(t, err) + err = os.Symlink(filepath.Join(cwdTarget, "file"), filepath.Join(outside, "symlink-file")) + require.NoError(t, err) - os.WriteFile(filepath.Join(cwdTarget, "file"), []byte{}, 0o600) - os.Symlink(cwdTarget, cwd) - os.Symlink(outsideDir, outside) - os.Symlink(filepath.Join(cwdTarget, "file"), filepath.Join(outside, "symlink-file")) return newBoundOS(cwd, true) }, filename: "symlink-outside/symlink-file", @@ -511,7 +556,8 @@ func TestLstat(t *testing.T) { { name: "file: rel", before: func(dir string) billy.Filesystem { - os.WriteFile(filepath.Join(dir, "test-file"), []byte("anything"), 0o600) + err := os.WriteFile(filepath.Join(dir, "test-file"), []byte("anything"), 0o600) + require.NoError(t, err) return newBoundOS(dir, true) }, filename: "test-file", @@ -519,7 +565,8 @@ func TestLstat(t *testing.T) { { name: "file: dot rel", before: func(dir string) billy.Filesystem { - os.WriteFile(filepath.Join(dir, "test-file"), []byte("anything"), 0o600) + err := os.WriteFile(filepath.Join(dir, "test-file"), []byte("anything"), 0o600) + require.NoError(t, err) return newBoundOS(dir, true) }, filename: "./test-file", @@ -527,7 +574,8 @@ func TestLstat(t *testing.T) { { name: "file: abs", before: func(dir string) billy.Filesystem { - os.WriteFile(filepath.Join(dir, "test-file"), []byte("anything"), 0o600) + err := os.WriteFile(filepath.Join(dir, "test-file"), []byte("anything"), 0o600) + require.NoError(t, err) return newBoundOS(dir, true) }, filename: "test-file", @@ -550,10 +598,10 @@ func TestLstat(t *testing.T) { } fi, err := fs.Lstat(filename) if tt.wantErr != "" { - assert.ErrorContains(err, tt.wantErr) + require.ErrorContains(t, err, tt.wantErr) assert.Nil(fi) } else { - assert.Nil(err) + require.NoError(t, err) assert.NotNil(fi) assert.Equal(filepath.Base(tt.filename), fi.Name()) } @@ -572,7 +620,8 @@ func TestStat(t *testing.T) { { name: "rel symlink: pointing to abs outside cwd", before: func(dir string) billy.Filesystem { - os.Symlink("/etc/passwd", filepath.Join(dir, "symlink")) + err := os.Symlink("/etc/passwd", filepath.Join(dir, "symlink")) + require.NoError(t, err) return newBoundOS(dir, true) }, filename: "symlink", @@ -581,7 +630,8 @@ func TestStat(t *testing.T) { { name: "rel symlink: pointing to rel path above cwd", before: func(dir string) billy.Filesystem { - os.Symlink("../../../../../../../../etc/passwd", filepath.Join(dir, "symlink")) + err := os.Symlink("../../../../../../../../etc/passwd", filepath.Join(dir, "symlink")) + require.NoError(t, err) return newBoundOS(dir, true) }, filename: "symlink", @@ -591,7 +641,8 @@ func TestStat(t *testing.T) { { name: "abs symlink: pointing to abs outside cwd", before: func(dir string) billy.Filesystem { - os.Symlink("/etc/passwd", filepath.Join(dir, "symlink")) + err := os.Symlink("/etc/passwd", filepath.Join(dir, "symlink")) + require.NoError(t, err) return newBoundOS(dir, true) }, filename: "symlink", @@ -601,7 +652,8 @@ func TestStat(t *testing.T) { { name: "abs symlink: pointing to rel outside cwd", before: func(dir string) billy.Filesystem { - os.Symlink("../../../../../../../../etc/passwd", filepath.Join(dir, "symlink")) + err := os.Symlink("../../../../../../../../etc/passwd", filepath.Join(dir, "symlink")) + require.NoError(t, err) return newBoundOS(dir, true) }, filename: "symlink", @@ -621,7 +673,8 @@ func TestStat(t *testing.T) { { name: "rel file", before: func(dir string) billy.Filesystem { - os.WriteFile(filepath.Join(dir, "test-file"), []byte("anything"), 0o600) + err := os.WriteFile(filepath.Join(dir, "test-file"), []byte("anything"), 0o600) + require.NoError(t, err) return newBoundOS(dir, true) }, filename: "test-file", @@ -636,7 +689,8 @@ func TestStat(t *testing.T) { { name: "abs file", before: func(dir string) billy.Filesystem { - os.WriteFile(filepath.Join(dir, "test-file"), []byte("anything"), 0o600) + err := os.WriteFile(filepath.Join(dir, "test-file"), []byte("anything"), 0o600) + require.NoError(t, err) return newBoundOS(dir, true) }, filename: "test-file", @@ -660,10 +714,10 @@ func TestStat(t *testing.T) { fi, err := fs.Stat(filename) if tt.wantErr != "" { - assert.ErrorContains(err, tt.wantErr) + require.ErrorContains(t, err, tt.wantErr) assert.Nil(fi) } else { - assert.Nil(err) + require.NoError(t, err) assert.NotNil(fi) } }) @@ -707,7 +761,8 @@ func TestRemove(t *testing.T) { { name: "same dir file", before: func(dir string) billy.Filesystem { - os.WriteFile(filepath.Join(dir, "test-file"), []byte("anything"), 0o600) + err := os.WriteFile(filepath.Join(dir, "test-file"), []byte("anything"), 0o600) + require.NoError(t, err) return newBoundOS(dir, true) }, filename: "test-file", @@ -716,8 +771,10 @@ func TestRemove(t *testing.T) { name: "symlink: same dir", before: func(dir string) billy.Filesystem { target := filepath.Join(dir, "target-file") - os.WriteFile(target, []byte("anything"), 0o600) - os.Symlink(target, filepath.Join(dir, "symlink")) + err := os.WriteFile(target, []byte("anything"), 0o600) + require.NoError(t, err) + err = os.Symlink(target, filepath.Join(dir, "symlink")) + require.NoError(t, err) return newBoundOS(dir, true) }, filename: "symlink", @@ -725,7 +782,8 @@ func TestRemove(t *testing.T) { { name: "rel path to file above cwd", before: func(dir string) billy.Filesystem { - os.WriteFile(filepath.Join(dir, "rel-above-cwd"), []byte("anything"), 0o600) + err := os.WriteFile(filepath.Join(dir, "rel-above-cwd"), []byte("anything"), 0o600) + require.NoError(t, err) return newBoundOS(dir, true) }, filename: "../../rel-above-cwd", @@ -733,7 +791,8 @@ func TestRemove(t *testing.T) { { name: "abs file", before: func(dir string) billy.Filesystem { - os.WriteFile(filepath.Join(dir, "abs-test-file"), []byte("anything"), 0o600) + err := os.WriteFile(filepath.Join(dir, "abs-test-file"), []byte("anything"), 0o600) + require.NoError(t, err) return newBoundOS(dir, true) }, filename: "abs-test-file", @@ -745,10 +804,14 @@ func TestRemove(t *testing.T) { cwd := filepath.Join(dir, "current-dir") outsideFile := filepath.Join(dir, "outside-cwd/file") - os.Mkdir(cwd, 0o700) - os.MkdirAll(filepath.Dir(outsideFile), 0o700) - os.WriteFile(outsideFile, []byte("anything"), 0o600) - os.Symlink(outsideFile, filepath.Join(cwd, "remove-abs-symlink")) + err := os.Mkdir(cwd, 0o700) + require.NoError(t, err) + err = os.MkdirAll(filepath.Dir(outsideFile), 0o700) + require.NoError(t, err) + err = os.WriteFile(outsideFile, []byte("anything"), 0o600) + require.NoError(t, err) + err = os.Symlink(outsideFile, filepath.Join(cwd, "remove-abs-symlink")) + require.NoError(t, err) return newBoundOS(cwd, true) }, filename: "remove-abs-symlink", @@ -760,10 +823,14 @@ func TestRemove(t *testing.T) { cwd := filepath.Join(dir, "current-dir") outsideFile := filepath.Join(dir, "outside-cwd", "file2") - os.Mkdir(cwd, 0o700) - os.MkdirAll(filepath.Dir(outsideFile), 0o700) - os.WriteFile(outsideFile, []byte("anything"), 0o600) - os.Symlink(filepath.Join("..", "outside-cwd", "file2"), filepath.Join(cwd, "remove-abs-symlink2")) + err := os.Mkdir(cwd, 0o700) + require.NoError(t, err) + err = os.MkdirAll(filepath.Dir(outsideFile), 0o700) + require.NoError(t, err) + err = os.WriteFile(outsideFile, []byte("anything"), 0o600) + require.NoError(t, err) + err = os.Symlink(filepath.Join("..", "outside-cwd", "file2"), filepath.Join(cwd, "remove-abs-symlink2")) + require.NoError(t, err) return newBoundOS(cwd, true) }, filename: "remove-rel-symlink", @@ -772,7 +839,6 @@ func TestRemove(t *testing.T) { } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - assert := assert.New(t) dir := t.TempDir() fs := newBoundOS(dir, true) @@ -787,9 +853,9 @@ func TestRemove(t *testing.T) { err := fs.Remove(filename) if tt.wantErr != "" { - assert.ErrorContains(err, tt.wantErr) + require.ErrorContains(t, err, tt.wantErr) } else { - assert.Nil(err) + require.NoError(t, err) } }) } @@ -800,13 +866,14 @@ func TestRemoveAll(t *testing.T) { name string filename string makeAbs bool - before func(dir string) billy.Filesystem + before func(t *testing.T, dir string) billy.Filesystem wantErr string }{ { name: "parent with children", - before: func(dir string) billy.Filesystem { - os.MkdirAll(filepath.Join(dir, "parent/children"), 0o600) + before: func(t *testing.T, dir string) billy.Filesystem { + err := os.MkdirAll(filepath.Join(dir, "parent", "children"), 0o700) + require.NoError(t, err) return newBoundOS(dir, true) }, filename: "parent", @@ -817,34 +884,39 @@ func TestRemoveAll(t *testing.T) { }, { name: "same dir file", - before: func(dir string) billy.Filesystem { - os.WriteFile(filepath.Join(dir, "test-file"), []byte("anything"), 0o600) + before: func(t *testing.T, dir string) billy.Filesystem { + err := os.WriteFile(filepath.Join(dir, "test-file"), []byte("anything"), 0o600) + require.NoError(t, err) return newBoundOS(dir, true) }, filename: "test-file", }, { name: "same dir symlink", - before: func(dir string) billy.Filesystem { + before: func(t *testing.T, dir string) billy.Filesystem { target := filepath.Join(dir, "target-file") - os.WriteFile(target, []byte("anything"), 0o600) - os.Symlink(target, filepath.Join(dir, "symlink")) + err := os.WriteFile(target, []byte("anything"), 0o600) + require.NoError(t, err) + err = os.Symlink(target, filepath.Join(dir, "symlink")) + require.NoError(t, err) return newBoundOS(dir, true) }, filename: "symlink", }, { name: "rel path to file above cwd", - before: func(dir string) billy.Filesystem { - os.WriteFile(filepath.Join(dir, "rel-above-cwd"), []byte("anything"), 0o600) + before: func(t *testing.T, dir string) billy.Filesystem { + err := os.WriteFile(filepath.Join(dir, "rel-above-cwd"), []byte("anything"), 0o600) + require.NoError(t, err) return newBoundOS(dir, true) }, filename: "../../rel-above-cwd", }, { name: "abs file", - before: func(dir string) billy.Filesystem { - os.WriteFile(filepath.Join(dir, "abs-test-file"), []byte("anything"), 0o600) + before: func(t *testing.T, dir string) billy.Filesystem { + err := os.WriteFile(filepath.Join(dir, "abs-test-file"), []byte("anything"), 0o600) + require.NoError(t, err) return newBoundOS(dir, true) }, filename: "abs-test-file", @@ -852,8 +924,9 @@ func TestRemoveAll(t *testing.T) { }, { name: "abs symlink", - before: func(dir string) billy.Filesystem { - os.Symlink("/etc/passwd", filepath.Join(dir, "symlink")) + before: func(t *testing.T, dir string) billy.Filesystem { + err := os.Symlink("/etc/passwd", filepath.Join(dir, "symlink")) + require.NoError(t, err) return newBoundOS(dir, true) }, filename: "symlink", @@ -864,10 +937,12 @@ func TestRemoveAll(t *testing.T) { t.Run(tt.name, func(t *testing.T) { assert := assert.New(t) dir := t.TempDir() - fs := newBoundOS(dir, true).(*BoundOS) + fs, ok := newBoundOS(dir, true).(*BoundOS) + assert.True(ok) if tt.before != nil { - fs = tt.before(dir).(*BoundOS) + fs, ok = tt.before(t, dir).(*BoundOS) + assert.True(ok) } filename := tt.filename @@ -877,9 +952,9 @@ func TestRemoveAll(t *testing.T) { err := fs.RemoveAll(filename) if tt.wantErr != "" { - assert.ErrorContains(err, tt.wantErr) + require.ErrorContains(t, err, tt.wantErr) } else { - assert.Nil(err) + require.NoError(t, err) } }) } @@ -990,7 +1065,8 @@ func TestAbs(t *testing.T) { expected: "within-cwd", makeExpectedAbs: true, before: func(dir string) { - os.Symlink(filepath.Join(dir, "within-cwd"), filepath.Join(dir, "ln-cwd-cwd")) + err := os.Symlink(filepath.Join(dir, "within-cwd"), filepath.Join(dir, "ln-cwd-cwd")) + require.NoError(t, err) }, deduplicatePath: true, }, @@ -1001,7 +1077,8 @@ func TestAbs(t *testing.T) { expected: "within-cwd", makeExpectedAbs: true, before: func(dir string) { - os.Symlink("within-cwd", filepath.Join(dir, "ln-rel-cwd-cwd")) + err := os.Symlink("within-cwd", filepath.Join(dir, "ln-rel-cwd-cwd")) + require.NoError(t, err) }, deduplicatePath: true, }, @@ -1012,7 +1089,8 @@ func TestAbs(t *testing.T) { expected: "/some/outside/dir", makeExpectedAbs: true, before: func(dir string) { - os.Symlink("/some/outside/dir", filepath.Join(dir, "ln-cwd-up")) + err := os.Symlink("/some/outside/dir", filepath.Join(dir, "ln-cwd-up")) + require.NoError(t, err) }, deduplicatePath: true, }, @@ -1023,7 +1101,8 @@ func TestAbs(t *testing.T) { expected: "outside-cwd", makeExpectedAbs: true, before: func(dir string) { - os.Symlink("../../outside-cwd", filepath.Join(dir, "ln-rel-cwd-up")) + err := os.Symlink("../../outside-cwd", filepath.Join(dir, "ln-rel-cwd-up")) + require.NoError(t, err) }, deduplicatePath: true, }, @@ -1033,7 +1112,8 @@ func TestAbs(t *testing.T) { expected: "within-cwd", makeExpectedAbs: true, before: func(dir string) { - os.Symlink(filepath.Join(dir, "within-cwd"), filepath.Join(dir, "ln-cwd-cwd")) + err := os.Symlink(filepath.Join(dir, "within-cwd"), filepath.Join(dir, "ln-cwd-cwd")) + require.NoError(t, err) }, deduplicatePath: true, }, @@ -1043,7 +1123,8 @@ func TestAbs(t *testing.T) { expected: "within-cwd", makeExpectedAbs: true, before: func(dir string) { - os.Symlink("within-cwd", filepath.Join(dir, "ln-rel-cwd-cwd2")) + err := os.Symlink("within-cwd", filepath.Join(dir, "ln-rel-cwd-cwd2")) + require.NoError(t, err) }, }, { @@ -1052,7 +1133,8 @@ func TestAbs(t *testing.T) { expected: "/outside/path/up", makeExpectedAbs: true, before: func(dir string) { - os.Symlink("/outside/path/up", filepath.Join(dir, "ln-cwd-up2")) + err := os.Symlink("/outside/path/up", filepath.Join(dir, "ln-cwd-up2")) + require.NoError(t, err) }, }, { @@ -1061,7 +1143,8 @@ func TestAbs(t *testing.T) { expected: "outside", makeExpectedAbs: true, before: func(dir string) { - os.Symlink("../../../../outside", filepath.Join(dir, "ln-rel-cwd-up2")) + err := os.Symlink("../../../../outside", filepath.Join(dir, "ln-rel-cwd-up2")) + require.NoError(t, err) }, }, } @@ -1073,7 +1156,9 @@ func TestAbs(t *testing.T) { cwd = t.TempDir() } - fs := newBoundOS(cwd, tt.deduplicatePath).(*BoundOS) + fs, ok := newBoundOS(cwd, tt.deduplicatePath).(*BoundOS) + assert.True(ok) + if tt.before != nil { tt.before(cwd) } @@ -1090,9 +1175,9 @@ func TestAbs(t *testing.T) { got, err := fs.abs(filename) if tt.wantErr != "" { - assert.ErrorContains(err, tt.wantErr) + require.ErrorContains(t, err, tt.wantErr) } else { - assert.NoError(err) + require.NoError(t, err) } assert.Equal(expected, got) @@ -1106,28 +1191,29 @@ func TestReadDir(t *testing.T) { fs := newBoundOS(dir, true) f, err := os.Create(filepath.Join(dir, "file1")) - assert.NoError(err) + require.NoError(t, err) assert.NotNil(f) - assert.NoError(f.Close()) + require.NoError(t, f.Close()) f, err = os.Create(filepath.Join(dir, "file2")) - assert.NoError(err) + require.NoError(t, err) assert.NotNil(f) - assert.NoError(f.Close()) + require.NoError(t, f.Close()) dirs, err := fs.ReadDir(dir) - assert.NoError(err) + require.NoError(t, err) assert.NotNil(dirs) assert.Len(dirs, 2) dirs, err = fs.ReadDir(".") - assert.NoError(err) + require.NoError(t, err) assert.NotNil(dirs) assert.Len(dirs, 2) - os.Symlink("/some/path/outside/cwd", filepath.Join(dir, "symlink")) + err = os.Symlink("/some/path/outside/cwd", filepath.Join(dir, "symlink")) + require.NoError(t, err) dirs, err = fs.ReadDir("symlink") - assert.ErrorContains(err, notFoundError()) + require.ErrorContains(t, err, notFoundError()) assert.Nil(dirs) } @@ -1137,12 +1223,12 @@ func TestInsideBaseDirEval(t *testing.T) { fs := BoundOS{baseDir: "/"} b, err := fs.insideBaseDirEval("a") assert.True(b) - assert.Nil(err) + require.NoError(t, err) fs = BoundOS{baseDir: ""} b, err = fs.insideBaseDirEval(filepath.Join("a", "b", "c")) assert.True(b) - assert.Nil(err) + require.NoError(t, err) } func TestMkdirAll(t *testing.T) { @@ -1156,22 +1242,22 @@ func TestMkdirAll(t *testing.T) { // Even if CWD is changed outside of the fs instance, // the base dir must still be observed. err := os.Chdir(os.TempDir()) - assert.NoError(err) + require.NoError(t, err) err = fs.MkdirAll(target, 0o700) - assert.NoError(err) + require.NoError(t, err) fi, err := os.Stat(targetAbs) - assert.NoError(err) + require.NoError(t, err) assert.NotNil(fi) err = os.Mkdir(filepath.Join(root, "outside"), 0o700) - assert.NoError(err) + require.NoError(t, err) err = os.Symlink(filepath.Join(root, "outside"), filepath.Join(cwd, "symlink")) - assert.NoError(err) + require.NoError(t, err) err = fs.MkdirAll(filepath.Join(cwd, "symlink", "new-dir"), 0o700) - assert.NoError(err) + require.NoError(t, err) // For windows, the volume name must be removed from the path or // it will lead to an invalid path. @@ -1193,24 +1279,24 @@ func TestRename(t *testing.T) { // Even if CWD is changed outside of the fs instance, // the base dir must still be observed. err := os.Chdir(os.TempDir()) - assert.NoError(err) + require.NoError(t, err) f, err := fs.Create(oldFile) - assert.NoError(err) - assert.NoError(f.Close()) + require.NoError(t, err) + require.NoError(t, f.Close()) err = fs.Rename(oldFile, newFile) - assert.NoError(err) + require.NoError(t, err) fi, err := os.Stat(filepath.Join(dir, newFile)) - assert.NoError(err) + require.NoError(t, err) assert.NotNil(fi) err = fs.Rename(filepath.FromSlash("/tmp/outside/cwd/file1"), newFile) - assert.ErrorContains(err, notFoundError()) + require.ErrorContains(t, err, notFoundError()) err = fs.Rename(oldFile, filepath.FromSlash("/tmp/outside/cwd/file2")) - assert.ErrorContains(err, notFoundError()) + require.ErrorContains(t, err, notFoundError()) } func mustExist(filename string) { diff --git a/osfs/os_chroot.go b/osfs/os_chroot.go index 702d4f6..9545633 100644 --- a/osfs/os_chroot.go +++ b/osfs/os_chroot.go @@ -59,7 +59,7 @@ func (fs *ChrootOS) Rename(from, to string) error { return rename(from, to) } -func (fs *ChrootOS) MkdirAll(path string, perm fs.FileMode) error { +func (fs *ChrootOS) MkdirAll(path string, _ os.FileMode) error { return os.MkdirAll(path, defaultDirectoryMode) } diff --git a/osfs/os_chroot_test.go b/osfs/os_chroot_test.go index 35f24a6..ff3fecf 100644 --- a/osfs/os_chroot_test.go +++ b/osfs/os_chroot_test.go @@ -11,9 +11,12 @@ import ( "github.com/go-git/go-billy/v6" "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" ) func setup(t *testing.T) (billy.Filesystem, string) { + t.Helper() + path := t.TempDir() if runtime.GOOS == "plan9" { // On Plan 9, permission mode of newly created files @@ -22,7 +25,7 @@ func setup(t *testing.T) (billy.Filesystem, string) { // Since TestOpenFileWithModes and TestStat creates files directly // in the temporary directory, we need to make it more permissive. err := os.Chmod(path, 0777) - assert.NoError(t, err) + require.NoError(t, err) } return newChrootOS(path), path } @@ -30,10 +33,10 @@ func setup(t *testing.T) (billy.Filesystem, string) { func TestOpenDoesNotCreateDir(t *testing.T) { fs, path := setup(t) _, err := fs.Open("dir/non-existent") - assert.Error(t, err) + require.Error(t, err) _, err = os.Stat(filepath.Join(path, "dir")) - assert.ErrorIs(t, err, os.ErrNotExist) + require.ErrorIs(t, err, os.ErrNotExist) } func TestCapabilities(t *testing.T) { diff --git a/osfs/os_js_test.go b/osfs/os_js_test.go index 46bf6f2..3da49b0 100644 --- a/osfs/os_js_test.go +++ b/osfs/os_js_test.go @@ -42,6 +42,7 @@ func TestDefault(t *testing.T) { } } -func TestNewAPI(t *testing.T) { +var ( + // API call assertions _ = New("/") -} +) diff --git a/osfs/os_posix.go b/osfs/os_posix.go index 6fb8273..de511ed 100644 --- a/osfs/os_posix.go +++ b/osfs/os_posix.go @@ -30,8 +30,8 @@ func rename(from, to string) error { // umask sets umask to a new value, and returns a func which allows the // caller to reset it back to what it was originally. -func umask(new int) func() { - old := syscall.Umask(new) +func umask(m int) func() { + old := syscall.Umask(m) return func() { syscall.Umask(old) } diff --git a/osfs/os_test.go b/osfs/os_test.go index 92f9791..b73b1be 100644 --- a/osfs/os_test.go +++ b/osfs/os_test.go @@ -20,8 +20,9 @@ func TestDefault(t *testing.T) { } } -func TestNewAPI(t *testing.T) { +var ( + // API call assertions _ = New("/") _ = New("/", WithBoundOS()) _ = New("/", WithChrootOS()) -} +) diff --git a/test/basic_test.go b/test/basic_test.go index 952ab9b..77b18ff 100644 --- a/test/basic_test.go +++ b/test/basic_test.go @@ -8,12 +8,15 @@ import ( "path/filepath" "testing" - . "github.com/go-git/go-billy/v6" + . "github.com/go-git/go-billy/v6" //nolint "github.com/go-git/go-billy/v6/util" "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" ) func eachBasicFS(t *testing.T, test func(t *testing.T, fs Basic)) { + t.Helper() + for _, fs := range allFS(t.TempDir) { t.Run(fmt.Sprintf("%T", fs), func(t *testing.T) { test(t, fs) @@ -23,90 +26,104 @@ func eachBasicFS(t *testing.T, test func(t *testing.T, fs Basic)) { func TestCreate(t *testing.T) { eachBasicFS(t, func(t *testing.T, fs Basic) { + t.Helper() + f, err := fs.Create("foo") - assert.NoError(t, err) + require.NoError(t, err) assert.Equal(t, "foo", f.Name()) - assert.NoError(t, f.Close()) + require.NoError(t, f.Close()) }) } func TestCreateDepth(t *testing.T) { eachBasicFS(t, func(t *testing.T, fs Basic) { + t.Helper() + f, err := fs.Create("bar/foo") - assert.NoError(t, err) + require.NoError(t, err) assert.Equal(t, fs.Join("bar", "foo"), f.Name()) - assert.NoError(t, f.Close()) + require.NoError(t, f.Close()) }) } func TestCreateDepthAbsolute(t *testing.T) { eachBasicFS(t, func(t *testing.T, fs Basic) { + t.Helper() + f, err := fs.Create("/bar/foo") - assert.NoError(t, err) + require.NoError(t, err) assert.Equal(t, fs.Join("bar", "foo"), f.Name()) - assert.NoError(t, f.Close()) + require.NoError(t, f.Close()) }) } func TestCreateOverwrite(t *testing.T) { eachBasicFS(t, func(t *testing.T, fs Basic) { + t.Helper() + for i := 0; i < 3; i++ { f, err := fs.Create("foo") - assert.NoError(t, err) + require.NoError(t, err) l, err := f.Write([]byte(fmt.Sprintf("foo%d", i))) - assert.NoError(t, err) - assert.Equal(t, l, 4) + require.NoError(t, err) + assert.Equal(t, 4, l) err = f.Close() - assert.NoError(t, err) + require.NoError(t, err) } f, err := fs.Open("foo") - assert.NoError(t, err) + require.NoError(t, err) wrote, err := io.ReadAll(f) - assert.NoError(t, err) - assert.Equal(t, string(wrote), "foo2") - assert.NoError(t, f.Close()) + require.NoError(t, err) + assert.Equal(t, "foo2", string(wrote)) + require.NoError(t, f.Close()) }) } func TestCreateAndClose(t *testing.T) { eachBasicFS(t, func(t *testing.T, fs Basic) { + t.Helper() + f, err := fs.Create("foo") - assert.NoError(t, err) + require.NoError(t, err) _, err = f.Write([]byte("foo")) - assert.NoError(t, err) - assert.NoError(t, f.Close()) + require.NoError(t, err) + require.NoError(t, f.Close()) f, err = fs.Open(f.Name()) - assert.NoError(t, err) + require.NoError(t, err) wrote, err := io.ReadAll(f) - assert.NoError(t, err) - assert.Equal(t, string(wrote), "foo") - assert.NoError(t, f.Close()) + require.NoError(t, err) + assert.Equal(t, "foo", string(wrote)) + require.NoError(t, f.Close()) }) } func TestOpen(t *testing.T) { eachBasicFS(t, func(t *testing.T, fs Basic) { + t.Helper() + f, err := fs.Create("foo") - assert.NoError(t, err) - assert.Equal(t, f.Name(), "foo") - assert.NoError(t, f.Close()) + require.NoError(t, err) + assert.Equal(t, "foo", f.Name()) + require.NoError(t, f.Close()) f, err = fs.Open("foo") - assert.NoError(t, err) - assert.Equal(t, f.Name(), "foo") - assert.NoError(t, f.Close()) + require.NoError(t, err) + assert.Equal(t, "foo", f.Name()) + require.NoError(t, f.Close()) }) } func TestOpenNotExists(t *testing.T) { eachBasicFS(t, func(t *testing.T, fs Basic) { + t.Helper() + f, err := fs.Open("not-exists") assert.NotNil(t, err) assert.Nil(t, f) @@ -115,103 +132,107 @@ func TestOpenNotExists(t *testing.T) { func TestOpenFile(t *testing.T) { eachBasicFS(t, func(t *testing.T, fs Basic) { + t.Helper() defaultMode := os.FileMode(0666) f, err := fs.OpenFile("foo1", os.O_CREATE|os.O_WRONLY|os.O_TRUNC, defaultMode) - assert.NoError(t, err) + require.NoError(t, err) testWriteClose(t, f, "foo1") // Truncate if it exists f, err = fs.OpenFile("foo1", os.O_CREATE|os.O_WRONLY|os.O_TRUNC, defaultMode) - assert.NoError(t, err) - assert.Equal(t, f.Name(), "foo1") + require.NoError(t, err) + assert.Equal(t, "foo1", f.Name()) testWriteClose(t, f, "foo1overwritten") // Read-only if it exists f, err = fs.OpenFile("foo1", os.O_RDONLY, defaultMode) - assert.NoError(t, err) - assert.Equal(t, f.Name(), "foo1") + require.NoError(t, err) + assert.Equal(t, "foo1", f.Name()) testReadClose(t, f, "foo1overwritten") // Create when it does exist f, err = fs.OpenFile("foo1", os.O_CREATE|os.O_WRONLY|os.O_TRUNC, defaultMode) - assert.NoError(t, err) - assert.Equal(t, f.Name(), "foo1") + require.NoError(t, err) + assert.Equal(t, "foo1", f.Name()) testWriteClose(t, f, "bar") f, err = fs.OpenFile("foo1", os.O_RDONLY, defaultMode) - assert.NoError(t, err) + require.NoError(t, err) testReadClose(t, f, "bar") }) } func TestOpenFileNoTruncate(t *testing.T) { eachBasicFS(t, func(t *testing.T, fs Basic) { + t.Helper() defaultMode := os.FileMode(0666) // Create when it does not exist f, err := fs.OpenFile("foo1", os.O_CREATE|os.O_WRONLY, defaultMode) - assert.NoError(t, err) - assert.Equal(t, f.Name(), "foo1") + require.NoError(t, err) + assert.Equal(t, "foo1", f.Name()) testWriteClose(t, f, "foo1") f, err = fs.OpenFile("foo1", os.O_RDONLY, defaultMode) - assert.NoError(t, err) + require.NoError(t, err) testReadClose(t, f, "foo1") // Create when it does exist f, err = fs.OpenFile("foo1", os.O_CREATE|os.O_WRONLY, defaultMode) - assert.NoError(t, err) - assert.Equal(t, f.Name(), "foo1") + require.NoError(t, err) + assert.Equal(t, "foo1", f.Name()) testWriteClose(t, f, "bar") f, err = fs.OpenFile("foo1", os.O_RDONLY, defaultMode) - assert.NoError(t, err) + require.NoError(t, err) testReadClose(t, f, "bar1") }) } func TestOpenFileAppend(t *testing.T) { eachBasicFS(t, func(t *testing.T, fs Basic) { + t.Helper() defaultMode := os.FileMode(0666) f, err := fs.OpenFile("foo1", os.O_CREATE|os.O_WRONLY|os.O_APPEND, defaultMode) - assert.NoError(t, err) - assert.Equal(t, f.Name(), "foo1") + require.NoError(t, err) + assert.Equal(t, "foo1", f.Name()) testWriteClose(t, f, "foo1") f, err = fs.OpenFile("foo1", os.O_WRONLY|os.O_APPEND, defaultMode) - assert.NoError(t, err) - assert.Equal(t, f.Name(), "foo1") + require.NoError(t, err) + assert.Equal(t, "foo1", f.Name()) testWriteClose(t, f, "bar1") f, err = fs.OpenFile("foo1", os.O_RDONLY, defaultMode) - assert.NoError(t, err) + require.NoError(t, err) testReadClose(t, f, "foo1bar1") }) } func TestOpenFileReadWrite(t *testing.T) { eachBasicFS(t, func(t *testing.T, fs Basic) { + t.Helper() defaultMode := os.FileMode(0666) f, err := fs.OpenFile("foo1", os.O_CREATE|os.O_TRUNC|os.O_RDWR, defaultMode) - assert.NoError(t, err) - assert.Equal(t, f.Name(), "foo1") + require.NoError(t, err) + assert.Equal(t, "foo1", f.Name()) written, err := f.Write([]byte("foobar")) - assert.Equal(t, written, 6) - assert.NoError(t, err) + assert.Equal(t, 6, written) + require.NoError(t, err) _, err = f.Seek(0, io.SeekStart) - assert.NoError(t, err) + require.NoError(t, err) written, err = f.Write([]byte("qux")) - assert.Equal(t, written, 3) - assert.NoError(t, err) + assert.Equal(t, 3, written) + require.NoError(t, err) _, err = f.Seek(0, io.SeekStart) - assert.NoError(t, err) + require.NoError(t, err) testReadClose(t, f, "quxbar") }) @@ -219,53 +240,62 @@ func TestOpenFileReadWrite(t *testing.T) { func TestOpenFileWithModes(t *testing.T) { eachBasicFS(t, func(t *testing.T, fs Basic) { + t.Helper() + f, err := fs.OpenFile("foo", os.O_CREATE|os.O_WRONLY|os.O_TRUNC, customMode) - assert.NoError(t, err) - assert.NoError(t, f.Close()) + require.NoError(t, err) + require.NoError(t, f.Close()) fi, err := fs.Stat("foo") - assert.NoError(t, err) - assert.Equal(t, fi.Mode(), os.FileMode(customMode)) + require.NoError(t, err) + assert.Equal(t, customMode, fi.Mode()) }) } func testWriteClose(t *testing.T, f File, content string) { + t.Helper() + written, err := f.Write([]byte(content)) - assert.Equal(t, written, len(content)) - assert.NoError(t, err) - assert.NoError(t, f.Close()) + assert.Equal(t, len(content), written) + require.NoError(t, err) + require.NoError(t, f.Close()) } func testReadClose(t *testing.T, f File, content string) { + t.Helper() read, err := io.ReadAll(f) - assert.NoError(t, err) + require.NoError(t, err) assert.Equal(t, string(read), content) - assert.NoError(t, f.Close()) + require.NoError(t, f.Close()) } func TestFileWrite(t *testing.T) { eachBasicFS(t, func(t *testing.T, fs Basic) { + t.Helper() f, err := fs.Create("foo") - assert.NoError(t, err) + require.NoError(t, err) n, err := f.Write([]byte("foo")) - assert.NoError(t, err) - assert.Equal(t, n, 3) + require.NoError(t, err) + assert.Equal(t, 3, n) + + _, err = f.Seek(0, io.SeekStart) + require.NoError(t, err) - f.Seek(0, io.SeekStart) all, err := io.ReadAll(f) - assert.NoError(t, err) - assert.Equal(t, string(all), "foo") - assert.NoError(t, f.Close()) + require.NoError(t, err) + assert.Equal(t, "foo", string(all)) + require.NoError(t, f.Close()) }) } func TestFileWriteClose(t *testing.T) { eachBasicFS(t, func(t *testing.T, fs Basic) { + t.Helper() f, err := fs.Create("foo") - assert.NoError(t, err) + require.NoError(t, err) - assert.NoError(t, f.Close()) + require.NoError(t, f.Close()) _, err = f.Write([]byte("foo")) assert.NotNil(t, err) @@ -274,27 +304,29 @@ func TestFileWriteClose(t *testing.T) { func TestFileRead(t *testing.T) { eachBasicFS(t, func(t *testing.T, fs Basic) { + t.Helper() err := util.WriteFile(fs, "foo", []byte("foo"), 0644) - assert.NoError(t, err) + require.NoError(t, err) f, err := fs.Open("foo") - assert.NoError(t, err) + require.NoError(t, err) all, err := io.ReadAll(f) - assert.NoError(t, err) - assert.Equal(t, string(all), "foo") - assert.NoError(t, f.Close()) + require.NoError(t, err) + assert.Equal(t, "foo", string(all)) + require.NoError(t, f.Close()) }) } func TestFileClosed(t *testing.T) { eachBasicFS(t, func(t *testing.T, fs Basic) { + t.Helper() err := util.WriteFile(fs, "foo", []byte("foo"), 0644) - assert.NoError(t, err) + require.NoError(t, err) f, err := fs.Open("foo") - assert.NoError(t, err) - assert.NoError(t, f.Close()) + require.NoError(t, err) + require.NoError(t, f.Close()) _, err = io.ReadAll(f) assert.NotNil(t, err) @@ -303,77 +335,83 @@ func TestFileClosed(t *testing.T) { func TestFileNonRead(t *testing.T) { eachBasicFS(t, func(t *testing.T, fs Basic) { + t.Helper() err := util.WriteFile(fs, "foo", []byte("foo"), 0644) - assert.NoError(t, err) + require.NoError(t, err) f, err := fs.OpenFile("foo", os.O_WRONLY, 0) - assert.NoError(t, err) + require.NoError(t, err) _, err = io.ReadAll(f) assert.NotNil(t, err) - assert.NoError(t, f.Close()) + require.NoError(t, f.Close()) }) } func TestFileSeekstart(t *testing.T) { eachBasicFS(t, func(t *testing.T, fs Basic) { + t.Helper() testFileSeek(t, fs, 10, io.SeekStart) }) } func TestFileSeekCurrent(t *testing.T) { eachBasicFS(t, func(t *testing.T, fs Basic) { + t.Helper() testFileSeek(t, fs, 5, io.SeekCurrent) }) } func TestFileSeekEnd(t *testing.T) { eachBasicFS(t, func(t *testing.T, fs Basic) { + t.Helper() testFileSeek(t, fs, -26, io.SeekEnd) }) } func testFileSeek(t *testing.T, fs Basic, offset int64, whence int) { + t.Helper() err := util.WriteFile(fs, "foo", []byte("0123456789abcdefghijklmnopqrstuvwxyz"), 0644) - assert.NoError(t, err) + require.NoError(t, err) f, err := fs.Open("foo") - assert.NoError(t, err) + require.NoError(t, err) some := make([]byte, 5) _, err = f.Read(some) - assert.NoError(t, err) - assert.Equal(t, string(some), "01234") + require.NoError(t, err) + assert.Equal(t, "01234", string(some)) p, err := f.Seek(offset, whence) - assert.NoError(t, err) - assert.Equal(t, int(p), 10) + require.NoError(t, err) + assert.Equal(t, 10, int(p)) all, err := io.ReadAll(f) - assert.NoError(t, err) + require.NoError(t, err) assert.Len(t, all, 26) - assert.Equal(t, string(all), "abcdefghijklmnopqrstuvwxyz") - assert.NoError(t, f.Close()) + assert.Equal(t, "abcdefghijklmnopqrstuvwxyz", string(all)) + require.NoError(t, f.Close()) } func TestSeekToEndAndWrite(t *testing.T) { eachBasicFS(t, func(t *testing.T, fs Basic) { + t.Helper() defaultMode := os.FileMode(0666) f, err := fs.OpenFile("foo1", os.O_CREATE|os.O_TRUNC|os.O_RDWR, defaultMode) - assert.NoError(t, err) - assert.Equal(t, f.Name(), "foo1") + require.NoError(t, err) + assert.Equal(t, "foo1", f.Name()) _, err = f.Seek(10, io.SeekEnd) - assert.NoError(t, err) + require.NoError(t, err) n, err := f.Write([]byte(`TEST`)) - assert.NoError(t, err) - assert.Equal(t, n, 4) + require.NoError(t, err) + assert.Equal(t, 4, n) _, err = f.Seek(0, io.SeekStart) - assert.NoError(t, err) + require.NoError(t, err) testReadClose(t, f, "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00TEST") }) @@ -381,12 +419,13 @@ func TestSeekToEndAndWrite(t *testing.T) { func TestFileSeekClosed(t *testing.T) { eachBasicFS(t, func(t *testing.T, fs Basic) { + t.Helper() err := util.WriteFile(fs, "foo", []byte("foo"), 0644) - assert.NoError(t, err) + require.NoError(t, err) f, err := fs.Open("foo") - assert.NoError(t, err) - assert.NoError(t, f.Close()) + require.NoError(t, err) + require.NoError(t, f.Close()) _, err = f.Seek(0, 0) assert.NotNil(t, err) @@ -395,30 +434,34 @@ func TestFileSeekClosed(t *testing.T) { func TestFileCloseTwice(t *testing.T) { eachBasicFS(t, func(t *testing.T, fs Basic) { + t.Helper() f, err := fs.Create("foo") - assert.NoError(t, err) + require.NoError(t, err) - assert.NoError(t, f.Close()) + require.NoError(t, f.Close()) assert.Error(t, f.Close()) }) } func TestStat(t *testing.T) { eachBasicFS(t, func(t *testing.T, fs Basic) { - util.WriteFile(fs, "foo/bar", []byte("foo"), customMode) + t.Helper() + err := util.WriteFile(fs, "foo/bar", []byte("foo"), customMode) + require.NoError(t, err) fi, err := fs.Stat("foo/bar") - assert.NoError(t, err) - assert.Equal(t, fi.Name(), "bar") - assert.Equal(t, fi.Size(), int64(3)) - assert.Equal(t, fi.Mode(), customMode) - assert.Equal(t, fi.ModTime().IsZero(), false) - assert.Equal(t, fi.IsDir(), false) + require.NoError(t, err) + assert.Equal(t, "bar", fi.Name()) + assert.Equal(t, int64(3), fi.Size()) + assert.Equal(t, customMode, fi.Mode()) + assert.False(t, fi.ModTime().IsZero()) + assert.False(t, fi.IsDir()) }) } func TestStatNonExistent(t *testing.T) { eachBasicFS(t, func(t *testing.T, fs Basic) { + t.Helper() fi, err := fs.Stat("non-existent") assert.ErrorIs(t, err, os.ErrNotExist) assert.Nil(t, fi) @@ -427,71 +470,76 @@ func TestStatNonExistent(t *testing.T) { func TestRename(t *testing.T) { eachBasicFS(t, func(t *testing.T, fs Basic) { + t.Helper() err := util.WriteFile(fs, "foo", nil, 0644) - assert.NoError(t, err) + require.NoError(t, err) err = fs.Rename("foo", "bar") - assert.NoError(t, err) + require.NoError(t, err) foo, err := fs.Stat("foo") assert.Nil(t, foo) assert.ErrorIs(t, err, os.ErrNotExist) bar, err := fs.Stat("bar") - assert.NoError(t, err) + require.NoError(t, err) assert.NotNil(t, bar) }) } func TestOpenAndWrite(t *testing.T) { eachBasicFS(t, func(t *testing.T, fs Basic) { + t.Helper() err := util.WriteFile(fs, "foo", nil, 0644) - assert.NoError(t, err) + require.NoError(t, err) foo, err := fs.Open("foo") assert.NotNil(t, foo) - assert.NoError(t, err) + require.NoError(t, err) n, err := foo.Write([]byte("foo")) assert.NotNil(t, err) - assert.Equal(t, n, 0) + assert.Equal(t, 0, n) - assert.NoError(t, foo.Close()) + require.NoError(t, foo.Close()) }) } func TestOpenAndStat(t *testing.T) { eachBasicFS(t, func(t *testing.T, fs Basic) { + t.Helper() err := util.WriteFile(fs, "foo", []byte("foo"), 0644) - assert.NoError(t, err) + require.NoError(t, err) foo, err := fs.Open("foo") assert.NotNil(t, foo) assert.Equal(t, "foo", foo.Name()) - assert.NoError(t, err) - assert.NoError(t, foo.Close()) + require.NoError(t, err) + require.NoError(t, foo.Close()) stat, err := fs.Stat("foo") assert.NotNil(t, stat) assert.NoError(t, err) - assert.Equal(t, stat.Name(), "foo") - assert.Equal(t, stat.Size(), int64(3)) + assert.Equal(t, "foo", stat.Name()) + assert.Equal(t, int64(3), stat.Size()) }) } func TestRemove(t *testing.T) { eachBasicFS(t, func(t *testing.T, fs Basic) { + t.Helper() f, err := fs.Create("foo") - assert.NoError(t, err) - assert.NoError(t, f.Close()) + require.NoError(t, err) + require.NoError(t, f.Close()) err = fs.Remove("foo") - assert.NoError(t, err) + require.NoError(t, err) }) } func TestRemoveNonExisting(t *testing.T) { eachBasicFS(t, func(t *testing.T, fs Basic) { + t.Helper() err := fs.Remove("NON-EXISTING") assert.NotNil(t, err) assert.ErrorIs(t, err, os.ErrNotExist) @@ -500,8 +548,9 @@ func TestRemoveNonExisting(t *testing.T) { func TestRemoveNotEmptyDir(t *testing.T) { eachBasicFS(t, func(t *testing.T, fs Basic) { + t.Helper() err := util.WriteFile(fs, "foo", nil, 0644) - assert.NoError(t, err) + require.NoError(t, err) err = fs.Remove("no-exists") assert.NotNil(t, err) @@ -510,56 +559,60 @@ func TestRemoveNotEmptyDir(t *testing.T) { func TestJoin(t *testing.T) { eachBasicFS(t, func(t *testing.T, fs Basic) { + t.Helper() assert.Equal(t, fs.Join("foo", "bar"), fmt.Sprintf("foo%cbar", filepath.Separator)) }) } func TestReadAtOnReadWrite(t *testing.T) { eachBasicFS(t, func(t *testing.T, fs Basic) { + t.Helper() f, err := fs.Create("foo") - assert.NoError(t, err) + require.NoError(t, err) _, err = f.Write([]byte("abcdefg")) - assert.NoError(t, err) + require.NoError(t, err) rf, ok := f.(io.ReaderAt) assert.True(t, ok) b := make([]byte, 3) n, err := rf.ReadAt(b, 2) - assert.NoError(t, err) + require.NoError(t, err) assert.Equal(t, n, 3) assert.Equal(t, string(b), "cde") - assert.NoError(t, f.Close()) + require.NoError(t, f.Close()) }) } func TestReadAtOnReadOnly(t *testing.T) { eachBasicFS(t, func(t *testing.T, fs Basic) { + t.Helper() err := util.WriteFile(fs, "foo", []byte("abcdefg"), 0644) - assert.NoError(t, err) + require.NoError(t, err) f, err := fs.Open("foo") - assert.NoError(t, err) + require.NoError(t, err) rf, ok := f.(io.ReaderAt) assert.True(t, ok) b := make([]byte, 3) n, err := rf.ReadAt(b, 2) - assert.NoError(t, err) + require.NoError(t, err) assert.Equal(t, n, 3) assert.Equal(t, string(b), "cde") - assert.NoError(t, f.Close()) + require.NoError(t, f.Close()) }) } func TestReadAtEOF(t *testing.T) { eachBasicFS(t, func(t *testing.T, fs Basic) { + t.Helper() err := util.WriteFile(fs, "foo", []byte("TEST"), 0644) - assert.NoError(t, err) + require.NoError(t, err) f, err := fs.Open("foo") - assert.NoError(t, err) + require.NoError(t, err) b := make([]byte, 5) n, err := f.ReadAt(b, 0) @@ -568,95 +621,99 @@ func TestReadAtEOF(t *testing.T) { assert.Equal(t, string(b), "TEST\x00") err = f.Close() - assert.NoError(t, err) + require.NoError(t, err) }) } func TestReadAtOffset(t *testing.T) { eachBasicFS(t, func(t *testing.T, fs Basic) { + t.Helper() err := util.WriteFile(fs, "foo", []byte("TEST"), 0644) - assert.NoError(t, err) + require.NoError(t, err) f, err := fs.Open("foo") - assert.NoError(t, err) + require.NoError(t, err) rf, ok := f.(io.ReaderAt) assert.True(t, ok) o, err := f.Seek(0, io.SeekCurrent) - assert.NoError(t, err) + require.NoError(t, err) assert.Equal(t, o, int64(0)) b := make([]byte, 4) n, err := rf.ReadAt(b, 0) - assert.NoError(t, err) + require.NoError(t, err) assert.Equal(t, n, 4) assert.Equal(t, string(b), "TEST") o, err = f.Seek(0, io.SeekCurrent) - assert.NoError(t, err) + require.NoError(t, err) assert.Equal(t, o, int64(0)) err = f.Close() - assert.NoError(t, err) + require.NoError(t, err) }) } func TestReadWriteLargeFile(t *testing.T) { eachBasicFS(t, func(t *testing.T, fs Basic) { + t.Helper() f, err := fs.Create("foo") - assert.NoError(t, err) + require.NoError(t, err) size := 1 << 20 n, err := f.Write(bytes.Repeat([]byte("F"), size)) - assert.NoError(t, err) + require.NoError(t, err) assert.Equal(t, n, size) - assert.NoError(t, f.Close()) + require.NoError(t, f.Close()) f, err = fs.Open("foo") - assert.NoError(t, err) + require.NoError(t, err) b, err := io.ReadAll(f) - assert.NoError(t, err) + require.NoError(t, err) assert.Equal(t, len(b), size) - assert.NoError(t, f.Close()) + require.NoError(t, f.Close()) }) } func TestWriteFile(t *testing.T) { eachBasicFS(t, func(t *testing.T, fs Basic) { + t.Helper() err := util.WriteFile(fs, "foo", []byte("bar"), 0777) - assert.NoError(t, err) + require.NoError(t, err) f, err := fs.Open("foo") - assert.NoError(t, err) + require.NoError(t, err) wrote, err := io.ReadAll(f) - assert.NoError(t, err) + require.NoError(t, err) assert.Equal(t, string(wrote), "bar") - assert.NoError(t, f.Close()) + require.NoError(t, f.Close()) }) } func TestTruncate(t *testing.T) { eachBasicFS(t, func(t *testing.T, fs Basic) { + t.Helper() f, err := fs.Create("foo") - assert.NoError(t, err) + require.NoError(t, err) for _, sz := range []int64{4, 7, 2, 30, 0, 1} { err = f.Truncate(sz) - assert.NoError(t, err) + require.NoError(t, err) bs, err := io.ReadAll(f) - assert.NoError(t, err) + require.NoError(t, err) assert.Equal(t, len(bs), int(sz)) _, err = f.Seek(0, io.SeekStart) - assert.NoError(t, err) + require.NoError(t, err) } - assert.NoError(t, f.Close()) + require.NoError(t, f.Close()) }) } diff --git a/test/chroot_test.go b/test/chroot_test.go index 13d4e33..061cf0e 100644 --- a/test/chroot_test.go +++ b/test/chroot_test.go @@ -5,9 +5,10 @@ import ( "os" "testing" - . "github.com/go-git/go-billy/v6" + . "github.com/go-git/go-billy/v6" //nolint "github.com/go-git/go-billy/v6/util" "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" ) type chrootFS interface { @@ -16,6 +17,7 @@ type chrootFS interface { } func eachChrootFS(t *testing.T, test func(t *testing.T, fs chrootFS)) { + t.Helper() for _, fs := range allFS(t.TempDir) { t.Run(fmt.Sprintf("%T", fs), func(t *testing.T) { test(t, fs) @@ -25,38 +27,41 @@ func eachChrootFS(t *testing.T, test func(t *testing.T, fs chrootFS)) { func TestCreateWithChroot(t *testing.T) { eachChrootFS(t, func(t *testing.T, fs chrootFS) { + t.Helper() chroot, _ := fs.Chroot("foo") f, err := chroot.Create("bar") - assert.Nil(t, err) - assert.Nil(t, f.Close()) + require.NoError(t, err) + require.NoError(t, f.Close()) assert.Equal(t, f.Name(), "bar") f, err = fs.Open("foo/bar") - assert.Nil(t, err) + require.NoError(t, err) assert.Equal(t, f.Name(), fs.Join("foo", "bar")) - assert.Nil(t, f.Close()) + require.NoError(t, f.Close()) }) } func TestOpenWithChroot(t *testing.T) { eachChrootFS(t, func(t *testing.T, fs chrootFS) { + t.Helper() chroot, _ := fs.Chroot("foo") f, err := chroot.Create("bar") - assert.Nil(t, err) - assert.Nil(t, f.Close()) + require.NoError(t, err) + require.NoError(t, f.Close()) assert.Equal(t, f.Name(), "bar") f, err = chroot.Open("bar") - assert.Nil(t, err) + require.NoError(t, err) assert.Equal(t, f.Name(), "bar") - assert.Nil(t, f.Close()) + require.NoError(t, f.Close()) }) } func TestOpenOutOffBoundary(t *testing.T) { eachChrootFS(t, func(t *testing.T, fs chrootFS) { + t.Helper() err := util.WriteFile(fs, "bar", nil, 0644) - assert.Nil(t, err) + require.NoError(t, err) chroot, _ := fs.Chroot("foo") f, err := chroot.Open("../bar") @@ -67,8 +72,9 @@ func TestOpenOutOffBoundary(t *testing.T) { func TestStatOutOffBoundary(t *testing.T) { eachChrootFS(t, func(t *testing.T, fs chrootFS) { + t.Helper() err := util.WriteFile(fs, "bar", nil, 0644) - assert.Nil(t, err) + require.NoError(t, err) chroot, _ := fs.Chroot("foo") f, err := chroot.Stat("../bar") @@ -79,10 +85,11 @@ func TestStatOutOffBoundary(t *testing.T) { func TestStatWithChroot(t *testing.T) { eachChrootFS(t, func(t *testing.T, fs chrootFS) { + t.Helper() files := []string{"foo", "bar", "qux/baz", "qux/qux"} for _, name := range files { err := util.WriteFile(fs, name, nil, 0644) - assert.Nil(t, err) + require.NoError(t, err) } // Some implementations detect directories based on a prefix @@ -92,31 +99,32 @@ func TestStatWithChroot(t *testing.T) { assert.Nil(t, fi) fi, err = fs.Stat("qux") - assert.Nil(t, err) + require.NoError(t, err) assert.Equal(t, fi.Name(), "qux") - assert.Equal(t, fi.IsDir(), true) + assert.True(t, fi.IsDir()) qux, _ := fs.Chroot("qux") fi, err = qux.Stat("baz") - assert.Nil(t, err) + require.NoError(t, err) assert.Equal(t, fi.Name(), "baz") - assert.Equal(t, fi.IsDir(), false) + assert.False(t, fi.IsDir()) fi, err = qux.Stat("/baz") - assert.Nil(t, err) + require.NoError(t, err) assert.Equal(t, fi.Name(), "baz") - assert.Equal(t, fi.IsDir(), false) + assert.False(t, fi.IsDir()) }) } func TestRenameOutOffBoundary(t *testing.T) { eachChrootFS(t, func(t *testing.T, fs chrootFS) { + t.Helper() err := util.WriteFile(fs, "foo/foo", nil, 0644) - assert.Nil(t, err) + require.NoError(t, err) err = util.WriteFile(fs, "bar", nil, 0644) - assert.Nil(t, err) + require.NoError(t, err) chroot, _ := fs.Chroot("foo") err = chroot.Rename("../bar", "foo") @@ -129,8 +137,9 @@ func TestRenameOutOffBoundary(t *testing.T) { func TestRemoveOutOffBoundary(t *testing.T) { eachChrootFS(t, func(t *testing.T, fs chrootFS) { + t.Helper() err := util.WriteFile(fs, "bar", nil, 0644) - assert.Nil(t, err) + require.NoError(t, err) chroot, _ := fs.Chroot("foo") err = chroot.Remove("../bar") @@ -140,6 +149,7 @@ func TestRemoveOutOffBoundary(t *testing.T) { func TestRoot(t *testing.T) { eachChrootFS(t, func(t *testing.T, fs chrootFS) { + t.Helper() assert.NotEmpty(t, fs.Root()) }) } diff --git a/test/dir_test.go b/test/dir_test.go index ff80764..857e568 100644 --- a/test/dir_test.go +++ b/test/dir_test.go @@ -6,9 +6,10 @@ import ( "strconv" "testing" - . "github.com/go-git/go-billy/v6" + . "github.com/go-git/go-billy/v6" //nolint "github.com/go-git/go-billy/v6/util" "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" ) type dirFS interface { @@ -27,10 +28,10 @@ func eachDirFS(t *testing.T, test func(t *testing.T, fs dirFS)) { func TestDir_MkdirAll(t *testing.T) { eachDirFS(t, func(t *testing.T, fs dirFS) { err := fs.MkdirAll("empty", os.FileMode(0755)) - assert.NoError(t, err) + require.NoError(t, err) fi, err := fs.Stat("empty") - assert.NoError(t, err) + require.NoError(t, err) assert.True(t, fi.IsDir()) }) } @@ -38,18 +39,18 @@ func TestDir_MkdirAll(t *testing.T) { func TestDir_MkdirAllNested(t *testing.T) { eachDirFS(t, func(t *testing.T, fs dirFS) { err := fs.MkdirAll("foo/bar/baz", os.FileMode(0755)) - assert.NoError(t, err) + require.NoError(t, err) fi, err := fs.Stat("foo/bar/baz") - assert.NoError(t, err) + require.NoError(t, err) assert.True(t, fi.IsDir()) fi, err = fs.Stat("foo/bar") - assert.NoError(t, err) + require.NoError(t, err) assert.True(t, fi.IsDir()) fi, err = fs.Stat("foo") - assert.NoError(t, err) + require.NoError(t, err) assert.True(t, fi.IsDir()) }) } @@ -57,16 +58,16 @@ func TestDir_MkdirAllNested(t *testing.T) { func TestDir_MkdirAllIdempotent(t *testing.T) { eachDirFS(t, func(t *testing.T, fs dirFS) { err := fs.MkdirAll("empty", 0755) - assert.NoError(t, err) + require.NoError(t, err) fi, err := fs.Stat("empty") - assert.NoError(t, err) + require.NoError(t, err) assert.True(t, fi.IsDir()) // idempotent err = fs.MkdirAll("empty", 0755) - assert.NoError(t, err) + require.NoError(t, err) fi, err = fs.Stat("empty") - assert.NoError(t, err) + require.NoError(t, err) assert.True(t, fi.IsDir()) }) } @@ -74,14 +75,14 @@ func TestDir_MkdirAllIdempotent(t *testing.T) { func TestDir_MkdirAllAndCreate(t *testing.T) { eachDirFS(t, func(t *testing.T, fs dirFS) { err := fs.MkdirAll("dir", os.FileMode(0755)) - assert.NoError(t, err) + require.NoError(t, err) f, err := fs.Create("dir/bar/foo") - assert.NoError(t, err) - assert.Nil(t, f.Close()) + require.NoError(t, err) + require.NoError(t, f.Close()) fi, err := fs.Stat("dir/bar/foo") - assert.NoError(t, err) + require.NoError(t, err) assert.False(t, fi.IsDir()) }) } @@ -89,27 +90,28 @@ func TestDir_MkdirAllAndCreate(t *testing.T) { func TestDir_MkdirAllWithExistingFile(t *testing.T) { eachDirFS(t, func(t *testing.T, fs dirFS) { f, err := fs.Create("dir/foo") - assert.NoError(t, err) - assert.Nil(t, f.Close()) + require.NoError(t, err) + require.NoError(t, f.Close()) err = fs.MkdirAll("dir/foo", os.FileMode(0755)) assert.Error(t, err) fi, err := fs.Stat("dir/foo") - assert.NoError(t, err) + require.NoError(t, err) assert.False(t, fi.IsDir()) }) } func TestDir_StatDir(t *testing.T) { eachDirFS(t, func(t *testing.T, fs dirFS) { - fs.MkdirAll("foo/bar", 0755) + err := fs.MkdirAll("foo/bar", 0755) + require.NoError(t, err) fi, err := fs.Stat("foo/bar") - assert.NoError(t, err) + require.NoError(t, err) assert.Equal(t, fi.Name(), "bar") - assert.Equal(t, fi.Mode().IsDir(), true) - assert.Equal(t, fi.ModTime().IsZero(), false) + assert.True(t, fi.Mode().IsDir()) + assert.False(t, fi.ModTime().IsZero()) assert.True(t, fi.IsDir()) }) } @@ -119,7 +121,7 @@ func TestDir_StatDeep(t *testing.T) { files := []string{"foo", "bar", "qux/baz", "qux/qux"} for _, name := range files { err := util.WriteFile(fs, name, nil, 0644) - assert.NoError(t, err) + require.NoError(t, err) } // Some implementations detect directories based on a prefix @@ -129,12 +131,12 @@ func TestDir_StatDeep(t *testing.T) { assert.Nil(t, fi) fi, err = fs.Stat("qux") - assert.NoError(t, err) + require.NoError(t, err) assert.Equal(t, fi.Name(), "qux") assert.True(t, fi.IsDir()) fi, err = fs.Stat("qux/baz") - assert.NoError(t, err) + require.NoError(t, err) assert.Equal(t, fi.Name(), "baz") assert.False(t, fi.IsDir()) }) @@ -145,44 +147,44 @@ func TestDir_ReadDir(t *testing.T) { files := []string{"foo", "bar", "qux/baz", "qux/qux"} for _, name := range files { err := util.WriteFile(fs, name, nil, 0644) - assert.NoError(t, err) + require.NoError(t, err) } info, err := fs.ReadDir("/") - assert.NoError(t, err) + require.NoError(t, err) assert.Len(t, info, 3) info, err = fs.ReadDir("/qux") - assert.NoError(t, err) + require.NoError(t, err) assert.Len(t, info, 2) }) } func TestDir_ReadDirNested(t *testing.T) { eachDirFS(t, func(t *testing.T, fs dirFS) { - max := 100 + maxNestedDirs := 100 path := "/" - for i := 0; i <= max; i++ { + for i := 0; i <= maxNestedDirs; i++ { path = fs.Join(path, strconv.Itoa(i)) } files := []string{fs.Join(path, "f1"), fs.Join(path, "f2")} for _, name := range files { err := util.WriteFile(fs, name, nil, 0644) - assert.NoError(t, err) + require.NoError(t, err) } path = "/" - for i := 0; i < max; i++ { + for i := 0; i < maxNestedDirs; i++ { path = fs.Join(path, strconv.Itoa(i)) info, err := fs.ReadDir(path) - assert.NoError(t, err) + require.NoError(t, err) assert.Len(t, info, 1) } - path = fs.Join(path, strconv.Itoa(max)) + path = fs.Join(path, strconv.Itoa(maxNestedDirs)) info, err := fs.ReadDir(path) - assert.NoError(t, err) + require.NoError(t, err) assert.Len(t, info, 2) }) } @@ -190,21 +192,21 @@ func TestDir_ReadDirNested(t *testing.T) { func TestDir_ReadDirWithMkDirAll(t *testing.T) { eachDirFS(t, func(t *testing.T, fs dirFS) { err := fs.MkdirAll("qux", 0755) - assert.NoError(t, err) + require.NoError(t, err) files := []string{"qux/baz", "qux/qux"} for _, name := range files { err := util.WriteFile(fs, name, nil, 0644) - assert.NoError(t, err) + require.NoError(t, err) } info, err := fs.ReadDir("/") - assert.NoError(t, err) + require.NoError(t, err) assert.Len(t, info, 1) - assert.Equal(t, info[0].IsDir(), true) + assert.True(t, info[0].IsDir()) info, err = fs.ReadDir("/qux") - assert.NoError(t, err) + require.NoError(t, err) assert.Len(t, info, 2) }) } @@ -212,14 +214,14 @@ func TestDir_ReadDirWithMkDirAll(t *testing.T) { func TestDir_ReadDirFileInfo(t *testing.T) { eachDirFS(t, func(t *testing.T, fs dirFS) { err := util.WriteFile(fs, "foo", []byte{'F', 'O', 'O'}, 0644) - assert.NoError(t, err) + require.NoError(t, err) info, err := fs.ReadDir("/") - assert.NoError(t, err) + require.NoError(t, err) assert.Len(t, info, 1) assert.Equal(t, info[0].Size(), int64(3)) - assert.Equal(t, info[0].IsDir(), false) + assert.False(t, info[0].IsDir()) assert.Equal(t, info[0].Name(), "foo") }) } @@ -229,20 +231,20 @@ func TestDir_ReadDirFileInfoDirs(t *testing.T) { files := []string{"qux/baz/foo"} for _, name := range files { err := util.WriteFile(fs, name, []byte{'F', 'O', 'O'}, 0644) - assert.NoError(t, err) + require.NoError(t, err) } info, err := fs.ReadDir("qux") - assert.NoError(t, err) + require.NoError(t, err) assert.Len(t, info, 1) - assert.Equal(t, info[0].IsDir(), true) - assert.Equal(t, info[0].Name(), "baz") + assert.True(t, info[0].IsDir()) + assert.Equal(t, "baz", info[0].Name()) info, err = fs.ReadDir("qux/baz") - assert.NoError(t, err) + require.NoError(t, err) assert.Len(t, info, 1) assert.Equal(t, info[0].Size(), int64(3)) - assert.Equal(t, info[0].IsDir(), false) + assert.False(t, info[0].IsDir()) assert.Equal(t, info[0].Name(), "foo") assert.NotEqual(t, info[0].Mode(), 0) }) @@ -251,50 +253,50 @@ func TestDir_ReadDirFileInfoDirs(t *testing.T) { func TestDir_RenameToDir(t *testing.T) { eachDirFS(t, func(t *testing.T, fs dirFS) { err := util.WriteFile(fs, "foo", nil, 0644) - assert.NoError(t, err) + require.NoError(t, err) err = fs.Rename("foo", "bar/qux") - assert.NoError(t, err) + require.NoError(t, err) old, err := fs.Stat("foo") assert.Nil(t, old) - assert.Equal(t, os.IsNotExist(err), true) + assert.ErrorIs(t, err, os.ErrNotExist) dir, err := fs.Stat("bar") assert.NotNil(t, dir) - assert.NoError(t, err) + require.NoError(t, err) file, err := fs.Stat("bar/qux") assert.Equal(t, file.Name(), "qux") - assert.NoError(t, err) + require.NoError(t, err) }) } func TestDir_RenameDir(t *testing.T) { eachDirFS(t, func(t *testing.T, fs dirFS) { err := fs.MkdirAll("foo", 0755) - assert.NoError(t, err) + require.NoError(t, err) err = util.WriteFile(fs, "foo/bar", nil, 0644) - assert.NoError(t, err) + require.NoError(t, err) err = fs.Rename("foo", "bar") - assert.NoError(t, err) + require.NoError(t, err) dirfoo, err := fs.Stat("foo") assert.Nil(t, dirfoo) - assert.Equal(t, os.IsNotExist(err), true) + assert.ErrorIs(t, err, os.ErrNotExist) dirbar, err := fs.Stat("bar") - assert.NoError(t, err) + require.NoError(t, err) assert.NotNil(t, dirbar) foo, err := fs.Stat("foo/bar") - assert.Equal(t, os.IsNotExist(err), true) + assert.ErrorIs(t, err, os.ErrNotExist) assert.Nil(t, foo) bar, err := fs.Stat("bar/bar") - assert.NoError(t, err) + require.NoError(t, err) assert.NotNil(t, bar) }) } diff --git a/test/fs_test.go b/test/fs_test.go index 4400976..02377c6 100644 --- a/test/fs_test.go +++ b/test/fs_test.go @@ -6,9 +6,10 @@ import ( "runtime" "testing" - . "github.com/go-git/go-billy/v6" + . "github.com/go-git/go-billy/v6" //nolint "github.com/go-git/go-billy/v6/util" "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" ) func eachFS(t *testing.T, test func(t *testing.T, fs Filesystem)) { @@ -25,13 +26,13 @@ func TestFS_SymlinkToDir(t *testing.T) { } eachFS(t, func(t *testing.T, fs Filesystem) { err := fs.MkdirAll("dir", 0755) - assert.NoError(t, err) + require.NoError(t, err) err = fs.Symlink("dir", "link") - assert.NoError(t, err) + require.NoError(t, err) fi, err := fs.Stat("link") - assert.NoError(t, err) + require.NoError(t, err) assert.Equal(t, fi.Name(), "link") assert.True(t, fi.IsDir()) }) @@ -43,13 +44,13 @@ func TestFS_SymlinkReadDir(t *testing.T) { } eachFS(t, func(t *testing.T, fs Filesystem) { err := util.WriteFile(fs, "dir/file", []byte("foo"), 0644) - assert.NoError(t, err) + require.NoError(t, err) err = fs.Symlink("dir", "link") - assert.NoError(t, err) + require.NoError(t, err) info, err := fs.ReadDir("link") - assert.NoError(t, err) + require.NoError(t, err) assert.Len(t, info, 1) assert.Equal(t, info[0].Size(), int64(3)) @@ -61,7 +62,7 @@ func TestFS_SymlinkReadDir(t *testing.T) { func TestFS_CreateWithExistantDir(t *testing.T) { eachFS(t, func(t *testing.T, fs Filesystem) { err := fs.MkdirAll("foo", 0644) - assert.NoError(t, err) + require.NoError(t, err) f, err := fs.Create("foo") assert.Error(t, err) @@ -74,13 +75,13 @@ func TestFS_ReadDirWithChroot(t *testing.T) { files := []string{"foo", "bar", "qux/baz", "qux/qux"} for _, name := range files { err := util.WriteFile(fs, name, nil, 0644) - assert.NoError(t, err) + require.NoError(t, err) } qux, _ := fs.Chroot("/qux") - info, err := qux.(Filesystem).ReadDir("/") - assert.NoError(t, err) + info, err := qux.ReadDir("/") + require.NoError(t, err) assert.Len(t, info, 2) }) } @@ -93,17 +94,17 @@ func TestFS_SymlinkWithChrootBasic(t *testing.T) { qux, _ := fs.Chroot("/qux") err := util.WriteFile(qux, "file", nil, 0644) - assert.NoError(t, err) + require.NoError(t, err) - err = qux.(Filesystem).Symlink("file", "link") - assert.NoError(t, err) + err = qux.Symlink("file", "link") + require.NoError(t, err) fi, err := qux.Stat("link") - assert.NoError(t, err) + require.NoError(t, err) assert.Equal(t, fi.Name(), "link") fi, err = fs.Stat("qux/link") - assert.NoError(t, err) + require.NoError(t, err) assert.Equal(t, fi.Name(), "link") }) } @@ -114,9 +115,10 @@ func TestFS_SymlinkWithChrootCrossBounders(t *testing.T) { } eachFS(t, func(t *testing.T, fs Filesystem) { qux, _ := fs.Chroot("/qux") - util.WriteFile(fs, "file", []byte("foo"), customMode) + err := util.WriteFile(fs, "file", []byte("foo"), customMode) + require.NoError(t, err) - err := qux.Symlink("../../file", "qux/link") + err = qux.Symlink("../../file", "qux/link") assert.Equal(t, err, nil) fi, err := qux.Stat("qux/link") @@ -130,25 +132,28 @@ func TestFS_ReadDirWithLink(t *testing.T) { t.Skip("skipping on Plan 9; symlinks are not supported") } eachFS(t, func(t *testing.T, fs Filesystem) { - util.WriteFile(fs, "foo/bar", []byte("foo"), customMode) - fs.Symlink("bar", "foo/qux") + err := util.WriteFile(fs, "foo/bar", []byte("foo"), customMode) + require.NoError(t, err) + + err = fs.Symlink("bar", "foo/qux") + require.NoError(t, err) info, err := fs.ReadDir("/foo") - assert.NoError(t, err) + require.NoError(t, err) assert.Len(t, info, 2) }) } func TestFS_RemoveAllNonExistent(t *testing.T) { eachFS(t, func(t *testing.T, fs Filesystem) { - assert.NoError(t, util.RemoveAll(fs, "non-existent")) + require.NoError(t, util.RemoveAll(fs, "non-existent")) }) } func TestFS_RemoveAllEmptyDir(t *testing.T) { eachFS(t, func(t *testing.T, fs Filesystem) { - assert.NoError(t, fs.MkdirAll("empty", os.FileMode(0755))) - assert.NoError(t, util.RemoveAll(fs, "empty")) + require.NoError(t, fs.MkdirAll("empty", os.FileMode(0755))) + require.NoError(t, util.RemoveAll(fs, "empty")) _, err := fs.Stat("empty") assert.Error(t, err) assert.Equal(t, os.IsNotExist(err), true) @@ -170,10 +175,10 @@ func TestFS_RemoveAll(t *testing.T) { eachFS(t, func(t *testing.T, fs Filesystem) { for _, fname := range fnames { err := util.WriteFile(fs, fname, nil, 0644) - assert.NoError(t, err) + require.NoError(t, err) } - assert.NoError(t, util.RemoveAll(fs, "foo")) + require.NoError(t, util.RemoveAll(fs, "foo")) for _, fname := range fnames { _, err := fs.Stat(fname) @@ -197,10 +202,10 @@ func TestFS_RemoveAllRelative(t *testing.T) { eachFS(t, func(t *testing.T, fs Filesystem) { for _, fname := range fnames { err := util.WriteFile(fs, fname, nil, 0644) - assert.NoError(t, err) + require.NoError(t, err) } - assert.NoError(t, util.RemoveAll(fs, "foo/bar/..")) + require.NoError(t, util.RemoveAll(fs, "foo/bar/..")) for _, fname := range fnames { _, err := fs.Stat(fname) @@ -212,20 +217,20 @@ func TestFS_RemoveAllRelative(t *testing.T) { func TestFS_ReadDir(t *testing.T) { eachFS(t, func(t *testing.T, fs Filesystem) { err := fs.MkdirAll("qux", 0755) - assert.NoError(t, err) + require.NoError(t, err) files := []string{"foo", "bar", "qux/baz", "qux/qux"} for _, name := range files { err := util.WriteFile(fs, name, nil, 0644) - assert.NoError(t, err) + require.NoError(t, err) } info, err := fs.ReadDir("/") - assert.NoError(t, err) + require.NoError(t, err) assert.Len(t, info, 3) info, err = fs.ReadDir("/qux") - assert.NoError(t, err) + require.NoError(t, err) assert.Len(t, info, 2) }) } diff --git a/test/symlink_test.go b/test/symlink_test.go index cba9c74..5ed54d9 100644 --- a/test/symlink_test.go +++ b/test/symlink_test.go @@ -7,9 +7,10 @@ import ( "runtime" "testing" - . "github.com/go-git/go-billy/v6" + . "github.com/go-git/go-billy/v6" //nolint "github.com/go-git/go-billy/v6/util" "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" ) type symlinkFS interface { @@ -32,17 +33,17 @@ func TestSymlink(t *testing.T) { eachSymlinkFS(t, func(t *testing.T, fs symlinkFS) { err := util.WriteFile(fs, "file", nil, 0644) - assert.NoError(t, err) + require.NoError(t, err) err = fs.Symlink("file", "link") - assert.NoError(t, err) + require.NoError(t, err) fi, err := fs.Lstat("link") - assert.NoError(t, err) + require.NoError(t, err) assert.Equal(t, "link", fi.Name()) fi, err = fs.Stat("link") - assert.NoError(t, err) + require.NoError(t, err) assert.Equal(t, "link", fi.Name()) }) } @@ -54,13 +55,13 @@ func TestSymlinkCrossDirs(t *testing.T) { eachSymlinkFS(t, func(t *testing.T, fs symlinkFS) { err := util.WriteFile(fs, "foo/file", nil, 0644) - assert.NoError(t, err) + require.NoError(t, err) err = fs.Symlink("../foo/file", "bar/link") - assert.NoError(t, err) + require.NoError(t, err) fi, err := fs.Stat("bar/link") - assert.NoError(t, err) + require.NoError(t, err) assert.Equal(t, fi.Name(), "link") }) } @@ -72,16 +73,16 @@ func TestSymlinkNested(t *testing.T) { eachSymlinkFS(t, func(t *testing.T, fs symlinkFS) { err := util.WriteFile(fs, "file", []byte("hello world!"), 0644) - assert.NoError(t, err) + require.NoError(t, err) err = fs.Symlink("file", "linkA") - assert.NoError(t, err) + require.NoError(t, err) err = fs.Symlink("linkA", "linkB") - assert.NoError(t, err) + require.NoError(t, err) fi, err := fs.Stat("linkB") - assert.NoError(t, err) + require.NoError(t, err) assert.Equal(t, fi.Name(), "linkB") assert.Equal(t, fi.Size(), int64(12)) }) @@ -94,7 +95,7 @@ func TestSymlinkWithNonExistentdTarget(t *testing.T) { eachSymlinkFS(t, func(t *testing.T, fs symlinkFS) { err := fs.Symlink("file", "link") - assert.NoError(t, err) + require.NoError(t, err) _, err = fs.Stat("link") assert.Equal(t, os.IsNotExist(err), true) @@ -108,7 +109,7 @@ func TestSymlinkWithExistingLink(t *testing.T) { eachSymlinkFS(t, func(t *testing.T, fs symlinkFS) { err := util.WriteFile(fs, "link", nil, 0644) - assert.NoError(t, err) + require.NoError(t, err) err = fs.Symlink("file", "link") assert.ErrorIs(t, err, os.ErrExist) @@ -122,16 +123,16 @@ func TestOpenWithSymlinkToRelativePath(t *testing.T) { eachSymlinkFS(t, func(t *testing.T, fs symlinkFS) { err := util.WriteFile(fs, "dir/file", []byte("foo"), 0644) - assert.NoError(t, err) + require.NoError(t, err) err = fs.Symlink("file", "dir/link") - assert.NoError(t, err) + require.NoError(t, err) f, err := fs.Open("dir/link") - assert.NoError(t, err) + require.NoError(t, err) all, err := io.ReadAll(f) - assert.NoError(t, err) + require.NoError(t, err) assert.Equal(t, string(all), "foo") assert.Nil(t, f.Close()) }) @@ -147,16 +148,16 @@ func TestOpenWithSymlinkToAbsolutePath(t *testing.T) { eachSymlinkFS(t, func(t *testing.T, fs symlinkFS) { err := util.WriteFile(fs, "dir/file", []byte("foo"), 0644) - assert.NoError(t, err) + require.NoError(t, err) err = fs.Symlink("/dir/file", "dir/link") - assert.NoError(t, err) + require.NoError(t, err) f, err := fs.Open("dir/link") - assert.NoError(t, err) + require.NoError(t, err) all, err := io.ReadAll(f) - assert.NoError(t, err) + require.NoError(t, err) assert.Equal(t, string(all), "foo") assert.Nil(t, f.Close()) }) @@ -169,7 +170,7 @@ func TestReadlink(t *testing.T) { eachSymlinkFS(t, func(t *testing.T, fs symlinkFS) { err := util.WriteFile(fs, "file", nil, 0644) - assert.NoError(t, err) + require.NoError(t, err) _, err = fs.Readlink("file") assert.Error(t, err) @@ -183,13 +184,13 @@ func TestReadlinkWithRelativePath(t *testing.T) { eachSymlinkFS(t, func(t *testing.T, fs symlinkFS) { err := util.WriteFile(fs, "dir/file", nil, 0644) - assert.NoError(t, err) + require.NoError(t, err) err = fs.Symlink("file", "dir/link") - assert.NoError(t, err) + require.NoError(t, err) oldname, err := fs.Readlink("dir/link") - assert.NoError(t, err) + require.NoError(t, err) assert.Equal(t, oldname, "file") }) } @@ -204,13 +205,13 @@ func TestReadlinkWithAbsolutePath(t *testing.T) { eachSymlinkFS(t, func(t *testing.T, fs symlinkFS) { err := util.WriteFile(fs, "dir/file", nil, 0644) - assert.NoError(t, err) + require.NoError(t, err) err = fs.Symlink("/dir/file", "dir/link") - assert.NoError(t, err) + require.NoError(t, err) oldname, err := fs.Readlink("dir/link") - assert.NoError(t, err) + require.NoError(t, err) assert.Equal(t, oldname, expectedSymlinkTarget) }) } @@ -222,10 +223,10 @@ func TestReadlinkWithNonExistentTarget(t *testing.T) { eachSymlinkFS(t, func(t *testing.T, fs symlinkFS) { err := fs.Symlink("file", "link") - assert.NoError(t, err) + require.NoError(t, err) oldname, err := fs.Readlink("link") - assert.NoError(t, err) + require.NoError(t, err) assert.Equal(t, oldname, "file") }) } @@ -247,11 +248,14 @@ func TestStatLink(t *testing.T) { } eachSymlinkFS(t, func(t *testing.T, fs symlinkFS) { - util.WriteFile(fs, "foo/bar", []byte("foo"), customMode) - fs.Symlink("bar", "foo/qux") + err := util.WriteFile(fs, "foo/bar", []byte("foo"), customMode) + require.NoError(t, err) + + err = fs.Symlink("bar", "foo/qux") + require.NoError(t, err) fi, err := fs.Stat("foo/qux") - assert.NoError(t, err) + require.NoError(t, err) assert.Equal(t, fi.Name(), "qux") assert.Equal(t, fi.Size(), int64(3)) assert.Equal(t, fi.Mode(), customMode) @@ -262,10 +266,11 @@ func TestStatLink(t *testing.T) { func TestLstat(t *testing.T) { eachSymlinkFS(t, func(t *testing.T, fs symlinkFS) { - util.WriteFile(fs, "foo/bar", []byte("foo"), customMode) + err := util.WriteFile(fs, "foo/bar", []byte("foo"), customMode) + require.NoError(t, err) fi, err := fs.Lstat("foo/bar") - assert.NoError(t, err) + require.NoError(t, err) assert.Equal(t, fi.Name(), "bar") assert.Equal(t, fi.Size(), int64(3)) assert.Equal(t, fi.Mode()&os.ModeSymlink != 0, false) @@ -280,11 +285,13 @@ func TestLstatLink(t *testing.T) { } eachSymlinkFS(t, func(t *testing.T, fs symlinkFS) { - util.WriteFile(fs, "foo/bar", []byte("fosddddaaao"), customMode) - fs.Symlink("bar", "foo/qux") + err := util.WriteFile(fs, "foo/bar", []byte("fosddddaaao"), customMode) + require.NoError(t, err) + err = fs.Symlink("bar", "foo/qux") + require.NoError(t, err) fi, err := fs.Lstat("foo/qux") - assert.NoError(t, err) + require.NoError(t, err) assert.Equal(t, fi.Name(), "qux") assert.Equal(t, fi.Mode()&os.ModeSymlink != 0, true) assert.Equal(t, fi.ModTime().IsZero(), false) @@ -299,13 +306,13 @@ func TestRenameWithSymlink(t *testing.T) { eachSymlinkFS(t, func(t *testing.T, fs symlinkFS) { err := fs.Symlink("file", "link") - assert.NoError(t, err) + require.NoError(t, err) err = fs.Rename("link", "newlink") - assert.NoError(t, err) + require.NoError(t, err) _, err = fs.Readlink("newlink") - assert.NoError(t, err) + require.NoError(t, err) }) } @@ -316,13 +323,13 @@ func TestRemoveWithSymlink(t *testing.T) { eachSymlinkFS(t, func(t *testing.T, fs symlinkFS) { err := util.WriteFile(fs, "file", []byte("foo"), 0644) - assert.NoError(t, err) + require.NoError(t, err) err = fs.Symlink("file", "link") - assert.NoError(t, err) + require.NoError(t, err) err = fs.Remove("link") - assert.NoError(t, err) + require.NoError(t, err) _, err = fs.Readlink("link") assert.Equal(t, os.IsNotExist(err), true) @@ -331,6 +338,6 @@ func TestRemoveWithSymlink(t *testing.T) { assert.Equal(t, os.IsNotExist(err), true) _, err = fs.Stat("file") - assert.NoError(t, err) + require.NoError(t, err) }) } diff --git a/test/tempfile_test.go b/test/tempfile_test.go index b37764a..922a679 100644 --- a/test/tempfile_test.go +++ b/test/tempfile_test.go @@ -8,6 +8,7 @@ import ( "github.com/go-git/go-billy/v6" "github.com/go-git/go-billy/v6/util" "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" ) type tempFS interface { @@ -26,8 +27,8 @@ func eachTempFS(t *testing.T, test func(t *testing.T, fs tempFS)) { func TestTempFile(t *testing.T) { eachTempFS(t, func(t *testing.T, fs tempFS) { f, err := fs.TempFile("", "bar") - assert.NoError(t, err) - assert.NoError(t, f.Close()) + require.NoError(t, err) + require.NoError(t, f.Close()) assert.NotEqual(t, strings.Index(f.Name(), "bar"), -1) }) @@ -36,8 +37,8 @@ func TestTempFile(t *testing.T) { func TestTempFileWithPath(t *testing.T) { eachTempFS(t, func(t *testing.T, fs tempFS) { f, err := fs.TempFile("foo", "bar") - assert.NoError(t, err) - assert.NoError(t, f.Close()) + require.NoError(t, err) + require.NoError(t, f.Close()) assert.True(t, strings.HasPrefix(f.Name(), fs.Join("foo", "bar"))) }) @@ -46,8 +47,8 @@ func TestTempFileWithPath(t *testing.T) { func TestTempFileFullWithPath(t *testing.T) { eachTempFS(t, func(t *testing.T, fs tempFS) { f, err := fs.TempFile("/foo", "bar") - assert.NoError(t, err) - assert.NoError(t, f.Close()) + require.NoError(t, err) + require.NoError(t, f.Close()) assert.NotEqual(t, strings.Index(f.Name(), fs.Join("foo", "bar")), -1) }) @@ -56,22 +57,22 @@ func TestTempFileFullWithPath(t *testing.T) { func TestRemoveTempFile(t *testing.T) { eachTempFS(t, func(t *testing.T, fs tempFS) { f, err := fs.TempFile("test-dir", "test-prefix") - assert.NoError(t, err) + require.NoError(t, err) fn := f.Name() - assert.NoError(t, f.Close()) - assert.NoError(t, fs.Remove(fn)) + require.NoError(t, f.Close()) + require.NoError(t, fs.Remove(fn)) }) } func TestRenameTempFile(t *testing.T) { eachTempFS(t, func(t *testing.T, fs tempFS) { f, err := fs.TempFile("test-dir", "test-prefix") - assert.NoError(t, err) + require.NoError(t, err) fn := f.Name() - assert.NoError(t, f.Close()) - assert.NoError(t, fs.Rename(fn, "other-path")) + require.NoError(t, f.Close()) + require.NoError(t, fs.Rename(fn, "other-path")) }) } @@ -82,13 +83,13 @@ func TestTempFileMany(t *testing.T) { for j := 0; j < 100; j++ { f, err := fs.TempFile("test-dir", "test-prefix") - assert.NoError(t, err) + require.NoError(t, err) files = append(files, f) } for _, f := range files { - assert.NoError(t, f.Close()) - assert.NoError(t, fs.Remove(f.Name())) + require.NoError(t, f.Close()) + require.NoError(t, fs.Remove(f.Name())) } } }) @@ -101,13 +102,13 @@ func TestTempFileManyWithUtil(t *testing.T) { for j := 0; j < 100; j++ { f, err := util.TempFile(fs, "test-dir", "test-prefix") - assert.NoError(t, err) + require.NoError(t, err) files = append(files, f) } for _, f := range files { - assert.NoError(t, f.Close()) - assert.NoError(t, fs.Remove(f.Name())) + require.NoError(t, f.Close()) + require.NoError(t, fs.Remove(f.Name())) } } }) diff --git a/util/glob.go b/util/glob.go index 31d343a..7de4778 100644 --- a/util/glob.go +++ b/util/glob.go @@ -102,7 +102,7 @@ func readdirnames(fs billy.Filesystem, dir string) ([]string, error) { return nil, err } - var names []string + names := make([]string, 0, len(files)) for _, file := range files { names = append(names, file.Name()) } diff --git a/util/glob_test.go b/util/glob_test.go index eadda44..256a334 100644 --- a/util/glob_test.go +++ b/util/glob_test.go @@ -8,23 +8,27 @@ import ( "github.com/go-git/go-billy/v6/memfs" "github.com/go-git/go-billy/v6/util" "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" ) func TestCreate(t *testing.T) { fs := memfs.New() - util.WriteFile(fs, "foo/qux", nil, 0o644) - util.WriteFile(fs, "foo/bar", nil, 0o644) - util.WriteFile(fs, "foo/baz/foo", nil, 0o644) + err := util.WriteFile(fs, "foo/qux", nil, 0o644) + require.NoError(t, err) + err = util.WriteFile(fs, "foo/bar", nil, 0o644) + require.NoError(t, err) + err = util.WriteFile(fs, "foo/baz/foo", nil, 0o644) + require.NoError(t, err) names, err := util.Glob(fs, "*/b*") assert := assert.New(t) - assert.NoError(err) + require.NoError(t, err) assert.Len(names, 2) sort.Strings(names) - assert.Equal(names, []string{ + assert.Equal([]string{ filepath.Join("foo", "bar"), filepath.Join("foo", "baz"), - }) + }, names) } diff --git a/util/util.go b/util/util.go index cba787e..24b84fa 100644 --- a/util/util.go +++ b/util/util.go @@ -2,6 +2,7 @@ package util import ( "errors" + "fmt" "io" "io/fs" "os" @@ -92,7 +93,6 @@ func removeAll(fs billy.Basic, path string) error { } return err - } // WriteFile writes data to a file named by filename in the given filesystem. @@ -182,9 +182,12 @@ func TempFile(fs billy.Basic, dir, prefix string) (f billy.File, err error) { // to remove the directory when no longer needed. func TempDir(fs billy.Dir, dir, prefix string) (name string, err error) { // This implementation is based on stdlib ioutil.TempDir - if dir == "" { - dir = getTempDir(fs.(billy.Basic)) + base, ok := fs.(billy.Basic) + if !ok { + return "", fmt.Errorf("fs does not implement billy.Basic") + } + dir = getTempDir(base) } nconflict := 0 diff --git a/util/util_test.go b/util/util_test.go index a6efba6..d142179 100644 --- a/util/util_test.go +++ b/util/util_test.go @@ -8,6 +8,7 @@ import ( "github.com/go-git/go-billy/v6/memfs" "github.com/go-git/go-billy/v6/util" + "github.com/stretchr/testify/require" ) func TestTempFile(t *testing.T) { @@ -17,7 +18,7 @@ func TestTempFile(t *testing.T) { if err != nil { t.Fatal(err) } - defer util.RemoveAll(fs, dir) + defer util.RemoveAll(fs, dir) //nolint f, err := util.TempFile(fs, dir, "foo") if f == nil || err != nil { @@ -34,7 +35,8 @@ func TestTempDir_WithDir(t *testing.T) { t.Errorf("TempDir(dir, `util_test`) = %v, %v", name, err) } if name != "" { - util.RemoveAll(fs, name) + err = util.RemoveAll(fs, name) + require.NoError(t, err) re := regexp.MustCompile("^" + regexp.QuoteMeta(filepath.Join(dir, "util_test")) + "[0-9]+$") if !re.MatchString(name) { t.Errorf("TempDir(`"+dir+"`, `util_test`) created bad name %s", name) @@ -45,12 +47,12 @@ func TestTempDir_WithDir(t *testing.T) { func TestReadFile(t *testing.T) { fs := memfs.New() f, err := util.TempFile(fs, "", "") - if err != nil { - t.Fatal(err) - } + require.NoError(t, err) - f.Write([]byte("foo")) - f.Close() + _, err = f.Write([]byte("foo")) + require.NoError(t, err) + err = f.Close() + require.NoError(t, err) data, err := util.ReadFile(fs, f.Name()) if err != nil { @@ -60,7 +62,6 @@ func TestReadFile(t *testing.T) { if string(data) != "foo" || err != nil { t.Errorf("ReadFile(%q, %q) = %v, %v", fs, f.Name(), data, err) } - } func TestTempDir(t *testing.T) { diff --git a/util/walk.go b/util/walk.go index fe61bec..982b92f 100644 --- a/util/walk.go +++ b/util/walk.go @@ -1,6 +1,7 @@ package util import ( + "errors" "os" "path/filepath" @@ -31,13 +32,13 @@ func walk(fs billy.Filesystem, path string, info os.FileInfo, walkFn filepath.Wa filename := filepath.Join(path, name) fileInfo, err := fs.Lstat(filename) if err != nil { - if err := walkFn(filename, fileInfo, err); err != nil && err != filepath.SkipDir { + if err := walkFn(filename, fileInfo, err); err != nil && !errors.Is(err, filepath.SkipDir) { return err } } else { err = walk(fs, filename, fileInfo, walkFn) if err != nil { - if !fileInfo.IsDir() || err != filepath.SkipDir { + if !fileInfo.IsDir() || !errors.Is(err, filepath.SkipDir) { return err } } @@ -64,7 +65,7 @@ func Walk(fs billy.Filesystem, root string, walkFn filepath.WalkFunc) error { err = walk(fs, root, info, walkFn) } - if err == filepath.SkipDir { + if errors.Is(err, filepath.SkipDir) { return nil } diff --git a/util/walk_test.go b/util/walk_test.go index 3baf805..5964329 100644 --- a/util/walk_test.go +++ b/util/walk_test.go @@ -18,16 +18,16 @@ var targetSubfolder = filepath.FromSlash("path/to/some/subfolder") func TestWalkCanSkipTopDirectory(t *testing.T) { filesystem := memfs.New() - err := util.Walk(filesystem, "/root/that/does/not/exist", func(path string, info os.FileInfo, err error) error { return filepath.SkipDir }) + err := util.Walk(filesystem, "/root/that/does/not/exist", func(_ string, _ os.FileInfo, _ error) error { return filepath.SkipDir }) - assert.NoError(t, err) + require.NoError(t, err) } func TestWalkReturnsAnErrorWhenRootDoesNotExist(t *testing.T) { filesystem := memfs.New() - err := util.Walk(filesystem, "/root/that/does/not/exist", func(path string, info os.FileInfo, err error) error { return err }) + err := util.Walk(filesystem, "/root/that/does/not/exist", func(_ string, _ os.FileInfo, err error) error { return err }) - assert.Error(t, err) + require.Error(t, err) } func TestWalkOnPlainFile(t *testing.T) { @@ -35,11 +35,11 @@ func TestWalkOnPlainFile(t *testing.T) { createFile(t, filesystem, "./README.md") discoveredPaths := []string{} - err := util.Walk(filesystem, "./README.md", func(path string, info os.FileInfo, err error) error { + err := util.Walk(filesystem, "./README.md", func(path string, _ os.FileInfo, _ error) error { discoveredPaths = append(discoveredPaths, path) return nil }) - assert.NoError(t, err) + require.NoError(t, err) assert.Equal(t, []string{"./README.md"}, discoveredPaths) } @@ -48,11 +48,11 @@ func TestWalkOnExistingFolder(t *testing.T) { createFile(t, filesystem, "path/to/some/subfolder/that/contain/file") createFile(t, filesystem, "path/to/some/file") discoveredPaths := []string{} - err := util.Walk(filesystem, "path", func(path string, info os.FileInfo, err error) error { + err := util.Walk(filesystem, "path", func(path string, _ os.FileInfo, _ error) error { discoveredPaths = append(discoveredPaths, path) return nil }) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, discoveredPaths, "path") assert.Contains(t, discoveredPaths, filepath.FromSlash("path/to")) @@ -69,14 +69,14 @@ func TestWalkCanSkipFolder(t *testing.T) { createFile(t, filesystem, "path/to/some/subfolder/that/contain/file") createFile(t, filesystem, "path/to/some/file") discoveredPaths := []string{} - err := util.Walk(filesystem, "path", func(path string, info os.FileInfo, err error) error { + err := util.Walk(filesystem, "path", func(path string, _ os.FileInfo, _ error) error { discoveredPaths = append(discoveredPaths, path) if path == targetSubfolder { return filepath.SkipDir } return nil }) - assert.NoError(t, err) + require.NoError(t, err) assert.Contains(t, discoveredPaths, "path") assert.Contains(t, discoveredPaths, filepath.FromSlash("path/to")) assert.Contains(t, discoveredPaths, filepath.FromSlash("path/to/some")) @@ -92,14 +92,14 @@ func TestWalkStopsOnError(t *testing.T) { createFile(t, filesystem, "path/to/some/subfolder/that/contain/file") createFile(t, filesystem, "path/to/some/file") discoveredPaths := []string{} - err := util.Walk(filesystem, "path", func(path string, info os.FileInfo, err error) error { + err := util.Walk(filesystem, "path", func(path string, _ os.FileInfo, _ error) error { discoveredPaths = append(discoveredPaths, path) if path == targetSubfolder { return errors.New("uncaught error") } return nil }) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, discoveredPaths, "path") assert.Contains(t, discoveredPaths, filepath.FromSlash("path/to")) assert.Contains(t, discoveredPaths, filepath.FromSlash("path/to/some")) @@ -125,14 +125,14 @@ func TestWalkForwardsStatErrors(t *testing.T) { createFile(t, filesystem, "path/to/some/subfolder/that/contain/file") createFile(t, filesystem, "path/to/some/file") discoveredPaths := []string{} - err := util.Walk(filesystem, "path", func(path string, info os.FileInfo, err error) error { + err := util.Walk(filesystem, "path", func(path string, _ os.FileInfo, err error) error { discoveredPaths = append(discoveredPaths, path) if path == targetSubfolder { - assert.Error(t, err) + require.Error(t, err) } return err }) - assert.Error(t, err) + require.Error(t, err) assert.Contains(t, discoveredPaths, "path") assert.Contains(t, discoveredPaths, filepath.FromSlash("path/to")) assert.Contains(t, discoveredPaths, filepath.FromSlash("path/to/some")) @@ -144,6 +144,7 @@ func TestWalkForwardsStatErrors(t *testing.T) { } func createFile(t *testing.T, filesystem billy.Filesystem, path string) { + t.Helper() fd, err := filesystem.Create(path) require.NoError(t, err)