Merge pull request #110229 from wojtek-t/fix_leaking_goroutines_1

Fix leaking goroutine in multiple integration tests by migrating to common StartTestServer utility

test/integration/certificates/field_selector_test.go

@@ -27,20 +27,19 @@ import (
 
 	certv1 "k8s.io/api/certificates/v1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/apimachinery/pkg/runtime/schema"
 	clientset "k8s.io/client-go/kubernetes"
 	certclientset "k8s.io/client-go/kubernetes/typed/certificates/v1"
-	restclient "k8s.io/client-go/rest"
+	kubeapiservertesting "k8s.io/kubernetes/cmd/kube-apiserver/app/testing"
 
 	"k8s.io/kubernetes/test/integration/framework"
 )
 
 // Verifies that the 'spec.signerName' field can be correctly used as a field selector on LIST requests
 func TestCSRSignerNameFieldSelector(t *testing.T) {
-	_, s, closeFn := framework.RunAnAPIServer(nil)
+	server := kubeapiservertesting.StartTestServerOrDie(t, nil, nil, framework.SharedEtcd())
-	defer closeFn()
+	defer server.TearDownFn()
 
-	client := clientset.NewForConfigOrDie(&restclient.Config{Host: s.URL, ContentConfig: restclient.ContentConfig{GroupVersion: &schema.GroupVersion{Group: "", Version: "v1"}}})
+	client := clientset.NewForConfigOrDie(server.ClientConfig)
 	csrClient := client.CertificatesV1().CertificateSigningRequests()
 	csr1 := createTestingCSR(t, csrClient, "csr-1", "example.com/signer-name-1", "")
 	csr2 := createTestingCSR(t, csrClient, "csr-2", "example.com/signer-name-2", "")

test/integration/configmap/configmap_test.go

@@ -24,22 +24,22 @@ import (
 
 	"k8s.io/api/core/v1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/apimachinery/pkg/runtime/schema"
 	clientset "k8s.io/client-go/kubernetes"
-	restclient "k8s.io/client-go/rest"
+	kubeapiservertesting "k8s.io/kubernetes/cmd/kube-apiserver/app/testing"
 	"k8s.io/kubernetes/test/integration"
 	"k8s.io/kubernetes/test/integration/framework"
 )
 
 // TestConfigMap tests apiserver-side behavior of creation of ConfigMaps and pods that consume them.
 func TestConfigMap(t *testing.T) {
-	_, s, closeFn := framework.RunAnAPIServer(nil)
+	// Disable ServiceAccount admission plugin as we don't have serviceaccount controller running.
-	defer closeFn()
+	server := kubeapiservertesting.StartTestServerOrDie(t, nil, []string{"--disable-admission-plugins=ServiceAccount"}, framework.SharedEtcd())
+	defer server.TearDownFn()
 
-	client := clientset.NewForConfigOrDie(&restclient.Config{Host: s.URL, ContentConfig: restclient.ContentConfig{GroupVersion: &schema.GroupVersion{Group: "", Version: "v1"}}})
+	client := clientset.NewForConfigOrDie(server.ClientConfig)
 
-	ns := framework.CreateTestingNamespace("config-map", t)
+	ns := framework.CreateNamespaceOrDie(client, "config-map", t)
-	defer framework.DeleteTestingNamespace(ns, t)
+	defer framework.DeleteNamespaceOrDie(client, ns, t)
 
 	DoTestConfigMap(t, client, ns)
 }

test/integration/cronjob/cronjob_test.go

@@ -30,29 +30,30 @@ import (
 	clientset "k8s.io/client-go/kubernetes"
 	clientbatchv1 "k8s.io/client-go/kubernetes/typed/batch/v1"
 	restclient "k8s.io/client-go/rest"
+	kubeapiservertesting "k8s.io/kubernetes/cmd/kube-apiserver/app/testing"
 	"k8s.io/kubernetes/pkg/controller/cronjob"
 	"k8s.io/kubernetes/pkg/controller/job"
 	"k8s.io/kubernetes/test/integration/framework"
 )
 
-func setup(t *testing.T) (framework.CloseFunc, *cronjob.ControllerV2, *job.Controller, informers.SharedInformerFactory, clientset.Interface, restclient.Config) {
+func setup(t *testing.T) (kubeapiservertesting.TearDownFunc, *cronjob.ControllerV2, *job.Controller, informers.SharedInformerFactory, clientset.Interface) {
-	controlPlaneConfig := framework.NewIntegrationTestControlPlaneConfig()
+	// Disable ServiceAccount admission plugin as we don't have serviceaccount controller running.
-	_, server, closeFn := framework.RunAnAPIServer(controlPlaneConfig)
+	server := kubeapiservertesting.StartTestServerOrDie(t, nil, []string{"--disable-admission-plugins=ServiceAccount"}, framework.SharedEtcd())
 
-	config := restclient.Config{Host: server.URL}
+	config := restclient.CopyConfig(server.ClientConfig)
-	clientSet, err := clientset.NewForConfig(&config)
+	clientSet, err := clientset.NewForConfig(config)
 	if err != nil {
 		t.Fatalf("Error creating clientset: %v", err)
 	}
 	resyncPeriod := 12 * time.Hour
-	informerSet := informers.NewSharedInformerFactory(clientset.NewForConfigOrDie(restclient.AddUserAgent(&config, "cronjob-informers")), resyncPeriod)
+	informerSet := informers.NewSharedInformerFactory(clientset.NewForConfigOrDie(restclient.AddUserAgent(config, "cronjob-informers")), resyncPeriod)
 	cjc, err := cronjob.NewControllerV2(informerSet.Batch().V1().Jobs(), informerSet.Batch().V1().CronJobs(), clientSet)
 	if err != nil {
 		t.Fatalf("Error creating CronJob controller: %v", err)
 	}
 	jc := job.NewController(informerSet.Core().V1().Pods(), informerSet.Batch().V1().Jobs(), clientSet)
 
-	return closeFn, cjc, jc, informerSet, clientSet, config
+	return server.TearDownFn, cjc, jc, informerSet, clientSet
 }
 
 func newCronJob(name, namespace, schedule string) *batchv1.CronJob {
@@ -143,14 +144,14 @@ func validateJobAndPod(t *testing.T, clientSet clientset.Interface, namespace st
 }
 
 func TestCronJobLaunchesPodAndCleansUp(t *testing.T) {
-	closeFn, cjc, jc, informerSet, clientSet, _ := setup(t)
+	closeFn, cjc, jc, informerSet, clientSet := setup(t)
 	defer closeFn()
 
 	cronJobName := "foo"
 	namespaceName := "simple-cronjob-test"
 
-	ns := framework.CreateTestingNamespace(namespaceName, t)
+	ns := framework.CreateNamespaceOrDie(clientSet, namespaceName, t)
-	defer framework.DeleteTestingNamespace(ns, t)
+	defer framework.DeleteNamespaceOrDie(clientSet, ns, t)
 
 	cjClient := clientSet.BatchV1().CronJobs(ns.Name)
 

test/integration/daemonset/daemonset_test.go

@@ -39,6 +39,7 @@ import (
 	"k8s.io/client-go/tools/events"
 	"k8s.io/client-go/util/flowcontrol"
 	"k8s.io/client-go/util/retry"
+	kubeapiservertesting "k8s.io/kubernetes/cmd/kube-apiserver/app/testing"
 	podutil "k8s.io/kubernetes/pkg/api/v1/pod"
 	"k8s.io/kubernetes/pkg/controller"
 	"k8s.io/kubernetes/pkg/controller/daemon"
@@ -50,30 +51,30 @@ import (
 
 var zero = int64(0)
 
-func setup(t *testing.T) (framework.CloseFunc, *daemon.DaemonSetsController, informers.SharedInformerFactory, clientset.Interface) {
+func setup(t *testing.T) (kubeapiservertesting.TearDownFunc, *daemon.DaemonSetsController, informers.SharedInformerFactory, clientset.Interface) {
-	controlPlaneConfig := framework.NewIntegrationTestControlPlaneConfig()
+	// Disable ServiceAccount admission plugin as we don't have serviceaccount controller running.
-	_, server, closeFn := framework.RunAnAPIServer(controlPlaneConfig)
+	server := kubeapiservertesting.StartTestServerOrDie(t, nil, []string{"--disable-admission-plugins=ServiceAccount,TaintNodesByCondition"}, framework.SharedEtcd())
 
-	config := restclient.Config{Host: server.URL}
+	config := restclient.CopyConfig(server.ClientConfig)
-	clientSet, err := clientset.NewForConfig(&config)
+	clientSet, err := clientset.NewForConfig(config)
 	if err != nil {
 		t.Fatalf("Error in creating clientset: %v", err)
 	}
 	resyncPeriod := 12 * time.Hour
-	informers := informers.NewSharedInformerFactory(clientset.NewForConfigOrDie(restclient.AddUserAgent(&config, "daemonset-informers")), resyncPeriod)
+	informers := informers.NewSharedInformerFactory(clientset.NewForConfigOrDie(restclient.AddUserAgent(config, "daemonset-informers")), resyncPeriod)
 	dc, err := daemon.NewDaemonSetsController(
 		informers.Apps().V1().DaemonSets(),
 		informers.Apps().V1().ControllerRevisions(),
 		informers.Core().V1().Pods(),
 		informers.Core().V1().Nodes(),
-		clientset.NewForConfigOrDie(restclient.AddUserAgent(&config, "daemonset-controller")),
+		clientset.NewForConfigOrDie(restclient.AddUserAgent(config, "daemonset-controller")),
 		flowcontrol.NewBackOff(5*time.Second, 15*time.Minute),
 	)
 	if err != nil {
 		t.Fatalf("error creating DaemonSets controller: %v", err)
 	}
 
-	return closeFn, dc, informers, clientSet
+	return server.TearDownFn, dc, informers, clientSet
 }
 
 func setupScheduler(
@@ -255,7 +256,7 @@ func validateDaemonSetPodsAndMarkReady(
 	numberPods int,
 	t *testing.T,
 ) {
-	if err := wait.Poll(10*time.Second, 60*time.Second, func() (bool, error) {
+	if err := wait.Poll(time.Second, 60*time.Second, func() (bool, error) {
 		objects := podInformer.GetIndexer().List()
 		if len(objects) != numberPods {
 			return false, nil
@@ -384,7 +385,7 @@ func validateDaemonSetStatus(
 	dsName string,
 	expectedNumberReady int32,
 	t *testing.T) {
-	if err := wait.Poll(5*time.Second, 60*time.Second, func() (bool, error) {
+	if err := wait.Poll(time.Second, 60*time.Second, func() (bool, error) {
 		ds, err := dsClient.Get(context.TODO(), dsName, metav1.GetOptions{})
 		if err != nil {
 			return false, err
@@ -422,8 +423,8 @@ func TestOneNodeDaemonLaunchesPod(t *testing.T) {
 	forEachStrategy(t, func(t *testing.T, strategy *apps.DaemonSetUpdateStrategy) {
 		closeFn, dc, informers, clientset := setup(t)
 		defer closeFn()
-		ns := framework.CreateTestingNamespace("one-node-daemonset-test", t)
+		ns := framework.CreateNamespaceOrDie(clientset, "one-node-daemonset-test", t)
-		defer framework.DeleteTestingNamespace(ns, t)
+		defer framework.DeleteNamespaceOrDie(clientset, ns, t)
 
 		dsClient := clientset.AppsV1().DaemonSets(ns.Name)
 		podClient := clientset.CoreV1().Pods(ns.Name)
@@ -461,8 +462,8 @@ func TestSimpleDaemonSetLaunchesPods(t *testing.T) {
 	forEachStrategy(t, func(t *testing.T, strategy *apps.DaemonSetUpdateStrategy) {
 		closeFn, dc, informers, clientset := setup(t)
 		defer closeFn()
-		ns := framework.CreateTestingNamespace("simple-daemonset-test", t)
+		ns := framework.CreateNamespaceOrDie(clientset, "simple-daemonset-test", t)
-		defer framework.DeleteTestingNamespace(ns, t)
+		defer framework.DeleteNamespaceOrDie(clientset, ns, t)
 
 		dsClient := clientset.AppsV1().DaemonSets(ns.Name)
 		podClient := clientset.CoreV1().Pods(ns.Name)
@@ -497,8 +498,8 @@ func TestDaemonSetWithNodeSelectorLaunchesPods(t *testing.T) {
 	forEachStrategy(t, func(t *testing.T, strategy *apps.DaemonSetUpdateStrategy) {
 		closeFn, dc, informers, clientset := setup(t)
 		defer closeFn()
-		ns := framework.CreateTestingNamespace("simple-daemonset-test", t)
+		ns := framework.CreateNamespaceOrDie(clientset, "simple-daemonset-test", t)
-		defer framework.DeleteTestingNamespace(ns, t)
+		defer framework.DeleteNamespaceOrDie(clientset, ns, t)
 
 		dsClient := clientset.AppsV1().DaemonSets(ns.Name)
 		podClient := clientset.CoreV1().Pods(ns.Name)
@@ -566,8 +567,8 @@ func TestNotReadyNodeDaemonDoesLaunchPod(t *testing.T) {
 	forEachStrategy(t, func(t *testing.T, strategy *apps.DaemonSetUpdateStrategy) {
 		closeFn, dc, informers, clientset := setup(t)
 		defer closeFn()
-		ns := framework.CreateTestingNamespace("simple-daemonset-test", t)
+		ns := framework.CreateNamespaceOrDie(clientset, "simple-daemonset-test", t)
-		defer framework.DeleteTestingNamespace(ns, t)
+		defer framework.DeleteNamespaceOrDie(clientset, ns, t)
 
 		dsClient := clientset.AppsV1().DaemonSets(ns.Name)
 		podClient := clientset.CoreV1().Pods(ns.Name)
@@ -613,8 +614,8 @@ func TestInsufficientCapacityNode(t *testing.T) {
 	forEachStrategy(t, func(t *testing.T, strategy *apps.DaemonSetUpdateStrategy) {
 		closeFn, dc, informers, clientset := setup(t)
 		defer closeFn()
-		ns := framework.CreateTestingNamespace("insufficient-capacity", t)
+		ns := framework.CreateNamespaceOrDie(clientset, "insufficient-capacity", t)
-		defer framework.DeleteTestingNamespace(ns, t)
+		defer framework.DeleteNamespaceOrDie(clientset, ns, t)
 
 		dsClient := clientset.AppsV1().DaemonSets(ns.Name)
 		podClient := clientset.CoreV1().Pods(ns.Name)
@@ -677,8 +678,8 @@ func TestInsufficientCapacityNode(t *testing.T) {
 func TestLaunchWithHashCollision(t *testing.T) {
 	closeFn, dc, informers, clientset := setup(t)
 	defer closeFn()
-	ns := framework.CreateTestingNamespace("one-node-daemonset-test", t)
+	ns := framework.CreateNamespaceOrDie(clientset, "one-node-daemonset-test", t)
-	defer framework.DeleteTestingNamespace(ns, t)
+	defer framework.DeleteNamespaceOrDie(clientset, ns, t)
 
 	dsClient := clientset.AppsV1().DaemonSets(ns.Name)
 	podInformer := informers.Core().V1().Pods().Informer()
@@ -788,8 +789,8 @@ func TestLaunchWithHashCollision(t *testing.T) {
 func TestDSCUpdatesPodLabelAfterDedupCurHistories(t *testing.T) {
 	closeFn, dc, informers, clientset := setup(t)
 	defer closeFn()
-	ns := framework.CreateTestingNamespace("one-node-daemonset-test", t)
+	ns := framework.CreateNamespaceOrDie(clientset, "one-node-daemonset-test", t)
-	defer framework.DeleteTestingNamespace(ns, t)
+	defer framework.DeleteNamespaceOrDie(clientset, ns, t)
 
 	dsClient := clientset.AppsV1().DaemonSets(ns.Name)
 	podInformer := informers.Core().V1().Pods().Informer()
@@ -916,8 +917,8 @@ func TestTaintedNode(t *testing.T) {
 	forEachStrategy(t, func(t *testing.T, strategy *apps.DaemonSetUpdateStrategy) {
 		closeFn, dc, informers, clientset := setup(t)
 		defer closeFn()
-		ns := framework.CreateTestingNamespace("tainted-node", t)
+		ns := framework.CreateNamespaceOrDie(clientset, "tainted-node", t)
-		defer framework.DeleteTestingNamespace(ns, t)
+		defer framework.DeleteNamespaceOrDie(clientset, ns, t)
 
 		dsClient := clientset.AppsV1().DaemonSets(ns.Name)
 		podClient := clientset.CoreV1().Pods(ns.Name)
@@ -981,8 +982,8 @@ func TestUnschedulableNodeDaemonDoesLaunchPod(t *testing.T) {
 	forEachStrategy(t, func(t *testing.T, strategy *apps.DaemonSetUpdateStrategy) {
 		closeFn, dc, informers, clientset := setup(t)
 		defer closeFn()
-		ns := framework.CreateTestingNamespace("daemonset-unschedulable-test", t)
+		ns := framework.CreateNamespaceOrDie(clientset, "daemonset-unschedulable-test", t)
-		defer framework.DeleteTestingNamespace(ns, t)
+		defer framework.DeleteNamespaceOrDie(clientset, ns, t)
 
 		dsClient := clientset.AppsV1().DaemonSets(ns.Name)
 		podClient := clientset.CoreV1().Pods(ns.Name)

test/integration/deployment/deployment_test.go

@@ -39,8 +39,9 @@ func TestNewDeployment(t *testing.T) {
 	closeFn, rm, dc, informers, c := dcSetup(t)
 	defer closeFn()
 	name := "test-new-deployment"
-	ns := framework.CreateTestingNamespace(name, t)
+
-	defer framework.DeleteTestingNamespace(ns, t)
+	ns := framework.CreateNamespaceOrDie(c, name, t)
+	defer framework.DeleteNamespaceOrDie(c, ns, t)
 
 	replicas := int32(20)
 	tester := &deploymentTester{t: t, c: c, deployment: newDeployment(name, ns.Name, replicas)}
@@ -113,9 +114,10 @@ func TestNewDeployment(t *testing.T) {
 func TestDeploymentRollingUpdate(t *testing.T) {
 	closeFn, rm, dc, informers, c := dcSetup(t)
 	defer closeFn()
+
 	name := "test-rolling-update-deployment"
-	ns := framework.CreateTestingNamespace(name, t)
+	ns := framework.CreateNamespaceOrDie(c, name, t)
-	defer framework.DeleteTestingNamespace(ns, t)
+	defer framework.DeleteNamespaceOrDie(c, ns, t)
 
 	// Start informer and controllers
 	stopControllers := runControllersAndInformers(t, rm, dc, informers)
@@ -207,9 +209,10 @@ func TestDeploymentRollingUpdate(t *testing.T) {
 func TestDeploymentSelectorImmutability(t *testing.T) {
 	closeFn, c := dcSimpleSetup(t)
 	defer closeFn()
+
 	name := "test-deployment-selector-immutability"
-	ns := framework.CreateTestingNamespace(name, t)
+	ns := framework.CreateNamespaceOrDie(c, name, t)
-	defer framework.DeleteTestingNamespace(ns, t)
+	defer framework.DeleteNamespaceOrDie(c, ns, t)
 
 	tester := &deploymentTester{t: t, c: c, deployment: newDeployment(name, ns.Name, int32(20))}
 	var err error
@@ -241,9 +244,10 @@ func TestDeploymentSelectorImmutability(t *testing.T) {
 func TestPausedDeployment(t *testing.T) {
 	closeFn, rm, dc, informers, c := dcSetup(t)
 	defer closeFn()
+
 	name := "test-paused-deployment"
-	ns := framework.CreateTestingNamespace(name, t)
+	ns := framework.CreateNamespaceOrDie(c, name, t)
-	defer framework.DeleteTestingNamespace(ns, t)
+	defer framework.DeleteNamespaceOrDie(c, ns, t)
 
 	replicas := int32(1)
 	tester := &deploymentTester{t: t, c: c, deployment: newDeployment(name, ns.Name, replicas)}
@@ -340,9 +344,10 @@ func TestPausedDeployment(t *testing.T) {
 func TestScalePausedDeployment(t *testing.T) {
 	closeFn, rm, dc, informers, c := dcSetup(t)
 	defer closeFn()
+
 	name := "test-scale-paused-deployment"
-	ns := framework.CreateTestingNamespace(name, t)
+	ns := framework.CreateNamespaceOrDie(c, name, t)
-	defer framework.DeleteTestingNamespace(ns, t)
+	defer framework.DeleteNamespaceOrDie(c, ns, t)
 
 	replicas := int32(1)
 	tester := &deploymentTester{t: t, c: c, deployment: newDeployment(name, ns.Name, replicas)}
@@ -420,9 +425,10 @@ func TestScalePausedDeployment(t *testing.T) {
 func TestDeploymentHashCollision(t *testing.T) {
 	closeFn, rm, dc, informers, c := dcSetup(t)
 	defer closeFn()
+
 	name := "test-hash-collision-deployment"
-	ns := framework.CreateTestingNamespace(name, t)
+	ns := framework.CreateNamespaceOrDie(c, name, t)
-	defer framework.DeleteTestingNamespace(ns, t)
+	defer framework.DeleteNamespaceOrDie(c, ns, t)
 
 	replicas := int32(1)
 	tester := &deploymentTester{t: t, c: c, deployment: newDeployment(name, ns.Name, replicas)}
@@ -518,9 +524,10 @@ func checkPodsHashLabel(pods *v1.PodList) (string, error) {
 func TestFailedDeployment(t *testing.T) {
 	closeFn, rm, dc, informers, c := dcSetup(t)
 	defer closeFn()
+
 	name := "test-failed-deployment"
-	ns := framework.CreateTestingNamespace(name, t)
+	ns := framework.CreateNamespaceOrDie(c, name, t)
-	defer framework.DeleteTestingNamespace(ns, t)
+	defer framework.DeleteNamespaceOrDie(c, ns, t)
 
 	deploymentName := "progress-check"
 	replicas := int32(1)
@@ -561,9 +568,10 @@ func TestFailedDeployment(t *testing.T) {
 func TestOverlappingDeployments(t *testing.T) {
 	closeFn, rm, dc, informers, c := dcSetup(t)
 	defer closeFn()
+
 	name := "test-overlapping-deployments"
-	ns := framework.CreateTestingNamespace(name, t)
+	ns := framework.CreateNamespaceOrDie(c, name, t)
-	defer framework.DeleteTestingNamespace(ns, t)
+	defer framework.DeleteNamespaceOrDie(c, ns, t)
 
 	replicas := int32(1)
 	firstDeploymentName := "first-deployment"
@@ -641,9 +649,10 @@ func TestOverlappingDeployments(t *testing.T) {
 func TestScaledRolloutDeployment(t *testing.T) {
 	closeFn, rm, dc, informers, c := dcSetup(t)
 	defer closeFn()
+
 	name := "test-scaled-rollout-deployment"
-	ns := framework.CreateTestingNamespace(name, t)
+	ns := framework.CreateNamespaceOrDie(c, name, t)
-	defer framework.DeleteTestingNamespace(ns, t)
+	defer framework.DeleteNamespaceOrDie(c, ns, t)
 
 	// Start informer and controllers
 	stopControllers := runControllersAndInformers(t, rm, dc, informers)
@@ -830,9 +839,10 @@ func TestScaledRolloutDeployment(t *testing.T) {
 func TestSpecReplicasChange(t *testing.T) {
 	closeFn, rm, dc, informers, c := dcSetup(t)
 	defer closeFn()
+
 	name := "test-spec-replicas-change"
-	ns := framework.CreateTestingNamespace(name, t)
+	ns := framework.CreateNamespaceOrDie(c, name, t)
-	defer framework.DeleteTestingNamespace(ns, t)
+	defer framework.DeleteNamespaceOrDie(c, ns, t)
 
 	deploymentName := "deployment"
 	replicas := int32(1)
@@ -883,9 +893,10 @@ func TestSpecReplicasChange(t *testing.T) {
 func TestDeploymentAvailableCondition(t *testing.T) {
 	closeFn, rm, dc, informers, c := dcSetup(t)
 	defer closeFn()
+
 	name := "test-deployment-available-condition"
-	ns := framework.CreateTestingNamespace(name, t)
+	ns := framework.CreateNamespaceOrDie(c, name, t)
-	defer framework.DeleteTestingNamespace(ns, t)
+	defer framework.DeleteNamespaceOrDie(c, ns, t)
 
 	deploymentName := "deployment"
 	replicas := int32(10)
@@ -1001,9 +1012,10 @@ func testRSControllerRefPatch(t *testing.T, tester *deploymentTester, rs *apps.R
 func TestGeneralReplicaSetAdoption(t *testing.T) {
 	closeFn, rm, dc, informers, c := dcSetup(t)
 	defer closeFn()
+
 	name := "test-general-replicaset-adoption"
-	ns := framework.CreateTestingNamespace(name, t)
+	ns := framework.CreateNamespaceOrDie(c, name, t)
-	defer framework.DeleteTestingNamespace(ns, t)
+	defer framework.DeleteNamespaceOrDie(c, ns, t)
 
 	deploymentName := "deployment"
 	replicas := int32(1)
@@ -1090,9 +1102,10 @@ func testScalingUsingScaleSubresource(t *testing.T, tester *deploymentTester, re
 func TestDeploymentScaleSubresource(t *testing.T) {
 	closeFn, rm, dc, informers, c := dcSetup(t)
 	defer closeFn()
+
 	name := "test-deployment-scale-subresource"
-	ns := framework.CreateTestingNamespace(name, t)
+	ns := framework.CreateNamespaceOrDie(c, name, t)
-	defer framework.DeleteTestingNamespace(ns, t)
+	defer framework.DeleteNamespaceOrDie(c, ns, t)
 
 	deploymentName := "deployment"
 	replicas := int32(2)
@@ -1131,9 +1144,10 @@ func TestDeploymentScaleSubresource(t *testing.T) {
 func TestReplicaSetOrphaningAndAdoptionWhenLabelsChange(t *testing.T) {
 	closeFn, rm, dc, informers, c := dcSetup(t)
 	defer closeFn()
+
 	name := "test-replicaset-orphaning-and-adoption-when-labels-change"
-	ns := framework.CreateTestingNamespace(name, t)
+	ns := framework.CreateNamespaceOrDie(c, name, t)
-	defer framework.DeleteTestingNamespace(ns, t)
+	defer framework.DeleteNamespaceOrDie(c, ns, t)
 
 	deploymentName := "deployment"
 	replicas := int32(1)

test/integration/deployment/util.go

@@ -31,6 +31,7 @@ import (
 	"k8s.io/client-go/informers"
 	clientset "k8s.io/client-go/kubernetes"
 	restclient "k8s.io/client-go/rest"
+	kubeapiservertesting "k8s.io/kubernetes/cmd/kube-apiserver/app/testing"
 	podutil "k8s.io/kubernetes/pkg/api/v1/pod"
 	"k8s.io/kubernetes/pkg/controller/deployment"
 	deploymentutil "k8s.io/kubernetes/pkg/controller/deployment/util"
@@ -101,23 +102,23 @@ func newDeployment(name, ns string, replicas int32) *apps.Deployment {
 }
 
 // dcSetup sets up necessities for Deployment integration test, including control plane, apiserver, informers, and clientset
-func dcSetup(t *testing.T) (framework.CloseFunc, *replicaset.ReplicaSetController, *deployment.DeploymentController, informers.SharedInformerFactory, clientset.Interface) {
+func dcSetup(t *testing.T) (kubeapiservertesting.TearDownFunc, *replicaset.ReplicaSetController, *deployment.DeploymentController, informers.SharedInformerFactory, clientset.Interface) {
-	controlPlaneConfig := framework.NewIntegrationTestControlPlaneConfig()
+	// Disable ServiceAccount admission plugin as we don't have serviceaccount controller running.
-	_, s, closeFn := framework.RunAnAPIServer(controlPlaneConfig)
+	server := kubeapiservertesting.StartTestServerOrDie(t, nil, []string{"--disable-admission-plugins=ServiceAccount"}, framework.SharedEtcd())
 
-	config := restclient.Config{Host: s.URL}
+	config := restclient.CopyConfig(server.ClientConfig)
-	clientSet, err := clientset.NewForConfig(&config)
+	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)
+	informers := informers.NewSharedInformerFactory(clientset.NewForConfigOrDie(restclient.AddUserAgent(config, "deployment-informers")), resyncPeriod)
 
 	dc, err := deployment.NewDeploymentController(
 		informers.Apps().V1().Deployments(),
 		informers.Apps().V1().ReplicaSets(),
 		informers.Core().V1().Pods(),
-		clientset.NewForConfigOrDie(restclient.AddUserAgent(&config, "deployment-controller")),
+		clientset.NewForConfigOrDie(restclient.AddUserAgent(config, "deployment-controller")),
 	)
 	if err != nil {
 		t.Fatalf("error creating Deployment controller: %v", err)
@@ -125,24 +126,24 @@ func dcSetup(t *testing.T) (framework.CloseFunc, *replicaset.ReplicaSetControlle
 	rm := replicaset.NewReplicaSetController(
 		informers.Apps().V1().ReplicaSets(),
 		informers.Core().V1().Pods(),
-		clientset.NewForConfigOrDie(restclient.AddUserAgent(&config, "replicaset-controller")),
+		clientset.NewForConfigOrDie(restclient.AddUserAgent(config, "replicaset-controller")),
 		replicaset.BurstReplicas,
 	)
-	return closeFn, rm, dc, informers, clientSet
+	return server.TearDownFn, rm, dc, informers, clientSet
 }
 
 // dcSimpleSetup sets up necessities for Deployment integration test, including control plane, apiserver,
 // and clientset, but not controllers and informers
-func dcSimpleSetup(t *testing.T) (framework.CloseFunc, clientset.Interface) {
+func dcSimpleSetup(t *testing.T) (kubeapiservertesting.TearDownFunc, clientset.Interface) {
-	controlPlaneConfig := framework.NewIntegrationTestControlPlaneConfig()
+	// Disable ServiceAccount admission plugin as we don't have serviceaccount controller running.
-	_, s, closeFn := framework.RunAnAPIServer(controlPlaneConfig)
+	server := kubeapiservertesting.StartTestServerOrDie(t, nil, []string{"--disable-admission-plugins=ServiceAccount"}, framework.SharedEtcd())
 
-	config := restclient.Config{Host: s.URL}
+	config := restclient.CopyConfig(server.ClientConfig)
-	clientSet, err := clientset.NewForConfig(&config)
+	clientSet, err := clientset.NewForConfig(config)
 	if err != nil {
 		t.Fatalf("error in create clientset: %v", err)
 	}
-	return closeFn, clientSet
+	return server.TearDownFn, clientSet
 }
 
 // runControllersAndInformers runs RS and deployment controllers and informers

test/integration/endpoints/endpoints_test.go

@@ -30,18 +30,17 @@ import (
 	"k8s.io/apimachinery/pkg/util/wait"
 	"k8s.io/client-go/informers"
 	clientset "k8s.io/client-go/kubernetes"
-	restclient "k8s.io/client-go/rest"
+	kubeapiservertesting "k8s.io/kubernetes/cmd/kube-apiserver/app/testing"
 	"k8s.io/kubernetes/pkg/controller/endpoint"
 	"k8s.io/kubernetes/test/integration/framework"
 )
 
 func TestEndpointUpdates(t *testing.T) {
-	controlPlaneConfig := framework.NewIntegrationTestControlPlaneConfig()
+	// Disable ServiceAccount admission plugin as we don't have serviceaccount controller running.
-	_, server, closeFn := framework.RunAnAPIServer(controlPlaneConfig)
+	server := kubeapiservertesting.StartTestServerOrDie(t, nil, []string{"--disable-admission-plugins=ServiceAccount"}, framework.SharedEtcd())
-	defer closeFn()
+	defer server.TearDownFn()
 
-	config := restclient.Config{Host: server.URL}
+	client, err := clientset.NewForConfig(server.ClientConfig)
-	client, err := clientset.NewForConfig(&config)
 	if err != nil {
 		t.Fatalf("Error creating clientset: %v", err)
 	}
@@ -62,8 +61,8 @@ func TestEndpointUpdates(t *testing.T) {
 	go epController.Run(ctx, 1)
 
 	// Create namespace
-	ns := framework.CreateTestingNamespace("test-endpoints-updates", t)
+	ns := framework.CreateNamespaceOrDie(client, "test-endpoints-updates", t)
-	defer framework.DeleteTestingNamespace(ns, t)
+	defer framework.DeleteNamespaceOrDie(client, ns, t)
 
 	// Create a pod with labels
 	pod := &v1.Pod{
@@ -165,12 +164,11 @@ func TestEndpointUpdates(t *testing.T) {
 // terminating endpoints in Endpoints, but in the mean time this test ensures we do not change
 // this behavior accidentally.
 func TestEndpointWithTerminatingPod(t *testing.T) {
-	controlPlaneConfig := framework.NewIntegrationTestControlPlaneConfig()
+	// Disable ServiceAccount admission plugin as we don't have serviceaccount controller running.
-	_, server, closeFn := framework.RunAnAPIServer(controlPlaneConfig)
+	server := kubeapiservertesting.StartTestServerOrDie(t, nil, []string{"--disable-admission-plugins=ServiceAccount"}, framework.SharedEtcd())
-	defer closeFn()
+	defer server.TearDownFn()
 
-	config := restclient.Config{Host: server.URL}
+	client, err := clientset.NewForConfig(server.ClientConfig)
-	client, err := clientset.NewForConfig(&config)
 	if err != nil {
 		t.Fatalf("Error creating clientset: %v", err)
 	}
@@ -191,8 +189,8 @@ func TestEndpointWithTerminatingPod(t *testing.T) {
 	go epController.Run(ctx, 1)
 
 	// Create namespace
-	ns := framework.CreateTestingNamespace("test-endpoints-terminating", t)
+	ns := framework.CreateNamespaceOrDie(client, "test-endpoints-terminating", t)
-	defer framework.DeleteTestingNamespace(ns, t)
+	defer framework.DeleteNamespaceOrDie(client, ns, t)
 
 	// Create a pod with labels
 	pod := &v1.Pod{

test/integration/endpointslice/endpointslicemirroring_test.go

@@ -32,7 +32,7 @@ import (
 	"k8s.io/client-go/informers"
 	"k8s.io/client-go/kubernetes"
 	clientset "k8s.io/client-go/kubernetes"
-	restclient "k8s.io/client-go/rest"
+	kubeapiservertesting "k8s.io/kubernetes/cmd/kube-apiserver/app/testing"
 	"k8s.io/kubernetes/pkg/controller/endpoint"
 	"k8s.io/kubernetes/pkg/controller/endpointslice"
 	"k8s.io/kubernetes/pkg/controller/endpointslicemirroring"
@@ -40,12 +40,11 @@ import (
 )
 
 func TestEndpointSliceMirroring(t *testing.T) {
-	controlPlaneConfig := framework.NewIntegrationTestControlPlaneConfig()
+	// Disable ServiceAccount admission plugin as we don't have serviceaccount controller running.
-	_, server, closeFn := framework.RunAnAPIServer(controlPlaneConfig)
+	server := kubeapiservertesting.StartTestServerOrDie(t, nil, []string{"--disable-admission-plugins=ServiceAccount"}, framework.SharedEtcd())
-	defer closeFn()
+	defer server.TearDownFn()
 
-	config := restclient.Config{Host: server.URL}
+	client, err := clientset.NewForConfig(server.ClientConfig)
-	client, err := clientset.NewForConfig(&config)
 	if err != nil {
 		t.Fatalf("Error creating clientset: %v", err)
 	}
@@ -174,8 +173,8 @@ func TestEndpointSliceMirroring(t *testing.T) {
 
 	for i, tc := range testCases {
 		t.Run(tc.testName, func(t *testing.T) {
-			ns := framework.CreateTestingNamespace(fmt.Sprintf("test-endpointslice-mirroring-%d", i), t)
+			ns := framework.CreateNamespaceOrDie(client, fmt.Sprintf("test-endpointslice-mirroring-%d", i), t)
-			defer framework.DeleteTestingNamespace(ns, t)
+			defer framework.DeleteNamespaceOrDie(client, ns, t)
 
 			resourceName := ""
 			if tc.service != nil {
@@ -234,12 +233,11 @@ func TestEndpointSliceMirroring(t *testing.T) {
 }
 
 func TestEndpointSliceMirroringUpdates(t *testing.T) {
-	controlPlaneConfig := framework.NewIntegrationTestControlPlaneConfig()
+	// Disable ServiceAccount admission plugin as we don't have serviceaccount controller running.
-	_, server, closeFn := framework.RunAnAPIServer(controlPlaneConfig)
+	server := kubeapiservertesting.StartTestServerOrDie(t, nil, []string{"--disable-admission-plugins=ServiceAccount"}, framework.SharedEtcd())
-	defer closeFn()
+	defer server.TearDownFn()
 
-	config := restclient.Config{Host: server.URL}
+	client, err := clientset.NewForConfig(server.ClientConfig)
-	client, err := clientset.NewForConfig(&config)
 	if err != nil {
 		t.Fatalf("Error creating clientset: %v", err)
 	}
@@ -294,8 +292,8 @@ func TestEndpointSliceMirroringUpdates(t *testing.T) {
 
 	for i, tc := range testCases {
 		t.Run(tc.testName, func(t *testing.T) {
-			ns := framework.CreateTestingNamespace(fmt.Sprintf("test-endpointslice-mirroring-%d", i), t)
+			ns := framework.CreateNamespaceOrDie(client, fmt.Sprintf("test-endpointslice-mirroring-%d", i), t)
-			defer framework.DeleteTestingNamespace(ns, t)
+			defer framework.DeleteNamespaceOrDie(client, ns, t)
 
 			service := &corev1.Service{
 				ObjectMeta: metav1.ObjectMeta{
@@ -410,12 +408,11 @@ func TestEndpointSliceMirroringUpdates(t *testing.T) {
 }
 
 func TestEndpointSliceMirroringSelectorTransition(t *testing.T) {
-	controlPlaneConfig := framework.NewIntegrationTestControlPlaneConfig()
+	// Disable ServiceAccount admission plugin as we don't have serviceaccount controller running.
-	_, server, closeFn := framework.RunAnAPIServer(controlPlaneConfig)
+	server := kubeapiservertesting.StartTestServerOrDie(t, nil, []string{"--disable-admission-plugins=ServiceAccount"}, framework.SharedEtcd())
-	defer closeFn()
+	defer server.TearDownFn()
 
-	config := restclient.Config{Host: server.URL}
+	client, err := clientset.NewForConfig(server.ClientConfig)
-	client, err := clientset.NewForConfig(&config)
 	if err != nil {
 		t.Fatalf("Error creating clientset: %v", err)
 	}
@@ -476,8 +473,8 @@ func TestEndpointSliceMirroringSelectorTransition(t *testing.T) {
 
 	for i, tc := range testCases {
 		t.Run(tc.testName, func(t *testing.T) {
-			ns := framework.CreateTestingNamespace(fmt.Sprintf("test-endpointslice-mirroring-%d", i), t)
+			ns := framework.CreateNamespaceOrDie(client, fmt.Sprintf("test-endpointslice-mirroring-%d", i), t)
-			defer framework.DeleteTestingNamespace(ns, t)
+			defer framework.DeleteNamespaceOrDie(client, ns, t)
 			meta := metav1.ObjectMeta{Name: "test-123", Namespace: ns.Name}
 
 			service := &corev1.Service{

test/integration/endpointslice/endpointsliceterminating_test.go

@@ -30,8 +30,8 @@ import (
 	utilfeature "k8s.io/apiserver/pkg/util/feature"
 	"k8s.io/client-go/informers"
 	clientset "k8s.io/client-go/kubernetes"
-	restclient "k8s.io/client-go/rest"
 	featuregatetesting "k8s.io/component-base/featuregate/testing"
+	kubeapiservertesting "k8s.io/kubernetes/cmd/kube-apiserver/app/testing"
 	"k8s.io/kubernetes/pkg/controller/endpointslice"
 	"k8s.io/kubernetes/pkg/features"
 	"k8s.io/kubernetes/test/integration/framework"
@@ -152,12 +152,11 @@ func TestEndpointSliceTerminating(t *testing.T) {
 		t.Run(testcase.name, func(t *testing.T) {
 			defer featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, features.EndpointSliceTerminatingCondition, testcase.terminatingGate)()
 
-			controlPlaneConfig := framework.NewIntegrationTestControlPlaneConfig()
+			// Disable ServiceAccount admission plugin as we don't have serviceaccount controller running.
-			_, server, closeFn := framework.RunAnAPIServer(controlPlaneConfig)
+			server := kubeapiservertesting.StartTestServerOrDie(t, nil, []string{"--disable-admission-plugins=ServiceAccount"}, framework.SharedEtcd())
-			defer closeFn()
+			defer server.TearDownFn()
 
-			config := restclient.Config{Host: server.URL}
+			client, err := clientset.NewForConfig(server.ClientConfig)
-			client, err := clientset.NewForConfig(&config)
 			if err != nil {
 				t.Fatalf("Error creating clientset: %v", err)
 			}
@@ -181,8 +180,8 @@ func TestEndpointSliceTerminating(t *testing.T) {
 			go epsController.Run(1, stopCh)
 
 			// Create namespace
-			ns := framework.CreateTestingNamespace("test-endpoints-terminating", t)
+			ns := framework.CreateNamespaceOrDie(client, "test-endpoints-terminating", t)
-			defer framework.DeleteTestingNamespace(ns, t)
+			defer framework.DeleteNamespaceOrDie(client, ns, t)
 
 			node := &corev1.Node{
 				ObjectMeta: metav1.ObjectMeta{

test/integration/evictions/evictions_test.go

@@ -20,7 +20,6 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
-	"net/http/httptest"
 	"reflect"
 	"strings"
 	"sync"
@@ -48,6 +47,7 @@ import (
 	"k8s.io/client-go/restmapper"
 	"k8s.io/client-go/scale"
 	"k8s.io/client-go/tools/cache"
+	kubeapiservertesting "k8s.io/kubernetes/cmd/kube-apiserver/app/testing"
 	"k8s.io/kubernetes/pkg/controller/disruption"
 	"k8s.io/kubernetes/test/integration/framework"
 )
@@ -61,23 +61,17 @@ const (
 func TestConcurrentEvictionRequests(t *testing.T) {
 	podNameFormat := "test-pod-%d"
 
-	s, closeFn, rm, informers, _ := rmSetup(t)
+	closeFn, rm, informers, _, clientSet := rmSetup(t)
 	defer closeFn()
 
-	ns := framework.CreateTestingNamespace("concurrent-eviction-requests", t)
+	ns := framework.CreateNamespaceOrDie(clientSet, "concurrent-eviction-requests", t)
-	defer framework.DeleteTestingNamespace(ns, t)
+	defer framework.DeleteNamespaceOrDie(clientSet, ns, t)
 
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 	informers.Start(ctx.Done())
 	go rm.Run(ctx)
 
-	config := restclient.Config{Host: s.URL}
-	clientSet, err := clientset.NewForConfig(&config)
-	if err != nil {
-		t.Fatalf("Failed to create clientset: %v", err)
-	}
-
 	var gracePeriodSeconds int64 = 30
 	deleteOption := metav1.DeleteOptions{
 		GracePeriodSeconds: &gracePeriodSeconds,
@@ -180,23 +174,17 @@ func TestConcurrentEvictionRequests(t *testing.T) {
 
 // TestTerminalPodEviction ensures that PDB is not checked for terminal pods.
 func TestTerminalPodEviction(t *testing.T) {
-	s, closeFn, rm, informers, _ := rmSetup(t)
+	closeFn, rm, informers, _, clientSet := rmSetup(t)
 	defer closeFn()
 
-	ns := framework.CreateTestingNamespace("terminalpod-eviction", t)
+	ns := framework.CreateNamespaceOrDie(clientSet, "terminalpod-eviction", t)
-	defer framework.DeleteTestingNamespace(ns, t)
+	defer framework.DeleteNamespaceOrDie(clientSet, ns, t)
 
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 	informers.Start(ctx.Done())
 	go rm.Run(ctx)
 
-	config := restclient.Config{Host: s.URL}
-	clientSet, err := clientset.NewForConfig(&config)
-	if err != nil {
-		t.Fatalf("Failed to create clientset: %v", err)
-	}
-
 	var gracePeriodSeconds int64 = 30
 	deleteOption := metav1.DeleteOptions{
 		GracePeriodSeconds: &gracePeriodSeconds,
@@ -259,7 +247,7 @@ func TestTerminalPodEviction(t *testing.T) {
 
 // TestEvictionVersions ensures the eviction endpoint accepts and returns the correct API versions
 func TestEvictionVersions(t *testing.T) {
-	s, closeFn, rm, informers, clientSet := rmSetup(t)
+	closeFn, rm, informers, config, clientSet := rmSetup(t)
 	defer closeFn()
 
 	ctx, cancel := context.WithCancel(context.Background())
@@ -267,8 +255,6 @@ func TestEvictionVersions(t *testing.T) {
 	informers.Start(ctx.Done())
 	go rm.Run(ctx)
 
-	config := restclient.Config{Host: s.URL}
-
 	ns := "default"
 	subresource := "eviction"
 	pod := newPod("test")
@@ -276,7 +262,7 @@ func TestEvictionVersions(t *testing.T) {
 		t.Errorf("Failed to create pod: %v", err)
 	}
 
-	dynamicClient, err := dynamic.NewForConfig(&config)
+	dynamicClient, err := dynamic.NewForConfig(config)
 	if err != nil {
 		t.Fatalf("Failed to create clientset: %v", err)
 	}
@@ -420,25 +406,25 @@ func newV1Eviction(ns, evictionName string, deleteOption metav1.DeleteOptions) *
 	}
 }
 
-func rmSetup(t *testing.T) (*httptest.Server, framework.CloseFunc, *disruption.DisruptionController, informers.SharedInformerFactory, clientset.Interface) {
+func rmSetup(t *testing.T) (kubeapiservertesting.TearDownFunc, *disruption.DisruptionController, informers.SharedInformerFactory, *restclient.Config, clientset.Interface) {
-	controlPlaneConfig := framework.NewIntegrationTestControlPlaneConfig()
+	// Disable ServiceAccount admission plugin as we don't have serviceaccount controller running.
-	_, s, closeFn := framework.RunAnAPIServer(controlPlaneConfig)
+	server := kubeapiservertesting.StartTestServerOrDie(t, nil, []string{"--disable-admission-plugins=ServiceAccount"}, framework.SharedEtcd())
 
-	config := restclient.Config{Host: s.URL}
+	config := restclient.CopyConfig(server.ClientConfig)
-	clientSet, err := clientset.NewForConfig(&config)
+	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, "pdb-informers")), resyncPeriod)
+	informers := informers.NewSharedInformerFactory(clientset.NewForConfigOrDie(restclient.AddUserAgent(config, "pdb-informers")), resyncPeriod)
 
-	client := clientset.NewForConfigOrDie(restclient.AddUserAgent(&config, "disruption-controller"))
+	client := clientset.NewForConfigOrDie(restclient.AddUserAgent(config, "disruption-controller"))
 
 	discoveryClient := cacheddiscovery.NewMemCacheClient(clientSet.Discovery())
 	mapper := restmapper.NewDeferredDiscoveryRESTMapper(discoveryClient)
 
 	scaleKindResolver := scale.NewDiscoveryScaleKindResolver(client.Discovery())
-	scaleClient, err := scale.NewForConfig(&config, mapper, dynamic.LegacyAPIPathResolverFunc, scaleKindResolver)
+	scaleClient, err := scale.NewForConfig(config, mapper, dynamic.LegacyAPIPathResolverFunc, scaleKindResolver)
 	if err != nil {
 		t.Fatalf("Error in create scaleClient: %v", err)
 	}
@@ -455,7 +441,7 @@ func rmSetup(t *testing.T) (*httptest.Server, framework.CloseFunc, *disruption.D
 		scaleClient,
 		client.Discovery(),
 	)
-	return s, closeFn, rm, informers, clientSet
+	return server.TearDownFn, rm, informers, config, clientSet
 }
 
 // wait for the podInformer to observe the pods. Call this function before

test/integration/framework/controlplane_utils.go

@@ -402,6 +402,9 @@ func NewControlPlaneConfigWithOptions(opts *ControlPlaneConfigOptions) *controlp
 // CloseFunc can be called to cleanup the API server
 type CloseFunc func()
 
+// DEPRECATED: Use StartTestServer or directly StartTestServer directly
+// from cmd/kube-apiserver/app/testing.
+//
 // RunAnAPIServer starts a API server with the provided config.
 func RunAnAPIServer(controlPlaneConfig *controlplane.Config) (*controlplane.Instance, *httptest.Server, CloseFunc) {
 	if controlPlaneConfig == nil {

test/integration/framework/util.go

@@ -66,6 +66,24 @@ func DeleteTestingNamespace(ns *v1.Namespace, t *testing.T) {
 	// cleaning up data they create has no impact.
 }
 
+// CreateNamespaceOrDie creates a namespace.
+func CreateNamespaceOrDie(c clientset.Interface, baseName string, t *testing.T) *v1.Namespace {
+	ns := &v1.Namespace{ObjectMeta: metav1.ObjectMeta{Name: baseName}}
+	result, err := c.CoreV1().Namespaces().Create(context.TODO(), ns, metav1.CreateOptions{})
+	if err != nil {
+		t.Fatalf("Failed to create namespace: %v", err)
+	}
+	return result
+}
+
+// DeleteNamespaceOrDie deletes a namespace.
+func DeleteNamespaceOrDie(c clientset.Interface, ns *v1.Namespace, t *testing.T) {
+	err := c.CoreV1().Namespaces().Delete(context.TODO(), ns.Name, metav1.DeleteOptions{})
+	if err != nil {
+		t.Fatalf("Failed to delete namespace: %v", err)
+	}
+}
+
 // GetReadySchedulableNodes addresses the common use case of getting nodes you can do work on.
 // 1) Needs to be schedulable.
 // 2) Needs to be ready.

test/integration/metrics/metrics_test.go

@@ -20,42 +20,31 @@ import (
 	"context"
 	"errors"
 	"fmt"
-	"io"
-	"net/http"
-	"net/http/httptest"
 	"runtime"
 	"testing"
 
 	"github.com/prometheus/common/model"
 	v1 "k8s.io/api/core/v1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/apimachinery/pkg/runtime/schema"
 	clientset "k8s.io/client-go/kubernetes"
 	restclient "k8s.io/client-go/rest"
 	"k8s.io/component-base/metrics/testutil"
+	kubeapiservertesting "k8s.io/kubernetes/cmd/kube-apiserver/app/testing"
 	"k8s.io/kubernetes/test/integration/framework"
 )
 
-func scrapeMetrics(s *httptest.Server) (testutil.Metrics, error) {
+func scrapeMetrics(s *kubeapiservertesting.TestServer) (testutil.Metrics, error) {
-	req, err := http.NewRequest("GET", s.URL+"/metrics", nil)
+	client, err := clientset.NewForConfig(s.ClientConfig)
 	if err != nil {
-		return nil, fmt.Errorf("Unable to create http request: %v", err)
+		return nil, fmt.Errorf("couldn't create client")
 	}
-	client := &http.Client{}
+
-	resp, err := client.Do(req)
+	body, err := client.RESTClient().Get().AbsPath("metrics").DoRaw(context.TODO())
 	if err != nil {
-		return nil, fmt.Errorf("Unable to contact metrics endpoint of API server: %v", err)
+		return nil, fmt.Errorf("request failed: %v", err)
-	}
-	defer resp.Body.Close()
-	if resp.StatusCode != http.StatusOK {
-		return nil, fmt.Errorf("Non-200 response trying to scrape metrics from API Server: %v", resp)
 	}
 	metrics := testutil.NewMetrics()
-	data, err := io.ReadAll(resp.Body)
+	err = testutil.ParseMetrics(string(body), &metrics)
-	if err != nil {
-		return nil, fmt.Errorf("Unable to read response: %v", resp)
-	}
-	err = testutil.ParseMetrics(string(data), &metrics)
 	return metrics, err
 }
 
@@ -72,8 +61,8 @@ func TestAPIServerProcessMetrics(t *testing.T) {
 		t.Skipf("not supported on GOOS=%s", runtime.GOOS)
 	}
 
-	_, s, closeFn := framework.RunAnAPIServer(nil)
+	s := kubeapiservertesting.StartTestServerOrDie(t, nil, nil, framework.SharedEtcd())
-	defer closeFn()
+	defer s.TearDownFn()
 
 	metrics, err := scrapeMetrics(s)
 	if err != nil {
@@ -88,12 +77,12 @@ func TestAPIServerProcessMetrics(t *testing.T) {
 }
 
 func TestAPIServerMetrics(t *testing.T) {
-	_, s, closeFn := framework.RunAnAPIServer(nil)
+	s := kubeapiservertesting.StartTestServerOrDie(t, nil, nil, framework.SharedEtcd())
-	defer closeFn()
+	defer s.TearDownFn()
 
 	// Make a request to the apiserver to ensure there's at least one data point
 	// for the metrics we're expecting -- otherwise, they won't be exported.
-	client := clientset.NewForConfigOrDie(&restclient.Config{Host: s.URL, ContentConfig: restclient.ContentConfig{GroupVersion: &schema.GroupVersion{Group: "", Version: "v1"}}})
+	client := clientset.NewForConfigOrDie(s.ClientConfig)
 	if _, err := client.CoreV1().Pods(metav1.NamespaceDefault).List(context.TODO(), metav1.ListOptions{}); err != nil {
 		t.Fatalf("unexpected error getting pods: %v", err)
 	}
@@ -116,10 +105,13 @@ func TestAPIServerMetrics(t *testing.T) {
 }
 
 func TestAPIServerMetricsLabels(t *testing.T) {
-	_, s, closeFn := framework.RunAnAPIServer(nil)
+	// Disable ServiceAccount admission plugin as we don't have service account controller running.
-	defer closeFn()
+	s := kubeapiservertesting.StartTestServerOrDie(t, nil, []string{"--disable-admission-plugins=ServiceAccount"}, framework.SharedEtcd())
+	defer s.TearDownFn()
 
-	client, err := clientset.NewForConfig(&restclient.Config{Host: s.URL, QPS: -1})
+	clientConfig := restclient.CopyConfig(s.ClientConfig)
+	clientConfig.QPS = -1
+	client, err := clientset.NewForConfig(clientConfig)
 	if err != nil {
 		t.Fatalf("Error in create clientset: %v", err)
 	}
@@ -266,10 +258,13 @@ func TestAPIServerMetricsPods(t *testing.T) {
 		}
 	}
 
-	_, server, closeFn := framework.RunAnAPIServer(framework.NewControlPlaneConfig())
+	// Disable ServiceAccount admission plugin as we don't have service account controller running.
-	defer closeFn()
+	server := kubeapiservertesting.StartTestServerOrDie(t, nil, []string{"--disable-admission-plugins=ServiceAccount"}, framework.SharedEtcd())
+	defer server.TearDownFn()
 
-	client, err := clientset.NewForConfig(&restclient.Config{Host: server.URL, QPS: -1})
+	clientConfig := restclient.CopyConfig(server.ClientConfig)
+	clientConfig.QPS = -1
+	client, err := clientset.NewForConfig(clientConfig)
 	if err != nil {
 		t.Fatalf("Error in create clientset: %v", err)
 	}
@@ -372,10 +367,12 @@ func TestAPIServerMetricsNamespaces(t *testing.T) {
 		}
 	}
 
-	_, server, closeFn := framework.RunAnAPIServer(framework.NewControlPlaneConfig())
+	server := kubeapiservertesting.StartTestServerOrDie(t, nil, nil, framework.SharedEtcd())
-	defer closeFn()
+	defer server.TearDownFn()
 
-	client, err := clientset.NewForConfig(&restclient.Config{Host: server.URL, QPS: -1})
+	clientConfig := restclient.CopyConfig(server.ClientConfig)
+	clientConfig.QPS = -1
+	client, err := clientset.NewForConfig(clientConfig)
 	if err != nil {
 		t.Fatalf("Error in create clientset: %v", err)
 	}
@@ -462,7 +459,7 @@ func TestAPIServerMetricsNamespaces(t *testing.T) {
 	}
 }
 
-func getSamples(s *httptest.Server) (model.Samples, error) {
+func getSamples(s *kubeapiservertesting.TestServer) (model.Samples, error) {
 	metrics, err := scrapeMetrics(s)
 	if err != nil {
 		return nil, err

test/integration/namespace/ns_conditions_test.go

@@ -35,6 +35,7 @@ import (
 	clientset "k8s.io/client-go/kubernetes"
 	"k8s.io/client-go/metadata"
 	restclient "k8s.io/client-go/rest"
+	kubeapiservertesting "k8s.io/kubernetes/cmd/kube-apiserver/app/testing"
 	"k8s.io/kubernetes/pkg/controller/namespace"
 	"k8s.io/kubernetes/test/integration/etcd"
 	"k8s.io/kubernetes/test/integration/framework"
@@ -164,21 +165,21 @@ func jsonToUnstructured(stub, version, kind string) (*unstructured.Unstructured,
 	return &unstructured.Unstructured{Object: typeMetaAdder}, nil
 }
 
-func namespaceLifecycleSetup(t *testing.T) (framework.CloseFunc, *namespace.NamespaceController, informers.SharedInformerFactory, clientset.Interface, dynamic.Interface) {
+func namespaceLifecycleSetup(t *testing.T) (kubeapiservertesting.TearDownFunc, *namespace.NamespaceController, informers.SharedInformerFactory, clientset.Interface, dynamic.Interface) {
-	controlPlaneConfig := framework.NewIntegrationTestControlPlaneConfig()
+	// Disable ServiceAccount admission plugin as we don't have serviceaccount controller running.
-	_, s, closeFn := framework.RunAnAPIServer(controlPlaneConfig)
+	server := kubeapiservertesting.StartTestServerOrDie(t, nil, []string{"--disable-admission-plugins=ServiceAccount"}, framework.SharedEtcd())
 
-	config := restclient.Config{Host: s.URL}
+	config := restclient.CopyConfig(server.ClientConfig)
 	config.QPS = 10000
 	config.Burst = 10000
-	clientSet, err := clientset.NewForConfig(&config)
+	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)
+	informers := informers.NewSharedInformerFactory(clientset.NewForConfigOrDie(restclient.AddUserAgent(config, "deployment-informers")), resyncPeriod)
 
-	metadataClient, err := metadata.NewForConfig(&config)
+	metadataClient, err := metadata.NewForConfig(config)
 	if err != nil {
 		panic(err)
 	}
@@ -193,5 +194,5 @@ func namespaceLifecycleSetup(t *testing.T) (framework.CloseFunc, *namespace.Name
 		10*time.Hour,
 		corev1.FinalizerKubernetes)
 
-	return closeFn, controller, informers, clientSet, dynamic.NewForConfigOrDie(&config)
+	return server.TearDownFn, controller, informers, clientSet, dynamic.NewForConfigOrDie(config)
 }

test/integration/pods/pods_test.go

@@ -25,26 +25,26 @@ import (
 	v1 "k8s.io/api/core/v1"
 	"k8s.io/apimachinery/pkg/api/errors"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/apimachinery/pkg/runtime/schema"
 	"k8s.io/apimachinery/pkg/types"
 	utilfeature "k8s.io/apiserver/pkg/util/feature"
 	clientset "k8s.io/client-go/kubernetes"
 	typedv1 "k8s.io/client-go/kubernetes/typed/core/v1"
-	restclient "k8s.io/client-go/rest"
 	featuregatetesting "k8s.io/component-base/featuregate/testing"
+	kubeapiservertesting "k8s.io/kubernetes/cmd/kube-apiserver/app/testing"
 	"k8s.io/kubernetes/pkg/features"
 	"k8s.io/kubernetes/test/integration"
 	"k8s.io/kubernetes/test/integration/framework"
 )
 
 func TestPodUpdateActiveDeadlineSeconds(t *testing.T) {
-	_, s, closeFn := framework.RunAnAPIServer(nil)
+	// Disable ServiceAccount admission plugin as we don't have serviceaccount controller running.
-	defer closeFn()
+	server := kubeapiservertesting.StartTestServerOrDie(t, nil, []string{"--disable-admission-plugins=ServiceAccount"}, framework.SharedEtcd())
+	defer server.TearDownFn()
 
-	ns := framework.CreateTestingNamespace("pod-activedeadline-update", t)
+	client := clientset.NewForConfigOrDie(server.ClientConfig)
-	defer framework.DeleteTestingNamespace(ns, t)
 
-	client := clientset.NewForConfigOrDie(&restclient.Config{Host: s.URL, ContentConfig: restclient.ContentConfig{GroupVersion: &schema.GroupVersion{Group: "", Version: "v1"}}})
+	ns := framework.CreateNamespaceOrDie(client, "pod-activedeadline-update", t)
+	defer framework.DeleteNamespaceOrDie(client, ns, t)
 
 	var (
 		iZero = int64(0)
@@ -155,14 +155,15 @@ func TestPodUpdateActiveDeadlineSeconds(t *testing.T) {
 }
 
 func TestPodReadOnlyFilesystem(t *testing.T) {
-	_, s, closeFn := framework.RunAnAPIServer(nil)
+	// Disable ServiceAccount admission plugin as we don't have serviceaccount controller running.
-	defer closeFn()
+	server := kubeapiservertesting.StartTestServerOrDie(t, nil, []string{"--disable-admission-plugins=ServiceAccount"}, framework.SharedEtcd())
+	defer server.TearDownFn()
+
+	client := clientset.NewForConfigOrDie(server.ClientConfig)
 
 	isReadOnly := true
-	ns := framework.CreateTestingNamespace("pod-readonly-root", t)
+	ns := framework.CreateNamespaceOrDie(client, "pod-readonly-root", t)
-	defer framework.DeleteTestingNamespace(ns, t)
+	defer framework.DeleteNamespaceOrDie(client, ns, t)
-
-	client := clientset.NewForConfigOrDie(&restclient.Config{Host: s.URL, ContentConfig: restclient.ContentConfig{GroupVersion: &schema.GroupVersion{Group: "", Version: "v1"}}})
 
 	pod := &v1.Pod{
 		ObjectMeta: metav1.ObjectMeta{
@@ -191,13 +192,14 @@ func TestPodReadOnlyFilesystem(t *testing.T) {
 func TestPodCreateEphemeralContainers(t *testing.T) {
 	defer featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, features.EphemeralContainers, true)()
 
-	_, s, closeFn := framework.RunAnAPIServer(nil)
+	// Disable ServiceAccount admission plugin as we don't have serviceaccount controller running.
-	defer closeFn()
+	server := kubeapiservertesting.StartTestServerOrDie(t, nil, []string{"--disable-admission-plugins=ServiceAccount"}, framework.SharedEtcd())
+	defer server.TearDownFn()
 
-	ns := framework.CreateTestingNamespace("pod-create-ephemeral-containers", t)
+	client := clientset.NewForConfigOrDie(server.ClientConfig)
-	defer framework.DeleteTestingNamespace(ns, t)
 
-	client := clientset.NewForConfigOrDie(&restclient.Config{Host: s.URL, ContentConfig: restclient.ContentConfig{GroupVersion: &schema.GroupVersion{Group: "", Version: "v1"}}})
+	ns := framework.CreateNamespaceOrDie(client, "pod-create-ephemeral-containers", t)
+	defer framework.DeleteNamespaceOrDie(client, ns, t)
 
 	pod := &v1.Pod{
 		ObjectMeta: metav1.ObjectMeta{
@@ -261,13 +263,14 @@ func setUpEphemeralContainers(podsClient typedv1.PodInterface, pod *v1.Pod, cont
 func TestPodPatchEphemeralContainers(t *testing.T) {
 	defer featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, features.EphemeralContainers, true)()
 
-	_, s, closeFn := framework.RunAnAPIServer(nil)
+	// Disable ServiceAccount admission plugin as we don't have serviceaccount controller running.
-	defer closeFn()
+	server := kubeapiservertesting.StartTestServerOrDie(t, nil, []string{"--disable-admission-plugins=ServiceAccount"}, framework.SharedEtcd())
+	defer server.TearDownFn()
 
-	ns := framework.CreateTestingNamespace("pod-patch-ephemeral-containers", t)
+	client := clientset.NewForConfigOrDie(server.ClientConfig)
-	defer framework.DeleteTestingNamespace(ns, t)
 
-	client := clientset.NewForConfigOrDie(&restclient.Config{Host: s.URL, ContentConfig: restclient.ContentConfig{GroupVersion: &schema.GroupVersion{Group: "", Version: "v1"}}})
+	ns := framework.CreateNamespaceOrDie(client, "pod-patch-ephemeral-containers", t)
+	defer framework.DeleteNamespaceOrDie(client, ns, t)
 
 	testPod := func(name string) *v1.Pod {
 		return &v1.Pod{
@@ -493,13 +496,14 @@ func TestPodPatchEphemeralContainers(t *testing.T) {
 func TestPodUpdateEphemeralContainers(t *testing.T) {
 	defer featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, features.EphemeralContainers, true)()
 
-	_, s, closeFn := framework.RunAnAPIServer(nil)
+	// Disable ServiceAccount admission plugin as we don't have serviceaccount controller running.
-	defer closeFn()
+	server := kubeapiservertesting.StartTestServerOrDie(t, nil, []string{"--disable-admission-plugins=ServiceAccount"}, framework.SharedEtcd())
+	defer server.TearDownFn()
 
-	ns := framework.CreateTestingNamespace("pod-update-ephemeral-containers", t)
+	client := clientset.NewForConfigOrDie(server.ClientConfig)
-	defer framework.DeleteTestingNamespace(ns, t)
 
-	client := clientset.NewForConfigOrDie(&restclient.Config{Host: s.URL, ContentConfig: restclient.ContentConfig{GroupVersion: &schema.GroupVersion{Group: "", Version: "v1"}}})
+	ns := framework.CreateNamespaceOrDie(client, "pod-update-ephemeral-containers", t)
+	defer framework.DeleteNamespaceOrDie(client, ns, t)
 
 	testPod := func(name string) *v1.Pod {
 		return &v1.Pod{
@@ -686,13 +690,14 @@ func TestPodUpdateEphemeralContainers(t *testing.T) {
 func TestPodEphemeralContainersDisabled(t *testing.T) {
 	defer featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, features.EphemeralContainers, false)()
 
-	_, s, closeFn := framework.RunAnAPIServer(nil)
+	// Disable ServiceAccount admission plugin as we don't have serviceaccount controller running.
-	defer closeFn()
+	server := kubeapiservertesting.StartTestServerOrDie(t, nil, []string{"--disable-admission-plugins=ServiceAccount"}, framework.SharedEtcd())
+	defer server.TearDownFn()
 
-	ns := framework.CreateTestingNamespace("pod-ephemeral-containers-disabled", t)
+	client := clientset.NewForConfigOrDie(server.ClientConfig)
-	defer framework.DeleteTestingNamespace(ns, t)
 
-	client := clientset.NewForConfigOrDie(&restclient.Config{Host: s.URL, ContentConfig: restclient.ContentConfig{GroupVersion: &schema.GroupVersion{Group: "", Version: "v1"}}})
+	ns := framework.CreateNamespaceOrDie(client, "pod-ephemeral-containers-disabled", t)
+	defer framework.DeleteNamespaceOrDie(client, ns, t)
 
 	pod := &v1.Pod{
 		ObjectMeta: metav1.ObjectMeta{

test/integration/replicaset/replicaset_test.go

@@ -40,6 +40,7 @@ import (
 	"k8s.io/client-go/tools/cache"
 	"k8s.io/client-go/util/retry"
 	featuregatetesting "k8s.io/component-base/featuregate/testing"
+	kubeapiservertesting "k8s.io/kubernetes/cmd/kube-apiserver/app/testing"
 	podutil "k8s.io/kubernetes/pkg/api/v1/pod"
 	"k8s.io/kubernetes/pkg/apis/core"
 	"k8s.io/kubernetes/pkg/controller/replicaset"
@@ -116,38 +117,38 @@ func newMatchingPod(podName, namespace string) *v1.Pod {
 	}
 }
 
-func rmSetup(t *testing.T) (framework.CloseFunc, *replicaset.ReplicaSetController, informers.SharedInformerFactory, clientset.Interface) {
+func rmSetup(t *testing.T) (kubeapiservertesting.TearDownFunc, *replicaset.ReplicaSetController, informers.SharedInformerFactory, clientset.Interface) {
-	controlPlaneConfig := framework.NewIntegrationTestControlPlaneConfig()
+	// Disable ServiceAccount admission plugin as we don't have serviceaccount controller running.
-	_, s, closeFn := framework.RunAnAPIServer(controlPlaneConfig)
+	server := kubeapiservertesting.StartTestServerOrDie(t, nil, []string{"--disable-admission-plugins=ServiceAccount"}, framework.SharedEtcd())
 
-	config := restclient.Config{Host: s.URL}
+	config := restclient.CopyConfig(server.ClientConfig)
-	clientSet, err := clientset.NewForConfig(&config)
+	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, "rs-informers")), resyncPeriod)
+	informers := informers.NewSharedInformerFactory(clientset.NewForConfigOrDie(restclient.AddUserAgent(config, "rs-informers")), resyncPeriod)
 
 	rm := replicaset.NewReplicaSetController(
 		informers.Apps().V1().ReplicaSets(),
 		informers.Core().V1().Pods(),
-		clientset.NewForConfigOrDie(restclient.AddUserAgent(&config, "replicaset-controller")),
+		clientset.NewForConfigOrDie(restclient.AddUserAgent(config, "replicaset-controller")),
 		replicaset.BurstReplicas,
 	)
 
-	return closeFn, rm, informers, clientSet
+	return server.TearDownFn, rm, informers, clientSet
 }
 
-func rmSimpleSetup(t *testing.T) (framework.CloseFunc, clientset.Interface) {
+func rmSimpleSetup(t *testing.T) (kubeapiservertesting.TearDownFunc, clientset.Interface) {
-	controlPlaneConfig := framework.NewIntegrationTestControlPlaneConfig()
+	// Disable ServiceAccount admission plugin as we don't have serviceaccount controller running.
-	_, s, closeFn := framework.RunAnAPIServer(controlPlaneConfig)
+	server := kubeapiservertesting.StartTestServerOrDie(t, nil, []string{"--disable-admission-plugins=ServiceAccount"}, framework.SharedEtcd())
 
-	config := restclient.Config{Host: s.URL}
+	config := restclient.CopyConfig(server.ClientConfig)
-	clientSet, err := clientset.NewForConfig(&config)
+	clientSet, err := clientset.NewForConfig(config)
 	if err != nil {
 		t.Fatalf("Error in create clientset: %v", err)
 	}
-	return closeFn, clientSet
+	return server.TearDownFn, clientSet
 }
 
 // Run RS controller and informers
@@ -424,8 +425,8 @@ func TestAdoption(t *testing.T) {
 		t.Run(tc.name, func(t *testing.T) {
 			closeFn, rm, informers, clientSet := rmSetup(t)
 			defer closeFn()
-			ns := framework.CreateTestingNamespace(fmt.Sprintf("rs-adoption-%d", i), t)
+			ns := framework.CreateNamespaceOrDie(clientSet, fmt.Sprintf("rs-adoption-%d", i), t)
-			defer framework.DeleteTestingNamespace(ns, t)
+			defer framework.DeleteNamespaceOrDie(clientSet, ns, t)
 
 			rsClient := clientSet.AppsV1().ReplicaSets(ns.Name)
 			podClient := clientSet.CoreV1().Pods(ns.Name)
@@ -468,8 +469,8 @@ func TestAdoption(t *testing.T) {
 func TestRSSelectorImmutability(t *testing.T) {
 	closeFn, clientSet := rmSimpleSetup(t)
 	defer closeFn()
-	ns := framework.CreateTestingNamespace("rs-selector-immutability", t)
+	ns := framework.CreateNamespaceOrDie(clientSet, "rs-selector-immutability", t)
-	defer framework.DeleteTestingNamespace(ns, t)
+	defer framework.DeleteNamespaceOrDie(clientSet, ns, t)
 	rs := newRS("rs", ns.Name, 0)
 	createRSsPods(t, clientSet, []*apps.ReplicaSet{rs}, []*v1.Pod{})
 
@@ -495,8 +496,8 @@ func TestRSSelectorImmutability(t *testing.T) {
 func TestSpecReplicasChange(t *testing.T) {
 	closeFn, rm, informers, c := rmSetup(t)
 	defer closeFn()
-	ns := framework.CreateTestingNamespace("test-spec-replicas-change", t)
+	ns := framework.CreateNamespaceOrDie(c, "test-spec-replicas-change", t)
-	defer framework.DeleteTestingNamespace(ns, t)
+	defer framework.DeleteNamespaceOrDie(c, ns, t)
 	stopControllers := runControllerAndInformers(t, rm, informers, 0)
 	defer stopControllers()
 
@@ -537,8 +538,8 @@ func TestSpecReplicasChange(t *testing.T) {
 func TestDeletingAndFailedPods(t *testing.T) {
 	closeFn, rm, informers, c := rmSetup(t)
 	defer closeFn()
-	ns := framework.CreateTestingNamespace("test-deleting-and-failed-pods", t)
+	ns := framework.CreateNamespaceOrDie(c, "test-deleting-and-failed-pods", t)
-	defer framework.DeleteTestingNamespace(ns, t)
+	defer framework.DeleteNamespaceOrDie(c, ns, t)
 	stopControllers := runControllerAndInformers(t, rm, informers, 0)
 	defer stopControllers()
 
@@ -640,8 +641,8 @@ func TestPodDeletionCost(t *testing.T) {
 			defer featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, features.PodDeletionCost, tc.enabled)()
 			closeFn, rm, informers, c := rmSetup(t)
 			defer closeFn()
-			ns := framework.CreateTestingNamespace(tc.name, t)
+			ns := framework.CreateNamespaceOrDie(c, tc.name, t)
-			defer framework.DeleteTestingNamespace(ns, t)
+			defer framework.DeleteNamespaceOrDie(c, ns, t)
 			stopControllers := runControllerAndInformers(t, rm, informers, 0)
 			defer stopControllers()
 
@@ -699,8 +700,8 @@ func TestPodDeletionCost(t *testing.T) {
 func TestOverlappingRSs(t *testing.T) {
 	closeFn, rm, informers, c := rmSetup(t)
 	defer closeFn()
-	ns := framework.CreateTestingNamespace("test-overlapping-rss", t)
+	ns := framework.CreateNamespaceOrDie(c, "test-overlapping-rss", t)
-	defer framework.DeleteTestingNamespace(ns, t)
+	defer framework.DeleteNamespaceOrDie(c, ns, t)
 	stopControllers := runControllerAndInformers(t, rm, informers, 0)
 	defer stopControllers()
 
@@ -734,8 +735,8 @@ func TestOverlappingRSs(t *testing.T) {
 func TestPodOrphaningAndAdoptionWhenLabelsChange(t *testing.T) {
 	closeFn, rm, informers, c := rmSetup(t)
 	defer closeFn()
-	ns := framework.CreateTestingNamespace("test-pod-orphaning-and-adoption-when-labels-change", t)
+	ns := framework.CreateNamespaceOrDie(c, "test-pod-orphaning-and-adoption-when-labels-change", t)
-	defer framework.DeleteTestingNamespace(ns, t)
+	defer framework.DeleteNamespaceOrDie(c, ns, t)
 	stopControllers := runControllerAndInformers(t, rm, informers, 0)
 	defer stopControllers()
 
@@ -811,8 +812,8 @@ func TestPodOrphaningAndAdoptionWhenLabelsChange(t *testing.T) {
 func TestGeneralPodAdoption(t *testing.T) {
 	closeFn, rm, informers, c := rmSetup(t)
 	defer closeFn()
-	ns := framework.CreateTestingNamespace("test-general-pod-adoption", t)
+	ns := framework.CreateNamespaceOrDie(c, "test-general-pod-adoption", t)
-	defer framework.DeleteTestingNamespace(ns, t)
+	defer framework.DeleteNamespaceOrDie(c, ns, t)
 	stopControllers := runControllerAndInformers(t, rm, informers, 0)
 	defer stopControllers()
 
@@ -843,8 +844,8 @@ func TestGeneralPodAdoption(t *testing.T) {
 func TestReadyAndAvailableReplicas(t *testing.T) {
 	closeFn, rm, informers, c := rmSetup(t)
 	defer closeFn()
-	ns := framework.CreateTestingNamespace("test-ready-and-available-replicas", t)
+	ns := framework.CreateNamespaceOrDie(c, "test-ready-and-available-replicas", t)
-	defer framework.DeleteTestingNamespace(ns, t)
+	defer framework.DeleteNamespaceOrDie(c, ns, t)
 	stopControllers := runControllerAndInformers(t, rm, informers, 0)
 	defer stopControllers()
 
@@ -895,8 +896,8 @@ func TestReadyAndAvailableReplicas(t *testing.T) {
 func TestRSScaleSubresource(t *testing.T) {
 	closeFn, rm, informers, c := rmSetup(t)
 	defer closeFn()
-	ns := framework.CreateTestingNamespace("test-rs-scale-subresource", t)
+	ns := framework.CreateNamespaceOrDie(c, "test-rs-scale-subresource", t)
-	defer framework.DeleteTestingNamespace(ns, t)
+	defer framework.DeleteNamespaceOrDie(c, ns, t)
 	stopControllers := runControllerAndInformers(t, rm, informers, 0)
 	defer stopControllers()
 
@@ -914,8 +915,8 @@ func TestRSScaleSubresource(t *testing.T) {
 func TestExtraPodsAdoptionAndDeletion(t *testing.T) {
 	closeFn, rm, informers, c := rmSetup(t)
 	defer closeFn()
-	ns := framework.CreateTestingNamespace("test-extra-pods-adoption-and-deletion", t)
+	ns := framework.CreateNamespaceOrDie(c, "test-extra-pods-adoption-and-deletion", t)
-	defer framework.DeleteTestingNamespace(ns, t)
+	defer framework.DeleteNamespaceOrDie(c, ns, t)
 
 	rs := newRS("rs", ns.Name, 2)
 	// Create 3 pods, RS should adopt only 2 of them
@@ -946,8 +947,8 @@ func TestExtraPodsAdoptionAndDeletion(t *testing.T) {
 func TestFullyLabeledReplicas(t *testing.T) {
 	closeFn, rm, informers, c := rmSetup(t)
 	defer closeFn()
-	ns := framework.CreateTestingNamespace("test-fully-labeled-replicas", t)
+	ns := framework.CreateNamespaceOrDie(c, "test-fully-labeled-replicas", t)
-	defer framework.DeleteTestingNamespace(ns, t)
+	defer framework.DeleteNamespaceOrDie(c, ns, t)
 	stopControllers := runControllerAndInformers(t, rm, informers, 0)
 	defer stopControllers()
 
@@ -989,8 +990,8 @@ func TestFullyLabeledReplicas(t *testing.T) {
 func TestReplicaSetsAppsV1DefaultGCPolicy(t *testing.T) {
 	closeFn, rm, informers, c := rmSetup(t)
 	defer closeFn()
-	ns := framework.CreateTestingNamespace("test-default-gc-v1", t)
+	ns := framework.CreateNamespaceOrDie(c, "test-default-gc-v1", t)
-	defer framework.DeleteTestingNamespace(ns, t)
+	defer framework.DeleteNamespaceOrDie(c, ns, t)
 	stopControllers := runControllerAndInformers(t, rm, informers, 0)
 	defer stopControllers()
 

test/integration/replicationcontroller/replicationcontroller_test.go

@@ -38,6 +38,7 @@ import (
 	"k8s.io/client-go/tools/cache"
 	"k8s.io/client-go/util/retry"
 	featuregatetesting "k8s.io/component-base/featuregate/testing"
+	kubeapiservertesting "k8s.io/kubernetes/cmd/kube-apiserver/app/testing"
 	podutil "k8s.io/kubernetes/pkg/api/v1/pod"
 	"k8s.io/kubernetes/pkg/controller/replication"
 	"k8s.io/kubernetes/pkg/features"
@@ -109,26 +110,26 @@ func newMatchingPod(podName, namespace string) *v1.Pod {
 	}
 }
 
-func rmSetup(t *testing.T) (framework.CloseFunc, *replication.ReplicationManager, informers.SharedInformerFactory, clientset.Interface) {
+func rmSetup(t *testing.T) (kubeapiservertesting.TearDownFunc, *replication.ReplicationManager, informers.SharedInformerFactory, clientset.Interface) {
-	controlPlaneConfig := framework.NewIntegrationTestControlPlaneConfig()
+	// Disable ServiceAccount admission plugin as we don't have serviceaccount controller running.
-	_, s, closeFn := framework.RunAnAPIServer(controlPlaneConfig)
+	server := kubeapiservertesting.StartTestServerOrDie(t, nil, []string{"--disable-admission-plugins=ServiceAccount"}, framework.SharedEtcd())
 
-	config := restclient.Config{Host: s.URL}
+	config := restclient.CopyConfig(server.ClientConfig)
-	clientSet, err := clientset.NewForConfig(&config)
+	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, "rc-informers")), resyncPeriod)
+	informers := informers.NewSharedInformerFactory(clientset.NewForConfigOrDie(restclient.AddUserAgent(config, "rc-informers")), resyncPeriod)
 
 	rm := replication.NewReplicationManager(
 		informers.Core().V1().Pods(),
 		informers.Core().V1().ReplicationControllers(),
-		clientset.NewForConfigOrDie(restclient.AddUserAgent(&config, "replication-controller")),
+		clientset.NewForConfigOrDie(restclient.AddUserAgent(config, "replication-controller")),
 		replication.BurstReplicas,
 	)
 
-	return closeFn, rm, informers, clientSet
+	return server.TearDownFn, rm, informers, clientSet
 }
 
 // Run RC controller and informers
@@ -412,8 +413,8 @@ func TestAdoption(t *testing.T) {
 		t.Run(tc.name, func(t *testing.T) {
 			closeFn, rm, informers, clientSet := rmSetup(t)
 			defer closeFn()
-			ns := framework.CreateTestingNamespace(fmt.Sprintf("rc-adoption-%d", i), t)
+			ns := framework.CreateNamespaceOrDie(clientSet, fmt.Sprintf("rc-adoption-%d", i), t)
-			defer framework.DeleteTestingNamespace(ns, t)
+			defer framework.DeleteNamespaceOrDie(clientSet, ns, t)
 
 			rcClient := clientSet.CoreV1().ReplicationControllers(ns.Name)
 			podClient := clientSet.CoreV1().Pods(ns.Name)
@@ -455,8 +456,8 @@ func TestAdoption(t *testing.T) {
 func TestSpecReplicasChange(t *testing.T) {
 	closeFn, rm, informers, c := rmSetup(t)
 	defer closeFn()
-	ns := framework.CreateTestingNamespace("test-spec-replicas-change", t)
+	ns := framework.CreateNamespaceOrDie(c, "test-spec-replicas-change", t)
-	defer framework.DeleteTestingNamespace(ns, t)
+	defer framework.DeleteNamespaceOrDie(c, ns, t)
 	stopControllers := runControllerAndInformers(t, rm, informers, 0)
 	defer stopControllers()
 
@@ -498,8 +499,8 @@ func TestLogarithmicScaleDown(t *testing.T) {
 	defer featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, features.LogarithmicScaleDown, true)()
 	closeFn, rm, informers, c := rmSetup(t)
 	defer closeFn()
-	ns := framework.CreateTestingNamespace("test-spec-replicas-change", t)
+	ns := framework.CreateNamespaceOrDie(c, "test-spec-replicas-change", t)
-	defer framework.DeleteTestingNamespace(ns, t)
+	defer framework.DeleteNamespaceOrDie(c, ns, t)
 	stopControllers := runControllerAndInformers(t, rm, informers, 0)
 	defer stopControllers()
 
@@ -535,8 +536,8 @@ func TestLogarithmicScaleDown(t *testing.T) {
 func TestDeletingAndFailedPods(t *testing.T) {
 	closeFn, rm, informers, c := rmSetup(t)
 	defer closeFn()
-	ns := framework.CreateTestingNamespace("test-deleting-and-failed-pods", t)
+	ns := framework.CreateNamespaceOrDie(c, "test-deleting-and-failed-pods", t)
-	defer framework.DeleteTestingNamespace(ns, t)
+	defer framework.DeleteNamespaceOrDie(c, ns, t)
 	stopControllers := runControllerAndInformers(t, rm, informers, 0)
 	defer stopControllers()
 
@@ -600,8 +601,8 @@ func TestDeletingAndFailedPods(t *testing.T) {
 func TestOverlappingRCs(t *testing.T) {
 	closeFn, rm, informers, c := rmSetup(t)
 	defer closeFn()
-	ns := framework.CreateTestingNamespace("test-overlapping-rcs", t)
+	ns := framework.CreateNamespaceOrDie(c, "test-overlapping-rcs", t)
-	defer framework.DeleteTestingNamespace(ns, t)
+	defer framework.DeleteNamespaceOrDie(c, ns, t)
 	stopControllers := runControllerAndInformers(t, rm, informers, 0)
 	defer stopControllers()
 
@@ -635,8 +636,8 @@ func TestOverlappingRCs(t *testing.T) {
 func TestPodOrphaningAndAdoptionWhenLabelsChange(t *testing.T) {
 	closeFn, rm, informers, c := rmSetup(t)
 	defer closeFn()
-	ns := framework.CreateTestingNamespace("test-pod-orphaning-and-adoption-when-labels-change", t)
+	ns := framework.CreateNamespaceOrDie(c, "test-pod-orphaning-and-adoption-when-labels-change", t)
-	defer framework.DeleteTestingNamespace(ns, t)
+	defer framework.DeleteNamespaceOrDie(c, ns, t)
 	stopControllers := runControllerAndInformers(t, rm, informers, 0)
 	defer stopControllers()
 
@@ -712,8 +713,8 @@ func TestPodOrphaningAndAdoptionWhenLabelsChange(t *testing.T) {
 func TestGeneralPodAdoption(t *testing.T) {
 	closeFn, rm, informers, c := rmSetup(t)
 	defer closeFn()
-	ns := framework.CreateTestingNamespace("test-general-pod-adoption", t)
+	ns := framework.CreateNamespaceOrDie(c, "test-general-pod-adoption", t)
-	defer framework.DeleteTestingNamespace(ns, t)
+	defer framework.DeleteNamespaceOrDie(c, ns, t)
 	stopControllers := runControllerAndInformers(t, rm, informers, 0)
 	defer stopControllers()
 
@@ -744,8 +745,8 @@ func TestGeneralPodAdoption(t *testing.T) {
 func TestReadyAndAvailableReplicas(t *testing.T) {
 	closeFn, rm, informers, c := rmSetup(t)
 	defer closeFn()
-	ns := framework.CreateTestingNamespace("test-ready-and-available-replicas", t)
+	ns := framework.CreateNamespaceOrDie(c, "test-ready-and-available-replicas", t)
-	defer framework.DeleteTestingNamespace(ns, t)
+	defer framework.DeleteNamespaceOrDie(c, ns, t)
 	stopControllers := runControllerAndInformers(t, rm, informers, 0)
 	defer stopControllers()
 
@@ -796,8 +797,8 @@ func TestReadyAndAvailableReplicas(t *testing.T) {
 func TestRCScaleSubresource(t *testing.T) {
 	closeFn, rm, informers, c := rmSetup(t)
 	defer closeFn()
-	ns := framework.CreateTestingNamespace("test-rc-scale-subresource", t)
+	ns := framework.CreateNamespaceOrDie(c, "test-rc-scale-subresource", t)
-	defer framework.DeleteTestingNamespace(ns, t)
+	defer framework.DeleteNamespaceOrDie(c, ns, t)
 	stopControllers := runControllerAndInformers(t, rm, informers, 0)
 	defer stopControllers()
 
@@ -815,8 +816,8 @@ func TestRCScaleSubresource(t *testing.T) {
 func TestExtraPodsAdoptionAndDeletion(t *testing.T) {
 	closeFn, rm, informers, c := rmSetup(t)
 	defer closeFn()
-	ns := framework.CreateTestingNamespace("test-extra-pods-adoption-and-deletion", t)
+	ns := framework.CreateNamespaceOrDie(c, "test-extra-pods-adoption-and-deletion", t)
-	defer framework.DeleteTestingNamespace(ns, t)
+	defer framework.DeleteNamespaceOrDie(c, ns, t)
 
 	rc := newRC("rc", ns.Name, 2)
 	// Create 3 pods, RC should adopt only 2 of them
@@ -847,8 +848,8 @@ func TestExtraPodsAdoptionAndDeletion(t *testing.T) {
 func TestFullyLabeledReplicas(t *testing.T) {
 	closeFn, rm, informers, c := rmSetup(t)
 	defer closeFn()
-	ns := framework.CreateTestingNamespace("test-fully-labeled-replicas", t)
+	ns := framework.CreateNamespaceOrDie(c, "test-fully-labeled-replicas", t)
-	defer framework.DeleteTestingNamespace(ns, t)
+	defer framework.DeleteNamespaceOrDie(c, ns, t)
 	stopControllers := runControllerAndInformers(t, rm, informers, 0)
 	defer stopControllers()
 

test/integration/secrets/secrets_test.go

@@ -24,9 +24,8 @@ import (
 
 	"k8s.io/api/core/v1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/apimachinery/pkg/runtime/schema"
 	clientset "k8s.io/client-go/kubernetes"
-	restclient "k8s.io/client-go/rest"
+	kubeapiservertesting "k8s.io/kubernetes/cmd/kube-apiserver/app/testing"
 	"k8s.io/kubernetes/test/integration"
 	"k8s.io/kubernetes/test/integration/framework"
 )
@@ -39,13 +38,14 @@ func deleteSecretOrErrorf(t *testing.T, c clientset.Interface, ns, name string)
 
 // TestSecrets tests apiserver-side behavior of creation of secret objects and their use by pods.
 func TestSecrets(t *testing.T) {
-	_, s, closeFn := framework.RunAnAPIServer(nil)
+	// Disable ServiceAccount admission plugin as we don't have serviceaccount controller running.
-	defer closeFn()
+	server := kubeapiservertesting.StartTestServerOrDie(t, nil, []string{"--disable-admission-plugins=ServiceAccount"}, framework.SharedEtcd())
+	defer server.TearDownFn()
 
-	client := clientset.NewForConfigOrDie(&restclient.Config{Host: s.URL, ContentConfig: restclient.ContentConfig{GroupVersion: &schema.GroupVersion{Group: "", Version: "v1"}}})
+	client := clientset.NewForConfigOrDie(server.ClientConfig)
 
-	ns := framework.CreateTestingNamespace("secret", t)
+	ns := framework.CreateNamespaceOrDie(client, "secret", t)
-	defer framework.DeleteTestingNamespace(ns, t)
+	defer framework.DeleteNamespaceOrDie(client, ns, t)
 
 	DoTestSecrets(t, client, ns)
 }

test/integration/service/loadbalancer_test.go

@@ -26,9 +26,9 @@ import (
 	utilfeature "k8s.io/apiserver/pkg/util/feature"
 	"k8s.io/client-go/informers"
 	clientset "k8s.io/client-go/kubernetes"
-	restclient "k8s.io/client-go/rest"
 	servicecontroller "k8s.io/cloud-provider/controllers/service"
 	fakecloud "k8s.io/cloud-provider/fake"
+	kubeapiservertesting "k8s.io/kubernetes/cmd/kube-apiserver/app/testing"
 	"k8s.io/kubernetes/test/integration/framework"
 	utilpointer "k8s.io/utils/pointer"
 )
@@ -36,19 +36,16 @@ import (
 // Test_ServiceLoadBalancerAllocateNodePorts tests that a Service with spec.allocateLoadBalancerNodePorts=false
 // does not allocate node ports for the Service.
 func Test_ServiceLoadBalancerDisableAllocateNodePorts(t *testing.T) {
+	server := kubeapiservertesting.StartTestServerOrDie(t, nil, nil, framework.SharedEtcd())
+	defer server.TearDownFn()
 
-	controlPlaneConfig := framework.NewIntegrationTestControlPlaneConfig()
+	client, err := clientset.NewForConfig(server.ClientConfig)
-	_, server, closeFn := framework.RunAnAPIServer(controlPlaneConfig)
-	defer closeFn()
-
-	config := restclient.Config{Host: server.URL}
-	client, err := clientset.NewForConfig(&config)
 	if err != nil {
 		t.Fatalf("Error creating clientset: %v", err)
 	}
 
-	ns := framework.CreateTestingNamespace("test-service-allocate-node-ports", t)
+	ns := framework.CreateNamespaceOrDie(client, "test-service-allocate-node-ports", t)
-	defer framework.DeleteTestingNamespace(ns, t)
+	defer framework.DeleteNamespaceOrDie(client, ns, t)
 
 	service := &corev1.Service{
 		ObjectMeta: metav1.ObjectMeta{
@@ -79,19 +76,16 @@ func Test_ServiceLoadBalancerDisableAllocateNodePorts(t *testing.T) {
 // Test_ServiceUpdateLoadBalancerAllocateNodePorts tests that a Service that is updated from ClusterIP to LoadBalancer
 // with spec.allocateLoadBalancerNodePorts=false does not allocate node ports for the Service
 func Test_ServiceUpdateLoadBalancerDisableAllocateNodePorts(t *testing.T) {
+	server := kubeapiservertesting.StartTestServerOrDie(t, nil, nil, framework.SharedEtcd())
+	defer server.TearDownFn()
 
-	controlPlaneConfig := framework.NewIntegrationTestControlPlaneConfig()
+	client, err := clientset.NewForConfig(server.ClientConfig)
-	_, server, closeFn := framework.RunAnAPIServer(controlPlaneConfig)
-	defer closeFn()
-
-	config := restclient.Config{Host: server.URL}
-	client, err := clientset.NewForConfig(&config)
 	if err != nil {
 		t.Fatalf("Error creating clientset: %v", err)
 	}
 
-	ns := framework.CreateTestingNamespace("test-service-allocate-node-ports", t)
+	ns := framework.CreateNamespaceOrDie(client, "test-service-allocate-node-ports", t)
-	defer framework.DeleteTestingNamespace(ns, t)
+	defer framework.DeleteNamespaceOrDie(client, ns, t)
 
 	service := &corev1.Service{
 		ObjectMeta: metav1.ObjectMeta{
@@ -132,19 +126,16 @@ func Test_ServiceUpdateLoadBalancerDisableAllocateNodePorts(t *testing.T) {
 // Test_ServiceLoadBalancerSwitchToDeallocatedNodePorts test that switching a Service
 // to spec.allocateLoadBalancerNodePorts=false, does not de-allocate existing node ports.
 func Test_ServiceLoadBalancerEnableThenDisableAllocatedNodePorts(t *testing.T) {
+	server := kubeapiservertesting.StartTestServerOrDie(t, nil, nil, framework.SharedEtcd())
+	defer server.TearDownFn()
 
-	controlPlaneConfig := framework.NewIntegrationTestControlPlaneConfig()
+	client, err := clientset.NewForConfig(server.ClientConfig)
-	_, server, closeFn := framework.RunAnAPIServer(controlPlaneConfig)
-	defer closeFn()
-
-	config := restclient.Config{Host: server.URL}
-	client, err := clientset.NewForConfig(&config)
 	if err != nil {
 		t.Fatalf("Error creating clientset: %v", err)
 	}
 
-	ns := framework.CreateTestingNamespace("test-service-deallocate-node-ports", t)
+	ns := framework.CreateNamespaceOrDie(client, "test-service-deallocate-node-ports", t)
-	defer framework.DeleteTestingNamespace(ns, t)
+	defer framework.DeleteNamespaceOrDie(client, ns, t)
 
 	service := &corev1.Service{
 		ObjectMeta: metav1.ObjectMeta{
@@ -185,19 +176,16 @@ func Test_ServiceLoadBalancerEnableThenDisableAllocatedNodePorts(t *testing.T) {
 // Test_ServiceLoadBalancerDisableThenEnableAllocatedNodePorts test that switching a Service
 // to spec.allocateLoadBalancerNodePorts=true from false, allocate new node ports.
 func Test_ServiceLoadBalancerDisableThenEnableAllocatedNodePorts(t *testing.T) {
+	server := kubeapiservertesting.StartTestServerOrDie(t, nil, nil, framework.SharedEtcd())
+	defer server.TearDownFn()
 
-	controlPlaneConfig := framework.NewIntegrationTestControlPlaneConfig()
+	client, err := clientset.NewForConfig(server.ClientConfig)
-	_, server, closeFn := framework.RunAnAPIServer(controlPlaneConfig)
-	defer closeFn()
-
-	config := restclient.Config{Host: server.URL}
-	client, err := clientset.NewForConfig(&config)
 	if err != nil {
 		t.Fatalf("Error creating clientset: %v", err)
 	}
 
-	ns := framework.CreateTestingNamespace("test-service-reallocate-node-ports", t)
+	ns := framework.CreateNamespaceOrDie(client, "test-service-reallocate-node-ports", t)
-	defer framework.DeleteTestingNamespace(ns, t)
+	defer framework.DeleteNamespaceOrDie(client, ns, t)
 
 	service := &corev1.Service{
 		ObjectMeta: metav1.ObjectMeta{
@@ -248,19 +236,16 @@ func serviceHasNodePorts(svc *corev1.Service) bool {
 // Test_ServiceLoadBalancerEnableLoadBalancerClass tests that when a LoadBalancer
 // type of service has spec.LoadBalancerClass set, cloud provider should not create default load balancer.
 func Test_ServiceLoadBalancerEnableLoadBalancerClass(t *testing.T) {
+	server := kubeapiservertesting.StartTestServerOrDie(t, nil, nil, framework.SharedEtcd())
+	defer server.TearDownFn()
 
-	controlPlaneConfig := framework.NewIntegrationTestControlPlaneConfig()
+	client, err := clientset.NewForConfig(server.ClientConfig)
-	_, server, closeFn := framework.RunAnAPIServer(controlPlaneConfig)
-	defer closeFn()
-
-	config := restclient.Config{Host: server.URL}
-	client, err := clientset.NewForConfig(&config)
 	if err != nil {
 		t.Fatalf("Error creating clientset: %v", err)
 	}
 
-	ns := framework.CreateTestingNamespace("test-service-load-balancer-class", t)
+	ns := framework.CreateNamespaceOrDie(client, "test-service-load-balancer-class", t)
-	defer framework.DeleteTestingNamespace(ns, t)
+	defer framework.DeleteNamespaceOrDie(client, ns, t)
 
 	controller, cloud, informer := newServiceController(t, client)
 
@@ -297,19 +282,16 @@ func Test_ServiceLoadBalancerEnableLoadBalancerClass(t *testing.T) {
 // type of service has spec.LoadBalancerClass set, it should be immutable as long as the service type
 // is still LoadBalancer.
 func Test_SetLoadBalancerClassThenUpdateLoadBalancerClass(t *testing.T) {
+	server := kubeapiservertesting.StartTestServerOrDie(t, nil, nil, framework.SharedEtcd())
+	defer server.TearDownFn()
 
-	controlPlaneConfig := framework.NewIntegrationTestControlPlaneConfig()
+	client, err := clientset.NewForConfig(server.ClientConfig)
-	_, server, closeFn := framework.RunAnAPIServer(controlPlaneConfig)
-	defer closeFn()
-
-	config := restclient.Config{Host: server.URL}
-	client, err := clientset.NewForConfig(&config)
 	if err != nil {
 		t.Fatalf("Error creating clientset: %v", err)
 	}
 
-	ns := framework.CreateTestingNamespace("test-service-immutable-load-balancer-class", t)
+	ns := framework.CreateNamespaceOrDie(client, "test-service-immutable-load-balancer-class", t)
-	defer framework.DeleteTestingNamespace(ns, t)
+	defer framework.DeleteNamespaceOrDie(client, ns, t)
 
 	controller, cloud, informer := newServiceController(t, client)
 
@@ -351,19 +333,16 @@ func Test_SetLoadBalancerClassThenUpdateLoadBalancerClass(t *testing.T) {
 // Test_UpdateLoadBalancerWithLoadBalancerClass tests that when a Load Balancer type of Service that
 // is updated from non loadBalancerClass set to loadBalancerClass set, it should be not allowed.
 func Test_UpdateLoadBalancerWithLoadBalancerClass(t *testing.T) {
+	server := kubeapiservertesting.StartTestServerOrDie(t, nil, nil, framework.SharedEtcd())
+	defer server.TearDownFn()
 
-	controlPlaneConfig := framework.NewIntegrationTestControlPlaneConfig()
+	client, err := clientset.NewForConfig(server.ClientConfig)
-	_, server, closeFn := framework.RunAnAPIServer(controlPlaneConfig)
-	defer closeFn()
-
-	config := restclient.Config{Host: server.URL}
-	client, err := clientset.NewForConfig(&config)
 	if err != nil {
 		t.Fatalf("Error creating clientset: %v", err)
 	}
 
-	ns := framework.CreateTestingNamespace("test-service-update-load-balancer-class", t)
+	ns := framework.CreateNamespaceOrDie(client, "test-service-update-load-balancer-class", t)
-	defer framework.DeleteTestingNamespace(ns, t)
+	defer framework.DeleteNamespaceOrDie(client, ns, t)
 
 	controller, cloud, informer := newServiceController(t, client)
 

test/integration/service/service_test.go

@@ -23,7 +23,7 @@ import (
 	corev1 "k8s.io/api/core/v1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	clientset "k8s.io/client-go/kubernetes"
-	restclient "k8s.io/client-go/rest"
+	kubeapiservertesting "k8s.io/kubernetes/cmd/kube-apiserver/app/testing"
 	"k8s.io/kubernetes/test/integration/framework"
 )
 
@@ -32,18 +32,16 @@ import (
 // the internalTrafficPolicy field was being defaulted in older versions. New versions stop defauting the
 // field and drop on read, but for compatibility reasons we still accept the field.
 func Test_ExternalNameServiceStopsDefaultingInternalTrafficPolicy(t *testing.T) {
-	controlPlaneConfig := framework.NewIntegrationTestControlPlaneConfig()
+	server := kubeapiservertesting.StartTestServerOrDie(t, nil, nil, framework.SharedEtcd())
-	_, server, closeFn := framework.RunAnAPIServer(controlPlaneConfig)
+	defer server.TearDownFn()
-	defer closeFn()
 
-	config := restclient.Config{Host: server.URL}
+	client, err := clientset.NewForConfig(server.ClientConfig)
-	client, err := clientset.NewForConfig(&config)
 	if err != nil {
 		t.Fatalf("Error creating clientset: %v", err)
 	}
 
-	ns := framework.CreateTestingNamespace("test-external-name-drops-internal-traffic-policy", t)
+	ns := framework.CreateNamespaceOrDie(client, "test-external-name-drops-internal-traffic-policy", t)
-	defer framework.DeleteTestingNamespace(ns, t)
+	defer framework.DeleteNamespaceOrDie(client, ns, t)
 
 	service := &corev1.Service{
 		ObjectMeta: metav1.ObjectMeta{
@@ -78,18 +76,16 @@ func Test_ExternalNameServiceStopsDefaultingInternalTrafficPolicy(t *testing.T)
 // but drops the field on read. This test exists due to historic reasons where the internalTrafficPolicy field was being defaulted
 // in older versions. New versions stop defauting the field and drop on read, but for compatibility reasons we still accept the field.
 func Test_ExternalNameServiceDropsInternalTrafficPolicy(t *testing.T) {
-	controlPlaneConfig := framework.NewIntegrationTestControlPlaneConfig()
+	server := kubeapiservertesting.StartTestServerOrDie(t, nil, nil, framework.SharedEtcd())
-	_, server, closeFn := framework.RunAnAPIServer(controlPlaneConfig)
+	defer server.TearDownFn()
-	defer closeFn()
 
-	config := restclient.Config{Host: server.URL}
+	client, err := clientset.NewForConfig(server.ClientConfig)
-	client, err := clientset.NewForConfig(&config)
 	if err != nil {
 		t.Fatalf("Error creating clientset: %v", err)
 	}
 
-	ns := framework.CreateTestingNamespace("test-external-name-drops-internal-traffic-policy", t)
+	ns := framework.CreateNamespaceOrDie(client, "test-external-name-drops-internal-traffic-policy", t)
-	defer framework.DeleteTestingNamespace(ns, t)
+	defer framework.DeleteNamespaceOrDie(client, ns, t)
 
 	internalTrafficPolicy := corev1.ServiceInternalTrafficPolicyCluster
 	service := &corev1.Service{
@@ -127,18 +123,16 @@ func Test_ExternalNameServiceDropsInternalTrafficPolicy(t *testing.T) {
 // field was being defaulted in older versions. New versions stop defauting the field and drop on read, but for compatibility reasons
 // we still accept the field.
 func Test_ConvertingToExternalNameServiceDropsInternalTrafficPolicy(t *testing.T) {
-	controlPlaneConfig := framework.NewIntegrationTestControlPlaneConfig()
+	server := kubeapiservertesting.StartTestServerOrDie(t, nil, nil, framework.SharedEtcd())
-	_, server, closeFn := framework.RunAnAPIServer(controlPlaneConfig)
+	defer server.TearDownFn()
-	defer closeFn()
 
-	config := restclient.Config{Host: server.URL}
+	client, err := clientset.NewForConfig(server.ClientConfig)
-	client, err := clientset.NewForConfig(&config)
 	if err != nil {
 		t.Fatalf("Error creating clientset: %v", err)
 	}
 
-	ns := framework.CreateTestingNamespace("test-external-name-drops-internal-traffic-policy", t)
+	ns := framework.CreateNamespaceOrDie(client, "test-external-name-drops-internal-traffic-policy", t)
-	defer framework.DeleteTestingNamespace(ns, t)
+	defer framework.DeleteNamespaceOrDie(client, ns, t)
 
 	service := &corev1.Service{
 		ObjectMeta: metav1.ObjectMeta{

test/integration/service/upgrade_test.go

@@ -31,8 +31,7 @@ import (
 
 func Test_UpgradeService(t *testing.T) {
 	etcdOptions := framework.SharedEtcd()
-	apiServerOptions := kubeapiservertesting.NewDefaultTestServerOptions()
+	s := kubeapiservertesting.StartTestServerOrDie(t, nil, nil, etcdOptions)
-	s := kubeapiservertesting.StartTestServerOrDie(t, apiServerOptions, nil, etcdOptions)
 	defer s.TearDownFn()
 	serviceName := "test-old-service"
 	ns := "old-service-ns"

test/integration/storageclasses/storage_classes_test.go

@@ -26,9 +26,8 @@ import (
 	storage "k8s.io/api/storage/v1"
 	"k8s.io/apimachinery/pkg/api/resource"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/apimachinery/pkg/runtime/schema"
 	clientset "k8s.io/client-go/kubernetes"
-	restclient "k8s.io/client-go/rest"
+	kubeapiservertesting "k8s.io/kubernetes/cmd/kube-apiserver/app/testing"
 	"k8s.io/kubernetes/test/integration/framework"
 )
 
@@ -36,13 +35,13 @@ const provisionerPluginName = "kubernetes.io/mock-provisioner"
 
 // TestStorageClasses tests apiserver-side behavior of creation of storage class objects and their use by pvcs.
 func TestStorageClasses(t *testing.T) {
-	_, s, closeFn := framework.RunAnAPIServer(nil)
+	server := kubeapiservertesting.StartTestServerOrDie(t, nil, []string{"--disable-admission-plugins=StorageObjectInUseProtection"}, framework.SharedEtcd())
-	defer closeFn()
+	defer server.TearDownFn()
 
-	client := clientset.NewForConfigOrDie(&restclient.Config{Host: s.URL, ContentConfig: restclient.ContentConfig{GroupVersion: &schema.GroupVersion{Group: "", Version: "v1"}}})
+	client := clientset.NewForConfigOrDie(server.ClientConfig)
 
-	ns := framework.CreateTestingNamespace("storageclass", t)
+	ns := framework.CreateNamespaceOrDie(client, "storageclass", t)
-	defer framework.DeleteTestingNamespace(ns, t)
+	defer framework.DeleteNamespaceOrDie(client, ns, t)
 
 	DoTestStorageClasses(t, client, ns)
 }

test/integration/ttlcontroller/ttlcontroller_test.go

@@ -19,7 +19,6 @@ package ttlcontroller
 import (
 	"context"
 	"fmt"
-	"net/http/httptest"
 	"strconv"
 	"sync"
 	"testing"
@@ -33,17 +32,16 @@ import (
 	clientset "k8s.io/client-go/kubernetes"
 	listers "k8s.io/client-go/listers/core/v1"
 	restclient "k8s.io/client-go/rest"
+	kubeapiservertesting "k8s.io/kubernetes/cmd/kube-apiserver/app/testing"
 	"k8s.io/kubernetes/pkg/controller/ttl"
 	"k8s.io/kubernetes/test/integration/framework"
 )
 
-func createClientAndInformers(t *testing.T, server *httptest.Server) (*clientset.Clientset, informers.SharedInformerFactory) {
+func createClientAndInformers(t *testing.T, server *kubeapiservertesting.TestServer) (*clientset.Clientset, informers.SharedInformerFactory) {
-	config := restclient.Config{
+	config := restclient.CopyConfig(server.ClientConfig)
-		Host:  server.URL,
+	config.QPS = 500
-		QPS:   500,
+	config.Burst = 500
-		Burst: 500,
+	testClient := clientset.NewForConfigOrDie(config)
-	}
-	testClient := clientset.NewForConfigOrDie(&config)
 
 	informers := informers.NewSharedInformerFactory(testClient, time.Second)
 	return testClient, informers
@@ -134,8 +132,8 @@ func waitForNodesWithTTLAnnotation(t *testing.T, nodeLister listers.NodeLister,
 
 // Test whether ttlcontroller sets correct ttl annotations.
 func TestTTLAnnotations(t *testing.T) {
-	_, server, closeFn := framework.RunAnAPIServer(nil)
+	server := kubeapiservertesting.StartTestServerOrDie(t, nil, nil, framework.SharedEtcd())
-	defer closeFn()
+	defer server.TearDownFn()
 
 	testClient, informers := createClientAndInformers(t, server)
 	nodeInformer := informers.Core().V1().Nodes()

test/integration/volume/attach_detach_test.go

@@ -19,14 +19,12 @@ package volume
 import (
 	"context"
 	"fmt"
-	"net/http/httptest"
 	"testing"
 	"time"
 
 	v1 "k8s.io/api/core/v1"
 	"k8s.io/apimachinery/pkg/api/resource"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/apimachinery/pkg/runtime/schema"
 	"k8s.io/apimachinery/pkg/util/wait"
 	utilfeature "k8s.io/apiserver/pkg/util/feature"
 	clientgoinformers "k8s.io/client-go/informers"
@@ -34,6 +32,7 @@ import (
 	restclient "k8s.io/client-go/rest"
 	"k8s.io/client-go/tools/cache"
 	fakecloud "k8s.io/cloud-provider/fake"
+	kubeapiservertesting "k8s.io/kubernetes/cmd/kube-apiserver/app/testing"
 	"k8s.io/kubernetes/pkg/controller/volume/attachdetach"
 	volumecache "k8s.io/kubernetes/pkg/controller/volume/attachdetach/cache"
 	"k8s.io/kubernetes/pkg/controller/volume/persistentvolume"
@@ -144,8 +143,10 @@ var defaultTimerConfig = attachdetach.TimerConfig{
 // event is somehow missed by AttachDetach controller - it still
 // gets cleaned up by Desired State of World populator.
 func TestPodDeletionWithDswp(t *testing.T) {
-	_, server, closeFn := framework.RunAnAPIServer(framework.NewIntegrationTestControlPlaneConfig())
+	// Disable ServiceAccount admission plugin as we don't have serviceaccount controller running.
-	defer closeFn()
+	server := kubeapiservertesting.StartTestServerOrDie(t, nil, []string{"--disable-admission-plugins=ServiceAccount"}, framework.SharedEtcd())
+	defer server.TearDownFn()
+
 	namespaceName := "test-pod-deletion"
 	node := &v1.Node{
 		ObjectMeta: metav1.ObjectMeta{
@@ -156,10 +157,11 @@ func TestPodDeletionWithDswp(t *testing.T) {
 		},
 	}
 
-	ns := framework.CreateTestingNamespace(namespaceName, t)
+	testClient, ctrl, _, informers := createAdClients(t, server, defaultSyncPeriod, defaultTimerConfig)
-	defer framework.DeleteTestingNamespace(ns, t)
+
+	ns := framework.CreateNamespaceOrDie(testClient, namespaceName, t)
+	defer framework.DeleteNamespaceOrDie(testClient, ns, t)
 
-	testClient, ctrl, _, informers := createAdClients(ns, t, server, defaultSyncPeriod, defaultTimerConfig)
 	pod := fakePodWithVol(namespaceName)
 	podStopCh := make(chan struct{})
 
@@ -218,8 +220,9 @@ func initCSIObjects(stopCh <-chan struct{}, informers clientgoinformers.SharedIn
 }
 
 func TestPodUpdateWithWithADC(t *testing.T) {
-	_, server, closeFn := framework.RunAnAPIServer(framework.NewIntegrationTestControlPlaneConfig())
+	// Disable ServiceAccount admission plugin as we don't have serviceaccount controller running.
-	defer closeFn()
+	server := kubeapiservertesting.StartTestServerOrDie(t, nil, []string{"--disable-admission-plugins=ServiceAccount"}, framework.SharedEtcd())
+	defer server.TearDownFn()
 	namespaceName := "test-pod-update"
 
 	node := &v1.Node{
@@ -231,10 +234,10 @@ func TestPodUpdateWithWithADC(t *testing.T) {
 		},
 	}
 
-	ns := framework.CreateTestingNamespace(namespaceName, t)
+	testClient, ctrl, _, informers := createAdClients(t, server, defaultSyncPeriod, defaultTimerConfig)
-	defer framework.DeleteTestingNamespace(ns, t)
 
-	testClient, ctrl, _, informers := createAdClients(ns, t, server, defaultSyncPeriod, defaultTimerConfig)
+	ns := framework.CreateNamespaceOrDie(testClient, namespaceName, t)
+	defer framework.DeleteNamespaceOrDie(testClient, ns, t)
 
 	pod := fakePodWithVol(namespaceName)
 	podStopCh := make(chan struct{})
@@ -287,8 +290,9 @@ func TestPodUpdateWithWithADC(t *testing.T) {
 }
 
 func TestPodUpdateWithKeepTerminatedPodVolumes(t *testing.T) {
-	_, server, closeFn := framework.RunAnAPIServer(framework.NewIntegrationTestControlPlaneConfig())
+	// Disable ServiceAccount admission plugin as we don't have serviceaccount controller running.
-	defer closeFn()
+	server := kubeapiservertesting.StartTestServerOrDie(t, nil, []string{"--disable-admission-plugins=ServiceAccount"}, framework.SharedEtcd())
+	defer server.TearDownFn()
 	namespaceName := "test-pod-update"
 
 	node := &v1.Node{
@@ -301,10 +305,10 @@ func TestPodUpdateWithKeepTerminatedPodVolumes(t *testing.T) {
 		},
 	}
 
-	ns := framework.CreateTestingNamespace(namespaceName, t)
+	testClient, ctrl, _, informers := createAdClients(t, server, defaultSyncPeriod, defaultTimerConfig)
-	defer framework.DeleteTestingNamespace(ns, t)
 
-	testClient, ctrl, _, informers := createAdClients(ns, t, server, defaultSyncPeriod, defaultTimerConfig)
+	ns := framework.CreateNamespaceOrDie(testClient, namespaceName, t)
+	defer framework.DeleteNamespaceOrDie(testClient, ns, t)
 
 	pod := fakePodWithVol(namespaceName)
 	podStopCh := make(chan struct{})
@@ -397,15 +401,12 @@ func waitForPodFuncInDSWP(t *testing.T, dswp volumecache.DesiredStateOfWorld, ch
 	}
 }
 
-func createAdClients(ns *v1.Namespace, t *testing.T, server *httptest.Server, syncPeriod time.Duration, timers attachdetach.TimerConfig) (*clientset.Clientset, attachdetach.AttachDetachController, *persistentvolume.PersistentVolumeController, clientgoinformers.SharedInformerFactory) {
+func createAdClients(t *testing.T, server *kubeapiservertesting.TestServer, syncPeriod time.Duration, timers attachdetach.TimerConfig) (*clientset.Clientset, attachdetach.AttachDetachController, *persistentvolume.PersistentVolumeController, clientgoinformers.SharedInformerFactory) {
-	config := restclient.Config{
+	config := restclient.CopyConfig(server.ClientConfig)
-		Host:          server.URL,
+	config.QPS = 1000000
-		ContentConfig: restclient.ContentConfig{GroupVersion: &schema.GroupVersion{Group: "", Version: "v1"}},
+	config.Burst = 1000000
-		QPS:           1000000,
-		Burst:         1000000,
-	}
 	resyncPeriod := 12 * time.Hour
-	testClient := clientset.NewForConfigOrDie(&config)
+	testClient := clientset.NewForConfigOrDie(server.ClientConfig)
 
 	host := volumetest.NewFakeVolumeHost(t, "/tmp/fake", nil, nil)
 	plugin := &volumetest.FakeVolumePlugin{
@@ -471,8 +472,9 @@ func createAdClients(ns *v1.Namespace, t *testing.T, server *httptest.Server, sy
 // event is somehow missed by AttachDetach controller - it still
 // gets added by Desired State of World populator.
 func TestPodAddedByDswp(t *testing.T) {
-	_, server, closeFn := framework.RunAnAPIServer(framework.NewIntegrationTestControlPlaneConfig())
+	// Disable ServiceAccount admission plugin as we don't have serviceaccount controller running.
-	defer closeFn()
+	server := kubeapiservertesting.StartTestServerOrDie(t, nil, []string{"--disable-admission-plugins=ServiceAccount"}, framework.SharedEtcd())
+	defer server.TearDownFn()
 	namespaceName := "test-pod-deletion"
 
 	node := &v1.Node{
@@ -483,11 +485,10 @@ func TestPodAddedByDswp(t *testing.T) {
 			},
 		},
 	}
+	testClient, ctrl, _, informers := createAdClients(t, server, defaultSyncPeriod, defaultTimerConfig)
 
-	ns := framework.CreateTestingNamespace(namespaceName, t)
+	ns := framework.CreateNamespaceOrDie(testClient, namespaceName, t)
-	defer framework.DeleteTestingNamespace(ns, t)
+	defer framework.DeleteNamespaceOrDie(testClient, ns, t)
-
-	testClient, ctrl, _, informers := createAdClients(ns, t, server, defaultSyncPeriod, defaultTimerConfig)
 
 	pod := fakePodWithVol(namespaceName)
 	podStopCh := make(chan struct{})
@@ -546,14 +547,12 @@ func TestPodAddedByDswp(t *testing.T) {
 }
 
 func TestPVCBoundWithADC(t *testing.T) {
-	_, server, closeFn := framework.RunAnAPIServer(framework.NewIntegrationTestControlPlaneConfig())
+	// Disable ServiceAccount admission plugin as we don't have serviceaccount controller running.
-	defer closeFn()
+	server := kubeapiservertesting.StartTestServerOrDie(t, nil, []string{"--disable-admission-plugins=ServiceAccount"}, framework.SharedEtcd())
+	defer server.TearDownFn()
 	namespaceName := "test-pod-deletion"
 
-	ns := framework.CreateTestingNamespace(namespaceName, t)
+	testClient, ctrl, pvCtrl, informers := createAdClients(t, server, defaultSyncPeriod, attachdetach.TimerConfig{
-	defer framework.DeleteTestingNamespace(ns, t)
-
-	testClient, ctrl, pvCtrl, informers := createAdClients(ns, t, server, defaultSyncPeriod, attachdetach.TimerConfig{
 		ReconcilerLoopPeriod:                        100 * time.Millisecond,
 		ReconcilerMaxWaitForUnmountDuration:         6 * time.Second,
 		DesiredStateOfWorldPopulatorLoopSleepPeriod: 24 * time.Hour,
@@ -561,6 +560,9 @@ func TestPVCBoundWithADC(t *testing.T) {
 		DesiredStateOfWorldPopulatorListPodsRetryDuration: 24 * time.Hour,
 	})
 
+	ns := framework.CreateNamespaceOrDie(testClient, namespaceName, t)
+	defer framework.DeleteNamespaceOrDie(testClient, ns, t)
+
 	node := &v1.Node{
 		ObjectMeta: metav1.ObjectMeta{
 			Name: "node-sandbox",

test/integration/volume/persistent_volumes_test.go

@@ -20,7 +20,6 @@ import (
 	"context"
 	"fmt"
 	"math/rand"
-	"net/http/httptest"
 	"os"
 	"strconv"
 	"testing"
@@ -36,13 +35,13 @@ import (
 	restclient "k8s.io/client-go/rest"
 	ref "k8s.io/client-go/tools/reference"
 	fakecloud "k8s.io/cloud-provider/fake"
+	kubeapiservertesting "k8s.io/kubernetes/cmd/kube-apiserver/app/testing"
 	"k8s.io/kubernetes/pkg/api/legacyscheme"
 	persistentvolumecontroller "k8s.io/kubernetes/pkg/controller/volume/persistentvolume"
 	"k8s.io/kubernetes/pkg/volume"
 	volumetest "k8s.io/kubernetes/pkg/volume/testing"
 	"k8s.io/kubernetes/test/integration/framework"
 
-	"k8s.io/apimachinery/pkg/runtime/schema"
 	"k8s.io/klog/v2"
 )
 
@@ -105,16 +104,17 @@ func testSleep() {
 
 func TestPersistentVolumeRecycler(t *testing.T) {
 	klog.V(2).Infof("TestPersistentVolumeRecycler started")
-	_, s, closeFn := framework.RunAnAPIServer(nil)
+	s := kubeapiservertesting.StartTestServerOrDie(t, nil, []string{"--disable-admission-plugins=ServiceAccount,StorageObjectInUseProtection"}, framework.SharedEtcd())
-	defer closeFn()
+	defer s.TearDownFn()
+	namespaceName := "pv-recycler"
 
-	ns := framework.CreateTestingNamespace("pv-recycler", t)
+	testClient, ctrl, informers, watchPV, watchPVC := createClients(namespaceName, t, s, defaultSyncPeriod)
-	defer framework.DeleteTestingNamespace(ns, t)
-
-	testClient, ctrl, informers, watchPV, watchPVC := createClients(ns, t, s, defaultSyncPeriod)
 	defer watchPV.Stop()
 	defer watchPVC.Stop()
 
+	ns := framework.CreateNamespaceOrDie(testClient, namespaceName, t)
+	defer framework.DeleteNamespaceOrDie(testClient, ns, t)
+
 	// NOTE: This test cannot run in parallel, because it is creating and deleting
 	// non-namespaced objects (PersistenceVolumes).
 	defer testClient.CoreV1().PersistentVolumes().DeleteCollection(context.TODO(), metav1.DeleteOptions{}, metav1.ListOptions{})
@@ -160,16 +160,17 @@ func TestPersistentVolumeRecycler(t *testing.T) {
 
 func TestPersistentVolumeDeleter(t *testing.T) {
 	klog.V(2).Infof("TestPersistentVolumeDeleter started")
-	_, s, closeFn := framework.RunAnAPIServer(nil)
+	s := kubeapiservertesting.StartTestServerOrDie(t, nil, []string{"--disable-admission-plugins=ServiceAccount,StorageObjectInUseProtection"}, framework.SharedEtcd())
-	defer closeFn()
+	defer s.TearDownFn()
+	namespaceName := "pv-deleter"
 
-	ns := framework.CreateTestingNamespace("pv-deleter", t)
+	testClient, ctrl, informers, watchPV, watchPVC := createClients(namespaceName, t, s, defaultSyncPeriod)
-	defer framework.DeleteTestingNamespace(ns, t)
-
-	testClient, ctrl, informers, watchPV, watchPVC := createClients(ns, t, s, defaultSyncPeriod)
 	defer watchPV.Stop()
 	defer watchPVC.Stop()
 
+	ns := framework.CreateNamespaceOrDie(testClient, namespaceName, t)
+	defer framework.DeleteNamespaceOrDie(testClient, ns, t)
+
 	// NOTE: This test cannot run in parallel, because it is creating and deleting
 	// non-namespaced objects (PersistenceVolumes).
 	defer testClient.CoreV1().PersistentVolumes().DeleteCollection(context.TODO(), metav1.DeleteOptions{}, metav1.ListOptions{})
@@ -220,16 +221,17 @@ func TestPersistentVolumeBindRace(t *testing.T) {
 	// Test a race binding many claims to a PV that is pre-bound to a specific
 	// PVC. Only this specific PVC should get bound.
 	klog.V(2).Infof("TestPersistentVolumeBindRace started")
-	_, s, closeFn := framework.RunAnAPIServer(nil)
+	s := kubeapiservertesting.StartTestServerOrDie(t, nil, []string{"--disable-admission-plugins=ServiceAccount,StorageObjectInUseProtection"}, framework.SharedEtcd())
-	defer closeFn()
+	defer s.TearDownFn()
+	namespaceName := "pv-bind-race"
 
-	ns := framework.CreateTestingNamespace("pv-bind-race", t)
+	testClient, ctrl, informers, watchPV, watchPVC := createClients(namespaceName, t, s, defaultSyncPeriod)
-	defer framework.DeleteTestingNamespace(ns, t)
-
-	testClient, ctrl, informers, watchPV, watchPVC := createClients(ns, t, s, defaultSyncPeriod)
 	defer watchPV.Stop()
 	defer watchPVC.Stop()
 
+	ns := framework.CreateNamespaceOrDie(testClient, namespaceName, t)
+	defer framework.DeleteNamespaceOrDie(testClient, ns, t)
+
 	// NOTE: This test cannot run in parallel, because it is creating and deleting
 	// non-namespaced objects (PersistenceVolumes).
 	defer testClient.CoreV1().PersistentVolumes().DeleteCollection(context.TODO(), metav1.DeleteOptions{}, metav1.ListOptions{})
@@ -290,16 +292,17 @@ func TestPersistentVolumeBindRace(t *testing.T) {
 
 // TestPersistentVolumeClaimLabelSelector test binding using label selectors
 func TestPersistentVolumeClaimLabelSelector(t *testing.T) {
-	_, s, closeFn := framework.RunAnAPIServer(nil)
+	s := kubeapiservertesting.StartTestServerOrDie(t, nil, []string{"--disable-admission-plugins=ServiceAccount,StorageObjectInUseProtection"}, framework.SharedEtcd())
-	defer closeFn()
+	defer s.TearDownFn()
+	namespaceName := "pvc-label-selector"
 
-	ns := framework.CreateTestingNamespace("pvc-label-selector", t)
+	testClient, controller, informers, watchPV, watchPVC := createClients(namespaceName, t, s, defaultSyncPeriod)
-	defer framework.DeleteTestingNamespace(ns, t)
-
-	testClient, controller, informers, watchPV, watchPVC := createClients(ns, t, s, defaultSyncPeriod)
 	defer watchPV.Stop()
 	defer watchPVC.Stop()
 
+	ns := framework.CreateNamespaceOrDie(testClient, namespaceName, t)
+	defer framework.DeleteNamespaceOrDie(testClient, ns, t)
+
 	// NOTE: This test cannot run in parallel, because it is creating and deleting
 	// non-namespaced objects (PersistenceVolumes).
 	defer testClient.CoreV1().PersistentVolumes().DeleteCollection(context.TODO(), metav1.DeleteOptions{}, metav1.ListOptions{})
@@ -371,16 +374,17 @@ func TestPersistentVolumeClaimLabelSelector(t *testing.T) {
 // TestPersistentVolumeClaimLabelSelectorMatchExpressions test binding using
 // MatchExpressions label selectors
 func TestPersistentVolumeClaimLabelSelectorMatchExpressions(t *testing.T) {
-	_, s, closeFn := framework.RunAnAPIServer(nil)
+	s := kubeapiservertesting.StartTestServerOrDie(t, nil, []string{"--disable-admission-plugins=ServiceAccount,StorageObjectInUseProtection"}, framework.SharedEtcd())
-	defer closeFn()
+	defer s.TearDownFn()
+	namespaceName := "pvc-match-expressions"
 
-	ns := framework.CreateTestingNamespace("pvc-match-expressions", t)
+	testClient, controller, informers, watchPV, watchPVC := createClients(namespaceName, t, s, defaultSyncPeriod)
-	defer framework.DeleteTestingNamespace(ns, t)
-
-	testClient, controller, informers, watchPV, watchPVC := createClients(ns, t, s, defaultSyncPeriod)
 	defer watchPV.Stop()
 	defer watchPVC.Stop()
 
+	ns := framework.CreateNamespaceOrDie(testClient, namespaceName, t)
+	defer framework.DeleteNamespaceOrDie(testClient, ns, t)
+
 	// NOTE: This test cannot run in parallel, because it is creating and deleting
 	// non-namespaced objects (PersistenceVolumes).
 	defer testClient.CoreV1().PersistentVolumes().DeleteCollection(context.TODO(), metav1.DeleteOptions{}, metav1.ListOptions{})
@@ -471,16 +475,17 @@ func TestPersistentVolumeClaimLabelSelectorMatchExpressions(t *testing.T) {
 // TestPersistentVolumeMultiPVs tests binding of one PVC to 100 PVs with
 // different size.
 func TestPersistentVolumeMultiPVs(t *testing.T) {
-	_, s, closeFn := framework.RunAnAPIServer(nil)
+	s := kubeapiservertesting.StartTestServerOrDie(t, nil, []string{"--disable-admission-plugins=ServiceAccount,StorageObjectInUseProtection"}, framework.SharedEtcd())
-	defer closeFn()
+	defer s.TearDownFn()
+	namespaceName := "multi-pvs"
 
-	ns := framework.CreateTestingNamespace("multi-pvs", t)
+	testClient, controller, informers, watchPV, watchPVC := createClients(namespaceName, t, s, defaultSyncPeriod)
-	defer framework.DeleteTestingNamespace(ns, t)
-
-	testClient, controller, informers, watchPV, watchPVC := createClients(ns, t, s, defaultSyncPeriod)
 	defer watchPV.Stop()
 	defer watchPVC.Stop()
 
+	ns := framework.CreateNamespaceOrDie(testClient, namespaceName, t)
+	defer framework.DeleteNamespaceOrDie(testClient, ns, t)
+
 	// NOTE: This test cannot run in parallel, because it is creating and deleting
 	// non-namespaced objects (PersistenceVolumes).
 	defer testClient.CoreV1().PersistentVolumes().DeleteCollection(context.TODO(), metav1.DeleteOptions{}, metav1.ListOptions{})
@@ -561,16 +566,17 @@ func TestPersistentVolumeMultiPVs(t *testing.T) {
 // TestPersistentVolumeMultiPVsPVCs tests binding of 100 PVC to 100 PVs.
 // This test is configurable by KUBE_INTEGRATION_PV_* variables.
 func TestPersistentVolumeMultiPVsPVCs(t *testing.T) {
-	_, s, closeFn := framework.RunAnAPIServer(nil)
+	s := kubeapiservertesting.StartTestServerOrDie(t, nil, []string{"--disable-admission-plugins=ServiceAccount,StorageObjectInUseProtection"}, framework.SharedEtcd())
-	defer closeFn()
+	defer s.TearDownFn()
+	namespaceName := "multi-pvs-pvcs"
 
-	ns := framework.CreateTestingNamespace("multi-pvs-pvcs", t)
+	testClient, binder, informers, watchPV, watchPVC := createClients(namespaceName, t, s, defaultSyncPeriod)
-	defer framework.DeleteTestingNamespace(ns, t)
-
-	testClient, binder, informers, watchPV, watchPVC := createClients(ns, t, s, defaultSyncPeriod)
 	defer watchPV.Stop()
 	defer watchPVC.Stop()
 
+	ns := framework.CreateNamespaceOrDie(testClient, namespaceName, t)
+	defer framework.DeleteNamespaceOrDie(testClient, ns, t)
+
 	// NOTE: This test cannot run in parallel, because it is creating and deleting
 	// non-namespaced objects (PersistenceVolumes).
 	defer testClient.CoreV1().PersistentVolumes().DeleteCollection(context.TODO(), metav1.DeleteOptions{}, metav1.ListOptions{})
@@ -721,21 +727,22 @@ func TestPersistentVolumeMultiPVsPVCs(t *testing.T) {
 // TestPersistentVolumeControllerStartup tests startup of the controller.
 // The controller should not unbind any volumes when it starts.
 func TestPersistentVolumeControllerStartup(t *testing.T) {
-	_, s, closeFn := framework.RunAnAPIServer(nil)
+	s := kubeapiservertesting.StartTestServerOrDie(t, nil, []string{"--disable-admission-plugins=ServiceAccount,StorageObjectInUseProtection"}, framework.SharedEtcd())
-	defer closeFn()
+	defer s.TearDownFn()
-
+	namespaceName := "controller-startup"
-	ns := framework.CreateTestingNamespace("controller-startup", t)
-	defer framework.DeleteTestingNamespace(ns, t)
 
 	objCount := getObjectCount()
 
 	const shortSyncPeriod = 2 * time.Second
 	syncPeriod := getSyncPeriod(shortSyncPeriod)
 
-	testClient, binder, informers, watchPV, watchPVC := createClients(ns, t, s, shortSyncPeriod)
+	testClient, binder, informers, watchPV, watchPVC := createClients(namespaceName, t, s, shortSyncPeriod)
 	defer watchPV.Stop()
 	defer watchPVC.Stop()
 
+	ns := framework.CreateNamespaceOrDie(testClient, namespaceName, t)
+	defer framework.DeleteNamespaceOrDie(testClient, ns, t)
+
 	// Create *bound* volumes and PVCs
 	pvs := make([]*v1.PersistentVolume, objCount)
 	pvcs := make([]*v1.PersistentVolumeClaim, objCount)
@@ -850,16 +857,17 @@ func TestPersistentVolumeControllerStartup(t *testing.T) {
 // TestPersistentVolumeProvisionMultiPVCs tests provisioning of many PVCs.
 // This test is configurable by KUBE_INTEGRATION_PV_* variables.
 func TestPersistentVolumeProvisionMultiPVCs(t *testing.T) {
-	_, s, closeFn := framework.RunAnAPIServer(nil)
+	s := kubeapiservertesting.StartTestServerOrDie(t, nil, []string{"--disable-admission-plugins=ServiceAccount,StorageObjectInUseProtection"}, framework.SharedEtcd())
-	defer closeFn()
+	defer s.TearDownFn()
+	namespaceName := "provision-multi-pvs"
 
-	ns := framework.CreateTestingNamespace("provision-multi-pvs", t)
+	testClient, binder, informers, watchPV, watchPVC := createClients(namespaceName, t, s, defaultSyncPeriod)
-	defer framework.DeleteTestingNamespace(ns, t)
-
-	testClient, binder, informers, watchPV, watchPVC := createClients(ns, t, s, defaultSyncPeriod)
 	defer watchPV.Stop()
 	defer watchPVC.Stop()
 
+	ns := framework.CreateNamespaceOrDie(testClient, namespaceName, t)
+	defer framework.DeleteNamespaceOrDie(testClient, ns, t)
+
 	// NOTE: This test cannot run in parallel, because it is creating and deleting
 	// non-namespaced objects (PersistenceVolumes and StorageClasses).
 	defer testClient.CoreV1().PersistentVolumes().DeleteCollection(context.TODO(), metav1.DeleteOptions{}, metav1.ListOptions{})
@@ -945,16 +953,17 @@ func TestPersistentVolumeProvisionMultiPVCs(t *testing.T) {
 // TestPersistentVolumeMultiPVsDiffAccessModes tests binding of one PVC to two
 // PVs with different access modes.
 func TestPersistentVolumeMultiPVsDiffAccessModes(t *testing.T) {
-	_, s, closeFn := framework.RunAnAPIServer(nil)
+	s := kubeapiservertesting.StartTestServerOrDie(t, nil, []string{"--disable-admission-plugins=ServiceAccount,StorageObjectInUseProtection"}, framework.SharedEtcd())
-	defer closeFn()
+	defer s.TearDownFn()
+	namespaceName := "multi-pvs-diff-access"
 
-	ns := framework.CreateTestingNamespace("multi-pvs-diff-access", t)
+	testClient, controller, informers, watchPV, watchPVC := createClients(namespaceName, t, s, defaultSyncPeriod)
-	defer framework.DeleteTestingNamespace(ns, t)
-
-	testClient, controller, informers, watchPV, watchPVC := createClients(ns, t, s, defaultSyncPeriod)
 	defer watchPV.Stop()
 	defer watchPVC.Stop()
 
+	ns := framework.CreateNamespaceOrDie(testClient, namespaceName, t)
+	defer framework.DeleteNamespaceOrDie(testClient, ns, t)
+
 	// NOTE: This test cannot run in parallel, because it is creating and deleting
 	// non-namespaced objects (PersistenceVolumes).
 	defer testClient.CoreV1().PersistentVolumes().DeleteCollection(context.TODO(), metav1.DeleteOptions{}, metav1.ListOptions{})
@@ -1093,21 +1102,17 @@ func waitForAnyPersistentVolumeClaimPhase(w watch.Interface, phase v1.Persistent
 	}
 }
 
-func createClients(ns *v1.Namespace, t *testing.T, s *httptest.Server, syncPeriod time.Duration) (*clientset.Clientset, *persistentvolumecontroller.PersistentVolumeController, informers.SharedInformerFactory, watch.Interface, watch.Interface) {
+func createClients(namespaceName string, t *testing.T, s *kubeapiservertesting.TestServer, syncPeriod time.Duration) (*clientset.Clientset, *persistentvolumecontroller.PersistentVolumeController, informers.SharedInformerFactory, watch.Interface, watch.Interface) {
 	// Use higher QPS and Burst, there is a test for race conditions which
 	// creates many objects and default values were too low.
-	binderClient := clientset.NewForConfigOrDie(&restclient.Config{
+	binderConfig := restclient.CopyConfig(s.ClientConfig)
-		Host:          s.URL,
+	binderConfig.QPS = 1000000
-		ContentConfig: restclient.ContentConfig{GroupVersion: &schema.GroupVersion{Group: "", Version: "v1"}},
+	binderConfig.Burst = 1000000
-		QPS:           1000000,
+	binderClient := clientset.NewForConfigOrDie(binderConfig)
-		Burst:         1000000,
+	testConfig := restclient.CopyConfig(s.ClientConfig)
-	})
+	testConfig.QPS = 1000000
-	testClient := clientset.NewForConfigOrDie(&restclient.Config{
+	testConfig.Burst = 1000000
-		Host:          s.URL,
+	testClient := clientset.NewForConfigOrDie(testConfig)
-		ContentConfig: restclient.ContentConfig{GroupVersion: &schema.GroupVersion{Group: "", Version: "v1"}},
-		QPS:           1000000,
-		Burst:         1000000,
-	})
 
 	host := volumetest.NewFakeVolumeHost(t, "/tmp/fake", nil, nil)
 	plugin := &volumetest.FakeVolumePlugin{
@@ -1146,7 +1151,7 @@ func createClients(ns *v1.Namespace, t *testing.T, s *httptest.Server, syncPerio
 	if err != nil {
 		t.Fatalf("Failed to watch PersistentVolumes: %v", err)
 	}
-	watchPVC, err := testClient.CoreV1().PersistentVolumeClaims(ns.Name).Watch(context.TODO(), metav1.ListOptions{})
+	watchPVC, err := testClient.CoreV1().PersistentVolumeClaims(namespaceName).Watch(context.TODO(), metav1.ListOptions{})
 	if err != nil {
 		t.Fatalf("Failed to watch PersistentVolumeClaims: %v", err)
 	}