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 21

Browse Source 
#### Description

refactor: convert tests to testify assert/require in pkg/cmd
Signed-off-by: Matthieu MOREL <matthieu.morel35@gmail.com>
pull/32437/head
Matthieu MOREL 3 days ago
parent 3f1f55c4c8
commit a934b827fa
17 changed files with 138 additions and 253 deletions
Show Stats Download Patch File Download Diff File

20
pkg/action/action_test.go
Unescape View File

@ -58,9 +58,7 @@ func actionConfigFixtureWithDummyResources(t *testing.T, dummyResources kube.Res
slog.SetDefault(logger)
registryClient, err := registry.NewClient()
if err != nil {
t.Fatal(err)
}
require.NoError(t, err)
return &Configuration{
Releases: storage.Init(driver.NewMemory()),
@ -371,16 +369,10 @@ func TestGetVersionSet(t *testing.T) {
client := fakeclientset.NewClientset()
vs, err := GetVersionSet(client.Discovery())
if err != nil {
t.Error(err)
}
require.NoError(t, err)
if !vs.Has("v1") {
t.Error("Expected supported versions to at least include v1.")
}
if vs.Has("nosuchversion/v1") {
t.Error("Non-existent version is reported found.")
}
assert.True(t, vs.Has("v1"), "Expected supported versions to at least include v1.")
assert.False(t, vs.Has("nosuchversion/v1"), "Non-existent version is reported found.")
}
// Mock PostRenderer for testing
@ -2031,9 +2023,7 @@ spec:
mockPR := &mockPostRenderer{
transform: func(content string) string {
count := strings.Count(content, "kind: ServiceAccount")
if count > 1 {
t.Errorf("post-renderer received %d ServiceAccount resources in a single stream, expected at most 1", count)
}
assert.LessOrEqualf(t, count, 1, "post-renderer received %d ServiceAccount resources in a single stream, expected at most 1", count)
return content
},
}

24
pkg/action/dependency_test.go
Unescape View File

@ -57,9 +57,7 @@ func TestList(t *testing.T) {
},
} {
buf := bytes.Buffer{}
if err := NewDependency().List(tcase.chart, &buf); err != nil {
t.Fatal(err)
}
require.NoError(t, NewDependency().List(tcase.chart, &buf))
test.AssertGoldenString(t, buf.String(), tcase.golden)
}
}
@ -71,22 +69,16 @@ func TestDependencyStatus_Dashes(t *testing.T) {
dir := t.TempDir()
chartpath := filepath.Join(dir, "charts")
if err := os.MkdirAll(chartpath, 0o700); err != nil {
t.Fatal(err)
}
require.NoError(t, os.MkdirAll(chartpath, 0o700))
// Add some fake charts
first := buildChart(withName("first-chart"))
_, err := chartutil.Save(first, chartpath)
if err != nil {
t.Fatal(err)
}
require.NoError(t, err)
second := buildChart(withName("first-chart-second-chart"))
_, err = chartutil.Save(second, chartpath)
if err != nil {
t.Fatal(err)
}
require.NoError(t, err)
dep := &chart.Dependency{
Name: "first-chart",
@ -95,9 +87,7 @@ func TestDependencyStatus_Dashes(t *testing.T) {
// Now try to get the deps
stat := NewDependency().dependencyStatus(dir, dep, first)
if stat != "ok" {
t.Errorf("Unexpected status: %q", stat)
}
assert.Equal(t, "ok", stat, "Unexpected status: %q", stat)
}
func TestStatArchiveForStatus(t *testing.T) {
@ -105,9 +95,7 @@ func TestStatArchiveForStatus(t *testing.T) {
dir := t.TempDir()
chartpath := filepath.Join(dir, "charts")
if err := os.MkdirAll(chartpath, 0o700); err != nil {
t.Fatal(err)
}
require.NoError(t, os.MkdirAll(chartpath, 0o700))
// unsaved chart
lilith := buildChart(withName("lilith"))

29
pkg/action/list_test.go
Unescape View File

@ -44,9 +44,7 @@ func TestListStates(t *testing.T) {
"unknown": ListUnknown,
"totally made up key": ListUnknown,
} {
if expect != expect.FromName(input) {
t.Errorf("Expected %d for %s", expect, input)
}
assert.Equal(t, expect.FromName(input), expect, "Expected %d for %s", expect, input)
// This is a cheap way to verify that ListAll actually allows everything but Unknown
if got := expect.FromName(input); got != ListUnknown && got&ListAll == 0 {
t.Errorf("Expected %s to match the ListAll filter", input)
@ -54,12 +52,10 @@ func TestListStates(t *testing.T) {
}
filter := ListDeployed | ListPendingRollback
if status := filter.FromName("deployed"); filter&status == 0 {
t.Errorf("Expected %d to match mask %d", status, filter)
}
if status := filter.FromName("failed"); filter&status != 0 {
t.Errorf("Expected %d to fail to match mask %d", status, filter)
}
status := filter.FromName("deployed")
assert.NotEqualf(t, ListStates(0), filter&status, "Expected %d to match mask %d", status, filter)
status = filter.FromName("failed")
assert.Equalf(t, ListStates(0), filter&status, "Expected %d to fail to match mask %d", status, filter)
}
func TestList_Empty(t *testing.T) {
@ -202,8 +198,7 @@ func TestList_StateMask(t *testing.T) {
}
one.SetStatus(common.StatusUninstalled, "uninstalled")
err = lister.cfg.Releases.Update(one)
req.NoError(err)
req.NoError(lister.cfg.Releases.Update(one))
res, err := lister.Run()
req.NoError(err)
@ -277,9 +272,7 @@ func makeMeSomeReleasesWithStaleFailure(t *testing.T, store *storage.Storage) {
five.Version = 1
for _, rel := range []*release.Release{one, two, three, four, five} {
if err := store.Create(rel); err != nil {
t.Fatal(err)
}
require.NoError(t, store.Create(rel))
}
all, err := store.ListReleases()
@ -328,9 +321,7 @@ func makeMeSomeReleases(t *testing.T, store *storage.Storage) {
three.Version = 3
for _, rel := range []*release.Release{one, two, three} {
if err := store.Create(rel); err != nil {
t.Fatal(err)
}
require.NoError(t, store.Create(rel))
}
all, err := store.ListReleases()
@ -389,9 +380,7 @@ func TestSelectorList(t *testing.T) {
lister := newListFixture(t)
for _, rel := range []*release.Release{r1, r2, r3} {
if err := lister.cfg.Releases.Create(rel); err != nil {
t.Fatal(err)
}
require.NoError(t, lister.cfg.Releases.Create(rel))
}
t.Run("should fail selector parsing", func(t *testing.T) {

29
pkg/chart/v2/lint/support/message_test.go
Unescape View File

@ -19,6 +19,9 @@ package support
import (
"errors"
"testing"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
var errLint = errors.New("lint failed")
@ -47,33 +50,19 @@ func TestRunLinterRule(t *testing.T) {
linter := Linter{}
for _, test := range tests {
isValid := linter.RunLinterRule(test.Severity, "chart", test.LintError)
if len(linter.Messages) != test.ExpectedMessages {
t.Errorf("RunLinterRule(%d, \"chart\", %v), linter.Messages should now have %d message, we got %d", test.Severity, test.LintError, test.ExpectedMessages, len(linter.Messages))
}
if linter.HighestSeverity != test.ExpectedHighestSeverity {
t.Errorf("RunLinterRule(%d, \"chart\", %v), linter.HighestSeverity should be %d, we got %d", test.Severity, test.LintError, test.ExpectedHighestSeverity, linter.HighestSeverity)
}
if isValid != test.ExpectedReturn {
t.Errorf("RunLinterRule(%d, \"chart\", %v), should have returned %t but returned %t", test.Severity, test.LintError, test.ExpectedReturn, isValid)
}
assert.Lenf(t, linter.Messages, test.ExpectedMessages, "RunLinterRule(%d, \"chart\", %v), linter.Messages should now have %d message, we got %d", test.Severity, test.LintError, test.ExpectedMessages, len(linter.Messages))
assert.Equalf(t, linter.HighestSeverity, test.ExpectedHighestSeverity, "RunLinterRule(%d, \"chart\", %v), linter.HighestSeverity should be %d, we got %d", test.Severity, test.LintError, test.ExpectedHighestSeverity, linter.HighestSeverity)
assert.Equalf(t, isValid, test.ExpectedReturn, "RunLinterRule(%d, \"chart\", %v), should have returned %t but returned %t", test.Severity, test.LintError, test.ExpectedReturn, isValid)
}
}
func TestMessage(t *testing.T) {
m := Message{ErrorSev, "Chart.yaml", errors.New("Foo")}
if m.Error() != "[ERROR] Chart.yaml: Foo" {
t.Errorf("Unexpected output: %s", m.Error())
}
require.EqualErrorf(t, m, "[ERROR] Chart.yaml: Foo", "Unexpected output: %s", m.Error())
m = Message{WarningSev, "templates/", errors.New("Bar")}
if m.Error() != "[WARNING] templates/: Bar" {
t.Errorf("Unexpected output: %s", m.Error())
}
require.EqualErrorf(t, m, "[WARNING] templates/: Bar", "Unexpected output: %s", m.Error())
m = Message{InfoSev, "templates/rc.yaml", errors.New("FooBar")}
if m.Error() != "[INFO] templates/rc.yaml: FooBar" {
t.Errorf("Unexpected output: %s", m.Error())
}
assert.EqualErrorf(t, m, "[INFO] templates/rc.yaml: FooBar", "Unexpected output: %s", m.Error())
}

30
pkg/cmd/history_test.go
Unescape View File

@ -385,16 +385,16 @@ func TestReleaseInfoUnmarshalJSON(t *testing.T) {
err := json.Unmarshal([]byte(tt.input), &info)
if tt.wantErr {
assert.Error(t, err)
return
} else {
require.NoError(t, err)
assert.Equal(t, tt.expected.Revision, info.Revision)
assert.Equal(t, tt.expected.Updated.Unix(), info.Updated.Unix())
assert.Equal(t, tt.expected.Status, info.Status)
assert.Equal(t, tt.expected.Chart, info.Chart)
assert.Equal(t, tt.expected.AppVersion, info.AppVersion)
assert.Equal(t, tt.expected.RollbackRevision, info.RollbackRevision)
assert.Equal(t, tt.expected.Description, info.Description)
}
require.NoError(t, err)
assert.Equal(t, tt.expected.Revision, info.Revision)
assert.Equal(t, tt.expected.Updated.Unix(), info.Updated.Unix())
assert.Equal(t, tt.expected.Status, info.Status)
assert.Equal(t, tt.expected.Chart, info.Chart)
assert.Equal(t, tt.expected.AppVersion, info.AppVersion)
assert.Equal(t, tt.expected.RollbackRevision, info.RollbackRevision)
assert.Equal(t, tt.expected.Description, info.Description)
})
}
}
@ -415,9 +415,7 @@ func TestReleaseInfoRoundTrip(t *testing.T) {
require.NoError(t, err)
var decoded releaseInfo
err = json.Unmarshal(data, &decoded)
require.NoError(t, err)
require.NoError(t, json.Unmarshal(data, &decoded))
assert.Equal(t, original.Revision, decoded.Revision)
assert.Equal(t, original.Updated.Unix(), decoded.Updated.Unix())
assert.Equal(t, original.Status, decoded.Status)
@ -433,11 +431,10 @@ func TestReleaseInfoEmptyStringRoundTrip(t *testing.T) {
input := `{"revision":1,"updated":"","status":"deployed","chart":"mychart-1.0.0","app_version":"1.0.0","description":"Test"}`
var info releaseInfo
err := json.Unmarshal([]byte(input), &info)
require.NoError(t, err)
require.NoError(t, json.Unmarshal([]byte(input), &info))
// Verify time field is zero value
assert.True(t, info.Updated.IsZero())
assert.Zero(t, info.Updated)
assert.Equal(t, 1, info.Revision)
assert.Equal(t, "deployed", info.Status)
@ -446,8 +443,7 @@ func TestReleaseInfoEmptyStringRoundTrip(t *testing.T) {
require.NoError(t, err)
var result map[string]any
err = json.Unmarshal(data, &result)
require.NoError(t, err)
require.NoError(t, json.Unmarshal(data, &result))
// Zero time value should be omitted
assert.NotContains(t, result, "updated")

16
pkg/cmd/require/args_test.go
Unescape View File

@ -18,10 +18,10 @@ package require
import (
"io"
"strconv"
"strings"
"testing"
"github.com/spf13/cobra"
"github.com/stretchr/testify/require"
)
func TestArgs(t *testing.T) {
@ -77,16 +77,10 @@ func runTestCases(t *testing.T, testCases []testCase) {
err := cmd.Execute()
if tc.wantError == "" {
if err != nil {
t.Fatalf("unexpected error, got '%v'", err)
}
return
}
if !strings.Contains(err.Error(), tc.wantError) {
t.Fatalf("unexpected error \n\nWANT:\n%q\n\nGOT:\n%q\n", tc.wantError, err)
}
if !strings.Contains(err.Error(), "Usage:") {
t.Fatalf("unexpected error: want Usage string\n\nGOT:\n%q\n", err)
require.NoError(t, err)
} else {
require.ErrorContains(t, err, tc.wantError)
require.ErrorContains(t, err, "Usage:")
}
})
}

26
pkg/cmd/rollback_test.go
Unescape View File

@ -21,6 +21,9 @@ import (
"reflect"
"testing"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
chart "helm.sh/helm/v4/pkg/chart/v2"
"helm.sh/helm/v4/pkg/release/common"
release "helm.sh/helm/v4/pkg/release/v1"
@ -148,24 +151,15 @@ func TestRollbackWithLabels(t *testing.T) {
}
storage := storageFixture()
for _, rel := range rels {
if err := storage.Create(rel); err != nil {
t.Fatal(err)
}
require.NoError(t, storage.Create(rel))
}
_, _, err := executeActionCommandC(storage, fmt.Sprintf("rollback %s 1", releaseName))
if err != nil {
t.Errorf("unexpected error, got '%v'", err)
}
require.NoError(t, err)
updatedReli, err := storage.Get(releaseName, 3)
if err != nil {
t.Errorf("unexpected error, got '%v'", err)
}
updatedRel, err := releaserToV1Release(updatedReli)
if err != nil {
t.Errorf("unexpected error, got '%v'", err)
}
require.NoError(t, err)
if !reflect.DeepEqual(updatedRel.Labels, labels1) {
t.Errorf("Expected {%v}, got {%v}", labels1, updatedRel.Labels)
}
updatedRel, err := releaserToV1Release(updatedReli)
require.NoError(t, err)
assert.Truef(t, reflect.DeepEqual(updatedRel.Labels, labels1), "Expected {%v}, got {%v}", labels1, updatedRel.Labels)
}

32
pkg/cmd/root_test.go
Unescape View File

@ -23,6 +23,9 @@ import (
"path/filepath"
"testing"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"helm.sh/helm/v4/internal/test/ensure"
"helm.sh/helm/v4/pkg/action"
"helm.sh/helm/v4/pkg/helmpath"
@ -86,9 +89,8 @@ func TestRootCmd(t *testing.T) {
t.Setenv(k, v)
}
if _, _, err := executeActionCommand(tt.args); err != nil {
t.Fatalf("unexpected error: %s", err)
}
_, _, err := executeActionCommand(tt.args)
require.NoError(t, err)
// NOTE(bacongobbler): we need to check here after calling ensure.HelmHome so we
// load the proper paths after XDG_*_HOME is set
@ -104,15 +106,9 @@ func TestRootCmd(t *testing.T) {
tt.dataPath = filepath.Join(os.Getenv(xdg.DataHomeEnvVar), "helm")
}
if helmpath.CachePath() != tt.cachePath {
t.Errorf("expected cache path %q, got %q", tt.cachePath, helmpath.CachePath())
}
if helmpath.ConfigPath() != tt.configPath {
t.Errorf("expected config path %q, got %q", tt.configPath, helmpath.ConfigPath())
}
if helmpath.DataPath() != tt.dataPath {
t.Errorf("expected data path %q, got %q", tt.dataPath, helmpath.DataPath())
}
assert.Equal(t, tt.cachePath, helmpath.CachePath(), "expected cache path %q, got %q", tt.cachePath, helmpath.CachePath())
assert.Equal(t, tt.configPath, helmpath.ConfigPath(), "expected config path %q, got %q", tt.configPath, helmpath.ConfigPath())
assert.Equal(t, tt.dataPath, helmpath.DataPath(), "expected data path %q, got %q", tt.dataPath, helmpath.DataPath())
})
}
}
@ -120,9 +116,7 @@ func TestRootCmd(t *testing.T) {
func TestUnknownSubCmd(t *testing.T) {
_, _, err := executeActionCommand("foobar")
if err == nil || err.Error() != `unknown command "foobar" for "helm"` {
t.Errorf("Expect unknown command error, got %q", err)
}
assert.EqualErrorf(t, err, `unknown command "foobar" for "helm"`, "Expect unknown command error")
}
// Need the release of Cobra following 1.0 to be able to disable
@ -138,14 +132,10 @@ func TestRootCmdLogger(t *testing.T) {
buf := new(bytes.Buffer)
actionConfig := action.NewConfiguration()
_, err := newRootCmdWithConfig(actionConfig, buf, args, SetupLogging)
if err != nil {
t.Errorf("expected no error, got: '%v'", err)
}
require.NoError(t, err)
l1 := actionConfig.Logger()
l2 := slog.Default()
if l1.Handler() != l2.Handler() {
t.Error("expected actionConfig logger to be the slog default logger")
}
assert.Equal(t, l2.Handler(), l1.Handler(), "expected actionConfig logger to be the slog default logger")
}

28
pkg/cmd/search_hub_test.go
Unescape View File

@ -21,6 +21,9 @@ import (
"net/http"
"net/http/httptest"
"testing"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
func TestSearchHubCmd(t *testing.T) {
@ -42,9 +45,7 @@ func TestSearchHubCmd(t *testing.T) {
testcmd := "search hub --endpoint " + ts.URL + " maria"
storage := storageFixture()
_, out, err := executeActionCommandC(storage, testcmd)
if err != nil {
t.Errorf("unexpected error, %s", err)
}
require.NoError(t, err)
if out != expected {
t.Error("expected and actual output did not match")
t.Log(out)
@ -71,9 +72,7 @@ func TestSearchHubListRepoCmd(t *testing.T) {
testcmd := "search hub --list-repo-url --endpoint " + ts.URL + " maria"
storage := storageFixture()
_, out, err := executeActionCommandC(storage, testcmd)
if err != nil {
t.Errorf("unexpected error, %s", err)
}
require.NoError(t, err)
if out != expected {
t.Error("expected and actual output did not match")
t.Log(out)
@ -165,21 +164,14 @@ func TestSearchHubCmd_FailOnNoResponseTests(t *testing.T) {
_, out, err := executeActionCommandC(storage, tt.cmd)
if tt.wantErr {
if err == nil {
t.Error("expected error due to no record in response, got nil")
}
require.Error(t, err, "expected error due to no record in response, got nil")
} else {
if err != nil {
t.Errorf("unexpected error, got %q", err)
}
require.NoError(t, err)
}
if out != tt.expected {
t.Errorf("expected and actual output did not match\n"+
"expected: %q\n"+
"actual : %q",
tt.expected, out)
}
assert.Equal(t, tt.expected, out, "expected and actual output did not match\n"+
"expected: %q\n"+
"actual : %q", tt.expected, out)
})
}
}

14
pkg/engine/files_test.go
Unescape View File

@ -44,17 +44,13 @@ func getTestFiles() files {
func TestNewFiles(t *testing.T) {
files := getTestFiles()
if len(files) != len(cases) {
t.Errorf("Expected len() = %d, got %d", len(cases), len(files))
}
assert.Len(t, files, len(cases), "Expected len() = %d, got %d", len(cases), len(files))
for i, f := range cases {
if got := string(files.GetBytes(f.path)); got != f.data {
t.Errorf("%d: expected %q, got %q", i, f.data, got)
}
if got := files.Get(f.path); got != f.data {
t.Errorf("%d: expected %q, got %q", i, f.data, got)
}
got := string(files.GetBytes(f.path))
assert.Equalf(t, got, f.data, "%d: expected %q, got %q", i, f.data, got)
got = files.Get(f.path)
assert.Equalf(t, got, f.data, "%d: expected %q, got %q", i, f.data, got)
}
}

12
pkg/engine/funcs_test.go
Unescape View File

@ -134,8 +134,7 @@ keyInElement1 = "valueInElement1"`,
for _, tt := range tests {
var b strings.Builder
err := template.Must(template.New("test").Funcs(funcMap()).Parse(tt.tpl)).Execute(&b, tt.vars)
require.NoError(t, err)
require.NoError(t, template.Must(template.New("test").Funcs(funcMap()).Parse(tt.tpl)).Execute(&b, tt.vars))
assert.Equal(t, tt.expect, b.String(), tt.tpl)
}
@ -360,8 +359,7 @@ func TestDurationHelpers(t *testing.T) {
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
var b strings.Builder
err := template.Must(template.New("test").Funcs(funcMap()).Parse(tt.tpl)).Execute(&b, tt.vars)
require.NoError(t, err, tt.tpl)
require.NoError(t, template.Must(template.New("test").Funcs(funcMap()).Parse(tt.tpl)).Execute(&b, tt.vars), tt.tpl)
assert.Equal(t, tt.expect, b.String(), tt.tpl)
})
}
@ -422,8 +420,7 @@ func TestDurationHelpers(t *testing.T) {
Funcs(funcMap()).
Parse(tt.tpl),
)
err := tmpl.Execute(&b, tt.vars)
require.Error(t, err, tt.tpl)
require.Error(t, tmpl.Execute(&b, tt.vars), tt.tpl)
})
}
}
@ -474,8 +471,7 @@ func TestMerge(t *testing.T) {
}
tpl := `{{merge .dst .src1 .src2}}`
var b strings.Builder
err := template.Must(template.New("test").Funcs(funcMap()).Parse(tpl)).Execute(&b, dict)
require.NoError(t, err)
require.NoError(t, template.Must(template.New("test").Funcs(funcMap()).Parse(tpl)).Execute(&b, dict))
expected := map[string]any{
"a": "one", // key overridden

23
pkg/getter/plugingetter_test.go
Unescape View File

@ -35,25 +35,18 @@ func TestCollectPlugins(t *testing.T) {
env.PluginsDirectory = pluginDir
p, err := collectGetterPlugins(env)
if err != nil {
t.Fatal(err)
}
require.NoError(t, err)
if len(p) != 2 {
t.Errorf("Expected 2 plugins, got %d: %v", len(p), p)
}
assert.Len(t, p, 2, "Expected 2 plugins, got %d: %v", len(p), p)
if _, err := p.ByScheme("test2"); err != nil {
t.Error(err)
}
_, err = p.ByScheme("test2")
require.NoError(t, err)
if _, err := p.ByScheme("test"); err != nil {
t.Error(err)
}
_, err = p.ByScheme("test")
require.NoError(t, err)
if _, err := p.ByScheme("nosuchthing"); err == nil {
t.Fatal("did not expect protocol handler for nosuchthing")
}
_, err = p.ByScheme("nosuchthing")
require.Error(t, err, "did not expect protocol handler for nosuchthing")
}
func TestConvertOptions(t *testing.T) {

31
pkg/pusher/pusher_test.go
Unescape View File

@ -18,6 +18,9 @@ package pusher
import (
"testing"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"helm.sh/helm/v4/pkg/cli"
"helm.sh/helm/v4/pkg/registry"
)
@ -28,9 +31,7 @@ func TestProvider(t *testing.T) {
func(_ ...Option) (Pusher, error) { return nil, nil },
}
if !p.Provides("three") {
t.Error("Expected provider to provide three")
}
assert.True(t, p.Provides("three"), "Expected provider to provide three")
}
func TestProviders(t *testing.T) {
@ -39,30 +40,24 @@ func TestProviders(t *testing.T) {
{[]string{"two", "four"}, func(_ ...Option) (Pusher, error) { return nil, nil }},
}
if _, err := ps.ByScheme("one"); err != nil {
t.Error(err)
}
if _, err := ps.ByScheme("four"); err != nil {
t.Error(err)
}
_, err := ps.ByScheme("one")
require.NoError(t, err)
_, err = ps.ByScheme("four")
require.NoError(t, err)
if _, err := ps.ByScheme("five"); err == nil {
t.Error("Did not expect handler for five")
}
_, err = ps.ByScheme("five")
assert.Error(t, err, "Did not expect handler for five")
}
func TestAll(t *testing.T) {
env := cli.New()
all := All(env)
if len(all) != 1 {
t.Errorf("expected 1 provider (OCI), got %d", len(all))
}
assert.Len(t, all, 1, "expected 1 provider (OCI), got %d", len(all))
}
func TestByScheme(t *testing.T) {
env := cli.New()
g := All(env)
if _, err := g.ByScheme(registry.OCIScheme); err != nil {
t.Error(err)
}
_, err := g.ByScheme(registry.OCIScheme)
assert.NoError(t, err)
}

13
pkg/registry/client_insecure_tls_test.go
Unescape View File

@ -38,15 +38,13 @@ func (suite *InsecureTLSRegistryClientTestSuite) TearDownSuite() {
}
func (suite *InsecureTLSRegistryClientTestSuite) Test_0_Login() {
err := suite.RegistryClient.Login(suite.DockerRegistryHost,
suite.Require().Error(suite.RegistryClient.Login(suite.DockerRegistryHost,
LoginOptBasicAuth("badverybad", "ohsobad"),
LoginOptInsecure(true))
suite.Require().Error(err, "error logging into registry with bad credentials")
LoginOptInsecure(true)), "error logging into registry with bad credentials")
err = suite.RegistryClient.Login(suite.DockerRegistryHost,
suite.Require().NoError(suite.RegistryClient.Login(suite.DockerRegistryHost,
LoginOptBasicAuth(testUsername, testPassword),
LoginOptInsecure(true))
suite.Require().NoError(err, "no error logging into registry with good credentials")
LoginOptInsecure(true)), "no error logging into registry with good credentials")
}
func (suite *InsecureTLSRegistryClientTestSuite) Test_1_Push() {
@ -68,8 +66,7 @@ func (suite *InsecureTLSRegistryClientTestSuite) Test_4_Logout() {
suite.Require().Error(err, "failed to delete the credential for this-host-aint-real:5000")
}
err = suite.RegistryClient.Logout(suite.DockerRegistryHost)
suite.Require().NoError(err, "no error logging out of registry")
suite.Require().NoError(suite.RegistryClient.Logout(suite.DockerRegistryHost), "no error logging out of registry")
}
func TestInsecureTLSRegistryClientTestSuite(t *testing.T) {

24
pkg/release/v1/hook_test.go
Unescape View File

@ -170,12 +170,12 @@ func TestHookExecutionUnmarshalJSON(t *testing.T) {
err := json.Unmarshal([]byte(tt.input), &exec)
if tt.wantErr {
assert.Error(t, err)
return
} else {
require.NoError(t, err)
assert.Equal(t, tt.expected.StartedAt.Unix(), exec.StartedAt.Unix())
assert.Equal(t, tt.expected.CompletedAt.Unix(), exec.CompletedAt.Unix())
assert.Equal(t, tt.expected.Phase, exec.Phase)
}
require.NoError(t, err)
assert.Equal(t, tt.expected.StartedAt.Unix(), exec.StartedAt.Unix())
assert.Equal(t, tt.expected.CompletedAt.Unix(), exec.CompletedAt.Unix())
assert.Equal(t, tt.expected.Phase, exec.Phase)
})
}
}
@ -194,9 +194,7 @@ func TestHookExecutionRoundTrip(t *testing.T) {
require.NoError(t, err)
var decoded HookExecution
err = json.Unmarshal(data, &decoded)
require.NoError(t, err)
require.NoError(t, json.Unmarshal(data, &decoded))
assert.Equal(t, original.StartedAt.Unix(), decoded.StartedAt.Unix())
assert.Equal(t, original.CompletedAt.Unix(), decoded.CompletedAt.Unix())
assert.Equal(t, original.Phase, decoded.Phase)
@ -208,12 +206,11 @@ func TestHookExecutionEmptyStringRoundTrip(t *testing.T) {
input := `{"started_at":"","completed_at":"","phase":"Succeeded"}`
var exec HookExecution
err := json.Unmarshal([]byte(input), &exec)
require.NoError(t, err)
require.NoError(t, json.Unmarshal([]byte(input), &exec))
// Verify time fields are zero values
assert.True(t, exec.StartedAt.IsZero())
assert.True(t, exec.CompletedAt.IsZero())
assert.Zero(t, exec.StartedAt)
assert.Zero(t, exec.CompletedAt)
assert.Equal(t, HookPhaseSucceeded, exec.Phase)
// Marshal back and verify empty time fields are omitted
@ -221,8 +218,7 @@ func TestHookExecutionEmptyStringRoundTrip(t *testing.T) {
require.NoError(t, err)
var result map[string]any
err = json.Unmarshal(data, &result)
require.NoError(t, err)
require.NoError(t, json.Unmarshal(data, &result))
// Zero time values should be omitted
assert.NotContains(t, result, "started_at")

18
pkg/storage/driver/mock_test.go
Unescape View File

@ -24,6 +24,7 @@ import (
sqlmock "github.com/DATA-DOG/go-sqlmock"
sq "github.com/Masterminds/squirrel"
"github.com/jmoiron/sqlx"
"github.com/stretchr/testify/require"
v1 "k8s.io/api/core/v1"
apierrors "k8s.io/apimachinery/pkg/api/errors"
@ -74,10 +75,7 @@ func tsFixtureMemory(t *testing.T) *Memory {
mem := NewMemory()
for _, tt := range hs {
err := mem.Create(testKey(tt.Name, tt.Version), tt)
if err != nil {
t.Fatalf("Test setup failed to create: %s\n", err)
}
require.NoError(t, mem.Create(testKey(tt.Name, tt.Version), tt), "Test setup failed to create")
}
return mem
}
@ -108,9 +106,7 @@ func (mock *MockConfigMapsInterface) Init(t *testing.T, releases ...*rspb.Releas
objkey := testKey(rls.Name, rls.Version)
cfgmap, err := newConfigMapsObject(objkey, rls, nil)
if err != nil {
t.Fatalf("Failed to create configmap: %s", err)
}
require.NoError(t, err, "Failed to create configmap")
mock.objects[objkey] = cfgmap
}
}
@ -196,9 +192,7 @@ func (mock *MockSecretsInterface) Init(t *testing.T, releases ...*rspb.Release)
objkey := testKey(rls.Name, rls.Version)
secret, err := newSecretsObject(objkey, rls, nil)
if err != nil {
t.Fatalf("Failed to create secret: %s", err)
}
require.NoError(t, err, "Failed to create secret")
mock.objects[objkey] = secret
}
}
@ -262,9 +256,7 @@ func (mock *MockSecretsInterface) Delete(_ context.Context, name string, _ metav
func newTestFixtureSQL(t *testing.T, _ ...*rspb.Release) (*SQL, sqlmock.Sqlmock) {
t.Helper()
sqlDB, mock, err := sqlmock.New()
if err != nil {
t.Fatalf("error when opening stub database connection: %v", err)
}
require.NoError(t, err, "error when opening stub database connection")
sqlxDB := sqlx.NewDb(sqlDB, "sqlmock")
return &SQL{

22
pkg/storage/driver/util_test.go
Unescape View File

@ -16,12 +16,13 @@ package driver
import (
"reflect"
"testing"
"github.com/stretchr/testify/assert"
)
func TestGetSystemLabel(t *testing.T) {
if output := GetSystemLabels(); !reflect.DeepEqual(systemLabels, output) {
t.Errorf("Expected {%v}, got {%v}", systemLabels, output)
}
output := GetSystemLabels()
assert.Truef(t, reflect.DeepEqual(systemLabels, output), "Expected {%v}, got {%v}", systemLabels, output)
}
func TestIsSystemLabel(t *testing.T) {
@ -32,9 +33,8 @@ func TestIsSystemLabel(t *testing.T) {
"NaMe": false,
}
for label, result := range tests {
if output := isSystemLabel(label); output != result {
t.Errorf("Output %t not equal to expected %t", output, result)
}
output := isSystemLabel(label)
assert.Equalf(t, output, result, "Output %t not equal to expected %t", output, result)
}
}
@ -68,9 +68,8 @@ func TestFilterSystemLabels(t *testing.T) {
}},
}
for _, test := range tests {
if output := filterSystemLabels(test[0]); !reflect.DeepEqual(test[1], output) {
t.Errorf("Expected {%v}, got {%v}", test[1], output)
}
output := filterSystemLabels(test[0])
assert.Truef(t, reflect.DeepEqual(test[1], output), "Expected {%v}, got {%v}", test[1], output)
}
}
@ -101,8 +100,7 @@ func TestContainsSystemLabels(t *testing.T) {
}, false},
}
for _, test := range tests {
if output := ContainsSystemLabels(test.input); !reflect.DeepEqual(test.output, output) {
t.Errorf("Expected {%v}, got {%v}", test.output, output)
}
output := ContainsSystemLabels(test.input)
assert.Truef(t, reflect.DeepEqual(test.output, output), "Expected {%v}, got {%v}", test.output, output)
}
}

Write Preview
Loading…
Cancel
Save