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 5

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

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

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

Write Preview
Loading…
Cancel
Save