From 436d5e717c4e0e14635d164045827f9dfb9eaa19 Mon Sep 17 00:00:00 2001 From: Francesc Campoy Date: Fri, 16 Jul 2021 09:12:42 -0700 Subject: [PATCH] All LocalPackageReader tests adapted, one fails --- kyaml/kio/pkgio_reader.go | 4 +- kyaml/kio/pkgio_reader_test.go | 392 +++++++++++++++++++-------------- 2 files changed, 224 insertions(+), 172 deletions(-) diff --git a/kyaml/kio/pkgio_reader.go b/kyaml/kio/pkgio_reader.go index 62ce756d3..2cb36a50c 100644 --- 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 { diff --git a/kyaml/kio/pkgio_reader_test.go b/kyaml/kio/pkgio_reader_test.go index 33ad5f971..06d37275b 100644 --- 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) } }