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)
 	}
 }