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