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

chore(pkg): refactor: finer tests conversions to testify part 2

Browse Source 
#### Description

refactor: finer tests conversions to testify in pkg/storage/driver
Signed-off-by: Matthieu MOREL <matthieu.morel35@gmail.com>
pull/32466/head
Matthieu MOREL 6 days ago
parent 39231d01e1
commit 4d9c03f51c
16 changed files with 151 additions and 213 deletions
Show Stats Download Patch File Download Diff File

15
pkg/chart/v2/lint/lint_test.go
Unescape View File

@ -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 {
t.Error("All returned linter messages when it shouldn't have")
if !assert.Empty(t, m, "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 {
t.Errorf("All should have had exactly 1 error. Got %d", ll)
if !assert.Len(t, m, 1, "All should have had exactly 1 error") {
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") {
t.Errorf("Unexpected lint error: %s", msg)
} else {
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 {
t.Error("All returned linter messages when it shouldn't have")
if !assert.Empty(t, m, "All returned linter messages when it shouldn't have") {
for i, msg := range m {
t.Logf("Message %d: %s", i, msg)
}

28
pkg/chart/v2/util/validate_name_test.go
Unescape View File

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

30
pkg/cli/values/options_test.go
Unescape View File

@ -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
}
// Regular test cases
got, err := readFile(actualFilePath, tt.providers)
if tt.expectError {
assert.Error(t, err)
return
}
require.NoError(t, err)
if tt.expectedData != nil {
assert.Equal(t, tt.expectedData, got)
} else {
// Regular test cases
got, err := readFile(actualFilePath, tt.providers)
if tt.expectError {
assert.Error(t, err)
} else {
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)
})
}
}

30
pkg/cmd/package_test.go
Unescape View File

@ -139,24 +139,22 @@ func TestPackage(t *testing.T) {
}
}
_, _, err = executeActionCommand(strings.Join(cmd, " "))
if err != nil {
if tt.err && re.MatchString(err.Error()) {
return
if tt.err {
require.Error(t, err)
require.True(t, re.MatchString(err.Error()))
} 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 != "" {
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)
}
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)
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)
}
}
})
}

30
pkg/cmd/pull_test.go
Unescape View File

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

33
pkg/cmd/search/search_test.go
Unescape View File

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

19
pkg/cmd/upgrade_test.go
Unescape View File

@ -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 {
t.Fatalf("Error creating chart: %v", err)
}
require.NoError(t, chartutil.SaveDir(parent, tmp), "Error creating chart")
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 {
t.Fatalf("Error creating charts dir: %v", err)
}
require.NoError(t, os.MkdirAll(filepath.Join(chartPath, "charts"), 0o755), "Error creating charts dir")
// 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 {
t.Fatal("expected an error resolving the OCI dependency, got nil")
}
require.Error(t, err, "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) {

23
pkg/downloader/manager_test.go
Unescape View File

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

27
pkg/engine/engine_test.go
Unescape View File

@ -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.Truef(t, ok, "Expected add-on function %q", f)
assert.Containsf(t, fns, f, "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, expected)
assert.EqualError(t, err, `parse error at (undefined_function:1): function "foo" not defined`)
}
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) {
t.Errorf("Expected err with suffix: %s", expectErr)
}
require.Error(t, err)
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!!!"
key := "CustomFunc/templates/manifest"
if rendered, ok := out[key]; !ok || rendered != expected {
t.Errorf("Expected %q, got %q", expected, rendered)
}
rendered, ok := out["CustomFunc/templates/manifest"]
require.True(t, ok)
assert.Equal(t, "hello!!!", rendered)
// Verify that the rendered template used the custom "upper" function.
expected = "custom:hello"
key = "CustomFunc/templates/override"
if rendered, ok := out[key]; !ok || rendered != expected {
t.Errorf("Expected %q, got %q", expected, rendered)
}
rendered, ok = out["CustomFunc/templates/override"]
require.True(t, ok)
assert.Equal(t, "custom:hello", rendered)
}
func TestTraceableError_SimpleForm(t *testing.T) {

10
pkg/getter/ocigetter_test.go
Unescape View File

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

24
pkg/repo/v1/index_test.go
Unescape View File

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

23
pkg/storage/driver/cfgmaps_test.go
Unescape View File

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

11
pkg/storage/driver/memory_test.go
Unescape View File

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

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

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

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

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

15
pkg/storage/storage_test.go
Unescape View File

@ -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,

Write Preview
Loading…
Cancel
Save