diff --git a/test/integration/persistent_volumes_test.go b/test/integration/persistent_volumes_test.go index 43edc3be36f..1def6df2771 100644 --- a/test/integration/persistent_volumes_test.go +++ b/test/integration/persistent_volumes_test.go @@ -104,23 +104,27 @@ func testSleep() { } func TestPersistentVolumeRecycler(t *testing.T) { - // TODO: Limit the test to a single non-default namespace and clean this up at the end. - framework.DeleteAllEtcdKeys() - glog.V(2).Infof("TestPersistentVolumeRecycler started") _, s := framework.RunAMaster(nil) defer s.Close() - testClient, ctrl, watchPV, watchPVC := createClients(t, s) + ns := framework.CreateTestingNamespace("pv-recycler", s, t) + defer framework.DeleteTestingNamespace(ns, s, t) + + testClient, ctrl, watchPV, watchPVC := createClients(ns, t, s) defer watchPV.Stop() defer watchPVC.Stop() + // NOTE: This test cannot run in parallel, because it is creating and deleting + // non-namespaced objects (PersistenceVolumes). + defer testClient.Core().PersistentVolumes().DeleteCollection(nil, api.ListOptions{}) + ctrl.Run() defer ctrl.Stop() // This PV will be claimed, released, and recycled. pv := createPV("fake-pv-recycler", "/tmp/foo", "10G", []api.PersistentVolumeAccessMode{api.ReadWriteOnce}, api.PersistentVolumeReclaimRecycle) - pvc := createPVC("fake-pvc-recycler", "5G", []api.PersistentVolumeAccessMode{api.ReadWriteOnce}) + pvc := createPVC("fake-pvc-recycler", ns.Name, "5G", []api.PersistentVolumeAccessMode{api.ReadWriteOnce}) _, err := testClient.PersistentVolumes().Create(pv) if err != nil { @@ -128,7 +132,7 @@ func TestPersistentVolumeRecycler(t *testing.T) { } glog.V(2).Infof("TestPersistentVolumeRecycler pvc created") - _, err = testClient.PersistentVolumeClaims(api.NamespaceDefault).Create(pvc) + _, err = testClient.PersistentVolumeClaims(ns.Name).Create(pvc) if err != nil { t.Errorf("Failed to create PersistentVolumeClaim: %v", err) } @@ -137,11 +141,11 @@ func TestPersistentVolumeRecycler(t *testing.T) { // wait until the controller pairs the volume and claim waitForPersistentVolumePhase(testClient, pv.Name, watchPV, api.VolumeBound) glog.V(2).Infof("TestPersistentVolumeRecycler pv bound") - waitForPersistentVolumeClaimPhase(testClient, pvc.Name, watchPVC, api.ClaimBound) + waitForPersistentVolumeClaimPhase(testClient, pvc.Name, ns.Name, watchPVC, api.ClaimBound) glog.V(2).Infof("TestPersistentVolumeRecycler pvc bound") // deleting a claim releases the volume, after which it can be recycled - if err := testClient.PersistentVolumeClaims(api.NamespaceDefault).Delete(pvc.Name, nil); err != nil { + if err := testClient.PersistentVolumeClaims(ns.Name).Delete(pvc.Name, nil); err != nil { t.Errorf("error deleting claim %s", pvc.Name) } glog.V(2).Infof("TestPersistentVolumeRecycler pvc deleted") @@ -150,45 +154,48 @@ func TestPersistentVolumeRecycler(t *testing.T) { glog.V(2).Infof("TestPersistentVolumeRecycler pv released") waitForPersistentVolumePhase(testClient, pv.Name, watchPV, api.VolumeAvailable) glog.V(2).Infof("TestPersistentVolumeRecycler pv available") - } func TestPersistentVolumeDeleter(t *testing.T) { - // TODO: Limit the test to a single non-default namespace and clean this up at the end. - framework.DeleteAllEtcdKeys() - glog.V(2).Infof("TestPersistentVolumeDeleter started") _, s := framework.RunAMaster(nil) defer s.Close() - testClient, ctrl, watchPV, watchPVC := createClients(t, s) + ns := framework.CreateTestingNamespace("pv-deleter", s, t) + defer framework.DeleteTestingNamespace(ns, s, t) + + testClient, ctrl, watchPV, watchPVC := createClients(ns, t, s) defer watchPV.Stop() defer watchPVC.Stop() + // NOTE: This test cannot run in parallel, because it is creating and deleting + // non-namespaced objects (PersistenceVolumes). + defer testClient.Core().PersistentVolumes().DeleteCollection(nil, api.ListOptions{}) + ctrl.Run() defer ctrl.Stop() // This PV will be claimed, released, and deleted. pv := createPV("fake-pv-deleter", "/tmp/foo", "10G", []api.PersistentVolumeAccessMode{api.ReadWriteOnce}, api.PersistentVolumeReclaimDelete) - pvc := createPVC("fake-pvc-deleter", "5G", []api.PersistentVolumeAccessMode{api.ReadWriteOnce}) + pvc := createPVC("fake-pvc-deleter", ns.Name, "5G", []api.PersistentVolumeAccessMode{api.ReadWriteOnce}) _, err := testClient.PersistentVolumes().Create(pv) if err != nil { t.Errorf("Failed to create PersistentVolume: %v", err) } glog.V(2).Infof("TestPersistentVolumeDeleter pv created") - _, err = testClient.PersistentVolumeClaims(api.NamespaceDefault).Create(pvc) + _, err = testClient.PersistentVolumeClaims(ns.Name).Create(pvc) if err != nil { t.Errorf("Failed to create PersistentVolumeClaim: %v", err) } glog.V(2).Infof("TestPersistentVolumeDeleter pvc created") waitForPersistentVolumePhase(testClient, pv.Name, watchPV, api.VolumeBound) glog.V(2).Infof("TestPersistentVolumeDeleter pv bound") - waitForPersistentVolumeClaimPhase(testClient, pvc.Name, watchPVC, api.ClaimBound) + waitForPersistentVolumeClaimPhase(testClient, pvc.Name, ns.Name, watchPVC, api.ClaimBound) glog.V(2).Infof("TestPersistentVolumeDeleter pvc bound") // deleting a claim releases the volume, after which it can be recycled - if err := testClient.PersistentVolumeClaims(api.NamespaceDefault).Delete(pvc.Name, nil); err != nil { + if err := testClient.PersistentVolumeClaims(ns.Name).Delete(pvc.Name, nil); err != nil { t.Errorf("error deleting claim %s", pvc.Name) } glog.V(2).Infof("TestPersistentVolumeDeleter pvc deleted") @@ -206,25 +213,28 @@ func TestPersistentVolumeDeleter(t *testing.T) { } func TestPersistentVolumeBindRace(t *testing.T) { - // TODO: Limit the test to a single non-default namespace and clean this up at the end. - framework.DeleteAllEtcdKeys() - // Test a race binding many claims to a PV that is pre-bound to a specific // PVC. Only this specific PVC should get bound. glog.V(2).Infof("TestPersistentVolumeBindRace started") _, s := framework.RunAMaster(nil) defer s.Close() - testClient, ctrl, watchPV, watchPVC := createClients(t, s) + ns := framework.CreateTestingNamespace("pv-bind-race", s, t) + defer framework.DeleteTestingNamespace(ns, s, t) + + testClient, ctrl, watchPV, watchPVC := createClients(ns, t, s) defer watchPV.Stop() defer watchPVC.Stop() + // NOTE: This test cannot run in parallel, because it is creating and deleting + // non-namespaced objects (PersistenceVolumes). + defer testClient.Core().PersistentVolumes().DeleteCollection(nil, api.ListOptions{}) + ctrl.Run() defer ctrl.Stop() pv := createPV("fake-pv-race", "/tmp/foo", "10G", []api.PersistentVolumeAccessMode{api.ReadWriteOnce}, api.PersistentVolumeReclaimRetain) - - pvc := createPVC("fake-pvc-race", "5G", []api.PersistentVolumeAccessMode{api.ReadWriteOnce}) + pvc := createPVC("fake-pvc-race", ns.Name, "5G", []api.PersistentVolumeAccessMode{api.ReadWriteOnce}) counter := 0 maxClaims := 100 claims := []*api.PersistentVolumeClaim{} @@ -233,7 +243,7 @@ func TestPersistentVolumeBindRace(t *testing.T) { clone, _ := conversion.NewCloner().DeepCopy(pvc) newPvc, _ := clone.(*api.PersistentVolumeClaim) newPvc.ObjectMeta = api.ObjectMeta{Name: fmt.Sprintf("fake-pvc-race-%d", counter)} - claim, err := testClient.PersistentVolumeClaims(api.NamespaceDefault).Create(newPvc) + claim, err := testClient.PersistentVolumeClaims(ns.Name).Create(newPvc) if err != nil { t.Fatal("Error creating newPvc: %v", err) } @@ -276,16 +286,20 @@ func TestPersistentVolumeBindRace(t *testing.T) { // TestPersistentVolumeClaimLabelSelector test binding using label selectors func TestPersistentVolumeClaimLabelSelector(t *testing.T) { - // TODO: Limit the test to a single non-default namespace and clean this up at the end. - framework.DeleteAllEtcdKeys() - _, s := framework.RunAMaster(nil) defer s.Close() - testClient, controller, watchPV, watchPVC := createClients(t, s) + ns := framework.CreateTestingNamespace("pvc-label-selector", s, t) + defer framework.DeleteTestingNamespace(ns, s, t) + + testClient, controller, watchPV, watchPVC := createClients(ns, t, s) defer watchPV.Stop() defer watchPVC.Stop() + // NOTE: This test cannot run in parallel, because it is creating and deleting + // non-namespaced objects (PersistenceVolumes). + defer testClient.Core().PersistentVolumes().DeleteCollection(nil, api.ListOptions{}) + controller.Run() defer controller.Stop() @@ -296,7 +310,7 @@ func TestPersistentVolumeClaimLabelSelector(t *testing.T) { pv_true = createPV("pv-true", "/tmp/foo-label", "1G", modes, reclaim) pv_false = createPV("pv-false", "/tmp/foo-label", "1G", modes, reclaim) - pvc = createPVC("pvc-ls-1", "1G", modes) + pvc = createPVC("pvc-ls-1", ns.Name, "1G", modes) ) pv_true.ObjectMeta.SetLabels(map[string]string{"foo": "true"}) @@ -318,7 +332,7 @@ func TestPersistentVolumeClaimLabelSelector(t *testing.T) { }, } - _, err = testClient.PersistentVolumeClaims(api.NamespaceDefault).Create(pvc) + _, err = testClient.PersistentVolumeClaims(ns.Name).Create(pvc) if err != nil { t.Fatalf("Failed to create PersistentVolumeClaim: %v", err) } @@ -326,7 +340,7 @@ func TestPersistentVolumeClaimLabelSelector(t *testing.T) { waitForAnyPersistentVolumePhase(watchPV, api.VolumeBound) t.Log("volume bound") - waitForPersistentVolumeClaimPhase(testClient, pvc.Name, watchPVC, api.ClaimBound) + waitForPersistentVolumeClaimPhase(testClient, pvc.Name, ns.Name, watchPVC, api.ClaimBound) t.Log("claim bound") pv, err := testClient.PersistentVolumes().Get("pv-false") @@ -351,16 +365,20 @@ func TestPersistentVolumeClaimLabelSelector(t *testing.T) { // TestPersistentVolumeClaimLabelSelectorMatchExpressions test binding using // MatchExpressions label selectors func TestPersistentVolumeClaimLabelSelectorMatchExpressions(t *testing.T) { - // TODO: Limit the test to a single non-default namespace and clean this up at the end. - framework.DeleteAllEtcdKeys() - _, s := framework.RunAMaster(nil) defer s.Close() - testClient, controller, watchPV, watchPVC := createClients(t, s) + ns := framework.CreateTestingNamespace("pvc-match-expresssions", s, t) + defer framework.DeleteTestingNamespace(ns, s, t) + + testClient, controller, watchPV, watchPVC := createClients(ns, t, s) defer watchPV.Stop() defer watchPVC.Stop() + // NOTE: This test cannot run in parallel, because it is creating and deleting + // non-namespaced objects (PersistenceVolumes). + defer testClient.Core().PersistentVolumes().DeleteCollection(nil, api.ListOptions{}) + controller.Run() defer controller.Stop() @@ -371,7 +389,7 @@ func TestPersistentVolumeClaimLabelSelectorMatchExpressions(t *testing.T) { pv_true = createPV("pv-true", "/tmp/foo-label", "1G", modes, reclaim) pv_false = createPV("pv-false", "/tmp/foo-label", "1G", modes, reclaim) - pvc = createPVC("pvc-ls-1", "1G", modes) + pvc = createPVC("pvc-ls-1", ns.Name, "1G", modes) ) pv_true.ObjectMeta.SetLabels(map[string]string{"foo": "valA", "bar": ""}) @@ -412,7 +430,7 @@ func TestPersistentVolumeClaimLabelSelectorMatchExpressions(t *testing.T) { }, } - _, err = testClient.PersistentVolumeClaims(api.NamespaceDefault).Create(pvc) + _, err = testClient.PersistentVolumeClaims(ns.Name).Create(pvc) if err != nil { t.Fatalf("Failed to create PersistentVolumeClaim: %v", err) } @@ -420,7 +438,7 @@ func TestPersistentVolumeClaimLabelSelectorMatchExpressions(t *testing.T) { waitForAnyPersistentVolumePhase(watchPV, api.VolumeBound) t.Log("volume bound") - waitForPersistentVolumeClaimPhase(testClient, pvc.Name, watchPVC, api.ClaimBound) + waitForPersistentVolumeClaimPhase(testClient, pvc.Name, ns.Name, watchPVC, api.ClaimBound) t.Log("claim bound") pv, err := testClient.PersistentVolumes().Get("pv-false") @@ -445,16 +463,20 @@ func TestPersistentVolumeClaimLabelSelectorMatchExpressions(t *testing.T) { // TestPersistentVolumeMultiPVs tests binding of one PVC to 100 PVs with // different size. func TestPersistentVolumeMultiPVs(t *testing.T) { - // TODO: Limit the test to a single non-default namespace and clean this up at the end. - framework.DeleteAllEtcdKeys() - _, s := framework.RunAMaster(nil) defer s.Close() - testClient, controller, watchPV, watchPVC := createClients(t, s) + ns := framework.CreateTestingNamespace("multi-pvs", s, t) + defer framework.DeleteTestingNamespace(ns, s, t) + + testClient, controller, watchPV, watchPVC := createClients(ns, t, s) defer watchPV.Stop() defer watchPVC.Stop() + // NOTE: This test cannot run in parallel, because it is creating and deleting + // non-namespaced objects (PersistenceVolumes). + defer testClient.Core().PersistentVolumes().DeleteCollection(nil, api.ListOptions{}) + controller.Run() defer controller.Stop() @@ -466,7 +488,7 @@ func TestPersistentVolumeMultiPVs(t *testing.T) { []api.PersistentVolumeAccessMode{api.ReadWriteOnce}, api.PersistentVolumeReclaimRetain) } - pvc := createPVC("pvc-2", strconv.Itoa(maxPVs/2)+"G", []api.PersistentVolumeAccessMode{api.ReadWriteOnce}) + pvc := createPVC("pvc-2", ns.Name, strconv.Itoa(maxPVs/2)+"G", []api.PersistentVolumeAccessMode{api.ReadWriteOnce}) for i := 0; i < maxPVs; i++ { _, err := testClient.PersistentVolumes().Create(pvs[i]) @@ -477,7 +499,7 @@ func TestPersistentVolumeMultiPVs(t *testing.T) { } t.Log("volumes created") - _, err := testClient.PersistentVolumeClaims(api.NamespaceDefault).Create(pvc) + _, err := testClient.PersistentVolumeClaims(ns.Name).Create(pvc) if err != nil { t.Errorf("Failed to create PersistentVolumeClaim: %v", err) } @@ -486,7 +508,7 @@ func TestPersistentVolumeMultiPVs(t *testing.T) { // wait until the binder pairs the claim with a volume waitForAnyPersistentVolumePhase(watchPV, api.VolumeBound) t.Log("volume bound") - waitForPersistentVolumeClaimPhase(testClient, pvc.Name, watchPVC, api.ClaimBound) + waitForPersistentVolumeClaimPhase(testClient, pvc.Name, ns.Name, watchPVC, api.ClaimBound) t.Log("claim bound") // only one PV is bound @@ -517,7 +539,7 @@ func TestPersistentVolumeMultiPVs(t *testing.T) { } // deleting a claim releases the volume - if err := testClient.PersistentVolumeClaims(api.NamespaceDefault).Delete(pvc.Name, nil); err != nil { + if err := testClient.PersistentVolumeClaims(ns.Name).Delete(pvc.Name, nil); err != nil { t.Errorf("error deleting claim %s", pvc.Name) } t.Log("claim deleted") @@ -529,16 +551,20 @@ 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) { - // TODO: Limit the test to a single non-default namespace and clean this up at the end. - framework.DeleteAllEtcdKeys() - _, s := framework.RunAMaster(nil) defer s.Close() - testClient, binder, watchPV, watchPVC := createClients(t, s) + ns := framework.CreateTestingNamespace("multi-pvs-pvcs", s, t) + defer framework.DeleteTestingNamespace(ns, s, t) + + testClient, binder, watchPV, watchPVC := createClients(ns, t, s) defer watchPV.Stop() defer watchPVC.Stop() + // NOTE: This test cannot run in parallel, because it is creating and deleting + // non-namespaced objects (PersistenceVolumes). + defer testClient.Core().PersistentVolumes().DeleteCollection(nil, api.ListOptions{}) + binder.Run() defer binder.Stop() @@ -549,7 +575,7 @@ func TestPersistentVolumeMultiPVsPVCs(t *testing.T) { // This PV will be claimed, released, and deleted pvs[i] = createPV("pv-"+strconv.Itoa(i), "/tmp/foo"+strconv.Itoa(i), "1G", []api.PersistentVolumeAccessMode{api.ReadWriteOnce}, api.PersistentVolumeReclaimRetain) - pvcs[i] = createPVC("pvc-"+strconv.Itoa(i), "1G", []api.PersistentVolumeAccessMode{api.ReadWriteOnce}) + pvcs[i] = createPVC("pvc-"+strconv.Itoa(i), ns.Name, "1G", []api.PersistentVolumeAccessMode{api.ReadWriteOnce}) } // Create PVs first @@ -573,7 +599,7 @@ func TestPersistentVolumeMultiPVsPVCs(t *testing.T) { // Create the claims, again in a separate goroutine. go func() { for i := 0; i < objCount; i++ { - _, _ = testClient.PersistentVolumeClaims(api.NamespaceDefault).Create(pvcs[i]) + _, _ = testClient.PersistentVolumeClaims(ns.Name).Create(pvcs[i]) } }() @@ -595,7 +621,7 @@ func TestPersistentVolumeMultiPVsPVCs(t *testing.T) { } glog.V(2).Infof("PV %q is bound to PVC %q", pv.Name, pv.Spec.ClaimRef.Name) - pvc, err := testClient.PersistentVolumeClaims(api.NamespaceDefault).Get(pvcs[i].Name) + pvc, err := testClient.PersistentVolumeClaims(ns.Name).Get(pvcs[i].Name) if err != nil { t.Fatalf("Unexpected error getting pvc: %v", err) } @@ -610,22 +636,27 @@ func TestPersistentVolumeMultiPVsPVCs(t *testing.T) { // TestPersistentVolumeProvisionMultiPVCs tests provisioning of many PVCs. // This test is configurable by KUBE_INTEGRATION_PV_* variables. func TestPersistentVolumeProvisionMultiPVCs(t *testing.T) { - // TODO: Limit the test to a single non-default namespace and clean this up at the end. - framework.DeleteAllEtcdKeys() - _, s := framework.RunAMaster(nil) defer s.Close() - testClient, binder, watchPV, watchPVC := createClients(t, s) + ns := framework.CreateTestingNamespace("provision-multi-pvs", s, t) + defer framework.DeleteTestingNamespace(ns, s, t) + + testClient, binder, watchPV, watchPVC := createClients(ns, t, s) defer watchPV.Stop() defer watchPVC.Stop() + + // NOTE: This test cannot run in parallel, because it is creating and deleting + // non-namespaced objects (PersistenceVolumes). + defer testClient.Core().PersistentVolumes().DeleteCollection(nil, api.ListOptions{}) + binder.Run() defer binder.Stop() objCount := getObjectCount() pvcs := make([]*api.PersistentVolumeClaim, objCount) for i := 0; i < objCount; i++ { - pvc := createPVC("pvc-provision-"+strconv.Itoa(i), "1G", []api.PersistentVolumeAccessMode{api.ReadWriteOnce}) + pvc := createPVC("pvc-provision-"+strconv.Itoa(i), ns.Name, "1G", []api.PersistentVolumeAccessMode{api.ReadWriteOnce}) pvc.Annotations = map[string]string{ "volume.alpha.kubernetes.io/storage-class": "", } @@ -637,7 +668,7 @@ func TestPersistentVolumeProvisionMultiPVCs(t *testing.T) { // early. It gets stuck with >3000 claims. go func() { for i := 0; i < objCount; i++ { - _, _ = testClient.PersistentVolumeClaims(api.NamespaceDefault).Create(pvcs[i]) + _, _ = testClient.PersistentVolumeClaims(ns.Name).Create(pvcs[i]) } }() @@ -666,7 +697,7 @@ func TestPersistentVolumeProvisionMultiPVCs(t *testing.T) { // Delete the claims for i := 0; i < objCount; i++ { - _ = testClient.PersistentVolumeClaims(api.NamespaceDefault).Delete(pvcs[i].Name, nil) + _ = testClient.PersistentVolumeClaims(ns.Name).Delete(pvcs[i].Name, nil) } // Wait for the PVs to get deleted by listing remaining volumes @@ -689,16 +720,20 @@ func TestPersistentVolumeProvisionMultiPVCs(t *testing.T) { // TestPersistentVolumeMultiPVsDiffAccessModes tests binding of one PVC to two // PVs with different access modes. func TestPersistentVolumeMultiPVsDiffAccessModes(t *testing.T) { - // TODO: Limit the test to a single non-default namespace and clean this up at the end. - framework.DeleteAllEtcdKeys() - _, s := framework.RunAMaster(nil) defer s.Close() - testClient, controller, watchPV, watchPVC := createClients(t, s) + ns := framework.CreateTestingNamespace("multi-pvs-diff-access", s, t) + defer framework.DeleteTestingNamespace(ns, s, t) + + testClient, controller, watchPV, watchPVC := createClients(ns, t, s) defer watchPV.Stop() defer watchPVC.Stop() + // NOTE: This test cannot run in parallel, because it is creating and deleting + // non-namespaced objects (PersistenceVolumes). + defer testClient.Core().PersistentVolumes().DeleteCollection(nil, api.ListOptions{}) + controller.Run() defer controller.Stop() @@ -708,7 +743,7 @@ func TestPersistentVolumeMultiPVsDiffAccessModes(t *testing.T) { pv_rwm := createPV("pv-rwm", "/tmp/bar", "10G", []api.PersistentVolumeAccessMode{api.ReadWriteMany}, api.PersistentVolumeReclaimRetain) - pvc := createPVC("pvc-rwm", "5G", []api.PersistentVolumeAccessMode{api.ReadWriteMany}) + pvc := createPVC("pvc-rwm", ns.Name, "5G", []api.PersistentVolumeAccessMode{api.ReadWriteMany}) _, err := testClient.PersistentVolumes().Create(pv_rwm) if err != nil { @@ -720,7 +755,7 @@ func TestPersistentVolumeMultiPVsDiffAccessModes(t *testing.T) { } t.Log("volumes created") - _, err = testClient.PersistentVolumeClaims(api.NamespaceDefault).Create(pvc) + _, err = testClient.PersistentVolumeClaims(ns.Name).Create(pvc) if err != nil { t.Errorf("Failed to create PersistentVolumeClaim: %v", err) } @@ -729,7 +764,7 @@ func TestPersistentVolumeMultiPVsDiffAccessModes(t *testing.T) { // wait until the controller pairs the volume and claim waitForAnyPersistentVolumePhase(watchPV, api.VolumeBound) t.Log("volume bound") - waitForPersistentVolumeClaimPhase(testClient, pvc.Name, watchPVC, api.ClaimBound) + waitForPersistentVolumeClaimPhase(testClient, pvc.Name, ns.Name, watchPVC, api.ClaimBound) t.Log("claim bound") // only RWM PV is bound @@ -752,7 +787,7 @@ func TestPersistentVolumeMultiPVsDiffAccessModes(t *testing.T) { } // deleting a claim releases the volume - if err := testClient.PersistentVolumeClaims(api.NamespaceDefault).Delete(pvc.Name, nil); err != nil { + if err := testClient.PersistentVolumeClaims(ns.Name).Delete(pvc.Name, nil); err != nil { t.Errorf("error deleting claim %s", pvc.Name) } t.Log("claim deleted") @@ -782,9 +817,9 @@ func waitForPersistentVolumePhase(client *clientset.Clientset, pvName string, w } } -func waitForPersistentVolumeClaimPhase(client *clientset.Clientset, claimName string, w watch.Interface, phase api.PersistentVolumeClaimPhase) { +func waitForPersistentVolumeClaimPhase(client *clientset.Clientset, claimName, namespace string, w watch.Interface, phase api.PersistentVolumeClaimPhase) { // Check if the claim is already in requested phase - claim, err := client.Core().PersistentVolumeClaims(api.NamespaceDefault).Get(claimName) + claim, err := client.Core().PersistentVolumeClaims(namespace).Get(claimName) if err == nil && claim.Status.Phase == phase { return } @@ -831,11 +866,21 @@ func waitForAnyPersistentVolumeClaimPhase(w watch.Interface, phase api.Persisten } } -func createClients(t *testing.T, s *httptest.Server) (*clientset.Clientset, *persistentvolumecontroller.PersistentVolumeController, watch.Interface, watch.Interface) { +func createClients(ns *api.Namespace, t *testing.T, s *httptest.Server) (*clientset.Clientset, *persistentvolumecontroller.PersistentVolumeController, 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: testapi.Default.GroupVersion()}, QPS: 1000000, Burst: 1000000}) - testClient := clientset.NewForConfigOrDie(&restclient.Config{Host: s.URL, ContentConfig: restclient.ContentConfig{GroupVersion: testapi.Default.GroupVersion()}, QPS: 1000000, Burst: 1000000}) + binderClient := clientset.NewForConfigOrDie(&restclient.Config{ + Host: s.URL, + ContentConfig: restclient.ContentConfig{GroupVersion: testapi.Default.GroupVersion()}, + QPS: 1000000, + Burst: 1000000, + }) + testClient := clientset.NewForConfigOrDie(&restclient.Config{ + Host: s.URL, + ContentConfig: restclient.ContentConfig{GroupVersion: testapi.Default.GroupVersion()}, + QPS: 1000000, + Burst: 1000000, + }) host := volumetest.NewFakeVolumeHost("/tmp/fake", nil, nil, "" /* rootContext */) plugin := &volumetest.FakeVolumePlugin{ @@ -860,7 +905,7 @@ func createClients(t *testing.T, s *httptest.Server) (*clientset.Clientset, *per if err != nil { t.Fatalf("Failed to watch PersistentVolumes: %v", err) } - watchPVC, err := testClient.PersistentVolumeClaims(api.NamespaceDefault).Watch(api.ListOptions{}) + watchPVC, err := testClient.PersistentVolumeClaims(ns.Name).Watch(api.ListOptions{}) if err != nil { t.Fatalf("Failed to watch PersistentVolumeClaimss: %v", err) } @@ -880,11 +925,11 @@ func createPV(name, path, cap string, mode []api.PersistentVolumeAccessMode, rec } } -func createPVC(name, cap string, mode []api.PersistentVolumeAccessMode) *api.PersistentVolumeClaim { +func createPVC(name, namespace, cap string, mode []api.PersistentVolumeAccessMode) *api.PersistentVolumeClaim { return &api.PersistentVolumeClaim{ ObjectMeta: api.ObjectMeta{ Name: name, - Namespace: api.NamespaceDefault, + Namespace: namespace, }, Spec: api.PersistentVolumeClaimSpec{ Resources: api.ResourceRequirements{Requests: api.ResourceList{api.ResourceName(api.ResourceStorage): resource.MustParse(cap)}},