chore(pkg): refactor: convert tests to testify assert/require part 14

refactor: convert tests to testify assert/require in pkg/storage/driver
Signed-off-by: Matthieu MOREL <matthieu.morel35@gmail.com>

pkg/chart/v2/metadata_test.go

@@ -16,8 +16,10 @@ limitations under the License.
 package v2
 
 import (
-	"errors"
 	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestValidate(t *testing.T) {
@@ -192,21 +194,13 @@ func TestValidate(t *testing.T) {
 
 	for _, tt := range tests {
 		result := tt.md.Validate()
-		if !errors.Is(result, tt.err) {
-			t.Errorf("expected %q, got %q in test %q", tt.err, result, tt.name)
-		}
+		assert.ErrorIs(t, result, tt.err, "expected %q, got %q in test %q", tt.err, result, tt.name)
 	}
 }
 
 func TestValidate_sanitize(t *testing.T) {
 	md := &Metadata{APIVersion: "v2", Name: "test", Version: "1.0", Description: "\adescr\u0081iption\rtest", Maintainers: []*Maintainer{{Name: "\r"}}}
-	if err := md.Validate(); err != nil {
-		t.Fatalf("unexpected error: %s", err)
-	}
-	if md.Description != "description test" {
-		t.Fatalf("description was not sanitized: %q", md.Description)
-	}
-	if md.Maintainers[0].Name != " " {
-		t.Fatal("maintainer name was not sanitized")
-	}
+	require.NoError(t, md.Validate())
+	require.Equal(t, "description test", md.Description, "description was not sanitized: %q", md.Description)
+	require.Equal(t, " ", md.Maintainers[0].Name, "maintainer name was not sanitized")
 }

pkg/downloader/chart_downloader_test.go

@@ -18,7 +18,6 @@ package downloader
 import (
 	"crypto/sha256"
 	"encoding/hex"
-	"errors"
 	"os"
 	"path/filepath"
 	"testing"
@@ -69,9 +68,7 @@ func TestResolveChartRef(t *testing.T) {
 
 	// Create a mock registry client for OCI references
 	registryClient, err := registry.NewClient()
-	if err != nil {
-		t.Fatal(err)
-	}
+	require.NoError(t, err)
 
 	c := ChartDownloader{
 		Out:              os.Stderr,
@@ -93,9 +90,8 @@ func TestResolveChartRef(t *testing.T) {
 			t.Errorf("%s: failed with error %q", tt.name, err)
 			continue
 		}
-		if got := u.String(); got != tt.expect {
-			t.Errorf("%s: expected %s, got %s", tt.name, tt.expect, got)
-		}
+		got := u.String()
+		assert.Equalf(t, tt.expect, got, "%s: expected %s, got %s", tt.name, tt.expect, got)
 	}
 }
 
@@ -162,14 +158,10 @@ func TestResolveChartOpts(t *testing.T) {
 
 func TestVerifyChart(t *testing.T) {
 	v, err := VerifyChart("testdata/signtest-0.1.0.tgz", "testdata/signtest-0.1.0.tgz.prov", "testdata/helm-test-key.pub")
-	if err != nil {
-		t.Fatal(err)
-	}
+	require.NoError(t, err)
 	// The verification is tested at length in the provenance package. Here,
 	// we just want a quick sanity check that the v is not empty.
-	if v.FileHash == "" {
-		t.Error("Digest missing")
-	}
+	assert.NotEmpty(t, v.FileHash, "Digest missing")
 }
 
 func TestIsTar(t *testing.T) {
@@ -183,9 +175,7 @@ func TestIsTar(t *testing.T) {
 	}
 
 	for src, expect := range tests {
-		if isTar(src) != expect {
-			t.Errorf("%q should be %t", src, expect)
-		}
+		assert.Equal(t, expect, isTar(src), "%q should be %t", src, expect)
 	}
 }
 
@@ -196,13 +186,8 @@ func TestDownloadTo(t *testing.T) {
 		repotest.WithMiddleware(repotest.BasicAuthMiddleware(t)),
 	)
 	defer srv.Stop()
-	if err := srv.CreateIndex(); err != nil {
-		t.Fatal(err)
-	}
-
-	if err := srv.LinkIndices(); err != nil {
-		t.Fatal(err)
-	}
+	require.NoError(t, srv.CreateIndex())
+	require.NoError(t, srv.LinkIndices())
 
 	contentCache := t.TempDir()
 
@@ -226,21 +211,14 @@ func TestDownloadTo(t *testing.T) {
 	cname := "/signtest-0.1.0.tgz"
 	dest := srv.Root()
 	where, v, err := c.DownloadTo(srv.URL()+cname, "", dest)
-	if err != nil {
-		t.Fatal(err)
-	}
+	require.NoError(t, err)
 
-	if expect := filepath.Join(dest, cname); where != expect {
-		t.Errorf("Expected download to %s, got %s", expect, where)
-	}
+	expect := filepath.Join(dest, cname)
+	assert.Equalf(t, expect, where, "Expected download to %s, got %s", expect, where)
+	assert.NotEmpty(t, v.FileHash, "File hash was empty, but verification is required.")
 
-	if v.FileHash == "" {
-		t.Error("File hash was empty, but verification is required.")
-	}
-
-	if _, err := os.Stat(filepath.Join(dest, cname)); err != nil {
-		t.Error(err)
-	}
+	_, err = os.Stat(filepath.Join(dest, cname))
+	assert.NoError(t, err)
 }
 
 func TestDownloadTo_TLS(t *testing.T) {
@@ -251,12 +229,8 @@ func TestDownloadTo_TLS(t *testing.T) {
 		repotest.WithTLSConfig(repotest.MakeTestTLSConfig(t, "../../testdata")),
 	)
 	defer srv.Stop()
-	if err := srv.CreateIndex(); err != nil {
-		t.Fatal(err)
-	}
-	if err := srv.LinkIndices(); err != nil {
-		t.Fatal(err)
-	}
+	require.NoError(t, srv.CreateIndex())
+	require.NoError(t, srv.LinkIndices())
 
 	repoConfig := filepath.Join(srv.Root(), "repositories.yaml")
 	repoCache := srv.Root()
@@ -285,22 +259,15 @@ func TestDownloadTo_TLS(t *testing.T) {
 	cname := "test/signtest"
 	dest := srv.Root()
 	where, v, err := c.DownloadTo(cname, "", dest)
-	if err != nil {
-		t.Fatal(err)
-	}
+	require.NoError(t, err)
 
 	target := filepath.Join(dest, "signtest-0.1.0.tgz")
-	if expect := target; where != expect {
-		t.Errorf("Expected download to %s, got %s", expect, where)
-	}
+	expect := target
+	assert.Equalf(t, expect, where, "Expected download to %s, got %s", expect, where)
+	assert.NotEmpty(t, v.FileHash, "File hash was empty, but verification is required.")
 
-	if v.FileHash == "" {
-		t.Error("File hash was empty, but verification is required.")
-	}
-
-	if _, err := os.Stat(target); err != nil {
-		t.Error(err)
-	}
+	_, err = os.Stat(target)
+	assert.NoError(t, err)
 }
 
 func TestDownloadTo_VerifyLater(t *testing.T) {
@@ -314,9 +281,7 @@ func TestDownloadTo_VerifyLater(t *testing.T) {
 		repotest.WithChartSourceGlob("testdata/*.tgz*"),
 	)
 	defer srv.Stop()
-	if err := srv.LinkIndices(); err != nil {
-		t.Fatal(err)
-	}
+	require.NoError(t, srv.LinkIndices())
 	contentCache := t.TempDir()
 
 	c := ChartDownloader{
@@ -333,20 +298,16 @@ func TestDownloadTo_VerifyLater(t *testing.T) {
 	}
 	cname := "/signtest-0.1.0.tgz"
 	where, _, err := c.DownloadTo(srv.URL()+cname, "", dest)
-	if err != nil {
-		t.Fatal(err)
-	}
+	require.NoError(t, err)
 
-	if expect := filepath.Join(dest, cname); where != expect {
-		t.Errorf("Expected download to %s, got %s", expect, where)
-	}
+	expect := filepath.Join(dest, cname)
+	assert.Equalf(t, expect, where, "Expected download to %s, got %s", expect, where)
 
-	if _, err := os.Stat(filepath.Join(dest, cname)); err != nil {
-		t.Fatal(err)
-	}
-	if _, err := os.Stat(filepath.Join(dest, cname+".prov")); err != nil {
-		t.Fatal(err)
-	}
+	_, err = os.Stat(filepath.Join(dest, cname))
+	require.NoError(t, err)
+
+	_, err = os.Stat(filepath.Join(dest, cname+".prov"))
+	require.NoError(t, err)
 }
 
 func TestScanReposForURL(t *testing.T) {
@@ -363,24 +324,17 @@ func TestScanReposForURL(t *testing.T) {
 
 	u := "http://example.com/alpine-0.2.0.tgz"
 	rf, err := repo.LoadFile(repoConfig)
-	if err != nil {
-		t.Fatal(err)
-	}
+	require.NoError(t, err)
 
 	entry, err := c.scanReposForURL(u, rf)
-	if err != nil {
-		t.Fatal(err)
-	}
+	require.NoError(t, err)
 
-	if entry.Name != "testing" {
-		t.Errorf("Unexpected repo %q for URL %q", entry.Name, u)
-	}
+	assert.Equal(t, "testing", entry.Name, "Unexpected repo %q for URL %q", entry.Name, u)
 
 	// A lookup failure should produce an ErrNoOwnerRepo
 	u = "https://no.such.repo/foo/bar-1.23.4.tgz"
-	if _, err = c.scanReposForURL(u, rf); !errors.Is(err, ErrNoOwnerRepo) {
-		t.Fatalf("expected ErrNoOwnerRepo, got %v", err)
-	}
+	_, err = c.scanReposForURL(u, rf)
+	require.ErrorIs(t, err, ErrNoOwnerRepo)
 }
 
 func TestDownloadToCache(t *testing.T) {
@@ -388,12 +342,8 @@ func TestDownloadToCache(t *testing.T) {
 		repotest.WithChartSourceGlob("testdata/*.tgz*"),
 	)
 	defer srv.Stop()
-	if err := srv.CreateIndex(); err != nil {
-		t.Fatal(err)
-	}
-	if err := srv.LinkIndices(); err != nil {
-		t.Fatal(err)
-	}
+	require.NoError(t, srv.CreateIndex())
+	require.NoError(t, srv.LinkIndices())
 
 	// The repo file needs to point to our server.
 	repoFile := filepath.Join(srv.Root(), "repositories.yaml")
@@ -431,6 +381,7 @@ func TestDownloadToCache(t *testing.T) {
 		// Check that it's in the cache
 		digest, _, err := c.ResolveChartVersion("test/signtest", "0.1.0")
 		require.NoError(t, err)
+
 		digestBytes, err := hex.DecodeString(digest)
 		require.NoError(t, err)
 		var digestArray [sha256.Size]byte
@@ -472,6 +423,7 @@ func TestDownloadToCache(t *testing.T) {
 		// Check that both chart and prov are in cache
 		digest, _, err := c.ResolveChartVersion("test/signtest", "0.1.0")
 		require.NoError(t, err)
+
 		digestBytes, err := hex.DecodeString(digest)
 		require.NoError(t, err)
 		var digestArray [sha256.Size]byte
@@ -479,6 +431,7 @@ func TestDownloadToCache(t *testing.T) {
 
 		_, err = c.Cache.Get(digestArray, CacheChart)
 		require.NoError(t, err, "chart should be in cache")
+
 		_, err = c.Cache.Get(digestArray, CacheProv)
 		require.NoError(t, err, "provenance file should be in cache")
 

pkg/storage/driver/secrets_test.go

@@ -16,10 +16,11 @@ package driver
 import (
 	"encoding/base64"
 	"encoding/json"
-	"errors"
 	"reflect"
 	"testing"
 
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 	v1 "k8s.io/api/core/v1"
 
 	"helm.sh/helm/v4/pkg/release"
@@ -29,9 +30,7 @@ import (
 
 func TestSecretName(t *testing.T) {
 	c := newTestFixtureSecrets(t)
-	if c.Name() != SecretsDriverName {
-		t.Errorf("Expected name to be %q, got %q", SecretsDriverName, c.Name())
-	}
+	assert.Equal(t, SecretsDriverName, c.Name(), "Expected name to be %q, got %q", SecretsDriverName, c.Name())
 }
 
 func TestSecretGet(t *testing.T) {
@@ -45,13 +44,9 @@ func TestSecretGet(t *testing.T) {
 
 	// get release with key
 	got, err := secrets.Get(key)
-	if err != nil {
-		t.Fatalf("Failed to get release: %s", err)
-	}
+	require.NoError(t, err, "Failed to get release")
 	// compare fetched release with original
-	if !reflect.DeepEqual(rel, got) {
-		t.Errorf("Expected {%v}, got {%v}", rel, got)
-	}
+	assert.Truef(t, reflect.DeepEqual(rel, got), "Expected {%v}, got {%v}", rel, got)
 }
 
 func TestUNcompressedSecretGet(t *testing.T) {
@@ -63,13 +58,9 @@ func TestUNcompressedSecretGet(t *testing.T) {
 
 	// Create a test fixture which contains an uncompressed release
 	secret, err := newSecretsObject(key, rel, nil)
-	if err != nil {
-		t.Fatalf("Failed to create secret: %s", err)
-	}
+	require.NoError(t, err, "Failed to create secret")
 	b, err := json.Marshal(rel)
-	if err != nil {
-		t.Fatalf("Failed to marshal release: %s", err)
-	}
+	require.NoError(t, err, "Failed to marshal release")
 	secret.Data["release"] = []byte(base64.StdEncoding.EncodeToString(b))
 	var mock MockSecretsInterface
 	mock.objects = map[string]*v1.Secret{key: secret}
@@ -77,13 +68,9 @@ func TestUNcompressedSecretGet(t *testing.T) {
 
 	// get release with key
 	got, err := secrets.Get(key)
-	if err != nil {
-		t.Fatalf("Failed to get release: %s", err)
-	}
+	require.NoError(t, err, "Failed to get release")
 	// compare fetched release with original
-	if !reflect.DeepEqual(rel, got) {
-		t.Errorf("Expected {%v}, got {%v}", rel, got)
-	}
+	assert.Truef(t, reflect.DeepEqual(rel, got), "Expected {%v}, got {%v}", rel, got)
 }
 
 func TestSecretList(t *testing.T) {
@@ -102,12 +89,8 @@ func TestSecretList(t *testing.T) {
 		return rls.Info.Status == common.StatusUninstalled
 	})
 	// check
-	if err != nil {
-		t.Errorf("Failed to list deleted: %s", err)
-	}
-	if len(del) != 2 {
-		t.Errorf("Expected 2 deleted, got %d:\n%v\n", len(del), del)
-	}
+	require.NoError(t, err, "Failed to list deleted")
+	assert.Len(t, del, 2, "Expected 2 deleted, got %d:\n%v\n", len(del), del)
 
 	// list all deployed releases
 	dpl, err := secrets.List(func(rel release.Releaser) bool {
@@ -115,12 +98,8 @@ func TestSecretList(t *testing.T) {
 		return rls.Info.Status == common.StatusDeployed
 	})
 	// check
-	if err != nil {
-		t.Errorf("Failed to list deployed: %s", err)
-	}
-	if len(dpl) != 2 {
-		t.Errorf("Expected 2 deployed, got %d", len(dpl))
-	}
+	require.NoError(t, err, "Failed to list deployed")
+	assert.Len(t, dpl, 2, "Expected 2 deployed, got %d", len(dpl))
 
 	// list all superseded releases
 	ssd, err := secrets.List(func(rel release.Releaser) bool {
@@ -128,22 +107,14 @@ func TestSecretList(t *testing.T) {
 		return rls.Info.Status == common.StatusSuperseded
 	})
 	// check
-	if err != nil {
-		t.Errorf("Failed to list superseded: %s", err)
-	}
-	if len(ssd) != 2 {
-		t.Errorf("Expected 2 superseded, got %d", len(ssd))
-	}
+	require.NoError(t, err, "Failed to list superseded")
+	assert.Len(t, ssd, 2, "Expected 2 superseded, got %d", len(ssd))
 	// 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"]
-	if !ok {
-		t.Fatalf("Expected 'name' label in results, actual %v", rls.Labels)
-	}
+	require.True(t, ok, "Expected 'name' label in results, actual %v", rls.Labels)
 	_, ok = rls.Labels["key1"]
-	if !ok {
-		t.Fatalf("Expected 'key1' label in results, actual %v", rls.Labels)
-	}
+	require.True(t, ok, "Expected 'key1' label in results, actual %v", rls.Labels)
 }
 
 func TestSecretQuery(t *testing.T) {
@@ -157,17 +128,11 @@ func TestSecretQuery(t *testing.T) {
 	}...)
 
 	rls, err := secrets.Query(map[string]string{"status": "deployed"})
-	if err != nil {
-		t.Fatalf("Failed to query: %s", err)
-	}
-	if len(rls) != 2 {
-		t.Fatalf("Expected 2 results, actual %d", len(rls))
-	}
+	require.NoError(t, err, "Failed to query")
+	require.Len(t, rls, 2, "Expected 2 results, actual %d", len(rls))
 
 	_, err = secrets.Query(map[string]string{"name": "notExist"})
-	if !errors.Is(err, ErrReleaseNotFound) {
-		t.Errorf("Expected {%v}, got {%v}", ErrReleaseNotFound, err)
-	}
+	assert.ErrorIs(t, err, ErrReleaseNotFound)
 }
 
 func TestSecretCreate(t *testing.T) {
@@ -180,20 +145,14 @@ func TestSecretCreate(t *testing.T) {
 	rel := releaseStub(name, vers, namespace, common.StatusDeployed)
 
 	// store the release in a secret
-	if err := secrets.Create(key, rel); err != nil {
-		t.Fatalf("Failed to create release with key %q: %s", key, err)
-	}
+	require.NoErrorf(t, secrets.Create(key, rel), "Failed to create release with key %q", key)
 
 	// get the release back
 	got, err := secrets.Get(key)
-	if err != nil {
-		t.Fatalf("Failed to get release with key %q: %s", key, err)
-	}
+	require.NoError(t, err, "Failed to get release with key %q", key)
 
 	// compare created release with original
-	if !reflect.DeepEqual(rel, got) {
-		t.Errorf("Expected {%v}, got {%v}", rel, got)
-	}
+	assert.Truef(t, reflect.DeepEqual(rel, got), "Expected {%v}, got {%v}", rel, got)
 }
 
 func TestSecretUpdate(t *testing.T) {
@@ -209,21 +168,15 @@ func TestSecretUpdate(t *testing.T) {
 	rel.Info.Status = common.StatusSuperseded
 
 	// perform the update
-	if err := secrets.Update(key, rel); err != nil {
-		t.Fatalf("Failed to update release: %s", err)
-	}
+	require.NoErrorf(t, secrets.Update(key, rel), "Failed to update release")
 
 	// fetch the updated release
 	goti, err := secrets.Get(key)
-	if err != nil {
-		t.Fatalf("Failed to get release with key %q: %s", key, err)
-	}
+	require.NoError(t, err, "Failed to get release with key %q", key)
 	got := convertReleaserToV1(t, goti)
 
 	// check release has actually been updated by comparing modified fields
-	if rel.Info.Status != got.Info.Status {
-		t.Errorf("Expected status %s, got status %s", rel.Info.Status.String(), got.Info.Status.String())
-	}
+	assert.Equal(t, got.Info.Status, rel.Info.Status, "Expected status %s, got status %s", rel.Info.Status.String(), got.Info.Status.String())
 }
 
 func TestSecretDelete(t *testing.T) {
@@ -237,20 +190,12 @@ func TestSecretDelete(t *testing.T) {
 
 	// perform the delete on a non-existing release
 	_, err := secrets.Delete("nonexistent")
-	if !errors.Is(err, ErrReleaseNotFound) {
-		t.Fatalf("Expected ErrReleaseNotFound, got: {%v}", err)
-	}
+	require.ErrorIs(t, err, ErrReleaseNotFound, "Expected ErrReleaseNotFound")
 
 	// perform the delete
 	rls, err := secrets.Delete(key)
-	if err != nil {
-		t.Fatalf("Failed to delete release with key %q: %s", key, err)
-	}
-	if !reflect.DeepEqual(rel, rls) {
-		t.Errorf("Expected {%v}, got {%v}", rel, rls)
-	}
+	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)
 	_, err = secrets.Get(key)
-	if !errors.Is(err, ErrReleaseNotFound) {
-		t.Errorf("Expected {%v}, got {%v}", ErrReleaseNotFound, err)
-	}
+	assert.ErrorIs(t, err, ErrReleaseNotFound)
 }

pkg/storage/driver/sql_test.go

@@ -24,6 +24,8 @@ import (
 
 	sqlmock "github.com/DATA-DOG/go-sqlmock"
 	migrate "github.com/rubenv/sql-migrate"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 
 	"helm.sh/helm/v4/pkg/release"
 	"helm.sh/helm/v4/pkg/release/common"
@@ -59,9 +61,7 @@ func (recentUnixTimestampArgument) Match(value driver.Value) bool {
 
 func TestSQLName(t *testing.T) {
 	sqlDriver, _ := newTestFixtureSQL(t)
-	if sqlDriver.Name() != SQLDriverName {
-		t.Errorf("Expected name to be %s, got %s", SQLDriverName, sqlDriver.Name())
-	}
+	assert.Equal(t, SQLDriverName, sqlDriver.Name(), "Expected name to be %s, got %s", SQLDriverName, sqlDriver.Name())
 }
 
 func TestSQLGet(t *testing.T) {
@@ -97,17 +97,10 @@ func TestSQLGet(t *testing.T) {
 	mockGetReleaseCustomLabels(mock, key, namespace, rel.Labels)
 
 	got, err := sqlDriver.Get(key)
-	if err != nil {
-		t.Fatalf("Failed to get release: %v", err)
-	}
+	require.NoError(t, err, "Failed to get release")
 
-	if !reflect.DeepEqual(rel, got) {
-		t.Errorf("Expected release {%v}, got {%v}", rel, got)
-	}
-
-	if err := mock.ExpectationsWereMet(); err != nil {
-		t.Errorf("sql expectations weren't met: %v", err)
-	}
+	assert.Truef(t, reflect.DeepEqual(rel, got), "Expected release {%v}, got {%v}", rel, got)
+	assert.NoErrorf(t, mock.ExpectationsWereMet(), "sql expectations weren't met")
 }
 
 func TestSQLList(t *testing.T) {
@@ -157,12 +150,8 @@ func TestSQLList(t *testing.T) {
 		return rls.Info.Status == common.StatusUninstalled
 	})
 	// check
-	if err != nil {
-		t.Errorf("Failed to list deleted: %v", err)
-	}
-	if len(del) != 2 {
-		t.Errorf("Expected 2 deleted, got %d:\n%v\n", len(del), del)
-	}
+	require.NoError(t, err, "Failed to list deleted")
+	assert.Len(t, del, 2, "Expected 2 deleted, got %d:\n%v\n", len(del), del)
 
 	// list all deployed releases
 	dpl, err := sqlDriver.List(func(rel release.Releaser) bool {
@@ -170,12 +159,8 @@ func TestSQLList(t *testing.T) {
 		return rls.Info.Status == common.StatusDeployed
 	})
 	// check
-	if err != nil {
-		t.Errorf("Failed to list deployed: %v", err)
-	}
-	if len(dpl) != 2 {
-		t.Errorf("Expected 2 deployed, got %d:\n%v\n", len(dpl), dpl)
-	}
+	require.NoError(t, err, "Failed to list deployed")
+	assert.Len(t, dpl, 2, "Expected 2 deployed, got %d:\n%v\n", len(dpl), dpl)
 
 	// list all superseded releases
 	ssd, err := sqlDriver.List(func(rel release.Releaser) bool {
@@ -183,27 +168,16 @@ func TestSQLList(t *testing.T) {
 		return rls.Info.Status == common.StatusSuperseded
 	})
 	// check
-	if err != nil {
-		t.Errorf("Failed to list superseded: %v", err)
-	}
-	if len(ssd) != 2 {
-		t.Errorf("Expected 2 superseded, got %d:\n%v\n", len(ssd), ssd)
-	}
-
-	if err := mock.ExpectationsWereMet(); err != nil {
-		t.Errorf("sql expectations weren't met: %v", err)
-	}
+	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.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"]
-	if !ok {
-		t.Fatalf("Expected 'name' label in results, actual %v", rls.Labels)
-	}
+	require.True(t, ok, "Expected 'name' label in results, actual %v", rls.Labels)
 	_, ok = rls.Labels["key1"]
-	if !ok {
-		t.Fatalf("Expected 'key1' label in results, actual %v", rls.Labels)
-	}
+	require.True(t, ok, "Expected 'key1' label in results, actual %v", rls.Labels)
 }
 
 func TestSqlCreate(t *testing.T) {
@@ -254,13 +228,8 @@ func TestSqlCreate(t *testing.T) {
 	}
 	mock.ExpectCommit()
 
-	if err := sqlDriver.Create(key, rel); err != nil {
-		t.Fatalf("failed to create release with key %s: %v", key, err)
-	}
-
-	if err := mock.ExpectationsWereMet(); err != nil {
-		t.Errorf("sql expectations weren't met: %v", err)
-	}
+	require.NoErrorf(t, sqlDriver.Create(key, rel), "failed to create release with key %s", key)
+	assert.NoErrorf(t, mock.ExpectationsWereMet(), "sql expectations weren't met")
 }
 
 func TestSqlCreateAlreadyExists(t *testing.T) {
@@ -315,13 +284,8 @@ func TestSqlCreateAlreadyExists(t *testing.T) {
 		).RowsWillBeClosed()
 	mock.ExpectRollback()
 
-	if err := sqlDriver.Create(key, rel); err == nil {
-		t.Fatalf("failed to create release with key %s: %v", key, err)
-	}
-
-	if err := mock.ExpectationsWereMet(); err != nil {
-		t.Errorf("sql expectations weren't met: %v", err)
-	}
+	require.Errorf(t, sqlDriver.Create(key, rel), "failed to create release with key %s", key)
+	assert.NoErrorf(t, mock.ExpectationsWereMet(), "sql expectations weren't met")
 }
 
 func TestSqlUpdate(t *testing.T) {
@@ -352,13 +316,8 @@ func TestSqlUpdate(t *testing.T) {
 		WithArgs(body, rel.Name, int(rel.Version), rel.Info.Status.String(), sqlReleaseDefaultOwner, recentUnixTimestamp(), key, namespace).
 		WillReturnResult(sqlmock.NewResult(0, 1))
 
-	if err := sqlDriver.Update(key, rel); err != nil {
-		t.Fatalf("failed to update release with key %s: %v", key, err)
-	}
-
-	if err := mock.ExpectationsWereMet(); err != nil {
-		t.Errorf("sql expectations weren't met: %v", err)
-	}
+	require.NoErrorf(t, sqlDriver.Update(key, rel), "failed to update release with key %s", key)
+	assert.NoErrorf(t, mock.ExpectationsWereMet(), "sql expectations weren't met")
 }
 
 func TestSqlQuery(t *testing.T) {
@@ -448,31 +407,20 @@ func TestSqlQuery(t *testing.T) {
 	mockGetReleaseCustomLabels(mock, "", deployedRelease.Namespace, deployedRelease.Labels)
 
 	_, err := sqlDriver.Query(labelSetUnknown)
-	if err == nil {
-		t.Errorf("Expected error {%v}, got nil", ErrReleaseNotFound)
-	} else if !errors.Is(err, ErrReleaseNotFound) {
-		t.Fatalf("failed to query for unknown smug-pigeon release: %v", err)
-	}
+	require.Errorf(t, err, "Expected error {%v}, got nil", ErrReleaseNotFound)
+	require.ErrorIsf(t, err, ErrReleaseNotFound, "failed to query for unknown smug-pigeon release")
 
 	results, err := sqlDriver.Query(labelSetDeployed)
-	if err != nil {
-		t.Fatalf("failed to query for deployed smug-pigeon release: %v", err)
-	}
+	require.NoError(t, err, "failed to query for deployed smug-pigeon release")
 
 	for _, res := range results {
-		if !reflect.DeepEqual(res, deployedRelease) {
-			t.Errorf("Expected release {%v}, got {%v}", deployedRelease, res)
-		}
+		assert.Truef(t, reflect.DeepEqual(res, deployedRelease), "Expected release {%v}, got {%v}", deployedRelease, res)
 	}
 
 	results, err = sqlDriver.Query(labelSetAll)
-	if err != nil {
-		t.Fatalf("failed to query release history for smug-pigeon: %v", err)
-	}
+	require.NoError(t, err, "failed to query release history for smug-pigeon")
 
-	if len(results) != 2 {
-		t.Errorf("expected a resultset of size 2, got %d", len(results))
-	}
+	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) {
@@ -480,9 +428,7 @@ func TestSqlQuery(t *testing.T) {
 		}
 	}
 
-	if err := mock.ExpectationsWereMet(); err != nil {
-		t.Errorf("sql expectations weren't met: %v", err)
-	}
+	assert.NoErrorf(t, mock.ExpectationsWereMet(), "sql expectations weren't met")
 }
 
 func TestSqlDelete(t *testing.T) {
@@ -544,16 +490,12 @@ func TestSqlDelete(t *testing.T) {
 	mock.ExpectCommit()
 
 	deletedRelease, err := sqlDriver.Delete(key)
-	if err := mock.ExpectationsWereMet(); err != nil {
-		t.Errorf("sql expectations weren't met: %v", err)
-	}
-	if err != nil {
-		t.Fatalf("failed to delete release with key %q: %v", key, err)
-	}
+	require.NoError(t, err)
+	err = mock.ExpectationsWereMet()
+	assert.NoErrorf(t, err, "sql expectations weren't met")
+	require.NoError(t, err, "failed to delete release with key %q", key)
 
-	if !reflect.DeepEqual(rel, deletedRelease) {
-		t.Errorf("Expected release {%v}, got {%v}", rel, deletedRelease)
-	}
+	assert.Truef(t, reflect.DeepEqual(rel, deletedRelease), "Expected release {%v}, got {%v}", rel, deletedRelease)
 }
 
 func mockGetReleaseCustomLabels(mock sqlmock.Sqlmock, key string, namespace string, labels map[string]string) {
@@ -621,8 +563,6 @@ func TestSqlCheckAppliedMigrations(t *testing.T) {
 			ExpectQuery("").
 			WillReturnRows(rows)
 		mock.ExpectCommit()
-		if sqlDriver.checkAlreadyApplied(c.migrationsToApply) != c.expectedResult {
-			t.Errorf("Test case: %v, Expected: %v, Have: %v, Explanation: %v", i, c.expectedResult, !c.expectedResult, c.errorExplanation)
-		}
+		assert.Equal(t, c.expectedResult, sqlDriver.checkAlreadyApplied(c.migrationsToApply), "Test case: %v, Expected: %v, Have: %v, Explanation: %v", i, c.expectedResult, !c.expectedResult, c.errorExplanation)
 	}
 }