msb-public
/
helm
mirror of https://github.com/helm/helm
1
0
Code Issues Projects Releases Wiki Activity

chore(internal): refactor: convert tests to testify assert/require part 3

Browse Source 
refactor: convert tests to testify assert/require in internal
Signed-off-by: Matthieu MOREL <matthieu.morel35@gmail.com>
pull/32407/head
Matthieu MOREL 2 months ago
parent 06978bd8c5
commit 668e7e580a
4 changed files with 112 additions and 253 deletions
Show Stats Download Patch File Download Diff File

10
internal/chart/v3/dependency_test.go
Unescape View File

@ -17,6 +17,8 @@ package v3
import ( import (
"testing" "testing"
"github.com/stretchr/testify/assert"
) )
func TestValidateDependency(t *testing.T) { func TestValidateDependency(t *testing.T) {
@ -35,10 +37,10 @@ func TestValidateDependency(t *testing.T) {
} { } {
dep.Alias = value dep.Alias = value
res := dep.Validate() res := dep.Validate()
if res != nil && !shouldFail { if shouldFail {
t.Errorf("Failed on case %q", dep.Alias) assert.Errorf(t, res, "Expected failure for %q", dep.Alias)
} else if res == nil && shouldFail { } else {
t.Errorf("Expected failure for %q", dep.Alias) assert.NoErrorf(t, res, "Failed on case %q", dep.Alias)
} }
} }
} }

53
internal/chart/v3/lint/rules/chartfile_test.go
Unescape View File

@ -52,24 +52,19 @@ func TestValidateChartYamlNotDirectory(t *testing.T) {
_ = os.Mkdir(nonExistingChartFilePath, os.ModePerm) _ = os.Mkdir(nonExistingChartFilePath, os.ModePerm)
defer os.Remove(nonExistingChartFilePath) defer os.Remove(nonExistingChartFilePath)
err := validateChartYamlNotDirectory(nonExistingChartFilePath) assert.Error(t, validateChartYamlNotDirectory(nonExistingChartFilePath), "validateChartYamlNotDirectory to return a linter error, got no error")
assert.Error(t, err, "validateChartYamlNotDirectory to return a linter error, got no error")
} }
func TestValidateChartYamlFormat(t *testing.T) { func TestValidateChartYamlFormat(t *testing.T) {
err := validateChartYamlFormat(errors.New("Read error")) require.Error(t, validateChartYamlFormat(errors.New("Read error")), "validateChartYamlFormat to return a linter error, got no error")
require.Error(t, err, "validateChartYamlFormat to return a linter error, got no error")
err = validateChartYamlFormat(nil) assert.NoError(t, validateChartYamlFormat(nil), "validateChartYamlFormat to return no error, got a linter error")
assert.NoError(t, err, "validateChartYamlFormat to return no error, got a linter error")
} }
func TestValidateChartName(t *testing.T) { func TestValidateChartName(t *testing.T) {
err := validateChartName(badChart) require.Error(t, validateChartName(badChart), "validateChartName to return a linter error, got no error")
require.Error(t, err, "validateChartName to return a linter error, got no error")
err = validateChartName(badChartName) assert.Error(t, validateChartName(badChartName), "expected validateChartName to return a linter error for an invalid name, got no error")
assert.Error(t, err, "expected validateChartName to return a linter error for an invalid name, got no error")
} }
func TestValidateChartVersion(t *testing.T) { func TestValidateChartVersion(t *testing.T) {
@ -90,15 +85,13 @@ func TestValidateChartVersion(t *testing.T) {
for i, test := range failTest { for i, test := range failTest {
t.Run(strconv.Itoa(i), func(t *testing.T) { t.Run(strconv.Itoa(i), func(t *testing.T) {
badChart.Version = test.Version badChart.Version = test.Version
err := validateChartVersion(badChart) require.ErrorContains(t, validateChartVersion(badChart), test.ErrorMsg, "validateChartVersion(%s) to return \"%s\", got no error", test.Version, test.ErrorMsg)
require.ErrorContains(t, err, test.ErrorMsg, "validateChartVersion(%s) to return \"%s\", got no error", test.Version, test.ErrorMsg)
}) })
} }
for _, version := range successTest { for _, version := range successTest {
badChart.Version = version badChart.Version = version
err := validateChartVersion(badChart) assert.NoError(t, validateChartVersion(badChart), "validateChartVersion(%s) to return no error, got a linter error", version)
assert.NoError(t, err, "validateChartVersion(%s) to return no error, got a linter error", version)
} }
} }
@ -124,24 +117,20 @@ func TestValidateChartMaintainer(t *testing.T) {
for _, test := range failTest { for _, test := range failTest {
t.Run(fmt.Sprintf("%s, %s", test.Name, test.Email), func(t *testing.T) { t.Run(fmt.Sprintf("%s, %s", test.Name, test.Email), func(t *testing.T) {
badChart.Maintainers = []*chart.Maintainer{{Name: test.Name, Email: test.Email}} badChart.Maintainers = []*chart.Maintainer{{Name: test.Name, Email: test.Email}}
err := validateChartMaintainer(badChart) require.ErrorContains(t, validateChartMaintainer(badChart), test.ErrorMsg, "validateChartMaintainer(%s, %s) to return \"%s\", got no error", test.Name, test.Email, test.ErrorMsg)
require.ErrorContains(t, err, test.ErrorMsg, "validateChartMaintainer(%s, %s) to return \"%s\", got no error", test.Name, test.Email, test.ErrorMsg)
}) })
} }
for _, test := range successTest { for _, test := range successTest {
t.Run(fmt.Sprintf("%s, %s", test.Name, test.Email), func(t *testing.T) { t.Run(fmt.Sprintf("%s, %s", test.Name, test.Email), func(t *testing.T) {
badChart.Maintainers = []*chart.Maintainer{{Name: test.Name, Email: test.Email}} badChart.Maintainers = []*chart.Maintainer{{Name: test.Name, Email: test.Email}}
err := validateChartMaintainer(badChart) require.NoError(t, validateChartMaintainer(badChart), "validateChartMaintainer(%s, %s) to return no error", test.Name, test.Email)
require.NoError(t, err, "validateChartMaintainer(%s, %s) to return no error", test.Name, test.Email)
}) })
} }
// Testing for an empty maintainer // Testing for an empty maintainer
badChart.Maintainers = []*chart.Maintainer{nil} badChart.Maintainers = []*chart.Maintainer{nil}
err := validateChartMaintainer(badChart) assert.EqualError(t, validateChartMaintainer(badChart), "a maintainer entry is empty")
require.Error(t, err, "validateChartMaintainer did not return error for nil maintainer as expected")
assert.EqualError(t, err, "a maintainer entry is empty", "validateChartMaintainer returned unexpected error for nil maintainer")
} }
func TestValidateChartSources(t *testing.T) { func TestValidateChartSources(t *testing.T) {
@ -150,15 +139,13 @@ func TestValidateChartSources(t *testing.T) {
for _, test := range failTest { for _, test := range failTest {
t.Run(test, func(t *testing.T) { t.Run(test, func(t *testing.T) {
badChart.Sources = []string{test} badChart.Sources = []string{test}
err := validateChartSources(badChart) require.ErrorContains(t, validateChartSources(badChart), "invalid source URL", "validateChartSources(%s) to return \"invalid source URL\", got no error", test)
require.ErrorContains(t, err, "invalid source URL", "validateChartSources(%s) to return \"invalid source URL\", got no error", test)
}) })
} }
for _, test := range successTest { for _, test := range successTest {
badChart.Sources = []string{test} badChart.Sources = []string{test}
err := validateChartSources(badChart) assert.NoError(t, validateChartSources(badChart), "validateChartSources(%s) to return no error", test)
assert.NoError(t, err, "validateChartSources(%s) to return no error", test)
} }
} }
@ -168,19 +155,13 @@ func TestValidateChartIconPresence(t *testing.T) {
Icon: "", Icon: "",
} }
err := validateChartIconPresence(testChart) assert.ErrorContains(t, validateChartIconPresence(testChart), "icon is recommended", "expected %q", "icon is recommended")
require.Error(t, err, "validateChartIconPresence to return a linter error, got no error")
assert.ErrorContains(t, err, "icon is recommended", "expected %q", "icon is recommended")
}) })
t.Run("Icon present", func(t *testing.T) { t.Run("Icon present", func(t *testing.T) {
testChart := &chart.Metadata{ testChart := &chart.Metadata{
Icon: "http://example.org/icon.png", Icon: "http://example.org/icon.png",
} }
assert.NoError(t, validateChartIconPresence(testChart))
err := validateChartIconPresence(testChart)
assert.NoError(t, err, "Unexpected error")
}) })
} }
@ -190,15 +171,13 @@ func TestValidateChartIconURL(t *testing.T) {
for _, test := range failTest { for _, test := range failTest {
t.Run(test, func(t *testing.T) { t.Run(test, func(t *testing.T) {
badChart.Icon = test badChart.Icon = test
err := validateChartIconURL(badChart) require.ErrorContains(t, validateChartIconURL(badChart), "invalid icon URL", "validateChartIconURL(%s) to return \"invalid icon URL\", got no error", test)
require.ErrorContains(t, err, "invalid icon URL", "validateChartIconURL(%s) to return \"invalid icon URL\", got no error", test)
}) })
} }
for _, test := range successTest { for _, test := range successTest {
badChart.Icon = test badChart.Icon = test
err := validateChartIconURL(badChart) assert.NoError(t, validateChartIconURL(badChart), "validateChartIconURL(%s) to return no error", test)
assert.NoError(t, err, "validateChartIconURL(%s) to return no error", test)
} }
} }

40
internal/chart/v3/util/expand_test.go
Unescape View File

@ -47,19 +47,19 @@ func makeTestChartArchive(t *testing.T, chartName, sourceDir string) *bytes.Buff
fStat, err := f.Stat() fStat, err := f.Stat()
require.NoError(t, err) require.NoError(t, err)
err = tw.WriteHeader(&tar.Header{ require.NoError(t, tw.WriteHeader(&tar.Header{
Name: filepath.Join(chartName, relPath), Name: filepath.Join(chartName, relPath),
Mode: int64(fStat.Mode()), Mode: int64(fStat.Mode()),
Size: fStat.Size(), Size: fStat.Size(),
}) }))
require.NoError(t, err)
data, err := fs.ReadFile(dir, relPath) data, err := fs.ReadFile(dir, relPath)
require.NoError(t, err) require.NoError(t, err)
tw.Write(data) _, err = tw.Write(data)
require.NoError(t, err)
} }
err := fs.WalkDir(dir, ".", func(path string, d os.DirEntry, walkErr error) error { require.NoError(t, fs.WalkDir(dir, ".", func(path string, d os.DirEntry, walkErr error) error {
if walkErr != nil { if walkErr != nil {
return walkErr return walkErr
} }
@ -71,13 +71,10 @@ func makeTestChartArchive(t *testing.T, chartName, sourceDir string) *bytes.Buff
writeFile(path) writeFile(path)
return nil return nil
}) }))
require.NoError(t, err)
err = tw.Close() require.NoError(t, tw.Close())
require.NoError(t, err) require.NoError(t, gw.Close())
err = gw.Close()
require.NoError(t, err)
return &result return &result
} }
@ -87,20 +84,18 @@ func TestExpand(t *testing.T) {
reader, err := os.Open("testdata/frobnitz-1.2.3.tgz") reader, err := os.Open("testdata/frobnitz-1.2.3.tgz")
require.NoError(t, err) require.NoError(t, err)
t.Cleanup(func() { assert.NoError(t, reader.Close()) })
if err := Expand(dest, reader); err != nil { require.NoError(t, Expand(dest, reader))
t.Fatal(err)
}
expectedChartPath := filepath.Join(dest, "frobnitz") expectedChartPath := filepath.Join(dest, "frobnitz")
fi, err := os.Stat(expectedChartPath) fi, err := os.Stat(expectedChartPath)
require.NoError(t, err) require.NoError(t, err)
if !fi.IsDir() { require.Truef(t, fi.IsDir(), "expected a chart directory at %s", expectedChartPath)
t.Fatalf("expected a chart directory at %s", expectedChartPath)
}
dir, err := os.Open(expectedChartPath) dir, err := os.Open(expectedChartPath)
require.NoError(t, err) require.NoError(t, err)
t.Cleanup(func() { assert.NoError(t, dir.Close()) })
fis, err := dir.Readdir(0) fis, err := dir.Readdir(0)
require.NoError(t, err) require.NoError(t, err)
@ -137,8 +132,7 @@ func TestExpandError(t *testing.T) {
archive := makeTestChartArchive(t, tt.chartName, tt.chartDir) archive := makeTestChartArchive(t, tt.chartName, tt.chartDir)
dest := t.TempDir() dest := t.TempDir()
err := Expand(dest, archive) assert.ErrorContains(t, Expand(dest, archive), tt.wantErr)
assert.ErrorContains(t, err, tt.wantErr)
}) })
} }
} }
@ -146,16 +140,12 @@ func TestExpandError(t *testing.T) {
func TestExpandFile(t *testing.T) { func TestExpandFile(t *testing.T) {
dest := t.TempDir() dest := t.TempDir()
if err := ExpandFile(dest, "testdata/frobnitz-1.2.3.tgz"); err != nil { require.NoError(t, ExpandFile(dest, "testdata/frobnitz-1.2.3.tgz"))
t.Fatal(err)
}
expectedChartPath := filepath.Join(dest, "frobnitz") expectedChartPath := filepath.Join(dest, "frobnitz")
fi, err := os.Stat(expectedChartPath) fi, err := os.Stat(expectedChartPath)
require.NoError(t, err) require.NoError(t, err)
if !fi.IsDir() { require.Truef(t, fi.IsDir(), "expected a chart directory at %s", expectedChartPath)
t.Fatalf("expected a chart directory at %s", expectedChartPath)
}
dir, err := os.Open(expectedChartPath) dir, err := os.Open(expectedChartPath)
require.NoError(t, err) require.NoError(t, err)

254
internal/third_party/dep/fs/fs_test.go vendored
Unescape View File

@ -32,54 +32,41 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
package fs package fs
import ( import (
"errors"
"os" "os"
"path/filepath" "path/filepath"
"runtime" "runtime"
"testing" "testing"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
) )
func TestRenameWithFallback(t *testing.T) { func TestRenameWithFallback(t *testing.T) {
dir := t.TempDir() dir := t.TempDir()
if err := RenameWithFallback(filepath.Join(dir, "does_not_exists"), filepath.Join(dir, "dst")); err == nil { require.Error(t, RenameWithFallback(filepath.Join(dir, "does_not_exists"), filepath.Join(dir, "dst")), "expected an error for non existing file, but got nil")
t.Fatal("expected an error for non existing file, but got nil")
}
srcpath := filepath.Join(dir, "src") srcpath := filepath.Join(dir, "src")
if srcf, err := os.Create(srcpath); err != nil { srcf, err := os.Create(srcpath)
t.Fatal(err) require.NoError(t, err)
} else {
srcf.Close() srcf.Close()
}
if err := RenameWithFallback(srcpath, filepath.Join(dir, "dst")); err != nil { require.NoError(t, RenameWithFallback(srcpath, filepath.Join(dir, "dst")))
t.Fatal(err)
}
srcpath = filepath.Join(dir, "a") srcpath = filepath.Join(dir, "a")
if err := os.MkdirAll(srcpath, 0o777); err != nil { require.NoError(t, os.MkdirAll(srcpath, 0o777))
t.Fatal(err)
}
dstpath := filepath.Join(dir, "b") dstpath := filepath.Join(dir, "b")
if err := os.MkdirAll(dstpath, 0o777); err != nil { require.NoError(t, os.MkdirAll(dstpath, 0o777))
t.Fatal(err) require.Error(t, RenameWithFallback(srcpath, dstpath), "expected an error if dst is an existing directory, but got nil")
}
if err := RenameWithFallback(srcpath, dstpath); err == nil {
t.Fatal("expected an error if dst is an existing directory, but got nil")
}
} }
func TestCopyDir(t *testing.T) { func TestCopyDir(t *testing.T) {
dir := t.TempDir() dir := t.TempDir()
srcdir := filepath.Join(dir, "src") srcdir := filepath.Join(dir, "src")
if err := os.MkdirAll(srcdir, 0o755); err != nil { require.NoError(t, os.MkdirAll(srcdir, 0o755))
t.Fatal(err)
}
files := []struct { files := []struct {
path string path string
@ -94,62 +81,41 @@ func TestCopyDir(t *testing.T) {
for i, file := range files { for i, file := range files {
fn := filepath.Join(srcdir, file.path) fn := filepath.Join(srcdir, file.path)
dn := filepath.Dir(fn) dn := filepath.Dir(fn)
if err := os.MkdirAll(dn, 0o755); err != nil { require.NoError(t, os.MkdirAll(dn, 0o755))
t.Fatal(err)
}
fh, err := os.Create(fn) fh, err := os.Create(fn)
if err != nil { require.NoError(t, err)
t.Fatal(err)
}
if _, err = fh.WriteString(file.contents); err != nil { _, err = fh.WriteString(file.contents)
t.Fatal(err) require.NoError(t, err)
}
fh.Close() fh.Close()
files[i].fi, err = os.Stat(fn) files[i].fi, err = os.Stat(fn)
if err != nil { require.NoError(t, err)
t.Fatal(err)
}
} }
destdir := filepath.Join(dir, "dest") destdir := filepath.Join(dir, "dest")
if err := CopyDir(srcdir, destdir); err != nil { require.NoError(t, CopyDir(srcdir, destdir))
t.Fatal(err)
}
// Compare copy against structure indicated in 'files' // Compare copy against structure indicated in 'files'
for _, file := range files { for _, file := range files {
fn := filepath.Join(srcdir, file.path) fn := filepath.Join(srcdir, file.path)
dn := filepath.Dir(fn) dn := filepath.Dir(fn)
dirOK, err := IsDir(dn) dirOK, err := IsDir(dn)
if err != nil { require.NoError(t, err)
t.Fatal(err) require.Truef(t, dirOK, "expected %s to be a directory", dn)
}
if !dirOK {
t.Fatalf("expected %s to be a directory", dn)
}
got, err := os.ReadFile(fn) got, err := os.ReadFile(fn)
if err != nil { require.NoError(t, err)
t.Fatal(err)
}
if file.contents != string(got) { require.Equalf(t, file.contents, string(got), "expected: %s, got: %s", file.contents, string(got))
t.Fatalf("expected: %s, got: %s", file.contents, string(got))
}
gotinfo, err := os.Stat(fn) gotinfo, err := os.Stat(fn)
if err != nil { require.NoError(t, err)
t.Fatal(err)
}
if file.fi.Mode() != gotinfo.Mode() { require.Equalf(t, file.fi.Mode(), gotinfo.Mode(), "expected %s: %#v\n to be the same mode as %s: %#v",
t.Fatalf("expected %s: %#v\n to be the same mode as %s: %#v",
file.path, file.fi.Mode(), fn, gotinfo.Mode()) file.path, file.fi.Mode(), fn, gotinfo.Mode())
} }
}
} }
func TestCopyDirFail_SrcInaccessible(t *testing.T) { func TestCopyDirFail_SrcInaccessible(t *testing.T) {
@ -178,9 +144,7 @@ func TestCopyDirFail_SrcInaccessible(t *testing.T) {
dir := t.TempDir() dir := t.TempDir()
dstdir = filepath.Join(dir, "dst") dstdir = filepath.Join(dir, "dst")
if err := CopyDir(srcdir, dstdir); err == nil { assert.Errorf(t, CopyDir(srcdir, dstdir), "expected error for CopyDir(%s, %s), got none", srcdir, dstdir)
t.Fatalf("expected error for CopyDir(%s, %s), got none", srcdir, dstdir)
}
} }
func TestCopyDirFail_DstInaccessible(t *testing.T) { func TestCopyDirFail_DstInaccessible(t *testing.T) {
@ -203,9 +167,7 @@ func TestCopyDirFail_DstInaccessible(t *testing.T) {
dir := t.TempDir() dir := t.TempDir()
srcdir = filepath.Join(dir, "src") srcdir = filepath.Join(dir, "src")
if err := os.MkdirAll(srcdir, 0o755); err != nil { require.NoError(t, os.MkdirAll(srcdir, 0o755))
t.Fatal(err)
}
cleanup := setupInaccessibleDir(t, func(dir string) error { cleanup := setupInaccessibleDir(t, func(dir string) error {
dstdir = filepath.Join(dir, "dst") dstdir = filepath.Join(dir, "dst")
@ -213,9 +175,7 @@ func TestCopyDirFail_DstInaccessible(t *testing.T) {
}) })
defer cleanup() defer cleanup()
if err := CopyDir(srcdir, dstdir); err == nil { assert.Errorf(t, CopyDir(srcdir, dstdir), "expected error for CopyDir(%s, %s), got none", srcdir, dstdir)
t.Fatalf("expected error for CopyDir(%s, %s), got none", srcdir, dstdir)
}
} }
func TestCopyDirFail_SrcIsNotDir(t *testing.T) { func TestCopyDirFail_SrcIsNotDir(t *testing.T) {
@ -225,44 +185,25 @@ func TestCopyDirFail_SrcIsNotDir(t *testing.T) {
dir := t.TempDir() dir := t.TempDir()
srcdir = filepath.Join(dir, "src") srcdir = filepath.Join(dir, "src")
if _, err = os.Create(srcdir); err != nil { _, err = os.Create(srcdir)
t.Fatal(err) require.NoError(t, err)
}
dstdir = filepath.Join(dir, "dst") dstdir = filepath.Join(dir, "dst")
if err = CopyDir(srcdir, dstdir); err == nil { require.ErrorIsf(t, CopyDir(srcdir, dstdir), errSrcNotDir, "expected %v error for CopyDir(%s, %s)", errSrcNotDir, srcdir, dstdir)
t.Fatalf("expected error for CopyDir(%s, %s), got none", srcdir, dstdir)
}
if !errors.Is(err, errSrcNotDir) {
t.Fatalf("expected %v error for CopyDir(%s, %s), got %s", errSrcNotDir, srcdir, dstdir, err)
}
} }
func TestCopyDirFail_DstExists(t *testing.T) { func TestCopyDirFail_DstExists(t *testing.T) {
var srcdir, dstdir string var srcdir, dstdir string
var err error
dir := t.TempDir() dir := t.TempDir()
srcdir = filepath.Join(dir, "src") srcdir = filepath.Join(dir, "src")
if err = os.MkdirAll(srcdir, 0o755); err != nil { require.NoError(t, os.MkdirAll(srcdir, 0o755))
t.Fatal(err)
}
dstdir = filepath.Join(dir, "dst") dstdir = filepath.Join(dir, "dst")
if err = os.MkdirAll(dstdir, 0o755); err != nil { require.NoError(t, os.MkdirAll(dstdir, 0o755))
t.Fatal(err) require.ErrorIs(t, CopyDir(srcdir, dstdir), errDstExist, "expected %v error for CopyDir(%s, %s)", errDstExist, srcdir, dstdir)
}
if err = CopyDir(srcdir, dstdir); err == nil {
t.Fatalf("expected error for CopyDir(%s, %s), got none", srcdir, dstdir)
}
if !errors.Is(err, errDstExist) {
t.Fatalf("expected %v error for CopyDir(%s, %s), got %s", errDstExist, srcdir, dstdir, err)
}
} }
func TestCopyDirFailOpen(t *testing.T) { func TestCopyDirFailOpen(t *testing.T) {
@ -288,70 +229,46 @@ func TestCopyDirFailOpen(t *testing.T) {
dir := t.TempDir() dir := t.TempDir()
srcdir = filepath.Join(dir, "src") srcdir = filepath.Join(dir, "src")
if err := os.MkdirAll(srcdir, 0o755); err != nil { require.NoError(t, os.MkdirAll(srcdir, 0o755))
t.Fatal(err)
}
srcfn := filepath.Join(srcdir, "file") srcfn := filepath.Join(srcdir, "file")
srcf, err := os.Create(srcfn) srcf, err := os.Create(srcfn)
if err != nil { require.NoError(t, err)
t.Fatal(err)
}
srcf.Close() srcf.Close()
// setup source file so that it cannot be read // setup source file so that it cannot be read
if err = os.Chmod(srcfn, 0o222); err != nil { require.NoError(t, os.Chmod(srcfn, 0o222))
t.Fatal(err)
}
dstdir = filepath.Join(dir, "dst") dstdir = filepath.Join(dir, "dst")
assert.Errorf(t, CopyDir(srcdir, dstdir), "expected error for CopyDir(%s, %s), got none", srcdir, dstdir)
if err = CopyDir(srcdir, dstdir); err == nil {
t.Fatalf("expected error for CopyDir(%s, %s), got none", srcdir, dstdir)
}
} }
func TestCopyFile(t *testing.T) { func TestCopyFile(t *testing.T) {
dir := t.TempDir() dir := t.TempDir()
srcf, err := os.Create(filepath.Join(dir, "srcfile")) srcf, err := os.Create(filepath.Join(dir, "srcfile"))
if err != nil { require.NoError(t, err)
t.Fatal(err)
}
want := "hello world" want := "hello world"
if _, err := srcf.WriteString(want); err != nil { _, err = srcf.WriteString(want)
t.Fatal(err) require.NoError(t, err)
}
srcf.Close() srcf.Close()
destf := filepath.Join(dir, "destf") destf := filepath.Join(dir, "destf")
if err := CopyFile(srcf.Name(), destf); err != nil { require.NoError(t, CopyFile(srcf.Name(), destf))
t.Fatal(err)
}
got, err := os.ReadFile(destf) got, err := os.ReadFile(destf)
if err != nil { require.NoError(t, err)
t.Fatal(err)
}
if want != string(got) { require.Equalf(t, want, string(got), "expected: %s, got: %s", want, string(got))
t.Fatalf("expected: %s, got: %s", want, string(got))
}
wantinfo, err := os.Stat(srcf.Name()) wantinfo, err := os.Stat(srcf.Name())
if err != nil { require.NoError(t, err)
t.Fatal(err)
}
gotinfo, err := os.Stat(destf) gotinfo, err := os.Stat(destf)
if err != nil { require.NoError(t, err)
t.Fatal(err)
}
if wantinfo.Mode() != gotinfo.Mode() { assert.Equalf(t, wantinfo.Mode(), gotinfo.Mode(), "expected %s: %#v\n to be the same mode as %s: %#v", srcf.Name(), wantinfo.Mode(), destf, gotinfo.Mode())
t.Fatalf("expected %s: %#v\n to be the same mode as %s: %#v", srcf.Name(), wantinfo.Mode(), destf, gotinfo.Mode())
}
} }
func TestCopyFileSymlink(t *testing.T) { func TestCopyFileSymlink(t *testing.T) {
@ -366,9 +283,7 @@ func TestCopyFileSymlink(t *testing.T) {
for symlink, dst := range testcases { for symlink, dst := range testcases {
t.Run(symlink, func(t *testing.T) { t.Run(symlink, func(t *testing.T) {
var err error var err error
if err = CopyFile(symlink, dst); err != nil { require.NoErrorf(t, CopyFile(symlink, dst), "failed to copy symlink")
t.Fatalf("failed to copy symlink: %s", err)
}
var want, got string var want, got string
@ -377,31 +292,21 @@ func TestCopyFileSymlink(t *testing.T) {
// regular users aren't granted usually. So we copy the file // regular users aren't granted usually. So we copy the file
// content as a fall back instead of creating a real symlink. // content as a fall back instead of creating a real symlink.
srcb, err := os.ReadFile(symlink) srcb, err := os.ReadFile(symlink)
if err != nil { require.NoError(t, err)
t.Fatalf("%+v", err)
}
dstb, err := os.ReadFile(dst) dstb, err := os.ReadFile(dst)
if err != nil { require.NoError(t, err)
t.Fatalf("%+v", err)
}
want = string(srcb) want = string(srcb)
got = string(dstb) got = string(dstb)
} else { } else {
want, err = os.Readlink(symlink) want, err = os.Readlink(symlink)
if err != nil { require.NoError(t, err)
t.Fatalf("%+v", err)
}
got, err = os.Readlink(dst) got, err = os.Readlink(dst)
if err != nil { require.NoErrorf(t, err, "could not resolve symlink")
t.Fatalf("could not resolve symlink: %s", err)
}
} }
if want != got { require.Equalf(t, want, got, "resolved path is incorrect. expected %s, got %s", want, got)
t.Fatalf("resolved path is incorrect. expected %s, got %s", want, got)
}
}) })
} }
} }
@ -424,9 +329,7 @@ func TestCopyFileFail(t *testing.T) {
dir := t.TempDir() dir := t.TempDir()
srcf, err := os.Create(filepath.Join(dir, "srcfile")) srcf, err := os.Create(filepath.Join(dir, "srcfile"))
if err != nil { require.NoError(t, err)
t.Fatal(err)
}
srcf.Close() srcf.Close()
var dstdir string var dstdir string
@ -438,9 +341,7 @@ func TestCopyFileFail(t *testing.T) {
defer cleanup() defer cleanup()
fn := filepath.Join(dstdir, "file") fn := filepath.Join(dstdir, "file")
if err := CopyFile(srcf.Name(), fn); err == nil { require.Errorf(t, CopyFile(srcf.Name(), fn), "expected error for %s, got none", fn)
t.Fatalf("expected error for %s, got none", fn)
}
} }
// setupInaccessibleDir creates a temporary location with a single // setupInaccessibleDir creates a temporary location with a single
@ -463,9 +364,7 @@ func setupInaccessibleDir(t *testing.T, op func(dir string) error) func() {
subdir := filepath.Join(dir, "dir") subdir := filepath.Join(dir, "dir")
cleanup := func() { cleanup := func() {
if err := os.Chmod(subdir, 0o777); err != nil { assert.NoError(t, os.Chmod(subdir, 0o777))
t.Error(err)
}
} }
if err := os.Mkdir(subdir, 0o777); err != nil { if err := os.Mkdir(subdir, 0o777); err != nil {
@ -498,9 +397,7 @@ func TestIsDir(t *testing.T) {
} }
wd, err := os.Getwd() wd, err := os.Getwd()
if err != nil { require.NoError(t, err)
t.Fatal(err)
}
var dn string var dn string
@ -530,14 +427,16 @@ func TestIsDir(t *testing.T) {
} }
for f, want := range tests { for f, want := range tests {
t.Run(f, func(t *testing.T) {
got, err := IsDir(f) got, err := IsDir(f)
if err != nil && !want.err {
t.Fatalf("expected no error, got %v", err)
}
if got != want.exists { if want.err {
t.Fatalf("expected %t for %s, got %t", want.exists, f, got) require.Error(t, err)
} else {
require.NoError(t, err)
} }
require.Equalf(t, want.exists, got, "expected %t for %s, got %t", want.exists, f, got)
})
} }
} }
@ -552,26 +451,18 @@ func TestIsSymlink(t *testing.T) {
dir := t.TempDir() dir := t.TempDir()
dirPath := filepath.Join(dir, "directory") dirPath := filepath.Join(dir, "directory")
if err := os.MkdirAll(dirPath, 0o777); err != nil { require.NoError(t, os.MkdirAll(dirPath, 0o777))
t.Fatal(err)
}
filePath := filepath.Join(dir, "file") filePath := filepath.Join(dir, "file")
f, err := os.Create(filePath) f, err := os.Create(filePath)
if err != nil { require.NoError(t, err)
t.Fatal(err)
}
f.Close() f.Close()
dirSymlink := filepath.Join(dir, "dirSymlink") dirSymlink := filepath.Join(dir, "dirSymlink")
fileSymlink := filepath.Join(dir, "fileSymlink") fileSymlink := filepath.Join(dir, "fileSymlink")
if err = os.Symlink(dirPath, dirSymlink); err != nil { require.NoError(t, os.Symlink(dirPath, dirSymlink))
t.Fatal(err) require.NoError(t, os.Symlink(filePath, fileSymlink))
}
if err = os.Symlink(filePath, fileSymlink); err != nil {
t.Fatal(err)
}
var ( var (
inaccessibleFile string inaccessibleFile string
@ -609,14 +500,11 @@ func TestIsSymlink(t *testing.T) {
for path, want := range tests { for path, want := range tests {
got, err := IsSymlink(path) got, err := IsSymlink(path)
if err != nil { if want.err {
if !want.err { require.Error(t, err, "expected an error")
t.Errorf("expected no error, got %v", err) } else {
} require.NoError(t, err, "expected no error")
}
if got != want.expected {
t.Errorf("expected %t for %s, got %t", want.expected, path, got)
} }
assert.Equalf(t, want.expected, got, "expected %t for %s, got %t", want.expected, path, got)
} }
} }

Write Preview
Loading…
Cancel
Save