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 4 (#32408)

Browse Source 
refactor: convert tests to testify assert/require in internal/chart/v3/util

Signed-off-by: Matthieu MOREL <matthieu.morel35@gmail.com>
pull/32411/head
Matthieu MOREL 2 months ago committed by GitHub
parent 06978bd8c5
commit 6c45810119
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
5 changed files with 121 additions and 279 deletions
Show Stats Download Patch File Download Diff File

281
internal/chart/v3/loader/load_test.go
Unescape View File

@ -41,13 +41,9 @@ import (
func TestLoadDir(t *testing.T) { func TestLoadDir(t *testing.T) {
l, err := Loader("testdata/frobnitz") l, err := Loader("testdata/frobnitz")
if err != nil { require.NoError(t, err, "Failed to load testdata")
t.Fatalf("Failed to load testdata: %s", err)
}
c, err := l.Load() c, err := l.Load()
if err != nil { require.NoError(t, err, "Failed to load testdata")
t.Fatalf("Failed to load testdata: %s", err)
}
verifyFrobnitz(t, c) verifyFrobnitz(t, c)
verifyChart(t, c) verifyChart(t, c)
verifyDependencies(t, c) verifyDependencies(t, c)
@ -60,33 +56,24 @@ func TestLoadDirWithDevNull(t *testing.T) {
} }
l, err := Loader("testdata/frobnitz_with_dev_null") l, err := Loader("testdata/frobnitz_with_dev_null")
if err != nil { require.NoError(t, err, "Failed to load testdata")
t.Fatalf("Failed to load testdata: %s", err) _, err = l.Load()
} assert.Error(t, err, "packages with an irregular file (/dev/null) should not load")
if _, err := l.Load(); err == nil {
t.Error("packages with an irregular file (/dev/null) should not load")
}
} }
func TestLoadDirWithSymlink(t *testing.T) { func TestLoadDirWithSymlink(t *testing.T) {
sym := filepath.Join("..", "LICENSE") sym := filepath.Join("..", "LICENSE")
link := filepath.Join("testdata", "frobnitz_with_symlink", "LICENSE") link := filepath.Join("testdata", "frobnitz_with_symlink", "LICENSE")
if err := os.Symlink(sym, link); err != nil { require.NoError(t, os.Symlink(sym, link))
t.Fatal(err)
}
defer os.Remove(link) defer os.Remove(link)
l, err := Loader("testdata/frobnitz_with_symlink") l, err := Loader("testdata/frobnitz_with_symlink")
if err != nil { require.NoError(t, err, "Failed to load testdata")
t.Fatalf("Failed to load testdata: %s", err)
}
c, err := l.Load() c, err := l.Load()
if err != nil { require.NoError(t, err, "Failed to load testdata")
t.Fatalf("Failed to load testdata: %s", err)
}
verifyFrobnitz(t, c) verifyFrobnitz(t, c)
verifyChart(t, c) verifyChart(t, c)
verifyDependencies(t, c) verifyDependencies(t, c)
@ -109,8 +96,7 @@ func TestBomTestData(t *testing.T) {
defer unzipped.Close() defer unzipped.Close()
for _, testFile := range testFiles { for _, testFile := range testFiles {
data := make([]byte, 3) data := make([]byte, 3)
err := unzipped.Reset(bytes.NewReader(archive)) require.NoErrorf(t, unzipped.Reset(bytes.NewReader(archive)), "Error reading archive frobnitz_with_bom.tgz")
require.NoErrorf(t, err, "Error reading archive frobnitz_with_bom.tgz")
tr := tar.NewReader(unzipped) tr := tar.NewReader(unzipped)
for { for {
file, err := tr.Next() file, err := tr.Next()
@ -132,13 +118,9 @@ func TestBomTestData(t *testing.T) {
func TestLoadDirWithUTFBOM(t *testing.T) { func TestLoadDirWithUTFBOM(t *testing.T) {
l, err := Loader("testdata/frobnitz_with_bom") l, err := Loader("testdata/frobnitz_with_bom")
if err != nil { require.NoError(t, err, "Failed to load testdata")
t.Fatalf("Failed to load testdata: %s", err)
}
c, err := l.Load() c, err := l.Load()
if err != nil { require.NoError(t, err, "Failed to load testdata")
t.Fatalf("Failed to load testdata: %s", err)
}
verifyFrobnitz(t, c) verifyFrobnitz(t, c)
verifyChart(t, c) verifyChart(t, c)
verifyDependencies(t, c) verifyDependencies(t, c)
@ -148,13 +130,9 @@ func TestLoadDirWithUTFBOM(t *testing.T) {
func TestLoadArchiveWithUTFBOM(t *testing.T) { func TestLoadArchiveWithUTFBOM(t *testing.T) {
l, err := Loader("testdata/frobnitz_with_bom.tgz") l, err := Loader("testdata/frobnitz_with_bom.tgz")
if err != nil { require.NoError(t, err, "Failed to load testdata")
t.Fatalf("Failed to load testdata: %s", err)
}
c, err := l.Load() c, err := l.Load()
if err != nil { require.NoError(t, err, "Failed to load testdata")
t.Fatalf("Failed to load testdata: %s", err)
}
verifyFrobnitz(t, c) verifyFrobnitz(t, c)
verifyChart(t, c) verifyChart(t, c)
verifyDependencies(t, c) verifyDependencies(t, c)
@ -164,13 +142,9 @@ func TestLoadArchiveWithUTFBOM(t *testing.T) {
func TestLoadFile(t *testing.T) { func TestLoadFile(t *testing.T) {
l, err := Loader("testdata/frobnitz-1.2.3.tgz") l, err := Loader("testdata/frobnitz-1.2.3.tgz")
if err != nil { require.NoError(t, err, "Failed to load testdata")
t.Fatalf("Failed to load testdata: %s", err)
}
c, err := l.Load() c, err := l.Load()
if err != nil { require.NoError(t, err, "Failed to load testdata")
t.Fatalf("Failed to load testdata: %s", err)
}
verifyFrobnitz(t, c) verifyFrobnitz(t, c)
verifyChart(t, c) verifyChart(t, c)
verifyDependencies(t, c) verifyDependencies(t, c)
@ -224,36 +198,18 @@ icon: https://example.com/64x64.png
} }
c, err := LoadFiles(goodFiles) c, err := LoadFiles(goodFiles)
if err != nil { require.NoError(t, err, "Expected good files to be loaded")
t.Errorf("Expected good files to be loaded, got %v", err) assert.Equal(t, "frobnitz", c.Name(), "Expected chart name to be 'frobnitz', got %s", c.Name())
} assert.Equal(t, "some values", c.Values["var"], "Expected chart values to be populated with default values")
assert.Len(t, c.Raw, 5, "Expected %d files, got %d", 5, len(c.Raw))
if c.Name() != "frobnitz" {
t.Errorf("Expected chart name to be 'frobnitz', got %s", c.Name())
}
if c.Values["var"] != "some values" {
t.Error("Expected chart values to be populated with default values")
}
if len(c.Raw) != 5 { assert.True(t, bytes.Equal(c.Schema, []byte("type: Values")), "Expected chart schema to be populated with default values")
t.Errorf("Expected %d files, got %d", 5, len(c.Raw))
}
if !bytes.Equal(c.Schema, []byte("type: Values")) { assert.Len(t, c.Templates, 2, "Expected number of templates == 2, got %d", len(c.Templates))
t.Error("Expected chart schema to be populated with default values")
}
if len(c.Templates) != 2 { _, err = LoadFiles([]*archive.BufferedFile{})
t.Errorf("Expected number of templates == 2, got %d", len(c.Templates)) require.Error(t, err, "Expected err to be non-nil")
} assert.EqualError(t, err, "Chart.yaml file is missing", "Expected chart metadata missing error, got '%s'", err.Error())
if _, err = LoadFiles([]*archive.BufferedFile{}); err == nil {
t.Fatal("Expected err to be non-nil")
}
if err.Error() != "Chart.yaml file is missing" {
t.Errorf("Expected chart metadata missing error, got '%s'", err.Error())
}
} }
// Test the order of file loading. The Chart.yaml file needs to come first for // Test the order of file loading. The Chart.yaml file needs to come first for
@ -309,9 +265,7 @@ icon: https://example.com/64x64.png
// Capture stderr to make sure message about Chart.yaml handle dependencies // Capture stderr to make sure message about Chart.yaml handle dependencies
// is not present // is not present
r, w, err := os.Pipe() r, w, err := os.Pipe()
if err != nil { require.NoError(t, err, "Unable to create pipe")
t.Fatalf("Unable to create pipe: %s", err)
}
stderr := log.Writer() stderr := log.Writer()
log.SetOutput(w) log.SetOutput(w)
defer func() { defer func() {
@ -319,25 +273,19 @@ icon: https://example.com/64x64.png
}() }()
_, err = LoadFiles(goodFiles) _, err = LoadFiles(goodFiles)
if err != nil { require.NoError(t, err, "Expected good files to be loaded")
t.Errorf("Expected good files to be loaded, got %v", err)
}
w.Close() w.Close()
var text bytes.Buffer var text bytes.Buffer
io.Copy(&text, r) io.Copy(&text, r)
if text.String() != "" { assert.Empty(t, text.String(), "Expected no message to Stderr, got %s", text.String())
t.Errorf("Expected no message to Stderr, got %s", text.String())
}
} }
// Packaging the chart on a Windows machine will produce an // Packaging the chart on a Windows machine will produce an
// archive that has \\ as delimiters. Test that we support these archives // archive that has \\ as delimiters. Test that we support these archives
func TestLoadFileBackslash(t *testing.T) { func TestLoadFileBackslash(t *testing.T) {
c, err := Load("testdata/frobnitz_backslash-1.2.3.tgz") c, err := Load("testdata/frobnitz_backslash-1.2.3.tgz")
if err != nil { require.NoError(t, err, "Failed to load testdata")
t.Fatalf("Failed to load testdata: %s", err)
}
verifyChartFileAndTemplate(t, c, "frobnitz_backslash") verifyChartFileAndTemplate(t, c, "frobnitz_backslash")
verifyChart(t, c) verifyChart(t, c)
verifyDependencies(t, c) verifyDependencies(t, c)
@ -345,13 +293,9 @@ func TestLoadFileBackslash(t *testing.T) {
func TestLoadV3WithReqs(t *testing.T) { func TestLoadV3WithReqs(t *testing.T) {
l, err := Loader("testdata/frobnitz.v3.reqs") l, err := Loader("testdata/frobnitz.v3.reqs")
if err != nil { require.NoError(t, err, "Failed to load testdata")
t.Fatalf("Failed to load testdata: %s", err)
}
c, err := l.Load() c, err := l.Load()
if err != nil { require.NoError(t, err, "Failed to load testdata")
t.Fatalf("Failed to load testdata: %s", err)
}
verifyDependencies(t, c) verifyDependencies(t, c)
verifyDependenciesLock(t, c) verifyDependenciesLock(t, c)
} }
@ -361,9 +305,7 @@ func TestLoadInvalidArchive(t *testing.T) {
writeTar := func(filename, internalPath string, body []byte) { writeTar := func(filename, internalPath string, body []byte) {
dest, err := os.Create(filename) dest, err := os.Create(filename)
if err != nil { require.NoError(t, err)
t.Fatal(err)
}
zipper := gzip.NewWriter(dest) zipper := gzip.NewWriter(dest)
tw := tar.NewWriter(zipper) tw := tar.NewWriter(zipper)
@ -373,12 +315,9 @@ func TestLoadInvalidArchive(t *testing.T) {
Size: int64(len(body)), Size: int64(len(body)),
ModTime: time.Now(), ModTime: time.Now(),
} }
if err := tw.WriteHeader(h); err != nil { require.NoError(t, tw.WriteHeader(h))
t.Fatal(err) _, err = tw.Write(body)
} require.NoError(t, err)
if _, err := tw.Write(body); err != nil {
t.Fatal(err)
}
tw.Close() tw.Close()
zipper.Close() zipper.Close()
dest.Close() dest.Close()
@ -410,37 +349,27 @@ func TestLoadInvalidArchive(t *testing.T) {
illegalChart := filepath.Join(tmpdir, tt.chartname) illegalChart := filepath.Join(tmpdir, tt.chartname)
writeTar(illegalChart, tt.internal, []byte("hello: world")) writeTar(illegalChart, tt.internal, []byte("hello: world"))
_, err := Load(illegalChart) _, err := Load(illegalChart)
if err == nil { require.Error(t, err, "expected error when unpacking illegal files")
t.Fatal("expected error when unpacking illegal files") require.ErrorContains(t, err, tt.expectError, "Expected error to contain %q, got %q for %s", tt.expectError, err.Error(), tt.chartname)
}
if !strings.Contains(err.Error(), tt.expectError) {
t.Errorf("Expected error to contain %q, got %q for %s", tt.expectError, err.Error(), tt.chartname)
}
} }
// Make sure that absolute path gets interpreted as relative // Make sure that absolute path gets interpreted as relative
illegalChart := filepath.Join(tmpdir, "abs-path.tgz") illegalChart := filepath.Join(tmpdir, "abs-path.tgz")
writeTar(illegalChart, "/Chart.yaml", []byte("hello: world")) writeTar(illegalChart, "/Chart.yaml", []byte("hello: world"))
_, err := Load(illegalChart) _, err := Load(illegalChart)
if err.Error() != "validation: chart.metadata.name is required" { require.EqualError(t, err, "validation: chart.metadata.name is required")
t.Error(err)
}
// And just to validate that the above was not spurious // And just to validate that the above was not spurious
illegalChart = filepath.Join(tmpdir, "abs-path2.tgz") illegalChart = filepath.Join(tmpdir, "abs-path2.tgz")
writeTar(illegalChart, "files/whatever.yaml", []byte("hello: world")) writeTar(illegalChart, "files/whatever.yaml", []byte("hello: world"))
_, err = Load(illegalChart) _, err = Load(illegalChart)
if err.Error() != "Chart.yaml file is missing" { require.EqualError(t, err, "Chart.yaml file is missing")
t.Errorf("Unexpected error message: %s", err)
}
// Finally, test that drive letter gets stripped off on Windows // Finally, test that drive letter gets stripped off on Windows
illegalChart = filepath.Join(tmpdir, "abs-winpath.tgz") illegalChart = filepath.Join(tmpdir, "abs-winpath.tgz")
writeTar(illegalChart, "c:\\Chart.yaml", []byte("hello: world")) writeTar(illegalChart, "c:\\Chart.yaml", []byte("hello: world"))
_, err = Load(illegalChart) _, err = Load(illegalChart)
if err.Error() != "validation: chart.metadata.name is required" { assert.EqualError(t, err, "validation: chart.metadata.name is required")
t.Error(err)
}
} }
func TestLoadValues(t *testing.T) { func TestLoadValues(t *testing.T) {
@ -487,12 +416,8 @@ foo:
for testName, testCase := range testCases { for testName, testCase := range testCases {
t.Run(testName, func(tt *testing.T) { t.Run(testName, func(tt *testing.T) {
values, err := LoadValues(bytes.NewReader(testCase.data)) values, err := LoadValues(bytes.NewReader(testCase.data))
if err != nil { require.NoError(tt, err)
tt.Fatal(err) assert.Truef(tt, reflect.DeepEqual(values, testCase.expctedValues), "Expected values: %v, got %v", testCase.expctedValues, values)
}
if !reflect.DeepEqual(values, testCase.expctedValues) {
tt.Errorf("Expected values: %v, got %v", testCase.expctedValues, values)
}
}) })
} }
} }
@ -521,21 +446,15 @@ func TestMergeValuesV3(t *testing.T) {
testMap := MergeMaps(flatMap, nestedMap) testMap := MergeMaps(flatMap, nestedMap)
equal := reflect.DeepEqual(testMap, nestedMap) equal := reflect.DeepEqual(testMap, nestedMap)
if !equal { assert.True(t, equal, "Expected a nested map to overwrite a flat value. Expected: %v, got %v", nestedMap, testMap)
t.Errorf("Expected a nested map to overwrite a flat value. Expected: %v, got %v", nestedMap, testMap)
}
testMap = MergeMaps(nestedMap, flatMap) testMap = MergeMaps(nestedMap, flatMap)
equal = reflect.DeepEqual(testMap, flatMap) equal = reflect.DeepEqual(testMap, flatMap)
if !equal { assert.True(t, equal, "Expected a flat value to overwrite a map. Expected: %v, got %v", flatMap, testMap)
t.Errorf("Expected a flat value to overwrite a map. Expected: %v, got %v", flatMap, testMap)
}
testMap = MergeMaps(nestedMap, anotherNestedMap) testMap = MergeMaps(nestedMap, anotherNestedMap)
equal = reflect.DeepEqual(testMap, anotherNestedMap) equal = reflect.DeepEqual(testMap, anotherNestedMap)
if !equal { assert.True(t, equal, "Expected a nested map to overwrite another nested map. Expected: %v, got %v", anotherNestedMap, testMap)
t.Errorf("Expected a nested map to overwrite another nested map. Expected: %v, got %v", anotherNestedMap, testMap)
}
testMap = MergeMaps(anotherFlatMap, anotherNestedMap) testMap = MergeMaps(anotherFlatMap, anotherNestedMap)
expectedMap := map[string]any{ expectedMap := map[string]any{
@ -547,20 +466,14 @@ func TestMergeValuesV3(t *testing.T) {
}, },
} }
equal = reflect.DeepEqual(testMap, expectedMap) equal = reflect.DeepEqual(testMap, expectedMap)
if !equal { assert.True(t, equal, "Expected a map with different keys to merge properly with another map. Expected: %v, got %v", expectedMap, testMap)
t.Errorf("Expected a map with different keys to merge properly with another map. Expected: %v, got %v", expectedMap, testMap)
}
} }
func verifyChart(t *testing.T, c *chart.Chart) { func verifyChart(t *testing.T, c *chart.Chart) {
t.Helper() t.Helper()
if c.Name() == "" { require.NotEmpty(t, c.Name(), "No chart metadata found on %v", c)
t.Fatalf("No chart metadata found on %v", c)
}
t.Logf("Verifying chart %s", c.Name()) t.Logf("Verifying chart %s", c.Name())
if len(c.Templates) != 1 { assert.Len(t, c.Templates, 1, "Expected 1 template, got %d", len(c.Templates))
t.Errorf("Expected 1 template, got %d", len(c.Templates))
}
numfiles := 6 numfiles := 6
if len(c.Files) != numfiles { if len(c.Files) != numfiles {
@ -587,62 +500,40 @@ func verifyChart(t *testing.T, c *chart.Chart) {
} }
for _, dep := range c.Dependencies() { for _, dep := range c.Dependencies() {
if dep.Metadata == nil { require.NotNil(t, dep.Metadata, "expected metadata on dependency: %v", dep)
t.Fatalf("expected metadata on dependency: %v", dep)
}
exp, ok := expect[dep.Name()] exp, ok := expect[dep.Name()]
if !ok { require.True(t, ok, "Unknown dependency %s", dep.Name())
t.Fatalf("Unknown dependency %s", dep.Name()) assert.Equal(t, exp["version"], dep.Metadata.Version, "Expected %s version %s, got %s", dep.Name(), exp["version"], dep.Metadata.Version)
}
if exp["version"] != dep.Metadata.Version {
t.Errorf("Expected %s version %s, got %s", dep.Name(), exp["version"], dep.Metadata.Version)
}
} }
} }
func verifyDependencies(t *testing.T, c *chart.Chart) { func verifyDependencies(t *testing.T, c *chart.Chart) {
t.Helper() t.Helper()
if len(c.Metadata.Dependencies) != 2 { assert.Len(t, c.Metadata.Dependencies, 2, "Expected 2 dependencies, got %d", len(c.Metadata.Dependencies))
t.Errorf("Expected 2 dependencies, got %d", len(c.Metadata.Dependencies))
}
tests := []*chart.Dependency{ tests := []*chart.Dependency{
{Name: "alpine", Version: "0.1.0", Repository: "https://example.com/charts"}, {Name: "alpine", Version: "0.1.0", Repository: "https://example.com/charts"},
{Name: "mariner", Version: "4.3.2", Repository: "https://example.com/charts"}, {Name: "mariner", Version: "4.3.2", Repository: "https://example.com/charts"},
} }
for i, tt := range tests { for i, tt := range tests {
d := c.Metadata.Dependencies[i] d := c.Metadata.Dependencies[i]
if d.Name != tt.Name { assert.Equal(t, tt.Name, d.Name, "Expected dependency named %q, got %q", tt.Name, d.Name)
t.Errorf("Expected dependency named %q, got %q", tt.Name, d.Name) assert.Equal(t, tt.Version, d.Version, "Expected dependency named %q to have version %q, got %q", tt.Name, tt.Version, d.Version)
} assert.Equal(t, tt.Repository, d.Repository, "Expected dependency named %q to have repository %q, got %q", tt.Name, tt.Repository, d.Repository)
if d.Version != tt.Version {
t.Errorf("Expected dependency named %q to have version %q, got %q", tt.Name, tt.Version, d.Version)
}
if d.Repository != tt.Repository {
t.Errorf("Expected dependency named %q to have repository %q, got %q", tt.Name, tt.Repository, d.Repository)
}
} }
} }
func verifyDependenciesLock(t *testing.T, c *chart.Chart) { func verifyDependenciesLock(t *testing.T, c *chart.Chart) {
t.Helper() t.Helper()
if len(c.Metadata.Dependencies) != 2 { assert.Len(t, c.Metadata.Dependencies, 2, "Expected 2 dependencies, got %d", len(c.Metadata.Dependencies))
t.Errorf("Expected 2 dependencies, got %d", len(c.Metadata.Dependencies))
}
tests := []*chart.Dependency{ tests := []*chart.Dependency{
{Name: "alpine", Version: "0.1.0", Repository: "https://example.com/charts"}, {Name: "alpine", Version: "0.1.0", Repository: "https://example.com/charts"},
{Name: "mariner", Version: "4.3.2", Repository: "https://example.com/charts"}, {Name: "mariner", Version: "4.3.2", Repository: "https://example.com/charts"},
} }
for i, tt := range tests { for i, tt := range tests {
d := c.Metadata.Dependencies[i] d := c.Metadata.Dependencies[i]
if d.Name != tt.Name { assert.Equal(t, tt.Name, d.Name, "Expected dependency named %q, got %q", tt.Name, d.Name)
t.Errorf("Expected dependency named %q, got %q", tt.Name, d.Name) assert.Equal(t, tt.Version, d.Version, "Expected dependency named %q to have version %q, got %q", tt.Name, tt.Version, d.Version)
} assert.Equal(t, tt.Repository, d.Repository, "Expected dependency named %q to have repository %q, got %q", tt.Name, tt.Repository, d.Repository)
if d.Version != tt.Version {
t.Errorf("Expected dependency named %q to have version %q, got %q", tt.Name, tt.Version, d.Version)
}
if d.Repository != tt.Repository {
t.Errorf("Expected dependency named %q to have repository %q, got %q", tt.Name, tt.Repository, d.Repository)
}
} }
} }
@ -653,51 +544,25 @@ func verifyFrobnitz(t *testing.T, c *chart.Chart) {
func verifyChartFileAndTemplate(t *testing.T, c *chart.Chart, name string) { func verifyChartFileAndTemplate(t *testing.T, c *chart.Chart, name string) {
t.Helper() t.Helper()
if c.Metadata == nil { require.NotNil(t, c.Metadata, "Metadata is nil")
t.Fatal("Metadata is nil") assert.Equal(t, name, c.Name(), "Expected %s, got %s", name, c.Name())
} require.Len(t, c.Templates, 1, "Expected 1 template, got %d", len(c.Templates))
if c.Name() != name { assert.Equal(t, "templates/template.tpl", c.Templates[0].Name, "Unexpected template: %s", c.Templates[0].Name)
t.Errorf("Expected %s, got %s", name, c.Name()) assert.NotEmpty(t, c.Templates[0].Data, "No template data.")
} require.Len(t, c.Files, 6, "Expected 6 Files, got %d", len(c.Files))
if len(c.Templates) != 1 { require.Len(t, c.Dependencies(), 2, "Expected 2 Dependency, got %d", len(c.Dependencies()))
t.Fatalf("Expected 1 template, got %d", len(c.Templates)) require.Len(t, c.Metadata.Dependencies, 2, "Expected 2 Dependencies.Dependency, got %d", len(c.Metadata.Dependencies))
} require.Len(t, c.Lock.Dependencies, 2, "Expected 2 Lock.Dependency, got %d", len(c.Lock.Dependencies))
if c.Templates[0].Name != "templates/template.tpl" {
t.Errorf("Unexpected template: %s", c.Templates[0].Name)
}
if len(c.Templates[0].Data) == 0 {
t.Error("No template data.")
}
if len(c.Files) != 6 {
t.Fatalf("Expected 6 Files, got %d", len(c.Files))
}
if len(c.Dependencies()) != 2 {
t.Fatalf("Expected 2 Dependency, got %d", len(c.Dependencies()))
}
if len(c.Metadata.Dependencies) != 2 {
t.Fatalf("Expected 2 Dependencies.Dependency, got %d", len(c.Metadata.Dependencies))
}
if len(c.Lock.Dependencies) != 2 {
t.Fatalf("Expected 2 Lock.Dependency, got %d", len(c.Lock.Dependencies))
}
for _, dep := range c.Dependencies() { for _, dep := range c.Dependencies() {
switch dep.Name() { switch dep.Name() {
case "mariner": case "mariner":
case "alpine": case "alpine":
if len(dep.Templates) != 1 { require.Len(t, dep.Templates, 1, "Expected 1 template, got %d", len(dep.Templates))
t.Fatalf("Expected 1 template, got %d", len(dep.Templates)) assert.Equal(t, "templates/alpine-pod.yaml", dep.Templates[0].Name, "Unexpected template: %s", dep.Templates[0].Name)
}
if dep.Templates[0].Name != "templates/alpine-pod.yaml" {
t.Errorf("Unexpected template: %s", dep.Templates[0].Name)
}
assert.NotEmpty(t, dep.Templates[0].Data, "No template data.") assert.NotEmpty(t, dep.Templates[0].Data, "No template data.")
if len(dep.Files) != 1 { require.Len(t, dep.Files, 1, "Expected 1 Files, got %d", len(dep.Files))
t.Fatalf("Expected 1 Files, got %d", len(dep.Files)) require.Len(t, dep.Dependencies(), 2, "Expected 2 Dependency, got %d", len(dep.Dependencies()))
}
if len(dep.Dependencies()) != 2 {
t.Fatalf("Expected 2 Dependency, got %d", len(dep.Dependencies()))
}
default: default:
t.Errorf("Unexpected dependency %s", dep.Name()) t.Errorf("Unexpected dependency %s", dep.Name())
} }
@ -707,8 +572,6 @@ func verifyChartFileAndTemplate(t *testing.T, c *chart.Chart, name string) {
func verifyBomStripped(t *testing.T, files []*common.File) { func verifyBomStripped(t *testing.T, files []*common.File) {
t.Helper() t.Helper()
for _, file := range files { for _, file := range files {
if bytes.HasPrefix(file.Data, utf8bom) { assert.Falsef(t, bytes.HasPrefix(file.Data, utf8bom), "Byte Order Mark still present in processed file %s", file.Name)
t.Errorf("Byte Order Mark still present in processed file %s", file.Name)
}
} }
} }

41
internal/chart/v3/util/create_test.go
Unescape View File

@ -38,7 +38,7 @@ func TestCreate(t *testing.T) {
dir := filepath.Join(tdir, "foo") dir := filepath.Join(tdir, "foo")
mychart, err := loader.LoadDir(c) mychart, err := loader.LoadDir(c)
require.NoError(t, err, "Failed to load newly created chart %q: %s", c, err) require.NoError(t, err, "Failed to load newly created chart %q", c)
assert.Equal(t, "foo", mychart.Name(), "Expected name to be 'foo', got %q", mychart.Name()) assert.Equal(t, "foo", mychart.Name(), "Expected name to be 'foo', got %q", mychart.Name())
@ -55,9 +55,8 @@ func TestCreate(t *testing.T) {
TestConnectionName, TestConnectionName,
ValuesfileName, ValuesfileName,
} { } {
if _, err := os.Stat(filepath.Join(dir, f)); err != nil { _, err := os.Stat(filepath.Join(dir, f))
t.Errorf("Expected %s file: %s", f, err) assert.NoErrorf(t, err, "Expected %s file", f)
}
} }
} }
@ -71,14 +70,12 @@ func TestCreateFrom(t *testing.T) {
} }
srcdir := "./testdata/frobnitz/charts/mariner" srcdir := "./testdata/frobnitz/charts/mariner"
if err := CreateFrom(cf, tdir, srcdir); err != nil { require.NoError(t, CreateFrom(cf, tdir, srcdir))
t.Fatal(err)
}
dir := filepath.Join(tdir, "foo") dir := filepath.Join(tdir, "foo")
c := filepath.Join(tdir, cf.Name) c := filepath.Join(tdir, cf.Name)
mychart, err := loader.LoadDir(c) mychart, err := loader.LoadDir(c)
require.NoError(t, err, "Failed to load newly created chart %q: %s", c, err) require.NoError(t, err, "Failed to load newly created chart %q", c)
assert.Equal(t, "foo", mychart.Name(), "Expected name to be 'foo', got %q", mychart.Name()) assert.Equal(t, "foo", mychart.Name(), "Expected name to be 'foo', got %q", mychart.Name())
@ -87,16 +84,13 @@ func TestCreateFrom(t *testing.T) {
ValuesfileName, ValuesfileName,
filepath.Join(TemplatesDir, "placeholder.tpl"), filepath.Join(TemplatesDir, "placeholder.tpl"),
} { } {
if _, err := os.Stat(filepath.Join(dir, f)); err != nil { _, err := os.Stat(filepath.Join(dir, f))
t.Errorf("Expected %s file: %s", f, err) require.NoErrorf(t, err, "Expected %s file", f)
}
// Check each file to make sure <CHARTNAME> has been replaced // Check each file to make sure <CHARTNAME> has been replaced
b, err := os.ReadFile(filepath.Join(dir, f)) b, err := os.ReadFile(filepath.Join(dir, f))
require.NoError(t, err, "Unable to read file %s: %s", f, err) require.NoError(t, err, "Unable to read file %s", f)
if bytes.Contains(b, []byte("<CHARTNAME>")) { assert.Falsef(t, bytes.Contains(b, []byte("<CHARTNAME>")), "File %s contains <CHARTNAME>", f)
t.Errorf("File %s contains <CHARTNAME>", f)
}
} }
} }
@ -106,9 +100,8 @@ func TestCreate_Overwrite(t *testing.T) {
var errlog bytes.Buffer var errlog bytes.Buffer
if _, err := Create("foo", tdir); err != nil { _, err := Create("foo", tdir)
t.Fatal(err) require.NoError(t, err)
}
dir := filepath.Join(tdir, "foo") dir := filepath.Join(tdir, "foo")
@ -117,9 +110,8 @@ func TestCreate_Overwrite(t *testing.T) {
// Now re-run the create // Now re-run the create
Stderr = &errlog Stderr = &errlog
if _, err := Create("foo", tdir); err != nil { _, err = Create("foo", tdir)
t.Fatal(err) require.NoError(t, err)
}
data, err := os.ReadFile(tplname) data, err := os.ReadFile(tplname)
require.NoError(t, err) require.NoError(t, err)
@ -150,8 +142,11 @@ func TestValidateChartName(t *testing.T) {
"abcdefghijklmnopqrstuvwxyz-_." + "abcdefghijklmnopqrstuvwxyz-_." +
"ABCDEFGHIJKLMNOPQRSTUVWXYZ-_.": false, "ABCDEFGHIJKLMNOPQRSTUVWXYZ-_.": false,
} { } {
if err := validateChartName(name); (err != nil) == shouldPass { err := validateChartName(name)
t.Errorf("test for %q failed", name) if shouldPass {
assert.NoErrorf(t, err, "Expected chart name %q to pass validation", name)
} else {
assert.Errorf(t, err, "Expected chart name %q to fail validation, but it passed", name)
} }
} }
} }

32
internal/chart/v3/util/save_test.go
Unescape View File

@ -62,13 +62,9 @@ func TestSave(t *testing.T) {
chartWithInvalidJSON := withSchema(*c, []byte("{")) chartWithInvalidJSON := withSchema(*c, []byte("{"))
where, err := Save(c, dest) where, err := Save(c, dest)
require.NoError(t, err, "Failed to save: %s", err) require.NoError(t, err, "Failed to save")
if !strings.HasPrefix(where, dest) { require.Truef(t, strings.HasPrefix(where, dest), "Expected %q to start with %q", where, dest)
t.Fatalf("Expected %q to start with %q", where, dest) require.Truef(t, strings.HasSuffix(where, ".tgz"), "Expected %q to end with .tgz", where)
}
if !strings.HasSuffix(where, ".tgz") {
t.Fatalf("Expected %q to end with .tgz", where)
}
c2, err := loader.LoadFile(where) c2, err := loader.LoadFile(where)
require.NoError(t, err) require.NoError(t, err)
@ -83,13 +79,12 @@ func TestSave(t *testing.T) {
formattedActual := Indent(indentation, string(c2.Schema)) formattedActual := Indent(indentation, string(c2.Schema))
t.Fatalf("Schema data did not match.\nExpected:\n%s\nActual:\n%s", formattedExpected, formattedActual) t.Fatalf("Schema data did not match.\nExpected:\n%s\nActual:\n%s", formattedExpected, formattedActual)
} }
if _, err := Save(&chartWithInvalidJSON, dest); err == nil { _, err = Save(&chartWithInvalidJSON, dest)
t.Fatal("Invalid JSON was not caught while saving chart") require.Error(t, err, "Invalid JSON was not caught while saving chart")
}
c.Metadata.APIVersion = chart.APIVersionV3 c.Metadata.APIVersion = chart.APIVersionV3
where, err = Save(c, dest) where, err = Save(c, dest)
require.NoError(t, err, "Failed to save: %s", err) require.NoError(t, err, "Failed to save")
c2, err = loader.LoadFile(where) c2, err = loader.LoadFile(where)
require.NoError(t, err) require.NoError(t, err)
require.NotNil(t, c2.Lock, "Expected v3 chart archive to contain a Chart.lock file") require.NotNil(t, c2.Lock, "Expected v3 chart archive to contain a Chart.lock file")
@ -152,16 +147,14 @@ func TestSavePreservesTimestamps(t *testing.T) {
} }
where, err := Save(c, tmp) where, err := Save(c, tmp)
require.NoError(t, err, "Failed to save: %s", err) require.NoError(t, err, "Failed to save")
allHeaders, err := retrieveAllHeadersFromTar(where) allHeaders, err := retrieveAllHeadersFromTar(where)
require.NoError(t, err, "Failed to parse tar: %v", err) require.NoError(t, err, "Failed to parse tar")
roundedTime := initialCreateTime.Round(time.Second) roundedTime := initialCreateTime.Round(time.Second)
for _, header := range allHeaders { for _, header := range allHeaders {
if !header.ModTime.Equal(roundedTime) { require.Truef(t, header.ModTime.Equal(roundedTime), "File timestamp not preserved: %v", header.ModTime)
t.Fatalf("File timestamp not preserved: %v", header.ModTime)
}
} }
} }
@ -235,8 +228,7 @@ func TestSaveDir(t *testing.T) {
pth := filepath.Join(tmp2, "tmpcharts") pth := filepath.Join(tmp2, "tmpcharts")
require.NoError(t, os.MkdirAll(filepath.Join(pth), 0o755), "Failed to create directory") require.NoError(t, os.MkdirAll(filepath.Join(pth), 0o755), "Failed to create directory")
err = SaveDir(c, pth) assert.EqualError(t, SaveDir(c, pth), "\"../ahab\" is not a valid chart name", "Did not get expected error for chart named %q", c.Name())
assert.EqualError(t, err, "\"../ahab\" is not a valid chart name", "Did not get expected error for chart named %q", c.Name())
} }
func TestRepeatableSave(t *testing.T) { func TestRepeatableSave(t *testing.T) {
@ -297,10 +289,10 @@ func TestRepeatableSave(t *testing.T) {
// create package // create package
dest := path.Join(tmp, "newdir") dest := path.Join(tmp, "newdir")
where, err := Save(test.chart, dest) where, err := Save(test.chart, dest)
require.NoError(t, err, "Failed to save: %s", err) require.NoError(t, err, "Failed to save")
// get shasum for package // get shasum for package
result, err := sha256Sum(where) result, err := sha256Sum(where)
require.NoError(t, err, "Failed to check shasum: %s", err) require.NoError(t, err, "Failed to check shasum")
// assert that the package SHA is what we wanted. // assert that the package SHA is what we wanted.
assert.Equal(t, test.want, result, "FormatName() result = %v, want %v", result, test.want) assert.Equal(t, test.want, result, "FormatName() result = %v, want %v", result, test.want)
}) })

4
internal/plugin/runtime_subprocess_test.go
Unescape View File

@ -16,7 +16,6 @@ limitations under the License.
package plugin package plugin
import ( import (
"errors"
"fmt" "fmt"
"os" "os"
"path/filepath" "path/filepath"
@ -78,8 +77,7 @@ func TestSubprocessPluginRuntime(t *testing.T) {
require.Error(t, err) require.Error(t, err)
ieerr := &InvokeExecError{} ieerr := &InvokeExecError{}
ok := errors.As(err, &ieerr) require.ErrorAs(t, err, &ieerr, "expected InvokeExecError")
require.True(t, ok, "expected InvokeExecError, got %T", err)
assert.Equal(t, 56, ieerr.ExitCode) assert.Equal(t, 56, ieerr.ExitCode)
assert.Nil(t, output) assert.Nil(t, output)

42
internal/release/v2/info_test.go
Unescape View File

@ -253,17 +253,17 @@ func TestInfoUnmarshalJSON(t *testing.T) {
err := json.Unmarshal([]byte(tt.input), &info) err := json.Unmarshal([]byte(tt.input), &info)
if tt.wantErr { if tt.wantErr {
assert.Error(t, err) assert.Error(t, err)
return } else {
require.NoError(t, err)
assert.Equal(t, tt.expected.FirstDeployed.Unix(), info.FirstDeployed.Unix())
assert.Equal(t, tt.expected.LastDeployed.Unix(), info.LastDeployed.Unix())
assert.Equal(t, tt.expected.Deleted.Unix(), info.Deleted.Unix())
assert.Equal(t, tt.expected.Description, info.Description)
assert.Equal(t, tt.expected.Status, info.Status)
assert.Equal(t, tt.expected.RollbackRevision, info.RollbackRevision)
assert.Equal(t, tt.expected.Notes, info.Notes)
assert.Equal(t, tt.expected.Resources, info.Resources)
} }
require.NoError(t, err)
assert.Equal(t, tt.expected.FirstDeployed.Unix(), info.FirstDeployed.Unix())
assert.Equal(t, tt.expected.LastDeployed.Unix(), info.LastDeployed.Unix())
assert.Equal(t, tt.expected.Deleted.Unix(), info.Deleted.Unix())
assert.Equal(t, tt.expected.Description, info.Description)
assert.Equal(t, tt.expected.Status, info.Status)
assert.Equal(t, tt.expected.RollbackRevision, info.RollbackRevision)
assert.Equal(t, tt.expected.Notes, info.Notes)
assert.Equal(t, tt.expected.Resources, info.Resources)
}) })
} }
} }
@ -284,9 +284,7 @@ func TestInfoRoundTrip(t *testing.T) {
require.NoError(t, err) require.NoError(t, err)
var decoded Info var decoded Info
err = json.Unmarshal(data, &decoded) require.NoError(t, json.Unmarshal(data, &decoded))
require.NoError(t, err)
assert.Equal(t, original.FirstDeployed.Unix(), decoded.FirstDeployed.Unix()) assert.Equal(t, original.FirstDeployed.Unix(), decoded.FirstDeployed.Unix())
assert.Equal(t, original.LastDeployed.Unix(), decoded.LastDeployed.Unix()) assert.Equal(t, original.LastDeployed.Unix(), decoded.LastDeployed.Unix())
assert.Equal(t, original.Deleted.Unix(), decoded.Deleted.Unix()) assert.Equal(t, original.Deleted.Unix(), decoded.Deleted.Unix())
@ -330,8 +328,7 @@ func TestInfoRollbackRevisionRoundTrip(t *testing.T) {
require.NoError(t, err) require.NoError(t, err)
var decoded Info var decoded Info
err = json.Unmarshal(data, &decoded) require.NoError(t, json.Unmarshal(data, &decoded))
require.NoError(t, err)
assert.Equal(t, tt.info.RollbackRevision, decoded.RollbackRevision) assert.Equal(t, tt.info.RollbackRevision, decoded.RollbackRevision)
assert.Equal(t, tt.info.FirstDeployed.Unix(), decoded.FirstDeployed.Unix()) assert.Equal(t, tt.info.FirstDeployed.Unix(), decoded.FirstDeployed.Unix())
@ -342,8 +339,7 @@ func TestInfoRollbackRevisionRoundTrip(t *testing.T) {
// Verify omitempty behavior: zero rollback_revision should not appear in JSON // Verify omitempty behavior: zero rollback_revision should not appear in JSON
if tt.info.RollbackRevision == 0 { if tt.info.RollbackRevision == 0 {
var raw map[string]any var raw map[string]any
err = json.Unmarshal(data, &raw) require.NoError(t, json.Unmarshal(data, &raw))
require.NoError(t, err)
assert.NotContains(t, raw, "rollback_revision") assert.NotContains(t, raw, "rollback_revision")
} }
}) })
@ -356,13 +352,12 @@ func TestInfoEmptyStringRoundTrip(t *testing.T) {
input := `{"first_deployed":"","last_deployed":"","deleted":"","status":"deployed","description":"test"}` input := `{"first_deployed":"","last_deployed":"","deleted":"","status":"deployed","description":"test"}`
var info Info var info Info
err := json.Unmarshal([]byte(input), &info) require.NoError(t, json.Unmarshal([]byte(input), &info))
require.NoError(t, err)
// Verify time fields are zero values // Verify time fields are zero values
assert.True(t, info.FirstDeployed.IsZero()) assert.Zero(t, info.FirstDeployed)
assert.True(t, info.LastDeployed.IsZero()) assert.Zero(t, info.LastDeployed)
assert.True(t, info.Deleted.IsZero()) assert.Zero(t, info.Deleted)
assert.Equal(t, common.StatusDeployed, info.Status) assert.Equal(t, common.StatusDeployed, info.Status)
assert.Equal(t, "test", info.Description) assert.Equal(t, "test", info.Description)
@ -371,8 +366,7 @@ func TestInfoEmptyStringRoundTrip(t *testing.T) {
require.NoError(t, err) require.NoError(t, err)
var result map[string]any var result map[string]any
err = json.Unmarshal(data, &result) require.NoError(t, json.Unmarshal(data, &result))
require.NoError(t, err)
// Zero time values should be omitted due to omitzero tag // Zero time values should be omitted due to omitzero tag
assert.NotContains(t, result, "first_deployed") assert.NotContains(t, result, "first_deployed")

Write Preview
Loading…
Cancel
Save