From 33c28395695c53b579c1f94d3dfcadbe2ff2b862 Mon Sep 17 00:00:00 2001
From: Matthieu MOREL <matthieu.morel35@gmail.com>
Date: Mon, 20 Jul 2026 20:50:56 +0200
Subject: [PATCH 01/13] chore(pkg): refactor: convert tests to testify
 assert/require part 19

refactor: convert tests to testify assert/require in pkg/action
Signed-off-by: Matthieu MOREL <matthieu.morel35@gmail.com>
---
 pkg/action/lint_test.go                | 46 +++++++++-------------
 pkg/action/show_test.go                | 41 ++++++--------------
 pkg/action/upgrade_test.go             | 40 ++++++++-----------
 pkg/action/validate_test.go            | 37 ++++++------------
 pkg/chart/v2/lint/rules/values_test.go | 44 ++++++---------------
 pkg/cmd/install_test.go                |  6 +--
 pkg/cmd/plugin_test.go                 | 48 +++++++----------------
 pkg/getter/getter_test.go              | 53 ++++++++++----------------
 pkg/storage/driver/records_test.go     | 53 ++++++++++----------------
 9 files changed, 125 insertions(+), 243 deletions(-)

diff --git a/pkg/action/lint_test.go b/pkg/action/lint_test.go
index 5b5c2c50a..5c956c682 100644
--- a/pkg/action/lint_test.go
+++ b/pkg/action/lint_test.go
@@ -21,6 +21,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 
 	"helm.sh/helm/v4/pkg/chart/v2/lint/support"
 )
@@ -89,11 +90,10 @@ func TestLintChart(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			_, err := lintChart(tt.chartPath, map[string]any{}, namespace, nil, tt.skipSchemaValidation)
-			switch {
-			case err != nil && !tt.err:
-				t.Errorf("%s", err)
-			case err == nil && tt.err:
-				t.Error("Expected a chart parsing error")
+			if tt.err {
+				require.Error(t, err, "Expected a chart parsing error")
+			} else {
+				require.NoError(t, err)
 			}
 		})
 	}
@@ -106,14 +106,10 @@ func TestNonExistentChart(t *testing.T) {
 		testLint := NewLint()
 
 		result := testLint.Run(testCharts, values)
-		if len(result.Errors) != 1 {
-			t.Error("expected one error, but got", len(result.Errors))
-		}
+		assert.Len(t, result.Errors, 1, "expected one error, but got", len(result.Errors))
 
 		actual := result.Errors[0].Error()
-		if actual != expectedError {
-			t.Errorf("expected '%s', but got '%s'", expectedError, actual)
-		}
+		assert.EqualError(t, result.Errors[0], expectedError, "expected '%s', but got '%s'", expectedError, actual)
 	})
 
 	t.Run("should error out for corrupted tgz chart", func(t *testing.T) {
@@ -122,31 +118,25 @@ func TestNonExistentChart(t *testing.T) {
 		testLint := NewLint()
 
 		result := testLint.Run(testCharts, values)
-		if len(result.Errors) != 1 {
-			t.Error("expected one error, but got", len(result.Errors))
-		}
+		assert.Len(t, result.Errors, 1, "expected one error, but got", len(result.Errors))
 
 		actual := result.Errors[0].Error()
-		if actual != expectedEOFError {
-			t.Errorf("expected '%s', but got '%s'", expectedEOFError, actual)
-		}
+		assert.EqualError(t, result.Errors[0], expectedEOFError, "expected '%s', but got '%s'", expectedEOFError, actual)
 	})
 }
 
 func TestLint_MultipleCharts(t *testing.T) {
 	testCharts := []string{chart2MultipleChartLint, chart1MultipleChartLint}
 	testLint := NewLint()
-	if result := testLint.Run(testCharts, values); len(result.Errors) > 0 {
-		t.Error(result.Errors)
-	}
+	result := testLint.Run(testCharts, values)
+	assert.Empty(t, result.Errors)
 }
 
 func TestLint_EmptyResultErrors(t *testing.T) {
 	testCharts := []string{chart2MultipleChartLint}
 	testLint := NewLint()
-	if result := testLint.Run(testCharts, values); len(result.Errors) > 0 {
-		t.Error("Expected no error, got more")
-	}
+	result := testLint.Run(testCharts, values)
+	assert.Empty(t, result.Errors, "Expected no error, got more")
 }
 
 func TestLint_ChartWithWarnings(t *testing.T) {
@@ -154,18 +144,16 @@ func TestLint_ChartWithWarnings(t *testing.T) {
 		testCharts := []string{chartWithNoTemplatesDir}
 		testLint := NewLint()
 		testLint.Strict = false
-		if result := testLint.Run(testCharts, values); len(result.Errors) > 0 {
-			t.Error("Expected no error, got more")
-		}
+		result := testLint.Run(testCharts, values)
+		assert.Empty(t, result.Errors, "Expected no error, got more")
 	})
 
 	t.Run("should fail with one error when strict", func(t *testing.T) {
 		testCharts := []string{chartWithNoTemplatesDir}
 		testLint := NewLint()
 		testLint.Strict = true
-		if result := testLint.Run(testCharts, values); len(result.Errors) != 1 {
-			t.Error("expected one error, but got", len(result.Errors))
-		}
+		result := testLint.Run(testCharts, values)
+		assert.Len(t, result.Errors, 1, "expected one error")
 	})
 }
 
diff --git a/pkg/action/show_test.go b/pkg/action/show_test.go
index 0dde7fb74..c6c55ead1 100644
--- a/pkg/action/show_test.go
+++ b/pkg/action/show_test.go
@@ -21,6 +21,7 @@ import (
 	"time"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 
 	"helm.sh/helm/v4/pkg/chart/common"
 	chart "helm.sh/helm/v4/pkg/chart/v2"
@@ -47,9 +48,7 @@ func TestShow(t *testing.T) {
 	}
 
 	output, err := client.Run("")
-	if err != nil {
-		t.Fatal(err)
-	}
+	require.NoError(t, err)
 
 	expect := `name: alpine
 
@@ -69,9 +68,7 @@ bar
 baz
 
 `
-	if output != expect {
-		t.Errorf("Expected\n%q\nGot\n%q\n", expect, output)
-	}
+	assert.Equal(t, expect, output, "Expected\n%q\nGot\n%q\n", expect, output)
 }
 
 func TestShowNoValues(t *testing.T) {
@@ -82,13 +79,9 @@ func TestShowNoValues(t *testing.T) {
 	// Regression tests for missing values. See issue #1024.
 	client.OutputFormat = ShowValues
 	output, err := client.Run("")
-	if err != nil {
-		t.Fatal(err)
-	}
+	require.NoError(t, err)
 
-	if output != "" {
-		t.Errorf("expected empty values buffer, got %s", output)
-	}
+	assert.Empty(t, output, "expected empty values buffer, got %s", output)
 }
 
 func TestShowValuesByJsonPathFormat(t *testing.T) {
@@ -97,13 +90,9 @@ func TestShowValuesByJsonPathFormat(t *testing.T) {
 	client.JSONPathTemplate = "{$.nestedKey.simpleKey}"
 	client.chart = buildChart(withSampleValues())
 	output, err := client.Run("")
-	if err != nil {
-		t.Fatal(err)
-	}
+	require.NoError(t, err)
 	expect := "simpleValue"
-	if output != expect {
-		t.Errorf("Expected\n%q\nGot\n%q\n", expect, output)
-	}
+	assert.Equal(t, expect, output, "Expected\n%q\nGot\n%q\n", expect, output)
 }
 
 func TestShowCRDs(t *testing.T) {
@@ -121,9 +110,7 @@ func TestShowCRDs(t *testing.T) {
 	}
 
 	output, err := client.Run("")
-	if err != nil {
-		t.Fatal(err)
-	}
+	require.NoError(t, err)
 
 	expect := `---
 foo
@@ -135,9 +122,7 @@ bar
 baz
 
 `
-	if output != expect {
-		t.Errorf("Expected\n%q\nGot\n%q\n", expect, output)
-	}
+	assert.Equal(t, expect, output, "Expected\n%q\nGot\n%q\n", expect, output)
 }
 
 func TestShowNoReadme(t *testing.T) {
@@ -154,9 +139,7 @@ func TestShowNoReadme(t *testing.T) {
 	}
 
 	output, err := client.Run("")
-	if err != nil {
-		t.Fatal(err)
-	}
+	require.NoError(t, err)
 
 	expect := `name: alpine
 
@@ -167,9 +150,7 @@ foo
 bar
 
 `
-	if output != expect {
-		t.Errorf("Expected\n%q\nGot\n%q\n", expect, output)
-	}
+	assert.Equal(t, expect, output, "Expected\n%q\nGot\n%q\n", expect, output)
 }
 
 func TestShowSetRegistryClient(t *testing.T) {
diff --git a/pkg/action/upgrade_test.go b/pkg/action/upgrade_test.go
index 7a73c7179..b7e25206d 100644
--- a/pkg/action/upgrade_test.go
+++ b/pkg/action/upgrade_test.go
@@ -176,8 +176,8 @@ func TestUpgradeRelease_RollbackOnFailure(t *testing.T) {
 
 		resi, err := upAction.Run(rel.Name, buildChart(), vals)
 		req.Error(err)
-		is.Contains(err.Error(), "arming key removed")
-		is.Contains(err.Error(), "rollback-on-failure")
+		req.ErrorContains(err, "arming key removed")
+		req.ErrorContains(err, "rollback-on-failure")
 		res, err := releaserToV1Release(resi)
 		req.NoError(err)
 
@@ -207,8 +207,8 @@ func TestUpgradeRelease_RollbackOnFailure(t *testing.T) {
 
 		_, err := upAction.Run(rel.Name, buildChart(), vals)
 		req.Error(err)
-		is.Contains(err.Error(), "update fail")
-		is.Contains(err.Error(), "an error occurred while rolling back the release")
+		req.ErrorContains(err, "update fail")
+		is.ErrorContains(err, "an error occurred while rolling back the release")
 	})
 }
 
@@ -240,8 +240,7 @@ func TestUpgradeRelease_ReuseValues(t *testing.T) {
 		rel.Info.Status = common.StatusDeployed
 		rel.Config = existingValues
 
-		err := upAction.cfg.Releases.Create(rel)
-		req.NoError(err)
+		req.NoError(upAction.cfg.Releases.Create(rel))
 
 		upAction.ReuseValues = true
 		// setting newValues and upgrading
@@ -303,8 +302,7 @@ func TestUpgradeRelease_ReuseValues(t *testing.T) {
 			Config:  existingValues,
 			Version: 1,
 		}
-		err := upAction.cfg.Releases.Create(rel)
-		req.NoError(err)
+		req.NoError(upAction.cfg.Releases.Create(rel))
 
 		upAction.ReuseValues = true
 		sampleChartWithSubChart := buildChart(
@@ -373,8 +371,7 @@ func TestUpgradeRelease_ResetThenReuseValues(t *testing.T) {
 		rel.Info.Status = common.StatusDeployed
 		rel.Config = existingValues
 
-		err := upAction.cfg.Releases.Create(rel)
-		req.NoError(err)
+		req.NoError(upAction.cfg.Releases.Create(rel))
 
 		upAction.ResetThenReuseValues = true
 		// setting newValues and upgrading
@@ -417,7 +414,7 @@ func TestUpgradeRelease_Pending(t *testing.T) {
 	vals := map[string]any{}
 
 	_, err := upAction.Run(rel.Name, buildChart(), vals)
-	req.Contains(err.Error(), "progress", err)
+	req.ErrorContains(err, "progress")
 }
 
 func TestUpgradeRelease_Interrupted_Wait(t *testing.T) {
@@ -470,7 +467,7 @@ func TestUpgradeRelease_Interrupted_RollbackOnFailure(t *testing.T) {
 	resi, err := upAction.RunWithContext(ctx, rel.Name, buildChart(), vals)
 
 	req.Error(err)
-	is.Contains(err.Error(), "release interrupted-release failed, and has been rolled back due to rollback-on-failure being set: context canceled")
+	req.ErrorContains(err, "release interrupted-release failed, and has been rolled back due to rollback-on-failure being set: context canceled")
 	res, err := releaserToV1Release(resi)
 	req.NoError(err)
 	// Now make sure it is actually upgraded
@@ -491,9 +488,8 @@ func TestMergeCustomLabels(t *testing.T) {
 		{map[string]string{"k1": "v1", "k2": "v2"}, map[string]string{"k1": "null", "k2": "v3"}, map[string]string{"k2": "v3"}},
 	}
 	for _, test := range tests {
-		if output := mergeCustomLabels(test[0], test[1]); !reflect.DeepEqual(test[2], output) {
-			t.Errorf("Expected {%v}, got {%v}", test[2], output)
-		}
+		output := mergeCustomLabels(test[0], test[1])
+		assert.Truef(t, reflect.DeepEqual(test[2], output), "Expected {%v}, got {%v}", test[2], output)
 	}
 }
 
@@ -511,8 +507,7 @@ func TestUpgradeRelease_Labels(t *testing.T) {
 	}
 	rel.Info.Status = common.StatusDeployed
 
-	err := upAction.cfg.Releases.Create(rel)
-	req.NoError(err)
+	req.NoError(upAction.cfg.Releases.Create(rel))
 
 	upAction.Labels = map[string]string{
 		"key1": "null",
@@ -566,8 +561,7 @@ func TestUpgradeRelease_SystemLabels(t *testing.T) {
 	}
 	rel.Info.Status = common.StatusDeployed
 
-	err := upAction.cfg.Releases.Create(rel)
-	req.NoError(err)
+	req.NoError(upAction.cfg.Releases.Create(rel))
 
 	upAction.Labels = map[string]string{
 		"key1":  "null",
@@ -575,12 +569,10 @@ func TestUpgradeRelease_SystemLabels(t *testing.T) {
 		"owner": "val3",
 	}
 	// setting newValues and upgrading
-	_, err = upAction.Run(rel.Name, buildChart(), nil)
-	if err == nil {
-		t.Fatal("expected an error")
-	}
+	_, err := upAction.Run(rel.Name, buildChart(), nil)
+	require.Error(t, err, "expected an error")
 
-	is.Equal(fmt.Errorf("user supplied labels contains system reserved label name. System labels: %+v", driver.GetSystemLabels()), err)
+	is.EqualError(err, fmt.Sprintf("user supplied labels contains system reserved label name. System labels: %+v", driver.GetSystemLabels()))
 }
 
 func TestUpgradeRelease_DryRun(t *testing.T) {
diff --git a/pkg/action/validate_test.go b/pkg/action/validate_test.go
index 878bec599..27097d177 100644
--- a/pkg/action/validate_test.go
+++ b/pkg/action/validate_test.go
@@ -171,45 +171,38 @@ func TestCheckOwnership(t *testing.T) {
 	deployFoo := newDeploymentResource("foo", "ns-a", "")
 
 	// Verify that a resource that lacks labels/annotations is not owned
-	err := checkOwnership(deployFoo.Object, "rel-a", "ns-a")
-	require.EqualError(t, err, `invalid ownership metadata; label validation error: missing key "app.kubernetes.io/managed-by": must be set to "Helm"; annotation validation error: missing key "meta.helm.sh/release-name": must be set to "rel-a"; annotation validation error: missing key "meta.helm.sh/release-namespace": must be set to "ns-a"`)
+	require.EqualError(t, checkOwnership(deployFoo.Object, "rel-a", "ns-a"), `invalid ownership metadata; label validation error: missing key "app.kubernetes.io/managed-by": must be set to "Helm"; annotation validation error: missing key "meta.helm.sh/release-name": must be set to "rel-a"; annotation validation error: missing key "meta.helm.sh/release-namespace": must be set to "ns-a"`)
 
 	// Set managed by label and verify annotation error message
 	_ = accessor.SetLabels(deployFoo.Object, map[string]string{
 		appManagedByLabel: appManagedByHelm,
 	})
-	err = checkOwnership(deployFoo.Object, "rel-a", "ns-a")
-	require.EqualError(t, err, `invalid ownership metadata; annotation validation error: missing key "meta.helm.sh/release-name": must be set to "rel-a"; annotation validation error: missing key "meta.helm.sh/release-namespace": must be set to "ns-a"`)
+	require.EqualError(t, checkOwnership(deployFoo.Object, "rel-a", "ns-a"), `invalid ownership metadata; annotation validation error: missing key "meta.helm.sh/release-name": must be set to "rel-a"; annotation validation error: missing key "meta.helm.sh/release-namespace": must be set to "ns-a"`)
 
 	// Set only the release name annotation and verify missing release namespace error message
 	_ = accessor.SetAnnotations(deployFoo.Object, map[string]string{
 		helmReleaseNameAnnotation: "rel-a",
 	})
-	err = checkOwnership(deployFoo.Object, "rel-a", "ns-a")
-	require.EqualError(t, err, `invalid ownership metadata; annotation validation error: missing key "meta.helm.sh/release-namespace": must be set to "ns-a"`)
+	require.EqualError(t, checkOwnership(deployFoo.Object, "rel-a", "ns-a"), `invalid ownership metadata; annotation validation error: missing key "meta.helm.sh/release-namespace": must be set to "ns-a"`)
 
 	// Set both release name and namespace annotations and verify no ownership errors
 	_ = accessor.SetAnnotations(deployFoo.Object, map[string]string{
 		helmReleaseNameAnnotation:      "rel-a",
 		helmReleaseNamespaceAnnotation: "ns-a",
 	})
-	err = checkOwnership(deployFoo.Object, "rel-a", "ns-a")
-	require.NoError(t, err)
+	require.NoError(t, checkOwnership(deployFoo.Object, "rel-a", "ns-a"))
 
 	// Verify ownership error for wrong release name
-	err = checkOwnership(deployFoo.Object, "rel-b", "ns-a")
-	require.EqualError(t, err, `invalid ownership metadata; annotation validation error: key "meta.helm.sh/release-name" must equal "rel-b": current value is "rel-a"`)
+	require.EqualError(t, checkOwnership(deployFoo.Object, "rel-b", "ns-a"), `invalid ownership metadata; annotation validation error: key "meta.helm.sh/release-name" must equal "rel-b": current value is "rel-a"`)
 
 	// Verify ownership error for wrong release namespace
-	err = checkOwnership(deployFoo.Object, "rel-a", "ns-b")
-	require.EqualError(t, err, `invalid ownership metadata; annotation validation error: key "meta.helm.sh/release-namespace" must equal "ns-b": current value is "ns-a"`)
+	require.EqualError(t, checkOwnership(deployFoo.Object, "rel-a", "ns-b"), `invalid ownership metadata; annotation validation error: key "meta.helm.sh/release-namespace" must equal "ns-b": current value is "ns-a"`)
 
 	// Verify ownership error for wrong manager label
 	_ = accessor.SetLabels(deployFoo.Object, map[string]string{
 		appManagedByLabel: "helm",
 	})
-	err = checkOwnership(deployFoo.Object, "rel-a", "ns-a")
-	assert.EqualError(t, err, `invalid ownership metadata; label validation error: key "app.kubernetes.io/managed-by" must equal "Helm": current value is "helm"`)
+	assert.EqualError(t, checkOwnership(deployFoo.Object, "rel-a", "ns-a"), `invalid ownership metadata; label validation error: key "app.kubernetes.io/managed-by" must equal "Helm": current value is "helm"`)
 }
 
 func TestVerifyOwnershipBeforeDelete(t *testing.T) {
@@ -306,32 +299,26 @@ func TestVerifyOwnershipBeforeDelete(t *testing.T) {
 
 func TestSetMetadataVisitor(t *testing.T) {
 	var (
-		err       error
 		deployFoo = newDeploymentResource("foo", "ns-a", "")
 		deployBar = newDeploymentResource("bar", "ns-a-system", "")
 		resources = kube.ResourceList{deployFoo, deployBar}
 	)
 
 	// Set release tracking metadata and verify no error
-	err = resources.Visit(setMetadataVisitor("rel-a", "ns-a", true))
-	require.NoError(t, err)
+	require.NoError(t, resources.Visit(setMetadataVisitor("rel-a", "ns-a", true)))
 
 	// Verify that release "b" cannot take ownership of "a"
-	err = resources.Visit(setMetadataVisitor("rel-b", "ns-a", false))
-	require.Error(t, err)
+	require.Error(t, resources.Visit(setMetadataVisitor("rel-b", "ns-a", false)))
 
 	// Force release "b" to take ownership
-	err = resources.Visit(setMetadataVisitor("rel-b", "ns-a", true))
-	require.NoError(t, err)
+	require.NoError(t, resources.Visit(setMetadataVisitor("rel-b", "ns-a", true)))
 
 	// Check that there is now no ownership error when setting metadata without force
-	err = resources.Visit(setMetadataVisitor("rel-b", "ns-a", false))
-	require.NoError(t, err)
+	require.NoError(t, resources.Visit(setMetadataVisitor("rel-b", "ns-a", false)))
 
 	// Add a new resource that is missing ownership metadata and verify error
 	resources.Append(newDeploymentResource("baz", "default", ""))
-	err = resources.Visit(setMetadataVisitor("rel-b", "ns-a", false))
-	assert.ErrorContains(t, err, `Deployment "baz" in namespace "" cannot be owned`)
+	assert.ErrorContains(t, resources.Visit(setMetadataVisitor("rel-b", "ns-a", false)), `Deployment "baz" in namespace "" cannot be owned`)
 }
 
 func TestValidateNameAndGenerateName(t *testing.T) {
diff --git a/pkg/chart/v2/lint/rules/values_test.go b/pkg/chart/v2/lint/rules/values_test.go
index 470904049..82e8e660e 100644
--- a/pkg/chart/v2/lint/rules/values_test.go
+++ b/pkg/chart/v2/lint/rules/values_test.go
@@ -22,6 +22,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 
 	"helm.sh/helm/v4/internal/test/ensure"
 )
@@ -54,11 +55,7 @@ const testSchema = `
 func TestValidateValuesYamlNotDirectory(t *testing.T) {
 	_ = os.Mkdir(nonExistingValuesFilePath, os.ModePerm)
 	defer os.Remove(nonExistingValuesFilePath)
-
-	err := validateValuesFileExistence(nonExistingValuesFilePath)
-	if err == nil {
-		t.Error("validateValuesFileExistence to return a linter error, got no error")
-	}
+	assert.Error(t, validateValuesFileExistence(nonExistingValuesFilePath), "validateValuesFileExistence to return a linter error, got no error")
 }
 
 func TestValidateValuesFileWellFormed(t *testing.T) {
@@ -67,9 +64,7 @@ func TestValidateValuesFileWellFormed(t *testing.T) {
 	`
 	tmpdir := ensure.TempFile(t, "values.yaml", []byte(badYaml))
 	valfile := filepath.Join(tmpdir, "values.yaml")
-	if err := validateValuesFile(valfile, map[string]any{}, false); err == nil {
-		t.Fatal("expected values file to fail parsing")
-	}
+	require.Error(t, validateValuesFile(valfile, map[string]any{}, false), "expected values file to fail parsing")
 }
 
 func TestValidateValuesFileSchema(t *testing.T) {
@@ -78,9 +73,7 @@ func TestValidateValuesFileSchema(t *testing.T) {
 	createTestingSchema(t, tmpdir)
 
 	valfile := filepath.Join(tmpdir, "values.yaml")
-	if err := validateValuesFile(valfile, map[string]any{}, false); err != nil {
-		t.Fatalf("Failed validation with %s", err)
-	}
+	require.NoErrorf(t, validateValuesFile(valfile, map[string]any{}, false), "Failed validation")
 }
 
 func TestValidateValuesFileSchemaFailure(t *testing.T) {
@@ -90,9 +83,7 @@ func TestValidateValuesFileSchemaFailure(t *testing.T) {
 	createTestingSchema(t, tmpdir)
 
 	valfile := filepath.Join(tmpdir, "values.yaml")
-
-	err := validateValuesFile(valfile, map[string]any{}, false)
-	assert.ErrorContains(t, err, "- at '/username': got number, want string")
+	assert.ErrorContains(t, validateValuesFile(valfile, map[string]any{}, false), "- at '/username': got number, want string")
 }
 
 func TestValidateValuesFileSchemaFailureButWithSkipSchemaValidation(t *testing.T) {
@@ -102,11 +93,7 @@ func TestValidateValuesFileSchemaFailureButWithSkipSchemaValidation(t *testing.T
 	createTestingSchema(t, tmpdir)
 
 	valfile := filepath.Join(tmpdir, "values.yaml")
-
-	err := validateValuesFile(valfile, map[string]any{}, true)
-	if err != nil {
-		t.Fatal("expected values file to pass parsing because of skipSchemaValidation")
-	}
+	require.NoError(t, validateValuesFile(valfile, map[string]any{}, true), "expected values file to pass parsing because of skipSchemaValidation")
 }
 
 func TestValidateValuesFileSchemaOverrides(t *testing.T) {
@@ -118,9 +105,7 @@ func TestValidateValuesFileSchemaOverrides(t *testing.T) {
 	createTestingSchema(t, tmpdir)
 
 	valfile := filepath.Join(tmpdir, "values.yaml")
-	if err := validateValuesFile(valfile, overrides, false); err != nil {
-		t.Fatalf("Failed validation with %s", err)
-	}
+	require.NoErrorf(t, validateValuesFile(valfile, overrides, false), "Failed validation")
 }
 
 func TestValidateValuesFile(t *testing.T) {
@@ -157,13 +142,10 @@ func TestValidateValuesFile(t *testing.T) {
 
 			err := validateValuesFile(valfile, tt.overrides, false)
 
-			switch {
-			case err != nil && tt.errorMessage == "":
-				t.Errorf("Failed validation with %s", err)
-			case err == nil && tt.errorMessage != "":
-				t.Error("expected values file to fail parsing")
-			case err != nil && tt.errorMessage != "":
-				assert.ErrorContains(t, err, tt.errorMessage, "Failed with unexpected error")
+			if tt.errorMessage == "" {
+				require.NoErrorf(t, err, "Failed validation with")
+			} else {
+				assert.ErrorContains(t, err, tt.errorMessage)
 			}
 		})
 	}
@@ -172,8 +154,6 @@ func TestValidateValuesFile(t *testing.T) {
 func createTestingSchema(t *testing.T, dir string) string {
 	t.Helper()
 	schemafile := filepath.Join(dir, "values.schema.json")
-	if err := os.WriteFile(schemafile, []byte(testSchema), 0o700); err != nil {
-		t.Fatalf("Failed to write schema to tmpdir: %s", err)
-	}
+	require.NoErrorf(t, os.WriteFile(schemafile, []byte(testSchema), 0o700), "Failed to write schema to tmpdir")
 	return schemafile
 }
diff --git a/pkg/cmd/install_test.go b/pkg/cmd/install_test.go
index 8d3435e03..d1e081e5c 100644
--- a/pkg/cmd/install_test.go
+++ b/pkg/cmd/install_test.go
@@ -23,6 +23,8 @@ import (
 	"path/filepath"
 	"testing"
 
+	"github.com/stretchr/testify/require"
+
 	"helm.sh/helm/v4/pkg/repo/v1/repotest"
 )
 
@@ -39,9 +41,7 @@ func TestInstall(t *testing.T) {
 	}))
 	defer srv2.Close()
 
-	if err := srv.LinkIndices(); err != nil {
-		t.Fatal(err)
-	}
+	require.NoError(t, srv.LinkIndices())
 
 	repoFile := filepath.Join(srv.Root(), "repositories.yaml")
 
diff --git a/pkg/cmd/plugin_test.go b/pkg/cmd/plugin_test.go
index 5364423a0..6a7980119 100644
--- a/pkg/cmd/plugin_test.go
+++ b/pkg/cmd/plugin_test.go
@@ -72,14 +72,10 @@ func TestManuallyProcessArgs(t *testing.T) {
 	known, unknown := manuallyProcessArgs(input)
 
 	for i, k := range known {
-		if k != expectKnown[i] {
-			t.Errorf("expected known flag %d to be %q, got %q", i, expectKnown[i], k)
-		}
+		assert.Equal(t, expectKnown[i], k, "expected known flag %d to be %q, got %q", i, expectKnown[i], k)
 	}
 	for i, k := range unknown {
-		if k != expectUnknown[i] {
-			t.Errorf("expected unknown flag %d to be %q, got %q", i, expectUnknown[i], k)
-		}
+		assert.Equal(t, expectUnknown[i], k, "expected unknown flag %d to be %q, got %q", i, expectUnknown[i], k)
 	}
 }
 
@@ -130,23 +126,17 @@ func TestLoadCLIPlugins(t *testing.T) {
 		pluginCmd := pluginCmds[i]
 		t.Run(fmt.Sprintf("%s-%d", pluginCmd.Name(), i), func(t *testing.T) {
 			out.Reset()
-			if pluginCmd.Use != tt.use {
-				t.Errorf("%d: Expected Use=%q, got %q", i, tt.use, pluginCmd.Use)
-			}
-			if pluginCmd.Short != tt.short {
-				t.Errorf("%d: Expected Use=%q, got %q", i, tt.short, pluginCmd.Short)
-			}
-			if pluginCmd.Long != tt.long {
-				t.Errorf("%d: Expected Use=%q, got %q", i, tt.long, pluginCmd.Long)
-			}
+			assert.Equal(t, tt.use, pluginCmd.Use, "%d: Expected Use=%q, got %q", i, tt.use, pluginCmd.Use)
+			assert.Equal(t, tt.short, pluginCmd.Short, "%d: Expected Use=%q, got %q", i, tt.short, pluginCmd.Short)
+			assert.Equal(t, tt.long, pluginCmd.Long, "%d: Expected Use=%q, got %q", i, tt.long, pluginCmd.Long)
 
 			// Currently, plugins assume a Linux subsystem. Skip the execution
 			// tests until this is fixed
 			if runtime.GOOS != "windows" {
 				if err := pluginCmd.RunE(pluginCmd, tt.args); err != nil {
-					if assert.Positive(t, tt.code, "Error running %s: %+v", tt.use, err) {
+					if assert.Positive(t, tt.code, "Error running %s", tt.use) {
 						var cerr CommandError
-						require.ErrorAs(t, err, &cerr, "Expected %s to return pluginError: got %v(%T)", tt.use, err, err)
+						require.ErrorAs(t, err, &cerr, "Expected %s to return pluginError", tt.use)
 						assert.Equalf(t, tt.code, cerr.ExitCode, "Expected %s to return %d: got %d", tt.use, tt.code, cerr.ExitCode)
 					}
 				}
@@ -190,31 +180,23 @@ func TestLoadPluginsWithSpace(t *testing.T) {
 
 	plugins := cmd.Commands()
 
-	if len(plugins) != len(tests) {
-		t.Fatalf("Expected %d plugins, got %d", len(tests), len(plugins))
-	}
+	require.Len(t, plugins, len(tests), "Expected %d plugins, got %d", len(tests), len(plugins))
 
 	for i := range plugins {
 		out.Reset()
 		tt := tests[i]
 		pp := plugins[i]
-		if pp.Use != tt.use {
-			t.Errorf("%d: Expected Use=%q, got %q", i, tt.use, pp.Use)
-		}
-		if pp.Short != tt.short {
-			t.Errorf("%d: Expected Use=%q, got %q", i, tt.short, pp.Short)
-		}
-		if pp.Long != tt.long {
-			t.Errorf("%d: Expected Use=%q, got %q", i, tt.long, pp.Long)
-		}
+		assert.Equal(t, tt.use, pp.Use, "%d: Expected Use=%q, got %q", i, tt.use, pp.Use)
+		assert.Equal(t, tt.short, pp.Short, "%d: Expected Use=%q, got %q", i, tt.short, pp.Short)
+		assert.Equal(t, tt.long, pp.Long, "%d: Expected Use=%q, got %q", i, tt.long, pp.Long)
 
 		// Currently, plugins assume a Linux subsystem. Skip the execution
 		// tests until this is fixed
 		if runtime.GOOS != "windows" {
 			if err := pp.RunE(pp, tt.args); err != nil {
-				if assert.Positive(t, tt.code, "Error running %s: %+v", tt.use, err) {
+				if assert.Positive(t, tt.code, "Error running %s", tt.use) {
 					var cerr CommandError
-					require.ErrorAs(t, err, &cerr, "Expected %s to return pluginError: got %v(%T)", tt.use, err, err)
+					require.ErrorAs(t, err, &cerr, "Expected %s to return pluginError", tt.use)
 					assert.Equalf(t, tt.code, cerr.ExitCode, "Expected %s to return %d: got %d", tt.use, tt.code, cerr.ExitCode)
 				}
 			}
@@ -334,9 +316,7 @@ func TestLoadCLIPlugins_HelmNoPlugins(t *testing.T) {
 	loadCLIPlugins(cmd, out)
 	plugins := cmd.Commands()
 
-	if len(plugins) != 0 {
-		t.Fatalf("Expected 0 plugins, got %d", len(plugins))
-	}
+	require.Empty(t, plugins, "Expected 0 plugins, got %d", len(plugins))
 }
 
 func TestPluginCmdsCompletion(t *testing.T) {
diff --git a/pkg/getter/getter_test.go b/pkg/getter/getter_test.go
index 3a09b4d82..67cfc2ef0 100644
--- a/pkg/getter/getter_test.go
+++ b/pkg/getter/getter_test.go
@@ -19,6 +19,9 @@ import (
 	"testing"
 	"time"
 
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
 	"helm.sh/helm/v4/pkg/cli"
 )
 
@@ -30,9 +33,7 @@ func TestProvider(t *testing.T) {
 		func(_ ...Option) (Getter, error) { return nil, nil },
 	}
 
-	if !p.Provides("three") {
-		t.Error("Expected provider to provide three")
-	}
+	assert.True(t, p.Provides("three"), "Expected provider to provide three")
 }
 
 func TestProviders(t *testing.T) {
@@ -41,34 +42,25 @@ func TestProviders(t *testing.T) {
 		{[]string{"two", "four"}, func(_ ...Option) (Getter, error) { return nil, nil }},
 	}
 
-	if _, err := ps.ByScheme("one"); err != nil {
-		t.Error(err)
-	}
-	if _, err := ps.ByScheme("four"); err != nil {
-		t.Error(err)
-	}
+	_, err := ps.ByScheme("one")
+	require.NoError(t, err)
+	_, err = ps.ByScheme("four")
+	require.NoError(t, err)
 
-	if _, err := ps.ByScheme("five"); err == nil {
-		t.Error("Did not expect handler for five")
-	}
+	_, err = ps.ByScheme("five")
+	assert.Error(t, err, "Did not expect handler for five")
 }
 
 func TestProvidersWithTimeout(t *testing.T) {
 	want := time.Hour
 	getters := Getters(WithTimeout(want))
 	getter, err := getters.ByScheme("http")
-	if err != nil {
-		t.Error(err)
-	}
+	require.NoError(t, err)
 	httpGetter := getter.(*HTTPGetter)
 	client, err := httpGetter.httpClient(httpGetter.opts)
-	if err != nil {
-		t.Error(err)
-	}
+	require.NoError(t, err)
 	got := client.Timeout
-	if got != want {
-		t.Errorf("Expected %q, got %q", want, got)
-	}
+	assert.Equal(t, want, got, "Expected %q, got %q", want, got)
 }
 
 func TestAll(t *testing.T) {
@@ -76,13 +68,10 @@ func TestAll(t *testing.T) {
 	env.PluginsDirectory = pluginDir
 
 	all := All(env)
-	if len(all) != 4 {
-		t.Errorf("expected 4 providers (default plus three plugins), got %d", len(all))
-	}
+	assert.Len(t, all, 4, "expected 4 providers (default plus three plugins), got %d", len(all))
 
-	if _, err := all.ByScheme("test2"); err != nil {
-		t.Error(err)
-	}
+	_, err := all.ByScheme("test2")
+	assert.NoError(t, err)
 }
 
 func TestByScheme(t *testing.T) {
@@ -90,10 +79,8 @@ func TestByScheme(t *testing.T) {
 	env.PluginsDirectory = pluginDir
 
 	g := All(env)
-	if _, err := g.ByScheme("test"); err != nil {
-		t.Error(err)
-	}
-	if _, err := g.ByScheme("https"); err != nil {
-		t.Error(err)
-	}
+	_, err := g.ByScheme("test")
+	require.NoError(t, err)
+	_, err = g.ByScheme("https")
+	assert.NoError(t, err)
 }
diff --git a/pkg/storage/driver/records_test.go b/pkg/storage/driver/records_test.go
index cd1064342..067e31e76 100644
--- a/pkg/storage/driver/records_test.go
+++ b/pkg/storage/driver/records_test.go
@@ -20,6 +20,9 @@ import (
 	"reflect"
 	"testing"
 
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
 	"helm.sh/helm/v4/pkg/release/common"
 )
 
@@ -50,10 +53,11 @@ func TestRecordsAdd(t *testing.T) {
 	}
 
 	for _, tt := range tests {
-		if err := rs.Add(tt.rec); err != nil {
-			if !tt.ok {
-				t.Fatalf("failed: %q: %s\n", tt.desc, err)
-			}
+		err := rs.Add(tt.rec)
+		if !tt.ok {
+			require.NoError(t, err, "failed: %q:", tt.desc)
+		} else {
+			require.Error(t, err)
 		}
 	}
 }
@@ -77,23 +81,18 @@ func TestRecordsRemove(t *testing.T) {
 	startLen := rs.Len()
 
 	for _, tt := range tests {
-		if r := rs.Remove(tt.key); r == nil {
-			if !tt.ok {
-				t.Fatalf("Failed to %q (key = %s). Expected nil, got %v",
-					tt.desc,
-					tt.key,
-					r,
-				)
-			}
+		r := rs.Remove(tt.key)
+		if tt.ok {
+			require.Nil(t, r, "Failed to %q (key = %s). Expected nil, got %v", tt.desc, tt.key, r)
+		} else {
+			require.NotNil(t, r)
 		}
 	}
 
 	// We expect the total number of records will be less now than there were
 	// when we started.
 	endLen := rs.Len()
-	if endLen >= startLen {
-		t.Errorf("expected ending length %d to be less than starting length %d", endLen, startLen)
-	}
+	assert.Lessf(t, endLen, startLen, "expected ending length %d to be less than starting length %d", endLen, startLen)
 }
 
 func TestRecordsRemoveAt(t *testing.T) {
@@ -102,14 +101,10 @@ func TestRecordsRemoveAt(t *testing.T) {
 		newRecord("rls-a.v2", releaseStub("rls-a", 2, "default", common.StatusDeployed)),
 	})
 
-	if len(rs) != 2 {
-		t.Fatal("Expected len=2 for mock")
-	}
+	require.Len(t, rs, 2, "Expected len=2 for mock")
 
 	rs.Remove("rls-a.v1")
-	if len(rs) != 1 {
-		t.Fatalf("Expected length of rs to be 1, got %d", len(rs))
-	}
+	require.Len(t, rs, 1, "Expected length of rs to be 1, got %d", len(rs))
 }
 
 func TestRecordsGet(t *testing.T) {
@@ -137,9 +132,7 @@ func TestRecordsGet(t *testing.T) {
 
 	for _, tt := range tests {
 		got := rs.Get(tt.key)
-		if !reflect.DeepEqual(tt.rec, got) {
-			t.Fatalf("Expected %v, got %v", tt.rec, got)
-		}
+		require.Truef(t, reflect.DeepEqual(tt.rec, got), "Expected %v, got %v", tt.rec, got)
 	}
 }
 
@@ -168,9 +161,7 @@ func TestRecordsIndex(t *testing.T) {
 
 	for _, tt := range tests {
 		got, _ := rs.Index(tt.key)
-		if got != tt.sort {
-			t.Fatalf("Expected %d, got %d", tt.sort, got)
-		}
+		require.Equal(t, tt.sort, got, "Expected %d, got %d", tt.sort, got)
 	}
 }
 
@@ -199,9 +190,7 @@ func TestRecordsExists(t *testing.T) {
 
 	for _, tt := range tests {
 		got := rs.Exists(tt.key)
-		if got != tt.ok {
-			t.Fatalf("Expected %t, got %t", tt.ok, got)
-		}
+		require.Equal(t, tt.ok, got, "Expected %t, got %t", tt.ok, got)
 	}
 }
 
@@ -233,8 +222,6 @@ func TestRecordsReplace(t *testing.T) {
 
 	for _, tt := range tests {
 		got := rs.Replace(tt.key, tt.rec)
-		if !reflect.DeepEqual(tt.expected, got) {
-			t.Fatalf("Expected %v, got %v", tt.expected, got)
-		}
+		require.Truef(t, reflect.DeepEqual(tt.expected, got), "Expected %v, got %v", tt.expected, got)
 	}
 }

From 050d3e99b9dc8796ced4b99cb272cba91c43055f Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Fri, 24 Jul 2026 04:32:02 -0600
Subject: [PATCH 02/13] chore(deps): bump ossf/scorecard-action in the
 github-actions group (#32458)

Bumps the github-actions group with 1 update: [ossf/scorecard-action](https://github.com/ossf/scorecard-action).


Updates `ossf/scorecard-action` from 2.4.3 to 2.4.4
- [Release notes](https://github.com/ossf/scorecard-action/releases)
- [Changelog](https://github.com/ossf/scorecard-action/blob/main/RELEASE.md)
- [Commits](https://github.com/ossf/scorecard-action/compare/4eaacf0543bb3f2c246792bd56e8cdeffafb205a...2d1146689b8cda280b9bc96326124645441f03bc)

---
updated-dependencies:
- dependency-name: ossf/scorecard-action
  dependency-version: 2.4.4
  dependency-type: direct:production
  update-type: version-update:semver-patch
  dependency-group: github-actions
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 .github/workflows/scorecards.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/scorecards.yml b/.github/workflows/scorecards.yml
index d8f878f10..6c142b511 100644
--- a/.github/workflows/scorecards.yml
+++ b/.github/workflows/scorecards.yml
@@ -33,7 +33,7 @@ jobs:
           persist-credentials: false
 
       - name: "Run analysis"
-        uses: ossf/scorecard-action@4eaacf0543bb3f2c246792bd56e8cdeffafb205a # v2.4.3
+        uses: ossf/scorecard-action@2d1146689b8cda280b9bc96326124645441f03bc # v2.4.4
         with:
           results_file: results.sarif
           results_format: sarif

From 8f74dce6ba8d7264ce75f52507616720865e712d Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Fri, 24 Jul 2026 04:40:32 -0600
Subject: [PATCH 03/13] chore(deps): bump the k8s-io group across 1 directory
 with 7 updates (#32459)

Bumps the k8s-io group with 4 updates in the / directory: [k8s.io/api](https://github.com/kubernetes/api), [k8s.io/apiextensions-apiserver](https://github.com/kubernetes/apiextensions-apiserver), [k8s.io/cli-runtime](https://github.com/kubernetes/cli-runtime) and [k8s.io/kubectl](https://github.com/kubernetes/kubectl).


Updates `k8s.io/api` from 0.36.2 to 0.36.3
- [Commits](https://github.com/kubernetes/api/compare/v0.36.2...v0.36.3)

Updates `k8s.io/apiextensions-apiserver` from 0.36.2 to 0.36.3
- [Release notes](https://github.com/kubernetes/apiextensions-apiserver/releases)
- [Commits](https://github.com/kubernetes/apiextensions-apiserver/compare/v0.36.2...v0.36.3)

Updates `k8s.io/apimachinery` from 0.36.2 to 0.36.3
- [Commits](https://github.com/kubernetes/apimachinery/compare/v0.36.2...v0.36.3)

Updates `k8s.io/apiserver` from 0.36.2 to 0.36.3
- [Commits](https://github.com/kubernetes/apiserver/compare/v0.36.2...v0.36.3)

Updates `k8s.io/cli-runtime` from 0.36.2 to 0.36.3
- [Commits](https://github.com/kubernetes/cli-runtime/compare/v0.36.2...v0.36.3)

Updates `k8s.io/client-go` from 0.36.2 to 0.36.3
- [Changelog](https://github.com/kubernetes/client-go/blob/master/CHANGELOG.md)
- [Commits](https://github.com/kubernetes/client-go/compare/v0.36.2...v0.36.3)

Updates `k8s.io/kubectl` from 0.36.2 to 0.36.3
- [Commits](https://github.com/kubernetes/kubectl/compare/v0.36.2...v0.36.3)

---
updated-dependencies:
- dependency-name: k8s.io/api
  dependency-version: 0.36.3
  dependency-type: direct:production
  update-type: version-update:semver-patch
  dependency-group: k8s-io
- dependency-name: k8s.io/apiextensions-apiserver
  dependency-version: 0.36.3
  dependency-type: direct:production
  update-type: version-update:semver-patch
  dependency-group: k8s-io
- dependency-name: k8s.io/apimachinery
  dependency-version: 0.36.3
  dependency-type: direct:production
  update-type: version-update:semver-patch
  dependency-group: k8s-io
- dependency-name: k8s.io/apiserver
  dependency-version: 0.36.3
  dependency-type: direct:production
  update-type: version-update:semver-patch
  dependency-group: k8s-io
- dependency-name: k8s.io/cli-runtime
  dependency-version: 0.36.3
  dependency-type: direct:production
  update-type: version-update:semver-patch
  dependency-group: k8s-io
- dependency-name: k8s.io/client-go
  dependency-version: 0.36.3
  dependency-type: direct:production
  update-type: version-update:semver-patch
  dependency-group: k8s-io
- dependency-name: k8s.io/kubectl
  dependency-version: 0.36.3
  dependency-type: direct:production
  update-type: version-update:semver-patch
  dependency-group: k8s-io
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 go.mod | 18 +++++++++---------
 go.sum | 36 ++++++++++++++++++------------------
 2 files changed, 27 insertions(+), 27 deletions(-)

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

From 5142ca8ddca79a19c8529508c77ab4b27cb23a8f Mon Sep 17 00:00:00 2001
From: Matthieu MOREL <matthieu.morel35@gmail.com>
Date: Fri, 24 Jul 2026 13:24:06 +0200
Subject: [PATCH 04/13] chore(internal): refactor: finer tests conversions to
 testify part 1

#### Description

refactor: finer tests conversions to testify in internal/chart/v3/util
Signed-off-by: Matthieu MOREL <matthieu.morel35@gmail.com>
---
 internal/chart/v3/lint/lint_test.go           | 15 +++---
 internal/chart/v3/lint/rules/crds_test.go     |  3 +-
 internal/chart/v3/lint/rules/template_test.go | 11 ++--
 .../chart/v3/lint/support/message_test.go     |  6 +--
 internal/chart/v3/loader/load_test.go         | 31 ++++-------
 internal/chart/v3/util/chartfile_test.go      | 19 +------
 internal/chart/v3/util/expand_test.go         |  4 +-
 internal/chart/v3/util/save_test.go           |  5 +-
 .../plugin/installer/http_installer_test.go   | 26 +++++-----
 internal/plugin/installer/installer_test.go   |  2 -
 .../plugin/installer/vcs_installer_test.go    | 25 ++++-----
 internal/plugin/subprocess_commands_test.go   | 15 +++---
 .../release/v2/util/manifest_sorter_test.go   |  1 -
 internal/resolver/resolver_test.go            | 52 ++++++++-----------
 14 files changed, 84 insertions(+), 131 deletions(-)

diff --git a/internal/chart/v3/lint/lint_test.go b/internal/chart/v3/lint/lint_test.go
index 8916c6e22..b0a7ce651 100644
--- a/internal/chart/v3/lint/lint_test.go
+++ b/internal/chart/v3/lint/lint_test.go
@@ -114,7 +114,7 @@ func TestBadValuesV3(t *testing.T) {
 func TestBadCrdFileV3(t *testing.T) {
 	var values map[string]any
 	m := RunAll(badCrdFileDir, values, namespace).Messages
-	assert.Lenf(t, m, 2, "All didn't fail with expected errors, got %#v", m)
+	require.Lenf(t, m, 2, "All didn't fail with expected errors, got %#v", m)
 	require.ErrorContains(t, m[0].Err, "apiVersion is not in 'apiextensions.k8s.io'")
 	assert.ErrorContains(t, m[1].Err, "object kind is not 'CustomResourceDefinition'")
 }
@@ -122,8 +122,7 @@ func TestBadCrdFileV3(t *testing.T) {
 func TestGoodChart(t *testing.T) {
 	var values map[string]any
 	m := RunAll(goodChartDir, values, namespace).Messages
-	if len(m) != 0 {
-		t.Error("All returned linter messages when it shouldn't have")
+	if !assert.Empty(t, m, "All returned linter messages when it shouldn't have") {
 		for i, msg := range m {
 			t.Logf("Message %d: %s", i, msg)
 		}
@@ -143,13 +142,12 @@ func TestHelmCreateChart(t *testing.T) {
 	// Note: we test with strict=true here, even though others have
 	// strict = false.
 	m := RunAll(createdChart, values, namespace, WithSkipSchemaValidation(true)).Messages
-	if ll := len(m); ll != 1 {
-		t.Errorf("All should have had exactly 1 error. Got %d", ll)
+	if !assert.Len(t, m, 1, "All should have had exactly 1 error") {
 		for i, msg := range m {
 			t.Logf("Message %d: %s", i, msg.Error())
 		}
-	} else if msg := m[0].Err.Error(); !strings.Contains(msg, "icon is recommended") {
-		t.Errorf("Unexpected lint error: %s", msg)
+	} else {
+		assert.ErrorContains(t, m[0].Err, "icon is recommended")
 	}
 }
 
@@ -192,8 +190,7 @@ func TestHelmCreateChart_CheckDeprecatedWarnings(t *testing.T) {
 func TestSubChartValuesChart(t *testing.T) {
 	var values map[string]any
 	m := RunAll(subChartValuesDir, values, namespace).Messages
-	if len(m) != 0 {
-		t.Error("All returned linter messages when it shouldn't have")
+	if !assert.Empty(t, m, "All returned linter messages when it shouldn't have") {
 		for i, msg := range m {
 			t.Logf("Message %d: %s", i, msg)
 		}
diff --git a/internal/chart/v3/lint/rules/crds_test.go b/internal/chart/v3/lint/rules/crds_test.go
index 60cb1b5ba..9009c1801 100644
--- a/internal/chart/v3/lint/rules/crds_test.go
+++ b/internal/chart/v3/lint/rules/crds_test.go
@@ -22,6 +22,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 
 	"helm.sh/helm/v4/internal/chart/v3/lint/support"
 )
@@ -33,7 +34,7 @@ func TestInvalidCrdsDir(t *testing.T) {
 	Crds(&linter)
 	res := linter.Messages
 
-	assert.Len(t, res, 1)
+	require.Len(t, res, 1)
 	assert.ErrorContains(t, res[0].Err, "not a directory")
 }
 
diff --git a/internal/chart/v3/lint/rules/template_test.go b/internal/chart/v3/lint/rules/template_test.go
index b4fa2d311..3271a5bbe 100644
--- a/internal/chart/v3/lint/rules/template_test.go
+++ b/internal/chart/v3/lint/rules/template_test.go
@@ -199,12 +199,12 @@ func TestDeprecatedAPIFails(t *testing.T) {
 
 	linter := support.Linter{ChartDir: filepath.Join(tmpdir, mychart.Name())}
 	Templates(&linter, values, namespace, strict)
-	if l := len(linter.Messages); l != 1 {
+	if !assert.Len(t, linter.Messages, 1) {
 		for i, msg := range linter.Messages {
 			t.Logf("Message %d: %s", i, msg)
 		}
-		t.Fatalf("Expected 1 lint error, got %d", l)
 	}
+	require.Len(t, linter.Messages, 1, "Expected 1 lint error")
 
 	var err deprecatedAPIError
 	require.ErrorAs(t, linter.Messages[0].Err, &err, "Expected error to be of type deprecatedAPIError")
@@ -252,8 +252,7 @@ func TestStrictTemplateParsingMapError(t *testing.T) {
 		ChartDir: filepath.Join(dir, ch.Metadata.Name),
 	}
 	Templates(linter, ch.Values, namespace, strict)
-	if len(linter.Messages) != 0 {
-		t.Errorf("expected zero messages, got %d", len(linter.Messages))
+	if !assert.Empty(t, linter.Messages, "expected zero messages") {
 		for i, msg := range linter.Messages {
 			t.Logf("Message %d: %q", i, msg)
 		}
@@ -376,12 +375,12 @@ func TestEmptyWithCommentsManifests(t *testing.T) {
 
 	linter := support.Linter{ChartDir: filepath.Join(tmpdir, mychart.Name())}
 	Templates(&linter, values, namespace, strict)
-	if l := len(linter.Messages); l > 0 {
+	if !assert.Empty(t, linter.Messages) {
 		for i, msg := range linter.Messages {
 			t.Logf("Message %d: %s", i, msg)
 		}
-		t.Fatalf("Expected 0 lint errors, got %d", l)
 	}
+	require.Empty(t, linter.Messages, "Expected 0 lint errors")
 }
 func TestValidateListAnnotations(t *testing.T) {
 	md := &k8sYamlStruct{
diff --git a/internal/chart/v3/lint/support/message_test.go b/internal/chart/v3/lint/support/message_test.go
index 4c3ed3a3f..d07cf9ed4 100644
--- a/internal/chart/v3/lint/support/message_test.go
+++ b/internal/chart/v3/lint/support/message_test.go
@@ -58,11 +58,11 @@ func TestRunLinterRule(t *testing.T) {
 
 func TestMessage(t *testing.T) {
 	m := Message{ErrorSev, "Chart.yaml", errors.New("Foo")}
-	require.EqualErrorf(t, m, "[ERROR] Chart.yaml: Foo", "Unexpected output: %s", m.Error())
+	require.EqualError(t, m, "[ERROR] Chart.yaml: Foo")
 
 	m = Message{WarningSev, "templates/", errors.New("Bar")}
-	require.EqualErrorf(t, m, "[WARNING] templates/: Bar", "Unexpected output: %s", m.Error())
+	require.EqualError(t, m, "[WARNING] templates/: Bar")
 
 	m = Message{InfoSev, "templates/rc.yaml", errors.New("FooBar")}
-	assert.EqualErrorf(t, m, "[INFO] templates/rc.yaml: FooBar", "Unexpected output: %s", m.Error())
+	assert.EqualError(t, m, "[INFO] templates/rc.yaml: FooBar")
 }
diff --git a/internal/chart/v3/loader/load_test.go b/internal/chart/v3/loader/load_test.go
index 9378bcdf5..dd5fdc8db 100644
--- a/internal/chart/v3/loader/load_test.go
+++ b/internal/chart/v3/loader/load_test.go
@@ -25,7 +25,6 @@ import (
 	"log"
 	"os"
 	"path/filepath"
-	"reflect"
 	"runtime"
 	"strings"
 	"testing"
@@ -201,11 +200,9 @@ icon: https://example.com/64x64.png
 	require.NoError(t, err, "Expected good files to be loaded")
 	assert.Equal(t, "frobnitz", c.Name(), "Expected chart name to be 'frobnitz', got %s", c.Name())
 	assert.Equal(t, "some values", c.Values["var"], "Expected chart values to be populated with default values")
-	assert.Len(t, c.Raw, 5, "Expected %d files, got %d", 5, len(c.Raw))
-
+	assert.Len(t, c.Raw, 5, "Expected 5 files")
 	assert.True(t, bytes.Equal(c.Schema, []byte("type: Values")), "Expected chart schema to be populated with default values")
-
-	assert.Len(t, c.Templates, 2, "Expected number of templates == 2, got %d", len(c.Templates))
+	assert.Len(t, c.Templates, 2, "Expected 2 templates")
 
 	_, err = LoadFiles([]*archive.BufferedFile{})
 	require.Error(t, err, "Expected err to be non-nil")
@@ -417,7 +414,7 @@ foo:
 		t.Run(testName, func(tt *testing.T) {
 			values, err := LoadValues(bytes.NewReader(testCase.data))
 			require.NoError(tt, err)
-			assert.Truef(tt, reflect.DeepEqual(values, testCase.expctedValues), "Expected values: %v, got %v", testCase.expctedValues, values)
+			assert.Equalf(tt, testCase.expctedValues, values, "Expected values: %v, got %v", testCase.expctedValues, values)
 		})
 	}
 }
@@ -445,16 +442,13 @@ func TestMergeValuesV3(t *testing.T) {
 	}
 
 	testMap := MergeMaps(flatMap, nestedMap)
-	equal := reflect.DeepEqual(testMap, nestedMap)
-	assert.True(t, equal, "Expected a nested map to overwrite a flat value. Expected: %v, got %v", nestedMap, testMap)
+	assert.Equal(t, testMap, nestedMap, "Expected a nested map to overwrite a flat value. Expected: %v, got %v", nestedMap, testMap)
 
 	testMap = MergeMaps(nestedMap, flatMap)
-	equal = reflect.DeepEqual(testMap, flatMap)
-	assert.True(t, equal, "Expected a flat value to overwrite a map. Expected: %v, got %v", flatMap, testMap)
+	assert.Equal(t, testMap, flatMap, "Expected a flat value to overwrite a map. Expected: %v, got %v", flatMap, testMap)
 
 	testMap = MergeMaps(nestedMap, anotherNestedMap)
-	equal = reflect.DeepEqual(testMap, anotherNestedMap)
-	assert.True(t, equal, "Expected a nested map to overwrite another nested map. Expected: %v, got %v", anotherNestedMap, testMap)
+	assert.Equal(t, testMap, anotherNestedMap, "Expected a nested map to overwrite another nested map. Expected: %v, got %v", anotherNestedMap, testMap)
 
 	testMap = MergeMaps(anotherFlatMap, anotherNestedMap)
 	expectedMap := map[string]any{
@@ -465,26 +459,23 @@ func TestMergeValuesV3(t *testing.T) {
 			"awesome": "stuff",
 		},
 	}
-	equal = reflect.DeepEqual(testMap, expectedMap)
-	assert.True(t, equal, "Expected a map with different keys to merge properly with another map. Expected: %v, got %v", expectedMap, testMap)
+	assert.Equal(t, expectedMap, testMap, "Expected a map with different keys to merge properly with another map. Expected: %v, got %v", expectedMap, testMap)
 }
 
 func verifyChart(t *testing.T, c *chart.Chart) {
 	t.Helper()
 	require.NotEmpty(t, c.Name(), "No chart metadata found on %v", c)
 	t.Logf("Verifying chart %s", c.Name())
-	assert.Len(t, c.Templates, 1, "Expected 1 template, got %d", len(c.Templates))
+	assert.Len(t, c.Templates, 1, "Expected 1 template")
 
 	numfiles := 6
-	if len(c.Files) != numfiles {
-		t.Errorf("Expected %d extra files, got %d", numfiles, len(c.Files))
+	if !assert.Len(t, c.Files, numfiles, "Expected %d extra files", numfiles) {
 		for _, n := range c.Files {
 			t.Logf("\t%s", n.Name)
 		}
 	}
 
-	if len(c.Dependencies()) != 2 {
-		t.Errorf("Expected 2 dependencies, got %d (%v)", len(c.Dependencies()), c.Dependencies())
+	if !assert.Len(t, c.Dependencies(), 2, "Expected 2 dependencies") {
 		for _, d := range c.Dependencies() {
 			t.Logf("\tSubchart: %s\n", d.Name())
 		}
@@ -509,7 +500,7 @@ func verifyChart(t *testing.T, c *chart.Chart) {
 
 func verifyDependencies(t *testing.T, c *chart.Chart) {
 	t.Helper()
-	assert.Len(t, c.Metadata.Dependencies, 2, "Expected 2 dependencies, got %d", len(c.Metadata.Dependencies))
+	assert.Len(t, c.Metadata.Dependencies, 2, "Expected 2 dependencies")
 	tests := []*chart.Dependency{
 		{Name: "alpine", Version: "0.1.0", Repository: "https://example.com/charts"},
 		{Name: "mariner", Version: "4.3.2", Repository: "https://example.com/charts"},
diff --git a/internal/chart/v3/util/chartfile_test.go b/internal/chart/v3/util/chartfile_test.go
index 0cc8a66af..850f39af2 100644
--- a/internal/chart/v3/util/chartfile_test.go
+++ b/internal/chart/v3/util/chartfile_test.go
@@ -36,36 +36,21 @@ func TestLoadChartfile(t *testing.T) {
 func verifyChartfile(t *testing.T, f *chart.Metadata, name string) {
 	t.Helper()
 	require.NotNil(t, f, "Failed verifyChartfile because f is nil")
-
 	assert.Equal(t, name, f.Name, "Expected %s, got %s", name, f.Name)
-
 	assert.Equal(t, "This is a frobnitz.", f.Description, "Unexpected description %q", f.Description)
-
 	assert.Equal(t, "1.2.3", f.Version, "Unexpected version %q", f.Version)
-
 	assert.Len(t, f.Maintainers, 2, "Expected 2 maintainers, got %d", len(f.Maintainers))
-
 	assert.Equal(t, "The Helm Team", f.Maintainers[0].Name, "Unexpected maintainer name.")
-
 	assert.Equal(t, "nobody@example.com", f.Maintainers[1].Email, "Unexpected maintainer email.")
-
 	require.Len(t, f.Sources, 1, "Unexpected number of sources")
-
 	assert.Equal(t, "https://example.com/foo/bar", f.Sources[0], "Expected https://example.com/foo/bar, got %s", f.Sources)
-
 	assert.Equal(t, "http://example.com", f.Home, "Unexpected home.")
-
 	assert.Equal(t, "https://example.com/64x64.png", f.Icon, "Unexpected icon: %q", f.Icon)
-
 	require.Len(t, f.Keywords, 3, "Unexpected keywords")
-
 	require.Len(t, f.Annotations, 2, "Unexpected annotations")
 
-	want, got := "extravalue", f.Annotations["extrakey"]
-	assert.Equalf(t, want, got, "Want %q, but got %q", want, got)
-
-	want, got = "anothervalue", f.Annotations["anotherkey"]
-	assert.Equalf(t, want, got, "Want %q, but got %q", want, got)
+	assert.Equal(t, "extravalue", f.Annotations["extrakey"])
+	assert.Equal(t, "anothervalue", f.Annotations["anotherkey"])
 
 	kk := []string{"frobnitz", "sprocket", "dodad"}
 	for i, k := range f.Keywords {
diff --git a/internal/chart/v3/util/expand_test.go b/internal/chart/v3/util/expand_test.go
index e6d66b74e..ddf74b392 100644
--- a/internal/chart/v3/util/expand_test.go
+++ b/internal/chart/v3/util/expand_test.go
@@ -101,7 +101,7 @@ func TestExpand(t *testing.T) {
 	require.NoError(t, err)
 
 	expectLen := 11
-	assert.Len(t, fis, expectLen, "Expected %d files, but got %d", expectLen, len(fis))
+	assert.Len(t, fis, expectLen, "Expected %d files", expectLen)
 
 	for _, fi := range fis {
 		expect, err := os.Stat(filepath.Join("testdata", "frobnitz", fi.Name()))
@@ -154,7 +154,7 @@ func TestExpandFile(t *testing.T) {
 	require.NoError(t, err)
 
 	expectLen := 11
-	assert.Len(t, fis, expectLen, "Expected %d files, but got %d", expectLen, len(fis))
+	assert.Len(t, fis, expectLen, "Expected %d files", expectLen)
 
 	for _, fi := range fis {
 		expect, err := os.Stat(filepath.Join("testdata", "frobnitz", fi.Name()))
diff --git a/internal/chart/v3/util/save_test.go b/internal/chart/v3/util/save_test.go
index f7bd5dcfb..26bb54019 100644
--- a/internal/chart/v3/util/save_test.go
+++ b/internal/chart/v3/util/save_test.go
@@ -69,9 +69,8 @@ func TestSave(t *testing.T) {
 			c2, err := loader.LoadFile(where)
 			require.NoError(t, err)
 			require.Equal(t, c.Name(), c2.Name(), "Expected chart archive to have %q, got %q", c.Name(), c2.Name())
-			if len(c2.Files) != 1 || c2.Files[0].Name != "scheherazade/shahryar.txt" {
-				t.Fatal("Files data did not match")
-			}
+			require.Len(t, c2.Files, 1, "Files data did not match")
+			require.Equal(t, "scheherazade/shahryar.txt", c2.Files[0].Name, "Files data did not match")
 
 			if !bytes.Equal(c.Schema, c2.Schema) {
 				indentation := 4
diff --git a/internal/plugin/installer/http_installer_test.go b/internal/plugin/installer/http_installer_test.go
index d0d5e099d..df8385ed6 100644
--- a/internal/plugin/installer/http_installer_test.go
+++ b/internal/plugin/installer/http_installer_test.go
@@ -67,10 +67,10 @@ func mockArchiveServer() *httptest.Server {
 		if !strings.HasSuffix(r.URL.Path, ".tar.gz") {
 			w.Header().Add("Content-Type", "text/html")
 			fmt.Fprintln(w, "broken")
-			return
+		} else {
+			w.Header().Add("Content-Type", "application/gzip")
+			fmt.Fprintln(w, "test")
 		}
-		w.Header().Add("Content-Type", "application/gzip")
-		fmt.Fprintln(w, "test")
 	}))
 }
 
@@ -221,22 +221,22 @@ func TestExtract(t *testing.T) {
 	expectedReadmePerm := os.FileMode(0o777 &^ currentUmask)
 
 	pluginYAMLFullPath := filepath.Join(tempDir, "plugin.yaml")
-	if info, err := os.Stat(pluginYAMLFullPath); err != nil {
+	info, err := os.Stat(pluginYAMLFullPath)
+	if err != nil {
 		require.NotErrorIs(t, err, fs.ErrNotExist, "Expected %s to exist but doesn't", pluginYAMLFullPath)
-		t.Fatal(err)
-	} else {
-		require.Equalf(t, expectedPluginYAMLPerm, info.Mode().Perm(), "Expected %s to have %o mode but has %o (umask: %o)",
-			pluginYAMLFullPath, expectedPluginYAMLPerm, info.Mode().Perm(), currentUmask)
 	}
+	require.NoError(t, err)
+	require.Equalf(t, expectedPluginYAMLPerm, info.Mode().Perm(), "Expected %s to have %o mode but has %o (umask: %o)",
+		pluginYAMLFullPath, expectedPluginYAMLPerm, info.Mode().Perm(), currentUmask)
 
 	readmeFullPath := filepath.Join(tempDir, "README.md")
-	if info, err := os.Stat(readmeFullPath); err != nil {
+	info, err = os.Stat(readmeFullPath)
+	if err != nil {
 		require.NotErrorIs(t, err, fs.ErrNotExist, "Expected %s to exist but doesn't", readmeFullPath)
-		t.Fatal(err)
-	} else {
-		require.Equalf(t, expectedReadmePerm, info.Mode().Perm(), "Expected %s to have %o mode but has %o (umask: %o)",
-			readmeFullPath, expectedReadmePerm, info.Mode().Perm(), currentUmask)
 	}
+	require.NoError(t, err)
+	require.Equalf(t, expectedReadmePerm, info.Mode().Perm(), "Expected %s to have %o mode but has %o (umask: %o)",
+		readmeFullPath, expectedReadmePerm, info.Mode().Perm(), currentUmask)
 }
 
 func TestCleanJoin(t *testing.T) {
diff --git a/internal/plugin/installer/installer_test.go b/internal/plugin/installer/installer_test.go
index 620afc183..75c22787b 100644
--- a/internal/plugin/installer/installer_test.go
+++ b/internal/plugin/installer/installer_test.go
@@ -34,8 +34,6 @@ func TestIsRemoteHTTPArchive(t *testing.T) {
 
 	// Test with invalid extension and unreachable server
 	assert.False(t, isRemoteHTTPArchive("https://127.0.0.1:123/fake/plugin-1.2.3.notanarchive"), "Bad URL without valid extension should not succeed")
-
 	assert.True(t, isRemoteHTTPArchive(source), "Expected %q to be a valid archive URL", source)
-
 	assert.False(t, isRemoteHTTPArchive(source+"-not-an-extension"), "Expected media type match to fail")
 }
diff --git a/internal/plugin/installer/vcs_installer_test.go b/internal/plugin/installer/vcs_installer_test.go
index 3f5b098e4..82401d069 100644
--- a/internal/plugin/installer/vcs_installer_test.go
+++ b/internal/plugin/installer/vcs_installer_test.go
@@ -96,16 +96,14 @@ func TestVCSInstallerNonExistentVersion(t *testing.T) {
 	require.NoError(t, err)
 
 	// ensure a VCSInstaller was returned
-	_, ok := i.(*VCSInstaller)
-	require.True(t, ok, "expected a VCSInstaller")
+	require.IsType(t, &VCSInstaller{}, i, "expected a VCSInstaller")
 
-	if err := Install(i); err == nil {
-		t.Fatal("expected error for version does not exists, got none")
-	} else if strings.Contains(err.Error(), "Could not resolve host: github.com") {
+	err = Install(i)
+	require.Error(t, err, "expected error for version does not exists, got none")
+	if strings.Contains(err.Error(), "Could not resolve host: github.com") {
 		t.Skip("Unable to run test without Internet access")
-	} else {
-		require.EqualErrorf(t, err, fmt.Sprintf("requested version %q does not exist for plugin %q", version, source), "expected error for version does not exists")
 	}
+	require.EqualErrorf(t, err, fmt.Sprintf("requested version %q does not exist for plugin %q", version, source), "expected error for version does not exists")
 }
 func TestVCSInstallerUpdate(t *testing.T) {
 	ensure.HelmHome(t)
@@ -116,19 +114,16 @@ func TestVCSInstallerUpdate(t *testing.T) {
 	require.NoError(t, err)
 
 	// ensure a VCSInstaller was returned
-	_, ok := i.(*VCSInstaller)
-	require.True(t, ok, "expected a VCSInstaller")
+	require.IsType(t, &VCSInstaller{}, i, "expected a VCSInstaller")
 
 	require.EqualErrorf(t, Update(i), "plugin does not exist", "expected error for plugin does not exist")
 
 	// Install plugin before update
-	if err := Install(i); err != nil {
-		if strings.Contains(err.Error(), "Could not resolve host: github.com") {
-			t.Skip("Unable to run test without Internet access")
-		} else {
-			t.Fatal(err)
-		}
+	err = Install(i)
+	if err != nil && strings.Contains(err.Error(), "Could not resolve host: github.com") {
+		t.Skip("Unable to run test without Internet access")
 	}
+	require.NoError(t, err)
 
 	// Test FindSource method for positive result
 	pluginInfo, err := FindSource(i.Path())
diff --git a/internal/plugin/subprocess_commands_test.go b/internal/plugin/subprocess_commands_test.go
index b2ac19c02..7505bf343 100644
--- a/internal/plugin/subprocess_commands_test.go
+++ b/internal/plugin/subprocess_commands_test.go
@@ -16,7 +16,6 @@ limitations under the License.
 package plugin
 
 import (
-	"reflect"
 	"runtime"
 	"testing"
 
@@ -39,7 +38,7 @@ func TestPrepareCommand(t *testing.T) {
 	cmd, args, err := PrepareCommands(platformCommand, true, []string{}, env)
 	require.NoError(t, err)
 	require.Equal(t, cmdMain, cmd, "Expected %q, got %q", cmdMain, cmd)
-	require.Truef(t, reflect.DeepEqual(args, cmdArgs), "Expected %v, got %v", cmdArgs, args)
+	require.Equalf(t, args, cmdArgs, "Expected %v, got %v", cmdArgs, args)
 }
 
 func TestPrepareCommandExtraArgs(t *testing.T) {
@@ -111,7 +110,7 @@ func TestPrepareCommands(t *testing.T) {
 	cmd, args, err := PrepareCommands(cmds, true, []string{}, env)
 	require.NoError(t, err)
 	require.Equal(t, cmdMain, cmd, "Expected %q, got %q", cmdMain, cmd)
-	require.Truef(t, reflect.DeepEqual(args, cmdArgs), "Expected %v, got %v", cmdArgs, args)
+	require.Equalf(t, args, cmdArgs, "Expected %v, got %v", cmdArgs, args)
 }
 
 func TestPrepareCommandsExtraArgs(t *testing.T) {
@@ -132,7 +131,7 @@ func TestPrepareCommandsExtraArgs(t *testing.T) {
 	cmd, args, err := PrepareCommands(cmds, true, extraArgs, env)
 	require.NoError(t, err)
 	require.Equal(t, cmdMain, cmd, "Expected %q, got %q", cmdMain, cmd)
-	require.Truef(t, reflect.DeepEqual(args, expectedArgs), "Expected %v, got %v", expectedArgs, args)
+	require.Equalf(t, expectedArgs, args, "Expected %v, got %v", expectedArgs, args)
 }
 
 func TestPrepareCommandsNoArch(t *testing.T) {
@@ -149,7 +148,7 @@ func TestPrepareCommandsNoArch(t *testing.T) {
 	cmd, args, err := PrepareCommands(cmds, true, []string{}, env)
 	require.NoError(t, err)
 	require.Equal(t, cmdMain, cmd, "Expected %q, got %q", cmdMain, cmd)
-	require.Truef(t, reflect.DeepEqual(args, cmdArgs), "Expected %v, got %v", cmdArgs, args)
+	require.Equalf(t, args, cmdArgs, "Expected %v, got %v", cmdArgs, args)
 }
 
 func TestPrepareCommandsNoOsNoArch(t *testing.T) {
@@ -166,7 +165,7 @@ func TestPrepareCommandsNoOsNoArch(t *testing.T) {
 	cmd, args, err := PrepareCommands(cmds, true, []string{}, env)
 	require.NoError(t, err)
 	require.Equal(t, cmdMain, cmd, "Expected %q, got %q", cmdMain, cmd)
-	require.Truef(t, reflect.DeepEqual(args, cmdArgs), "Expected %v, got %v", cmdArgs, args)
+	require.Equalf(t, args, cmdArgs, "Expected %v, got %v", cmdArgs, args)
 }
 
 func TestPrepareCommandsNoMatch(t *testing.T) {
@@ -206,7 +205,7 @@ func TestPrepareCommandsExpand(t *testing.T) {
 	cmd, args, err := PrepareCommands(cmds, true, []string{}, env)
 	require.NoError(t, err)
 	require.Equal(t, cmdMain, cmd, "Expected %q, got %q", cmdMain, cmd)
-	require.Truef(t, reflect.DeepEqual(args, expectedArgs), "Expected %v, got %v", expectedArgs, args)
+	require.Equalf(t, expectedArgs, args, "Expected %v, got %v", expectedArgs, args)
 }
 
 func TestPrepareCommandsNoExpand(t *testing.T) {
@@ -223,5 +222,5 @@ func TestPrepareCommandsNoExpand(t *testing.T) {
 	cmd, args, err := PrepareCommands(cmds, false, []string{}, env)
 	require.NoError(t, err)
 	require.Equal(t, cmdMain, cmd, "Expected %q, got %q", cmdMain, cmd)
-	require.Truef(t, reflect.DeepEqual(args, cmdArgs), "Expected %v, got %v", cmdArgs, args)
+	require.Equalf(t, args, cmdArgs, "Expected %v, got %v", cmdArgs, args)
 }
diff --git a/internal/release/v2/util/manifest_sorter_test.go b/internal/release/v2/util/manifest_sorter_test.go
index deb9426ce..6cf529bff 100644
--- a/internal/release/v2/util/manifest_sorter_test.go
+++ b/internal/release/v2/util/manifest_sorter_test.go
@@ -143,7 +143,6 @@ metadata:
 
 	// This test will fail if 'six' or 'seven' was added.
 	assert.Len(t, generic, 2)
-
 	assert.Len(t, hs, 4)
 
 	for _, out := range hs {
diff --git a/internal/resolver/resolver_test.go b/internal/resolver/resolver_test.go
index 547419e17..db976a45b 100644
--- a/internal/resolver/resolver_test.go
+++ b/internal/resolver/resolver_test.go
@@ -148,28 +148,22 @@ func TestResolve(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			l, err := r.Resolve(tt.req, repoNames)
-			if err != nil {
-				if tt.err {
-					return
-				}
+			if tt.err {
+				require.Error(t, err)
+			} else {
 				require.NoError(t, err)
-			}
+				h, err := HashReq(tt.req, tt.expect.Dependencies)
+				require.NoError(t, err)
+				assert.Equal(t, l.Digest, h, "%q: hashes don't match.", tt.name)
 
-			if tt.err {
-				require.Failf(t, "Expected error in test %q", tt.name)
+				// Check fields.
+				require.Len(t, l.Dependencies, len(tt.req), "%s: wrong number of dependencies in lock", tt.name)
+				d0 := l.Dependencies[0]
+				e0 := tt.expect.Dependencies[0]
+				assert.Equal(t, e0.Name, d0.Name, tt.name)
+				assert.Equal(t, e0.Repository, d0.Repository, tt.name)
+				assert.Equal(t, e0.Version, d0.Version, tt.name)
 			}
-
-			h, err := HashReq(tt.req, tt.expect.Dependencies)
-			require.NoError(t, err)
-			assert.Equal(t, l.Digest, h, "%q: hashes don't match.", tt.name)
-
-			// Check fields.
-			assert.Len(t, l.Dependencies, len(tt.req), "%s: wrong number of dependencies in lock", tt.name)
-			d0 := l.Dependencies[0]
-			e0 := tt.expect.Dependencies[0]
-			assert.Equal(t, e0.Name, d0.Name, tt.name)
-			assert.Equal(t, e0.Repository, d0.Repository, tt.name)
-			assert.Equal(t, e0.Version, d0.Version, tt.name)
 		})
 	}
 }
@@ -280,20 +274,16 @@ func TestGetLocalPath(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			p, err := GetLocalPath(tt.repo, tt.chartpath)
-			if err != nil {
-				if tt.err {
-					return
-				}
-				require.NoError(t, err)
-			}
 			if tt.err {
-				require.Failf(t, "Expected error in test %q", tt.name)
-			}
-			expect := tt.expect
-			if runtime.GOOS == "windows" {
-				expect = tt.winExpect
+				require.Error(t, err)
+			} else {
+				require.NoError(t, err)
+				if runtime.GOOS == "windows" {
+					assert.Equal(t, tt.winExpect, p, tt.name)
+				} else {
+					assert.Equal(t, tt.expect, p, tt.name)
+				}
 			}
-			assert.Equal(t, expect, p, tt.name)
 		})
 	}
 }

From 4d9c03f51c30f851a03676a1315f492de10210e6 Mon Sep 17 00:00:00 2001
From: Matthieu MOREL <matthieu.morel35@gmail.com>
Date: Fri, 24 Jul 2026 13:24:06 +0200
Subject: [PATCH 05/13] chore(pkg): refactor: finer tests conversions to
 testify part 2

#### Description

refactor: finer tests conversions to testify in pkg/storage/driver
Signed-off-by: Matthieu MOREL <matthieu.morel35@gmail.com>
---
 pkg/chart/v2/lint/lint_test.go          | 15 +++++------
 pkg/chart/v2/util/validate_name_test.go | 28 +++++++++++----------
 pkg/cli/values/options_test.go          | 30 +++++++++++-----------
 pkg/cmd/package_test.go                 | 30 +++++++++++-----------
 pkg/cmd/pull_test.go                    | 30 +++++++++++-----------
 pkg/cmd/search/search_test.go           | 33 +++++++++++--------------
 pkg/cmd/upgrade_test.go                 | 19 +++++---------
 pkg/downloader/manager_test.go          | 23 +++++++----------
 pkg/engine/engine_test.go               | 27 ++++++++------------
 pkg/getter/ocigetter_test.go            | 10 --------
 pkg/repo/v1/index_test.go               | 24 +++++++-----------
 pkg/storage/driver/cfgmaps_test.go      | 23 ++++++++---------
 pkg/storage/driver/memory_test.go       | 11 +++------
 pkg/storage/driver/secrets_test.go      | 21 +++++++---------
 pkg/storage/driver/sql_test.go          | 25 ++++++++-----------
 pkg/storage/storage_test.go             | 15 ++++++-----
 16 files changed, 151 insertions(+), 213 deletions(-)

diff --git a/pkg/chart/v2/lint/lint_test.go b/pkg/chart/v2/lint/lint_test.go
index 1782c01d4..c4705872d 100644
--- a/pkg/chart/v2/lint/lint_test.go
+++ b/pkg/chart/v2/lint/lint_test.go
@@ -118,7 +118,7 @@ func TestBadValues(t *testing.T) {
 func TestBadCrdFile(t *testing.T) {
 	var values map[string]any
 	m := RunAll(badCrdFileDir, values, namespace).Messages
-	assert.Lenf(t, m, 2, "All didn't fail with expected errors, got %#v", m)
+	require.Lenf(t, m, 2, "All didn't fail with expected errors, got %#v", m)
 	require.ErrorContains(t, m[0].Err, "apiVersion is not in 'apiextensions.k8s.io'")
 	assert.ErrorContains(t, m[1].Err, "object kind is not 'CustomResourceDefinition'")
 }
@@ -126,8 +126,7 @@ func TestBadCrdFile(t *testing.T) {
 func TestGoodChart(t *testing.T) {
 	var values map[string]any
 	m := RunAll(goodChartDir, values, namespace).Messages
-	if len(m) != 0 {
-		t.Error("All returned linter messages when it shouldn't have")
+	if !assert.Empty(t, m, "All returned linter messages when it shouldn't have") {
 		for i, msg := range m {
 			t.Logf("Message %d: %s", i, msg)
 		}
@@ -147,13 +146,12 @@ func TestHelmCreateChart(t *testing.T) {
 	// Note: we test with strict=true here, even though others have
 	// strict = false.
 	m := RunAll(createdChart, values, namespace, WithSkipSchemaValidation(true)).Messages
-	if ll := len(m); ll != 1 {
-		t.Errorf("All should have had exactly 1 error. Got %d", ll)
+	if !assert.Len(t, m, 1, "All should have had exactly 1 error") {
 		for i, msg := range m {
 			t.Logf("Message %d: %s", i, msg.Error())
 		}
-	} else if msg := m[0].Err.Error(); !strings.Contains(msg, "icon is recommended") {
-		t.Errorf("Unexpected lint error: %s", msg)
+	} else {
+		assert.ErrorContains(t, m[0].Err, "icon is recommended")
 	}
 }
 
@@ -196,8 +194,7 @@ func TestHelmCreateChart_CheckDeprecatedWarnings(t *testing.T) {
 func TestSubChartValuesChart(t *testing.T) {
 	var values map[string]any
 	m := RunAll(subChartValuesDir, values, namespace).Messages
-	if len(m) != 0 {
-		t.Error("All returned linter messages when it shouldn't have")
+	if !assert.Empty(t, m, "All returned linter messages when it shouldn't have") {
 		for i, msg := range m {
 			t.Logf("Message %d: %s", i, msg)
 		}
diff --git a/pkg/chart/v2/util/validate_name_test.go b/pkg/chart/v2/util/validate_name_test.go
index cfc62a0f7..9095dc4dc 100644
--- a/pkg/chart/v2/util/validate_name_test.go
+++ b/pkg/chart/v2/util/validate_name_test.go
@@ -16,7 +16,11 @@ limitations under the License.
 
 package util
 
-import "testing"
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
 
 // TestValidateReleaseName is a regression test for ValidateName
 //
@@ -46,12 +50,11 @@ func TestValidateReleaseName(t *testing.T) {
 		"a1111111111111111111111111111111111111111111111111111111111z": false,
 	}
 	for input, expectPass := range names {
-		if err := ValidateReleaseName(input); (err == nil) != expectPass {
-			st := "fail"
-			if expectPass {
-				st = "succeed"
-			}
-			t.Errorf("Expected %q to %s", input, st)
+		err := ValidateReleaseName(input)
+		if expectPass {
+			assert.NoError(t, err)
+		} else {
+			assert.Error(t, err)
 		}
 	}
 }
@@ -80,12 +83,11 @@ func TestValidateMetadataName(t *testing.T) {
 			"a1111111111111111111111111111111111111111111111111111111111z": false,
 	}
 	for input, expectPass := range names {
-		if err := ValidateMetadataName(input); (err == nil) != expectPass {
-			st := "fail"
-			if expectPass {
-				st = "succeed"
-			}
-			t.Errorf("Expected %q to %s", input, st)
+		err := ValidateMetadataName(input)
+		if expectPass {
+			assert.NoError(t, err)
+		} else {
+			assert.Error(t, err)
 		}
 	}
 }
diff --git a/pkg/cli/values/options_test.go b/pkg/cli/values/options_test.go
index 40590f33f..6debb693e 100644
--- a/pkg/cli/values/options_test.go
+++ b/pkg/cli/values/options_test.go
@@ -215,19 +215,17 @@ func TestReadFile(t *testing.T) {
 				got, err := readFile(actualFilePath, tt.providers)
 				require.NoError(t, err, "readFile() expected no error for stdin")
 				assert.Equal(t, testData, got)
-				return
-			}
-
-			// Regular test cases
-			got, err := readFile(actualFilePath, tt.providers)
-			if tt.expectError {
-				assert.Error(t, err)
-				return
-			}
-			require.NoError(t, err)
-
-			if tt.expectedData != nil {
-				assert.Equal(t, tt.expectedData, got)
+			} else {
+				// Regular test cases
+				got, err := readFile(actualFilePath, tt.providers)
+				if tt.expectError {
+					assert.Error(t, err)
+				} else {
+					require.NoError(t, err)
+					if tt.expectedData != nil {
+						assert.Equal(t, tt.expectedData, got)
+					}
+				}
 			}
 		})
 	}
@@ -356,10 +354,10 @@ func TestMergeValuesCLI(t *testing.T) {
 			got, err := tt.opts.MergeValues(getter.Providers{})
 			if tt.wantErr {
 				assert.Error(t, err)
-				return
+			} else {
+				require.NoError(t, err)
+				assert.Equal(t, tt.expected, got)
 			}
-			require.NoError(t, err)
-			assert.Equal(t, tt.expected, got)
 		})
 	}
 }
diff --git a/pkg/cmd/package_test.go b/pkg/cmd/package_test.go
index d78f5d88d..8b19faf08 100644
--- a/pkg/cmd/package_test.go
+++ b/pkg/cmd/package_test.go
@@ -139,24 +139,22 @@ func TestPackage(t *testing.T) {
 				}
 			}
 			_, _, err = executeActionCommand(strings.Join(cmd, " "))
-
-			if err != nil {
-				if tt.err && re.MatchString(err.Error()) {
-					return
+			if tt.err {
+				require.Error(t, err)
+				require.True(t, re.MatchString(err.Error()))
+			} else {
+				require.NoError(t, err)
+				if tt.hasfile != "" {
+					fi, err := os.Stat(tt.hasfile)
+					require.NoErrorf(t, err, "%q: expected file %q", tt.name, tt.hasfile)
+					assert.NotEqualf(t, 0, fi.Size(), "%q: file %q has zero bytes.", tt.name, tt.hasfile)
 				}
-				t.Fatalf("%q: expected error %q, got %q", tt.name, tt.expect, err)
-			}
 
-			if tt.hasfile != "" {
-				fi, err := os.Stat(tt.hasfile)
-				require.NoErrorf(t, err, "%q: expected file %q", tt.name, tt.hasfile)
-				assert.NotEqualf(t, 0, fi.Size(), "%q: file %q has zero bytes.", tt.name, tt.hasfile)
-			}
-
-			if v, ok := tt.flags["sign"]; ok && v == "1" {
-				fi, err := os.Stat(tt.hasfile + ".prov")
-				require.NoErrorf(t, err, "%q: expected provenance file", tt.name)
-				assert.NotEqualf(t, 0, fi.Size(), "%q: provenance file is empty", tt.name)
+				if v, ok := tt.flags["sign"]; ok && v == "1" {
+					fi, err := os.Stat(tt.hasfile + ".prov")
+					require.NoErrorf(t, err, "%q: expected provenance file", tt.name)
+					assert.NotEqualf(t, 0, fi.Size(), "%q: provenance file is empty", tt.name)
+				}
 			}
 		})
 	}
diff --git a/pkg/cmd/pull_test.go b/pkg/cmd/pull_test.go
index 352c36a29..d0371710b 100644
--- a/pkg/cmd/pull_test.go
+++ b/pkg/cmd/pull_test.go
@@ -237,25 +237,23 @@ func TestPullCmd(t *testing.T) {
 				require.NoError(t, os.MkdirAll(file, 0o755))
 			}
 			_, out, err := executeActionCommand(cmd)
-			if err != nil {
-				if tt.wantError {
-					if tt.wantErrorMsg != "" && tt.wantErrorMsg != err.Error() {
-						t.Fatalf("Actual error '%s', not equal to expected error '%s'", err, tt.wantErrorMsg)
-					}
-					return
+			if tt.wantError {
+				if tt.wantErrorMsg != "" {
+					require.EqualError(t, err, tt.wantErrorMsg, "Actual error '%s', not equal to expected error '%s'", err, tt.wantErrorMsg)
 				}
-				t.Fatalf("%q reported error: %s", tt.name, err)
-			}
+			} else {
+				require.NoError(t, err)
 
-			if tt.expectVerify {
-				outString := helmTestKeyOut + tt.expectSha + "\n"
-				assert.Equal(t, outString, out, "%q: expected verification output %q, got %q", tt.name, outString, out)
-			}
+				if tt.expectVerify {
+					outString := helmTestKeyOut + tt.expectSha + "\n"
+					assert.Equal(t, outString, out, "%q: expected verification output %q, got %q", tt.name, outString, out)
+				}
 
-			ef := filepath.Join(outdir, tt.expectFile)
-			fi, err := os.Stat(ef)
-			require.NoError(t, err, "%q: expected a file at %s.", tt.name, ef)
-			assert.Equal(t, tt.expectDir, fi.IsDir(), "%q: expected directory=%t, but it's not.", tt.name, tt.expectDir)
+				ef := filepath.Join(outdir, tt.expectFile)
+				fi, err := os.Stat(ef)
+				require.NoError(t, err, "%q: expected a file at %s.", tt.name, ef)
+				assert.Equal(t, tt.expectDir, fi.IsDir(), "%q: expected directory=%t, but it's not.", tt.name, tt.expectDir)
+			}
 		})
 	}
 }
diff --git a/pkg/cmd/search/search_test.go b/pkg/cmd/search/search_test.go
index f8c9504d1..e45386947 100644
--- a/pkg/cmd/search/search_test.go
+++ b/pkg/cmd/search/search_test.go
@@ -232,26 +232,21 @@ func TestSearchByName(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			charts, err := i.Search(tt.query, 100, tt.regexp)
-			if err != nil {
-				if tt.fail {
-					require.ErrorContains(t, err, tt.failMsg)
-					return
-				}
-				t.Fatalf("%s: %s", tt.name, err)
-			}
-			// Give us predictably ordered results.
-			SortScore(charts)
+			if tt.fail {
+				require.ErrorContains(t, err, tt.failMsg)
+			} else {
+				require.NoError(t, err) // Give us predictably ordered results.
+				SortScore(charts)
 
-			l := len(charts)
-			require.Lenf(t, tt.expect, l, "Expected %d result, got %d", len(tt.expect), l)
-			// For empty result sets, just keep going.
-			if l == 0 {
-				return
-			}
-
-			for i, got := range charts {
-				ex := tt.expect[i]
-				assert.Equalf(t, got.Name, ex.Name, "[%d]: Expected name %q, got %q", i, ex.Name, got.Name)
+				l := len(tt.expect)
+				require.Len(t, charts, len(tt.expect))
+				// For empty result sets, just keep going.
+				if l != 0 {
+					for i, got := range charts {
+						ex := tt.expect[i]
+						assert.Equalf(t, got.Name, ex.Name, "[%d]: Expected name %q, got %q", i, ex.Name, got.Name)
+					}
+				}
 			}
 		})
 	}
diff --git a/pkg/cmd/upgrade_test.go b/pkg/cmd/upgrade_test.go
index 1c1823199..5aba7b11b 100644
--- a/pkg/cmd/upgrade_test.go
+++ b/pkg/cmd/upgrade_test.go
@@ -22,7 +22,6 @@ import (
 	"net/http/httptest"
 	"os"
 	"path/filepath"
-	"reflect"
 	"testing"
 	"time"
 
@@ -201,9 +200,9 @@ func TestUpgradeDependencyUpdateOCINoPanic(t *testing.T) {
 		w.Header().Set("Docker-Distribution-API-Version", "registry/2.0")
 		if r.URL.Path == "/v2/" {
 			w.WriteHeader(http.StatusOK)
-			return
+		} else {
+			w.WriteHeader(http.StatusNotFound)
 		}
-		w.WriteHeader(http.StatusNotFound)
 	}))
 	defer srv.Close()
 
@@ -224,23 +223,17 @@ func TestUpgradeDependencyUpdateOCINoPanic(t *testing.T) {
 			}},
 		},
 	}
-	if err := chartutil.SaveDir(parent, tmp); err != nil {
-		t.Fatalf("Error creating chart: %v", err)
-	}
+	require.NoError(t, chartutil.SaveDir(parent, tmp), "Error creating chart")
 	chartPath := filepath.Join(tmp, parent.Metadata.Name)
 	// SaveDir writes only resolved subcharts (Chart.Dependencies()), not the
 	// declared Metadata.Dependencies, so create the empty charts/ directory
 	// explicitly to make the "dependency missing from charts/" state concrete.
-	if err := os.MkdirAll(filepath.Join(chartPath, "charts"), 0o755); err != nil {
-		t.Fatalf("Error creating charts dir: %v", err)
-	}
+	require.NoError(t, os.MkdirAll(filepath.Join(chartPath, "charts"), 0o755), "Error creating charts dir")
 
 	// The command must return an error (registry rejects the lookup), not panic.
 	_, _, err := executeActionCommandC(storageFixture(),
 		fmt.Sprintf("upgrade --dependency-update --plain-http oci-parent '%s'", chartPath))
-	if err == nil {
-		t.Fatal("expected an error resolving the OCI dependency, got nil")
-	}
+	require.Error(t, err, "expected an error resolving the OCI dependency, got nil")
 }
 
 func TestUpgradeWithValue(t *testing.T) {
@@ -471,7 +464,7 @@ func TestUpgradeInstallWithLabels(t *testing.T) {
 
 	updatedRel, err := releaserToV1Release(updatedReli)
 	require.NoError(t, err)
-	assert.Truef(t, reflect.DeepEqual(updatedRel.Labels, expectedLabels), "Expected {%v}, got {%v}", expectedLabels, updatedRel.Labels)
+	assert.Equal(t, expectedLabels, updatedRel.Labels)
 }
 
 func prepareMockReleaseWithSecret(t *testing.T, releaseName string) (func(n string, v int, ch *chart.Chart) *release.Release, *chart.Chart, string) {
diff --git a/pkg/downloader/manager_test.go b/pkg/downloader/manager_test.go
index 00cb5b668..e40bbbac1 100644
--- a/pkg/downloader/manager_test.go
+++ b/pkg/downloader/manager_test.go
@@ -20,7 +20,6 @@ import (
 	"io/fs"
 	"os"
 	"path/filepath"
-	"reflect"
 	"testing"
 	"time"
 
@@ -168,19 +167,16 @@ func TestGetRepoNames(t *testing.T) {
 	}
 
 	for _, tt := range tests {
-		l, err := m.resolveRepoNames(tt.req)
-		if err != nil {
+		t.Run(tt.name, func(t *testing.T) {
+			l, err := m.resolveRepoNames(tt.req)
 			if tt.err {
-				continue
+				require.Error(t, err)
+			} else {
+				require.NoError(t, err)
+				// m1 and m2 are the maps we want to compare
+				assert.Equal(t, l, tt.expect, "%s: expected map %v, got %v", tt.name, l, tt.name)
 			}
-			t.Fatal(err)
-		}
-
-		require.False(t, tt.err, "Expected error in test %q", tt.name)
-
-		// m1 and m2 are the maps we want to compare
-		eq := reflect.DeepEqual(l, tt.expect)
-		assert.True(t, eq, "%s: expected map %v, got %v", tt.name, l, tt.name)
+		})
 	}
 }
 
@@ -479,8 +475,7 @@ func TestErrRepoNotFound_Error(t *testing.T) {
 			e := ErrRepoNotFound{
 				Repos: tt.fields.Repos,
 			}
-			got := e.Error()
-			assert.EqualErrorf(t, e, tt.want, "Error() = %v, want %v", got, tt.want)
+			assert.EqualError(t, e, tt.want)
 		})
 	}
 }
diff --git a/pkg/engine/engine_test.go b/pkg/engine/engine_test.go
index ecc1eee3b..1f3096366 100644
--- a/pkg/engine/engine_test.go
+++ b/pkg/engine/engine_test.go
@@ -78,8 +78,7 @@ func TestFuncMap(t *testing.T) {
 	// Test for Engine-specific template functions.
 	expect := []string{"include", "required", "tpl", "toYaml", "fromYaml", "toToml", "fromToml", "toJson", "fromJson", "lookup"}
 	for _, f := range expect {
-		_, ok := fns[f]
-		assert.Truef(t, ok, "Expected add-on function %q", f)
+		assert.Containsf(t, fns, f, "Expected add-on function %q", f)
 	}
 }
 
@@ -412,8 +411,7 @@ func TestParseErrors(t *testing.T) {
 	}
 	_, err := new(Engine).render(t.Context(), tplsUndefinedFunction)
 	require.Error(t, err, "Expected failures while rendering")
-	expected := `parse error at (undefined_function:1): function "foo" not defined`
-	assert.EqualError(t, err, expected)
+	assert.EqualError(t, err, `parse error at (undefined_function:1): function "foo" not defined`)
 }
 
 func TestExecErrors(t *testing.T) {
@@ -887,9 +885,8 @@ func TestRenderRecursionLimit(t *testing.T) {
 	expectErr := "rendering template has a nested reference name: recursion: unable to execute template"
 
 	_, err := Render(c, v)
-	if err == nil || !strings.HasSuffix(err.Error(), expectErr) {
-		t.Errorf("Expected err with suffix: %s", expectErr)
-	}
+	require.Error(t, err)
+	assert.True(t, strings.HasSuffix(err.Error(), expectErr), "Expected err with suffix: %s", expectErr)
 
 	// calling the same function many times is ok
 	times := 4000
@@ -1261,18 +1258,14 @@ func TestRenderCustomTemplateFuncs(t *testing.T) {
 	require.NoError(t, err)
 
 	// Expected output should be "hello!!!".
-	expected := "hello!!!"
-	key := "CustomFunc/templates/manifest"
-	if rendered, ok := out[key]; !ok || rendered != expected {
-		t.Errorf("Expected %q, got %q", expected, rendered)
-	}
+	rendered, ok := out["CustomFunc/templates/manifest"]
+	require.True(t, ok)
+	assert.Equal(t, "hello!!!", rendered)
 
 	// Verify that the rendered template used the custom "upper" function.
-	expected = "custom:hello"
-	key = "CustomFunc/templates/override"
-	if rendered, ok := out[key]; !ok || rendered != expected {
-		t.Errorf("Expected %q, got %q", expected, rendered)
-	}
+	rendered, ok = out["CustomFunc/templates/override"]
+	require.True(t, ok)
+	assert.Equal(t, "custom:hello", rendered)
 }
 
 func TestTraceableError_SimpleForm(t *testing.T) {
diff --git a/pkg/getter/ocigetter_test.go b/pkg/getter/ocigetter_test.go
index dfcc74890..5e7f01420 100644
--- a/pkg/getter/ocigetter_test.go
+++ b/pkg/getter/ocigetter_test.go
@@ -55,23 +55,14 @@ func TestOCIGetter(t *testing.T) {
 
 	og, ok := g.(*OCIGetter)
 	require.True(t, ok, "expected NewOCIGetter to produce an *OCIGetter")
-
 	assert.Equal(t, "I", og.opts.username, "Expected NewOCIGetter to contain %q as the username, got %q", "I", og.opts.username)
-
 	assert.Equal(t, "Am", og.opts.password, "Expected NewOCIGetter to contain %q as the password, got %q", "Am", og.opts.password)
-
 	assert.Equal(t, pub, og.opts.certFile, "Expected NewOCIGetter to contain %q as the public key file, got %q", pub, og.opts.certFile)
-
 	assert.Equal(t, priv, og.opts.keyFile, "Expected NewOCIGetter to contain %q as the private key file, got %q", priv, og.opts.keyFile)
-
 	assert.Equal(t, ca, og.opts.caFile, "Expected NewOCIGetter to contain %q as the CA file, got %q", ca, og.opts.caFile)
-
 	assert.Equal(t, timeout, og.opts.timeout, "Expected NewOCIGetter to contain %s as Timeout flag, got %s", timeout, og.opts.timeout)
-
 	assert.Equal(t, transport, og.opts.transport, "Expected NewOCIGetter to contain %p as Transport, got %p", transport, og.opts.transport)
-
 	assert.Equal(t, plainHTTP, og.opts.plainHTTP, "Expected NewOCIGetter to have plainHTTP as %t, got %t", plainHTTP, og.opts.plainHTTP)
-
 	assert.Equal(t, insecureSkipVerifyTLS, og.opts.insecureSkipVerifyTLS, "Expected NewOCIGetter to have insecureSkipVerifyTLS as %t, got %t", insecureSkipVerifyTLS, og.opts.insecureSkipVerifyTLS)
 
 	// Test if setting registryClient is being passed to the ops
@@ -84,7 +75,6 @@ func TestOCIGetter(t *testing.T) {
 	require.NoError(t, err)
 	og, ok = g.(*OCIGetter)
 	require.True(t, ok, "expected NewOCIGetter to produce an *OCIGetter")
-
 	assert.Equal(t, registryClient, og.opts.registryClient, "Expected NewOCIGetter to contain %p as RegistryClient, got %p", registryClient, og.opts.registryClient)
 }
 
diff --git a/pkg/repo/v1/index_test.go b/pkg/repo/v1/index_test.go
index 88aed14d7..09fc7de8a 100644
--- a/pkg/repo/v1/index_test.go
+++ b/pkg/repo/v1/index_test.go
@@ -116,9 +116,8 @@ func TestIndexFile(t *testing.T) {
 	assert.Equalf(t, "0.2.0", v, "Unexpected first version: %s", v)
 
 	cv, err := i.Get("setter", "0.1.9")
-	if err == nil && !strings.Contains(cv.Version, "0.1.9") {
-		t.Errorf("Unexpected version: %s", cv.Version)
-	}
+	require.NoError(t, err)
+	assert.Contains(t, cv.Version, "0.1.9", "Unexpected version: %s", cv.Version)
 
 	cv, err = i.Get("setter", "0.1.9+alpha")
 	require.NoError(t, err, "Expected version: 0.1.9+alpha")
@@ -304,9 +303,8 @@ func verifyLocalIndex(t *testing.T, i *IndexFile) {
 	require.Equalf(t, 1, l, "'alpine' should have 1 chart, got %d", l)
 
 	nginx, ok := i.Entries["nginx"]
-	if !ok || len(nginx) != 2 {
-		t.Fatal("Expected 2 nginx entries")
-	}
+	require.True(t, ok)
+	require.Len(t, nginx, 2, "Expected 2 nginx entries")
 
 	expects := []*ChartVersion{
 		{
@@ -507,18 +505,14 @@ func TestIgnoreSkippableChartValidationError(t *testing.T) {
 	for name, tc := range testCases {
 		t.Run(name, func(t *testing.T) {
 			result := ignoreSkippableChartValidationError(tc.Input)
-
-			if tc.Input == nil {
+			switch {
+			case tc.Input == nil:
 				assert.NoError(t, result, "expected nil result for nil input")
-				return
-			}
-
-			if tc.ErrorSkipped {
+			case tc.ErrorSkipped:
 				assert.NoError(t, result, "expected nil result for skipped error")
-				return
+			default:
+				assert.ErrorIs(t, tc.Input, result, "expected the result equal to input")
 			}
-
-			assert.ErrorIs(t, tc.Input, result, "expected the result equal to input")
 		})
 	}
 }
diff --git a/pkg/storage/driver/cfgmaps_test.go b/pkg/storage/driver/cfgmaps_test.go
index e36aecce8..b8449f67e 100644
--- a/pkg/storage/driver/cfgmaps_test.go
+++ b/pkg/storage/driver/cfgmaps_test.go
@@ -16,7 +16,6 @@ package driver
 import (
 	"encoding/base64"
 	"encoding/json"
-	"reflect"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
@@ -46,7 +45,7 @@ func TestConfigMapGet(t *testing.T) {
 	got, err := cfgmaps.Get(key)
 	require.NoError(t, err, "Failed to get release")
 	// compare fetched release with original
-	assert.Truef(t, reflect.DeepEqual(rel, got), "Expected {%v}, got {%v}", rel, got)
+	assert.Equalf(t, rel, got, "Expected {%v}, got {%v}", rel, got)
 }
 
 func TestUncompressedConfigMapGet(t *testing.T) {
@@ -70,7 +69,7 @@ func TestUncompressedConfigMapGet(t *testing.T) {
 	got, err := cfgmaps.Get(key)
 	require.NoError(t, err, "Failed to get release")
 	// compare fetched release with original
-	assert.Truef(t, reflect.DeepEqual(rel, got), "Expected {%v}, got {%v}", rel, got)
+	assert.Equalf(t, rel, got, "Expected {%v}, got {%v}", rel, got)
 }
 
 func convertReleaserToV1(t *testing.T, rel release.Releaser) *rspb.Release {
@@ -105,7 +104,7 @@ func TestConfigMapList(t *testing.T) {
 	})
 	// check
 	require.NoError(t, err, "Failed to list deleted")
-	assert.Len(t, del, 2, "Expected 2 deleted, got %d:\n%v\n", len(del), del)
+	assert.Len(t, del, 2, "Expected 2 deleted")
 
 	// list all deployed releases
 	dpl, err := cfgmaps.List(func(rel release.Releaser) bool {
@@ -114,7 +113,7 @@ func TestConfigMapList(t *testing.T) {
 	})
 	// check
 	require.NoError(t, err, "Failed to list deployed")
-	assert.Len(t, dpl, 2, "Expected 2 deployed, got %d", len(dpl))
+	assert.Len(t, dpl, 2, "Expected 2 deployed")
 
 	// list all superseded releases
 	ssd, err := cfgmaps.List(func(rel release.Releaser) bool {
@@ -123,13 +122,11 @@ func TestConfigMapList(t *testing.T) {
 	})
 	// check
 	require.NoError(t, err, "Failed to list superseded")
-	assert.Len(t, ssd, 2, "Expected 2 superseded, got %d", len(ssd))
+	assert.Len(t, ssd, 2, "Expected 2 superseded")
 	// Check if release having both system and custom labels, this is needed to ensure that selector filtering would work.
 	rls := convertReleaserToV1(t, ssd[0])
-	_, ok := rls.Labels["name"]
-	require.True(t, ok, "Expected 'name' label in results, actual %v", rls.Labels)
-	_, ok = rls.Labels["key1"]
-	require.True(t, ok, "Expected 'key1' label in results, actual %v", rls.Labels)
+	require.Contains(t, rls.Labels, "name", "Expected 'name' label in results, actual %v", rls.Labels)
+	require.Contains(t, rls.Labels, "key1", "Expected 'key1' label in results, actual %v", rls.Labels)
 }
 
 func TestConfigMapQuery(t *testing.T) {
@@ -144,7 +141,7 @@ func TestConfigMapQuery(t *testing.T) {
 
 	rls, err := cfgmaps.Query(map[string]string{"status": "deployed"})
 	require.NoError(t, err, "Failed to query")
-	assert.Len(t, rls, 2, "Expected 2 results, got %d", len(rls))
+	assert.Len(t, rls, 2, "Expected 2 results")
 
 	_, err = cfgmaps.Query(map[string]string{"name": "notExist"})
 	assert.ErrorIs(t, err, ErrReleaseNotFound)
@@ -167,7 +164,7 @@ func TestConfigMapCreate(t *testing.T) {
 	require.NoError(t, err, "Failed to get release with key %q", key)
 
 	// compare created release with original
-	assert.Truef(t, reflect.DeepEqual(rel, got), "Expected {%v}, got {%v}", rel, got)
+	assert.Equalf(t, rel, got, "Expected {%v}, got {%v}", rel, got)
 }
 
 func TestConfigMapUpdate(t *testing.T) {
@@ -210,7 +207,7 @@ func TestConfigMapDelete(t *testing.T) {
 	// perform the delete
 	rls, err := cfgmaps.Delete(key)
 	require.NoError(t, err, "Failed to delete release with key %q", key)
-	assert.Truef(t, reflect.DeepEqual(rel, rls), "Expected {%v}, got {%v}", rel, rls)
+	assert.Equalf(t, rel, rls, "Expected {%v}, got {%v}", rel, rls)
 	_, err = cfgmaps.Get(key)
 	assert.ErrorIs(t, err, ErrReleaseNotFound)
 }
diff --git a/pkg/storage/driver/memory_test.go b/pkg/storage/driver/memory_test.go
index 7a8d4cb3e..c0eff3cf9 100644
--- a/pkg/storage/driver/memory_test.go
+++ b/pkg/storage/driver/memory_test.go
@@ -18,7 +18,6 @@ package driver
 
 import (
 	"fmt"
-	"reflect"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
@@ -112,7 +111,7 @@ func TestMemoryList(t *testing.T) {
 	})
 	// check
 	require.NoError(t, err, "Failed to list deployed releases")
-	assert.Len(t, dpl, 2, "Expected 2 deployed, got %d", len(dpl))
+	assert.Len(t, dpl, 2, "Expected 2 deployed")
 
 	// list all superseded releases
 	ssd, err := ts.List(func(rel release.Releaser) bool {
@@ -121,7 +120,7 @@ func TestMemoryList(t *testing.T) {
 	})
 	// check
 	require.NoError(t, err, "Failed to list superseded releases")
-	assert.Len(t, ssd, 6, "Expected 6 superseded, got %d", len(ssd))
+	assert.Len(t, ssd, 6, "Expected 6 superseded")
 
 	// list all deleted releases
 	del, err := ts.List(func(rel release.Releaser) bool {
@@ -210,7 +209,7 @@ func TestMemoryUpdate(t *testing.T) {
 
 			r, err := ts.Get(tt.key)
 			require.NoError(t, err, "Failed to get")
-			require.Truef(t, reflect.DeepEqual(r, tt.rls), "Expected %v, actual %v\n", tt.rls, r)
+			require.Equalf(t, r, tt.rls, "Expected %v, actual %v\n", tt.rls, r)
 		}
 	}
 }
@@ -256,10 +255,8 @@ func TestMemoryDelete(t *testing.T) {
 	ts.SetNamespace("")
 	end, err := ts.Query(map[string]string{"status": "deployed"})
 	require.NoError(t, err, "Query failed")
-	endLen := len(end)
 
-	if startLen-2 != endLen {
-		t.Errorf("expected end to be %d instead of %d", startLen-2, endLen)
+	if !assert.Len(t, end, startLen-2) {
 		for _, ee := range end {
 			rac, err := release.NewAccessor(ee)
 			require.NoError(t, err, "unable to get release accessor")
diff --git a/pkg/storage/driver/secrets_test.go b/pkg/storage/driver/secrets_test.go
index 8cc3f390d..b53f17ad9 100644
--- a/pkg/storage/driver/secrets_test.go
+++ b/pkg/storage/driver/secrets_test.go
@@ -16,7 +16,6 @@ package driver
 import (
 	"encoding/base64"
 	"encoding/json"
-	"reflect"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
@@ -46,7 +45,7 @@ func TestSecretGet(t *testing.T) {
 	got, err := secrets.Get(key)
 	require.NoError(t, err, "Failed to get release")
 	// compare fetched release with original
-	assert.Truef(t, reflect.DeepEqual(rel, got), "Expected {%v}, got {%v}", rel, got)
+	assert.Equalf(t, rel, got, "Expected {%v}, got {%v}", rel, got)
 }
 
 func TestUNcompressedSecretGet(t *testing.T) {
@@ -70,7 +69,7 @@ func TestUNcompressedSecretGet(t *testing.T) {
 	got, err := secrets.Get(key)
 	require.NoError(t, err, "Failed to get release")
 	// compare fetched release with original
-	assert.Truef(t, reflect.DeepEqual(rel, got), "Expected {%v}, got {%v}", rel, got)
+	assert.Equalf(t, rel, got, "Expected {%v}, got {%v}", rel, got)
 }
 
 func TestSecretList(t *testing.T) {
@@ -90,7 +89,7 @@ func TestSecretList(t *testing.T) {
 	})
 	// check
 	require.NoError(t, err, "Failed to list deleted")
-	assert.Len(t, del, 2, "Expected 2 deleted, got %d:\n%v\n", len(del), del)
+	assert.Len(t, del, 2, "Expected 2 deleted")
 
 	// list all deployed releases
 	dpl, err := secrets.List(func(rel release.Releaser) bool {
@@ -99,7 +98,7 @@ func TestSecretList(t *testing.T) {
 	})
 	// check
 	require.NoError(t, err, "Failed to list deployed")
-	assert.Len(t, dpl, 2, "Expected 2 deployed, got %d", len(dpl))
+	assert.Len(t, dpl, 2, "Expected 2 deployed")
 
 	// list all superseded releases
 	ssd, err := secrets.List(func(rel release.Releaser) bool {
@@ -108,13 +107,11 @@ func TestSecretList(t *testing.T) {
 	})
 	// check
 	require.NoError(t, err, "Failed to list superseded")
-	assert.Len(t, ssd, 2, "Expected 2 superseded, got %d", len(ssd))
+	require.Len(t, ssd, 2, "Expected 2 superseded")
 	// Check if release having both system and custom labels, this is needed to ensure that selector filtering would work.
 	rls := convertReleaserToV1(t, ssd[0])
-	_, ok := rls.Labels["name"]
-	require.True(t, ok, "Expected 'name' label in results, actual %v", rls.Labels)
-	_, ok = rls.Labels["key1"]
-	require.True(t, ok, "Expected 'key1' label in results, actual %v", rls.Labels)
+	require.Contains(t, rls.Labels, "name", "Expected 'name' label in results, actual %v", rls.Labels)
+	require.Contains(t, rls.Labels, "key1", "Expected 'key1' label in results, actual %v", rls.Labels)
 }
 
 func TestSecretQuery(t *testing.T) {
@@ -152,7 +149,7 @@ func TestSecretCreate(t *testing.T) {
 	require.NoError(t, err, "Failed to get release with key %q", key)
 
 	// compare created release with original
-	assert.Truef(t, reflect.DeepEqual(rel, got), "Expected {%v}, got {%v}", rel, got)
+	assert.Equalf(t, rel, got, "Expected {%v}, got {%v}", rel, got)
 }
 
 func TestSecretUpdate(t *testing.T) {
@@ -195,7 +192,7 @@ func TestSecretDelete(t *testing.T) {
 	// perform the delete
 	rls, err := secrets.Delete(key)
 	require.NoError(t, err, "Failed to delete release with key %q", key)
-	assert.Truef(t, reflect.DeepEqual(rel, rls), "Expected {%v}, got {%v}", rel, rls)
+	assert.Equalf(t, rel, rls, "Expected {%v}, got {%v}", rel, rls)
 	_, err = secrets.Get(key)
 	assert.ErrorIs(t, err, ErrReleaseNotFound)
 }
diff --git a/pkg/storage/driver/sql_test.go b/pkg/storage/driver/sql_test.go
index adcc780aa..044e9df7b 100644
--- a/pkg/storage/driver/sql_test.go
+++ b/pkg/storage/driver/sql_test.go
@@ -99,7 +99,7 @@ func TestSQLGet(t *testing.T) {
 	got, err := sqlDriver.Get(key)
 	require.NoError(t, err, "Failed to get release")
 
-	assert.Truef(t, reflect.DeepEqual(rel, got), "Expected release {%v}, got {%v}", rel, got)
+	assert.Equalf(t, rel, got, "Expected release {%v}, got {%v}", rel, got)
 	assert.NoErrorf(t, mock.ExpectationsWereMet(), "sql expectations weren't met")
 }
 
@@ -151,7 +151,7 @@ func TestSQLList(t *testing.T) {
 	})
 	// check
 	require.NoError(t, err, "Failed to list deleted")
-	assert.Len(t, del, 2, "Expected 2 deleted, got %d:\n%v\n", len(del), del)
+	assert.Len(t, del, 2, "Expected 2 deleted")
 
 	// list all deployed releases
 	dpl, err := sqlDriver.List(func(rel release.Releaser) bool {
@@ -160,7 +160,7 @@ func TestSQLList(t *testing.T) {
 	})
 	// check
 	require.NoError(t, err, "Failed to list deployed")
-	assert.Len(t, dpl, 2, "Expected 2 deployed, got %d:\n%v\n", len(dpl), dpl)
+	assert.Len(t, dpl, 2, "Expected 2 deployed")
 
 	// list all superseded releases
 	ssd, err := sqlDriver.List(func(rel release.Releaser) bool {
@@ -169,15 +169,13 @@ func TestSQLList(t *testing.T) {
 	})
 	// check
 	require.NoError(t, err, "Failed to list superseded")
-	assert.Len(t, ssd, 2, "Expected 2 superseded, got %d:\n%v\n", len(ssd), ssd)
+	require.Len(t, ssd, 2, "Expected 2 superseded")
 	require.NoErrorf(t, mock.ExpectationsWereMet(), "sql expectations weren't met")
 
 	// Check if release having both system and custom labels, this is needed to ensure that selector filtering would work.
 	rls := convertReleaserToV1(t, ssd[0])
-	_, ok := rls.Labels["name"]
-	require.True(t, ok, "Expected 'name' label in results, actual %v", rls.Labels)
-	_, ok = rls.Labels["key1"]
-	require.True(t, ok, "Expected 'key1' label in results, actual %v", rls.Labels)
+	require.Contains(t, rls.Labels, "name", "Expected 'name' label in results, actual %v", rls.Labels)
+	require.Contains(t, rls.Labels, "key1", "Expected 'key1' label in results, actual %v", rls.Labels)
 }
 
 func TestSqlCreate(t *testing.T) {
@@ -414,18 +412,15 @@ func TestSqlQuery(t *testing.T) {
 	require.NoError(t, err, "failed to query for deployed smug-pigeon release")
 
 	for _, res := range results {
-		assert.Truef(t, reflect.DeepEqual(res, deployedRelease), "Expected release {%v}, got {%v}", deployedRelease, res)
+		assert.Equalf(t, res, deployedRelease, "Expected release {%v}, got {%v}", deployedRelease, res)
 	}
 
 	results, err = sqlDriver.Query(labelSetAll)
 	require.NoError(t, err, "failed to query release history for smug-pigeon")
-
-	assert.Len(t, results, 2, "expected a resultset of size 2, got %d", len(results))
+	assert.Len(t, results, 2, "expected a resultset of size 2")
 
 	for _, res := range results {
-		if !reflect.DeepEqual(res, deployedRelease) && !reflect.DeepEqual(res, supersededRelease) {
-			t.Errorf("Expected release {%v} or {%v}, got {%v}", deployedRelease, supersededRelease, res)
-		}
+		assert.False(t, !reflect.DeepEqual(res, deployedRelease) && !reflect.DeepEqual(res, supersededRelease), "Expected release {%v} or {%v}, got {%v}", deployedRelease, supersededRelease, res)
 	}
 
 	assert.NoErrorf(t, mock.ExpectationsWereMet(), "sql expectations weren't met")
@@ -495,7 +490,7 @@ func TestSqlDelete(t *testing.T) {
 	assert.NoErrorf(t, err, "sql expectations weren't met")
 	require.NoError(t, err, "failed to delete release with key %q", key)
 
-	assert.Truef(t, reflect.DeepEqual(rel, deletedRelease), "Expected release {%v}, got {%v}", rel, deletedRelease)
+	assert.Equalf(t, rel, deletedRelease, "Expected release {%v}, got {%v}", rel, deletedRelease)
 }
 
 func mockGetReleaseCustomLabels(mock sqlmock.Sqlmock, key string, namespace string, labels map[string]string) {
diff --git a/pkg/storage/storage_test.go b/pkg/storage/storage_test.go
index 821eccb81..58cb56776 100644
--- a/pkg/storage/storage_test.go
+++ b/pkg/storage/storage_test.go
@@ -20,7 +20,6 @@ import (
 	"context"
 	"errors"
 	"log/slog"
-	"reflect"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
@@ -49,7 +48,7 @@ func TestStorageCreate(t *testing.T) {
 	require.NoError(t, err, "QueryRelease")
 
 	// verify the fetched and created release are the same
-	require.Truef(t, reflect.DeepEqual(rls, res), "Expected %v, got %v", rls, res)
+	require.Equalf(t, rls, res, "Expected %v, got %v", rls, res)
 }
 
 func TestStorageUpdate(t *testing.T) {
@@ -74,7 +73,7 @@ func TestStorageUpdate(t *testing.T) {
 	require.NoError(t, err, "QueryRelease")
 
 	// verify updated and fetched releases are the same.
-	require.Truef(t, reflect.DeepEqual(rls, res), "Expected %v, got %v", rls, res)
+	require.Equalf(t, rls, res, "Expected %v, got %v", rls, res)
 }
 
 func TestStorageDelete(t *testing.T) {
@@ -99,7 +98,7 @@ func TestStorageDelete(t *testing.T) {
 	require.NoError(t, err, "DeleteRelease")
 
 	// verify updated and fetched releases are the same.
-	require.Truef(t, reflect.DeepEqual(rls, res), "Expected %v, got %v", rls, res)
+	require.Equalf(t, rls, res, "Expected %v, got %v", rls, res)
 
 	hist, err := storage.History(rls.Name)
 	require.NoError(t, err)
@@ -348,12 +347,12 @@ func TestStorageRemoveLeastRecent(t *testing.T) {
 	require.NoError(t, err)
 	rhist, err := releaseListToV1List(hist)
 	require.NoError(t, err)
-	if len(rhist) != storage.MaxHistory {
+	if !assert.Len(t, rhist, storage.MaxHistory) {
 		for _, item := range rhist {
 			t.Logf("%s %v", item.Name, item.Version)
 		}
-		t.Fatalf("expected %d items in history, got %d", storage.MaxHistory, len(rhist))
 	}
+	require.Len(t, rhist, storage.MaxHistory)
 
 	// We expect the existing records to be 3, 4, and 5.
 	for i, item := range rhist {
@@ -392,14 +391,14 @@ func TestStorageDoNotDeleteDeployed(t *testing.T) {
 	// (the only deployed release), to still exist
 	hist, err := storage.History(name)
 	require.NoError(t, err)
-	if len(hist) != storage.MaxHistory {
+	if !assert.Len(t, hist, storage.MaxHistory) {
 		rhist, err := releaseListToV1List(hist)
 		require.NoError(t, err)
 		for _, item := range rhist {
 			t.Logf("%s %v", item.Name, item.Version)
 		}
-		t.Fatalf("expected %d items in history, got %d", storage.MaxHistory, len(rhist))
 	}
+	require.Len(t, hist, storage.MaxHistory)
 
 	expectedVersions := map[int]bool{
 		2: true,

From 9a2be11e6f1af0c89dc0988b88fd339751baa44c Mon Sep 17 00:00:00 2001
From: Matthieu MOREL <matthieu.morel35@gmail.com>
Date: Fri, 24 Jul 2026 13:24:06 +0200
Subject: [PATCH 06/13] chore(pkg): refactor: finer tests conversions to
 testify part 3

refactor: finer tests conversions to testify in pkg/cmd
Signed-off-by: Matthieu MOREL <matthieu.morel35@gmail.com>
---
 pkg/action/install_test.go                    |  6 +-
 pkg/action/lint_test.go                       | 12 ++--
 pkg/action/validate_test.go                   | 12 ++--
 pkg/chart/common/util/coalesce_test.go        | 12 ++--
 pkg/chart/v2/lint/rules/chartfile_test.go     |  7 +--
 pkg/chart/v2/lint/rules/crds_test.go          |  3 +-
 pkg/chart/v2/lint/rules/dependencies_test.go  |  3 +-
 pkg/chart/v2/lint/support/message_test.go     |  6 +-
 pkg/chart/v2/util/chartfile_test.go           |  8 +--
 pkg/chart/v2/util/create_test.go              |  7 ++-
 pkg/chart/v2/util/dependencies_test.go        |  2 +-
 pkg/cmd/completion_test.go                    | 13 ++---
 pkg/cmd/repo_index_test.go                    |  4 +-
 pkg/cmd/repo_update_test.go                   |  6 +-
 pkg/cmd/rollback_test.go                      |  3 +-
 pkg/cmd/search_hub_test.go                    | 12 +---
 pkg/cmd/show_test.go                          | 10 ++--
 .../chart_downloader_windows_test.go          | 14 ++---
 pkg/engine/files_test.go                      |  9 +--
 pkg/gates/gates_test.go                       |  2 +-
 pkg/getter/httpgetter_test.go                 | 18 +++---
 pkg/kube/ready_test.go                        | 55 +++++++++++++++----
 pkg/kube/resource_test.go                     |  6 +-
 pkg/kube/wait_test.go                         |  6 +-
 pkg/kubeenv/roundtripper_test.go              |  9 ++-
 pkg/provenance/sign_test.go                   | 12 +---
 pkg/pusher/ocipusher_test.go                  |  5 +-
 pkg/registry/chart_test.go                    |  6 +-
 pkg/registry/client_test.go                   |  4 +-
 pkg/registry/plugin_test.go                   |  7 +--
 pkg/registry/registry_test.go                 | 14 ++---
 pkg/release/v1/util/manifest_sorter_test.go   |  1 -
 pkg/repo/v1/chartrepo_test.go                 |  8 +--
 pkg/repo/v1/repo_test.go                      | 14 ++---
 pkg/repo/v1/repotest/server_test.go           |  9 +--
 pkg/storage/driver/labels_test.go             |  8 ++-
 pkg/storage/driver/records_test.go            |  5 +-
 pkg/storage/driver/util_test.go               |  7 +--
 38 files changed, 158 insertions(+), 187 deletions(-)

diff --git a/pkg/action/install_test.go b/pkg/action/install_test.go
index da680f41a..4dbeb7c79 100644
--- a/pkg/action/install_test.go
+++ b/pkg/action/install_test.go
@@ -420,9 +420,7 @@ func TestInstallRelease_WithChartAndDependencyAllNotes(t *testing.T) {
 	req.NoError(err)
 	is.Equal("with-notes", rel.Name)
 	// test run can return as either 'parent\nchild' or 'child\nparent'
-	if !strings.Contains(rel.Info.Notes, "parent") && !strings.Contains(rel.Info.Notes, "child") {
-		t.Fatalf("Expected 'parent\nchild' or 'child\nparent', got '%s'", rel.Info.Notes)
-	}
+	req.True(strings.Contains(rel.Info.Notes, "parent") || strings.Contains(rel.Info.Notes, "child"), "Expected 'parent\nchild' or 'child\nparent', got '%s'", rel.Info.Notes)
 	is.Equal("Install complete", rel.Info.Description)
 }
 
@@ -1096,7 +1094,7 @@ func TestInstallCRDs(t *testing.T) {
 	mockChart := buildChart(withFile(mockFile))
 	crdsToInstall := mockChart.CRDObjects()
 
-	assert.Len(t, crdsToInstall, 1)
+	require.Len(t, crdsToInstall, 1)
 	assert.Equal(t, crdsToInstall[0].File.Data, mockFile.Data)
 	require.NoError(t, instAction.installCRDs(crdsToInstall))
 }
diff --git a/pkg/action/lint_test.go b/pkg/action/lint_test.go
index 5c956c682..f3fd994d7 100644
--- a/pkg/action/lint_test.go
+++ b/pkg/action/lint_test.go
@@ -106,10 +106,8 @@ func TestNonExistentChart(t *testing.T) {
 		testLint := NewLint()
 
 		result := testLint.Run(testCharts, values)
-		assert.Len(t, result.Errors, 1, "expected one error, but got", len(result.Errors))
-
-		actual := result.Errors[0].Error()
-		assert.EqualError(t, result.Errors[0], expectedError, "expected '%s', but got '%s'", expectedError, actual)
+		require.Len(t, result.Errors, 1, "expected one error, but got", len(result.Errors))
+		assert.EqualError(t, result.Errors[0], expectedError)
 	})
 
 	t.Run("should error out for corrupted tgz chart", func(t *testing.T) {
@@ -118,10 +116,8 @@ func TestNonExistentChart(t *testing.T) {
 		testLint := NewLint()
 
 		result := testLint.Run(testCharts, values)
-		assert.Len(t, result.Errors, 1, "expected one error, but got", len(result.Errors))
-
-		actual := result.Errors[0].Error()
-		assert.EqualError(t, result.Errors[0], expectedEOFError, "expected '%s', but got '%s'", expectedEOFError, actual)
+		require.Len(t, result.Errors, 1, "expected one error, but got", len(result.Errors))
+		assert.EqualError(t, result.Errors[0], expectedEOFError)
 	})
 }
 
diff --git a/pkg/action/validate_test.go b/pkg/action/validate_test.go
index 27097d177..8bd9f1916 100644
--- a/pkg/action/validate_test.go
+++ b/pkg/action/validate_test.go
@@ -132,7 +132,7 @@ func TestRequireAdoption(t *testing.T) {
 	// Verify that a resource that lacks labels/annotations can be adopted
 	found, err := requireAdoption(resources)
 	require.NoError(t, err)
-	assert.Len(t, found, 1)
+	require.Len(t, found, 1)
 	assert.Equal(t, found[0], existing)
 	assert.NotSame(t, found[0], existing)
 }
@@ -157,7 +157,7 @@ func TestExistingResourceConflict(t *testing.T) {
 	// Verify only existing resources are returned
 	found, err := existingResourceConflict(resources, releaseName, releaseNamespace)
 	require.NoError(t, err)
-	assert.Len(t, found, 1)
+	require.Len(t, found, 1)
 	assert.Equal(t, found[0], existing)
 	assert.NotSame(t, found[0], existing)
 
@@ -242,8 +242,8 @@ func TestVerifyOwnershipBeforeDelete(t *testing.T) {
 
 		ownedList, unownedList, _, err := verifyOwnershipBeforeDelete(resources, releaseName, releaseNamespace)
 		require.NoError(t, err)
-		assert.Len(t, ownedList, 1)
-		assert.Len(t, unownedList, 1)
+		require.Len(t, ownedList, 1)
+		require.Len(t, unownedList, 1)
 		assert.Equal(t, "owned", ownedList[0].Name)
 		assert.Equal(t, "unowned", unownedList[0].Name)
 	})
@@ -290,8 +290,8 @@ func TestVerifyOwnershipBeforeDelete(t *testing.T) {
 
 		ownedList, unownedList, _, err := verifyOwnershipBeforeDelete(resources, releaseName, releaseNamespace)
 		require.NoError(t, err)
-		assert.Len(t, ownedList, 1)
-		assert.Len(t, unownedList, 1)
+		require.Len(t, ownedList, 1)
+		require.Len(t, unownedList, 1)
 		assert.Equal(t, "owned", ownedList[0].Name)
 		assert.Equal(t, "unowned", unownedList[0].Name)
 	})
diff --git a/pkg/chart/common/util/coalesce_test.go b/pkg/chart/common/util/coalesce_test.go
index 6ef092365..e058bd996 100644
--- a/pkg/chart/common/util/coalesce_test.go
+++ b/pkg/chart/common/util/coalesce_test.go
@@ -372,8 +372,7 @@ func TestMergeValues(t *testing.T) {
 	assert.True(t, ok, "Expected nested boat key to be present but it was removed")
 
 	subchart := v["pequod"].(map[string]any)["ahab"].(map[string]any)
-	_, ok = subchart["boat"]
-	assert.True(t, ok, "Expected subchart boat key to be present but it was removed")
+	assert.Contains(t, subchart, "boat", "Expected subchart boat key to be present but it was removed")
 
 	_, ok = subchart["nested"].(map[string]any)["bar"]
 	assert.True(t, ok, "Expected subchart nested bar key to be present but it was removed")
@@ -526,8 +525,7 @@ func TestMergeTables(t *testing.T) {
 
 	// This is one test that is different from CoalesceTables. Because hole
 	// is a nil value and it's not removed it's still present.
-	_, ok = dst["hole"]
-	assert.True(t, ok, "The hole no longer exists.")
+	assert.Contains(t, dst, "hole", "The hole no longer exists.")
 
 	dst2 := map[string]any{
 		"name": "Ishmael",
@@ -559,8 +557,7 @@ func TestMergeTables(t *testing.T) {
 	det2, ok := dst2["details"].(map[string]any)
 	require.Truef(t, ok, "Details is the wrong type: %v", dst2["details"])
 
-	_, ok = det2["friends"]
-	assert.True(t, ok, "Could not find your friends. Maybe you don't have any. :-(")
+	assert.Contains(t, det2, "friends", "Could not find your friends. Maybe you don't have any. :-(")
 	assert.Equal(t, "pequod", dst2["boat"].(string), "Expected boat string, got %v", dst2["boat"])
 	assert.Equal(t, "black", dst2["hole"].(string), "Expected hole string, got %v", dst2["hole"])
 	assert.Nil(t, dst2["nilval"], "Expected nilvalue to have nil value but it does not")
@@ -659,8 +656,7 @@ func TestCoalesceValuesEmptyMapWithNils(t *testing.T) {
 	is.Equal("bar", data["foo"])
 
 	// "baz" should be preserved with nil value since it wasn't in chart defaults
-	_, ok = data["baz"]
-	is.True(ok, "Expected data.baz key to be present but it was removed")
+	is.Contains(data, "baz", "Expected data.baz key to be present but it was removed")
 	is.Nil(data["baz"], "Expected data.baz key to be nil but it is not")
 }
 
diff --git a/pkg/chart/v2/lint/rules/chartfile_test.go b/pkg/chart/v2/lint/rules/chartfile_test.go
index 7c9f1c422..1cc331a74 100644
--- a/pkg/chart/v2/lint/rules/chartfile_test.go
+++ b/pkg/chart/v2/lint/rules/chartfile_test.go
@@ -195,7 +195,6 @@ func TestChartfile(t *testing.T) {
 		expectedNumberOfErrorMessages := 7
 
 		require.Lenf(t, msgs, expectedNumberOfErrorMessages, "Expected %d errors, got %d", expectedNumberOfErrorMessages, len(msgs))
-
 		require.ErrorContains(t, msgs[0].Err, "name is required", "Unexpected message 0: %s", msgs[0].Err)
 		require.ErrorContains(t, msgs[1].Err, "apiVersion is required. The value must be either \"v1\" or \"v2\"", "Unexpected message 1: %s", msgs[1].Err)
 		require.ErrorContains(t, msgs[2].Err, "version '0.0.0.0' is not a valid SemVer", "Unexpected message 2: %s", msgs[2].Err)
@@ -211,11 +210,7 @@ func TestChartfile(t *testing.T) {
 		msgs := linter.Messages
 		expectedNumberOfErrorMessages := 4
 
-		if len(msgs) != expectedNumberOfErrorMessages {
-			t.Errorf("Expected %d errors, got %d", expectedNumberOfErrorMessages, len(msgs))
-			return
-		}
-
+		require.Len(t, msgs, expectedNumberOfErrorMessages, "Expected %d errors, got %d", expectedNumberOfErrorMessages, len(msgs))
 		require.ErrorContains(t, msgs[0].Err, "version should be of type string", "Unexpected message 0: %s", msgs[0].Err)
 		require.ErrorContains(t, msgs[1].Err, "version '7.2445e+06' is not a valid SemVer", "Unexpected message 1: %s", msgs[1].Err)
 		require.ErrorContains(t, msgs[2].Err, "appVersion should be of type string", "Unexpected message 2: %s", msgs[2].Err)
diff --git a/pkg/chart/v2/lint/rules/crds_test.go b/pkg/chart/v2/lint/rules/crds_test.go
index 7016c4d9a..d0790692f 100644
--- a/pkg/chart/v2/lint/rules/crds_test.go
+++ b/pkg/chart/v2/lint/rules/crds_test.go
@@ -22,6 +22,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 
 	"helm.sh/helm/v4/pkg/chart/v2/lint/support"
 )
@@ -33,7 +34,7 @@ func TestInvalidCrdsDir(t *testing.T) {
 	Crds(&linter)
 	res := linter.Messages
 
-	assert.Len(t, res, 1)
+	require.Len(t, res, 1)
 	assert.ErrorContains(t, res[0].Err, "not a directory")
 }
 
diff --git a/pkg/chart/v2/lint/rules/dependencies_test.go b/pkg/chart/v2/lint/rules/dependencies_test.go
index c800887bd..4bd7b3e37 100644
--- a/pkg/chart/v2/lint/rules/dependencies_test.go
+++ b/pkg/chart/v2/lint/rules/dependencies_test.go
@@ -140,8 +140,7 @@ func TestDependencies(t *testing.T) {
 	linter := support.Linter{ChartDir: filepath.Join(tmp, c.Metadata.Name)}
 
 	Dependencies(&linter)
-	if l := len(linter.Messages); l != 2 {
-		t.Errorf("expected 2 linter errors for bad chart dependencies. Got %d.", l)
+	if !assert.Len(t, linter.Messages, 2, "expected 2 linter errors for bad chart dependencies") {
 		for i, msg := range linter.Messages {
 			t.Logf("Message: %d, Error: %#v", i, msg)
 		}
diff --git a/pkg/chart/v2/lint/support/message_test.go b/pkg/chart/v2/lint/support/message_test.go
index dfbc65844..6d09df688 100644
--- a/pkg/chart/v2/lint/support/message_test.go
+++ b/pkg/chart/v2/lint/support/message_test.go
@@ -58,11 +58,11 @@ func TestRunLinterRule(t *testing.T) {
 
 func TestMessage(t *testing.T) {
 	m := Message{ErrorSev, "Chart.yaml", errors.New("Foo")}
-	require.EqualErrorf(t, m, "[ERROR] Chart.yaml: Foo", "Unexpected output: %s", m.Error())
+	require.EqualError(t, m, "[ERROR] Chart.yaml: Foo")
 
 	m = Message{WarningSev, "templates/", errors.New("Bar")}
-	require.EqualErrorf(t, m, "[WARNING] templates/: Bar", "Unexpected output: %s", m.Error())
+	require.EqualError(t, m, "[WARNING] templates/: Bar")
 
 	m = Message{InfoSev, "templates/rc.yaml", errors.New("FooBar")}
-	assert.EqualErrorf(t, m, "[INFO] templates/rc.yaml: FooBar", "Unexpected output: %s", m.Error())
+	assert.EqualError(t, m, "[INFO] templates/rc.yaml: FooBar")
 }
diff --git a/pkg/chart/v2/util/chartfile_test.go b/pkg/chart/v2/util/chartfile_test.go
index bdcb506da..981d0e131 100644
--- a/pkg/chart/v2/util/chartfile_test.go
+++ b/pkg/chart/v2/util/chartfile_test.go
@@ -49,12 +49,8 @@ func verifyChartfile(t *testing.T, f *chart.Metadata, name string) {
 	assert.Equal(t, "https://example.com/64x64.png", f.Icon, "Unexpected icon: %q", f.Icon)
 	assert.Len(t, f.Keywords, 3, "Unexpected keywords")
 	require.Len(t, f.Annotations, 2, "Unexpected annotations")
-
-	want, got := "extravalue", f.Annotations["extrakey"]
-	assert.Equalf(t, want, got, "Want %q, but got %q", want, got)
-
-	want, got = "anothervalue", f.Annotations["anotherkey"]
-	assert.Equalf(t, want, got, "Want %q, but got %q", want, got)
+	assert.Equal(t, "extravalue", f.Annotations["extrakey"])
+	assert.Equal(t, "anothervalue", f.Annotations["anotherkey"])
 
 	kk := []string{"frobnitz", "sprocket", "dodad"}
 	for i, k := range f.Keywords {
diff --git a/pkg/chart/v2/util/create_test.go b/pkg/chart/v2/util/create_test.go
index c85c4e3d4..69ba1336d 100644
--- a/pkg/chart/v2/util/create_test.go
+++ b/pkg/chart/v2/util/create_test.go
@@ -138,8 +138,11 @@ func TestValidateChartName(t *testing.T) {
 			"abcdefghijklmnopqrstuvwxyz-_." +
 			"ABCDEFGHIJKLMNOPQRSTUVWXYZ-_.": false,
 	} {
-		if err := validateChartName(name); (err != nil) == shouldPass {
-			t.Errorf("test for %q failed", name)
+		err := validateChartName(name)
+		if shouldPass {
+			assert.NoError(t, err)
+		} else {
+			assert.Error(t, err)
 		}
 	}
 }
diff --git a/pkg/chart/v2/util/dependencies_test.go b/pkg/chart/v2/util/dependencies_test.go
index 2386d2c28..097663783 100644
--- a/pkg/chart/v2/util/dependencies_test.go
+++ b/pkg/chart/v2/util/dependencies_test.go
@@ -43,7 +43,7 @@ func TestLoadDependency(t *testing.T) {
 	}
 
 	check := func(deps []*chart.Dependency) {
-		assert.Len(t, deps, 2, "expected 2 dependencies, got %d", len(deps))
+		require.Len(t, deps, 2, "expected 2 dependencies, got %d", len(deps))
 		for i, tt := range tests {
 			assert.Equal(t, tt.Name, deps[i].Name, "expected dependency named %q, got %q", tt.Name, deps[i].Name)
 			assert.Equal(t, tt.Version, deps[i].Version, "expected dependency named %q to have version %q, got %q", tt.Name, tt.Version, deps[i].Version)
diff --git a/pkg/cmd/completion_test.go b/pkg/cmd/completion_test.go
index 219d1eed0..296ae457e 100644
--- a/pkg/cmd/completion_test.go
+++ b/pkg/cmd/completion_test.go
@@ -18,9 +18,9 @@ package cmd
 
 import (
 	"fmt"
-	"strings"
 	"testing"
 
+	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 
 	chart "helm.sh/helm/v4/pkg/chart/v2"
@@ -47,13 +47,10 @@ func checkFileCompletion(t *testing.T, cmdName string, shouldBePerformed bool) {
 	testcmd := fmt.Sprintf("__complete %s ''", cmdName)
 	_, out, err := executeActionCommandC(storage, testcmd)
 	require.NoError(t, err)
-	if !strings.Contains(out, "ShellCompDirectiveNoFileComp") != shouldBePerformed {
-		if shouldBePerformed {
-			t.Errorf("Unexpected directive ShellCompDirectiveNoFileComp when completing '%s'", cmdName)
-		} else {
-			t.Errorf("Did not receive directive ShellCompDirectiveNoFileComp when completing '%s'", cmdName)
-		}
-		t.Log(out)
+	if shouldBePerformed {
+		assert.NotContains(t, out, "ShellCompDirectiveNoFileComp", "Unexpected directive ShellCompDirectiveNoFileComp when completing '%s'", cmdName)
+	} else {
+		assert.Contains(t, out, "ShellCompDirectiveNoFileComp", "Did not receive directive ShellCompDirectiveNoFileComp when completing '%s'", cmdName)
 	}
 }
 
diff --git a/pkg/cmd/repo_index_test.go b/pkg/cmd/repo_index_test.go
index 30700749b..67984f3b7 100644
--- a/pkg/cmd/repo_index_test.go
+++ b/pkg/cmd/repo_index_test.go
@@ -48,10 +48,10 @@ func TestRepoIndexCmd(t *testing.T) {
 	index, err := repo.LoadIndexFile(destIndex)
 	require.NoError(t, err)
 
-	assert.Len(t, index.Entries, 1, "expected 1 entry, got %d: %#v", len(index.Entries), index.Entries)
+	require.Len(t, index.Entries, 1, "expected 1 entry, got %d: %#v", len(index.Entries), index.Entries)
 
 	vs := index.Entries["compressedchart"]
-	assert.Len(t, vs, 2, "expected 2 versions, got %d: %#v", len(vs), vs)
+	require.Len(t, vs, 2, "expected 2 versions")
 
 	expectedVersion := "0.2.0"
 	assert.Equal(t, expectedVersion, vs[0].Version, "expected %q, got %q", expectedVersion, vs[0].Version)
diff --git a/pkg/cmd/repo_update_test.go b/pkg/cmd/repo_update_test.go
index ccd8b89c6..70b6dfbef 100644
--- a/pkg/cmd/repo_update_test.go
+++ b/pkg/cmd/repo_update_test.go
@@ -174,10 +174,8 @@ func TestUpdateChartsFailWithError(t *testing.T) {
 	b := bytes.NewBuffer(nil)
 	err = updateCharts([]*repo.ChartRepository{r1, r2}, b)
 	require.Error(t, err, "Repo update should return error because update of repository fails and 'fail-on-repo-update-fail' flag set")
-	var expectedErr = "failed to update the following repositories"
-	var receivedErr = err.Error()
-	require.ErrorContains(t, err, expectedErr, "Expected error (%s) but got (%s) instead", expectedErr, receivedErr)
-	require.ErrorContains(t, err, invalidURL, "Expected invalid URL (%s) in error message but got (%s) instead", invalidURL, receivedErr)
+	require.ErrorContains(t, err, "failed to update the following repositories")
+	require.ErrorContains(t, err, invalidURL)
 
 	got := b.String()
 	assert.Contains(t, got, "Unable to get an update", "Repo should have failed update but instead got: %q", got)
diff --git a/pkg/cmd/rollback_test.go b/pkg/cmd/rollback_test.go
index ff7f314c9..aa60043aa 100644
--- a/pkg/cmd/rollback_test.go
+++ b/pkg/cmd/rollback_test.go
@@ -18,7 +18,6 @@ package cmd
 
 import (
 	"fmt"
-	"reflect"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
@@ -161,5 +160,5 @@ func TestRollbackWithLabels(t *testing.T) {
 
 	updatedRel, err := releaserToV1Release(updatedReli)
 	require.NoError(t, err)
-	assert.Truef(t, reflect.DeepEqual(updatedRel.Labels, labels1), "Expected {%v}, got {%v}", labels1, updatedRel.Labels)
+	assert.Equalf(t, updatedRel.Labels, labels1, "Expected {%v}, got {%v}", labels1, updatedRel.Labels)
 }
diff --git a/pkg/cmd/search_hub_test.go b/pkg/cmd/search_hub_test.go
index 7b00cc295..a1612443a 100644
--- a/pkg/cmd/search_hub_test.go
+++ b/pkg/cmd/search_hub_test.go
@@ -46,11 +46,7 @@ func TestSearchHubCmd(t *testing.T) {
 	storage := storageFixture()
 	_, out, err := executeActionCommandC(storage, testcmd)
 	require.NoError(t, err)
-	if out != expected {
-		t.Error("expected and actual output did not match")
-		t.Log(out)
-		t.Log(expected)
-	}
+	assert.Equal(t, expected, out, "expected and actual output did not match")
 }
 
 func TestSearchHubListRepoCmd(t *testing.T) {
@@ -73,11 +69,7 @@ func TestSearchHubListRepoCmd(t *testing.T) {
 	storage := storageFixture()
 	_, out, err := executeActionCommandC(storage, testcmd)
 	require.NoError(t, err)
-	if out != expected {
-		t.Error("expected and actual output did not match")
-		t.Log(out)
-		t.Log(expected)
-	}
+	assert.Equal(t, expected, out, "expected and actual output did not match")
 }
 
 func TestSearchHubOutputCompletion(t *testing.T) {
diff --git a/pkg/cmd/show_test.go b/pkg/cmd/show_test.go
index 3ed01d418..b7ad94d94 100644
--- a/pkg/cmd/show_test.go
+++ b/pkg/cmd/show_test.go
@@ -77,12 +77,10 @@ func TestShowPreReleaseChart(t *testing.T) {
 				contentTmp,
 			)
 			_, _, err := executeActionCommand(cmd)
-			if err != nil {
-				if tt.fail {
-					assert.ErrorContains(t, err, tt.expectedErr, "%q expected error: %s, got: %s", tt.name, tt.expectedErr, err.Error())
-					return
-				}
-				t.Errorf("%q reported error: %s", tt.name, err)
+			if tt.fail {
+				assert.ErrorContains(t, err, tt.expectedErr, "%q expected error: %s, got: %s", tt.name, tt.expectedErr, err.Error())
+			} else {
+				assert.NoError(t, err)
 			}
 		})
 	}
diff --git a/pkg/downloader/chart_downloader_windows_test.go b/pkg/downloader/chart_downloader_windows_test.go
index 2b6bea5eb..0c7a23d23 100644
--- a/pkg/downloader/chart_downloader_windows_test.go
+++ b/pkg/downloader/chart_downloader_windows_test.go
@@ -99,10 +99,8 @@ func TestParallelDownloadTo(t *testing.T) {
 	// Verify the file has the expected size (should match the source file)
 	sourceFile := "testdata/local-subchart-0.1.0.tgz"
 	sourceInfo, err := os.Stat(sourceFile)
-	if err == nil && info.Size() != sourceInfo.Size() {
-		t.Errorf("Downloaded file size (%d bytes) doesn't match source file size (%d bytes)",
-			info.Size(), sourceInfo.Size())
-	}
+	require.NoError(t, err)
+	assert.False(t, info.Size() != sourceInfo.Size(), "Downloaded file size doesn't match source file size")
 
 	// Verify it's a valid tar.gz file by checking the magic bytes
 	file, err := os.Open(expectedFile)
@@ -110,10 +108,10 @@ func TestParallelDownloadTo(t *testing.T) {
 		defer file.Close()
 		// gzip magic bytes are 0x1f 0x8b
 		magic := make([]byte, 2)
-		if n, err := file.Read(magic); err == nil && n == 2 {
-			if magic[0] != 0x1f || magic[1] != 0x8b {
-				t.Errorf("Downloaded file is not a valid gzip file (magic bytes: %x)", magic)
-			}
+		n, err := file.Read(magic)
+		require.NoError(t, err)
+		if n == 2 {
+			assert.False(t, magic[0] != 0x1f || magic[1] != 0x8b, "Downloaded file is not a valid gzip file (magic bytes: %x)", magic)
 		}
 	}
 
diff --git a/pkg/engine/files_test.go b/pkg/engine/files_test.go
index 6ff251aad..9fec2e132 100644
--- a/pkg/engine/files_test.go
+++ b/pkg/engine/files_test.go
@@ -16,6 +16,7 @@ limitations under the License.
 package engine
 
 import (
+	"strconv"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
@@ -47,10 +48,10 @@ func TestNewFiles(t *testing.T) {
 	assert.Len(t, files, len(cases), "Expected len() = %d, got %d", len(cases), len(files))
 
 	for i, f := range cases {
-		got := string(files.GetBytes(f.path))
-		assert.Equalf(t, got, f.data, "%d: expected %q, got %q", i, f.data, got)
-		got = files.Get(f.path)
-		assert.Equalf(t, got, f.data, "%d: expected %q, got %q", i, f.data, got)
+		t.Run(strconv.Itoa(i), func(t *testing.T) {
+			assert.Equal(t, f.data, string(files.GetBytes(f.path)))
+			assert.Equal(t, f.data, files.Get(f.path))
+		})
 	}
 }
 
diff --git a/pkg/gates/gates_test.go b/pkg/gates/gates_test.go
index 217ee1bbe..e57f1aa8f 100644
--- a/pkg/gates/gates_test.go
+++ b/pkg/gates/gates_test.go
@@ -38,7 +38,7 @@ func TestError(t *testing.T) {
 	os.Unsetenv(name)
 	g := Gate(name)
 
-	assert.Equal(t, "this feature has been marked as experimental and is not enabled by default. Please set HELM_EXPERIMENTAL_FEATURE=1 in your environment to use this feature", g.Error().Error())
+	assert.EqualError(t, g.Error(), "this feature has been marked as experimental and is not enabled by default. Please set HELM_EXPERIMENTAL_FEATURE=1 in your environment to use this feature")
 }
 
 func TestString(t *testing.T) {
diff --git a/pkg/getter/httpgetter_test.go b/pkg/getter/httpgetter_test.go
index bfde5efa8..aebb6f11c 100644
--- a/pkg/getter/httpgetter_test.go
+++ b/pkg/getter/httpgetter_test.go
@@ -122,9 +122,9 @@ func TestDownload(t *testing.T) {
 	const expectedUserAgent = "I am Groot"
 	basicAuthSrv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		username, password, ok := r.BasicAuth()
-		if !ok || username != "username" || password != "password" {
-			t.Errorf("Expected request to use basic auth and for username == 'username' and password == 'password', got '%v', '%s', '%s'", ok, username, password)
-		}
+		assert.True(t, ok, "Expected request to use basic auth")
+		assert.Equal(t, "username", username)
+		assert.Equal(t, "password", password)
 		assert.Equal(t, expectedUserAgent, r.UserAgent(), "Expected '%s', got '%s'", expectedUserAgent, r.UserAgent())
 		fmt.Fprint(w, expect)
 	}))
@@ -147,9 +147,9 @@ func TestDownload(t *testing.T) {
 	// test with Get URL differing from withURL
 	crossAuthSrv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		username, password, ok := r.BasicAuth()
-		if ok || username == "username" || password == "password" {
-			t.Errorf("Expected request to not include but got '%v', '%s', '%s'", ok, username, password)
-		}
+		assert.False(t, ok)
+		assert.NotEqual(t, "username", username)
+		assert.NotEqual(t, "password", password)
 		fmt.Fprint(w, expect)
 	}))
 
@@ -176,9 +176,9 @@ func TestDownload(t *testing.T) {
 	// test with Get URL differing from withURL and should pass creds
 	crossAuthSrv = httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		username, password, ok := r.BasicAuth()
-		if !ok || username != "username" || password != "password" {
-			t.Errorf("Expected request to use basic auth and for username == 'username' and password == 'password', got '%v', '%s', '%s'", ok, username, password)
-		}
+		assert.True(t, ok, "Expected request to use basic auth")
+		assert.Equal(t, "username", username)
+		assert.Equal(t, "password", password)
 		fmt.Fprint(w, expect)
 	}))
 
diff --git a/pkg/kube/ready_test.go b/pkg/kube/ready_test.go
index 01f6db3cb..c40ad1d4d 100644
--- a/pkg/kube/ready_test.go
+++ b/pkg/kube/ready_test.go
@@ -165,7 +165,11 @@ func Test_ReadyChecker_IsReady_Job(t *testing.T) {
 
 			require.NoError(t, err, "Failed to create Job")
 			got, err := c.IsReady(tt.args.ctx, tt.args.resource)
-			assert.Equal(t, tt.wantErr, (err != nil), "IsReady() error = %v, wantErr %v", err, tt.wantErr)
+			if tt.wantErr {
+				require.Error(t, err, "IsReady()")
+			} else {
+				require.NoError(t, err, "IsReady()")
+			}
 			assert.Equal(t, tt.want, got, "IsReady() = %v, want %v", got, tt.want)
 		})
 	}
@@ -237,7 +241,11 @@ func Test_ReadyChecker_IsReady_Deployment(t *testing.T) {
 			require.NoError(t, err, "Failed to create ReplicaSet")
 
 			got, err := c.IsReady(tt.args.ctx, tt.args.resource)
-			assert.Equal(t, tt.wantErr, (err != nil), "IsReady() error = %v, wantErr %v", err, tt.wantErr)
+			if tt.wantErr {
+				require.Error(t, err, "IsReady()")
+			} else {
+				require.NoError(t, err, "IsReady()")
+			}
 			assert.Equal(t, tt.want, got, "IsReady() = %v, want %v", got, tt.want)
 		})
 	}
@@ -303,7 +311,11 @@ func Test_ReadyChecker_IsReady_PersistentVolumeClaim(t *testing.T) {
 			require.NoError(t, err, "Failed to create PersistentVolumeClaim")
 
 			got, err := c.IsReady(tt.args.ctx, tt.args.resource)
-			assert.Equal(t, tt.wantErr, (err != nil), "IsReady() error = %v, wantErr %v", err, tt.wantErr)
+			if tt.wantErr {
+				require.Error(t, err, "IsReady()")
+			} else {
+				require.NoError(t, err, "IsReady()")
+			}
 			assert.Equal(t, tt.want, got, "IsReady() = %v, want %v", got, tt.want)
 		})
 	}
@@ -369,7 +381,11 @@ func Test_ReadyChecker_IsReady_Service(t *testing.T) {
 			require.NoError(t, err, "Failed to create Service")
 
 			got, err := c.IsReady(tt.args.ctx, tt.args.resource)
-			assert.Equal(t, tt.wantErr, (err != nil), "IsReady() error = %v, wantErr %v", err, tt.wantErr)
+			if tt.wantErr {
+				require.Error(t, err, "IsReady()")
+			} else {
+				require.NoError(t, err, "IsReady()")
+			}
 			assert.Equal(t, tt.want, got, "IsReady() = %v, want %v", got, tt.want)
 		})
 	}
@@ -435,7 +451,11 @@ func Test_ReadyChecker_IsReady_DaemonSet(t *testing.T) {
 			require.NoError(t, err, "Failed to create DaemonSet")
 
 			got, err := c.IsReady(tt.args.ctx, tt.args.resource)
-			assert.Equal(t, tt.wantErr, (err != nil), "IsReady() error = %v, wantErr %v", err, tt.wantErr)
+			if tt.wantErr {
+				require.Error(t, err, "IsReady()")
+			} else {
+				require.NoError(t, err, "IsReady()")
+			}
 			assert.Equal(t, tt.want, got, "IsReady() = %v, want %v", got, tt.want)
 		})
 	}
@@ -501,7 +521,11 @@ func Test_ReadyChecker_IsReady_StatefulSet(t *testing.T) {
 			require.NoError(t, err, "Failed to create StatefulSet")
 
 			got, err := c.IsReady(tt.args.ctx, tt.args.resource)
-			assert.Equal(t, tt.wantErr, (err != nil), "IsReady() error = %v, wantErr %v", err, tt.wantErr)
+			if tt.wantErr {
+				require.Error(t, err, "IsReady()")
+			} else {
+				require.NoError(t, err, "IsReady()")
+			}
 			assert.Equal(t, tt.want, got, "IsReady() = %v, want %v", got, tt.want)
 		})
 	}
@@ -582,7 +606,11 @@ func Test_ReadyChecker_IsReady_ReplicationController(t *testing.T) {
 			require.NoError(t, err, "Failed to create ReplicationController")
 
 			got, err := c.IsReady(tt.args.ctx, tt.args.resource)
-			assert.Equal(t, tt.wantErr, (err != nil), "IsReady() error = %v, wantErr %v", err, tt.wantErr)
+			if tt.wantErr {
+				require.Error(t, err, "IsReady()")
+			} else {
+				require.NoError(t, err, "IsReady()")
+			}
 			assert.Equal(t, tt.want, got, "IsReady() = %v, want %v", got, tt.want)
 		})
 	}
@@ -646,7 +674,11 @@ func Test_ReadyChecker_IsReady_ReplicaSet(t *testing.T) {
 			}
 			//
 			got, err := c.IsReady(tt.args.ctx, tt.args.resource)
-			assert.Equal(t, tt.wantErr, (err != nil), "IsReady() error = %v, wantErr %v", err, tt.wantErr)
+			if tt.wantErr {
+				require.Error(t, err, "IsReady()")
+			} else {
+				require.NoError(t, err, "IsReady()")
+			}
 			assert.Equal(t, tt.want, got, "IsReady() = %v, want %v", got, tt.want)
 		})
 	}
@@ -1044,9 +1076,10 @@ func Test_ReadyChecker_jobReady(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			c := NewReadyChecker(fake.NewClientset())
 			got, err := c.jobReady(tt.args.job)
-			if (err != nil) != tt.wantErr {
-				t.Errorf("jobReady() error = %v, wantErr %v", err, tt.wantErr)
-				return
+			if tt.wantErr {
+				require.Error(t, err, "jobReady()")
+			} else {
+				require.NoError(t, err, "jobReady()")
 			}
 			assert.Equal(t, tt.want, got, "jobReady() = %v, want %v", got, tt.want)
 		})
diff --git a/pkg/kube/resource_test.go b/pkg/kube/resource_test.go
index ca41a06ed..18501d4e8 100644
--- a/pkg/kube/resource_test.go
+++ b/pkg/kube/resource_test.go
@@ -42,13 +42,11 @@ func TestResourceList(t *testing.T) {
 
 	diff := r1.Difference(r2)
 	assert.Len(t, diff, 1, "expected 1 result")
-
-	assert.True(t, diff.Contains(info("foo")), "expected diff to return foo")
+	assert.Contains(t, diff, info("foo"), "expected diff to return foo")
 
 	inter := r1.Intersect(r2)
 	assert.Len(t, inter, 1, "expected 1 result")
-
-	assert.True(t, inter.Contains(info("bar")), "expected intersect to return bar")
+	assert.Contains(t, inter, info("bar"), "expected intersect to return bar")
 }
 
 func TestIsMatchingInfo(t *testing.T) {
diff --git a/pkg/kube/wait_test.go b/pkg/kube/wait_test.go
index 9cf1e5506..d33a12c87 100644
--- a/pkg/kube/wait_test.go
+++ b/pkg/kube/wait_test.go
@@ -297,8 +297,7 @@ func TestLegacyWaiter_waitForPodSuccess(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			done, err := lw.waitForPodSuccess(tt.obj, "foo")
 			if tt.wantErr {
-				require.Error(t, err, "expected error, got none")
-				require.ErrorContains(t, err, tt.errMessage, "expected error to contain %q, got %q", tt.errMessage, err.Error())
+				require.ErrorContains(t, err, tt.errMessage)
 			} else {
 				require.NoError(t, err)
 			}
@@ -384,8 +383,7 @@ func TestLegacyWaiter_waitForJob(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			done, err := lw.waitForJob(tt.obj, "test-job")
 			if tt.wantErr {
-				require.Error(t, err, "expected error, got none")
-				require.ErrorContainsf(t, err, tt.errMessage, "expected error to contain %q, got %q", tt.errMessage, err.Error())
+				require.ErrorContains(t, err, tt.errMessage)
 			} else {
 				require.NoError(t, err)
 				assert.Equal(t, tt.wantDone, done, "got done=%v, want %v", done, tt.wantDone)
diff --git a/pkg/kubeenv/roundtripper_test.go b/pkg/kubeenv/roundtripper_test.go
index 6f0caf6f8..8d5b80e39 100644
--- a/pkg/kubeenv/roundtripper_test.go
+++ b/pkg/kubeenv/roundtripper_test.go
@@ -141,12 +141,11 @@ func TestRetryingRoundTripper_RoundTrip(t *testing.T) {
 
 			if tt.expectedErr != "" {
 				require.ErrorContains(t, err, tt.expectedErr)
-				return
+			} else {
+				require.NoError(t, err)
+				assert.Equal(t, tt.expectedCode, resp.StatusCode)
+				assert.Equal(t, tt.expectedCalls, fakeRT.calls)
 			}
-			require.NoError(t, err)
-
-			assert.Equal(t, tt.expectedCode, resp.StatusCode)
-			assert.Equal(t, tt.expectedCalls, fakeRT.calls)
 		})
 	}
 }
diff --git a/pkg/provenance/sign_test.go b/pkg/provenance/sign_test.go
index 32253df90..ec6e6194b 100644
--- a/pkg/provenance/sign_test.go
+++ b/pkg/provenance/sign_test.go
@@ -128,9 +128,7 @@ func TestParseMessageBlock(t *testing.T) {
 func TestLoadKey(t *testing.T) {
 	k, err := loadKey(testKeyfile)
 	require.NoError(t, err)
-
-	_, ok := k.Identities[testKeyName]
-	assert.Truef(t, ok, "Expected to load a key for user %q", testKeyName)
+	assert.Containsf(t, k.Identities, testKeyName, "Expected to load a key for user %q", testKeyName)
 }
 
 func TestLoadKeyRing(t *testing.T) {
@@ -163,8 +161,7 @@ func TestNewFromFiles(t *testing.T) {
 	s, err := NewFromFiles(testKeyfile, testPubfile)
 	require.NoError(t, err)
 
-	_, ok := s.Entity.Identities[testKeyName]
-	assert.Truef(t, ok, "Expected to load a key for user %q", testKeyName)
+	assert.Containsf(t, s.Entity.Identities, testKeyName, "Expected to load a key for user %q", testKeyName)
 }
 
 func TestDigestFile(t *testing.T) {
@@ -240,7 +237,6 @@ func TestMixedKeyringRSASigningAndVerification(t *testing.T) {
 	}
 
 	assert.True(t, hasEdDSA, "expected %s to include an Ed25519 public key", testMixedKeyring)
-
 	require.NotNil(t, signer.Entity, "expected signer entity to be loaded")
 	require.NotNil(t, signer.Entity.PrivateKey, "expected signer private key to be loaded")
 	assert.Equal(t, packet.PubKeyAlgoRSA, signer.Entity.PrivateKey.PubKeyAlgo, "expected RSA key")
@@ -259,9 +255,7 @@ func TestMixedKeyringRSASigningAndVerification(t *testing.T) {
 	require.NotNil(t, verification.SignedBy, "expected verification to include signer")
 	require.NotNil(t, verification.SignedBy.PrimaryKey, "expected verification to include signer primary key")
 	assert.Equal(t, packet.PubKeyAlgoRSA, verification.SignedBy.PrimaryKey.PubKeyAlgo, "expected verification to report RSA key")
-
-	_, ok := verification.SignedBy.Identities[testKeyName]
-	assert.True(t, ok, "expected verification to be signed by %q", testKeyName)
+	assert.Contains(t, verification.SignedBy.Identities, testKeyName, "expected verification to be signed by %q", testKeyName)
 }
 
 // failSigner always fails to sign and returns an error
diff --git a/pkg/pusher/ocipusher_test.go b/pkg/pusher/ocipusher_test.go
index ceb61d442..b63077293 100644
--- a/pkg/pusher/ocipusher_test.go
+++ b/pkg/pusher/ocipusher_test.go
@@ -33,8 +33,7 @@ func TestNewOCIPusher(t *testing.T) {
 	p, err := NewOCIPusher()
 	require.NoError(t, err)
 
-	_, ok := p.(*OCIPusher)
-	require.True(t, ok, "Expected NewOCIPusher to produce an *OCIPusher")
+	require.IsType(t, &OCIPusher{}, p, "Expected NewOCIPusher to produce an *OCIPusher")
 
 	cd := "../../testdata"
 	join := filepath.Join
@@ -196,7 +195,7 @@ func TestOCIPusher_newRegistryClient(t *testing.T) {
 			if tt.expectError {
 				require.Error(t, err, "Expected error but got none")
 				if tt.errorContains != "" {
-					require.ErrorContainsf(t, err, tt.errorContains, "Expected error containing %q, got %q", tt.errorContains, err.Error())
+					require.ErrorContains(t, err, tt.errorContains)
 				}
 			} else {
 				require.NoError(t, err)
diff --git a/pkg/registry/chart_test.go b/pkg/registry/chart_test.go
index 95e429a0b..3edf21e38 100644
--- a/pkg/registry/chart_test.go
+++ b/pkg/registry/chart_test.go
@@ -232,8 +232,7 @@ func TestGenerateOCICreatedAnnotations(t *testing.T) {
 	result := generateOCIAnnotations(testChart, nowTimeString)
 
 	// Check that created annotation exists
-	_, ok := result[ocispec.AnnotationCreated]
-	assert.True(t, ok, "%s annotation not created", ocispec.AnnotationCreated)
+	assert.Contains(t, result, ocispec.AnnotationCreated, "%s annotation not created", ocispec.AnnotationCreated)
 
 	// Verify value of created artifact in RFC3339 format
 	_, err := time.Parse(time.RFC3339, result[ocispec.AnnotationCreated])
@@ -243,8 +242,7 @@ func TestGenerateOCICreatedAnnotations(t *testing.T) {
 	result = generateOCIAnnotations(testChart, "")
 
 	// Check that created annotation exists
-	_, ok = result[ocispec.AnnotationCreated]
-	require.True(t, ok, "%s annotation not created", ocispec.AnnotationCreated)
+	require.Contains(t, result, ocispec.AnnotationCreated, "%s annotation not created", ocispec.AnnotationCreated)
 
 	createdTimeAnnotation, err := time.Parse(time.RFC3339, result[ocispec.AnnotationCreated])
 	require.NoError(t, err, "%s annotation with value '%s' not in RFC3339 format", ocispec.AnnotationCreated, result[ocispec.AnnotationCreated])
diff --git a/pkg/registry/client_test.go b/pkg/registry/client_test.go
index 97b7c7c4c..21604ce7e 100644
--- a/pkg/registry/client_test.go
+++ b/pkg/registry/client_test.go
@@ -65,9 +65,9 @@ func TestLogin_ResetsForceAttemptOAuth2_OnSuccess(t *testing.T) {
 		if r.URL.Path == "/v2/" {
 			// Accept either HEAD or GET
 			w.WriteHeader(http.StatusOK)
-			return
+		} else {
+			http.NotFound(w, r)
 		}
-		http.NotFound(w, r)
 	}))
 	defer srv.Close()
 
diff --git a/pkg/registry/plugin_test.go b/pkg/registry/plugin_test.go
index bb557c5b8..d51cfa0d6 100644
--- a/pkg/registry/plugin_test.go
+++ b/pkg/registry/plugin_test.go
@@ -78,11 +78,10 @@ func TestGetPluginName(t *testing.T) {
 
 			if tt.expectErr {
 				assert.Error(t, err, "expected error but got none")
-				return
+			} else {
+				require.NoError(t, err)
+				assert.Equal(t, tt.expected, pluginName)
 			}
-
-			require.NoError(t, err)
-			assert.Equal(t, tt.expected, pluginName)
 		})
 	}
 }
diff --git a/pkg/registry/registry_test.go b/pkg/registry/registry_test.go
index 313cb861c..40ebe9687 100644
--- a/pkg/registry/registry_test.go
+++ b/pkg/registry/registry_test.go
@@ -376,23 +376,21 @@ func initFakeRegistryTestServer() string {
 			if err != nil {
 				w.WriteHeader(http.StatusInternalServerError)
 				w.Write([]byte(err.Error()))
-				return
+			} else {
+				w.Header().Set("Content-Type", ProvLayerMediaType)
+				w.Write(data)
 			}
 
-			w.Header().Set("Content-Type", ProvLayerMediaType)
-			w.Write(data)
-
 		case "/v2/testrepo/image-index/blobs/sha256:e5ef611620fb97704d8751c16bab17fedb68883bfb0edc76f78a70e9173f9b55":
 			data, err := os.ReadFile("../downloader/testdata/signtest-0.1.0.tgz")
 			if err != nil {
 				w.WriteHeader(http.StatusInternalServerError)
 				w.Write([]byte(err.Error()))
-				return
+			} else {
+				w.Header().Set("Content-Type", ChartLayerMediaType)
+				w.Write(data)
 			}
 
-			w.Header().Set("Content-Type", ChartLayerMediaType)
-			w.Write(data)
-
 		default:
 			w.WriteHeader(http.StatusNotFound)
 		}
diff --git a/pkg/release/v1/util/manifest_sorter_test.go b/pkg/release/v1/util/manifest_sorter_test.go
index 35c7a0721..da08ab169 100644
--- a/pkg/release/v1/util/manifest_sorter_test.go
+++ b/pkg/release/v1/util/manifest_sorter_test.go
@@ -143,7 +143,6 @@ metadata:
 
 	// This test will fail if 'six' or 'seven' was added.
 	assert.Len(t, generic, 2)
-
 	assert.Len(t, hs, 4)
 
 	for _, out := range hs {
diff --git a/pkg/repo/v1/chartrepo_test.go b/pkg/repo/v1/chartrepo_test.go
index 4be2ebf73..54275e28d 100644
--- a/pkg/repo/v1/chartrepo_test.go
+++ b/pkg/repo/v1/chartrepo_test.go
@@ -175,9 +175,7 @@ func TestFindChartInAuthAndTLSAndPassRepoURL(t *testing.T) {
 	// versions of Darwin do not. As there are people developing Helm using both old and new versions of Darwin we test
 	// for both messages.
 	if runtime.GOOS == "darwin" {
-		if !strings.Contains(err.Error(), "x509: “Acme Co” certificate is not trusted") && !strings.Contains(err.Error(), "x509: certificate signed by unknown authority") {
-			t.Errorf("Expected TLS error for function  FindChartInAuthAndTLSAndPassRepoURL not found, but got a different error (%v)", err)
-		}
+		assert.True(t, strings.Contains(err.Error(), "x509: “Acme Co” certificate is not trusted") || strings.Contains(err.Error(), "x509: certificate signed by unknown authority"), "Expected TLS error for function  FindChartInAuthAndTLSAndPassRepoURL not found, but got a different error (%v)", err)
 	} else {
 		assert.ErrorContainsf(t, err, "x509: certificate signed by unknown authority", "Expected TLS error for function  FindChartInAuthAndTLSAndPassRepoURL not found, but got a different error")
 	}
@@ -203,7 +201,6 @@ func TestErrorFindChartInRepoURL(t *testing.T) {
 	})
 
 	_, err := FindChartInRepoURL("http://someserver/something", "nginx", g)
-	require.Error(t, err, "Expected error for bad chart URL, but did not get any errors")
 	require.ErrorContainsf(t, err, `looks like "http://someserver/something" is not a valid chart repository or cannot be reached`, "Expected error for bad chart URL, but got a different error")
 
 	srv, err := startLocalServerForTests(nil)
@@ -211,16 +208,13 @@ func TestErrorFindChartInRepoURL(t *testing.T) {
 	defer srv.Close()
 
 	_, err = FindChartInRepoURL(srv.URL, "nginx1", g)
-	require.Error(t, err, "Expected error for chart not found, but did not get any errors")
 	require.EqualError(t, err, `chart "nginx1" not found in `+srv.URL+` repository`, "Expected error for chart not found, but got a different error")
 	require.ErrorIs(t, err, ChartNotFoundError{}, "error is not of correct error type structure")
 
 	_, err = FindChartInRepoURL(srv.URL, "nginx1", g, WithChartVersion("0.1.0"))
-	require.Error(t, err, "Expected error for chart not found, but did not get any errors")
 	require.EqualError(t, err, `chart "nginx1" version "0.1.0" not found in `+srv.URL+` repository`, "Expected error for chart not found, but got a different error")
 
 	_, err = FindChartInRepoURL(srv.URL, "chartWithNoURL", g)
-	require.Error(t, err, "Expected error for no chart URLs available, but did not get any errors")
 	assert.EqualError(t, err, `chart "chartWithNoURL" has no downloadable URLs`, "Expected error for chart not found, but got a different error")
 }
 
diff --git a/pkg/repo/v1/repo_test.go b/pkg/repo/v1/repo_test.go
index e3373fc49..f7f5df9be 100644
--- a/pkg/repo/v1/repo_test.go
+++ b/pkg/repo/v1/repo_test.go
@@ -120,11 +120,8 @@ func TestRemoveRepository(t *testing.T) {
 	)
 
 	removeRepository := "stable"
-	found := sampleRepository.Remove(removeRepository)
-	assert.Truef(t, found, "expected repository %s not found", removeRepository)
-
-	found = sampleRepository.Has(removeRepository)
-	assert.Falsef(t, found, "repository %s not deleted", removeRepository)
+	assert.Truef(t, sampleRepository.Remove(removeRepository), "expected repository %s not found", removeRepository)
+	assert.Falsef(t, sampleRepository.Has(removeRepository), "repository %s not deleted", removeRepository)
 }
 
 func TestUpdateRepository(t *testing.T) {
@@ -205,9 +202,6 @@ func TestRemoveRepositoryInvalidEntries(t *testing.T) {
 	)
 
 	removeRepository := "stable"
-	found := sampleRepository.Remove(removeRepository)
-	assert.Truef(t, found, "expected repository %s not found", removeRepository)
-
-	found = sampleRepository.Has(removeRepository)
-	assert.Falsef(t, found, "repository %s not deleted", removeRepository)
+	assert.Truef(t, sampleRepository.Remove(removeRepository), "expected repository %s not found", removeRepository)
+	assert.Falsef(t, sampleRepository.Has(removeRepository), "repository %s not deleted", removeRepository)
 }
diff --git a/pkg/repo/v1/repotest/server_test.go b/pkg/repo/v1/repotest/server_test.go
index 7008e2305..f74adb445 100644
--- a/pkg/repo/v1/repotest/server_test.go
+++ b/pkg/repo/v1/repotest/server_test.go
@@ -42,24 +42,25 @@ func TestServer(t *testing.T) {
 
 	c, err := srv.CopyCharts("testdata/*.tgz")
 	require.NoError(t, err)
-
-	assert.Len(t, c, 1)
-
+	require.Len(t, c, 1)
 	assert.Equal(t, "examplechart-0.1.0.tgz", filepath.Base(c[0]))
 
 	req, err := http.NewRequestWithContext(t.Context(), http.MethodGet, srv.URL()+"/examplechart-0.1.0.tgz", http.NoBody)
 	require.NoError(t, err)
+
 	client := http.DefaultClient
 	res, err := client.Do(req)
 	require.NoError(t, err)
-	res.Body.Close()
 
+	res.Body.Close()
 	assert.GreaterOrEqual(t, res.ContentLength, int64(500))
 
 	req, err = http.NewRequestWithContext(t.Context(), http.MethodGet, srv.URL()+"/index.yaml", http.NoBody)
 	require.NoError(t, err)
+
 	res, err = client.Do(req)
 	require.NoError(t, err)
+
 	data, err := io.ReadAll(res.Body)
 	res.Body.Close()
 	require.NoError(t, err)
diff --git a/pkg/storage/driver/labels_test.go b/pkg/storage/driver/labels_test.go
index 848ae8861..481b8c467 100644
--- a/pkg/storage/driver/labels_test.go
+++ b/pkg/storage/driver/labels_test.go
@@ -18,6 +18,8 @@ package driver
 
 import (
 	"testing"
+
+	"github.com/stretchr/testify/require"
 )
 
 func TestLabelsMatch(t *testing.T) {
@@ -42,8 +44,8 @@ func TestLabelsMatch(t *testing.T) {
 	}
 
 	for _, tt := range tests {
-		if !tt.set1.match(tt.set2) && tt.expect {
-			t.Fatalf("Expected match '%s'\n", tt.desc)
-		}
+		t.Run(tt.desc, func(t *testing.T) {
+			require.False(t, !tt.set1.match(tt.set2) && tt.expect)
+		})
 	}
 }
diff --git a/pkg/storage/driver/records_test.go b/pkg/storage/driver/records_test.go
index 067e31e76..22d54e6cc 100644
--- a/pkg/storage/driver/records_test.go
+++ b/pkg/storage/driver/records_test.go
@@ -17,7 +17,6 @@ limitations under the License.
 package driver
 
 import (
-	"reflect"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
@@ -132,7 +131,7 @@ func TestRecordsGet(t *testing.T) {
 
 	for _, tt := range tests {
 		got := rs.Get(tt.key)
-		require.Truef(t, reflect.DeepEqual(tt.rec, got), "Expected %v, got %v", tt.rec, got)
+		require.Equal(t, tt.rec, got, "Expected %v, got %v", tt.rec, got)
 	}
 }
 
@@ -222,6 +221,6 @@ func TestRecordsReplace(t *testing.T) {
 
 	for _, tt := range tests {
 		got := rs.Replace(tt.key, tt.rec)
-		require.Truef(t, reflect.DeepEqual(tt.expected, got), "Expected %v, got %v", tt.expected, got)
+		require.Equalf(t, tt.expected, got, "Expected %v, got %v", tt.expected, got)
 	}
 }
diff --git a/pkg/storage/driver/util_test.go b/pkg/storage/driver/util_test.go
index 7074f252a..5dda3cd1f 100644
--- a/pkg/storage/driver/util_test.go
+++ b/pkg/storage/driver/util_test.go
@@ -14,7 +14,6 @@ limitations under the License.
 package driver
 
 import (
-	"reflect"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
@@ -22,7 +21,7 @@ import (
 
 func TestGetSystemLabel(t *testing.T) {
 	output := GetSystemLabels()
-	assert.Truef(t, reflect.DeepEqual(systemLabels, output), "Expected {%v}, got {%v}", systemLabels, output)
+	assert.Equalf(t, systemLabels, output, "Expected {%v}, got {%v}", systemLabels, output)
 }
 
 func TestIsSystemLabel(t *testing.T) {
@@ -69,7 +68,7 @@ func TestFilterSystemLabels(t *testing.T) {
 	}
 	for _, test := range tests {
 		output := filterSystemLabels(test[0])
-		assert.Truef(t, reflect.DeepEqual(test[1], output), "Expected {%v}, got {%v}", test[1], output)
+		assert.Equalf(t, test[1], output, "Expected {%v}, got {%v}", test[1], output)
 	}
 }
 
@@ -101,6 +100,6 @@ func TestContainsSystemLabels(t *testing.T) {
 	}
 	for _, test := range tests {
 		output := ContainsSystemLabels(test.input)
-		assert.Truef(t, reflect.DeepEqual(test.output, output), "Expected {%v}, got {%v}", test.output, output)
+		assert.Equalf(t, test.output, output, "Expected {%v}, got {%v}", test.output, output)
 	}
 }

From 828d01a8786162987482408b7803ceb3f3c176ac Mon Sep 17 00:00:00 2001
From: Matthieu MOREL <matthieu.morel35@gmail.com>
Date: Fri, 24 Jul 2026 13:24:06 +0200
Subject: [PATCH 07/13] chore(pkg): refactor: finer tests conversions to
 testify part 1

refactor: finer tests conversions to testify in pkg/strvals
Signed-off-by: Matthieu MOREL <matthieu.morel35@gmail.com>
---
 pkg/action/upgrade_test.go               |  25 +--
 pkg/chart/v2/lint/rules/template_test.go |  29 ++--
 pkg/chart/v2/loader/load_test.go         |  37 ++---
 pkg/downloader/chart_downloader_test.go  |  65 ++++----
 pkg/kube/client_test.go                  |  22 ++-
 pkg/strvals/literal_parser_test.go       |  81 ++++------
 pkg/strvals/parser_test.go               | 189 +++++++++--------------
 7 files changed, 177 insertions(+), 271 deletions(-)

diff --git a/pkg/action/upgrade_test.go b/pkg/action/upgrade_test.go
index b7e25206d..53419b6a8 100644
--- a/pkg/action/upgrade_test.go
+++ b/pkg/action/upgrade_test.go
@@ -252,11 +252,8 @@ func TestUpgradeRelease_ReuseValues(t *testing.T) {
 		// Now make sure it is actually upgraded
 		updatedResi, err := upAction.cfg.Releases.Get(res.Name, 2)
 		req.NoError(err)
+		req.NotNil(updatedResi, "Updated Release is nil")
 
-		if updatedResi == nil {
-			is.Fail("Updated Release is nil")
-			return
-		}
 		updatedRes, err := releaserToV1Release(updatedResi)
 		req.NoError(err)
 
@@ -320,11 +317,8 @@ func TestUpgradeRelease_ReuseValues(t *testing.T) {
 		// Now get the upgraded release
 		updatedResi, err := upAction.cfg.Releases.Get(res.Name, 2)
 		req.NoError(err)
+		req.NotNil(updatedResi, "Updated Release is nil")
 
-		if updatedResi == nil {
-			is.Fail("Updated Release is nil")
-			return
-		}
 		updatedRes, err := releaserToV1Release(updatedResi)
 		req.NoError(err)
 
@@ -383,11 +377,8 @@ func TestUpgradeRelease_ResetThenReuseValues(t *testing.T) {
 		// Now make sure it is actually upgraded
 		updatedResi, err := upAction.cfg.Releases.Get(res.Name, 2)
 		req.NoError(err)
+		req.NotNil(updatedResi, "Updated Release is nil")
 
-		if updatedResi == nil {
-			is.Fail("Updated Release is nil")
-			return
-		}
 		updatedRes, err := releaserToV1Release(updatedResi)
 		req.NoError(err)
 
@@ -523,11 +514,8 @@ func TestUpgradeRelease_Labels(t *testing.T) {
 	// Now make sure it is actually upgraded and labels were merged
 	updatedResi, err := upAction.cfg.Releases.Get(res.Name, 2)
 	req.NoError(err)
+	req.NotNil(updatedResi, "Updated Release is nil")
 
-	if updatedResi == nil {
-		is.Fail("Updated Release is nil")
-		return
-	}
 	updatedRes, err := releaserToV1Release(updatedResi)
 	req.NoError(err)
 	is.Equal(common.StatusDeployed, updatedRes.Info.Status)
@@ -536,11 +524,8 @@ func TestUpgradeRelease_Labels(t *testing.T) {
 	// Now make sure it is suppressed release still contains original labels
 	initialResi, err := upAction.cfg.Releases.Get(res.Name, 1)
 	req.NoError(err)
+	req.NotNil(initialResi, "Initial Release is nil")
 
-	if initialResi == nil {
-		is.Fail("Updated Release is nil")
-		return
-	}
 	initialRes, err := releaserToV1Release(initialResi)
 	req.NoError(err)
 	is.Equal(common.StatusSuperseded, initialRes.Info.Status)
diff --git a/pkg/chart/v2/lint/rules/template_test.go b/pkg/chart/v2/lint/rules/template_test.go
index 37a33a7eb..ab78450b9 100644
--- a/pkg/chart/v2/lint/rules/template_test.go
+++ b/pkg/chart/v2/lint/rules/template_test.go
@@ -171,8 +171,11 @@ func TestValidateMetadataName(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(fmt.Sprintf("%s/%s", tt.obj.Kind, tt.obj.Metadata.Name), func(t *testing.T) {
-			if err := validateMetadataName(tt.obj); (err != nil) != tt.wantErr {
-				t.Errorf("validateMetadataName() error = %v, wantErr %v", err, tt.wantErr)
+			err := validateMetadataName(tt.obj)
+			if tt.wantErr {
+				require.Error(t, err, "validateMetadataName()")
+			} else {
+				require.NoError(t, err, "validateMetadataName()")
 			}
 		})
 	}
@@ -210,12 +213,12 @@ func TestDeprecatedAPIFails(t *testing.T) {
 		namespace,
 		values,
 		TemplateLinterSkipSchemaValidation(false))
-	if l := len(linter.Messages); l != 1 {
+	if !assert.Len(t, linter.Messages, 1) {
 		for i, msg := range linter.Messages {
 			t.Logf("Message %d: %s", i, msg)
 		}
-		t.Fatalf("Expected 1 lint error, got %d", l)
 	}
+	require.Len(t, linter.Messages, 1, "Expected 1 lint error")
 
 	var depErr deprecatedAPIError
 	require.ErrorAs(t, linter.Messages[0].Err, &depErr)
@@ -267,8 +270,7 @@ func TestStrictTemplateParsingMapError(t *testing.T) {
 		namespace,
 		ch.Values,
 		TemplateLinterSkipSchemaValidation(false))
-	if len(linter.Messages) != 0 {
-		t.Errorf("expected zero messages, got %d", len(linter.Messages))
+	if !assert.Empty(t, linter.Messages, "expected zero messages") {
 		for i, msg := range linter.Messages {
 			t.Logf("Message %d: %q", i, msg)
 		}
@@ -358,9 +360,14 @@ func TestValidateTopIndentLevel(t *testing.T) {
 		"  apiVersion:foo":         true,
 		"\n\n  apiVersion:foo\n\n": true,
 	} {
-		if err := validateTopIndentLevel(doc); (err == nil) == shouldFail {
-			t.Errorf("Expected %t for %q", shouldFail, doc)
-		}
+		t.Run(doc, func(t *testing.T) {
+			err := validateTopIndentLevel(doc)
+			if shouldFail {
+				assert.Error(t, err)
+			} else {
+				assert.NoError(t, err)
+			}
+		})
 	}
 }
 
@@ -392,12 +399,12 @@ func TestEmptyWithCommentsManifests(t *testing.T) {
 		namespace,
 		values,
 		TemplateLinterSkipSchemaValidation(false))
-	if l := len(linter.Messages); l > 0 {
+	if !assert.Empty(t, linter.Messages) {
 		for i, msg := range linter.Messages {
 			t.Logf("Message %d: %s", i, msg)
 		}
-		t.Fatalf("Expected 0 lint errors, got %d", l)
 	}
+	require.Empty(t, linter.Messages, "Expected 0 lint errors")
 }
 func TestValidateListAnnotations(t *testing.T) {
 	md := &k8sYamlStruct{
diff --git a/pkg/chart/v2/loader/load_test.go b/pkg/chart/v2/loader/load_test.go
index da5c3b725..4d73cb0d6 100644
--- a/pkg/chart/v2/loader/load_test.go
+++ b/pkg/chart/v2/loader/load_test.go
@@ -25,7 +25,6 @@ import (
 	"log"
 	"os"
 	"path/filepath"
-	"reflect"
 	"runtime"
 	"strings"
 	"testing"
@@ -385,11 +384,13 @@ func TestLoadInvalidArchive(t *testing.T) {
 		{"illegal-abspath5.tgz", "/./c://foo", "chart contains illegally named files"},
 		{"illegal-abspath6.tgz", "\\\\?\\Some\\windows\\magic", "chart illegally contains absolute paths"},
 	} {
-		illegalChart := filepath.Join(tmpdir, tt.chartname)
-		writeTar(illegalChart, tt.internal, []byte("hello: world"))
-		_, err := Load(illegalChart)
-		require.Error(t, err, "expected error when unpacking illegal files")
-		require.ErrorContains(t, err, tt.expectError, "Expected error to contain %q, got %q for %s", tt.expectError, err.Error(), tt.chartname)
+		t.Run(tt.chartname, func(t *testing.T) {
+			illegalChart := filepath.Join(tmpdir, tt.chartname)
+			writeTar(illegalChart, tt.internal, []byte("hello: world"))
+			_, err := Load(illegalChart)
+			require.Error(t, err, "expected error when unpacking illegal files")
+			require.ErrorContains(t, err, tt.expectError)
+		})
 	}
 
 	// Make sure that absolute path gets interpreted as relative
@@ -456,7 +457,7 @@ foo:
 		t.Run(testName, func(tt *testing.T) {
 			values, err := LoadValues(bytes.NewReader(testCase.data))
 			require.NoError(tt, err)
-			assert.Truef(t, reflect.DeepEqual(values, testCase.expctedValues), "Expected values: %v, got %v", testCase.expctedValues, values)
+			assert.Equal(t, testCase.expctedValues, values)
 		})
 	}
 }
@@ -484,16 +485,13 @@ func TestMergeValuesV2(t *testing.T) {
 	}
 
 	testMap := MergeMaps(flatMap, nestedMap)
-	equal := reflect.DeepEqual(testMap, nestedMap)
-	assert.True(t, equal, "Expected a nested map to overwrite a flat value. Expected: %v, got %v", nestedMap, testMap)
+	assert.Equal(t, testMap, nestedMap, "Expected a nested map to overwrite a flat value. Expected: %v, got %v", nestedMap, testMap)
 
 	testMap = MergeMaps(nestedMap, flatMap)
-	equal = reflect.DeepEqual(testMap, flatMap)
-	assert.True(t, equal, "Expected a flat value to overwrite a map. Expected: %v, got %v", flatMap, testMap)
+	assert.Equal(t, testMap, flatMap, "Expected a flat value to overwrite a map. Expected: %v, got %v", flatMap, testMap)
 
 	testMap = MergeMaps(nestedMap, anotherNestedMap)
-	equal = reflect.DeepEqual(testMap, anotherNestedMap)
-	assert.True(t, equal, "Expected a nested map to overwrite another nested map. Expected: %v, got %v", anotherNestedMap, testMap)
+	assert.Equal(t, testMap, anotherNestedMap, "Expected a nested map to overwrite another nested map. Expected: %v, got %v", anotherNestedMap, testMap)
 
 	testMap = MergeMaps(anotherFlatMap, anotherNestedMap)
 	expectedMap := map[string]any{
@@ -504,8 +502,7 @@ func TestMergeValuesV2(t *testing.T) {
 			"awesome": "stuff",
 		},
 	}
-	equal = reflect.DeepEqual(testMap, expectedMap)
-	assert.True(t, equal, "Expected a map with different keys to merge properly with another map. Expected: %v, got %v", expectedMap, testMap)
+	assert.Equal(t, expectedMap, testMap, "Expected a map with different keys to merge properly with another map. Expected: %v, got %v", expectedMap, testMap)
 }
 
 func verifyChart(t *testing.T, c *chart.Chart) {
@@ -515,15 +512,13 @@ func verifyChart(t *testing.T, c *chart.Chart) {
 	assert.Len(t, c.Templates, 1, "Expected 1 template, got %d", len(c.Templates))
 
 	numfiles := 6
-	if len(c.Files) != numfiles {
-		t.Errorf("Expected %d extra files, got %d", numfiles, len(c.Files))
+	if !assert.Len(t, c.Files, numfiles) {
 		for _, n := range c.Files {
 			t.Logf("\t%s", n.Name)
 		}
 	}
 
-	if len(c.Dependencies()) != 2 {
-		t.Errorf("Expected 2 dependencies, got %d (%v)", len(c.Dependencies()), c.Dependencies())
+	if !assert.Len(t, c.Dependencies(), 2, "Expected 2 dependencies") {
 		for _, d := range c.Dependencies() {
 			t.Logf("\tSubchart: %s\n", d.Name())
 		}
@@ -548,7 +543,7 @@ func verifyChart(t *testing.T, c *chart.Chart) {
 
 func verifyDependencies(t *testing.T, c *chart.Chart) {
 	t.Helper()
-	assert.Len(t, c.Metadata.Dependencies, 2, "Expected 2 dependencies, got %d", len(c.Metadata.Dependencies))
+	require.Len(t, c.Metadata.Dependencies, 2, "Expected 2 dependencies, got %d", len(c.Metadata.Dependencies))
 	tests := []*chart.Dependency{
 		{Name: "alpine", Version: "0.1.0", Repository: "https://example.com/charts"},
 		{Name: "mariner", Version: "4.3.2", Repository: "https://example.com/charts"},
@@ -563,7 +558,7 @@ func verifyDependencies(t *testing.T, c *chart.Chart) {
 
 func verifyDependenciesLock(t *testing.T, c *chart.Chart) {
 	t.Helper()
-	assert.Len(t, c.Metadata.Dependencies, 2, "Expected 2 dependencies, got %d", len(c.Metadata.Dependencies))
+	require.Len(t, c.Metadata.Dependencies, 2, "Expected 2 dependencies, got %d", len(c.Metadata.Dependencies))
 	tests := []*chart.Dependency{
 		{Name: "alpine", Version: "0.1.0", Repository: "https://example.com/charts"},
 		{Name: "mariner", Version: "4.3.2", Repository: "https://example.com/charts"},
diff --git a/pkg/downloader/chart_downloader_test.go b/pkg/downloader/chart_downloader_test.go
index 7187bdff1..92d4f024d 100644
--- a/pkg/downloader/chart_downloader_test.go
+++ b/pkg/downloader/chart_downloader_test.go
@@ -82,16 +82,15 @@ func TestResolveChartRef(t *testing.T) {
 	}
 
 	for _, tt := range tests {
-		_, u, err := c.ResolveChartVersion(tt.ref, tt.version)
-		if err != nil {
-			if tt.fail {
-				continue
+		t.Run(tt.name, func(t *testing.T) {
+			_, u, err := c.ResolveChartVersion(tt.ref, tt.version)
+			if err != nil {
+				require.True(t, tt.fail)
+			} else {
+				got := u.String()
+				assert.Equalf(t, tt.expect, got, "%s: expected %s, got %s", tt.name, tt.expect, got)
 			}
-			t.Errorf("%s: failed with error %q", tt.name, err)
-			continue
-		}
-		got := u.String()
-		assert.Equalf(t, tt.expect, got, "%s: expected %s, got %s", tt.name, tt.expect, got)
+		})
 	}
 }
 
@@ -124,35 +123,25 @@ func TestResolveChartOpts(t *testing.T) {
 	snapshotOpts := c.Options
 
 	for _, tt := range tests {
-		// reset chart downloader options for each test case
-		c.Options = snapshotOpts
-
-		expect, err := getter.NewHTTPGetter(tt.expect...)
-		if err != nil {
-			t.Errorf("%s: failed to setup http client: %s", tt.name, err)
-			continue
-		}
-
-		_, u, err := c.ResolveChartVersion(tt.ref, tt.version)
-		if err != nil {
-			t.Errorf("%s: failed with error %s", tt.name, err)
-			continue
-		}
-
-		got, err := getter.NewHTTPGetter(
-			append(
-				c.Options,
-				getter.WithURL(u.String()),
-			)...,
-		)
-		if err != nil {
-			t.Errorf("%s: failed to create http client: %s", tt.name, err)
-			continue
-		}
-
-		if *(got.(*getter.HTTPGetter)) != *(expect.(*getter.HTTPGetter)) {
-			t.Errorf("%s: expected %s, got %s", tt.name, expect, got)
-		}
+		t.Run(tt.name, func(t *testing.T) {
+			// reset chart downloader options for each test case
+			c.Options = snapshotOpts
+
+			expect, err := getter.NewHTTPGetter(tt.expect...)
+			require.NoError(t, err, "failed to setup http client")
+
+			_, u, err := c.ResolveChartVersion(tt.ref, tt.version)
+			require.NoError(t, err, "failed with error")
+
+			got, err := getter.NewHTTPGetter(
+				append(
+					c.Options,
+					getter.WithURL(u.String()),
+				)...,
+			)
+			require.NoError(t, err, "failed to create http client")
+			assert.Equal(t, expect, got)
+		})
 	}
 }
 
diff --git a/pkg/kube/client_test.go b/pkg/kube/client_test.go
index 4d46d2692..405925a30 100644
--- a/pkg/kube/client_test.go
+++ b/pkg/kube/client_test.go
@@ -567,17 +567,16 @@ func TestUpdate(t *testing.T) {
 
 			// Special handling for the rollback test case
 			if name == "rollback after failed upgrade with removed resource" {
-				assert.Empty(t, result.Created, "expected 0 resource created, got %d", len(result.Created))
-				assert.Len(t, result.Updated, 1, "expected 1 resource updated, got %d", len(result.Updated))
-				assert.Empty(t, result.Deleted, "expected 0 resource deleted, got %d", len(result.Deleted))
+				assert.Empty(t, result.Created, "expected 0 resource created")
+				assert.Len(t, result.Updated, 1, "expected 1 resource updated")
+				assert.Empty(t, result.Deleted, "expected 0 resource deleted")
 			} else {
-				assert.Len(t, result.Created, 1, "expected 1 resource created, got %d", len(result.Created))
-				assert.Len(t, result.Updated, 2, "expected 2 resource updated, got %d", len(result.Updated))
-				assert.Len(t, result.Deleted, 1, "expected 1 resource deleted, got %d", len(result.Deleted))
+				assert.Len(t, result.Created, 1, "expected 1 resource created")
+				assert.Len(t, result.Updated, 2, "expected 2 resource updated")
+				assert.Len(t, result.Deleted, 1, "expected 1 resource deleted")
 			}
 
 			if tc.ExpectedError != "" {
-				require.Error(t, err)
 				require.ErrorContains(t, err, tc.ExpectedError)
 			} else {
 				require.NoError(t, err)
@@ -702,11 +701,11 @@ func TestPerform(t *testing.T) {
 			}
 
 			err = perform(infos, fn)
-			assert.Equal(t, tt.err, (err != nil), "expected error: %v", tt.err)
-			if err != nil {
-				require.EqualErrorf(t, err, tt.errMessage, "expected error message: %v, got %v", tt.errMessage, err)
+			if tt.err {
+				require.EqualError(t, err, tt.errMessage)
+			} else {
+				require.NoError(t, err)
 			}
-
 			assert.Len(t, results, tt.count, "expected %d result objects, got %d", tt.count, len(results))
 		})
 	}
@@ -782,7 +781,6 @@ func TestWait(t *testing.T) {
 	require.NoError(t, err)
 	assert.Len(t, result.Created, 3, "expected 3 resource created, got %d", len(result.Created))
 	require.NoErrorf(t, c.Wait(resources, time.Second*30), "expected wait without error")
-
 	assert.GreaterOrEqualf(t, time.Since(*created), time.Second*5, "expected to wait at least 5 seconds before ready status was detected, but got %s", time.Since(*created))
 }
 
diff --git a/pkg/strvals/literal_parser_test.go b/pkg/strvals/literal_parser_test.go
index 6c22a732b..94e0c6050 100644
--- a/pkg/strvals/literal_parser_test.go
+++ b/pkg/strvals/literal_parser_test.go
@@ -16,7 +16,6 @@ limitations under the License.
 package strvals
 
 import (
-	"bytes"
 	"fmt"
 	"strings"
 	"testing"
@@ -279,29 +278,21 @@ func TestParseLiteral(t *testing.T) {
 	}
 
 	for _, tt := range cases {
-		got, err := ParseLiteral(tt.str)
-		if err != nil {
-			if !tt.err {
-				require.NoError(t, err, tt.str)
-			}
-			continue
-		}
-
-		if tt.err {
-			assert.Fail(t, "Expected error. Got nil", tt.str)
-		}
-
-		y1, err := yaml.Marshal(tt.expect)
-		require.NoError(t, err)
+		t.Run(tt.str, func(t *testing.T) {
+			got, err := ParseLiteral(tt.str)
+			if tt.err {
+				require.Error(t, err)
+			} else {
+				require.NoError(t, err)
+				y1, err := yaml.Marshal(tt.expect)
+				require.NoError(t, err)
 
-		y2, err := yaml.Marshal(got)
-		if err != nil {
-			require.NoError(t, err, "Error serializing parsed value")
-		}
+				y2, err := yaml.Marshal(got)
+				require.NoError(t, err, "Error serializing parsed value")
 
-		if !bytes.Equal(y1, y2) {
-			assert.Equal(t, string(y1), string(y2), tt.str)
-		}
+				assert.YAMLEq(t, string(y1), string(y2), tt.str)
+			}
+		})
 	}
 }
 
@@ -386,17 +377,13 @@ func TestParseLiteralInto(t *testing.T) {
 	}
 
 	for _, tt := range tests {
-		if err := ParseLiteralInto(tt.input, tt.got); err != nil {
-			require.NoError(t, err)
-		}
+		require.NoError(t, ParseLiteralInto(tt.input, tt.got))
 		if tt.err {
 			assert.Fail(t, "Expected error. Got nil", tt.input)
 		}
 
 		if tt.input2 != "" {
-			if err := ParseLiteralInto(tt.input2, tt.got); err != nil {
-				require.NoError(t, err)
-			}
+			require.NoError(t, ParseLiteralInto(tt.input2, tt.got))
 			if tt.err {
 				assert.Fail(t, "Expected error. Got nil", tt.input2)
 			}
@@ -406,13 +393,9 @@ func TestParseLiteralInto(t *testing.T) {
 		require.NoError(t, err)
 
 		y2, err := yaml.Marshal(tt.got)
-		if err != nil {
-			require.NoError(t, err, "Error serializing parsed value")
-		}
+		require.NoError(t, err, "Error serializing parsed value")
 
-		if !bytes.Equal(y1, y2) {
-			assert.Equal(t, string(y1), string(y2), tt.input)
-		}
+		assert.YAMLEq(t, string(y1), string(y2), tt.input)
 	}
 }
 
@@ -447,29 +430,23 @@ func TestParseLiteralNestedLevels(t *testing.T) {
 	}
 
 	for _, tt := range tests {
-		got, err := ParseLiteral(tt.str)
-		if err != nil {
+		t.Run(tt.str, func(t *testing.T) {
+			got, err := ParseLiteral(tt.str)
 			if tt.err {
+				require.Error(t, err)
 				if tt.errStr != "" {
 					require.EqualError(t, err, tt.errStr)
 				}
-				continue
-			}
-			require.NoError(t, err, tt.str)
-		}
-
-		if tt.err {
-			assert.Fail(t, "Expected error. Got nil", tt.str)
-		}
-
-		y1, err := yaml.Marshal(tt.expect)
-		require.NoError(t, err)
+			} else {
+				require.NoError(t, err)
+				y1, err := yaml.Marshal(tt.expect)
+				require.NoError(t, err)
 
-		y2, err := yaml.Marshal(got)
-		require.NoError(t, err, "Error serializing parsed value")
+				y2, err := yaml.Marshal(got)
+				require.NoError(t, err, "Error serializing parsed value")
 
-		if !bytes.Equal(y1, y2) {
-			assert.Equal(t, string(y1), string(y2), tt.str)
-		}
+				assert.YAMLEq(t, string(y1), string(y2), tt.str)
+			}
+		})
 	}
 }
diff --git a/pkg/strvals/parser_test.go b/pkg/strvals/parser_test.go
index e68bc4e19..c6c866711 100644
--- a/pkg/strvals/parser_test.go
+++ b/pkg/strvals/parser_test.go
@@ -16,8 +16,8 @@ limitations under the License.
 package strvals
 
 import (
-	"bytes"
 	"fmt"
+	"strconv"
 	"strings"
 	"testing"
 
@@ -383,50 +383,37 @@ func TestParseSet(t *testing.T) {
 	}
 
 	for _, tt := range tests {
-		got, err := Parse(tt.str)
-		if err != nil {
+		t.Run(tt.str, func(t *testing.T) {
+			got, err := Parse(tt.str)
 			if tt.err {
-				continue
-			}
-			require.NoError(t, err, tt.str)
-		}
-		if tt.err {
-			assert.Fail(t, "Expected error. Got nil", tt.str)
-		}
-
-		y1, err := yaml.Marshal(tt.expect)
-		require.NoError(t, err)
-		y2, err := yaml.Marshal(got)
-		if err != nil {
-			require.NoError(t, err, "Error serializing parsed value")
-		}
+				require.Error(t, err)
+			} else {
+				require.NoError(t, err)
+				y1, err := yaml.Marshal(tt.expect)
+				require.NoError(t, err)
+				y2, err := yaml.Marshal(got)
+				if err != nil {
+					require.NoError(t, err, "Error serializing parsed value")
+				}
 
-		if !bytes.Equal(y1, y2) {
-			assert.Equal(t, string(y1), string(y2), tt.str)
-		}
+				assert.YAMLEq(t, string(y1), string(y2), tt.str)
+			}
+		})
 	}
 	for _, tt := range testsString {
-		got, err := ParseString(tt.str)
-		if err != nil {
+		t.Run(tt.str, func(t *testing.T) {
+			got, err := ParseString(tt.str)
 			if tt.err {
-				continue
+				require.Error(t, err)
+			} else {
+				require.NoError(t, err)
+				y1, err := yaml.Marshal(tt.expect)
+				require.NoError(t, err)
+				y2, err := yaml.Marshal(got)
+				require.NoError(t, err, "Error serializing parsed value")
+				assert.YAMLEq(t, string(y1), string(y2))
 			}
-			require.NoError(t, err, tt.str)
-		}
-		if tt.err {
-			assert.Fail(t, "Expected error. Got nil", tt.str)
-		}
-
-		y1, err := yaml.Marshal(tt.expect)
-		require.NoError(t, err)
-		y2, err := yaml.Marshal(got)
-		if err != nil {
-			require.NoError(t, err, "Error serializing parsed value")
-		}
-
-		if !bytes.Equal(y1, y2) {
-			assert.Equal(t, string(y1), string(y2), tt.str)
-		}
+		})
 	}
 }
 
@@ -511,33 +498,26 @@ func TestParseInto(t *testing.T) {
 			err: false,
 		},
 	}
-	for _, tt := range tests {
-		if err := ParseInto(tt.input, tt.got); err != nil {
-			require.NoError(t, err)
-		}
-		if tt.err {
-			assert.Fail(t, "Expected error. Got nil", tt.input)
-		}
-
-		if tt.input2 != "" {
-			if err := ParseInto(tt.input2, tt.got); err != nil {
-				require.NoError(t, err)
-			}
+	for i, tt := range tests {
+		t.Run(strconv.Itoa(i), func(t *testing.T) {
+			require.NoError(t, ParseInto(tt.input, tt.got))
 			if tt.err {
-				assert.Fail(t, "Expected error. Got nil", tt.input2)
+				assert.Fail(t, "Expected error. Got nil", tt.input)
 			}
-		}
 
-		y1, err := yaml.Marshal(tt.expect)
-		require.NoError(t, err)
-		y2, err := yaml.Marshal(tt.got)
-		if err != nil {
-			require.NoError(t, err, "Error serializing parsed value")
-		}
+			if tt.input2 != "" {
+				require.NoError(t, ParseInto(tt.input2, tt.got))
+				if tt.err {
+					assert.Fail(t, "Expected error. Got nil", tt.input2)
+				}
+			}
 
-		if !bytes.Equal(y1, y2) {
-			assert.Equal(t, string(y1), string(y2), tt.input)
-		}
+			y1, err := yaml.Marshal(tt.expect)
+			require.NoError(t, err)
+			y2, err := yaml.Marshal(tt.got)
+			require.NoError(t, err, "Error serializing parsed value")
+			assert.YAMLEq(t, string(y1), string(y2), tt.input)
+		})
 	}
 }
 
@@ -564,13 +544,8 @@ func TestParseIntoString(t *testing.T) {
 	y1, err := yaml.Marshal(expect)
 	require.NoError(t, err)
 	y2, err := yaml.Marshal(got)
-	if err != nil {
-		require.NoError(t, err, "Error serializing parsed value")
-	}
-
-	if !bytes.Equal(y1, y2) {
-		assert.Equal(t, string(y1), string(y2), input)
-	}
+	require.NoError(t, err, "Error serializing parsed value")
+	assert.YAMLEq(t, string(y1), string(y2), input)
 }
 
 func TestParseJSON(t *testing.T) {
@@ -650,27 +625,19 @@ func TestParseJSON(t *testing.T) {
 		},
 	}
 	for _, tt := range tests {
-		if err := ParseJSON(tt.input, tt.got); err != nil {
+		t.Run(tt.input, func(t *testing.T) {
+			err := ParseJSON(tt.input, tt.got)
 			if tt.err {
-				continue
+				require.Error(t, err)
+			} else {
+				require.NoError(t, err)
+				y1, err := yaml.Marshal(tt.expect)
+				require.NoError(t, err, "Error serializing expected value")
+				y2, err := yaml.Marshal(tt.got)
+				require.NoError(t, err, "Error serializing parsed value")
+				assert.YAMLEq(t, string(y1), string(y2))
 			}
-			require.NoError(t, err, tt.input)
-		}
-		if tt.err {
-			require.Fail(t, "Expected error. Got nil", tt.input)
-		}
-		y1, err := yaml.Marshal(tt.expect)
-		if err != nil {
-			require.NoError(t, err, "Error serializing expected value")
-		}
-		y2, err := yaml.Marshal(tt.got)
-		if err != nil {
-			require.NoError(t, err, "Error serializing parsed value")
-		}
-
-		if !bytes.Equal(y1, y2) {
-			assert.Equal(t, string(y1), string(y2), tt.input)
-		}
+		})
 	}
 }
 
@@ -693,14 +660,10 @@ func TestParseFile(t *testing.T) {
 
 	y1, err := yaml.Marshal(expect)
 	require.NoError(t, err)
-	y2, err := yaml.Marshal(got)
-	if err != nil {
-		require.NoError(t, err, "Error serializing parsed value")
-	}
 
-	if !bytes.Equal(y1, y2) {
-		assert.Equal(t, string(y1), string(y2), input)
-	}
+	y2, err := yaml.Marshal(got)
+	require.NoError(t, err, "Error serializing parsed value")
+	assert.YAMLEq(t, string(y1), string(y2), input)
 }
 
 func TestParseIntoFile(t *testing.T) {
@@ -725,13 +688,9 @@ func TestParseIntoFile(t *testing.T) {
 	y1, err := yaml.Marshal(expect)
 	require.NoError(t, err)
 	y2, err := yaml.Marshal(got)
-	if err != nil {
-		require.NoError(t, err, "Error serializing parsed value")
-	}
+	require.NoError(t, err, "Error serializing parsed value")
 
-	if !bytes.Equal(y1, y2) {
-		assert.Equal(t, string(y1), string(y2), input)
-	}
+	assert.YAMLEq(t, string(y1), string(y2), input)
 }
 
 func TestToYAML(t *testing.T) {
@@ -775,27 +734,23 @@ func TestParseSetNestedLevels(t *testing.T) {
 	}
 
 	for _, tt := range tests {
-		got, err := Parse(tt.str)
-		if err != nil {
+		t.Run(tt.str, func(t *testing.T) {
+			got, err := Parse(tt.str)
 			if tt.err {
+				require.Error(t, err)
 				if tt.errStr != "" {
 					require.EqualError(t, err, tt.errStr)
 				}
-				continue
-			}
-			require.NoError(t, err, tt.str)
-		}
-		if tt.err {
-			assert.Fail(t, "Expected error. Got nil", tt.str)
-		}
+			} else {
+				require.NoError(t, err)
 
-		y1, err := yaml.Marshal(tt.expect)
-		require.NoError(t, err)
-		y2, err := yaml.Marshal(got)
-		require.NoError(t, err, "Error serializing parsed value")
+				y1, err := yaml.Marshal(tt.expect)
+				require.NoError(t, err)
 
-		if !bytes.Equal(y1, y2) {
-			assert.Equal(t, string(y1), string(y2), tt.str)
-		}
+				y2, err := yaml.Marshal(got)
+				require.NoError(t, err, "Error serializing parsed value")
+				assert.YAMLEq(t, string(y1), string(y2), tt.str)
+			}
+		})
 	}
 }

From a27f3a062027d8b459eed2186076fb9384b82f38 Mon Sep 17 00:00:00 2001
From: Matthieu MOREL <matthieu.morel35@gmail.com>
Date: Fri, 24 Jul 2026 18:19:56 +0200
Subject: [PATCH 08/13] Potential fix for pull request finding

Co-authored-by: Copilot Autofix powered by AI <175728472+Copilot@users.noreply.github.com>
Signed-off-by: Matthieu MOREL <matthieu.morel35@gmail.com>
---
 pkg/cmd/rollback_test.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pkg/cmd/rollback_test.go b/pkg/cmd/rollback_test.go
index aa60043aa..e4dbf9779 100644
--- a/pkg/cmd/rollback_test.go
+++ b/pkg/cmd/rollback_test.go
@@ -160,5 +160,5 @@ func TestRollbackWithLabels(t *testing.T) {
 
 	updatedRel, err := releaserToV1Release(updatedReli)
 	require.NoError(t, err)
-	assert.Equalf(t, updatedRel.Labels, labels1, "Expected {%v}, got {%v}", labels1, updatedRel.Labels)
+assert.Equalf(t, labels1, updatedRel.Labels, "Expected {%v}, got {%v}", labels1, updatedRel.Labels)
 }

From b59dfd39015311d94c04541ec5b91959c6b4b6d3 Mon Sep 17 00:00:00 2001
From: Matthieu MOREL <matthieu.morel35@gmail.com>
Date: Fri, 24 Jul 2026 18:44:53 +0200
Subject: [PATCH 09/13] Update rollback_test.go

Signed-off-by: Matthieu MOREL <matthieu.morel35@gmail.com>
---
 pkg/cmd/rollback_test.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pkg/cmd/rollback_test.go b/pkg/cmd/rollback_test.go
index e4dbf9779..21d6a65af 100644
--- a/pkg/cmd/rollback_test.go
+++ b/pkg/cmd/rollback_test.go
@@ -160,5 +160,5 @@ func TestRollbackWithLabels(t *testing.T) {
 
 	updatedRel, err := releaserToV1Release(updatedReli)
 	require.NoError(t, err)
-assert.Equalf(t, labels1, updatedRel.Labels, "Expected {%v}, got {%v}", labels1, updatedRel.Labels)
+	assert.Equalf(t, labels1, updatedRel.Labels, "Expected {%v}, got {%v}", labels1, updatedRel.Labels)
 }

From bfca0688b1a44b1cf7ae37ac5f64792a8dffe7f1 Mon Sep 17 00:00:00 2001
From: Matthieu MOREL <matthieu.morel35@gmail.com>
Date: Fri, 24 Jul 2026 18:45:58 +0200
Subject: [PATCH 10/13] Update show_test.go

Signed-off-by: Matthieu MOREL <matthieu.morel35@gmail.com>
---
 pkg/cmd/show_test.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pkg/cmd/show_test.go b/pkg/cmd/show_test.go
index b7ad94d94..61c4f8b10 100644
--- a/pkg/cmd/show_test.go
+++ b/pkg/cmd/show_test.go
@@ -78,7 +78,7 @@ func TestShowPreReleaseChart(t *testing.T) {
 			)
 			_, _, err := executeActionCommand(cmd)
 			if tt.fail {
-				assert.ErrorContains(t, err, tt.expectedErr, "%q expected error: %s, got: %s", tt.name, tt.expectedErr, err.Error())
+				assert.ErrorContains(t, err, tt.expectedErr)
 			} else {
 				assert.NoError(t, err)
 			}

From 532eabf88afa2b119f90ef82d1bf309923cbbb78 Mon Sep 17 00:00:00 2001
From: Matthieu MOREL <matthieu.morel35@gmail.com>
Date: Fri, 24 Jul 2026 18:47:43 +0200
Subject: [PATCH 11/13] Update chartrepo_test.go

Signed-off-by: Matthieu MOREL <matthieu.morel35@gmail.com>
---
 pkg/repo/v1/chartrepo_test.go | 1 +
 1 file changed, 1 insertion(+)

diff --git a/pkg/repo/v1/chartrepo_test.go b/pkg/repo/v1/chartrepo_test.go
index 54275e28d..f0e5839ac 100644
--- a/pkg/repo/v1/chartrepo_test.go
+++ b/pkg/repo/v1/chartrepo_test.go
@@ -175,6 +175,7 @@ func TestFindChartInAuthAndTLSAndPassRepoURL(t *testing.T) {
 	// versions of Darwin do not. As there are people developing Helm using both old and new versions of Darwin we test
 	// for both messages.
 	if runtime.GOOS == "darwin" {
+		require.Error(t, err)
 		assert.True(t, strings.Contains(err.Error(), "x509: “Acme Co” certificate is not trusted") || strings.Contains(err.Error(), "x509: certificate signed by unknown authority"), "Expected TLS error for function  FindChartInAuthAndTLSAndPassRepoURL not found, but got a different error (%v)", err)
 	} else {
 		assert.ErrorContainsf(t, err, "x509: certificate signed by unknown authority", "Expected TLS error for function  FindChartInAuthAndTLSAndPassRepoURL not found, but got a different error")

From 61d99a8bdbc90219c474c96e11790ab6a90cde61 Mon Sep 17 00:00:00 2001
From: Matthieu MOREL <matthieu.morel35@gmail.com>
Date: Fri, 24 Jul 2026 18:53:45 +0200
Subject: [PATCH 12/13] Update labels_test.go

Signed-off-by: Matthieu MOREL <matthieu.morel35@gmail.com>
---
 pkg/storage/driver/labels_test.go | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/pkg/storage/driver/labels_test.go b/pkg/storage/driver/labels_test.go
index 481b8c467..34f01be79 100644
--- a/pkg/storage/driver/labels_test.go
+++ b/pkg/storage/driver/labels_test.go
@@ -45,7 +45,11 @@ func TestLabelsMatch(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.desc, func(t *testing.T) {
-			require.False(t, !tt.set1.match(tt.set2) && tt.expect)
+			if tt.expect {
+				require.True(t, tt.set1.match(tt.set2))
+			} else {
+				require.False(t, tt.set1.match(tt.set2))
+			}
 		})
 	}
 }

From 622f16b37fdb1f1915aece9436165dc53c26b3c5 Mon Sep 17 00:00:00 2001
From: Matthieu MOREL <matthieu.morel35@gmail.com>
Date: Fri, 24 Jul 2026 19:06:05 +0200
Subject: [PATCH 13/13] Update resource_test.go

Signed-off-by: Matthieu MOREL <matthieu.morel35@gmail.com>
---
 pkg/kube/resource_test.go | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/pkg/kube/resource_test.go b/pkg/kube/resource_test.go
index 18501d4e8..8bc644833 100644
--- a/pkg/kube/resource_test.go
+++ b/pkg/kube/resource_test.go
@@ -20,6 +20,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 	"k8s.io/apimachinery/pkg/api/meta"
 	"k8s.io/apimachinery/pkg/runtime/schema"
 	"k8s.io/cli-runtime/pkg/resource"
@@ -41,11 +42,11 @@ func TestResourceList(t *testing.T) {
 	assert.Equal(t, "pod", r1.Get(info("bar")).Mapping.Resource.Resource, "expected get pod")
 
 	diff := r1.Difference(r2)
-	assert.Len(t, diff, 1, "expected 1 result")
+	require.Len(t, diff, 1, "expected 1 result")
 	assert.Contains(t, diff, info("foo"), "expected diff to return foo")
 
 	inter := r1.Intersect(r2)
-	assert.Len(t, inter, 1, "expected 1 result")
+	require.Len(t, inter, 1, "expected 1 result")
 	assert.Contains(t, inter, info("bar"), "expected intersect to return bar")
 }