Replace godep with dep

vendor/k8s.io/kubernetes/test/integration/deployment/BUILD

@@ -0,0 +1,57 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+    "go_test",
+)
+
+go_test(
+    name = "go_default_test",
+    size = "large",
+    srcs = [
+        "deployment_test.go",
+        "main_test.go",
+    ],
+    library = ":go_default_library",
+    deps = [
+        "//pkg/controller/deployment/util:go_default_library",
+        "//test/integration/framework:go_default_library",
+        "//vendor/k8s.io/api/core/v1:go_default_library",
+        "//vendor/k8s.io/api/extensions/v1beta1:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",
+    ],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["util.go"],
+    deps = [
+        "//pkg/api/v1/pod:go_default_library",
+        "//pkg/controller/deployment:go_default_library",
+        "//pkg/controller/deployment/util:go_default_library",
+        "//pkg/controller/replicaset:go_default_library",
+        "//test/integration/framework:go_default_library",
+        "//test/utils:go_default_library",
+        "//vendor/k8s.io/api/core/v1:go_default_library",
+        "//vendor/k8s.io/api/extensions/v1beta1:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/util/wait:go_default_library",
+        "//vendor/k8s.io/client-go/informers:go_default_library",
+        "//vendor/k8s.io/client-go/kubernetes:go_default_library",
+        "//vendor/k8s.io/client-go/rest:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+)

vendor/k8s.io/kubernetes/test/integration/deployment/OWNERS

@@ -0,0 +1,7 @@
+reviewers:
+  - janetkuo
+  - kargakis
+  - tnozicka
+approvers:
+  - janetkuo
+  - kargakis

vendor/k8s.io/kubernetes/test/integration/deployment/deployment_test.go

@@ -0,0 +1,321 @@
+/*
+Copyright 2017 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package deployment
+
+import (
+	"reflect"
+	"strings"
+	"testing"
+
+	"k8s.io/api/core/v1"
+	"k8s.io/api/extensions/v1beta1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	deploymentutil "k8s.io/kubernetes/pkg/controller/deployment/util"
+	"k8s.io/kubernetes/test/integration/framework"
+)
+
+func TestNewDeployment(t *testing.T) {
+	s, closeFn, rm, dc, informers, c := dcSetup(t)
+	defer closeFn()
+	name := "test-new-deployment"
+	ns := framework.CreateTestingNamespace(name, s, t)
+	defer framework.DeleteTestingNamespace(ns, s, t)
+
+	replicas := int32(20)
+	tester := &deploymentTester{t: t, c: c, deployment: newDeployment(name, ns.Name, replicas)}
+	tester.deployment.Spec.MinReadySeconds = 4
+
+	tester.deployment.Annotations = map[string]string{"test": "should-copy-to-replica-set", v1.LastAppliedConfigAnnotation: "should-not-copy-to-replica-set"}
+	var err error
+	tester.deployment, err = c.ExtensionsV1beta1().Deployments(ns.Name).Create(tester.deployment)
+	if err != nil {
+		t.Fatalf("failed to create deployment %s: %v", tester.deployment.Name, err)
+	}
+
+	// Start informer and controllers
+	stopCh := make(chan struct{})
+	defer close(stopCh)
+	informers.Start(stopCh)
+	go rm.Run(5, stopCh)
+	go dc.Run(5, stopCh)
+
+	// Wait for the Deployment to be updated to revision 1
+	if err := tester.waitForDeploymentRevisionAndImage("1", fakeImage); err != nil {
+		t.Fatal(err)
+	}
+
+	// Make sure the Deployment status becomes valid while manually marking Deployment pods as ready at the same time
+	if err := tester.waitForDeploymentStatusValidAndMarkPodsReady(); err != nil {
+		t.Fatal(err)
+	}
+
+	// Check new RS annotations
+	newRS, err := tester.expectNewReplicaSet()
+	if err != nil {
+		t.Fatal(err)
+	}
+	if newRS.Annotations["test"] != "should-copy-to-replica-set" {
+		t.Errorf("expected new ReplicaSet annotations copied from Deployment %s, got: %v", tester.deployment.Name, newRS.Annotations)
+	}
+	if newRS.Annotations[v1.LastAppliedConfigAnnotation] != "" {
+		t.Errorf("expected new ReplicaSet last-applied annotation not copied from Deployment %s", tester.deployment.Name)
+	}
+}
+
+// selectors are IMMUTABLE for all API versions except apps/v1beta1 and extensions/v1beta1
+func TestDeploymentSelectorImmutability(t *testing.T) {
+	s, closeFn, c := dcSimpleSetup(t)
+	defer closeFn()
+	name := "test-deployment-selector-immutability"
+	ns := framework.CreateTestingNamespace(name, s, t)
+	defer framework.DeleteTestingNamespace(ns, s, t)
+
+	tester := &deploymentTester{t: t, c: c, deployment: newDeployment(name, ns.Name, int32(20))}
+	deploymentExtensionsV1beta1, err := c.ExtensionsV1beta1().Deployments(ns.Name).Create(tester.deployment)
+	if err != nil {
+		t.Fatalf("failed to create extensions/v1beta1 deployment %s: %v", tester.deployment.Name, err)
+	}
+
+	// test to ensure extensions/v1beta1 selector is mutable
+	newSelectorLabels := map[string]string{"name_extensions_v1beta1": "test_extensions_v1beta1"}
+	deploymentExtensionsV1beta1.Spec.Selector.MatchLabels = newSelectorLabels
+	deploymentExtensionsV1beta1.Spec.Template.Labels = newSelectorLabels
+	updatedDeploymentExtensionsV1beta1, err := c.ExtensionsV1beta1().Deployments(ns.Name).Update(deploymentExtensionsV1beta1)
+	if err != nil {
+		t.Fatalf("failed to update extensions/v1beta1 deployment %s: %v", deploymentExtensionsV1beta1.Name, err)
+	}
+	if !reflect.DeepEqual(updatedDeploymentExtensionsV1beta1.Spec.Selector.MatchLabels, newSelectorLabels) {
+		t.Errorf("selector should be changed for extensions/v1beta1, expected: %v, got: %v", newSelectorLabels, updatedDeploymentExtensionsV1beta1.Spec.Selector.MatchLabels)
+	}
+
+	// test to ensure apps/v1beta1 selector is mutable
+	deploymentAppsV1beta1, err := c.AppsV1beta1().Deployments(ns.Name).Get(updatedDeploymentExtensionsV1beta1.Name, metav1.GetOptions{})
+	if err != nil {
+		t.Fatalf("failed to get apps/v1beta1 deployment %s: %v", updatedDeploymentExtensionsV1beta1.Name, err)
+	}
+
+	newSelectorLabels = map[string]string{"name_apps_v1beta1": "test_apps_v1beta1"}
+	deploymentAppsV1beta1.Spec.Selector.MatchLabels = newSelectorLabels
+	deploymentAppsV1beta1.Spec.Template.Labels = newSelectorLabels
+	updatedDeploymentAppsV1beta1, err := c.AppsV1beta1().Deployments(ns.Name).Update(deploymentAppsV1beta1)
+	if err != nil {
+		t.Fatalf("failed to update apps/v1beta1 deployment %s: %v", deploymentAppsV1beta1.Name, err)
+	}
+	if !reflect.DeepEqual(updatedDeploymentAppsV1beta1.Spec.Selector.MatchLabels, newSelectorLabels) {
+		t.Errorf("selector should be changed for apps/v1beta1, expected: %v, got: %v", newSelectorLabels, updatedDeploymentAppsV1beta1.Spec.Selector.MatchLabels)
+	}
+
+	// test to ensure apps/v1beta2 selector is immutable
+	deploymentAppsV1beta2, err := c.AppsV1beta2().Deployments(ns.Name).Get(updatedDeploymentAppsV1beta1.Name, metav1.GetOptions{})
+	if err != nil {
+		t.Fatalf("failed to get apps/v1beta2 deployment %s: %v", updatedDeploymentAppsV1beta1.Name, err)
+	}
+	newSelectorLabels = map[string]string{"name_apps_v1beta2": "test_apps_v1beta2"}
+	deploymentAppsV1beta2.Spec.Selector.MatchLabels = newSelectorLabels
+	deploymentAppsV1beta2.Spec.Template.Labels = newSelectorLabels
+	_, err = c.AppsV1beta2().Deployments(ns.Name).Update(deploymentAppsV1beta2)
+	if err == nil {
+		t.Fatalf("failed to provide validation error when changing immutable selector when updating apps/v1beta2 deployment %s", deploymentAppsV1beta2.Name)
+	}
+	expectedErrType := "Invalid value"
+	expectedErrDetail := "field is immutable"
+	if !strings.Contains(err.Error(), expectedErrType) || !strings.Contains(err.Error(), expectedErrDetail) {
+		t.Errorf("error message does not match, expected type: %s, expected detail: %s, got: %s", expectedErrType, expectedErrDetail, err.Error())
+	}
+}
+
+// Paused deployment should not start new rollout
+func TestPausedDeployment(t *testing.T) {
+	s, closeFn, rm, dc, informers, c := dcSetup(t)
+	defer closeFn()
+	name := "test-paused-deployment"
+	ns := framework.CreateTestingNamespace(name, s, t)
+	defer framework.DeleteTestingNamespace(ns, s, t)
+
+	replicas := int32(1)
+	tester := &deploymentTester{t: t, c: c, deployment: newDeployment(name, ns.Name, replicas)}
+	tester.deployment.Spec.Paused = true
+	tgps := int64(1)
+	tester.deployment.Spec.Template.Spec.TerminationGracePeriodSeconds = &tgps
+
+	var err error
+	tester.deployment, err = c.ExtensionsV1beta1().Deployments(ns.Name).Create(tester.deployment)
+	if err != nil {
+		t.Fatalf("failed to create deployment %s: %v", tester.deployment.Name, err)
+	}
+
+	// Start informer and controllers
+	stopCh := make(chan struct{})
+	defer close(stopCh)
+	informers.Start(stopCh)
+	go rm.Run(5, stopCh)
+	go dc.Run(5, stopCh)
+
+	// Verify that the paused deployment won't create new replica set.
+	if err := tester.expectNoNewReplicaSet(); err != nil {
+		t.Fatal(err)
+	}
+
+	// Resume the deployment
+	tester.deployment, err = tester.updateDeployment(resumeFn())
+	if err != nil {
+		t.Fatalf("failed to resume deployment %s: %v", tester.deployment.Name, err)
+	}
+
+	// Wait for the controller to notice the resume.
+	if err := tester.waitForObservedDeployment(tester.deployment.Generation); err != nil {
+		t.Fatal(err)
+	}
+
+	// Wait for the Deployment to be updated to revision 1
+	if err := tester.waitForDeploymentRevisionAndImage("1", fakeImage); err != nil {
+		t.Fatal(err)
+	}
+
+	// Make sure the Deployment status becomes valid while manually marking Deployment pods as ready at the same time
+	if err := tester.waitForDeploymentStatusValidAndMarkPodsReady(); err != nil {
+		t.Fatal(err)
+	}
+
+	// A new replicaset should be created.
+	if _, err := tester.expectNewReplicaSet(); err != nil {
+		t.Fatal(err)
+	}
+
+	// Pause the deployment.
+	// The paused deployment shouldn't trigger a new rollout.
+	tester.deployment, err = tester.updateDeployment(pauseFn())
+	if err != nil {
+		t.Fatalf("failed to pause deployment %s: %v", tester.deployment.Name, err)
+	}
+
+	// Wait for the controller to notice the pause.
+	if err := tester.waitForObservedDeployment(tester.deployment.Generation); err != nil {
+		t.Fatal(err)
+	}
+
+	// Update the deployment template
+	newTGPS := int64(0)
+	tester.deployment, err = tester.updateDeployment(func(update *v1beta1.Deployment) {
+		update.Spec.Template.Spec.TerminationGracePeriodSeconds = &newTGPS
+	})
+	if err != nil {
+		t.Fatalf("failed updating template of deployment %s: %v", tester.deployment.Name, err)
+	}
+
+	// Wait for the controller to notice the rollout.
+	if err := tester.waitForObservedDeployment(tester.deployment.Generation); err != nil {
+		t.Fatal(err)
+	}
+
+	// Verify that the paused deployment won't create new replica set.
+	if err := tester.expectNoNewReplicaSet(); err != nil {
+		t.Fatal(err)
+	}
+
+	_, allOldRs, err := deploymentutil.GetOldReplicaSets(tester.deployment, c.ExtensionsV1beta1())
+	if err != nil {
+		t.Fatalf("failed retrieving old replicasets of deployment %s: %v", tester.deployment.Name, err)
+	}
+	if len(allOldRs) != 1 {
+		t.Errorf("expected an old replica set, got %v", allOldRs)
+	}
+	if *allOldRs[0].Spec.Template.Spec.TerminationGracePeriodSeconds == newTGPS {
+		t.Errorf("TerminationGracePeriodSeconds on the replica set should be %d, got %d", tgps, newTGPS)
+	}
+}
+
+// Paused deployment can be scaled
+func TestScalePausedDeployment(t *testing.T) {
+	s, closeFn, rm, dc, informers, c := dcSetup(t)
+	defer closeFn()
+	name := "test-scale-paused-deployment"
+	ns := framework.CreateTestingNamespace(name, s, t)
+	defer framework.DeleteTestingNamespace(ns, s, t)
+
+	replicas := int32(1)
+	tester := &deploymentTester{t: t, c: c, deployment: newDeployment(name, ns.Name, replicas)}
+	tgps := int64(1)
+	tester.deployment.Spec.Template.Spec.TerminationGracePeriodSeconds = &tgps
+
+	var err error
+	tester.deployment, err = c.ExtensionsV1beta1().Deployments(ns.Name).Create(tester.deployment)
+	if err != nil {
+		t.Fatalf("failed to create deployment %s: %v", tester.deployment.Name, err)
+	}
+
+	// Start informer and controllers
+	stopCh := make(chan struct{})
+	defer close(stopCh)
+	informers.Start(stopCh)
+	go rm.Run(5, stopCh)
+	go dc.Run(5, stopCh)
+
+	// Wait for the Deployment to be updated to revision 1
+	if err := tester.waitForDeploymentRevisionAndImage("1", fakeImage); err != nil {
+		t.Fatal(err)
+	}
+
+	// Make sure the Deployment status becomes valid while manually marking Deployment pods as ready at the same time
+	if err := tester.waitForDeploymentStatusValidAndMarkPodsReady(); err != nil {
+		t.Fatal(err)
+	}
+
+	// A new replicaset should be created.
+	if _, err := tester.expectNewReplicaSet(); err != nil {
+		t.Fatal(err)
+	}
+
+	// Pause the deployment.
+	tester.deployment, err = tester.updateDeployment(pauseFn())
+	if err != nil {
+		t.Fatalf("failed to pause deployment %s: %v", tester.deployment.Name, err)
+	}
+
+	// Wait for the controller to notice the scale.
+	if err := tester.waitForObservedDeployment(tester.deployment.Generation); err != nil {
+		t.Fatal(err)
+	}
+
+	// Scale the paused deployment.
+	newReplicas := int32(10)
+	tester.deployment, err = tester.updateDeployment(func(update *v1beta1.Deployment) {
+		update.Spec.Replicas = &newReplicas
+	})
+	if err != nil {
+		t.Fatalf("failed updating deployment %s: %v", tester.deployment.Name, err)
+	}
+
+	// Wait for the controller to notice the scale.
+	if err := tester.waitForObservedDeployment(tester.deployment.Generation); err != nil {
+		t.Fatal(err)
+	}
+
+	// Verify that the new replicaset is scaled.
+	rs, err := tester.expectNewReplicaSet()
+	if err != nil {
+		t.Fatal(err)
+	}
+	if *rs.Spec.Replicas != newReplicas {
+		t.Errorf("expected new replicaset replicas = %d, got %d", newReplicas, *rs.Spec.Replicas)
+	}
+
+	// Make sure the Deployment status becomes valid while manually marking Deployment pods as ready at the same time
+	if err := tester.waitForDeploymentStatusValidAndMarkPodsReady(); err != nil {
+		t.Fatal(err)
+	}
+}

vendor/k8s.io/kubernetes/test/integration/deployment/main_test.go

@@ -0,0 +1,27 @@
+/*
+Copyright 2017 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package deployment
+
+import (
+	"testing"
+
+	"k8s.io/kubernetes/test/integration/framework"
+)
+
+func TestMain(m *testing.M) {
+	framework.EtcdMain(m.Run)
+}

vendor/k8s.io/kubernetes/test/integration/deployment/util.go

@@ -0,0 +1,262 @@
+/*
+Copyright 2017 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package deployment
+
+import (
+	"fmt"
+	"net/http/httptest"
+	"testing"
+	"time"
+
+	"k8s.io/api/core/v1"
+	"k8s.io/api/extensions/v1beta1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/util/wait"
+	"k8s.io/client-go/informers"
+	clientset "k8s.io/client-go/kubernetes"
+	restclient "k8s.io/client-go/rest"
+	podutil "k8s.io/kubernetes/pkg/api/v1/pod"
+	"k8s.io/kubernetes/pkg/controller/deployment"
+	deploymentutil "k8s.io/kubernetes/pkg/controller/deployment/util"
+	"k8s.io/kubernetes/pkg/controller/replicaset"
+	"k8s.io/kubernetes/test/integration/framework"
+	testutil "k8s.io/kubernetes/test/utils"
+)
+
+const (
+	pollInterval = 1 * time.Second
+	pollTimeout  = 60 * time.Second
+
+	fakeImageName = "fake-name"
+	fakeImage     = "fakeimage"
+)
+
+type deploymentTester struct {
+	t          *testing.T
+	c          clientset.Interface
+	deployment *v1beta1.Deployment
+}
+
+func testLabels() map[string]string {
+	return map[string]string{"name": "test"}
+}
+
+// newDeployment returns a RollingUpdate Deployment with with a fake container image
+func newDeployment(name, ns string, replicas int32) *v1beta1.Deployment {
+	return &v1beta1.Deployment{
+		TypeMeta: metav1.TypeMeta{
+			Kind:       "Deployment",
+			APIVersion: "extensions/v1beta1",
+		},
+		ObjectMeta: metav1.ObjectMeta{
+			Namespace: ns,
+			Name:      name,
+		},
+		Spec: v1beta1.DeploymentSpec{
+			Replicas: &replicas,
+			Selector: &metav1.LabelSelector{MatchLabels: testLabels()},
+			Strategy: v1beta1.DeploymentStrategy{
+				Type: v1beta1.RollingUpdateDeploymentStrategyType,
+			},
+			Template: v1.PodTemplateSpec{
+				ObjectMeta: metav1.ObjectMeta{
+					Labels: testLabels(),
+				},
+				Spec: v1.PodSpec{
+					Containers: []v1.Container{
+						{
+							Name:  fakeImageName,
+							Image: fakeImage,
+						},
+					},
+				},
+			},
+		},
+	}
+}
+
+// dcSetup sets up necessities for Deployment integration test, including master, apiserver, informers, and clientset
+func dcSetup(t *testing.T) (*httptest.Server, framework.CloseFunc, *replicaset.ReplicaSetController, *deployment.DeploymentController, informers.SharedInformerFactory, clientset.Interface) {
+	masterConfig := framework.NewIntegrationTestMasterConfig()
+	_, s, closeFn := framework.RunAMaster(masterConfig)
+
+	config := restclient.Config{Host: s.URL}
+	clientSet, err := clientset.NewForConfig(&config)
+	if err != nil {
+		t.Fatalf("error in create clientset: %v", err)
+	}
+	resyncPeriod := 12 * time.Hour
+	informers := informers.NewSharedInformerFactory(clientset.NewForConfigOrDie(restclient.AddUserAgent(&config, "deployment-informers")), resyncPeriod)
+
+	dc := deployment.NewDeploymentController(
+		informers.Extensions().V1beta1().Deployments(),
+		informers.Extensions().V1beta1().ReplicaSets(),
+		informers.Core().V1().Pods(),
+		clientset.NewForConfigOrDie(restclient.AddUserAgent(&config, "deployment-controller")),
+	)
+	rm := replicaset.NewReplicaSetController(
+		informers.Extensions().V1beta1().ReplicaSets(),
+		informers.Core().V1().Pods(),
+		clientset.NewForConfigOrDie(restclient.AddUserAgent(&config, "replicaset-controller")),
+		replicaset.BurstReplicas,
+	)
+	return s, closeFn, rm, dc, informers, clientSet
+}
+
+// dcSimpleSetup sets up necessities for Deployment integration test, including master, apiserver,
+// and clientset, but not controllers and informers
+func dcSimpleSetup(t *testing.T) (*httptest.Server, framework.CloseFunc, clientset.Interface) {
+	masterConfig := framework.NewIntegrationTestMasterConfig()
+	_, s, closeFn := framework.RunAMaster(masterConfig)
+
+	config := restclient.Config{Host: s.URL}
+	clientSet, err := clientset.NewForConfig(&config)
+	if err != nil {
+		t.Fatalf("error in create clientset: %v", err)
+	}
+	return s, closeFn, clientSet
+}
+
+// addPodConditionReady sets given pod status to ready at given time
+func addPodConditionReady(pod *v1.Pod, time metav1.Time) {
+	pod.Status = v1.PodStatus{
+		Phase: v1.PodRunning,
+		Conditions: []v1.PodCondition{
+			{
+				Type:               v1.PodReady,
+				Status:             v1.ConditionTrue,
+				LastTransitionTime: time,
+			},
+		},
+	}
+}
+
+func (d *deploymentTester) waitForDeploymentRevisionAndImage(revision, image string) error {
+	if err := testutil.WaitForDeploymentRevisionAndImage(d.c, d.deployment.Namespace, d.deployment.Name, revision, image, d.t.Logf, pollInterval, pollTimeout); err != nil {
+		return fmt.Errorf("failed to wait for Deployment revision %s: %v", d.deployment.Name, err)
+	}
+	return nil
+}
+
+// markAllPodsReady manually updates all Deployment pods status to ready
+func (d *deploymentTester) markAllPodsReady() {
+	ns := d.deployment.Namespace
+	selector, err := metav1.LabelSelectorAsSelector(d.deployment.Spec.Selector)
+	if err != nil {
+		d.t.Fatalf("failed to parse Deployment selector: %v", err)
+	}
+	var readyPods int32
+	err = wait.Poll(100*time.Millisecond, pollTimeout, func() (bool, error) {
+		readyPods = 0
+		pods, err := d.c.Core().Pods(ns).List(metav1.ListOptions{LabelSelector: selector.String()})
+		if err != nil {
+			d.t.Logf("failed to list Deployment pods, will retry later: %v", err)
+			return false, nil
+		}
+		for i := range pods.Items {
+			pod := pods.Items[i]
+			if podutil.IsPodReady(&pod) {
+				readyPods++
+				continue
+			}
+			addPodConditionReady(&pod, metav1.Now())
+			if _, err = d.c.Core().Pods(ns).UpdateStatus(&pod); err != nil {
+				d.t.Logf("failed to update Deployment pod %s, will retry later: %v", pod.Name, err)
+			} else {
+				readyPods++
+			}
+		}
+		if readyPods >= *d.deployment.Spec.Replicas {
+			return true, nil
+		}
+		return false, nil
+	})
+	if err != nil {
+		d.t.Fatalf("failed to mark all Deployment pods to ready: %v", err)
+	}
+}
+
+func (d *deploymentTester) waitForDeploymentStatusValid() error {
+	return testutil.WaitForDeploymentStatusValid(d.c, d.deployment, d.t.Logf, pollInterval, pollTimeout)
+}
+
+// waitForDeploymentStatusValidAndMarkPodsReady waits for the Deployment status to become valid
+// while marking all Deployment pods as ready at the same time.
+func (d *deploymentTester) waitForDeploymentStatusValidAndMarkPodsReady() error {
+	// Manually mark all Deployment pods as ready in a separate goroutine
+	go d.markAllPodsReady()
+
+	// Make sure the Deployment status is valid while Deployment pods are becoming ready
+	err := d.waitForDeploymentStatusValid()
+	if err != nil {
+		return fmt.Errorf("failed to wait for Deployment status %s: %v", d.deployment.Name, err)
+	}
+	return nil
+}
+
+func (d *deploymentTester) updateDeployment(applyUpdate testutil.UpdateDeploymentFunc) (*v1beta1.Deployment, error) {
+	return testutil.UpdateDeploymentWithRetries(d.c, d.deployment.Namespace, d.deployment.Name, applyUpdate, d.t.Logf)
+}
+
+func (d *deploymentTester) waitForObservedDeployment(desiredGeneration int64) error {
+	if err := testutil.WaitForObservedDeployment(d.c, d.deployment.Namespace, d.deployment.Name, desiredGeneration); err != nil {
+		return fmt.Errorf("failed waiting for ObservedGeneration of deployment %s to become %d: %v", d.deployment.Name, desiredGeneration, err)
+	}
+	return nil
+}
+
+func (d *deploymentTester) getNewReplicaSet() (*v1beta1.ReplicaSet, error) {
+	rs, err := deploymentutil.GetNewReplicaSet(d.deployment, d.c.ExtensionsV1beta1())
+	if err != nil {
+		return nil, fmt.Errorf("failed retrieving new replicaset of deployment %s: %v", d.deployment.Name, err)
+	}
+	return rs, nil
+}
+
+func (d *deploymentTester) expectNoNewReplicaSet() error {
+	rs, err := d.getNewReplicaSet()
+	if err != nil {
+		return err
+	}
+	if rs != nil {
+		return fmt.Errorf("expected deployment %s not to create a new replicaset, got %v", d.deployment.Name, rs)
+	}
+	return nil
+}
+
+func (d *deploymentTester) expectNewReplicaSet() (*v1beta1.ReplicaSet, error) {
+	rs, err := d.getNewReplicaSet()
+	if err != nil {
+		return nil, err
+	}
+	if rs == nil {
+		return nil, fmt.Errorf("expected deployment %s to create a new replicaset, got nil", d.deployment.Name)
+	}
+	return rs, nil
+}
+
+func pauseFn() func(update *v1beta1.Deployment) {
+	return func(update *v1beta1.Deployment) {
+		update.Spec.Paused = true
+	}
+}
+
+func resumeFn() func(update *v1beta1.Deployment) {
+	return func(update *v1beta1.Deployment) {
+		update.Spec.Paused = false
+	}
+}