diff --git a/pkg/action/action_test.go b/pkg/action/action_test.go
index 880a9930b..056c539a5 100644
--- a/pkg/action/action_test.go
+++ b/pkg/action/action_test.go
@@ -58,9 +58,7 @@ func actionConfigFixtureWithDummyResources(t *testing.T, dummyResources kube.Res
 	slog.SetDefault(logger)
 
 	registryClient, err := registry.NewClient()
-	if err != nil {
-		t.Fatal(err)
-	}
+	require.NoError(t, err)
 
 	return &Configuration{
 		Releases:       storage.Init(driver.NewMemory()),
@@ -371,16 +369,10 @@ func TestGetVersionSet(t *testing.T) {
 	client := fakeclientset.NewClientset()
 
 	vs, err := GetVersionSet(client.Discovery())
-	if err != nil {
-		t.Error(err)
-	}
+	require.NoError(t, err)
 
-	if !vs.Has("v1") {
-		t.Error("Expected supported versions to at least include v1.")
-	}
-	if vs.Has("nosuchversion/v1") {
-		t.Error("Non-existent version is reported found.")
-	}
+	assert.True(t, vs.Has("v1"), "Expected supported versions to at least include v1.")
+	assert.False(t, vs.Has("nosuchversion/v1"), "Non-existent version is reported found.")
 }
 
 // Mock PostRenderer for testing
@@ -2031,9 +2023,7 @@ spec:
 	mockPR := &mockPostRenderer{
 		transform: func(content string) string {
 			count := strings.Count(content, "kind: ServiceAccount")
-			if count > 1 {
-				t.Errorf("post-renderer received %d ServiceAccount resources in a single stream, expected at most 1", count)
-			}
+			assert.LessOrEqualf(t, count, 1, "post-renderer received %d ServiceAccount resources in a single stream, expected at most 1", count)
 			return content
 		},
 	}
diff --git a/pkg/action/dependency_test.go b/pkg/action/dependency_test.go
index 25664b98c..adbe311d6 100644
--- a/pkg/action/dependency_test.go
+++ b/pkg/action/dependency_test.go
@@ -57,9 +57,7 @@ func TestList(t *testing.T) {
 		},
 	} {
 		buf := bytes.Buffer{}
-		if err := NewDependency().List(tcase.chart, &buf); err != nil {
-			t.Fatal(err)
-		}
+		require.NoError(t, NewDependency().List(tcase.chart, &buf))
 		test.AssertGoldenString(t, buf.String(), tcase.golden)
 	}
 }
@@ -71,22 +69,16 @@ func TestDependencyStatus_Dashes(t *testing.T) {
 	dir := t.TempDir()
 
 	chartpath := filepath.Join(dir, "charts")
-	if err := os.MkdirAll(chartpath, 0o700); err != nil {
-		t.Fatal(err)
-	}
+	require.NoError(t, os.MkdirAll(chartpath, 0o700))
 
 	// Add some fake charts
 	first := buildChart(withName("first-chart"))
 	_, err := chartutil.Save(first, chartpath)
-	if err != nil {
-		t.Fatal(err)
-	}
+	require.NoError(t, err)
 
 	second := buildChart(withName("first-chart-second-chart"))
 	_, err = chartutil.Save(second, chartpath)
-	if err != nil {
-		t.Fatal(err)
-	}
+	require.NoError(t, err)
 
 	dep := &chart.Dependency{
 		Name:    "first-chart",
@@ -95,9 +87,7 @@ func TestDependencyStatus_Dashes(t *testing.T) {
 
 	// Now try to get the deps
 	stat := NewDependency().dependencyStatus(dir, dep, first)
-	if stat != "ok" {
-		t.Errorf("Unexpected status: %q", stat)
-	}
+	assert.Equal(t, "ok", stat, "Unexpected status: %q", stat)
 }
 
 func TestStatArchiveForStatus(t *testing.T) {
@@ -105,9 +95,7 @@ func TestStatArchiveForStatus(t *testing.T) {
 	dir := t.TempDir()
 
 	chartpath := filepath.Join(dir, "charts")
-	if err := os.MkdirAll(chartpath, 0o700); err != nil {
-		t.Fatal(err)
-	}
+	require.NoError(t, os.MkdirAll(chartpath, 0o700))
 
 	// unsaved chart
 	lilith := buildChart(withName("lilith"))
diff --git a/pkg/action/list_test.go b/pkg/action/list_test.go
index e7c2770d7..1c849028d 100644
--- a/pkg/action/list_test.go
+++ b/pkg/action/list_test.go
@@ -44,9 +44,7 @@ func TestListStates(t *testing.T) {
 		"unknown":             ListUnknown,
 		"totally made up key": ListUnknown,
 	} {
-		if expect != expect.FromName(input) {
-			t.Errorf("Expected %d for %s", expect, input)
-		}
+		assert.Equal(t, expect.FromName(input), expect, "Expected %d for %s", expect, input)
 		// This is a cheap way to verify that ListAll actually allows everything but Unknown
 		if got := expect.FromName(input); got != ListUnknown && got&ListAll == 0 {
 			t.Errorf("Expected %s to match the ListAll filter", input)
@@ -54,12 +52,10 @@ func TestListStates(t *testing.T) {
 	}
 
 	filter := ListDeployed | ListPendingRollback
-	if status := filter.FromName("deployed"); filter&status == 0 {
-		t.Errorf("Expected %d to match mask %d", status, filter)
-	}
-	if status := filter.FromName("failed"); filter&status != 0 {
-		t.Errorf("Expected %d to fail to match mask %d", status, filter)
-	}
+	status := filter.FromName("deployed")
+	assert.NotEqualf(t, ListStates(0), filter&status, "Expected %d to match mask %d", status, filter)
+	status = filter.FromName("failed")
+	assert.Equalf(t, ListStates(0), filter&status, "Expected %d to fail to match mask %d", status, filter)
 }
 
 func TestList_Empty(t *testing.T) {
@@ -202,8 +198,7 @@ func TestList_StateMask(t *testing.T) {
 	}
 
 	one.SetStatus(common.StatusUninstalled, "uninstalled")
-	err = lister.cfg.Releases.Update(one)
-	req.NoError(err)
+	req.NoError(lister.cfg.Releases.Update(one))
 
 	res, err := lister.Run()
 	req.NoError(err)
@@ -277,9 +272,7 @@ func makeMeSomeReleasesWithStaleFailure(t *testing.T, store *storage.Storage) {
 	five.Version = 1
 
 	for _, rel := range []*release.Release{one, two, three, four, five} {
-		if err := store.Create(rel); err != nil {
-			t.Fatal(err)
-		}
+		require.NoError(t, store.Create(rel))
 	}
 
 	all, err := store.ListReleases()
@@ -328,9 +321,7 @@ func makeMeSomeReleases(t *testing.T, store *storage.Storage) {
 	three.Version = 3
 
 	for _, rel := range []*release.Release{one, two, three} {
-		if err := store.Create(rel); err != nil {
-			t.Fatal(err)
-		}
+		require.NoError(t, store.Create(rel))
 	}
 
 	all, err := store.ListReleases()
@@ -389,9 +380,7 @@ func TestSelectorList(t *testing.T) {
 
 	lister := newListFixture(t)
 	for _, rel := range []*release.Release{r1, r2, r3} {
-		if err := lister.cfg.Releases.Create(rel); err != nil {
-			t.Fatal(err)
-		}
+		require.NoError(t, lister.cfg.Releases.Create(rel))
 	}
 
 	t.Run("should fail selector parsing", func(t *testing.T) {
diff --git a/pkg/chart/v2/lint/support/message_test.go b/pkg/chart/v2/lint/support/message_test.go
index ce5b5e42e..dfbc65844 100644
--- a/pkg/chart/v2/lint/support/message_test.go
+++ b/pkg/chart/v2/lint/support/message_test.go
@@ -19,6 +19,9 @@ package support
 import (
 	"errors"
 	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 var errLint = errors.New("lint failed")
@@ -47,33 +50,19 @@ func TestRunLinterRule(t *testing.T) {
 	linter := Linter{}
 	for _, test := range tests {
 		isValid := linter.RunLinterRule(test.Severity, "chart", test.LintError)
-		if len(linter.Messages) != test.ExpectedMessages {
-			t.Errorf("RunLinterRule(%d, \"chart\", %v), linter.Messages should now have %d message, we got %d", test.Severity, test.LintError, test.ExpectedMessages, len(linter.Messages))
-		}
-
-		if linter.HighestSeverity != test.ExpectedHighestSeverity {
-			t.Errorf("RunLinterRule(%d, \"chart\", %v), linter.HighestSeverity should be %d, we got %d", test.Severity, test.LintError, test.ExpectedHighestSeverity, linter.HighestSeverity)
-		}
-
-		if isValid != test.ExpectedReturn {
-			t.Errorf("RunLinterRule(%d, \"chart\", %v), should have returned %t but returned %t", test.Severity, test.LintError, test.ExpectedReturn, isValid)
-		}
+		assert.Lenf(t, linter.Messages, test.ExpectedMessages, "RunLinterRule(%d, \"chart\", %v), linter.Messages should now have %d message, we got %d", test.Severity, test.LintError, test.ExpectedMessages, len(linter.Messages))
+		assert.Equalf(t, linter.HighestSeverity, test.ExpectedHighestSeverity, "RunLinterRule(%d, \"chart\", %v), linter.HighestSeverity should be %d, we got %d", test.Severity, test.LintError, test.ExpectedHighestSeverity, linter.HighestSeverity)
+		assert.Equalf(t, isValid, test.ExpectedReturn, "RunLinterRule(%d, \"chart\", %v), should have returned %t but returned %t", test.Severity, test.LintError, test.ExpectedReturn, isValid)
 	}
 }
 
 func TestMessage(t *testing.T) {
 	m := Message{ErrorSev, "Chart.yaml", errors.New("Foo")}
-	if m.Error() != "[ERROR] Chart.yaml: Foo" {
-		t.Errorf("Unexpected output: %s", m.Error())
-	}
+	require.EqualErrorf(t, m, "[ERROR] Chart.yaml: Foo", "Unexpected output: %s", m.Error())
 
 	m = Message{WarningSev, "templates/", errors.New("Bar")}
-	if m.Error() != "[WARNING] templates/: Bar" {
-		t.Errorf("Unexpected output: %s", m.Error())
-	}
+	require.EqualErrorf(t, m, "[WARNING] templates/: Bar", "Unexpected output: %s", m.Error())
 
 	m = Message{InfoSev, "templates/rc.yaml", errors.New("FooBar")}
-	if m.Error() != "[INFO] templates/rc.yaml: FooBar" {
-		t.Errorf("Unexpected output: %s", m.Error())
-	}
+	assert.EqualErrorf(t, m, "[INFO] templates/rc.yaml: FooBar", "Unexpected output: %s", m.Error())
 }
diff --git a/pkg/cmd/history_test.go b/pkg/cmd/history_test.go
index 2bace98e0..cd8e353e7 100644
--- a/pkg/cmd/history_test.go
+++ b/pkg/cmd/history_test.go
@@ -385,16 +385,16 @@ func TestReleaseInfoUnmarshalJSON(t *testing.T) {
 			err := json.Unmarshal([]byte(tt.input), &info)
 			if tt.wantErr {
 				assert.Error(t, err)
-				return
+			} else {
+				require.NoError(t, err)
+				assert.Equal(t, tt.expected.Revision, info.Revision)
+				assert.Equal(t, tt.expected.Updated.Unix(), info.Updated.Unix())
+				assert.Equal(t, tt.expected.Status, info.Status)
+				assert.Equal(t, tt.expected.Chart, info.Chart)
+				assert.Equal(t, tt.expected.AppVersion, info.AppVersion)
+				assert.Equal(t, tt.expected.RollbackRevision, info.RollbackRevision)
+				assert.Equal(t, tt.expected.Description, info.Description)
 			}
-			require.NoError(t, err)
-			assert.Equal(t, tt.expected.Revision, info.Revision)
-			assert.Equal(t, tt.expected.Updated.Unix(), info.Updated.Unix())
-			assert.Equal(t, tt.expected.Status, info.Status)
-			assert.Equal(t, tt.expected.Chart, info.Chart)
-			assert.Equal(t, tt.expected.AppVersion, info.AppVersion)
-			assert.Equal(t, tt.expected.RollbackRevision, info.RollbackRevision)
-			assert.Equal(t, tt.expected.Description, info.Description)
 		})
 	}
 }
@@ -415,9 +415,7 @@ func TestReleaseInfoRoundTrip(t *testing.T) {
 	require.NoError(t, err)
 
 	var decoded releaseInfo
-	err = json.Unmarshal(data, &decoded)
-	require.NoError(t, err)
-
+	require.NoError(t, json.Unmarshal(data, &decoded))
 	assert.Equal(t, original.Revision, decoded.Revision)
 	assert.Equal(t, original.Updated.Unix(), decoded.Updated.Unix())
 	assert.Equal(t, original.Status, decoded.Status)
@@ -433,11 +431,10 @@ func TestReleaseInfoEmptyStringRoundTrip(t *testing.T) {
 	input := `{"revision":1,"updated":"","status":"deployed","chart":"mychart-1.0.0","app_version":"1.0.0","description":"Test"}`
 
 	var info releaseInfo
-	err := json.Unmarshal([]byte(input), &info)
-	require.NoError(t, err)
+	require.NoError(t, json.Unmarshal([]byte(input), &info))
 
 	// Verify time field is zero value
-	assert.True(t, info.Updated.IsZero())
+	assert.Zero(t, info.Updated)
 	assert.Equal(t, 1, info.Revision)
 	assert.Equal(t, "deployed", info.Status)
 
@@ -446,8 +443,7 @@ func TestReleaseInfoEmptyStringRoundTrip(t *testing.T) {
 	require.NoError(t, err)
 
 	var result map[string]any
-	err = json.Unmarshal(data, &result)
-	require.NoError(t, err)
+	require.NoError(t, json.Unmarshal(data, &result))
 
 	// Zero time value should be omitted
 	assert.NotContains(t, result, "updated")
diff --git a/pkg/cmd/require/args_test.go b/pkg/cmd/require/args_test.go
index 89403140e..5d3a9f003 100644
--- a/pkg/cmd/require/args_test.go
+++ b/pkg/cmd/require/args_test.go
@@ -18,10 +18,10 @@ package require
 import (
 	"io"
 	"strconv"
-	"strings"
 	"testing"
 
 	"github.com/spf13/cobra"
+	"github.com/stretchr/testify/require"
 )
 
 func TestArgs(t *testing.T) {
@@ -77,16 +77,10 @@ func runTestCases(t *testing.T, testCases []testCase) {
 
 			err := cmd.Execute()
 			if tc.wantError == "" {
-				if err != nil {
-					t.Fatalf("unexpected error, got '%v'", err)
-				}
-				return
-			}
-			if !strings.Contains(err.Error(), tc.wantError) {
-				t.Fatalf("unexpected error \n\nWANT:\n%q\n\nGOT:\n%q\n", tc.wantError, err)
-			}
-			if !strings.Contains(err.Error(), "Usage:") {
-				t.Fatalf("unexpected error: want Usage string\n\nGOT:\n%q\n", err)
+				require.NoError(t, err)
+			} else {
+				require.ErrorContains(t, err, tc.wantError)
+				require.ErrorContains(t, err, "Usage:")
 			}
 		})
 	}
diff --git a/pkg/cmd/rollback_test.go b/pkg/cmd/rollback_test.go
index 116e158fd..ff7f314c9 100644
--- a/pkg/cmd/rollback_test.go
+++ b/pkg/cmd/rollback_test.go
@@ -21,6 +21,9 @@ import (
 	"reflect"
 	"testing"
 
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
 	chart "helm.sh/helm/v4/pkg/chart/v2"
 	"helm.sh/helm/v4/pkg/release/common"
 	release "helm.sh/helm/v4/pkg/release/v1"
@@ -148,24 +151,15 @@ func TestRollbackWithLabels(t *testing.T) {
 	}
 	storage := storageFixture()
 	for _, rel := range rels {
-		if err := storage.Create(rel); err != nil {
-			t.Fatal(err)
-		}
+		require.NoError(t, storage.Create(rel))
 	}
 	_, _, err := executeActionCommandC(storage, fmt.Sprintf("rollback %s 1", releaseName))
-	if err != nil {
-		t.Errorf("unexpected error, got '%v'", err)
-	}
+	require.NoError(t, err)
+
 	updatedReli, err := storage.Get(releaseName, 3)
-	if err != nil {
-		t.Errorf("unexpected error, got '%v'", err)
-	}
-	updatedRel, err := releaserToV1Release(updatedReli)
-	if err != nil {
-		t.Errorf("unexpected error, got '%v'", err)
-	}
+	require.NoError(t, err)
 
-	if !reflect.DeepEqual(updatedRel.Labels, labels1) {
-		t.Errorf("Expected {%v}, got {%v}", labels1, updatedRel.Labels)
-	}
+	updatedRel, err := releaserToV1Release(updatedReli)
+	require.NoError(t, err)
+	assert.Truef(t, reflect.DeepEqual(updatedRel.Labels, labels1), "Expected {%v}, got {%v}", labels1, updatedRel.Labels)
 }
diff --git a/pkg/cmd/root_test.go b/pkg/cmd/root_test.go
index 316e6bd2e..b07bdbbf6 100644
--- a/pkg/cmd/root_test.go
+++ b/pkg/cmd/root_test.go
@@ -23,6 +23,9 @@ import (
 	"path/filepath"
 	"testing"
 
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
 	"helm.sh/helm/v4/internal/test/ensure"
 	"helm.sh/helm/v4/pkg/action"
 	"helm.sh/helm/v4/pkg/helmpath"
@@ -86,9 +89,8 @@ func TestRootCmd(t *testing.T) {
 				t.Setenv(k, v)
 			}
 
-			if _, _, err := executeActionCommand(tt.args); err != nil {
-				t.Fatalf("unexpected error: %s", err)
-			}
+			_, _, err := executeActionCommand(tt.args)
+			require.NoError(t, err)
 
 			// NOTE(bacongobbler): we need to check here after calling ensure.HelmHome so we
 			// load the proper paths after XDG_*_HOME is set
@@ -104,15 +106,9 @@ func TestRootCmd(t *testing.T) {
 				tt.dataPath = filepath.Join(os.Getenv(xdg.DataHomeEnvVar), "helm")
 			}
 
-			if helmpath.CachePath() != tt.cachePath {
-				t.Errorf("expected cache path %q, got %q", tt.cachePath, helmpath.CachePath())
-			}
-			if helmpath.ConfigPath() != tt.configPath {
-				t.Errorf("expected config path %q, got %q", tt.configPath, helmpath.ConfigPath())
-			}
-			if helmpath.DataPath() != tt.dataPath {
-				t.Errorf("expected data path %q, got %q", tt.dataPath, helmpath.DataPath())
-			}
+			assert.Equal(t, tt.cachePath, helmpath.CachePath(), "expected cache path %q, got %q", tt.cachePath, helmpath.CachePath())
+			assert.Equal(t, tt.configPath, helmpath.ConfigPath(), "expected config path %q, got %q", tt.configPath, helmpath.ConfigPath())
+			assert.Equal(t, tt.dataPath, helmpath.DataPath(), "expected data path %q, got %q", tt.dataPath, helmpath.DataPath())
 		})
 	}
 }
@@ -120,9 +116,7 @@ func TestRootCmd(t *testing.T) {
 func TestUnknownSubCmd(t *testing.T) {
 	_, _, err := executeActionCommand("foobar")
 
-	if err == nil || err.Error() != `unknown command "foobar" for "helm"` {
-		t.Errorf("Expect unknown command error, got %q", err)
-	}
+	assert.EqualErrorf(t, err, `unknown command "foobar" for "helm"`, "Expect unknown command error")
 }
 
 // Need the release of Cobra following 1.0 to be able to disable
@@ -138,14 +132,10 @@ func TestRootCmdLogger(t *testing.T) {
 	buf := new(bytes.Buffer)
 	actionConfig := action.NewConfiguration()
 	_, err := newRootCmdWithConfig(actionConfig, buf, args, SetupLogging)
-	if err != nil {
-		t.Errorf("expected no error, got: '%v'", err)
-	}
+	require.NoError(t, err)
 
 	l1 := actionConfig.Logger()
 	l2 := slog.Default()
 
-	if l1.Handler() != l2.Handler() {
-		t.Error("expected actionConfig logger to be the slog default logger")
-	}
+	assert.Equal(t, l2.Handler(), l1.Handler(), "expected actionConfig logger to be the slog default logger")
 }
diff --git a/pkg/cmd/search_hub_test.go b/pkg/cmd/search_hub_test.go
index 98bf052f2..7b00cc295 100644
--- a/pkg/cmd/search_hub_test.go
+++ b/pkg/cmd/search_hub_test.go
@@ -21,6 +21,9 @@ import (
 	"net/http"
 	"net/http/httptest"
 	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestSearchHubCmd(t *testing.T) {
@@ -42,9 +45,7 @@ func TestSearchHubCmd(t *testing.T) {
 	testcmd := "search hub --endpoint " + ts.URL + " maria"
 	storage := storageFixture()
 	_, out, err := executeActionCommandC(storage, testcmd)
-	if err != nil {
-		t.Errorf("unexpected error, %s", err)
-	}
+	require.NoError(t, err)
 	if out != expected {
 		t.Error("expected and actual output did not match")
 		t.Log(out)
@@ -71,9 +72,7 @@ func TestSearchHubListRepoCmd(t *testing.T) {
 	testcmd := "search hub --list-repo-url --endpoint " + ts.URL + " maria"
 	storage := storageFixture()
 	_, out, err := executeActionCommandC(storage, testcmd)
-	if err != nil {
-		t.Errorf("unexpected error, %s", err)
-	}
+	require.NoError(t, err)
 	if out != expected {
 		t.Error("expected and actual output did not match")
 		t.Log(out)
@@ -165,21 +164,14 @@ func TestSearchHubCmd_FailOnNoResponseTests(t *testing.T) {
 
 			_, out, err := executeActionCommandC(storage, tt.cmd)
 			if tt.wantErr {
-				if err == nil {
-					t.Error("expected error due to no record in response, got nil")
-				}
+				require.Error(t, err, "expected error due to no record in response, got nil")
 			} else {
-				if err != nil {
-					t.Errorf("unexpected error, got %q", err)
-				}
+				require.NoError(t, err)
 			}
 
-			if out != tt.expected {
-				t.Errorf("expected and actual output did not match\n"+
-					"expected: %q\n"+
-					"actual  : %q",
-					tt.expected, out)
-			}
+			assert.Equal(t, tt.expected, out, "expected and actual output did not match\n"+
+				"expected: %q\n"+
+				"actual  : %q", tt.expected, out)
 		})
 	}
 }
diff --git a/pkg/engine/files_test.go b/pkg/engine/files_test.go
index b4318a597..6ff251aad 100644
--- a/pkg/engine/files_test.go
+++ b/pkg/engine/files_test.go
@@ -44,17 +44,13 @@ func getTestFiles() files {
 
 func TestNewFiles(t *testing.T) {
 	files := getTestFiles()
-	if len(files) != len(cases) {
-		t.Errorf("Expected len() = %d, got %d", len(cases), len(files))
-	}
+	assert.Len(t, files, len(cases), "Expected len() = %d, got %d", len(cases), len(files))
 
 	for i, f := range cases {
-		if got := string(files.GetBytes(f.path)); got != f.data {
-			t.Errorf("%d: expected %q, got %q", i, f.data, got)
-		}
-		if got := files.Get(f.path); got != f.data {
-			t.Errorf("%d: expected %q, got %q", i, f.data, got)
-		}
+		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)
 	}
 }
 
diff --git a/pkg/engine/funcs_test.go b/pkg/engine/funcs_test.go
index bc541339b..beb87b429 100644
--- a/pkg/engine/funcs_test.go
+++ b/pkg/engine/funcs_test.go
@@ -134,8 +134,7 @@ keyInElement1 = "valueInElement1"`,
 
 	for _, tt := range tests {
 		var b strings.Builder
-		err := template.Must(template.New("test").Funcs(funcMap()).Parse(tt.tpl)).Execute(&b, tt.vars)
-		require.NoError(t, err)
+		require.NoError(t, template.Must(template.New("test").Funcs(funcMap()).Parse(tt.tpl)).Execute(&b, tt.vars))
 		assert.Equal(t, tt.expect, b.String(), tt.tpl)
 	}
 
@@ -360,8 +359,7 @@ func TestDurationHelpers(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			var b strings.Builder
-			err := template.Must(template.New("test").Funcs(funcMap()).Parse(tt.tpl)).Execute(&b, tt.vars)
-			require.NoError(t, err, tt.tpl)
+			require.NoError(t, template.Must(template.New("test").Funcs(funcMap()).Parse(tt.tpl)).Execute(&b, tt.vars), tt.tpl)
 			assert.Equal(t, tt.expect, b.String(), tt.tpl)
 		})
 	}
@@ -422,8 +420,7 @@ func TestDurationHelpers(t *testing.T) {
 					Funcs(funcMap()).
 					Parse(tt.tpl),
 			)
-			err := tmpl.Execute(&b, tt.vars)
-			require.Error(t, err, tt.tpl)
+			require.Error(t, tmpl.Execute(&b, tt.vars), tt.tpl)
 		})
 	}
 }
@@ -474,8 +471,7 @@ func TestMerge(t *testing.T) {
 	}
 	tpl := `{{merge .dst .src1 .src2}}`
 	var b strings.Builder
-	err := template.Must(template.New("test").Funcs(funcMap()).Parse(tpl)).Execute(&b, dict)
-	require.NoError(t, err)
+	require.NoError(t, template.Must(template.New("test").Funcs(funcMap()).Parse(tpl)).Execute(&b, dict))
 
 	expected := map[string]any{
 		"a": "one", // key overridden
diff --git a/pkg/getter/plugingetter_test.go b/pkg/getter/plugingetter_test.go
index 16af9eb31..c9ed9f779 100644
--- a/pkg/getter/plugingetter_test.go
+++ b/pkg/getter/plugingetter_test.go
@@ -35,25 +35,18 @@ func TestCollectPlugins(t *testing.T) {
 	env.PluginsDirectory = pluginDir
 
 	p, err := collectGetterPlugins(env)
-	if err != nil {
-		t.Fatal(err)
-	}
+	require.NoError(t, err)
 
-	if len(p) != 2 {
-		t.Errorf("Expected 2 plugins, got %d: %v", len(p), p)
-	}
+	assert.Len(t, p, 2, "Expected 2 plugins, got %d: %v", len(p), p)
 
-	if _, err := p.ByScheme("test2"); err != nil {
-		t.Error(err)
-	}
+	_, err = p.ByScheme("test2")
+	require.NoError(t, err)
 
-	if _, err := p.ByScheme("test"); err != nil {
-		t.Error(err)
-	}
+	_, err = p.ByScheme("test")
+	require.NoError(t, err)
 
-	if _, err := p.ByScheme("nosuchthing"); err == nil {
-		t.Fatal("did not expect protocol handler for nosuchthing")
-	}
+	_, err = p.ByScheme("nosuchthing")
+	require.Error(t, err, "did not expect protocol handler for nosuchthing")
 }
 
 func TestConvertOptions(t *testing.T) {
diff --git a/pkg/pusher/pusher_test.go b/pkg/pusher/pusher_test.go
index 71fab8694..078b2fa73 100644
--- a/pkg/pusher/pusher_test.go
+++ b/pkg/pusher/pusher_test.go
@@ -18,6 +18,9 @@ package pusher
 import (
 	"testing"
 
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
 	"helm.sh/helm/v4/pkg/cli"
 	"helm.sh/helm/v4/pkg/registry"
 )
@@ -28,9 +31,7 @@ func TestProvider(t *testing.T) {
 		func(_ ...Option) (Pusher, 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) {
@@ -39,30 +40,24 @@ func TestProviders(t *testing.T) {
 		{[]string{"two", "four"}, func(_ ...Option) (Pusher, 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 TestAll(t *testing.T) {
 	env := cli.New()
 	all := All(env)
-	if len(all) != 1 {
-		t.Errorf("expected 1 provider (OCI), got %d", len(all))
-	}
+	assert.Len(t, all, 1, "expected 1 provider (OCI), got %d", len(all))
 }
 
 func TestByScheme(t *testing.T) {
 	env := cli.New()
 	g := All(env)
-	if _, err := g.ByScheme(registry.OCIScheme); err != nil {
-		t.Error(err)
-	}
+	_, err := g.ByScheme(registry.OCIScheme)
+	assert.NoError(t, err)
 }
diff --git a/pkg/registry/client_insecure_tls_test.go b/pkg/registry/client_insecure_tls_test.go
index ae0a44337..f1ece1b1c 100644
--- a/pkg/registry/client_insecure_tls_test.go
+++ b/pkg/registry/client_insecure_tls_test.go
@@ -38,15 +38,13 @@ func (suite *InsecureTLSRegistryClientTestSuite) TearDownSuite() {
 }
 
 func (suite *InsecureTLSRegistryClientTestSuite) Test_0_Login() {
-	err := suite.RegistryClient.Login(suite.DockerRegistryHost,
+	suite.Require().Error(suite.RegistryClient.Login(suite.DockerRegistryHost,
 		LoginOptBasicAuth("badverybad", "ohsobad"),
-		LoginOptInsecure(true))
-	suite.Require().Error(err, "error logging into registry with bad credentials")
+		LoginOptInsecure(true)), "error logging into registry with bad credentials")
 
-	err = suite.RegistryClient.Login(suite.DockerRegistryHost,
+	suite.Require().NoError(suite.RegistryClient.Login(suite.DockerRegistryHost,
 		LoginOptBasicAuth(testUsername, testPassword),
-		LoginOptInsecure(true))
-	suite.Require().NoError(err, "no error logging into registry with good credentials")
+		LoginOptInsecure(true)), "no error logging into registry with good credentials")
 }
 
 func (suite *InsecureTLSRegistryClientTestSuite) Test_1_Push() {
@@ -68,8 +66,7 @@ func (suite *InsecureTLSRegistryClientTestSuite) Test_4_Logout() {
 		suite.Require().Error(err, "failed to delete the credential for this-host-aint-real:5000")
 	}
 
-	err = suite.RegistryClient.Logout(suite.DockerRegistryHost)
-	suite.Require().NoError(err, "no error logging out of registry")
+	suite.Require().NoError(suite.RegistryClient.Logout(suite.DockerRegistryHost), "no error logging out of registry")
 }
 
 func TestInsecureTLSRegistryClientTestSuite(t *testing.T) {
diff --git a/pkg/release/v1/hook_test.go b/pkg/release/v1/hook_test.go
index f3b8811a6..9e803a0fc 100644
--- a/pkg/release/v1/hook_test.go
+++ b/pkg/release/v1/hook_test.go
@@ -170,12 +170,12 @@ func TestHookExecutionUnmarshalJSON(t *testing.T) {
 			err := json.Unmarshal([]byte(tt.input), &exec)
 			if tt.wantErr {
 				assert.Error(t, err)
-				return
+			} else {
+				require.NoError(t, err)
+				assert.Equal(t, tt.expected.StartedAt.Unix(), exec.StartedAt.Unix())
+				assert.Equal(t, tt.expected.CompletedAt.Unix(), exec.CompletedAt.Unix())
+				assert.Equal(t, tt.expected.Phase, exec.Phase)
 			}
-			require.NoError(t, err)
-			assert.Equal(t, tt.expected.StartedAt.Unix(), exec.StartedAt.Unix())
-			assert.Equal(t, tt.expected.CompletedAt.Unix(), exec.CompletedAt.Unix())
-			assert.Equal(t, tt.expected.Phase, exec.Phase)
 		})
 	}
 }
@@ -194,9 +194,7 @@ func TestHookExecutionRoundTrip(t *testing.T) {
 	require.NoError(t, err)
 
 	var decoded HookExecution
-	err = json.Unmarshal(data, &decoded)
-	require.NoError(t, err)
-
+	require.NoError(t, json.Unmarshal(data, &decoded))
 	assert.Equal(t, original.StartedAt.Unix(), decoded.StartedAt.Unix())
 	assert.Equal(t, original.CompletedAt.Unix(), decoded.CompletedAt.Unix())
 	assert.Equal(t, original.Phase, decoded.Phase)
@@ -208,12 +206,11 @@ func TestHookExecutionEmptyStringRoundTrip(t *testing.T) {
 	input := `{"started_at":"","completed_at":"","phase":"Succeeded"}`
 
 	var exec HookExecution
-	err := json.Unmarshal([]byte(input), &exec)
-	require.NoError(t, err)
+	require.NoError(t, json.Unmarshal([]byte(input), &exec))
 
 	// Verify time fields are zero values
-	assert.True(t, exec.StartedAt.IsZero())
-	assert.True(t, exec.CompletedAt.IsZero())
+	assert.Zero(t, exec.StartedAt)
+	assert.Zero(t, exec.CompletedAt)
 	assert.Equal(t, HookPhaseSucceeded, exec.Phase)
 
 	// Marshal back and verify empty time fields are omitted
@@ -221,8 +218,7 @@ func TestHookExecutionEmptyStringRoundTrip(t *testing.T) {
 	require.NoError(t, err)
 
 	var result map[string]any
-	err = json.Unmarshal(data, &result)
-	require.NoError(t, err)
+	require.NoError(t, json.Unmarshal(data, &result))
 
 	// Zero time values should be omitted
 	assert.NotContains(t, result, "started_at")
diff --git a/pkg/storage/driver/mock_test.go b/pkg/storage/driver/mock_test.go
index ab7b261cf..c366d106d 100644
--- a/pkg/storage/driver/mock_test.go
+++ b/pkg/storage/driver/mock_test.go
@@ -24,6 +24,7 @@ import (
 	sqlmock "github.com/DATA-DOG/go-sqlmock"
 	sq "github.com/Masterminds/squirrel"
 	"github.com/jmoiron/sqlx"
+	"github.com/stretchr/testify/require"
 
 	v1 "k8s.io/api/core/v1"
 	apierrors "k8s.io/apimachinery/pkg/api/errors"
@@ -74,10 +75,7 @@ func tsFixtureMemory(t *testing.T) *Memory {
 
 	mem := NewMemory()
 	for _, tt := range hs {
-		err := mem.Create(testKey(tt.Name, tt.Version), tt)
-		if err != nil {
-			t.Fatalf("Test setup failed to create: %s\n", err)
-		}
+		require.NoError(t, mem.Create(testKey(tt.Name, tt.Version), tt), "Test setup failed to create")
 	}
 	return mem
 }
@@ -108,9 +106,7 @@ func (mock *MockConfigMapsInterface) Init(t *testing.T, releases ...*rspb.Releas
 		objkey := testKey(rls.Name, rls.Version)
 
 		cfgmap, err := newConfigMapsObject(objkey, rls, nil)
-		if err != nil {
-			t.Fatalf("Failed to create configmap: %s", err)
-		}
+		require.NoError(t, err, "Failed to create configmap")
 		mock.objects[objkey] = cfgmap
 	}
 }
@@ -196,9 +192,7 @@ func (mock *MockSecretsInterface) Init(t *testing.T, releases ...*rspb.Release)
 		objkey := testKey(rls.Name, rls.Version)
 
 		secret, err := newSecretsObject(objkey, rls, nil)
-		if err != nil {
-			t.Fatalf("Failed to create secret: %s", err)
-		}
+		require.NoError(t, err, "Failed to create secret")
 		mock.objects[objkey] = secret
 	}
 }
@@ -262,9 +256,7 @@ func (mock *MockSecretsInterface) Delete(_ context.Context, name string, _ metav
 func newTestFixtureSQL(t *testing.T, _ ...*rspb.Release) (*SQL, sqlmock.Sqlmock) {
 	t.Helper()
 	sqlDB, mock, err := sqlmock.New()
-	if err != nil {
-		t.Fatalf("error when opening stub database connection: %v", err)
-	}
+	require.NoError(t, err, "error when opening stub database connection")
 
 	sqlxDB := sqlx.NewDb(sqlDB, "sqlmock")
 	return &SQL{
diff --git a/pkg/storage/driver/util_test.go b/pkg/storage/driver/util_test.go
index d16043924..7074f252a 100644
--- a/pkg/storage/driver/util_test.go
+++ b/pkg/storage/driver/util_test.go
@@ -16,12 +16,13 @@ package driver
 import (
 	"reflect"
 	"testing"
+
+	"github.com/stretchr/testify/assert"
 )
 
 func TestGetSystemLabel(t *testing.T) {
-	if output := GetSystemLabels(); !reflect.DeepEqual(systemLabels, output) {
-		t.Errorf("Expected {%v}, got {%v}", systemLabels, output)
-	}
+	output := GetSystemLabels()
+	assert.Truef(t, reflect.DeepEqual(systemLabels, output), "Expected {%v}, got {%v}", systemLabels, output)
 }
 
 func TestIsSystemLabel(t *testing.T) {
@@ -32,9 +33,8 @@ func TestIsSystemLabel(t *testing.T) {
 		"NaMe":  false,
 	}
 	for label, result := range tests {
-		if output := isSystemLabel(label); output != result {
-			t.Errorf("Output %t not equal to expected %t", output, result)
-		}
+		output := isSystemLabel(label)
+		assert.Equalf(t, output, result, "Output %t not equal to expected %t", output, result)
 	}
 }
 
@@ -68,9 +68,8 @@ func TestFilterSystemLabels(t *testing.T) {
 		}},
 	}
 	for _, test := range tests {
-		if output := filterSystemLabels(test[0]); !reflect.DeepEqual(test[1], output) {
-			t.Errorf("Expected {%v}, got {%v}", test[1], output)
-		}
+		output := filterSystemLabels(test[0])
+		assert.Truef(t, reflect.DeepEqual(test[1], output), "Expected {%v}, got {%v}", test[1], output)
 	}
 }
 
@@ -101,8 +100,7 @@ func TestContainsSystemLabels(t *testing.T) {
 		}, false},
 	}
 	for _, test := range tests {
-		if output := ContainsSystemLabels(test.input); !reflect.DeepEqual(test.output, output) {
-			t.Errorf("Expected {%v}, got {%v}", test.output, output)
-		}
+		output := ContainsSystemLabels(test.input)
+		assert.Truef(t, reflect.DeepEqual(test.output, output), "Expected {%v}, got {%v}", test.output, output)
 	}
 }