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

Merge pull request #131680 from karlkfi/karl-test-http-context 

test: Pass test context to http requests

Kubernetes-commit: 43be8301ed4041e7b6d6d517badf95473696d03a
This commit is contained in:
Kubernetes Publisher 2025-05-09 04:15:14 -07:00
parent f2b80d742a 1552f6cea3
commit 2ffdf9039f
24 changed files with 270 additions and 130 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
go.mod
View File

@ -49,7 +49,7 @@ require (
gopkg.in/go-jose/go-jose.v2 v2.6.3
gopkg.in/natefinch/lumberjack.v2 v2.2.1
k8s.io/api v0.0.0-20250503031400-f7e72be095ee
k8s.io/apimachinery v0.0.0-20250508031140-d56afd172ac5
k8s.io/apimachinery v0.0.0-20250509073128-f7c43800319c
k8s.io/client-go v0.0.0-20250508032644-996ce6af9b5e
k8s.io/component-base v0.0.0-20250506232724-41c27b0c0716
k8s.io/klog/v2 v2.130.1

4
go.sum
View File

@ -369,8 +369,8 @@ honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWh
honnef.co/go/tools v0.0.0-20190523083050-ea95bdfd59fc/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
k8s.io/api v0.0.0-20250503031400-f7e72be095ee h1:+YExLdNpiASfnQXQfpyLIGIps0RcJPNt7NdiCVH8Bys=
k8s.io/api v0.0.0-20250503031400-f7e72be095ee/go.mod h1:AsuSCzGYZszSLf5GB+qx8FBGGirk0I/TZUkQJFsPRAQ=
k8s.io/apimachinery v0.0.0-20250508031140-d56afd172ac5 h1:JVQ9c90KR8hQpxscK1za1B1u+iSl5FQa4yj8W0IkthQ=
k8s.io/apimachinery v0.0.0-20250508031140-d56afd172ac5/go.mod h1:b+h1nads2hmyfwvvorkgHUriRTTaJ2p2mk0l03sESn8=
k8s.io/apimachinery v0.0.0-20250509073128-f7c43800319c h1:AOgTXCqYQBXL3LukOqiunp3VtlOBvrvoUM9kDvG1kjM=
k8s.io/apimachinery v0.0.0-20250509073128-f7c43800319c/go.mod h1:b+h1nads2hmyfwvvorkgHUriRTTaJ2p2mk0l03sESn8=
k8s.io/client-go v0.0.0-20250508032644-996ce6af9b5e h1:87FD9fyCZ9Bk8dvnl1tNYE03luBomy1GNE55c9jYgxw=
k8s.io/client-go v0.0.0-20250508032644-996ce6af9b5e/go.mod h1:dvTAhQJ95EC+zjWHIb6bgrSGDNnmsN+CewryqZhfkZY=
k8s.io/component-base v0.0.0-20250506232724-41c27b0c0716 h1:0LG0V3rheo9y8JjS/ctgwDV7nMwNSDYZrhVsnF14yjE=

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