From e240aff741ed4281640683f7bf0f70e3eaec4b66 Mon Sep 17 00:00:00 2001 From: Wojciech Tyczynski Date: Sat, 10 Sep 2016 18:35:07 +0200 Subject: [PATCH] Revert "Use scale subresource" --- pkg/client/unversioned/testclient/fixture.go | 17 +- pkg/kubectl/scale.go | 84 +++--- pkg/kubectl/scale_test.go | 268 +++++++++++++++---- pkg/kubectl/stop_test.go | 31 +-- 4 files changed, 270 insertions(+), 130 deletions(-) diff --git a/pkg/client/unversioned/testclient/fixture.go b/pkg/client/unversioned/testclient/fixture.go index f862670e6f..6149f0a8de 100644 --- a/pkg/client/unversioned/testclient/fixture.go +++ b/pkg/client/unversioned/testclient/fixture.go @@ -54,22 +54,13 @@ type ObjectScheme interface { // Object or error that matches the requested action. For instance, list-replicationControllers // should attempt to return a list of replication controllers. This method delegates to the // ObjectRetriever interface to satisfy retrieval of lists or retrieval of single items. +// TODO: add support for sub resources func ObjectReaction(o ObjectRetriever, mapper meta.RESTMapper) ReactionFunc { return func(action Action) (bool, runtime.Object, error) { - var err error - var kind unversioned.GroupVersionKind - - if action.GetSubresource() != "" { - kind, err = mapper.KindFor(unversioned.GroupVersionResource{Resource: action.GetSubresource()}) - if err != nil { - return false, nil, fmt.Errorf("unrecognized subresource action %s/%s: %v", action.GetResource(), action.GetSubresource(), err) - } - } else { - kind, err = mapper.KindFor(unversioned.GroupVersionResource{Resource: action.GetResource()}) - if err != nil { - return false, nil, fmt.Errorf("unrecognized action %s: %v", action.GetResource(), err) - } + kind, err := mapper.KindFor(unversioned.GroupVersionResource{Resource: action.GetResource()}) + if err != nil { + return false, nil, fmt.Errorf("unrecognized action %s: %v", action.GetResource(), err) } // TODO: have mapper return a Kind for a subresource? diff --git a/pkg/kubectl/scale.go b/pkg/kubectl/scale.go index c34e839752..044be5706f 100644 --- a/pkg/kubectl/scale.go +++ b/pkg/kubectl/scale.go @@ -143,13 +143,13 @@ func (precondition *ScalePrecondition) ValidatePetSet(ps *apps.PetSet) error { return nil } -// ValidateScale ensures that the preconditions match. Returns nil if they are valid, an error otherwise -func (precondition *ScalePrecondition) ValidateScale(scale *extensions.Scale) error { - if precondition.Size != -1 && int(scale.Spec.Replicas) != precondition.Size { - return PreconditionError{"replicas", strconv.Itoa(precondition.Size), strconv.Itoa(int(scale.Spec.Replicas))} +// ValidateReplicationController ensures that the preconditions match. Returns nil if they are valid, an error otherwise +func (precondition *ScalePrecondition) ValidateReplicationController(controller *api.ReplicationController) error { + if precondition.Size != -1 && int(controller.Spec.Replicas) != precondition.Size { + return PreconditionError{"replicas", strconv.Itoa(precondition.Size), strconv.Itoa(int(controller.Spec.Replicas))} } - if len(precondition.ResourceVersion) != 0 && scale.ResourceVersion != precondition.ResourceVersion { - return PreconditionError{"resource version", precondition.ResourceVersion, scale.ResourceVersion} + if len(precondition.ResourceVersion) != 0 && controller.ResourceVersion != precondition.ResourceVersion { + return PreconditionError{"resource version", precondition.ResourceVersion, controller.ResourceVersion} } return nil } @@ -161,24 +161,24 @@ type ReplicationControllerScaler struct { // ScaleSimple does a simple one-shot attempt at scaling. It returns the // resourceVersion of the replication controller if the update is successful. func (scaler *ReplicationControllerScaler) ScaleSimple(namespace, name string, preconditions *ScalePrecondition, newSize uint) (string, error) { - sc := scaler.c.Extensions().Scales(namespace) - scale, err := sc.Get("ReplicationController", name) + controller, err := scaler.c.ReplicationControllers(namespace).Get(name) if err != nil { return "", ScaleError{ScaleGetFailure, "Unknown", err} } if preconditions != nil { - if err := preconditions.ValidateScale(scale); err != nil { + if err := preconditions.ValidateReplicationController(controller); err != nil { return "", err } } - scale.Spec.Replicas = int32(newSize) - if _, err := sc.Update("ReplicationController", scale); err != nil { + controller.Spec.Replicas = int32(newSize) + updatedRC, err := scaler.c.ReplicationControllers(namespace).Update(controller) + if err != nil { if errors.IsConflict(err) { - return "", ScaleError{ScaleUpdateConflictFailure, scale.ResourceVersion, err} + return "", ScaleError{ScaleUpdateConflictFailure, controller.ResourceVersion, err} } - return "", ScaleError{ScaleUpdateFailure, scale.ResourceVersion, err} + return "", ScaleError{ScaleUpdateFailure, controller.ResourceVersion, err} } - return scale.ObjectMeta.ResourceVersion, nil + return updatedRC.ObjectMeta.ResourceVersion, nil } // Scale updates a ReplicationController to a new size, with optional precondition check (if preconditions is not nil), @@ -241,6 +241,17 @@ func (scaler *ReplicationControllerScaler) Scale(namespace, name string, newSize return nil } +// ValidateReplicaSet ensures that the preconditions match. Returns nil if they are valid, an error otherwise +func (precondition *ScalePrecondition) ValidateReplicaSet(replicaSet *extensions.ReplicaSet) error { + if precondition.Size != -1 && int(replicaSet.Spec.Replicas) != precondition.Size { + return PreconditionError{"replicas", strconv.Itoa(precondition.Size), strconv.Itoa(int(replicaSet.Spec.Replicas))} + } + if len(precondition.ResourceVersion) != 0 && replicaSet.ResourceVersion != precondition.ResourceVersion { + return PreconditionError{"resource version", precondition.ResourceVersion, replicaSet.ResourceVersion} + } + return nil +} + type ReplicaSetScaler struct { c client.ExtensionsInterface } @@ -248,24 +259,24 @@ type ReplicaSetScaler struct { // ScaleSimple does a simple one-shot attempt at scaling. It returns the // resourceVersion of the replicaset if the update is successful. func (scaler *ReplicaSetScaler) ScaleSimple(namespace, name string, preconditions *ScalePrecondition, newSize uint) (string, error) { - sc := scaler.c.Scales(namespace) - scale, err := sc.Get("ReplicaSet", name) + rs, err := scaler.c.ReplicaSets(namespace).Get(name) if err != nil { return "", ScaleError{ScaleGetFailure, "Unknown", err} } if preconditions != nil { - if err := preconditions.ValidateScale(scale); err != nil { + if err := preconditions.ValidateReplicaSet(rs); err != nil { return "", err } } - scale.Spec.Replicas = int32(newSize) - if _, err := sc.Update("ReplicaSet", scale); err != nil { + rs.Spec.Replicas = int32(newSize) + updatedRS, err := scaler.c.ReplicaSets(namespace).Update(rs) + if err != nil { if errors.IsConflict(err) { - return "", ScaleError{ScaleUpdateConflictFailure, scale.ResourceVersion, err} + return "", ScaleError{ScaleUpdateConflictFailure, rs.ResourceVersion, err} } - return "", ScaleError{ScaleUpdateFailure, scale.ResourceVersion, err} + return "", ScaleError{ScaleUpdateFailure, rs.ResourceVersion, err} } - return scale.ObjectMeta.ResourceVersion, nil + return updatedRS.ObjectMeta.ResourceVersion, nil } // Scale updates a ReplicaSet to a new size, with optional precondition check (if preconditions is @@ -422,6 +433,17 @@ func (scaler *JobScaler) Scale(namespace, name string, newSize uint, preconditio return nil } +// ValidateDeployment ensures that the preconditions match. Returns nil if they are valid, an error otherwise. +func (precondition *ScalePrecondition) ValidateDeployment(deployment *extensions.Deployment) error { + if precondition.Size != -1 && int(deployment.Spec.Replicas) != precondition.Size { + return PreconditionError{"replicas", strconv.Itoa(precondition.Size), strconv.Itoa(int(deployment.Spec.Replicas))} + } + if len(precondition.ResourceVersion) != 0 && deployment.ResourceVersion != precondition.ResourceVersion { + return PreconditionError{"resource version", precondition.ResourceVersion, deployment.ResourceVersion} + } + return nil +} + type DeploymentScaler struct { c client.ExtensionsInterface } @@ -430,25 +452,27 @@ type DeploymentScaler struct { // count. It returns the resourceVersion of the deployment if the update is // successful. func (scaler *DeploymentScaler) ScaleSimple(namespace, name string, preconditions *ScalePrecondition, newSize uint) (string, error) { - sc := scaler.c.Scales(namespace) - scale, err := sc.Get("Deployment", name) + deployment, err := scaler.c.Deployments(namespace).Get(name) if err != nil { return "", ScaleError{ScaleGetFailure, "Unknown", err} } if preconditions != nil { - if err := preconditions.ValidateScale(scale); err != nil { + if err := preconditions.ValidateDeployment(deployment); err != nil { return "", err } } - scale.Spec.Replicas = int32(newSize) - if _, err := sc.Update("Deployment", scale); err != nil { + // TODO(madhusudancs): Fix this when Scale group issues are resolved (see issue #18528). + // For now I'm falling back to regular Deployment update operation. + deployment.Spec.Replicas = int32(newSize) + updatedDeployment, err := scaler.c.Deployments(namespace).Update(deployment) + if err != nil { if errors.IsConflict(err) { - return "", ScaleError{ScaleUpdateConflictFailure, scale.ResourceVersion, err} + return "", ScaleError{ScaleUpdateConflictFailure, deployment.ResourceVersion, err} } - return "", ScaleError{ScaleUpdateFailure, scale.ResourceVersion, err} + return "", ScaleError{ScaleUpdateFailure, deployment.ResourceVersion, err} } - return scale.ObjectMeta.ResourceVersion, nil + return updatedDeployment.ObjectMeta.ResourceVersion, nil } // Scale updates a deployment to a new size, with optional precondition check (if preconditions is not nil), diff --git a/pkg/kubectl/scale_test.go b/pkg/kubectl/scale_test.go index 0dc9bd3238..9306a1828e 100644 --- a/pkg/kubectl/scale_test.go +++ b/pkg/kubectl/scale_test.go @@ -28,52 +28,38 @@ import ( "k8s.io/kubernetes/pkg/client/unversioned/testclient" ) -type ErrorScales struct { - testclient.FakeScales +type ErrorReplicationControllers struct { + testclient.FakeReplicationControllers conflict bool invalid bool } -func (c *ErrorScales) Update(kind string, scale *extensions.Scale) (*extensions.Scale, error) { +func (c *ErrorReplicationControllers) Update(controller *api.ReplicationController) (*api.ReplicationController, error) { switch { case c.invalid: - return nil, kerrors.NewInvalid(api.Kind(kind), scale.Name, nil) + return nil, kerrors.NewInvalid(api.Kind(controller.Kind), controller.Name, nil) case c.conflict: - return nil, kerrors.NewConflict(api.Resource(kind), scale.Name, nil) + return nil, kerrors.NewConflict(api.Resource(controller.Kind), controller.Name, nil) } - return nil, errors.New("Scale update failure") + return nil, errors.New("Replication controller update failure") } -type ErrorExtensions struct { - testclient.FakeExperimental - conflict bool - invalid bool -} - -func (c *ErrorExtensions) Scales(namespace string) client.ScaleInterface { - return &ErrorScales{ - FakeScales: testclient.FakeScales{Fake: &c.FakeExperimental, Namespace: namespace}, - conflict: c.conflict, - invalid: c.invalid, - } -} - -type ErrorExtensionsClient struct { +type ErrorReplicationControllerClient struct { testclient.Fake conflict bool invalid bool } -func (c *ErrorExtensionsClient) Extensions() client.ExtensionsInterface { - return &ErrorExtensions{ - FakeExperimental: testclient.FakeExperimental{Fake: &c.Fake}, - conflict: c.conflict, - invalid: c.invalid, +func (c *ErrorReplicationControllerClient) ReplicationControllers(namespace string) client.ReplicationControllerInterface { + return &ErrorReplicationControllers{ + FakeReplicationControllers: testclient.FakeReplicationControllers{Fake: &c.Fake, Namespace: namespace}, + conflict: c.conflict, + invalid: c.invalid, } } func TestReplicationControllerScaleRetry(t *testing.T) { - fake := &ErrorExtensionsClient{Fake: testclient.Fake{}, conflict: true} + fake := &ErrorReplicationControllerClient{Fake: testclient.Fake{}, conflict: true} scaler := ReplicationControllerScaler{fake} preconditions := ScalePrecondition{-1, ""} count := uint(3) @@ -97,7 +83,7 @@ func TestReplicationControllerScaleRetry(t *testing.T) { } func TestReplicationControllerScaleInvalid(t *testing.T) { - fake := &ErrorExtensionsClient{Fake: testclient.Fake{}, invalid: true} + fake := &ErrorReplicationControllerClient{Fake: testclient.Fake{}, invalid: true} scaler := ReplicationControllerScaler{fake} preconditions := ScalePrecondition{-1, ""} count := uint(3) @@ -117,7 +103,7 @@ func TestReplicationControllerScaleInvalid(t *testing.T) { func TestReplicationControllerScale(t *testing.T) { fake := &testclient.Fake{} - scaler := ReplicationControllerScaler{&testclient.FakeExperimental{fake}} + scaler := ReplicationControllerScaler{fake} preconditions := ScalePrecondition{-1, ""} count := uint(3) name := "foo" @@ -127,17 +113,17 @@ func TestReplicationControllerScale(t *testing.T) { if len(actions) != 2 { t.Errorf("unexpected actions: %v, expected 2 actions (get, update)", actions) } - if action, ok := actions[0].(testclient.GetAction); !ok || action.GetResource() != "ReplicationController" || action.GetName() != name || action.GetSubresource() != "scale" { + if action, ok := actions[0].(testclient.GetAction); !ok || action.GetResource() != "replicationcontrollers" || action.GetName() != name { t.Errorf("unexpected action: %v, expected get-replicationController %s", actions[0], name) } - if action, ok := actions[1].(testclient.UpdateAction); !ok || action.GetResource() != "ReplicationController" || action.GetObject().(*extensions.Scale).Spec.Replicas != int32(count) || action.GetSubresource() != "scale" { + if action, ok := actions[1].(testclient.UpdateAction); !ok || action.GetResource() != "replicationcontrollers" || action.GetObject().(*api.ReplicationController).Spec.Replicas != int32(count) { t.Errorf("unexpected action %v, expected update-replicationController with replicas = %d", actions[1], count) } } func TestReplicationControllerScaleFailsPreconditions(t *testing.T) { - fake := testclient.NewSimpleFake(&extensions.Scale{ - Spec: extensions.ScaleSpec{ + fake := testclient.NewSimpleFake(&api.ReplicationController{ + Spec: api.ReplicationControllerSpec{ Replicas: 10, }, }) @@ -151,15 +137,15 @@ func TestReplicationControllerScaleFailsPreconditions(t *testing.T) { if len(actions) != 1 { t.Errorf("unexpected actions: %v, expected 1 action (get)", actions) } - if action, ok := actions[0].(testclient.GetAction); !ok || action.GetResource() != "ReplicationController" || action.GetName() != name || action.GetSubresource() != "scale" { + if action, ok := actions[0].(testclient.GetAction); !ok || action.GetResource() != "replicationcontrollers" || action.GetName() != name { t.Errorf("unexpected action: %v, expected get-replicationController %s", actions[0], name) } } -func TestValidateScale(t *testing.T) { +func TestValidateReplicationController(t *testing.T) { tests := []struct { preconditions ScalePrecondition - scale extensions.Scale + controller api.ReplicationController expectError bool test string }{ @@ -170,11 +156,11 @@ func TestValidateScale(t *testing.T) { }, { preconditions: ScalePrecondition{-1, ""}, - scale: extensions.Scale{ + controller: api.ReplicationController{ ObjectMeta: api.ObjectMeta{ ResourceVersion: "foo", }, - Spec: extensions.ScaleSpec{ + Spec: api.ReplicationControllerSpec{ Replicas: 10, }, }, @@ -183,11 +169,11 @@ func TestValidateScale(t *testing.T) { }, { preconditions: ScalePrecondition{0, ""}, - scale: extensions.Scale{ + controller: api.ReplicationController{ ObjectMeta: api.ObjectMeta{ ResourceVersion: "foo", }, - Spec: extensions.ScaleSpec{ + Spec: api.ReplicationControllerSpec{ Replicas: 0, }, }, @@ -196,11 +182,11 @@ func TestValidateScale(t *testing.T) { }, { preconditions: ScalePrecondition{-1, "foo"}, - scale: extensions.Scale{ + controller: api.ReplicationController{ ObjectMeta: api.ObjectMeta{ ResourceVersion: "foo", }, - Spec: extensions.ScaleSpec{ + Spec: api.ReplicationControllerSpec{ Replicas: 10, }, }, @@ -209,11 +195,11 @@ func TestValidateScale(t *testing.T) { }, { preconditions: ScalePrecondition{10, "foo"}, - scale: extensions.Scale{ + controller: api.ReplicationController{ ObjectMeta: api.ObjectMeta{ ResourceVersion: "foo", }, - Spec: extensions.ScaleSpec{ + Spec: api.ReplicationControllerSpec{ Replicas: 10, }, }, @@ -222,11 +208,11 @@ func TestValidateScale(t *testing.T) { }, { preconditions: ScalePrecondition{10, "foo"}, - scale: extensions.Scale{ + controller: api.ReplicationController{ ObjectMeta: api.ObjectMeta{ ResourceVersion: "foo", }, - Spec: extensions.ScaleSpec{ + Spec: api.ReplicationControllerSpec{ Replicas: 20, }, }, @@ -235,11 +221,11 @@ func TestValidateScale(t *testing.T) { }, { preconditions: ScalePrecondition{10, "foo"}, - scale: extensions.Scale{ + controller: api.ReplicationController{ ObjectMeta: api.ObjectMeta{ ResourceVersion: "bar", }, - Spec: extensions.ScaleSpec{ + Spec: api.ReplicationControllerSpec{ Replicas: 10, }, }, @@ -248,11 +234,11 @@ func TestValidateScale(t *testing.T) { }, { preconditions: ScalePrecondition{10, "foo"}, - scale: extensions.Scale{ + controller: api.ReplicationController{ ObjectMeta: api.ObjectMeta{ ResourceVersion: "bar", }, - Spec: extensions.ScaleSpec{ + Spec: api.ReplicationControllerSpec{ Replicas: 20, }, }, @@ -261,7 +247,7 @@ func TestValidateScale(t *testing.T) { }, } for _, test := range tests { - err := test.preconditions.ValidateScale(&test.scale) + err := test.preconditions.ValidateReplicationController(&test.controller) if err != nil && !test.expectError { t.Errorf("unexpected error: %v (%s)", err, test.test) } @@ -521,8 +507,46 @@ func TestValidateJob(t *testing.T) { } } +type ErrorDeployments struct { + testclient.FakeDeployments + conflict bool + invalid bool +} + +func (c *ErrorDeployments) Update(deployment *extensions.Deployment) (*extensions.Deployment, error) { + switch { + case c.invalid: + return nil, kerrors.NewInvalid(api.Kind(deployment.Kind), deployment.Name, nil) + case c.conflict: + return nil, kerrors.NewConflict(api.Resource(deployment.Kind), deployment.Name, nil) + } + return nil, errors.New("deployment update failure") +} + +func (c *ErrorDeployments) Get(name string) (*extensions.Deployment, error) { + return &extensions.Deployment{ + Spec: extensions.DeploymentSpec{ + Replicas: 0, + }, + }, nil +} + +type ErrorDeploymentClient struct { + testclient.FakeExperimental + conflict bool + invalid bool +} + +func (c *ErrorDeploymentClient) Deployments(namespace string) client.DeploymentInterface { + return &ErrorDeployments{ + FakeDeployments: testclient.FakeDeployments{Fake: &c.FakeExperimental, Namespace: namespace}, + invalid: c.invalid, + conflict: c.conflict, + } +} + func TestDeploymentScaleRetry(t *testing.T) { - fake := &ErrorExtensions{FakeExperimental: testclient.FakeExperimental{Fake: &testclient.Fake{}}, conflict: true} + fake := &ErrorDeploymentClient{FakeExperimental: testclient.FakeExperimental{}, conflict: true} scaler := &DeploymentScaler{fake} preconditions := &ScalePrecondition{-1, ""} count := uint(3) @@ -557,16 +581,16 @@ func TestDeploymentScale(t *testing.T) { if len(actions) != 2 { t.Errorf("unexpected actions: %v, expected 2 actions (get, update)", actions) } - if action, ok := actions[0].(testclient.GetAction); !ok || action.GetResource() != "Deployment" || action.GetName() != name || action.GetSubresource() != "scale" { - t.Errorf("unexpected action: %v, expected get-deployment %s", actions[0], name) + if action, ok := actions[0].(testclient.GetAction); !ok || action.GetResource() != "deployments" || action.GetName() != name { + t.Errorf("unexpected action: %v, expected get-replicationController %s", actions[0], name) } - if action, ok := actions[1].(testclient.UpdateAction); !ok || action.GetResource() != "Deployment" || action.GetObject().(*extensions.Scale).Spec.Replicas != int32(count) || action.GetSubresource() != "scale" { + if action, ok := actions[1].(testclient.UpdateAction); !ok || action.GetResource() != "deployments" || action.GetObject().(*extensions.Deployment).Spec.Replicas != int32(count) { t.Errorf("unexpected action %v, expected update-deployment with replicas = %d", actions[1], count) } } func TestDeploymentScaleInvalid(t *testing.T) { - fake := &ErrorExtensions{FakeExperimental: testclient.FakeExperimental{Fake: &testclient.Fake{}}, invalid: true} + fake := &ErrorDeploymentClient{FakeExperimental: testclient.FakeExperimental{}, invalid: true} scaler := DeploymentScaler{fake} preconditions := ScalePrecondition{-1, ""} count := uint(3) @@ -585,8 +609,8 @@ func TestDeploymentScaleInvalid(t *testing.T) { } func TestDeploymentScaleFailsPreconditions(t *testing.T) { - fake := testclient.NewSimpleFake(&extensions.Scale{ - Spec: extensions.ScaleSpec{ + fake := testclient.NewSimpleFake(&extensions.Deployment{ + Spec: extensions.DeploymentSpec{ Replicas: 10, }, }) @@ -600,7 +624,133 @@ func TestDeploymentScaleFailsPreconditions(t *testing.T) { if len(actions) != 1 { t.Errorf("unexpected actions: %v, expected 1 actions (get)", actions) } - if action, ok := actions[0].(testclient.GetAction); !ok || action.GetResource() != "Deployment" || action.GetName() != name || action.GetSubresource() != "scale" { + if action, ok := actions[0].(testclient.GetAction); !ok || action.GetResource() != "deployments" || action.GetName() != name { t.Errorf("unexpected action: %v, expected get-deployment %s", actions[0], name) } } + +func TestValidateDeployment(t *testing.T) { + zero, ten, twenty := int32(0), int32(10), int32(20) + tests := []struct { + preconditions ScalePrecondition + deployment extensions.Deployment + expectError bool + test string + }{ + { + preconditions: ScalePrecondition{-1, ""}, + expectError: false, + test: "defaults", + }, + { + preconditions: ScalePrecondition{-1, ""}, + deployment: extensions.Deployment{ + ObjectMeta: api.ObjectMeta{ + ResourceVersion: "foo", + }, + Spec: extensions.DeploymentSpec{ + Replicas: ten, + }, + }, + expectError: false, + test: "defaults 2", + }, + { + preconditions: ScalePrecondition{0, ""}, + deployment: extensions.Deployment{ + ObjectMeta: api.ObjectMeta{ + ResourceVersion: "foo", + }, + Spec: extensions.DeploymentSpec{ + Replicas: zero, + }, + }, + expectError: false, + test: "size matches", + }, + { + preconditions: ScalePrecondition{-1, "foo"}, + deployment: extensions.Deployment{ + ObjectMeta: api.ObjectMeta{ + ResourceVersion: "foo", + }, + Spec: extensions.DeploymentSpec{ + Replicas: ten, + }, + }, + expectError: false, + test: "resource version matches", + }, + { + preconditions: ScalePrecondition{10, "foo"}, + deployment: extensions.Deployment{ + ObjectMeta: api.ObjectMeta{ + ResourceVersion: "foo", + }, + Spec: extensions.DeploymentSpec{ + Replicas: ten, + }, + }, + expectError: false, + test: "both match", + }, + { + preconditions: ScalePrecondition{10, "foo"}, + deployment: extensions.Deployment{ + ObjectMeta: api.ObjectMeta{ + ResourceVersion: "foo", + }, + Spec: extensions.DeploymentSpec{ + Replicas: twenty, + }, + }, + expectError: true, + test: "size different", + }, + { + preconditions: ScalePrecondition{10, "foo"}, + deployment: extensions.Deployment{ + ObjectMeta: api.ObjectMeta{ + ResourceVersion: "foo", + }, + }, + expectError: true, + test: "no replicas", + }, + { + preconditions: ScalePrecondition{10, "foo"}, + deployment: extensions.Deployment{ + ObjectMeta: api.ObjectMeta{ + ResourceVersion: "bar", + }, + Spec: extensions.DeploymentSpec{ + Replicas: ten, + }, + }, + expectError: true, + test: "version different", + }, + { + preconditions: ScalePrecondition{10, "foo"}, + deployment: extensions.Deployment{ + ObjectMeta: api.ObjectMeta{ + ResourceVersion: "bar", + }, + Spec: extensions.DeploymentSpec{ + Replicas: twenty, + }, + }, + expectError: true, + test: "both different", + }, + } + for _, test := range tests { + err := test.preconditions.ValidateDeployment(&test.deployment) + if err != nil && !test.expectError { + t.Errorf("unexpected error: %v (%s)", err, test.test) + } + if err == nil && test.expectError { + t.Errorf("unexpected non-error: %v (%s)", err, test.test) + } + } +} diff --git a/pkg/kubectl/stop_test.go b/pkg/kubectl/stop_test.go index e56e465cee..9c388099e9 100644 --- a/pkg/kubectl/stop_test.go +++ b/pkg/kubectl/stop_test.go @@ -69,11 +69,6 @@ func TestReplicationControllerStop(t *testing.T) { }, }, }, - &extensions.Scale{ - Spec: extensions.ScaleSpec{ - Replicas: 0, - }, - }, }, StopError: nil, ExpectedActions: []string{"get", "list", "get", "update", "get", "delete"}, @@ -112,11 +107,6 @@ func TestReplicationControllerStop(t *testing.T) { }, }, }, - &extensions.Scale{ - Spec: extensions.ScaleSpec{ - Replicas: 0, - }, - }, }, StopError: nil, ExpectedActions: []string{"get", "list", "get", "update", "get", "delete"}, @@ -279,7 +269,7 @@ func TestReplicationControllerStop(t *testing.T) { continue } for i, verb := range test.ExpectedActions { - if actions[i].GetResource() != "replicationcontrollers" && actions[i].GetSubresource() != "scale" { + if actions[i].GetResource() != "replicationcontrollers" { t.Errorf("%s unexpected action: %+v, expected %s-replicationController", test.Name, actions[i], verb) } if actions[i].GetVerb() != verb { @@ -325,11 +315,6 @@ func TestReplicaSetStop(t *testing.T) { }, }, }, - &extensions.Scale{ - Spec: extensions.ScaleSpec{ - Replicas: 0, - }, - }, }, StopError: nil, ExpectedActions: []string{"get", "get", "update", "get", "get", "delete"}, @@ -371,11 +356,6 @@ func TestReplicaSetStop(t *testing.T) { }, }, }, - &extensions.Scale{ - Spec: extensions.ScaleSpec{ - Replicas: 0, - }, - }, }, StopError: nil, ExpectedActions: []string{"get", "get", "update", "get", "get", "delete"}, @@ -399,7 +379,7 @@ func TestReplicaSetStop(t *testing.T) { continue } for i, verb := range test.ExpectedActions { - if actions[i].GetResource() != "replicasets" && actions[i].GetSubresource() != "scale" { + if actions[i].GetResource() != "replicasets" { t.Errorf("%s unexpected action: %+v, expected %s-replicaSet", test.Name, actions[i], verb) } if actions[i].GetVerb() != verb { @@ -591,11 +571,6 @@ func TestDeploymentStop(t *testing.T) { }, }, }, - &extensions.Scale{ - Spec: extensions.ScaleSpec{ - Replicas: 0, - }, - }, }, StopError: nil, ExpectedActions: []string{"get:deployments", "update:deployments", @@ -624,7 +599,7 @@ func TestDeploymentStop(t *testing.T) { if actions[i].GetVerb() != action[0] { t.Errorf("%s unexpected verb: %+v, expected %s", test.Name, actions[i], expAction) } - if actions[i].GetResource() != action[1] && actions[i].GetSubresource() != "scale" { + if actions[i].GetResource() != action[1] { t.Errorf("%s unexpected resource: %+v, expected %s", test.Name, actions[i], expAction) } if len(action) == 3 && actions[i].GetSubresource() != action[2] {