Merge branch 'helm:main' into feature/enhance-dry-run-for-helm-4

pull/31616/head
MrJack 5 days ago committed by GitHub
commit eeb4cbdaa8
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194

@ -33,7 +33,7 @@ jobs:
persist-credentials: false
- name: "Run analysis"
uses: ossf/scorecard-action@4eaacf0543bb3f2c246792bd56e8cdeffafb205a # v2.4.3
uses: ossf/scorecard-action@2d1146689b8cda280b9bc96326124645441f03bc # v2.4.4
with:
results_file: results.sarif
results_format: sarif

@ -39,14 +39,14 @@ require (
golang.org/x/term v0.45.0
golang.org/x/text v0.40.0
gopkg.in/yaml.v3 v3.0.1 // indirect
k8s.io/api v0.36.2
k8s.io/apiextensions-apiserver v0.36.2
k8s.io/apimachinery v0.36.2
k8s.io/apiserver v0.36.2
k8s.io/cli-runtime v0.36.2
k8s.io/client-go v0.36.2
k8s.io/api v0.36.3
k8s.io/apiextensions-apiserver v0.36.3
k8s.io/apimachinery v0.36.3
k8s.io/apiserver v0.36.3
k8s.io/cli-runtime v0.36.3
k8s.io/client-go v0.36.3
k8s.io/klog/v2 v2.140.0
k8s.io/kubectl v0.36.2
k8s.io/kubectl v0.36.3
oras.land/oras-go/v2 v2.6.2
sigs.k8s.io/controller-runtime v0.24.1
sigs.k8s.io/kustomize/kyaml v0.21.1
@ -172,11 +172,11 @@ require (
gopkg.in/evanphx/json-patch.v4 v4.13.0 // indirect
gopkg.in/inf.v0 v0.9.1 // indirect
gopkg.in/yaml.v2 v2.4.0 // indirect
k8s.io/component-base v0.36.2 // indirect
k8s.io/component-base v0.36.3 // indirect
k8s.io/kube-openapi v0.0.0-20260317180543-43fb72c5454a // indirect
k8s.io/utils v0.0.0-20260507154919-ff6756f316d2 // indirect
sigs.k8s.io/json v0.0.0-20250730193827-2d320260d730 // indirect
sigs.k8s.io/kustomize/api v0.21.1 // indirect
sigs.k8s.io/randfill v1.0.0 // indirect
sigs.k8s.io/structured-merge-diff/v6 v6.3.2 // indirect
sigs.k8s.io/structured-merge-diff/v6 v6.3.3 // indirect
)

@ -487,26 +487,26 @@ gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ=
gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
k8s.io/api v0.36.2 h1:TF6YDLIzKfccK7cq9YpTcGX8TJmEkHVRv78DM51fRYY=
k8s.io/api v0.36.2/go.mod h1:F4LbMO4brjZYh7yFkXWhynSvtB7YauxV4c+HHkNRGNg=
k8s.io/apiextensions-apiserver v0.36.2 h1:3O5gqOj/dt2XWWbpMe+TXWpE9yU6pjM/tXxtHHJT/K4=
k8s.io/apiextensions-apiserver v0.36.2/go.mod h1:cL1tBWe8XSaP1H30iWKGo7hf6iAUUUJPEU70dskmAnA=
k8s.io/apimachinery v0.36.2 h1:0PE/W/WNy1UX61NLbXY5TMbJ6UwLL6E6lAPkYrKFxbQ=
k8s.io/apimachinery v0.36.2/go.mod h1:fvf/HOLXq9RId0rnDIbN1OEBvHXdQbLMM8nu0LcBUf4=
k8s.io/apiserver v0.36.2 h1:6vMnkmHZPeBloNkHUhmZYq7Ylv8WIB8xjyEl+eSt26E=
k8s.io/apiserver v0.36.2/go.mod h1:9PoQ2ikCytrZyZg11mGhLEF5m8Rgsb5FJmYJ4Wvnl1k=
k8s.io/cli-runtime v0.36.2 h1:CconTvEeV4DJs4ZX3HQKCFbFRGsm6OtuBM9yjmMP2VM=
k8s.io/cli-runtime v0.36.2/go.mod h1:LddcjiMf4YlnHO7c1Y7rEtDqL84FyiYVLco7V679GUU=
k8s.io/client-go v0.36.2 h1:bfgxmFKc9CgqsgX4xKLAAdmTQlWee7Ob/HlDOrJ5TBI=
k8s.io/client-go v0.36.2/go.mod h1:1vgO4OAlfPnoLcb+Rze2GF5rAr14w8qjrYMoyXJzQj0=
k8s.io/component-base v0.36.2 h1:Z0VH80O7Ng0HDZnZj3WRR3urEGa0kTwmO8CwEwjVK1w=
k8s.io/component-base v0.36.2/go.mod h1:mGfFOA7Gwpdm1VW2cwSQYbiDIlz8GD2WGwH88QSeCyA=
k8s.io/api v0.36.3 h1:NxB+05W2UGqXWFXcLO0RB5cnqnUPP5v5sVlaOH0Iz4w=
k8s.io/api v0.36.3/go.mod h1:JzLQKqRHC5+I8RVj/lS3lCg0mg6nWI9Fo/Sk3ElxHzg=
k8s.io/apiextensions-apiserver v0.36.3 h1:dPmOAPhwTtqb1bTxbFPsy18KHPhktQeO3WUPXunZIB0=
k8s.io/apiextensions-apiserver v0.36.3/go.mod h1:KTXFqgXiuw2pRoL+Wpmttqc+up9Xt/GohadPWeLLOa4=
k8s.io/apimachinery v0.36.3 h1:PkzMRBRG8joFD8EhCuQAtNPvJlxb82FwplP26HIzvAM=
k8s.io/apimachinery v0.36.3/go.mod h1:cTSjBWgPe/6CQyBKzY/hDIRWCQQQeK0mfLbml0UYFHE=
k8s.io/apiserver v0.36.3 h1:MGSg2SkdfuytiDEcRylT5mQFmmSsbx90XFUO67Y4bsQ=
k8s.io/apiserver v0.36.3/go.mod h1:fVH7zv9EUNUA7Fl7LtDKh8aB9W7u1VQPSGtWV5SjUxg=
k8s.io/cli-runtime v0.36.3 h1:g+eJ+M1sYpnNYp/q5fzaw2KejIL0Q7DH+xFl6YVoL4U=
k8s.io/cli-runtime v0.36.3/go.mod h1:hZpAqK8nSFXvvLaVCbzUPVp8e9TRLSTCfpNzMt7s3tE=
k8s.io/client-go v0.36.3 h1:M4JdVzXxYcZk4fGpfDdYnxSwhLKWCFoQsHW6t+z8Hfg=
k8s.io/client-go v0.36.3/go.mod h1:gcPwr0c87vjjG6HB6pWEqOeuYVoXSsREjzux2j6GF30=
k8s.io/component-base v0.36.3 h1:vc/UFvPCkW0irPz84LAodAL1j3f4xktPM6dDJIEheAY=
k8s.io/component-base v0.36.3/go.mod h1:hZbNFG+gCMl9EbykDGEu73feKP9/Cq6JsV4pTo9GTO8=
k8s.io/klog/v2 v2.140.0 h1:Tf+J3AH7xnUzZyVVXhTgGhEKnFqye14aadWv7bzXdzc=
k8s.io/klog/v2 v2.140.0/go.mod h1:o+/RWfJ6PwpnFn7OyAG3QnO47BFsymfEfrz6XyYSSp0=
k8s.io/kube-openapi v0.0.0-20260317180543-43fb72c5454a h1:xCeOEAOoGYl2jnJoHkC3hkbPJgdATINPMAxaynU2Ovg=
k8s.io/kube-openapi v0.0.0-20260317180543-43fb72c5454a/go.mod h1:uGBT7iTA6c6MvqUvSXIaYZo9ukscABYi2btjhvgKGZ0=
k8s.io/kubectl v0.36.2 h1:rpUGGpeL09XVOLep2yle5jrtk//JA1L6ZHfkQQtVEwk=
k8s.io/kubectl v0.36.2/go.mod h1:gVbQ3B/yb4bSR2ggQ7rd0W6icUSWs7sduH4e16Vii+0=
k8s.io/kubectl v0.36.3 h1:TesKp+XYQEjPYoFvuobcVnuvira2+/xAVlq//+kksaI=
k8s.io/kubectl v0.36.3/go.mod h1:W+NEb1CzBGmoaI1Nrpn2ETo9omNBl0AsyxnnMT40N6E=
k8s.io/utils v0.0.0-20260507154919-ff6756f316d2 h1:wU4tMEhLGgIbLvXQb1cfN+EcM0wf7zC6CPF+C79jroc=
k8s.io/utils v0.0.0-20260507154919-ff6756f316d2/go.mod h1:xDxuJ0whA3d0I4mf/C4ppKHxXynQ+fxnkmQH0vTHnuk=
oras.land/oras-go/v2 v2.6.2 h1:N04RXngAp1LJKTG6ifz3xHPipasEkWr+hFmInja5YKo=
@ -521,7 +521,7 @@ sigs.k8s.io/kustomize/kyaml v0.21.1 h1:IVlbmhC076nf6foyL6Taw4BkrLuEsXUXNpsE+ScX7
sigs.k8s.io/kustomize/kyaml v0.21.1/go.mod h1:hmxADesM3yUN2vbA5z1/YTBnzLJ1dajdqpQonwBL1FQ=
sigs.k8s.io/randfill v1.0.0 h1:JfjMILfT8A6RbawdsK2JXGBR5AQVfd+9TbzrlneTyrU=
sigs.k8s.io/randfill v1.0.0/go.mod h1:XeLlZ/jmk4i1HRopwe7/aU3H5n1zNUcX6TM94b3QxOY=
sigs.k8s.io/structured-merge-diff/v6 v6.3.2 h1:kwVWMx5yS1CrnFWA/2QHyRVJ8jM6dBA80uLmm0wJkk8=
sigs.k8s.io/structured-merge-diff/v6 v6.3.2/go.mod h1:M3W8sfWvn2HhQDIbGWj3S099YozAsymCo/wrT5ohRUE=
sigs.k8s.io/structured-merge-diff/v6 v6.3.3 h1:u08YRbVUi59ri4YD6cg0UqNM4Dimn0sIl+wldcx5PYw=
sigs.k8s.io/structured-merge-diff/v6 v6.3.3/go.mod h1:M3W8sfWvn2HhQDIbGWj3S099YozAsymCo/wrT5ohRUE=
sigs.k8s.io/yaml v1.6.0 h1:G8fkbMSAFqgEFgh4b1wmtzDnioxFCUgTZhlbj5P9QYs=
sigs.k8s.io/yaml v1.6.0/go.mod h1:796bPqUfzR/0jLAl6XjHl3Ck7MiyVv8dbTdyT3/pMf4=

@ -114,7 +114,7 @@ func TestBadValuesV3(t *testing.T) {
func TestBadCrdFileV3(t *testing.T) {
var values map[string]any
m := RunAll(badCrdFileDir, values, namespace).Messages
assert.Lenf(t, m, 2, "All didn't fail with expected errors, got %#v", m)
require.Lenf(t, m, 2, "All didn't fail with expected errors, got %#v", m)
require.ErrorContains(t, m[0].Err, "apiVersion is not in 'apiextensions.k8s.io'")
assert.ErrorContains(t, m[1].Err, "object kind is not 'CustomResourceDefinition'")
}
@ -122,8 +122,7 @@ func TestBadCrdFileV3(t *testing.T) {
func TestGoodChart(t *testing.T) {
var values map[string]any
m := RunAll(goodChartDir, values, namespace).Messages
if len(m) != 0 {
t.Error("All returned linter messages when it shouldn't have")
if !assert.Empty(t, m, "All returned linter messages when it shouldn't have") {
for i, msg := range m {
t.Logf("Message %d: %s", i, msg)
}
@ -143,13 +142,12 @@ func TestHelmCreateChart(t *testing.T) {
// Note: we test with strict=true here, even though others have
// strict = false.
m := RunAll(createdChart, values, namespace, WithSkipSchemaValidation(true)).Messages
if ll := len(m); ll != 1 {
t.Errorf("All should have had exactly 1 error. Got %d", ll)
if !assert.Len(t, m, 1, "All should have had exactly 1 error") {
for i, msg := range m {
t.Logf("Message %d: %s", i, msg.Error())
}
} else if msg := m[0].Err.Error(); !strings.Contains(msg, "icon is recommended") {
t.Errorf("Unexpected lint error: %s", msg)
} else {
assert.ErrorContains(t, m[0].Err, "icon is recommended")
}
}
@ -192,8 +190,7 @@ func TestHelmCreateChart_CheckDeprecatedWarnings(t *testing.T) {
func TestSubChartValuesChart(t *testing.T) {
var values map[string]any
m := RunAll(subChartValuesDir, values, namespace).Messages
if len(m) != 0 {
t.Error("All returned linter messages when it shouldn't have")
if !assert.Empty(t, m, "All returned linter messages when it shouldn't have") {
for i, msg := range m {
t.Logf("Message %d: %s", i, msg)
}

@ -22,6 +22,7 @@ import (
"testing"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"helm.sh/helm/v4/internal/chart/v3/lint/support"
)
@ -33,7 +34,7 @@ func TestInvalidCrdsDir(t *testing.T) {
Crds(&linter)
res := linter.Messages
assert.Len(t, res, 1)
require.Len(t, res, 1)
assert.ErrorContains(t, res[0].Err, "not a directory")
}

@ -199,12 +199,12 @@ func TestDeprecatedAPIFails(t *testing.T) {
linter := support.Linter{ChartDir: filepath.Join(tmpdir, mychart.Name())}
Templates(&linter, values, namespace, strict)
if l := len(linter.Messages); l != 1 {
if !assert.Len(t, linter.Messages, 1) {
for i, msg := range linter.Messages {
t.Logf("Message %d: %s", i, msg)
}
t.Fatalf("Expected 1 lint error, got %d", l)
}
require.Len(t, linter.Messages, 1, "Expected 1 lint error")
var err deprecatedAPIError
require.ErrorAs(t, linter.Messages[0].Err, &err, "Expected error to be of type deprecatedAPIError")
@ -252,8 +252,7 @@ func TestStrictTemplateParsingMapError(t *testing.T) {
ChartDir: filepath.Join(dir, ch.Metadata.Name),
}
Templates(linter, ch.Values, namespace, strict)
if len(linter.Messages) != 0 {
t.Errorf("expected zero messages, got %d", len(linter.Messages))
if !assert.Empty(t, linter.Messages, "expected zero messages") {
for i, msg := range linter.Messages {
t.Logf("Message %d: %q", i, msg)
}
@ -376,12 +375,12 @@ func TestEmptyWithCommentsManifests(t *testing.T) {
linter := support.Linter{ChartDir: filepath.Join(tmpdir, mychart.Name())}
Templates(&linter, values, namespace, strict)
if l := len(linter.Messages); l > 0 {
if !assert.Empty(t, linter.Messages) {
for i, msg := range linter.Messages {
t.Logf("Message %d: %s", i, msg)
}
t.Fatalf("Expected 0 lint errors, got %d", l)
}
require.Empty(t, linter.Messages, "Expected 0 lint errors")
}
func TestValidateListAnnotations(t *testing.T) {
md := &k8sYamlStruct{

@ -58,11 +58,11 @@ func TestRunLinterRule(t *testing.T) {
func TestMessage(t *testing.T) {
m := Message{ErrorSev, "Chart.yaml", errors.New("Foo")}
require.EqualErrorf(t, m, "[ERROR] Chart.yaml: Foo", "Unexpected output: %s", m.Error())
require.EqualError(t, m, "[ERROR] Chart.yaml: Foo")
m = Message{WarningSev, "templates/", errors.New("Bar")}
require.EqualErrorf(t, m, "[WARNING] templates/: Bar", "Unexpected output: %s", m.Error())
require.EqualError(t, m, "[WARNING] templates/: Bar")
m = Message{InfoSev, "templates/rc.yaml", errors.New("FooBar")}
assert.EqualErrorf(t, m, "[INFO] templates/rc.yaml: FooBar", "Unexpected output: %s", m.Error())
assert.EqualError(t, m, "[INFO] templates/rc.yaml: FooBar")
}

@ -25,7 +25,6 @@ import (
"log"
"os"
"path/filepath"
"reflect"
"runtime"
"strings"
"testing"
@ -201,11 +200,9 @@ icon: https://example.com/64x64.png
require.NoError(t, err, "Expected good files to be loaded")
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))
assert.Len(t, c.Raw, 5, "Expected 5 files")
assert.True(t, bytes.Equal(c.Schema, []byte("type: Values")), "Expected chart schema to be populated with default values")
assert.Len(t, c.Templates, 2, "Expected number of templates == 2, got %d", len(c.Templates))
assert.Len(t, c.Templates, 2, "Expected 2 templates")
_, err = LoadFiles([]*archive.BufferedFile{})
require.Error(t, err, "Expected err to be non-nil")
@ -417,7 +414,7 @@ foo:
t.Run(testName, func(tt *testing.T) {
values, err := LoadValues(bytes.NewReader(testCase.data))
require.NoError(tt, err)
assert.Truef(tt, reflect.DeepEqual(values, testCase.expctedValues), "Expected values: %v, got %v", testCase.expctedValues, values)
assert.Equalf(tt, testCase.expctedValues, values, "Expected values: %v, got %v", testCase.expctedValues, values)
})
}
}
@ -445,16 +442,13 @@ func TestMergeValuesV3(t *testing.T) {
}
testMap := MergeMaps(flatMap, nestedMap)
equal := reflect.DeepEqual(testMap, nestedMap)
assert.True(t, equal, "Expected a nested map to overwrite a flat value. Expected: %v, got %v", nestedMap, testMap)
assert.Equal(t, testMap, nestedMap, "Expected a nested map to overwrite a flat value. Expected: %v, got %v", nestedMap, testMap)
testMap = MergeMaps(nestedMap, flatMap)
equal = reflect.DeepEqual(testMap, flatMap)
assert.True(t, equal, "Expected a flat value to overwrite a map. Expected: %v, got %v", flatMap, testMap)
assert.Equal(t, testMap, flatMap, "Expected a flat value to overwrite a map. Expected: %v, got %v", flatMap, testMap)
testMap = MergeMaps(nestedMap, anotherNestedMap)
equal = reflect.DeepEqual(testMap, anotherNestedMap)
assert.True(t, equal, "Expected a nested map to overwrite another nested map. Expected: %v, got %v", anotherNestedMap, testMap)
assert.Equal(t, testMap, anotherNestedMap, "Expected a nested map to overwrite another nested map. Expected: %v, got %v", anotherNestedMap, testMap)
testMap = MergeMaps(anotherFlatMap, anotherNestedMap)
expectedMap := map[string]any{
@ -465,26 +459,23 @@ func TestMergeValuesV3(t *testing.T) {
"awesome": "stuff",
},
}
equal = reflect.DeepEqual(testMap, expectedMap)
assert.True(t, equal, "Expected a map with different keys to merge properly with another map. Expected: %v, got %v", expectedMap, testMap)
assert.Equal(t, expectedMap, testMap, "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) {
t.Helper()
require.NotEmpty(t, c.Name(), "No chart metadata found on %v", c)
t.Logf("Verifying chart %s", c.Name())
assert.Len(t, c.Templates, 1, "Expected 1 template, got %d", len(c.Templates))
assert.Len(t, c.Templates, 1, "Expected 1 template")
numfiles := 6
if len(c.Files) != numfiles {
t.Errorf("Expected %d extra files, got %d", numfiles, len(c.Files))
if !assert.Len(t, c.Files, numfiles, "Expected %d extra files", numfiles) {
for _, n := range c.Files {
t.Logf("\t%s", n.Name)
}
}
if len(c.Dependencies()) != 2 {
t.Errorf("Expected 2 dependencies, got %d (%v)", len(c.Dependencies()), c.Dependencies())
if !assert.Len(t, c.Dependencies(), 2, "Expected 2 dependencies") {
for _, d := range c.Dependencies() {
t.Logf("\tSubchart: %s\n", d.Name())
}
@ -509,7 +500,7 @@ func verifyChart(t *testing.T, c *chart.Chart) {
func verifyDependencies(t *testing.T, c *chart.Chart) {
t.Helper()
assert.Len(t, c.Metadata.Dependencies, 2, "Expected 2 dependencies, got %d", len(c.Metadata.Dependencies))
assert.Len(t, c.Metadata.Dependencies, 2, "Expected 2 dependencies")
tests := []*chart.Dependency{
{Name: "alpine", Version: "0.1.0", Repository: "https://example.com/charts"},
{Name: "mariner", Version: "4.3.2", Repository: "https://example.com/charts"},

@ -36,36 +36,21 @@ func TestLoadChartfile(t *testing.T) {
func verifyChartfile(t *testing.T, f *chart.Metadata, name string) {
t.Helper()
require.NotNil(t, f, "Failed verifyChartfile because f is nil")
assert.Equal(t, name, f.Name, "Expected %s, got %s", name, f.Name)
assert.Equal(t, "This is a frobnitz.", f.Description, "Unexpected description %q", f.Description)
assert.Equal(t, "1.2.3", f.Version, "Unexpected version %q", f.Version)
assert.Len(t, f.Maintainers, 2, "Expected 2 maintainers, got %d", len(f.Maintainers))
assert.Equal(t, "The Helm Team", f.Maintainers[0].Name, "Unexpected maintainer name.")
assert.Equal(t, "nobody@example.com", f.Maintainers[1].Email, "Unexpected maintainer email.")
require.Len(t, f.Sources, 1, "Unexpected number of sources")
assert.Equal(t, "https://example.com/foo/bar", f.Sources[0], "Expected https://example.com/foo/bar, got %s", f.Sources)
assert.Equal(t, "http://example.com", f.Home, "Unexpected home.")
assert.Equal(t, "https://example.com/64x64.png", f.Icon, "Unexpected icon: %q", f.Icon)
require.Len(t, f.Keywords, 3, "Unexpected keywords")
require.Len(t, f.Annotations, 2, "Unexpected annotations")
want, got := "extravalue", f.Annotations["extrakey"]
assert.Equalf(t, want, got, "Want %q, but got %q", want, got)
want, got = "anothervalue", f.Annotations["anotherkey"]
assert.Equalf(t, want, got, "Want %q, but got %q", want, got)
assert.Equal(t, "extravalue", f.Annotations["extrakey"])
assert.Equal(t, "anothervalue", f.Annotations["anotherkey"])
kk := []string{"frobnitz", "sprocket", "dodad"}
for i, k := range f.Keywords {

@ -101,7 +101,7 @@ func TestExpand(t *testing.T) {
require.NoError(t, err)
expectLen := 11
assert.Len(t, fis, expectLen, "Expected %d files, but got %d", expectLen, len(fis))
assert.Len(t, fis, expectLen, "Expected %d files", expectLen)
for _, fi := range fis {
expect, err := os.Stat(filepath.Join("testdata", "frobnitz", fi.Name()))
@ -154,7 +154,7 @@ func TestExpandFile(t *testing.T) {
require.NoError(t, err)
expectLen := 11
assert.Len(t, fis, expectLen, "Expected %d files, but got %d", expectLen, len(fis))
assert.Len(t, fis, expectLen, "Expected %d files", expectLen)
for _, fi := range fis {
expect, err := os.Stat(filepath.Join("testdata", "frobnitz", fi.Name()))

@ -69,9 +69,8 @@ func TestSave(t *testing.T) {
c2, err := loader.LoadFile(where)
require.NoError(t, err)
require.Equal(t, c.Name(), c2.Name(), "Expected chart archive to have %q, got %q", c.Name(), c2.Name())
if len(c2.Files) != 1 || c2.Files[0].Name != "scheherazade/shahryar.txt" {
t.Fatal("Files data did not match")
}
require.Len(t, c2.Files, 1, "Files data did not match")
require.Equal(t, "scheherazade/shahryar.txt", c2.Files[0].Name, "Files data did not match")
if !bytes.Equal(c.Schema, c2.Schema) {
indentation := 4

@ -67,10 +67,10 @@ func mockArchiveServer() *httptest.Server {
if !strings.HasSuffix(r.URL.Path, ".tar.gz") {
w.Header().Add("Content-Type", "text/html")
fmt.Fprintln(w, "broken")
return
} else {
w.Header().Add("Content-Type", "application/gzip")
fmt.Fprintln(w, "test")
}
w.Header().Add("Content-Type", "application/gzip")
fmt.Fprintln(w, "test")
}))
}
@ -221,22 +221,22 @@ func TestExtract(t *testing.T) {
expectedReadmePerm := os.FileMode(0o777 &^ currentUmask)
pluginYAMLFullPath := filepath.Join(tempDir, "plugin.yaml")
if info, err := os.Stat(pluginYAMLFullPath); err != nil {
info, err := os.Stat(pluginYAMLFullPath)
if err != nil {
require.NotErrorIs(t, err, fs.ErrNotExist, "Expected %s to exist but doesn't", pluginYAMLFullPath)
t.Fatal(err)
} else {
require.Equalf(t, expectedPluginYAMLPerm, info.Mode().Perm(), "Expected %s to have %o mode but has %o (umask: %o)",
pluginYAMLFullPath, expectedPluginYAMLPerm, info.Mode().Perm(), currentUmask)
}
require.NoError(t, err)
require.Equalf(t, expectedPluginYAMLPerm, info.Mode().Perm(), "Expected %s to have %o mode but has %o (umask: %o)",
pluginYAMLFullPath, expectedPluginYAMLPerm, info.Mode().Perm(), currentUmask)
readmeFullPath := filepath.Join(tempDir, "README.md")
if info, err := os.Stat(readmeFullPath); err != nil {
info, err = os.Stat(readmeFullPath)
if err != nil {
require.NotErrorIs(t, err, fs.ErrNotExist, "Expected %s to exist but doesn't", readmeFullPath)
t.Fatal(err)
} else {
require.Equalf(t, expectedReadmePerm, info.Mode().Perm(), "Expected %s to have %o mode but has %o (umask: %o)",
readmeFullPath, expectedReadmePerm, info.Mode().Perm(), currentUmask)
}
require.NoError(t, err)
require.Equalf(t, expectedReadmePerm, info.Mode().Perm(), "Expected %s to have %o mode but has %o (umask: %o)",
readmeFullPath, expectedReadmePerm, info.Mode().Perm(), currentUmask)
}
func TestCleanJoin(t *testing.T) {

@ -34,8 +34,6 @@ func TestIsRemoteHTTPArchive(t *testing.T) {
// Test with invalid extension and unreachable server
assert.False(t, isRemoteHTTPArchive("https://127.0.0.1:123/fake/plugin-1.2.3.notanarchive"), "Bad URL without valid extension should not succeed")
assert.True(t, isRemoteHTTPArchive(source), "Expected %q to be a valid archive URL", source)
assert.False(t, isRemoteHTTPArchive(source+"-not-an-extension"), "Expected media type match to fail")
}

@ -96,16 +96,14 @@ func TestVCSInstallerNonExistentVersion(t *testing.T) {
require.NoError(t, err)
// ensure a VCSInstaller was returned
_, ok := i.(*VCSInstaller)
require.True(t, ok, "expected a VCSInstaller")
require.IsType(t, &VCSInstaller{}, i, "expected a VCSInstaller")
if err := Install(i); err == nil {
t.Fatal("expected error for version does not exists, got none")
} else if strings.Contains(err.Error(), "Could not resolve host: github.com") {
err = Install(i)
require.Error(t, err, "expected error for version does not exists, got none")
if strings.Contains(err.Error(), "Could not resolve host: github.com") {
t.Skip("Unable to run test without Internet access")
} else {
require.EqualErrorf(t, err, fmt.Sprintf("requested version %q does not exist for plugin %q", version, source), "expected error for version does not exists")
}
require.EqualErrorf(t, err, fmt.Sprintf("requested version %q does not exist for plugin %q", version, source), "expected error for version does not exists")
}
func TestVCSInstallerUpdate(t *testing.T) {
ensure.HelmHome(t)
@ -116,19 +114,16 @@ func TestVCSInstallerUpdate(t *testing.T) {
require.NoError(t, err)
// ensure a VCSInstaller was returned
_, ok := i.(*VCSInstaller)
require.True(t, ok, "expected a VCSInstaller")
require.IsType(t, &VCSInstaller{}, i, "expected a VCSInstaller")
require.EqualErrorf(t, Update(i), "plugin does not exist", "expected error for plugin does not exist")
// Install plugin before update
if err := Install(i); err != nil {
if strings.Contains(err.Error(), "Could not resolve host: github.com") {
t.Skip("Unable to run test without Internet access")
} else {
t.Fatal(err)
}
err = Install(i)
if err != nil && strings.Contains(err.Error(), "Could not resolve host: github.com") {
t.Skip("Unable to run test without Internet access")
}
require.NoError(t, err)
// Test FindSource method for positive result
pluginInfo, err := FindSource(i.Path())

@ -16,7 +16,6 @@ limitations under the License.
package plugin
import (
"reflect"
"runtime"
"testing"
@ -39,7 +38,7 @@ func TestPrepareCommand(t *testing.T) {
cmd, args, err := PrepareCommands(platformCommand, true, []string{}, env)
require.NoError(t, err)
require.Equal(t, cmdMain, cmd, "Expected %q, got %q", cmdMain, cmd)
require.Truef(t, reflect.DeepEqual(args, cmdArgs), "Expected %v, got %v", cmdArgs, args)
require.Equalf(t, args, cmdArgs, "Expected %v, got %v", cmdArgs, args)
}
func TestPrepareCommandExtraArgs(t *testing.T) {
@ -111,7 +110,7 @@ func TestPrepareCommands(t *testing.T) {
cmd, args, err := PrepareCommands(cmds, true, []string{}, env)
require.NoError(t, err)
require.Equal(t, cmdMain, cmd, "Expected %q, got %q", cmdMain, cmd)
require.Truef(t, reflect.DeepEqual(args, cmdArgs), "Expected %v, got %v", cmdArgs, args)
require.Equalf(t, args, cmdArgs, "Expected %v, got %v", cmdArgs, args)
}
func TestPrepareCommandsExtraArgs(t *testing.T) {
@ -132,7 +131,7 @@ func TestPrepareCommandsExtraArgs(t *testing.T) {
cmd, args, err := PrepareCommands(cmds, true, extraArgs, env)
require.NoError(t, err)
require.Equal(t, cmdMain, cmd, "Expected %q, got %q", cmdMain, cmd)
require.Truef(t, reflect.DeepEqual(args, expectedArgs), "Expected %v, got %v", expectedArgs, args)
require.Equalf(t, expectedArgs, args, "Expected %v, got %v", expectedArgs, args)
}
func TestPrepareCommandsNoArch(t *testing.T) {
@ -149,7 +148,7 @@ func TestPrepareCommandsNoArch(t *testing.T) {
cmd, args, err := PrepareCommands(cmds, true, []string{}, env)
require.NoError(t, err)
require.Equal(t, cmdMain, cmd, "Expected %q, got %q", cmdMain, cmd)
require.Truef(t, reflect.DeepEqual(args, cmdArgs), "Expected %v, got %v", cmdArgs, args)
require.Equalf(t, args, cmdArgs, "Expected %v, got %v", cmdArgs, args)
}
func TestPrepareCommandsNoOsNoArch(t *testing.T) {
@ -166,7 +165,7 @@ func TestPrepareCommandsNoOsNoArch(t *testing.T) {
cmd, args, err := PrepareCommands(cmds, true, []string{}, env)
require.NoError(t, err)
require.Equal(t, cmdMain, cmd, "Expected %q, got %q", cmdMain, cmd)
require.Truef(t, reflect.DeepEqual(args, cmdArgs), "Expected %v, got %v", cmdArgs, args)
require.Equalf(t, args, cmdArgs, "Expected %v, got %v", cmdArgs, args)
}
func TestPrepareCommandsNoMatch(t *testing.T) {
@ -206,7 +205,7 @@ func TestPrepareCommandsExpand(t *testing.T) {
cmd, args, err := PrepareCommands(cmds, true, []string{}, env)
require.NoError(t, err)
require.Equal(t, cmdMain, cmd, "Expected %q, got %q", cmdMain, cmd)
require.Truef(t, reflect.DeepEqual(args, expectedArgs), "Expected %v, got %v", expectedArgs, args)
require.Equalf(t, expectedArgs, args, "Expected %v, got %v", expectedArgs, args)
}
func TestPrepareCommandsNoExpand(t *testing.T) {
@ -223,5 +222,5 @@ func TestPrepareCommandsNoExpand(t *testing.T) {
cmd, args, err := PrepareCommands(cmds, false, []string{}, env)
require.NoError(t, err)
require.Equal(t, cmdMain, cmd, "Expected %q, got %q", cmdMain, cmd)
require.Truef(t, reflect.DeepEqual(args, cmdArgs), "Expected %v, got %v", cmdArgs, args)
require.Equalf(t, args, cmdArgs, "Expected %v, got %v", cmdArgs, args)
}

@ -143,7 +143,6 @@ metadata:
// This test will fail if 'six' or 'seven' was added.
assert.Len(t, generic, 2)
assert.Len(t, hs, 4)
for _, out := range hs {

@ -148,28 +148,22 @@ func TestResolve(t *testing.T) {
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
l, err := r.Resolve(tt.req, repoNames)
if err != nil {
if tt.err {
return
}
if tt.err {
require.Error(t, err)
} else {
require.NoError(t, err)
}
h, err := HashReq(tt.req, tt.expect.Dependencies)
require.NoError(t, err)
assert.Equal(t, l.Digest, h, "%q: hashes don't match.", tt.name)
if tt.err {
require.Failf(t, "Expected error in test %q", tt.name)
// Check fields.
require.Len(t, l.Dependencies, len(tt.req), "%s: wrong number of dependencies in lock", tt.name)
d0 := l.Dependencies[0]
e0 := tt.expect.Dependencies[0]
assert.Equal(t, e0.Name, d0.Name, tt.name)
assert.Equal(t, e0.Repository, d0.Repository, tt.name)
assert.Equal(t, e0.Version, d0.Version, tt.name)
}
h, err := HashReq(tt.req, tt.expect.Dependencies)
require.NoError(t, err)
assert.Equal(t, l.Digest, h, "%q: hashes don't match.", tt.name)
// Check fields.
assert.Len(t, l.Dependencies, len(tt.req), "%s: wrong number of dependencies in lock", tt.name)
d0 := l.Dependencies[0]
e0 := tt.expect.Dependencies[0]
assert.Equal(t, e0.Name, d0.Name, tt.name)
assert.Equal(t, e0.Repository, d0.Repository, tt.name)
assert.Equal(t, e0.Version, d0.Version, tt.name)
})
}
}
@ -280,20 +274,16 @@ func TestGetLocalPath(t *testing.T) {
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
p, err := GetLocalPath(tt.repo, tt.chartpath)
if err != nil {
if tt.err {
return
}
require.NoError(t, err)
}
if tt.err {
require.Failf(t, "Expected error in test %q", tt.name)
}
expect := tt.expect
if runtime.GOOS == "windows" {
expect = tt.winExpect
require.Error(t, err)
} else {
require.NoError(t, err)
if runtime.GOOS == "windows" {
assert.Equal(t, tt.winExpect, p, tt.name)
} else {
assert.Equal(t, tt.expect, p, tt.name)
}
}
assert.Equal(t, expect, p, tt.name)
})
}
}

@ -420,9 +420,7 @@ func TestInstallRelease_WithChartAndDependencyAllNotes(t *testing.T) {
req.NoError(err)
is.Equal("with-notes", rel.Name)
// test run can return as either 'parent\nchild' or 'child\nparent'
if !strings.Contains(rel.Info.Notes, "parent") && !strings.Contains(rel.Info.Notes, "child") {
t.Fatalf("Expected 'parent\nchild' or 'child\nparent', got '%s'", rel.Info.Notes)
}
req.True(strings.Contains(rel.Info.Notes, "parent") || strings.Contains(rel.Info.Notes, "child"), "Expected 'parent\nchild' or 'child\nparent', got '%s'", rel.Info.Notes)
is.Equal("Install complete", rel.Info.Description)
}
@ -1130,7 +1128,7 @@ func TestInstallCRDs(t *testing.T) {
mockChart := buildChart(withFile(mockFile))
crdsToInstall := mockChart.CRDObjects()
assert.Len(t, crdsToInstall, 1)
require.Len(t, crdsToInstall, 1)
assert.Equal(t, crdsToInstall[0].File.Data, mockFile.Data)
require.NoError(t, instAction.installCRDs(crdsToInstall))
}

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

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

@ -176,8 +176,8 @@ func TestUpgradeRelease_RollbackOnFailure(t *testing.T) {
resi, err := upAction.Run(rel.Name, buildChart(), vals)
req.Error(err)
is.Contains(err.Error(), "arming key removed")
is.Contains(err.Error(), "rollback-on-failure")
req.ErrorContains(err, "arming key removed")
req.ErrorContains(err, "rollback-on-failure")
res, err := releaserToV1Release(resi)
req.NoError(err)
@ -207,8 +207,8 @@ func TestUpgradeRelease_RollbackOnFailure(t *testing.T) {
_, err := upAction.Run(rel.Name, buildChart(), vals)
req.Error(err)
is.Contains(err.Error(), "update fail")
is.Contains(err.Error(), "an error occurred while rolling back the release")
req.ErrorContains(err, "update fail")
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.Config = existingValues
err := upAction.cfg.Releases.Create(rel)
req.NoError(err)
req.NoError(upAction.cfg.Releases.Create(rel))
upAction.ReuseValues = true
// setting newValues and upgrading
@ -253,11 +252,8 @@ func TestUpgradeRelease_ReuseValues(t *testing.T) {
// Now make sure it is actually upgraded
updatedResi, err := upAction.cfg.Releases.Get(res.Name, 2)
req.NoError(err)
req.NotNil(updatedResi, "Updated Release is nil")
if updatedResi == nil {
is.Fail("Updated Release is nil")
return
}
updatedRes, err := releaserToV1Release(updatedResi)
req.NoError(err)
@ -303,8 +299,7 @@ func TestUpgradeRelease_ReuseValues(t *testing.T) {
Config: existingValues,
Version: 1,
}
err := upAction.cfg.Releases.Create(rel)
req.NoError(err)
req.NoError(upAction.cfg.Releases.Create(rel))
upAction.ReuseValues = true
sampleChartWithSubChart := buildChart(
@ -322,11 +317,8 @@ func TestUpgradeRelease_ReuseValues(t *testing.T) {
// Now get the upgraded release
updatedResi, err := upAction.cfg.Releases.Get(res.Name, 2)
req.NoError(err)
req.NotNil(updatedResi, "Updated Release is nil")
if updatedResi == nil {
is.Fail("Updated Release is nil")
return
}
updatedRes, err := releaserToV1Release(updatedResi)
req.NoError(err)
@ -373,8 +365,7 @@ func TestUpgradeRelease_ResetThenReuseValues(t *testing.T) {
rel.Info.Status = common.StatusDeployed
rel.Config = existingValues
err := upAction.cfg.Releases.Create(rel)
req.NoError(err)
req.NoError(upAction.cfg.Releases.Create(rel))
upAction.ResetThenReuseValues = true
// setting newValues and upgrading
@ -386,11 +377,8 @@ func TestUpgradeRelease_ResetThenReuseValues(t *testing.T) {
// Now make sure it is actually upgraded
updatedResi, err := upAction.cfg.Releases.Get(res.Name, 2)
req.NoError(err)
req.NotNil(updatedResi, "Updated Release is nil")
if updatedResi == nil {
is.Fail("Updated Release is nil")
return
}
updatedRes, err := releaserToV1Release(updatedResi)
req.NoError(err)
@ -417,7 +405,7 @@ func TestUpgradeRelease_Pending(t *testing.T) {
vals := map[string]any{}
_, err := upAction.Run(rel.Name, buildChart(), vals)
req.Contains(err.Error(), "progress", err)
req.ErrorContains(err, "progress")
}
func TestUpgradeRelease_Interrupted_Wait(t *testing.T) {
@ -470,7 +458,7 @@ func TestUpgradeRelease_Interrupted_RollbackOnFailure(t *testing.T) {
resi, err := upAction.RunWithContext(ctx, rel.Name, buildChart(), vals)
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)
req.NoError(err)
// Now make sure it is actually upgraded
@ -491,9 +479,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"}},
}
for _, test := range tests {
if output := mergeCustomLabels(test[0], test[1]); !reflect.DeepEqual(test[2], output) {
t.Errorf("Expected {%v}, got {%v}", test[2], output)
}
output := mergeCustomLabels(test[0], test[1])
assert.Truef(t, reflect.DeepEqual(test[2], output), "Expected {%v}, got {%v}", test[2], output)
}
}
@ -511,8 +498,7 @@ func TestUpgradeRelease_Labels(t *testing.T) {
}
rel.Info.Status = common.StatusDeployed
err := upAction.cfg.Releases.Create(rel)
req.NoError(err)
req.NoError(upAction.cfg.Releases.Create(rel))
upAction.Labels = map[string]string{
"key1": "null",
@ -528,11 +514,8 @@ func TestUpgradeRelease_Labels(t *testing.T) {
// Now make sure it is actually upgraded and labels were merged
updatedResi, err := upAction.cfg.Releases.Get(res.Name, 2)
req.NoError(err)
req.NotNil(updatedResi, "Updated Release is nil")
if updatedResi == nil {
is.Fail("Updated Release is nil")
return
}
updatedRes, err := releaserToV1Release(updatedResi)
req.NoError(err)
is.Equal(common.StatusDeployed, updatedRes.Info.Status)
@ -541,11 +524,8 @@ func TestUpgradeRelease_Labels(t *testing.T) {
// Now make sure it is suppressed release still contains original labels
initialResi, err := upAction.cfg.Releases.Get(res.Name, 1)
req.NoError(err)
req.NotNil(initialResi, "Initial Release is nil")
if initialResi == nil {
is.Fail("Updated Release is nil")
return
}
initialRes, err := releaserToV1Release(initialResi)
req.NoError(err)
is.Equal(common.StatusSuperseded, initialRes.Info.Status)
@ -566,8 +546,7 @@ func TestUpgradeRelease_SystemLabels(t *testing.T) {
}
rel.Info.Status = common.StatusDeployed
err := upAction.cfg.Releases.Create(rel)
req.NoError(err)
req.NoError(upAction.cfg.Releases.Create(rel))
upAction.Labels = map[string]string{
"key1": "null",
@ -575,12 +554,10 @@ func TestUpgradeRelease_SystemLabels(t *testing.T) {
"owner": "val3",
}
// setting newValues and upgrading
_, err = upAction.Run(rel.Name, buildChart(), nil)
if err == nil {
t.Fatal("expected an error")
}
_, err := upAction.Run(rel.Name, buildChart(), nil)
require.Error(t, err, "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) {

@ -132,7 +132,7 @@ func TestRequireAdoption(t *testing.T) {
// Verify that a resource that lacks labels/annotations can be adopted
found, err := requireAdoption(resources)
require.NoError(t, err)
assert.Len(t, found, 1)
require.Len(t, found, 1)
assert.Equal(t, found[0], existing)
assert.NotSame(t, found[0], existing)
}
@ -157,7 +157,7 @@ func TestExistingResourceConflict(t *testing.T) {
// Verify only existing resources are returned
found, err := existingResourceConflict(resources, releaseName, releaseNamespace)
require.NoError(t, err)
assert.Len(t, found, 1)
require.Len(t, found, 1)
assert.Equal(t, found[0], existing)
assert.NotSame(t, found[0], existing)
@ -171,45 +171,38 @@ func TestCheckOwnership(t *testing.T) {
deployFoo := newDeploymentResource("foo", "ns-a", "")
// Verify that a resource that lacks labels/annotations is not owned
err := checkOwnership(deployFoo.Object, "rel-a", "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"`)
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"`)
// Set managed by label and verify annotation error message
_ = accessor.SetLabels(deployFoo.Object, map[string]string{
appManagedByLabel: appManagedByHelm,
})
err = checkOwnership(deployFoo.Object, "rel-a", "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"`)
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"`)
// Set only the release name annotation and verify missing release namespace error message
_ = accessor.SetAnnotations(deployFoo.Object, map[string]string{
helmReleaseNameAnnotation: "rel-a",
})
err = checkOwnership(deployFoo.Object, "rel-a", "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"`)
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"`)
// Set both release name and namespace annotations and verify no ownership errors
_ = accessor.SetAnnotations(deployFoo.Object, map[string]string{
helmReleaseNameAnnotation: "rel-a",
helmReleaseNamespaceAnnotation: "ns-a",
})
err = checkOwnership(deployFoo.Object, "rel-a", "ns-a")
require.NoError(t, err)
require.NoError(t, checkOwnership(deployFoo.Object, "rel-a", "ns-a"))
// Verify ownership error for wrong release name
err = checkOwnership(deployFoo.Object, "rel-b", "ns-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"`)
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"`)
// Verify ownership error for wrong release namespace
err = checkOwnership(deployFoo.Object, "rel-a", "ns-b")
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"`)
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"`)
// Verify ownership error for wrong manager label
_ = accessor.SetLabels(deployFoo.Object, map[string]string{
appManagedByLabel: "helm",
})
err = checkOwnership(deployFoo.Object, "rel-a", "ns-a")
assert.EqualError(t, err, `invalid ownership metadata; label validation error: key "app.kubernetes.io/managed-by" must equal "Helm": current value is "helm"`)
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"`)
}
func TestVerifyOwnershipBeforeDelete(t *testing.T) {
@ -249,8 +242,8 @@ func TestVerifyOwnershipBeforeDelete(t *testing.T) {
ownedList, unownedList, _, err := verifyOwnershipBeforeDelete(resources, releaseName, releaseNamespace)
require.NoError(t, err)
assert.Len(t, ownedList, 1)
assert.Len(t, unownedList, 1)
require.Len(t, ownedList, 1)
require.Len(t, unownedList, 1)
assert.Equal(t, "owned", ownedList[0].Name)
assert.Equal(t, "unowned", unownedList[0].Name)
})
@ -297,8 +290,8 @@ func TestVerifyOwnershipBeforeDelete(t *testing.T) {
ownedList, unownedList, _, err := verifyOwnershipBeforeDelete(resources, releaseName, releaseNamespace)
require.NoError(t, err)
assert.Len(t, ownedList, 1)
assert.Len(t, unownedList, 1)
require.Len(t, ownedList, 1)
require.Len(t, unownedList, 1)
assert.Equal(t, "owned", ownedList[0].Name)
assert.Equal(t, "unowned", unownedList[0].Name)
})
@ -306,32 +299,26 @@ func TestVerifyOwnershipBeforeDelete(t *testing.T) {
func TestSetMetadataVisitor(t *testing.T) {
var (
err error
deployFoo = newDeploymentResource("foo", "ns-a", "")
deployBar = newDeploymentResource("bar", "ns-a-system", "")
resources = kube.ResourceList{deployFoo, deployBar}
)
// Set release tracking metadata and verify no error
err = resources.Visit(setMetadataVisitor("rel-a", "ns-a", true))
require.NoError(t, err)
require.NoError(t, resources.Visit(setMetadataVisitor("rel-a", "ns-a", true)))
// Verify that release "b" cannot take ownership of "a"
err = resources.Visit(setMetadataVisitor("rel-b", "ns-a", false))
require.Error(t, err)
require.Error(t, resources.Visit(setMetadataVisitor("rel-b", "ns-a", false)))
// Force release "b" to take ownership
err = resources.Visit(setMetadataVisitor("rel-b", "ns-a", true))
require.NoError(t, err)
require.NoError(t, resources.Visit(setMetadataVisitor("rel-b", "ns-a", true)))
// 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, err)
require.NoError(t, resources.Visit(setMetadataVisitor("rel-b", "ns-a", false)))
// Add a new resource that is missing ownership metadata and verify error
resources.Append(newDeploymentResource("baz", "default", ""))
err = resources.Visit(setMetadataVisitor("rel-b", "ns-a", false))
assert.ErrorContains(t, err, `Deployment "baz" in namespace "" cannot be owned`)
assert.ErrorContains(t, resources.Visit(setMetadataVisitor("rel-b", "ns-a", false)), `Deployment "baz" in namespace "" cannot be owned`)
}
func TestValidateNameAndGenerateName(t *testing.T) {

@ -372,8 +372,7 @@ func TestMergeValues(t *testing.T) {
assert.True(t, ok, "Expected nested boat key to be present but it was removed")
subchart := v["pequod"].(map[string]any)["ahab"].(map[string]any)
_, ok = subchart["boat"]
assert.True(t, ok, "Expected subchart boat key to be present but it was removed")
assert.Contains(t, subchart, "boat", "Expected subchart boat key to be present but it was removed")
_, ok = subchart["nested"].(map[string]any)["bar"]
assert.True(t, ok, "Expected subchart nested bar key to be present but it was removed")
@ -526,8 +525,7 @@ func TestMergeTables(t *testing.T) {
// This is one test that is different from CoalesceTables. Because hole
// is a nil value and it's not removed it's still present.
_, ok = dst["hole"]
assert.True(t, ok, "The hole no longer exists.")
assert.Contains(t, dst, "hole", "The hole no longer exists.")
dst2 := map[string]any{
"name": "Ishmael",
@ -559,8 +557,7 @@ func TestMergeTables(t *testing.T) {
det2, ok := dst2["details"].(map[string]any)
require.Truef(t, ok, "Details is the wrong type: %v", dst2["details"])
_, ok = det2["friends"]
assert.True(t, ok, "Could not find your friends. Maybe you don't have any. :-(")
assert.Contains(t, det2, "friends", "Could not find your friends. Maybe you don't have any. :-(")
assert.Equal(t, "pequod", dst2["boat"].(string), "Expected boat string, got %v", dst2["boat"])
assert.Equal(t, "black", dst2["hole"].(string), "Expected hole string, got %v", dst2["hole"])
assert.Nil(t, dst2["nilval"], "Expected nilvalue to have nil value but it does not")
@ -659,8 +656,7 @@ func TestCoalesceValuesEmptyMapWithNils(t *testing.T) {
is.Equal("bar", data["foo"])
// "baz" should be preserved with nil value since it wasn't in chart defaults
_, ok = data["baz"]
is.True(ok, "Expected data.baz key to be present but it was removed")
is.Contains(data, "baz", "Expected data.baz key to be present but it was removed")
is.Nil(data["baz"], "Expected data.baz key to be nil but it is not")
}

@ -118,7 +118,7 @@ func TestBadValues(t *testing.T) {
func TestBadCrdFile(t *testing.T) {
var values map[string]any
m := RunAll(badCrdFileDir, values, namespace).Messages
assert.Lenf(t, m, 2, "All didn't fail with expected errors, got %#v", m)
require.Lenf(t, m, 2, "All didn't fail with expected errors, got %#v", m)
require.ErrorContains(t, m[0].Err, "apiVersion is not in 'apiextensions.k8s.io'")
assert.ErrorContains(t, m[1].Err, "object kind is not 'CustomResourceDefinition'")
}
@ -126,8 +126,7 @@ func TestBadCrdFile(t *testing.T) {
func TestGoodChart(t *testing.T) {
var values map[string]any
m := RunAll(goodChartDir, values, namespace).Messages
if len(m) != 0 {
t.Error("All returned linter messages when it shouldn't have")
if !assert.Empty(t, m, "All returned linter messages when it shouldn't have") {
for i, msg := range m {
t.Logf("Message %d: %s", i, msg)
}
@ -147,13 +146,12 @@ func TestHelmCreateChart(t *testing.T) {
// Note: we test with strict=true here, even though others have
// strict = false.
m := RunAll(createdChart, values, namespace, WithSkipSchemaValidation(true)).Messages
if ll := len(m); ll != 1 {
t.Errorf("All should have had exactly 1 error. Got %d", ll)
if !assert.Len(t, m, 1, "All should have had exactly 1 error") {
for i, msg := range m {
t.Logf("Message %d: %s", i, msg.Error())
}
} else if msg := m[0].Err.Error(); !strings.Contains(msg, "icon is recommended") {
t.Errorf("Unexpected lint error: %s", msg)
} else {
assert.ErrorContains(t, m[0].Err, "icon is recommended")
}
}
@ -196,8 +194,7 @@ func TestHelmCreateChart_CheckDeprecatedWarnings(t *testing.T) {
func TestSubChartValuesChart(t *testing.T) {
var values map[string]any
m := RunAll(subChartValuesDir, values, namespace).Messages
if len(m) != 0 {
t.Error("All returned linter messages when it shouldn't have")
if !assert.Empty(t, m, "All returned linter messages when it shouldn't have") {
for i, msg := range m {
t.Logf("Message %d: %s", i, msg)
}

@ -195,7 +195,6 @@ func TestChartfile(t *testing.T) {
expectedNumberOfErrorMessages := 7
require.Lenf(t, msgs, expectedNumberOfErrorMessages, "Expected %d errors, got %d", expectedNumberOfErrorMessages, len(msgs))
require.ErrorContains(t, msgs[0].Err, "name is required", "Unexpected message 0: %s", msgs[0].Err)
require.ErrorContains(t, msgs[1].Err, "apiVersion is required. The value must be either \"v1\" or \"v2\"", "Unexpected message 1: %s", msgs[1].Err)
require.ErrorContains(t, msgs[2].Err, "version '0.0.0.0' is not a valid SemVer", "Unexpected message 2: %s", msgs[2].Err)
@ -211,11 +210,7 @@ func TestChartfile(t *testing.T) {
msgs := linter.Messages
expectedNumberOfErrorMessages := 4
if len(msgs) != expectedNumberOfErrorMessages {
t.Errorf("Expected %d errors, got %d", expectedNumberOfErrorMessages, len(msgs))
return
}
require.Len(t, msgs, expectedNumberOfErrorMessages, "Expected %d errors, got %d", expectedNumberOfErrorMessages, len(msgs))
require.ErrorContains(t, msgs[0].Err, "version should be of type string", "Unexpected message 0: %s", msgs[0].Err)
require.ErrorContains(t, msgs[1].Err, "version '7.2445e+06' is not a valid SemVer", "Unexpected message 1: %s", msgs[1].Err)
require.ErrorContains(t, msgs[2].Err, "appVersion should be of type string", "Unexpected message 2: %s", msgs[2].Err)

@ -22,6 +22,7 @@ import (
"testing"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"helm.sh/helm/v4/pkg/chart/v2/lint/support"
)
@ -33,7 +34,7 @@ func TestInvalidCrdsDir(t *testing.T) {
Crds(&linter)
res := linter.Messages
assert.Len(t, res, 1)
require.Len(t, res, 1)
assert.ErrorContains(t, res[0].Err, "not a directory")
}

@ -140,8 +140,7 @@ func TestDependencies(t *testing.T) {
linter := support.Linter{ChartDir: filepath.Join(tmp, c.Metadata.Name)}
Dependencies(&linter)
if l := len(linter.Messages); l != 2 {
t.Errorf("expected 2 linter errors for bad chart dependencies. Got %d.", l)
if !assert.Len(t, linter.Messages, 2, "expected 2 linter errors for bad chart dependencies") {
for i, msg := range linter.Messages {
t.Logf("Message: %d, Error: %#v", i, msg)
}

@ -171,8 +171,11 @@ func TestValidateMetadataName(t *testing.T) {
}
for _, tt := range tests {
t.Run(fmt.Sprintf("%s/%s", tt.obj.Kind, tt.obj.Metadata.Name), func(t *testing.T) {
if err := validateMetadataName(tt.obj); (err != nil) != tt.wantErr {
t.Errorf("validateMetadataName() error = %v, wantErr %v", err, tt.wantErr)
err := validateMetadataName(tt.obj)
if tt.wantErr {
require.Error(t, err, "validateMetadataName()")
} else {
require.NoError(t, err, "validateMetadataName()")
}
})
}
@ -210,12 +213,12 @@ func TestDeprecatedAPIFails(t *testing.T) {
namespace,
values,
TemplateLinterSkipSchemaValidation(false))
if l := len(linter.Messages); l != 1 {
if !assert.Len(t, linter.Messages, 1) {
for i, msg := range linter.Messages {
t.Logf("Message %d: %s", i, msg)
}
t.Fatalf("Expected 1 lint error, got %d", l)
}
require.Len(t, linter.Messages, 1, "Expected 1 lint error")
var depErr deprecatedAPIError
require.ErrorAs(t, linter.Messages[0].Err, &depErr)
@ -267,8 +270,7 @@ func TestStrictTemplateParsingMapError(t *testing.T) {
namespace,
ch.Values,
TemplateLinterSkipSchemaValidation(false))
if len(linter.Messages) != 0 {
t.Errorf("expected zero messages, got %d", len(linter.Messages))
if !assert.Empty(t, linter.Messages, "expected zero messages") {
for i, msg := range linter.Messages {
t.Logf("Message %d: %q", i, msg)
}
@ -358,9 +360,14 @@ func TestValidateTopIndentLevel(t *testing.T) {
" apiVersion:foo": true,
"\n\n apiVersion:foo\n\n": true,
} {
if err := validateTopIndentLevel(doc); (err == nil) == shouldFail {
t.Errorf("Expected %t for %q", shouldFail, doc)
}
t.Run(doc, func(t *testing.T) {
err := validateTopIndentLevel(doc)
if shouldFail {
assert.Error(t, err)
} else {
assert.NoError(t, err)
}
})
}
}
@ -392,12 +399,12 @@ func TestEmptyWithCommentsManifests(t *testing.T) {
namespace,
values,
TemplateLinterSkipSchemaValidation(false))
if l := len(linter.Messages); l > 0 {
if !assert.Empty(t, linter.Messages) {
for i, msg := range linter.Messages {
t.Logf("Message %d: %s", i, msg)
}
t.Fatalf("Expected 0 lint errors, got %d", l)
}
require.Empty(t, linter.Messages, "Expected 0 lint errors")
}
func TestValidateListAnnotations(t *testing.T) {
md := &k8sYamlStruct{

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

@ -58,11 +58,11 @@ func TestRunLinterRule(t *testing.T) {
func TestMessage(t *testing.T) {
m := Message{ErrorSev, "Chart.yaml", errors.New("Foo")}
require.EqualErrorf(t, m, "[ERROR] Chart.yaml: Foo", "Unexpected output: %s", m.Error())
require.EqualError(t, m, "[ERROR] Chart.yaml: Foo")
m = Message{WarningSev, "templates/", errors.New("Bar")}
require.EqualErrorf(t, m, "[WARNING] templates/: Bar", "Unexpected output: %s", m.Error())
require.EqualError(t, m, "[WARNING] templates/: Bar")
m = Message{InfoSev, "templates/rc.yaml", errors.New("FooBar")}
assert.EqualErrorf(t, m, "[INFO] templates/rc.yaml: FooBar", "Unexpected output: %s", m.Error())
assert.EqualError(t, m, "[INFO] templates/rc.yaml: FooBar")
}

@ -25,7 +25,6 @@ import (
"log"
"os"
"path/filepath"
"reflect"
"runtime"
"strings"
"testing"
@ -385,11 +384,13 @@ func TestLoadInvalidArchive(t *testing.T) {
{"illegal-abspath5.tgz", "/./c://foo", "chart contains illegally named files"},
{"illegal-abspath6.tgz", "\\\\?\\Some\\windows\\magic", "chart illegally contains absolute paths"},
} {
illegalChart := filepath.Join(tmpdir, tt.chartname)
writeTar(illegalChart, tt.internal, []byte("hello: world"))
_, err := Load(illegalChart)
require.Error(t, err, "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)
t.Run(tt.chartname, func(t *testing.T) {
illegalChart := filepath.Join(tmpdir, tt.chartname)
writeTar(illegalChart, tt.internal, []byte("hello: world"))
_, err := Load(illegalChart)
require.Error(t, err, "expected error when unpacking illegal files")
require.ErrorContains(t, err, tt.expectError)
})
}
// Make sure that absolute path gets interpreted as relative
@ -456,7 +457,7 @@ foo:
t.Run(testName, func(tt *testing.T) {
values, err := LoadValues(bytes.NewReader(testCase.data))
require.NoError(tt, err)
assert.Truef(t, reflect.DeepEqual(values, testCase.expctedValues), "Expected values: %v, got %v", testCase.expctedValues, values)
assert.Equal(t, testCase.expctedValues, values)
})
}
}
@ -484,16 +485,13 @@ func TestMergeValuesV2(t *testing.T) {
}
testMap := MergeMaps(flatMap, nestedMap)
equal := reflect.DeepEqual(testMap, nestedMap)
assert.True(t, equal, "Expected a nested map to overwrite a flat value. Expected: %v, got %v", nestedMap, testMap)
assert.Equal(t, testMap, nestedMap, "Expected a nested map to overwrite a flat value. Expected: %v, got %v", nestedMap, testMap)
testMap = MergeMaps(nestedMap, flatMap)
equal = reflect.DeepEqual(testMap, flatMap)
assert.True(t, equal, "Expected a flat value to overwrite a map. Expected: %v, got %v", flatMap, testMap)
assert.Equal(t, testMap, flatMap, "Expected a flat value to overwrite a map. Expected: %v, got %v", flatMap, testMap)
testMap = MergeMaps(nestedMap, anotherNestedMap)
equal = reflect.DeepEqual(testMap, anotherNestedMap)
assert.True(t, equal, "Expected a nested map to overwrite another nested map. Expected: %v, got %v", anotherNestedMap, testMap)
assert.Equal(t, testMap, anotherNestedMap, "Expected a nested map to overwrite another nested map. Expected: %v, got %v", anotherNestedMap, testMap)
testMap = MergeMaps(anotherFlatMap, anotherNestedMap)
expectedMap := map[string]any{
@ -504,8 +502,7 @@ func TestMergeValuesV2(t *testing.T) {
"awesome": "stuff",
},
}
equal = reflect.DeepEqual(testMap, expectedMap)
assert.True(t, equal, "Expected a map with different keys to merge properly with another map. Expected: %v, got %v", expectedMap, testMap)
assert.Equal(t, expectedMap, testMap, "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) {
@ -515,15 +512,13 @@ func verifyChart(t *testing.T, c *chart.Chart) {
assert.Len(t, c.Templates, 1, "Expected 1 template, got %d", len(c.Templates))
numfiles := 6
if len(c.Files) != numfiles {
t.Errorf("Expected %d extra files, got %d", numfiles, len(c.Files))
if !assert.Len(t, c.Files, numfiles) {
for _, n := range c.Files {
t.Logf("\t%s", n.Name)
}
}
if len(c.Dependencies()) != 2 {
t.Errorf("Expected 2 dependencies, got %d (%v)", len(c.Dependencies()), c.Dependencies())
if !assert.Len(t, c.Dependencies(), 2, "Expected 2 dependencies") {
for _, d := range c.Dependencies() {
t.Logf("\tSubchart: %s\n", d.Name())
}
@ -548,7 +543,7 @@ func verifyChart(t *testing.T, c *chart.Chart) {
func verifyDependencies(t *testing.T, c *chart.Chart) {
t.Helper()
assert.Len(t, c.Metadata.Dependencies, 2, "Expected 2 dependencies, got %d", len(c.Metadata.Dependencies))
require.Len(t, c.Metadata.Dependencies, 2, "Expected 2 dependencies, got %d", len(c.Metadata.Dependencies))
tests := []*chart.Dependency{
{Name: "alpine", Version: "0.1.0", Repository: "https://example.com/charts"},
{Name: "mariner", Version: "4.3.2", Repository: "https://example.com/charts"},
@ -563,7 +558,7 @@ func verifyDependencies(t *testing.T, c *chart.Chart) {
func verifyDependenciesLock(t *testing.T, c *chart.Chart) {
t.Helper()
assert.Len(t, c.Metadata.Dependencies, 2, "Expected 2 dependencies, got %d", len(c.Metadata.Dependencies))
require.Len(t, c.Metadata.Dependencies, 2, "Expected 2 dependencies, got %d", len(c.Metadata.Dependencies))
tests := []*chart.Dependency{
{Name: "alpine", Version: "0.1.0", Repository: "https://example.com/charts"},
{Name: "mariner", Version: "4.3.2", Repository: "https://example.com/charts"},

@ -49,12 +49,8 @@ func verifyChartfile(t *testing.T, f *chart.Metadata, name string) {
assert.Equal(t, "https://example.com/64x64.png", f.Icon, "Unexpected icon: %q", f.Icon)
assert.Len(t, f.Keywords, 3, "Unexpected keywords")
require.Len(t, f.Annotations, 2, "Unexpected annotations")
want, got := "extravalue", f.Annotations["extrakey"]
assert.Equalf(t, want, got, "Want %q, but got %q", want, got)
want, got = "anothervalue", f.Annotations["anotherkey"]
assert.Equalf(t, want, got, "Want %q, but got %q", want, got)
assert.Equal(t, "extravalue", f.Annotations["extrakey"])
assert.Equal(t, "anothervalue", f.Annotations["anotherkey"])
kk := []string{"frobnitz", "sprocket", "dodad"}
for i, k := range f.Keywords {

@ -138,8 +138,11 @@ func TestValidateChartName(t *testing.T) {
"abcdefghijklmnopqrstuvwxyz-_." +
"ABCDEFGHIJKLMNOPQRSTUVWXYZ-_.": false,
} {
if err := validateChartName(name); (err != nil) == shouldPass {
t.Errorf("test for %q failed", name)
err := validateChartName(name)
if shouldPass {
assert.NoError(t, err)
} else {
assert.Error(t, err)
}
}
}

@ -43,7 +43,7 @@ func TestLoadDependency(t *testing.T) {
}
check := func(deps []*chart.Dependency) {
assert.Len(t, deps, 2, "expected 2 dependencies, got %d", len(deps))
require.Len(t, deps, 2, "expected 2 dependencies, got %d", len(deps))
for i, tt := range tests {
assert.Equal(t, tt.Name, deps[i].Name, "expected dependency named %q, got %q", tt.Name, deps[i].Name)
assert.Equal(t, tt.Version, deps[i].Version, "expected dependency named %q to have version %q, got %q", tt.Name, tt.Version, deps[i].Version)

@ -16,7 +16,11 @@ limitations under the License.
package util
import "testing"
import (
"testing"
"github.com/stretchr/testify/assert"
)
// TestValidateReleaseName is a regression test for ValidateName
//
@ -46,12 +50,11 @@ func TestValidateReleaseName(t *testing.T) {
"a1111111111111111111111111111111111111111111111111111111111z": false,
}
for input, expectPass := range names {
if err := ValidateReleaseName(input); (err == nil) != expectPass {
st := "fail"
if expectPass {
st = "succeed"
}
t.Errorf("Expected %q to %s", input, st)
err := ValidateReleaseName(input)
if expectPass {
assert.NoError(t, err)
} else {
assert.Error(t, err)
}
}
}
@ -80,12 +83,11 @@ func TestValidateMetadataName(t *testing.T) {
"a1111111111111111111111111111111111111111111111111111111111z": false,
}
for input, expectPass := range names {
if err := ValidateMetadataName(input); (err == nil) != expectPass {
st := "fail"
if expectPass {
st = "succeed"
}
t.Errorf("Expected %q to %s", input, st)
err := ValidateMetadataName(input)
if expectPass {
assert.NoError(t, err)
} else {
assert.Error(t, err)
}
}
}

@ -215,19 +215,17 @@ func TestReadFile(t *testing.T) {
got, err := readFile(actualFilePath, tt.providers)
require.NoError(t, err, "readFile() expected no error for stdin")
assert.Equal(t, testData, got)
return
}
// Regular test cases
got, err := readFile(actualFilePath, tt.providers)
if tt.expectError {
assert.Error(t, err)
return
}
require.NoError(t, err)
if tt.expectedData != nil {
assert.Equal(t, tt.expectedData, got)
} else {
// Regular test cases
got, err := readFile(actualFilePath, tt.providers)
if tt.expectError {
assert.Error(t, err)
} else {
require.NoError(t, err)
if tt.expectedData != nil {
assert.Equal(t, tt.expectedData, got)
}
}
}
})
}
@ -356,10 +354,10 @@ func TestMergeValuesCLI(t *testing.T) {
got, err := tt.opts.MergeValues(getter.Providers{})
if tt.wantErr {
assert.Error(t, err)
return
} else {
require.NoError(t, err)
assert.Equal(t, tt.expected, got)
}
require.NoError(t, err)
assert.Equal(t, tt.expected, got)
})
}
}

@ -18,9 +18,9 @@ package cmd
import (
"fmt"
"strings"
"testing"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
chart "helm.sh/helm/v4/pkg/chart/v2"
@ -47,13 +47,10 @@ func checkFileCompletion(t *testing.T, cmdName string, shouldBePerformed bool) {
testcmd := fmt.Sprintf("__complete %s ''", cmdName)
_, out, err := executeActionCommandC(storage, testcmd)
require.NoError(t, err)
if !strings.Contains(out, "ShellCompDirectiveNoFileComp") != shouldBePerformed {
if shouldBePerformed {
t.Errorf("Unexpected directive ShellCompDirectiveNoFileComp when completing '%s'", cmdName)
} else {
t.Errorf("Did not receive directive ShellCompDirectiveNoFileComp when completing '%s'", cmdName)
}
t.Log(out)
if shouldBePerformed {
assert.NotContains(t, out, "ShellCompDirectiveNoFileComp", "Unexpected directive ShellCompDirectiveNoFileComp when completing '%s'", cmdName)
} else {
assert.Contains(t, out, "ShellCompDirectiveNoFileComp", "Did not receive directive ShellCompDirectiveNoFileComp when completing '%s'", cmdName)
}
}

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

@ -139,24 +139,22 @@ func TestPackage(t *testing.T) {
}
}
_, _, err = executeActionCommand(strings.Join(cmd, " "))
if err != nil {
if tt.err && re.MatchString(err.Error()) {
return
if tt.err {
require.Error(t, err)
require.True(t, re.MatchString(err.Error()))
} else {
require.NoError(t, err)
if tt.hasfile != "" {
fi, err := os.Stat(tt.hasfile)
require.NoErrorf(t, err, "%q: expected file %q", tt.name, tt.hasfile)
assert.NotEqualf(t, 0, fi.Size(), "%q: file %q has zero bytes.", tt.name, tt.hasfile)
}
t.Fatalf("%q: expected error %q, got %q", tt.name, tt.expect, err)
}
if tt.hasfile != "" {
fi, err := os.Stat(tt.hasfile)
require.NoErrorf(t, err, "%q: expected file %q", tt.name, tt.hasfile)
assert.NotEqualf(t, 0, fi.Size(), "%q: file %q has zero bytes.", tt.name, tt.hasfile)
}
if v, ok := tt.flags["sign"]; ok && v == "1" {
fi, err := os.Stat(tt.hasfile + ".prov")
require.NoErrorf(t, err, "%q: expected provenance file", tt.name)
assert.NotEqualf(t, 0, fi.Size(), "%q: provenance file is empty", tt.name)
if v, ok := tt.flags["sign"]; ok && v == "1" {
fi, err := os.Stat(tt.hasfile + ".prov")
require.NoErrorf(t, err, "%q: expected provenance file", tt.name)
assert.NotEqualf(t, 0, fi.Size(), "%q: provenance file is empty", tt.name)
}
}
})
}

@ -72,14 +72,10 @@ func TestManuallyProcessArgs(t *testing.T) {
known, unknown := manuallyProcessArgs(input)
for i, k := range known {
if k != expectKnown[i] {
t.Errorf("expected known flag %d to be %q, got %q", i, expectKnown[i], k)
}
assert.Equal(t, expectKnown[i], k, "expected known flag %d to be %q, got %q", i, expectKnown[i], k)
}
for i, k := range unknown {
if k != expectUnknown[i] {
t.Errorf("expected unknown flag %d to be %q, got %q", i, expectUnknown[i], k)
}
assert.Equal(t, expectUnknown[i], k, "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]
t.Run(fmt.Sprintf("%s-%d", pluginCmd.Name(), i), func(t *testing.T) {
out.Reset()
if pluginCmd.Use != tt.use {
t.Errorf("%d: Expected Use=%q, got %q", i, tt.use, pluginCmd.Use)
}
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)
}
assert.Equal(t, tt.use, pluginCmd.Use, "%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)
// Currently, plugins assume a Linux subsystem. Skip the execution
// tests until this is fixed
if runtime.GOOS != "windows" {
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
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)
}
}
@ -190,31 +180,23 @@ func TestLoadPluginsWithSpace(t *testing.T) {
plugins := cmd.Commands()
if len(plugins) != len(tests) {
t.Fatalf("Expected %d plugins, got %d", len(tests), len(plugins))
}
require.Len(t, plugins, len(tests), "Expected %d plugins, got %d", len(tests), len(plugins))
for i := range plugins {
out.Reset()
tt := tests[i]
pp := plugins[i]
if pp.Use != tt.use {
t.Errorf("%d: Expected Use=%q, got %q", i, tt.use, pp.Use)
}
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)
}
assert.Equal(t, tt.use, pp.Use, "%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)
// Currently, plugins assume a Linux subsystem. Skip the execution
// tests until this is fixed
if runtime.GOOS != "windows" {
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
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)
}
}
@ -334,9 +316,7 @@ func TestLoadCLIPlugins_HelmNoPlugins(t *testing.T) {
loadCLIPlugins(cmd, out)
plugins := cmd.Commands()
if len(plugins) != 0 {
t.Fatalf("Expected 0 plugins, got %d", len(plugins))
}
require.Empty(t, plugins, "Expected 0 plugins, got %d", len(plugins))
}
func TestPluginCmdsCompletion(t *testing.T) {

@ -237,25 +237,23 @@ func TestPullCmd(t *testing.T) {
require.NoError(t, os.MkdirAll(file, 0o755))
}
_, out, err := executeActionCommand(cmd)
if err != nil {
if tt.wantError {
if tt.wantErrorMsg != "" && tt.wantErrorMsg != err.Error() {
t.Fatalf("Actual error '%s', not equal to expected error '%s'", err, tt.wantErrorMsg)
}
return
if tt.wantError {
if tt.wantErrorMsg != "" {
require.EqualError(t, err, tt.wantErrorMsg, "Actual error '%s', not equal to expected error '%s'", err, tt.wantErrorMsg)
}
t.Fatalf("%q reported error: %s", tt.name, err)
}
} else {
require.NoError(t, err)
if tt.expectVerify {
outString := helmTestKeyOut + tt.expectSha + "\n"
assert.Equal(t, outString, out, "%q: expected verification output %q, got %q", tt.name, outString, out)
}
if tt.expectVerify {
outString := helmTestKeyOut + tt.expectSha + "\n"
assert.Equal(t, outString, out, "%q: expected verification output %q, got %q", tt.name, outString, out)
}
ef := filepath.Join(outdir, tt.expectFile)
fi, err := os.Stat(ef)
require.NoError(t, err, "%q: expected a file at %s.", tt.name, ef)
assert.Equal(t, tt.expectDir, fi.IsDir(), "%q: expected directory=%t, but it's not.", tt.name, tt.expectDir)
ef := filepath.Join(outdir, tt.expectFile)
fi, err := os.Stat(ef)
require.NoError(t, err, "%q: expected a file at %s.", tt.name, ef)
assert.Equal(t, tt.expectDir, fi.IsDir(), "%q: expected directory=%t, but it's not.", tt.name, tt.expectDir)
}
})
}
}

@ -48,10 +48,10 @@ func TestRepoIndexCmd(t *testing.T) {
index, err := repo.LoadIndexFile(destIndex)
require.NoError(t, err)
assert.Len(t, index.Entries, 1, "expected 1 entry, got %d: %#v", len(index.Entries), index.Entries)
require.Len(t, index.Entries, 1, "expected 1 entry, got %d: %#v", len(index.Entries), index.Entries)
vs := index.Entries["compressedchart"]
assert.Len(t, vs, 2, "expected 2 versions, got %d: %#v", len(vs), vs)
require.Len(t, vs, 2, "expected 2 versions")
expectedVersion := "0.2.0"
assert.Equal(t, expectedVersion, vs[0].Version, "expected %q, got %q", expectedVersion, vs[0].Version)

@ -174,10 +174,8 @@ func TestUpdateChartsFailWithError(t *testing.T) {
b := bytes.NewBuffer(nil)
err = updateCharts([]*repo.ChartRepository{r1, r2}, b)
require.Error(t, err, "Repo update should return error because update of repository fails and 'fail-on-repo-update-fail' flag set")
var expectedErr = "failed to update the following repositories"
var receivedErr = err.Error()
require.ErrorContains(t, err, expectedErr, "Expected error (%s) but got (%s) instead", expectedErr, receivedErr)
require.ErrorContains(t, err, invalidURL, "Expected invalid URL (%s) in error message but got (%s) instead", invalidURL, receivedErr)
require.ErrorContains(t, err, "failed to update the following repositories")
require.ErrorContains(t, err, invalidURL)
got := b.String()
assert.Contains(t, got, "Unable to get an update", "Repo should have failed update but instead got: %q", got)

@ -18,7 +18,6 @@ package cmd
import (
"fmt"
"reflect"
"testing"
"github.com/stretchr/testify/assert"
@ -161,5 +160,5 @@ func TestRollbackWithLabels(t *testing.T) {
updatedRel, err := releaserToV1Release(updatedReli)
require.NoError(t, err)
assert.Truef(t, reflect.DeepEqual(updatedRel.Labels, labels1), "Expected {%v}, got {%v}", labels1, updatedRel.Labels)
assert.Equalf(t, labels1, updatedRel.Labels, "Expected {%v}, got {%v}", labels1, updatedRel.Labels)
}

@ -232,26 +232,21 @@ func TestSearchByName(t *testing.T) {
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
charts, err := i.Search(tt.query, 100, tt.regexp)
if err != nil {
if tt.fail {
require.ErrorContains(t, err, tt.failMsg)
return
}
t.Fatalf("%s: %s", tt.name, err)
}
// Give us predictably ordered results.
SortScore(charts)
if tt.fail {
require.ErrorContains(t, err, tt.failMsg)
} else {
require.NoError(t, err) // Give us predictably ordered results.
SortScore(charts)
l := len(charts)
require.Lenf(t, tt.expect, l, "Expected %d result, got %d", len(tt.expect), l)
// For empty result sets, just keep going.
if l == 0 {
return
}
for i, got := range charts {
ex := tt.expect[i]
assert.Equalf(t, got.Name, ex.Name, "[%d]: Expected name %q, got %q", i, ex.Name, got.Name)
l := len(tt.expect)
require.Len(t, charts, len(tt.expect))
// For empty result sets, just keep going.
if l != 0 {
for i, got := range charts {
ex := tt.expect[i]
assert.Equalf(t, got.Name, ex.Name, "[%d]: Expected name %q, got %q", i, ex.Name, got.Name)
}
}
}
})
}

@ -46,11 +46,7 @@ func TestSearchHubCmd(t *testing.T) {
storage := storageFixture()
_, out, err := executeActionCommandC(storage, testcmd)
require.NoError(t, err)
if out != expected {
t.Error("expected and actual output did not match")
t.Log(out)
t.Log(expected)
}
assert.Equal(t, expected, out, "expected and actual output did not match")
}
func TestSearchHubListRepoCmd(t *testing.T) {
@ -73,11 +69,7 @@ func TestSearchHubListRepoCmd(t *testing.T) {
storage := storageFixture()
_, out, err := executeActionCommandC(storage, testcmd)
require.NoError(t, err)
if out != expected {
t.Error("expected and actual output did not match")
t.Log(out)
t.Log(expected)
}
assert.Equal(t, expected, out, "expected and actual output did not match")
}
func TestSearchHubOutputCompletion(t *testing.T) {

@ -77,12 +77,10 @@ func TestShowPreReleaseChart(t *testing.T) {
contentTmp,
)
_, _, err := executeActionCommand(cmd)
if err != nil {
if tt.fail {
assert.ErrorContains(t, err, tt.expectedErr, "%q expected error: %s, got: %s", tt.name, tt.expectedErr, err.Error())
return
}
t.Errorf("%q reported error: %s", tt.name, err)
if tt.fail {
assert.ErrorContains(t, err, tt.expectedErr)
} else {
assert.NoError(t, err)
}
})
}

@ -22,7 +22,6 @@ import (
"net/http/httptest"
"os"
"path/filepath"
"reflect"
"testing"
"time"
@ -201,9 +200,9 @@ func TestUpgradeDependencyUpdateOCINoPanic(t *testing.T) {
w.Header().Set("Docker-Distribution-API-Version", "registry/2.0")
if r.URL.Path == "/v2/" {
w.WriteHeader(http.StatusOK)
return
} else {
w.WriteHeader(http.StatusNotFound)
}
w.WriteHeader(http.StatusNotFound)
}))
defer srv.Close()
@ -224,23 +223,17 @@ func TestUpgradeDependencyUpdateOCINoPanic(t *testing.T) {
}},
},
}
if err := chartutil.SaveDir(parent, tmp); err != nil {
t.Fatalf("Error creating chart: %v", err)
}
require.NoError(t, chartutil.SaveDir(parent, tmp), "Error creating chart")
chartPath := filepath.Join(tmp, parent.Metadata.Name)
// SaveDir writes only resolved subcharts (Chart.Dependencies()), not the
// declared Metadata.Dependencies, so create the empty charts/ directory
// explicitly to make the "dependency missing from charts/" state concrete.
if err := os.MkdirAll(filepath.Join(chartPath, "charts"), 0o755); err != nil {
t.Fatalf("Error creating charts dir: %v", err)
}
require.NoError(t, os.MkdirAll(filepath.Join(chartPath, "charts"), 0o755), "Error creating charts dir")
// The command must return an error (registry rejects the lookup), not panic.
_, _, err := executeActionCommandC(storageFixture(),
fmt.Sprintf("upgrade --dependency-update --plain-http oci-parent '%s'", chartPath))
if err == nil {
t.Fatal("expected an error resolving the OCI dependency, got nil")
}
require.Error(t, err, "expected an error resolving the OCI dependency, got nil")
}
func TestUpgradeWithValue(t *testing.T) {
@ -471,7 +464,7 @@ func TestUpgradeInstallWithLabels(t *testing.T) {
updatedRel, err := releaserToV1Release(updatedReli)
require.NoError(t, err)
assert.Truef(t, reflect.DeepEqual(updatedRel.Labels, expectedLabels), "Expected {%v}, got {%v}", expectedLabels, updatedRel.Labels)
assert.Equal(t, expectedLabels, updatedRel.Labels)
}
func prepareMockReleaseWithSecret(t *testing.T, releaseName string) (func(n string, v int, ch *chart.Chart) *release.Release, *chart.Chart, string) {

@ -82,16 +82,15 @@ func TestResolveChartRef(t *testing.T) {
}
for _, tt := range tests {
_, u, err := c.ResolveChartVersion(tt.ref, tt.version)
if err != nil {
if tt.fail {
continue
t.Run(tt.name, func(t *testing.T) {
_, u, err := c.ResolveChartVersion(tt.ref, tt.version)
if err != nil {
require.True(t, tt.fail)
} else {
got := u.String()
assert.Equalf(t, tt.expect, got, "%s: expected %s, got %s", tt.name, tt.expect, got)
}
t.Errorf("%s: failed with error %q", tt.name, err)
continue
}
got := u.String()
assert.Equalf(t, tt.expect, got, "%s: expected %s, got %s", tt.name, tt.expect, got)
})
}
}
@ -124,35 +123,25 @@ func TestResolveChartOpts(t *testing.T) {
snapshotOpts := c.Options
for _, tt := range tests {
// reset chart downloader options for each test case
c.Options = snapshotOpts
expect, err := getter.NewHTTPGetter(tt.expect...)
if err != nil {
t.Errorf("%s: failed to setup http client: %s", tt.name, err)
continue
}
_, u, err := c.ResolveChartVersion(tt.ref, tt.version)
if err != nil {
t.Errorf("%s: failed with error %s", tt.name, err)
continue
}
got, err := getter.NewHTTPGetter(
append(
c.Options,
getter.WithURL(u.String()),
)...,
)
if err != nil {
t.Errorf("%s: failed to create http client: %s", tt.name, err)
continue
}
if *(got.(*getter.HTTPGetter)) != *(expect.(*getter.HTTPGetter)) {
t.Errorf("%s: expected %s, got %s", tt.name, expect, got)
}
t.Run(tt.name, func(t *testing.T) {
// reset chart downloader options for each test case
c.Options = snapshotOpts
expect, err := getter.NewHTTPGetter(tt.expect...)
require.NoError(t, err, "failed to setup http client")
_, u, err := c.ResolveChartVersion(tt.ref, tt.version)
require.NoError(t, err, "failed with error")
got, err := getter.NewHTTPGetter(
append(
c.Options,
getter.WithURL(u.String()),
)...,
)
require.NoError(t, err, "failed to create http client")
assert.Equal(t, expect, got)
})
}
}

@ -99,10 +99,8 @@ func TestParallelDownloadTo(t *testing.T) {
// Verify the file has the expected size (should match the source file)
sourceFile := "testdata/local-subchart-0.1.0.tgz"
sourceInfo, err := os.Stat(sourceFile)
if err == nil && info.Size() != sourceInfo.Size() {
t.Errorf("Downloaded file size (%d bytes) doesn't match source file size (%d bytes)",
info.Size(), sourceInfo.Size())
}
require.NoError(t, err)
assert.False(t, info.Size() != sourceInfo.Size(), "Downloaded file size doesn't match source file size")
// Verify it's a valid tar.gz file by checking the magic bytes
file, err := os.Open(expectedFile)
@ -110,10 +108,10 @@ func TestParallelDownloadTo(t *testing.T) {
defer file.Close()
// gzip magic bytes are 0x1f 0x8b
magic := make([]byte, 2)
if n, err := file.Read(magic); err == nil && n == 2 {
if magic[0] != 0x1f || magic[1] != 0x8b {
t.Errorf("Downloaded file is not a valid gzip file (magic bytes: %x)", magic)
}
n, err := file.Read(magic)
require.NoError(t, err)
if n == 2 {
assert.False(t, magic[0] != 0x1f || magic[1] != 0x8b, "Downloaded file is not a valid gzip file (magic bytes: %x)", magic)
}
}

@ -20,7 +20,6 @@ import (
"io/fs"
"os"
"path/filepath"
"reflect"
"testing"
"time"
@ -168,19 +167,16 @@ func TestGetRepoNames(t *testing.T) {
}
for _, tt := range tests {
l, err := m.resolveRepoNames(tt.req)
if err != nil {
t.Run(tt.name, func(t *testing.T) {
l, err := m.resolveRepoNames(tt.req)
if tt.err {
continue
require.Error(t, err)
} else {
require.NoError(t, err)
// m1 and m2 are the maps we want to compare
assert.Equal(t, l, tt.expect, "%s: expected map %v, got %v", tt.name, l, tt.name)
}
t.Fatal(err)
}
require.False(t, tt.err, "Expected error in test %q", tt.name)
// m1 and m2 are the maps we want to compare
eq := reflect.DeepEqual(l, tt.expect)
assert.True(t, eq, "%s: expected map %v, got %v", tt.name, l, tt.name)
})
}
}
@ -479,8 +475,7 @@ func TestErrRepoNotFound_Error(t *testing.T) {
e := ErrRepoNotFound{
Repos: tt.fields.Repos,
}
got := e.Error()
assert.EqualErrorf(t, e, tt.want, "Error() = %v, want %v", got, tt.want)
assert.EqualError(t, e, tt.want)
})
}
}

@ -78,8 +78,7 @@ func TestFuncMap(t *testing.T) {
// Test for Engine-specific template functions.
expect := []string{"include", "required", "tpl", "toYaml", "fromYaml", "toToml", "fromToml", "toJson", "fromJson", "lookup"}
for _, f := range expect {
_, ok := fns[f]
assert.Truef(t, ok, "Expected add-on function %q", f)
assert.Containsf(t, fns, f, "Expected add-on function %q", f)
}
}
@ -412,8 +411,7 @@ func TestParseErrors(t *testing.T) {
}
_, err := new(Engine).render(t.Context(), tplsUndefinedFunction)
require.Error(t, err, "Expected failures while rendering")
expected := `parse error at (undefined_function:1): function "foo" not defined`
assert.EqualError(t, err, expected)
assert.EqualError(t, err, `parse error at (undefined_function:1): function "foo" not defined`)
}
func TestExecErrors(t *testing.T) {
@ -887,9 +885,8 @@ func TestRenderRecursionLimit(t *testing.T) {
expectErr := "rendering template has a nested reference name: recursion: unable to execute template"
_, err := Render(c, v)
if err == nil || !strings.HasSuffix(err.Error(), expectErr) {
t.Errorf("Expected err with suffix: %s", expectErr)
}
require.Error(t, err)
assert.True(t, strings.HasSuffix(err.Error(), expectErr), "Expected err with suffix: %s", expectErr)
// calling the same function many times is ok
times := 4000
@ -1261,18 +1258,14 @@ func TestRenderCustomTemplateFuncs(t *testing.T) {
require.NoError(t, err)
// Expected output should be "hello!!!".
expected := "hello!!!"
key := "CustomFunc/templates/manifest"
if rendered, ok := out[key]; !ok || rendered != expected {
t.Errorf("Expected %q, got %q", expected, rendered)
}
rendered, ok := out["CustomFunc/templates/manifest"]
require.True(t, ok)
assert.Equal(t, "hello!!!", rendered)
// Verify that the rendered template used the custom "upper" function.
expected = "custom:hello"
key = "CustomFunc/templates/override"
if rendered, ok := out[key]; !ok || rendered != expected {
t.Errorf("Expected %q, got %q", expected, rendered)
}
rendered, ok = out["CustomFunc/templates/override"]
require.True(t, ok)
assert.Equal(t, "custom:hello", rendered)
}
func TestTraceableError_SimpleForm(t *testing.T) {

@ -16,6 +16,7 @@ limitations under the License.
package engine
import (
"strconv"
"testing"
"github.com/stretchr/testify/assert"
@ -47,10 +48,10 @@ func TestNewFiles(t *testing.T) {
assert.Len(t, files, len(cases), "Expected len() = %d, got %d", len(cases), len(files))
for i, f := range cases {
got := string(files.GetBytes(f.path))
assert.Equalf(t, got, f.data, "%d: expected %q, got %q", i, f.data, got)
got = files.Get(f.path)
assert.Equalf(t, got, f.data, "%d: expected %q, got %q", i, f.data, got)
t.Run(strconv.Itoa(i), func(t *testing.T) {
assert.Equal(t, f.data, string(files.GetBytes(f.path)))
assert.Equal(t, f.data, files.Get(f.path))
})
}
}

@ -38,7 +38,7 @@ func TestError(t *testing.T) {
os.Unsetenv(name)
g := Gate(name)
assert.Equal(t, "this feature has been marked as experimental and is not enabled by default. Please set HELM_EXPERIMENTAL_FEATURE=1 in your environment to use this feature", g.Error().Error())
assert.EqualError(t, g.Error(), "this feature has been marked as experimental and is not enabled by default. Please set HELM_EXPERIMENTAL_FEATURE=1 in your environment to use this feature")
}
func TestString(t *testing.T) {

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

@ -122,9 +122,9 @@ func TestDownload(t *testing.T) {
const expectedUserAgent = "I am Groot"
basicAuthSrv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
username, password, ok := r.BasicAuth()
if !ok || username != "username" || password != "password" {
t.Errorf("Expected request to use basic auth and for username == 'username' and password == 'password', got '%v', '%s', '%s'", ok, username, password)
}
assert.True(t, ok, "Expected request to use basic auth")
assert.Equal(t, "username", username)
assert.Equal(t, "password", password)
assert.Equal(t, expectedUserAgent, r.UserAgent(), "Expected '%s', got '%s'", expectedUserAgent, r.UserAgent())
fmt.Fprint(w, expect)
}))
@ -147,9 +147,9 @@ func TestDownload(t *testing.T) {
// test with Get URL differing from withURL
crossAuthSrv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
username, password, ok := r.BasicAuth()
if ok || username == "username" || password == "password" {
t.Errorf("Expected request to not include but got '%v', '%s', '%s'", ok, username, password)
}
assert.False(t, ok)
assert.NotEqual(t, "username", username)
assert.NotEqual(t, "password", password)
fmt.Fprint(w, expect)
}))
@ -176,9 +176,9 @@ func TestDownload(t *testing.T) {
// test with Get URL differing from withURL and should pass creds
crossAuthSrv = httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
username, password, ok := r.BasicAuth()
if !ok || username != "username" || password != "password" {
t.Errorf("Expected request to use basic auth and for username == 'username' and password == 'password', got '%v', '%s', '%s'", ok, username, password)
}
assert.True(t, ok, "Expected request to use basic auth")
assert.Equal(t, "username", username)
assert.Equal(t, "password", password)
fmt.Fprint(w, expect)
}))

@ -55,23 +55,14 @@ func TestOCIGetter(t *testing.T) {
og, ok := g.(*OCIGetter)
require.True(t, ok, "expected NewOCIGetter to produce an *OCIGetter")
assert.Equal(t, "I", og.opts.username, "Expected NewOCIGetter to contain %q as the username, got %q", "I", og.opts.username)
assert.Equal(t, "Am", og.opts.password, "Expected NewOCIGetter to contain %q as the password, got %q", "Am", og.opts.password)
assert.Equal(t, pub, og.opts.certFile, "Expected NewOCIGetter to contain %q as the public key file, got %q", pub, og.opts.certFile)
assert.Equal(t, priv, og.opts.keyFile, "Expected NewOCIGetter to contain %q as the private key file, got %q", priv, og.opts.keyFile)
assert.Equal(t, ca, og.opts.caFile, "Expected NewOCIGetter to contain %q as the CA file, got %q", ca, og.opts.caFile)
assert.Equal(t, timeout, og.opts.timeout, "Expected NewOCIGetter to contain %s as Timeout flag, got %s", timeout, og.opts.timeout)
assert.Equal(t, transport, og.opts.transport, "Expected NewOCIGetter to contain %p as Transport, got %p", transport, og.opts.transport)
assert.Equal(t, plainHTTP, og.opts.plainHTTP, "Expected NewOCIGetter to have plainHTTP as %t, got %t", plainHTTP, og.opts.plainHTTP)
assert.Equal(t, insecureSkipVerifyTLS, og.opts.insecureSkipVerifyTLS, "Expected NewOCIGetter to have insecureSkipVerifyTLS as %t, got %t", insecureSkipVerifyTLS, og.opts.insecureSkipVerifyTLS)
// Test if setting registryClient is being passed to the ops
@ -84,7 +75,6 @@ func TestOCIGetter(t *testing.T) {
require.NoError(t, err)
og, ok = g.(*OCIGetter)
require.True(t, ok, "expected NewOCIGetter to produce an *OCIGetter")
assert.Equal(t, registryClient, og.opts.registryClient, "Expected NewOCIGetter to contain %p as RegistryClient, got %p", registryClient, og.opts.registryClient)
}

@ -567,17 +567,16 @@ func TestUpdate(t *testing.T) {
// Special handling for the rollback test case
if name == "rollback after failed upgrade with removed resource" {
assert.Empty(t, result.Created, "expected 0 resource created, got %d", len(result.Created))
assert.Len(t, result.Updated, 1, "expected 1 resource updated, got %d", len(result.Updated))
assert.Empty(t, result.Deleted, "expected 0 resource deleted, got %d", len(result.Deleted))
assert.Empty(t, result.Created, "expected 0 resource created")
assert.Len(t, result.Updated, 1, "expected 1 resource updated")
assert.Empty(t, result.Deleted, "expected 0 resource deleted")
} else {
assert.Len(t, result.Created, 1, "expected 1 resource created, got %d", len(result.Created))
assert.Len(t, result.Updated, 2, "expected 2 resource updated, got %d", len(result.Updated))
assert.Len(t, result.Deleted, 1, "expected 1 resource deleted, got %d", len(result.Deleted))
assert.Len(t, result.Created, 1, "expected 1 resource created")
assert.Len(t, result.Updated, 2, "expected 2 resource updated")
assert.Len(t, result.Deleted, 1, "expected 1 resource deleted")
}
if tc.ExpectedError != "" {
require.Error(t, err)
require.ErrorContains(t, err, tc.ExpectedError)
} else {
require.NoError(t, err)
@ -702,11 +701,11 @@ func TestPerform(t *testing.T) {
}
err = perform(infos, fn)
assert.Equal(t, tt.err, (err != nil), "expected error: %v", tt.err)
if err != nil {
require.EqualErrorf(t, err, tt.errMessage, "expected error message: %v, got %v", tt.errMessage, err)
if tt.err {
require.EqualError(t, err, tt.errMessage)
} else {
require.NoError(t, err)
}
assert.Len(t, results, tt.count, "expected %d result objects, got %d", tt.count, len(results))
})
}
@ -782,7 +781,6 @@ func TestWait(t *testing.T) {
require.NoError(t, err)
assert.Len(t, result.Created, 3, "expected 3 resource created, got %d", len(result.Created))
require.NoErrorf(t, c.Wait(resources, time.Second*30), "expected wait without error")
assert.GreaterOrEqualf(t, time.Since(*created), time.Second*5, "expected to wait at least 5 seconds before ready status was detected, but got %s", time.Since(*created))
}

@ -165,7 +165,11 @@ func Test_ReadyChecker_IsReady_Job(t *testing.T) {
require.NoError(t, err, "Failed to create Job")
got, err := c.IsReady(tt.args.ctx, tt.args.resource)
assert.Equal(t, tt.wantErr, (err != nil), "IsReady() error = %v, wantErr %v", err, tt.wantErr)
if tt.wantErr {
require.Error(t, err, "IsReady()")
} else {
require.NoError(t, err, "IsReady()")
}
assert.Equal(t, tt.want, got, "IsReady() = %v, want %v", got, tt.want)
})
}
@ -237,7 +241,11 @@ func Test_ReadyChecker_IsReady_Deployment(t *testing.T) {
require.NoError(t, err, "Failed to create ReplicaSet")
got, err := c.IsReady(tt.args.ctx, tt.args.resource)
assert.Equal(t, tt.wantErr, (err != nil), "IsReady() error = %v, wantErr %v", err, tt.wantErr)
if tt.wantErr {
require.Error(t, err, "IsReady()")
} else {
require.NoError(t, err, "IsReady()")
}
assert.Equal(t, tt.want, got, "IsReady() = %v, want %v", got, tt.want)
})
}
@ -303,7 +311,11 @@ func Test_ReadyChecker_IsReady_PersistentVolumeClaim(t *testing.T) {
require.NoError(t, err, "Failed to create PersistentVolumeClaim")
got, err := c.IsReady(tt.args.ctx, tt.args.resource)
assert.Equal(t, tt.wantErr, (err != nil), "IsReady() error = %v, wantErr %v", err, tt.wantErr)
if tt.wantErr {
require.Error(t, err, "IsReady()")
} else {
require.NoError(t, err, "IsReady()")
}
assert.Equal(t, tt.want, got, "IsReady() = %v, want %v", got, tt.want)
})
}
@ -369,7 +381,11 @@ func Test_ReadyChecker_IsReady_Service(t *testing.T) {
require.NoError(t, err, "Failed to create Service")
got, err := c.IsReady(tt.args.ctx, tt.args.resource)
assert.Equal(t, tt.wantErr, (err != nil), "IsReady() error = %v, wantErr %v", err, tt.wantErr)
if tt.wantErr {
require.Error(t, err, "IsReady()")
} else {
require.NoError(t, err, "IsReady()")
}
assert.Equal(t, tt.want, got, "IsReady() = %v, want %v", got, tt.want)
})
}
@ -435,7 +451,11 @@ func Test_ReadyChecker_IsReady_DaemonSet(t *testing.T) {
require.NoError(t, err, "Failed to create DaemonSet")
got, err := c.IsReady(tt.args.ctx, tt.args.resource)
assert.Equal(t, tt.wantErr, (err != nil), "IsReady() error = %v, wantErr %v", err, tt.wantErr)
if tt.wantErr {
require.Error(t, err, "IsReady()")
} else {
require.NoError(t, err, "IsReady()")
}
assert.Equal(t, tt.want, got, "IsReady() = %v, want %v", got, tt.want)
})
}
@ -501,7 +521,11 @@ func Test_ReadyChecker_IsReady_StatefulSet(t *testing.T) {
require.NoError(t, err, "Failed to create StatefulSet")
got, err := c.IsReady(tt.args.ctx, tt.args.resource)
assert.Equal(t, tt.wantErr, (err != nil), "IsReady() error = %v, wantErr %v", err, tt.wantErr)
if tt.wantErr {
require.Error(t, err, "IsReady()")
} else {
require.NoError(t, err, "IsReady()")
}
assert.Equal(t, tt.want, got, "IsReady() = %v, want %v", got, tt.want)
})
}
@ -582,7 +606,11 @@ func Test_ReadyChecker_IsReady_ReplicationController(t *testing.T) {
require.NoError(t, err, "Failed to create ReplicationController")
got, err := c.IsReady(tt.args.ctx, tt.args.resource)
assert.Equal(t, tt.wantErr, (err != nil), "IsReady() error = %v, wantErr %v", err, tt.wantErr)
if tt.wantErr {
require.Error(t, err, "IsReady()")
} else {
require.NoError(t, err, "IsReady()")
}
assert.Equal(t, tt.want, got, "IsReady() = %v, want %v", got, tt.want)
})
}
@ -646,7 +674,11 @@ func Test_ReadyChecker_IsReady_ReplicaSet(t *testing.T) {
}
//
got, err := c.IsReady(tt.args.ctx, tt.args.resource)
assert.Equal(t, tt.wantErr, (err != nil), "IsReady() error = %v, wantErr %v", err, tt.wantErr)
if tt.wantErr {
require.Error(t, err, "IsReady()")
} else {
require.NoError(t, err, "IsReady()")
}
assert.Equal(t, tt.want, got, "IsReady() = %v, want %v", got, tt.want)
})
}
@ -1044,9 +1076,10 @@ func Test_ReadyChecker_jobReady(t *testing.T) {
t.Run(tt.name, func(t *testing.T) {
c := NewReadyChecker(fake.NewClientset())
got, err := c.jobReady(tt.args.job)
if (err != nil) != tt.wantErr {
t.Errorf("jobReady() error = %v, wantErr %v", err, tt.wantErr)
return
if tt.wantErr {
require.Error(t, err, "jobReady()")
} else {
require.NoError(t, err, "jobReady()")
}
assert.Equal(t, tt.want, got, "jobReady() = %v, want %v", got, tt.want)
})

@ -20,6 +20,7 @@ import (
"testing"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"k8s.io/apimachinery/pkg/api/meta"
"k8s.io/apimachinery/pkg/runtime/schema"
"k8s.io/cli-runtime/pkg/resource"
@ -41,14 +42,12 @@ func TestResourceList(t *testing.T) {
assert.Equal(t, "pod", r1.Get(info("bar")).Mapping.Resource.Resource, "expected get pod")
diff := r1.Difference(r2)
assert.Len(t, diff, 1, "expected 1 result")
assert.True(t, diff.Contains(info("foo")), "expected diff to return foo")
require.Len(t, diff, 1, "expected 1 result")
assert.Contains(t, diff, info("foo"), "expected diff to return foo")
inter := r1.Intersect(r2)
assert.Len(t, inter, 1, "expected 1 result")
assert.True(t, inter.Contains(info("bar")), "expected intersect to return bar")
require.Len(t, inter, 1, "expected 1 result")
assert.Contains(t, inter, info("bar"), "expected intersect to return bar")
}
func TestIsMatchingInfo(t *testing.T) {

@ -297,8 +297,7 @@ func TestLegacyWaiter_waitForPodSuccess(t *testing.T) {
t.Run(tt.name, func(t *testing.T) {
done, err := lw.waitForPodSuccess(tt.obj, "foo")
if tt.wantErr {
require.Error(t, err, "expected error, got none")
require.ErrorContains(t, err, tt.errMessage, "expected error to contain %q, got %q", tt.errMessage, err.Error())
require.ErrorContains(t, err, tt.errMessage)
} else {
require.NoError(t, err)
}
@ -384,8 +383,7 @@ func TestLegacyWaiter_waitForJob(t *testing.T) {
t.Run(tt.name, func(t *testing.T) {
done, err := lw.waitForJob(tt.obj, "test-job")
if tt.wantErr {
require.Error(t, err, "expected error, got none")
require.ErrorContainsf(t, err, tt.errMessage, "expected error to contain %q, got %q", tt.errMessage, err.Error())
require.ErrorContains(t, err, tt.errMessage)
} else {
require.NoError(t, err)
assert.Equal(t, tt.wantDone, done, "got done=%v, want %v", done, tt.wantDone)

@ -141,12 +141,11 @@ func TestRetryingRoundTripper_RoundTrip(t *testing.T) {
if tt.expectedErr != "" {
require.ErrorContains(t, err, tt.expectedErr)
return
} else {
require.NoError(t, err)
assert.Equal(t, tt.expectedCode, resp.StatusCode)
assert.Equal(t, tt.expectedCalls, fakeRT.calls)
}
require.NoError(t, err)
assert.Equal(t, tt.expectedCode, resp.StatusCode)
assert.Equal(t, tt.expectedCalls, fakeRT.calls)
})
}
}

@ -128,9 +128,7 @@ func TestParseMessageBlock(t *testing.T) {
func TestLoadKey(t *testing.T) {
k, err := loadKey(testKeyfile)
require.NoError(t, err)
_, ok := k.Identities[testKeyName]
assert.Truef(t, ok, "Expected to load a key for user %q", testKeyName)
assert.Containsf(t, k.Identities, testKeyName, "Expected to load a key for user %q", testKeyName)
}
func TestLoadKeyRing(t *testing.T) {
@ -163,8 +161,7 @@ func TestNewFromFiles(t *testing.T) {
s, err := NewFromFiles(testKeyfile, testPubfile)
require.NoError(t, err)
_, ok := s.Entity.Identities[testKeyName]
assert.Truef(t, ok, "Expected to load a key for user %q", testKeyName)
assert.Containsf(t, s.Entity.Identities, testKeyName, "Expected to load a key for user %q", testKeyName)
}
func TestDigestFile(t *testing.T) {
@ -240,7 +237,6 @@ func TestMixedKeyringRSASigningAndVerification(t *testing.T) {
}
assert.True(t, hasEdDSA, "expected %s to include an Ed25519 public key", testMixedKeyring)
require.NotNil(t, signer.Entity, "expected signer entity to be loaded")
require.NotNil(t, signer.Entity.PrivateKey, "expected signer private key to be loaded")
assert.Equal(t, packet.PubKeyAlgoRSA, signer.Entity.PrivateKey.PubKeyAlgo, "expected RSA key")
@ -259,9 +255,7 @@ func TestMixedKeyringRSASigningAndVerification(t *testing.T) {
require.NotNil(t, verification.SignedBy, "expected verification to include signer")
require.NotNil(t, verification.SignedBy.PrimaryKey, "expected verification to include signer primary key")
assert.Equal(t, packet.PubKeyAlgoRSA, verification.SignedBy.PrimaryKey.PubKeyAlgo, "expected verification to report RSA key")
_, ok := verification.SignedBy.Identities[testKeyName]
assert.True(t, ok, "expected verification to be signed by %q", testKeyName)
assert.Contains(t, verification.SignedBy.Identities, testKeyName, "expected verification to be signed by %q", testKeyName)
}
// failSigner always fails to sign and returns an error

@ -33,8 +33,7 @@ func TestNewOCIPusher(t *testing.T) {
p, err := NewOCIPusher()
require.NoError(t, err)
_, ok := p.(*OCIPusher)
require.True(t, ok, "Expected NewOCIPusher to produce an *OCIPusher")
require.IsType(t, &OCIPusher{}, p, "Expected NewOCIPusher to produce an *OCIPusher")
cd := "../../testdata"
join := filepath.Join
@ -196,7 +195,7 @@ func TestOCIPusher_newRegistryClient(t *testing.T) {
if tt.expectError {
require.Error(t, err, "Expected error but got none")
if tt.errorContains != "" {
require.ErrorContainsf(t, err, tt.errorContains, "Expected error containing %q, got %q", tt.errorContains, err.Error())
require.ErrorContains(t, err, tt.errorContains)
}
} else {
require.NoError(t, err)

@ -232,8 +232,7 @@ func TestGenerateOCICreatedAnnotations(t *testing.T) {
result := generateOCIAnnotations(testChart, nowTimeString)
// Check that created annotation exists
_, ok := result[ocispec.AnnotationCreated]
assert.True(t, ok, "%s annotation not created", ocispec.AnnotationCreated)
assert.Contains(t, result, ocispec.AnnotationCreated, "%s annotation not created", ocispec.AnnotationCreated)
// Verify value of created artifact in RFC3339 format
_, err := time.Parse(time.RFC3339, result[ocispec.AnnotationCreated])
@ -243,8 +242,7 @@ func TestGenerateOCICreatedAnnotations(t *testing.T) {
result = generateOCIAnnotations(testChart, "")
// Check that created annotation exists
_, ok = result[ocispec.AnnotationCreated]
require.True(t, ok, "%s annotation not created", ocispec.AnnotationCreated)
require.Contains(t, result, ocispec.AnnotationCreated, "%s annotation not created", ocispec.AnnotationCreated)
createdTimeAnnotation, err := time.Parse(time.RFC3339, result[ocispec.AnnotationCreated])
require.NoError(t, err, "%s annotation with value '%s' not in RFC3339 format", ocispec.AnnotationCreated, result[ocispec.AnnotationCreated])

@ -65,9 +65,9 @@ func TestLogin_ResetsForceAttemptOAuth2_OnSuccess(t *testing.T) {
if r.URL.Path == "/v2/" {
// Accept either HEAD or GET
w.WriteHeader(http.StatusOK)
return
} else {
http.NotFound(w, r)
}
http.NotFound(w, r)
}))
defer srv.Close()

@ -78,11 +78,10 @@ func TestGetPluginName(t *testing.T) {
if tt.expectErr {
assert.Error(t, err, "expected error but got none")
return
} else {
require.NoError(t, err)
assert.Equal(t, tt.expected, pluginName)
}
require.NoError(t, err)
assert.Equal(t, tt.expected, pluginName)
})
}
}

@ -376,23 +376,21 @@ func initFakeRegistryTestServer() string {
if err != nil {
w.WriteHeader(http.StatusInternalServerError)
w.Write([]byte(err.Error()))
return
} else {
w.Header().Set("Content-Type", ProvLayerMediaType)
w.Write(data)
}
w.Header().Set("Content-Type", ProvLayerMediaType)
w.Write(data)
case "/v2/testrepo/image-index/blobs/sha256:e5ef611620fb97704d8751c16bab17fedb68883bfb0edc76f78a70e9173f9b55":
data, err := os.ReadFile("../downloader/testdata/signtest-0.1.0.tgz")
if err != nil {
w.WriteHeader(http.StatusInternalServerError)
w.Write([]byte(err.Error()))
return
} else {
w.Header().Set("Content-Type", ChartLayerMediaType)
w.Write(data)
}
w.Header().Set("Content-Type", ChartLayerMediaType)
w.Write(data)
default:
w.WriteHeader(http.StatusNotFound)
}

@ -143,7 +143,6 @@ metadata:
// This test will fail if 'six' or 'seven' was added.
assert.Len(t, generic, 2)
assert.Len(t, hs, 4)
for _, out := range hs {

@ -175,9 +175,8 @@ func TestFindChartInAuthAndTLSAndPassRepoURL(t *testing.T) {
// versions of Darwin do not. As there are people developing Helm using both old and new versions of Darwin we test
// for both messages.
if runtime.GOOS == "darwin" {
if !strings.Contains(err.Error(), "x509: “Acme Co” certificate is not trusted") && !strings.Contains(err.Error(), "x509: certificate signed by unknown authority") {
t.Errorf("Expected TLS error for function FindChartInAuthAndTLSAndPassRepoURL not found, but got a different error (%v)", err)
}
require.Error(t, err)
assert.True(t, strings.Contains(err.Error(), "x509: “Acme Co” certificate is not trusted") || strings.Contains(err.Error(), "x509: certificate signed by unknown authority"), "Expected TLS error for function FindChartInAuthAndTLSAndPassRepoURL not found, but got a different error (%v)", err)
} else {
assert.ErrorContainsf(t, err, "x509: certificate signed by unknown authority", "Expected TLS error for function FindChartInAuthAndTLSAndPassRepoURL not found, but got a different error")
}
@ -203,7 +202,6 @@ func TestErrorFindChartInRepoURL(t *testing.T) {
})
_, err := FindChartInRepoURL("http://someserver/something", "nginx", g)
require.Error(t, err, "Expected error for bad chart URL, but did not get any errors")
require.ErrorContainsf(t, err, `looks like "http://someserver/something" is not a valid chart repository or cannot be reached`, "Expected error for bad chart URL, but got a different error")
srv, err := startLocalServerForTests(nil)
@ -211,16 +209,13 @@ func TestErrorFindChartInRepoURL(t *testing.T) {
defer srv.Close()
_, err = FindChartInRepoURL(srv.URL, "nginx1", g)
require.Error(t, err, "Expected error for chart not found, but did not get any errors")
require.EqualError(t, err, `chart "nginx1" not found in `+srv.URL+` repository`, "Expected error for chart not found, but got a different error")
require.ErrorIs(t, err, ChartNotFoundError{}, "error is not of correct error type structure")
_, err = FindChartInRepoURL(srv.URL, "nginx1", g, WithChartVersion("0.1.0"))
require.Error(t, err, "Expected error for chart not found, but did not get any errors")
require.EqualError(t, err, `chart "nginx1" version "0.1.0" not found in `+srv.URL+` repository`, "Expected error for chart not found, but got a different error")
_, err = FindChartInRepoURL(srv.URL, "chartWithNoURL", g)
require.Error(t, err, "Expected error for no chart URLs available, but did not get any errors")
assert.EqualError(t, err, `chart "chartWithNoURL" has no downloadable URLs`, "Expected error for chart not found, but got a different error")
}

@ -116,9 +116,8 @@ func TestIndexFile(t *testing.T) {
assert.Equalf(t, "0.2.0", v, "Unexpected first version: %s", v)
cv, err := i.Get("setter", "0.1.9")
if err == nil && !strings.Contains(cv.Version, "0.1.9") {
t.Errorf("Unexpected version: %s", cv.Version)
}
require.NoError(t, err)
assert.Contains(t, cv.Version, "0.1.9", "Unexpected version: %s", cv.Version)
cv, err = i.Get("setter", "0.1.9+alpha")
require.NoError(t, err, "Expected version: 0.1.9+alpha")
@ -304,9 +303,8 @@ func verifyLocalIndex(t *testing.T, i *IndexFile) {
require.Equalf(t, 1, l, "'alpine' should have 1 chart, got %d", l)
nginx, ok := i.Entries["nginx"]
if !ok || len(nginx) != 2 {
t.Fatal("Expected 2 nginx entries")
}
require.True(t, ok)
require.Len(t, nginx, 2, "Expected 2 nginx entries")
expects := []*ChartVersion{
{
@ -507,18 +505,14 @@ func TestIgnoreSkippableChartValidationError(t *testing.T) {
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
result := ignoreSkippableChartValidationError(tc.Input)
if tc.Input == nil {
switch {
case tc.Input == nil:
assert.NoError(t, result, "expected nil result for nil input")
return
}
if tc.ErrorSkipped {
case tc.ErrorSkipped:
assert.NoError(t, result, "expected nil result for skipped error")
return
default:
assert.ErrorIs(t, tc.Input, result, "expected the result equal to input")
}
assert.ErrorIs(t, tc.Input, result, "expected the result equal to input")
})
}
}

@ -120,11 +120,8 @@ func TestRemoveRepository(t *testing.T) {
)
removeRepository := "stable"
found := sampleRepository.Remove(removeRepository)
assert.Truef(t, found, "expected repository %s not found", removeRepository)
found = sampleRepository.Has(removeRepository)
assert.Falsef(t, found, "repository %s not deleted", removeRepository)
assert.Truef(t, sampleRepository.Remove(removeRepository), "expected repository %s not found", removeRepository)
assert.Falsef(t, sampleRepository.Has(removeRepository), "repository %s not deleted", removeRepository)
}
func TestUpdateRepository(t *testing.T) {
@ -205,9 +202,6 @@ func TestRemoveRepositoryInvalidEntries(t *testing.T) {
)
removeRepository := "stable"
found := sampleRepository.Remove(removeRepository)
assert.Truef(t, found, "expected repository %s not found", removeRepository)
found = sampleRepository.Has(removeRepository)
assert.Falsef(t, found, "repository %s not deleted", removeRepository)
assert.Truef(t, sampleRepository.Remove(removeRepository), "expected repository %s not found", removeRepository)
assert.Falsef(t, sampleRepository.Has(removeRepository), "repository %s not deleted", removeRepository)
}

@ -42,24 +42,25 @@ func TestServer(t *testing.T) {
c, err := srv.CopyCharts("testdata/*.tgz")
require.NoError(t, err)
assert.Len(t, c, 1)
require.Len(t, c, 1)
assert.Equal(t, "examplechart-0.1.0.tgz", filepath.Base(c[0]))
req, err := http.NewRequestWithContext(t.Context(), http.MethodGet, srv.URL()+"/examplechart-0.1.0.tgz", http.NoBody)
require.NoError(t, err)
client := http.DefaultClient
res, err := client.Do(req)
require.NoError(t, err)
res.Body.Close()
res.Body.Close()
assert.GreaterOrEqual(t, res.ContentLength, int64(500))
req, err = http.NewRequestWithContext(t.Context(), http.MethodGet, srv.URL()+"/index.yaml", http.NoBody)
require.NoError(t, err)
res, err = client.Do(req)
require.NoError(t, err)
data, err := io.ReadAll(res.Body)
res.Body.Close()
require.NoError(t, err)

@ -16,7 +16,6 @@ package driver
import (
"encoding/base64"
"encoding/json"
"reflect"
"testing"
"github.com/stretchr/testify/assert"
@ -46,7 +45,7 @@ func TestConfigMapGet(t *testing.T) {
got, err := cfgmaps.Get(key)
require.NoError(t, err, "Failed to get release")
// compare fetched release with original
assert.Truef(t, reflect.DeepEqual(rel, got), "Expected {%v}, got {%v}", rel, got)
assert.Equalf(t, rel, got, "Expected {%v}, got {%v}", rel, got)
}
func TestUncompressedConfigMapGet(t *testing.T) {
@ -70,7 +69,7 @@ func TestUncompressedConfigMapGet(t *testing.T) {
got, err := cfgmaps.Get(key)
require.NoError(t, err, "Failed to get release")
// compare fetched release with original
assert.Truef(t, reflect.DeepEqual(rel, got), "Expected {%v}, got {%v}", rel, got)
assert.Equalf(t, rel, got, "Expected {%v}, got {%v}", rel, got)
}
func convertReleaserToV1(t *testing.T, rel release.Releaser) *rspb.Release {
@ -105,7 +104,7 @@ func TestConfigMapList(t *testing.T) {
})
// check
require.NoError(t, err, "Failed to list deleted")
assert.Len(t, del, 2, "Expected 2 deleted, got %d:\n%v\n", len(del), del)
assert.Len(t, del, 2, "Expected 2 deleted")
// list all deployed releases
dpl, err := cfgmaps.List(func(rel release.Releaser) bool {
@ -114,7 +113,7 @@ func TestConfigMapList(t *testing.T) {
})
// check
require.NoError(t, err, "Failed to list deployed")
assert.Len(t, dpl, 2, "Expected 2 deployed, got %d", len(dpl))
assert.Len(t, dpl, 2, "Expected 2 deployed")
// list all superseded releases
ssd, err := cfgmaps.List(func(rel release.Releaser) bool {
@ -123,13 +122,11 @@ func TestConfigMapList(t *testing.T) {
})
// check
require.NoError(t, err, "Failed to list superseded")
assert.Len(t, ssd, 2, "Expected 2 superseded, got %d", len(ssd))
assert.Len(t, ssd, 2, "Expected 2 superseded")
// Check if release having both system and custom labels, this is needed to ensure that selector filtering would work.
rls := convertReleaserToV1(t, ssd[0])
_, ok := rls.Labels["name"]
require.True(t, ok, "Expected 'name' label in results, actual %v", rls.Labels)
_, ok = rls.Labels["key1"]
require.True(t, ok, "Expected 'key1' label in results, actual %v", rls.Labels)
require.Contains(t, rls.Labels, "name", "Expected 'name' label in results, actual %v", rls.Labels)
require.Contains(t, rls.Labels, "key1", "Expected 'key1' label in results, actual %v", rls.Labels)
}
func TestConfigMapQuery(t *testing.T) {
@ -144,7 +141,7 @@ func TestConfigMapQuery(t *testing.T) {
rls, err := cfgmaps.Query(map[string]string{"status": "deployed"})
require.NoError(t, err, "Failed to query")
assert.Len(t, rls, 2, "Expected 2 results, got %d", len(rls))
assert.Len(t, rls, 2, "Expected 2 results")
_, err = cfgmaps.Query(map[string]string{"name": "notExist"})
assert.ErrorIs(t, err, ErrReleaseNotFound)
@ -167,7 +164,7 @@ func TestConfigMapCreate(t *testing.T) {
require.NoError(t, err, "Failed to get release with key %q", key)
// compare created release with original
assert.Truef(t, reflect.DeepEqual(rel, got), "Expected {%v}, got {%v}", rel, got)
assert.Equalf(t, rel, got, "Expected {%v}, got {%v}", rel, got)
}
func TestConfigMapUpdate(t *testing.T) {
@ -210,7 +207,7 @@ func TestConfigMapDelete(t *testing.T) {
// perform the delete
rls, err := cfgmaps.Delete(key)
require.NoError(t, err, "Failed to delete release with key %q", key)
assert.Truef(t, reflect.DeepEqual(rel, rls), "Expected {%v}, got {%v}", rel, rls)
assert.Equalf(t, rel, rls, "Expected {%v}, got {%v}", rel, rls)
_, err = cfgmaps.Get(key)
assert.ErrorIs(t, err, ErrReleaseNotFound)
}

@ -18,6 +18,8 @@ package driver
import (
"testing"
"github.com/stretchr/testify/require"
)
func TestLabelsMatch(t *testing.T) {
@ -42,8 +44,12 @@ func TestLabelsMatch(t *testing.T) {
}
for _, tt := range tests {
if !tt.set1.match(tt.set2) && tt.expect {
t.Fatalf("Expected match '%s'\n", tt.desc)
}
t.Run(tt.desc, func(t *testing.T) {
if tt.expect {
require.True(t, tt.set1.match(tt.set2))
} else {
require.False(t, tt.set1.match(tt.set2))
}
})
}
}

@ -18,7 +18,6 @@ package driver
import (
"fmt"
"reflect"
"testing"
"github.com/stretchr/testify/assert"
@ -112,7 +111,7 @@ func TestMemoryList(t *testing.T) {
})
// check
require.NoError(t, err, "Failed to list deployed releases")
assert.Len(t, dpl, 2, "Expected 2 deployed, got %d", len(dpl))
assert.Len(t, dpl, 2, "Expected 2 deployed")
// list all superseded releases
ssd, err := ts.List(func(rel release.Releaser) bool {
@ -121,7 +120,7 @@ func TestMemoryList(t *testing.T) {
})
// check
require.NoError(t, err, "Failed to list superseded releases")
assert.Len(t, ssd, 6, "Expected 6 superseded, got %d", len(ssd))
assert.Len(t, ssd, 6, "Expected 6 superseded")
// list all deleted releases
del, err := ts.List(func(rel release.Releaser) bool {
@ -210,7 +209,7 @@ func TestMemoryUpdate(t *testing.T) {
r, err := ts.Get(tt.key)
require.NoError(t, err, "Failed to get")
require.Truef(t, reflect.DeepEqual(r, tt.rls), "Expected %v, actual %v\n", tt.rls, r)
require.Equalf(t, r, tt.rls, "Expected %v, actual %v\n", tt.rls, r)
}
}
}
@ -256,10 +255,8 @@ func TestMemoryDelete(t *testing.T) {
ts.SetNamespace("")
end, err := ts.Query(map[string]string{"status": "deployed"})
require.NoError(t, err, "Query failed")
endLen := len(end)
if startLen-2 != endLen {
t.Errorf("expected end to be %d instead of %d", startLen-2, endLen)
if !assert.Len(t, end, startLen-2) {
for _, ee := range end {
rac, err := release.NewAccessor(ee)
require.NoError(t, err, "unable to get release accessor")

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

@ -16,7 +16,6 @@ package driver
import (
"encoding/base64"
"encoding/json"
"reflect"
"testing"
"github.com/stretchr/testify/assert"
@ -46,7 +45,7 @@ func TestSecretGet(t *testing.T) {
got, err := secrets.Get(key)
require.NoError(t, err, "Failed to get release")
// compare fetched release with original
assert.Truef(t, reflect.DeepEqual(rel, got), "Expected {%v}, got {%v}", rel, got)
assert.Equalf(t, rel, got, "Expected {%v}, got {%v}", rel, got)
}
func TestUNcompressedSecretGet(t *testing.T) {
@ -70,7 +69,7 @@ func TestUNcompressedSecretGet(t *testing.T) {
got, err := secrets.Get(key)
require.NoError(t, err, "Failed to get release")
// compare fetched release with original
assert.Truef(t, reflect.DeepEqual(rel, got), "Expected {%v}, got {%v}", rel, got)
assert.Equalf(t, rel, got, "Expected {%v}, got {%v}", rel, got)
}
func TestSecretList(t *testing.T) {
@ -90,7 +89,7 @@ func TestSecretList(t *testing.T) {
})
// check
require.NoError(t, err, "Failed to list deleted")
assert.Len(t, del, 2, "Expected 2 deleted, got %d:\n%v\n", len(del), del)
assert.Len(t, del, 2, "Expected 2 deleted")
// list all deployed releases
dpl, err := secrets.List(func(rel release.Releaser) bool {
@ -99,7 +98,7 @@ func TestSecretList(t *testing.T) {
})
// check
require.NoError(t, err, "Failed to list deployed")
assert.Len(t, dpl, 2, "Expected 2 deployed, got %d", len(dpl))
assert.Len(t, dpl, 2, "Expected 2 deployed")
// list all superseded releases
ssd, err := secrets.List(func(rel release.Releaser) bool {
@ -108,13 +107,11 @@ func TestSecretList(t *testing.T) {
})
// check
require.NoError(t, err, "Failed to list superseded")
assert.Len(t, ssd, 2, "Expected 2 superseded, got %d", len(ssd))
require.Len(t, ssd, 2, "Expected 2 superseded")
// Check if release having both system and custom labels, this is needed to ensure that selector filtering would work.
rls := convertReleaserToV1(t, ssd[0])
_, ok := rls.Labels["name"]
require.True(t, ok, "Expected 'name' label in results, actual %v", rls.Labels)
_, ok = rls.Labels["key1"]
require.True(t, ok, "Expected 'key1' label in results, actual %v", rls.Labels)
require.Contains(t, rls.Labels, "name", "Expected 'name' label in results, actual %v", rls.Labels)
require.Contains(t, rls.Labels, "key1", "Expected 'key1' label in results, actual %v", rls.Labels)
}
func TestSecretQuery(t *testing.T) {
@ -152,7 +149,7 @@ func TestSecretCreate(t *testing.T) {
require.NoError(t, err, "Failed to get release with key %q", key)
// compare created release with original
assert.Truef(t, reflect.DeepEqual(rel, got), "Expected {%v}, got {%v}", rel, got)
assert.Equalf(t, rel, got, "Expected {%v}, got {%v}", rel, got)
}
func TestSecretUpdate(t *testing.T) {
@ -195,7 +192,7 @@ func TestSecretDelete(t *testing.T) {
// perform the delete
rls, err := secrets.Delete(key)
require.NoError(t, err, "Failed to delete release with key %q", key)
assert.Truef(t, reflect.DeepEqual(rel, rls), "Expected {%v}, got {%v}", rel, rls)
assert.Equalf(t, rel, rls, "Expected {%v}, got {%v}", rel, rls)
_, err = secrets.Get(key)
assert.ErrorIs(t, err, ErrReleaseNotFound)
}

@ -99,7 +99,7 @@ func TestSQLGet(t *testing.T) {
got, err := sqlDriver.Get(key)
require.NoError(t, err, "Failed to get release")
assert.Truef(t, reflect.DeepEqual(rel, got), "Expected release {%v}, got {%v}", rel, got)
assert.Equalf(t, rel, got, "Expected release {%v}, got {%v}", rel, got)
assert.NoErrorf(t, mock.ExpectationsWereMet(), "sql expectations weren't met")
}
@ -151,7 +151,7 @@ func TestSQLList(t *testing.T) {
})
// check
require.NoError(t, err, "Failed to list deleted")
assert.Len(t, del, 2, "Expected 2 deleted, got %d:\n%v\n", len(del), del)
assert.Len(t, del, 2, "Expected 2 deleted")
// list all deployed releases
dpl, err := sqlDriver.List(func(rel release.Releaser) bool {
@ -160,7 +160,7 @@ func TestSQLList(t *testing.T) {
})
// check
require.NoError(t, err, "Failed to list deployed")
assert.Len(t, dpl, 2, "Expected 2 deployed, got %d:\n%v\n", len(dpl), dpl)
assert.Len(t, dpl, 2, "Expected 2 deployed")
// list all superseded releases
ssd, err := sqlDriver.List(func(rel release.Releaser) bool {
@ -169,15 +169,13 @@ func TestSQLList(t *testing.T) {
})
// check
require.NoError(t, err, "Failed to list superseded")
assert.Len(t, ssd, 2, "Expected 2 superseded, got %d:\n%v\n", len(ssd), ssd)
require.Len(t, ssd, 2, "Expected 2 superseded")
require.NoErrorf(t, mock.ExpectationsWereMet(), "sql expectations weren't met")
// Check if release having both system and custom labels, this is needed to ensure that selector filtering would work.
rls := convertReleaserToV1(t, ssd[0])
_, ok := rls.Labels["name"]
require.True(t, ok, "Expected 'name' label in results, actual %v", rls.Labels)
_, ok = rls.Labels["key1"]
require.True(t, ok, "Expected 'key1' label in results, actual %v", rls.Labels)
require.Contains(t, rls.Labels, "name", "Expected 'name' label in results, actual %v", rls.Labels)
require.Contains(t, rls.Labels, "key1", "Expected 'key1' label in results, actual %v", rls.Labels)
}
func TestSqlCreate(t *testing.T) {
@ -414,18 +412,15 @@ func TestSqlQuery(t *testing.T) {
require.NoError(t, err, "failed to query for deployed smug-pigeon release")
for _, res := range results {
assert.Truef(t, reflect.DeepEqual(res, deployedRelease), "Expected release {%v}, got {%v}", deployedRelease, res)
assert.Equalf(t, res, deployedRelease, "Expected release {%v}, got {%v}", deployedRelease, res)
}
results, err = sqlDriver.Query(labelSetAll)
require.NoError(t, err, "failed to query release history for smug-pigeon")
assert.Len(t, results, 2, "expected a resultset of size 2, got %d", len(results))
assert.Len(t, results, 2, "expected a resultset of size 2")
for _, res := range results {
if !reflect.DeepEqual(res, deployedRelease) && !reflect.DeepEqual(res, supersededRelease) {
t.Errorf("Expected release {%v} or {%v}, got {%v}", deployedRelease, supersededRelease, res)
}
assert.False(t, !reflect.DeepEqual(res, deployedRelease) && !reflect.DeepEqual(res, supersededRelease), "Expected release {%v} or {%v}, got {%v}", deployedRelease, supersededRelease, res)
}
assert.NoErrorf(t, mock.ExpectationsWereMet(), "sql expectations weren't met")
@ -495,7 +490,7 @@ func TestSqlDelete(t *testing.T) {
assert.NoErrorf(t, err, "sql expectations weren't met")
require.NoError(t, err, "failed to delete release with key %q", key)
assert.Truef(t, reflect.DeepEqual(rel, deletedRelease), "Expected release {%v}, got {%v}", rel, deletedRelease)
assert.Equalf(t, rel, deletedRelease, "Expected release {%v}, got {%v}", rel, deletedRelease)
}
func mockGetReleaseCustomLabels(mock sqlmock.Sqlmock, key string, namespace string, labels map[string]string) {

@ -14,7 +14,6 @@ limitations under the License.
package driver
import (
"reflect"
"testing"
"github.com/stretchr/testify/assert"
@ -22,7 +21,7 @@ import (
func TestGetSystemLabel(t *testing.T) {
output := GetSystemLabels()
assert.Truef(t, reflect.DeepEqual(systemLabels, output), "Expected {%v}, got {%v}", systemLabels, output)
assert.Equalf(t, systemLabels, output, "Expected {%v}, got {%v}", systemLabels, output)
}
func TestIsSystemLabel(t *testing.T) {
@ -69,7 +68,7 @@ func TestFilterSystemLabels(t *testing.T) {
}
for _, test := range tests {
output := filterSystemLabels(test[0])
assert.Truef(t, reflect.DeepEqual(test[1], output), "Expected {%v}, got {%v}", test[1], output)
assert.Equalf(t, test[1], output, "Expected {%v}, got {%v}", test[1], output)
}
}
@ -101,6 +100,6 @@ func TestContainsSystemLabels(t *testing.T) {
}
for _, test := range tests {
output := ContainsSystemLabels(test.input)
assert.Truef(t, reflect.DeepEqual(test.output, output), "Expected {%v}, got {%v}", test.output, output)
assert.Equalf(t, test.output, output, "Expected {%v}, got {%v}", test.output, output)
}
}

@ -20,7 +20,6 @@ import (
"context"
"errors"
"log/slog"
"reflect"
"testing"
"github.com/stretchr/testify/assert"
@ -49,7 +48,7 @@ func TestStorageCreate(t *testing.T) {
require.NoError(t, err, "QueryRelease")
// verify the fetched and created release are the same
require.Truef(t, reflect.DeepEqual(rls, res), "Expected %v, got %v", rls, res)
require.Equalf(t, rls, res, "Expected %v, got %v", rls, res)
}
func TestStorageUpdate(t *testing.T) {
@ -74,7 +73,7 @@ func TestStorageUpdate(t *testing.T) {
require.NoError(t, err, "QueryRelease")
// verify updated and fetched releases are the same.
require.Truef(t, reflect.DeepEqual(rls, res), "Expected %v, got %v", rls, res)
require.Equalf(t, rls, res, "Expected %v, got %v", rls, res)
}
func TestStorageDelete(t *testing.T) {
@ -99,7 +98,7 @@ func TestStorageDelete(t *testing.T) {
require.NoError(t, err, "DeleteRelease")
// verify updated and fetched releases are the same.
require.Truef(t, reflect.DeepEqual(rls, res), "Expected %v, got %v", rls, res)
require.Equalf(t, rls, res, "Expected %v, got %v", rls, res)
hist, err := storage.History(rls.Name)
require.NoError(t, err)
@ -348,12 +347,12 @@ func TestStorageRemoveLeastRecent(t *testing.T) {
require.NoError(t, err)
rhist, err := releaseListToV1List(hist)
require.NoError(t, err)
if len(rhist) != storage.MaxHistory {
if !assert.Len(t, rhist, storage.MaxHistory) {
for _, item := range rhist {
t.Logf("%s %v", item.Name, item.Version)
}
t.Fatalf("expected %d items in history, got %d", storage.MaxHistory, len(rhist))
}
require.Len(t, rhist, storage.MaxHistory)
// We expect the existing records to be 3, 4, and 5.
for i, item := range rhist {
@ -392,14 +391,14 @@ func TestStorageDoNotDeleteDeployed(t *testing.T) {
// (the only deployed release), to still exist
hist, err := storage.History(name)
require.NoError(t, err)
if len(hist) != storage.MaxHistory {
if !assert.Len(t, hist, storage.MaxHistory) {
rhist, err := releaseListToV1List(hist)
require.NoError(t, err)
for _, item := range rhist {
t.Logf("%s %v", item.Name, item.Version)
}
t.Fatalf("expected %d items in history, got %d", storage.MaxHistory, len(rhist))
}
require.Len(t, hist, storage.MaxHistory)
expectedVersions := map[int]bool{
2: true,

@ -16,7 +16,6 @@ limitations under the License.
package strvals
import (
"bytes"
"fmt"
"strings"
"testing"
@ -279,29 +278,21 @@ func TestParseLiteral(t *testing.T) {
}
for _, tt := range cases {
got, err := ParseLiteral(tt.str)
if err != nil {
if !tt.err {
require.NoError(t, err, tt.str)
}
continue
}
if tt.err {
assert.Fail(t, "Expected error. Got nil", tt.str)
}
y1, err := yaml.Marshal(tt.expect)
require.NoError(t, err)
t.Run(tt.str, func(t *testing.T) {
got, err := ParseLiteral(tt.str)
if tt.err {
require.Error(t, err)
} else {
require.NoError(t, err)
y1, err := yaml.Marshal(tt.expect)
require.NoError(t, err)
y2, err := yaml.Marshal(got)
if err != nil {
require.NoError(t, err, "Error serializing parsed value")
}
y2, err := yaml.Marshal(got)
require.NoError(t, err, "Error serializing parsed value")
if !bytes.Equal(y1, y2) {
assert.Equal(t, string(y1), string(y2), tt.str)
}
assert.YAMLEq(t, string(y1), string(y2), tt.str)
}
})
}
}
@ -386,17 +377,13 @@ func TestParseLiteralInto(t *testing.T) {
}
for _, tt := range tests {
if err := ParseLiteralInto(tt.input, tt.got); err != nil {
require.NoError(t, err)
}
require.NoError(t, ParseLiteralInto(tt.input, tt.got))
if tt.err {
assert.Fail(t, "Expected error. Got nil", tt.input)
}
if tt.input2 != "" {
if err := ParseLiteralInto(tt.input2, tt.got); err != nil {
require.NoError(t, err)
}
require.NoError(t, ParseLiteralInto(tt.input2, tt.got))
if tt.err {
assert.Fail(t, "Expected error. Got nil", tt.input2)
}
@ -406,13 +393,9 @@ func TestParseLiteralInto(t *testing.T) {
require.NoError(t, err)
y2, err := yaml.Marshal(tt.got)
if err != nil {
require.NoError(t, err, "Error serializing parsed value")
}
require.NoError(t, err, "Error serializing parsed value")
if !bytes.Equal(y1, y2) {
assert.Equal(t, string(y1), string(y2), tt.input)
}
assert.YAMLEq(t, string(y1), string(y2), tt.input)
}
}
@ -447,29 +430,23 @@ func TestParseLiteralNestedLevels(t *testing.T) {
}
for _, tt := range tests {
got, err := ParseLiteral(tt.str)
if err != nil {
t.Run(tt.str, func(t *testing.T) {
got, err := ParseLiteral(tt.str)
if tt.err {
require.Error(t, err)
if tt.errStr != "" {
require.EqualError(t, err, tt.errStr)
}
continue
}
require.NoError(t, err, tt.str)
}
if tt.err {
assert.Fail(t, "Expected error. Got nil", tt.str)
}
y1, err := yaml.Marshal(tt.expect)
require.NoError(t, err)
} else {
require.NoError(t, err)
y1, err := yaml.Marshal(tt.expect)
require.NoError(t, err)
y2, err := yaml.Marshal(got)
require.NoError(t, err, "Error serializing parsed value")
y2, err := yaml.Marshal(got)
require.NoError(t, err, "Error serializing parsed value")
if !bytes.Equal(y1, y2) {
assert.Equal(t, string(y1), string(y2), tt.str)
}
assert.YAMLEq(t, string(y1), string(y2), tt.str)
}
})
}
}

@ -16,8 +16,8 @@ limitations under the License.
package strvals
import (
"bytes"
"fmt"
"strconv"
"strings"
"testing"
@ -383,50 +383,37 @@ func TestParseSet(t *testing.T) {
}
for _, tt := range tests {
got, err := Parse(tt.str)
if err != nil {
t.Run(tt.str, func(t *testing.T) {
got, err := Parse(tt.str)
if tt.err {
continue
}
require.NoError(t, err, tt.str)
}
if tt.err {
assert.Fail(t, "Expected error. Got nil", tt.str)
}
y1, err := yaml.Marshal(tt.expect)
require.NoError(t, err)
y2, err := yaml.Marshal(got)
if err != nil {
require.NoError(t, err, "Error serializing parsed value")
}
require.Error(t, err)
} else {
require.NoError(t, err)
y1, err := yaml.Marshal(tt.expect)
require.NoError(t, err)
y2, err := yaml.Marshal(got)
if err != nil {
require.NoError(t, err, "Error serializing parsed value")
}
if !bytes.Equal(y1, y2) {
assert.Equal(t, string(y1), string(y2), tt.str)
}
assert.YAMLEq(t, string(y1), string(y2), tt.str)
}
})
}
for _, tt := range testsString {
got, err := ParseString(tt.str)
if err != nil {
t.Run(tt.str, func(t *testing.T) {
got, err := ParseString(tt.str)
if tt.err {
continue
require.Error(t, err)
} else {
require.NoError(t, err)
y1, err := yaml.Marshal(tt.expect)
require.NoError(t, err)
y2, err := yaml.Marshal(got)
require.NoError(t, err, "Error serializing parsed value")
assert.YAMLEq(t, string(y1), string(y2))
}
require.NoError(t, err, tt.str)
}
if tt.err {
assert.Fail(t, "Expected error. Got nil", tt.str)
}
y1, err := yaml.Marshal(tt.expect)
require.NoError(t, err)
y2, err := yaml.Marshal(got)
if err != nil {
require.NoError(t, err, "Error serializing parsed value")
}
if !bytes.Equal(y1, y2) {
assert.Equal(t, string(y1), string(y2), tt.str)
}
})
}
}
@ -511,33 +498,26 @@ func TestParseInto(t *testing.T) {
err: false,
},
}
for _, tt := range tests {
if err := ParseInto(tt.input, tt.got); err != nil {
require.NoError(t, err)
}
if tt.err {
assert.Fail(t, "Expected error. Got nil", tt.input)
}
if tt.input2 != "" {
if err := ParseInto(tt.input2, tt.got); err != nil {
require.NoError(t, err)
}
for i, tt := range tests {
t.Run(strconv.Itoa(i), func(t *testing.T) {
require.NoError(t, ParseInto(tt.input, tt.got))
if tt.err {
assert.Fail(t, "Expected error. Got nil", tt.input2)
assert.Fail(t, "Expected error. Got nil", tt.input)
}
}
y1, err := yaml.Marshal(tt.expect)
require.NoError(t, err)
y2, err := yaml.Marshal(tt.got)
if err != nil {
require.NoError(t, err, "Error serializing parsed value")
}
if tt.input2 != "" {
require.NoError(t, ParseInto(tt.input2, tt.got))
if tt.err {
assert.Fail(t, "Expected error. Got nil", tt.input2)
}
}
if !bytes.Equal(y1, y2) {
assert.Equal(t, string(y1), string(y2), tt.input)
}
y1, err := yaml.Marshal(tt.expect)
require.NoError(t, err)
y2, err := yaml.Marshal(tt.got)
require.NoError(t, err, "Error serializing parsed value")
assert.YAMLEq(t, string(y1), string(y2), tt.input)
})
}
}
@ -564,13 +544,8 @@ func TestParseIntoString(t *testing.T) {
y1, err := yaml.Marshal(expect)
require.NoError(t, err)
y2, err := yaml.Marshal(got)
if err != nil {
require.NoError(t, err, "Error serializing parsed value")
}
if !bytes.Equal(y1, y2) {
assert.Equal(t, string(y1), string(y2), input)
}
require.NoError(t, err, "Error serializing parsed value")
assert.YAMLEq(t, string(y1), string(y2), input)
}
func TestParseJSON(t *testing.T) {
@ -650,27 +625,19 @@ func TestParseJSON(t *testing.T) {
},
}
for _, tt := range tests {
if err := ParseJSON(tt.input, tt.got); err != nil {
t.Run(tt.input, func(t *testing.T) {
err := ParseJSON(tt.input, tt.got)
if tt.err {
continue
require.Error(t, err)
} else {
require.NoError(t, err)
y1, err := yaml.Marshal(tt.expect)
require.NoError(t, err, "Error serializing expected value")
y2, err := yaml.Marshal(tt.got)
require.NoError(t, err, "Error serializing parsed value")
assert.YAMLEq(t, string(y1), string(y2))
}
require.NoError(t, err, tt.input)
}
if tt.err {
require.Fail(t, "Expected error. Got nil", tt.input)
}
y1, err := yaml.Marshal(tt.expect)
if err != nil {
require.NoError(t, err, "Error serializing expected value")
}
y2, err := yaml.Marshal(tt.got)
if err != nil {
require.NoError(t, err, "Error serializing parsed value")
}
if !bytes.Equal(y1, y2) {
assert.Equal(t, string(y1), string(y2), tt.input)
}
})
}
}
@ -693,14 +660,10 @@ func TestParseFile(t *testing.T) {
y1, err := yaml.Marshal(expect)
require.NoError(t, err)
y2, err := yaml.Marshal(got)
if err != nil {
require.NoError(t, err, "Error serializing parsed value")
}
if !bytes.Equal(y1, y2) {
assert.Equal(t, string(y1), string(y2), input)
}
y2, err := yaml.Marshal(got)
require.NoError(t, err, "Error serializing parsed value")
assert.YAMLEq(t, string(y1), string(y2), input)
}
func TestParseIntoFile(t *testing.T) {
@ -725,13 +688,9 @@ func TestParseIntoFile(t *testing.T) {
y1, err := yaml.Marshal(expect)
require.NoError(t, err)
y2, err := yaml.Marshal(got)
if err != nil {
require.NoError(t, err, "Error serializing parsed value")
}
require.NoError(t, err, "Error serializing parsed value")
if !bytes.Equal(y1, y2) {
assert.Equal(t, string(y1), string(y2), input)
}
assert.YAMLEq(t, string(y1), string(y2), input)
}
func TestToYAML(t *testing.T) {
@ -775,27 +734,23 @@ func TestParseSetNestedLevels(t *testing.T) {
}
for _, tt := range tests {
got, err := Parse(tt.str)
if err != nil {
t.Run(tt.str, func(t *testing.T) {
got, err := Parse(tt.str)
if tt.err {
require.Error(t, err)
if tt.errStr != "" {
require.EqualError(t, err, tt.errStr)
}
continue
}
require.NoError(t, err, tt.str)
}
if tt.err {
assert.Fail(t, "Expected error. Got nil", tt.str)
}
} else {
require.NoError(t, err)
y1, err := yaml.Marshal(tt.expect)
require.NoError(t, err)
y2, err := yaml.Marshal(got)
require.NoError(t, err, "Error serializing parsed value")
y1, err := yaml.Marshal(tt.expect)
require.NoError(t, err)
if !bytes.Equal(y1, y2) {
assert.Equal(t, string(y1), string(y2), tt.str)
}
y2, err := yaml.Marshal(got)
require.NoError(t, err, "Error serializing parsed value")
assert.YAMLEq(t, string(y1), string(y2), tt.str)
}
})
}
}

Loading…
Cancel
Save