msb-public
/
helm
mirror of https://github.com/helm/helm
1
0
Code Issues Projects Releases Wiki Activity

Merge pull request #32435 from mmorel-35/testifylint-manual-assert-pkg-19

Browse Source 
chore(pkg): refactor: convert tests to testify assert/require part 19
pull/32458/head
Robert Sirchia 2 months ago committed by GitHub
parent f65e3b72b0 33c2839569
commit 39231d01e1
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
9 changed files with 125 additions and 243 deletions
Show Stats Download Patch File Download Diff File

46
pkg/action/lint_test.go
Unescape View File

@ -21,6 +21,7 @@ import (
"testing" "testing"
"github.com/stretchr/testify/assert" "github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"helm.sh/helm/v4/pkg/chart/v2/lint/support" "helm.sh/helm/v4/pkg/chart/v2/lint/support"
) )
@ -89,11 +90,10 @@ func TestLintChart(t *testing.T) {
for _, tt := range tests { for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) { t.Run(tt.name, func(t *testing.T) {
_, err := lintChart(tt.chartPath, map[string]any{}, namespace, nil, tt.skipSchemaValidation) _, err := lintChart(tt.chartPath, map[string]any{}, namespace, nil, tt.skipSchemaValidation)
switch { if tt.err {
case err != nil && !tt.err: require.Error(t, err, "Expected a chart parsing error")
t.Errorf("%s", err) } else {
case err == nil && tt.err: require.NoError(t, err)
t.Error("Expected a chart parsing error")
} }
}) })
} }
@ -106,14 +106,10 @@ func TestNonExistentChart(t *testing.T) {
testLint := NewLint() testLint := NewLint()
result := testLint.Run(testCharts, values) result := testLint.Run(testCharts, values)
if len(result.Errors) != 1 { assert.Len(t, result.Errors, 1, "expected one error, but got", len(result.Errors))
t.Error("expected one error, but got", len(result.Errors))
}
actual := result.Errors[0].Error() actual := result.Errors[0].Error()
if actual != expectedError { assert.EqualError(t, result.Errors[0], expectedError, "expected '%s', but got '%s'", expectedError, actual)
t.Errorf("expected '%s', but got '%s'", expectedError, actual)
}
}) })
t.Run("should error out for corrupted tgz chart", func(t *testing.T) { t.Run("should error out for corrupted tgz chart", func(t *testing.T) {
@ -122,31 +118,25 @@ func TestNonExistentChart(t *testing.T) {
testLint := NewLint() testLint := NewLint()
result := testLint.Run(testCharts, values) result := testLint.Run(testCharts, values)
if len(result.Errors) != 1 { assert.Len(t, result.Errors, 1, "expected one error, but got", len(result.Errors))
t.Error("expected one error, but got", len(result.Errors))
}
actual := result.Errors[0].Error() actual := result.Errors[0].Error()
if actual != expectedEOFError { assert.EqualError(t, result.Errors[0], expectedEOFError, "expected '%s', but got '%s'", expectedEOFError, actual)
t.Errorf("expected '%s', but got '%s'", expectedEOFError, actual)
}
}) })
} }
func TestLint_MultipleCharts(t *testing.T) { func TestLint_MultipleCharts(t *testing.T) {
testCharts := []string{chart2MultipleChartLint, chart1MultipleChartLint} testCharts := []string{chart2MultipleChartLint, chart1MultipleChartLint}
testLint := NewLint() testLint := NewLint()
if result := testLint.Run(testCharts, values); len(result.Errors) > 0 { result := testLint.Run(testCharts, values)
t.Error(result.Errors) assert.Empty(t, result.Errors)
}
} }
func TestLint_EmptyResultErrors(t *testing.T) { func TestLint_EmptyResultErrors(t *testing.T) {
testCharts := []string{chart2MultipleChartLint} testCharts := []string{chart2MultipleChartLint}
testLint := NewLint() testLint := NewLint()
if result := testLint.Run(testCharts, values); len(result.Errors) > 0 { result := testLint.Run(testCharts, values)
t.Error("Expected no error, got more") assert.Empty(t, result.Errors, "Expected no error, got more")
}
} }
func TestLint_ChartWithWarnings(t *testing.T) { func TestLint_ChartWithWarnings(t *testing.T) {
@ -154,18 +144,16 @@ func TestLint_ChartWithWarnings(t *testing.T) {
testCharts := []string{chartWithNoTemplatesDir} testCharts := []string{chartWithNoTemplatesDir}
testLint := NewLint() testLint := NewLint()
testLint.Strict = false testLint.Strict = false
if result := testLint.Run(testCharts, values); len(result.Errors) > 0 { result := testLint.Run(testCharts, values)
t.Error("Expected no error, got more") assert.Empty(t, result.Errors, "Expected no error, got more")
}
}) })
t.Run("should fail with one error when strict", func(t *testing.T) { t.Run("should fail with one error when strict", func(t *testing.T) {
testCharts := []string{chartWithNoTemplatesDir} testCharts := []string{chartWithNoTemplatesDir}
testLint := NewLint() testLint := NewLint()
testLint.Strict = true testLint.Strict = true
if result := testLint.Run(testCharts, values); len(result.Errors) != 1 { result := testLint.Run(testCharts, values)
t.Error("expected one error, but got", len(result.Errors)) assert.Len(t, result.Errors, 1, "expected one error")
}
}) })
} }

41
pkg/action/show_test.go
Unescape View File

@ -21,6 +21,7 @@ import (
"time" "time"
"github.com/stretchr/testify/assert" "github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"helm.sh/helm/v4/pkg/chart/common" "helm.sh/helm/v4/pkg/chart/common"
chart "helm.sh/helm/v4/pkg/chart/v2" chart "helm.sh/helm/v4/pkg/chart/v2"
@ -47,9 +48,7 @@ func TestShow(t *testing.T) {
} }
output, err := client.Run("") output, err := client.Run("")
if err != nil { require.NoError(t, err)
t.Fatal(err)
}
expect := `name: alpine expect := `name: alpine
@ -69,9 +68,7 @@ bar
baz baz
` `
if output != expect { assert.Equal(t, expect, output, "Expected\n%q\nGot\n%q\n", expect, output)
t.Errorf("Expected\n%q\nGot\n%q\n", expect, output)
}
} }
func TestShowNoValues(t *testing.T) { func TestShowNoValues(t *testing.T) {
@ -82,13 +79,9 @@ func TestShowNoValues(t *testing.T) {
// Regression tests for missing values. See issue #1024. // Regression tests for missing values. See issue #1024.
client.OutputFormat = ShowValues client.OutputFormat = ShowValues
output, err := client.Run("") output, err := client.Run("")
if err != nil { require.NoError(t, err)
t.Fatal(err)
}
if output != "" { assert.Empty(t, output, "expected empty values buffer, got %s", output)
t.Errorf("expected empty values buffer, got %s", output)
}
} }
func TestShowValuesByJsonPathFormat(t *testing.T) { func TestShowValuesByJsonPathFormat(t *testing.T) {
@ -97,13 +90,9 @@ func TestShowValuesByJsonPathFormat(t *testing.T) {
client.JSONPathTemplate = "{$.nestedKey.simpleKey}" client.JSONPathTemplate = "{$.nestedKey.simpleKey}"
client.chart = buildChart(withSampleValues()) client.chart = buildChart(withSampleValues())
output, err := client.Run("") output, err := client.Run("")
if err != nil { require.NoError(t, err)
t.Fatal(err)
}
expect := "simpleValue" expect := "simpleValue"
if output != expect { assert.Equal(t, expect, output, "Expected\n%q\nGot\n%q\n", expect, output)
t.Errorf("Expected\n%q\nGot\n%q\n", expect, output)
}
} }
func TestShowCRDs(t *testing.T) { func TestShowCRDs(t *testing.T) {
@ -121,9 +110,7 @@ func TestShowCRDs(t *testing.T) {
} }
output, err := client.Run("") output, err := client.Run("")
if err != nil { require.NoError(t, err)
t.Fatal(err)
}
expect := `--- expect := `---
foo foo
@ -135,9 +122,7 @@ bar
baz baz
` `
if output != expect { assert.Equal(t, expect, output, "Expected\n%q\nGot\n%q\n", expect, output)
t.Errorf("Expected\n%q\nGot\n%q\n", expect, output)
}
} }
func TestShowNoReadme(t *testing.T) { func TestShowNoReadme(t *testing.T) {
@ -154,9 +139,7 @@ func TestShowNoReadme(t *testing.T) {
} }
output, err := client.Run("") output, err := client.Run("")
if err != nil { require.NoError(t, err)
t.Fatal(err)
}
expect := `name: alpine expect := `name: alpine
@ -167,9 +150,7 @@ foo
bar bar
` `
if output != expect { assert.Equal(t, expect, output, "Expected\n%q\nGot\n%q\n", expect, output)
t.Errorf("Expected\n%q\nGot\n%q\n", expect, output)
}
} }
func TestShowSetRegistryClient(t *testing.T) { func TestShowSetRegistryClient(t *testing.T) {

40
pkg/action/upgrade_test.go
Unescape View File

@ -176,8 +176,8 @@ func TestUpgradeRelease_RollbackOnFailure(t *testing.T) {
resi, err := upAction.Run(rel.Name, buildChart(), vals) resi, err := upAction.Run(rel.Name, buildChart(), vals)
req.Error(err) req.Error(err)
is.Contains(err.Error(), "arming key removed") req.ErrorContains(err, "arming key removed")
is.Contains(err.Error(), "rollback-on-failure") req.ErrorContains(err, "rollback-on-failure")
res, err := releaserToV1Release(resi) res, err := releaserToV1Release(resi)
req.NoError(err) req.NoError(err)
@ -207,8 +207,8 @@ func TestUpgradeRelease_RollbackOnFailure(t *testing.T) {
_, err := upAction.Run(rel.Name, buildChart(), vals) _, err := upAction.Run(rel.Name, buildChart(), vals)
req.Error(err) req.Error(err)
is.Contains(err.Error(), "update fail") req.ErrorContains(err, "update fail")
is.Contains(err.Error(), "an error occurred while rolling back the release") is.ErrorContains(err, "an error occurred while rolling back the release")
}) })
} }
@ -240,8 +240,7 @@ func TestUpgradeRelease_ReuseValues(t *testing.T) {
rel.Info.Status = common.StatusDeployed rel.Info.Status = common.StatusDeployed
rel.Config = existingValues rel.Config = existingValues
err := upAction.cfg.Releases.Create(rel) req.NoError(upAction.cfg.Releases.Create(rel))
req.NoError(err)
upAction.ReuseValues = true upAction.ReuseValues = true
// setting newValues and upgrading // setting newValues and upgrading
@ -303,8 +302,7 @@ func TestUpgradeRelease_ReuseValues(t *testing.T) {
Config: existingValues, Config: existingValues,
Version: 1, Version: 1,
} }
err := upAction.cfg.Releases.Create(rel) req.NoError(upAction.cfg.Releases.Create(rel))
req.NoError(err)
upAction.ReuseValues = true upAction.ReuseValues = true
sampleChartWithSubChart := buildChart( sampleChartWithSubChart := buildChart(
@ -373,8 +371,7 @@ func TestUpgradeRelease_ResetThenReuseValues(t *testing.T) {
rel.Info.Status = common.StatusDeployed rel.Info.Status = common.StatusDeployed
rel.Config = existingValues rel.Config = existingValues
err := upAction.cfg.Releases.Create(rel) req.NoError(upAction.cfg.Releases.Create(rel))
req.NoError(err)
upAction.ResetThenReuseValues = true upAction.ResetThenReuseValues = true
// setting newValues and upgrading // setting newValues and upgrading
@ -417,7 +414,7 @@ func TestUpgradeRelease_Pending(t *testing.T) {
vals := map[string]any{} vals := map[string]any{}
_, err := upAction.Run(rel.Name, buildChart(), vals) _, err := upAction.Run(rel.Name, buildChart(), vals)
req.Contains(err.Error(), "progress", err) req.ErrorContains(err, "progress")
} }
func TestUpgradeRelease_Interrupted_Wait(t *testing.T) { func TestUpgradeRelease_Interrupted_Wait(t *testing.T) {
@ -470,7 +467,7 @@ func TestUpgradeRelease_Interrupted_RollbackOnFailure(t *testing.T) {
resi, err := upAction.RunWithContext(ctx, rel.Name, buildChart(), vals) resi, err := upAction.RunWithContext(ctx, rel.Name, buildChart(), vals)
req.Error(err) req.Error(err)
is.Contains(err.Error(), "release interrupted-release failed, and has been rolled back due to rollback-on-failure being set: context canceled") req.ErrorContains(err, "release interrupted-release failed, and has been rolled back due to rollback-on-failure being set: context canceled")
res, err := releaserToV1Release(resi) res, err := releaserToV1Release(resi)
req.NoError(err) req.NoError(err)
// Now make sure it is actually upgraded // Now make sure it is actually upgraded
@ -491,9 +488,8 @@ func TestMergeCustomLabels(t *testing.T) {
{map[string]string{"k1": "v1", "k2": "v2"}, map[string]string{"k1": "null", "k2": "v3"}, map[string]string{"k2": "v3"}}, {map[string]string{"k1": "v1", "k2": "v2"}, map[string]string{"k1": "null", "k2": "v3"}, map[string]string{"k2": "v3"}},
} }
for _, test := range tests { for _, test := range tests {
if output := mergeCustomLabels(test[0], test[1]); !reflect.DeepEqual(test[2], output) { output := mergeCustomLabels(test[0], test[1])
t.Errorf("Expected {%v}, got {%v}", test[2], output) assert.Truef(t, reflect.DeepEqual(test[2], output), "Expected {%v}, got {%v}", test[2], output)
}
} }
} }
@ -511,8 +507,7 @@ func TestUpgradeRelease_Labels(t *testing.T) {
} }
rel.Info.Status = common.StatusDeployed rel.Info.Status = common.StatusDeployed
err := upAction.cfg.Releases.Create(rel) req.NoError(upAction.cfg.Releases.Create(rel))
req.NoError(err)
upAction.Labels = map[string]string{ upAction.Labels = map[string]string{
"key1": "null", "key1": "null",
@ -566,8 +561,7 @@ func TestUpgradeRelease_SystemLabels(t *testing.T) {
} }
rel.Info.Status = common.StatusDeployed rel.Info.Status = common.StatusDeployed
err := upAction.cfg.Releases.Create(rel) req.NoError(upAction.cfg.Releases.Create(rel))
req.NoError(err)
upAction.Labels = map[string]string{ upAction.Labels = map[string]string{
"key1": "null", "key1": "null",
@ -575,12 +569,10 @@ func TestUpgradeRelease_SystemLabels(t *testing.T) {
"owner": "val3", "owner": "val3",
} }
// setting newValues and upgrading // setting newValues and upgrading
_, err = upAction.Run(rel.Name, buildChart(), nil) _, err := upAction.Run(rel.Name, buildChart(), nil)
if err == nil { require.Error(t, err, "expected an error")
t.Fatal("expected an error")
}
is.Equal(fmt.Errorf("user supplied labels contains system reserved label name. System labels: %+v", driver.GetSystemLabels()), err) is.EqualError(err, fmt.Sprintf("user supplied labels contains system reserved label name. System labels: %+v", driver.GetSystemLabels()))
} }
func TestUpgradeRelease_DryRun(t *testing.T) { func TestUpgradeRelease_DryRun(t *testing.T) {

37
pkg/action/validate_test.go
Unescape View File

@ -171,45 +171,38 @@ func TestCheckOwnership(t *testing.T) {
deployFoo := newDeploymentResource("foo", "ns-a", "") deployFoo := newDeploymentResource("foo", "ns-a", "")
// Verify that a resource that lacks labels/annotations is not owned // Verify that a resource that lacks labels/annotations is not owned
err := checkOwnership(deployFoo.Object, "rel-a", "ns-a") require.EqualError(t, checkOwnership(deployFoo.Object, "rel-a", "ns-a"), `invalid ownership metadata; label validation error: missing key "app.kubernetes.io/managed-by": must be set to "Helm"; annotation validation error: missing key "meta.helm.sh/release-name": must be set to "rel-a"; annotation validation error: missing key "meta.helm.sh/release-namespace": must be set to "ns-a"`)
require.EqualError(t, err, `invalid ownership metadata; label validation error: missing key "app.kubernetes.io/managed-by": must be set to "Helm"; annotation validation error: missing key "meta.helm.sh/release-name": must be set to "rel-a"; annotation validation error: missing key "meta.helm.sh/release-namespace": must be set to "ns-a"`)
// Set managed by label and verify annotation error message // Set managed by label and verify annotation error message
_ = accessor.SetLabels(deployFoo.Object, map[string]string{ _ = accessor.SetLabels(deployFoo.Object, map[string]string{
appManagedByLabel: appManagedByHelm, appManagedByLabel: appManagedByHelm,
}) })
err = checkOwnership(deployFoo.Object, "rel-a", "ns-a") require.EqualError(t, checkOwnership(deployFoo.Object, "rel-a", "ns-a"), `invalid ownership metadata; annotation validation error: missing key "meta.helm.sh/release-name": must be set to "rel-a"; annotation validation error: missing key "meta.helm.sh/release-namespace": must be set to "ns-a"`)
require.EqualError(t, err, `invalid ownership metadata; annotation validation error: missing key "meta.helm.sh/release-name": must be set to "rel-a"; annotation validation error: missing key "meta.helm.sh/release-namespace": must be set to "ns-a"`)
// Set only the release name annotation and verify missing release namespace error message // Set only the release name annotation and verify missing release namespace error message
_ = accessor.SetAnnotations(deployFoo.Object, map[string]string{ _ = accessor.SetAnnotations(deployFoo.Object, map[string]string{
helmReleaseNameAnnotation: "rel-a", helmReleaseNameAnnotation: "rel-a",
}) })
err = checkOwnership(deployFoo.Object, "rel-a", "ns-a") require.EqualError(t, checkOwnership(deployFoo.Object, "rel-a", "ns-a"), `invalid ownership metadata; annotation validation error: missing key "meta.helm.sh/release-namespace": must be set to "ns-a"`)
require.EqualError(t, err, `invalid ownership metadata; annotation validation error: missing key "meta.helm.sh/release-namespace": must be set to "ns-a"`)
// Set both release name and namespace annotations and verify no ownership errors // Set both release name and namespace annotations and verify no ownership errors
_ = accessor.SetAnnotations(deployFoo.Object, map[string]string{ _ = accessor.SetAnnotations(deployFoo.Object, map[string]string{
helmReleaseNameAnnotation: "rel-a", helmReleaseNameAnnotation: "rel-a",
helmReleaseNamespaceAnnotation: "ns-a", helmReleaseNamespaceAnnotation: "ns-a",
}) })
err = checkOwnership(deployFoo.Object, "rel-a", "ns-a") require.NoError(t, checkOwnership(deployFoo.Object, "rel-a", "ns-a"))
require.NoError(t, err)
// Verify ownership error for wrong release name // Verify ownership error for wrong release name
err = checkOwnership(deployFoo.Object, "rel-b", "ns-a") require.EqualError(t, checkOwnership(deployFoo.Object, "rel-b", "ns-a"), `invalid ownership metadata; annotation validation error: key "meta.helm.sh/release-name" must equal "rel-b": current value is "rel-a"`)
require.EqualError(t, err, `invalid ownership metadata; annotation validation error: key "meta.helm.sh/release-name" must equal "rel-b": current value is "rel-a"`)
// Verify ownership error for wrong release namespace // Verify ownership error for wrong release namespace
err = checkOwnership(deployFoo.Object, "rel-a", "ns-b") require.EqualError(t, checkOwnership(deployFoo.Object, "rel-a", "ns-b"), `invalid ownership metadata; annotation validation error: key "meta.helm.sh/release-namespace" must equal "ns-b": current value is "ns-a"`)
require.EqualError(t, err, `invalid ownership metadata; annotation validation error: key "meta.helm.sh/release-namespace" must equal "ns-b": current value is "ns-a"`)
// Verify ownership error for wrong manager label // Verify ownership error for wrong manager label
_ = accessor.SetLabels(deployFoo.Object, map[string]string{ _ = accessor.SetLabels(deployFoo.Object, map[string]string{
appManagedByLabel: "helm", appManagedByLabel: "helm",
}) })
err = checkOwnership(deployFoo.Object, "rel-a", "ns-a") assert.EqualError(t, checkOwnership(deployFoo.Object, "rel-a", "ns-a"), `invalid ownership metadata; label validation error: key "app.kubernetes.io/managed-by" must equal "Helm": current value is "helm"`)
assert.EqualError(t, err, `invalid ownership metadata; label validation error: key "app.kubernetes.io/managed-by" must equal "Helm": current value is "helm"`)
} }
func TestVerifyOwnershipBeforeDelete(t *testing.T) { func TestVerifyOwnershipBeforeDelete(t *testing.T) {
@ -306,32 +299,26 @@ func TestVerifyOwnershipBeforeDelete(t *testing.T) {
func TestSetMetadataVisitor(t *testing.T) { func TestSetMetadataVisitor(t *testing.T) {
var ( var (
err error
deployFoo = newDeploymentResource("foo", "ns-a", "") deployFoo = newDeploymentResource("foo", "ns-a", "")
deployBar = newDeploymentResource("bar", "ns-a-system", "") deployBar = newDeploymentResource("bar", "ns-a-system", "")
resources = kube.ResourceList{deployFoo, deployBar} resources = kube.ResourceList{deployFoo, deployBar}
) )
// Set release tracking metadata and verify no error // Set release tracking metadata and verify no error
err = resources.Visit(setMetadataVisitor("rel-a", "ns-a", true)) require.NoError(t, resources.Visit(setMetadataVisitor("rel-a", "ns-a", true)))
require.NoError(t, err)
// Verify that release "b" cannot take ownership of "a" // Verify that release "b" cannot take ownership of "a"
err = resources.Visit(setMetadataVisitor("rel-b", "ns-a", false)) require.Error(t, resources.Visit(setMetadataVisitor("rel-b", "ns-a", false)))
require.Error(t, err)
// Force release "b" to take ownership // Force release "b" to take ownership
err = resources.Visit(setMetadataVisitor("rel-b", "ns-a", true)) require.NoError(t, resources.Visit(setMetadataVisitor("rel-b", "ns-a", true)))
require.NoError(t, err)
// Check that there is now no ownership error when setting metadata without force // Check that there is now no ownership error when setting metadata without force
err = resources.Visit(setMetadataVisitor("rel-b", "ns-a", false)) require.NoError(t, resources.Visit(setMetadataVisitor("rel-b", "ns-a", false)))
require.NoError(t, err)
// Add a new resource that is missing ownership metadata and verify error // Add a new resource that is missing ownership metadata and verify error
resources.Append(newDeploymentResource("baz", "default", "")) resources.Append(newDeploymentResource("baz", "default", ""))
err = resources.Visit(setMetadataVisitor("rel-b", "ns-a", false)) assert.ErrorContains(t, resources.Visit(setMetadataVisitor("rel-b", "ns-a", false)), `Deployment "baz" in namespace "" cannot be owned`)
assert.ErrorContains(t, err, `Deployment "baz" in namespace "" cannot be owned`)
} }
func TestValidateNameAndGenerateName(t *testing.T) { func TestValidateNameAndGenerateName(t *testing.T) {

44
pkg/chart/v2/lint/rules/values_test.go
Unescape View File

@ -22,6 +22,7 @@ import (
"testing" "testing"
"github.com/stretchr/testify/assert" "github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"helm.sh/helm/v4/internal/test/ensure" "helm.sh/helm/v4/internal/test/ensure"
) )
@ -54,11 +55,7 @@ const testSchema = `
func TestValidateValuesYamlNotDirectory(t *testing.T) { func TestValidateValuesYamlNotDirectory(t *testing.T) {
_ = os.Mkdir(nonExistingValuesFilePath, os.ModePerm) _ = os.Mkdir(nonExistingValuesFilePath, os.ModePerm)
defer os.Remove(nonExistingValuesFilePath) defer os.Remove(nonExistingValuesFilePath)
assert.Error(t, validateValuesFileExistence(nonExistingValuesFilePath), "validateValuesFileExistence to return a linter error, got no error")
err := validateValuesFileExistence(nonExistingValuesFilePath)
if err == nil {
t.Error("validateValuesFileExistence to return a linter error, got no error")
}
} }
func TestValidateValuesFileWellFormed(t *testing.T) { func TestValidateValuesFileWellFormed(t *testing.T) {
@ -67,9 +64,7 @@ func TestValidateValuesFileWellFormed(t *testing.T) {
` `
tmpdir := ensure.TempFile(t, "values.yaml", []byte(badYaml)) tmpdir := ensure.TempFile(t, "values.yaml", []byte(badYaml))
valfile := filepath.Join(tmpdir, "values.yaml") valfile := filepath.Join(tmpdir, "values.yaml")
if err := validateValuesFile(valfile, map[string]any{}, false); err == nil { require.Error(t, validateValuesFile(valfile, map[string]any{}, false), "expected values file to fail parsing")
t.Fatal("expected values file to fail parsing")
}
} }
func TestValidateValuesFileSchema(t *testing.T) { func TestValidateValuesFileSchema(t *testing.T) {
@ -78,9 +73,7 @@ func TestValidateValuesFileSchema(t *testing.T) {
createTestingSchema(t, tmpdir) createTestingSchema(t, tmpdir)
valfile := filepath.Join(tmpdir, "values.yaml") valfile := filepath.Join(tmpdir, "values.yaml")
if err := validateValuesFile(valfile, map[string]any{}, false); err != nil { require.NoErrorf(t, validateValuesFile(valfile, map[string]any{}, false), "Failed validation")
t.Fatalf("Failed validation with %s", err)
}
} }
func TestValidateValuesFileSchemaFailure(t *testing.T) { func TestValidateValuesFileSchemaFailure(t *testing.T) {
@ -90,9 +83,7 @@ func TestValidateValuesFileSchemaFailure(t *testing.T) {
createTestingSchema(t, tmpdir) createTestingSchema(t, tmpdir)
valfile := filepath.Join(tmpdir, "values.yaml") valfile := filepath.Join(tmpdir, "values.yaml")
assert.ErrorContains(t, validateValuesFile(valfile, map[string]any{}, false), "- at '/username': got number, want string")
err := validateValuesFile(valfile, map[string]any{}, false)
assert.ErrorContains(t, err, "- at '/username': got number, want string")
} }
func TestValidateValuesFileSchemaFailureButWithSkipSchemaValidation(t *testing.T) { func TestValidateValuesFileSchemaFailureButWithSkipSchemaValidation(t *testing.T) {
@ -102,11 +93,7 @@ func TestValidateValuesFileSchemaFailureButWithSkipSchemaValidation(t *testing.T
createTestingSchema(t, tmpdir) createTestingSchema(t, tmpdir)
valfile := filepath.Join(tmpdir, "values.yaml") valfile := filepath.Join(tmpdir, "values.yaml")
require.NoError(t, validateValuesFile(valfile, map[string]any{}, true), "expected values file to pass parsing because of skipSchemaValidation")
err := validateValuesFile(valfile, map[string]any{}, true)
if err != nil {
t.Fatal("expected values file to pass parsing because of skipSchemaValidation")
}
} }
func TestValidateValuesFileSchemaOverrides(t *testing.T) { func TestValidateValuesFileSchemaOverrides(t *testing.T) {
@ -118,9 +105,7 @@ func TestValidateValuesFileSchemaOverrides(t *testing.T) {
createTestingSchema(t, tmpdir) createTestingSchema(t, tmpdir)
valfile := filepath.Join(tmpdir, "values.yaml") valfile := filepath.Join(tmpdir, "values.yaml")
if err := validateValuesFile(valfile, overrides, false); err != nil { require.NoErrorf(t, validateValuesFile(valfile, overrides, false), "Failed validation")
t.Fatalf("Failed validation with %s", err)
}
} }
func TestValidateValuesFile(t *testing.T) { func TestValidateValuesFile(t *testing.T) {
@ -157,13 +142,10 @@ func TestValidateValuesFile(t *testing.T) {
err := validateValuesFile(valfile, tt.overrides, false) err := validateValuesFile(valfile, tt.overrides, false)
switch { if tt.errorMessage == "" {
case err != nil && tt.errorMessage == "": require.NoErrorf(t, err, "Failed validation with")
t.Errorf("Failed validation with %s", err) } else {
case err == nil && tt.errorMessage != "": assert.ErrorContains(t, err, tt.errorMessage)
t.Error("expected values file to fail parsing")
case err != nil && tt.errorMessage != "":
assert.ErrorContains(t, err, tt.errorMessage, "Failed with unexpected error")
} }
}) })
} }
@ -172,8 +154,6 @@ func TestValidateValuesFile(t *testing.T) {
func createTestingSchema(t *testing.T, dir string) string { func createTestingSchema(t *testing.T, dir string) string {
t.Helper() t.Helper()
schemafile := filepath.Join(dir, "values.schema.json") schemafile := filepath.Join(dir, "values.schema.json")
if err := os.WriteFile(schemafile, []byte(testSchema), 0o700); err != nil { require.NoErrorf(t, os.WriteFile(schemafile, []byte(testSchema), 0o700), "Failed to write schema to tmpdir")
t.Fatalf("Failed to write schema to tmpdir: %s", err)
}
return schemafile return schemafile
} }

6
pkg/cmd/install_test.go
Unescape View File

@ -23,6 +23,8 @@ import (
"path/filepath" "path/filepath"
"testing" "testing"
"github.com/stretchr/testify/require"
"helm.sh/helm/v4/pkg/repo/v1/repotest" "helm.sh/helm/v4/pkg/repo/v1/repotest"
) )
@ -39,9 +41,7 @@ func TestInstall(t *testing.T) {
})) }))
defer srv2.Close() defer srv2.Close()
if err := srv.LinkIndices(); err != nil { require.NoError(t, srv.LinkIndices())
t.Fatal(err)
}
repoFile := filepath.Join(srv.Root(), "repositories.yaml") repoFile := filepath.Join(srv.Root(), "repositories.yaml")

48
pkg/cmd/plugin_test.go
Unescape View File

@ -72,14 +72,10 @@ func TestManuallyProcessArgs(t *testing.T) {
known, unknown := manuallyProcessArgs(input) known, unknown := manuallyProcessArgs(input)
for i, k := range known { for i, k := range known {
if k != expectKnown[i] { assert.Equal(t, expectKnown[i], k, "expected known flag %d to be %q, got %q", i, expectKnown[i], k)
t.Errorf("expected known flag %d to be %q, got %q", i, expectKnown[i], k)
}
} }
for i, k := range unknown { for i, k := range unknown {
if k != expectUnknown[i] { assert.Equal(t, expectUnknown[i], k, "expected unknown flag %d to be %q, got %q", i, expectUnknown[i], k)
t.Errorf("expected unknown flag %d to be %q, got %q", i, expectUnknown[i], k)
}
} }
} }
@ -130,23 +126,17 @@ func TestLoadCLIPlugins(t *testing.T) {
pluginCmd := pluginCmds[i] pluginCmd := pluginCmds[i]
t.Run(fmt.Sprintf("%s-%d", pluginCmd.Name(), i), func(t *testing.T) { t.Run(fmt.Sprintf("%s-%d", pluginCmd.Name(), i), func(t *testing.T) {
out.Reset() out.Reset()
if pluginCmd.Use != tt.use { assert.Equal(t, tt.use, pluginCmd.Use, "%d: Expected Use=%q, got %q", i, tt.use, pluginCmd.Use)
t.Errorf("%d: Expected Use=%q, got %q", i, tt.use, pluginCmd.Use) assert.Equal(t, tt.short, pluginCmd.Short, "%d: Expected Use=%q, got %q", i, tt.short, pluginCmd.Short)
} assert.Equal(t, tt.long, pluginCmd.Long, "%d: Expected Use=%q, got %q", i, tt.long, pluginCmd.Long)
if pluginCmd.Short != tt.short {
t.Errorf("%d: Expected Use=%q, got %q", i, tt.short, pluginCmd.Short)
}
if pluginCmd.Long != tt.long {
t.Errorf("%d: Expected Use=%q, got %q", i, tt.long, pluginCmd.Long)
}
// Currently, plugins assume a Linux subsystem. Skip the execution // Currently, plugins assume a Linux subsystem. Skip the execution
// tests until this is fixed // tests until this is fixed
if runtime.GOOS != "windows" { if runtime.GOOS != "windows" {
if err := pluginCmd.RunE(pluginCmd, tt.args); err != nil { if err := pluginCmd.RunE(pluginCmd, tt.args); err != nil {
if assert.Positive(t, tt.code, "Error running %s: %+v", tt.use, err) { if assert.Positive(t, tt.code, "Error running %s", tt.use) {
var cerr CommandError var cerr CommandError
require.ErrorAs(t, err, &cerr, "Expected %s to return pluginError: got %v(%T)", tt.use, err, err) require.ErrorAs(t, err, &cerr, "Expected %s to return pluginError", tt.use)
assert.Equalf(t, tt.code, cerr.ExitCode, "Expected %s to return %d: got %d", tt.use, tt.code, cerr.ExitCode) assert.Equalf(t, tt.code, cerr.ExitCode, "Expected %s to return %d: got %d", tt.use, tt.code, cerr.ExitCode)
} }
} }
@ -190,31 +180,23 @@ func TestLoadPluginsWithSpace(t *testing.T) {
plugins := cmd.Commands() plugins := cmd.Commands()
if len(plugins) != len(tests) { require.Len(t, plugins, len(tests), "Expected %d plugins, got %d", len(tests), len(plugins))
t.Fatalf("Expected %d plugins, got %d", len(tests), len(plugins))
}
for i := range plugins { for i := range plugins {
out.Reset() out.Reset()
tt := tests[i] tt := tests[i]
pp := plugins[i] pp := plugins[i]
if pp.Use != tt.use { assert.Equal(t, tt.use, pp.Use, "%d: Expected Use=%q, got %q", i, tt.use, pp.Use)
t.Errorf("%d: Expected Use=%q, got %q", i, tt.use, pp.Use) assert.Equal(t, tt.short, pp.Short, "%d: Expected Use=%q, got %q", i, tt.short, pp.Short)
} assert.Equal(t, tt.long, pp.Long, "%d: Expected Use=%q, got %q", i, tt.long, pp.Long)
if pp.Short != tt.short {
t.Errorf("%d: Expected Use=%q, got %q", i, tt.short, pp.Short)
}
if pp.Long != tt.long {
t.Errorf("%d: Expected Use=%q, got %q", i, tt.long, pp.Long)
}
// Currently, plugins assume a Linux subsystem. Skip the execution // Currently, plugins assume a Linux subsystem. Skip the execution
// tests until this is fixed // tests until this is fixed
if runtime.GOOS != "windows" { if runtime.GOOS != "windows" {
if err := pp.RunE(pp, tt.args); err != nil { if err := pp.RunE(pp, tt.args); err != nil {
if assert.Positive(t, tt.code, "Error running %s: %+v", tt.use, err) { if assert.Positive(t, tt.code, "Error running %s", tt.use) {
var cerr CommandError var cerr CommandError
require.ErrorAs(t, err, &cerr, "Expected %s to return pluginError: got %v(%T)", tt.use, err, err) require.ErrorAs(t, err, &cerr, "Expected %s to return pluginError", tt.use)
assert.Equalf(t, tt.code, cerr.ExitCode, "Expected %s to return %d: got %d", tt.use, tt.code, cerr.ExitCode) assert.Equalf(t, tt.code, cerr.ExitCode, "Expected %s to return %d: got %d", tt.use, tt.code, cerr.ExitCode)
} }
} }
@ -334,9 +316,7 @@ func TestLoadCLIPlugins_HelmNoPlugins(t *testing.T) {
loadCLIPlugins(cmd, out) loadCLIPlugins(cmd, out)
plugins := cmd.Commands() plugins := cmd.Commands()
if len(plugins) != 0 { require.Empty(t, plugins, "Expected 0 plugins, got %d", len(plugins))
t.Fatalf("Expected 0 plugins, got %d", len(plugins))
}
} }
func TestPluginCmdsCompletion(t *testing.T) { func TestPluginCmdsCompletion(t *testing.T) {

53
pkg/getter/getter_test.go
Unescape View File

@ -19,6 +19,9 @@ import (
"testing" "testing"
"time" "time"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"helm.sh/helm/v4/pkg/cli" "helm.sh/helm/v4/pkg/cli"
) )
@ -30,9 +33,7 @@ func TestProvider(t *testing.T) {
func(_ ...Option) (Getter, error) { return nil, nil }, func(_ ...Option) (Getter, error) { return nil, nil },
} }
if !p.Provides("three") { assert.True(t, p.Provides("three"), "Expected provider to provide three")
t.Error("Expected provider to provide three")
}
} }
func TestProviders(t *testing.T) { func TestProviders(t *testing.T) {
@ -41,34 +42,25 @@ func TestProviders(t *testing.T) {
{[]string{"two", "four"}, func(_ ...Option) (Getter, error) { return nil, nil }}, {[]string{"two", "four"}, func(_ ...Option) (Getter, error) { return nil, nil }},
} }
if _, err := ps.ByScheme("one"); err != nil { _, err := ps.ByScheme("one")
t.Error(err) require.NoError(t, err)
} _, err = ps.ByScheme("four")
if _, err := ps.ByScheme("four"); err != nil { require.NoError(t, err)
t.Error(err)
}
if _, err := ps.ByScheme("five"); err == nil { _, err = ps.ByScheme("five")
t.Error("Did not expect handler for five") assert.Error(t, err, "Did not expect handler for five")
}
} }
func TestProvidersWithTimeout(t *testing.T) { func TestProvidersWithTimeout(t *testing.T) {
want := time.Hour want := time.Hour
getters := Getters(WithTimeout(want)) getters := Getters(WithTimeout(want))
getter, err := getters.ByScheme("http") getter, err := getters.ByScheme("http")
if err != nil { require.NoError(t, err)
t.Error(err)
}
httpGetter := getter.(*HTTPGetter) httpGetter := getter.(*HTTPGetter)
client, err := httpGetter.httpClient(httpGetter.opts) client, err := httpGetter.httpClient(httpGetter.opts)
if err != nil { require.NoError(t, err)
t.Error(err)
}
got := client.Timeout got := client.Timeout
if got != want { assert.Equal(t, want, got, "Expected %q, got %q", want, got)
t.Errorf("Expected %q, got %q", want, got)
}
} }
func TestAll(t *testing.T) { func TestAll(t *testing.T) {
@ -76,13 +68,10 @@ func TestAll(t *testing.T) {
env.PluginsDirectory = pluginDir env.PluginsDirectory = pluginDir
all := All(env) all := All(env)
if len(all) != 4 { assert.Len(t, all, 4, "expected 4 providers (default plus three plugins), got %d", len(all))
t.Errorf("expected 4 providers (default plus three plugins), got %d", len(all))
}
if _, err := all.ByScheme("test2"); err != nil { _, err := all.ByScheme("test2")
t.Error(err) assert.NoError(t, err)
}
} }
func TestByScheme(t *testing.T) { func TestByScheme(t *testing.T) {
@ -90,10 +79,8 @@ func TestByScheme(t *testing.T) {
env.PluginsDirectory = pluginDir env.PluginsDirectory = pluginDir
g := All(env) g := All(env)
if _, err := g.ByScheme("test"); err != nil { _, err := g.ByScheme("test")
t.Error(err) require.NoError(t, err)
} _, err = g.ByScheme("https")
if _, err := g.ByScheme("https"); err != nil { assert.NoError(t, err)
t.Error(err)
}
} }

53
pkg/storage/driver/records_test.go
Unescape View File

@ -20,6 +20,9 @@ import (
"reflect" "reflect"
"testing" "testing"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"helm.sh/helm/v4/pkg/release/common" "helm.sh/helm/v4/pkg/release/common"
) )
@ -50,10 +53,11 @@ func TestRecordsAdd(t *testing.T) {
} }
for _, tt := range tests { for _, tt := range tests {
if err := rs.Add(tt.rec); err != nil { err := rs.Add(tt.rec)
if !tt.ok { if !tt.ok {
t.Fatalf("failed: %q: %s\n", tt.desc, err) require.NoError(t, err, "failed: %q:", tt.desc)
} } else {
require.Error(t, err)
} }
} }
} }
@ -77,23 +81,18 @@ func TestRecordsRemove(t *testing.T) {
startLen := rs.Len() startLen := rs.Len()
for _, tt := range tests { for _, tt := range tests {
if r := rs.Remove(tt.key); r == nil { r := rs.Remove(tt.key)
if !tt.ok { if tt.ok {
t.Fatalf("Failed to %q (key = %s). Expected nil, got %v", require.Nil(t, r, "Failed to %q (key = %s). Expected nil, got %v", tt.desc, tt.key, r)
tt.desc, } else {
tt.key, require.NotNil(t, r)
r,
)
}
} }
} }
// We expect the total number of records will be less now than there were // We expect the total number of records will be less now than there were
// when we started. // when we started.
endLen := rs.Len() endLen := rs.Len()
if endLen >= startLen { assert.Lessf(t, endLen, startLen, "expected ending length %d to be less than starting length %d", endLen, startLen)
t.Errorf("expected ending length %d to be less than starting length %d", endLen, startLen)
}
} }
func TestRecordsRemoveAt(t *testing.T) { func TestRecordsRemoveAt(t *testing.T) {
@ -102,14 +101,10 @@ func TestRecordsRemoveAt(t *testing.T) {
newRecord("rls-a.v2", releaseStub("rls-a", 2, "default", common.StatusDeployed)), newRecord("rls-a.v2", releaseStub("rls-a", 2, "default", common.StatusDeployed)),
}) })
if len(rs) != 2 { require.Len(t, rs, 2, "Expected len=2 for mock")
t.Fatal("Expected len=2 for mock")
}
rs.Remove("rls-a.v1") rs.Remove("rls-a.v1")
if len(rs) != 1 { require.Len(t, rs, 1, "Expected length of rs to be 1, got %d", len(rs))
t.Fatalf("Expected length of rs to be 1, got %d", len(rs))
}
} }
func TestRecordsGet(t *testing.T) { func TestRecordsGet(t *testing.T) {
@ -137,9 +132,7 @@ func TestRecordsGet(t *testing.T) {
for _, tt := range tests { for _, tt := range tests {
got := rs.Get(tt.key) got := rs.Get(tt.key)
if !reflect.DeepEqual(tt.rec, got) { require.Truef(t, reflect.DeepEqual(tt.rec, got), "Expected %v, got %v", tt.rec, got)
t.Fatalf("Expected %v, got %v", tt.rec, got)
}
} }
} }
@ -168,9 +161,7 @@ func TestRecordsIndex(t *testing.T) {
for _, tt := range tests { for _, tt := range tests {
got, _ := rs.Index(tt.key) got, _ := rs.Index(tt.key)
if got != tt.sort { require.Equal(t, tt.sort, got, "Expected %d, got %d", tt.sort, got)
t.Fatalf("Expected %d, got %d", tt.sort, got)
}
} }
} }
@ -199,9 +190,7 @@ func TestRecordsExists(t *testing.T) {
for _, tt := range tests { for _, tt := range tests {
got := rs.Exists(tt.key) got := rs.Exists(tt.key)
if got != tt.ok { require.Equal(t, tt.ok, got, "Expected %t, got %t", tt.ok, got)
t.Fatalf("Expected %t, got %t", tt.ok, got)
}
} }
} }
@ -233,8 +222,6 @@ func TestRecordsReplace(t *testing.T) {
for _, tt := range tests { for _, tt := range tests {
got := rs.Replace(tt.key, tt.rec) got := rs.Replace(tt.key, tt.rec)
if !reflect.DeepEqual(tt.expected, got) { require.Truef(t, reflect.DeepEqual(tt.expected, got), "Expected %v, got %v", tt.expected, got)
t.Fatalf("Expected %v, got %v", tt.expected, got)
}
} }
} }

Write Preview
Loading…
Cancel
Save