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) }
// TestSecrets tests apiserver-side behavior of creation of secret objects and their use by pods. func TestSecrets(t *testing.T) { helper, err := framework.NewHelper() if err != nil { t.Fatalf("unexpected error: %v", err) } var m *master.Master s := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) { m.Handler.ServeHTTP(w, req) })) defer s.Close() m = master.New(&master.Config{ EtcdHelper: helper, QingletClient: client.FakeQingletClient{}, EnableCoreControllers: true, EnableLogsSupport: false, EnableUISupport: false, EnableIndex: true, APIPrefix: "/api", Authorizer: apiserver.NewAlwaysAllowAuthorizer(), AdmissionControl: admit.NewAlwaysAdmit(), }) framework.DeleteAllEtcdKeys() client := client.NewOrDie(&client.Config{Host: s.URL, Version: testapi.Version()}) DoTestSecrets(t, client, testapi.Version()) }
func newExternalScheme() (*runtime.Scheme, meta.RESTMapper, runtime.Codec) { scheme := runtime.NewScheme() scheme.AddKnownTypeWithName("", "Type", &internalType{}) scheme.AddKnownTypeWithName("unlikelyversion", "Type", &externalType{}) //This tests that qingctl will not confuse the external scheme with the internal scheme, even when they accidentally have versions of the same name. scheme.AddKnownTypeWithName(testapi.Version(), "Type", &ExternalType2{}) codec := runtime.CodecFor(scheme, "unlikelyversion") validVersion := testapi.Version() mapper := meta.NewDefaultRESTMapper([]string{"unlikelyversion", validVersion}, func(version string) (*meta.VersionInterfaces, bool) { return &meta.VersionInterfaces{ Codec: runtime.CodecFor(scheme, version), ObjectConvertor: scheme, MetadataAccessor: meta.NewAccessor(), }, (version == validVersion || version == "unlikelyversion") }) for _, version := range []string{"unlikelyversion", validVersion} { for kind := range scheme.KnownTypes(version) { mixedCase := false scope := meta.RESTScopeNamespace mapper.Add(scope, kind, version, mixedCase) } } return scheme, mapper, codec }
func TestSetsCodec(t *testing.T) { testCases := map[string]struct { Err bool Prefix string Codec runtime.Codec }{ testapi.Version(): {false, "/api/" + testapi.Version() + "/", testapi.Codec()}, "invalidVersion": {true, "", nil}, } for version, expected := range testCases { client, err := New(&Config{Host: "127.0.0.1", Version: version}) switch { case err == nil && expected.Err: t.Errorf("expected error but was nil") continue case err != nil && !expected.Err: t.Errorf("unexpected error %v", err) continue case err != nil: continue } if e, a := expected.Prefix, client.RESTClient.baseURL.Path; e != a { t.Errorf("expected %#v, got %#v", e, a) } if e, a := expected.Codec, client.RESTClient.Codec; e != a { t.Errorf("expected %#v, got %#v", e, a) } } }
// buildResourcePath is a convenience function for knowing if a namespace should be in a path param or not func buildResourcePath(namespace, resource string) string { if len(namespace) > 0 { if !(testapi.Version() == "v1beta1" || testapi.Version() == "v1beta2") { return path.Join("namespaces", namespace, resource) } } return resource }
func (c *testClient) ValidateCommon(t *testing.T, err error) { defer c.server.Close() if c.Error { if err == nil { t.Errorf("error expected for %#v, got none", c.Request) } return } if err != nil { t.Errorf("no error expected for %#v, got: %v", c.Request, err) } if c.handler.RequestReceived == nil { t.Errorf("handler had an empty request, %#v", c) return } requestBody := body(c.Request.Body, c.Request.RawBody) actualQuery := c.handler.RequestReceived.URL.Query() t.Logf("got query: %v", actualQuery) t.Logf("path: %v", c.Request.Path) // We check the query manually, so blank it out so that FakeHandler.ValidateRequest // won't check it. c.handler.RequestReceived.URL.RawQuery = "" c.handler.ValidateRequest(t, path.Join(c.Request.Path), c.Request.Method, requestBody) for key, values := range c.Request.Query { validator, ok := c.QueryValidator[key] if !ok { switch key { case api.LabelSelectorQueryParam(testapi.Version()): validator = validateLabels case api.FieldSelectorQueryParam(testapi.Version()): validator = validateFields default: validator = func(a, b string) bool { return a == b } } } observed := actualQuery.Get(key) wanted := strings.Join(values, "") if !validator(wanted, observed) { t.Errorf("Unexpected query arg for key: %s. Expected %s, Received %s", key, wanted, observed) } } if c.Request.Header != "" { if c.handler.RequestReceived.Header.Get(c.Request.Header) == "" { t.Errorf("header %q not found in request %#v", c.Request.Header, c.handler.RequestReceived) } } if expected, received := requestBody, c.handler.RequestBody; expected != nil && *expected != received { t.Errorf("bad body for request %#v: expected %s, got %s", c.Request, *expected, received) } }
func TestRESTClientRequires(t *testing.T) { if _, err := RESTClientFor(&Config{Host: "127.0.0.1", Version: "", Codec: testapi.Codec()}); err == nil { t.Errorf("unexpected non-error") } if _, err := RESTClientFor(&Config{Host: "127.0.0.1", Version: testapi.Version()}); err == nil { t.Errorf("unexpected non-error") } if _, err := RESTClientFor(&Config{Host: "127.0.0.1", Version: testapi.Version(), Codec: testapi.Codec()}); err != nil { t.Errorf("unexpected error: %v", err) } }
func init() { scheme = runtime.NewScheme() scheme.AddKnownTypes("", &TestResource{}) scheme.AddKnownTypes(testapi.Version(), &TestResource{}) codec = runtime.CodecFor(scheme, testapi.Version()) scheme.AddConversionFuncs( func(in *TestResource, out *TestResource, s conversion.Scope) error { *out = *in return nil }, ) }
func TestRESTList(t *testing.T) { reg, rest := NewTestREST() eventA := &api.Event{ InvolvedObject: api.ObjectReference{ Kind: "Pod", Name: "foo", UID: "long uid string", APIVersion: testapi.Version(), ResourceVersion: "0", FieldPath: "", }, Reason: "ForTesting", Source: api.EventSource{Component: "GoodSource"}, } eventB := &api.Event{ InvolvedObject: api.ObjectReference{ Kind: "Pod", Name: "bar", UID: "other long uid string", APIVersion: testapi.Version(), ResourceVersion: "0", FieldPath: "", }, Reason: "ForTesting", Source: api.EventSource{Component: "GoodSource"}, } eventC := &api.Event{ InvolvedObject: api.ObjectReference{ Kind: "Pod", Name: "baz", UID: "yet another long uid string", APIVersion: testapi.Version(), ResourceVersion: "0", FieldPath: "", }, Reason: "ForTesting", Source: api.EventSource{Component: "OtherSource"}, } reg.ObjectList = &api.EventList{ Items: []api.Event{*eventA, *eventB, *eventC}, } got, err := rest.List(api.NewContext(), labels.Everything(), fields.Set{"source": "GoodSource"}.AsSelector()) if err != nil { t.Fatalf("Unexpected error %v", err) } expect := &api.EventList{ Items: []api.Event{*eventA, *eventB}, } if e, a := expect, got; !reflect.DeepEqual(e, a) { t.Errorf("diff: %s", util.ObjectDiff(e, a)) } }
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 BenchmarkPodConversion(b *testing.B) { data, err := ioutil.ReadFile("pod_example.json") if err != nil { b.Fatalf("Unexpected error while reading file: %v", err) } var pod api.Pod if err := api.Scheme.DecodeInto(data, &pod); err != nil { b.Fatalf("Unexpected error decoding pod: %v", err) } scheme := api.Scheme.Raw() var result *api.Pod for i := 0; i < b.N; i++ { versionedObj, err := scheme.ConvertToVersion(&pod, testapi.Version()) if err != nil { b.Fatalf("Conversion error: %v", err) } obj, err := scheme.ConvertToVersion(versionedObj, scheme.InternalVersion) if err != nil { b.Fatalf("Conversion error: %v", err) } result = obj.(*api.Pod) } if !api.Semantic.DeepDerivative(pod, *result) { b.Fatalf("Incorrect conversion: expected %v, got %v", pod, *result) } }
func addPods(store cache.Store, namespace string, nPods int, nPorts int) { for i := 0; i < nPods; i++ { p := &api.Pod{ TypeMeta: api.TypeMeta{APIVersion: testapi.Version()}, ObjectMeta: api.ObjectMeta{ Namespace: namespace, Name: fmt.Sprintf("pod%d", i), Labels: map[string]string{"foo": "bar"}, }, Spec: api.PodSpec{ Containers: []api.Container{{Ports: []api.ContainerPort{}}}, }, Status: api.PodStatus{ PodIP: fmt.Sprintf("1.2.3.%d", 4+i), Conditions: []api.PodCondition{ { Type: api.PodReady, Status: api.ConditionTrue, }, }, }, } for j := 0; j < nPorts; j++ { p.Spec.Containers[0].Ports = append(p.Spec.Containers[0].Ports, api.ContainerPort{Name: fmt.Sprintf("port%d", i), ContainerPort: 8080 + j}) } store.Add(p) } }
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 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 TestDeleteFinalStateUnknown(t *testing.T) { client := client.NewOrDie(&client.Config{Host: "", Version: testapi.Version()}) fakePodControl := FakePodControl{} manager := NewReplicationManager(client, BurstReplicas) manager.podStoreSynced = alwaysReady manager.podControl = &fakePodControl received := make(chan string) manager.syncHandler = func(key string) error { received <- key return nil } // The DeletedFinalStateUnknown object should cause the rc manager to insert // the controller matching the selectors of the deleted pod into the work queue. controllerSpec := newReplicationController(1) manager.controllerStore.Store.Add(controllerSpec) pods := newPodList(nil, 1, api.PodRunning, controllerSpec) manager.deletePod(cache.DeletedFinalStateUnknown{Key: "foo", Obj: &pods.Items[0]}) go manager.worker() expected := getKey(controllerSpec, t) select { case key := <-received: if key != expected { t.Errorf("Unexpected sync all for rc %v, expected %v", key, expected) } case <-time.After(100 * time.Millisecond): t.Errorf("Processing DeleteFinalStateUnknown took longer than expected") } }
// Create a pod with a given index, requiring one port func NewTestPod(i int) *api.Pod { name := fmt.Sprintf("pod%d", i) return &api.Pod{ TypeMeta: api.TypeMeta{APIVersion: testapi.Version()}, ObjectMeta: api.ObjectMeta{ Name: name, Namespace: api.NamespaceDefault, SelfLink: testapi.SelfLink("pods", string(i)), }, Spec: api.PodSpec{ Containers: []api.Container{ { Name: "foo", Ports: []api.ContainerPort{ { ContainerPort: 8000 + i, Protocol: api.ProtocolTCP, }, }, }, }, }, Status: api.PodStatus{ Conditions: []api.PodCondition{ { Type: api.PodReady, Status: api.ConditionTrue, }, }, }, } }
func TestListObjectWithDifferentVersions(t *testing.T) { pods, svc := testData() labelKey := api.LabelSelectorQueryParam(testapi.Version()) obj, err := NewBuilder(latest.RESTMapper, api.Scheme, fakeClientWith("", t, map[string]string{ "/namespaces/test/pods?" + labelKey + "=a%3Db": runtime.EncodeOrDie(latest.Codec, pods), "/namespaces/test/services?" + labelKey + "=a%3Db": runtime.EncodeOrDie(latest.Codec, svc), })). SelectorParam("a=b"). NamespaceParam("test"). ResourceTypeOrNameArgs(true, "pods,services"). Flatten(). Do().Object() if err != nil { t.Fatalf("unexpected error: %v", err) } list, ok := obj.(*api.List) if !ok { t.Fatalf("unexpected object: %#v", obj) } // resource version differs between type lists, so it's not possible to get a single version. if list.ResourceVersion != "" || len(list.Items) != 3 { t.Errorf("unexpected list: %#v", list) } }
func BenchmarkCheckRetryClosesBody(t *testing.B) { count := 0 testServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) { count++ if count%3 == 0 { w.WriteHeader(http.StatusOK) return } w.Header().Set("Retry-After", "0") w.WriteHeader(apierrors.StatusTooManyRequests) })) defer testServer.Close() c := NewOrDie(&Config{Host: testServer.URL, Version: testapi.Version(), Username: "******", Password: "******"}) r := c.Verb("POST"). Prefix("foo", "bar"). Suffix("baz"). Timeout(time.Second). Body([]byte(strings.Repeat("abcd", 1000))) for i := 0; i < t.N; i++ { if _, err := r.DoRaw(); err != nil { t.Fatalf("Unexpected error: %v %#v", err, err) } } }
func TestRESTWatch(t *testing.T) { eventA := &api.Event{ InvolvedObject: api.ObjectReference{ Kind: "Pod", Name: "foo", UID: "long uid string", APIVersion: testapi.Version(), ResourceVersion: "0", FieldPath: "", }, Reason: "ForTesting", } reg, rest := NewTestREST() wi, err := rest.Watch(api.NewContext(), labels.Everything(), fields.Everything(), "0") if err != nil { t.Fatalf("Unexpected error %v", err) } go func() { reg.Broadcaster.Action(watch.Added, eventA) }() got := <-wi.ResultChan() if e, a := eventA, got.Object; !reflect.DeepEqual(e, a) { t.Errorf("diff: %s", util.ObjectDiff(e, a)) } }
func TestCheckRetryClosesBody(t *testing.T) { count := 0 ch := make(chan struct{}) testServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) { count++ t.Logf("attempt %d", count) if count >= 5 { w.WriteHeader(http.StatusOK) close(ch) return } w.Header().Set("Retry-After", "0") w.WriteHeader(apierrors.StatusTooManyRequests) })) defer testServer.Close() c := NewOrDie(&Config{Host: testServer.URL, Version: testapi.Version(), Username: "******", Password: "******"}) _, err := c.Verb("POST"). Prefix("foo", "bar"). Suffix("baz"). Timeout(time.Second). Body([]byte(strings.Repeat("abcd", 1000))). DoRaw() if err != nil { t.Fatalf("Unexpected error: %v %#v", err, err) } <-ch if count != 5 { t.Errorf("unexpected retries: %d", count) } }
func init() { if api.PreV1Beta3(testapi.Version()) { nodeResourceName = "minions" } else { nodeResourceName = "nodes" } }
func TestDeleteControllerAndExpectations(t *testing.T) { client := client.NewOrDie(&client.Config{Host: "", Version: testapi.Version()}) manager := NewReplicationManager(client, 10) manager.podStoreSynced = alwaysReady rc := newReplicationController(1) manager.controllerStore.Store.Add(rc) fakePodControl := FakePodControl{} manager.podControl = &fakePodControl // This should set expectations for the rc manager.syncReplicationController(getKey(rc, t)) validateSyncReplication(t, &fakePodControl, 1, 0) fakePodControl.clear() // This is to simulate a concurrent addPod, that has a handle on the expectations // as the controller deletes it. podExp, exists, err := manager.expectations.GetExpectations(rc) if !exists || err != nil { t.Errorf("No expectations found for rc") } manager.controllerStore.Delete(rc) manager.syncReplicationController(getKey(rc, t)) if _, exists, err = manager.expectations.GetExpectations(rc); exists { t.Errorf("Found expectaions, expected none since the rc has been deleted.") } // This should have no effect, since we've deleted the rc. podExp.Seen(1, 0) manager.podStore.Store.Replace(make([]interface{}, 0)) manager.syncReplicationController(getKey(rc, t)) validateSyncReplication(t, &fakePodControl, 0, 0) }
func TestSelector(t *testing.T) { pods, svc := testData() labelKey := api.LabelSelectorQueryParam(testapi.Version()) b := NewBuilder(latest.RESTMapper, api.Scheme, fakeClientWith("", t, map[string]string{ "/namespaces/test/pods?" + labelKey + "=a%3Db": runtime.EncodeOrDie(latest.Codec, pods), "/namespaces/test/services?" + labelKey + "=a%3Db": runtime.EncodeOrDie(latest.Codec, svc), })). SelectorParam("a=b"). NamespaceParam("test"). Flatten() test := &testVisitor{} singular := false if b.Do().Err() == nil { t.Errorf("unexpected non-error") } b.ResourceTypeOrNameArgs(true, "pods,service") err := b.Do().IntoSingular(&singular).Visit(test.Handle) if err != nil || singular || len(test.Infos) != 3 { t.Fatalf("unexpected response: %v %t %#v", err, singular, test.Infos) } if !api.Semantic.DeepDerivative([]runtime.Object{&pods.Items[0], &pods.Items[1], &svc.Items[0]}, test.Objects()) { t.Errorf("unexpected visited objects: %#v", test.Objects()) } if _, err := b.Do().ResourceMapping(); err == nil { t.Errorf("unexpected non-error") } }
func BenchmarkReplicationControllerConversion(b *testing.B) { data, err := ioutil.ReadFile("replication_controller_example.json") if err != nil { b.Fatalf("Unexpected error while reading file: %v", err) } var replicationController api.ReplicationController if err := api.Scheme.DecodeInto(data, &replicationController); err != nil { b.Fatalf("Unexpected error decoding node: %v", err) } scheme := api.Scheme.Raw() var result *api.ReplicationController for i := 0; i < b.N; i++ { versionedObj, err := scheme.ConvertToVersion(&replicationController, testapi.Version()) if err != nil { b.Fatalf("Conversion error: %v", err) } obj, err := scheme.ConvertToVersion(versionedObj, scheme.InternalVersion) if err != nil { b.Fatalf("Conversion error: %v", err) } result = obj.(*api.ReplicationController) } if !api.Semantic.DeepDerivative(replicationController, *result) { b.Fatalf("Incorrect conversion: expected %v, got %v", replicationController, *result) } }
func TestListObject(t *testing.T) { pods, _ := testData() labelKey := api.LabelSelectorQueryParam(testapi.Version()) b := NewBuilder(latest.RESTMapper, api.Scheme, fakeClientWith("", t, map[string]string{ "/namespaces/test/pods?" + labelKey + "=a%3Db": runtime.EncodeOrDie(latest.Codec, pods), })). SelectorParam("a=b"). NamespaceParam("test"). ResourceTypeOrNameArgs(true, "pods"). Flatten() obj, err := b.Do().Object() if err != nil { t.Fatalf("unexpected error: %v", err) } list, ok := obj.(*api.List) if !ok { t.Fatalf("unexpected object: %#v", obj) } if list.ResourceVersion != pods.ResourceVersion || len(list.Items) != 2 { t.Errorf("unexpected list: %#v", list) } mapping, err := b.Do().ResourceMapping() if err != nil { t.Fatalf("unexpected error: %v", err) } if mapping.Resource != "pods" { t.Errorf("unexpected resource mapping: %#v", mapping) } }
func TestCheckLeftoverEndpoints(t *testing.T) { ns := api.NamespaceDefault // Note that this requests *all* endpoints, therefore the NamespaceAll // below. testServer, _ := makeTestServer(t, api.NamespaceAll, serverResponse{http.StatusOK, &api.EndpointsList{ ListMeta: api.ListMeta{ ResourceVersion: "1", }, Items: []api.Endpoints{{ ObjectMeta: api.ObjectMeta{ Name: "foo", Namespace: ns, ResourceVersion: "1", }, 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) endpoints.checkLeftoverEndpoints() if e, a := 1, endpoints.queue.Len(); e != a { t.Fatalf("Expected %v, got %v", e, a) } got, _ := endpoints.queue.Get() if e, a := ns+"/foo", got; e != a { t.Errorf("Expected %v, got %v", e, a) } }
func TestDoRequestBearer(t *testing.T) { status := &api.Status{Status: api.StatusFailure} expectedBody, _ := latest.Codec.Encode(status) fakeHandler := util.FakeHandler{ StatusCode: 400, ResponseBody: string(expectedBody), T: t, } testServer := httptest.NewServer(&fakeHandler) defer testServer.Close() request, _ := http.NewRequest("GET", testServer.URL, nil) c, err := RESTClientFor(&Config{ Host: testServer.URL, Version: testapi.Version(), Codec: testapi.Codec(), BearerToken: "test", }) if err != nil { t.Fatalf("unexpected error: %v", err) } err = c.Get().Do().Error() if err == nil { t.Fatalf("unexpected non-error: %v", err) } if fakeHandler.RequestReceived.Header.Get("Authorization") != "Bearer test" { t.Errorf("Request is missing authorization header: %#v", *request) } }
func TestSyncEndpointsProtocolUDP(t *testing.T) { ns := "other" testServer, endpointsHandler := makeTestServer(t, ns, serverResponse{http.StatusOK, &api.Endpoints{ ObjectMeta: api.ObjectMeta{ Name: "foo", Namespace: ns, ResourceVersion: "1", }, Subsets: []api.EndpointSubset{{ Addresses: []api.EndpointAddress{{IP: "6.7.8.9"}}, Ports: []api.EndpointPort{{Port: 1000, Protocol: "UDP"}}, }}, }}) defer testServer.Close() client := client.NewOrDie(&client.Config{Host: testServer.URL, Version: testapi.Version()}) endpoints := NewEndpointController(client) endpoints.serviceStore.Store.Add(&api.Service{ ObjectMeta: api.ObjectMeta{Name: "foo", Namespace: ns}, Spec: api.ServiceSpec{ Selector: map[string]string{}, Ports: []api.ServicePort{{Port: 80}}, }, }) endpoints.syncService(ns + "/foo") endpointsHandler.ValidateRequestCount(t, 0) }
func readPod(filename string) (string, error) { data, err := ioutil.ReadFile("testdata/" + testapi.Version() + "/" + filename) if err != nil { return "", err } return string(data), nil }
func TestRCManagerNotReady(t *testing.T) { client := client.NewOrDie(&client.Config{Host: "", Version: testapi.Version()}) fakePodControl := FakePodControl{} manager := NewReplicationManager(client, 2) manager.podControl = &fakePodControl manager.podStoreSynced = func() bool { return false } // Simulates the rc reflector running before the pod reflector. We don't // want to end up creating replicas in this case until the pod reflector // has synced, so the rc manager should just requeue the rc. controllerSpec := newReplicationController(1) manager.controllerStore.Store.Add(controllerSpec) rcKey := getKey(controllerSpec, t) manager.syncReplicationController(rcKey) validateSyncReplication(t, &fakePodControl, 0, 0) queueRC, _ := manager.queue.Get() if queueRC != rcKey { t.Fatalf("Expected to find key %v in queue, found %v", rcKey, queueRC) } manager.podStoreSynced = alwaysReady manager.syncReplicationController(rcKey) validateSyncReplication(t, &fakePodControl, 1, 0) }