func TestCreateSetsFields(t *testing.T) { fakeEtcdClient, etcdStorage := newEtcdStorage(t) storage, _, _ := NewStorage(etcdStorage) namespace := validNewNamespace() _, err := storage.Create(api.NewContext(), namespace) if err != fakeEtcdClient.Err { t.Fatalf("unexpected error: %v", err) } actual := &api.Namespace{} ctx := api.NewContext() key, err := storage.Etcd.KeyFunc(ctx, "foo") if err != nil { t.Fatalf("unexpected key error: %v", err) } if err := etcdStorage.Get(key, actual, false); err != nil { t.Fatalf("unexpected extraction error: %v", err) } if actual.Name != namespace.Name { t.Errorf("unexpected namespace: %#v", actual) } if len(actual.UID) == 0 { t.Errorf("expected namespace UID to be set: %#v", actual) } if actual.Status.Phase != api.NamespaceActive { t.Errorf("expected namespace phase to be set to active, but %v", actual.Status.Phase) } }
func TestStrategyPrepareMethods(t *testing.T) { _, helper := newHelper(t) storage, _ := NewREST(helper, testDefaultRegistry, &fakeSubjectAccessReviewRegistry{}) stream := validNewStream() strategy := fakeStrategy{imagestream.NewStrategy(testDefaultRegistry, &fakeSubjectAccessReviewRegistry{})} storage.store.CreateStrategy = strategy storage.store.UpdateStrategy = strategy ctx := kapi.WithUser(kapi.NewDefaultContext(), &fakeUser{}) obj, err := storage.Create(ctx, stream) if err != nil { t.Fatalf("Unexpected error: %v", err) } updatedStream := obj.(*api.ImageStream) if updatedStream.Annotations["test"] != "PrepareForCreate" { t.Errorf("Expected PrepareForCreate annotation") } obj, _, err = storage.Update(ctx, updatedStream) if err != nil { t.Errorf("Unexpected error: %v", err) } updatedStream = obj.(*api.ImageStream) if updatedStream.Annotations["test"] != "PrepareForUpdate" { t.Errorf("Expected PrepareForUpdate annotation") } }
func TestCreateImageStreamOK(t *testing.T) { _, helper := newHelper(t) storage, _ := NewREST(helper, noDefaultRegistry, &fakeSubjectAccessReviewRegistry{}) stream := &api.ImageStream{ObjectMeta: kapi.ObjectMeta{Name: "foo"}} ctx := kapi.WithUser(kapi.NewDefaultContext(), &fakeUser{}) _, err := storage.Create(ctx, stream) if err != nil { t.Fatalf("Unexpected non-nil error: %#v", err) } actual := &api.ImageStream{} if err := helper.Get("/imagestreams/default/foo", actual, false); err != nil { t.Fatalf("unexpected extraction error: %v", err) } if actual.Name != stream.Name { t.Errorf("unexpected stream: %#v", actual) } if len(actual.UID) == 0 { t.Errorf("expected stream UID to be set: %#v", actual) } if stream.CreationTimestamp.IsZero() { t.Error("Unexpected zero CreationTimestamp") } if stream.Spec.DockerImageRepository != "" { t.Errorf("unexpected stream: %#v", stream) } }
func TestUpdate(t *testing.T) { fakeEtcdClient, etcdStorage := newEtcdStorage(t) storage := NewStorage(etcdStorage) test := resttest.New(t, storage, fakeEtcdClient.SetError) key, err := storage.KeyFunc(test.TestContext(), "foo") if err != nil { t.Fatal(err) } key = etcdtest.AddPrefix(key) fakeEtcdClient.ExpectNotFoundGet(key) fakeEtcdClient.ChangeIndex = 2 secret := validNewSecret("foo") existing := validNewSecret("exists") existing.Namespace = test.TestNamespace() obj, err := storage.Create(test.TestContext(), existing) if err != nil { t.Fatalf("unable to create object: %v", err) } older := obj.(*api.Secret) older.ResourceVersion = "1" test.TestUpdate( secret, existing, older, ) }
func TestCreate(t *testing.T) { _, helper := newHelper(t) storage, _ := NewREST(helper, noDefaultRegistry, &fakeSubjectAccessReviewRegistry{}) stream := validNewStream() ctx := kapi.WithUser(kapi.NewDefaultContext(), &fakeUser{}) _, err := storage.Create(ctx, stream) if err != nil { t.Fatalf("unexpected error: %v", err) } }
func TestCreateRegistryError(t *testing.T) { fakeEtcdClient, etcdStorage := newEtcdStorage(t) fakeEtcdClient.Err = fmt.Errorf("test error") storage, _ := NewStorage(etcdStorage) resourcequota := validNewResourceQuota() _, err := storage.Create(api.NewDefaultContext(), resourcequota) if err != fakeEtcdClient.Err { t.Fatalf("unexpected error: %v", err) } }
func TestCreateRegistryError(t *testing.T) { fakeEtcdClient, helper := newHelper(t) fakeEtcdClient.Err = fmt.Errorf("test error") storage := NewREST(helper) image := validNewImage() _, err := storage.Create(kapi.NewDefaultContext(), image) if err != fakeEtcdClient.Err { t.Fatalf("unexpected error: %v", err) } }
func TestCreateRegistryError(t *testing.T) { fakeEtcdClient, etcdStorage := newEtcdStorage(t) fakeEtcdClient.Err = fmt.Errorf("test error") storage := NewStorage(etcdStorage, nil).Pod pod := validNewPod() _, err := storage.Create(api.NewDefaultContext(), pod) if err != fakeEtcdClient.Err { t.Fatalf("unexpected error: %v", err) } }
func TestCreateRegistryErrorSaving(t *testing.T) { fakeEtcdClient, helper := newHelper(t) fakeEtcdClient.Err = fmt.Errorf("foo") storage, _ := NewREST(helper, noDefaultRegistry, &fakeSubjectAccessReviewRegistry{}) ctx := kapi.WithUser(kapi.NewDefaultContext(), &fakeUser{}) _, err := storage.Create(ctx, &api.ImageStream{ObjectMeta: kapi.ObjectMeta{Name: "foo"}}) if err != fakeEtcdClient.Err { t.Fatalf("Unexpected non-nil error: %#v", err) } }
func TestEtcdCreateControllerAlreadyExisting(t *testing.T) { ctx := api.NewDefaultContext() storage, fakeClient := newStorage(t) key, _ := makeControllerKey(ctx, validController.Name) key = etcdtest.AddPrefix(key) fakeClient.Set(key, runtime.EncodeOrDie(latest.Codec, &validController), 0) _, err := storage.Create(ctx, &validController) if !errors.IsAlreadyExists(err) { t.Errorf("expected already exists err, got %#v", err) } }
func TestCreateMissingID(t *testing.T) { _, helper := newHelper(t) storage := NewREST(helper) obj, err := storage.Create(kapi.NewDefaultContext(), &api.Image{}) if obj != nil { t.Errorf("Expected nil obj, got %v", obj) } if !errors.IsInvalid(err) { t.Errorf("Expected 'invalid' error, got %v", err) } }
func TestEtcdCreateControllerValidates(t *testing.T) { ctx := api.NewDefaultContext() storage, _ := newStorage(t) emptyName := validController emptyName.Name = "" failureCases := []api.ReplicationController{emptyName} for _, failureCase := range failureCases { c, err := storage.Create(ctx, &failureCase) if c != nil { t.Errorf("Expected nil channel") } if !errors.IsInvalid(err) { t.Errorf("Expected to get an invalid resource error, got %v", err) } } }
// TODO: remove, this is covered by RESTTest.TestCreate func TestPodStorageValidatesCreate(t *testing.T) { fakeEtcdClient, etcdStorage := newEtcdStorage(t) fakeEtcdClient.Err = fmt.Errorf("test error") storage := NewStorage(etcdStorage, nil).Pod pod := validNewPod() pod.Labels = map[string]string{ "invalid/label/to/cause/validation/failure": "bar", } c, err := storage.Create(api.NewDefaultContext(), pod) if c != nil { t.Errorf("Expected nil object") } if !errors.IsInvalid(err) { t.Errorf("Expected to get an invalid resource error, got %v", err) } }
// TODO: remove, this is covered by RESTTest.TestCreate func TestCreateWithConflictingNamespace(t *testing.T) { _, etcdStorage := newEtcdStorage(t) storage := NewStorage(etcdStorage, nil).Pod pod := validNewPod() pod.Namespace = "not-default" obj, err := storage.Create(api.NewDefaultContext(), pod) if obj != nil { t.Error("Expected a nil obj, but we got a value") } if err == nil { t.Errorf("Expected an error, but we didn't get one") } else if strings.Contains(err.Error(), "Controller.Namespace does not match the provided context") { t.Errorf("Expected 'Pod.Namespace does not match the provided context' error, got '%v'", err.Error()) } }
func TestStrategyPrepareMethods(t *testing.T) { _, helper := newHelper(t) storage := NewREST(helper) img := validNewImage() strategy := fakeStrategy{image.Strategy} storage.store.CreateStrategy = strategy obj, err := storage.Create(kapi.NewDefaultContext(), img) if err != nil { t.Errorf("Unexpected error: %v", err) } newImage := obj.(*api.Image) if newImage.Annotations["test"] != "PrepareForCreate" { t.Errorf("Expected PrepareForCreate annotation") } }
func TestCreateControllerWithConflictingNamespace(t *testing.T) { storage, _ := newStorage(t) controller := &api.ReplicationController{ ObjectMeta: api.ObjectMeta{Name: "test", Namespace: "not-default"}, } ctx := api.NewDefaultContext() channel, err := storage.Create(ctx, controller) if channel != nil { t.Error("Expected a nil channel, but we got a value") } errSubString := "namespace" if err == nil { t.Errorf("Expected an error, but we didn't get one") } else if !errors.IsBadRequest(err) || strings.Index(err.Error(), errSubString) == -1 { t.Errorf("Expected a Bad Request error with the sub string '%s', got %v", errSubString, err) } }
func TestCreateSetsFields(t *testing.T) { fakeEtcdClient, etcdStorage := newEtcdStorage(t) storage := NewStorage(etcdStorage, nil).Pod pod := validNewPod() _, err := storage.Create(api.NewDefaultContext(), pod) if err != fakeEtcdClient.Err { t.Fatalf("unexpected error: %v", err) } ctx := api.NewDefaultContext() key, _ := storage.Etcd.KeyFunc(ctx, "foo") actual := &api.Pod{} if err := etcdStorage.Get(key, actual, false); err != nil { t.Fatalf("unexpected extraction error: %v", err) } if actual.Name != pod.Name { t.Errorf("unexpected pod: %#v", actual) } if len(actual.UID) == 0 { t.Errorf("expected pod UID to be set: %#v", actual) } }
func TestCreateSetsFields(t *testing.T) { fakeEtcdClient, etcdStorage := newEtcdStorage(t) storage, _ := NewStorage(etcdStorage) ctx := api.NewDefaultContext() resourcequota := validNewResourceQuota() _, err := storage.Create(api.NewDefaultContext(), resourcequota) if err != fakeEtcdClient.Err { t.Fatalf("unexpected error: %v", err) } actual := &api.ResourceQuota{} key, _ := storage.Etcd.KeyFunc(ctx, "foo") if err := etcdStorage.Get(key, actual, false); err != nil { t.Fatalf("unexpected extraction error: %v", err) } if actual.Name != resourcequota.Name { t.Errorf("unexpected resourcequota: %#v", actual) } if len(actual.UID) == 0 { t.Errorf("expected resourcequota UID to be set: %#v", actual) } }
// TODO: remove, this is covered by RESTTest.TestCreate func TestCreatePod(t *testing.T) { _, etcdStorage := newEtcdStorage(t) storage := NewStorage(etcdStorage, nil).Pod ctx := api.NewDefaultContext() key, _ := storage.Etcd.KeyFunc(ctx, "foo") pod := validNewPod() obj, err := storage.Create(api.NewDefaultContext(), pod) if err != nil { t.Fatalf("unexpected error: %v", err) } if obj == nil { t.Fatalf("unexpected object: %#v", obj) } actual := &api.Pod{} if err := etcdStorage.Get(key, actual, false); err != nil { t.Fatalf("unexpected extraction error: %v", err) } if !api.HasObjectMetaSystemFieldValues(&actual.ObjectMeta) { t.Errorf("Expected ObjectMeta field values were populated: %#v", actual) } }
func TestEtcdCreateController(t *testing.T) { ctx := api.NewDefaultContext() storage, fakeClient := newStorage(t) _, err := storage.Create(ctx, &validController) if err != nil { t.Errorf("unexpected error: %v", err) } key, _ := makeControllerKey(ctx, validController.Name) key = etcdtest.AddPrefix(key) resp, err := fakeClient.Get(key, false, false) if err != nil { t.Fatalf("Unexpected error %v", err) } var ctrl api.ReplicationController err = latest.Codec.DecodeInto([]byte(resp.Node.Value), &ctrl) if err != nil { t.Errorf("unexpected error: %v", err) } if ctrl.Name != "foo" { t.Errorf("Unexpected controller: %#v %s", ctrl, resp.Node.Value) } }
func TestCreateOK(t *testing.T) { _, helper := newHelper(t) storage := NewREST(helper) obj, err := storage.Create(kapi.NewDefaultContext(), &api.Image{ ObjectMeta: kapi.ObjectMeta{Name: "foo"}, DockerImageReference: "openshift/ruby-19-centos", }) if obj == nil { t.Errorf("Expected nil obj, got %v", obj) } if err != nil { t.Errorf("Unexpected non-nil error: %#v", err) } image, ok := obj.(*api.Image) if !ok { t.Errorf("Expected image type, got: %#v", obj) } if image.Name != "foo" { t.Errorf("Unexpected image: %#v", image) } }
func TestCreateControllerWithGeneratedName(t *testing.T) { storage, _ := newStorage(t) controller := &api.ReplicationController{ ObjectMeta: api.ObjectMeta{ Namespace: api.NamespaceDefault, GenerateName: "rc-", }, Spec: api.ReplicationControllerSpec{ Replicas: 2, Selector: map[string]string{"a": "b"}, Template: &validPodTemplate.Template, }, } ctx := api.NewDefaultContext() _, err := storage.Create(ctx, controller) if err != nil { t.Fatalf("unexpected error: %v", err) } if controller.Name == "rc-" || !strings.HasPrefix(controller.Name, "rc-") { t.Errorf("unexpected name: %#v", controller) } }
func TestUpdate(t *testing.T) { fakeEtcdClient, etcdStorage := newEtcdStorage(t) storage := NewStorage(etcdStorage) test := resttest.New(t, storage, fakeEtcdClient.SetError).ClusterScope() key := etcdtest.AddPrefix("securitycontextconstraints/foo") fakeEtcdClient.ExpectNotFoundGet(key) fakeEtcdClient.ChangeIndex = 2 scc := validNewSecurityContextConstraints("foo") existing := validNewSecurityContextConstraints("exists") obj, err := storage.Create(api.NewDefaultContext(), existing) if err != nil { t.Fatalf("unable to create object: %v", err) } older := obj.(*api.SecurityContextConstraints) older.ResourceVersion = "1" test.TestUpdate( scc, existing, older, ) }
func TestCreateAlreadyExists(t *testing.T) { fakeEtcdClient, helper := newHelper(t) fakeEtcdClient.TestIndex = true storage := NewREST(helper) existingImage := &api.Image{ ObjectMeta: kapi.ObjectMeta{ Name: "foo", ResourceVersion: "1", }, DockerImageReference: "foo/bar:abcd1234", } fakeEtcdClient.Data["/images/foo"] = tools.EtcdResponseWithError{ R: &etcd.Response{ Node: &etcd.Node{ Value: runtime.EncodeOrDie(latest.Codec, existingImage), CreatedIndex: 1, ModifiedIndex: 1, }, }, } _, err := storage.Create(kapi.NewDefaultContext(), &api.Image{ ObjectMeta: kapi.ObjectMeta{ Name: "foo", }, DockerImageReference: "foo/bar:abcd1234", }) if err == nil { t.Fatalf("Unexpected non error") } if !errors.IsAlreadyExists(err) { t.Errorf("Expected already exists error, got %s", err) } }
func TestCreateImageStreamSpecTagsFromSet(t *testing.T) { tests := map[string]struct { otherNamespace string sarExpected bool sarAllowed bool }{ "same namespace (blank), no sar": { otherNamespace: "", sarExpected: false, }, "same namespace (set), no sar": { otherNamespace: "default", sarExpected: false, }, "different namespace, sar allowed": { otherNamespace: "otherns", sarExpected: true, sarAllowed: true, }, "different namespace, sar denied": { otherNamespace: "otherns", sarExpected: true, sarAllowed: false, }, } for name, test := range tests { fakeEtcdClient, helper := newHelper(t) sarRegistry := &fakeSubjectAccessReviewRegistry{ allow: test.sarAllowed, } storage, _ := NewREST(helper, noDefaultRegistry, sarRegistry) otherNamespace := test.otherNamespace if len(otherNamespace) == 0 { otherNamespace = "default" } fakeEtcdClient.Data[fmt.Sprintf("/imagestreams/%s/other", otherNamespace)] = tools.EtcdResponseWithError{ R: &etcd.Response{ Node: &etcd.Node{ Value: runtime.EncodeOrDie(latest.Codec, &api.ImageStream{ ObjectMeta: kapi.ObjectMeta{Name: "other", Namespace: otherNamespace}, Status: api.ImageStreamStatus{ Tags: map[string]api.TagEventList{ "latest": { Items: []api.TagEvent{ { DockerImageReference: fmt.Sprintf("%s/other:latest", otherNamespace), }, }, }, }, }, }), ModifiedIndex: 1, }, }, } stream := &api.ImageStream{ ObjectMeta: kapi.ObjectMeta{Name: "foo"}, Spec: api.ImageStreamSpec{ Tags: map[string]api.TagReference{ "other": { From: &kapi.ObjectReference{ Kind: "ImageStreamTag", Namespace: test.otherNamespace, Name: "other:latest", }, }, }, }, } ctx := kapi.WithUser(kapi.NewDefaultContext(), &fakeUser{}) _, err := storage.Create(ctx, stream) if test.sarExpected { if sarRegistry.request == nil { t.Errorf("%s: expected sar request", name) continue } if e, a := test.sarAllowed, err == nil; e != a { t.Errorf("%s: expected sarAllowed=%t, got error %t: %v", name, e, a, err) continue } continue } // sar not expected if err != nil { t.Fatalf("%s: unexpected error: %v", name, err) } actual := &api.ImageStream{} if err := helper.Get("/imagestreams/default/foo", actual, false); err != nil { t.Fatalf("%s: unexpected extraction error: %v", name, err) } if e, a := fmt.Sprintf("%s/other:latest", otherNamespace), actual.Status.Tags["other"].Items[0].DockerImageReference; e != a { t.Errorf("%s: dockerImageReference: expected %q, got %q", name, e, a) } } }