From e48116bb75ba76f4c6ae7b47615b5310a278f751 Mon Sep 17 00:00:00 2001 From: Wojciech Tyczynski Date: Tue, 10 May 2016 17:09:14 +0200 Subject: [PATCH 1/2] Client renegotiation --- pkg/client/restclient/client.go | 8 ++++++++ pkg/client/restclient/request.go | 30 +++++++++++++++++++++++++++--- 2 files changed, 35 insertions(+), 3 deletions(-) diff --git a/pkg/client/restclient/client.go b/pkg/client/restclient/client.go index 782797ad767..bf813d052a0 100644 --- a/pkg/client/restclient/client.go +++ b/pkg/client/restclient/client.go @@ -69,6 +69,7 @@ type Serializers struct { Decoder runtime.Decoder StreamingSerializer runtime.Serializer Framer runtime.Framer + RenegotiatedDecoder func(contentType string, params map[string]string) (runtime.Decoder, error) } // NewRESTClient creates a new RESTClient. This client performs generic REST functions @@ -156,6 +157,13 @@ func createSerializers(config ContentConfig) (*Serializers, error) { Decoder: negotiated.DecoderToVersion(info.Serializer, internalGV), StreamingSerializer: streamInfo.Serializer, Framer: streamInfo.Framer, + RenegotiatedDecoder: func(contentType string, params map[string]string) (runtime.Decoder, error) { + renegotiated, ok := negotiated.SerializerForMediaType(contentType, params) + if !ok { + return nil, fmt.Errorf("serializer for %s not registered", contentType) + } + return negotiated.DecoderToVersion(renegotiated.Serializer, internalGV), nil + }, }, nil } diff --git a/pkg/client/restclient/request.go b/pkg/client/restclient/request.go index e5d3511d1bf..7050eab9a98 100644 --- a/pkg/client/restclient/request.go +++ b/pkg/client/restclient/request.go @@ -910,12 +910,30 @@ func (r *Request) transformResponse(resp *http.Response, req *http.Request) Resu return Result{err: errors.FromObject(status)} } - // TODO: Check ContentType. + contentType := resp.Header.Get("Content-Type") + var decoder runtime.Decoder + if contentType == r.content.ContentType { + decoder = r.serializers.Decoder + } else { + mediaType, params, err := mime.ParseMediaType(contentType) + if err != nil { + return Result{err: errors.NewInternalError(err)} + } + decoder, err = r.serializers.RenegotiatedDecoder(mediaType, params) + if err != nil { + return Result{ + body: body, + contentType: contentType, + statusCode: resp.StatusCode, + } + } + } + return Result{ body: body, - contentType: resp.Header.Get("Content-Type"), + contentType: contentType, statusCode: resp.StatusCode, - decoder: r.serializers.Decoder, + decoder: decoder, } } @@ -1021,6 +1039,9 @@ func (r Result) Get() (runtime.Object, error) { if r.err != nil { return nil, r.err } + if r.decoder == nil { + return nil, fmt.Errorf("serializer for %s doesn't exist", r.contentType) + } return runtime.Decode(r.decoder, r.body) } @@ -1036,6 +1057,9 @@ func (r Result) Into(obj runtime.Object) error { if r.err != nil { return r.err } + if r.decoder == nil { + return fmt.Errorf("serializer for %s doesn't exist", r.contentType) + } return runtime.DecodeInto(r.decoder, r.body, obj) } From 5d046fed4127a4bc9a115a6bdefb4f087a4426ec Mon Sep 17 00:00:00 2001 From: Wojciech Tyczynski Date: Wed, 11 May 2016 09:50:47 +0200 Subject: [PATCH 2/2] Fix tests for renegotiation --- pkg/client/typed/dynamic/client_test.go | 6 +++ pkg/client/unversioned/fake/fake.go | 1 + .../unversioned/helper_blackbox_test.go | 5 +- .../namespace/namespace_controller_test.go | 2 + pkg/kubectl/cmd/annotate_test.go | 14 ++--- pkg/kubectl/cmd/apply_test.go | 16 +++--- pkg/kubectl/cmd/attach_test.go | 4 +- pkg/kubectl/cmd/cmd_test.go | 16 ++++++ pkg/kubectl/cmd/create_configmap_test.go | 2 +- pkg/kubectl/cmd/create_namespace_test.go | 2 +- pkg/kubectl/cmd/create_secret_test.go | 4 +- pkg/kubectl/cmd/create_serviceaccount_test.go | 2 +- pkg/kubectl/cmd/create_test.go | 8 +-- pkg/kubectl/cmd/delete_test.go | 48 ++++++++--------- pkg/kubectl/cmd/describe_test.go | 10 ++-- pkg/kubectl/cmd/drain_test.go | 29 +++++----- pkg/kubectl/cmd/exec_test.go | 2 +- pkg/kubectl/cmd/expose_test.go | 4 +- pkg/kubectl/cmd/get_test.go | 54 +++++++++---------- pkg/kubectl/cmd/label_test.go | 10 ++-- pkg/kubectl/cmd/logs_test.go | 4 +- pkg/kubectl/cmd/patch_test.go | 4 +- pkg/kubectl/cmd/portforward_test.go | 4 +- pkg/kubectl/cmd/replace_test.go | 20 +++---- pkg/kubectl/cmd/run_test.go | 4 +- pkg/kubectl/cmd/util/factory_test.go | 10 +++- pkg/kubectl/resource/builder_test.go | 3 ++ pkg/kubectl/resource/helper_test.go | 30 ++++++++--- pkg/kubectl/rolling_updater_test.go | 24 +++++---- 29 files changed, 199 insertions(+), 143 deletions(-) diff --git a/pkg/client/typed/dynamic/client_test.go b/pkg/client/typed/dynamic/client_test.go index b2e7a423651..850645b2199 100644 --- a/pkg/client/typed/dynamic/client_test.go +++ b/pkg/client/typed/dynamic/client_test.go @@ -125,6 +125,7 @@ func TestList(t *testing.T) { t.Errorf("List(%q) got path %s. wanted %s", tc.name, r.URL.Path, tc.path) } + w.Header().Set("Content-Type", runtime.ContentTypeJSON) w.Write(tc.resp) }) if err != nil { @@ -179,6 +180,7 @@ func TestGet(t *testing.T) { t.Errorf("Get(%q) got path %s. wanted %s", tc.name, r.URL.Path, tc.path) } + w.Header().Set("Content-Type", runtime.ContentTypeJSON) w.Write(tc.resp) }) if err != nil { @@ -231,6 +233,7 @@ func TestDelete(t *testing.T) { t.Errorf("Delete(%q) got path %s. wanted %s", tc.name, r.URL.Path, tc.path) } + w.Header().Set("Content-Type", runtime.ContentTypeJSON) runtime.UnstructuredJSONScheme.EncodeToStream(statusOK, w) }) if err != nil { @@ -279,6 +282,7 @@ func TestDeleteCollection(t *testing.T) { t.Errorf("DeleteCollection(%q) got path %s. wanted %s", tc.name, r.URL.Path, tc.path) } + w.Header().Set("Content-Type", runtime.ContentTypeJSON) runtime.UnstructuredJSONScheme.EncodeToStream(statusOK, w) }) if err != nil { @@ -326,6 +330,7 @@ func TestCreate(t *testing.T) { t.Errorf("Create(%q) got path %s. wanted %s", tc.name, r.URL.Path, tc.path) } + w.Header().Set("Content-Type", runtime.ContentTypeJSON) data, err := ioutil.ReadAll(r.Body) if err != nil { t.Errorf("Create(%q) unexpected error reading body: %v", tc.name, err) @@ -384,6 +389,7 @@ func TestUpdate(t *testing.T) { t.Errorf("Update(%q) got path %s. wanted %s", tc.name, r.URL.Path, tc.path) } + w.Header().Set("Content-Type", runtime.ContentTypeJSON) data, err := ioutil.ReadAll(r.Body) if err != nil { t.Errorf("Update(%q) unexpected error reading body: %v", tc.name, err) diff --git a/pkg/client/unversioned/fake/fake.go b/pkg/client/unversioned/fake/fake.go index df7824251f9..7fd452d264d 100644 --- a/pkg/client/unversioned/fake/fake.go +++ b/pkg/client/unversioned/fake/fake.go @@ -71,6 +71,7 @@ func (c *RESTClient) Delete() *restclient.Request { func (c *RESTClient) request(verb string) *restclient.Request { config := restclient.ContentConfig{ + ContentType: runtime.ContentTypeJSON, GroupVersion: testapi.Default.GroupVersion(), Codec: c.Codec, } diff --git a/pkg/client/unversioned/helper_blackbox_test.go b/pkg/client/unversioned/helper_blackbox_test.go index c4860a12f82..ce517530c18 100644 --- a/pkg/client/unversioned/helper_blackbox_test.go +++ b/pkg/client/unversioned/helper_blackbox_test.go @@ -31,6 +31,7 @@ import ( "k8s.io/kubernetes/pkg/client/restclient" "k8s.io/kubernetes/pkg/client/unversioned" "k8s.io/kubernetes/pkg/client/unversioned/fake" + "k8s.io/kubernetes/pkg/runtime" ) func objBody(object interface{}) io.ReadCloser { @@ -104,7 +105,9 @@ func TestNegotiateVersion(t *testing.T) { if test.sendErr != nil { return nil, test.sendErr } - return &http.Response{StatusCode: 200, Body: objBody(&uapi.APIVersions{Versions: test.serverVersions})}, nil + header := http.Header{} + header.Set("Content-Type", runtime.ContentTypeJSON) + return &http.Response{StatusCode: 200, Header: header, Body: objBody(&uapi.APIVersions{Versions: test.serverVersions})}, nil }), } c := unversioned.NewOrDie(test.config) diff --git a/pkg/controller/namespace/namespace_controller_test.go b/pkg/controller/namespace/namespace_controller_test.go index b0dcd3fcffc..f03a59d7130 100644 --- a/pkg/controller/namespace/namespace_controller_test.go +++ b/pkg/controller/namespace/namespace_controller_test.go @@ -33,6 +33,7 @@ import ( "k8s.io/kubernetes/pkg/client/restclient" "k8s.io/kubernetes/pkg/client/testing/core" "k8s.io/kubernetes/pkg/client/typed/dynamic" + "k8s.io/kubernetes/pkg/runtime" "k8s.io/kubernetes/pkg/util/sets" ) @@ -268,6 +269,7 @@ func (f *fakeActionHandler) ServeHTTP(response http.ResponseWriter, request *htt defer f.lock.Unlock() f.actions = append(f.actions, fakeAction{method: request.Method, path: request.URL.Path}) + response.Header().Set("Content-Type", runtime.ContentTypeJSON) response.WriteHeader(f.statusCode) response.Write([]byte("{\"kind\": \"List\"}")) } diff --git a/pkg/kubectl/cmd/annotate_test.go b/pkg/kubectl/cmd/annotate_test.go index 2cd94445eb8..58730662ab0 100644 --- a/pkg/kubectl/cmd/annotate_test.go +++ b/pkg/kubectl/cmd/annotate_test.go @@ -428,7 +428,7 @@ func TestAnnotateObject(t *testing.T) { case "GET": switch req.URL.Path { case "/namespaces/test/pods/foo": - return &http.Response{StatusCode: 200, Body: objBody(codec, &pods.Items[0])}, nil + return &http.Response{StatusCode: 200, Header: defaultHeader(), Body: objBody(codec, &pods.Items[0])}, nil default: t.Fatalf("unexpected request: %#v\n%#v", req.URL, req) return nil, nil @@ -436,7 +436,7 @@ func TestAnnotateObject(t *testing.T) { case "PATCH": switch req.URL.Path { case "/namespaces/test/pods/foo": - return &http.Response{StatusCode: 200, Body: objBody(codec, &pods.Items[0])}, nil + return &http.Response{StatusCode: 200, Header: defaultHeader(), Body: objBody(codec, &pods.Items[0])}, nil default: t.Fatalf("unexpected request: %#v\n%#v", req.URL, req) return nil, nil @@ -478,7 +478,7 @@ func TestAnnotateObjectFromFile(t *testing.T) { case "GET": switch req.URL.Path { case "/namespaces/test/replicationcontrollers/cassandra": - return &http.Response{StatusCode: 200, Body: objBody(codec, &pods.Items[0])}, nil + return &http.Response{StatusCode: 200, Header: defaultHeader(), Body: objBody(codec, &pods.Items[0])}, nil default: t.Fatalf("unexpected request: %#v\n%#v", req.URL, req) return nil, nil @@ -486,7 +486,7 @@ func TestAnnotateObjectFromFile(t *testing.T) { case "PATCH": switch req.URL.Path { case "/namespaces/test/replicationcontrollers/cassandra": - return &http.Response{StatusCode: 200, Body: objBody(codec, &pods.Items[0])}, nil + return &http.Response{StatusCode: 200, Header: defaultHeader(), Body: objBody(codec, &pods.Items[0])}, nil default: t.Fatalf("unexpected request: %#v\n%#v", req.URL, req) return nil, nil @@ -529,7 +529,7 @@ func TestAnnotateMultipleObjects(t *testing.T) { case "GET": switch req.URL.Path { case "/namespaces/test/pods": - return &http.Response{StatusCode: 200, Body: objBody(codec, pods)}, nil + return &http.Response{StatusCode: 200, Header: defaultHeader(), Body: objBody(codec, pods)}, nil default: t.Fatalf("unexpected request: %#v\n%#v", req.URL, req) return nil, nil @@ -537,9 +537,9 @@ func TestAnnotateMultipleObjects(t *testing.T) { case "PATCH": switch req.URL.Path { case "/namespaces/test/pods/foo": - return &http.Response{StatusCode: 200, Body: objBody(codec, &pods.Items[0])}, nil + return &http.Response{StatusCode: 200, Header: defaultHeader(), Body: objBody(codec, &pods.Items[0])}, nil case "/namespaces/test/pods/bar": - return &http.Response{StatusCode: 200, Body: objBody(codec, &pods.Items[1])}, nil + return &http.Response{StatusCode: 200, Header: defaultHeader(), Body: objBody(codec, &pods.Items[1])}, nil default: t.Fatalf("unexpected request: %#v\n%#v", req.URL, req) return nil, nil diff --git a/pkg/kubectl/cmd/apply_test.go b/pkg/kubectl/cmd/apply_test.go index 050dfd92560..a711802d7be 100644 --- a/pkg/kubectl/cmd/apply_test.go +++ b/pkg/kubectl/cmd/apply_test.go @@ -187,11 +187,11 @@ func TestApplyObject(t *testing.T) { switch p, m := req.URL.Path, req.Method; { case p == pathRC && m == "GET": bodyRC := ioutil.NopCloser(bytes.NewReader(currentRC)) - return &http.Response{StatusCode: 200, Body: bodyRC}, nil + return &http.Response{StatusCode: 200, Header: defaultHeader(), Body: bodyRC}, nil case p == pathRC && m == "PATCH": validatePatchApplication(t, req) bodyRC := ioutil.NopCloser(bytes.NewReader(currentRC)) - return &http.Response{StatusCode: 200, Body: bodyRC}, nil + return &http.Response{StatusCode: 200, Header: defaultHeader(), Body: bodyRC}, nil default: t.Fatalf("unexpected request: %#v\n%#v", req.URL, req) return nil, nil @@ -225,10 +225,10 @@ func TestApplyNonExistObject(t *testing.T) { Client: fake.CreateHTTPClient(func(req *http.Request) (*http.Response, error) { switch p, m := req.URL.Path, req.Method; { case p == pathNameRC && m == "GET": - return &http.Response{StatusCode: 404, Body: ioutil.NopCloser(bytes.NewReader(nil))}, nil + return &http.Response{StatusCode: 404, Header: defaultHeader(), Body: ioutil.NopCloser(bytes.NewReader(nil))}, nil case p == pathRC && m == "POST": bodyRC := ioutil.NopCloser(bytes.NewReader(currentRC)) - return &http.Response{StatusCode: 201, Body: bodyRC}, nil + return &http.Response{StatusCode: 201, Header: defaultHeader(), Body: bodyRC}, nil default: t.Fatalf("unexpected request: %#v\n%#v", req.URL, req) return nil, nil @@ -273,18 +273,18 @@ func testApplyMultipleObjects(t *testing.T, asList bool) { switch p, m := req.URL.Path, req.Method; { case p == pathRC && m == "GET": bodyRC := ioutil.NopCloser(bytes.NewReader(currentRC)) - return &http.Response{StatusCode: 200, Body: bodyRC}, nil + return &http.Response{StatusCode: 200, Header: defaultHeader(), Body: bodyRC}, nil case p == pathRC && m == "PATCH": validatePatchApplication(t, req) bodyRC := ioutil.NopCloser(bytes.NewReader(currentRC)) - return &http.Response{StatusCode: 200, Body: bodyRC}, nil + return &http.Response{StatusCode: 200, Header: defaultHeader(), Body: bodyRC}, nil case p == pathSVC && m == "GET": bodySVC := ioutil.NopCloser(bytes.NewReader(currentSVC)) - return &http.Response{StatusCode: 200, Body: bodySVC}, nil + return &http.Response{StatusCode: 200, Header: defaultHeader(), Body: bodySVC}, nil case p == pathSVC && m == "PATCH": validatePatchApplication(t, req) bodySVC := ioutil.NopCloser(bytes.NewReader(currentSVC)) - return &http.Response{StatusCode: 200, Body: bodySVC}, nil + return &http.Response{StatusCode: 200, Header: defaultHeader(), Body: bodySVC}, nil default: t.Fatalf("unexpected request: %#v\n%#v", req.URL, req) return nil, nil diff --git a/pkg/kubectl/cmd/attach_test.go b/pkg/kubectl/cmd/attach_test.go index fcefb74fb44..29128ae5188 100644 --- a/pkg/kubectl/cmd/attach_test.go +++ b/pkg/kubectl/cmd/attach_test.go @@ -141,7 +141,7 @@ func TestAttach(t *testing.T) { switch p, m := req.URL.Path, req.Method; { case p == test.podPath && m == "GET": body := objBody(codec, test.pod) - return &http.Response{StatusCode: 200, Body: body}, nil + return &http.Response{StatusCode: 200, Header: defaultHeader(), Body: body}, nil default: // Ensures no GET is performed when deleting by name t.Errorf("%s: unexpected request: %s %#v\n%#v", test.name, req.Method, req.URL, req) @@ -219,7 +219,7 @@ func TestAttachWarnings(t *testing.T) { switch p, m := req.URL.Path, req.Method; { case p == test.podPath && m == "GET": body := objBody(codec, test.pod) - return &http.Response{StatusCode: 200, Body: body}, nil + return &http.Response{StatusCode: 200, Header: defaultHeader(), Body: body}, nil default: t.Errorf("%s: unexpected request: %s %#v\n%#v", test.name, req.Method, req.URL, req) return nil, fmt.Errorf("unexpected request") diff --git a/pkg/kubectl/cmd/cmd_test.go b/pkg/kubectl/cmd/cmd_test.go index 500b7a7d242..2e63261411b 100644 --- a/pkg/kubectl/cmd/cmd_test.go +++ b/pkg/kubectl/cmd/cmd_test.go @@ -22,6 +22,7 @@ import ( "fmt" "io" "io/ioutil" + "net/http" "os" "reflect" "testing" @@ -49,6 +50,21 @@ func initTestErrorHandler(t *testing.T) { }) } +func defaultHeader() http.Header { + header := http.Header{} + header.Set("Content-Type", runtime.ContentTypeJSON) + return header +} + +func defaultClientConfig() *restclient.Config { + return &restclient.Config{ + ContentConfig: restclient.ContentConfig{ + ContentType: runtime.ContentTypeJSON, + GroupVersion: testapi.Default.GroupVersion(), + }, + } +} + type internalType struct { Kind string APIVersion string diff --git a/pkg/kubectl/cmd/create_configmap_test.go b/pkg/kubectl/cmd/create_configmap_test.go index 9c3971e36ac..fff769a48df 100644 --- a/pkg/kubectl/cmd/create_configmap_test.go +++ b/pkg/kubectl/cmd/create_configmap_test.go @@ -35,7 +35,7 @@ func TestCreateConfigMap(t *testing.T) { Client: fake.CreateHTTPClient(func(req *http.Request) (*http.Response, error) { switch p, m := req.URL.Path, req.Method; { case p == "/namespaces/test/configmaps" && m == "POST": - return &http.Response{StatusCode: 201, Body: objBody(codec, configMap)}, nil + return &http.Response{StatusCode: 201, Header: defaultHeader(), Body: objBody(codec, configMap)}, nil default: t.Fatalf("unexpected request: %#v\n%#v", req.URL, req) return nil, nil diff --git a/pkg/kubectl/cmd/create_namespace_test.go b/pkg/kubectl/cmd/create_namespace_test.go index dd74eec4bd2..80483f2f588 100644 --- a/pkg/kubectl/cmd/create_namespace_test.go +++ b/pkg/kubectl/cmd/create_namespace_test.go @@ -35,7 +35,7 @@ func TestCreateNamespace(t *testing.T) { Client: fake.CreateHTTPClient(func(req *http.Request) (*http.Response, error) { switch p, m := req.URL.Path, req.Method; { case p == "/namespaces" && m == "POST": - return &http.Response{StatusCode: 201, Body: objBody(codec, namespaceObject)}, nil + return &http.Response{StatusCode: 201, Header: defaultHeader(), Body: objBody(codec, namespaceObject)}, nil default: t.Fatalf("unexpected request: %#v\n%#v", req.URL, req) return nil, nil diff --git a/pkg/kubectl/cmd/create_secret_test.go b/pkg/kubectl/cmd/create_secret_test.go index 8365513eb08..ff3dcf162ab 100644 --- a/pkg/kubectl/cmd/create_secret_test.go +++ b/pkg/kubectl/cmd/create_secret_test.go @@ -35,7 +35,7 @@ func TestCreateSecretGeneric(t *testing.T) { Client: fake.CreateHTTPClient(func(req *http.Request) (*http.Response, error) { switch p, m := req.URL.Path, req.Method; { case p == "/namespaces/test/secrets" && m == "POST": - return &http.Response{StatusCode: 201, Body: objBody(codec, secretObject)}, nil + return &http.Response{StatusCode: 201, Header: defaultHeader(), Body: objBody(codec, secretObject)}, nil default: t.Fatalf("unexpected request: %#v\n%#v", req.URL, req) return nil, nil @@ -63,7 +63,7 @@ func TestCreateSecretDockerRegistry(t *testing.T) { Client: fake.CreateHTTPClient(func(req *http.Request) (*http.Response, error) { switch p, m := req.URL.Path, req.Method; { case p == "/namespaces/test/secrets" && m == "POST": - return &http.Response{StatusCode: 201, Body: objBody(codec, secretObject)}, nil + return &http.Response{StatusCode: 201, Header: defaultHeader(), Body: objBody(codec, secretObject)}, nil default: t.Fatalf("unexpected request: %#v\n%#v", req.URL, req) return nil, nil diff --git a/pkg/kubectl/cmd/create_serviceaccount_test.go b/pkg/kubectl/cmd/create_serviceaccount_test.go index 6573e6d0219..927e6132ae8 100644 --- a/pkg/kubectl/cmd/create_serviceaccount_test.go +++ b/pkg/kubectl/cmd/create_serviceaccount_test.go @@ -35,7 +35,7 @@ func TestCreateServiceAccount(t *testing.T) { Client: fake.CreateHTTPClient(func(req *http.Request) (*http.Response, error) { switch p, m := req.URL.Path, req.Method; { case p == "/namespaces/test/serviceaccounts" && m == "POST": - return &http.Response{StatusCode: 201, Body: objBody(codec, serviceAccountObject)}, nil + return &http.Response{StatusCode: 201, Header: defaultHeader(), Body: objBody(codec, serviceAccountObject)}, nil default: t.Fatalf("unexpected request: %#v\n%#v", req.URL, req) return nil, nil diff --git a/pkg/kubectl/cmd/create_test.go b/pkg/kubectl/cmd/create_test.go index 005b5faeefb..e365b406e2f 100644 --- a/pkg/kubectl/cmd/create_test.go +++ b/pkg/kubectl/cmd/create_test.go @@ -49,7 +49,7 @@ func TestCreateObject(t *testing.T) { Client: fake.CreateHTTPClient(func(req *http.Request) (*http.Response, error) { switch p, m := req.URL.Path, req.Method; { case p == "/namespaces/test/replicationcontrollers" && m == "POST": - return &http.Response{StatusCode: 201, Body: objBody(codec, &rc.Items[0])}, nil + return &http.Response{StatusCode: 201, Header: defaultHeader(), Body: objBody(codec, &rc.Items[0])}, nil default: t.Fatalf("unexpected request: %#v\n%#v", req.URL, req) return nil, nil @@ -81,9 +81,9 @@ func TestCreateMultipleObject(t *testing.T) { Client: fake.CreateHTTPClient(func(req *http.Request) (*http.Response, error) { switch p, m := req.URL.Path, req.Method; { case p == "/namespaces/test/services" && m == "POST": - return &http.Response{StatusCode: 201, Body: objBody(codec, &svc.Items[0])}, nil + return &http.Response{StatusCode: 201, Header: defaultHeader(), Body: objBody(codec, &svc.Items[0])}, nil case p == "/namespaces/test/replicationcontrollers" && m == "POST": - return &http.Response{StatusCode: 201, Body: objBody(codec, &rc.Items[0])}, nil + return &http.Response{StatusCode: 201, Header: defaultHeader(), Body: objBody(codec, &rc.Items[0])}, nil default: t.Fatalf("unexpected request: %#v\n%#v", req.URL, req) return nil, nil @@ -117,7 +117,7 @@ func TestCreateDirectory(t *testing.T) { Client: fake.CreateHTTPClient(func(req *http.Request) (*http.Response, error) { switch p, m := req.URL.Path, req.Method; { case p == "/namespaces/test/replicationcontrollers" && m == "POST": - return &http.Response{StatusCode: 201, Body: objBody(codec, &rc.Items[0])}, nil + return &http.Response{StatusCode: 201, Header: defaultHeader(), Body: objBody(codec, &rc.Items[0])}, nil default: t.Fatalf("unexpected request: %#v\n%#v", req.URL, req) return nil, nil diff --git a/pkg/kubectl/cmd/delete_test.go b/pkg/kubectl/cmd/delete_test.go index 5e3cf3c99b3..1f2122ab013 100644 --- a/pkg/kubectl/cmd/delete_test.go +++ b/pkg/kubectl/cmd/delete_test.go @@ -39,7 +39,7 @@ func TestDeleteObjectByTuple(t *testing.T) { Client: fake.CreateHTTPClient(func(req *http.Request) (*http.Response, error) { switch p, m := req.URL.Path, req.Method; { case p == "/namespaces/test/replicationcontrollers/redis-master-controller" && m == "DELETE": - return &http.Response{StatusCode: 200, Body: objBody(codec, &rc.Items[0])}, nil + return &http.Response{StatusCode: 200, Header: defaultHeader(), Body: objBody(codec, &rc.Items[0])}, nil default: // Ensures no GET is performed when deleting by name t.Fatalf("unexpected request: %#v\n%#v", req.URL, req) @@ -71,7 +71,7 @@ func TestDeleteNamedObject(t *testing.T) { Client: fake.CreateHTTPClient(func(req *http.Request) (*http.Response, error) { switch p, m := req.URL.Path, req.Method; { case p == "/namespaces/test/replicationcontrollers/redis-master-controller" && m == "DELETE": - return &http.Response{StatusCode: 200, Body: objBody(codec, &rc.Items[0])}, nil + return &http.Response{StatusCode: 200, Header: defaultHeader(), Body: objBody(codec, &rc.Items[0])}, nil default: // Ensures no GET is performed when deleting by name t.Fatalf("unexpected request: %#v\n%#v", req.URL, req) @@ -103,7 +103,7 @@ func TestDeleteObject(t *testing.T) { Client: fake.CreateHTTPClient(func(req *http.Request) (*http.Response, error) { switch p, m := req.URL.Path, req.Method; { case p == "/namespaces/test/replicationcontrollers/redis-master" && m == "DELETE": - return &http.Response{StatusCode: 200, Body: objBody(codec, &rc.Items[0])}, nil + return &http.Response{StatusCode: 200, Header: defaultHeader(), Body: objBody(codec, &rc.Items[0])}, nil default: t.Fatalf("unexpected request: %#v\n%#v", req.URL, req) return nil, nil @@ -133,7 +133,7 @@ func TestDeleteObjectNotFound(t *testing.T) { Client: fake.CreateHTTPClient(func(req *http.Request) (*http.Response, error) { switch p, m := req.URL.Path, req.Method; { case p == "/namespaces/test/replicationcontrollers/redis-master" && m == "DELETE": - return &http.Response{StatusCode: 404, Body: stringBody("")}, nil + return &http.Response{StatusCode: 404, Header: defaultHeader(), Body: stringBody("")}, nil default: t.Fatalf("unexpected request: %#v\n%#v", req.URL, req) return nil, nil @@ -163,7 +163,7 @@ func TestDeleteObjectIgnoreNotFound(t *testing.T) { Client: fake.CreateHTTPClient(func(req *http.Request) (*http.Response, error) { switch p, m := req.URL.Path, req.Method; { case p == "/namespaces/test/replicationcontrollers/redis-master" && m == "DELETE": - return &http.Response{StatusCode: 404, Body: stringBody("")}, nil + return &http.Response{StatusCode: 404, Header: defaultHeader(), Body: stringBody("")}, nil default: t.Fatalf("unexpected request: %#v\n%#v", req.URL, req) return nil, nil @@ -200,11 +200,11 @@ func TestDeleteAllNotFound(t *testing.T) { Client: fake.CreateHTTPClient(func(req *http.Request) (*http.Response, error) { switch p, m := req.URL.Path, req.Method; { case p == "/namespaces/test/services" && m == "GET": - return &http.Response{StatusCode: 200, Body: objBody(codec, svc)}, nil + return &http.Response{StatusCode: 200, Header: defaultHeader(), Body: objBody(codec, svc)}, nil case p == "/namespaces/test/services/foo" && m == "DELETE": - return &http.Response{StatusCode: 404, Body: objBody(codec, notFoundError)}, nil + return &http.Response{StatusCode: 404, Header: defaultHeader(), Body: objBody(codec, notFoundError)}, nil case p == "/namespaces/test/services/baz" && m == "DELETE": - return &http.Response{StatusCode: 200, Body: objBody(codec, &svc.Items[0])}, nil + return &http.Response{StatusCode: 200, Header: defaultHeader(), Body: objBody(codec, &svc.Items[0])}, nil default: t.Fatalf("unexpected request: %#v\n%#v", req.URL, req) return nil, nil @@ -242,11 +242,11 @@ func TestDeleteAllIgnoreNotFound(t *testing.T) { Client: fake.CreateHTTPClient(func(req *http.Request) (*http.Response, error) { switch p, m := req.URL.Path, req.Method; { case p == "/namespaces/test/services" && m == "GET": - return &http.Response{StatusCode: 200, Body: objBody(codec, svc)}, nil + return &http.Response{StatusCode: 200, Header: defaultHeader(), Body: objBody(codec, svc)}, nil case p == "/namespaces/test/services/foo" && m == "DELETE": - return &http.Response{StatusCode: 404, Body: objBody(codec, notFoundError)}, nil + return &http.Response{StatusCode: 404, Header: defaultHeader(), Body: objBody(codec, notFoundError)}, nil case p == "/namespaces/test/services/baz" && m == "DELETE": - return &http.Response{StatusCode: 200, Body: objBody(codec, &svc.Items[0])}, nil + return &http.Response{StatusCode: 200, Header: defaultHeader(), Body: objBody(codec, &svc.Items[0])}, nil default: t.Fatalf("unexpected request: %#v\n%#v", req.URL, req) return nil, nil @@ -277,9 +277,9 @@ func TestDeleteMultipleObject(t *testing.T) { Client: fake.CreateHTTPClient(func(req *http.Request) (*http.Response, error) { switch p, m := req.URL.Path, req.Method; { case p == "/namespaces/test/replicationcontrollers/redis-master" && m == "DELETE": - return &http.Response{StatusCode: 200, Body: objBody(codec, &rc.Items[0])}, nil + return &http.Response{StatusCode: 200, Header: defaultHeader(), Body: objBody(codec, &rc.Items[0])}, nil case p == "/namespaces/test/services/frontend" && m == "DELETE": - return &http.Response{StatusCode: 200, Body: objBody(codec, &svc.Items[0])}, nil + return &http.Response{StatusCode: 200, Header: defaultHeader(), Body: objBody(codec, &svc.Items[0])}, nil default: t.Fatalf("unexpected request: %#v\n%#v", req.URL, req) return nil, nil @@ -311,9 +311,9 @@ func TestDeleteMultipleObjectContinueOnMissing(t *testing.T) { Client: fake.CreateHTTPClient(func(req *http.Request) (*http.Response, error) { switch p, m := req.URL.Path, req.Method; { case p == "/namespaces/test/replicationcontrollers/redis-master" && m == "DELETE": - return &http.Response{StatusCode: 404, Body: stringBody("")}, nil + return &http.Response{StatusCode: 404, Header: defaultHeader(), Body: stringBody("")}, nil case p == "/namespaces/test/services/frontend" && m == "DELETE": - return &http.Response{StatusCode: 200, Body: objBody(codec, &svc.Items[0])}, nil + return &http.Response{StatusCode: 200, Header: defaultHeader(), Body: objBody(codec, &svc.Items[0])}, nil default: t.Fatalf("unexpected request: %#v\n%#v", req.URL, req) return nil, nil @@ -348,13 +348,13 @@ func TestDeleteMultipleResourcesWithTheSameName(t *testing.T) { Client: fake.CreateHTTPClient(func(req *http.Request) (*http.Response, error) { switch p, m := req.URL.Path, req.Method; { case p == "/namespaces/test/replicationcontrollers/baz" && m == "DELETE": - return &http.Response{StatusCode: 200, Body: objBody(codec, &rc.Items[0])}, nil + return &http.Response{StatusCode: 200, Header: defaultHeader(), Body: objBody(codec, &rc.Items[0])}, nil case p == "/namespaces/test/replicationcontrollers/foo" && m == "DELETE": - return &http.Response{StatusCode: 200, Body: objBody(codec, &rc.Items[0])}, nil + return &http.Response{StatusCode: 200, Header: defaultHeader(), Body: objBody(codec, &rc.Items[0])}, nil case p == "/namespaces/test/services/baz" && m == "DELETE": - return &http.Response{StatusCode: 200, Body: objBody(codec, &svc.Items[0])}, nil + return &http.Response{StatusCode: 200, Header: defaultHeader(), Body: objBody(codec, &svc.Items[0])}, nil case p == "/namespaces/test/services/foo" && m == "DELETE": - return &http.Response{StatusCode: 200, Body: objBody(codec, &svc.Items[0])}, nil + return &http.Response{StatusCode: 200, Header: defaultHeader(), Body: objBody(codec, &svc.Items[0])}, nil default: // Ensures no GET is performed when deleting by name t.Fatalf("unexpected request: %#v\n%#v", req.URL, req) @@ -384,7 +384,7 @@ func TestDeleteDirectory(t *testing.T) { Client: fake.CreateHTTPClient(func(req *http.Request) (*http.Response, error) { switch p, m := req.URL.Path, req.Method; { case strings.HasPrefix(p, "/namespaces/test/replicationcontrollers/") && m == "DELETE": - return &http.Response{StatusCode: 200, Body: objBody(codec, &rc.Items[0])}, nil + return &http.Response{StatusCode: 200, Header: defaultHeader(), Body: objBody(codec, &rc.Items[0])}, nil default: t.Fatalf("unexpected request: %#v\n%#v", req.URL, req) return nil, nil @@ -418,16 +418,16 @@ func TestDeleteMultipleSelector(t *testing.T) { if req.URL.Query().Get(unversioned.LabelSelectorQueryParam(testapi.Default.GroupVersion().String())) != "a=b" { t.Fatalf("unexpected request: %#v\n%#v", req.URL, req) } - return &http.Response{StatusCode: 200, Body: objBody(codec, pods)}, nil + return &http.Response{StatusCode: 200, Header: defaultHeader(), Body: objBody(codec, pods)}, nil case p == "/namespaces/test/services" && m == "GET": if req.URL.Query().Get(unversioned.LabelSelectorQueryParam(testapi.Default.GroupVersion().String())) != "a=b" { t.Fatalf("unexpected request: %#v\n%#v", req.URL, req) } - return &http.Response{StatusCode: 200, Body: objBody(codec, svc)}, nil + return &http.Response{StatusCode: 200, Header: defaultHeader(), Body: objBody(codec, svc)}, nil case strings.HasPrefix(p, "/namespaces/test/pods/") && m == "DELETE": - return &http.Response{StatusCode: 200, Body: objBody(codec, &pods.Items[0])}, nil + return &http.Response{StatusCode: 200, Header: defaultHeader(), Body: objBody(codec, &pods.Items[0])}, nil case strings.HasPrefix(p, "/namespaces/test/services/") && m == "DELETE": - return &http.Response{StatusCode: 200, Body: objBody(codec, &svc.Items[0])}, nil + return &http.Response{StatusCode: 200, Header: defaultHeader(), Body: objBody(codec, &svc.Items[0])}, nil default: t.Fatalf("unexpected request: %#v\n%#v", req.URL, req) return nil, nil diff --git a/pkg/kubectl/cmd/describe_test.go b/pkg/kubectl/cmd/describe_test.go index c8b9905ece6..54f6ce5dbe0 100644 --- a/pkg/kubectl/cmd/describe_test.go +++ b/pkg/kubectl/cmd/describe_test.go @@ -32,7 +32,7 @@ func TestDescribeUnknownSchemaObject(t *testing.T) { tf.Describer = d tf.Client = &fake.RESTClient{ Codec: codec, - Resp: &http.Response{StatusCode: 200, Body: objBody(codec, &internalType{Name: "foo"})}, + Resp: &http.Response{StatusCode: 200, Header: defaultHeader(), Body: objBody(codec, &internalType{Name: "foo"})}, } tf.Namespace = "non-default" buf := bytes.NewBuffer([]byte{}) @@ -59,7 +59,7 @@ func TestDescribeObject(t *testing.T) { Client: fake.CreateHTTPClient(func(req *http.Request) (*http.Response, error) { switch p, m := req.URL.Path, req.Method; { case p == "/namespaces/test/replicationcontrollers/redis-master" && m == "GET": - return &http.Response{StatusCode: 200, Body: objBody(codec, &rc.Items[0])}, nil + return &http.Response{StatusCode: 200, Header: defaultHeader(), Body: objBody(codec, &rc.Items[0])}, nil default: t.Fatalf("unexpected request: %#v\n%#v", req.URL, req) return nil, nil @@ -89,7 +89,7 @@ func TestDescribeListObjects(t *testing.T) { tf.Describer = d tf.Client = &fake.RESTClient{ Codec: codec, - Resp: &http.Response{StatusCode: 200, Body: objBody(codec, pods)}, + Resp: &http.Response{StatusCode: 200, Header: defaultHeader(), Body: objBody(codec, pods)}, } tf.Namespace = "test" @@ -108,7 +108,7 @@ func TestDescribeObjectShowEvents(t *testing.T) { tf.Describer = d tf.Client = &fake.RESTClient{ Codec: codec, - Resp: &http.Response{StatusCode: 200, Body: objBody(codec, pods)}, + Resp: &http.Response{StatusCode: 200, Header: defaultHeader(), Body: objBody(codec, pods)}, } tf.Namespace = "test" @@ -128,7 +128,7 @@ func TestDescribeObjectSkipEvents(t *testing.T) { tf.Describer = d tf.Client = &fake.RESTClient{ Codec: codec, - Resp: &http.Response{StatusCode: 200, Body: objBody(codec, pods)}, + Resp: &http.Response{StatusCode: 200, Header: defaultHeader(), Body: objBody(codec, pods)}, } tf.Namespace = "test" diff --git a/pkg/kubectl/cmd/drain_test.go b/pkg/kubectl/cmd/drain_test.go index e1f421bcd6b..eb79b0b262e 100644 --- a/pkg/kubectl/cmd/drain_test.go +++ b/pkg/kubectl/cmd/drain_test.go @@ -35,7 +35,6 @@ import ( "k8s.io/kubernetes/pkg/api/unversioned" "k8s.io/kubernetes/pkg/apis/batch" "k8s.io/kubernetes/pkg/apis/extensions" - "k8s.io/kubernetes/pkg/client/restclient" "k8s.io/kubernetes/pkg/client/unversioned/fake" "k8s.io/kubernetes/pkg/controller" "k8s.io/kubernetes/pkg/conversion" @@ -143,9 +142,9 @@ func TestCordon(t *testing.T) { m := &MyReq{req} switch { case m.isFor("GET", "/nodes/node"): - return &http.Response{StatusCode: 200, Body: objBody(codec, test.node)}, nil + return &http.Response{StatusCode: 200, Header: defaultHeader(), Body: objBody(codec, test.node)}, nil case m.isFor("GET", "/nodes/bar"): - return &http.Response{StatusCode: 404, Body: stringBody("nope")}, nil + return &http.Response{StatusCode: 404, Header: defaultHeader(), Body: stringBody("nope")}, nil case m.isFor("PUT", "/nodes/node"): data, err := ioutil.ReadAll(req.Body) if err != nil { @@ -159,14 +158,14 @@ func TestCordon(t *testing.T) { t.Fatalf("%s: expected:\n%v\nsaw:\n%v\n", test.description, test.expected.Spec, new_node.Spec) } updated = true - return &http.Response{StatusCode: 200, Body: objBody(codec, new_node)}, nil + return &http.Response{StatusCode: 200, Header: defaultHeader(), Body: objBody(codec, new_node)}, nil default: t.Fatalf("%s: unexpected request: %v %#v\n%#v", test.description, req.Method, req.URL, req) return nil, nil } }), } - tf.ClientConfig = &restclient.Config{ContentConfig: restclient.ContentConfig{GroupVersion: testapi.Default.GroupVersion()}} + tf.ClientConfig = defaultClientConfig() buf := bytes.NewBuffer([]byte{}) cmd := test.cmd(f, buf) @@ -430,15 +429,15 @@ func TestDrain(t *testing.T) { m := &MyReq{req} switch { case m.isFor("GET", "/nodes/node"): - return &http.Response{StatusCode: 200, Body: objBody(codec, test.node)}, nil + return &http.Response{StatusCode: 200, Header: defaultHeader(), Body: objBody(codec, test.node)}, nil case m.isFor("GET", "/namespaces/default/replicationcontrollers/rc"): - return &http.Response{StatusCode: 200, Body: objBody(codec, &test.rcs[0])}, nil + return &http.Response{StatusCode: 200, Header: defaultHeader(), Body: objBody(codec, &test.rcs[0])}, nil case m.isFor("GET", "/namespaces/default/daemonsets/ds"): - return &http.Response{StatusCode: 200, Body: objBody(testapi.Extensions.Codec(), &ds)}, nil + return &http.Response{StatusCode: 200, Header: defaultHeader(), Body: objBody(testapi.Extensions.Codec(), &ds)}, nil case m.isFor("GET", "/namespaces/default/jobs/job"): - return &http.Response{StatusCode: 200, Body: objBody(testapi.Extensions.Codec(), &job)}, nil + return &http.Response{StatusCode: 200, Header: defaultHeader(), Body: objBody(testapi.Extensions.Codec(), &job)}, nil case m.isFor("GET", "/namespaces/default/replicasets/rs"): - return &http.Response{StatusCode: 200, Body: objBody(testapi.Extensions.Codec(), &test.replicaSets[0])}, nil + return &http.Response{StatusCode: 200, Header: defaultHeader(), Body: objBody(testapi.Extensions.Codec(), &test.replicaSets[0])}, nil case m.isFor("GET", "/pods"): values, err := url.ParseQuery(req.URL.RawQuery) if err != nil { @@ -449,9 +448,9 @@ func TestDrain(t *testing.T) { if !reflect.DeepEqual(get_params, values) { t.Fatalf("%s: expected:\n%v\nsaw:\n%v\n", test.description, get_params, values) } - return &http.Response{StatusCode: 200, Body: objBody(codec, &api.PodList{Items: test.pods})}, nil + return &http.Response{StatusCode: 200, Header: defaultHeader(), Body: objBody(codec, &api.PodList{Items: test.pods})}, nil case m.isFor("GET", "/replicationcontrollers"): - return &http.Response{StatusCode: 200, Body: objBody(codec, &api.ReplicationControllerList{Items: test.rcs})}, nil + return &http.Response{StatusCode: 200, Header: defaultHeader(), Body: objBody(codec, &api.ReplicationControllerList{Items: test.rcs})}, nil case m.isFor("PUT", "/nodes/node"): data, err := ioutil.ReadAll(req.Body) if err != nil { @@ -464,17 +463,17 @@ func TestDrain(t *testing.T) { if !reflect.DeepEqual(test.expected.Spec, new_node.Spec) { t.Fatalf("%s: expected:\n%v\nsaw:\n%v\n", test.description, test.expected.Spec, new_node.Spec) } - return &http.Response{StatusCode: 200, Body: objBody(codec, new_node)}, nil + return &http.Response{StatusCode: 200, Header: defaultHeader(), Body: objBody(codec, new_node)}, nil case m.isFor("DELETE", "/namespaces/default/pods/bar"): deleted = true - return &http.Response{StatusCode: 204, Body: objBody(codec, &test.pods[0])}, nil + return &http.Response{StatusCode: 204, Header: defaultHeader(), Body: objBody(codec, &test.pods[0])}, nil default: t.Fatalf("%s: unexpected request: %v %#v\n%#v", test.description, req.Method, req.URL, req) return nil, nil } }), } - tf.ClientConfig = &restclient.Config{ContentConfig: restclient.ContentConfig{GroupVersion: testapi.Default.GroupVersion()}} + tf.ClientConfig = defaultClientConfig() buf := bytes.NewBuffer([]byte{}) cmd := NewCmdDrain(f, buf) diff --git a/pkg/kubectl/cmd/exec_test.go b/pkg/kubectl/cmd/exec_test.go index 001f59a4771..9b77322a305 100644 --- a/pkg/kubectl/cmd/exec_test.go +++ b/pkg/kubectl/cmd/exec_test.go @@ -187,7 +187,7 @@ func TestExec(t *testing.T) { switch p, m := req.URL.Path, req.Method; { case p == test.podPath && m == "GET": body := objBody(codec, test.pod) - return &http.Response{StatusCode: 200, Body: body}, nil + return &http.Response{StatusCode: 200, Header: defaultHeader(), Body: body}, nil default: // Ensures no GET is performed when deleting by name t.Errorf("%s: unexpected request: %s %#v\n%#v", test.name, req.Method, req.URL, req) diff --git a/pkg/kubectl/cmd/expose_test.go b/pkg/kubectl/cmd/expose_test.go index 6bad24357f4..f22a68536e2 100644 --- a/pkg/kubectl/cmd/expose_test.go +++ b/pkg/kubectl/cmd/expose_test.go @@ -314,9 +314,9 @@ func TestRunExposeService(t *testing.T) { Client: fake.CreateHTTPClient(func(req *http.Request) (*http.Response, error) { switch p, m := req.URL.Path, req.Method; { case p == test.calls[m] && m == "GET": - return &http.Response{StatusCode: test.status, Body: objBody(codec, test.input)}, nil + return &http.Response{StatusCode: test.status, Header: defaultHeader(), Body: objBody(codec, test.input)}, nil case p == test.calls[m] && m == "POST": - return &http.Response{StatusCode: test.status, Body: objBody(codec, test.output)}, nil + return &http.Response{StatusCode: test.status, Header: defaultHeader(), Body: objBody(codec, test.output)}, nil default: t.Fatalf("unexpected request: %#v\n%#v", req.URL, req) return nil, nil diff --git a/pkg/kubectl/cmd/get_test.go b/pkg/kubectl/cmd/get_test.go index 8b0981233cc..6f18031c4a8 100644 --- a/pkg/kubectl/cmd/get_test.go +++ b/pkg/kubectl/cmd/get_test.go @@ -121,7 +121,7 @@ func TestGetUnknownSchemaObject(t *testing.T) { tf.Printer = &testPrinter{} tf.Client = &fake.RESTClient{ Codec: codec, - Resp: &http.Response{StatusCode: 200, Body: objBody(codec, &internalType{Name: "foo"})}, + Resp: &http.Response{StatusCode: 200, Header: defaultHeader(), Body: objBody(codec, &internalType{Name: "foo"})}, } tf.Namespace = "test" tf.ClientConfig = &restclient.Config{ContentConfig: restclient.ContentConfig{GroupVersion: testapi.Default.GroupVersion()}} @@ -183,7 +183,7 @@ func TestGetUnknownSchemaObjectListGeneric(t *testing.T) { regularClient := &fake.RESTClient{ Codec: apiCodec, Client: fake.CreateHTTPClient(func(req *http.Request) (*http.Response, error) { - return &http.Response{StatusCode: 200, Body: objBody(apiCodec, &api.ReplicationController{ObjectMeta: api.ObjectMeta{Name: "foo"}})}, nil + return &http.Response{StatusCode: 200, Header: defaultHeader(), Body: objBody(apiCodec, &api.ReplicationController{ObjectMeta: api.ObjectMeta{Name: "foo"}})}, nil }), } @@ -192,7 +192,7 @@ func TestGetUnknownSchemaObjectListGeneric(t *testing.T) { tf.Client = &fake.RESTClient{ Codec: codec, Client: fake.CreateHTTPClient(func(req *http.Request) (*http.Response, error) { - return &http.Response{StatusCode: 200, Body: objBody(codec, &internalType{Name: "foo"})}, nil + return &http.Response{StatusCode: 200, Header: defaultHeader(), Body: objBody(codec, &internalType{Name: "foo"})}, nil }), } tf.Namespace = "test" @@ -235,7 +235,7 @@ func TestGetSchemaObject(t *testing.T) { tf.Printer = &testPrinter{} tf.Client = &fake.RESTClient{ Codec: codec, - Resp: &http.Response{StatusCode: 200, Body: objBody(codec, &api.ReplicationController{ObjectMeta: api.ObjectMeta{Name: "foo"}})}, + Resp: &http.Response{StatusCode: 200, Header: defaultHeader(), Body: objBody(codec, &api.ReplicationController{ObjectMeta: api.ObjectMeta{Name: "foo"}})}, } tf.Namespace = "test" tf.ClientConfig = &restclient.Config{ContentConfig: restclient.ContentConfig{GroupVersion: &unversioned.GroupVersion{Version: "v1"}}} @@ -256,7 +256,7 @@ func TestGetObjects(t *testing.T) { tf.Printer = &testPrinter{} tf.Client = &fake.RESTClient{ Codec: codec, - Resp: &http.Response{StatusCode: 200, Body: objBody(codec, &pods.Items[0])}, + Resp: &http.Response{StatusCode: 200, Header: defaultHeader(), Body: objBody(codec, &pods.Items[0])}, } tf.Namespace = "test" buf := bytes.NewBuffer([]byte{}) @@ -300,7 +300,7 @@ func TestGetSortedObjects(t *testing.T) { tf.Printer = &testPrinter{} tf.Client = &fake.RESTClient{ Codec: codec, - Resp: &http.Response{StatusCode: 200, Body: objBody(codec, pods)}, + Resp: &http.Response{StatusCode: 200, Header: defaultHeader(), Body: objBody(codec, pods)}, } tf.Namespace = "test" tf.ClientConfig = &restclient.Config{ContentConfig: restclient.ContentConfig{GroupVersion: &unversioned.GroupVersion{Version: "v1"}}} @@ -332,7 +332,7 @@ func TestGetObjectsIdentifiedByFile(t *testing.T) { tf.Printer = &testPrinter{} tf.Client = &fake.RESTClient{ Codec: codec, - Resp: &http.Response{StatusCode: 200, Body: objBody(codec, &pods.Items[0])}, + Resp: &http.Response{StatusCode: 200, Header: defaultHeader(), Body: objBody(codec, &pods.Items[0])}, } tf.Namespace = "test" buf := bytes.NewBuffer([]byte{}) @@ -359,7 +359,7 @@ func TestGetListObjects(t *testing.T) { tf.Printer = &testPrinter{} tf.Client = &fake.RESTClient{ Codec: codec, - Resp: &http.Response{StatusCode: 200, Body: objBody(codec, pods)}, + Resp: &http.Response{StatusCode: 200, Header: defaultHeader(), Body: objBody(codec, pods)}, } tf.Namespace = "test" buf := bytes.NewBuffer([]byte{}) @@ -402,7 +402,7 @@ func TestGetAllListObjects(t *testing.T) { tf.Printer = &testPrinter{} tf.Client = &fake.RESTClient{ Codec: codec, - Resp: &http.Response{StatusCode: 200, Body: objBody(codec, pods)}, + Resp: &http.Response{StatusCode: 200, Header: defaultHeader(), Body: objBody(codec, pods)}, } tf.Namespace = "test" buf := bytes.NewBuffer([]byte{}) @@ -432,7 +432,7 @@ func TestGetListComponentStatus(t *testing.T) { tf.Printer = &testPrinter{} tf.Client = &fake.RESTClient{ Codec: codec, - Resp: &http.Response{StatusCode: 200, Body: objBody(codec, statuses)}, + Resp: &http.Response{StatusCode: 200, Header: defaultHeader(), Body: objBody(codec, statuses)}, } tf.Namespace = "test" buf := bytes.NewBuffer([]byte{}) @@ -464,9 +464,9 @@ func TestGetMultipleTypeObjects(t *testing.T) { Client: fake.CreateHTTPClient(func(req *http.Request) (*http.Response, error) { switch req.URL.Path { case "/namespaces/test/pods": - return &http.Response{StatusCode: 200, Body: objBody(codec, pods)}, nil + return &http.Response{StatusCode: 200, Header: defaultHeader(), Body: objBody(codec, pods)}, nil case "/namespaces/test/services": - return &http.Response{StatusCode: 200, Body: objBody(codec, svc)}, nil + return &http.Response{StatusCode: 200, Header: defaultHeader(), Body: objBody(codec, svc)}, nil default: t.Fatalf("unexpected request: %#v\n%#v", req.URL, req) return nil, nil @@ -503,9 +503,9 @@ func TestGetMultipleTypeObjectsAsList(t *testing.T) { Client: fake.CreateHTTPClient(func(req *http.Request) (*http.Response, error) { switch req.URL.Path { case "/namespaces/test/pods": - return &http.Response{StatusCode: 200, Body: objBody(codec, pods)}, nil + return &http.Response{StatusCode: 200, Header: defaultHeader(), Body: objBody(codec, pods)}, nil case "/namespaces/test/services": - return &http.Response{StatusCode: 200, Body: objBody(codec, svc)}, nil + return &http.Response{StatusCode: 200, Header: defaultHeader(), Body: objBody(codec, svc)}, nil default: t.Fatalf("unexpected request: %#v\n%#v", req.URL, req) return nil, nil @@ -566,9 +566,9 @@ func TestGetMultipleTypeObjectsWithSelector(t *testing.T) { } switch req.URL.Path { case "/namespaces/test/pods": - return &http.Response{StatusCode: 200, Body: objBody(codec, pods)}, nil + return &http.Response{StatusCode: 200, Header: defaultHeader(), Body: objBody(codec, pods)}, nil case "/namespaces/test/services": - return &http.Response{StatusCode: 200, Body: objBody(codec, svc)}, nil + return &http.Response{StatusCode: 200, Header: defaultHeader(), Body: objBody(codec, svc)}, nil default: t.Fatalf("unexpected request: %#v\n%#v", req.URL, req) return nil, nil @@ -615,9 +615,9 @@ func TestGetMultipleTypeObjectsWithDirectReference(t *testing.T) { Client: fake.CreateHTTPClient(func(req *http.Request) (*http.Response, error) { switch req.URL.Path { case "/nodes/foo": - return &http.Response{StatusCode: 200, Body: objBody(codec, node)}, nil + return &http.Response{StatusCode: 200, Header: defaultHeader(), Body: objBody(codec, node)}, nil case "/namespaces/test/services/bar": - return &http.Response{StatusCode: 200, Body: objBody(codec, &svc.Items[0])}, nil + return &http.Response{StatusCode: 200, Header: defaultHeader(), Body: objBody(codec, &svc.Items[0])}, nil default: t.Fatalf("unexpected request: %#v\n%#v", req.URL, req) return nil, nil @@ -649,7 +649,7 @@ func TestGetByNameForcesFlag(t *testing.T) { tf.Printer = &testPrinter{} tf.Client = &fake.RESTClient{ Codec: codec, - Resp: &http.Response{StatusCode: 200, Body: objBody(codec, &pods.Items[0])}, + Resp: &http.Response{StatusCode: 200, Header: defaultHeader(), Body: objBody(codec, &pods.Items[0])}, } tf.Namespace = "test" buf := bytes.NewBuffer([]byte{}) @@ -715,9 +715,9 @@ func TestWatchSelector(t *testing.T) { } switch req.URL.Path { case "/namespaces/test/pods": - return &http.Response{StatusCode: 200, Body: objBody(codec, &api.PodList{Items: pods})}, nil + return &http.Response{StatusCode: 200, Header: defaultHeader(), Body: objBody(codec, &api.PodList{Items: pods})}, nil case "/watch/namespaces/test/pods": - return &http.Response{StatusCode: 200, Body: watchBody(codec, events)}, nil + return &http.Response{StatusCode: 200, Header: defaultHeader(), Body: watchBody(codec, events)}, nil default: t.Fatalf("unexpected request: %#v\n%#v", req.URL, req) return nil, nil @@ -754,9 +754,9 @@ func TestWatchResource(t *testing.T) { Client: fake.CreateHTTPClient(func(req *http.Request) (*http.Response, error) { switch req.URL.Path { case "/namespaces/test/pods/foo": - return &http.Response{StatusCode: 200, Body: objBody(codec, &pods[0])}, nil + return &http.Response{StatusCode: 200, Header: defaultHeader(), Body: objBody(codec, &pods[0])}, nil case "/watch/namespaces/test/pods/foo": - return &http.Response{StatusCode: 200, Body: watchBody(codec, events)}, nil + return &http.Response{StatusCode: 200, Header: defaultHeader(), Body: watchBody(codec, events)}, nil default: t.Fatalf("unexpected request: %#v\n%#v", req.URL, req) return nil, nil @@ -792,9 +792,9 @@ func TestWatchResourceIdentifiedByFile(t *testing.T) { Client: fake.CreateHTTPClient(func(req *http.Request) (*http.Response, error) { switch req.URL.Path { case "/namespaces/test/replicationcontrollers/cassandra": - return &http.Response{StatusCode: 200, Body: objBody(codec, &pods[0])}, nil + return &http.Response{StatusCode: 200, Header: defaultHeader(), Body: objBody(codec, &pods[0])}, nil case "/watch/namespaces/test/replicationcontrollers/cassandra": - return &http.Response{StatusCode: 200, Body: watchBody(codec, events)}, nil + return &http.Response{StatusCode: 200, Header: defaultHeader(), Body: watchBody(codec, events)}, nil default: t.Fatalf("unexpected request: %#v\n%#v", req.URL, req) return nil, nil @@ -831,9 +831,9 @@ func TestWatchOnlyResource(t *testing.T) { Client: fake.CreateHTTPClient(func(req *http.Request) (*http.Response, error) { switch req.URL.Path { case "/namespaces/test/pods/foo": - return &http.Response{StatusCode: 200, Body: objBody(codec, &pods[0])}, nil + return &http.Response{StatusCode: 200, Header: defaultHeader(), Body: objBody(codec, &pods[0])}, nil case "/watch/namespaces/test/pods/foo": - return &http.Response{StatusCode: 200, Body: watchBody(codec, events)}, nil + return &http.Response{StatusCode: 200, Header: defaultHeader(), Body: watchBody(codec, events)}, nil default: t.Fatalf("unexpected request: %#v\n%#v", req.URL, req) return nil, nil diff --git a/pkg/kubectl/cmd/label_test.go b/pkg/kubectl/cmd/label_test.go index 5c5f4d24f83..24c2cff20ea 100644 --- a/pkg/kubectl/cmd/label_test.go +++ b/pkg/kubectl/cmd/label_test.go @@ -334,7 +334,7 @@ func TestLabelForResourceFromFile(t *testing.T) { case "GET": switch req.URL.Path { case "/namespaces/test/replicationcontrollers/cassandra": - return &http.Response{StatusCode: 200, Body: objBody(codec, &pods.Items[0])}, nil + return &http.Response{StatusCode: 200, Header: defaultHeader(), Body: objBody(codec, &pods.Items[0])}, nil default: t.Fatalf("unexpected request: %#v\n%#v", req.URL, req) return nil, nil @@ -342,7 +342,7 @@ func TestLabelForResourceFromFile(t *testing.T) { case "PATCH": switch req.URL.Path { case "/namespaces/test/replicationcontrollers/cassandra": - return &http.Response{StatusCode: 200, Body: objBody(codec, &pods.Items[0])}, nil + return &http.Response{StatusCode: 200, Header: defaultHeader(), Body: objBody(codec, &pods.Items[0])}, nil default: t.Fatalf("unexpected request: %#v\n%#v", req.URL, req) return nil, nil @@ -381,7 +381,7 @@ func TestLabelMultipleObjects(t *testing.T) { case "GET": switch req.URL.Path { case "/namespaces/test/pods": - return &http.Response{StatusCode: 200, Body: objBody(codec, pods)}, nil + return &http.Response{StatusCode: 200, Header: defaultHeader(), Body: objBody(codec, pods)}, nil default: t.Fatalf("unexpected request: %#v\n%#v", req.URL, req) return nil, nil @@ -389,9 +389,9 @@ func TestLabelMultipleObjects(t *testing.T) { case "PATCH": switch req.URL.Path { case "/namespaces/test/pods/foo": - return &http.Response{StatusCode: 200, Body: objBody(codec, &pods.Items[0])}, nil + return &http.Response{StatusCode: 200, Header: defaultHeader(), Body: objBody(codec, &pods.Items[0])}, nil case "/namespaces/test/pods/bar": - return &http.Response{StatusCode: 200, Body: objBody(codec, &pods.Items[1])}, nil + return &http.Response{StatusCode: 200, Header: defaultHeader(), Body: objBody(codec, &pods.Items[1])}, nil default: t.Fatalf("unexpected request: %#v\n%#v", req.URL, req) return nil, nil diff --git a/pkg/kubectl/cmd/logs_test.go b/pkg/kubectl/cmd/logs_test.go index 9f1205f7153..3eaa4e59a23 100644 --- a/pkg/kubectl/cmd/logs_test.go +++ b/pkg/kubectl/cmd/logs_test.go @@ -54,10 +54,10 @@ func TestLog(t *testing.T) { switch p, m := req.URL.Path, req.Method; { case p == test.podPath && m == "GET": body := objBody(codec, test.pod) - return &http.Response{StatusCode: 200, Body: body}, nil + return &http.Response{StatusCode: 200, Header: defaultHeader(), Body: body}, nil case p == test.logPath && m == "GET": body := ioutil.NopCloser(bytes.NewBufferString(logContent)) - return &http.Response{StatusCode: 200, Body: body}, nil + return &http.Response{StatusCode: 200, Header: defaultHeader(), Body: body}, nil default: // Ensures no GET is performed when deleting by name t.Errorf("%s: unexpected request: %#v\n%#v", test.name, req.URL, req) diff --git a/pkg/kubectl/cmd/patch_test.go b/pkg/kubectl/cmd/patch_test.go index fd22dcaf4ef..a6e2a5432f2 100644 --- a/pkg/kubectl/cmd/patch_test.go +++ b/pkg/kubectl/cmd/patch_test.go @@ -34,7 +34,7 @@ func TestPatchObject(t *testing.T) { Client: fake.CreateHTTPClient(func(req *http.Request) (*http.Response, error) { switch p, m := req.URL.Path, req.Method; { case p == "/namespaces/test/services/frontend" && (m == "PATCH" || m == "GET"): - return &http.Response{StatusCode: 200, Body: objBody(codec, &svc.Items[0])}, nil + return &http.Response{StatusCode: 200, Header: defaultHeader(), Body: objBody(codec, &svc.Items[0])}, nil default: t.Fatalf("unexpected request: %#v\n%#v", req.URL, req) return nil, nil @@ -66,7 +66,7 @@ func TestPatchObjectFromFile(t *testing.T) { Client: fake.CreateHTTPClient(func(req *http.Request) (*http.Response, error) { switch p, m := req.URL.Path, req.Method; { case p == "/namespaces/test/services/frontend" && (m == "PATCH" || m == "GET"): - return &http.Response{StatusCode: 200, Body: objBody(codec, &svc.Items[0])}, nil + return &http.Response{StatusCode: 200, Header: defaultHeader(), Body: objBody(codec, &svc.Items[0])}, nil default: t.Fatalf("unexpected request: %#v\n%#v", req.URL, req) return nil, nil diff --git a/pkg/kubectl/cmd/portforward_test.go b/pkg/kubectl/cmd/portforward_test.go index d88ab90f449..75363d2ca8c 100644 --- a/pkg/kubectl/cmd/portforward_test.go +++ b/pkg/kubectl/cmd/portforward_test.go @@ -75,7 +75,7 @@ func TestPortForward(t *testing.T) { switch p, m := req.URL.Path, req.Method; { case p == test.podPath && m == "GET": body := objBody(codec, test.pod) - return &http.Response{StatusCode: 200, Body: body}, nil + return &http.Response{StatusCode: 200, Header: defaultHeader(), Body: body}, nil default: // Ensures no GET is performed when deleting by name t.Errorf("%s: unexpected request: %#v\n%#v", test.name, req.URL, req) @@ -145,7 +145,7 @@ func TestPortForwardWithPFlag(t *testing.T) { switch p, m := req.URL.Path, req.Method; { case p == test.podPath && m == "GET": body := objBody(codec, test.pod) - return &http.Response{StatusCode: 200, Body: body}, nil + return &http.Response{StatusCode: 200, Header: defaultHeader(), Body: body}, nil default: // Ensures no GET is performed when deleting by name t.Errorf("%s: unexpected request: %#v\n%#v", test.name, req.URL, req) diff --git a/pkg/kubectl/cmd/replace_test.go b/pkg/kubectl/cmd/replace_test.go index e511f92b8ff..47ed751a734 100644 --- a/pkg/kubectl/cmd/replace_test.go +++ b/pkg/kubectl/cmd/replace_test.go @@ -35,9 +35,9 @@ func TestReplaceObject(t *testing.T) { Client: fake.CreateHTTPClient(func(req *http.Request) (*http.Response, error) { switch p, m := req.URL.Path, req.Method; { case p == "/namespaces/test/replicationcontrollers/redis-master" && (m == "GET" || m == "PUT" || m == "DELETE"): - return &http.Response{StatusCode: 200, Body: objBody(codec, &rc.Items[0])}, nil + return &http.Response{StatusCode: 200, Header: defaultHeader(), Body: objBody(codec, &rc.Items[0])}, nil case p == "/namespaces/test/replicationcontrollers" && m == "POST": - return &http.Response{StatusCode: 201, Body: objBody(codec, &rc.Items[0])}, nil + return &http.Response{StatusCode: 201, Header: defaultHeader(), Body: objBody(codec, &rc.Items[0])}, nil default: t.Fatalf("unexpected request: %#v\n%#v", req.URL, req) return nil, nil @@ -78,13 +78,13 @@ func TestReplaceMultipleObject(t *testing.T) { Client: fake.CreateHTTPClient(func(req *http.Request) (*http.Response, error) { switch p, m := req.URL.Path, req.Method; { case p == "/namespaces/test/replicationcontrollers/redis-master" && (m == "GET" || m == "PUT" || m == "DELETE"): - return &http.Response{StatusCode: 200, Body: objBody(codec, &rc.Items[0])}, nil + return &http.Response{StatusCode: 200, Header: defaultHeader(), Body: objBody(codec, &rc.Items[0])}, nil case p == "/namespaces/test/replicationcontrollers" && m == "POST": - return &http.Response{StatusCode: 201, Body: objBody(codec, &rc.Items[0])}, nil + return &http.Response{StatusCode: 201, Header: defaultHeader(), Body: objBody(codec, &rc.Items[0])}, nil case p == "/namespaces/test/services/frontend" && (m == "GET" || m == "PUT" || m == "DELETE"): - return &http.Response{StatusCode: 200, Body: objBody(codec, &svc.Items[0])}, nil + return &http.Response{StatusCode: 200, Header: defaultHeader(), Body: objBody(codec, &svc.Items[0])}, nil case p == "/namespaces/test/services" && m == "POST": - return &http.Response{StatusCode: 201, Body: objBody(codec, &svc.Items[0])}, nil + return &http.Response{StatusCode: 201, Header: defaultHeader(), Body: objBody(codec, &svc.Items[0])}, nil default: t.Fatalf("unexpected request: %#v\n%#v", req.URL, req) return nil, nil @@ -125,9 +125,9 @@ func TestReplaceDirectory(t *testing.T) { Client: fake.CreateHTTPClient(func(req *http.Request) (*http.Response, error) { switch p, m := req.URL.Path, req.Method; { case strings.HasPrefix(p, "/namespaces/test/replicationcontrollers/") && (m == "GET" || m == "PUT" || m == "DELETE"): - return &http.Response{StatusCode: 200, Body: objBody(codec, &rc.Items[0])}, nil + return &http.Response{StatusCode: 200, Header: defaultHeader(), Body: objBody(codec, &rc.Items[0])}, nil case strings.HasPrefix(p, "/namespaces/test/replicationcontrollers") && m == "POST": - return &http.Response{StatusCode: 201, Body: objBody(codec, &rc.Items[0])}, nil + return &http.Response{StatusCode: 201, Header: defaultHeader(), Body: objBody(codec, &rc.Items[0])}, nil default: t.Fatalf("unexpected request: %#v\n%#v", req.URL, req) return nil, nil @@ -168,9 +168,9 @@ func TestForceReplaceObjectNotFound(t *testing.T) { Client: fake.CreateHTTPClient(func(req *http.Request) (*http.Response, error) { switch p, m := req.URL.Path, req.Method; { case p == "/namespaces/test/replicationcontrollers/redis-master" && m == "DELETE": - return &http.Response{StatusCode: 404, Body: stringBody("")}, nil + return &http.Response{StatusCode: 404, Header: defaultHeader(), Body: stringBody("")}, nil case p == "/namespaces/test/replicationcontrollers" && m == "POST": - return &http.Response{StatusCode: 201, Body: objBody(codec, &rc.Items[0])}, nil + return &http.Response{StatusCode: 201, Header: defaultHeader(), Body: objBody(codec, &rc.Items[0])}, nil default: t.Fatalf("unexpected request: %#v\n%#v", req.URL, req) return nil, nil diff --git a/pkg/kubectl/cmd/run_test.go b/pkg/kubectl/cmd/run_test.go index 1894deca89c..13cbf036401 100644 --- a/pkg/kubectl/cmd/run_test.go +++ b/pkg/kubectl/cmd/run_test.go @@ -153,7 +153,7 @@ func TestRunArgsFollowDashRules(t *testing.T) { tf.Client = &fake.RESTClient{ Codec: codec, Client: fake.CreateHTTPClient(func(req *http.Request) (*http.Response, error) { - return &http.Response{StatusCode: 201, Body: objBody(codec, &rc.Items[0])}, nil + return &http.Response{StatusCode: 201, Header: defaultHeader(), Body: objBody(codec, &rc.Items[0])}, nil }), } tf.Namespace = "test" @@ -290,7 +290,7 @@ func TestGenerateService(t *testing.T) { if !reflect.DeepEqual(&test.service, svc) { t.Errorf("expected:\n%v\nsaw:\n%v\n", &test.service, svc) } - return &http.Response{StatusCode: 200, Body: body}, nil + return &http.Response{StatusCode: 200, Header: defaultHeader(), Body: body}, nil default: // Ensures no GET is performed when deleting by name t.Errorf("%s: unexpected request: %s %#v\n%#v", test.name, req.Method, req.URL, req) diff --git a/pkg/kubectl/cmd/util/factory_test.go b/pkg/kubectl/cmd/util/factory_test.go index 07fb3a7fd6e..7751fd7cfd3 100644 --- a/pkg/kubectl/cmd/util/factory_test.go +++ b/pkg/kubectl/cmd/util/factory_test.go @@ -201,6 +201,12 @@ func loadSchemaForTest() (validation.Schema, error) { return validation.NewSwaggerSchemaFromBytes(data) } +func header() http.Header { + header := http.Header{} + header.Set("Content-Type", runtime.ContentTypeJSON) + return header +} + func TestRefetchSchemaWhenValidationFails(t *testing.T) { schema, err := loadSchemaForTest() if err != nil { @@ -220,7 +226,7 @@ func TestRefetchSchemaWhenValidationFails(t *testing.T) { switch p, m := req.URL.Path, req.Method; { case strings.HasPrefix(p, "/swaggerapi") && m == "GET": requests[p] = requests[p] + 1 - return &http.Response{StatusCode: 200, Body: ioutil.NopCloser(bytes.NewBuffer(output))}, nil + return &http.Response{StatusCode: 200, Header: header(), Body: ioutil.NopCloser(bytes.NewBuffer(output))}, nil default: t.Fatalf("unexpected request: %#v\n%#v", req.URL, req) return nil, nil @@ -277,7 +283,7 @@ func TestValidateCachesSchema(t *testing.T) { switch p, m := req.URL.Path, req.Method; { case strings.HasPrefix(p, "/swaggerapi") && m == "GET": requests[p] = requests[p] + 1 - return &http.Response{StatusCode: 200, Body: ioutil.NopCloser(bytes.NewBuffer(output))}, nil + return &http.Response{StatusCode: 200, Header: header(), Body: ioutil.NopCloser(bytes.NewBuffer(output))}, nil default: t.Fatalf("unexpected request: %#v\n%#v", req.URL, req) return nil, nil diff --git a/pkg/kubectl/resource/builder_test.go b/pkg/kubectl/resource/builder_test.go index 15abe6fe821..66076f9e32d 100644 --- a/pkg/kubectl/resource/builder_test.go +++ b/pkg/kubectl/resource/builder_test.go @@ -80,8 +80,11 @@ func fakeClientWith(testName string, t *testing.T, data map[string]string) Clien if !ok { t.Fatalf("%s: unexpected request: %s (%s)\n%#v", testName, p, req.URL, req) } + header := http.Header{} + header.Set("Content-Type", runtime.ContentTypeJSON) return &http.Response{ StatusCode: http.StatusOK, + Header: header, Body: stringBody(body), }, nil }), diff --git a/pkg/kubectl/resource/helper_test.go b/pkg/kubectl/resource/helper_test.go index bfb05f7f747..0cd438b0593 100644 --- a/pkg/kubectl/resource/helper_test.go +++ b/pkg/kubectl/resource/helper_test.go @@ -39,6 +39,12 @@ func objBody(obj runtime.Object) io.ReadCloser { return ioutil.NopCloser(bytes.NewReader([]byte(runtime.EncodeOrDie(testapi.Default.Codec(), obj)))) } +func header() http.Header { + header := http.Header{} + header.Set("Content-Type", runtime.ContentTypeJSON) + return header +} + // splitPath returns the segments for a URL path. func splitPath(path string) []string { path = strings.Trim(path, "/") @@ -62,6 +68,7 @@ func TestHelperDelete(t *testing.T) { { Resp: &http.Response{ StatusCode: http.StatusNotFound, + Header: header(), Body: objBody(&unversioned.Status{Status: unversioned.StatusFailure}), }, Err: true, @@ -69,6 +76,7 @@ func TestHelperDelete(t *testing.T) { { Resp: &http.Response{ StatusCode: http.StatusOK, + Header: header(), Body: objBody(&unversioned.Status{Status: unversioned.StatusSuccess}), }, Req: func(req *http.Request) bool { @@ -147,6 +155,7 @@ func TestHelperCreate(t *testing.T) { { Resp: &http.Response{ StatusCode: http.StatusNotFound, + Header: header(), Body: objBody(&unversioned.Status{Status: unversioned.StatusFailure}), }, Err: true, @@ -154,6 +163,7 @@ func TestHelperCreate(t *testing.T) { { Resp: &http.Response{ StatusCode: http.StatusOK, + Header: header(), Body: objBody(&unversioned.Status{Status: unversioned.StatusSuccess}), }, Object: &api.Pod{ObjectMeta: api.ObjectMeta{Name: "foo"}}, @@ -164,7 +174,7 @@ func TestHelperCreate(t *testing.T) { Modify: false, Object: &api.Pod{ObjectMeta: api.ObjectMeta{Name: "foo", ResourceVersion: "10"}}, ExpectObject: &api.Pod{ObjectMeta: api.ObjectMeta{Name: "foo", ResourceVersion: "10"}}, - Resp: &http.Response{StatusCode: http.StatusOK, Body: objBody(&unversioned.Status{Status: unversioned.StatusSuccess})}, + Resp: &http.Response{StatusCode: http.StatusOK, Header: header(), Body: objBody(&unversioned.Status{Status: unversioned.StatusSuccess})}, Req: expectPost, }, { @@ -177,7 +187,7 @@ func TestHelperCreate(t *testing.T) { ObjectMeta: api.ObjectMeta{Name: "foo"}, Spec: apitesting.DeepEqualSafePodSpec(), }, - Resp: &http.Response{StatusCode: http.StatusOK, Body: objBody(&unversioned.Status{Status: unversioned.StatusSuccess})}, + Resp: &http.Response{StatusCode: http.StatusOK, Header: header(), Body: objBody(&unversioned.Status{Status: unversioned.StatusSuccess})}, Req: expectPost, }, } @@ -232,6 +242,7 @@ func TestHelperGet(t *testing.T) { { Resp: &http.Response{ StatusCode: http.StatusNotFound, + Header: header(), Body: objBody(&unversioned.Status{Status: unversioned.StatusFailure}), }, Err: true, @@ -239,6 +250,7 @@ func TestHelperGet(t *testing.T) { { Resp: &http.Response{ StatusCode: http.StatusOK, + Header: header(), Body: objBody(&api.Pod{ObjectMeta: api.ObjectMeta{Name: "foo"}}), }, Req: func(req *http.Request) bool { @@ -299,6 +311,7 @@ func TestHelperList(t *testing.T) { { Resp: &http.Response{ StatusCode: http.StatusNotFound, + Header: header(), Body: objBody(&unversioned.Status{Status: unversioned.StatusFailure}), }, Err: true, @@ -306,6 +319,7 @@ func TestHelperList(t *testing.T) { { Resp: &http.Response{ StatusCode: http.StatusOK, + Header: header(), Body: objBody(&api.PodList{ Items: []api.Pod{{ ObjectMeta: api.ObjectMeta{Name: "foo"}, @@ -395,6 +409,7 @@ func TestHelperReplace(t *testing.T) { Object: &api.Pod{ObjectMeta: api.ObjectMeta{Name: "foo"}}, Resp: &http.Response{ StatusCode: http.StatusNotFound, + Header: header(), Body: objBody(&unversioned.Status{Status: unversioned.StatusFailure}), }, Err: true, @@ -407,6 +422,7 @@ func TestHelperReplace(t *testing.T) { ExpectObject: &api.Pod{ObjectMeta: api.ObjectMeta{Name: "foo"}}, Resp: &http.Response{ StatusCode: http.StatusOK, + Header: header(), Body: objBody(&unversioned.Status{Status: unversioned.StatusSuccess}), }, Req: expectPut, @@ -427,9 +443,9 @@ func TestHelperReplace(t *testing.T) { Overwrite: true, HTTPClient: fake.CreateHTTPClient(func(req *http.Request) (*http.Response, error) { if req.Method == "PUT" { - return &http.Response{StatusCode: http.StatusOK, Body: objBody(&unversioned.Status{Status: unversioned.StatusSuccess})}, nil + return &http.Response{StatusCode: http.StatusOK, Header: header(), Body: objBody(&unversioned.Status{Status: unversioned.StatusSuccess})}, nil } - return &http.Response{StatusCode: http.StatusOK, Body: objBody(&api.Pod{ObjectMeta: api.ObjectMeta{Name: "foo", ResourceVersion: "10"}})}, nil + return &http.Response{StatusCode: http.StatusOK, Header: header(), Body: objBody(&api.Pod{ObjectMeta: api.ObjectMeta{Name: "foo", ResourceVersion: "10"}})}, nil }), Req: expectPut, }, @@ -445,9 +461,9 @@ func TestHelperReplace(t *testing.T) { ExpectPath: "/foo", HTTPClient: fake.CreateHTTPClient(func(req *http.Request) (*http.Response, error) { if req.Method == "PUT" { - return &http.Response{StatusCode: http.StatusOK, Body: objBody(&unversioned.Status{Status: unversioned.StatusSuccess})}, nil + return &http.Response{StatusCode: http.StatusOK, Header: header(), Body: objBody(&unversioned.Status{Status: unversioned.StatusSuccess})}, nil } - return &http.Response{StatusCode: http.StatusOK, Body: objBody(&api.Node{ObjectMeta: api.ObjectMeta{Name: "foo", ResourceVersion: "10"}})}, nil + return &http.Response{StatusCode: http.StatusOK, Header: header(), Body: objBody(&api.Node{ObjectMeta: api.ObjectMeta{Name: "foo", ResourceVersion: "10"}})}, nil }), Req: expectPut, }, @@ -457,7 +473,7 @@ func TestHelperReplace(t *testing.T) { Object: &api.Pod{ObjectMeta: api.ObjectMeta{Name: "foo", ResourceVersion: "10"}}, ExpectPath: "/namespaces/bar/foo", ExpectObject: &api.Pod{ObjectMeta: api.ObjectMeta{Name: "foo", ResourceVersion: "10"}}, - Resp: &http.Response{StatusCode: http.StatusOK, Body: objBody(&unversioned.Status{Status: unversioned.StatusSuccess})}, + Resp: &http.Response{StatusCode: http.StatusOK, Header: header(), Body: objBody(&unversioned.Status{Status: unversioned.StatusSuccess})}, Req: expectPut, }, } diff --git a/pkg/kubectl/rolling_updater_test.go b/pkg/kubectl/rolling_updater_test.go index c30f08b2c4a..d55dd7dbb4b 100644 --- a/pkg/kubectl/rolling_updater_test.go +++ b/pkg/kubectl/rolling_updater_test.go @@ -1400,14 +1400,16 @@ func TestUpdateWithRetries(t *testing.T) { newRc := *rc newRc.ResourceVersion = "2" newRc.Spec.Selector["baz"] = "foobar" + header := http.Header{} + header.Set("Content-Type", runtime.ContentTypeJSON) updates := []*http.Response{ - {StatusCode: 500, Body: objBody(codec, &api.ReplicationController{})}, - {StatusCode: 500, Body: objBody(codec, &api.ReplicationController{})}, - {StatusCode: 200, Body: objBody(codec, &newRc)}, + {StatusCode: 500, Header: header, Body: objBody(codec, &api.ReplicationController{})}, + {StatusCode: 500, Header: header, Body: objBody(codec, &api.ReplicationController{})}, + {StatusCode: 200, Header: header, Body: objBody(codec, &newRc)}, } gets := []*http.Response{ - {StatusCode: 500, Body: objBody(codec, &api.ReplicationController{})}, - {StatusCode: 200, Body: objBody(codec, rc)}, + {StatusCode: 500, Header: header, Body: objBody(codec, &api.ReplicationController{})}, + {StatusCode: 200, Header: header, Body: objBody(codec, rc)}, } fakeClient := &fake.RESTClient{ Codec: codec, @@ -1503,30 +1505,32 @@ func TestAddDeploymentHash(t *testing.T) { fakeClient := &fake.RESTClient{ Codec: codec, Client: fake.CreateHTTPClient(func(req *http.Request) (*http.Response, error) { + header := http.Header{} + header.Set("Content-Type", runtime.ContentTypeJSON) switch p, m := req.URL.Path, req.Method; { case p == testapi.Default.ResourcePath("pods", "default", "") && m == "GET": if req.URL.RawQuery != "labelSelector=foo%3Dbar" { t.Errorf("Unexpected query string: %s", req.URL.RawQuery) } - return &http.Response{StatusCode: 200, Body: objBody(codec, podList)}, nil + return &http.Response{StatusCode: 200, Header: header, Body: objBody(codec, podList)}, nil case p == testapi.Default.ResourcePath("pods", "default", "foo") && m == "PUT": seen.Insert("foo") obj := readOrDie(t, req, codec) podList.Items[0] = *(obj.(*api.Pod)) - return &http.Response{StatusCode: 200, Body: objBody(codec, &podList.Items[0])}, nil + return &http.Response{StatusCode: 200, Header: header, Body: objBody(codec, &podList.Items[0])}, nil case p == testapi.Default.ResourcePath("pods", "default", "bar") && m == "PUT": seen.Insert("bar") obj := readOrDie(t, req, codec) podList.Items[1] = *(obj.(*api.Pod)) - return &http.Response{StatusCode: 200, Body: objBody(codec, &podList.Items[1])}, nil + return &http.Response{StatusCode: 200, Header: header, Body: objBody(codec, &podList.Items[1])}, nil case p == testapi.Default.ResourcePath("pods", "default", "baz") && m == "PUT": seen.Insert("baz") obj := readOrDie(t, req, codec) podList.Items[2] = *(obj.(*api.Pod)) - return &http.Response{StatusCode: 200, Body: objBody(codec, &podList.Items[2])}, nil + return &http.Response{StatusCode: 200, Header: header, Body: objBody(codec, &podList.Items[2])}, nil case p == testapi.Default.ResourcePath("replicationcontrollers", "default", "rc") && m == "PUT": updatedRc = true - return &http.Response{StatusCode: 200, Body: objBody(codec, rc)}, nil + return &http.Response{StatusCode: 200, Header: header, Body: objBody(codec, rc)}, nil default: t.Fatalf("unexpected request: %#v\n%#v", req.URL, req) return nil, nil