Merge branch 'helm:main' into main

pull/31615/head
MrJack 2 months ago committed by GitHub
commit d558f4db04
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194

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

@ -39,14 +39,14 @@ require (
golang.org/x/term v0.45.0 golang.org/x/term v0.45.0
golang.org/x/text v0.40.0 golang.org/x/text v0.40.0
gopkg.in/yaml.v3 v3.0.1 // indirect gopkg.in/yaml.v3 v3.0.1 // indirect
k8s.io/api v0.36.2 k8s.io/api v0.36.3
k8s.io/apiextensions-apiserver v0.36.2 k8s.io/apiextensions-apiserver v0.36.3
k8s.io/apimachinery v0.36.2 k8s.io/apimachinery v0.36.3
k8s.io/apiserver v0.36.2 k8s.io/apiserver v0.36.3
k8s.io/cli-runtime v0.36.2 k8s.io/cli-runtime v0.36.3
k8s.io/client-go v0.36.2 k8s.io/client-go v0.36.3
k8s.io/klog/v2 v2.140.0 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 oras.land/oras-go/v2 v2.6.2
sigs.k8s.io/controller-runtime v0.24.1 sigs.k8s.io/controller-runtime v0.24.1
sigs.k8s.io/kustomize/kyaml v0.21.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/evanphx/json-patch.v4 v4.13.0 // indirect
gopkg.in/inf.v0 v0.9.1 // indirect gopkg.in/inf.v0 v0.9.1 // indirect
gopkg.in/yaml.v2 v2.4.0 // 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/kube-openapi v0.0.0-20260317180543-43fb72c5454a // indirect
k8s.io/utils v0.0.0-20260507154919-ff6756f316d2 // indirect k8s.io/utils v0.0.0-20260507154919-ff6756f316d2 // indirect
sigs.k8s.io/json v0.0.0-20250730193827-2d320260d730 // indirect sigs.k8s.io/json v0.0.0-20250730193827-2d320260d730 // indirect
sigs.k8s.io/kustomize/api v0.21.1 // indirect sigs.k8s.io/kustomize/api v0.21.1 // indirect
sigs.k8s.io/randfill v1.0.0 // 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.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 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= 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.3 h1:NxB+05W2UGqXWFXcLO0RB5cnqnUPP5v5sVlaOH0Iz4w=
k8s.io/api v0.36.2/go.mod h1:F4LbMO4brjZYh7yFkXWhynSvtB7YauxV4c+HHkNRGNg= k8s.io/api v0.36.3/go.mod h1:JzLQKqRHC5+I8RVj/lS3lCg0mg6nWI9Fo/Sk3ElxHzg=
k8s.io/apiextensions-apiserver v0.36.2 h1:3O5gqOj/dt2XWWbpMe+TXWpE9yU6pjM/tXxtHHJT/K4= k8s.io/apiextensions-apiserver v0.36.3 h1:dPmOAPhwTtqb1bTxbFPsy18KHPhktQeO3WUPXunZIB0=
k8s.io/apiextensions-apiserver v0.36.2/go.mod h1:cL1tBWe8XSaP1H30iWKGo7hf6iAUUUJPEU70dskmAnA= k8s.io/apiextensions-apiserver v0.36.3/go.mod h1:KTXFqgXiuw2pRoL+Wpmttqc+up9Xt/GohadPWeLLOa4=
k8s.io/apimachinery v0.36.2 h1:0PE/W/WNy1UX61NLbXY5TMbJ6UwLL6E6lAPkYrKFxbQ= k8s.io/apimachinery v0.36.3 h1:PkzMRBRG8joFD8EhCuQAtNPvJlxb82FwplP26HIzvAM=
k8s.io/apimachinery v0.36.2/go.mod h1:fvf/HOLXq9RId0rnDIbN1OEBvHXdQbLMM8nu0LcBUf4= k8s.io/apimachinery v0.36.3/go.mod h1:cTSjBWgPe/6CQyBKzY/hDIRWCQQQeK0mfLbml0UYFHE=
k8s.io/apiserver v0.36.2 h1:6vMnkmHZPeBloNkHUhmZYq7Ylv8WIB8xjyEl+eSt26E= k8s.io/apiserver v0.36.3 h1:MGSg2SkdfuytiDEcRylT5mQFmmSsbx90XFUO67Y4bsQ=
k8s.io/apiserver v0.36.2/go.mod h1:9PoQ2ikCytrZyZg11mGhLEF5m8Rgsb5FJmYJ4Wvnl1k= k8s.io/apiserver v0.36.3/go.mod h1:fVH7zv9EUNUA7Fl7LtDKh8aB9W7u1VQPSGtWV5SjUxg=
k8s.io/cli-runtime v0.36.2 h1:CconTvEeV4DJs4ZX3HQKCFbFRGsm6OtuBM9yjmMP2VM= k8s.io/cli-runtime v0.36.3 h1:g+eJ+M1sYpnNYp/q5fzaw2KejIL0Q7DH+xFl6YVoL4U=
k8s.io/cli-runtime v0.36.2/go.mod h1:LddcjiMf4YlnHO7c1Y7rEtDqL84FyiYVLco7V679GUU= k8s.io/cli-runtime v0.36.3/go.mod h1:hZpAqK8nSFXvvLaVCbzUPVp8e9TRLSTCfpNzMt7s3tE=
k8s.io/client-go v0.36.2 h1:bfgxmFKc9CgqsgX4xKLAAdmTQlWee7Ob/HlDOrJ5TBI= k8s.io/client-go v0.36.3 h1:M4JdVzXxYcZk4fGpfDdYnxSwhLKWCFoQsHW6t+z8Hfg=
k8s.io/client-go v0.36.2/go.mod h1:1vgO4OAlfPnoLcb+Rze2GF5rAr14w8qjrYMoyXJzQj0= k8s.io/client-go v0.36.3/go.mod h1:gcPwr0c87vjjG6HB6pWEqOeuYVoXSsREjzux2j6GF30=
k8s.io/component-base v0.36.2 h1:Z0VH80O7Ng0HDZnZj3WRR3urEGa0kTwmO8CwEwjVK1w= k8s.io/component-base v0.36.3 h1:vc/UFvPCkW0irPz84LAodAL1j3f4xktPM6dDJIEheAY=
k8s.io/component-base v0.36.2/go.mod h1:mGfFOA7Gwpdm1VW2cwSQYbiDIlz8GD2WGwH88QSeCyA= 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 h1:Tf+J3AH7xnUzZyVVXhTgGhEKnFqye14aadWv7bzXdzc=
k8s.io/klog/v2 v2.140.0/go.mod h1:o+/RWfJ6PwpnFn7OyAG3QnO47BFsymfEfrz6XyYSSp0= 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 h1:xCeOEAOoGYl2jnJoHkC3hkbPJgdATINPMAxaynU2Ovg=
k8s.io/kube-openapi v0.0.0-20260317180543-43fb72c5454a/go.mod h1:uGBT7iTA6c6MvqUvSXIaYZo9ukscABYi2btjhvgKGZ0= 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.3 h1:TesKp+XYQEjPYoFvuobcVnuvira2+/xAVlq//+kksaI=
k8s.io/kubectl v0.36.2/go.mod h1:gVbQ3B/yb4bSR2ggQ7rd0W6icUSWs7sduH4e16Vii+0= 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 h1:wU4tMEhLGgIbLvXQb1cfN+EcM0wf7zC6CPF+C79jroc=
k8s.io/utils v0.0.0-20260507154919-ff6756f316d2/go.mod h1:xDxuJ0whA3d0I4mf/C4ppKHxXynQ+fxnkmQH0vTHnuk= 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= 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/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 h1:JfjMILfT8A6RbawdsK2JXGBR5AQVfd+9TbzrlneTyrU=
sigs.k8s.io/randfill v1.0.0/go.mod h1:XeLlZ/jmk4i1HRopwe7/aU3H5n1zNUcX6TM94b3QxOY= 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.3 h1:u08YRbVUi59ri4YD6cg0UqNM4Dimn0sIl+wldcx5PYw=
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/go.mod h1:M3W8sfWvn2HhQDIbGWj3S099YozAsymCo/wrT5ohRUE=
sigs.k8s.io/yaml v1.6.0 h1:G8fkbMSAFqgEFgh4b1wmtzDnioxFCUgTZhlbj5P9QYs= sigs.k8s.io/yaml v1.6.0 h1:G8fkbMSAFqgEFgh4b1wmtzDnioxFCUgTZhlbj5P9QYs=
sigs.k8s.io/yaml v1.6.0/go.mod h1:796bPqUfzR/0jLAl6XjHl3Ck7MiyVv8dbTdyT3/pMf4= 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) { func TestBadCrdFileV3(t *testing.T) {
var values map[string]any var values map[string]any
m := RunAll(badCrdFileDir, values, namespace).Messages 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'") require.ErrorContains(t, m[0].Err, "apiVersion is not in 'apiextensions.k8s.io'")
assert.ErrorContains(t, m[1].Err, "object kind is not 'CustomResourceDefinition'") 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) { func TestGoodChart(t *testing.T) {
var values map[string]any var values map[string]any
m := RunAll(goodChartDir, values, namespace).Messages m := RunAll(goodChartDir, values, namespace).Messages
if len(m) != 0 { if !assert.Empty(t, m, "All returned linter messages when it shouldn't have") {
t.Error("All returned linter messages when it shouldn't have")
for i, msg := range m { for i, msg := range m {
t.Logf("Message %d: %s", i, msg) 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 // Note: we test with strict=true here, even though others have
// strict = false. // strict = false.
m := RunAll(createdChart, values, namespace, WithSkipSchemaValidation(true)).Messages m := RunAll(createdChart, values, namespace, WithSkipSchemaValidation(true)).Messages
if ll := len(m); ll != 1 { if !assert.Len(t, m, 1, "All should have had exactly 1 error") {
t.Errorf("All should have had exactly 1 error. Got %d", ll)
for i, msg := range m { for i, msg := range m {
t.Logf("Message %d: %s", i, msg.Error()) t.Logf("Message %d: %s", i, msg.Error())
} }
} else if msg := m[0].Err.Error(); !strings.Contains(msg, "icon is recommended") { } else {
t.Errorf("Unexpected lint error: %s", msg) assert.ErrorContains(t, m[0].Err, "icon is recommended")
} }
} }
@ -192,8 +190,7 @@ func TestHelmCreateChart_CheckDeprecatedWarnings(t *testing.T) {
func TestSubChartValuesChart(t *testing.T) { func TestSubChartValuesChart(t *testing.T) {
var values map[string]any var values map[string]any
m := RunAll(subChartValuesDir, values, namespace).Messages m := RunAll(subChartValuesDir, values, namespace).Messages
if len(m) != 0 { if !assert.Empty(t, m, "All returned linter messages when it shouldn't have") {
t.Error("All returned linter messages when it shouldn't have")
for i, msg := range m { for i, msg := range m {
t.Logf("Message %d: %s", i, msg) t.Logf("Message %d: %s", i, msg)
} }

@ -22,6 +22,7 @@ import (
"testing" "testing"
"github.com/stretchr/testify/assert" "github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"helm.sh/helm/v4/internal/chart/v3/lint/support" "helm.sh/helm/v4/internal/chart/v3/lint/support"
) )
@ -33,7 +34,7 @@ func TestInvalidCrdsDir(t *testing.T) {
Crds(&linter) Crds(&linter)
res := linter.Messages res := linter.Messages
assert.Len(t, res, 1) require.Len(t, res, 1)
assert.ErrorContains(t, res[0].Err, "not a directory") 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())} linter := support.Linter{ChartDir: filepath.Join(tmpdir, mychart.Name())}
Templates(&linter, values, namespace, strict) 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 { for i, msg := range linter.Messages {
t.Logf("Message %d: %s", i, msg) 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 var err deprecatedAPIError
require.ErrorAs(t, linter.Messages[0].Err, &err, "Expected error to be of type 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), ChartDir: filepath.Join(dir, ch.Metadata.Name),
} }
Templates(linter, ch.Values, namespace, strict) Templates(linter, ch.Values, namespace, strict)
if len(linter.Messages) != 0 { if !assert.Empty(t, linter.Messages, "expected zero messages") {
t.Errorf("expected zero messages, got %d", len(linter.Messages))
for i, msg := range linter.Messages { for i, msg := range linter.Messages {
t.Logf("Message %d: %q", i, msg) 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())} linter := support.Linter{ChartDir: filepath.Join(tmpdir, mychart.Name())}
Templates(&linter, values, namespace, strict) Templates(&linter, values, namespace, strict)
if l := len(linter.Messages); l > 0 { if !assert.Empty(t, linter.Messages) {
for i, msg := range linter.Messages { for i, msg := range linter.Messages {
t.Logf("Message %d: %s", i, msg) 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) { func TestValidateListAnnotations(t *testing.T) {
md := &k8sYamlStruct{ md := &k8sYamlStruct{

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

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

@ -101,7 +101,7 @@ func TestExpand(t *testing.T) {
require.NoError(t, err) require.NoError(t, err)
expectLen := 11 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 { for _, fi := range fis {
expect, err := os.Stat(filepath.Join("testdata", "frobnitz", fi.Name())) expect, err := os.Stat(filepath.Join("testdata", "frobnitz", fi.Name()))
@ -154,7 +154,7 @@ func TestExpandFile(t *testing.T) {
require.NoError(t, err) require.NoError(t, err)
expectLen := 11 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 { for _, fi := range fis {
expect, err := os.Stat(filepath.Join("testdata", "frobnitz", fi.Name())) expect, err := os.Stat(filepath.Join("testdata", "frobnitz", fi.Name()))

@ -69,9 +69,8 @@ func TestSave(t *testing.T) {
c2, err := loader.LoadFile(where) c2, err := loader.LoadFile(where)
require.NoError(t, err) require.NoError(t, err)
require.Equal(t, c.Name(), c2.Name(), "Expected chart archive to have %q, got %q", c.Name(), c2.Name()) 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" { require.Len(t, c2.Files, 1, "Files data did not match")
t.Fatal("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) { if !bytes.Equal(c.Schema, c2.Schema) {
indentation := 4 indentation := 4

@ -67,10 +67,10 @@ func mockArchiveServer() *httptest.Server {
if !strings.HasSuffix(r.URL.Path, ".tar.gz") { if !strings.HasSuffix(r.URL.Path, ".tar.gz") {
w.Header().Add("Content-Type", "text/html") w.Header().Add("Content-Type", "text/html")
fmt.Fprintln(w, "broken") 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) expectedReadmePerm := os.FileMode(0o777 &^ currentUmask)
pluginYAMLFullPath := filepath.Join(tempDir, "plugin.yaml") 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) 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") 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) 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) { func TestCleanJoin(t *testing.T) {

@ -34,8 +34,6 @@ func TestIsRemoteHTTPArchive(t *testing.T) {
// Test with invalid extension and unreachable server // 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.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.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") assert.False(t, isRemoteHTTPArchive(source+"-not-an-extension"), "Expected media type match to fail")
} }

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

@ -16,7 +16,6 @@ limitations under the License.
package plugin package plugin
import ( import (
"reflect"
"runtime" "runtime"
"testing" "testing"
@ -39,7 +38,7 @@ func TestPrepareCommand(t *testing.T) {
cmd, args, err := PrepareCommands(platformCommand, true, []string{}, env) cmd, args, err := PrepareCommands(platformCommand, true, []string{}, env)
require.NoError(t, err) require.NoError(t, err)
require.Equal(t, cmdMain, cmd, "Expected %q, got %q", cmdMain, cmd) 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) { func TestPrepareCommandExtraArgs(t *testing.T) {
@ -111,7 +110,7 @@ func TestPrepareCommands(t *testing.T) {
cmd, args, err := PrepareCommands(cmds, true, []string{}, env) cmd, args, err := PrepareCommands(cmds, true, []string{}, env)
require.NoError(t, err) require.NoError(t, err)
require.Equal(t, cmdMain, cmd, "Expected %q, got %q", cmdMain, cmd) 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) { func TestPrepareCommandsExtraArgs(t *testing.T) {
@ -132,7 +131,7 @@ func TestPrepareCommandsExtraArgs(t *testing.T) {
cmd, args, err := PrepareCommands(cmds, true, extraArgs, env) cmd, args, err := PrepareCommands(cmds, true, extraArgs, env)
require.NoError(t, err) require.NoError(t, err)
require.Equal(t, cmdMain, cmd, "Expected %q, got %q", cmdMain, cmd) 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) { func TestPrepareCommandsNoArch(t *testing.T) {
@ -149,7 +148,7 @@ func TestPrepareCommandsNoArch(t *testing.T) {
cmd, args, err := PrepareCommands(cmds, true, []string{}, env) cmd, args, err := PrepareCommands(cmds, true, []string{}, env)
require.NoError(t, err) require.NoError(t, err)
require.Equal(t, cmdMain, cmd, "Expected %q, got %q", cmdMain, cmd) 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) { func TestPrepareCommandsNoOsNoArch(t *testing.T) {
@ -166,7 +165,7 @@ func TestPrepareCommandsNoOsNoArch(t *testing.T) {
cmd, args, err := PrepareCommands(cmds, true, []string{}, env) cmd, args, err := PrepareCommands(cmds, true, []string{}, env)
require.NoError(t, err) require.NoError(t, err)
require.Equal(t, cmdMain, cmd, "Expected %q, got %q", cmdMain, cmd) 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) { func TestPrepareCommandsNoMatch(t *testing.T) {
@ -206,7 +205,7 @@ func TestPrepareCommandsExpand(t *testing.T) {
cmd, args, err := PrepareCommands(cmds, true, []string{}, env) cmd, args, err := PrepareCommands(cmds, true, []string{}, env)
require.NoError(t, err) require.NoError(t, err)
require.Equal(t, cmdMain, cmd, "Expected %q, got %q", cmdMain, cmd) 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) { func TestPrepareCommandsNoExpand(t *testing.T) {
@ -223,5 +222,5 @@ func TestPrepareCommandsNoExpand(t *testing.T) {
cmd, args, err := PrepareCommands(cmds, false, []string{}, env) cmd, args, err := PrepareCommands(cmds, false, []string{}, env)
require.NoError(t, err) require.NoError(t, err)
require.Equal(t, cmdMain, cmd, "Expected %q, got %q", cmdMain, cmd) 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. // This test will fail if 'six' or 'seven' was added.
assert.Len(t, generic, 2) assert.Len(t, generic, 2)
assert.Len(t, hs, 4) assert.Len(t, hs, 4)
for _, out := range hs { for _, out := range hs {

@ -148,28 +148,22 @@ func TestResolve(t *testing.T) {
for _, tt := range tests { for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) { t.Run(tt.name, func(t *testing.T) {
l, err := r.Resolve(tt.req, repoNames) l, err := r.Resolve(tt.req, repoNames)
if err != nil { if tt.err {
if tt.err { require.Error(t, err)
return } else {
}
require.NoError(t, err) 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 { // Check fields.
require.Failf(t, "Expected error in test %q", tt.name) 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 { for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) { t.Run(tt.name, func(t *testing.T) {
p, err := GetLocalPath(tt.repo, tt.chartpath) p, err := GetLocalPath(tt.repo, tt.chartpath)
if err != nil {
if tt.err {
return
}
require.NoError(t, err)
}
if tt.err { if tt.err {
require.Failf(t, "Expected error in test %q", tt.name) require.Error(t, err)
} } else {
expect := tt.expect require.NoError(t, err)
if runtime.GOOS == "windows" { if runtime.GOOS == "windows" {
expect = tt.winExpect 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) req.NoError(err)
is.Equal("with-notes", rel.Name) is.Equal("with-notes", rel.Name)
// test run can return as either 'parent\nchild' or 'child\nparent' // test run can return as either 'parent\nchild' or 'child\nparent'
if !strings.Contains(rel.Info.Notes, "parent") && !strings.Contains(rel.Info.Notes, "child") { 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)
t.Fatalf("Expected 'parent\nchild' or 'child\nparent', got '%s'", rel.Info.Notes)
}
is.Equal("Install complete", rel.Info.Description) is.Equal("Install complete", rel.Info.Description)
} }
@ -1096,7 +1094,7 @@ func TestInstallCRDs(t *testing.T) {
mockChart := buildChart(withFile(mockFile)) mockChart := buildChart(withFile(mockFile))
crdsToInstall := mockChart.CRDObjects() crdsToInstall := mockChart.CRDObjects()
assert.Len(t, crdsToInstall, 1) require.Len(t, crdsToInstall, 1)
assert.Equal(t, crdsToInstall[0].File.Data, mockFile.Data) assert.Equal(t, crdsToInstall[0].File.Data, mockFile.Data)
require.NoError(t, instAction.installCRDs(crdsToInstall)) require.NoError(t, instAction.installCRDs(crdsToInstall))
} }

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

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

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

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

@ -372,8 +372,7 @@ func TestMergeValues(t *testing.T) {
assert.True(t, ok, "Expected nested boat key to be present but it was removed") 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) subchart := v["pequod"].(map[string]any)["ahab"].(map[string]any)
_, ok = subchart["boat"] assert.Contains(t, subchart, "boat", "Expected subchart boat key to be present but it was removed")
assert.True(t, ok, "Expected subchart boat key to be present but it was removed")
_, ok = subchart["nested"].(map[string]any)["bar"] _, ok = subchart["nested"].(map[string]any)["bar"]
assert.True(t, ok, "Expected subchart nested bar key to be present but it was removed") 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 // This is one test that is different from CoalesceTables. Because hole
// is a nil value and it's not removed it's still present. // is a nil value and it's not removed it's still present.
_, ok = dst["hole"] assert.Contains(t, dst, "hole", "The hole no longer exists.")
assert.True(t, ok, "The hole no longer exists.")
dst2 := map[string]any{ dst2 := map[string]any{
"name": "Ishmael", "name": "Ishmael",
@ -559,8 +557,7 @@ func TestMergeTables(t *testing.T) {
det2, ok := dst2["details"].(map[string]any) det2, ok := dst2["details"].(map[string]any)
require.Truef(t, ok, "Details is the wrong type: %v", dst2["details"]) require.Truef(t, ok, "Details is the wrong type: %v", dst2["details"])
_, ok = det2["friends"] assert.Contains(t, det2, "friends", "Could not find your friends. Maybe you don't have any. :-(")
assert.True(t, ok, "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, "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.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") 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"]) is.Equal("bar", data["foo"])
// "baz" should be preserved with nil value since it wasn't in chart defaults // "baz" should be preserved with nil value since it wasn't in chart defaults
_, ok = data["baz"] is.Contains(data, "baz", "Expected data.baz key to be present but it was removed")
is.True(ok, "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") 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) { func TestBadCrdFile(t *testing.T) {
var values map[string]any var values map[string]any
m := RunAll(badCrdFileDir, values, namespace).Messages 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'") require.ErrorContains(t, m[0].Err, "apiVersion is not in 'apiextensions.k8s.io'")
assert.ErrorContains(t, m[1].Err, "object kind is not 'CustomResourceDefinition'") 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) { func TestGoodChart(t *testing.T) {
var values map[string]any var values map[string]any
m := RunAll(goodChartDir, values, namespace).Messages m := RunAll(goodChartDir, values, namespace).Messages
if len(m) != 0 { if !assert.Empty(t, m, "All returned linter messages when it shouldn't have") {
t.Error("All returned linter messages when it shouldn't have")
for i, msg := range m { for i, msg := range m {
t.Logf("Message %d: %s", i, msg) 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 // Note: we test with strict=true here, even though others have
// strict = false. // strict = false.
m := RunAll(createdChart, values, namespace, WithSkipSchemaValidation(true)).Messages m := RunAll(createdChart, values, namespace, WithSkipSchemaValidation(true)).Messages
if ll := len(m); ll != 1 { if !assert.Len(t, m, 1, "All should have had exactly 1 error") {
t.Errorf("All should have had exactly 1 error. Got %d", ll)
for i, msg := range m { for i, msg := range m {
t.Logf("Message %d: %s", i, msg.Error()) t.Logf("Message %d: %s", i, msg.Error())
} }
} else if msg := m[0].Err.Error(); !strings.Contains(msg, "icon is recommended") { } else {
t.Errorf("Unexpected lint error: %s", msg) assert.ErrorContains(t, m[0].Err, "icon is recommended")
} }
} }
@ -196,8 +194,7 @@ func TestHelmCreateChart_CheckDeprecatedWarnings(t *testing.T) {
func TestSubChartValuesChart(t *testing.T) { func TestSubChartValuesChart(t *testing.T) {
var values map[string]any var values map[string]any
m := RunAll(subChartValuesDir, values, namespace).Messages m := RunAll(subChartValuesDir, values, namespace).Messages
if len(m) != 0 { if !assert.Empty(t, m, "All returned linter messages when it shouldn't have") {
t.Error("All returned linter messages when it shouldn't have")
for i, msg := range m { for i, msg := range m {
t.Logf("Message %d: %s", i, msg) t.Logf("Message %d: %s", i, msg)
} }

@ -195,7 +195,6 @@ func TestChartfile(t *testing.T) {
expectedNumberOfErrorMessages := 7 expectedNumberOfErrorMessages := 7
require.Lenf(t, msgs, expectedNumberOfErrorMessages, "Expected %d errors, got %d", expectedNumberOfErrorMessages, len(msgs)) 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[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[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) 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 msgs := linter.Messages
expectedNumberOfErrorMessages := 4 expectedNumberOfErrorMessages := 4
if len(msgs) != expectedNumberOfErrorMessages { require.Len(t, msgs, expectedNumberOfErrorMessages, "Expected %d errors, got %d", expectedNumberOfErrorMessages, len(msgs))
t.Errorf("Expected %d errors, got %d", expectedNumberOfErrorMessages, len(msgs))
return
}
require.ErrorContains(t, msgs[0].Err, "version should be of type string", "Unexpected message 0: %s", msgs[0].Err) 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[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) 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" "testing"
"github.com/stretchr/testify/assert" "github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"helm.sh/helm/v4/pkg/chart/v2/lint/support" "helm.sh/helm/v4/pkg/chart/v2/lint/support"
) )
@ -33,7 +34,7 @@ func TestInvalidCrdsDir(t *testing.T) {
Crds(&linter) Crds(&linter)
res := linter.Messages res := linter.Messages
assert.Len(t, res, 1) require.Len(t, res, 1)
assert.ErrorContains(t, res[0].Err, "not a directory") 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)} linter := support.Linter{ChartDir: filepath.Join(tmp, c.Metadata.Name)}
Dependencies(&linter) Dependencies(&linter)
if l := len(linter.Messages); l != 2 { if !assert.Len(t, linter.Messages, 2, "expected 2 linter errors for bad chart dependencies") {
t.Errorf("expected 2 linter errors for bad chart dependencies. Got %d.", l)
for i, msg := range linter.Messages { for i, msg := range linter.Messages {
t.Logf("Message: %d, Error: %#v", i, msg) t.Logf("Message: %d, Error: %#v", i, msg)
} }

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

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

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

@ -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.Equal(t, "https://example.com/64x64.png", f.Icon, "Unexpected icon: %q", f.Icon)
assert.Len(t, f.Keywords, 3, "Unexpected keywords") assert.Len(t, f.Keywords, 3, "Unexpected keywords")
require.Len(t, f.Annotations, 2, "Unexpected annotations") require.Len(t, f.Annotations, 2, "Unexpected annotations")
assert.Equal(t, "extravalue", f.Annotations["extrakey"])
want, got := "extravalue", f.Annotations["extrakey"] assert.Equal(t, "anothervalue", f.Annotations["anotherkey"])
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)
kk := []string{"frobnitz", "sprocket", "dodad"} kk := []string{"frobnitz", "sprocket", "dodad"}
for i, k := range f.Keywords { for i, k := range f.Keywords {

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

@ -43,7 +43,7 @@ func TestLoadDependency(t *testing.T) {
} }
check := func(deps []*chart.Dependency) { 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 { 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.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) 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 package util
import "testing" import (
"testing"
"github.com/stretchr/testify/assert"
)
// TestValidateReleaseName is a regression test for ValidateName // TestValidateReleaseName is a regression test for ValidateName
// //
@ -46,12 +50,11 @@ func TestValidateReleaseName(t *testing.T) {
"a1111111111111111111111111111111111111111111111111111111111z": false, "a1111111111111111111111111111111111111111111111111111111111z": false,
} }
for input, expectPass := range names { for input, expectPass := range names {
if err := ValidateReleaseName(input); (err == nil) != expectPass { err := ValidateReleaseName(input)
st := "fail" if expectPass {
if expectPass { assert.NoError(t, err)
st = "succeed" } else {
} assert.Error(t, err)
t.Errorf("Expected %q to %s", input, st)
} }
} }
} }
@ -80,12 +83,11 @@ func TestValidateMetadataName(t *testing.T) {
"a1111111111111111111111111111111111111111111111111111111111z": false, "a1111111111111111111111111111111111111111111111111111111111z": false,
} }
for input, expectPass := range names { for input, expectPass := range names {
if err := ValidateMetadataName(input); (err == nil) != expectPass { err := ValidateMetadataName(input)
st := "fail" if expectPass {
if expectPass { assert.NoError(t, err)
st = "succeed" } else {
} assert.Error(t, err)
t.Errorf("Expected %q to %s", input, st)
} }
} }
} }

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

@ -18,9 +18,9 @@ package cmd
import ( import (
"fmt" "fmt"
"strings"
"testing" "testing"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require" "github.com/stretchr/testify/require"
chart "helm.sh/helm/v4/pkg/chart/v2" 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) testcmd := fmt.Sprintf("__complete %s ''", cmdName)
_, out, err := executeActionCommandC(storage, testcmd) _, out, err := executeActionCommandC(storage, testcmd)
require.NoError(t, err) require.NoError(t, err)
if !strings.Contains(out, "ShellCompDirectiveNoFileComp") != shouldBePerformed { if shouldBePerformed {
if shouldBePerformed { assert.NotContains(t, out, "ShellCompDirectiveNoFileComp", "Unexpected directive ShellCompDirectiveNoFileComp when completing '%s'", cmdName)
t.Errorf("Unexpected directive ShellCompDirectiveNoFileComp when completing '%s'", cmdName) } else {
} else { assert.Contains(t, out, "ShellCompDirectiveNoFileComp", "Did not receive directive ShellCompDirectiveNoFileComp when completing '%s'", cmdName)
t.Errorf("Did not receive directive ShellCompDirectiveNoFileComp when completing '%s'", cmdName)
}
t.Log(out)
} }
} }

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

@ -139,24 +139,22 @@ func TestPackage(t *testing.T) {
} }
} }
_, _, err = executeActionCommand(strings.Join(cmd, " ")) _, _, err = executeActionCommand(strings.Join(cmd, " "))
if tt.err {
if err != nil { require.Error(t, err)
if tt.err && re.MatchString(err.Error()) { require.True(t, re.MatchString(err.Error()))
return } 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 != "" { if v, ok := tt.flags["sign"]; ok && v == "1" {
fi, err := os.Stat(tt.hasfile) fi, err := os.Stat(tt.hasfile + ".prov")
require.NoErrorf(t, err, "%q: expected file %q", tt.name, tt.hasfile) require.NoErrorf(t, err, "%q: expected provenance file", tt.name)
assert.NotEqualf(t, 0, fi.Size(), "%q: file %q has zero bytes.", tt.name, tt.hasfile) 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) known, unknown := manuallyProcessArgs(input)
for i, k := range known { for i, k := range known {
if k != expectKnown[i] { assert.Equal(t, expectKnown[i], k, "expected known flag %d to be %q, got %q", i, expectKnown[i], k)
t.Errorf("expected known flag %d to be %q, got %q", i, expectKnown[i], k)
}
} }
for i, k := range unknown { for i, k := range unknown {
if k != expectUnknown[i] { assert.Equal(t, expectUnknown[i], k, "expected unknown flag %d to be %q, got %q", i, expectUnknown[i], k)
t.Errorf("expected unknown flag %d to be %q, got %q", i, expectUnknown[i], k)
}
} }
} }
@ -130,23 +126,17 @@ func TestLoadCLIPlugins(t *testing.T) {
pluginCmd := pluginCmds[i] pluginCmd := pluginCmds[i]
t.Run(fmt.Sprintf("%s-%d", pluginCmd.Name(), i), func(t *testing.T) { t.Run(fmt.Sprintf("%s-%d", pluginCmd.Name(), i), func(t *testing.T) {
out.Reset() out.Reset()
if pluginCmd.Use != tt.use { assert.Equal(t, tt.use, pluginCmd.Use, "%d: Expected Use=%q, got %q", i, tt.use, pluginCmd.Use)
t.Errorf("%d: Expected Use=%q, got %q", i, tt.use, pluginCmd.Use) assert.Equal(t, tt.short, pluginCmd.Short, "%d: Expected Use=%q, got %q", i, tt.short, pluginCmd.Short)
} assert.Equal(t, tt.long, pluginCmd.Long, "%d: Expected Use=%q, got %q", i, tt.long, pluginCmd.Long)
if pluginCmd.Short != tt.short {
t.Errorf("%d: Expected Use=%q, got %q", i, tt.short, pluginCmd.Short)
}
if pluginCmd.Long != tt.long {
t.Errorf("%d: Expected Use=%q, got %q", i, tt.long, pluginCmd.Long)
}
// Currently, plugins assume a Linux subsystem. Skip the execution // Currently, plugins assume a Linux subsystem. Skip the execution
// tests until this is fixed // tests until this is fixed
if runtime.GOOS != "windows" { if runtime.GOOS != "windows" {
if err := pluginCmd.RunE(pluginCmd, tt.args); err != nil { if err := pluginCmd.RunE(pluginCmd, tt.args); err != nil {
if assert.Positive(t, tt.code, "Error running %s: %+v", tt.use, err) { if assert.Positive(t, tt.code, "Error running %s", tt.use) {
var cerr CommandError var cerr CommandError
require.ErrorAs(t, err, &cerr, "Expected %s to return pluginError: got %v(%T)", tt.use, err, err) require.ErrorAs(t, err, &cerr, "Expected %s to return pluginError", tt.use)
assert.Equalf(t, tt.code, cerr.ExitCode, "Expected %s to return %d: got %d", tt.use, tt.code, cerr.ExitCode) assert.Equalf(t, tt.code, cerr.ExitCode, "Expected %s to return %d: got %d", tt.use, tt.code, cerr.ExitCode)
} }
} }
@ -190,31 +180,23 @@ func TestLoadPluginsWithSpace(t *testing.T) {
plugins := cmd.Commands() plugins := cmd.Commands()
if len(plugins) != len(tests) { require.Len(t, plugins, len(tests), "Expected %d plugins, got %d", len(tests), len(plugins))
t.Fatalf("Expected %d plugins, got %d", len(tests), len(plugins))
}
for i := range plugins { for i := range plugins {
out.Reset() out.Reset()
tt := tests[i] tt := tests[i]
pp := plugins[i] pp := plugins[i]
if pp.Use != tt.use { assert.Equal(t, tt.use, pp.Use, "%d: Expected Use=%q, got %q", i, tt.use, pp.Use)
t.Errorf("%d: Expected Use=%q, got %q", i, tt.use, pp.Use) assert.Equal(t, tt.short, pp.Short, "%d: Expected Use=%q, got %q", i, tt.short, pp.Short)
} assert.Equal(t, tt.long, pp.Long, "%d: Expected Use=%q, got %q", i, tt.long, pp.Long)
if pp.Short != tt.short {
t.Errorf("%d: Expected Use=%q, got %q", i, tt.short, pp.Short)
}
if pp.Long != tt.long {
t.Errorf("%d: Expected Use=%q, got %q", i, tt.long, pp.Long)
}
// Currently, plugins assume a Linux subsystem. Skip the execution // Currently, plugins assume a Linux subsystem. Skip the execution
// tests until this is fixed // tests until this is fixed
if runtime.GOOS != "windows" { if runtime.GOOS != "windows" {
if err := pp.RunE(pp, tt.args); err != nil { if err := pp.RunE(pp, tt.args); err != nil {
if assert.Positive(t, tt.code, "Error running %s: %+v", tt.use, err) { if assert.Positive(t, tt.code, "Error running %s", tt.use) {
var cerr CommandError var cerr CommandError
require.ErrorAs(t, err, &cerr, "Expected %s to return pluginError: got %v(%T)", tt.use, err, err) require.ErrorAs(t, err, &cerr, "Expected %s to return pluginError", tt.use)
assert.Equalf(t, tt.code, cerr.ExitCode, "Expected %s to return %d: got %d", tt.use, tt.code, cerr.ExitCode) assert.Equalf(t, tt.code, cerr.ExitCode, "Expected %s to return %d: got %d", tt.use, tt.code, cerr.ExitCode)
} }
} }
@ -334,9 +316,7 @@ func TestLoadCLIPlugins_HelmNoPlugins(t *testing.T) {
loadCLIPlugins(cmd, out) loadCLIPlugins(cmd, out)
plugins := cmd.Commands() plugins := cmd.Commands()
if len(plugins) != 0 { require.Empty(t, plugins, "Expected 0 plugins, got %d", len(plugins))
t.Fatalf("Expected 0 plugins, got %d", len(plugins))
}
} }
func TestPluginCmdsCompletion(t *testing.T) { func TestPluginCmdsCompletion(t *testing.T) {

@ -237,25 +237,23 @@ func TestPullCmd(t *testing.T) {
require.NoError(t, os.MkdirAll(file, 0o755)) require.NoError(t, os.MkdirAll(file, 0o755))
} }
_, out, err := executeActionCommand(cmd) _, out, err := executeActionCommand(cmd)
if err != nil { if tt.wantError {
if tt.wantError { if tt.wantErrorMsg != "" {
if tt.wantErrorMsg != "" && tt.wantErrorMsg != err.Error() { require.EqualError(t, err, tt.wantErrorMsg, "Actual error '%s', not equal to expected error '%s'", err, tt.wantErrorMsg)
t.Fatalf("Actual error '%s', not equal to expected error '%s'", err, tt.wantErrorMsg)
}
return
} }
t.Fatalf("%q reported error: %s", tt.name, err) } else {
} require.NoError(t, err)
if tt.expectVerify { if tt.expectVerify {
outString := helmTestKeyOut + tt.expectSha + "\n" outString := helmTestKeyOut + tt.expectSha + "\n"
assert.Equal(t, outString, out, "%q: expected verification output %q, got %q", tt.name, outString, out) assert.Equal(t, outString, out, "%q: expected verification output %q, got %q", tt.name, outString, out)
} }
ef := filepath.Join(outdir, tt.expectFile) ef := filepath.Join(outdir, tt.expectFile)
fi, err := os.Stat(ef) fi, err := os.Stat(ef)
require.NoError(t, err, "%q: expected a file at %s.", tt.name, 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) 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) index, err := repo.LoadIndexFile(destIndex)
require.NoError(t, err) 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"] 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" expectedVersion := "0.2.0"
assert.Equal(t, expectedVersion, vs[0].Version, "expected %q, got %q", expectedVersion, vs[0].Version) 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) b := bytes.NewBuffer(nil)
err = updateCharts([]*repo.ChartRepository{r1, r2}, b) 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") 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" require.ErrorContains(t, err, "failed to update the following repositories")
var receivedErr = err.Error() require.ErrorContains(t, err, invalidURL)
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)
got := b.String() got := b.String()
assert.Contains(t, got, "Unable to get an update", "Repo should have failed update but instead got: %q", got) 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 ( import (
"fmt" "fmt"
"reflect"
"testing" "testing"
"github.com/stretchr/testify/assert" "github.com/stretchr/testify/assert"
@ -161,5 +160,5 @@ func TestRollbackWithLabels(t *testing.T) {
updatedRel, err := releaserToV1Release(updatedReli) updatedRel, err := releaserToV1Release(updatedReli)
require.NoError(t, err) 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 { for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) { t.Run(tt.name, func(t *testing.T) {
charts, err := i.Search(tt.query, 100, tt.regexp) charts, err := i.Search(tt.query, 100, tt.regexp)
if err != nil { if tt.fail {
if tt.fail { require.ErrorContains(t, err, tt.failMsg)
require.ErrorContains(t, err, tt.failMsg) } else {
return require.NoError(t, err) // Give us predictably ordered results.
} SortScore(charts)
t.Fatalf("%s: %s", tt.name, err)
}
// Give us predictably ordered results.
SortScore(charts)
l := len(charts) l := len(tt.expect)
require.Lenf(t, tt.expect, l, "Expected %d result, got %d", len(tt.expect), l) require.Len(t, charts, len(tt.expect))
// For empty result sets, just keep going. // For empty result sets, just keep going.
if l == 0 { 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)
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() storage := storageFixture()
_, out, err := executeActionCommandC(storage, testcmd) _, out, err := executeActionCommandC(storage, testcmd)
require.NoError(t, err) require.NoError(t, err)
if out != expected { assert.Equal(t, expected, out, "expected and actual output did not match")
t.Error("expected and actual output did not match")
t.Log(out)
t.Log(expected)
}
} }
func TestSearchHubListRepoCmd(t *testing.T) { func TestSearchHubListRepoCmd(t *testing.T) {
@ -73,11 +69,7 @@ func TestSearchHubListRepoCmd(t *testing.T) {
storage := storageFixture() storage := storageFixture()
_, out, err := executeActionCommandC(storage, testcmd) _, out, err := executeActionCommandC(storage, testcmd)
require.NoError(t, err) require.NoError(t, err)
if out != expected { assert.Equal(t, expected, out, "expected and actual output did not match")
t.Error("expected and actual output did not match")
t.Log(out)
t.Log(expected)
}
} }
func TestSearchHubOutputCompletion(t *testing.T) { func TestSearchHubOutputCompletion(t *testing.T) {

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

@ -22,7 +22,6 @@ import (
"net/http/httptest" "net/http/httptest"
"os" "os"
"path/filepath" "path/filepath"
"reflect"
"testing" "testing"
"time" "time"
@ -201,9 +200,9 @@ func TestUpgradeDependencyUpdateOCINoPanic(t *testing.T) {
w.Header().Set("Docker-Distribution-API-Version", "registry/2.0") w.Header().Set("Docker-Distribution-API-Version", "registry/2.0")
if r.URL.Path == "/v2/" { if r.URL.Path == "/v2/" {
w.WriteHeader(http.StatusOK) w.WriteHeader(http.StatusOK)
return } else {
w.WriteHeader(http.StatusNotFound)
} }
w.WriteHeader(http.StatusNotFound)
})) }))
defer srv.Close() defer srv.Close()
@ -224,23 +223,17 @@ func TestUpgradeDependencyUpdateOCINoPanic(t *testing.T) {
}}, }},
}, },
} }
if err := chartutil.SaveDir(parent, tmp); err != nil { require.NoError(t, chartutil.SaveDir(parent, tmp), "Error creating chart")
t.Fatalf("Error creating chart: %v", err)
}
chartPath := filepath.Join(tmp, parent.Metadata.Name) chartPath := filepath.Join(tmp, parent.Metadata.Name)
// SaveDir writes only resolved subcharts (Chart.Dependencies()), not the // SaveDir writes only resolved subcharts (Chart.Dependencies()), not the
// declared Metadata.Dependencies, so create the empty charts/ directory // declared Metadata.Dependencies, so create the empty charts/ directory
// explicitly to make the "dependency missing from charts/" state concrete. // explicitly to make the "dependency missing from charts/" state concrete.
if err := os.MkdirAll(filepath.Join(chartPath, "charts"), 0o755); err != nil { require.NoError(t, os.MkdirAll(filepath.Join(chartPath, "charts"), 0o755), "Error creating charts dir")
t.Fatalf("Error creating charts dir: %v", err)
}
// The command must return an error (registry rejects the lookup), not panic. // The command must return an error (registry rejects the lookup), not panic.
_, _, err := executeActionCommandC(storageFixture(), _, _, err := executeActionCommandC(storageFixture(),
fmt.Sprintf("upgrade --dependency-update --plain-http oci-parent '%s'", chartPath)) fmt.Sprintf("upgrade --dependency-update --plain-http oci-parent '%s'", chartPath))
if err == nil { require.Error(t, err, "expected an error resolving the OCI dependency, got nil")
t.Fatal("expected an error resolving the OCI dependency, got nil")
}
} }
func TestUpgradeWithValue(t *testing.T) { func TestUpgradeWithValue(t *testing.T) {
@ -471,7 +464,7 @@ func TestUpgradeInstallWithLabels(t *testing.T) {
updatedRel, err := releaserToV1Release(updatedReli) updatedRel, err := releaserToV1Release(updatedReli)
require.NoError(t, err) 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) { 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 { for _, tt := range tests {
_, u, err := c.ResolveChartVersion(tt.ref, tt.version) t.Run(tt.name, func(t *testing.T) {
if err != nil { _, u, err := c.ResolveChartVersion(tt.ref, tt.version)
if tt.fail { if err != nil {
continue 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 snapshotOpts := c.Options
for _, tt := range tests { for _, tt := range tests {
// reset chart downloader options for each test case t.Run(tt.name, func(t *testing.T) {
c.Options = snapshotOpts // reset chart downloader options for each test case
c.Options = snapshotOpts
expect, err := getter.NewHTTPGetter(tt.expect...)
if err != nil { expect, err := getter.NewHTTPGetter(tt.expect...)
t.Errorf("%s: failed to setup http client: %s", tt.name, err) require.NoError(t, err, "failed to setup http client")
continue
} _, u, err := c.ResolveChartVersion(tt.ref, tt.version)
require.NoError(t, err, "failed with error")
_, u, err := c.ResolveChartVersion(tt.ref, tt.version)
if err != nil { got, err := getter.NewHTTPGetter(
t.Errorf("%s: failed with error %s", tt.name, err) append(
continue c.Options,
} getter.WithURL(u.String()),
)...,
got, err := getter.NewHTTPGetter( )
append( require.NoError(t, err, "failed to create http client")
c.Options, assert.Equal(t, expect, got)
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)
}
} }
} }

@ -99,10 +99,8 @@ func TestParallelDownloadTo(t *testing.T) {
// Verify the file has the expected size (should match the source file) // Verify the file has the expected size (should match the source file)
sourceFile := "testdata/local-subchart-0.1.0.tgz" sourceFile := "testdata/local-subchart-0.1.0.tgz"
sourceInfo, err := os.Stat(sourceFile) sourceInfo, err := os.Stat(sourceFile)
if err == nil && info.Size() != sourceInfo.Size() { require.NoError(t, err)
t.Errorf("Downloaded file size (%d bytes) doesn't match source file size (%d bytes)", assert.False(t, info.Size() != sourceInfo.Size(), "Downloaded file size doesn't match source file size")
info.Size(), sourceInfo.Size())
}
// Verify it's a valid tar.gz file by checking the magic bytes // Verify it's a valid tar.gz file by checking the magic bytes
file, err := os.Open(expectedFile) file, err := os.Open(expectedFile)
@ -110,10 +108,10 @@ func TestParallelDownloadTo(t *testing.T) {
defer file.Close() defer file.Close()
// gzip magic bytes are 0x1f 0x8b // gzip magic bytes are 0x1f 0x8b
magic := make([]byte, 2) magic := make([]byte, 2)
if n, err := file.Read(magic); err == nil && n == 2 { n, err := file.Read(magic)
if magic[0] != 0x1f || magic[1] != 0x8b { require.NoError(t, err)
t.Errorf("Downloaded file is not a valid gzip file (magic bytes: %x)", magic) 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" "io/fs"
"os" "os"
"path/filepath" "path/filepath"
"reflect"
"testing" "testing"
"time" "time"
@ -168,19 +167,16 @@ func TestGetRepoNames(t *testing.T) {
} }
for _, tt := range tests { for _, tt := range tests {
l, err := m.resolveRepoNames(tt.req) t.Run(tt.name, func(t *testing.T) {
if err != nil { l, err := m.resolveRepoNames(tt.req)
if tt.err { 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{ e := ErrRepoNotFound{
Repos: tt.fields.Repos, Repos: tt.fields.Repos,
} }
got := e.Error() assert.EqualError(t, e, tt.want)
assert.EqualErrorf(t, e, tt.want, "Error() = %v, want %v", got, tt.want)
}) })
} }
} }

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

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

@ -38,7 +38,7 @@ func TestError(t *testing.T) {
os.Unsetenv(name) os.Unsetenv(name)
g := Gate(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) { func TestString(t *testing.T) {

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

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

@ -55,23 +55,14 @@ func TestOCIGetter(t *testing.T) {
og, ok := g.(*OCIGetter) og, ok := g.(*OCIGetter)
require.True(t, ok, "expected NewOCIGetter to produce an *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, "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, "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, 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, 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, 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, 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, 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, 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) 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 // Test if setting registryClient is being passed to the ops
@ -84,7 +75,6 @@ func TestOCIGetter(t *testing.T) {
require.NoError(t, err) require.NoError(t, err)
og, ok = g.(*OCIGetter) og, ok = g.(*OCIGetter)
require.True(t, ok, "expected NewOCIGetter to produce an *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) 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 // Special handling for the rollback test case
if name == "rollback after failed upgrade with removed resource" { if name == "rollback after failed upgrade with removed resource" {
assert.Empty(t, result.Created, "expected 0 resource created, got %d", len(result.Created)) assert.Empty(t, result.Created, "expected 0 resource created")
assert.Len(t, result.Updated, 1, "expected 1 resource updated, got %d", len(result.Updated)) assert.Len(t, result.Updated, 1, "expected 1 resource updated")
assert.Empty(t, result.Deleted, "expected 0 resource deleted, got %d", len(result.Deleted)) assert.Empty(t, result.Deleted, "expected 0 resource deleted")
} else { } else {
assert.Len(t, result.Created, 1, "expected 1 resource created, got %d", len(result.Created)) assert.Len(t, result.Created, 1, "expected 1 resource created")
assert.Len(t, result.Updated, 2, "expected 2 resource updated, got %d", len(result.Updated)) assert.Len(t, result.Updated, 2, "expected 2 resource updated")
assert.Len(t, result.Deleted, 1, "expected 1 resource deleted, got %d", len(result.Deleted)) assert.Len(t, result.Deleted, 1, "expected 1 resource deleted")
} }
if tc.ExpectedError != "" { if tc.ExpectedError != "" {
require.Error(t, err)
require.ErrorContains(t, err, tc.ExpectedError) require.ErrorContains(t, err, tc.ExpectedError)
} else { } else {
require.NoError(t, err) require.NoError(t, err)
@ -702,11 +701,11 @@ func TestPerform(t *testing.T) {
} }
err = perform(infos, fn) err = perform(infos, fn)
assert.Equal(t, tt.err, (err != nil), "expected error: %v", tt.err) if tt.err {
if err != nil { require.EqualError(t, err, tt.errMessage)
require.EqualErrorf(t, err, tt.errMessage, "expected error message: %v, got %v", tt.errMessage, err) } else {
require.NoError(t, err)
} }
assert.Len(t, results, tt.count, "expected %d result objects, got %d", tt.count, len(results)) 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) require.NoError(t, err)
assert.Len(t, result.Created, 3, "expected 3 resource created, got %d", len(result.Created)) 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") 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)) 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") require.NoError(t, err, "Failed to create Job")
got, err := c.IsReady(tt.args.ctx, tt.args.resource) 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) 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") require.NoError(t, err, "Failed to create ReplicaSet")
got, err := c.IsReady(tt.args.ctx, tt.args.resource) 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) 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") require.NoError(t, err, "Failed to create PersistentVolumeClaim")
got, err := c.IsReady(tt.args.ctx, tt.args.resource) 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) 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") require.NoError(t, err, "Failed to create Service")
got, err := c.IsReady(tt.args.ctx, tt.args.resource) 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) 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") require.NoError(t, err, "Failed to create DaemonSet")
got, err := c.IsReady(tt.args.ctx, tt.args.resource) 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) 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") require.NoError(t, err, "Failed to create StatefulSet")
got, err := c.IsReady(tt.args.ctx, tt.args.resource) 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) 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") require.NoError(t, err, "Failed to create ReplicationController")
got, err := c.IsReady(tt.args.ctx, tt.args.resource) 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) 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) 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) 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) { t.Run(tt.name, func(t *testing.T) {
c := NewReadyChecker(fake.NewClientset()) c := NewReadyChecker(fake.NewClientset())
got, err := c.jobReady(tt.args.job) got, err := c.jobReady(tt.args.job)
if (err != nil) != tt.wantErr { if tt.wantErr {
t.Errorf("jobReady() error = %v, wantErr %v", err, tt.wantErr) require.Error(t, err, "jobReady()")
return } else {
require.NoError(t, err, "jobReady()")
} }
assert.Equal(t, tt.want, got, "jobReady() = %v, want %v", got, tt.want) assert.Equal(t, tt.want, got, "jobReady() = %v, want %v", got, tt.want)
}) })

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

@ -297,8 +297,7 @@ func TestLegacyWaiter_waitForPodSuccess(t *testing.T) {
t.Run(tt.name, func(t *testing.T) { t.Run(tt.name, func(t *testing.T) {
done, err := lw.waitForPodSuccess(tt.obj, "foo") done, err := lw.waitForPodSuccess(tt.obj, "foo")
if tt.wantErr { if tt.wantErr {
require.Error(t, err, "expected error, got none") require.ErrorContains(t, err, tt.errMessage)
require.ErrorContains(t, err, tt.errMessage, "expected error to contain %q, got %q", tt.errMessage, err.Error())
} else { } else {
require.NoError(t, err) require.NoError(t, err)
} }
@ -384,8 +383,7 @@ func TestLegacyWaiter_waitForJob(t *testing.T) {
t.Run(tt.name, func(t *testing.T) { t.Run(tt.name, func(t *testing.T) {
done, err := lw.waitForJob(tt.obj, "test-job") done, err := lw.waitForJob(tt.obj, "test-job")
if tt.wantErr { if tt.wantErr {
require.Error(t, err, "expected error, got none") require.ErrorContains(t, err, tt.errMessage)
require.ErrorContainsf(t, err, tt.errMessage, "expected error to contain %q, got %q", tt.errMessage, err.Error())
} else { } else {
require.NoError(t, err) require.NoError(t, err)
assert.Equal(t, tt.wantDone, done, "got done=%v, want %v", done, tt.wantDone) 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 != "" { if tt.expectedErr != "" {
require.ErrorContains(t, err, 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) { func TestLoadKey(t *testing.T) {
k, err := loadKey(testKeyfile) k, err := loadKey(testKeyfile)
require.NoError(t, err) require.NoError(t, err)
assert.Containsf(t, k.Identities, testKeyName, "Expected to load a key for user %q", testKeyName)
_, ok := k.Identities[testKeyName]
assert.Truef(t, ok, "Expected to load a key for user %q", testKeyName)
} }
func TestLoadKeyRing(t *testing.T) { func TestLoadKeyRing(t *testing.T) {
@ -163,8 +161,7 @@ func TestNewFromFiles(t *testing.T) {
s, err := NewFromFiles(testKeyfile, testPubfile) s, err := NewFromFiles(testKeyfile, testPubfile)
require.NoError(t, err) require.NoError(t, err)
_, ok := s.Entity.Identities[testKeyName] assert.Containsf(t, s.Entity.Identities, testKeyName, "Expected to load a key for user %q", testKeyName)
assert.Truef(t, ok, "Expected to load a key for user %q", testKeyName)
} }
func TestDigestFile(t *testing.T) { 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) 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, "expected signer entity to be loaded")
require.NotNil(t, signer.Entity.PrivateKey, "expected signer private key 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") 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, "expected verification to include signer")
require.NotNil(t, verification.SignedBy.PrimaryKey, "expected verification to include signer primary key") 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") assert.Equal(t, packet.PubKeyAlgoRSA, verification.SignedBy.PrimaryKey.PubKeyAlgo, "expected verification to report RSA key")
assert.Contains(t, verification.SignedBy.Identities, testKeyName, "expected verification to be signed by %q", testKeyName)
_, ok := verification.SignedBy.Identities[testKeyName]
assert.True(t, ok, "expected verification to be signed by %q", testKeyName)
} }
// failSigner always fails to sign and returns an error // failSigner always fails to sign and returns an error

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

@ -232,8 +232,7 @@ func TestGenerateOCICreatedAnnotations(t *testing.T) {
result := generateOCIAnnotations(testChart, nowTimeString) result := generateOCIAnnotations(testChart, nowTimeString)
// Check that created annotation exists // Check that created annotation exists
_, ok := result[ocispec.AnnotationCreated] assert.Contains(t, result, ocispec.AnnotationCreated, "%s annotation not created", ocispec.AnnotationCreated)
assert.True(t, ok, "%s annotation not created", ocispec.AnnotationCreated)
// Verify value of created artifact in RFC3339 format // Verify value of created artifact in RFC3339 format
_, err := time.Parse(time.RFC3339, result[ocispec.AnnotationCreated]) _, err := time.Parse(time.RFC3339, result[ocispec.AnnotationCreated])
@ -243,8 +242,7 @@ func TestGenerateOCICreatedAnnotations(t *testing.T) {
result = generateOCIAnnotations(testChart, "") result = generateOCIAnnotations(testChart, "")
// Check that created annotation exists // Check that created annotation exists
_, ok = result[ocispec.AnnotationCreated] require.Contains(t, result, ocispec.AnnotationCreated, "%s annotation not created", ocispec.AnnotationCreated)
require.True(t, ok, "%s annotation not created", ocispec.AnnotationCreated)
createdTimeAnnotation, err := time.Parse(time.RFC3339, result[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]) 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/" { if r.URL.Path == "/v2/" {
// Accept either HEAD or GET // Accept either HEAD or GET
w.WriteHeader(http.StatusOK) w.WriteHeader(http.StatusOK)
return } else {
http.NotFound(w, r)
} }
http.NotFound(w, r)
})) }))
defer srv.Close() defer srv.Close()

@ -78,11 +78,10 @@ func TestGetPluginName(t *testing.T) {
if tt.expectErr { if tt.expectErr {
assert.Error(t, err, "expected error but got none") 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 { if err != nil {
w.WriteHeader(http.StatusInternalServerError) w.WriteHeader(http.StatusInternalServerError)
w.Write([]byte(err.Error())) 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": case "/v2/testrepo/image-index/blobs/sha256:e5ef611620fb97704d8751c16bab17fedb68883bfb0edc76f78a70e9173f9b55":
data, err := os.ReadFile("../downloader/testdata/signtest-0.1.0.tgz") data, err := os.ReadFile("../downloader/testdata/signtest-0.1.0.tgz")
if err != nil { if err != nil {
w.WriteHeader(http.StatusInternalServerError) w.WriteHeader(http.StatusInternalServerError)
w.Write([]byte(err.Error())) 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: default:
w.WriteHeader(http.StatusNotFound) w.WriteHeader(http.StatusNotFound)
} }

@ -143,7 +143,6 @@ metadata:
// This test will fail if 'six' or 'seven' was added. // This test will fail if 'six' or 'seven' was added.
assert.Len(t, generic, 2) assert.Len(t, generic, 2)
assert.Len(t, hs, 4) assert.Len(t, hs, 4)
for _, out := range hs { 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 // versions of Darwin do not. As there are people developing Helm using both old and new versions of Darwin we test
// for both messages. // for both messages.
if runtime.GOOS == "darwin" { 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") { require.Error(t, err)
t.Errorf("Expected TLS error for function FindChartInAuthAndTLSAndPassRepoURL not found, but got a different error (%v)", 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 { } else {
assert.ErrorContainsf(t, err, "x509: certificate signed by unknown authority", "Expected TLS error for function FindChartInAuthAndTLSAndPassRepoURL not found, but got a different error") 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) _, 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") 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) srv, err := startLocalServerForTests(nil)
@ -211,16 +209,13 @@ func TestErrorFindChartInRepoURL(t *testing.T) {
defer srv.Close() defer srv.Close()
_, err = FindChartInRepoURL(srv.URL, "nginx1", g) _, 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.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") require.ErrorIs(t, err, ChartNotFoundError{}, "error is not of correct error type structure")
_, err = FindChartInRepoURL(srv.URL, "nginx1", g, WithChartVersion("0.1.0")) _, 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") 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) _, 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") 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) assert.Equalf(t, "0.2.0", v, "Unexpected first version: %s", v)
cv, err := i.Get("setter", "0.1.9") cv, err := i.Get("setter", "0.1.9")
if err == nil && !strings.Contains(cv.Version, "0.1.9") { require.NoError(t, err)
t.Errorf("Unexpected version: %s", cv.Version) assert.Contains(t, cv.Version, "0.1.9", "Unexpected version: %s", cv.Version)
}
cv, err = i.Get("setter", "0.1.9+alpha") cv, err = i.Get("setter", "0.1.9+alpha")
require.NoError(t, err, "Expected version: 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) require.Equalf(t, 1, l, "'alpine' should have 1 chart, got %d", l)
nginx, ok := i.Entries["nginx"] nginx, ok := i.Entries["nginx"]
if !ok || len(nginx) != 2 { require.True(t, ok)
t.Fatal("Expected 2 nginx entries") require.Len(t, nginx, 2, "Expected 2 nginx entries")
}
expects := []*ChartVersion{ expects := []*ChartVersion{
{ {
@ -507,18 +505,14 @@ func TestIgnoreSkippableChartValidationError(t *testing.T) {
for name, tc := range testCases { for name, tc := range testCases {
t.Run(name, func(t *testing.T) { t.Run(name, func(t *testing.T) {
result := ignoreSkippableChartValidationError(tc.Input) result := ignoreSkippableChartValidationError(tc.Input)
switch {
if tc.Input == nil { case tc.Input == nil:
assert.NoError(t, result, "expected nil result for nil input") assert.NoError(t, result, "expected nil result for nil input")
return case tc.ErrorSkipped:
}
if tc.ErrorSkipped {
assert.NoError(t, result, "expected nil result for skipped error") 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" removeRepository := "stable"
found := sampleRepository.Remove(removeRepository) assert.Truef(t, sampleRepository.Remove(removeRepository), "expected repository %s not found", removeRepository)
assert.Truef(t, found, "expected repository %s not found", removeRepository) assert.Falsef(t, sampleRepository.Has(removeRepository), "repository %s not deleted", removeRepository)
found = sampleRepository.Has(removeRepository)
assert.Falsef(t, found, "repository %s not deleted", removeRepository)
} }
func TestUpdateRepository(t *testing.T) { func TestUpdateRepository(t *testing.T) {
@ -205,9 +202,6 @@ func TestRemoveRepositoryInvalidEntries(t *testing.T) {
) )
removeRepository := "stable" removeRepository := "stable"
found := sampleRepository.Remove(removeRepository) assert.Truef(t, sampleRepository.Remove(removeRepository), "expected repository %s not found", removeRepository)
assert.Truef(t, found, "expected repository %s not found", removeRepository) assert.Falsef(t, sampleRepository.Has(removeRepository), "repository %s not deleted", removeRepository)
found = sampleRepository.Has(removeRepository)
assert.Falsef(t, found, "repository %s not deleted", removeRepository)
} }

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

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

@ -18,6 +18,8 @@ package driver
import ( import (
"testing" "testing"
"github.com/stretchr/testify/require"
) )
func TestLabelsMatch(t *testing.T) { func TestLabelsMatch(t *testing.T) {
@ -42,8 +44,12 @@ func TestLabelsMatch(t *testing.T) {
} }
for _, tt := range tests { for _, tt := range tests {
if !tt.set1.match(tt.set2) && tt.expect { t.Run(tt.desc, func(t *testing.T) {
t.Fatalf("Expected match '%s'\n", tt.desc) 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 ( import (
"fmt" "fmt"
"reflect"
"testing" "testing"
"github.com/stretchr/testify/assert" "github.com/stretchr/testify/assert"
@ -112,7 +111,7 @@ func TestMemoryList(t *testing.T) {
}) })
// check // check
require.NoError(t, err, "Failed to list deployed releases") 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 // list all superseded releases
ssd, err := ts.List(func(rel release.Releaser) bool { ssd, err := ts.List(func(rel release.Releaser) bool {
@ -121,7 +120,7 @@ func TestMemoryList(t *testing.T) {
}) })
// check // check
require.NoError(t, err, "Failed to list superseded releases") 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 // list all deleted releases
del, err := ts.List(func(rel release.Releaser) bool { del, err := ts.List(func(rel release.Releaser) bool {
@ -210,7 +209,7 @@ func TestMemoryUpdate(t *testing.T) {
r, err := ts.Get(tt.key) r, err := ts.Get(tt.key)
require.NoError(t, err, "Failed to get") 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("") ts.SetNamespace("")
end, err := ts.Query(map[string]string{"status": "deployed"}) end, err := ts.Query(map[string]string{"status": "deployed"})
require.NoError(t, err, "Query failed") require.NoError(t, err, "Query failed")
endLen := len(end)
if startLen-2 != endLen { if !assert.Len(t, end, startLen-2) {
t.Errorf("expected end to be %d instead of %d", startLen-2, endLen)
for _, ee := range end { for _, ee := range end {
rac, err := release.NewAccessor(ee) rac, err := release.NewAccessor(ee)
require.NoError(t, err, "unable to get release accessor") require.NoError(t, err, "unable to get release accessor")

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

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

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

@ -14,7 +14,6 @@ limitations under the License.
package driver package driver
import ( import (
"reflect"
"testing" "testing"
"github.com/stretchr/testify/assert" "github.com/stretchr/testify/assert"
@ -22,7 +21,7 @@ import (
func TestGetSystemLabel(t *testing.T) { func TestGetSystemLabel(t *testing.T) {
output := GetSystemLabels() 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) { func TestIsSystemLabel(t *testing.T) {
@ -69,7 +68,7 @@ func TestFilterSystemLabels(t *testing.T) {
} }
for _, test := range tests { for _, test := range tests {
output := filterSystemLabels(test[0]) 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 { for _, test := range tests {
output := ContainsSystemLabels(test.input) 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" "context"
"errors" "errors"
"log/slog" "log/slog"
"reflect"
"testing" "testing"
"github.com/stretchr/testify/assert" "github.com/stretchr/testify/assert"
@ -49,7 +48,7 @@ func TestStorageCreate(t *testing.T) {
require.NoError(t, err, "QueryRelease") require.NoError(t, err, "QueryRelease")
// verify the fetched and created release are the same // 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) { func TestStorageUpdate(t *testing.T) {
@ -74,7 +73,7 @@ func TestStorageUpdate(t *testing.T) {
require.NoError(t, err, "QueryRelease") require.NoError(t, err, "QueryRelease")
// verify updated and fetched releases are the same. // 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) { func TestStorageDelete(t *testing.T) {
@ -99,7 +98,7 @@ func TestStorageDelete(t *testing.T) {
require.NoError(t, err, "DeleteRelease") require.NoError(t, err, "DeleteRelease")
// verify updated and fetched releases are the same. // 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) hist, err := storage.History(rls.Name)
require.NoError(t, err) require.NoError(t, err)
@ -348,12 +347,12 @@ func TestStorageRemoveLeastRecent(t *testing.T) {
require.NoError(t, err) require.NoError(t, err)
rhist, err := releaseListToV1List(hist) rhist, err := releaseListToV1List(hist)
require.NoError(t, err) require.NoError(t, err)
if len(rhist) != storage.MaxHistory { if !assert.Len(t, rhist, storage.MaxHistory) {
for _, item := range rhist { for _, item := range rhist {
t.Logf("%s %v", item.Name, item.Version) 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. // We expect the existing records to be 3, 4, and 5.
for i, item := range rhist { for i, item := range rhist {
@ -392,14 +391,14 @@ func TestStorageDoNotDeleteDeployed(t *testing.T) {
// (the only deployed release), to still exist // (the only deployed release), to still exist
hist, err := storage.History(name) hist, err := storage.History(name)
require.NoError(t, err) require.NoError(t, err)
if len(hist) != storage.MaxHistory { if !assert.Len(t, hist, storage.MaxHistory) {
rhist, err := releaseListToV1List(hist) rhist, err := releaseListToV1List(hist)
require.NoError(t, err) require.NoError(t, err)
for _, item := range rhist { for _, item := range rhist {
t.Logf("%s %v", item.Name, item.Version) 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{ expectedVersions := map[int]bool{
2: true, 2: true,

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

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

Loading…
Cancel
Save