From 1552f6cea34e2bc1969e18e6c284c6d41bf06db7 Mon Sep 17 00:00:00 2001 From: Karl Isenberg Date: Tue, 29 Apr 2025 17:05:13 -0700 Subject: [PATCH] test: pass the test context to http requests This handles canceling the request after the test completes, cleaning up resources on the client and server. Kubernetes-commit: 080d6f9ead740ec1358e320e388f79cc4de97697 --- pkg/endpoints/apiserver_test.go | 202 +++++++++++++----- pkg/endpoints/audit_test.go | 46 ++-- pkg/endpoints/discovery/root_test.go | 6 +- .../filterlatency/filterlatency_test.go | 15 +- pkg/endpoints/filters/audit_init_test.go | 3 +- pkg/endpoints/filters/audit_test.go | 12 +- pkg/endpoints/filters/authentication_test.go | 3 +- pkg/endpoints/filters/authn_audit_test.go | 12 +- pkg/endpoints/filters/authorization_test.go | 6 +- pkg/endpoints/filters/cachecontrol_test.go | 3 +- pkg/endpoints/filters/impersonation_test.go | 2 +- pkg/endpoints/filters/metrics_test.go | 3 +- .../filters/read_write_deadline_test.go | 3 +- .../filters/request_deadline_test.go | 9 +- .../filters/request_received_time_test.go | 3 +- pkg/endpoints/handlers/delete_test.go | 3 +- pkg/endpoints/handlers/rest_test.go | 3 +- pkg/endpoints/handlers/watch_test.go | 9 +- pkg/endpoints/patchhandler_test.go | 13 +- pkg/endpoints/request/requestinfo_test.go | 12 +- pkg/endpoints/responsewriter/wrapper_test.go | 3 +- pkg/endpoints/watch_test.go | 23 +- 22 files changed, 267 insertions(+), 127 deletions(-) diff --git a/pkg/endpoints/apiserver_test.go b/pkg/endpoints/apiserver_test.go index 6a98d2fa7..86f36aa3d 100644 --- a/pkg/endpoints/apiserver_test.go +++ b/pkg/endpoints/apiserver_test.go @@ -38,6 +38,7 @@ import ( "github.com/emicklei/go-restful/v3" "github.com/google/go-cmp/cmp" + "github.com/stretchr/testify/require" "k8s.io/apimachinery/pkg/api/apitesting/fuzzer" apiequality "k8s.io/apimachinery/pkg/api/equality" @@ -807,7 +808,8 @@ func TestNotFound(t *testing.T) { defer server.Close() client := http.Client{} for k, v := range cases { - request, err := http.NewRequest(v.Method, server.URL+v.Path, nil) + ctx := t.Context() + request, err := http.NewRequestWithContext(ctx, v.Method, server.URL+v.Path, nil) if err != nil { t.Fatalf("unexpected error: %v", err) } @@ -877,7 +879,8 @@ func TestUnimplementedRESTStorage(t *testing.T) { defer server.Close() client := http.Client{} for k, v := range cases { - request, err := http.NewRequest(v.Method, server.URL+v.Path, bytes.NewReader([]byte(`{"kind":"Simple","apiVersion":"version"}`))) + ctx := t.Context() + request, err := http.NewRequestWithContext(ctx, v.Method, server.URL+v.Path, bytes.NewReader([]byte(`{"kind":"Simple","apiVersion":"version"}`))) if err != nil { t.Fatalf("unexpected error: %v", err) } @@ -946,7 +949,8 @@ func TestSomeUnimplementedRESTStorage(t *testing.T) { defer server.Close() client := http.Client{} for k, v := range cases { - request, err := http.NewRequest(v.Method, server.URL+v.Path, bytes.NewReader([]byte(`{"kind":"Simple","apiVersion":"version"}`))) + ctx := t.Context() + request, err := http.NewRequestWithContext(ctx, v.Method, server.URL+v.Path, bytes.NewReader([]byte(`{"kind":"Simple","apiVersion":"version"}`))) if err != nil { t.Fatalf("unexpected error: %v", err) } @@ -1106,6 +1110,7 @@ func TestList(t *testing.T) { }, } for i, testCase := range testCases { + ctx := t.Context() storage := map[string]rest.Storage{} simpleStorage := SimpleRESTStorage{expectedResourceNamespace: testCase.namespace} storage["simple"] = &simpleStorage @@ -1113,7 +1118,10 @@ func TestList(t *testing.T) { server := httptest.NewServer(handler) defer server.Close() - resp, err := http.Get(server.URL + testCase.url) + url := server.URL + testCase.url + req, err := http.NewRequestWithContext(ctx, request.MethodGet, url, nil) + require.NoError(t, err) + resp, err := http.DefaultClient.Do(req) if err != nil { t.Errorf("%d: unexpected error: %v", i, err) continue @@ -1164,9 +1172,10 @@ func TestRequestsWithInvalidQuery(t *testing.T) { // {"/simple/foo?resourceVersion=", request.MethodGet}, TODO: there is no invalid resourceVersion. Should we be more strict? // {"/withoptions?labelSelector=", request.MethodGet}, TODO: SimpleGetOptions is always valid. Add more validation that can fail. } { + ctx := t.Context() baseURL := server.URL + "/" + grouplessPrefix + "/" + grouplessGroupVersion.Version + "/namespaces/default" url := baseURL + test.postfix - r, err := http.NewRequest(test.method, url, nil) + r, err := http.NewRequestWithContext(ctx, test.method, url, nil) if err != nil { t.Errorf("%d: unexpected error: %v", i, err) continue @@ -1211,6 +1220,7 @@ func TestListCompression(t *testing.T) { }, } for i, testCase := range testCases { + ctx := t.Context() storage := map[string]rest.Storage{} simpleStorage := SimpleRESTStorage{ expectedResourceNamespace: testCase.namespace, @@ -1227,7 +1237,7 @@ func TestListCompression(t *testing.T) { defer server.Close() - req, err := http.NewRequest(request.MethodGet, server.URL+testCase.url, nil) + req, err := http.NewRequestWithContext(ctx, request.MethodGet, server.URL+testCase.url, nil) if err != nil { t.Errorf("%d: unexpected error: %v", i, err) continue @@ -1283,12 +1293,13 @@ func TestListCompression(t *testing.T) { } func TestLogs(t *testing.T) { + ctx := t.Context() handler := handle(map[string]rest.Storage{}) server := httptest.NewServer(handler) defer server.Close() client := http.Client{} - request, err := http.NewRequest(request.MethodGet, server.URL+"/logs", nil) + request, err := http.NewRequestWithContext(ctx, request.MethodGet, server.URL+"/logs", nil) if err != nil { t.Errorf("unexpected error: %v", err) } @@ -1306,6 +1317,7 @@ func TestLogs(t *testing.T) { } func TestErrorList(t *testing.T) { + ctx := t.Context() storage := map[string]rest.Storage{} simpleStorage := SimpleRESTStorage{ errors: map[string]error{"list": fmt.Errorf("test Error")}, @@ -1315,7 +1327,10 @@ func TestErrorList(t *testing.T) { server := httptest.NewServer(handler) defer server.Close() - resp, err := http.Get(server.URL + "/" + prefix + "/" + testGroupVersion.Group + "/" + testGroupVersion.Version + "/simple") + url := server.URL + "/" + prefix + "/" + testGroupVersion.Group + "/" + testGroupVersion.Version + "/simple" + req, err := http.NewRequestWithContext(ctx, request.MethodGet, url, nil) + require.NoError(t, err) + resp, err := http.DefaultClient.Do(req) if err != nil { t.Fatalf("unexpected error: %v", err) } @@ -1326,6 +1341,7 @@ func TestErrorList(t *testing.T) { } func TestNonEmptyList(t *testing.T) { + ctx := t.Context() storage := map[string]rest.Storage{} simpleStorage := SimpleRESTStorage{ list: []genericapitesting.Simple{ @@ -1340,7 +1356,10 @@ func TestNonEmptyList(t *testing.T) { server := httptest.NewServer(handler) defer server.Close() - resp, err := http.Get(server.URL + "/" + prefix + "/" + testGroupVersion.Group + "/" + testGroupVersion.Version + "/simple") + url := server.URL + "/" + prefix + "/" + testGroupVersion.Group + "/" + testGroupVersion.Version + "/simple" + req, err := http.NewRequestWithContext(ctx, request.MethodGet, url, nil) + require.NoError(t, err) + resp, err := http.DefaultClient.Do(req) if err != nil { t.Fatalf("unexpected error: %v", err) } @@ -1408,6 +1427,7 @@ func TestMetadata(t *testing.T) { } func TestGet(t *testing.T) { + ctx := t.Context() storage := map[string]rest.Storage{} simpleStorage := SimpleRESTStorage{ item: genericapitesting.Simple{ @@ -1419,7 +1439,10 @@ func TestGet(t *testing.T) { server := httptest.NewServer(handler) defer server.Close() - resp, err := http.Get(server.URL + "/" + prefix + "/" + testGroupVersion.Group + "/" + testGroupVersion.Version + "/namespaces/default/simple/id") + url := server.URL + "/" + prefix + "/" + testGroupVersion.Group + "/" + testGroupVersion.Version + "/namespaces/default/simple/id" + req, err := http.NewRequestWithContext(ctx, request.MethodGet, url, nil) + require.NoError(t, err) + resp, err := http.DefaultClient.Do(req) if err != nil { t.Fatalf("unexpected error: %v", err) } @@ -1438,6 +1461,7 @@ func TestGet(t *testing.T) { } func BenchmarkGet(b *testing.B) { + ctx := b.Context() storage := map[string]rest.Storage{} simpleStorage := SimpleRESTStorage{ item: genericapitesting.Simple{ @@ -1449,11 +1473,13 @@ func BenchmarkGet(b *testing.B) { server := httptest.NewServer(handler) defer server.Close() - u := server.URL + "/" + prefix + "/" + testGroupVersion.Group + "/" + testGroupVersion.Version + "/namespaces/default/simple/id" + url := server.URL + "/" + prefix + "/" + testGroupVersion.Group + "/" + testGroupVersion.Version + "/namespaces/default/simple/id" b.ResetTimer() for i := 0; i < b.N; i++ { - resp, err := http.Get(u) + req, err := http.NewRequestWithContext(ctx, request.MethodGet, url, nil) + require.NoError(b, err) + resp, err := http.DefaultClient.Do(req) if err != nil { b.Fatalf("unexpected error: %v", err) } @@ -1525,7 +1551,8 @@ func TestGetCompression(t *testing.T) { } for _, test := range tests { - req, err := http.NewRequest(request.MethodGet, server.URL+"/"+prefix+"/"+testGroupVersion.Group+"/"+testGroupVersion.Version+"/namespaces/default/simple/id", nil) + ctx := t.Context() + req, err := http.NewRequestWithContext(ctx, request.MethodGet, server.URL+"/"+prefix+"/"+testGroupVersion.Group+"/"+testGroupVersion.Version+"/namespaces/default/simple/id", nil) if err != nil { t.Fatalf("unexpected error creating request: %v", err) } @@ -2260,6 +2287,7 @@ func TestGetPartialObjectMetadata(t *testing.T) { } func TestGetBinary(t *testing.T) { + ctx := t.Context() simpleStorage := SimpleRESTStorage{ stream: &SimpleStream{ contentType: "text/plain", @@ -2270,7 +2298,7 @@ func TestGetBinary(t *testing.T) { server := httptest.NewServer(handle(map[string]rest.Storage{"simple": &simpleStorage})) defer server.Close() - req, err := http.NewRequest(request.MethodGet, server.URL+"/"+prefix+"/"+testGroupVersion.Group+"/"+testGroupVersion.Version+"/namespaces/default/simple/binary", nil) + req, err := http.NewRequestWithContext(ctx, request.MethodGet, server.URL+"/"+prefix+"/"+testGroupVersion.Group+"/"+testGroupVersion.Version+"/namespaces/default/simple/binary", nil) if err != nil { t.Fatalf("unexpected error: %v", err) } @@ -2387,6 +2415,7 @@ func TestGetWithOptions(t *testing.T) { } for _, test := range tests { + ctx := t.Context() simpleStorage := GetWithOptionsRESTStorage{ SimpleRESTStorage: &SimpleRESTStorage{ item: genericapitesting.Simple{ @@ -2417,7 +2446,10 @@ func TestGetWithOptions(t *testing.T) { server := httptest.NewServer(handler) defer server.Close() - resp, err := http.Get(server.URL + "/" + prefix + "/" + testGroupVersion.Group + "/" + testGroupVersion.Version + test.requestURL) + url := server.URL + "/" + prefix + "/" + testGroupVersion.Group + "/" + testGroupVersion.Version + test.requestURL + req, err := http.NewRequestWithContext(ctx, request.MethodGet, url, nil) + require.NoError(t, err) + resp, err := http.DefaultClient.Do(req) if err != nil { t.Errorf("%s: %v", test.name, err) continue @@ -2471,6 +2503,7 @@ func TestGetWithOptions(t *testing.T) { } func TestGetMissing(t *testing.T) { + ctx := t.Context() storage := map[string]rest.Storage{} simpleStorage := SimpleRESTStorage{ errors: map[string]error{"get": apierrors.NewNotFound(schema.GroupResource{Resource: "simples"}, "id")}, @@ -2480,7 +2513,10 @@ func TestGetMissing(t *testing.T) { server := httptest.NewServer(handler) defer server.Close() - resp, err := http.Get(server.URL + "/" + prefix + "/" + testGroupVersion.Group + "/" + testGroupVersion.Version + "/namespaces/default/simple/id") + url := server.URL + "/" + prefix + "/" + testGroupVersion.Group + "/" + testGroupVersion.Version + "/namespaces/default/simple/id" + req, err := http.NewRequestWithContext(ctx, request.MethodGet, url, nil) + require.NoError(t, err) + resp, err := http.DefaultClient.Do(req) if err != nil { t.Errorf("unexpected error: %v", err) } @@ -2491,6 +2527,7 @@ func TestGetMissing(t *testing.T) { } func TestGetRetryAfter(t *testing.T) { + ctx := t.Context() storage := map[string]rest.Storage{} simpleStorage := SimpleRESTStorage{ errors: map[string]error{"get": apierrors.NewServerTimeout(schema.GroupResource{Resource: "simples"}, "id", 2)}, @@ -2500,7 +2537,10 @@ func TestGetRetryAfter(t *testing.T) { server := httptest.NewServer(handler) defer server.Close() - resp, err := http.Get(server.URL + "/" + prefix + "/" + testGroupVersion.Group + "/" + testGroupVersion.Version + "/namespaces/default/simple/id") + url := server.URL + "/" + prefix + "/" + testGroupVersion.Group + "/" + testGroupVersion.Version + "/namespaces/default/simple/id" + req, err := http.NewRequestWithContext(ctx, request.MethodGet, url, nil) + require.NoError(t, err) + resp, err := http.DefaultClient.Do(req) if err != nil { t.Errorf("unexpected error: %v", err) } @@ -2513,6 +2553,7 @@ func TestGetRetryAfter(t *testing.T) { } func TestConnect(t *testing.T) { + ctx := t.Context() responseText := "Hello World" itemID := "theID" connectStorage := &ConnecterRESTStorage{ @@ -2528,8 +2569,10 @@ func TestConnect(t *testing.T) { server := httptest.NewServer(handler) defer server.Close() - resp, err := http.Get(server.URL + "/" + prefix + "/" + testGroupVersion.Group + "/" + testGroupVersion.Version + "/namespaces/default/simple/" + itemID + "/connect") - + url := server.URL + "/" + prefix + "/" + testGroupVersion.Group + "/" + testGroupVersion.Version + "/namespaces/default/simple/" + itemID + "/connect" + req, err := http.NewRequestWithContext(ctx, request.MethodGet, url, nil) + require.NoError(t, err) + resp, err := http.DefaultClient.Do(req) if err != nil { t.Errorf("unexpected error: %v", err) } @@ -2550,6 +2593,7 @@ func TestConnect(t *testing.T) { } func TestConnectResponderObject(t *testing.T) { + ctx := t.Context() itemID := "theID" simple := &genericapitesting.Simple{Other: "foo"} connectStorage := &ConnecterRESTStorage{} @@ -2566,8 +2610,10 @@ func TestConnectResponderObject(t *testing.T) { server := httptest.NewServer(handler) defer server.Close() - resp, err := http.Get(server.URL + "/" + prefix + "/" + testGroupVersion.Group + "/" + testGroupVersion.Version + "/namespaces/default/simple/" + itemID + "/connect") - + url := server.URL + "/" + prefix + "/" + testGroupVersion.Group + "/" + testGroupVersion.Version + "/namespaces/default/simple/" + itemID + "/connect" + req, err := http.NewRequestWithContext(ctx, request.MethodGet, url, nil) + require.NoError(t, err) + resp, err := http.DefaultClient.Do(req) if err != nil { t.Errorf("unexpected error: %v", err) } @@ -2592,6 +2638,7 @@ func TestConnectResponderObject(t *testing.T) { } func TestConnectResponderError(t *testing.T) { + ctx := t.Context() itemID := "theID" connectStorage := &ConnecterRESTStorage{} connectStorage.handlerFunc = func() http.Handler { @@ -2607,8 +2654,10 @@ func TestConnectResponderError(t *testing.T) { server := httptest.NewServer(handler) defer server.Close() - resp, err := http.Get(server.URL + "/" + prefix + "/" + testGroupVersion.Group + "/" + testGroupVersion.Version + "/namespaces/default/simple/" + itemID + "/connect") - + url := server.URL + "/" + prefix + "/" + testGroupVersion.Group + "/" + testGroupVersion.Version + "/namespaces/default/simple/" + itemID + "/connect" + req, err := http.NewRequestWithContext(ctx, request.MethodGet, url, nil) + require.NoError(t, err) + resp, err := http.DefaultClient.Do(req) if err != nil { t.Errorf("unexpected error: %v", err) } @@ -2660,6 +2709,7 @@ func TestConnectWithOptionsRouteParams(t *testing.T) { } func TestConnectWithOptions(t *testing.T) { + ctx := t.Context() responseText := "Hello World" itemID := "theID" connectStorage := &ConnecterRESTStorage{ @@ -2676,8 +2726,10 @@ func TestConnectWithOptions(t *testing.T) { server := httptest.NewServer(handler) defer server.Close() - resp, err := http.Get(server.URL + "/" + prefix + "/" + testGroupVersion.Group + "/" + testGroupVersion.Version + "/namespaces/default/simple/" + itemID + "/connect?param1=value1¶m2=value2") - + url := server.URL + "/" + prefix + "/" + testGroupVersion.Group + "/" + testGroupVersion.Version + "/namespaces/default/simple/" + itemID + "/connect?param1=value1¶m2=value2" + req, err := http.NewRequestWithContext(ctx, request.MethodGet, url, nil) + require.NoError(t, err) + resp, err := http.DefaultClient.Do(req) if err != nil { t.Errorf("unexpected error: %v", err) } @@ -2708,6 +2760,7 @@ func TestConnectWithOptions(t *testing.T) { } func TestConnectWithOptionsAndPath(t *testing.T) { + ctx := t.Context() responseText := "Hello World" itemID := "theID" testPath := "/a/b/c/def" @@ -2726,8 +2779,10 @@ func TestConnectWithOptionsAndPath(t *testing.T) { server := httptest.NewServer(handler) defer server.Close() - resp, err := http.Get(server.URL + "/" + prefix + "/" + testGroupVersion.Group + "/" + testGroupVersion.Version + "/namespaces/default/simple/" + itemID + "/connect" + testPath + "?param1=value1¶m2=value2") - + url := server.URL + "/" + prefix + "/" + testGroupVersion.Group + "/" + testGroupVersion.Version + "/namespaces/default/simple/" + itemID + "/connect" + testPath + "?param1=value1¶m2=value2" + req, err := http.NewRequestWithContext(ctx, request.MethodGet, url, nil) + require.NoError(t, err) + resp, err := http.DefaultClient.Do(req) if err != nil { t.Errorf("unexpected error: %v", err) } @@ -2758,6 +2813,7 @@ func TestConnectWithOptionsAndPath(t *testing.T) { } func TestDelete(t *testing.T) { + ctx := t.Context() storage := map[string]rest.Storage{} simpleStorage := SimpleRESTStorage{} ID := "id" @@ -2767,7 +2823,7 @@ func TestDelete(t *testing.T) { defer server.Close() client := http.Client{} - request, err := http.NewRequest(request.MethodDelete, server.URL+"/"+prefix+"/"+testGroupVersion.Group+"/"+testGroupVersion.Version+"/namespaces/default/simple/"+ID, nil) + request, err := http.NewRequestWithContext(ctx, request.MethodDelete, server.URL+"/"+prefix+"/"+testGroupVersion.Group+"/"+testGroupVersion.Version+"/namespaces/default/simple/"+ID, nil) if err != nil { t.Errorf("unexpected error: %v", err) } @@ -2784,6 +2840,7 @@ func TestDelete(t *testing.T) { } func TestDeleteWithOptions(t *testing.T) { + ctx := t.Context() storage := map[string]rest.Storage{} simpleStorage := SimpleRESTStorage{} ID := "id" @@ -2802,7 +2859,7 @@ func TestDeleteWithOptions(t *testing.T) { } client := http.Client{} - request, err := http.NewRequest(request.MethodDelete, server.URL+"/"+prefix+"/"+testGroupVersion.Group+"/"+testGroupVersion.Version+"/namespaces/default/simple/"+ID, bytes.NewReader(body)) + request, err := http.NewRequestWithContext(ctx, request.MethodDelete, server.URL+"/"+prefix+"/"+testGroupVersion.Group+"/"+testGroupVersion.Version+"/namespaces/default/simple/"+ID, bytes.NewReader(body)) if err != nil { t.Errorf("unexpected error: %v", err) } @@ -2828,6 +2885,7 @@ func TestDeleteWithOptions(t *testing.T) { } func TestDeleteWithOptionsQuery(t *testing.T) { + ctx := t.Context() storage := map[string]rest.Storage{} simpleStorage := SimpleRESTStorage{} ID := "id" @@ -2842,7 +2900,7 @@ func TestDeleteWithOptionsQuery(t *testing.T) { } client := http.Client{} - request, err := http.NewRequest(request.MethodDelete, server.URL+"/"+prefix+"/"+testGroupVersion.Group+"/"+testGroupVersion.Version+"/namespaces/default/simple/"+ID+"?gracePeriodSeconds="+strconv.FormatInt(grace, 10), nil) + request, err := http.NewRequestWithContext(ctx, request.MethodDelete, server.URL+"/"+prefix+"/"+testGroupVersion.Group+"/"+testGroupVersion.Version+"/namespaces/default/simple/"+ID+"?gracePeriodSeconds="+strconv.FormatInt(grace, 10), nil) if err != nil { t.Errorf("unexpected error: %v", err) } @@ -2868,6 +2926,7 @@ func TestDeleteWithOptionsQuery(t *testing.T) { } func TestDeleteWithOptionsQueryAndBody(t *testing.T) { + ctx := t.Context() storage := map[string]rest.Storage{} simpleStorage := SimpleRESTStorage{} ID := "id" @@ -2885,7 +2944,7 @@ func TestDeleteWithOptionsQueryAndBody(t *testing.T) { t.Fatalf("unexpected error: %v", err) } client := http.Client{} - request, err := http.NewRequest(request.MethodDelete, server.URL+"/"+prefix+"/"+testGroupVersion.Group+"/"+testGroupVersion.Version+"/namespaces/default/simple/"+ID+"?gracePeriodSeconds="+strconv.FormatInt(grace+10, 10), bytes.NewReader(body)) + request, err := http.NewRequestWithContext(ctx, request.MethodDelete, server.URL+"/"+prefix+"/"+testGroupVersion.Group+"/"+testGroupVersion.Version+"/namespaces/default/simple/"+ID+"?gracePeriodSeconds="+strconv.FormatInt(grace+10, 10), bytes.NewReader(body)) if err != nil { t.Errorf("unexpected error: %v", err) } @@ -2914,6 +2973,7 @@ func TestDeleteInvokesAdmissionControl(t *testing.T) { // TODO: remove mutating deny when we removed it from the endpoint implementation and ported all plugins for _, admit := range []admission.Interface{alwaysMutatingDeny{}, alwaysValidatingDeny{}} { t.Logf("Testing %T", admit) + ctx := t.Context() storage := map[string]rest.Storage{} simpleStorage := SimpleRESTStorage{} @@ -2924,7 +2984,7 @@ func TestDeleteInvokesAdmissionControl(t *testing.T) { defer server.Close() client := http.Client{} - request, err := http.NewRequest(request.MethodDelete, server.URL+"/"+prefix+"/"+testGroupVersion.Group+"/"+testGroupVersion.Version+"/namespaces/default/simple/"+ID, nil) + request, err := http.NewRequestWithContext(ctx, request.MethodDelete, server.URL+"/"+prefix+"/"+testGroupVersion.Group+"/"+testGroupVersion.Version+"/namespaces/default/simple/"+ID, nil) if err != nil { t.Errorf("unexpected error: %v", err) } @@ -2939,6 +2999,7 @@ func TestDeleteInvokesAdmissionControl(t *testing.T) { } func TestDeleteMissing(t *testing.T) { + ctx := t.Context() storage := map[string]rest.Storage{} ID := "id" simpleStorage := SimpleRESTStorage{ @@ -2950,7 +3011,7 @@ func TestDeleteMissing(t *testing.T) { defer server.Close() client := http.Client{} - request, err := http.NewRequest(request.MethodDelete, server.URL+"/"+prefix+"/"+testGroupVersion.Group+"/"+testGroupVersion.Version+"/namespaces/default/simple/"+ID, nil) + request, err := http.NewRequestWithContext(ctx, request.MethodDelete, server.URL+"/"+prefix+"/"+testGroupVersion.Group+"/"+testGroupVersion.Version+"/namespaces/default/simple/"+ID, nil) if err != nil { t.Errorf("unexpected error: %v", err) } @@ -2965,6 +3026,7 @@ func TestDeleteMissing(t *testing.T) { } func TestUpdate(t *testing.T) { + ctx := t.Context() storage := map[string]rest.Storage{} simpleStorage := SimpleRESTStorage{} ID := "id" @@ -2987,7 +3049,7 @@ func TestUpdate(t *testing.T) { } client := http.Client{} - request, err := http.NewRequest(request.MethodPut, server.URL+"/"+prefix+"/"+testGroupVersion.Group+"/"+testGroupVersion.Version+"/namespaces/default/simple/"+ID, bytes.NewReader(body)) + request, err := http.NewRequestWithContext(ctx, request.MethodPut, server.URL+"/"+prefix+"/"+testGroupVersion.Group+"/"+testGroupVersion.Version+"/namespaces/default/simple/"+ID, bytes.NewReader(body)) if err != nil { t.Errorf("unexpected error: %v", err) } @@ -3006,6 +3068,7 @@ func TestUpdate(t *testing.T) { func TestUpdateInvokesAdmissionControl(t *testing.T) { for _, admit := range []admission.Interface{alwaysMutatingDeny{}, alwaysValidatingDeny{}} { t.Logf("Testing %T", admit) + ctx := t.Context() storage := map[string]rest.Storage{} simpleStorage := SimpleRESTStorage{} @@ -3029,7 +3092,7 @@ func TestUpdateInvokesAdmissionControl(t *testing.T) { } client := http.Client{} - request, err := http.NewRequest(request.MethodPut, server.URL+"/"+prefix+"/"+testGroupVersion.Group+"/"+testGroupVersion.Version+"/namespaces/default/simple/"+ID, bytes.NewReader(body)) + request, err := http.NewRequestWithContext(ctx, request.MethodPut, server.URL+"/"+prefix+"/"+testGroupVersion.Group+"/"+testGroupVersion.Version+"/namespaces/default/simple/"+ID, bytes.NewReader(body)) if err != nil { t.Errorf("unexpected error: %v", err) } @@ -3047,6 +3110,7 @@ func TestUpdateInvokesAdmissionControl(t *testing.T) { } func TestUpdateRequiresMatchingName(t *testing.T) { + ctx := t.Context() storage := map[string]rest.Storage{} simpleStorage := SimpleRESTStorage{} ID := "id" @@ -3065,7 +3129,7 @@ func TestUpdateRequiresMatchingName(t *testing.T) { } client := http.Client{} - request, err := http.NewRequest(request.MethodPut, server.URL+"/"+prefix+"/"+testGroupVersion.Group+"/"+testGroupVersion.Version+"/namespaces/default/simple/"+ID, bytes.NewReader(body)) + request, err := http.NewRequestWithContext(ctx, request.MethodPut, server.URL+"/"+prefix+"/"+testGroupVersion.Group+"/"+testGroupVersion.Version+"/namespaces/default/simple/"+ID, bytes.NewReader(body)) if err != nil { t.Errorf("unexpected error: %v", err) } @@ -3081,6 +3145,7 @@ func TestUpdateRequiresMatchingName(t *testing.T) { } func TestUpdateAllowsMissingNamespace(t *testing.T) { + ctx := t.Context() storage := map[string]rest.Storage{} simpleStorage := SimpleRESTStorage{} ID := "id" @@ -3102,7 +3167,7 @@ func TestUpdateAllowsMissingNamespace(t *testing.T) { } client := http.Client{} - request, err := http.NewRequest(request.MethodPut, server.URL+"/"+prefix+"/"+testGroupVersion.Group+"/"+testGroupVersion.Version+"/namespaces/default/simple/"+ID, bytes.NewReader(body)) + request, err := http.NewRequestWithContext(ctx, request.MethodPut, server.URL+"/"+prefix+"/"+testGroupVersion.Group+"/"+testGroupVersion.Version+"/namespaces/default/simple/"+ID, bytes.NewReader(body)) if err != nil { t.Errorf("unexpected error: %v", err) } @@ -3120,6 +3185,7 @@ func TestUpdateAllowsMissingNamespace(t *testing.T) { // when the object name and namespace can't be retrieved, don't update. It isn't safe. func TestUpdateDisallowsMismatchedNamespaceOnError(t *testing.T) { + ctx := t.Context() storage := map[string]rest.Storage{} simpleStorage := SimpleRESTStorage{} ID := "id" @@ -3142,7 +3208,7 @@ func TestUpdateDisallowsMismatchedNamespaceOnError(t *testing.T) { } client := http.Client{} - request, err := http.NewRequest(request.MethodPut, server.URL+"/"+prefix+"/"+testGroupVersion.Group+"/"+testGroupVersion.Version+"/namespaces/default/simple/"+ID, bytes.NewReader(body)) + request, err := http.NewRequestWithContext(ctx, request.MethodPut, server.URL+"/"+prefix+"/"+testGroupVersion.Group+"/"+testGroupVersion.Version+"/namespaces/default/simple/"+ID, bytes.NewReader(body)) if err != nil { t.Errorf("unexpected error: %v", err) } @@ -3159,6 +3225,7 @@ func TestUpdateDisallowsMismatchedNamespaceOnError(t *testing.T) { } func TestUpdatePreventsMismatchedNamespace(t *testing.T) { + ctx := t.Context() storage := map[string]rest.Storage{} simpleStorage := SimpleRESTStorage{} ID := "id" @@ -3181,7 +3248,7 @@ func TestUpdatePreventsMismatchedNamespace(t *testing.T) { } client := http.Client{} - request, err := http.NewRequest(request.MethodPut, server.URL+"/"+prefix+"/"+testGroupVersion.Group+"/"+testGroupVersion.Version+"/namespaces/default/simple/"+ID, bytes.NewReader(body)) + request, err := http.NewRequestWithContext(ctx, request.MethodPut, server.URL+"/"+prefix+"/"+testGroupVersion.Group+"/"+testGroupVersion.Version+"/namespaces/default/simple/"+ID, bytes.NewReader(body)) if err != nil { t.Errorf("unexpected error: %v", err) } @@ -3195,6 +3262,7 @@ func TestUpdatePreventsMismatchedNamespace(t *testing.T) { } func TestUpdateMissing(t *testing.T) { + ctx := t.Context() storage := map[string]rest.Storage{} ID := "id" simpleStorage := SimpleRESTStorage{ @@ -3218,7 +3286,7 @@ func TestUpdateMissing(t *testing.T) { } client := http.Client{} - request, err := http.NewRequest(request.MethodPut, server.URL+"/"+prefix+"/"+testGroupVersion.Group+"/"+testGroupVersion.Version+"/namespaces/default/simple/"+ID, bytes.NewReader(body)) + request, err := http.NewRequestWithContext(ctx, request.MethodPut, server.URL+"/"+prefix+"/"+testGroupVersion.Group+"/"+testGroupVersion.Version+"/namespaces/default/simple/"+ID, bytes.NewReader(body)) if err != nil { t.Errorf("unexpected error: %v", err) } @@ -3232,6 +3300,7 @@ func TestUpdateMissing(t *testing.T) { } func TestCreateNotFound(t *testing.T) { + ctx := t.Context() handler := handle(map[string]rest.Storage{ "simple": &SimpleRESTStorage{ // storage.Create can fail with not found error in theory. @@ -3248,7 +3317,7 @@ func TestCreateNotFound(t *testing.T) { if err != nil { t.Errorf("unexpected error: %v", err) } - request, err := http.NewRequest(request.MethodPost, server.URL+"/"+prefix+"/"+testGroupVersion.Group+"/"+testGroupVersion.Version+"/namespaces/default/simple", bytes.NewBuffer(data)) + request, err := http.NewRequestWithContext(ctx, request.MethodPost, server.URL+"/"+prefix+"/"+testGroupVersion.Group+"/"+testGroupVersion.Version+"/namespaces/default/simple", bytes.NewBuffer(data)) if err != nil { t.Errorf("unexpected error: %v", err) } @@ -3264,6 +3333,7 @@ func TestCreateNotFound(t *testing.T) { } func TestCreateChecksDecode(t *testing.T) { + ctx := t.Context() handler := handle(map[string]rest.Storage{"simple": &SimpleRESTStorage{}}) server := httptest.NewServer(handler) defer server.Close() @@ -3274,7 +3344,7 @@ func TestCreateChecksDecode(t *testing.T) { if err != nil { t.Errorf("unexpected error: %v", err) } - request, err := http.NewRequest(request.MethodPost, server.URL+"/"+prefix+"/"+testGroupVersion.Group+"/"+testGroupVersion.Version+"/namespaces/default/simple", bytes.NewBuffer(data)) + request, err := http.NewRequestWithContext(ctx, request.MethodPost, server.URL+"/"+prefix+"/"+testGroupVersion.Group+"/"+testGroupVersion.Version+"/namespaces/default/simple", bytes.NewBuffer(data)) if err != nil { t.Errorf("unexpected error: %v", err) } @@ -3379,6 +3449,7 @@ func TestParentResourceIsRequired(t *testing.T) { } func TestNamedCreaterWithName(t *testing.T) { + ctx := t.Context() pathName := "helloworld" storage := &NamedCreaterRESTStorage{SimpleRESTStorage: &SimpleRESTStorage{}} handler := handle(map[string]rest.Storage{ @@ -3394,7 +3465,7 @@ func TestNamedCreaterWithName(t *testing.T) { if err != nil { t.Errorf("unexpected error: %v", err) } - request, err := http.NewRequest(request.MethodPost, server.URL+"/"+prefix+"/"+testGroupVersion.Group+"/"+testGroupVersion.Version+"/namespaces/default/simple/"+pathName+"/sub", bytes.NewBuffer(data)) + request, err := http.NewRequestWithContext(ctx, request.MethodPost, server.URL+"/"+prefix+"/"+testGroupVersion.Group+"/"+testGroupVersion.Version+"/namespaces/default/simple/"+pathName+"/sub", bytes.NewBuffer(data)) if err != nil { t.Errorf("unexpected error: %v", err) } @@ -3411,6 +3482,7 @@ func TestNamedCreaterWithName(t *testing.T) { } func TestNamedCreaterWithoutName(t *testing.T) { + ctx := t.Context() storage := &NamedCreaterRESTStorage{ SimpleRESTStorage: &SimpleRESTStorage{ injectedFunction: func(obj runtime.Object) (runtime.Object, error) { @@ -3432,7 +3504,7 @@ func TestNamedCreaterWithoutName(t *testing.T) { if err != nil { t.Errorf("unexpected error: %v", err) } - request, err := http.NewRequest(request.MethodPost, server.URL+"/"+prefix+"/"+testGroupVersion.Group+"/"+testGroupVersion.Version+"/namespaces/default/foo", bytes.NewBuffer(data)) + request, err := http.NewRequestWithContext(ctx, request.MethodPost, server.URL+"/"+prefix+"/"+testGroupVersion.Group+"/"+testGroupVersion.Version+"/namespaces/default/foo", bytes.NewBuffer(data)) if err != nil { t.Errorf("unexpected error: %v", err) } @@ -3473,6 +3545,7 @@ func (npac *namePopulatorAdmissionControl) Handles(operation admission.Operation var _ admission.ValidationInterface = &namePopulatorAdmissionControl{} func TestNamedCreaterWithGenerateName(t *testing.T) { + ctx := t.Context() populateName := "bar" storage := &SimpleRESTStorage{ injectedFunction: func(obj runtime.Object) (runtime.Object, error) { @@ -3506,7 +3579,7 @@ func TestNamedCreaterWithGenerateName(t *testing.T) { if err != nil { t.Errorf("unexpected error: %v", err) } - request, err := http.NewRequest(request.MethodPost, server.URL+"/"+prefix+"/"+testGroupVersion.Group+"/"+testGroupVersion.Version+"/namespaces/default/foo", bytes.NewBuffer(data)) + request, err := http.NewRequestWithContext(ctx, request.MethodPost, server.URL+"/"+prefix+"/"+testGroupVersion.Group+"/"+testGroupVersion.Version+"/namespaces/default/foo", bytes.NewBuffer(data)) if err != nil { t.Errorf("unexpected error: %v", err) } @@ -3543,6 +3616,7 @@ func TestNamedCreaterWithGenerateName(t *testing.T) { } func TestUpdateChecksDecode(t *testing.T) { + ctx := t.Context() handler := handle(map[string]rest.Storage{"simple": &SimpleRESTStorage{}}) server := httptest.NewServer(handler) defer server.Close() @@ -3553,7 +3627,7 @@ func TestUpdateChecksDecode(t *testing.T) { if err != nil { t.Errorf("unexpected error: %v", err) } - request, err := http.NewRequest(request.MethodPut, server.URL+"/"+prefix+"/"+testGroupVersion.Group+"/"+testGroupVersion.Version+"/namespaces/default/simple/bar", bytes.NewBuffer(data)) + request, err := http.NewRequestWithContext(ctx, request.MethodPut, server.URL+"/"+prefix+"/"+testGroupVersion.Group+"/"+testGroupVersion.Version+"/namespaces/default/simple/bar", bytes.NewBuffer(data)) if err != nil { t.Errorf("unexpected error: %v", err) } @@ -3573,6 +3647,7 @@ func TestUpdateChecksDecode(t *testing.T) { } func TestCreate(t *testing.T) { + ctx := t.Context() storage := SimpleRESTStorage{ injectedFunction: func(obj runtime.Object) (runtime.Object, error) { time.Sleep(5 * time.Millisecond) @@ -3591,7 +3666,7 @@ func TestCreate(t *testing.T) { if err != nil { t.Errorf("unexpected error: %v", err) } - request, err := http.NewRequest(request.MethodPost, server.URL+"/"+prefix+"/"+testGroupVersion.Group+"/"+testGroupVersion.Version+"/namespaces/default/foo", bytes.NewBuffer(data)) + request, err := http.NewRequestWithContext(ctx, request.MethodPost, server.URL+"/"+prefix+"/"+testGroupVersion.Group+"/"+testGroupVersion.Version+"/namespaces/default/foo", bytes.NewBuffer(data)) if err != nil { t.Errorf("unexpected error: %v", err) } @@ -3627,6 +3702,7 @@ func TestCreate(t *testing.T) { } func TestCreateYAML(t *testing.T) { + ctx := t.Context() storage := SimpleRESTStorage{ injectedFunction: func(obj runtime.Object) (runtime.Object, error) { time.Sleep(5 * time.Millisecond) @@ -3653,7 +3729,7 @@ func TestCreateYAML(t *testing.T) { if err != nil { t.Fatalf("unexpected error: %v", err) } - request, err := http.NewRequest(request.MethodPost, server.URL+"/"+prefix+"/"+testGroupVersion.Group+"/"+testGroupVersion.Version+"/namespaces/default/foo", bytes.NewBuffer(data)) + request, err := http.NewRequestWithContext(ctx, request.MethodPost, server.URL+"/"+prefix+"/"+testGroupVersion.Group+"/"+testGroupVersion.Version+"/namespaces/default/foo", bytes.NewBuffer(data)) if err != nil { t.Fatalf("unexpected error: %v", err) } @@ -3691,6 +3767,7 @@ func TestCreateYAML(t *testing.T) { } func TestCreateInNamespace(t *testing.T) { + ctx := t.Context() storage := SimpleRESTStorage{ injectedFunction: func(obj runtime.Object) (runtime.Object, error) { time.Sleep(5 * time.Millisecond) @@ -3709,7 +3786,7 @@ func TestCreateInNamespace(t *testing.T) { if err != nil { t.Fatalf("unexpected error: %v", err) } - request, err := http.NewRequest(request.MethodPost, server.URL+"/"+prefix+"/"+testGroupVersion.Group+"/"+testGroupVersion.Version+"/namespaces/other/foo", bytes.NewBuffer(data)) + request, err := http.NewRequestWithContext(ctx, request.MethodPost, server.URL+"/"+prefix+"/"+testGroupVersion.Group+"/"+testGroupVersion.Version+"/namespaces/other/foo", bytes.NewBuffer(data)) if err != nil { t.Fatalf("unexpected error: %v", err) } @@ -3747,6 +3824,7 @@ func TestCreateInNamespace(t *testing.T) { func TestCreateInvokeAdmissionControl(t *testing.T) { for _, admit := range []admission.Interface{alwaysMutatingDeny{}, alwaysValidatingDeny{}} { t.Logf("Testing %T", admit) + ctx := t.Context() storage := SimpleRESTStorage{ injectedFunction: func(obj runtime.Object) (runtime.Object, error) { @@ -3766,7 +3844,7 @@ func TestCreateInvokeAdmissionControl(t *testing.T) { if err != nil { t.Errorf("unexpected error: %v", err) } - request, err := http.NewRequest(request.MethodPost, server.URL+"/"+prefix+"/"+testGroupVersion.Group+"/"+testGroupVersion.Version+"/namespaces/other/foo", bytes.NewBuffer(data)) + request, err := http.NewRequestWithContext(ctx, request.MethodPost, server.URL+"/"+prefix+"/"+testGroupVersion.Group+"/"+testGroupVersion.Version+"/namespaces/other/foo", bytes.NewBuffer(data)) if err != nil { t.Errorf("unexpected error: %v", err) } @@ -3784,8 +3862,9 @@ func TestCreateInvokeAdmissionControl(t *testing.T) { func expectAPIStatus(t *testing.T, method, url string, data []byte, code int) *metav1.Status { t.Helper() + ctx := t.Context() client := http.Client{} - request, err := http.NewRequest(method, url, bytes.NewBuffer(data)) + request, err := http.NewRequestWithContext(ctx, method, url, bytes.NewBuffer(data)) if err != nil { t.Fatalf("unexpected error %#v", err) return nil @@ -3909,6 +3988,7 @@ func TestCreateTimeout(t *testing.T) { } func TestCreateChecksAPIVersion(t *testing.T) { + ctx := t.Context() handler := handle(map[string]rest.Storage{"simple": &SimpleRESTStorage{}}) server := httptest.NewServer(handler) defer server.Close() @@ -3920,7 +4000,7 @@ func TestCreateChecksAPIVersion(t *testing.T) { if err != nil { t.Errorf("unexpected error: %v", err) } - request, err := http.NewRequest(request.MethodPost, server.URL+"/"+prefix+"/"+testGroupVersion.Group+"/"+testGroupVersion.Version+"/namespaces/default/simple", bytes.NewBuffer(data)) + request, err := http.NewRequestWithContext(ctx, request.MethodPost, server.URL+"/"+prefix+"/"+testGroupVersion.Group+"/"+testGroupVersion.Version+"/namespaces/default/simple", bytes.NewBuffer(data)) if err != nil { t.Errorf("unexpected error: %v", err) } @@ -3940,6 +4020,7 @@ func TestCreateChecksAPIVersion(t *testing.T) { } func TestCreateDefaultsAPIVersion(t *testing.T) { + ctx := t.Context() handler := handle(map[string]rest.Storage{"simple": &SimpleRESTStorage{}}) server := httptest.NewServer(handler) defer server.Close() @@ -3961,7 +4042,7 @@ func TestCreateDefaultsAPIVersion(t *testing.T) { t.Errorf("unexpected error: %v", err) } - request, err := http.NewRequest(request.MethodPost, server.URL+"/"+prefix+"/"+testGroupVersion.Group+"/"+testGroupVersion.Version+"/namespaces/default/simple", bytes.NewBuffer(data)) + request, err := http.NewRequestWithContext(ctx, request.MethodPost, server.URL+"/"+prefix+"/"+testGroupVersion.Group+"/"+testGroupVersion.Version+"/namespaces/default/simple", bytes.NewBuffer(data)) if err != nil { t.Errorf("unexpected error: %v", err) } @@ -3975,6 +4056,7 @@ func TestCreateDefaultsAPIVersion(t *testing.T) { } func TestUpdateChecksAPIVersion(t *testing.T) { + ctx := t.Context() handler := handle(map[string]rest.Storage{"simple": &SimpleRESTStorage{}}) server := httptest.NewServer(handler) defer server.Close() @@ -3985,7 +4067,7 @@ func TestUpdateChecksAPIVersion(t *testing.T) { if err != nil { t.Fatalf("unexpected error: %v", err) } - request, err := http.NewRequest(request.MethodPut, server.URL+"/"+prefix+"/"+testGroupVersion.Group+"/"+testGroupVersion.Version+"/namespaces/default/simple/bar", bytes.NewBuffer(data)) + request, err := http.NewRequestWithContext(ctx, request.MethodPut, server.URL+"/"+prefix+"/"+testGroupVersion.Group+"/"+testGroupVersion.Version+"/namespaces/default/simple/bar", bytes.NewBuffer(data)) if err != nil { t.Fatalf("unexpected error: %v", err) } @@ -4007,7 +4089,8 @@ func TestUpdateChecksAPIVersion(t *testing.T) { // runRequest is used by TestDryRun since it runs the test twice in a // row with a slightly different URL (one has ?dryRun, one doesn't). func runRequest(t testing.TB, path, verb string, data []byte, contentType string) *http.Response { - request, err := http.NewRequest(verb, path, bytes.NewBuffer(data)) + ctx := t.Context() + request, err := http.NewRequestWithContext(ctx, verb, path, bytes.NewBuffer(data)) if err != nil { t.Fatalf("unexpected error: %v", err) } @@ -4307,6 +4390,7 @@ func (storage *SimpleXGSubresourceRESTStorage) GetSingularName() string { } func TestXGSubresource(t *testing.T) { + ctx := t.Context() container := restful.NewContainer() container.Router(restful.CurlyRouter{}) mux := container.ServeMux @@ -4353,7 +4437,10 @@ func TestXGSubresource(t *testing.T) { server := newTestServer(defaultAPIServer{mux, container}) defer server.Close() - resp, err := http.Get(server.URL + "/" + prefix + "/" + testGroupVersion.Group + "/" + testGroupVersion.Version + "/namespaces/default/simple/" + itemID + "/subsimple") + url := server.URL + "/" + prefix + "/" + testGroupVersion.Group + "/" + testGroupVersion.Version + "/namespaces/default/simple/" + itemID + "/subsimple" + req, err := http.NewRequestWithContext(ctx, request.MethodGet, url, nil) + require.NoError(t, err) + resp, err := http.DefaultClient.Do(req) if err != nil { t.Fatalf("unexpected error: %v", err) } @@ -4399,6 +4486,7 @@ func readBodyOrDie(r io.Reader) []byte { // BenchmarkUpdateProtobuf measures the cost of processing an update on the server in proto func BenchmarkUpdateProtobuf(b *testing.B) { + ctx := b.Context() items := benchmarkItems(b) simpleStorage := &SimpleRESTStorage{} @@ -4420,7 +4508,7 @@ func BenchmarkUpdateProtobuf(b *testing.B) { b.ResetTimer() for i := 0; i < b.N; i++ { - request, err := http.NewRequest(request.MethodPut, dest.String(), bytes.NewReader(data)) + request, err := http.NewRequestWithContext(ctx, request.MethodPut, dest.String(), bytes.NewReader(data)) if err != nil { b.Fatalf("unexpected error: %v", err) } diff --git a/pkg/endpoints/audit_test.go b/pkg/endpoints/audit_test.go index c6e1b8d7d..14d02aa53 100644 --- a/pkg/endpoints/audit_test.go +++ b/pkg/endpoints/audit_test.go @@ -18,6 +18,7 @@ package endpoints import ( "bytes" + "context" "fmt" "net/http" "net/http/httptest" @@ -149,15 +150,15 @@ func TestAudit(t *testing.T) { for _, test := range []struct { desc string - req func(server string) (*http.Request, error) + req func(ctx context.Context, server string) (*http.Request, error) code int events int checks []eventCheck }{ { "get", - func(server string) (*http.Request, error) { - return http.NewRequest(request.MethodGet, server+"/"+prefix+"/"+testGroupVersion.Group+"/"+testGroupVersion.Version+"/namespaces/other/simple/c", bytes.NewBuffer(simpleFooJSON)) + func(ctx context.Context, server string) (*http.Request, error) { + return http.NewRequestWithContext(ctx, request.MethodGet, server+"/"+prefix+"/"+testGroupVersion.Group+"/"+testGroupVersion.Version+"/namespaces/other/simple/c", bytes.NewBuffer(simpleFooJSON)) }, 200, 2, @@ -169,8 +170,8 @@ func TestAudit(t *testing.T) { }, { "list", - func(server string) (*http.Request, error) { - return http.NewRequest(request.MethodGet, server+"/"+prefix+"/"+testGroupVersion.Group+"/"+testGroupVersion.Version+"/namespaces/other/simple?labelSelector=a%3Dfoobar", nil) + func(ctx context.Context, server string) (*http.Request, error) { + return http.NewRequestWithContext(ctx, request.MethodGet, server+"/"+prefix+"/"+testGroupVersion.Group+"/"+testGroupVersion.Version+"/namespaces/other/simple?labelSelector=a%3Dfoobar", nil) }, 200, 2, @@ -182,8 +183,8 @@ func TestAudit(t *testing.T) { }, { "create", - func(server string) (*http.Request, error) { - return http.NewRequest(request.MethodPost, server+"/"+prefix+"/"+testGroupVersion.Group+"/"+testGroupVersion.Version+"/namespaces/default/simple", bytes.NewBuffer(simpleFooJSON)) + func(ctx context.Context, server string) (*http.Request, error) { + return http.NewRequestWithContext(ctx, request.MethodPost, server+"/"+prefix+"/"+testGroupVersion.Group+"/"+testGroupVersion.Version+"/namespaces/default/simple", bytes.NewBuffer(simpleFooJSON)) }, 201, 2, @@ -195,8 +196,8 @@ func TestAudit(t *testing.T) { }, { "not-allowed-named-create", - func(server string) (*http.Request, error) { - return http.NewRequest(request.MethodPost, server+"/"+prefix+"/"+testGroupVersion.Group+"/"+testGroupVersion.Version+"/namespaces/default/simple/named", bytes.NewBuffer(simpleFooJSON)) + func(ctx context.Context, server string) (*http.Request, error) { + return http.NewRequestWithContext(ctx, request.MethodPost, server+"/"+prefix+"/"+testGroupVersion.Group+"/"+testGroupVersion.Version+"/namespaces/default/simple/named", bytes.NewBuffer(simpleFooJSON)) }, 405, 2, @@ -208,8 +209,8 @@ func TestAudit(t *testing.T) { }, { "delete", - func(server string) (*http.Request, error) { - return http.NewRequest(request.MethodDelete, server+"/"+prefix+"/"+testGroupVersion.Group+"/"+testGroupVersion.Version+"/namespaces/default/simple/a", nil) + func(ctx context.Context, server string) (*http.Request, error) { + return http.NewRequestWithContext(ctx, request.MethodDelete, server+"/"+prefix+"/"+testGroupVersion.Group+"/"+testGroupVersion.Version+"/namespaces/default/simple/a", nil) }, 200, 2, @@ -221,8 +222,8 @@ func TestAudit(t *testing.T) { }, { "delete-with-options-in-body", - func(server string) (*http.Request, error) { - return http.NewRequest(request.MethodDelete, server+"/"+prefix+"/"+testGroupVersion.Group+"/"+testGroupVersion.Version+"/namespaces/default/simple/a", bytes.NewBuffer([]byte(`{"kind":"DeleteOptions"}`))) + func(ctx context.Context, server string) (*http.Request, error) { + return http.NewRequestWithContext(ctx, request.MethodDelete, server+"/"+prefix+"/"+testGroupVersion.Group+"/"+testGroupVersion.Version+"/namespaces/default/simple/a", bytes.NewBuffer([]byte(`{"kind":"DeleteOptions"}`))) }, 200, 2, @@ -234,8 +235,8 @@ func TestAudit(t *testing.T) { }, { "update", - func(server string) (*http.Request, error) { - return http.NewRequest(request.MethodPut, server+"/"+prefix+"/"+testGroupVersion.Group+"/"+testGroupVersion.Version+"/namespaces/other/simple/c", bytes.NewBuffer(simpleCPrimeJSON)) + func(ctx context.Context, server string) (*http.Request, error) { + return http.NewRequestWithContext(ctx, request.MethodPut, server+"/"+prefix+"/"+testGroupVersion.Group+"/"+testGroupVersion.Version+"/namespaces/other/simple/c", bytes.NewBuffer(simpleCPrimeJSON)) }, 200, 2, @@ -247,8 +248,8 @@ func TestAudit(t *testing.T) { }, { "update-wrong-namespace", - func(server string) (*http.Request, error) { - return http.NewRequest(request.MethodPut, server+"/"+prefix+"/"+testGroupVersion.Group+"/"+testGroupVersion.Version+"/namespaces/default/simple/c", bytes.NewBuffer(simpleCPrimeJSON)) + func(ctx context.Context, server string) (*http.Request, error) { + return http.NewRequestWithContext(ctx, request.MethodPut, server+"/"+prefix+"/"+testGroupVersion.Group+"/"+testGroupVersion.Version+"/namespaces/default/simple/c", bytes.NewBuffer(simpleCPrimeJSON)) }, 400, 2, @@ -260,8 +261,8 @@ func TestAudit(t *testing.T) { }, { "patch", - func(server string) (*http.Request, error) { - req, _ := http.NewRequest(request.MethodPatch, server+"/"+prefix+"/"+testGroupVersion.Group+"/"+testGroupVersion.Version+"/namespaces/other/simple/c", bytes.NewReader([]byte(`{"labels":{"foo":"bar"}}`))) + func(ctx context.Context, server string) (*http.Request, error) { + req, _ := http.NewRequestWithContext(ctx, request.MethodPatch, server+"/"+prefix+"/"+testGroupVersion.Group+"/"+testGroupVersion.Version+"/namespaces/other/simple/c", bytes.NewReader([]byte(`{"labels":{"foo":"bar"}}`))) req.Header.Set("Content-Type", "application/merge-patch+json; charset=UTF-8") return req, nil }, @@ -275,8 +276,8 @@ func TestAudit(t *testing.T) { }, { "watch", - func(server string) (*http.Request, error) { - return http.NewRequest(request.MethodGet, server+"/"+prefix+"/"+testGroupVersion.Group+"/"+testGroupVersion.Version+"/namespaces/other/simple?watch=true", nil) + func(ctx context.Context, server string) (*http.Request, error) { + return http.NewRequestWithContext(ctx, request.MethodGet, server+"/"+prefix+"/"+testGroupVersion.Group+"/"+testGroupVersion.Version+"/namespaces/other/simple?watch=true", nil) }, 200, 3, @@ -288,6 +289,7 @@ func TestAudit(t *testing.T) { }, } { t.Run(test.desc, func(t *testing.T) { + ctx := t.Context() sink := &fakeAuditSink{} handler := handleInternal(map[string]rest.Storage{ "simple": &SimpleRESTStorage{ @@ -312,7 +314,7 @@ func TestAudit(t *testing.T) { defer server.Close() client := http.Client{Timeout: 2 * time.Second} - req, err := test.req(server.URL) + req, err := test.req(ctx, server.URL) if err != nil { t.Errorf("[%s] error creating the request: %v", test.desc, err) } diff --git a/pkg/endpoints/discovery/root_test.go b/pkg/endpoints/discovery/root_test.go index ba4015b46..2a531013e 100644 --- a/pkg/endpoints/discovery/root_test.go +++ b/pkg/endpoints/discovery/root_test.go @@ -26,6 +26,7 @@ import ( "testing" "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/runtime" @@ -67,7 +68,10 @@ func decodeResponse(t *testing.T, resp *http.Response, obj interface{}) error { } func getGroupList(t *testing.T, server *httptest.Server) (*metav1.APIGroupList, error) { - resp, err := http.Get(server.URL) + ctx := t.Context() + req, err := http.NewRequestWithContext(ctx, request.MethodGet, server.URL, nil) + require.NoError(t, err) + resp, err := http.DefaultClient.Do(req) if err != nil { return nil, err } diff --git a/pkg/endpoints/filterlatency/filterlatency_test.go b/pkg/endpoints/filterlatency/filterlatency_test.go index de138ca3c..3ff8f5b7f 100644 --- a/pkg/endpoints/filterlatency/filterlatency_test.go +++ b/pkg/endpoints/filterlatency/filterlatency_test.go @@ -31,6 +31,7 @@ import ( ) func TestTrackStartedWithContextAlreadyHasFilterRecord(t *testing.T) { + ctx := t.Context() filterName := "my-filter" var ( callCount int @@ -47,7 +48,7 @@ func TestTrackStartedWithContextAlreadyHasFilterRecord(t *testing.T) { requestFilterStarted := time.Now() wrapped := trackStarted(handler, noopoteltrace.NewTracerProvider(), filterName, testingclock.NewFakeClock(requestFilterStarted)) - testRequest, err := http.NewRequest(http.MethodGet, "/api/v1/namespaces", nil) + testRequest, err := http.NewRequestWithContext(ctx, http.MethodGet, "/api/v1/namespaces", nil) if err != nil { t.Fatalf("failed to create new http request - %v", err) } @@ -74,6 +75,7 @@ func TestTrackStartedWithContextAlreadyHasFilterRecord(t *testing.T) { } func TestTrackStartedWithContextDoesNotHaveFilterRecord(t *testing.T) { + ctx := t.Context() filterName := "my-filter" var ( callCount int @@ -90,7 +92,7 @@ func TestTrackStartedWithContextDoesNotHaveFilterRecord(t *testing.T) { requestFilterStarted := time.Now() wrapped := trackStarted(handler, noopoteltrace.NewTracerProvider(), filterName, testingclock.NewFakeClock(requestFilterStarted)) - testRequest, err := http.NewRequest(http.MethodGet, "/api/v1/namespaces", nil) + testRequest, err := http.NewRequestWithContext(ctx, http.MethodGet, "/api/v1/namespaces", nil) if err != nil { t.Fatalf("failed to create new http request - %v", err) } @@ -113,6 +115,7 @@ func TestTrackStartedWithContextDoesNotHaveFilterRecord(t *testing.T) { } func TestTrackCompletedContextHasFilterRecord(t *testing.T) { + ctx := t.Context() var ( handlerCallCount int actionCallCount int @@ -131,7 +134,7 @@ func TestTrackCompletedContextHasFilterRecord(t *testing.T) { filterCompletedAtGot = completedAt }) - testRequest, err := http.NewRequest(http.MethodGet, "/api/v1/namespaces", nil) + testRequest, err := http.NewRequestWithContext(ctx, http.MethodGet, "/api/v1/namespaces", nil) if err != nil { t.Fatalf("failed to create new http request - %v", err) } @@ -156,6 +159,7 @@ func TestTrackCompletedContextHasFilterRecord(t *testing.T) { } func TestTrackCompletedContextDoesNotHaveFilterRecord(t *testing.T) { + ctx := t.Context() var actionCallCount, handlerCallCount int handler := http.HandlerFunc(func(_ http.ResponseWriter, req *http.Request) { handlerCallCount++ @@ -165,7 +169,7 @@ func TestTrackCompletedContextDoesNotHaveFilterRecord(t *testing.T) { actionCallCount++ }) - testRequest, err := http.NewRequest(http.MethodGet, "/api/v1/namespaces", nil) + testRequest, err := http.NewRequestWithContext(ctx, http.MethodGet, "/api/v1/namespaces", nil) if err != nil { t.Fatalf("failed to create new http request - %v", err) } @@ -182,6 +186,7 @@ func TestTrackCompletedContextDoesNotHaveFilterRecord(t *testing.T) { } func TestStartedAndCompletedOpenTelemetryTracing(t *testing.T) { + ctx := t.Context() filterName := "my-filter" // Seup OTel for testing fakeRecorder := tracetest.NewSpanRecorder() @@ -197,7 +202,7 @@ func TestStartedAndCompletedOpenTelemetryTracing(t *testing.T) { wrapped := TrackCompleted(handler) wrapped = TrackStarted(wrapped, tp, filterName) - testRequest, err := http.NewRequest(http.MethodGet, "/api/v1/namespaces", nil) + testRequest, err := http.NewRequestWithContext(ctx, http.MethodGet, "/api/v1/namespaces", nil) if err != nil { t.Fatalf("failed to create new http request - %v", err) } diff --git a/pkg/endpoints/filters/audit_init_test.go b/pkg/endpoints/filters/audit_init_test.go index 9f08f0cf0..c12b28791 100644 --- a/pkg/endpoints/filters/audit_init_test.go +++ b/pkg/endpoints/filters/audit_init_test.go @@ -62,6 +62,7 @@ func TestWithAuditID(t *testing.T) { for _, test := range tests { t.Run(test.name, func(t *testing.T) { + ctx := t.Context() const auditKey = "Audit-ID" var ( innerHandlerCallCount int @@ -83,7 +84,7 @@ func TestWithAuditID(t *testing.T) { wrapped = withAuditInit(handler, test.newAuditIDFunc) } - testRequest, err := http.NewRequest(http.MethodGet, "/api/v1/namespaces", nil) + testRequest, err := http.NewRequestWithContext(ctx, http.MethodGet, "/api/v1/namespaces", nil) if err != nil { t.Fatalf("failed to create new http request - %v", err) } diff --git a/pkg/endpoints/filters/audit_test.go b/pkg/endpoints/filters/audit_test.go index 051062900..e2e77ac37 100644 --- a/pkg/endpoints/filters/audit_test.go +++ b/pkg/endpoints/filters/audit_test.go @@ -706,6 +706,7 @@ func TestAudit(t *testing.T) { }, } { t.Run(test.desc, func(t *testing.T) { + ctx := t.Context() sink := &fakeAuditSink{} fakeRuleEvaluator := policy.NewFakePolicyRuleEvaluator(auditinternal.LevelRequestResponse, test.omitStages) handler := WithAudit(http.HandlerFunc(test.handler), sink, fakeRuleEvaluator, func(r *http.Request, ri *request.RequestInfo) bool { @@ -714,7 +715,7 @@ func TestAudit(t *testing.T) { }) handler = WithAuditInit(handler) - req, _ := http.NewRequest(test.verb, test.path, nil) + req, _ := http.NewRequestWithContext(ctx, test.verb, test.path, nil) req = withTestContext(req, &user.DefaultInfo{Name: "admin"}, nil) if test.auditID != "" { req.Header.Add("Audit-ID", test.auditID) @@ -777,15 +778,17 @@ func TestAudit(t *testing.T) { } func TestAuditNoPanicOnNilUser(t *testing.T) { + ctx := t.Context() fakeRuleEvaluator := policy.NewFakePolicyRuleEvaluator(auditinternal.LevelRequestResponse, nil) handler := WithAudit(&fakeHTTPHandler{}, &fakeAuditSink{}, fakeRuleEvaluator, nil) - req, _ := http.NewRequest(request.MethodGet, "/api/v1/namespaces/default/pods", nil) + req, _ := http.NewRequestWithContext(ctx, request.MethodGet, "/api/v1/namespaces/default/pods", nil) req = withTestContext(req, nil, nil) req.RemoteAddr = "127.0.0.1" handler.ServeHTTP(httptest.NewRecorder(), req) } func TestAuditLevelNone(t *testing.T) { + ctx := t.Context() sink := &fakeAuditSink{} var handler http.Handler handler = http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) { @@ -794,7 +797,7 @@ func TestAuditLevelNone(t *testing.T) { fakeRuleEvaluator := policy.NewFakePolicyRuleEvaluator(auditinternal.LevelNone, nil) handler = WithAudit(handler, sink, fakeRuleEvaluator, nil) - req, _ := http.NewRequest(request.MethodGet, "/api/v1/namespaces/default/pods", nil) + req, _ := http.NewRequestWithContext(ctx, request.MethodGet, "/api/v1/namespaces/default/pods", nil) req.RemoteAddr = "127.0.0.1" req = withTestContext(req, &user.DefaultInfo{Name: "admin"}, nil) @@ -841,6 +844,7 @@ func TestAuditIDHttpHeader(t *testing.T) { }, } { t.Run(test.desc, func(t *testing.T) { + ctx := t.Context() sink := &fakeAuditSink{} var handler http.Handler handler = http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) { @@ -850,7 +854,7 @@ func TestAuditIDHttpHeader(t *testing.T) { handler = WithAudit(handler, sink, fakeRuleEvaluator, nil) handler = WithAuditInit(handler) - req, _ := http.NewRequest(request.MethodGet, "/api/v1/namespaces/default/pods", nil) + req, _ := http.NewRequestWithContext(ctx, request.MethodGet, "/api/v1/namespaces/default/pods", nil) req.RemoteAddr = "127.0.0.1" req = withTestContext(req, &user.DefaultInfo{Name: "admin"}, nil) if test.requestHeader != "" { diff --git a/pkg/endpoints/filters/authentication_test.go b/pkg/endpoints/filters/authentication_test.go index 75bc14c5c..865bab11c 100644 --- a/pkg/endpoints/filters/authentication_test.go +++ b/pkg/endpoints/filters/authentication_test.go @@ -628,6 +628,7 @@ func TestUnauthenticatedHTTP2ClientConnectionClose(t *testing.T) { for _, tc := range cases { t.Run(tc.name, func(t *testing.T) { f := func(t *testing.T, nextProto string, expectConnections uint64) { + ctx := t.Context() featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, features.UnauthenticatedHTTP2DOSMitigation, !tc.skipHTTP2DOSMitigation) var localAddrs atomic.Uint64 // indicates how many TCP connection set up @@ -671,7 +672,7 @@ func TestUnauthenticatedHTTP2ClientConnectionClose(t *testing.T) { } for i := 0; i < reqs; i++ { - req, err := http.NewRequest(http.MethodGet, s.URL, nil) + req, err := http.NewRequestWithContext(ctx, http.MethodGet, s.URL, nil) if err != nil { t.Fatal(err) } diff --git a/pkg/endpoints/filters/authn_audit_test.go b/pkg/endpoints/filters/authn_audit_test.go index dff0c685e..181fa479f 100644 --- a/pkg/endpoints/filters/authn_audit_test.go +++ b/pkg/endpoints/filters/authn_audit_test.go @@ -30,6 +30,7 @@ import ( ) func TestFailedAuthnAudit(t *testing.T) { + ctx := t.Context() sink := &fakeAuditSink{} fakeRuleEvaluator := policy.NewFakePolicyRuleEvaluator(auditinternal.LevelRequestResponse, nil) handler := WithFailedAuthenticationAudit( @@ -37,7 +38,7 @@ func TestFailedAuthnAudit(t *testing.T) { http.Error(w, "", http.StatusUnauthorized) }), sink, fakeRuleEvaluator) - req, _ := http.NewRequest(request.MethodGet, "/api/v1/namespaces/default/pods", nil) + req, _ := http.NewRequestWithContext(ctx, request.MethodGet, "/api/v1/namespaces/default/pods", nil) req.RemoteAddr = "127.0.0.1" req = withTestContext(req, nil, nil) req.SetBasicAuth("username", "password") @@ -62,6 +63,7 @@ func TestFailedAuthnAudit(t *testing.T) { } func TestFailedMultipleAuthnAudit(t *testing.T) { + ctx := t.Context() sink := &fakeAuditSink{} fakeRuleEvaluator := policy.NewFakePolicyRuleEvaluator(auditinternal.LevelRequestResponse, nil) handler := WithFailedAuthenticationAudit( @@ -69,7 +71,7 @@ func TestFailedMultipleAuthnAudit(t *testing.T) { http.Error(w, "", http.StatusUnauthorized) }), sink, fakeRuleEvaluator) - req, _ := http.NewRequest(request.MethodGet, "/api/v1/namespaces/default/pods", nil) + req, _ := http.NewRequestWithContext(ctx, request.MethodGet, "/api/v1/namespaces/default/pods", nil) req.RemoteAddr = "127.0.0.1" req = withTestContext(req, nil, nil) req.SetBasicAuth("username", "password") @@ -95,6 +97,7 @@ func TestFailedMultipleAuthnAudit(t *testing.T) { } func TestFailedAuthnAuditWithoutAuthorization(t *testing.T) { + ctx := t.Context() sink := &fakeAuditSink{} fakeRuleEvaluator := policy.NewFakePolicyRuleEvaluator(auditinternal.LevelRequestResponse, nil) handler := WithFailedAuthenticationAudit( @@ -102,7 +105,7 @@ func TestFailedAuthnAuditWithoutAuthorization(t *testing.T) { http.Error(w, "", http.StatusUnauthorized) }), sink, fakeRuleEvaluator) - req, _ := http.NewRequest(request.MethodGet, "/api/v1/namespaces/default/pods", nil) + req, _ := http.NewRequestWithContext(ctx, request.MethodGet, "/api/v1/namespaces/default/pods", nil) req.RemoteAddr = "127.0.0.1" req = withTestContext(req, nil, nil) handler.ServeHTTP(httptest.NewRecorder(), req) @@ -126,6 +129,7 @@ func TestFailedAuthnAuditWithoutAuthorization(t *testing.T) { } func TestFailedAuthnAuditOmitted(t *testing.T) { + ctx := t.Context() sink := &fakeAuditSink{} fakeRuleEvaluator := policy.NewFakePolicyRuleEvaluator(auditinternal.LevelRequestResponse, []auditinternal.Stage{auditinternal.StageResponseStarted}) handler := WithFailedAuthenticationAudit( @@ -133,7 +137,7 @@ func TestFailedAuthnAuditOmitted(t *testing.T) { http.Error(w, "", http.StatusUnauthorized) }), sink, fakeRuleEvaluator) - req, _ := http.NewRequest(request.MethodGet, "/api/v1/namespaces/default/pods", nil) + req, _ := http.NewRequestWithContext(ctx, request.MethodGet, "/api/v1/namespaces/default/pods", nil) req.RemoteAddr = "127.0.0.1" req = withTestContext(req, nil, nil) handler.ServeHTTP(httptest.NewRecorder(), req) diff --git a/pkg/endpoints/filters/authorization_test.go b/pkg/endpoints/filters/authorization_test.go index a390260f6..49b93e7d8 100644 --- a/pkg/endpoints/filters/authorization_test.go +++ b/pkg/endpoints/filters/authorization_test.go @@ -209,11 +209,12 @@ func TestGetAuthorizerAttributes(t *testing.T) { for k, tc := range testcases { t.Run(k, func(t *testing.T) { + ctx := t.Context() if tc.EnableAuthorizationSelector { featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, genericfeatures.AuthorizeWithSelectors, true) } - req, _ := http.NewRequest(tc.Verb, tc.Path, nil) + req, _ := http.NewRequestWithContext(ctx, tc.Verb, tc.Path, nil) req.RemoteAddr = "127.0.0.1" var attribs authorizer.Attributes @@ -282,10 +283,11 @@ func TestAuditAnnotation(t *testing.T) { scheme := runtime.NewScheme() negotiatedSerializer := serializer.NewCodecFactory(scheme).WithoutConversion() for k, tc := range testcases { + ctx := t.Context() handler := WithAuthorization(&fakeHTTPHandler{}, tc.authorizer, negotiatedSerializer) // TODO: fake audit injector - req, _ := http.NewRequest(http.MethodGet, "/api/v1/namespaces/default/pods", nil) + req, _ := http.NewRequestWithContext(ctx, http.MethodGet, "/api/v1/namespaces/default/pods", nil) req = withTestContext(req, nil, &auditinternal.Event{Level: auditinternal.LevelMetadata}) ae := audit.AuditContextFrom(req.Context()) req.RemoteAddr = "127.0.0.1" diff --git a/pkg/endpoints/filters/cachecontrol_test.go b/pkg/endpoints/filters/cachecontrol_test.go index 1bfdf0a1a..7a5766ef4 100644 --- a/pkg/endpoints/filters/cachecontrol_test.go +++ b/pkg/endpoints/filters/cachecontrol_test.go @@ -50,12 +50,13 @@ func TestCacheControl(t *testing.T) { for _, test := range tests { t.Run(test.name, func(t *testing.T) { + ctx := t.Context() handler := http.HandlerFunc(func(http.ResponseWriter, *http.Request) { //do nothing }) wrapped := WithCacheControl(handler) - testRequest, err := http.NewRequest(http.MethodGet, test.path, nil) + testRequest, err := http.NewRequestWithContext(ctx, http.MethodGet, test.path, nil) if err != nil { t.Fatal(err) } diff --git a/pkg/endpoints/filters/impersonation_test.go b/pkg/endpoints/filters/impersonation_test.go index 617202a2a..241486926 100644 --- a/pkg/endpoints/filters/impersonation_test.go +++ b/pkg/endpoints/filters/impersonation_test.go @@ -532,7 +532,7 @@ func TestImpersonationFilter(t *testing.T) { ctx = request.WithUser(request.NewContext(), tc.user) }() - req, err := http.NewRequest(http.MethodGet, server.URL, nil) + req, err := http.NewRequestWithContext(ctx, http.MethodGet, server.URL, nil) if err != nil { t.Errorf("%s: unexpected error: %v", tc.name, err) return diff --git a/pkg/endpoints/filters/metrics_test.go b/pkg/endpoints/filters/metrics_test.go index 4aa09a448..e45646368 100644 --- a/pkg/endpoints/filters/metrics_test.go +++ b/pkg/endpoints/filters/metrics_test.go @@ -252,13 +252,14 @@ func TestRecordAuthorizationMetricsMetrics(t *testing.T) { for _, tt := range testCases { t.Run(tt.desc, func(t *testing.T) { + ctx := t.Context() defer authorizationAttemptsCounter.Reset() audit := &auditinternal.Event{Level: auditinternal.LevelMetadata} handler := WithAuthorization(&fakeHTTPHandler{}, tt.authorizer, negotiatedSerializer) // TODO: fake audit injector - req, _ := http.NewRequest(http.MethodGet, "/api/v1/namespaces/default/pods", nil) + req, _ := http.NewRequestWithContext(ctx, http.MethodGet, "/api/v1/namespaces/default/pods", nil) req = withTestContext(req, nil, audit) req.RemoteAddr = "127.0.0.1" handler.ServeHTTP(httptest.NewRecorder(), req) diff --git a/pkg/endpoints/filters/read_write_deadline_test.go b/pkg/endpoints/filters/read_write_deadline_test.go index 089fe5c22..4d1321942 100644 --- a/pkg/endpoints/filters/read_write_deadline_test.go +++ b/pkg/endpoints/filters/read_write_deadline_test.go @@ -1313,7 +1313,8 @@ func TestPerRequestWithSlowReader(t *testing.T) { func sendWithTrace(t *testing.T, client *http.Client, url string, f func(*testing.T, httptrace.GotConnInfo)) (*http.Response, error) { t.Helper() - req, err := http.NewRequest(http.MethodGet, url, nil) + ctx := t.Context() + req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil) if err != nil { t.Fatalf("failed to create new request: %v", err) } diff --git a/pkg/endpoints/filters/request_deadline_test.go b/pkg/endpoints/filters/request_deadline_test.go index 6216429f8..86fbfc08a 100644 --- a/pkg/endpoints/filters/request_deadline_test.go +++ b/pkg/endpoints/filters/request_deadline_test.go @@ -70,7 +70,8 @@ func TestParseTimeout(t *testing.T) { for _, test := range tests { t.Run(test.name, func(t *testing.T) { - request, err := http.NewRequest(http.MethodGet, test.url, nil) + ctx := t.Context() + request, err := http.NewRequestWithContext(ctx, http.MethodGet, test.url, nil) if err != nil { t.Fatalf("failed to create new http request - %v", err) } @@ -442,12 +443,12 @@ func TestWithFailedRequestAudit(t *testing.T) { } func newRequest(t *testing.T, requestURL string) *http.Request { - req, err := http.NewRequest(http.MethodGet, requestURL, nil) + ctx := t.Context() + req, err := http.NewRequestWithContext(ctx, http.MethodGet, requestURL, nil) if err != nil { t.Fatalf("failed to create new http request - %v", err) } - ctx := audit.WithAuditContext(req.Context()) - return req.WithContext(ctx) + return req.WithContext(audit.WithAuditContext(req.Context())) } func message(err error) string { diff --git a/pkg/endpoints/filters/request_received_time_test.go b/pkg/endpoints/filters/request_received_time_test.go index ec4ee68e0..d0cf8e1ab 100644 --- a/pkg/endpoints/filters/request_received_time_test.go +++ b/pkg/endpoints/filters/request_received_time_test.go @@ -27,6 +27,7 @@ import ( ) func TestWithRequestReceivedTimestamp(t *testing.T) { + ctx := t.Context() receivedTimestampExpected := time.Now() var ( @@ -43,7 +44,7 @@ func TestWithRequestReceivedTimestamp(t *testing.T) { wrapped := withRequestReceivedTimestampWithClock(handler, testingclock.NewFakeClock(receivedTimestampExpected)) - testRequest, err := http.NewRequest(http.MethodGet, "/api/v1/namespaces", nil) + testRequest, err := http.NewRequestWithContext(ctx, http.MethodGet, "/api/v1/namespaces", nil) if err != nil { t.Fatalf("failed to create new http request - %v", err) } diff --git a/pkg/endpoints/handlers/delete_test.go b/pkg/endpoints/handlers/delete_test.go index 27a112f93..a317e43ab 100644 --- a/pkg/endpoints/handlers/delete_test.go +++ b/pkg/endpoints/handlers/delete_test.go @@ -216,6 +216,7 @@ func TestDeleteCollection(t *testing.T) { } func TestDeleteCollectionWithNoContextDeadlineEnforced(t *testing.T) { + ctx := t.Context() var invokedGot, hasDeadlineGot int32 fakeDeleterFn := func(ctx context.Context, _ rest.ValidateObjectFunc, _ *metav1.DeleteOptions, _ *metainternalversion.ListOptions) (runtime.Object, error) { // we expect CollectionDeleter to be executed once @@ -237,7 +238,7 @@ func TestDeleteCollectionWithNoContextDeadlineEnforced(t *testing.T) { } handler := DeleteCollection(fakeCollectionDeleterFunc(fakeDeleterFn), false, scope, nil) - request, err := http.NewRequest(request.MethodGet, "/test", nil) + request, err := http.NewRequestWithContext(ctx, request.MethodGet, "/test", nil) if err != nil { t.Fatalf("unexpected error: %v", err) } diff --git a/pkg/endpoints/handlers/rest_test.go b/pkg/endpoints/handlers/rest_test.go index 4c5a00068..d4b0aaab3 100644 --- a/pkg/endpoints/handlers/rest_test.go +++ b/pkg/endpoints/handlers/rest_test.go @@ -177,11 +177,12 @@ func TestLimitedReadBody(t *testing.T) { for _, tc := range testcases { t.Run(tc.desc, func(t *testing.T) { + ctx := t.Context() // reset metrics defer metrics.RequestBodySizes.Reset() defer legacyregistry.Reset() - req, err := http.NewRequest(request.MethodPost, "/", tc.requestBody) + req, err := http.NewRequestWithContext(ctx, request.MethodPost, "/", tc.requestBody) if err != nil { t.Errorf("err not expected: got %v", err) } diff --git a/pkg/endpoints/handlers/watch_test.go b/pkg/endpoints/handlers/watch_test.go index 77410bfa5..5d64fffd4 100644 --- a/pkg/endpoints/handlers/watch_test.go +++ b/pkg/endpoints/handlers/watch_test.go @@ -61,6 +61,7 @@ func init() { } func TestWatchHTTPErrors(t *testing.T) { + ctx := t.Context() watcher := watch.NewFake() timeoutCh := make(chan time.Time) doneCh := make(chan struct{}) @@ -92,7 +93,7 @@ func TestWatchHTTPErrors(t *testing.T) { dest.Path = "/" + namedGroupPrefix + "/" + testGroupV2.Group + "/" + testGroupV2.Version + "/simple" dest.RawQuery = "watch=true" - req, _ := http.NewRequest(http.MethodGet, dest.String(), nil) + req, _ := http.NewRequestWithContext(ctx, http.MethodGet, dest.String(), nil) client := http.Client{} resp, err := client.Do(req) require.NoError(t, err) @@ -124,6 +125,7 @@ func TestWatchHTTPErrors(t *testing.T) { } func TestWatchHTTPErrorsBeforeServe(t *testing.T) { + ctx := t.Context() watcher := watch.NewFake() timeoutCh := make(chan time.Time) doneCh := make(chan struct{}) @@ -161,7 +163,7 @@ func TestWatchHTTPErrorsBeforeServe(t *testing.T) { dest.Path = "/" + namedGroupPrefix + "/" + testGroupV2.Group + "/" + testGroupV2.Version + "/simple" dest.RawQuery = "watch=true" - req, _ := http.NewRequest(http.MethodGet, dest.String(), nil) + req, _ := http.NewRequestWithContext(ctx, http.MethodGet, dest.String(), nil) client := http.Client{} resp, err := client.Do(req) require.NoError(t, err) @@ -227,6 +229,7 @@ func TestWatchHTTPDynamicClientErrors(t *testing.T) { } func TestWatchHTTPTimeout(t *testing.T) { + ctx := t.Context() watcher := watch.NewFake() timeoutCh := make(chan time.Time) done := make(chan struct{}) @@ -258,7 +261,7 @@ func TestWatchHTTPTimeout(t *testing.T) { dest.Path = "/" + namedGroupPrefix + "/" + testGroupV2.Group + "/" + testGroupV2.Version + "/simple" dest.RawQuery = "watch=true" - req, _ := http.NewRequest(http.MethodGet, dest.String(), nil) + req, _ := http.NewRequestWithContext(ctx, http.MethodGet, dest.String(), nil) client := http.Client{} resp, err := client.Do(req) require.NoError(t, err) diff --git a/pkg/endpoints/patchhandler_test.go b/pkg/endpoints/patchhandler_test.go index b3db9a037..dd20b9026 100644 --- a/pkg/endpoints/patchhandler_test.go +++ b/pkg/endpoints/patchhandler_test.go @@ -30,6 +30,7 @@ import ( ) func TestPatch(t *testing.T) { + ctx := t.Context() storage := map[string]rest.Storage{} ID := "id" item := &genericapitesting.Simple{ @@ -47,7 +48,7 @@ func TestPatch(t *testing.T) { defer server.Close() client := http.Client{} - request, err := http.NewRequest(request.MethodPatch, server.URL+"/"+prefix+"/"+testGroupVersion.Group+"/"+testGroupVersion.Version+"/namespaces/default/simple/"+ID, bytes.NewReader([]byte(`{"labels":{"foo":"bar"}}`))) + request, err := http.NewRequestWithContext(ctx, request.MethodPatch, server.URL+"/"+prefix+"/"+testGroupVersion.Group+"/"+testGroupVersion.Version+"/namespaces/default/simple/"+ID, bytes.NewReader([]byte(`{"labels":{"foo":"bar"}}`))) if err != nil { t.Errorf("unexpected error: %v", err) } @@ -65,6 +66,7 @@ func TestPatch(t *testing.T) { } func TestForbiddenForceOnNonApply(t *testing.T) { + ctx := t.Context() storage := map[string]rest.Storage{} ID := "id" item := &genericapitesting.Simple{ @@ -82,7 +84,7 @@ func TestForbiddenForceOnNonApply(t *testing.T) { defer server.Close() client := http.Client{} - req, err := http.NewRequest(request.MethodPatch, server.URL+"/"+prefix+"/"+testGroupVersion.Group+"/"+testGroupVersion.Version+"/namespaces/default/simple/"+ID, bytes.NewReader([]byte(`{"labels":{"foo":"bar"}}`))) + req, err := http.NewRequestWithContext(ctx, request.MethodPatch, server.URL+"/"+prefix+"/"+testGroupVersion.Group+"/"+testGroupVersion.Version+"/namespaces/default/simple/"+ID, bytes.NewReader([]byte(`{"labels":{"foo":"bar"}}`))) if err != nil { t.Errorf("unexpected error: %v", err) } @@ -92,7 +94,7 @@ func TestForbiddenForceOnNonApply(t *testing.T) { t.Errorf("unexpected error: %v", err) } - req, err = http.NewRequest(request.MethodPatch, server.URL+"/"+prefix+"/"+testGroupVersion.Group+"/"+testGroupVersion.Version+"/namespaces/default/simple/"+ID+"?force=true", bytes.NewReader([]byte(`{"labels":{"foo":"bar"}}`))) + req, err = http.NewRequestWithContext(ctx, request.MethodPatch, server.URL+"/"+prefix+"/"+testGroupVersion.Group+"/"+testGroupVersion.Version+"/namespaces/default/simple/"+ID+"?force=true", bytes.NewReader([]byte(`{"labels":{"foo":"bar"}}`))) if err != nil { t.Errorf("unexpected error: %v", err) } @@ -105,7 +107,7 @@ func TestForbiddenForceOnNonApply(t *testing.T) { t.Errorf("Unexpected response %#v", response) } - req, err = http.NewRequest(request.MethodPatch, server.URL+"/"+prefix+"/"+testGroupVersion.Group+"/"+testGroupVersion.Version+"/namespaces/default/simple/"+ID+"?force=false", bytes.NewReader([]byte(`{"labels":{"foo":"bar"}}`))) + req, err = http.NewRequestWithContext(ctx, request.MethodPatch, server.URL+"/"+prefix+"/"+testGroupVersion.Group+"/"+testGroupVersion.Version+"/namespaces/default/simple/"+ID+"?force=false", bytes.NewReader([]byte(`{"labels":{"foo":"bar"}}`))) if err != nil { t.Errorf("unexpected error: %v", err) } @@ -120,6 +122,7 @@ func TestForbiddenForceOnNonApply(t *testing.T) { } func TestPatchRequiresMatchingName(t *testing.T) { + ctx := t.Context() storage := map[string]rest.Storage{} ID := "id" item := &genericapitesting.Simple{ @@ -137,7 +140,7 @@ func TestPatchRequiresMatchingName(t *testing.T) { defer server.Close() client := http.Client{} - request, err := http.NewRequest(request.MethodPatch, server.URL+"/"+prefix+"/"+testGroupVersion.Group+"/"+testGroupVersion.Version+"/namespaces/default/simple/"+ID, bytes.NewReader([]byte(`{"metadata":{"name":"idbar"}}`))) + request, err := http.NewRequestWithContext(ctx, request.MethodPatch, server.URL+"/"+prefix+"/"+testGroupVersion.Group+"/"+testGroupVersion.Version+"/namespaces/default/simple/"+ID, bytes.NewReader([]byte(`{"metadata":{"name":"idbar"}}`))) if err != nil { t.Errorf("unexpected error: %v", err) } diff --git a/pkg/endpoints/request/requestinfo_test.go b/pkg/endpoints/request/requestinfo_test.go index 8e4d53fd0..ec40c2686 100644 --- a/pkg/endpoints/request/requestinfo_test.go +++ b/pkg/endpoints/request/requestinfo_test.go @@ -95,7 +95,8 @@ func TestGetAPIRequestInfo(t *testing.T) { resolver := newTestRequestInfoResolver() for _, successCase := range successCases { - req, _ := http.NewRequest(successCase.method, successCase.url, nil) + ctx := t.Context() + req, _ := http.NewRequestWithContext(ctx, successCase.method, successCase.url, nil) apiRequestInfo, err := resolver.NewRequestInfo(req) if err != nil { @@ -136,7 +137,8 @@ func TestGetAPIRequestInfo(t *testing.T) { "missing api group": "/apis/version/resource", } for k, v := range errorCases { - req, err := http.NewRequest(MethodGet, v, nil) + ctx := t.Context() + req, err := http.NewRequestWithContext(ctx, MethodGet, v, nil) if err != nil { t.Errorf("Unexpected error %v", err) } @@ -174,7 +176,8 @@ func TestGetNonAPIRequestInfo(t *testing.T) { resolver := newTestRequestInfoResolver() for testName, tc := range tests { - req, _ := http.NewRequest(MethodGet, tc.url, nil) + ctx := t.Context() + req, _ := http.NewRequestWithContext(ctx, MethodGet, tc.url, nil) apiRequestInfo, err := resolver.NewRequestInfo(req) if err != nil { @@ -315,7 +318,8 @@ func TestSelectorParsing(t *testing.T) { featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, genericfeatures.AuthorizeWithSelectors, true) for _, tc := range tests { - req, _ := http.NewRequest(tc.method, tc.url, nil) + ctx := t.Context() + req, _ := http.NewRequestWithContext(ctx, tc.method, tc.url, nil) apiRequestInfo, err := resolver.NewRequestInfo(req) if err != nil { diff --git a/pkg/endpoints/responsewriter/wrapper_test.go b/pkg/endpoints/responsewriter/wrapper_test.go index b30a87ae5..e35793f9e 100644 --- a/pkg/endpoints/responsewriter/wrapper_test.go +++ b/pkg/endpoints/responsewriter/wrapper_test.go @@ -224,7 +224,8 @@ func newServer(t *testing.T, h http.Handler, http2 bool) *httptest.Server { } func sendRequest(t *testing.T, server *httptest.Server) { - req, err := http.NewRequest(request.MethodGet, server.URL, nil) + ctx := t.Context() + req, err := http.NewRequestWithContext(ctx, request.MethodGet, server.URL, nil) if err != nil { t.Fatalf("error creating request: %v", err) } diff --git a/pkg/endpoints/watch_test.go b/pkg/endpoints/watch_test.go index 1a2995408..fba072a53 100644 --- a/pkg/endpoints/watch_test.go +++ b/pkg/endpoints/watch_test.go @@ -30,7 +30,9 @@ import ( "time" "github.com/google/go-cmp/cmp" + "github.com/stretchr/testify/require" "golang.org/x/net/websocket" + apiequality "k8s.io/apimachinery/pkg/api/equality" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/fields" @@ -209,6 +211,7 @@ func TestWatchWebsocketClientClose(t *testing.T) { } func TestWatchClientClose(t *testing.T) { + ctx := t.Context() simpleStorage := &SimpleRESTStorage{} _ = rest.Watcher(simpleStorage) // Give compile error if this doesn't work. handler := handle(map[string]rest.Storage{"simples": simpleStorage}) @@ -219,7 +222,7 @@ func TestWatchClientClose(t *testing.T) { dest.Path = "/" + prefix + "/" + testGroupVersion.Group + "/" + testGroupVersion.Version + "/simples" dest.RawQuery = "watch=1" - request, err := http.NewRequest(request.MethodGet, dest.String(), nil) + request, err := http.NewRequestWithContext(ctx, request.MethodGet, dest.String(), nil) if err != nil { t.Fatalf("unexpected error: %v", err) } @@ -251,6 +254,7 @@ func TestWatchClientClose(t *testing.T) { } func TestWatchRead(t *testing.T) { + ctx := t.Context() simpleStorage := &SimpleRESTStorage{} _ = rest.Watcher(simpleStorage) // Give compile error if this doesn't work. handler := handle(map[string]rest.Storage{"simples": simpleStorage}) @@ -263,7 +267,7 @@ func TestWatchRead(t *testing.T) { connectHTTP := func(accept string) (io.ReadCloser, string) { client := http.Client{} - request, err := http.NewRequest(request.MethodGet, dest.String(), nil) + request, err := http.NewRequestWithContext(ctx, request.MethodGet, dest.String(), nil) if err != nil { t.Fatalf("unexpected error: %v", err) } @@ -405,6 +409,7 @@ func TestWatchRead(t *testing.T) { } func TestWatchHTTPAccept(t *testing.T) { + ctx := t.Context() simpleStorage := &SimpleRESTStorage{} handler := handle(map[string]rest.Storage{"simples": simpleStorage}) server := httptest.NewServer(handler) @@ -415,7 +420,7 @@ func TestWatchHTTPAccept(t *testing.T) { dest.Path = "/" + prefix + "/" + testGroupVersion.Group + "/" + testGroupVersion.Version + "/watch/simples" dest.RawQuery = "" - request, err := http.NewRequest(request.MethodGet, dest.String(), nil) + request, err := http.NewRequestWithContext(ctx, request.MethodGet, dest.String(), nil) if err != nil { t.Errorf("unexpected error: %v", err) } @@ -515,13 +520,17 @@ func TestWatchParamParsing(t *testing.T) { } for _, item := range table { + ctx := t.Context() simpleStorage.requestedLabelSelector = labels.Everything() simpleStorage.requestedFieldSelector = fields.Everything() simpleStorage.requestedResourceVersion = "5" // Prove this is set in all cases simpleStorage.requestedResourceNamespace = "" dest.Path = item.path dest.RawQuery = item.rawQuery - resp, err := http.Get(dest.String()) + + req, err := http.NewRequestWithContext(ctx, request.MethodGet, dest.String(), nil) + require.NoError(t, err) + resp, err := http.DefaultClient.Do(req) if err != nil { t.Errorf("%v: unexpected error: %v", item.rawQuery, err) continue @@ -565,7 +574,8 @@ func TestWatchProtocolSelection(t *testing.T) { } for _, item := range table { - request, err := http.NewRequest(request.MethodGet, dest.String(), nil) + ctx := t.Context() + request, err := http.NewRequestWithContext(ctx, request.MethodGet, dest.String(), nil) if err != nil { t.Errorf("unexpected error: %v", err) } @@ -627,6 +637,7 @@ func toObjectSlice(in []example.Pod) []runtime.Object { } func runWatchHTTPBenchmark(b *testing.B, items []runtime.Object, contentType string) { + ctx := b.Context() simpleStorage := &SimpleRESTStorage{} handler := handle(map[string]rest.Storage{"simples": simpleStorage}) server := httptest.NewServer(handler) @@ -637,7 +648,7 @@ func runWatchHTTPBenchmark(b *testing.B, items []runtime.Object, contentType str dest.Path = "/" + prefix + "/" + newGroupVersion.Group + "/" + newGroupVersion.Version + "/watch/simples" dest.RawQuery = "" - req, err := http.NewRequest(request.MethodGet, dest.String(), nil) + req, err := http.NewRequestWithContext(ctx, request.MethodGet, dest.String(), nil) if err != nil { b.Fatalf("unexpected error: %v", err) }