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

Merge pull request #32419 from mmorel-35/testifylint-manual-assert-pkg-5

Browse Source 
chore(pkg): refactor: convert tests to testify assert/require part 5
pull/32416/head
Terry Howe 4 days ago committed by GitHub
parent b100b44bef 3ff05c835e
commit 90669b3a78
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
3 changed files with 109 additions and 275 deletions
Show Stats Download Patch File Download Diff File

5
pkg/downloader/cache_test.go
Unescape View File

@ -105,10 +105,9 @@ func TestDiskCache_PutAndGet(t *testing.T) {
t.Run("GetDirectory", func(t *testing.T) {
dirKey := sha256.Sum256([]byte("i am a directory"))
dirPath := cache.fileName(dirKey, CacheChart)
err := os.MkdirAll(dirPath, 0o755)
require.NoError(t, err)
require.NoError(t, os.MkdirAll(dirPath, 0o755))
_, err = cache.Get(dirKey, CacheChart)
_, err := cache.Get(dirKey, CacheChart)
assert.EqualError(t, err, "is a directory")
})
}

279
pkg/kube/client_test.go
Unescape View File

@ -316,9 +316,7 @@ func TestCreate(t *testing.T) {
list, err := c.Build(objBody(&tc.Pods), false)
require.NoError(t, err)
if err != nil {
t.Fatal(err)
}
require.NoError(t, err)
result, err := c.Create(
list,
@ -487,7 +485,7 @@ func TestUpdate(t *testing.T) {
data, err := io.ReadAll(req.Body)
require.NoError(t, err)
assert.Equal(t, `{}`, string(data))
assert.JSONEq(t, `{}`, string(data))
}
return newResponse(http.StatusOK, &listTarget.Items[0])
@ -622,15 +620,12 @@ func TestBuild(t *testing.T) {
t.Run(tt.name, func(t *testing.T) {
// Test for an invalid manifest
infos, err := c.Build(tt.reader, false)
if err != nil && !tt.err {
t.Errorf("Got error message when no error should have occurred: %v", err)
} else if err != nil && strings.Contains(err.Error(), "--validate=false") {
t.Error("error message was not scrubbed")
}
if len(infos) != tt.count {
t.Errorf("expected %d result objects, got %d", tt.count, len(infos))
if tt.err {
require.ErrorContains(t, err, "--validate=false", "error message was not scrubbed")
} else {
require.NoError(t, err, "Got error message when no error should have occurred")
}
assert.Len(t, infos, tt.count, "expected %d result objects, got %d", tt.count, len(infos))
})
}
}
@ -661,15 +656,12 @@ func TestBuildTable(t *testing.T) {
t.Run(tt.name, func(t *testing.T) {
// Test for an invalid manifest
infos, err := c.BuildTable(tt.reader, false)
if err != nil && !tt.err {
t.Errorf("Got error message when no error should have occurred: %v", err)
} else if err != nil && strings.Contains(err.Error(), "--validate=false") {
t.Error("error message was not scrubbed")
}
if len(infos) != tt.count {
t.Errorf("expected %d result objects, got %d", tt.count, len(infos))
if tt.err {
require.ErrorContains(t, err, "--validate=false", "error message was not scrubbed")
} else {
require.NoError(t, err, "Got error message when no error should have occurred")
}
assert.Len(t, infos, tt.count, "expected %d result objects, got %d", tt.count, len(infos))
})
}
}
@ -705,21 +697,17 @@ func TestPerform(t *testing.T) {
c := newTestClient(t)
infos, err := c.Build(tt.reader, false)
if err != nil && err.Error() != tt.errMessage {
t.Errorf("Error while building manifests: %v", err)
if err != nil {
require.EqualErrorf(t, err, tt.errMessage, "Error while building manifests")
}
err = perform(infos, fn)
if (err != nil) != tt.err {
t.Errorf("expected error: %v, got %v", tt.err, err)
}
if err != nil && err.Error() != tt.errMessage {
t.Errorf("expected error message: %v, got %v", tt.errMessage, err)
assert.Equal(t, tt.err, (err != nil), "expected error: %v", tt.err)
if err != nil {
require.EqualErrorf(t, err, tt.errMessage, "expected error message: %v, got %v", tt.errMessage, err)
}
if len(results) != tt.count {
t.Errorf("expected %d result objects, got %d", tt.count, len(results))
}
assert.Len(t, results, tt.count, "expected %d result objects, got %d", tt.count, len(results))
})
}
}
@ -771,9 +759,7 @@ func TestWait(t *testing.T) {
return newResponse(http.StatusOK, pod)
case p == "/namespaces/default/pods" && m == http.MethodPost:
resources, err := c.Build(req.Body, false)
if err != nil {
t.Fatal(err)
}
require.NoError(t, err)
now := time.Now()
created = &now
return newResponse(http.StatusOK, resources[0].Object)
@ -785,32 +771,19 @@ func TestWait(t *testing.T) {
}
var err error
c.Waiter, err = c.GetWaiterWithOptions(LegacyStrategy)
if err != nil {
t.Fatal(err)
}
require.NoError(t, err)
resources, err := c.Build(objBody(&podList), false)
if err != nil {
t.Fatal(err)
}
require.NoError(t, err)
result, err := c.Create(
resources,
ClientCreateOptionServerSideApply(false, false))
if err != nil {
t.Fatal(err)
}
if len(result.Created) != 3 {
t.Errorf("expected 3 resource created, got %d", len(result.Created))
}
if err := c.Wait(resources, time.Second*30); err != nil {
t.Errorf("expected wait without error, got %s", err)
}
require.NoError(t, err)
assert.Len(t, result.Created, 3, "expected 3 resource created, got %d", len(result.Created))
require.NoErrorf(t, c.Wait(resources, time.Second*30), "expected wait without error")
if time.Since(*created) < time.Second*5 {
t.Errorf("expected to wait at least 5 seconds before ready status was detected, but got %s", time.Since(*created))
}
assert.GreaterOrEqualf(t, time.Since(*created), time.Second*5, "expected to wait at least 5 seconds before ready status was detected, but got %s", time.Since(*created))
}
func TestWaitJob(t *testing.T) {
@ -832,9 +805,7 @@ func TestWaitJob(t *testing.T) {
return newResponse(http.StatusOK, job)
case p == "/namespaces/default/jobs" && m == http.MethodPost:
resources, err := c.Build(req.Body, false)
if err != nil {
t.Fatal(err)
}
require.NoError(t, err)
now := time.Now()
created = &now
return newResponse(http.StatusOK, resources[0].Object)
@ -846,31 +817,17 @@ func TestWaitJob(t *testing.T) {
}
var err error
c.Waiter, err = c.GetWaiterWithOptions(LegacyStrategy)
if err != nil {
t.Fatal(err)
}
require.NoError(t, err)
resources, err := c.Build(objBody(job), false)
if err != nil {
t.Fatal(err)
}
require.NoError(t, err)
result, err := c.Create(
resources,
ClientCreateOptionServerSideApply(false, false))
if err != nil {
t.Fatal(err)
}
if len(result.Created) != 1 {
t.Errorf("expected 1 resource created, got %d", len(result.Created))
}
if err := c.WaitWithJobs(resources, time.Second*30); err != nil {
t.Errorf("expected wait without error, got %s", err)
}
if time.Since(*created) < time.Second*5 {
t.Errorf("expected to wait at least 5 seconds before ready status was detected, but got %s", time.Since(*created))
}
require.NoError(t, err)
assert.Len(t, result.Created, 1, "expected 1 resource created, got %d", len(result.Created))
require.NoErrorf(t, c.WaitWithJobs(resources, time.Second*30), "expected wait without error")
assert.GreaterOrEqualf(t, time.Since(*created), time.Second*5, "expected to wait at least 5 seconds before ready status was detected, but got %s", time.Since(*created))
}
func TestWaitDelete(t *testing.T) {
@ -896,9 +853,7 @@ func TestWaitDelete(t *testing.T) {
return newResponse(http.StatusOK, &pod)
case p == "/namespaces/default/pods" && m == http.MethodPost:
resources, err := c.Build(req.Body, false)
if err != nil {
t.Fatal(err)
}
require.NoError(t, err)
return newResponse(http.StatusOK, resources[0].Object)
default:
t.Fatalf("unexpected request: %s %s", req.Method, req.URL.Path)
@ -908,73 +863,46 @@ func TestWaitDelete(t *testing.T) {
}
var err error
c.Waiter, err = c.GetWaiterWithOptions(LegacyStrategy)
if err != nil {
t.Fatal(err)
}
require.NoError(t, err)
resources, err := c.Build(objBody(&pod), false)
if err != nil {
t.Fatal(err)
}
require.NoError(t, err)
result, err := c.Create(
resources,
ClientCreateOptionServerSideApply(false, false))
if err != nil {
t.Fatal(err)
}
if len(result.Created) != 1 {
t.Errorf("expected 1 resource created, got %d", len(result.Created))
}
if _, err := c.Delete(resources, metav1.DeletePropagationBackground); err != nil {
t.Fatal(err)
}
if err := c.WaitForDelete(resources, time.Second*30); err != nil {
t.Errorf("expected wait without error, got %s", err)
}
if time.Since(*deleted) < time.Second*5 {
t.Errorf("expected to wait at least 5 seconds before ready status was detected, but got %s", time.Since(*deleted))
}
require.NoError(t, err)
assert.Len(t, result.Created, 1, "expected 1 resource created, got %d", len(result.Created))
_, errs := c.Delete(resources, metav1.DeletePropagationBackground)
require.Nil(t, errs)
require.NoErrorf(t, c.WaitForDelete(resources, time.Second*30), "expected wait without error")
assert.GreaterOrEqualf(t, time.Since(*deleted), time.Second*5, "expected to wait at least 5 seconds before ready status was detected, but got %s", time.Since(*deleted))
}
func TestReal(t *testing.T) {
t.Skip("This is a live test, comment this line to run")
c := New(nil)
resources, err := c.Build(strings.NewReader(guestbookManifest), false)
if err != nil {
t.Fatal(err)
}
if _, err := c.Create(resources); err != nil {
t.Fatal(err)
}
require.NoError(t, err)
_, err = c.Create(resources)
require.NoError(t, err)
testSvcEndpointManifest := testServiceManifest + "\n---\n" + testEndpointManifest
c = New(nil)
resources, err = c.Build(strings.NewReader(testSvcEndpointManifest), false)
if err != nil {
t.Fatal(err)
}
if _, err := c.Create(resources); err != nil {
t.Fatal(err)
}
require.NoError(t, err)
_, err = c.Create(resources)
require.NoError(t, err)
resources, err = c.Build(strings.NewReader(testEndpointManifest), false)
if err != nil {
t.Fatal(err)
}
require.NoError(t, err)
if _, errs := c.Delete(resources, metav1.DeletePropagationBackground); errs != nil {
t.Fatal(errs)
}
_, errs := c.Delete(resources, metav1.DeletePropagationBackground)
require.Nil(t, errs)
resources, err = c.Build(strings.NewReader(testSvcEndpointManifest), false)
if err != nil {
t.Fatal(err)
}
require.NoError(t, err)
// ensures that delete does not fail if a resource is not found
if _, errs := c.Delete(resources, metav1.DeletePropagationBackground); errs != nil {
t.Fatal(errs)
}
_, errs = c.Delete(resources, metav1.DeletePropagationBackground)
require.Nil(t, errs)
}
func TestGetPodList(t *testing.T) {
@ -1004,10 +932,9 @@ func TestOutputContainerLogsForPodList(t *testing.T) {
c := Client{Namespace: namespace, kubeClient: kubeClient}
outBuffer := &bytes.Buffer{}
outBufferFunc := func(_, _, _ string) io.Writer { return outBuffer }
err := c.OutputContainerLogsForPodList(&somePodList, namespace, outBufferFunc)
clientAssertions := assert.New(t)
req := require.New(t)
req.NoError(err)
req.NoError(c.OutputContainerLogsForPodList(&somePodList, namespace, outBufferFunc))
clientAssertions.Equal("fake logsfake logsfake logs", outBuffer.String())
}
@ -1247,23 +1174,11 @@ func (c createPatchTestCase) run(t *testing.T) {
}
patch, patchType, err := createPatch(c.original, targetInfo, c.threeWayMergeForUnstructured)
if err != nil {
t.Fatalf("Failed to create patch: %v", err)
}
require.NoError(t, err, "Failed to create patch")
if c.expectedPatch != string(patch) {
t.Errorf("Unexpected patch.\nTarget:\n%s\nOriginal:\n%s\nActual:\n%s\n\nExpected:\n%s\nGot:\n%s",
c.target,
c.original,
c.actual,
c.expectedPatch,
string(patch),
)
}
assert.Equal(t, c.expectedPatch, string(patch), "Unexpected patch.\nTarget:\n%s\nOriginal:\n%s\nActual:\n%s\n\nExpected:\n%s\nGot:\n%s", c.target, c.original, c.actual, c.expectedPatch, string(patch))
if patchType != types.MergePatchType {
t.Errorf("Expected patch type %s, got %s", types.MergePatchType, patchType)
}
assert.Equal(t, types.MergePatchType, patchType, "Expected patch type %s, got %s", types.MergePatchType, patchType)
}
func newTestCustomResourceData(metadata map[string]string, spec map[string]any) *unstructured.Unstructured {
@ -1438,12 +1353,8 @@ func TestIsReachableTwiceAfterClientCreationFailure(t *testing.T) {
assertReachableErr := func(label string, err error) {
t.Helper()
if err == nil {
t.Fatalf("%s: expected error, got nil", label)
}
if !errors.Is(err, refusedErr) {
t.Fatalf("%s: expected error wrapping %v, got %v", label, refusedErr, err)
}
require.Error(t, err, "%s: expected error, got nil", label)
require.ErrorIs(t, err, refusedErr)
}
assertReachableErr("first call", client.IsReachable())
@ -1472,9 +1383,7 @@ func TestIsIncompatibleServerError(t *testing.T) {
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
if got := isIncompatibleServerError(tc.Err); got != tc.Want {
t.Errorf("isIncompatibleServerError() = %v, want %v", got, tc.Want)
}
assert.Equalf(t, tc.Want, isIncompatibleServerError(tc.Err), "isIncompatibleServerError()")
})
}
}
@ -1926,9 +1835,7 @@ func TestClientWaitContextCancellationLegacy(t *testing.T) {
return newResponse(http.StatusOK, pod)
case p == "/namespaces/default/pods" && m == http.MethodPost:
resources, err := c.Build(req.Body, false)
if err != nil {
t.Fatal(err)
}
require.NoError(t, err)
return newResponse(http.StatusOK, resources[0].Object)
default:
t.Logf("unexpected request: %s %s", req.Method, req.URL.Path)
@ -1949,10 +1856,7 @@ func TestClientWaitContextCancellationLegacy(t *testing.T) {
ClientCreateOptionServerSideApply(false, false))
require.NoError(t, err)
assert.Len(t, result.Created, 2, "expected 2 resources created, got %d", len(result.Created))
err = c.Wait(resources, time.Second*30)
require.Error(t, err)
assert.ErrorContains(t, err, "context canceled", "expected context canceled error, got: %v", err)
assert.ErrorContains(t, c.Wait(resources, time.Second*30), "context canceled")
}
func TestClientWaitWithJobsContextCancellationLegacy(t *testing.T) {
@ -1981,9 +1885,7 @@ func TestClientWaitWithJobsContextCancellationLegacy(t *testing.T) {
return newResponse(http.StatusOK, job)
case p == "/namespaces/default/jobs" && m == http.MethodPost:
resources, err := c.Build(req.Body, false)
if err != nil {
t.Fatal(err)
}
require.NoError(t, err)
return newResponse(http.StatusOK, resources[0].Object)
default:
t.Logf("unexpected request: %s %s", req.Method, req.URL.Path)
@ -2004,9 +1906,7 @@ func TestClientWaitWithJobsContextCancellationLegacy(t *testing.T) {
ClientCreateOptionServerSideApply(false, false))
require.NoError(t, err)
assert.Len(t, result.Created, 1, "expected 1 resource created, got %d", len(result.Created))
err = c.WaitWithJobs(resources, time.Second*30)
assert.ErrorContains(t, err, "context canceled", "expected context canceled error, got: %v", err)
assert.ErrorContains(t, c.WaitWithJobs(resources, time.Second*30), "context canceled", "expected context canceled error")
}
func TestClientWaitForDeleteContextCancellationLegacy(t *testing.T) {
@ -2041,9 +1941,7 @@ func TestClientWaitForDeleteContextCancellationLegacy(t *testing.T) {
return newResponse(http.StatusOK, &pod)
case p == "/namespaces/default/pods" && m == http.MethodPost:
resources, err := c.Build(req.Body, false)
if err != nil {
t.Fatal(err)
}
require.NoError(t, err)
return newResponse(http.StatusOK, resources[0].Object)
default:
t.Logf("unexpected request: %s %s", req.Method, req.URL.Path)
@ -2065,12 +1963,9 @@ func TestClientWaitForDeleteContextCancellationLegacy(t *testing.T) {
require.NoError(t, err)
assert.Len(t, result.Created, 1, "expected 1 resource created, got %d", len(result.Created))
if _, err := c.Delete(resources, metav1.DeletePropagationBackground); err != nil {
t.Fatal(err)
}
err = c.WaitForDelete(resources, time.Second*30)
assert.ErrorContains(t, err, "context canceled", "expected context canceled error, got: %v", err)
_, errs := c.Delete(resources, metav1.DeletePropagationBackground)
require.Nil(t, errs)
assert.ErrorContains(t, c.WaitForDelete(resources, time.Second*30), "context canceled", "expected context canceled error")
}
func TestClientWaitContextNilDoesNotPanic(t *testing.T) {
@ -2100,9 +1995,7 @@ func TestClientWaitContextNilDoesNotPanic(t *testing.T) {
return newResponse(http.StatusOK, pod)
case p == "/namespaces/default/pods" && m == http.MethodPost:
resources, err := c.Build(req.Body, false)
if err != nil {
t.Fatal(err)
}
require.NoError(t, err)
now := time.Now()
created = &now
return newResponse(http.StatusOK, resources[0].Object)
@ -2125,10 +2018,7 @@ func TestClientWaitContextNilDoesNotPanic(t *testing.T) {
ClientCreateOptionServerSideApply(false, false))
require.NoError(t, err)
assert.Len(t, result.Created, 1, "expected 1 resource created, got %d", len(result.Created))
err = c.Wait(resources, time.Second*30)
require.NoError(t, err)
require.NoError(t, c.Wait(resources, time.Second*30))
assert.GreaterOrEqual(t, time.Since(*created), time.Second*2, "expected to wait at least 2 seconds")
}
@ -2152,9 +2042,7 @@ func TestClientWaitContextPreCancelledLegacy(t *testing.T) {
return newResponse(http.StatusOK, pod)
case p == "/namespaces/default/pods" && m == http.MethodPost:
resources, err := c.Build(req.Body, false)
if err != nil {
t.Fatal(err)
}
require.NoError(t, err)
return newResponse(http.StatusOK, resources[0].Object)
default:
t.Fatalf("unexpected request: %s %s", req.Method, req.URL.Path)
@ -2175,9 +2063,7 @@ func TestClientWaitContextPreCancelledLegacy(t *testing.T) {
ClientCreateOptionServerSideApply(false, false))
require.NoError(t, err)
assert.Len(t, result.Created, 1, "expected 1 resource created, got %d", len(result.Created))
err = c.Wait(resources, time.Second*30)
assert.ErrorContains(t, err, "context canceled", "expected context canceled error, got: %v", err)
assert.ErrorContains(t, c.Wait(resources, time.Second*30), "context canceled")
}
func TestClientWaitContextCancellationStatusWatcher(t *testing.T) {
@ -2202,8 +2088,7 @@ metadata:
cancel()
err = c.Wait(resources, time.Second*30)
assert.ErrorContains(t, err, "context canceled", "expected context canceled error, got: %v", err)
assert.ErrorContains(t, c.Wait(resources, time.Second*30), "context canceled", "expected context canceled error")
}
func TestClientWaitWithJobsContextCancellationStatusWatcher(t *testing.T) {
@ -2228,8 +2113,7 @@ metadata:
cancel()
err = c.WaitWithJobs(resources, time.Second*30)
assert.ErrorContains(t, err, "context canceled", "expected context canceled error, got: %v", err)
assert.ErrorContains(t, c.WaitWithJobs(resources, time.Second*30), "context canceled")
}
func TestClientWaitForDeleteContextCancellationStatusWatcher(t *testing.T) {
@ -2259,8 +2143,7 @@ status:
cancel()
err = c.WaitForDelete(resources, time.Second*30)
assert.ErrorContains(t, err, "context canceled", "expected context canceled error, got: %v", err)
assert.ErrorContains(t, c.WaitForDelete(resources, time.Second*30), "context canceled")
}
// testStatusReader is a custom status reader for testing that returns a configurable status.
@ -2334,8 +2217,7 @@ metadata:
// The pod has no Ready condition, but our custom reader returns CurrentStatus,
// so the wait should succeed immediately without timeout.
err = c.Wait(resources, time.Second*3)
require.NoError(t, err)
require.NoError(t, c.Wait(resources, time.Second*3))
}
func TestClientStatusReadersWithWaitWithJobs(t *testing.T) {
@ -2376,8 +2258,7 @@ metadata:
// The job has no Complete condition, but our custom reader returns CurrentStatus,
// so the wait should succeed immediately without timeout.
err = c.WaitWithJobs(resources, time.Second*3)
require.NoError(t, err)
require.NoError(t, c.WaitWithJobs(resources, time.Second*3))
}
func createManifest(t *testing.T, manifest string,
@ -2385,12 +2266,10 @@ func createManifest(t *testing.T, manifest string,
t.Helper()
m := make(map[string]any)
err := yaml.Unmarshal([]byte(manifest), &m)
require.NoError(t, err)
require.NoError(t, yaml.Unmarshal([]byte(manifest), &m))
obj := &unstructured.Unstructured{Object: m}
gvk := obj.GroupVersionKind()
mapping, err := fakeMapper.RESTMapping(gvk.GroupKind(), gvk.Version)
require.NoError(t, err)
err = fakeClient.Tracker().Create(mapping.Resource, obj, obj.GetNamespace())
require.NoError(t, err)
require.NoError(t, fakeClient.Tracker().Create(mapping.Resource, obj, obj.GetNamespace()))
}

100
pkg/repo/v1/repo_test.go
Unescape View File

@ -18,8 +18,10 @@ package repo
import (
"os"
"strings"
"testing"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
const testRepositoriesFile = "testdata/repositories.yaml"
@ -37,24 +39,14 @@ func TestFile(t *testing.T) {
},
)
if len(rf.Repositories) != 2 {
t.Fatal("Expected 2 repositories")
}
require.Len(t, rf.Repositories, 2, "Expected 2 repositories")
if rf.Has("nosuchrepo") {
t.Error("Found nonexistent repo")
}
if !rf.Has("incubator") {
t.Error("incubator repo is missing")
}
assert.False(t, rf.Has("nosuchrepo"), "Found nonexistent repo")
assert.True(t, rf.Has("incubator"), "incubator repo is missing")
stable := rf.Repositories[0]
if stable.Name != "stable" {
t.Error("stable is not named stable")
}
if stable.URL != "https://example.com/stable/charts" {
t.Error("Wrong URL for stable")
}
assert.Equal(t, "stable", stable.Name, "stable is not named stable")
assert.Equal(t, "https://example.com/stable/charts", stable.URL, "Wrong URL for stable")
}
func TestNewFile(t *testing.T) {
@ -71,22 +63,14 @@ func TestNewFile(t *testing.T) {
)
file, err := LoadFile(testRepositoriesFile)
if err != nil {
t.Errorf("%q could not be loaded: %s", testRepositoriesFile, err)
}
require.NoErrorf(t, err, "%q could not be loaded", testRepositoriesFile)
if len(expects.Repositories) != len(file.Repositories) {
t.Fatalf("Unexpected repo data: %#v", file.Repositories)
}
require.Lenf(t, file.Repositories, len(expects.Repositories), "Unexpected repo data: %#v", file.Repositories)
for i, expect := range expects.Repositories {
got := file.Repositories[i]
if expect.Name != got.Name {
t.Errorf("Expected name %q, got %q", expect.Name, got.Name)
}
if expect.URL != got.URL {
t.Errorf("Expected url %q, got %q", expect.URL, got.URL)
}
assert.Equalf(t, expect.Name, got.Name, "Expected name %q, got %q", expect.Name, got.Name)
assert.Equalf(t, expect.URL, got.URL, "Expected url %q, got %q", expect.URL, got.URL)
}
}
@ -114,18 +98,12 @@ func TestRepoFile_Get(t *testing.T) {
name := "second"
entry := repo.Get(name)
if entry == nil {
t.Fatalf("Expected repo entry %q to be found", name)
}
require.NotNilf(t, entry, "Expected repo entry %q to be found", name)
if entry.URL != "https://example.com/second" {
t.Errorf("Expected repo URL to be %q but got %q", "https://example.com/second", entry.URL)
}
assert.Equalf(t, "https://example.com/second", entry.URL, "Expected repo URL to be %q but got %q", "https://example.com/second", entry.URL)
entry = repo.Get("nonexistent")
if entry != nil {
t.Errorf("Got unexpected entry %+v", entry)
}
assert.Nilf(t, entry, "Got unexpected entry %+v", entry)
}
func TestRemoveRepository(t *testing.T) {
@ -143,14 +121,10 @@ func TestRemoveRepository(t *testing.T) {
removeRepository := "stable"
found := sampleRepository.Remove(removeRepository)
if !found {
t.Errorf("expected repository %s not found", removeRepository)
}
assert.Truef(t, found, "expected repository %s not found", removeRepository)
found = sampleRepository.Has(removeRepository)
if found {
t.Errorf("repository %s not deleted", removeRepository)
}
assert.Falsef(t, found, "repository %s not deleted", removeRepository)
}
func TestUpdateRepository(t *testing.T) {
@ -170,18 +144,14 @@ func TestUpdateRepository(t *testing.T) {
URL: "https://example.com/sample",
})
if !sampleRepository.Has(newRepoName) {
t.Errorf("expected repository %s not found", newRepoName)
}
assert.Truef(t, sampleRepository.Has(newRepoName), "expected repository %s not found", newRepoName)
repoCount := len(sampleRepository.Repositories)
sampleRepository.Update(&Entry{Name: newRepoName,
URL: "https://example.com/sample",
})
if repoCount != len(sampleRepository.Repositories) {
t.Errorf("invalid number of repositories found %d, expected number of repositories %d", len(sampleRepository.Repositories), repoCount)
}
assert.Lenf(t, sampleRepository.Repositories, repoCount, "invalid number of repositories found %d, expected number of repositories %d", len(sampleRepository.Repositories), repoCount)
}
func TestWriteFile(t *testing.T) {
@ -198,31 +168,21 @@ func TestWriteFile(t *testing.T) {
)
file, err := os.CreateTemp(t.TempDir(), "helm-repo")
if err != nil {
t.Errorf("failed to create test-file (%v)", err)
}
require.NoErrorf(t, err, "failed to create test-file")
defer os.Remove(file.Name())
if err := sampleRepository.WriteFile(file.Name(), 0o600); err != nil {
t.Errorf("failed to write file (%v)", err)
}
require.NoErrorf(t, sampleRepository.WriteFile(file.Name(), 0o600), "failed to write file")
repos, err := LoadFile(file.Name())
if err != nil {
t.Errorf("failed to load file (%v)", err)
}
require.NoErrorf(t, err, "failed to load file")
for _, repo := range sampleRepository.Repositories {
if !repos.Has(repo.Name) {
t.Errorf("expected repository %s not found", repo.Name)
}
assert.Truef(t, repos.Has(repo.Name), "expected repository %s not found", repo.Name)
}
}
func TestRepoNotExists(t *testing.T) {
if _, err := LoadFile("/this/path/does/not/exist.yaml"); err == nil {
t.Error("expected err to be non-nil when path does not exist")
} else if !strings.Contains(err.Error(), "couldn't load repositories file") {
t.Error("expected prompt `couldn't load repositories file`")
}
_, err := LoadFile("/this/path/does/not/exist.yaml")
require.Error(t, err, "expected err to be non-nil when path does not exist")
assert.ErrorContains(t, err, "couldn't load repositories file", "expected prompt `couldn't load repositories file`")
}
func TestRemoveRepositoryInvalidEntries(t *testing.T) {
@ -246,12 +206,8 @@ func TestRemoveRepositoryInvalidEntries(t *testing.T) {
removeRepository := "stable"
found := sampleRepository.Remove(removeRepository)
if !found {
t.Errorf("expected repository %s not found", removeRepository)
}
assert.Truef(t, found, "expected repository %s not found", removeRepository)
found = sampleRepository.Has(removeRepository)
if found {
t.Errorf("repository %s not deleted", removeRepository)
}
assert.Falsef(t, found, "repository %s not deleted", removeRepository)
}

Write Preview
Loading…
Cancel
Save