kubernetes
/
apiserver
mirror of https://github.com/kubernetes/apiserver.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

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
This commit is contained in:
Karl Isenberg 2025-04-29 17:05:13 -07:00 committed by Kubernetes Publisher
parent f2b80d742a
commit 1552f6cea3
22 changed files with 267 additions and 127 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

202
pkg/endpoints/apiserver_test.go
View File

@ -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=<invalid>", request.MethodGet}, TODO: there is no invalid resourceVersion. Should we be more strict?
// {"/withoptions?labelSelector=<invalid>", 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&param2=value2")
url := server.URL + "/" + prefix + "/" + testGroupVersion.Group + "/" + testGroupVersion.Version + "/namespaces/default/simple/" + itemID + "/connect?param1=value1&param2=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&param2=value2")
url := server.URL + "/" + prefix + "/" + testGroupVersion.Group + "/" + testGroupVersion.Version + "/namespaces/default/simple/" + itemID + "/connect" + testPath + "?param1=value1&param2=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)
}

46
pkg/endpoints/audit_test.go
View File

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

6
pkg/endpoints/discovery/root_test.go
View File

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

15
pkg/endpoints/filterlatency/filterlatency_test.go
View File

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

3
pkg/endpoints/filters/audit_init_test.go
View File

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

12
pkg/endpoints/filters/audit_test.go
View File

@ -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 != "" {

3
pkg/endpoints/filters/authentication_test.go
View File

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

12
pkg/endpoints/filters/authn_audit_test.go
View File

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

6
pkg/endpoints/filters/authorization_test.go
View File

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

3
pkg/endpoints/filters/cachecontrol_test.go
View File

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

2
pkg/endpoints/filters/impersonation_test.go
View File

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

3
pkg/endpoints/filters/metrics_test.go
View File

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

3
pkg/endpoints/filters/read_write_deadline_test.go
View File

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

9
pkg/endpoints/filters/request_deadline_test.go
View File

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

3
pkg/endpoints/filters/request_received_time_test.go
View File

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

3
pkg/endpoints/handlers/delete_test.go
View File

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

3
pkg/endpoints/handlers/rest_test.go
View File

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

9
pkg/endpoints/handlers/watch_test.go
View File

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

13
pkg/endpoints/patchhandler_test.go
View File

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

12
pkg/endpoints/request/requestinfo_test.go
View File

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

3
pkg/endpoints/responsewriter/wrapper_test.go
View File

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

23
pkg/endpoints/watch_test.go
View File

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