func makeTestServer(t *testing.T, namespace, name string, podResponse, controllerResponse, updateResponse serverResponse) (*httptest.Server, *util.FakeHandler) { fakePodHandler := util.FakeHandler{ StatusCode: podResponse.statusCode, ResponseBody: runtime.EncodeOrDie(testapi.Codec(), podResponse.obj.(runtime.Object)), } fakeControllerHandler := util.FakeHandler{ StatusCode: controllerResponse.statusCode, ResponseBody: runtime.EncodeOrDie(testapi.Codec(), controllerResponse.obj.(runtime.Object)), } fakeUpdateHandler := util.FakeHandler{ StatusCode: updateResponse.statusCode, ResponseBody: runtime.EncodeOrDie(testapi.Codec(), updateResponse.obj.(runtime.Object)), } mux := http.NewServeMux() mux.Handle(testapi.ResourcePath("pods", namespace, ""), &fakePodHandler) mux.Handle(testapi.ResourcePath(replicationControllerResourceName(), "", ""), &fakeControllerHandler) if namespace != "" { mux.Handle(testapi.ResourcePath(replicationControllerResourceName(), namespace, ""), &fakeControllerHandler) } if name != "" { mux.Handle(testapi.ResourcePath(replicationControllerResourceName(), namespace, name), &fakeUpdateHandler) } mux.HandleFunc("/", func(res http.ResponseWriter, req *http.Request) { t.Errorf("unexpected request: %v", req.RequestURI) res.WriteHeader(http.StatusNotFound) }) return httptest.NewServer(mux), &fakeUpdateHandler }
func makeTestServer(t *testing.T, namespace string, endpointsResponse serverResponse) (*httptest.Server, *util.FakeHandler) { fakeEndpointsHandler := util.FakeHandler{ StatusCode: endpointsResponse.statusCode, ResponseBody: runtime.EncodeOrDie(testapi.Codec(), endpointsResponse.obj.(runtime.Object)), } mux := http.NewServeMux() mux.Handle(testapi.ResourcePath("endpoints", namespace, ""), &fakeEndpointsHandler) mux.Handle(testapi.ResourcePath("endpoints/", namespace, ""), &fakeEndpointsHandler) mux.HandleFunc("/", func(res http.ResponseWriter, req *http.Request) { t.Errorf("unexpected request: %v", req.RequestURI) res.WriteHeader(http.StatusNotFound) }) return httptest.NewServer(mux), &fakeEndpointsHandler }
func TestListWatchesCanList(t *testing.T) { fieldSelectorQueryParamName := api.FieldSelectorQueryParam(testapi.Version()) table := []struct { location string resource string namespace string fieldSelector fields.Selector }{ // Minion { location: testapi.ResourcePath("minions", api.NamespaceAll, ""), resource: "minions", namespace: api.NamespaceAll, fieldSelector: parseSelectorOrDie(""), }, // pod with "assigned" field selector. { location: buildLocation( testapi.ResourcePath("pods", api.NamespaceAll, ""), buildQueryValues(url.Values{fieldSelectorQueryParamName: []string{"spec.host="}})), resource: "pods", namespace: api.NamespaceAll, fieldSelector: fields.Set{"spec.host": ""}.AsSelector(), }, // pod in namespace "foo" { location: buildLocation( testapi.ResourcePath("pods", "foo", ""), buildQueryValues(url.Values{fieldSelectorQueryParamName: []string{"spec.host="}})), resource: "pods", namespace: "foo", fieldSelector: fields.Set{"spec.host": ""}.AsSelector(), }, } for _, item := range table { handler := util.FakeHandler{ StatusCode: 500, ResponseBody: "", T: t, } server := httptest.NewServer(&handler) defer server.Close() client := client.NewOrDie(&client.Config{Host: server.URL, Version: testapi.Version()}) lw := NewListWatchFromClient(client, item.resource, item.namespace, item.fieldSelector) // This test merely tests that the correct request is made. lw.List() handler.ValidateRequest(t, item.location, "GET", nil) } }
func TestNamespaceList(t *testing.T) { namespaceList := &api.NamespaceList{ Items: []api.Namespace{ { ObjectMeta: api.ObjectMeta{Name: "foo"}, }, }, } c := &testClient{ Request: testRequest{ Method: "GET", Path: testapi.ResourcePath("namespaces", "", ""), Body: nil, }, Response: Response{StatusCode: 200, Body: namespaceList}, } response, err := c.Setup().Namespaces().List(labels.Everything(), fields.Everything()) if err != nil { t.Errorf("%#v should be nil.", err) } if len(response.Items) != 1 { t.Errorf("%#v response.Items should have len 1.", response.Items) } responseNamespace := response.Items[0] if e, r := responseNamespace.Name, "foo"; e != r { t.Errorf("%#v != %#v.", e, r) } }
func TestNamespaceCreate(t *testing.T) { // we create a namespace relative to another namespace namespace := &api.Namespace{ ObjectMeta: api.ObjectMeta{Name: "foo"}, } c := &testClient{ Request: testRequest{ Method: "POST", Path: testapi.ResourcePath("namespaces", "", ""), Body: namespace, }, Response: Response{StatusCode: 200, Body: namespace}, } // from the source ns, provision a new global namespace "foo" response, err := c.Setup().Namespaces().Create(namespace) if err != nil { t.Errorf("%#v should be nil.", err) } if e, a := response.Name, namespace.Name; e != a { t.Errorf("%#v != %#v.", e, a) } }
func TestListPodsLabels(t *testing.T) { ns := api.NamespaceDefault labelSelectorQueryParamName := api.LabelSelectorQueryParam(testapi.Version()) c := &testClient{ Request: testRequest{ Method: "GET", Path: testapi.ResourcePath("pods", ns, ""), Query: buildQueryValues(ns, url.Values{labelSelectorQueryParamName: []string{"foo=bar,name=baz"}})}, Response: Response{ StatusCode: 200, Body: &api.PodList{ Items: []api.Pod{ { Status: api.PodStatus{ Phase: api.PodRunning, }, ObjectMeta: api.ObjectMeta{ Labels: map[string]string{ "foo": "bar", "name": "baz", }, }, }, }, }, }, } c.Setup() c.QueryValidator[labelSelectorQueryParamName] = validateLabels selector := labels.Set{"foo": "bar", "name": "baz"}.AsSelector() receivedPodList, err := c.Pods(ns).List(selector, fields.Everything()) c.Validate(t, receivedPodList, err) }
func TestListPods(t *testing.T) { ns := api.NamespaceDefault c := &testClient{ Request: testRequest{Method: "GET", Path: testapi.ResourcePath("pods", ns, ""), Query: buildQueryValues(ns, nil)}, Response: Response{StatusCode: 200, Body: &api.PodList{ Items: []api.Pod{ { Status: api.PodStatus{ Phase: api.PodRunning, }, ObjectMeta: api.ObjectMeta{ Labels: map[string]string{ "foo": "bar", "name": "baz", }, }, }, }, }, }, } receivedPodList, err := c.Setup().Pods(ns).List(labels.Everything(), fields.Everything()) c.Validate(t, receivedPodList, err) }
func TestListMinionsLabels(t *testing.T) { ns := api.NamespaceNone labelSelectorQueryParamName := api.LabelSelectorQueryParam(testapi.Version()) c := &testClient{ Request: testRequest{ Method: "GET", Path: testapi.ResourcePath(getNodesResourceName(), "", ""), Query: buildQueryValues(ns, url.Values{labelSelectorQueryParamName: []string{"foo=bar,name=baz"}})}, Response: Response{ StatusCode: 200, Body: &api.NodeList{ Items: []api.Node{ { ObjectMeta: api.ObjectMeta{ Labels: map[string]string{ "foo": "bar", "name": "baz", }, }, }, }, }, }, } c.Setup() c.QueryValidator[labelSelectorQueryParamName] = validateLabels selector := labels.Set{"foo": "bar", "name": "baz"}.AsSelector() receivedNodeList, err := c.Nodes().List(selector, fields.Everything()) c.Validate(t, receivedNodeList, err) }
func TestUpdateController(t *testing.T) { ns := api.NamespaceDefault requestController := &api.ReplicationController{ ObjectMeta: api.ObjectMeta{Name: "foo", ResourceVersion: "1"}, } c := &testClient{ Request: testRequest{Method: "PUT", Path: testapi.ResourcePath(getRCResourceName(), ns, "foo"), Query: buildQueryValues(ns, nil)}, Response: Response{ StatusCode: 200, Body: &api.ReplicationController{ ObjectMeta: api.ObjectMeta{ Name: "foo", Labels: map[string]string{ "foo": "bar", "name": "baz", }, }, Spec: api.ReplicationControllerSpec{ Replicas: 2, Template: &api.PodTemplateSpec{}, }, }, }, } receivedController, err := c.Setup().ReplicationControllers(ns).Update(requestController) c.Validate(t, receivedController, err) }
func TestPersistentVolumeClaimGet(t *testing.T) { ns := api.NamespaceDefault persistentVolumeClaim := &api.PersistentVolumeClaim{ ObjectMeta: api.ObjectMeta{ Name: "abc", Namespace: "foo", }, Spec: api.PersistentVolumeClaimSpec{ AccessModes: []api.PersistentVolumeAccessMode{ api.ReadWriteOnce, api.ReadOnlyMany, }, Resources: api.ResourceRequirements{ Requests: api.ResourceList{ api.ResourceName(api.ResourceStorage): resource.MustParse("10G"), }, }, }, } c := &testClient{ Request: testRequest{ Method: "GET", Path: testapi.ResourcePath(getPersistentVolumeClaimsResoureName(), ns, "abc"), Query: buildQueryValues(ns, nil), Body: nil, }, Response: Response{StatusCode: 200, Body: persistentVolumeClaim}, } response, err := c.Setup().PersistentVolumeClaims(ns).Get("abc") c.Validate(t, response, err) }
func TestSyncEndpointsItemsPreexistingIdentical(t *testing.T) { ns := api.NamespaceDefault testServer, endpointsHandler := makeTestServer(t, api.NamespaceDefault, serverResponse{http.StatusOK, &api.Endpoints{ ObjectMeta: api.ObjectMeta{ ResourceVersion: "1", Name: "foo", Namespace: ns, }, Subsets: []api.EndpointSubset{{ Addresses: []api.EndpointAddress{{IP: "1.2.3.4", TargetRef: &api.ObjectReference{Kind: "Pod", Name: "pod0", Namespace: ns}}}, Ports: []api.EndpointPort{{Port: 8080, Protocol: "TCP"}}, }}, }}) defer testServer.Close() client := client.NewOrDie(&client.Config{Host: testServer.URL, Version: testapi.Version()}) endpoints := NewEndpointController(client) addPods(endpoints.podStore.Store, api.NamespaceDefault, 1, 1) endpoints.serviceStore.Store.Add(&api.Service{ ObjectMeta: api.ObjectMeta{Name: "foo", Namespace: api.NamespaceDefault}, Spec: api.ServiceSpec{ Selector: map[string]string{"foo": "bar"}, Ports: []api.ServicePort{{Port: 80, Protocol: "TCP", TargetPort: util.NewIntOrStringFromInt(8080)}}, }, }) endpoints.syncService(ns + "/foo") endpointsHandler.ValidateRequest(t, testapi.ResourcePath("endpoints", api.NamespaceDefault, "foo"), "GET", nil) }
func TestEventSearch(t *testing.T) { c := &testClient{ Request: testRequest{ Method: "GET", Path: testapi.ResourcePath("events", "baz", ""), Query: url.Values{ api.FieldSelectorQueryParam(testapi.Version()): []string{ getInvolvedObjectNameFieldLabel(testapi.Version()) + "=foo,", "involvedObject.namespace=baz,", "involvedObject.kind=Pod", }, api.LabelSelectorQueryParam(testapi.Version()): []string{}, }, }, Response: Response{StatusCode: 200, Body: &api.EventList{}}, } eventList, err := c.Setup().Events("baz").Search( &api.Pod{ ObjectMeta: api.ObjectMeta{ Name: "foo", Namespace: "baz", SelfLink: testapi.SelfLink("pods", ""), }, }, ) c.Validate(t, eventList, err) }
func TestCreateMinion(t *testing.T) { requestMinion := &api.Node{ ObjectMeta: api.ObjectMeta{ Name: "minion-1", }, Status: api.NodeStatus{ Capacity: api.ResourceList{ api.ResourceCPU: resource.MustParse("1000m"), api.ResourceMemory: resource.MustParse("1Mi"), }, }, Spec: api.NodeSpec{ Unschedulable: false, }, } c := &testClient{ Request: testRequest{ Method: "POST", Path: testapi.ResourcePath(getNodesResourceName(), "", ""), Body: requestMinion}, Response: Response{ StatusCode: 200, Body: requestMinion, }, } receivedMinion, err := c.Setup().Nodes().Create(requestMinion) c.Validate(t, receivedMinion, err) }
func TestResourceQuotaGet(t *testing.T) { ns := api.NamespaceDefault resourceQuota := &api.ResourceQuota{ ObjectMeta: api.ObjectMeta{ Name: "abc", Namespace: "foo", }, Spec: api.ResourceQuotaSpec{ Hard: api.ResourceList{ api.ResourceCPU: resource.MustParse("100"), api.ResourceMemory: resource.MustParse("10000"), api.ResourcePods: resource.MustParse("10"), api.ResourceServices: resource.MustParse("10"), api.ResourceReplicationControllers: resource.MustParse("10"), api.ResourceQuotas: resource.MustParse("10"), }, }, } c := &testClient{ Request: testRequest{ Method: "GET", Path: testapi.ResourcePath(getResourceQuotasResoureName(), ns, "abc"), Query: buildQueryValues(ns, nil), Body: nil, }, Response: Response{StatusCode: 200, Body: resourceQuota}, } response, err := c.Setup().ResourceQuotas(ns).Get("abc") c.Validate(t, response, err) }
func TestListControllers(t *testing.T) { ns := api.NamespaceAll c := &testClient{ Request: testRequest{ Method: "GET", Path: testapi.ResourcePath(getRCResourceName(), ns, ""), }, Response: Response{StatusCode: 200, Body: &api.ReplicationControllerList{ Items: []api.ReplicationController{ { ObjectMeta: api.ObjectMeta{ Name: "foo", Labels: map[string]string{ "foo": "bar", "name": "baz", }, }, Spec: api.ReplicationControllerSpec{ Replicas: 2, Template: &api.PodTemplateSpec{}, }, }, }, }, }, } receivedControllerList, err := c.Setup().ReplicationControllers(ns).List(labels.Everything()) c.Validate(t, receivedControllerList, err) }
func TestNamespaceDelete(t *testing.T) { c := &testClient{ Request: testRequest{Method: "DELETE", Path: testapi.ResourcePath("namespaces", "", "foo")}, Response: Response{StatusCode: 200}, } err := c.Setup().Namespaces().Delete("foo") c.Validate(t, nil, err) }
func TestPodTemplateDelete(t *testing.T) { ns := api.NamespaceDefault c := &testClient{ Request: testRequest{Method: "DELETE", Path: testapi.ResourcePath(getPodTemplatesResoureName(), ns, "foo"), Query: buildQueryValues(ns, nil)}, Response: Response{StatusCode: 200}, } err := c.Setup().PodTemplates(ns).Delete("foo", nil) c.Validate(t, nil, err) }
func TestDeleteController(t *testing.T) { ns := api.NamespaceDefault c := &testClient{ Request: testRequest{Method: "DELETE", Path: testapi.ResourcePath(getRCResourceName(), ns, "foo"), Query: buildQueryValues(ns, nil)}, Response: Response{StatusCode: 200}, } err := c.Setup().ReplicationControllers(ns).Delete("foo") c.Validate(t, nil, err) }
func TestGetEndpoints(t *testing.T) { ns := api.NamespaceDefault c := &testClient{ Request: testRequest{Method: "GET", Path: testapi.ResourcePath("endpoints", ns, "endpoint-1"), Query: buildQueryValues(ns, nil)}, Response: Response{StatusCode: 200, Body: &api.Endpoints{ObjectMeta: api.ObjectMeta{Name: "endpoint-1"}}}, } response, err := c.Setup().Endpoints(ns).Get("endpoint-1") c.Validate(t, response, err) }
func TestListEmptyPods(t *testing.T) { ns := api.NamespaceDefault c := &testClient{ Request: testRequest{Method: "GET", Path: testapi.ResourcePath("pods", ns, ""), Query: buildQueryValues(ns, nil)}, Response: Response{StatusCode: 200, Body: &api.PodList{}}, } podList, err := c.Setup().Pods(ns).List(labels.Everything(), fields.Everything()) c.Validate(t, podList, err) }
func TestListMinions(t *testing.T) { c := &testClient{ Request: testRequest{ Method: "GET", Path: testapi.ResourcePath(getNodesResourceName(), "", ""), }, Response: Response{StatusCode: 200, Body: &api.NodeList{ListMeta: api.ListMeta{ResourceVersion: "1"}}}, } response, err := c.Setup().Nodes().List(labels.Everything(), fields.Everything()) c.Validate(t, response, err) }
func TestDeleteMinion(t *testing.T) { c := &testClient{ Request: testRequest{ Method: "DELETE", Path: testapi.ResourcePath(getNodesResourceName(), "", "foo"), }, Response: Response{StatusCode: 200}, } err := c.Setup().Nodes().Delete("foo") c.Validate(t, nil, err) }
func TestGetMinion(t *testing.T) { c := &testClient{ Request: testRequest{ Method: "GET", Path: testapi.ResourcePath(getNodesResourceName(), "", "1"), }, Response: Response{StatusCode: 200, Body: &api.Node{ObjectMeta: api.ObjectMeta{Name: "minion-1"}}}, } response, err := c.Setup().Nodes().Get("1") c.Validate(t, response, err) }
func TestEventDelete(t *testing.T) { ns := api.NamespaceDefault c := &testClient{ Request: testRequest{ Method: "DELETE", Path: testapi.ResourcePath("events", ns, "foo"), }, Response: Response{StatusCode: 200}, } err := c.Setup().Events(ns).Delete("foo") c.Validate(t, nil, err) }
func NewTestServer(t *testing.T, namespace string, pods *api.PodList) *TestServer { ts := TestServer{ Stats: map[string]uint{}, } mux := http.NewServeMux() mux.HandleFunc(testapi.ResourcePath("bindings", namespace, ""), func(w http.ResponseWriter, r *http.Request) { w.WriteHeader(http.StatusOK) }) ts.server = httptest.NewServer(mux) return &ts }
func TestSyncEndpointsItemsPreexistingLabelsChange(t *testing.T) { ns := "bar" testServer, endpointsHandler := makeTestServer(t, ns, serverResponse{http.StatusOK, &api.Endpoints{ ObjectMeta: api.ObjectMeta{ Name: "foo", Namespace: ns, ResourceVersion: "1", Labels: map[string]string{ "foo": "bar", }, }, Subsets: []api.EndpointSubset{{ Addresses: []api.EndpointAddress{{IP: "6.7.8.9"}}, Ports: []api.EndpointPort{{Port: 1000}}, }}, }}) defer testServer.Close() client := client.NewOrDie(&client.Config{Host: testServer.URL, Version: testapi.Version()}) endpoints := NewEndpointController(client) addPods(endpoints.podStore.Store, ns, 1, 1) serviceLabels := map[string]string{"baz": "blah"} endpoints.serviceStore.Store.Add(&api.Service{ ObjectMeta: api.ObjectMeta{ Name: "foo", Namespace: ns, Labels: serviceLabels, }, Spec: api.ServiceSpec{ Selector: map[string]string{"foo": "bar"}, Ports: []api.ServicePort{{Port: 80, Protocol: "TCP", TargetPort: util.NewIntOrStringFromInt(8080)}}, }, }) endpoints.syncService(ns + "/foo") data := runtime.EncodeOrDie(testapi.Codec(), &api.Endpoints{ ObjectMeta: api.ObjectMeta{ Name: "foo", Namespace: ns, ResourceVersion: "1", Labels: serviceLabels, }, Subsets: []api.EndpointSubset{{ Addresses: []api.EndpointAddress{{IP: "1.2.3.4", TargetRef: &api.ObjectReference{Kind: "Pod", Name: "pod0", Namespace: ns}}}, Ports: []api.EndpointPort{{Port: 8080, Protocol: "TCP"}}, }}, }) endpointsHandler.ValidateRequest(t, testapi.ResourcePath("endpoints", ns, "foo"), "PUT", &data) }
func TestEventList(t *testing.T) { ns := api.NamespaceDefault objReference := &api.ObjectReference{ Kind: "foo", Namespace: ns, Name: "objref1", UID: "uid", APIVersion: "apiv1", ResourceVersion: "1", } timeStamp := util.Now() eventList := &api.EventList{ Items: []api.Event{ { InvolvedObject: *objReference, FirstTimestamp: timeStamp, LastTimestamp: timeStamp, Count: 1, }, }, } c := &testClient{ Request: testRequest{ Method: "GET", Path: testapi.ResourcePath("events", ns, ""), Body: nil, }, Response: Response{StatusCode: 200, Body: eventList}, } response, err := c.Setup().Events(ns).List(labels.Everything(), fields.Everything()) if err != nil { t.Errorf("%#v should be nil.", err) } if len(response.Items) != 1 { t.Errorf("%#v response.Items should have len 1.", response.Items) } responseEvent := response.Items[0] if e, r := eventList.Items[0].InvolvedObject, responseEvent.InvolvedObject; !reflect.DeepEqual(e, r) { t.Errorf("%#v != %#v.", e, r) } }
func TestPodTemplateUpdate(t *testing.T) { ns := api.NamespaceDefault podTemplate := &api.PodTemplate{ ObjectMeta: api.ObjectMeta{ Name: "abc", Namespace: ns, ResourceVersion: "1", }, Template: api.PodTemplateSpec{}, } c := &testClient{ Request: testRequest{Method: "PUT", Path: testapi.ResourcePath(getPodTemplatesResoureName(), ns, "abc"), Query: buildQueryValues(ns, nil)}, Response: Response{StatusCode: 200, Body: podTemplate}, } response, err := c.Setup().PodTemplates(ns).Update(podTemplate) c.Validate(t, response, err) }
func TestSyncEndpointsItemsWithLabels(t *testing.T) { ns := "other" testServer, endpointsHandler := makeTestServer(t, ns, serverResponse{http.StatusOK, &api.Endpoints{}}) defer testServer.Close() client := client.NewOrDie(&client.Config{Host: testServer.URL, Version: testapi.Version()}) endpoints := NewEndpointController(client) addPods(endpoints.podStore.Store, ns, 3, 2) serviceLabels := map[string]string{"foo": "bar"} endpoints.serviceStore.Store.Add(&api.Service{ ObjectMeta: api.ObjectMeta{ Name: "foo", Namespace: ns, Labels: serviceLabels, }, Spec: api.ServiceSpec{ Selector: map[string]string{"foo": "bar"}, Ports: []api.ServicePort{ {Name: "port0", Port: 80, Protocol: "TCP", TargetPort: util.NewIntOrStringFromInt(8080)}, {Name: "port1", Port: 88, Protocol: "TCP", TargetPort: util.NewIntOrStringFromInt(8088)}, }, }, }) endpoints.syncService(ns + "/foo") expectedSubsets := []api.EndpointSubset{{ Addresses: []api.EndpointAddress{ {IP: "1.2.3.4", TargetRef: &api.ObjectReference{Kind: "Pod", Name: "pod0", Namespace: ns}}, {IP: "1.2.3.5", TargetRef: &api.ObjectReference{Kind: "Pod", Name: "pod1", Namespace: ns}}, {IP: "1.2.3.6", TargetRef: &api.ObjectReference{Kind: "Pod", Name: "pod2", Namespace: ns}}, }, Ports: []api.EndpointPort{ {Name: "port0", Port: 8080, Protocol: "TCP"}, {Name: "port1", Port: 8088, Protocol: "TCP"}, }, }} data := runtime.EncodeOrDie(testapi.Codec(), &api.Endpoints{ ObjectMeta: api.ObjectMeta{ ResourceVersion: "", Labels: serviceLabels, }, Subsets: endptspkg.SortSubsets(expectedSubsets), }) // endpointsHandler should get 2 requests - one for "GET" and the next for "POST". endpointsHandler.ValidateRequestCount(t, 2) endpointsHandler.ValidateRequest(t, testapi.ResourcePath("endpoints", ns, ""), "POST", &data) }
func TestDoRequestNewWayObj(t *testing.T) { reqObj := &api.Pod{ObjectMeta: api.ObjectMeta{Name: "foo"}} reqBodyExpected, _ := testapi.Codec().Encode(reqObj) expectedObj := &api.Service{Spec: api.ServiceSpec{Ports: []api.ServicePort{{ Protocol: "TCP", Port: 12345, TargetPort: util.NewIntOrStringFromInt(12345), }}}} expectedBody, _ := testapi.Codec().Encode(expectedObj) fakeHandler := util.FakeHandler{ StatusCode: 200, ResponseBody: string(expectedBody), T: t, } testServer := httptest.NewServer(&fakeHandler) c := NewOrDie(&Config{Host: testServer.URL, Version: testapi.Version(), Username: "******", Password: "******"}) obj, err := c.Verb("POST"). Suffix("baz"). Name("bar"). Resource("foo"). LabelsSelectorParam(labels.Set{"name": "foo"}.AsSelector()). Timeout(time.Second). Body(reqObj). Do().Get() if err != nil { t.Errorf("Unexpected error: %v %#v", err, err) return } if obj == nil { t.Error("nil obj") } else if !api.Semantic.DeepDerivative(expectedObj, obj) { t.Errorf("Expected: %#v, got %#v", expectedObj, obj) } tmpStr := string(reqBodyExpected) requestURL := testapi.ResourcePath("foo", "", "bar/baz") requestURL += "?" + api.LabelSelectorQueryParam(testapi.Version()) + "=name%3Dfoo&timeout=1s" fakeHandler.ValidateRequest(t, requestURL, "POST", &tmpStr) if fakeHandler.RequestReceived.Header["Authorization"] == nil { t.Errorf("Request is missing authorization header: %#v", *fakeHandler.RequestReceived) } }