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

@@ -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 {
+	if !assert.Empty(t, m, "All returned linter messages when it shouldn't have") {
-		t.Error("All returned linter messages when it shouldn't have")
 		for i, msg := range m {
 			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 {
+	if !assert.Len(t, m, 1, "All should have had exactly 1 error") {
-		t.Errorf("All should have had exactly 1 error. Got %d", ll)
 		for i, msg := range m {
 			t.Logf("Message %d: %s", i, msg.Error())
 		}
-	} else if msg := m[0].Err.Error(); !strings.Contains(msg, "icon is recommended") {
+	} else {
-		t.Errorf("Unexpected lint error: %s", msg)
+		assert.ErrorContains(t, m[0].Err, "icon is recommended")
 	}
 }
 
@@ -196,8 +194,7 @@ func TestHelmCreateChart_CheckDeprecatedWarnings(t *testing.T) {
 func TestSubChartValuesChart(t *testing.T) {
 	var values map[string]any
 	m := RunAll(subChartValuesDir, values, namespace).Messages
-	if len(m) != 0 {
+	if !assert.Empty(t, m, "All returned linter messages when it shouldn't have") {
-		t.Error("All returned linter messages when it shouldn't have")
 		for i, msg := range m {
 			t.Logf("Message %d: %s", i, msg)
 		}

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 {
+		err := ValidateReleaseName(input)
-			st := "fail"
+		if expectPass {
-			if expectPass {
+			assert.NoError(t, err)
-				st = "succeed"
+		} else {
-			}
+			assert.Error(t, err)
-			t.Errorf("Expected %q to %s", input, st)
 		}
 	}
 }
@@ -80,12 +83,11 @@ func TestValidateMetadataName(t *testing.T) {
 			"a1111111111111111111111111111111111111111111111111111111111z": false,
 	}
 	for input, expectPass := range names {
-		if err := ValidateMetadataName(input); (err == nil) != expectPass {
+		err := ValidateMetadataName(input)
-			st := "fail"
+		if expectPass {
-			if expectPass {
+			assert.NoError(t, err)
-				st = "succeed"
+		} else {
-			}
+			assert.Error(t, err)
-			t.Errorf("Expected %q to %s", input, st)
 		}
 	}
 }

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
+			} else {
-			}
+				// Regular test cases
-
+				got, err := readFile(actualFilePath, tt.providers)
-			// Regular test cases
+				if tt.expectError {
-			got, err := readFile(actualFilePath, tt.providers)
+					assert.Error(t, err)
-			if tt.expectError {
+				} else {
-				assert.Error(t, err)
+					require.NoError(t, err)
-				return
+					if tt.expectedData != nil {
-			}
+						assert.Equal(t, tt.expectedData, got)
-			require.NoError(t, err)
+					}
-
+				}
-			if tt.expectedData != nil {
-				assert.Equal(t, tt.expectedData, got)
 			}
 		})
 	}
@@ -356,10 +354,10 @@ func TestMergeValuesCLI(t *testing.T) {
 			got, err := tt.opts.MergeValues(getter.Providers{})
 			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)
 		})
 	}
 }

pkg/cmd/package_test.go

@@ -139,24 +139,22 @@ func TestPackage(t *testing.T) {
 				}
 			}
 			_, _, err = executeActionCommand(strings.Join(cmd, " "))
-
+			if tt.err {
-			if err != nil {
+				require.Error(t, err)
-				if tt.err && re.MatchString(err.Error()) {
+				require.True(t, re.MatchString(err.Error()))
-					return
+			} else {
+				require.NoError(t, err)
+				if tt.hasfile != "" {
+					fi, err := os.Stat(tt.hasfile)
+					require.NoErrorf(t, err, "%q: expected file %q", tt.name, tt.hasfile)
+					assert.NotEqualf(t, 0, fi.Size(), "%q: file %q has zero bytes.", tt.name, tt.hasfile)
 				}
-				t.Fatalf("%q: expected error %q, got %q", tt.name, tt.expect, err)
-			}
 
-			if tt.hasfile != "" {
+				if v, ok := tt.flags["sign"]; ok && v == "1" {
-				fi, err := os.Stat(tt.hasfile)
+					fi, err := os.Stat(tt.hasfile + ".prov")
-				require.NoErrorf(t, err, "%q: expected file %q", tt.name, tt.hasfile)
+					require.NoErrorf(t, err, "%q: expected provenance file", tt.name)
-				assert.NotEqualf(t, 0, fi.Size(), "%q: file %q has zero bytes.", tt.name, tt.hasfile)
+					assert.NotEqualf(t, 0, fi.Size(), "%q: provenance file is empty", tt.name)
-			}
+				}
-
-			if v, ok := tt.flags["sign"]; ok && v == "1" {
-				fi, err := os.Stat(tt.hasfile + ".prov")
-				require.NoErrorf(t, err, "%q: expected provenance file", tt.name)
-				assert.NotEqualf(t, 0, fi.Size(), "%q: provenance file is empty", tt.name)
 			}
 		})
 	}

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.wantError {
+				if tt.wantErrorMsg != "" {
-					if tt.wantErrorMsg != "" && tt.wantErrorMsg != err.Error() {
+					require.EqualError(t, err, tt.wantErrorMsg, "Actual error '%s', not equal to expected error '%s'", err, tt.wantErrorMsg)
-						t.Fatalf("Actual error '%s', not equal to expected error '%s'", err, tt.wantErrorMsg)
-					}
-					return
 				}
-				t.Fatalf("%q reported error: %s", tt.name, err)
+			} else {
-			}
+				require.NoError(t, err)
 
-			if tt.expectVerify {
+				if tt.expectVerify {
-				outString := helmTestKeyOut + tt.expectSha + "\n"
+					outString := helmTestKeyOut + tt.expectSha + "\n"
-				assert.Equal(t, outString, out, "%q: expected verification output %q, got %q", tt.name, outString, out)
+					assert.Equal(t, outString, out, "%q: expected verification output %q, got %q", tt.name, outString, out)
-			}
+				}
 
-			ef := filepath.Join(outdir, tt.expectFile)
+				ef := filepath.Join(outdir, tt.expectFile)
-			fi, err := os.Stat(ef)
+				fi, err := os.Stat(ef)
-			require.NoError(t, err, "%q: expected a file at %s.", tt.name, ef)
+				require.NoError(t, err, "%q: expected a file at %s.", tt.name, ef)
-			assert.Equal(t, tt.expectDir, fi.IsDir(), "%q: expected directory=%t, but it's not.", tt.name, tt.expectDir)
+				assert.Equal(t, tt.expectDir, fi.IsDir(), "%q: expected directory=%t, but it's not.", tt.name, tt.expectDir)
+			}
 		})
 	}
 }

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 {
-				if tt.fail {
+				require.ErrorContains(t, err, tt.failMsg)
-					require.ErrorContains(t, err, tt.failMsg)
+			} else {
-					return
+				require.NoError(t, err) // Give us predictably ordered results.
-				}
+				SortScore(charts)
-				t.Fatalf("%s: %s", tt.name, err)
-			}
-			// Give us predictably ordered results.
-			SortScore(charts)
 
-			l := len(charts)
+				l := len(tt.expect)
-			require.Lenf(t, tt.expect, l, "Expected %d result, got %d", len(tt.expect), l)
+				require.Len(t, charts, len(tt.expect))
-			// For empty result sets, just keep going.
+				// For empty result sets, just keep going.
-			if l == 0 {
+				if l != 0 {
-				return
+					for i, got := range charts {
-			}
+						ex := tt.expect[i]
-
+						assert.Equalf(t, got.Name, ex.Name, "[%d]: Expected name %q, got %q", i, ex.Name, got.Name)
-			for i, got := range charts {
+					}
-				ex := tt.expect[i]
+				}
-				assert.Equalf(t, got.Name, ex.Name, "[%d]: Expected name %q, got %q", i, ex.Name, got.Name)
 			}
 		})
 	}

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 {
+	require.NoError(t, chartutil.SaveDir(parent, tmp), "Error creating chart")
-		t.Fatalf("Error creating chart: %v", err)
-	}
 	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 {
+	require.NoError(t, os.MkdirAll(filepath.Join(chartPath, "charts"), 0o755), "Error creating charts dir")
-		t.Fatalf("Error creating charts dir: %v", err)
-	}
 
 	// The command must return an error (registry rejects the lookup), not panic.
 	_, _, err := executeActionCommandC(storageFixture(),
 		fmt.Sprintf("upgrade --dependency-update --plain-http oci-parent '%s'", chartPath))
-	if err == nil {
+	require.Error(t, err, "expected an error resolving the OCI dependency, got nil")
-		t.Fatal("expected an error resolving the OCI dependency, got nil")
-	}
 }
 
 func TestUpgradeWithValue(t *testing.T) {
@@ -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) {

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)
+		t.Run(tt.name, func(t *testing.T) {
-		if err != nil {
+			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.EqualError(t, e, tt.want)
-			assert.EqualErrorf(t, e, tt.want, "Error() = %v, want %v", got, tt.want)
 		})
 	}
 }

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.Containsf(t, fns, f, "Expected add-on function %q", f)
-		assert.Truef(t, ok, "Expected add-on function %q", f)
 	}
 }
 
@@ -412,8 +411,7 @@ func TestParseErrors(t *testing.T) {
 	}
 	_, err := new(Engine).render(t.Context(), tplsUndefinedFunction)
 	require.Error(t, err, "Expected failures while rendering")
-	expected := `parse error at (undefined_function:1): function "foo" not defined`
+	assert.EqualError(t, err, `parse error at (undefined_function:1): function "foo" not defined`)
-	assert.EqualError(t, err, expected)
 }
 
 func TestExecErrors(t *testing.T) {
@@ -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) {
+	require.Error(t, err)
-		t.Errorf("Expected err with suffix: %s", expectErr)
+	assert.True(t, strings.HasSuffix(err.Error(), expectErr), "Expected err with suffix: %s", expectErr)
-	}
 
 	// calling the same function many times is ok
 	times := 4000
@@ -1261,18 +1258,14 @@ func TestRenderCustomTemplateFuncs(t *testing.T) {
 	require.NoError(t, err)
 
 	// Expected output should be "hello!!!".
-	expected := "hello!!!"
+	rendered, ok := out["CustomFunc/templates/manifest"]
-	key := "CustomFunc/templates/manifest"
+	require.True(t, ok)
-	if rendered, ok := out[key]; !ok || rendered != expected {
+	assert.Equal(t, "hello!!!", rendered)
-		t.Errorf("Expected %q, got %q", expected, rendered)
-	}
 
 	// Verify that the rendered template used the custom "upper" function.
-	expected = "custom:hello"
+	rendered, ok = out["CustomFunc/templates/override"]
-	key = "CustomFunc/templates/override"
+	require.True(t, ok)
-	if rendered, ok := out[key]; !ok || rendered != expected {
+	assert.Equal(t, "custom:hello", rendered)
-		t.Errorf("Expected %q, got %q", expected, rendered)
-	}
 }
 
 func TestTraceableError_SimpleForm(t *testing.T) {

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

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") {
+	require.NoError(t, err)
-		t.Errorf("Unexpected version: %s", cv.Version)
+	assert.Contains(t, cv.Version, "0.1.9", "Unexpected version: %s", cv.Version)
-	}
 
 	cv, err = i.Get("setter", "0.1.9+alpha")
 	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 {
+	require.True(t, ok)
-		t.Fatal("Expected 2 nginx entries")
+	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)
-
+			switch {
-			if tc.Input == nil {
+			case tc.Input == nil:
 				assert.NoError(t, result, "expected nil result for nil input")
-				return
+			case tc.ErrorSkipped:
-			}
-
-			if tc.ErrorSkipped {
 				assert.NoError(t, result, "expected nil result for skipped error")
-				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")
 		})
 	}
 }

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.Contains(t, rls.Labels, "name", "Expected 'name' label in results, actual %v", rls.Labels)
-	require.True(t, ok, "Expected 'name' label in results, actual %v", rls.Labels)
+	require.Contains(t, rls.Labels, "key1", "Expected 'key1' label in results, actual %v", rls.Labels)
-	_, ok = rls.Labels["key1"]
-	require.True(t, ok, "Expected 'key1' label in results, actual %v", rls.Labels)
 }
 
 func TestConfigMapQuery(t *testing.T) {
@@ -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)
 }

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 {
+	if !assert.Len(t, end, startLen-2) {
-		t.Errorf("expected end to be %d instead of %d", startLen-2, endLen)
 		for _, ee := range end {
 			rac, err := release.NewAccessor(ee)
 			require.NoError(t, err, "unable to get release accessor")

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.Contains(t, rls.Labels, "name", "Expected 'name' label in results, actual %v", rls.Labels)
-	require.True(t, ok, "Expected 'name' label in results, actual %v", rls.Labels)
+	require.Contains(t, rls.Labels, "key1", "Expected 'key1' label in results, actual %v", rls.Labels)
-	_, ok = rls.Labels["key1"]
-	require.True(t, ok, "Expected 'key1' label in results, actual %v", rls.Labels)
 }
 
 func TestSecretQuery(t *testing.T) {
@@ -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)
 }

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.Contains(t, rls.Labels, "name", "Expected 'name' label in results, actual %v", rls.Labels)
-	require.True(t, ok, "Expected 'name' label in results, actual %v", rls.Labels)
+	require.Contains(t, rls.Labels, "key1", "Expected 'key1' label in results, actual %v", rls.Labels)
-	_, ok = rls.Labels["key1"]
-	require.True(t, ok, "Expected 'key1' label in results, actual %v", rls.Labels)
 }
 
 func TestSqlCreate(t *testing.T) {
@@ -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")
-	assert.Len(t, results, 2, "expected a resultset of size 2, got %d", len(results))
 
 	for _, res := range results {
-		if !reflect.DeepEqual(res, deployedRelease) && !reflect.DeepEqual(res, supersededRelease) {
+		assert.False(t, !reflect.DeepEqual(res, deployedRelease) && !reflect.DeepEqual(res, supersededRelease), "Expected release {%v} or {%v}, got {%v}", deployedRelease, supersededRelease, res)
-			t.Errorf("Expected release {%v} or {%v}, got {%v}", deployedRelease, supersededRelease, res)
-		}
 	}
 
 	assert.NoErrorf(t, mock.ExpectationsWereMet(), "sql expectations weren't met")
@@ -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) {

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,