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

Merge pull request #32429 from mmorel-35/testifylint-manual-assert-pkg-14

Browse Source 
chore(pkg): refactor: convert tests to testify assert/require part 14
pull/32453/head
Terry Howe 2 months ago committed by GitHub
parent da9e2b6bab dc66ee7be7
commit ea9e38035d
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
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 package v2
import ( import (
"errors"
"testing" "testing"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
) )
func TestValidate(t *testing.T) { func TestValidate(t *testing.T) {
@ -192,21 +194,13 @@ func TestValidate(t *testing.T) {
for _, tt := range tests { for _, tt := range tests {
result := tt.md.Validate() result := tt.md.Validate()
if !errors.Is(result, tt.err) { assert.ErrorIs(t, result, tt.err, "expected %q, got %q in test %q", tt.err, result, tt.name)
t.Errorf("expected %q, got %q in test %q", tt.err, result, tt.name)
}
} }
} }
func TestValidate_sanitize(t *testing.T) { func TestValidate_sanitize(t *testing.T) {
md := &Metadata{APIVersion: "v2", Name: "test", Version: "1.0", Description: "\adescr\u0081iption\rtest", Maintainers: []*Maintainer{{Name: "\r"}}} md := &Metadata{APIVersion: "v2", Name: "test", Version: "1.0", Description: "\adescr\u0081iption\rtest", Maintainers: []*Maintainer{{Name: "\r"}}}
if err := md.Validate(); err != nil { require.NoError(t, md.Validate())
t.Fatalf("unexpected error: %s", err) 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")
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")
}
} }

129
pkg/downloader/chart_downloader_test.go
Unescape View File

@ -18,7 +18,6 @@ package downloader
import ( import (
"crypto/sha256" "crypto/sha256"
"encoding/hex" "encoding/hex"
"errors"
"os" "os"
"path/filepath" "path/filepath"
"testing" "testing"
@ -69,9 +68,7 @@ func TestResolveChartRef(t *testing.T) {
// Create a mock registry client for OCI references // Create a mock registry client for OCI references
registryClient, err := registry.NewClient() registryClient, err := registry.NewClient()
if err != nil { require.NoError(t, err)
t.Fatal(err)
}
c := ChartDownloader{ c := ChartDownloader{
Out: os.Stderr, Out: os.Stderr,
@ -93,9 +90,8 @@ func TestResolveChartRef(t *testing.T) {
t.Errorf("%s: failed with error %q", tt.name, err) t.Errorf("%s: failed with error %q", tt.name, err)
continue continue
} }
if got := u.String(); got != tt.expect { got := u.String()
t.Errorf("%s: expected %s, got %s", tt.name, tt.expect, got) 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) { 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") v, err := VerifyChart("testdata/signtest-0.1.0.tgz", "testdata/signtest-0.1.0.tgz.prov", "testdata/helm-test-key.pub")
if err != nil { require.NoError(t, err)
t.Fatal(err)
}
// The verification is tested at length in the provenance package. Here, // The verification is tested at length in the provenance package. Here,
// we just want a quick sanity check that the v is not empty. // we just want a quick sanity check that the v is not empty.
if v.FileHash == "" { assert.NotEmpty(t, v.FileHash, "Digest missing")
t.Error("Digest missing")
}
} }
func TestIsTar(t *testing.T) { func TestIsTar(t *testing.T) {
@ -183,9 +175,7 @@ func TestIsTar(t *testing.T) {
} }
for src, expect := range tests { for src, expect := range tests {
if isTar(src) != expect { assert.Equal(t, expect, isTar(src), "%q should be %t", src, expect)
t.Errorf("%q should be %t", src, expect)
}
} }
} }
@ -196,13 +186,8 @@ func TestDownloadTo(t *testing.T) {
repotest.WithMiddleware(repotest.BasicAuthMiddleware(t)), repotest.WithMiddleware(repotest.BasicAuthMiddleware(t)),
) )
defer srv.Stop() defer srv.Stop()
if err := srv.CreateIndex(); err != nil { require.NoError(t, srv.CreateIndex())
t.Fatal(err) require.NoError(t, srv.LinkIndices())
}
if err := srv.LinkIndices(); err != nil {
t.Fatal(err)
}
contentCache := t.TempDir() contentCache := t.TempDir()
@ -226,21 +211,14 @@ func TestDownloadTo(t *testing.T) {
cname := "/signtest-0.1.0.tgz" cname := "/signtest-0.1.0.tgz"
dest := srv.Root() dest := srv.Root()
where, v, err := c.DownloadTo(srv.URL()+cname, "", dest) where, v, err := c.DownloadTo(srv.URL()+cname, "", dest)
if err != nil { require.NoError(t, err)
t.Fatal(err)
}
if expect := filepath.Join(dest, cname); where != expect { expect := filepath.Join(dest, cname)
t.Errorf("Expected download to %s, got %s", expect, where) 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 { _, err = os.Stat(filepath.Join(dest, cname))
t.Error(err) assert.NoError(t, err)
}
} }
func TestDownloadTo_TLS(t *testing.T) { func TestDownloadTo_TLS(t *testing.T) {
@ -251,12 +229,8 @@ func TestDownloadTo_TLS(t *testing.T) {
repotest.WithTLSConfig(repotest.MakeTestTLSConfig(t, "../../testdata")), repotest.WithTLSConfig(repotest.MakeTestTLSConfig(t, "../../testdata")),
) )
defer srv.Stop() defer srv.Stop()
if err := srv.CreateIndex(); err != nil { require.NoError(t, srv.CreateIndex())
t.Fatal(err) require.NoError(t, srv.LinkIndices())
}
if err := srv.LinkIndices(); err != nil {
t.Fatal(err)
}
repoConfig := filepath.Join(srv.Root(), "repositories.yaml") repoConfig := filepath.Join(srv.Root(), "repositories.yaml")
repoCache := srv.Root() repoCache := srv.Root()
@ -285,22 +259,15 @@ func TestDownloadTo_TLS(t *testing.T) {
cname := "test/signtest" cname := "test/signtest"
dest := srv.Root() dest := srv.Root()
where, v, err := c.DownloadTo(cname, "", dest) where, v, err := c.DownloadTo(cname, "", dest)
if err != nil { require.NoError(t, err)
t.Fatal(err)
}
target := filepath.Join(dest, "signtest-0.1.0.tgz") target := filepath.Join(dest, "signtest-0.1.0.tgz")
if expect := target; where != expect { expect := target
t.Errorf("Expected download to %s, got %s", expect, where) 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 == "" { _, err = os.Stat(target)
t.Error("File hash was empty, but verification is required.") assert.NoError(t, err)
}
if _, err := os.Stat(target); err != nil {
t.Error(err)
}
} }
func TestDownloadTo_VerifyLater(t *testing.T) { func TestDownloadTo_VerifyLater(t *testing.T) {
@ -314,9 +281,7 @@ func TestDownloadTo_VerifyLater(t *testing.T) {
repotest.WithChartSourceGlob("testdata/*.tgz*"), repotest.WithChartSourceGlob("testdata/*.tgz*"),
) )
defer srv.Stop() defer srv.Stop()
if err := srv.LinkIndices(); err != nil { require.NoError(t, srv.LinkIndices())
t.Fatal(err)
}
contentCache := t.TempDir() contentCache := t.TempDir()
c := ChartDownloader{ c := ChartDownloader{
@ -333,20 +298,16 @@ func TestDownloadTo_VerifyLater(t *testing.T) {
} }
cname := "/signtest-0.1.0.tgz" cname := "/signtest-0.1.0.tgz"
where, _, err := c.DownloadTo(srv.URL()+cname, "", dest) where, _, err := c.DownloadTo(srv.URL()+cname, "", dest)
if err != nil { require.NoError(t, err)
t.Fatal(err)
}
if expect := filepath.Join(dest, cname); where != expect { expect := filepath.Join(dest, cname)
t.Errorf("Expected download to %s, got %s", expect, where) assert.Equalf(t, expect, where, "Expected download to %s, got %s", expect, where)
}
if _, err := os.Stat(filepath.Join(dest, cname)); err != nil { _, err = os.Stat(filepath.Join(dest, cname))
t.Fatal(err) require.NoError(t, err)
}
if _, err := os.Stat(filepath.Join(dest, cname+".prov")); err != nil { _, err = os.Stat(filepath.Join(dest, cname+".prov"))
t.Fatal(err) require.NoError(t, err)
}
} }
func TestScanReposForURL(t *testing.T) { func TestScanReposForURL(t *testing.T) {
@ -363,24 +324,17 @@ func TestScanReposForURL(t *testing.T) {
u := "http://example.com/alpine-0.2.0.tgz" u := "http://example.com/alpine-0.2.0.tgz"
rf, err := repo.LoadFile(repoConfig) rf, err := repo.LoadFile(repoConfig)
if err != nil { require.NoError(t, err)
t.Fatal(err)
}
entry, err := c.scanReposForURL(u, rf) entry, err := c.scanReposForURL(u, rf)
if err != nil { require.NoError(t, err)
t.Fatal(err)
}
if entry.Name != "testing" { assert.Equal(t, "testing", entry.Name, "Unexpected repo %q for URL %q", entry.Name, u)
t.Errorf("Unexpected repo %q for URL %q", entry.Name, u)
}
// A lookup failure should produce an ErrNoOwnerRepo // A lookup failure should produce an ErrNoOwnerRepo
u = "https://no.such.repo/foo/bar-1.23.4.tgz" u = "https://no.such.repo/foo/bar-1.23.4.tgz"
if _, err = c.scanReposForURL(u, rf); !errors.Is(err, ErrNoOwnerRepo) { _, err = c.scanReposForURL(u, rf)
t.Fatalf("expected ErrNoOwnerRepo, got %v", err) require.ErrorIs(t, err, ErrNoOwnerRepo)
}
} }
func TestDownloadToCache(t *testing.T) { func TestDownloadToCache(t *testing.T) {
@ -388,12 +342,8 @@ func TestDownloadToCache(t *testing.T) {
repotest.WithChartSourceGlob("testdata/*.tgz*"), repotest.WithChartSourceGlob("testdata/*.tgz*"),
) )
defer srv.Stop() defer srv.Stop()
if err := srv.CreateIndex(); err != nil { require.NoError(t, srv.CreateIndex())
t.Fatal(err) require.NoError(t, srv.LinkIndices())
}
if err := srv.LinkIndices(); err != nil {
t.Fatal(err)
}
// The repo file needs to point to our server. // The repo file needs to point to our server.
repoFile := filepath.Join(srv.Root(), "repositories.yaml") repoFile := filepath.Join(srv.Root(), "repositories.yaml")
@ -431,6 +381,7 @@ func TestDownloadToCache(t *testing.T) {
// Check that it's in the cache // Check that it's in the cache
digest, _, err := c.ResolveChartVersion("test/signtest", "0.1.0") digest, _, err := c.ResolveChartVersion("test/signtest", "0.1.0")
require.NoError(t, err) require.NoError(t, err)
digestBytes, err := hex.DecodeString(digest) digestBytes, err := hex.DecodeString(digest)
require.NoError(t, err) require.NoError(t, err)
var digestArray [sha256.Size]byte var digestArray [sha256.Size]byte
@ -472,6 +423,7 @@ func TestDownloadToCache(t *testing.T) {
// Check that both chart and prov are in cache // Check that both chart and prov are in cache
digest, _, err := c.ResolveChartVersion("test/signtest", "0.1.0") digest, _, err := c.ResolveChartVersion("test/signtest", "0.1.0")
require.NoError(t, err) require.NoError(t, err)
digestBytes, err := hex.DecodeString(digest) digestBytes, err := hex.DecodeString(digest)
require.NoError(t, err) require.NoError(t, err)
var digestArray [sha256.Size]byte var digestArray [sha256.Size]byte
@ -479,6 +431,7 @@ func TestDownloadToCache(t *testing.T) {
_, err = c.Cache.Get(digestArray, CacheChart) _, err = c.Cache.Get(digestArray, CacheChart)
require.NoError(t, err, "chart should be in cache") require.NoError(t, err, "chart should be in cache")
_, err = c.Cache.Get(digestArray, CacheProv) _, err = c.Cache.Get(digestArray, CacheProv)
require.NoError(t, err, "provenance file should be in cache") 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 ( import (
"encoding/base64" "encoding/base64"
"encoding/json" "encoding/json"
"errors"
"reflect" "reflect"
"testing" "testing"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
v1 "k8s.io/api/core/v1" v1 "k8s.io/api/core/v1"
"helm.sh/helm/v4/pkg/release" "helm.sh/helm/v4/pkg/release"
@ -29,9 +30,7 @@ import (
func TestSecretName(t *testing.T) { func TestSecretName(t *testing.T) {
c := newTestFixtureSecrets(t) c := newTestFixtureSecrets(t)
if c.Name() != SecretsDriverName { assert.Equal(t, SecretsDriverName, c.Name(), "Expected name to be %q, got %q", SecretsDriverName, c.Name())
t.Errorf("Expected name to be %q, got %q", SecretsDriverName, c.Name())
}
} }
func TestSecretGet(t *testing.T) { func TestSecretGet(t *testing.T) {
@ -45,13 +44,9 @@ func TestSecretGet(t *testing.T) {
// get release with key // get release with key
got, err := secrets.Get(key) got, err := secrets.Get(key)
if err != nil { require.NoError(t, err, "Failed to get release")
t.Fatalf("Failed to get release: %s", err)
}
// compare fetched release with original // compare fetched release with original
if !reflect.DeepEqual(rel, got) { assert.Truef(t, reflect.DeepEqual(rel, got), "Expected {%v}, got {%v}", rel, got)
t.Errorf("Expected {%v}, got {%v}", rel, got)
}
} }
func TestUNcompressedSecretGet(t *testing.T) { func TestUNcompressedSecretGet(t *testing.T) {
@ -63,13 +58,9 @@ func TestUNcompressedSecretGet(t *testing.T) {
// Create a test fixture which contains an uncompressed release // Create a test fixture which contains an uncompressed release
secret, err := newSecretsObject(key, rel, nil) secret, err := newSecretsObject(key, rel, nil)
if err != nil { require.NoError(t, err, "Failed to create secret")
t.Fatalf("Failed to create secret: %s", err)
}
b, err := json.Marshal(rel) b, err := json.Marshal(rel)
if err != nil { require.NoError(t, err, "Failed to marshal release")
t.Fatalf("Failed to marshal release: %s", err)
}
secret.Data["release"] = []byte(base64.StdEncoding.EncodeToString(b)) secret.Data["release"] = []byte(base64.StdEncoding.EncodeToString(b))
var mock MockSecretsInterface var mock MockSecretsInterface
mock.objects = map[string]*v1.Secret{key: secret} mock.objects = map[string]*v1.Secret{key: secret}
@ -77,13 +68,9 @@ func TestUNcompressedSecretGet(t *testing.T) {
// get release with key // get release with key
got, err := secrets.Get(key) got, err := secrets.Get(key)
if err != nil { require.NoError(t, err, "Failed to get release")
t.Fatalf("Failed to get release: %s", err)
}
// compare fetched release with original // compare fetched release with original
if !reflect.DeepEqual(rel, got) { assert.Truef(t, reflect.DeepEqual(rel, got), "Expected {%v}, got {%v}", rel, got)
t.Errorf("Expected {%v}, got {%v}", rel, got)
}
} }
func TestSecretList(t *testing.T) { func TestSecretList(t *testing.T) {
@ -102,12 +89,8 @@ func TestSecretList(t *testing.T) {
return rls.Info.Status == common.StatusUninstalled return rls.Info.Status == common.StatusUninstalled
}) })
// check // check
if err != nil { require.NoError(t, err, "Failed to list deleted")
t.Errorf("Failed to list deleted: %s", err) assert.Len(t, del, 2, "Expected 2 deleted, got %d:\n%v\n", len(del), del)
}
if len(del) != 2 {
t.Errorf("Expected 2 deleted, got %d:\n%v\n", len(del), del)
}
// list all deployed releases // list all deployed releases
dpl, err := secrets.List(func(rel release.Releaser) bool { dpl, err := secrets.List(func(rel release.Releaser) bool {
@ -115,12 +98,8 @@ func TestSecretList(t *testing.T) {
return rls.Info.Status == common.StatusDeployed return rls.Info.Status == common.StatusDeployed
}) })
// check // check
if err != nil { require.NoError(t, err, "Failed to list deployed")
t.Errorf("Failed to list deployed: %s", err) assert.Len(t, dpl, 2, "Expected 2 deployed, got %d", len(dpl))
}
if len(dpl) != 2 {
t.Errorf("Expected 2 deployed, got %d", len(dpl))
}
// list all superseded releases // list all superseded releases
ssd, err := secrets.List(func(rel release.Releaser) bool { ssd, err := secrets.List(func(rel release.Releaser) bool {
@ -128,22 +107,14 @@ func TestSecretList(t *testing.T) {
return rls.Info.Status == common.StatusSuperseded return rls.Info.Status == common.StatusSuperseded
}) })
// check // check
if err != nil { require.NoError(t, err, "Failed to list superseded")
t.Errorf("Failed to list superseded: %s", err) assert.Len(t, ssd, 2, "Expected 2 superseded, got %d", len(ssd))
}
if len(ssd) != 2 {
t.Errorf("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. // Check if release having both system and custom labels, this is needed to ensure that selector filtering would work.
rls := convertReleaserToV1(t, ssd[0]) rls := convertReleaserToV1(t, ssd[0])
_, ok := rls.Labels["name"] _, ok := rls.Labels["name"]
if !ok { require.True(t, ok, "Expected 'name' label in results, actual %v", rls.Labels)
t.Fatalf("Expected 'name' label in results, actual %v", rls.Labels)
}
_, ok = rls.Labels["key1"] _, ok = rls.Labels["key1"]
if !ok { require.True(t, ok, "Expected 'key1' label in results, actual %v", rls.Labels)
t.Fatalf("Expected 'key1' label in results, actual %v", rls.Labels)
}
} }
func TestSecretQuery(t *testing.T) { func TestSecretQuery(t *testing.T) {
@ -157,17 +128,11 @@ func TestSecretQuery(t *testing.T) {
}...) }...)
rls, err := secrets.Query(map[string]string{"status": "deployed"}) rls, err := secrets.Query(map[string]string{"status": "deployed"})
if err != nil { require.NoError(t, err, "Failed to query")
t.Fatalf("Failed to query: %s", err) require.Len(t, rls, 2, "Expected 2 results, actual %d", len(rls))
}
if len(rls) != 2 {
t.Fatalf("Expected 2 results, actual %d", len(rls))
}
_, err = secrets.Query(map[string]string{"name": "notExist"}) _, err = secrets.Query(map[string]string{"name": "notExist"})
if !errors.Is(err, ErrReleaseNotFound) { assert.ErrorIs(t, err, ErrReleaseNotFound)
t.Errorf("Expected {%v}, got {%v}", ErrReleaseNotFound, err)
}
} }
func TestSecretCreate(t *testing.T) { func TestSecretCreate(t *testing.T) {
@ -180,20 +145,14 @@ func TestSecretCreate(t *testing.T) {
rel := releaseStub(name, vers, namespace, common.StatusDeployed) rel := releaseStub(name, vers, namespace, common.StatusDeployed)
// store the release in a secret // store the release in a secret
if err := secrets.Create(key, rel); err != nil { require.NoErrorf(t, secrets.Create(key, rel), "Failed to create release with key %q", key)
t.Fatalf("Failed to create release with key %q: %s", key, err)
}
// get the release back // get the release back
got, err := secrets.Get(key) got, err := secrets.Get(key)
if err != nil { require.NoError(t, err, "Failed to get release with key %q", key)
t.Fatalf("Failed to get release with key %q: %s", key, err)
}
// compare created release with original // compare created release with original
if !reflect.DeepEqual(rel, got) { assert.Truef(t, reflect.DeepEqual(rel, got), "Expected {%v}, got {%v}", rel, got)
t.Errorf("Expected {%v}, got {%v}", rel, got)
}
} }
func TestSecretUpdate(t *testing.T) { func TestSecretUpdate(t *testing.T) {
@ -209,21 +168,15 @@ func TestSecretUpdate(t *testing.T) {
rel.Info.Status = common.StatusSuperseded rel.Info.Status = common.StatusSuperseded
// perform the update // perform the update
if err := secrets.Update(key, rel); err != nil { require.NoErrorf(t, secrets.Update(key, rel), "Failed to update release")
t.Fatalf("Failed to update release: %s", err)
}
// fetch the updated release // fetch the updated release
goti, err := secrets.Get(key) goti, err := secrets.Get(key)
if err != nil { require.NoError(t, err, "Failed to get release with key %q", key)
t.Fatalf("Failed to get release with key %q: %s", key, err)
}
got := convertReleaserToV1(t, goti) got := convertReleaserToV1(t, goti)
// check release has actually been updated by comparing modified fields // check release has actually been updated by comparing modified fields
if rel.Info.Status != got.Info.Status { assert.Equal(t, got.Info.Status, rel.Info.Status, "Expected status %s, got status %s", rel.Info.Status.String(), got.Info.Status.String())
t.Errorf("Expected status %s, got status %s", rel.Info.Status.String(), got.Info.Status.String())
}
} }
func TestSecretDelete(t *testing.T) { func TestSecretDelete(t *testing.T) {
@ -237,20 +190,12 @@ func TestSecretDelete(t *testing.T) {
// perform the delete on a non-existing release // perform the delete on a non-existing release
_, err := secrets.Delete("nonexistent") _, err := secrets.Delete("nonexistent")
if !errors.Is(err, ErrReleaseNotFound) { require.ErrorIs(t, err, ErrReleaseNotFound, "Expected ErrReleaseNotFound")
t.Fatalf("Expected ErrReleaseNotFound, got: {%v}", err)
}
// perform the delete // perform the delete
rls, err := secrets.Delete(key) rls, err := secrets.Delete(key)
if err != nil { require.NoError(t, err, "Failed to delete release with key %q", key)
t.Fatalf("Failed to delete release with key %q: %s", key, err) assert.Truef(t, reflect.DeepEqual(rel, rls), "Expected {%v}, got {%v}", rel, rls)
}
if !reflect.DeepEqual(rel, rls) {
t.Errorf("Expected {%v}, got {%v}", rel, rls)
}
_, err = secrets.Get(key) _, err = secrets.Get(key)
if !errors.Is(err, ErrReleaseNotFound) { assert.ErrorIs(t, err, ErrReleaseNotFound)
t.Errorf("Expected {%v}, got {%v}", ErrReleaseNotFound, err)
}
} }

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

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

Write Preview
Loading…
Cancel
Save