All LocalPackageReader tests adapted, one fails

2026-05-17 18:25:26 +00:00 · 2021-07-16 09:12:42 -07:00
parent d37fa66ebc
commit 436d5e717c
2 changed files with 224 additions and 172 deletions
--- a/kyaml/kio/pkgio_reader.go
+++ b/kyaml/kio/pkgio_reader.go
@@ -214,11 +214,11 @@ func (r LocalPackageReader) Read() ([]*yaml.RNode, error) {
 	ignoreFilesMatcher := &ignoreFilesMatcher{
 		fs: r.FileSystem,
 	}
-	dir, _, err := r.FileSystem.CleanedAbs(r.PackagePath)
+	dir, file, err := r.FileSystem.CleanedAbs(r.PackagePath)
 	if err != nil {
 		return nil, errors.Wrap(err)
 	}
-	r.PackagePath = string(dir)
+	r.PackagePath = filepath.Join(string(dir), file)
 	err = r.FileSystem.Walk(r.PackagePath, func(
 		path string, info os.FileInfo, err error) error {
 		if err != nil {
--- a/kyaml/kio/pkgio_reader_test.go
+++ b/kyaml/kio/pkgio_reader_test.go
@@ -8,7 +8,6 @@ import (
 	"strings"
 	"testing"

-	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"sigs.k8s.io/kustomize/kyaml/filesys"
 	. "sigs.k8s.io/kustomize/kyaml/kio"
@@ -44,10 +43,9 @@ var pkgFile = []byte(``)
 func TestLocalPackageReader_Read_empty(t *testing.T) {
 	var r LocalPackageReader
 	nodes, err := r.Read()
-	if assert.Error(t, err) {
-		assert.Contains(t, err.Error(), "must specify package path")
-	}
-	assert.Nil(t, nodes)
+	require.Error(t, err)
+	require.Contains(t, err.Error(), "must specify package path")
+	require.Nil(t, nodes)
 }

 func TestLocalPackageReader_Read_pkg(t *testing.T) {
@@ -77,8 +75,10 @@ func TestLocalPackageReader_Read_pkg(t *testing.T) {
 }

 func testLocalPackageReaderReadPkg(t *testing.T, path string, mockFS filesys.FileSystem) {
-	rfr := LocalPackageReader{PackagePath: path}
-	rfr.FileSystem.Set(mockFS)
+	rfr := LocalPackageReader{
+		PackagePath: path,
+		FileSystem:  filesys.FileSystemOrOnDisk{FileSystem: mockFS},
+	}
 	nodes, err := rfr.Read()
 	require.NoError(t, err)
 	require.Len(t, nodes, 5)
@@ -154,20 +154,13 @@ func TestLocalPackageReader_Read_pkgAndSkipFile(t *testing.T) {

 func testLocalPackageReaderReadPkgAndSkipFile(t *testing.T, path string, mockFS filesys.FileSystem) {
 	rfr := LocalPackageReader{
-		PackagePath: path,
-		FileSkipFunc: func(relPath string) bool {
-			return relPath == "d_test.yaml"
-		},
-		FileSystem: filesys.FileSystemOrOnDisk{FileSystem: mockFS},
+		PackagePath:  path,
+		FileSkipFunc: func(relPath string) bool { return relPath == "d_test.yaml" },
+		FileSystem:   filesys.FileSystemOrOnDisk{FileSystem: mockFS},
 	}
 	nodes, err := rfr.Read()
-	if !assert.NoError(t, err) {
-		return
-	}
-
-	if !assert.Len(t, nodes, 4) {
-		return
-	}
+	require.NoError(t, err)
+	require.Len(t, nodes, 4)
 	expected := []string{
 		`a: b #first
 metadata:
@@ -240,7 +233,10 @@ func TestLocalPackageReader_Read_JSON(t *testing.T) {
 }

 func testLocalPackageReaderReadJSON(t *testing.T, path string, mockFS filesys.FileSystem) {
-	rfr := LocalPackageReader{PackagePath: path, MatchFilesGlob: []string{"*.json"}}
+	rfr := LocalPackageReader{
+		PackagePath:    path,
+		MatchFilesGlob: []string{"*.json"},
+	}
 	rfr.FileSystem.Set(mockFS)
 	nodes, err := rfr.Read()
 	require.NoError(t, err)
@@ -310,92 +306,103 @@ metadata:
 }

 func TestLocalPackageReader_Read_pkgOmitAnnotations(t *testing.T) {
-	s := SetupDirectories(t, filepath.Join("a", "b"), filepath.Join("a", "c"))
-	defer s.Clean()
-	s.WriteFile(t, filepath.Join("a_test.yaml"), readFileA)
-	s.WriteFile(t, filepath.Join("b_test.yaml"), readFileB)
+	t.Run("on_disk", func(t *testing.T) {
+		s := SetupDirectories(t, filepath.Join("a", "b"), filepath.Join("a", "c"))
+		defer s.Clean()
+		s.WriteFile(t, filepath.Join("a_test.yaml"), readFileA)
+		s.WriteFile(t, filepath.Join("b_test.yaml"), readFileB)

-	paths := []struct {
-		path string
-	}{
-		{path: "./"},
-		{path: s.Root},
+		testLocalPackageReaderReadPkgOmitAnnotations(t, "./", nil)
+		testLocalPackageReaderReadPkgOmitAnnotations(t, s.Root, nil)
+	})
+
+	t.Run("on_mem", func(t *testing.T) {
+		fs := filesys.MakeFsInMemory()
+		require.NoError(t, fs.MkdirAll(filepath.Join("a", "b")))
+		require.NoError(t, fs.MkdirAll(filepath.Join("a", "c")))
+		require.NoError(t, fs.WriteFile("a_test.yaml", readFileA))
+		require.NoError(t, fs.WriteFile("b_test.yaml", readFileB))
+
+		testLocalPackageReaderReadPkgOmitAnnotations(t, "/", fs)
+	})
+}
+
+func testLocalPackageReaderReadPkgOmitAnnotations(t *testing.T, path string, mockFS filesys.FileSystem) {
+	rfr := LocalPackageReader{
+		PackagePath:           path,
+		OmitReaderAnnotations: true,
+		FileSystem:            filesys.FileSystemOrOnDisk{FileSystem: mockFS},
 	}
-	for _, p := range paths {
-		// empty path
-		rfr := LocalPackageReader{PackagePath: p.path, OmitReaderAnnotations: true}
-		nodes, err := rfr.Read()
-		if !assert.NoError(t, err) {
-			return
-		}
-
-		if !assert.Len(t, nodes, 3) {
-			return
-		}
-		expected := []string{
-			`a: b #first
+	nodes, err := rfr.Read()
+	require.NoError(t, err)
+	require.Len(t, nodes, 3)
+	expected := []string{
+		`a: b #first
 `,
-			`c: d # second
+		`c: d # second
 `,
-			`# second thing
+		`# second thing
 e: f
 g:
  h:
  - i # has a list
  - j
 `,
-		}
-		for i := range nodes {
-			val, err := nodes[i].String()
-			if !assert.NoError(t, err) {
-				return
-			}
-			if !assert.Equal(t, expected[i], val) {
-				return
-			}
-		}
+	}
+	for i := range nodes {
+		val, err := nodes[i].String()
+		require.NoError(t, err)
+		require.Equal(t, expected[i], val)
 	}
 }

 func TestLocalPackageReader_Read_PreserveSeqIndent(t *testing.T) {
-	s := SetupDirectories(t, filepath.Join("a", "b"), filepath.Join("a", "c"))
-	defer s.Clean()
-	s.WriteFile(t, filepath.Join("a_test.yaml"), readFileA)
-	s.WriteFile(t, filepath.Join("b_test.yaml"), readFileB)
+	t.Run("on_disk", func(t *testing.T) {
+		s := SetupDirectories(t, filepath.Join("a", "b"), filepath.Join("a", "c"))
+		defer s.Clean()
+		s.WriteFile(t, filepath.Join("a_test.yaml"), readFileA)
+		s.WriteFile(t, filepath.Join("b_test.yaml"), readFileB)

-	paths := []struct {
-		path string
-	}{
-		{path: "./"},
-		{path: s.Root},
+		testLocalPackageReaderReadPreserveSeqIndent(t, "./", nil)
+		testLocalPackageReaderReadPreserveSeqIndent(t, s.Root, nil)
+	})
+
+	t.Run("on_mem", func(t *testing.T) {
+		fs := filesys.MakeFsInMemory()
+		require.NoError(t, fs.MkdirAll(filepath.Join("a", "b")))
+		require.NoError(t, fs.MkdirAll(filepath.Join("a", "c")))
+		require.NoError(t, fs.WriteFile("a_test.yaml", readFileA))
+		require.NoError(t, fs.WriteFile("b_test.yaml", readFileB))
+
+		testLocalPackageReaderReadPreserveSeqIndent(t, "/", fs)
+	})
+}
+
+func testLocalPackageReaderReadPreserveSeqIndent(t *testing.T, path string, mockFS filesys.FileSystem) {
+	rfr := LocalPackageReader{
+		PackagePath:       path,
+		PreserveSeqIndent: true,
+		FileSystem:        filesys.FileSystemOrOnDisk{FileSystem: mockFS},
 	}
-	for _, p := range paths {
-		// empty path
-		rfr := LocalPackageReader{PackagePath: p.path, PreserveSeqIndent: true}
-		nodes, err := rfr.Read()
-		if !assert.NoError(t, err) {
-			return
-		}
-
-		if !assert.Len(t, nodes, 3) {
-			return
-		}
-		expected := []string{
-			`a: b #first
+	nodes, err := rfr.Read()
+	require.NoError(t, err)
+	require.Len(t, nodes, 3)
+	expected := []string{
+		`a: b #first
 metadata:
  annotations:
    config.kubernetes.io/index: '0'
    config.kubernetes.io/path: 'a_test.yaml'
    internal.config.kubernetes.io/seqindent: 'compact'
 `,
-			`c: d # second
+		`c: d # second
 metadata:
  annotations:
    config.kubernetes.io/index: '1'
    config.kubernetes.io/path: 'a_test.yaml'
    internal.config.kubernetes.io/seqindent: 'compact'
 `,
-			`# second thing
+		`# second thing
 e: f
 g:
  h:
@@ -407,56 +414,58 @@ metadata:
    config.kubernetes.io/path: 'b_test.yaml'
    internal.config.kubernetes.io/seqindent: 'compact'
 `,
-		}
-		for i := range nodes {
-			val, err := nodes[i].String()
-			if !assert.NoError(t, err) {
-				return
-			}
-			if !assert.Equal(t, expected[i], val) {
-				return
-			}
-		}
+	}
+	for i := range nodes {
+		val, err := nodes[i].String()
+		require.NoError(t, err)
+		require.Equal(t, expected[i], val)
 	}
 }

 func TestLocalPackageReader_Read_nestedDirs(t *testing.T) {
-	s := SetupDirectories(t, filepath.Join("a", "b"), filepath.Join("a", "c"))
-	defer s.Clean()
-	s.WriteFile(t, filepath.Join("a", "b", "a_test.yaml"), readFileA)
-	s.WriteFile(t, filepath.Join("a", "b", "b_test.yaml"), readFileB)
+	t.Run("on_disk", func(t *testing.T) {
+		s := SetupDirectories(t, filepath.Join("a", "b"), filepath.Join("a", "c"))
+		defer s.Clean()
+		s.WriteFile(t, filepath.Join("a", "b", "a_test.yaml"), readFileA)
+		s.WriteFile(t, filepath.Join("a", "b", "b_test.yaml"), readFileB)

-	paths := []struct {
-		path string
-	}{
-		{path: "./"},
-		{path: s.Root},
+		testLocalPackageReaderReadNestedDirs(t, "./", nil)
+		testLocalPackageReaderReadNestedDirs(t, s.Root, nil)
+	})
+
+	t.Run("on_mem", func(t *testing.T) {
+		fs := filesys.MakeFsInMemory()
+		require.NoError(t, fs.MkdirAll(filepath.Join("a", "b")))
+		require.NoError(t, fs.MkdirAll(filepath.Join("a", "c")))
+		require.NoError(t, fs.WriteFile(filepath.Join("a", "b", "a_test.yaml"), readFileA))
+		require.NoError(t, fs.WriteFile(filepath.Join("a", "b", "b_test.yaml"), readFileB))
+
+		testLocalPackageReaderReadNestedDirs(t, "/", fs)
+	})
+}
+
+func testLocalPackageReaderReadNestedDirs(t *testing.T, path string, mockFS filesys.FileSystem) {
+	rfr := LocalPackageReader{
+		PackagePath: path,
+		FileSystem:  filesys.FileSystemOrOnDisk{FileSystem: mockFS},
 	}
-	for _, p := range paths {
-		// empty path
-		rfr := LocalPackageReader{PackagePath: p.path}
-		nodes, err := rfr.Read()
-		if !assert.NoError(t, err) {
-			assert.FailNow(t, err.Error())
-		}
-
-		if !assert.Len(t, nodes, 3) {
-			return
-		}
-		expected := []string{
-			`a: b #first
+	nodes, err := rfr.Read()
+	require.NoError(t, err)
+	require.Len(t, nodes, 3)
+	expected := []string{
+		`a: b #first
 metadata:
  annotations:
    config.kubernetes.io/index: '0'
    config.kubernetes.io/path: 'a${SEP}b${SEP}a_test.yaml'
 `,
-			`c: d # second
+		`c: d # second
 metadata:
  annotations:
    config.kubernetes.io/index: '1'
    config.kubernetes.io/path: 'a${SEP}b${SEP}a_test.yaml'
 `,
-			`# second thing
+		`# second thing
 e: f
 g:
  h:
@@ -467,36 +476,46 @@ metadata:
    config.kubernetes.io/index: '0'
    config.kubernetes.io/path: 'a${SEP}b${SEP}b_test.yaml'
 `,
-		}
-		for i := range nodes {
-			val, err := nodes[i].String()
-			if !assert.NoError(t, err) {
-				return
-			}
-			want := strings.ReplaceAll(expected[i], "${SEP}", string(filepath.Separator))
-			if !assert.Equal(t, want, val) {
-				return
-			}
-		}
+	}
+	for i := range nodes {
+		val, err := nodes[i].String()
+		require.NoError(t, err)
+		want := strings.ReplaceAll(expected[i], "${SEP}", string(filepath.Separator))
+		require.Equal(t, want, val)
 	}
 }

 func TestLocalPackageReader_Read_matchRegex(t *testing.T) {
-	s := SetupDirectories(t, filepath.Join("a", "b"), filepath.Join("a", "c"))
-	defer s.Clean()
-	s.WriteFile(t, filepath.Join("a", "b", "a_test.yaml"), readFileA)
-	s.WriteFile(t, filepath.Join("a", "b", "b_test.yaml"), readFileB)
+	t.Run("on_disk", func(t *testing.T) {
+		s := SetupDirectories(t, filepath.Join("a", "b"), filepath.Join("a", "c"))
+		defer s.Clean()
+		s.WriteFile(t, filepath.Join("a", "b", "a_test.yaml"), readFileA)
+		s.WriteFile(t, filepath.Join("a", "b", "b_test.yaml"), readFileB)

-	// empty path
-	rfr := LocalPackageReader{PackagePath: s.Root, MatchFilesGlob: []string{`a*.yaml`}}
+		testLocalPackageReaderReadMatchRegex(t, "./", nil)
+		testLocalPackageReaderReadMatchRegex(t, s.Root, nil)
+	})
+
+	t.Run("on_mem", func(t *testing.T) {
+		fs := filesys.MakeFsInMemory()
+		require.NoError(t, fs.MkdirAll(filepath.Join("a", "b")))
+		require.NoError(t, fs.MkdirAll(filepath.Join("a", "c")))
+		require.NoError(t, fs.WriteFile(filepath.Join("a", "b", "a_test.yaml"), readFileA))
+		require.NoError(t, fs.WriteFile(filepath.Join("a", "b", "b_test.yaml"), readFileB))
+
+		testLocalPackageReaderReadMatchRegex(t, "/", fs)
+	})
+}
+
+func testLocalPackageReaderReadMatchRegex(t *testing.T, path string, mockFS filesys.FileSystem) {
+	rfr := LocalPackageReader{
+		PackagePath:    path,
+		MatchFilesGlob: []string{`a*.yaml`},
+		FileSystem:     filesys.FileSystemOrOnDisk{FileSystem: mockFS},
+	}
 	nodes, err := rfr.Read()
-	if !assert.NoError(t, err) {
-		assert.FailNow(t, err.Error())
-	}
-
-	if !assert.Len(t, nodes, 2) {
-		assert.FailNow(t, "wrong number items")
-	}
+	require.NoError(t, err)
+	require.Len(t, nodes, 2)

 	expected := []string{
 		`a: b #first
@@ -515,29 +534,45 @@ metadata:

 	for i, node := range nodes {
 		val, err := node.String()
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		want := strings.ReplaceAll(expected[i], "${SEP}", string(filepath.Separator))
-		assert.Equal(t, want, val)
+		require.Equal(t, want, val)
 	}
 }

 func TestLocalPackageReader_Read_skipSubpackage(t *testing.T) {
-	s := SetupDirectories(t, filepath.Join("a", "b"), filepath.Join("a", "c"))
-	defer s.Clean()
-	s.WriteFile(t, filepath.Join("a", "b", "a_test.yaml"), readFileA)
-	s.WriteFile(t, filepath.Join("a", "c", "c_test.yaml"), readFileB)
-	s.WriteFile(t, filepath.Join("a", "c", "pkgFile"), pkgFile)
+	t.Run("on_disk", func(t *testing.T) {
+		s := SetupDirectories(t, filepath.Join("a", "b"), filepath.Join("a", "c"))
+		defer s.Clean()
+		s.WriteFile(t, filepath.Join("a", "b", "a_test.yaml"), readFileA)
+		s.WriteFile(t, filepath.Join("a", "c", "c_test.yaml"), readFileB)
+		s.WriteFile(t, filepath.Join("a", "c", "pkgFile"), pkgFile)

-	// empty path
-	rfr := LocalPackageReader{PackagePath: s.Root, PackageFileName: "pkgFile"}
+		testLocalPackageReaderReadSkipSubpackage(t, "./", nil)
+		testLocalPackageReaderReadSkipSubpackage(t, s.Root, nil)
+	})
+
+	t.Run("on_mem", func(t *testing.T) {
+		fs := filesys.MakeFsInMemory()
+		require.NoError(t, fs.MkdirAll(filepath.Join("a", "b")))
+		require.NoError(t, fs.MkdirAll(filepath.Join("a", "c")))
+		require.NoError(t, fs.WriteFile(filepath.Join("a", "b", "a_test.yaml"), readFileA))
+		require.NoError(t, fs.WriteFile(filepath.Join("a", "c", "c_test.yaml"), readFileB))
+		require.NoError(t, fs.WriteFile(filepath.Join("a", "c", "pkgFile"), pkgFile))
+
+		testLocalPackageReaderReadSkipSubpackage(t, "/", fs)
+	})
+}
+
+func testLocalPackageReaderReadSkipSubpackage(t *testing.T, path string, mockFS filesys.FileSystem) {
+	rfr := LocalPackageReader{
+		PackagePath:     path,
+		PackageFileName: "pkgFile",
+		FileSystem:      filesys.FileSystemOrOnDisk{FileSystem: mockFS},
+	}
 	nodes, err := rfr.Read()
-	if !assert.NoError(t, err) {
-		assert.FailNow(t, err.Error())
-	}
-
-	if !assert.Len(t, nodes, 2) {
-		assert.FailNow(t, "wrong number items")
-	}
+	require.NoError(t, err)
+	require.Len(t, nodes, 2)

 	expected := []string{
 		`a: b #first
@@ -556,29 +591,46 @@ metadata:

 	for i, node := range nodes {
 		val, err := node.String()
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		want := strings.ReplaceAll(expected[i], "${SEP}", string(filepath.Separator))
-		assert.Equal(t, want, val)
+		require.Equal(t, want, val)
 	}
 }

 func TestLocalPackageReader_Read_includeSubpackage(t *testing.T) {
-	s := SetupDirectories(t, filepath.Join("a", "b"), filepath.Join("a", "c"))
-	defer s.Clean()
-	s.WriteFile(t, filepath.Join("a", "b", "a_test.yaml"), readFileA)
-	s.WriteFile(t, filepath.Join("a", "c", "c_test.yaml"), readFileB)
-	s.WriteFile(t, filepath.Join("a", "c", "pkgFile"), pkgFile)
+	t.Run("on_disk", func(t *testing.T) {
+		s := SetupDirectories(t, filepath.Join("a", "b"), filepath.Join("a", "c"))
+		defer s.Clean()
+		s.WriteFile(t, filepath.Join("a", "b", "a_test.yaml"), readFileA)
+		s.WriteFile(t, filepath.Join("a", "c", "c_test.yaml"), readFileB)
+		s.WriteFile(t, filepath.Join("a", "c", "pkgFile"), pkgFile)

-	// empty path
-	rfr := LocalPackageReader{PackagePath: s.Root, IncludeSubpackages: true, PackageFileName: "pkgFile"}
+		testLocalPackageReaderReadIncludeSubpackage(t, "./", nil)
+		testLocalPackageReaderReadIncludeSubpackage(t, s.Root, nil)
+	})
+
+	t.Run("on_mem", func(t *testing.T) {
+		fs := filesys.MakeFsInMemory()
+		require.NoError(t, fs.MkdirAll(filepath.Join("a", "b")))
+		require.NoError(t, fs.MkdirAll(filepath.Join("a", "c")))
+		require.NoError(t, fs.WriteFile(filepath.Join("a", "b", "a_test.yaml"), readFileA))
+		require.NoError(t, fs.WriteFile(filepath.Join("a", "c", "c_test.yaml"), readFileB))
+		require.NoError(t, fs.WriteFile(filepath.Join("a", "c", "pkgFile"), pkgFile))
+
+		testLocalPackageReaderReadIncludeSubpackage(t, "/", fs)
+	})
+}
+
+func testLocalPackageReaderReadIncludeSubpackage(t *testing.T, path string, mockFS filesys.FileSystem) {
+	rfr := LocalPackageReader{
+		PackagePath:        path,
+		IncludeSubpackages: true,
+		PackageFileName:    "pkgFile",
+		FileSystem:         filesys.FileSystemOrOnDisk{FileSystem: mockFS},
+	}
 	nodes, err := rfr.Read()
-	if !assert.NoError(t, err) {
-		assert.FailNow(t, err.Error())
-	}
-
-	if !assert.Len(t, nodes, 3) {
-		assert.FailNow(t, "wrong number items")
-	}
+	require.NoError(t, err)
+	require.Len(t, nodes, 3)

 	expected := []string{
 		`a: b #first
@@ -608,9 +660,9 @@ metadata:

 	for i, node := range nodes {
 		val, err := node.String()
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		want := strings.ReplaceAll(expected[i], "${SEP}", string(filepath.Separator))
-		assert.Equal(t, want, val)
+		require.Equal(t, want, val)
 	}
 }