msb-public
/
helm
mirror of https://github.com/helm/helm
1
0
Code Issues Projects Releases Wiki Activity

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

Browse Source 
refactor: convert tests to testify assert/require in pkg/storage/driver
Signed-off-by: Matthieu MOREL <matthieu.morel35@gmail.com>
pull/32429/head
Matthieu MOREL 6 days ago
parent 3f1f55c4c8
commit dc66ee7be7
4 changed files with 112 additions and 280 deletions
Show Stats Download Patch File Download Diff File

20
pkg/chart/v2/metadata_test.go
Unescape View File

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

129
pkg/downloader/chart_downloader_test.go
Unescape View File

@ -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)
}
if v.FileHash == "" {
t.Error("File hash was empty, but verification is required.")
}
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 _, 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")

115
pkg/storage/driver/secrets_test.go
Unescape View File

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

128
pkg/storage/driver/sql_test.go
Unescape View File

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

Write Preview
Loading…
Cancel
Save