github/kubernetes
1
0
Fork 0
mirror of https://github.com/k3s-io/kubernetes.git synced 2025-07-20 02:11:09 +00:00
Code Issues Projects Releases Wiki Activity

Merge pull request #110229 from wojtek-t/fix_leaking_goroutines_1

Browse Source 
Fix leaking goroutine in multiple integration tests by migrating to common StartTestServer utility
This commit is contained in:
Kubernetes Prow Robot 2022-05-27 00:41:19 -07:00 committed by GitHub
commit 61b983a66b
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
25 changed files with 531 additions and 533 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
test/integration/certificates/field_selector_test.go
View File

@ -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)
defer closeFn()
server := kubeapiservertesting.StartTestServerOrDie(t, nil, nil, 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)
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", "")

14
test/integration/configmap/configmap_test.go
View File

@ -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)
defer closeFn()
// Disable ServiceAccount admission plugin as we don't have serviceaccount controller running.
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)
defer framework.DeleteTestingNamespace(ns, t)
ns := framework.CreateNamespaceOrDie(client, "config-map", t)
defer framework.DeleteNamespaceOrDie(client, ns, t)
DoTestConfigMap(t, client, ns)
}

21
test/integration/cronjob/cronjob_test.go
View File

@ -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) {
controlPlaneConfig := framework.NewIntegrationTestControlPlaneConfig()
_, server, closeFn := framework.RunAnAPIServer(controlPlaneConfig)
func setup(t *testing.T) (kubeapiservertesting.TearDownFunc, *cronjob.ControllerV2, *job.Controller, informers.SharedInformerFactory, clientset.Interface) {
// Disable ServiceAccount admission plugin as we don't have serviceaccount controller running.
server := kubeapiservertesting.StartTestServerOrDie(t, nil, []string{"--disable-admission-plugins=ServiceAccount"}, framework.SharedEtcd())
config := restclient.Config{Host: server.URL}
clientSet, err := clientset.NewForConfig(&config)
config := restclient.CopyConfig(server.ClientConfig)
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)
defer framework.DeleteTestingNamespace(ns, t)
ns := framework.CreateNamespaceOrDie(clientSet, namespaceName, t)
defer framework.DeleteNamespaceOrDie(clientSet, ns, t)
cjClient := clientSet.BatchV1().CronJobs(ns.Name)

57
test/integration/daemonset/daemonset_test.go
View File

@ -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) {
controlPlaneConfig := framework.NewIntegrationTestControlPlaneConfig()
_, server, closeFn := framework.RunAnAPIServer(controlPlaneConfig)
func setup(t *testing.T) (kubeapiservertesting.TearDownFunc, *daemon.DaemonSetsController, informers.SharedInformerFactory, clientset.Interface) {
// Disable ServiceAccount admission plugin as we don't have serviceaccount controller running.
server := kubeapiservertesting.StartTestServerOrDie(t, nil, []string{"--disable-admission-plugins=ServiceAccount,TaintNodesByCondition"}, framework.SharedEtcd())
config := restclient.Config{Host: server.URL}
clientSet, err := clientset.NewForConfig(&config)
config := restclient.CopyConfig(server.ClientConfig)
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)
defer framework.DeleteTestingNamespace(ns, t)
ns := framework.CreateNamespaceOrDie(clientset, "one-node-daemonset-test", 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)
defer framework.DeleteTestingNamespace(ns, t)
ns := framework.CreateNamespaceOrDie(clientset, "simple-daemonset-test", 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)
defer framework.DeleteTestingNamespace(ns, t)
ns := framework.CreateNamespaceOrDie(clientset, "simple-daemonset-test", 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)
defer framework.DeleteTestingNamespace(ns, t)
ns := framework.CreateNamespaceOrDie(clientset, "simple-daemonset-test", 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)
defer framework.DeleteTestingNamespace(ns, t)
ns := framework.CreateNamespaceOrDie(clientset, "insufficient-capacity", 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)
defer framework.DeleteTestingNamespace(ns, t)
ns := framework.CreateNamespaceOrDie(clientset, "one-node-daemonset-test", 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)
defer framework.DeleteTestingNamespace(ns, t)
ns := framework.CreateNamespaceOrDie(clientset, "one-node-daemonset-test", 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)
defer framework.DeleteTestingNamespace(ns, t)
ns := framework.CreateNamespaceOrDie(clientset, "tainted-node", 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)
defer framework.DeleteTestingNamespace(ns, t)
ns := framework.CreateNamespaceOrDie(clientset, "daemonset-unschedulable-test", t)
defer framework.DeleteNamespaceOrDie(clientset, ns, t)
dsClient := clientset.AppsV1().DaemonSets(ns.Name)
podClient := clientset.CoreV1().Pods(ns.Name)

70
test/integration/deployment/deployment_test.go
View File

@ -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)
defer framework.DeleteTestingNamespace(ns, t)
ns := framework.CreateNamespaceOrDie(c, name, 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)
defer framework.DeleteTestingNamespace(ns, t)
ns := framework.CreateNamespaceOrDie(c, name, 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)
defer framework.DeleteTestingNamespace(ns, t)
ns := framework.CreateNamespaceOrDie(c, name, 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)
defer framework.DeleteTestingNamespace(ns, t)
ns := framework.CreateNamespaceOrDie(c, name, 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)
defer framework.DeleteTestingNamespace(ns, t)
ns := framework.CreateNamespaceOrDie(c, name, 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)
defer framework.DeleteTestingNamespace(ns, t)
ns := framework.CreateNamespaceOrDie(c, name, 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)
defer framework.DeleteTestingNamespace(ns, t)
ns := framework.CreateNamespaceOrDie(c, name, 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)
defer framework.DeleteTestingNamespace(ns, t)
ns := framework.CreateNamespaceOrDie(c, name, 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)
defer framework.DeleteTestingNamespace(ns, t)
ns := framework.CreateNamespaceOrDie(c, name, 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)
defer framework.DeleteTestingNamespace(ns, t)
ns := framework.CreateNamespaceOrDie(c, name, 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)
defer framework.DeleteTestingNamespace(ns, t)
ns := framework.CreateNamespaceOrDie(c, name, 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)
defer framework.DeleteTestingNamespace(ns, t)
ns := framework.CreateNamespaceOrDie(c, name, 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)
defer framework.DeleteTestingNamespace(ns, t)
ns := framework.CreateNamespaceOrDie(c, name, t)
defer framework.DeleteNamespaceOrDie(c, ns, t)
deploymentName := "deployment"
replicas := int32(1)

31
test/integration/deployment/util.go
View File

@ -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) {
controlPlaneConfig := framework.NewIntegrationTestControlPlaneConfig()
_, s, closeFn := framework.RunAnAPIServer(controlPlaneConfig)
func dcSetup(t *testing.T) (kubeapiservertesting.TearDownFunc, *replicaset.ReplicaSetController, *deployment.DeploymentController, informers.SharedInformerFactory, clientset.Interface) {
// Disable ServiceAccount admission plugin as we don't have serviceaccount controller running.
server := kubeapiservertesting.StartTestServerOrDie(t, nil, []string{"--disable-admission-plugins=ServiceAccount"}, framework.SharedEtcd())
config := restclient.Config{Host: s.URL}
clientSet, err := clientset.NewForConfig(&config)
config := restclient.CopyConfig(server.ClientConfig)
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) {
controlPlaneConfig := framework.NewIntegrationTestControlPlaneConfig()
_, s, closeFn := framework.RunAnAPIServer(controlPlaneConfig)
func dcSimpleSetup(t *testing.T) (kubeapiservertesting.TearDownFunc, clientset.Interface) {
// Disable ServiceAccount admission plugin as we don't have serviceaccount controller running.
server := kubeapiservertesting.StartTestServerOrDie(t, nil, []string{"--disable-admission-plugins=ServiceAccount"}, framework.SharedEtcd())
config := restclient.Config{Host: s.URL}
clientSet, err := clientset.NewForConfig(&config)
config := restclient.CopyConfig(server.ClientConfig)
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

28
test/integration/endpoints/endpoints_test.go
View File

@ -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()
_, server, closeFn := framework.RunAnAPIServer(controlPlaneConfig)
defer closeFn()
// Disable ServiceAccount admission plugin as we don't have serviceaccount controller running.
server := kubeapiservertesting.StartTestServerOrDie(t, nil, []string{"--disable-admission-plugins=ServiceAccount"}, framework.SharedEtcd())
defer server.TearDownFn()
config := restclient.Config{Host: server.URL}
client, err := clientset.NewForConfig(&config)
client, err := clientset.NewForConfig(server.ClientConfig)
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)
defer framework.DeleteTestingNamespace(ns, t)
ns := framework.CreateNamespaceOrDie(client, "test-endpoints-updates", 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()
_, server, closeFn := framework.RunAnAPIServer(controlPlaneConfig)
defer closeFn()
// Disable ServiceAccount admission plugin as we don't have serviceaccount controller running.
server := kubeapiservertesting.StartTestServerOrDie(t, nil, []string{"--disable-admission-plugins=ServiceAccount"}, framework.SharedEtcd())
defer server.TearDownFn()
config := restclient.Config{Host: server.URL}
client, err := clientset.NewForConfig(&config)
client, err := clientset.NewForConfig(server.ClientConfig)
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)
defer framework.DeleteTestingNamespace(ns, t)
ns := framework.CreateNamespaceOrDie(client, "test-endpoints-terminating", t)
defer framework.DeleteNamespaceOrDie(client, ns, t)
// Create a pod with labels
pod := &v1.Pod{

41
test/integration/endpointslice/endpointslicemirroring_test.go
View File

@ -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()
_, server, closeFn := framework.RunAnAPIServer(controlPlaneConfig)
defer closeFn()
// Disable ServiceAccount admission plugin as we don't have serviceaccount controller running.
server := kubeapiservertesting.StartTestServerOrDie(t, nil, []string{"--disable-admission-plugins=ServiceAccount"}, framework.SharedEtcd())
defer server.TearDownFn()
config := restclient.Config{Host: server.URL}
client, err := clientset.NewForConfig(&config)
client, err := clientset.NewForConfig(server.ClientConfig)
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)
defer framework.DeleteTestingNamespace(ns, t)
ns := framework.CreateNamespaceOrDie(client, fmt.Sprintf("test-endpointslice-mirroring-%d", i), 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()
_, server, closeFn := framework.RunAnAPIServer(controlPlaneConfig)
defer closeFn()
// Disable ServiceAccount admission plugin as we don't have serviceaccount controller running.
server := kubeapiservertesting.StartTestServerOrDie(t, nil, []string{"--disable-admission-plugins=ServiceAccount"}, framework.SharedEtcd())
defer server.TearDownFn()
config := restclient.Config{Host: server.URL}
client, err := clientset.NewForConfig(&config)
client, err := clientset.NewForConfig(server.ClientConfig)
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)
defer framework.DeleteTestingNamespace(ns, t)
ns := framework.CreateNamespaceOrDie(client, fmt.Sprintf("test-endpointslice-mirroring-%d", i), 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()
_, server, closeFn := framework.RunAnAPIServer(controlPlaneConfig)
defer closeFn()
// Disable ServiceAccount admission plugin as we don't have serviceaccount controller running.
server := kubeapiservertesting.StartTestServerOrDie(t, nil, []string{"--disable-admission-plugins=ServiceAccount"}, framework.SharedEtcd())
defer server.TearDownFn()
config := restclient.Config{Host: server.URL}
client, err := clientset.NewForConfig(&config)
client, err := clientset.NewForConfig(server.ClientConfig)
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)
defer framework.DeleteTestingNamespace(ns, t)
ns := framework.CreateNamespaceOrDie(client, fmt.Sprintf("test-endpointslice-mirroring-%d", i), t)
defer framework.DeleteNamespaceOrDie(client, ns, t)
meta := metav1.ObjectMeta{Name: "test-123", Namespace: ns.Name}
service := &corev1.Service{

15
test/integration/endpointslice/endpointsliceterminating_test.go
View File

@ -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()
_, server, closeFn := framework.RunAnAPIServer(controlPlaneConfig)
defer closeFn()
// Disable ServiceAccount admission plugin as we don't have serviceaccount controller running.
server := kubeapiservertesting.StartTestServerOrDie(t, nil, []string{"--disable-admission-plugins=ServiceAccount"}, framework.SharedEtcd())
defer server.TearDownFn()
config := restclient.Config{Host: server.URL}
client, err := clientset.NewForConfig(&config)
client, err := clientset.NewForConfig(server.ClientConfig)
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)
defer framework.DeleteTestingNamespace(ns, t)
ns := framework.CreateNamespaceOrDie(client, "test-endpoints-terminating", t)
defer framework.DeleteNamespaceOrDie(client, ns, t)
node := &corev1.Node{
ObjectMeta: metav1.ObjectMeta{

50
test/integration/evictions/evictions_test.go
View File

@ -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)
defer framework.DeleteTestingNamespace(ns, t)
ns := framework.CreateNamespaceOrDie(clientSet, "concurrent-eviction-requests", 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)
defer framework.DeleteTestingNamespace(ns, t)
ns := framework.CreateNamespaceOrDie(clientSet, "terminalpod-eviction", 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) {
controlPlaneConfig := framework.NewIntegrationTestControlPlaneConfig()
_, s, closeFn := framework.RunAnAPIServer(controlPlaneConfig)
func rmSetup(t *testing.T) (kubeapiservertesting.TearDownFunc, *disruption.DisruptionController, informers.SharedInformerFactory, *restclient.Config, clientset.Interface) {
// Disable ServiceAccount admission plugin as we don't have serviceaccount controller running.
server := kubeapiservertesting.StartTestServerOrDie(t, nil, []string{"--disable-admission-plugins=ServiceAccount"}, framework.SharedEtcd())
config := restclient.Config{Host: s.URL}
clientSet, err := clientset.NewForConfig(&config)
config := restclient.CopyConfig(server.ClientConfig)
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

3
test/integration/framework/controlplane_utils.go
View File

@ -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 {

18
test/integration/framework/util.go
View File

@ -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.

65
test/integration/metrics/metrics_test.go
View File

@ -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) {
req, err := http.NewRequest("GET", s.URL+"/metrics", nil)
func scrapeMetrics(s *kubeapiservertesting.TestServer) (testutil.Metrics, error) {
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)
}
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)
return nil, fmt.Errorf("request failed: %v", err)
}
metrics := testutil.NewMetrics()
data, err := io.ReadAll(resp.Body)
if err != nil {
return nil, fmt.Errorf("Unable to read response: %v", resp)
}
err = testutil.ParseMetrics(string(data), &metrics)
err = testutil.ParseMetrics(string(body), &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)
defer closeFn()
s := kubeapiservertesting.StartTestServerOrDie(t, nil, nil, framework.SharedEtcd())
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)
defer closeFn()
s := kubeapiservertesting.StartTestServerOrDie(t, nil, nil, framework.SharedEtcd())
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)
defer closeFn()
// Disable ServiceAccount admission plugin as we don't have service account controller running.
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())
defer closeFn()
// Disable ServiceAccount admission plugin as we don't have service account controller running.
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())
defer closeFn()
server := kubeapiservertesting.StartTestServerOrDie(t, nil, nil, 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)
}
@ -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

17
test/integration/namespace/ns_conditions_test.go
View File

@ -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) {
controlPlaneConfig := framework.NewIntegrationTestControlPlaneConfig()
_, s, closeFn := framework.RunAnAPIServer(controlPlaneConfig)
func namespaceLifecycleSetup(t *testing.T) (kubeapiservertesting.TearDownFunc, *namespace.NamespaceController, informers.SharedInformerFactory, clientset.Interface, dynamic.Interface) {
// Disable ServiceAccount admission plugin as we don't have serviceaccount controller running.
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)
}

71
test/integration/pods/pods_test.go
View File

@ -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)
defer closeFn()
// Disable ServiceAccount admission plugin as we don't have serviceaccount controller running.
server := kubeapiservertesting.StartTestServerOrDie(t, nil, []string{"--disable-admission-plugins=ServiceAccount"}, framework.SharedEtcd())
defer server.TearDownFn()
ns := framework.CreateTestingNamespace("pod-activedeadline-update", t)
defer framework.DeleteTestingNamespace(ns, t)
client := clientset.NewForConfigOrDie(server.ClientConfig)
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)
defer closeFn()
// Disable ServiceAccount admission plugin as we don't have serviceaccount controller running.
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)
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-readonly-root", t)
defer framework.DeleteNamespaceOrDie(client, ns, t)
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)
defer closeFn()
// Disable ServiceAccount admission plugin as we don't have serviceaccount controller running.
server := kubeapiservertesting.StartTestServerOrDie(t, nil, []string{"--disable-admission-plugins=ServiceAccount"}, framework.SharedEtcd())
defer server.TearDownFn()
ns := framework.CreateTestingNamespace("pod-create-ephemeral-containers", t)
defer framework.DeleteTestingNamespace(ns, t)
client := clientset.NewForConfigOrDie(server.ClientConfig)
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)
defer closeFn()
// Disable ServiceAccount admission plugin as we don't have serviceaccount controller running.
server := kubeapiservertesting.StartTestServerOrDie(t, nil, []string{"--disable-admission-plugins=ServiceAccount"}, framework.SharedEtcd())
defer server.TearDownFn()
ns := framework.CreateTestingNamespace("pod-patch-ephemeral-containers", t)
defer framework.DeleteTestingNamespace(ns, t)
client := clientset.NewForConfigOrDie(server.ClientConfig)
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)
defer closeFn()
// Disable ServiceAccount admission plugin as we don't have serviceaccount controller running.
server := kubeapiservertesting.StartTestServerOrDie(t, nil, []string{"--disable-admission-plugins=ServiceAccount"}, framework.SharedEtcd())
defer server.TearDownFn()
ns := framework.CreateTestingNamespace("pod-update-ephemeral-containers", t)
defer framework.DeleteTestingNamespace(ns, t)
client := clientset.NewForConfigOrDie(server.ClientConfig)
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)
defer closeFn()
// Disable ServiceAccount admission plugin as we don't have serviceaccount controller running.
server := kubeapiservertesting.StartTestServerOrDie(t, nil, []string{"--disable-admission-plugins=ServiceAccount"}, framework.SharedEtcd())
defer server.TearDownFn()
ns := framework.CreateTestingNamespace("pod-ephemeral-containers-disabled", t)
defer framework.DeleteTestingNamespace(ns, t)
client := clientset.NewForConfigOrDie(server.ClientConfig)
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{

81
test/integration/replicaset/replicaset_test.go
View File

@ -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) {
controlPlaneConfig := framework.NewIntegrationTestControlPlaneConfig()
_, s, closeFn := framework.RunAnAPIServer(controlPlaneConfig)
func rmSetup(t *testing.T) (kubeapiservertesting.TearDownFunc, *replicaset.ReplicaSetController, informers.SharedInformerFactory, clientset.Interface) {
// Disable ServiceAccount admission plugin as we don't have serviceaccount controller running.
server := kubeapiservertesting.StartTestServerOrDie(t, nil, []string{"--disable-admission-plugins=ServiceAccount"}, framework.SharedEtcd())
config := restclient.Config{Host: s.URL}
clientSet, err := clientset.NewForConfig(&config)
config := restclient.CopyConfig(server.ClientConfig)
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) {
controlPlaneConfig := framework.NewIntegrationTestControlPlaneConfig()
_, s, closeFn := framework.RunAnAPIServer(controlPlaneConfig)
func rmSimpleSetup(t *testing.T) (kubeapiservertesting.TearDownFunc, clientset.Interface) {
// Disable ServiceAccount admission plugin as we don't have serviceaccount controller running.
server := kubeapiservertesting.StartTestServerOrDie(t, nil, []string{"--disable-admission-plugins=ServiceAccount"}, framework.SharedEtcd())
config := restclient.Config{Host: s.URL}
clientSet, err := clientset.NewForConfig(&config)
config := restclient.CopyConfig(server.ClientConfig)
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)
defer framework.DeleteTestingNamespace(ns, t)
ns := framework.CreateNamespaceOrDie(clientSet, fmt.Sprintf("rs-adoption-%d", i), 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)
defer framework.DeleteTestingNamespace(ns, t)
ns := framework.CreateNamespaceOrDie(clientSet, "rs-selector-immutability", 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)
defer framework.DeleteTestingNamespace(ns, t)
ns := framework.CreateNamespaceOrDie(c, "test-spec-replicas-change", 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)
defer framework.DeleteTestingNamespace(ns, t)
ns := framework.CreateNamespaceOrDie(c, "test-deleting-and-failed-pods", 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)
defer framework.DeleteTestingNamespace(ns, t)
ns := framework.CreateNamespaceOrDie(c, tc.name, 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)
defer framework.DeleteTestingNamespace(ns, t)
ns := framework.CreateNamespaceOrDie(c, "test-overlapping-rss", 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)
defer framework.DeleteTestingNamespace(ns, t)
ns := framework.CreateNamespaceOrDie(c, "test-pod-orphaning-and-adoption-when-labels-change", 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)
defer framework.DeleteTestingNamespace(ns, t)
ns := framework.CreateNamespaceOrDie(c, "test-general-pod-adoption", 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)
defer framework.DeleteTestingNamespace(ns, t)
ns := framework.CreateNamespaceOrDie(c, "test-ready-and-available-replicas", 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)
defer framework.DeleteTestingNamespace(ns, t)
ns := framework.CreateNamespaceOrDie(c, "test-rs-scale-subresource", 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)
defer framework.DeleteTestingNamespace(ns, t)
ns := framework.CreateNamespaceOrDie(c, "test-extra-pods-adoption-and-deletion", 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)
defer framework.DeleteTestingNamespace(ns, t)
ns := framework.CreateNamespaceOrDie(c, "test-fully-labeled-replicas", 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)
defer framework.DeleteTestingNamespace(ns, t)
ns := framework.CreateNamespaceOrDie(c, "test-default-gc-v1", t)
defer framework.DeleteNamespaceOrDie(c, ns, t)
stopControllers := runControllerAndInformers(t, rm, informers, 0)
defer stopControllers()

61
test/integration/replicationcontroller/replicationcontroller_test.go
View File

@ -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) {
controlPlaneConfig := framework.NewIntegrationTestControlPlaneConfig()
_, s, closeFn := framework.RunAnAPIServer(controlPlaneConfig)
func rmSetup(t *testing.T) (kubeapiservertesting.TearDownFunc, *replication.ReplicationManager, informers.SharedInformerFactory, clientset.Interface) {
// Disable ServiceAccount admission plugin as we don't have serviceaccount controller running.
server := kubeapiservertesting.StartTestServerOrDie(t, nil, []string{"--disable-admission-plugins=ServiceAccount"}, framework.SharedEtcd())
config := restclient.Config{Host: s.URL}
clientSet, err := clientset.NewForConfig(&config)
config := restclient.CopyConfig(server.ClientConfig)
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)
defer framework.DeleteTestingNamespace(ns, t)
ns := framework.CreateNamespaceOrDie(clientSet, fmt.Sprintf("rc-adoption-%d", i), 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)
defer framework.DeleteTestingNamespace(ns, t)
ns := framework.CreateNamespaceOrDie(c, "test-spec-replicas-change", 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)
defer framework.DeleteTestingNamespace(ns, t)
ns := framework.CreateNamespaceOrDie(c, "test-spec-replicas-change", 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)
defer framework.DeleteTestingNamespace(ns, t)
ns := framework.CreateNamespaceOrDie(c, "test-deleting-and-failed-pods", 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)
defer framework.DeleteTestingNamespace(ns, t)
ns := framework.CreateNamespaceOrDie(c, "test-overlapping-rcs", 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)
defer framework.DeleteTestingNamespace(ns, t)
ns := framework.CreateNamespaceOrDie(c, "test-pod-orphaning-and-adoption-when-labels-change", 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)
defer framework.DeleteTestingNamespace(ns, t)
ns := framework.CreateNamespaceOrDie(c, "test-general-pod-adoption", 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)
defer framework.DeleteTestingNamespace(ns, t)
ns := framework.CreateNamespaceOrDie(c, "test-ready-and-available-replicas", 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)
defer framework.DeleteTestingNamespace(ns, t)
ns := framework.CreateNamespaceOrDie(c, "test-rc-scale-subresource", 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)
defer framework.DeleteTestingNamespace(ns, t)
ns := framework.CreateNamespaceOrDie(c, "test-extra-pods-adoption-and-deletion", 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)
defer framework.DeleteTestingNamespace(ns, t)
ns := framework.CreateNamespaceOrDie(c, "test-fully-labeled-replicas", t)
defer framework.DeleteNamespaceOrDie(c, ns, t)
stopControllers := runControllerAndInformers(t, rm, informers, 0)
defer stopControllers()

14
test/integration/secrets/secrets_test.go
View File

@ -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)
defer closeFn()
// Disable ServiceAccount admission plugin as we don't have serviceaccount controller running.
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)
defer framework.DeleteTestingNamespace(ns, t)
ns := framework.CreateNamespaceOrDie(client, "secret", t)
defer framework.DeleteNamespaceOrDie(client, ns, t)
DoTestSecrets(t, client, ns)
}

93
test/integration/service/loadbalancer_test.go
View File

@ -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()
_, server, closeFn := framework.RunAnAPIServer(controlPlaneConfig)
defer closeFn()
config := restclient.Config{Host: server.URL}
client, err := clientset.NewForConfig(&config)
client, err := clientset.NewForConfig(server.ClientConfig)
if err != nil {
t.Fatalf("Error creating clientset: %v", err)
}
ns := framework.CreateTestingNamespace("test-service-allocate-node-ports", t)
defer framework.DeleteTestingNamespace(ns, t)
ns := framework.CreateNamespaceOrDie(client, "test-service-allocate-node-ports", 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()
_, server, closeFn := framework.RunAnAPIServer(controlPlaneConfig)
defer closeFn()
config := restclient.Config{Host: server.URL}
client, err := clientset.NewForConfig(&config)
client, err := clientset.NewForConfig(server.ClientConfig)
if err != nil {
t.Fatalf("Error creating clientset: %v", err)
}
ns := framework.CreateTestingNamespace("test-service-allocate-node-ports", t)
defer framework.DeleteTestingNamespace(ns, t)
ns := framework.CreateNamespaceOrDie(client, "test-service-allocate-node-ports", 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()
_, server, closeFn := framework.RunAnAPIServer(controlPlaneConfig)
defer closeFn()
config := restclient.Config{Host: server.URL}
client, err := clientset.NewForConfig(&config)
client, err := clientset.NewForConfig(server.ClientConfig)
if err != nil {
t.Fatalf("Error creating clientset: %v", err)
}
ns := framework.CreateTestingNamespace("test-service-deallocate-node-ports", t)
defer framework.DeleteTestingNamespace(ns, t)
ns := framework.CreateNamespaceOrDie(client, "test-service-deallocate-node-ports", 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()
_, server, closeFn := framework.RunAnAPIServer(controlPlaneConfig)
defer closeFn()
config := restclient.Config{Host: server.URL}
client, err := clientset.NewForConfig(&config)
client, err := clientset.NewForConfig(server.ClientConfig)
if err != nil {
t.Fatalf("Error creating clientset: %v", err)
}
ns := framework.CreateTestingNamespace("test-service-reallocate-node-ports", t)
defer framework.DeleteTestingNamespace(ns, t)
ns := framework.CreateNamespaceOrDie(client, "test-service-reallocate-node-ports", 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()
_, server, closeFn := framework.RunAnAPIServer(controlPlaneConfig)
defer closeFn()
config := restclient.Config{Host: server.URL}
client, err := clientset.NewForConfig(&config)
client, err := clientset.NewForConfig(server.ClientConfig)
if err != nil {
t.Fatalf("Error creating clientset: %v", err)
}
ns := framework.CreateTestingNamespace("test-service-load-balancer-class", t)
defer framework.DeleteTestingNamespace(ns, t)
ns := framework.CreateNamespaceOrDie(client, "test-service-load-balancer-class", 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()
_, server, closeFn := framework.RunAnAPIServer(controlPlaneConfig)
defer closeFn()
config := restclient.Config{Host: server.URL}
client, err := clientset.NewForConfig(&config)
client, err := clientset.NewForConfig(server.ClientConfig)
if err != nil {
t.Fatalf("Error creating clientset: %v", err)
}
ns := framework.CreateTestingNamespace("test-service-immutable-load-balancer-class", t)
defer framework.DeleteTestingNamespace(ns, t)
ns := framework.CreateNamespaceOrDie(client, "test-service-immutable-load-balancer-class", 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()
_, server, closeFn := framework.RunAnAPIServer(controlPlaneConfig)
defer closeFn()
config := restclient.Config{Host: server.URL}
client, err := clientset.NewForConfig(&config)
client, err := clientset.NewForConfig(server.ClientConfig)
if err != nil {
t.Fatalf("Error creating clientset: %v", err)
}
ns := framework.CreateTestingNamespace("test-service-update-load-balancer-class", t)
defer framework.DeleteTestingNamespace(ns, t)
ns := framework.CreateNamespaceOrDie(client, "test-service-update-load-balancer-class", t)
defer framework.DeleteNamespaceOrDie(client, ns, t)
controller, cloud, informer := newServiceController(t, client)

38
test/integration/service/service_test.go
View File

@ -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, closeFn := framework.RunAnAPIServer(controlPlaneConfig)
defer closeFn()
server := kubeapiservertesting.StartTestServerOrDie(t, nil, nil, framework.SharedEtcd())
defer server.TearDownFn()
config := restclient.Config{Host: server.URL}
client, err := clientset.NewForConfig(&config)
client, err := clientset.NewForConfig(server.ClientConfig)
if err != nil {
t.Fatalf("Error creating clientset: %v", err)
}
ns := framework.CreateTestingNamespace("test-external-name-drops-internal-traffic-policy", t)
defer framework.DeleteTestingNamespace(ns, t)
ns := framework.CreateNamespaceOrDie(client, "test-external-name-drops-internal-traffic-policy", 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, closeFn := framework.RunAnAPIServer(controlPlaneConfig)
defer closeFn()
server := kubeapiservertesting.StartTestServerOrDie(t, nil, nil, framework.SharedEtcd())
defer server.TearDownFn()
config := restclient.Config{Host: server.URL}
client, err := clientset.NewForConfig(&config)
client, err := clientset.NewForConfig(server.ClientConfig)
if err != nil {
t.Fatalf("Error creating clientset: %v", err)
}
ns := framework.CreateTestingNamespace("test-external-name-drops-internal-traffic-policy", t)
defer framework.DeleteTestingNamespace(ns, t)
ns := framework.CreateNamespaceOrDie(client, "test-external-name-drops-internal-traffic-policy", 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, closeFn := framework.RunAnAPIServer(controlPlaneConfig)
defer closeFn()
server := kubeapiservertesting.StartTestServerOrDie(t, nil, nil, framework.SharedEtcd())
defer server.TearDownFn()
config := restclient.Config{Host: server.URL}
client, err := clientset.NewForConfig(&config)
client, err := clientset.NewForConfig(server.ClientConfig)
if err != nil {
t.Fatalf("Error creating clientset: %v", err)
}
ns := framework.CreateTestingNamespace("test-external-name-drops-internal-traffic-policy", t)
defer framework.DeleteTestingNamespace(ns, t)
ns := framework.CreateNamespaceOrDie(client, "test-external-name-drops-internal-traffic-policy", t)
defer framework.DeleteNamespaceOrDie(client, ns, t)
service := &corev1.Service{
ObjectMeta: metav1.ObjectMeta{

3
test/integration/service/upgrade_test.go
View File

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

13
test/integration/storageclasses/storage_classes_test.go
View File

@ -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)
defer closeFn()
server := kubeapiservertesting.StartTestServerOrDie(t, nil, []string{"--disable-admission-plugins=StorageObjectInUseProtection"}, 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("storageclass", t)
defer framework.DeleteTestingNamespace(ns, t)
ns := framework.CreateNamespaceOrDie(client, "storageclass", t)
defer framework.DeleteNamespaceOrDie(client, ns, t)
DoTestStorageClasses(t, client, ns)
}

18
test/integration/ttlcontroller/ttlcontroller_test.go
View File

@ -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) {
config := restclient.Config{
Host: server.URL,
QPS: 500,
Burst: 500,
}
testClient := clientset.NewForConfigOrDie(&config)
func createClientAndInformers(t *testing.T, server *kubeapiservertesting.TestServer) (*clientset.Clientset, informers.SharedInformerFactory) {
config := restclient.CopyConfig(server.ClientConfig)
config.QPS = 500
config.Burst = 500
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)
defer closeFn()
server := kubeapiservertesting.StartTestServerOrDie(t, nil, nil, framework.SharedEtcd())
defer server.TearDownFn()
testClient, informers := createClientAndInformers(t, server)
nodeInformer := informers.Core().V1().Nodes()

76
test/integration/volume/attach_detach_test.go
View File

@ -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())
defer closeFn()
// Disable ServiceAccount admission plugin as we don't have serviceaccount controller running.
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)
defer framework.DeleteTestingNamespace(ns, t)
testClient, ctrl, _, informers := createAdClients(t, server, defaultSyncPeriod, defaultTimerConfig)
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())
defer closeFn()
// Disable ServiceAccount admission plugin as we don't have serviceaccount controller running.
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)
defer framework.DeleteTestingNamespace(ns, t)
testClient, ctrl, _, informers := createAdClients(t, server, defaultSyncPeriod, defaultTimerConfig)
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())
defer closeFn()
// Disable ServiceAccount admission plugin as we don't have serviceaccount controller running.
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)
defer framework.DeleteTestingNamespace(ns, t)
testClient, ctrl, _, informers := createAdClients(t, server, defaultSyncPeriod, defaultTimerConfig)
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) {
config := restclient.Config{
Host: server.URL,
ContentConfig: restclient.ContentConfig{GroupVersion: &schema.GroupVersion{Group: "", Version: "v1"}},
QPS: 1000000,
Burst: 1000000,
}
func createAdClients(t *testing.T, server *kubeapiservertesting.TestServer, syncPeriod time.Duration, timers attachdetach.TimerConfig) (*clientset.Clientset, attachdetach.AttachDetachController, *persistentvolume.PersistentVolumeController, clientgoinformers.SharedInformerFactory) {
config := restclient.CopyConfig(server.ClientConfig)
config.QPS = 1000000
config.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())
defer closeFn()
// Disable ServiceAccount admission plugin as we don't have serviceaccount controller running.
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)
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{})
@ -546,14 +547,12 @@ func TestPodAddedByDswp(t *testing.T) {
}
func TestPVCBoundWithADC(t *testing.T) {
_, server, closeFn := framework.RunAnAPIServer(framework.NewIntegrationTestControlPlaneConfig())
defer closeFn()
// Disable ServiceAccount admission plugin as we don't have serviceaccount controller running.
server := kubeapiservertesting.StartTestServerOrDie(t, nil, []string{"--disable-admission-plugins=ServiceAccount"}, framework.SharedEtcd())
defer server.TearDownFn()
namespaceName := "test-pod-deletion"
ns := framework.CreateTestingNamespace(namespaceName, t)
defer framework.DeleteTestingNamespace(ns, t)
testClient, ctrl, pvCtrl, informers := createAdClients(ns, t, server, defaultSyncPeriod, attachdetach.TimerConfig{
testClient, ctrl, pvCtrl, informers := createAdClients(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",

157
test/integration/volume/persistent_volumes_test.go
View File

@ -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)
defer closeFn()
s := kubeapiservertesting.StartTestServerOrDie(t, nil, []string{"--disable-admission-plugins=ServiceAccount,StorageObjectInUseProtection"}, framework.SharedEtcd())
defer s.TearDownFn()
namespaceName := "pv-recycler"
ns := framework.CreateTestingNamespace("pv-recycler", t)
defer framework.DeleteTestingNamespace(ns, t)
testClient, ctrl, informers, watchPV, watchPVC := createClients(ns, t, s, defaultSyncPeriod)
testClient, ctrl, informers, watchPV, watchPVC := createClients(namespaceName, 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)
defer closeFn()
s := kubeapiservertesting.StartTestServerOrDie(t, nil, []string{"--disable-admission-plugins=ServiceAccount,StorageObjectInUseProtection"}, framework.SharedEtcd())
defer s.TearDownFn()
namespaceName := "pv-deleter"
ns := framework.CreateTestingNamespace("pv-deleter", t)
defer framework.DeleteTestingNamespace(ns, t)
testClient, ctrl, informers, watchPV, watchPVC := createClients(ns, t, s, defaultSyncPeriod)
testClient, ctrl, informers, watchPV, watchPVC := createClients(namespaceName, 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)
defer closeFn()
s := kubeapiservertesting.StartTestServerOrDie(t, nil, []string{"--disable-admission-plugins=ServiceAccount,StorageObjectInUseProtection"}, framework.SharedEtcd())
defer s.TearDownFn()
namespaceName := "pv-bind-race"
ns := framework.CreateTestingNamespace("pv-bind-race", t)
defer framework.DeleteTestingNamespace(ns, t)
testClient, ctrl, informers, watchPV, watchPVC := createClients(ns, t, s, defaultSyncPeriod)
testClient, ctrl, informers, watchPV, watchPVC := createClients(namespaceName, 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)
defer closeFn()
s := kubeapiservertesting.StartTestServerOrDie(t, nil, []string{"--disable-admission-plugins=ServiceAccount,StorageObjectInUseProtection"}, framework.SharedEtcd())
defer s.TearDownFn()
namespaceName := "pvc-label-selector"
ns := framework.CreateTestingNamespace("pvc-label-selector", t)
defer framework.DeleteTestingNamespace(ns, t)
testClient, controller, informers, watchPV, watchPVC := createClients(ns, t, s, defaultSyncPeriod)
testClient, controller, informers, watchPV, watchPVC := createClients(namespaceName, 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)
defer closeFn()
s := kubeapiservertesting.StartTestServerOrDie(t, nil, []string{"--disable-admission-plugins=ServiceAccount,StorageObjectInUseProtection"}, framework.SharedEtcd())
defer s.TearDownFn()
namespaceName := "pvc-match-expressions"
ns := framework.CreateTestingNamespace("pvc-match-expressions", t)
defer framework.DeleteTestingNamespace(ns, t)
testClient, controller, informers, watchPV, watchPVC := createClients(ns, t, s, defaultSyncPeriod)
testClient, controller, informers, watchPV, watchPVC := createClients(namespaceName, 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)
defer closeFn()
s := kubeapiservertesting.StartTestServerOrDie(t, nil, []string{"--disable-admission-plugins=ServiceAccount,StorageObjectInUseProtection"}, framework.SharedEtcd())
defer s.TearDownFn()
namespaceName := "multi-pvs"
ns := framework.CreateTestingNamespace("multi-pvs", t)
defer framework.DeleteTestingNamespace(ns, t)
testClient, controller, informers, watchPV, watchPVC := createClients(ns, t, s, defaultSyncPeriod)
testClient, controller, informers, watchPV, watchPVC := createClients(namespaceName, 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)
defer closeFn()
s := kubeapiservertesting.StartTestServerOrDie(t, nil, []string{"--disable-admission-plugins=ServiceAccount,StorageObjectInUseProtection"}, framework.SharedEtcd())
defer s.TearDownFn()
namespaceName := "multi-pvs-pvcs"
ns := framework.CreateTestingNamespace("multi-pvs-pvcs", t)
defer framework.DeleteTestingNamespace(ns, t)
testClient, binder, informers, watchPV, watchPVC := createClients(ns, t, s, defaultSyncPeriod)
testClient, binder, informers, watchPV, watchPVC := createClients(namespaceName, 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)
defer closeFn()
ns := framework.CreateTestingNamespace("controller-startup", t)
defer framework.DeleteTestingNamespace(ns, t)
s := kubeapiservertesting.StartTestServerOrDie(t, nil, []string{"--disable-admission-plugins=ServiceAccount,StorageObjectInUseProtection"}, framework.SharedEtcd())
defer s.TearDownFn()
namespaceName := "controller-startup"
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)
defer closeFn()
s := kubeapiservertesting.StartTestServerOrDie(t, nil, []string{"--disable-admission-plugins=ServiceAccount,StorageObjectInUseProtection"}, framework.SharedEtcd())
defer s.TearDownFn()
namespaceName := "provision-multi-pvs"
ns := framework.CreateTestingNamespace("provision-multi-pvs", t)
defer framework.DeleteTestingNamespace(ns, t)
testClient, binder, informers, watchPV, watchPVC := createClients(ns, t, s, defaultSyncPeriod)
testClient, binder, informers, watchPV, watchPVC := createClients(namespaceName, 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)
defer closeFn()
s := kubeapiservertesting.StartTestServerOrDie(t, nil, []string{"--disable-admission-plugins=ServiceAccount,StorageObjectInUseProtection"}, framework.SharedEtcd())
defer s.TearDownFn()
namespaceName := "multi-pvs-diff-access"
ns := framework.CreateTestingNamespace("multi-pvs-diff-access", t)
defer framework.DeleteTestingNamespace(ns, t)
testClient, controller, informers, watchPV, watchPVC := createClients(ns, t, s, defaultSyncPeriod)
testClient, controller, informers, watchPV, watchPVC := createClients(namespaceName, 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{
Host: s.URL,
ContentConfig: restclient.ContentConfig{GroupVersion: &schema.GroupVersion{Group: "", Version: "v1"}},
QPS: 1000000,
Burst: 1000000,
})
testClient := clientset.NewForConfigOrDie(&restclient.Config{
Host: s.URL,
ContentConfig: restclient.ContentConfig{GroupVersion: &schema.GroupVersion{Group: "", Version: "v1"}},
QPS: 1000000,
Burst: 1000000,
})
binderConfig := restclient.CopyConfig(s.ClientConfig)
binderConfig.QPS = 1000000
binderConfig.Burst = 1000000
binderClient := clientset.NewForConfigOrDie(binderConfig)
testConfig := restclient.CopyConfig(s.ClientConfig)
testConfig.QPS = 1000000
testConfig.Burst = 1000000
testClient := clientset.NewForConfigOrDie(testConfig)
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)
}