kubernetes-sigs/kustomize
1
0
Fork 0
mirror of https://github.com/kubernetes-sigs/kustomize.git synced 2026-06-12 01:14:22 +00:00
Code Issues Packages Projects Releases 1 Wiki Activity

Simplified tests with helper func

Browse Source
This commit is contained in:
Francesc Campoy
2021-07-16 11:06:32 -07:00
parent 927568eea2
commit be4fe7540e
1 changed files with 307 additions and 472 deletions
Download Patch File Download Diff File Expand all files Collapse all files

779
kyaml/kio/pkgio_reader_test.go
View File

@@ -49,53 +49,35 @@ func TestLocalPackageReader_Read_empty(t *testing.T) {
} }
func TestLocalPackageReader_Read_pkg(t *testing.T) { func TestLocalPackageReader_Read_pkg(t *testing.T) {
t.Run("on_disk", func(t *testing.T) { testOnDiskAndOnMem(t, []mockFile{
s := SetupDirectories(t, filepath.Join("a", "b"), filepath.Join("a", "c")) {path: "a/b"},
defer s.Clean() {path: "a/c"},
s.WriteFile(t, "a_test.yaml", readFileA) {path: "a_test.yaml", content: readFileA},
s.WriteFile(t, "b_test.yaml", readFileB) {path: "b_test.yaml", content: readFileB},
s.WriteFile(t, "c_test.yaml", readFileC) {path: "c_test.yaml", content: readFileC},
s.WriteFile(t, "d_test.yaml", readFileD) {path: "d_test.yaml", content: readFileD},
}, func(t *testing.T, path string, mockFS filesys.FileSystem) {
testLocalPackageReaderReadPkg(t, "./", nil) rfr := LocalPackageReader{
testLocalPackageReaderReadPkg(t, s.Root, nil) PackagePath: path,
}) FileSystem: filesys.FileSystemOrOnDisk{FileSystem: mockFS},
}
t.Run("on_mem", func(t *testing.T) { nodes, err := rfr.Read()
fs := filesys.MakeFsInMemory() require.NoError(t, err)
require.NoError(t, fs.MkdirAll(filepath.Join("a", "b"))) require.Len(t, nodes, 5)
require.NoError(t, fs.MkdirAll(filepath.Join("a", "c"))) expected := []string{
require.NoError(t, fs.WriteFile("a_test.yaml", readFileA)) `a: b #first
require.NoError(t, fs.WriteFile("b_test.yaml", readFileB))
require.NoError(t, fs.WriteFile("c_test.yaml", readFileC))
require.NoError(t, fs.WriteFile("d_test.yaml", readFileD))
testLocalPackageReaderReadPkg(t, "/", fs)
})
}
func testLocalPackageReaderReadPkg(t *testing.T, path string, mockFS filesys.FileSystem) {
rfr := LocalPackageReader{
PackagePath: path,
FileSystem: filesys.FileSystemOrOnDisk{FileSystem: mockFS},
}
nodes, err := rfr.Read()
require.NoError(t, err)
require.Len(t, nodes, 5)
expected := []string{
`a: b #first
metadata: metadata:
annotations: annotations:
config.kubernetes.io/index: '0' config.kubernetes.io/index: '0'
config.kubernetes.io/path: 'a_test.yaml' config.kubernetes.io/path: 'a_test.yaml'
`, `,
`c: d # second `c: d # second
metadata: metadata:
annotations: annotations:
config.kubernetes.io/index: '1' config.kubernetes.io/index: '1'
config.kubernetes.io/path: 'a_test.yaml' config.kubernetes.io/path: 'a_test.yaml'
`, `,
`# second thing `# second thing
e: f e: f
g: g:
h: h:
@@ -106,75 +88,58 @@ metadata:
config.kubernetes.io/index: '0' config.kubernetes.io/index: '0'
config.kubernetes.io/path: 'b_test.yaml' config.kubernetes.io/path: 'b_test.yaml'
`, `,
`a: b #third `a: b #third
metadata: metadata:
annotations: annotations:
config.kubernetes.io/index: '0' config.kubernetes.io/index: '0'
config.kubernetes.io/path: 'c_test.yaml' config.kubernetes.io/path: 'c_test.yaml'
`, `,
`a: b #forth `a: b #forth
metadata: metadata:
annotations: annotations:
config.kubernetes.io/index: '0' config.kubernetes.io/index: '0'
config.kubernetes.io/path: 'd_test.yaml' config.kubernetes.io/path: 'd_test.yaml'
`, `,
} }
for i := range nodes { for i := range nodes {
val, err := nodes[i].String() val, err := nodes[i].String()
require.NoError(t, err) require.NoError(t, err)
require.Equal(t, expected[i], val) require.Equal(t, expected[i], val)
} }
})
} }
func TestLocalPackageReader_Read_pkgAndSkipFile(t *testing.T) { func TestLocalPackageReader_Read_pkgAndSkipFile(t *testing.T) {
t.Run("on_disk", func(t *testing.T) { testOnDiskAndOnMem(t, []mockFile{
s := SetupDirectories(t, filepath.Join("a", "b"), filepath.Join("a", "c")) {path: "a/b"},
defer s.Clean() {path: "a/c"},
s.WriteFile(t, "a_test.yaml", readFileA) {path: "a_test.yaml", content: readFileA},
s.WriteFile(t, "b_test.yaml", readFileB) {path: "b_test.yaml", content: readFileB},
s.WriteFile(t, "c_test.yaml", readFileC) {path: "c_test.yaml", content: readFileC},
s.WriteFile(t, "d_test.yaml", readFileD) {path: "d_test.yaml", content: readFileD},
}, func(t *testing.T, path string, mockFS filesys.FileSystem) {
testLocalPackageReaderReadPkgAndSkipFile(t, "./", nil) rfr := LocalPackageReader{
testLocalPackageReaderReadPkgAndSkipFile(t, s.Root, nil) PackagePath: path,
}) FileSkipFunc: func(relPath string) bool { return relPath == "d_test.yaml" },
FileSystem: filesys.FileSystemOrOnDisk{FileSystem: mockFS},
t.Run("on_mem", func(t *testing.T) { }
fs := filesys.MakeFsInMemory() nodes, err := rfr.Read()
require.NoError(t, fs.MkdirAll(filepath.Join("a", "b"))) require.NoError(t, err)
require.NoError(t, fs.MkdirAll(filepath.Join("a", "c"))) require.Len(t, nodes, 4)
require.NoError(t, fs.WriteFile("a_test.yaml", readFileA)) expected := []string{
require.NoError(t, fs.WriteFile("b_test.yaml", readFileB)) `a: b #first
require.NoError(t, fs.WriteFile("c_test.yaml", readFileC))
require.NoError(t, fs.WriteFile("d_test.yaml", readFileD))
testLocalPackageReaderReadPkgAndSkipFile(t, "/", fs)
})
}
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},
}
nodes, err := rfr.Read()
require.NoError(t, err)
require.Len(t, nodes, 4)
expected := []string{
`a: b #first
metadata: metadata:
annotations: annotations:
config.kubernetes.io/index: '0' config.kubernetes.io/index: '0'
config.kubernetes.io/path: 'a_test.yaml' config.kubernetes.io/path: 'a_test.yaml'
`, `,
`c: d # second `c: d # second
metadata: metadata:
annotations: annotations:
config.kubernetes.io/index: '1' config.kubernetes.io/index: '1'
config.kubernetes.io/path: 'a_test.yaml' config.kubernetes.io/path: 'a_test.yaml'
`, `,
`# second thing `# second thing
e: f e: f
g: g:
h: h:
@@ -185,224 +150,162 @@ metadata:
config.kubernetes.io/index: '0' config.kubernetes.io/index: '0'
config.kubernetes.io/path: 'b_test.yaml' config.kubernetes.io/path: 'b_test.yaml'
`, `,
`a: b #third `a: b #third
metadata: metadata:
annotations: annotations:
config.kubernetes.io/index: '0' config.kubernetes.io/index: '0'
config.kubernetes.io/path: 'c_test.yaml' config.kubernetes.io/path: 'c_test.yaml'
`, `,
} }
for i := range nodes { for i := range nodes {
val, err := nodes[i].String() val, err := nodes[i].String()
require.NoError(t, err) require.NoError(t, err)
require.Equal(t, expected[i], val) require.Equal(t, expected[i], val)
} }
})
} }
func TestLocalPackageReader_Read_JSON(t *testing.T) { func TestLocalPackageReader_Read_JSON(t *testing.T) {
aTestJSON := []byte(`{ testOnDiskAndOnMem(t, []mockFile{
"a": "b" {path: "a/b"},
}`) {path: "a/c"},
bTestJSON := []byte(`{ {path: "a_test.json", content: []byte(`{
"e": "f", "a": "b"
"g": { }`),
"h": ["i", "j"] },
{path: "b_test.json", content: []byte(`{
"e": "f",
"g": {
"h": ["i", "j"]
}
}`),
},
}, func(t *testing.T, path string, mockFS filesys.FileSystem) {
rfr := LocalPackageReader{
PackagePath: path,
MatchFilesGlob: []string{"*.json"},
FileSystem: filesys.FileSystemOrOnDisk{FileSystem: mockFS},
} }
}`) nodes, err := rfr.Read()
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, "a_test.json", aTestJSON)
s.WriteFile(t, "b_test.json", bTestJSON)
testLocalPackageReaderReadJSON(t, "./", nil)
testLocalPackageReaderReadJSON(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.json", aTestJSON))
require.NoError(t, fs.WriteFile("b_test.json", bTestJSON))
testLocalPackageReaderReadJSON(t, "/", fs)
})
}
func testLocalPackageReaderReadJSON(t *testing.T, path string, mockFS filesys.FileSystem) {
rfr := LocalPackageReader{
PackagePath: path,
MatchFilesGlob: []string{"*.json"},
}
rfr.FileSystem.Set(mockFS)
nodes, err := rfr.Read()
require.NoError(t, err)
require.Len(t, nodes, 2)
expected := []string{
`{"a": "b", metadata: {annotations: {config.kubernetes.io/index: '0', config.kubernetes.io/path: 'a_test.json'}}}
`,
`{"e": "f", "g": {"h": ["i", "j"]}, metadata: {annotations: {config.kubernetes.io/index: '0', config.kubernetes.io/path: 'b_test.json'}}}
`,
}
for i := range nodes {
val, err := nodes[i].String()
require.NoError(t, err) require.NoError(t, err)
require.Equal(t, expected[i], val) require.Len(t, nodes, 2)
} expected := []string{
`{"a": "b", metadata: {annotations: {config.kubernetes.io/index: '0', config.kubernetes.io/path: 'a_test.json'}}}
`,
`{"e": "f", "g": {"h": ["i", "j"]}, metadata: {annotations: {config.kubernetes.io/index: '0', config.kubernetes.io/path: 'b_test.json'}}}
`,
}
for i := range nodes {
val, err := nodes[i].String()
require.NoError(t, err)
require.Equal(t, expected[i], val)
}
})
} }
func TestLocalPackageReader_Read_file(t *testing.T) { func TestLocalPackageReader_Read_file(t *testing.T) {
t.Run("on_disk", func(t *testing.T) { testOnDiskAndOnMem(t, []mockFile{
s := SetupDirectories(t, filepath.Join("a", "b"), filepath.Join("a", "c")) {path: "a/b"},
defer s.Clean() {path: "a/c"},
s.WriteFile(t, filepath.Join("a_test.yaml"), readFileA) {path: "a_test.yaml", content: readFileA},
s.WriteFile(t, filepath.Join("b_test.yaml"), readFileB) {path: "b_test.yaml", content: readFileB},
}, func(t *testing.T, path string, mockFS filesys.FileSystem) {
testLocalPackageReaderReadFile(t, "./", nil) rfr := LocalPackageReader{
testLocalPackageReaderReadFile(t, s.Root, nil) PackagePath: filepath.Join(path, "a_test.yaml"),
}) FileSystem: filesys.FileSystemOrOnDisk{FileSystem: mockFS},
}
t.Run("on_mem", func(t *testing.T) { nodes, err := rfr.Read()
fs := filesys.MakeFsInMemory() require.NoError(t, err)
require.NoError(t, fs.MkdirAll(filepath.Join("a", "b"))) require.Len(t, nodes, 2)
require.NoError(t, fs.MkdirAll(filepath.Join("a", "c"))) expected := []string{
require.NoError(t, fs.WriteFile("a_test.yaml", readFileA)) `a: b #first
require.NoError(t, fs.WriteFile("b_test.yaml", readFileB))
testLocalPackageReaderReadFile(t, "/", fs)
})
}
func testLocalPackageReaderReadFile(t *testing.T, path string, mockFS filesys.FileSystem) {
rfr := LocalPackageReader{
PackagePath: filepath.Join(path, "a_test.yaml"),
FileSystem: filesys.FileSystemOrOnDisk{FileSystem: mockFS},
}
nodes, err := rfr.Read()
require.NoError(t, err)
require.Len(t, nodes, 2)
expected := []string{
`a: b #first
metadata: metadata:
annotations: annotations:
config.kubernetes.io/index: '0' config.kubernetes.io/index: '0'
config.kubernetes.io/path: 'a_test.yaml' config.kubernetes.io/path: 'a_test.yaml'
`, `,
`c: d # second `c: d # second
metadata: metadata:
annotations: annotations:
config.kubernetes.io/index: '1' config.kubernetes.io/index: '1'
config.kubernetes.io/path: 'a_test.yaml' config.kubernetes.io/path: 'a_test.yaml'
`, `,
} }
for i := range nodes { for i := range nodes {
val, err := nodes[i].String() val, err := nodes[i].String()
require.NoError(t, err) require.NoError(t, err)
require.Equal(t, expected[i], val) require.Equal(t, expected[i], val)
} }
})
} }
func TestLocalPackageReader_Read_pkgOmitAnnotations(t *testing.T) { func TestLocalPackageReader_Read_pkgOmitAnnotations(t *testing.T) {
t.Run("on_disk", func(t *testing.T) { testOnDiskAndOnMem(t, []mockFile{
s := SetupDirectories(t, filepath.Join("a", "b"), filepath.Join("a", "c")) {path: "a/b"},
defer s.Clean() {path: "a/c"},
s.WriteFile(t, filepath.Join("a_test.yaml"), readFileA) {path: "a_test.yaml", content: readFileA},
s.WriteFile(t, filepath.Join("b_test.yaml"), readFileB) {path: "b_test.yaml", content: readFileB},
}, func(t *testing.T, path string, mockFS filesys.FileSystem) {
testLocalPackageReaderReadPkgOmitAnnotations(t, "./", nil) rfr := LocalPackageReader{
testLocalPackageReaderReadPkgOmitAnnotations(t, s.Root, nil) PackagePath: path,
}) OmitReaderAnnotations: true,
FileSystem: filesys.FileSystemOrOnDisk{FileSystem: mockFS},
t.Run("on_mem", func(t *testing.T) { }
fs := filesys.MakeFsInMemory() nodes, err := rfr.Read()
require.NoError(t, fs.MkdirAll(filepath.Join("a", "b"))) require.NoError(t, err)
require.NoError(t, fs.MkdirAll(filepath.Join("a", "c"))) require.Len(t, nodes, 3)
require.NoError(t, fs.WriteFile("a_test.yaml", readFileA)) expected := []string{
require.NoError(t, fs.WriteFile("b_test.yaml", readFileB)) `a: b #first
testLocalPackageReaderReadPkgOmitAnnotations(t, "/", fs)
})
}
func testLocalPackageReaderReadPkgOmitAnnotations(t *testing.T, path string, mockFS filesys.FileSystem) {
rfr := LocalPackageReader{
PackagePath: path,
OmitReaderAnnotations: true,
FileSystem: filesys.FileSystemOrOnDisk{FileSystem: mockFS},
}
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 e: f
g: g:
h: h:
- i # has a list - i # has a list
- j - j
`, `,
} }
for i := range nodes { for i := range nodes {
val, err := nodes[i].String() val, err := nodes[i].String()
require.NoError(t, err) require.NoError(t, err)
require.Equal(t, expected[i], val) require.Equal(t, expected[i], val)
} }
})
} }
func TestLocalPackageReader_Read_PreserveSeqIndent(t *testing.T) { func TestLocalPackageReader_Read_PreserveSeqIndent(t *testing.T) {
t.Run("on_disk", func(t *testing.T) { testOnDiskAndOnMem(t, []mockFile{
s := SetupDirectories(t, filepath.Join("a", "b"), filepath.Join("a", "c")) {path: "a/b"},
defer s.Clean() {path: "a/c"},
s.WriteFile(t, filepath.Join("a_test.yaml"), readFileA) {path: "a_test.yaml", content: readFileA},
s.WriteFile(t, filepath.Join("b_test.yaml"), readFileB) {path: "b_test.yaml", content: readFileB},
}, func(t *testing.T, path string, mockFS filesys.FileSystem) {
testLocalPackageReaderReadPreserveSeqIndent(t, "./", nil) rfr := LocalPackageReader{
testLocalPackageReaderReadPreserveSeqIndent(t, s.Root, nil) PackagePath: path,
}) PreserveSeqIndent: true,
FileSystem: filesys.FileSystemOrOnDisk{FileSystem: mockFS},
t.Run("on_mem", func(t *testing.T) { }
fs := filesys.MakeFsInMemory() nodes, err := rfr.Read()
require.NoError(t, fs.MkdirAll(filepath.Join("a", "b"))) require.NoError(t, err)
require.NoError(t, fs.MkdirAll(filepath.Join("a", "c"))) require.Len(t, nodes, 3)
require.NoError(t, fs.WriteFile("a_test.yaml", readFileA)) expected := []string{
require.NoError(t, fs.WriteFile("b_test.yaml", readFileB)) `a: b #first
testLocalPackageReaderReadPreserveSeqIndent(t, "/", fs)
})
}
func testLocalPackageReaderReadPreserveSeqIndent(t *testing.T, path string, mockFS filesys.FileSystem) {
rfr := LocalPackageReader{
PackagePath: path,
PreserveSeqIndent: true,
FileSystem: filesys.FileSystemOrOnDisk{FileSystem: mockFS},
}
nodes, err := rfr.Read()
require.NoError(t, err)
require.Len(t, nodes, 3)
expected := []string{
`a: b #first
metadata: metadata:
annotations: annotations:
config.kubernetes.io/index: '0' config.kubernetes.io/index: '0'
config.kubernetes.io/path: 'a_test.yaml' config.kubernetes.io/path: 'a_test.yaml'
internal.config.kubernetes.io/seqindent: 'compact' internal.config.kubernetes.io/seqindent: 'compact'
`, `,
`c: d # second `c: d # second
metadata: metadata:
annotations: annotations:
config.kubernetes.io/index: '1' config.kubernetes.io/index: '1'
config.kubernetes.io/path: 'a_test.yaml' config.kubernetes.io/path: 'a_test.yaml'
internal.config.kubernetes.io/seqindent: 'compact' internal.config.kubernetes.io/seqindent: 'compact'
`, `,
`# second thing `# second thing
e: f e: f
g: g:
h: h:
@@ -414,58 +317,43 @@ metadata:
config.kubernetes.io/path: 'b_test.yaml' config.kubernetes.io/path: 'b_test.yaml'
internal.config.kubernetes.io/seqindent: 'compact' internal.config.kubernetes.io/seqindent: 'compact'
`, `,
} }
for i := range nodes { for i := range nodes {
val, err := nodes[i].String() val, err := nodes[i].String()
require.NoError(t, err) require.NoError(t, err)
require.Equal(t, expected[i], val) require.Equal(t, expected[i], val)
} }
})
} }
func TestLocalPackageReader_Read_nestedDirs(t *testing.T) { func TestLocalPackageReader_Read_nestedDirs(t *testing.T) {
t.Run("on_disk", func(t *testing.T) { testOnDiskAndOnMem(t, []mockFile{
s := SetupDirectories(t, filepath.Join("a", "b"), filepath.Join("a", "c")) {path: "a/b"},
defer s.Clean() {path: "a/c"},
s.WriteFile(t, filepath.Join("a", "b", "a_test.yaml"), readFileA) {path: "a/b/a_test.yaml", content: readFileA},
s.WriteFile(t, filepath.Join("a", "b", "b_test.yaml"), readFileB) {path: "a/b/b_test.yaml", content: readFileB},
}, func(t *testing.T, path string, mockFS filesys.FileSystem) {
testLocalPackageReaderReadNestedDirs(t, "./", nil) rfr := LocalPackageReader{
testLocalPackageReaderReadNestedDirs(t, s.Root, nil) PackagePath: path,
}) FileSystem: filesys.FileSystemOrOnDisk{FileSystem: mockFS},
}
t.Run("on_mem", func(t *testing.T) { nodes, err := rfr.Read()
fs := filesys.MakeFsInMemory() require.NoError(t, err)
require.NoError(t, fs.MkdirAll(filepath.Join("a", "b"))) require.Len(t, nodes, 3)
require.NoError(t, fs.MkdirAll(filepath.Join("a", "c"))) expected := []string{
require.NoError(t, fs.WriteFile(filepath.Join("a", "b", "a_test.yaml"), readFileA)) `a: b #first
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},
}
nodes, err := rfr.Read()
require.NoError(t, err)
require.Len(t, nodes, 3)
expected := []string{
`a: b #first
metadata: metadata:
annotations: annotations:
config.kubernetes.io/index: '0' config.kubernetes.io/index: '0'
config.kubernetes.io/path: 'a${SEP}b${SEP}a_test.yaml' config.kubernetes.io/path: 'a${SEP}b${SEP}a_test.yaml'
`, `,
`c: d # second `c: d # second
metadata: metadata:
annotations: annotations:
config.kubernetes.io/index: '1' config.kubernetes.io/index: '1'
config.kubernetes.io/path: 'a${SEP}b${SEP}a_test.yaml' config.kubernetes.io/path: 'a${SEP}b${SEP}a_test.yaml'
`, `,
`# second thing `# second thing
e: f e: f
g: g:
h: h:
@@ -476,176 +364,129 @@ metadata:
config.kubernetes.io/index: '0' config.kubernetes.io/index: '0'
config.kubernetes.io/path: 'a${SEP}b${SEP}b_test.yaml' config.kubernetes.io/path: 'a${SEP}b${SEP}b_test.yaml'
`, `,
} }
for i := range nodes { for i := range nodes {
val, err := nodes[i].String() val, err := nodes[i].String()
require.NoError(t, err) require.NoError(t, err)
want := strings.ReplaceAll(expected[i], "${SEP}", string(filepath.Separator)) want := strings.ReplaceAll(expected[i], "${SEP}", string(filepath.Separator))
require.Equal(t, want, val) require.Equal(t, want, val)
} }
})
} }
func TestLocalPackageReader_Read_matchRegex(t *testing.T) { func TestLocalPackageReader_Read_matchRegex(t *testing.T) {
t.Run("on_disk", func(t *testing.T) { testOnDiskAndOnMem(t, []mockFile{
s := SetupDirectories(t, filepath.Join("a", "b"), filepath.Join("a", "c")) {path: "a/b"},
defer s.Clean() {path: "a/c"},
s.WriteFile(t, filepath.Join("a", "b", "a_test.yaml"), readFileA) {path: "a/b/a_test.yaml", content: readFileA},
s.WriteFile(t, filepath.Join("a", "b", "b_test.yaml"), readFileB) {path: "a/b/b_test.yaml", content: readFileB},
}, func(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()
require.NoError(t, err)
require.Len(t, nodes, 2)
testLocalPackageReaderReadMatchRegex(t, "./", nil) expected := []string{
testLocalPackageReaderReadMatchRegex(t, s.Root, nil) `a: b #first
})
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()
require.NoError(t, err)
require.Len(t, nodes, 2)
expected := []string{
`a: b #first
metadata: metadata:
annotations: annotations:
config.kubernetes.io/index: '0' config.kubernetes.io/index: '0'
config.kubernetes.io/path: 'a${SEP}b${SEP}a_test.yaml' config.kubernetes.io/path: 'a${SEP}b${SEP}a_test.yaml'
`, `,
`c: d # second `c: d # second
metadata: metadata:
annotations: annotations:
config.kubernetes.io/index: '1' config.kubernetes.io/index: '1'
config.kubernetes.io/path: 'a${SEP}b${SEP}a_test.yaml' config.kubernetes.io/path: 'a${SEP}b${SEP}a_test.yaml'
`, `,
} }
for i, node := range nodes { for i, node := range nodes {
val, err := node.String() val, err := node.String()
require.NoError(t, err) require.NoError(t, err)
want := strings.ReplaceAll(expected[i], "${SEP}", string(filepath.Separator)) want := strings.ReplaceAll(expected[i], "${SEP}", string(filepath.Separator))
require.Equal(t, want, val) require.Equal(t, want, val)
} }
})
} }
func TestLocalPackageReader_Read_skipSubpackage(t *testing.T) { func TestLocalPackageReader_Read_skipSubpackage(t *testing.T) {
t.Run("on_disk", func(t *testing.T) { testOnDiskAndOnMem(t, []mockFile{
s := SetupDirectories(t, filepath.Join("a", "b"), filepath.Join("a", "c")) {path: "a/b"},
defer s.Clean() {path: "a/c"},
s.WriteFile(t, filepath.Join("a", "b", "a_test.yaml"), readFileA) {path: "a/b/a_test.yaml", content: readFileA},
s.WriteFile(t, filepath.Join("a", "c", "c_test.yaml"), readFileB) {path: "a/c/c_test.yaml", content: readFileB},
s.WriteFile(t, filepath.Join("a", "c", "pkgFile"), pkgFile) {path: "a/c/pkgFile", content: pkgFile},
}, func(t *testing.T, path string, mockFS filesys.FileSystem) {
rfr := LocalPackageReader{
PackagePath: path,
PackageFileName: "pkgFile",
FileSystem: filesys.FileSystemOrOnDisk{FileSystem: mockFS},
}
nodes, err := rfr.Read()
require.NoError(t, err)
require.Len(t, nodes, 2)
testLocalPackageReaderReadSkipSubpackage(t, "./", nil) expected := []string{
testLocalPackageReaderReadSkipSubpackage(t, s.Root, nil) `a: b #first
})
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()
require.NoError(t, err)
require.Len(t, nodes, 2)
expected := []string{
`a: b #first
metadata: metadata:
annotations: annotations:
config.kubernetes.io/index: '0' config.kubernetes.io/index: '0'
config.kubernetes.io/path: 'a${SEP}b${SEP}a_test.yaml' config.kubernetes.io/path: 'a${SEP}b${SEP}a_test.yaml'
`, `,
`c: d # second `c: d # second
metadata: metadata:
annotations: annotations:
config.kubernetes.io/index: '1' config.kubernetes.io/index: '1'
config.kubernetes.io/path: 'a${SEP}b${SEP}a_test.yaml' config.kubernetes.io/path: 'a${SEP}b${SEP}a_test.yaml'
`, `,
} }
for i, node := range nodes { for i, node := range nodes {
val, err := node.String() val, err := node.String()
require.NoError(t, err) require.NoError(t, err)
want := strings.ReplaceAll(expected[i], "${SEP}", string(filepath.Separator)) want := strings.ReplaceAll(expected[i], "${SEP}", string(filepath.Separator))
require.Equal(t, want, val) require.Equal(t, want, val)
} }
})
} }
func TestLocalPackageReader_Read_includeSubpackage(t *testing.T) { func TestLocalPackageReader_Read_includeSubpackage(t *testing.T) {
t.Run("on_disk", func(t *testing.T) { testOnDiskAndOnMem(t, []mockFile{
s := SetupDirectories(t, filepath.Join("a", "b"), filepath.Join("a", "c")) {path: "a/b"},
defer s.Clean() {path: "a/c"},
s.WriteFile(t, filepath.Join("a", "b", "a_test.yaml"), readFileA) {path: "a/b/a_test.yaml", content: readFileA},
s.WriteFile(t, filepath.Join("a", "c", "c_test.yaml"), readFileB) {path: "a/c/c_test.yaml", content: readFileB},
s.WriteFile(t, filepath.Join("a", "c", "pkgFile"), pkgFile) {path: "a/c/pkgFile", content: pkgFile},
}, func(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()
require.NoError(t, err)
require.Len(t, nodes, 3)
testLocalPackageReaderReadIncludeSubpackage(t, "./", nil) expected := []string{
testLocalPackageReaderReadIncludeSubpackage(t, s.Root, nil) `a: b #first
})
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()
require.NoError(t, err)
require.Len(t, nodes, 3)
expected := []string{
`a: b #first
metadata: metadata:
annotations: annotations:
config.kubernetes.io/index: '0' config.kubernetes.io/index: '0'
config.kubernetes.io/path: 'a${SEP}b${SEP}a_test.yaml' config.kubernetes.io/path: 'a${SEP}b${SEP}a_test.yaml'
`, `,
`c: d # second `c: d # second
metadata: metadata:
annotations: annotations:
config.kubernetes.io/index: '1' config.kubernetes.io/index: '1'
config.kubernetes.io/path: 'a${SEP}b${SEP}a_test.yaml' config.kubernetes.io/path: 'a${SEP}b${SEP}a_test.yaml'
`, `,
`# second thing `# second thing
e: f e: f
g: g:
h: h:
@@ -656,61 +497,55 @@ metadata:
config.kubernetes.io/index: '0' config.kubernetes.io/index: '0'
config.kubernetes.io/path: 'a${SEP}c${SEP}c_test.yaml' config.kubernetes.io/path: 'a${SEP}c${SEP}c_test.yaml'
`, `,
} }
for i, node := range nodes { for i, node := range nodes {
val, err := node.String() val, err := node.String()
require.NoError(t, err) require.NoError(t, err)
want := strings.ReplaceAll(expected[i], "${SEP}", string(filepath.Separator)) want := strings.ReplaceAll(expected[i], "${SEP}", string(filepath.Separator))
require.Equal(t, want, val) require.Equal(t, want, val)
} }
})
} }
// func TestLocalPackageReaderWriter_DeleteFiles(t *testing.T) { type mockFile struct {
// g, _, clean := testutil.SetupDefaultRepoAndWorkspace(t) path string
// defer clean() // nil content implies this is a directory
// if !assert.NoError(t, os.Chdir(g.RepoDirectory)) { content []byte
// return }
// }
// func testOnDiskAndOnMem(t *testing.T, files []mockFile, f func(t *testing.T, path string, fs filesys.FileSystem)) {
// rw := LocalPackageReadWriter{PackagePath: "."} t.Run("on_disk", func(t *testing.T) {
// nodes, err := rw.Read() var dirs []string
// if !assert.NoError(t, err) { for _, file := range files {
// t.FailNow() if file.content == nil {
// } dirs = append(dirs, filepath.FromSlash(file.path))
// _, err = os.Stat(filepath.Join("java", "java-deployment.resource.yaml")) }
// if !assert.NoError(t, err) { }
// t.FailNow()
// } s := SetupDirectories(t, dirs...)
// defer s.Clean()
// // delete one of the nodes for _, file := range files {
// var newNodes []*yaml.RNode if file.content != nil {
// for i := range nodes { s.WriteFile(t, filepath.FromSlash(file.path), file.content)
// meta, err := nodes[i].GetMeta() }
// if !assert.NoError(t, err) { }
// t.FailNow()
// } f(t, "./", nil)
// if meta.Name == "app" && meta.Kind == "Deployment" { f(t, s.Root, nil)
// continue })
// }
// newNodes = append(newNodes, nodes[i]) t.Run("on_mem", func(t *testing.T) {
// } fs := filesys.MakeFsInMemory()
// for _, file := range files {
// if !assert.NoError(t, rw.Write(newNodes)) { path := filepath.FromSlash(file.path)
// t.FailNow() if file.content == nil {
// } require.NoError(t, fs.MkdirAll(path))
// } else {
// _, err = os.Stat(filepath.Join("java", "java-deployment.resource.yaml")) require.NoError(t, fs.WriteFile(path, file.content))
// if !assert.Error(t, err) { }
// t.FailNow() }
// }
// f(t, "/", fs)
// diff, err := copyutil.Diff(filepath.Join(g.DatasetDirectory, testutil.Dataset1), ".") })
// if !assert.NoError(t, err) { }
// t.FailNow()
// }
//
// assert.ElementsMatch(t,
// diff.List(),
// []string{filepath.Join("java", "java-deployment.resource.yaml")})
// }