feat: graduate ScheduleDaemonSetPods to GA

test/integration/daemonset/BUILD

@@ -18,7 +18,6 @@ go_test(
         "//pkg/api/v1/pod:go_default_library",
         "//pkg/controller:go_default_library",
         "//pkg/controller/daemon:go_default_library",
-        "//pkg/features:go_default_library",
         "//pkg/scheduler:go_default_library",
         "//pkg/scheduler/algorithmprovider:go_default_library",
         "//pkg/scheduler/api:go_default_library",
@@ -32,7 +31,6 @@ go_test(
         "//staging/src/k8s.io/apimachinery/pkg/util/intstr:go_default_library",
         "//staging/src/k8s.io/apimachinery/pkg/util/uuid:go_default_library",
         "//staging/src/k8s.io/apimachinery/pkg/util/wait:go_default_library",
-        "//staging/src/k8s.io/apiserver/pkg/util/feature:go_default_library",
         "//staging/src/k8s.io/client-go/informers:go_default_library",
         "//staging/src/k8s.io/client-go/kubernetes:go_default_library",
         "//staging/src/k8s.io/client-go/kubernetes/typed/apps/v1:go_default_library",
@@ -42,8 +40,6 @@ go_test(
         "//staging/src/k8s.io/client-go/tools/events:go_default_library",
         "//staging/src/k8s.io/client-go/util/flowcontrol:go_default_library",
         "//staging/src/k8s.io/client-go/util/retry:go_default_library",
-        "//staging/src/k8s.io/component-base/featuregate:go_default_library",
-        "//staging/src/k8s.io/component-base/featuregate/testing:go_default_library",
         "//test/integration/framework:go_default_library",
     ],
 )

test/integration/daemonset/daemonset_test.go

@@ -31,7 +31,6 @@ import (
 	"k8s.io/apimachinery/pkg/util/intstr"
 	"k8s.io/apimachinery/pkg/util/uuid"
 	"k8s.io/apimachinery/pkg/util/wait"
-	utilfeature "k8s.io/apiserver/pkg/util/feature"
 	"k8s.io/client-go/informers"
 	clientset "k8s.io/client-go/kubernetes"
 	appstyped "k8s.io/client-go/kubernetes/typed/apps/v1"
@@ -41,13 +40,10 @@ import (
 	"k8s.io/client-go/tools/events"
 	"k8s.io/client-go/util/flowcontrol"
 	"k8s.io/client-go/util/retry"
-	"k8s.io/component-base/featuregate"
-	featuregatetesting "k8s.io/component-base/featuregate/testing"
 	"k8s.io/kubernetes/pkg/api/legacyscheme"
 	podutil "k8s.io/kubernetes/pkg/api/v1/pod"
 	"k8s.io/kubernetes/pkg/controller"
 	"k8s.io/kubernetes/pkg/controller/daemon"
-	"k8s.io/kubernetes/pkg/features"
 	"k8s.io/kubernetes/pkg/scheduler"
 	"k8s.io/kubernetes/pkg/scheduler/algorithmprovider"
 	schedulerapi "k8s.io/kubernetes/pkg/scheduler/api"
@@ -90,12 +86,6 @@ func setupScheduler(
 	cs clientset.Interface,
 	informerFactory informers.SharedInformerFactory,
 ) (restoreFeatureGates func()) {
-	restoreFeatureGates = func() {}
-	// If ScheduleDaemonSetPods is disabled, do not start scheduler.
-	if !utilfeature.DefaultFeatureGate.Enabled(features.ScheduleDaemonSetPods) {
-		return
-	}
-
 	// Enable Features.
 	restoreFeatureGates = algorithmprovider.ApplyFeatureGates()
 
@@ -221,12 +211,6 @@ func updateStrategies() []*apps.DaemonSetUpdateStrategy {
 	return []*apps.DaemonSetUpdateStrategy{newOnDeleteStrategy(), newRollbackStrategy()}
 }
 
-func featureGates() []featuregate.Feature {
-	return []featuregate.Feature{
-		features.ScheduleDaemonSetPods,
-	}
-}
-
 func allocatableResources(memory, cpu string) v1.ResourceList {
 	return v1.ResourceList{
 		v1.ResourceMemory: resource.MustParse(memory),
@@ -427,31 +411,6 @@ func validateDaemonSetStatus(
 	}
 }
 
-func validateFailedPlacementEvent(eventClient corev1client.EventInterface, t *testing.T) {
-	if err := wait.Poll(5*time.Second, 60*time.Second, func() (bool, error) {
-		eventList, err := eventClient.List(metav1.ListOptions{})
-		if err != nil {
-			return false, err
-		}
-		if len(eventList.Items) == 0 {
-			return false, nil
-		}
-		if len(eventList.Items) > 1 {
-			t.Errorf("Expected 1 event got %d", len(eventList.Items))
-		}
-		event := eventList.Items[0]
-		if event.Type != v1.EventTypeWarning {
-			t.Errorf("Event type expected %s got %s", v1.EventTypeWarning, event.Type)
-		}
-		if event.Reason != daemon.FailedPlacementReason {
-			t.Errorf("Event reason expected %s got %s", daemon.FailedPlacementReason, event.Reason)
-		}
-		return true, nil
-	}); err != nil {
-		t.Fatal(err)
-	}
-}
-
 func updateDS(t *testing.T, dsClient appstyped.DaemonSetInterface, dsName string, updateFunc func(*apps.DaemonSet)) *apps.DaemonSet {
 	var ds *apps.DaemonSet
 	if err := retry.RetryOnConflict(retry.DefaultBackoff, func() error {
@@ -468,17 +427,6 @@ func updateDS(t *testing.T, dsClient appstyped.DaemonSetInterface, dsName string
 	return ds
 }
 
-func forEachFeatureGate(t *testing.T, tf func(t *testing.T)) {
-	for _, fg := range featureGates() {
-		for _, f := range []bool{true, false} {
-			func() {
-				defer featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, fg, f)()
-				t.Run(fmt.Sprintf("%v (%t)", fg, f), tf)
-			}()
-		}
-	}
-}
-
 func forEachStrategy(t *testing.T, tf func(t *testing.T, strategy *apps.DaemonSetUpdateStrategy)) {
 	for _, strategy := range updateStrategies() {
 		t.Run(fmt.Sprintf("%s (%v)", t.Name(), strategy),
@@ -487,152 +435,146 @@ func forEachStrategy(t *testing.T, tf func(t *testing.T, strategy *apps.DaemonSe
 }
 
 func TestOneNodeDaemonLaunchesPod(t *testing.T) {
-	forEachFeatureGate(t, func(t *testing.T) {
-		forEachStrategy(t, func(t *testing.T, strategy *apps.DaemonSetUpdateStrategy) {
-			server, closeFn, dc, informers, clientset := setup(t)
-			defer closeFn()
-			ns := framework.CreateTestingNamespace("one-node-daemonset-test", server, t)
-			defer framework.DeleteTestingNamespace(ns, server, t)
+	forEachStrategy(t, func(t *testing.T, strategy *apps.DaemonSetUpdateStrategy) {
+		server, closeFn, dc, informers, clientset := setup(t)
+		defer closeFn()
+		ns := framework.CreateTestingNamespace("one-node-daemonset-test", server, t)
+		defer framework.DeleteTestingNamespace(ns, server, t)
 
-			dsClient := clientset.AppsV1().DaemonSets(ns.Name)
-			podClient := clientset.CoreV1().Pods(ns.Name)
-			nodeClient := clientset.CoreV1().Nodes()
-			podInformer := informers.Core().V1().Pods().Informer()
+		dsClient := clientset.AppsV1().DaemonSets(ns.Name)
+		podClient := clientset.CoreV1().Pods(ns.Name)
+		nodeClient := clientset.CoreV1().Nodes()
+		podInformer := informers.Core().V1().Pods().Informer()
 
-			ctx, cancel := context.WithCancel(context.Background())
-			defer cancel()
+		ctx, cancel := context.WithCancel(context.Background())
+		defer cancel()
 
-			// Start Scheduler
-			defer setupScheduler(ctx, t, clientset, informers)()
+		// Start Scheduler
+		defer setupScheduler(ctx, t, clientset, informers)()
 
-			informers.Start(ctx.Done())
-			go dc.Run(5, ctx.Done())
+		informers.Start(ctx.Done())
+		go dc.Run(5, ctx.Done())
 
-			ds := newDaemonSet("foo", ns.Name)
-			ds.Spec.UpdateStrategy = *strategy
-			_, err := dsClient.Create(ds)
-			if err != nil {
-				t.Fatalf("Failed to create DaemonSet: %v", err)
-			}
-			defer cleanupDaemonSets(t, clientset, ds)
+		ds := newDaemonSet("foo", ns.Name)
+		ds.Spec.UpdateStrategy = *strategy
+		_, err := dsClient.Create(ds)
+		if err != nil {
+			t.Fatalf("Failed to create DaemonSet: %v", err)
+		}
+		defer cleanupDaemonSets(t, clientset, ds)
 
-			_, err = nodeClient.Create(newNode("single-node", nil))
-			if err != nil {
-				t.Fatalf("Failed to create node: %v", err)
-			}
+		_, err = nodeClient.Create(newNode("single-node", nil))
+		if err != nil {
+			t.Fatalf("Failed to create node: %v", err)
+		}
 
-			validateDaemonSetPodsAndMarkReady(podClient, podInformer, 1, t)
-			validateDaemonSetStatus(dsClient, ds.Name, 1, t)
-		})
+		validateDaemonSetPodsAndMarkReady(podClient, podInformer, 1, t)
+		validateDaemonSetStatus(dsClient, ds.Name, 1, t)
 	})
 }
 
 func TestSimpleDaemonSetLaunchesPods(t *testing.T) {
-	forEachFeatureGate(t, func(t *testing.T) {
-		forEachStrategy(t, func(t *testing.T, strategy *apps.DaemonSetUpdateStrategy) {
-			server, closeFn, dc, informers, clientset := setup(t)
-			defer closeFn()
-			ns := framework.CreateTestingNamespace("simple-daemonset-test", server, t)
-			defer framework.DeleteTestingNamespace(ns, server, t)
+	forEachStrategy(t, func(t *testing.T, strategy *apps.DaemonSetUpdateStrategy) {
+		server, closeFn, dc, informers, clientset := setup(t)
+		defer closeFn()
+		ns := framework.CreateTestingNamespace("simple-daemonset-test", server, t)
+		defer framework.DeleteTestingNamespace(ns, server, t)
 
-			dsClient := clientset.AppsV1().DaemonSets(ns.Name)
-			podClient := clientset.CoreV1().Pods(ns.Name)
-			nodeClient := clientset.CoreV1().Nodes()
-			podInformer := informers.Core().V1().Pods().Informer()
+		dsClient := clientset.AppsV1().DaemonSets(ns.Name)
+		podClient := clientset.CoreV1().Pods(ns.Name)
+		nodeClient := clientset.CoreV1().Nodes()
+		podInformer := informers.Core().V1().Pods().Informer()
 
-			ctx, cancel := context.WithCancel(context.Background())
-			defer cancel()
+		ctx, cancel := context.WithCancel(context.Background())
+		defer cancel()
 
-			informers.Start(ctx.Done())
-			go dc.Run(5, ctx.Done())
+		informers.Start(ctx.Done())
+		go dc.Run(5, ctx.Done())
 
-			// Start Scheduler
-			defer setupScheduler(ctx, t, clientset, informers)()
+		// Start Scheduler
+		defer setupScheduler(ctx, t, clientset, informers)()
 
-			ds := newDaemonSet("foo", ns.Name)
-			ds.Spec.UpdateStrategy = *strategy
-			_, err := dsClient.Create(ds)
-			if err != nil {
-				t.Fatalf("Failed to create DaemonSet: %v", err)
-			}
-			defer cleanupDaemonSets(t, clientset, ds)
+		ds := newDaemonSet("foo", ns.Name)
+		ds.Spec.UpdateStrategy = *strategy
+		_, err := dsClient.Create(ds)
+		if err != nil {
+			t.Fatalf("Failed to create DaemonSet: %v", err)
+		}
+		defer cleanupDaemonSets(t, clientset, ds)
 
-			addNodes(nodeClient, 0, 5, nil, t)
+		addNodes(nodeClient, 0, 5, nil, t)
 
-			validateDaemonSetPodsAndMarkReady(podClient, podInformer, 5, t)
-			validateDaemonSetStatus(dsClient, ds.Name, 5, t)
-		})
+		validateDaemonSetPodsAndMarkReady(podClient, podInformer, 5, t)
+		validateDaemonSetStatus(dsClient, ds.Name, 5, t)
 	})
 }
 
 func TestDaemonSetWithNodeSelectorLaunchesPods(t *testing.T) {
-	forEachFeatureGate(t, func(t *testing.T) {
-		forEachStrategy(t, func(t *testing.T, strategy *apps.DaemonSetUpdateStrategy) {
-			server, closeFn, dc, informers, clientset := setup(t)
-			defer closeFn()
-			ns := framework.CreateTestingNamespace("simple-daemonset-test", server, t)
-			defer framework.DeleteTestingNamespace(ns, server, t)
+	forEachStrategy(t, func(t *testing.T, strategy *apps.DaemonSetUpdateStrategy) {
+		server, closeFn, dc, informers, clientset := setup(t)
+		defer closeFn()
+		ns := framework.CreateTestingNamespace("simple-daemonset-test", server, t)
+		defer framework.DeleteTestingNamespace(ns, server, t)
 
-			dsClient := clientset.AppsV1().DaemonSets(ns.Name)
-			podClient := clientset.CoreV1().Pods(ns.Name)
-			nodeClient := clientset.CoreV1().Nodes()
-			podInformer := informers.Core().V1().Pods().Informer()
+		dsClient := clientset.AppsV1().DaemonSets(ns.Name)
+		podClient := clientset.CoreV1().Pods(ns.Name)
+		nodeClient := clientset.CoreV1().Nodes()
+		podInformer := informers.Core().V1().Pods().Informer()
 
-			ctx, cancel := context.WithCancel(context.Background())
-			defer cancel()
+		ctx, cancel := context.WithCancel(context.Background())
+		defer cancel()
 
-			informers.Start(ctx.Done())
-			go dc.Run(5, ctx.Done())
+		informers.Start(ctx.Done())
+		go dc.Run(5, ctx.Done())
 
-			// Start Scheduler
-			defer setupScheduler(ctx, t, clientset, informers)()
+		// Start Scheduler
+		defer setupScheduler(ctx, t, clientset, informers)()
 
-			ds := newDaemonSet("foo", ns.Name)
-			ds.Spec.UpdateStrategy = *strategy
+		ds := newDaemonSet("foo", ns.Name)
+		ds.Spec.UpdateStrategy = *strategy
 
-			ds.Spec.Template.Spec.Affinity = &v1.Affinity{
-				NodeAffinity: &v1.NodeAffinity{
-					RequiredDuringSchedulingIgnoredDuringExecution: &v1.NodeSelector{
-						NodeSelectorTerms: []v1.NodeSelectorTerm{
-							{
-								MatchExpressions: []v1.NodeSelectorRequirement{
-									{
-										Key:      "zone",
-										Operator: v1.NodeSelectorOpIn,
-										Values:   []string{"test"},
-									},
+		ds.Spec.Template.Spec.Affinity = &v1.Affinity{
+			NodeAffinity: &v1.NodeAffinity{
+				RequiredDuringSchedulingIgnoredDuringExecution: &v1.NodeSelector{
+					NodeSelectorTerms: []v1.NodeSelectorTerm{
+						{
+							MatchExpressions: []v1.NodeSelectorRequirement{
+								{
+									Key:      "zone",
+									Operator: v1.NodeSelectorOpIn,
+									Values:   []string{"test"},
 								},
 							},
-							{
-								MatchFields: []v1.NodeSelectorRequirement{
-									{
-										Key:      schedulerapi.NodeFieldSelectorKeyNodeName,
-										Operator: v1.NodeSelectorOpIn,
-										Values:   []string{"node-1"},
-									},
+						},
+						{
+							MatchFields: []v1.NodeSelectorRequirement{
+								{
+									Key:      schedulerapi.NodeFieldSelectorKeyNodeName,
+									Operator: v1.NodeSelectorOpIn,
+									Values:   []string{"node-1"},
 								},
 							},
 						},
 					},
 				},
-			}
+			},
+		}
 
-			_, err := dsClient.Create(ds)
-			if err != nil {
-				t.Fatalf("Failed to create DaemonSet: %v", err)
-			}
-			defer cleanupDaemonSets(t, clientset, ds)
+		_, err := dsClient.Create(ds)
+		if err != nil {
+			t.Fatalf("Failed to create DaemonSet: %v", err)
+		}
+		defer cleanupDaemonSets(t, clientset, ds)
 
-			addNodes(nodeClient, 0, 2, nil, t)
-			// Two nodes with labels
-			addNodes(nodeClient, 2, 2, map[string]string{
-				"zone": "test",
-			}, t)
-			addNodes(nodeClient, 4, 2, nil, t)
+		addNodes(nodeClient, 0, 2, nil, t)
+		// Two nodes with labels
+		addNodes(nodeClient, 2, 2, map[string]string{
+			"zone": "test",
+		}, t)
+		addNodes(nodeClient, 4, 2, nil, t)
 
-			validateDaemonSetPodsAndMarkReady(podClient, podInformer, 3, t)
-			validateDaemonSetStatus(dsClient, ds.Name, 3, t)
-		})
+		validateDaemonSetPodsAndMarkReady(podClient, podInformer, 3, t)
+		validateDaemonSetStatus(dsClient, ds.Name, 3, t)
 	})
 }
 
@@ -680,52 +622,10 @@ func TestNotReadyNodeDaemonDoesLaunchPod(t *testing.T) {
 	})
 }
 
-// When ScheduleDaemonSetPods is disabled, DaemonSets should not launch onto nodes with insufficient capacity.
-// Look for TestInsufficientCapacityNodeWhenScheduleDaemonSetPodsEnabled, we don't need this test anymore.
-func TestInsufficientCapacityNodeDaemonDoesNotLaunchPod(t *testing.T) {
-	defer featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, features.ScheduleDaemonSetPods, false)()
-	forEachStrategy(t, func(t *testing.T, strategy *apps.DaemonSetUpdateStrategy) {
-		server, closeFn, dc, informers, clientset := setup(t)
-		defer closeFn()
-		ns := framework.CreateTestingNamespace("insufficient-capacity", server, t)
-		defer framework.DeleteTestingNamespace(ns, server, t)
-
-		dsClient := clientset.AppsV1().DaemonSets(ns.Name)
-		nodeClient := clientset.CoreV1().Nodes()
-		eventClient := clientset.CoreV1().Events(ns.Namespace)
-
-		stopCh := make(chan struct{})
-		defer close(stopCh)
-
-		informers.Start(stopCh)
-		go dc.Run(5, stopCh)
-
-		ds := newDaemonSet("foo", ns.Name)
-		ds.Spec.Template.Spec = resourcePodSpec("node-with-limited-memory", "120M", "75m")
-		ds.Spec.UpdateStrategy = *strategy
-		_, err := dsClient.Create(ds)
-		if err != nil {
-			t.Fatalf("Failed to create DaemonSet: %v", err)
-		}
-		defer cleanupDaemonSets(t, clientset, ds)
-
-		node := newNode("node-with-limited-memory", nil)
-		node.Status.Allocatable = allocatableResources("100M", "200m")
-		_, err = nodeClient.Create(node)
-		if err != nil {
-			t.Fatalf("Failed to create node: %v", err)
-		}
-
-		validateFailedPlacementEvent(eventClient, t)
-	})
-}
-
-// TestInsufficientCapacityNodeDaemonSetCreateButNotLaunchPod tests that when "ScheduleDaemonSetPods"
-// feature is enabled, the DaemonSet should create Pods for all the nodes regardless of available resource
-// on the nodes, and kube-scheduler should not schedule Pods onto the nodes with insufficient resource.
-func TestInsufficientCapacityNodeWhenScheduleDaemonSetPodsEnabled(t *testing.T) {
-	defer featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, features.ScheduleDaemonSetPods, true)()
-
+// TestInsufficientCapacityNodeDaemonSetCreateButNotLaunchPod tests thaat the DaemonSet should create
+// Pods for all the nodes regardless of available resource on the nodes, and kube-scheduler should
+// not schedule Pods onto the nodes with insufficient resource.
+func TestInsufficientCapacityNode(t *testing.T) {
 	forEachStrategy(t, func(t *testing.T, strategy *apps.DaemonSetUpdateStrategy) {
 		server, closeFn, dc, informers, clientset := setup(t)
 		defer closeFn()
@@ -782,8 +682,7 @@ func TestInsufficientCapacityNodeWhenScheduleDaemonSetPodsEnabled(t *testing.T)
 			t.Fatalf("Failed to create node: %v", err)
 		}
 
-		// When ScheduleDaemonSetPods enabled, 2 pods are created. But only one
-		// of two Pods is scheduled by default scheduler.
+		// 2 pods are created. But only one of two Pods is scheduled by default scheduler.
 		validateDaemonSetPodsAndMarkReady(podClient, podInformer, 2, t)
 		validateDaemonSetStatus(dsClient, ds.Name, 1, t)
 	})
@@ -898,142 +797,137 @@ func TestLaunchWithHashCollision(t *testing.T) {
 	validateDaemonSetCollisionCount(dsClient, ds.Name, orgCollisionCount+1, t)
 }
 
-// TestTaintedNode tests that no matter "ScheduleDaemonSetPods" feature is enabled or not
-// tainted node isn't expected to have pod scheduled
+// TestTaintedNode tests tainted node isn't expected to have pod scheduled
 func TestTaintedNode(t *testing.T) {
-	forEachFeatureGate(t, func(t *testing.T) {
-		forEachStrategy(t, func(t *testing.T, strategy *apps.DaemonSetUpdateStrategy) {
-			server, closeFn, dc, informers, clientset := setup(t)
-			defer closeFn()
-			ns := framework.CreateTestingNamespace("tainted-node", server, t)
-			defer framework.DeleteTestingNamespace(ns, server, t)
+	forEachStrategy(t, func(t *testing.T, strategy *apps.DaemonSetUpdateStrategy) {
+		server, closeFn, dc, informers, clientset := setup(t)
+		defer closeFn()
+		ns := framework.CreateTestingNamespace("tainted-node", server, t)
+		defer framework.DeleteTestingNamespace(ns, server, t)
 
-			dsClient := clientset.AppsV1().DaemonSets(ns.Name)
-			podClient := clientset.CoreV1().Pods(ns.Name)
-			podInformer := informers.Core().V1().Pods().Informer()
-			nodeClient := clientset.CoreV1().Nodes()
+		dsClient := clientset.AppsV1().DaemonSets(ns.Name)
+		podClient := clientset.CoreV1().Pods(ns.Name)
+		podInformer := informers.Core().V1().Pods().Informer()
+		nodeClient := clientset.CoreV1().Nodes()
 
-			ctx, cancel := context.WithCancel(context.Background())
-			defer cancel()
+		ctx, cancel := context.WithCancel(context.Background())
+		defer cancel()
 
-			informers.Start(ctx.Done())
-			go dc.Run(5, ctx.Done())
+		informers.Start(ctx.Done())
+		go dc.Run(5, ctx.Done())
 
-			// Start Scheduler
-			defer setupScheduler(ctx, t, clientset, informers)()
+		// Start Scheduler
+		defer setupScheduler(ctx, t, clientset, informers)()
 
-			ds := newDaemonSet("foo", ns.Name)
-			ds.Spec.UpdateStrategy = *strategy
-			ds, err := dsClient.Create(ds)
-			if err != nil {
-				t.Fatalf("Failed to create DaemonSet: %v", err)
-			}
+		ds := newDaemonSet("foo", ns.Name)
+		ds.Spec.UpdateStrategy = *strategy
+		ds, err := dsClient.Create(ds)
+		if err != nil {
+			t.Fatalf("Failed to create DaemonSet: %v", err)
+		}
 
-			defer cleanupDaemonSets(t, clientset, ds)
+		defer cleanupDaemonSets(t, clientset, ds)
 
-			nodeWithTaint := newNode("node-with-taint", nil)
-			nodeWithTaint.Spec.Taints = []v1.Taint{{Key: "key1", Value: "val1", Effect: "NoSchedule"}}
-			_, err = nodeClient.Create(nodeWithTaint)
-			if err != nil {
-				t.Fatalf("Failed to create nodeWithTaint: %v", err)
-			}
+		nodeWithTaint := newNode("node-with-taint", nil)
+		nodeWithTaint.Spec.Taints = []v1.Taint{{Key: "key1", Value: "val1", Effect: "NoSchedule"}}
+		_, err = nodeClient.Create(nodeWithTaint)
+		if err != nil {
+			t.Fatalf("Failed to create nodeWithTaint: %v", err)
+		}
 
-			nodeWithoutTaint := newNode("node-without-taint", nil)
-			_, err = nodeClient.Create(nodeWithoutTaint)
-			if err != nil {
-				t.Fatalf("Failed to create nodeWithoutTaint: %v", err)
-			}
+		nodeWithoutTaint := newNode("node-without-taint", nil)
+		_, err = nodeClient.Create(nodeWithoutTaint)
+		if err != nil {
+			t.Fatalf("Failed to create nodeWithoutTaint: %v", err)
+		}
 
-			validateDaemonSetPodsAndMarkReady(podClient, podInformer, 1, t)
-			validateDaemonSetStatus(dsClient, ds.Name, 1, t)
+		validateDaemonSetPodsAndMarkReady(podClient, podInformer, 1, t)
+		validateDaemonSetStatus(dsClient, ds.Name, 1, t)
 
-			// remove taint from nodeWithTaint
-			nodeWithTaint, err = nodeClient.Get("node-with-taint", metav1.GetOptions{})
-			if err != nil {
-				t.Fatalf("Failed to retrieve nodeWithTaint: %v", err)
-			}
-			nodeWithTaintCopy := nodeWithTaint.DeepCopy()
-			nodeWithTaintCopy.Spec.Taints = []v1.Taint{}
-			_, err = nodeClient.Update(nodeWithTaintCopy)
-			if err != nil {
-				t.Fatalf("Failed to update nodeWithTaint: %v", err)
-			}
+		// remove taint from nodeWithTaint
+		nodeWithTaint, err = nodeClient.Get("node-with-taint", metav1.GetOptions{})
+		if err != nil {
+			t.Fatalf("Failed to retrieve nodeWithTaint: %v", err)
+		}
+		nodeWithTaintCopy := nodeWithTaint.DeepCopy()
+		nodeWithTaintCopy.Spec.Taints = []v1.Taint{}
+		_, err = nodeClient.Update(nodeWithTaintCopy)
+		if err != nil {
+			t.Fatalf("Failed to update nodeWithTaint: %v", err)
+		}
 
-			validateDaemonSetPodsAndMarkReady(podClient, podInformer, 2, t)
-			validateDaemonSetStatus(dsClient, ds.Name, 2, t)
-		})
+		validateDaemonSetPodsAndMarkReady(podClient, podInformer, 2, t)
+		validateDaemonSetStatus(dsClient, ds.Name, 2, t)
 	})
 }
 
 // TestUnschedulableNodeDaemonDoesLaunchPod tests that the DaemonSet Pods can still be scheduled
 // to the Unschedulable nodes.
 func TestUnschedulableNodeDaemonDoesLaunchPod(t *testing.T) {
-	forEachFeatureGate(t, func(t *testing.T) {
-		forEachStrategy(t, func(t *testing.T, strategy *apps.DaemonSetUpdateStrategy) {
-			server, closeFn, dc, informers, clientset := setup(t)
-			defer closeFn()
-			ns := framework.CreateTestingNamespace("daemonset-unschedulable-test", server, t)
-			defer framework.DeleteTestingNamespace(ns, server, t)
+	forEachStrategy(t, func(t *testing.T, strategy *apps.DaemonSetUpdateStrategy) {
+		server, closeFn, dc, informers, clientset := setup(t)
+		defer closeFn()
+		ns := framework.CreateTestingNamespace("daemonset-unschedulable-test", server, t)
+		defer framework.DeleteTestingNamespace(ns, server, t)
 
-			dsClient := clientset.AppsV1().DaemonSets(ns.Name)
-			podClient := clientset.CoreV1().Pods(ns.Name)
-			nodeClient := clientset.CoreV1().Nodes()
-			podInformer := informers.Core().V1().Pods().Informer()
+		dsClient := clientset.AppsV1().DaemonSets(ns.Name)
+		podClient := clientset.CoreV1().Pods(ns.Name)
+		nodeClient := clientset.CoreV1().Nodes()
+		podInformer := informers.Core().V1().Pods().Informer()
 
-			ctx, cancel := context.WithCancel(context.Background())
-			defer cancel()
+		ctx, cancel := context.WithCancel(context.Background())
+		defer cancel()
 
-			informers.Start(ctx.Done())
-			go dc.Run(5, ctx.Done())
+		informers.Start(ctx.Done())
+		go dc.Run(5, ctx.Done())
 
-			// Start Scheduler
-			defer setupScheduler(ctx, t, clientset, informers)()
+		// Start Scheduler
+		defer setupScheduler(ctx, t, clientset, informers)()
 
-			ds := newDaemonSet("foo", ns.Name)
-			ds.Spec.UpdateStrategy = *strategy
-			ds.Spec.Template.Spec.HostNetwork = true
-			_, err := dsClient.Create(ds)
-			if err != nil {
-				t.Fatalf("Failed to create DaemonSet: %v", err)
-			}
+		ds := newDaemonSet("foo", ns.Name)
+		ds.Spec.UpdateStrategy = *strategy
+		ds.Spec.Template.Spec.HostNetwork = true
+		_, err := dsClient.Create(ds)
+		if err != nil {
+			t.Fatalf("Failed to create DaemonSet: %v", err)
+		}
 
-			defer cleanupDaemonSets(t, clientset, ds)
+		defer cleanupDaemonSets(t, clientset, ds)
 
-			// Creates unschedulable node.
-			node := newNode("unschedulable-node", nil)
-			node.Spec.Unschedulable = true
-			node.Spec.Taints = []v1.Taint{
-				{
-					Key:    schedulerapi.TaintNodeUnschedulable,
-					Effect: v1.TaintEffectNoSchedule,
-				},
-			}
+		// Creates unschedulable node.
+		node := newNode("unschedulable-node", nil)
+		node.Spec.Unschedulable = true
+		node.Spec.Taints = []v1.Taint{
+			{
+				Key:    schedulerapi.TaintNodeUnschedulable,
+				Effect: v1.TaintEffectNoSchedule,
+			},
+		}
 
-			_, err = nodeClient.Create(node)
-			if err != nil {
-				t.Fatalf("Failed to create node: %v", err)
-			}
+		_, err = nodeClient.Create(node)
+		if err != nil {
+			t.Fatalf("Failed to create node: %v", err)
+		}
 
-			// Creates network-unavailable node.
-			nodeNU := newNode("network-unavailable-node", nil)
-			nodeNU.Status.Conditions = []v1.NodeCondition{
-				{Type: v1.NodeReady, Status: v1.ConditionFalse},
-				{Type: v1.NodeNetworkUnavailable, Status: v1.ConditionTrue},
-			}
-			nodeNU.Spec.Taints = []v1.Taint{
-				{
-					Key:    schedulerapi.TaintNodeNetworkUnavailable,
-					Effect: v1.TaintEffectNoSchedule,
-				},
-			}
+		// Creates network-unavailable node.
+		nodeNU := newNode("network-unavailable-node", nil)
+		nodeNU.Status.Conditions = []v1.NodeCondition{
+			{Type: v1.NodeReady, Status: v1.ConditionFalse},
+			{Type: v1.NodeNetworkUnavailable, Status: v1.ConditionTrue},
+		}
+		nodeNU.Spec.Taints = []v1.Taint{
+			{
+				Key:    schedulerapi.TaintNodeNetworkUnavailable,
+				Effect: v1.TaintEffectNoSchedule,
+			},
+		}
 
-			_, err = nodeClient.Create(nodeNU)
-			if err != nil {
-				t.Fatalf("Failed to create node: %v", err)
-			}
+		_, err = nodeClient.Create(nodeNU)
+		if err != nil {
+			t.Fatalf("Failed to create node: %v", err)
+		}
 
-			validateDaemonSetPodsAndMarkReady(podClient, podInformer, 2, t)
-			validateDaemonSetStatus(dsClient, ds.Name, 2, t)
-		})
+		validateDaemonSetPodsAndMarkReady(podClient, podInformer, 2, t)
+		validateDaemonSetStatus(dsClient, ds.Name, 2, t)
 	})
 }