mirror of
https://github.com/kyverno/kyverno.git
synced 2025-03-06 16:06:56 +00:00
274 lines
7.4 KiB
Go
274 lines
7.4 KiB
Go
package fs
|
|
|
|
import (
|
|
"fmt"
|
|
"path/filepath"
|
|
"runtime"
|
|
"testing"
|
|
|
|
"gotest.tools/assert"
|
|
is "gotest.tools/assert/cmp"
|
|
"gotest.tools/skip"
|
|
)
|
|
|
|
func TestEqualMissingRoot(t *testing.T) {
|
|
result := Equal("/bogus/path/does/not/exist", Expected(t))()
|
|
assert.Assert(t, !result.Success())
|
|
expected := "stat /bogus/path/does/not/exist: no such file or directory"
|
|
if runtime.GOOS == "windows" {
|
|
expected = "CreateFile /bogus/path/does/not/exist"
|
|
}
|
|
assert.Assert(t, is.Contains(result.(cmpFailure).FailureMessage(), expected))
|
|
}
|
|
|
|
func TestEqualModeMismatch(t *testing.T) {
|
|
dir := NewDir(t, t.Name(), WithMode(0500))
|
|
defer dir.Remove()
|
|
|
|
result := Equal(dir.Path(), Expected(t))()
|
|
assert.Assert(t, !result.Success())
|
|
expected := fmtExpected(`directory %s does not match expected:
|
|
/
|
|
mode: expected drwx------ got dr-x------
|
|
`, dir.Path())
|
|
if runtime.GOOS == "windows" {
|
|
expected = fmtExpected(`directory %s does not match expected:
|
|
\
|
|
mode: expected drwxrwxrwx got dr-xr-xr-x
|
|
`, dir.Path())
|
|
}
|
|
assert.Equal(t, result.(cmpFailure).FailureMessage(), expected)
|
|
}
|
|
|
|
func TestEqualRootIsAFile(t *testing.T) {
|
|
file := NewFile(t, t.Name())
|
|
defer file.Remove()
|
|
|
|
result := Equal(file.Path(), Expected(t))()
|
|
assert.Assert(t, !result.Success())
|
|
expected := fmt.Sprintf("path %s must be a directory", file.Path())
|
|
assert.Equal(t, result.(cmpFailure).FailureMessage(), expected)
|
|
}
|
|
|
|
func TestEqualSuccess(t *testing.T) {
|
|
dir := NewDir(t, t.Name(), WithMode(0700))
|
|
defer dir.Remove()
|
|
|
|
assert.Assert(t, Equal(dir.Path(), Expected(t)))
|
|
}
|
|
|
|
func TestEqualDirectoryHasWithExtraFiles(t *testing.T) {
|
|
dir := NewDir(t, t.Name(),
|
|
WithFile("extra1", "content"))
|
|
defer dir.Remove()
|
|
|
|
manifest := Expected(t, WithFile("file1", "content"))
|
|
result := Equal(dir.Path(), manifest)()
|
|
assert.Assert(t, !result.Success())
|
|
expected := fmtExpected(`directory %s does not match expected:
|
|
/
|
|
file1: expected file to exist
|
|
extra1: unexpected file
|
|
`, dir.Path())
|
|
assert.Equal(t, result.(cmpFailure).FailureMessage(), expected)
|
|
}
|
|
|
|
func fmtExpected(format string, args ...interface{}) string {
|
|
return filepath.FromSlash(fmt.Sprintf(format, args...))
|
|
}
|
|
|
|
func TestEqualWithMatchAnyFileContent(t *testing.T) {
|
|
dir := NewDir(t, t.Name(),
|
|
WithFile("data", "this is some data"))
|
|
defer dir.Remove()
|
|
|
|
expected := Expected(t,
|
|
WithFile("data", "different content", MatchAnyFileContent))
|
|
assert.Assert(t, Equal(dir.Path(), expected))
|
|
}
|
|
|
|
func TestEqualWithFileContent(t *testing.T) {
|
|
dir := NewDir(t, "assert-test-root",
|
|
WithFile("file1", "line1\nline2\nline3"))
|
|
defer dir.Remove()
|
|
|
|
manifest := Expected(t,
|
|
WithFile("file1", "line2\nline3"))
|
|
|
|
result := Equal(dir.Path(), manifest)()
|
|
expected := fmtExpected(`directory %s does not match expected:
|
|
/file1
|
|
content:
|
|
--- expected
|
|
+++ actual
|
|
@@ -1,2 +1,3 @@
|
|
+line1
|
|
line2
|
|
line3
|
|
`, dir.Path())
|
|
assert.Equal(t, result.(cmpFailure).FailureMessage(), expected)
|
|
}
|
|
|
|
func TestEqualWithMatchContentIgnoreCarriageReturn(t *testing.T) {
|
|
dir := NewDir(t, t.Name(),
|
|
WithFile("file1", "line1\r\nline2"))
|
|
defer dir.Remove()
|
|
|
|
manifest := Expected(t,
|
|
WithFile("file1", "line1\nline2", MatchContentIgnoreCarriageReturn))
|
|
|
|
result := Equal(dir.Path(), manifest)()
|
|
assert.Assert(t, result.Success())
|
|
}
|
|
|
|
func TestEqualDirectoryWithMatchExtraFiles(t *testing.T) {
|
|
file1 := WithFile("file1", "same in both")
|
|
dir := NewDir(t, t.Name(),
|
|
file1,
|
|
WithFile("extra", "some content"))
|
|
defer dir.Remove()
|
|
|
|
expected := Expected(t, file1, MatchExtraFiles)
|
|
assert.Assert(t, Equal(dir.Path(), expected))
|
|
}
|
|
|
|
func TestEqualManyFailures(t *testing.T) {
|
|
dir := NewDir(t, t.Name(),
|
|
WithFile("file1", "same in both"),
|
|
WithFile("extra", "some content"),
|
|
WithSymlink("sym1", "extra"))
|
|
defer dir.Remove()
|
|
|
|
manifest := Expected(t,
|
|
WithDir("subdir",
|
|
WithFile("somefile", "")),
|
|
WithFile("file1", "not the\nsame in both"))
|
|
|
|
result := Equal(dir.Path(), manifest)()
|
|
assert.Assert(t, !result.Success())
|
|
|
|
expected := fmtExpected(`directory %s does not match expected:
|
|
/
|
|
subdir: expected directory to exist
|
|
extra: unexpected file
|
|
sym1: unexpected symlink
|
|
/file1
|
|
content:
|
|
--- expected
|
|
+++ actual
|
|
@@ -1,2 +1 @@
|
|
-not the
|
|
same in both
|
|
`, dir.Path())
|
|
assert.Equal(t, result.(cmpFailure).FailureMessage(), expected)
|
|
}
|
|
|
|
type cmpFailure interface {
|
|
FailureMessage() string
|
|
}
|
|
|
|
func TestMatchAnyFileMode(t *testing.T) {
|
|
dir := NewDir(t, t.Name(),
|
|
WithFile("data", "content",
|
|
WithMode(0777)))
|
|
defer dir.Remove()
|
|
|
|
expected := Expected(t,
|
|
WithFile("data", "content", MatchAnyFileMode))
|
|
assert.Assert(t, Equal(dir.Path(), expected))
|
|
}
|
|
|
|
func TestMatchFileContent(t *testing.T) {
|
|
dir := NewDir(t, t.Name(),
|
|
WithFile("data", "content"))
|
|
defer dir.Remove()
|
|
|
|
t.Run("content matches", func(t *testing.T) {
|
|
matcher := func(b []byte) CompareResult {
|
|
return is.ResultSuccess
|
|
}
|
|
manifest := Expected(t,
|
|
WithFile("data", "different", MatchFileContent(matcher)))
|
|
assert.Assert(t, Equal(dir.Path(), manifest))
|
|
})
|
|
|
|
t.Run("content does not match", func(t *testing.T) {
|
|
matcher := func(b []byte) CompareResult {
|
|
return is.ResultFailure("data content differs from expected")
|
|
}
|
|
manifest := Expected(t,
|
|
WithFile("data", "content", MatchFileContent(matcher)))
|
|
result := Equal(dir.Path(), manifest)()
|
|
assert.Assert(t, !result.Success())
|
|
|
|
expected := fmtExpected(`directory %s does not match expected:
|
|
/data
|
|
content: data content differs from expected
|
|
`, dir.Path())
|
|
assert.Equal(t, result.(cmpFailure).FailureMessage(), expected)
|
|
})
|
|
}
|
|
|
|
func TestMatchExtraFilesGlob(t *testing.T) {
|
|
dir := NewDir(t, t.Name(),
|
|
WithFile("t.go", "data"),
|
|
WithFile("a.go", "data"),
|
|
WithFile("conf.yml", "content", WithMode(0600)))
|
|
defer dir.Remove()
|
|
|
|
t.Run("matching globs", func(t *testing.T) {
|
|
manifest := Expected(t,
|
|
MatchFilesWithGlob("*.go", MatchAnyFileMode, MatchAnyFileContent),
|
|
MatchFilesWithGlob("*.yml", MatchAnyFileMode, MatchAnyFileContent))
|
|
assert.Assert(t, Equal(dir.Path(), manifest))
|
|
})
|
|
|
|
t.Run("matching globs with wrong mode", func(t *testing.T) {
|
|
skip.If(t, runtime.GOOS == "windows", "expect mode does not match on windows")
|
|
manifest := Expected(t,
|
|
MatchFilesWithGlob("*.go", MatchAnyFileMode, MatchAnyFileContent),
|
|
MatchFilesWithGlob("*.yml", MatchAnyFileContent, WithMode(0700)))
|
|
|
|
result := Equal(dir.Path(), manifest)()
|
|
|
|
assert.Assert(t, !result.Success())
|
|
expected := fmtExpected(`directory %s does not match expected:
|
|
conf.yml
|
|
mode: expected -rwx------ got -rw-------
|
|
`, dir.Path())
|
|
assert.Equal(t, result.(cmpFailure).FailureMessage(), expected)
|
|
})
|
|
|
|
t.Run("matching partial glob", func(t *testing.T) {
|
|
manifest := Expected(t, MatchFilesWithGlob("*.go", MatchAnyFileMode, MatchAnyFileContent))
|
|
result := Equal(dir.Path(), manifest)()
|
|
assert.Assert(t, !result.Success())
|
|
|
|
expected := fmtExpected(`directory %s does not match expected:
|
|
/
|
|
conf.yml: unexpected file
|
|
`, dir.Path())
|
|
assert.Equal(t, result.(cmpFailure).FailureMessage(), expected)
|
|
})
|
|
|
|
t.Run("invalid glob", func(t *testing.T) {
|
|
manifest := Expected(t, MatchFilesWithGlob("[-x]"))
|
|
result := Equal(dir.Path(), manifest)()
|
|
assert.Assert(t, !result.Success())
|
|
|
|
expected := fmtExpected(`directory %s does not match expected:
|
|
/
|
|
a.go: unexpected file
|
|
conf.yml: unexpected file
|
|
t.go: unexpected file
|
|
a.go
|
|
failed to match glob pattern: syntax error in pattern
|
|
conf.yml
|
|
failed to match glob pattern: syntax error in pattern
|
|
t.go
|
|
failed to match glob pattern: syntax error in pattern
|
|
`, dir.Path())
|
|
assert.Equal(t, result.(cmpFailure).FailureMessage(), expected)
|
|
})
|
|
|
|
}
|