diff --git a/pkg/action/install_test.go b/pkg/action/install_test.go
index f79590670..da680f41a 100644
--- a/pkg/action/install_test.go
+++ b/pkg/action/install_test.go
@@ -185,9 +185,7 @@ func TestInstallRelease(t *testing.T) {
 	vals := map[string]any{}
 	ctx, done := context.WithCancel(t.Context())
 	resi, err := instAction.RunWithContext(ctx, buildChart(), vals)
-	if err != nil {
-		t.Fatalf("Failed install: %s", err)
-	}
+	req.NoError(err, "Failed install")
 	res, err := releaserToV1Release(resi)
 	req.NoError(err)
 	is.Equal("test-install-release", res.Name, "Expected release name.")
@@ -238,9 +236,7 @@ func TestInstallReleaseWithTakeOwnership_ResourceNotOwned(t *testing.T) {
 	instAction := installActionWithConfig(config)
 	instAction.TakeOwnership = true
 	resi, err := instAction.Run(buildChart(), nil)
-	if err != nil {
-		t.Fatalf("Failed install: %s", err)
-	}
+	req.NoError(err, "Failed install")
 	res, err := releaserToV1Release(resi)
 	req.NoError(err)
 
@@ -262,9 +258,7 @@ func TestInstallReleaseWithTakeOwnership_ResourceOwned(t *testing.T) {
 	instAction := installActionWithConfig(config)
 	instAction.TakeOwnership = false
 	resi, err := instAction.Run(buildChart(), nil)
-	if err != nil {
-		t.Fatalf("Failed install: %s", err)
-	}
+	req.NoError(err, "Failed install")
 	res, err := releaserToV1Release(resi)
 	req.NoError(err)
 	r, err := instAction.cfg.Releases.Get(res.Name, res.Version)
@@ -285,7 +279,7 @@ func TestInstallReleaseWithTakeOwnership_ResourceOwnedNoFlag(t *testing.T) {
 	instAction := installActionWithConfig(config)
 	_, err := instAction.Run(buildChart(), nil)
 	req.Error(err)
-	is.Contains(err.Error(), "unable to continue with install")
+	is.ErrorContains(err, "unable to continue with install")
 }
 
 func TestInstallReleaseWithValues(t *testing.T) {
@@ -303,9 +297,7 @@ func TestInstallReleaseWithValues(t *testing.T) {
 		},
 	}
 	resi, err := instAction.Run(buildChart(withSampleValues()), userVals)
-	if err != nil {
-		t.Fatalf("Failed install: %s", err)
-	}
+	req.NoError(err, "Failed install")
 	res, err := releaserToV1Release(resi)
 	req.NoError(err)
 	is.Equal("test-install-release", res.Name, "Expected release name.")
@@ -344,9 +336,7 @@ func TestInstallRelease_WithNotes(t *testing.T) {
 	instAction.ReleaseName = "with-notes"
 	vals := map[string]any{}
 	resi, err := instAction.Run(buildChart(withNotes("note here")), vals)
-	if err != nil {
-		t.Fatalf("Failed install: %s", err)
-	}
+	req.NoError(err, "Failed install")
 	res, err := releaserToV1Release(resi)
 	req.NoError(err)
 
@@ -376,9 +366,7 @@ func TestInstallRelease_WithNotesRendered(t *testing.T) {
 	instAction.ReleaseName = "with-notes"
 	vals := map[string]any{}
 	resi, err := instAction.Run(buildChart(withNotes("got-{{.Release.Name}}")), vals)
-	if err != nil {
-		t.Fatalf("Failed install: %s", err)
-	}
+	req.NoError(err, "Failed install")
 	res, err := releaserToV1Release(resi)
 	req.NoError(err)
 
@@ -400,9 +388,7 @@ func TestInstallRelease_WithChartAndDependencyParentNotes(t *testing.T) {
 	instAction.ReleaseName = "with-notes"
 	vals := map[string]any{}
 	resi, err := instAction.Run(buildChart(withNotes("parent"), withDependency(withNotes("child"))), vals)
-	if err != nil {
-		t.Fatalf("Failed install: %s", err)
-	}
+	req.NoError(err, "Failed install")
 	res, err := releaserToV1Release(resi)
 	req.NoError(err)
 
@@ -424,9 +410,7 @@ func TestInstallRelease_WithChartAndDependencyAllNotes(t *testing.T) {
 	instAction.SubNotes = true
 	vals := map[string]any{}
 	resi, err := instAction.Run(buildChart(withNotes("parent"), withDependency(withNotes("child"))), vals)
-	if err != nil {
-		t.Fatalf("Failed install: %s", err)
-	}
+	req.NoError(err, "Failed install")
 	res, err := releaserToV1Release(resi)
 	req.NoError(err)
 
@@ -451,9 +435,7 @@ func TestInstallRelease_DryRunClient(t *testing.T) {
 
 		vals := map[string]any{}
 		resi, err := instAction.Run(buildChart(withSampleTemplates()), vals)
-		if err != nil {
-			t.Fatalf("Failed install: %s", err)
-		}
+		req.NoError(err, "Failed install")
 		res, err := releaserToV1Release(resi)
 		req.NoError(err)
 
@@ -466,7 +448,7 @@ func TestInstallRelease_DryRunClient(t *testing.T) {
 		_, err = instAction.cfg.Releases.Get(res.Name, res.Version)
 		req.Error(err)
 		is.Len(res.Hooks, 1)
-		is.True(res.Hooks[0].LastRun.CompletedAt.IsZero(), "expect hook to not be marked as run")
+		is.Zero(res.Hooks[0].LastRun.CompletedAt, "expect hook to not be marked as run")
 		is.Equal("Dry run complete", res.Info.Description)
 	}
 }
@@ -480,9 +462,7 @@ func TestInstallRelease_DryRunHiddenSecret(t *testing.T) {
 	instAction.DryRunStrategy = DryRunClient
 	vals := map[string]any{}
 	resi, err := instAction.Run(buildChart(withSampleSecret(), withSampleTemplates()), vals)
-	if err != nil {
-		t.Fatalf("Failed install: %s", err)
-	}
+	req.NoError(err, "Failed install")
 	res, err := releaserToV1Release(resi)
 	req.NoError(err)
 	is.Contains(res.Manifest, "---\n# Source: hello/templates/secret.yaml\napiVersion: v1\nkind: Secret")
@@ -495,9 +475,7 @@ func TestInstallRelease_DryRunHiddenSecret(t *testing.T) {
 	instAction.HideSecret = true
 	vals = map[string]any{}
 	res2i, err := instAction.Run(buildChart(withSampleSecret(), withSampleTemplates()), vals)
-	if err != nil {
-		t.Fatalf("Failed install: %s", err)
-	}
+	req.NoError(err, "Failed install")
 	res2, err := releaserToV1Release(res2i)
 	req.NoError(err)
 
@@ -511,9 +489,7 @@ func TestInstallRelease_DryRunHiddenSecret(t *testing.T) {
 	instAction.DryRunStrategy = DryRunNone
 	vals = map[string]any{}
 	_, err = instAction.Run(buildChart(withSampleSecret(), withSampleTemplates()), vals)
-	if err == nil {
-		t.Fatal("Did not get the expected error when dry-run is false and hide secret is true")
-	}
+	req.Error(err, "Did not get the expected error when dry-run is false and hide secret is true")
 }
 
 // Regression test for #7955
@@ -532,9 +508,7 @@ func TestInstallRelease_DryRun_Lookup(t *testing.T) {
 	})
 
 	resi, err := instAction.Run(mockChart, vals)
-	if err != nil {
-		t.Fatalf("Failed install: %s", err)
-	}
+	req.NoError(err, "Failed install")
 	res, err := releaserToV1Release(resi)
 	req.NoError(err)
 
@@ -543,6 +517,7 @@ func TestInstallRelease_DryRun_Lookup(t *testing.T) {
 
 func TestInstallReleaseIncorrectTemplate_DryRun(t *testing.T) {
 	is := assert.New(t)
+	req := require.New(t)
 	instAction := installAction(t)
 	instAction.DryRunStrategy = DryRunNone
 	vals := map[string]any{}
@@ -550,10 +525,8 @@ func TestInstallReleaseIncorrectTemplate_DryRun(t *testing.T) {
 	expectedErr := `hello/templates/incorrect:1:10
   executing "hello/templates/incorrect" at <.Values.bad.doh>:
     nil pointer evaluating interface {}.doh`
-	if err == nil {
-		t.Fatalf("Install should fail containing error: %s", expectedErr)
-	}
-	is.Contains(err.Error(), expectedErr)
+	req.Error(err, "Install should fail containing error: %s", expectedErr)
+	is.ErrorContains(err, expectedErr)
 }
 
 func TestInstallRelease_NoHooks(t *testing.T) {
@@ -562,17 +535,15 @@ func TestInstallRelease_NoHooks(t *testing.T) {
 	instAction := installAction(t)
 	instAction.DisableHooks = true
 	instAction.ReleaseName = "no-hooks"
-	require.NoError(t, instAction.cfg.Releases.Create(releaseStub()))
+	req.NoError(instAction.cfg.Releases.Create(releaseStub()))
 
 	vals := map[string]any{}
 	resi, err := instAction.Run(buildChart(), vals)
-	if err != nil {
-		t.Fatalf("Failed install: %s", err)
-	}
+	req.NoError(err, "Failed install")
 	res, err := releaserToV1Release(resi)
 	req.NoError(err)
 
-	is.True(res.Hooks[0].LastRun.CompletedAt.IsZero(), "hooks should not run with no-hooks")
+	is.Zero(res.Hooks[0].LastRun.CompletedAt, "hooks should not run with no-hooks")
 }
 
 func TestInstallRelease_FailedHooks(t *testing.T) {
@@ -637,7 +608,7 @@ func TestInstallRelease_KubeVersion(t *testing.T) {
 	vals = map[string]any{}
 	_, err = instAction.Run(buildChart(withKube(">=99.0.0")), vals)
 	req.Error(err)
-	is.Contains(err.Error(), "chart requires kubeVersion: >=99.0.0 which is incompatible with Kubernetes v1.20.")
+	is.ErrorContains(err, "chart requires kubeVersion: >=99.0.0 which is incompatible with Kubernetes v1.20.")
 }
 
 func TestInstallRelease_Wait(t *testing.T) {
@@ -680,7 +651,7 @@ func TestInstallRelease_Wait_Interrupted(t *testing.T) {
 
 	_, err := instAction.RunWithContext(ctx, buildChart(), vals)
 	req.Error(err)
-	is.Contains(err.Error(), "context canceled")
+	req.ErrorContains(err, "context canceled")
 
 	is.Equal(goroutines+1, instAction.getGoroutineCount()) // installation goroutine still is in background
 	time.Sleep(10 * time.Second)                           // wait for goroutine to finish
@@ -723,8 +694,8 @@ func TestInstallRelease_RollbackOnFailure(t *testing.T) {
 
 		resi, err := instAction.Run(buildChart(), vals)
 		req.Error(err)
-		is.Contains(err.Error(), "I timed out")
-		is.Contains(err.Error(), "rollback-on-failure")
+		req.ErrorContains(err, "I timed out")
+		req.ErrorContains(err, "rollback-on-failure")
 
 		res, err := releaserToV1Release(resi)
 		req.NoError(err)
@@ -748,9 +719,9 @@ func TestInstallRelease_RollbackOnFailure(t *testing.T) {
 
 		_, err := instAction.Run(buildChart(), vals)
 		req.Error(err)
-		is.Contains(err.Error(), "I timed out")
-		is.Contains(err.Error(), "uninstall fail")
-		is.Contains(err.Error(), "an error occurred while uninstalling the release")
+		req.ErrorContains(err, "I timed out")
+		req.ErrorContains(err, "uninstall fail")
+		is.ErrorContains(err, "an error occurred while uninstalling the release")
 	})
 }
 func TestInstallRelease_RollbackOnFailure_Interrupted(t *testing.T) {
@@ -771,9 +742,9 @@ func TestInstallRelease_RollbackOnFailure_Interrupted(t *testing.T) {
 
 	resi, err := instAction.RunWithContext(ctx, buildChart(), vals)
 	req.Error(err)
-	is.Contains(err.Error(), "context canceled")
-	is.Contains(err.Error(), "rollback-on-failure")
-	is.Contains(err.Error(), "uninstalled")
+	req.ErrorContains(err, "context canceled")
+	req.ErrorContains(err, "rollback-on-failure")
+	req.ErrorContains(err, "uninstalled")
 
 	res, err := releaserToV1Release(resi)
 	req.NoError(err)
@@ -820,36 +791,23 @@ func TestNameTemplate(t *testing.T) {
 	}
 
 	for _, tc := range testCases {
-		n, err := TemplateName(tc.tpl)
-		if err != nil {
+		t.Run(tc.tpl, func(t *testing.T) {
+			n, err := TemplateName(tc.tpl)
 			if tc.expectedErrorStr == "" {
-				t.Errorf("Was not expecting error, but got: %v", err)
-				continue
+				require.NoError(t, err)
+			} else {
+				require.Error(t, err)
+				re, compErr := regexp.Compile(tc.expectedErrorStr)
+				require.NoError(t, compErr, "Expected error string failed to compile")
+				assert.True(t, re.MatchString(err.Error()), "Error didn't match for %s expected %s", tc.tpl, tc.expectedErrorStr)
 			}
-			re, compErr := regexp.Compile(tc.expectedErrorStr)
-			if compErr != nil {
-				t.Errorf("Expected error string failed to compile: %v", compErr)
-				continue
-			}
-			if !re.MatchString(err.Error()) {
-				t.Errorf("Error didn't match for %s expected %s but got %v", tc.tpl, tc.expectedErrorStr, err)
-				continue
-			}
-		}
-		if err == nil && tc.expectedErrorStr != "" {
-			t.Errorf("Was expecting error %s but didn't get an error back", tc.expectedErrorStr)
-		}
 
-		if tc.expected != "" {
-			re, err := regexp.Compile(tc.expected)
-			if err != nil {
-				t.Errorf("Expected string failed to compile: %v", err)
-				continue
-			}
-			if !re.MatchString(n) {
-				t.Errorf("Returned name didn't match for %s expected %s but got %s", tc.tpl, tc.expected, n)
+			if tc.expected != "" {
+				re, err := regexp.Compile(tc.expected)
+				require.NoError(t, err)
+				assert.True(t, re.MatchString(n), "Returned name didn't match for %s expected %s but got %s", tc.tpl, tc.expected, n)
 			}
-		}
+		})
 	}
 }
 
@@ -864,9 +822,7 @@ func TestInstallReleaseOutputDir(t *testing.T) {
 	instAction.OutputDir = dir
 
 	_, err := instAction.Run(buildChart(withSampleTemplates(), withMultipleManifestTemplate()), vals)
-	if err != nil {
-		t.Fatalf("Failed install: %s", err)
-	}
+	req.NoError(err, "Failed install")
 
 	_, err = os.Stat(filepath.Join(dir, "hello", "templates", "goodbye"))
 	req.NoError(err)
@@ -901,9 +857,7 @@ func TestInstallOutputDirWithReleaseName(t *testing.T) {
 	newDir := filepath.Join(dir, instAction.ReleaseName)
 
 	_, err := instAction.Run(buildChart(withSampleTemplates(), withMultipleManifestTemplate()), vals)
-	if err != nil {
-		t.Fatalf("Failed install: %s", err)
-	}
+	req.NoError(err, "Failed install")
 
 	_, err = os.Stat(filepath.Join(newDir, "hello", "templates", "goodbye"))
 	req.NoError(err)
@@ -925,46 +879,37 @@ func TestInstallOutputDirWithReleaseName(t *testing.T) {
 
 func TestNameAndChart(t *testing.T) {
 	is := assert.New(t)
+	req := require.New(t)
 	instAction := installAction(t)
 	chartName := "./foo"
 
 	name, chrt, err := instAction.NameAndChart([]string{chartName})
-	if err != nil {
-		t.Fatal(err)
-	}
+	req.NoError(err)
 	is.Equal(instAction.ReleaseName, name)
 	is.Equal(chartName, chrt)
 
 	instAction.GenerateName = true
 	_, _, err = instAction.NameAndChart([]string{"foo", chartName})
-	if err == nil {
-		t.Fatal("expected an error")
-	}
-	is.Equal("cannot set --generate-name and also specify a name", err.Error())
+	req.Error(err, "expected an error")
+	req.EqualError(err, "cannot set --generate-name and also specify a name")
 
 	instAction.GenerateName = false
 	instAction.NameTemplate = "{{ . }}"
 	_, _, err = instAction.NameAndChart([]string{"foo", chartName})
-	if err == nil {
-		t.Fatal("expected an error")
-	}
-	is.Equal("cannot set --name-template and also specify a name", err.Error())
+	req.Error(err, "expected an error")
+	req.EqualError(err, "cannot set --name-template and also specify a name")
 
 	instAction.NameTemplate = ""
 	instAction.ReleaseName = ""
 	_, _, err = instAction.NameAndChart([]string{chartName})
-	if err == nil {
-		t.Fatal("expected an error")
-	}
-	is.Equal("must either provide a name or specify --generate-name", err.Error())
+	req.Error(err, "expected an error")
+	req.EqualError(err, "must either provide a name or specify --generate-name")
 
 	instAction.NameTemplate = ""
 	instAction.ReleaseName = ""
 	_, _, err = instAction.NameAndChart([]string{"foo", chartName, "bar"})
-	if err == nil {
-		t.Fatal("expected an error")
-	}
-	is.Equal("expected at most two arguments, unexpected arguments: bar", err.Error())
+	req.Error(err, "expected an error")
+	is.EqualError(err, "expected at most two arguments, unexpected arguments: bar")
 }
 
 func TestNameAndChartGenerateName(t *testing.T) {
@@ -1016,9 +961,7 @@ func TestNameAndChartGenerateName(t *testing.T) {
 			t.Parallel()
 
 			name, chrt, err := instAction.NameAndChart([]string{tc.Chart})
-			if err != nil {
-				t.Fatal(err)
-			}
+			require.NoError(t, err)
 
 			is.Equal(tc.ExpectedName, name)
 			is.Equal(tc.Chart, chrt)
@@ -1035,9 +978,7 @@ func TestInstallWithLabels(t *testing.T) {
 		"key2": "val2",
 	}
 	resi, err := instAction.Run(buildChart(), nil)
-	if err != nil {
-		t.Fatalf("Failed install: %s", err)
-	}
+	req.NoError(err, "Failed install")
 	res, err := releaserToV1Release(resi)
 	req.NoError(err)
 
@@ -1046,17 +987,15 @@ func TestInstallWithLabels(t *testing.T) {
 
 func TestInstallWithSystemLabels(t *testing.T) {
 	is := assert.New(t)
+	req := require.New(t)
 	instAction := installAction(t)
 	instAction.Labels = map[string]string{
 		"owner": "val1",
 		"key2":  "val2",
 	}
 	_, err := instAction.Run(buildChart(), nil)
-	if err == nil {
-		t.Fatal("expected an error")
-	}
-
-	is.Equal(fmt.Errorf("user supplied labels contains system reserved label name. System labels: %+v", driver.GetSystemLabels()), err)
+	req.Error(err, "expected an error")
+	is.EqualError(err, fmt.Sprintf("user supplied labels contains system reserved label name. System labels: %+v", driver.GetSystemLabels()))
 }
 
 func TestUrlEqual(t *testing.T) {
@@ -1111,13 +1050,9 @@ func TestUrlEqual(t *testing.T) {
 			t.Parallel()
 
 			u1, err := url.Parse(tc.url1)
-			if err != nil {
-				t.Fatalf("Failed to parse URL1 %s: %v", tc.url1, err)
-			}
+			require.NoError(t, err, "Failed to parse URL1 %s", tc.url1)
 			u2, err := url.Parse(tc.url2)
-			if err != nil {
-				t.Fatalf("Failed to parse URL2 %s: %v", tc.url2, err)
-			}
+			require.NoError(t, err, "Failed to parse URL2 %s", tc.url2)
 
 			is.Equal(tc.expected, urlEqual(u1, u2))
 		})
@@ -1285,11 +1220,7 @@ func TestInstallCRDs_CheckNilErrors(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			instAction := installAction(t)
-
-			err := instAction.installCRDs(tt.input)
-			if err == nil {
-				t.Error("got nil expected err")
-			}
+			assert.Error(t, instAction.installCRDs(tt.input), "got nil expected err")
 		})
 	}
 }
diff --git a/pkg/cmd/verify_test.go b/pkg/cmd/verify_test.go
index 050d799c9..0b4078e1e 100644
--- a/pkg/cmd/verify_test.go
+++ b/pkg/cmd/verify_test.go
@@ -19,6 +19,9 @@ import (
 	"fmt"
 	"runtime"
 	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestVerifyCmd(t *testing.T) {
@@ -73,18 +76,11 @@ func TestVerifyCmd(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			_, out, err := executeActionCommand(tt.cmd)
 			if tt.wantError {
-				if err == nil {
-					t.Errorf("Expected error, but got none: %q", out)
-				}
-				if err.Error() != tt.expect {
-					t.Errorf("Expected error %q, got %q", tt.expect, err)
-				}
-				return
-			} else if err != nil {
-				t.Errorf("Unexpected error: %s", err)
-			}
-			if out != tt.expect {
-				t.Errorf("Expected %q, got %q", tt.expect, out)
+				require.Error(t, err, "Expected error, but got none: %q", out)
+				assert.EqualError(t, err, tt.expect, "Expected error %q", tt.expect)
+			} else {
+				require.NoError(t, err)
+				assert.Equal(t, tt.expect, out, "Expected %q, got %q", tt.expect, out)
 			}
 		})
 	}
diff --git a/pkg/provenance/sign_test.go b/pkg/provenance/sign_test.go
index 79b33a970..32253df90 100644
--- a/pkg/provenance/sign_test.go
+++ b/pkg/provenance/sign_test.go
@@ -89,14 +89,10 @@ func loadChartMetadataForSigning(t *testing.T, chartPath string) []byte {
 	t.Helper()
 
 	chart, err := loader.LoadFile(chartPath)
-	if err != nil {
-		t.Fatal(err)
-	}
+	require.NoError(t, err)
 
 	metadataBytes, err := yaml.Marshal(chart.Metadata)
-	if err != nil {
-		t.Fatal(err)
-	}
+	require.NoError(t, err)
 
 	return metadataBytes
 }
@@ -106,170 +102,116 @@ func TestMessageBlock(t *testing.T) {
 
 	// Read the chart file data
 	archiveData, err := os.ReadFile(testChartfile)
-	if err != nil {
-		t.Fatal(err)
-	}
+	require.NoError(t, err)
 
 	out, err := messageBlock(archiveData, filepath.Base(testChartfile), metadataBytes)
-	if err != nil {
-		t.Fatal(err)
-	}
+	require.NoError(t, err)
 	got := out.String()
 
-	if got != testMessageBlock {
-		t.Errorf("Expected:\n%q\nGot\n%q\n", testMessageBlock, got)
-	}
+	assert.Equal(t, testMessageBlock, got, "Expected:\n%q\nGot\n%q\n", testMessageBlock, got)
 }
 
 func TestParseMessageBlock(t *testing.T) {
 	sc, err := parseMessageBlock([]byte(testMessageBlock))
-	if err != nil {
-		t.Fatal(err)
-	}
+	require.NoError(t, err)
 
 	// parseMessageBlock only returns checksums, not metadata (like upstream)
 
-	if lsc := len(sc.Files); lsc != 1 {
-		t.Errorf("Expected 1 file, got %d", lsc)
-	}
+	lsc := len(sc.Files)
+	assert.Equalf(t, 1, lsc, "Expected 1 file, got %d", lsc)
 
-	if hash, ok := sc.Files["hashtest-1.2.3.tgz"]; !ok {
-		t.Error("hashtest file not found in Files")
-	} else if hash != "sha256:c6841b3a895f1444a6738b5d04564a57e860ce42f8519c3be807fb6d9bee7888" {
-		t.Errorf("Unexpected hash: %q", hash)
-	}
+	hash, ok := sc.Files["hashtest-1.2.3.tgz"]
+	assert.True(t, ok, "hashtest file not found in Files")
+	assert.Equalf(t, "sha256:c6841b3a895f1444a6738b5d04564a57e860ce42f8519c3be807fb6d9bee7888", hash, "Unexpected hash: %q", hash)
 }
 
 func TestLoadKey(t *testing.T) {
 	k, err := loadKey(testKeyfile)
-	if err != nil {
-		t.Fatal(err)
-	}
+	require.NoError(t, err)
 
-	if _, ok := k.Identities[testKeyName]; !ok {
-		t.Errorf("Expected to load a key for user %q", testKeyName)
-	}
+	_, ok := k.Identities[testKeyName]
+	assert.Truef(t, ok, "Expected to load a key for user %q", testKeyName)
 }
 
 func TestLoadKeyRing(t *testing.T) {
 	k, err := loadKeyRing(testPubfile)
-	if err != nil {
-		t.Fatal(err)
-	}
+	require.NoError(t, err)
 
-	if len(k) > 1 {
-		t.Errorf("Expected 1, got %d", len(k))
-	}
+	assert.LessOrEqualf(t, len(k), 1, "Expected 1, got %d", len(k))
 
 	for _, e := range k {
-		if ii, ok := e.Identities[testKeyName]; !ok {
-			t.Errorf("Expected %s in %v", testKeyName, ii)
-		}
+		ii, ok := e.Identities[testKeyName]
+		assert.Truef(t, ok, "Expected %s in %v", testKeyName, ii)
 	}
 }
 
 func TestDigest(t *testing.T) {
 	f, err := os.Open(testChartfile)
-	if err != nil {
-		t.Fatal(err)
-	}
+	require.NoError(t, err)
 	defer f.Close()
 
 	hash, err := Digest(f)
-	if err != nil {
-		t.Fatal(err)
-	}
+	require.NoError(t, err)
 
 	sig, err := readSumFile(testSumfile)
-	if err != nil {
-		t.Fatal(err)
-	}
+	require.NoError(t, err)
 
-	if !strings.Contains(sig, hash) {
-		t.Errorf("Expected %s to be in %s", hash, sig)
-	}
+	assert.Contains(t, sig, hash, "Expected %s to be in %s", hash, sig)
 }
 
 func TestNewFromFiles(t *testing.T) {
 	s, err := NewFromFiles(testKeyfile, testPubfile)
-	if err != nil {
-		t.Fatal(err)
-	}
+	require.NoError(t, err)
 
-	if _, ok := s.Entity.Identities[testKeyName]; !ok {
-		t.Errorf("Expected to load a key for user %q", testKeyName)
-	}
+	_, ok := s.Entity.Identities[testKeyName]
+	assert.Truef(t, ok, "Expected to load a key for user %q", testKeyName)
 }
 
 func TestDigestFile(t *testing.T) {
 	hash, err := DigestFile(testChartfile)
-	if err != nil {
-		t.Fatal(err)
-	}
+	require.NoError(t, err)
 
 	sig, err := readSumFile(testSumfile)
-	if err != nil {
-		t.Fatal(err)
-	}
+	require.NoError(t, err)
 
-	if !strings.Contains(sig, hash) {
-		t.Errorf("Expected %s to be in %s", hash, sig)
-	}
+	assert.Contains(t, sig, hash, "Expected %s to be in %s", hash, sig)
 }
 
 func TestDecryptKey(t *testing.T) {
 	k, err := NewFromKeyring(testPasswordKeyfile, testPasswordKeyName)
-	if err != nil {
-		t.Fatal(err)
-	}
+	require.NoError(t, err)
 
-	if !k.Entity.PrivateKey.Encrypted {
-		t.Fatal("Key is not encrypted")
-	}
+	require.True(t, k.Entity.PrivateKey.Encrypted, "Key is not encrypted")
 
 	// We give this a simple callback that returns the password.
-	if err := k.DecryptKey(func(_ string) ([]byte, error) {
+	require.NoError(t, k.DecryptKey(func(_ string) ([]byte, error) {
 		return []byte("secret"), nil
-	}); err != nil {
-		t.Fatal(err)
-	}
+	}))
 
 	// Re-read the key (since we already unlocked it)
 	k, err = NewFromKeyring(testPasswordKeyfile, testPasswordKeyName)
-	if err != nil {
-		t.Fatal(err)
-	}
+	require.NoError(t, err)
 	// Now we give it a bogus password.
-	if err := k.DecryptKey(func(_ string) ([]byte, error) {
+	require.Error(t, k.DecryptKey(func(_ string) ([]byte, error) {
 		return []byte("secrets_and_lies"), nil
-	}); err == nil {
-		t.Fatal("Expected an error when giving a bogus passphrase")
-	}
+	}), "Expected an error when giving a bogus passphrase")
 }
 
 func TestClearSign(t *testing.T) {
 	signer, err := NewFromFiles(testKeyfile, testPubfile)
-	if err != nil {
-		t.Fatal(err)
-	}
+	require.NoError(t, err)
 
 	metadataBytes := loadChartMetadataForSigning(t, testChartfile)
 
 	// Read the chart file data
 	archiveData, err := os.ReadFile(testChartfile)
-	if err != nil {
-		t.Fatal(err)
-	}
+	require.NoError(t, err)
 
 	sig, err := signer.ClearSign(archiveData, filepath.Base(testChartfile), metadataBytes)
-	if err != nil {
-		t.Fatal(err)
-	}
+	require.NoError(t, err)
 	t.Logf("Sig:\n%s", sig)
 
-	if !strings.Contains(sig, testMessageBlock) {
-		t.Errorf("expected message block to be in sig: %s", sig)
-	}
+	assert.Contains(t, sig, testMessageBlock, "expected message block to be in sig: %s", sig)
 }
 
 func TestMixedKeyringRSASigningAndVerification(t *testing.T) {
@@ -335,9 +277,7 @@ func (s failSigner) Sign(_ io.Reader, _ []byte, _ crypto.SignerOpts) ([]byte, er
 
 func TestClearSignError(t *testing.T) {
 	signer, err := NewFromFiles(testKeyfile, testPubfile)
-	if err != nil {
-		t.Fatal(err)
-	}
+	require.NoError(t, err)
 
 	// ensure that signing always fails
 	signer.Entity.PrivateKey.PrivateKey = failSigner{}
@@ -346,18 +286,11 @@ func TestClearSignError(t *testing.T) {
 
 	// Read the chart file data
 	archiveData, err := os.ReadFile(testChartfile)
-	if err != nil {
-		t.Fatal(err)
-	}
+	require.NoError(t, err)
 
 	sig, err := signer.ClearSign(archiveData, filepath.Base(testChartfile), metadataBytes)
-	if err == nil {
-		t.Fatal("didn't get an error from ClearSign but expected one")
-	}
-
-	if sig != "" {
-		t.Fatalf("expected an empty signature after failed ClearSign but got %q", sig)
-	}
+	require.Error(t, err, "didn't get an error from ClearSign but expected one")
+	assert.Empty(t, sig, "expected an empty signature after failed ClearSign but got %q", sig)
 }
 
 func TestVerify(t *testing.T) {
@@ -386,7 +319,7 @@ func TestVerify(t *testing.T) {
 	require.Errorf(t, err, "Expected %s to fail.", testTamperedSigBlock)
 
 	var sErr pgperrors.SignatureError
-	if assert.ErrorAs(t, err, &sErr, "Expected invalid signature error, got %q (%T)", err, err) {
+	if assert.ErrorAs(t, err, &sErr, "Expected invalid signature error") {
 		t.Logf("Tampered sig block error: %s (%T)", sErr, sErr)
 	}
 }