Merge pull request #80382 from davidz627/fix/refactor

Dedupe all Make PVC API object functions into the one MakePersistentVolumeClaim to rule them all

test/e2e/framework/pv_util.go

@@ -88,15 +88,22 @@ type PersistentVolumeConfig struct {
 	VolumeMode       *v1.PersistentVolumeMode
 }
 
-// PersistentVolumeClaimConfig is consumed by MakePersistentVolumeClaim() to generate a PVC object.
+// PersistentVolumeClaimConfig is consumed by MakePersistentVolumeClaim() to
-// AccessModes defaults to all modes (RWO, RWX, ROX) if left empty
+// generate a PVC object.
-// (+optional) Annotations defines the PVC's annotations
 type PersistentVolumeClaimConfig struct {
+	// NamePrefix defaults to "pvc-" if unspecified
+	NamePrefix string
+	// ClaimSize must be specified in the Quantity format. Defaults to 2Gi if
+	// unspecified
+	ClaimSize string
+	// AccessModes defaults to RWO if unspecified
 	AccessModes      []v1.PersistentVolumeAccessMode
 	Annotations      map[string]string
 	Selector         *metav1.LabelSelector
 	StorageClassName *string
-	VolumeMode       *v1.PersistentVolumeMode
+	// VolumeMode defaults to nil if unspecified or specified as the empty
+	// string
+	VolumeMode *v1.PersistentVolumeMode
 }
 
 // NodeSelection specifies where to run a pod, using a combination of fixed node name,
@@ -613,21 +620,29 @@ func MakePersistentVolume(pvConfig PersistentVolumeConfig) *v1.PersistentVolume
 	}
 }
 
-// MakePersistentVolumeClaim returns a PVC definition based on the namespace.
+// MakePersistentVolumeClaim returns a PVC API Object based on the PersistentVolumeClaimConfig.
-// Note: if this PVC is intended to be pre-bound to a PV, whose name is not
-//   known until the PV is instantiated, then the func CreatePVPVC will add
-//   pvc.Spec.VolumeName to this claim.
 func MakePersistentVolumeClaim(cfg PersistentVolumeClaimConfig, ns string) *v1.PersistentVolumeClaim {
-	// Specs are expected to match this test's PersistentVolume
 
 	if len(cfg.AccessModes) == 0 {
-		e2elog.Logf("AccessModes unspecified, default: ReadWriteOnce (RWO).")
 		cfg.AccessModes = append(cfg.AccessModes, v1.ReadWriteOnce)
 	}
 
+	if len(cfg.ClaimSize) == 0 {
+		cfg.ClaimSize = "2Gi"
+	}
+
+	if len(cfg.NamePrefix) == 0 {
+		cfg.NamePrefix = "pvc-"
+	}
+
+	if cfg.VolumeMode != nil && *cfg.VolumeMode == "" {
+		e2elog.Logf("Warning: Making PVC: VolumeMode specified as invalid empty string, treating as nil")
+		cfg.VolumeMode = nil
+	}
+
 	return &v1.PersistentVolumeClaim{
 		ObjectMeta: metav1.ObjectMeta{
-			GenerateName: "pvc-",
+			GenerateName: cfg.NamePrefix,
 			Namespace:    ns,
 			Annotations:  cfg.Annotations,
 		},
@@ -636,7 +651,7 @@ func MakePersistentVolumeClaim(cfg PersistentVolumeClaimConfig, ns string) *v1.P
 			AccessModes: cfg.AccessModes,
 			Resources: v1.ResourceRequirements{
 				Requests: v1.ResourceList{
-					v1.ResourceName(v1.ResourceStorage): resource.MustParse("1Gi"),
+					v1.ResourceName(v1.ResourceStorage): resource.MustParse(cfg.ClaimSize),
 				},
 			},
 			StorageClassName: cfg.StorageClassName,

test/e2e/storage/csi_mock_volume.go

@@ -602,8 +602,11 @@ func startPausePod(cs clientset.Interface, t testsuites.StorageClassTest, node f
 		framework.ExpectNoError(err, "Failed to create class : %v", err)
 	}
 
-	claim := newClaim(t, ns, "")
+	claim := framework.MakePersistentVolumeClaim(framework.PersistentVolumeClaimConfig{
-	claim.Spec.StorageClassName = &class.Name
+		ClaimSize:        t.ClaimSize,
+		StorageClassName: &(class.Name),
+		VolumeMode:       &t.VolumeMode,
+	}, ns)
 	claim, err = cs.CoreV1().PersistentVolumeClaims(ns).Create(claim)
 	framework.ExpectNoError(err, "Failed to create claim: %v", err)
 

test/e2e/storage/csi_volumes.go

@@ -119,8 +119,11 @@ func testTopologyPositive(cs clientset.Interface, suffix, namespace string, dela
 		addSingleCSIZoneAllowedTopologyToStorageClass(cs, class, topoZone)
 	}
 	test.Client = cs
-	test.Claim = newClaim(test, namespace, suffix)
+	test.Claim = framework.MakePersistentVolumeClaim(framework.PersistentVolumeClaimConfig{
-	test.Claim.Spec.StorageClassName = &class.Name
+		ClaimSize:        test.ClaimSize,
+		StorageClassName: &(class.Name),
+		VolumeMode:       &test.VolumeMode,
+	}, namespace)
 	test.Class = class
 
 	if delayBinding {
@@ -150,8 +153,11 @@ func testTopologyNegative(cs clientset.Interface, suffix, namespace string, dela
 	test.Client = cs
 	test.Class = newStorageClass(test, namespace, suffix)
 	addSingleCSIZoneAllowedTopologyToStorageClass(cs, test.Class, pvZone)
-	test.Claim = newClaim(test, namespace, suffix)
+	test.Claim = framework.MakePersistentVolumeClaim(framework.PersistentVolumeClaimConfig{
-	test.Claim.Spec.StorageClassName = &test.Class.Name
+		ClaimSize:        test.ClaimSize,
+		StorageClassName: &(test.Class.Name),
+		VolumeMode:       &test.VolumeMode,
+	}, namespace)
 	if delayBinding {
 		test.TestBindingWaitForFirstConsumer(nodeSelector, true /* expect unschedulable */)
 	} else {

test/e2e/storage/flexvolume_mounted_volume_resize.go

@@ -96,8 +96,10 @@ var _ = utils.SIGDescribe("Mounted flexvolume expand[Slow]", func() {
 		framework.ExpectNoError(err, "Error creating resizable storage class")
 		gomega.Expect(*resizableSc.AllowVolumeExpansion).To(gomega.BeTrue())
 
-		pvc = getClaim("2Gi", ns)
+		pvc = framework.MakePersistentVolumeClaim(framework.PersistentVolumeClaimConfig{
-		pvc.Spec.StorageClassName = &resizableSc.Name
+			StorageClassName: &(resizableSc.Name),
+			ClaimSize:        "2Gi",
+		}, ns)
 		pvc, err = c.CoreV1().PersistentVolumeClaims(pvc.Namespace).Create(pvc)
 		framework.ExpectNoError(err, "Error creating pvc")
 	})

test/e2e/storage/flexvolume_online_resize.go

@@ -88,8 +88,10 @@ var _ = utils.SIGDescribe("Mounted flexvolume volume expand [Slow] [Feature:Expa
 		framework.ExpectNoError(err, "Error creating resizable storage class: %v", err)
 		gomega.Expect(*resizableSc.AllowVolumeExpansion).To(gomega.BeTrue())
 
-		pvc = getClaim("2Gi", ns)
+		pvc = framework.MakePersistentVolumeClaim(framework.PersistentVolumeClaimConfig{
-		pvc.Spec.StorageClassName = &resizableSc.Name
+			StorageClassName: &(resizableSc.Name),
+			ClaimSize:        "2Gi",
+		}, ns)
 		pvc, err = c.CoreV1().PersistentVolumeClaims(pvc.Namespace).Create(pvc)
 		framework.ExpectNoError(err, "Error creating pvc: %v", err)
 

test/e2e/storage/generic_persistent_volume-disruptive.go

@@ -90,7 +90,10 @@ func createPodPVCFromSC(f *framework.Framework, c clientset.Interface, ns string
 		Name:      "default",
 		ClaimSize: "2Gi",
 	}
-	pvc := newClaim(test, ns, "default")
+	pvc := framework.MakePersistentVolumeClaim(framework.PersistentVolumeClaimConfig{
+		ClaimSize:  test.ClaimSize,
+		VolumeMode: &test.VolumeMode,
+	}, ns)
 	pvc, err = c.CoreV1().PersistentVolumeClaims(pvc.Namespace).Create(pvc)
 	framework.ExpectNoError(err, "Error creating pvc")
 	pvcClaims := []*v1.PersistentVolumeClaim{pvc}

test/e2e/storage/mounted_volume_resize.go

@@ -85,8 +85,11 @@ var _ = utils.SIGDescribe("Mounted volume expand", func() {
 		framework.ExpectNoError(err, "Error creating resizable storage class")
 		gomega.Expect(*resizableSc.AllowVolumeExpansion).To(gomega.BeTrue())
 
-		pvc = newClaim(test, ns, "default")
+		pvc = framework.MakePersistentVolumeClaim(framework.PersistentVolumeClaimConfig{
-		pvc.Spec.StorageClassName = &resizableSc.Name
+			ClaimSize:        test.ClaimSize,
+			StorageClassName: &(resizableSc.Name),
+			VolumeMode:       &test.VolumeMode,
+		}, ns)
 		pvc, err = c.CoreV1().PersistentVolumeClaims(pvc.Namespace).Create(pvc)
 		framework.ExpectNoError(err, "Error creating pvc")
 	})

test/e2e/storage/pvc_protection.go

@@ -47,12 +47,16 @@ var _ = utils.SIGDescribe("PVC Protection", func() {
 		framework.ExpectNoError(framework.WaitForAllNodesSchedulable(client, framework.TestContext.NodeSchedulableTimeout))
 
 		ginkgo.By("Creating a PVC")
-		suffix := "pvc-protection"
+		prefix := "pvc-protection"
 		framework.SkipIfNoDefaultStorageClass(client)
-		testStorageClass := testsuites.StorageClassTest{
+		t := testsuites.StorageClassTest{
 			ClaimSize: "1Gi",
 		}
-		pvc = newClaim(testStorageClass, nameSpace, suffix)
+		pvc = framework.MakePersistentVolumeClaim(framework.PersistentVolumeClaimConfig{
+			NamePrefix: prefix,
+			ClaimSize:  t.ClaimSize,
+			VolumeMode: &t.VolumeMode,
+		}, nameSpace)
 		pvc, err = client.CoreV1().PersistentVolumeClaims(pvc.Namespace).Create(pvc)
 		framework.ExpectNoError(err, "Error creating PVC")
 		pvcCreatedAndNotDeleted = true

test/e2e/storage/regional_pd.go

@@ -149,8 +149,11 @@ func testVolumeProvisioning(c clientset.Interface, ns string) {
 	for _, test := range tests {
 		test.Client = c
 		test.Class = newStorageClass(test, ns, "" /* suffix */)
-		test.Claim = newClaim(test, ns, "" /* suffix */)
+		test.Claim = framework.MakePersistentVolumeClaim(framework.PersistentVolumeClaimConfig{
-		test.Claim.Spec.StorageClassName = &test.Class.Name
+			ClaimSize:        test.ClaimSize,
+			StorageClassName: &(test.Class.Name),
+			VolumeMode:       &test.VolumeMode,
+		}, ns)
 		test.TestDynamicProvisioning()
 	}
 }
@@ -170,9 +173,12 @@ func testZonalFailover(c clientset.Interface, ns string) {
 		ExpectedSize: repdMinSize,
 	}
 	class := newStorageClass(testSpec, ns, "" /* suffix */)
-	claimTemplate := newClaim(testSpec, ns, "" /* suffix */)
+	claimTemplate := framework.MakePersistentVolumeClaim(framework.PersistentVolumeClaimConfig{
-	claimTemplate.Name = pvcName
+		NamePrefix:       pvcName,
-	claimTemplate.Spec.StorageClassName = &class.Name
+		ClaimSize:        testSpec.ClaimSize,
+		StorageClassName: &(class.Name),
+		VolumeMode:       &testSpec.VolumeMode,
+	}, ns)
 	statefulSet, service, regionalPDLabels := newStatefulSet(claimTemplate, ns)
 
 	ginkgo.By("creating a StorageClass " + class.Name)
@@ -332,8 +338,11 @@ func testRegionalDelayedBinding(c clientset.Interface, ns string, pvcCount int)
 	test.Class = newStorageClass(test, ns, suffix)
 	var claims []*v1.PersistentVolumeClaim
 	for i := 0; i < pvcCount; i++ {
-		claim := newClaim(test, ns, suffix)
+		claim := framework.MakePersistentVolumeClaim(framework.PersistentVolumeClaimConfig{
-		claim.Spec.StorageClassName = &test.Class.Name
+			ClaimSize:        test.ClaimSize,
+			StorageClassName: &(test.Class.Name),
+			VolumeMode:       &test.VolumeMode,
+		}, ns)
 		claims = append(claims, claim)
 	}
 	pvs, node := test.TestBindingWaitForFirstConsumerMultiPVC(claims, nil /* node selector */, false /* expect unschedulable */)
@@ -366,8 +375,12 @@ func testRegionalAllowedTopologies(c clientset.Interface, ns string) {
 	test.Class = newStorageClass(test, ns, suffix)
 	zones := getTwoRandomZones(c)
 	addAllowedTopologiesToStorageClass(c, test.Class, zones)
-	test.Claim = newClaim(test, ns, suffix)
+	test.Claim = framework.MakePersistentVolumeClaim(framework.PersistentVolumeClaimConfig{
-	test.Claim.Spec.StorageClassName = &test.Class.Name
+		NamePrefix:       pvcName,
+		ClaimSize:        test.ClaimSize,
+		StorageClassName: &(test.Class.Name),
+		VolumeMode:       &test.VolumeMode,
+	}, ns)
 
 	pv := test.TestDynamicProvisioning()
 	checkZonesFromLabelAndAffinity(pv, sets.NewString(zones...), true)
@@ -392,8 +405,11 @@ func testRegionalAllowedTopologiesWithDelayedBinding(c clientset.Interface, ns s
 	addAllowedTopologiesToStorageClass(c, test.Class, topoZones)
 	var claims []*v1.PersistentVolumeClaim
 	for i := 0; i < pvcCount; i++ {
-		claim := newClaim(test, ns, suffix)
+		claim := framework.MakePersistentVolumeClaim(framework.PersistentVolumeClaimConfig{
-		claim.Spec.StorageClassName = &test.Class.Name
+			ClaimSize:        test.ClaimSize,
+			StorageClassName: &(test.Class.Name),
+			VolumeMode:       &test.VolumeMode,
+		}, ns)
 		claims = append(claims, claim)
 	}
 	pvs, node := test.TestBindingWaitForFirstConsumerMultiPVC(claims, nil /* node selector */, false /* expect unschedulable */)

test/e2e/storage/testsuites/base.go

@@ -29,7 +29,6 @@ import (
 	v1 "k8s.io/api/core/v1"
 	storagev1 "k8s.io/api/storage/v1"
 	apierrs "k8s.io/apimachinery/pkg/api/errors"
-	"k8s.io/apimachinery/pkg/api/resource"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
 	utilerrors "k8s.io/apimachinery/pkg/util/errors"
@@ -202,7 +201,8 @@ func createGenericVolumeTestResource(driver TestDriver, config *PerTestConfig, p
 		if pDriver, ok := driver.(PreprovisionedPVTestDriver); ok {
 			pvSource, volumeNodeAffinity := pDriver.GetPersistentVolumeSource(false, pattern.FsType, r.volume)
 			if pvSource != nil {
-				r.volSource, r.pv, r.pvc = createVolumeSourceWithPVCPV(f, dInfo.Name, pvSource, volumeNodeAffinity, false, pattern.VolMode)
+				r.pv, r.pvc = createPVCPV(f, dInfo.Name, pvSource, volumeNodeAffinity, pattern.VolMode)
+				r.volSource = createVolumeSource(r.pvc.Name, false /* readOnly */)
 			}
 			r.volType = fmt.Sprintf("%s-preprovisionedPV", dInfo.Name)
 		}
@@ -225,8 +225,9 @@ func createGenericVolumeTestResource(driver TestDriver, config *PerTestConfig, p
 			framework.ExpectNoError(err)
 
 			if r.sc != nil {
-				r.volSource, r.pv, r.pvc = createVolumeSourceWithPVCPVFromDynamicProvisionSC(
+				r.pv, r.pvc = createPVCPVFromDynamicProvisionSC(
-					f, dInfo.Name, claimSize, r.sc, false, pattern.VolMode)
+					f, dInfo.Name, claimSize, r.sc, pattern.VolMode)
+				r.volSource = createVolumeSource(r.pvc.Name, false /* readOnly */)
 			}
 			r.volType = fmt.Sprintf("%s-dynamicPV", dInfo.Name)
 		}
@@ -241,6 +242,16 @@ func createGenericVolumeTestResource(driver TestDriver, config *PerTestConfig, p
 	return &r
 }
 
+func createVolumeSource(pvcName string, readOnly bool) *v1.VolumeSource {
+	return &v1.VolumeSource{
+		PersistentVolumeClaim: &v1.PersistentVolumeClaimVolumeSource{
+			ClaimName: pvcName,
+			ReadOnly:  readOnly,
+		},
+	}
+
+}
+
 // cleanupResource cleans up genericVolumeTestResource
 func (r *genericVolumeTestResource) cleanupResource() {
 	f := r.config.Framework
@@ -283,14 +294,13 @@ func (r *genericVolumeTestResource) cleanupResource() {
 	}
 }
 
-func createVolumeSourceWithPVCPV(
+func createPVCPV(
 	f *framework.Framework,
 	name string,
 	pvSource *v1.PersistentVolumeSource,
 	volumeNodeAffinity *v1.VolumeNodeAffinity,
-	readOnly bool,
 	volMode v1.PersistentVolumeMode,
-) (*v1.VolumeSource, *v1.PersistentVolume, *v1.PersistentVolumeClaim) {
+) (*v1.PersistentVolume, *v1.PersistentVolumeClaim) {
 	pvConfig := framework.PersistentVolumeConfig{
 		NamePrefix:       fmt.Sprintf("%s-", name),
 		StorageClassName: f.Namespace.Name,
@@ -314,33 +324,32 @@ func createVolumeSourceWithPVCPV(
 	err = framework.WaitOnPVandPVC(f.ClientSet, f.Namespace.Name, pv, pvc)
 	framework.ExpectNoError(err, "PVC, PV failed to bind")
 
-	volSource := &v1.VolumeSource{
+	return pv, pvc
-		PersistentVolumeClaim: &v1.PersistentVolumeClaimVolumeSource{
-			ClaimName: pvc.Name,
-			ReadOnly:  readOnly,
-		},
-	}
-	return volSource, pv, pvc
 }
 
-func createVolumeSourceWithPVCPVFromDynamicProvisionSC(
+func createPVCPVFromDynamicProvisionSC(
 	f *framework.Framework,
 	name string,
 	claimSize string,
 	sc *storagev1.StorageClass,
-	readOnly bool,
 	volMode v1.PersistentVolumeMode,
-) (*v1.VolumeSource, *v1.PersistentVolume, *v1.PersistentVolumeClaim) {
+) (*v1.PersistentVolume, *v1.PersistentVolumeClaim) {
 	cs := f.ClientSet
 	ns := f.Namespace.Name
 
 	ginkgo.By("creating a claim")
-	pvc := getClaim(claimSize, ns)
+	pvcCfg := framework.PersistentVolumeClaimConfig{
-	pvc.Spec.StorageClassName = &sc.Name
+		NamePrefix:       name,
-	if volMode != "" {
+		ClaimSize:        claimSize,
-		pvc.Spec.VolumeMode = &volMode
+		StorageClassName: &(sc.Name),
 	}
 
+	if len(volMode) != 0 {
+		pvcCfg.VolumeMode = &volMode
+	}
+
+	pvc := framework.MakePersistentVolumeClaim(pvcCfg, ns)
+
 	var err error
 	pvc, err = cs.CoreV1().PersistentVolumeClaims(ns).Create(pvc)
 	framework.ExpectNoError(err)
@@ -359,13 +368,7 @@ func createVolumeSourceWithPVCPVFromDynamicProvisionSC(
 		framework.ExpectNoError(err)
 	}
 
-	volSource := &v1.VolumeSource{
+	return pv, pvc
-		PersistentVolumeClaim: &v1.PersistentVolumeClaimVolumeSource{
-			ClaimName: pvc.Name,
-			ReadOnly:  readOnly,
-		},
-	}
-	return volSource, pv, pvc
 }
 
 func isDelayedBinding(sc *storagev1.StorageClass) bool {
@@ -375,27 +378,6 @@ func isDelayedBinding(sc *storagev1.StorageClass) bool {
 	return false
 }
 
-func getClaim(claimSize string, ns string) *v1.PersistentVolumeClaim {
-	claim := v1.PersistentVolumeClaim{
-		ObjectMeta: metav1.ObjectMeta{
-			GenerateName: "pvc-",
-			Namespace:    ns,
-		},
-		Spec: v1.PersistentVolumeClaimSpec{
-			AccessModes: []v1.PersistentVolumeAccessMode{
-				v1.ReadWriteOnce,
-			},
-			Resources: v1.ResourceRequirements{
-				Requests: v1.ResourceList{
-					v1.ResourceName(v1.ResourceStorage): resource.MustParse(claimSize),
-				},
-			},
-		},
-	}
-
-	return &claim
-}
-
 // deleteStorageClass deletes the passed in StorageClass and catches errors other than "Not Found"
 func deleteStorageClass(cs clientset.Interface, className string) {
 	err := cs.StorageV1().StorageClasses().Delete(className, nil)

test/e2e/storage/testsuites/provisioning.go

@@ -130,8 +130,10 @@ func (p *provisioningTestSuite) defineTests(driver TestDriver, pattern testpatte
 		if l.sc == nil {
 			framework.Skipf("Driver %q does not define Dynamic Provision StorageClass - skipping", dInfo.Name)
 		}
-		l.pvc = getClaim(claimSize, l.config.Framework.Namespace.Name)
+		l.pvc = framework.MakePersistentVolumeClaim(framework.PersistentVolumeClaimConfig{
-		l.pvc.Spec.StorageClassName = &l.sc.Name
+			ClaimSize:        claimSize,
+			StorageClassName: &(l.sc.Name),
+		}, l.config.Framework.Namespace.Name)
 		e2elog.Logf("In creating storage class object and pvc object for driver - sc: %v, pvc: %v", l.sc, l.pvc)
 		l.testCase = &StorageClassTest{
 			Client:       l.config.Framework.ClientSet,

test/e2e/storage/testsuites/snapshottable.go

@@ -107,9 +107,11 @@ func (s *snapshottableTestSuite) defineTests(driver TestDriver, pattern testpatt
 			framework.Skipf("Driver %q does not define Dynamic Provision StorageClass - skipping", driver.GetDriverInfo().Name)
 		}
 
-		claimSize := dDriver.GetClaimSize()
+		pvc := framework.MakePersistentVolumeClaim(framework.PersistentVolumeClaimConfig{
-		pvc := getClaim(claimSize, config.Framework.Namespace.Name)
+			ClaimSize:        dDriver.GetClaimSize(),
-		pvc.Spec.StorageClassName = &class.Name
+			StorageClassName: &(class.Name),
+		}, config.Framework.Namespace.Name)
+
 		e2elog.Logf("In creating storage class object and pvc object for driver - sc: %v, pvc: %v", class, pvc)
 
 		ginkgo.By("creating a StorageClass " + class.Name)

test/e2e/storage/testsuites/volumemode.go

@@ -139,10 +139,11 @@ func (t *volumeModeTestSuite) defineTests(driver TestDriver, pattern testpattern
 				}
 				l.sc.VolumeBindingMode = &volBindMode
 
-				claimSize := dDriver.GetClaimSize()
+				l.pvc = framework.MakePersistentVolumeClaim(framework.PersistentVolumeClaimConfig{
-				l.pvc = getClaim(claimSize, l.ns.Name)
+					ClaimSize:        dDriver.GetClaimSize(),
-				l.pvc.Spec.StorageClassName = &l.sc.Name
+					StorageClassName: &(l.sc.Name),
-				l.pvc.Spec.VolumeMode = &pattern.VolMode
+					VolumeMode:       &pattern.VolMode,
+				}, l.ns.Name)
 			}
 		default:
 			e2elog.Failf("Volume mode test doesn't support: %s", pattern.VolType)

test/e2e/storage/volume_metrics.go

@@ -65,7 +65,10 @@ var _ = utils.SIGDescribe("[Serial] Volume metrics", func() {
 			ClaimSize: "2Gi",
 		}
 
-		pvc = newClaim(test, ns, "default")
+		pvc = framework.MakePersistentVolumeClaim(framework.PersistentVolumeClaimConfig{
+			ClaimSize:  test.ClaimSize,
+			VolumeMode: &test.VolumeMode,
+		}, ns)
 
 		metricsGrabber, err = metrics.NewMetricsGrabber(c, nil, true, false, true, false, false)
 

test/e2e/storage/volume_provisioning.go

@@ -225,8 +225,11 @@ func testZonalDelayedBinding(c clientset.Interface, ns string, specifyAllowedTop
 		ginkgo.By(action)
 		var claims []*v1.PersistentVolumeClaim
 		for i := 0; i < pvcCount; i++ {
-			claim := newClaim(test, ns, suffix)
+			claim := framework.MakePersistentVolumeClaim(framework.PersistentVolumeClaimConfig{
-			claim.Spec.StorageClassName = &test.Class.Name
+				ClaimSize:        test.ClaimSize,
+				StorageClassName: &test.Class.Name,
+				VolumeMode:       &test.VolumeMode,
+			}, ns)
 			claims = append(claims, claim)
 		}
 		pvs, node := test.TestBindingWaitForFirstConsumerMultiPVC(claims, nil /* node selector */, false /* expect unschedulable */)
@@ -458,8 +461,11 @@ var _ = utils.SIGDescribe("Dynamic Provisioning", func() {
 				suffix := fmt.Sprintf("%d", i)
 				test.Client = c
 				test.Class = newStorageClass(test, ns, suffix)
-				test.Claim = newClaim(test, ns, suffix)
+				test.Claim = framework.MakePersistentVolumeClaim(framework.PersistentVolumeClaimConfig{
-				test.Claim.Spec.StorageClassName = &test.Class.Name
+					ClaimSize:        test.ClaimSize,
+					StorageClassName: &test.Class.Name,
+					VolumeMode:       &test.VolumeMode,
+				}, ns)
 				test.TestDynamicProvisioning()
 			}
 
@@ -474,7 +480,11 @@ var _ = utils.SIGDescribe("Dynamic Provisioning", func() {
 
 				betaTest.Client = c
 				betaTest.Class = nil
-				betaTest.Claim = newClaim(*betaTest, ns, "beta")
+				betaTest.Claim = framework.MakePersistentVolumeClaim(framework.PersistentVolumeClaimConfig{
+					ClaimSize:        betaTest.ClaimSize,
+					StorageClassName: &class.Name,
+					VolumeMode:       &betaTest.VolumeMode,
+				}, ns)
 				betaTest.Claim.Spec.StorageClassName = &(class.Name)
 				(*betaTest).TestDynamicProvisioning()
 			}
@@ -504,8 +514,11 @@ var _ = utils.SIGDescribe("Dynamic Provisioning", func() {
 			test.Class = newStorageClass(test, ns, "reclaimpolicy")
 			retain := v1.PersistentVolumeReclaimRetain
 			test.Class.ReclaimPolicy = &retain
-			test.Claim = newClaim(test, ns, "reclaimpolicy")
+			test.Claim = framework.MakePersistentVolumeClaim(framework.PersistentVolumeClaimConfig{
-			test.Claim.Spec.StorageClassName = &test.Class.Name
+				ClaimSize:        test.ClaimSize,
+				StorageClassName: &test.Class.Name,
+				VolumeMode:       &test.VolumeMode,
+			}, ns)
 			pv := test.TestDynamicProvisioning()
 
 			ginkgo.By(fmt.Sprintf("waiting for the provisioned PV %q to enter phase %s", pv.Name, v1.VolumeReleased))
@@ -563,8 +576,11 @@ var _ = utils.SIGDescribe("Dynamic Provisioning", func() {
 			defer deleteStorageClass(c, sc.Name)
 
 			ginkgo.By("Creating a claim and expecting it to timeout")
-			pvc := newClaim(test, ns, suffix)
+			pvc := framework.MakePersistentVolumeClaim(framework.PersistentVolumeClaimConfig{
-			pvc.Spec.StorageClassName = &sc.Name
+				ClaimSize:        test.ClaimSize,
+				StorageClassName: &sc.Name,
+				VolumeMode:       &test.VolumeMode,
+			}, ns)
 			pvc, err = c.CoreV1().PersistentVolumeClaims(ns).Create(pvc)
 			framework.ExpectNoError(err)
 			defer func() {
@@ -601,9 +617,13 @@ var _ = utils.SIGDescribe("Dynamic Provisioning", func() {
 
 			// To increase chance of detection, attempt multiple iterations
 			for i := 0; i < raceAttempts; i++ {
-				suffix := fmt.Sprintf("race-%d", i)
+				prefix := fmt.Sprintf("race-%d", i)
-				claim := newClaim(test, ns, suffix)
+				claim := framework.MakePersistentVolumeClaim(framework.PersistentVolumeClaimConfig{
-				claim.Spec.StorageClassName = &class.Name
+					NamePrefix:       prefix,
+					ClaimSize:        test.ClaimSize,
+					StorageClassName: &class.Name,
+					VolumeMode:       &test.VolumeMode,
+				}, ns)
 				tmpClaim, err := framework.CreatePVC(c, ns, claim)
 				framework.ExpectNoError(err)
 				framework.ExpectNoError(framework.DeletePersistentVolumeClaim(c, tmpClaim.Name, ns))
@@ -749,8 +769,11 @@ var _ = utils.SIGDescribe("Dynamic Provisioning", func() {
 				ExpectedSize: "1500Mi",
 			}
 			test.Class = newStorageClass(test, ns, "external")
-			test.Claim = newClaim(test, ns, "external")
+			test.Claim = framework.MakePersistentVolumeClaim(framework.PersistentVolumeClaimConfig{
-			test.Claim.Spec.StorageClassName = &test.Class.Name
+				ClaimSize:        test.ClaimSize,
+				StorageClassName: &test.Class.Name,
+				VolumeMode:       &test.VolumeMode,
+			}, ns)
 
 			ginkgo.By("creating a claim with a external provisioning annotation")
 			test.TestDynamicProvisioning()
@@ -769,7 +792,10 @@ var _ = utils.SIGDescribe("Dynamic Provisioning", func() {
 				ExpectedSize: "2Gi",
 			}
 
-			test.Claim = newClaim(test, ns, "default")
+			test.Claim = framework.MakePersistentVolumeClaim(framework.PersistentVolumeClaimConfig{
+				ClaimSize:  test.ClaimSize,
+				VolumeMode: &test.VolumeMode,
+			}, ns)
 			test.TestDynamicProvisioning()
 		})
 
@@ -791,7 +817,10 @@ var _ = utils.SIGDescribe("Dynamic Provisioning", func() {
 			updateDefaultStorageClass(c, scName, "false")
 
 			ginkgo.By("creating a claim with default storageclass and expecting it to timeout")
-			claim := newClaim(test, ns, "default")
+			claim := framework.MakePersistentVolumeClaim(framework.PersistentVolumeClaimConfig{
+				ClaimSize:  test.ClaimSize,
+				VolumeMode: &test.VolumeMode,
+			}, ns)
 			claim, err := c.CoreV1().PersistentVolumeClaims(ns).Create(claim)
 			framework.ExpectNoError(err)
 			defer func() {
@@ -825,7 +854,10 @@ var _ = utils.SIGDescribe("Dynamic Provisioning", func() {
 			updateDefaultStorageClass(c, scName, "")
 
 			ginkgo.By("creating a claim with default storageclass and expecting it to timeout")
-			claim := newClaim(test, ns, "default")
+			claim := framework.MakePersistentVolumeClaim(framework.PersistentVolumeClaimConfig{
+				ClaimSize:  test.ClaimSize,
+				VolumeMode: &test.VolumeMode,
+			}, ns)
 			claim, err := c.CoreV1().PersistentVolumeClaims(ns).Create(claim)
 			framework.ExpectNoError(err)
 			defer func() {
@@ -861,8 +893,11 @@ var _ = utils.SIGDescribe("Dynamic Provisioning", func() {
 			test.Class = newStorageClass(test, ns, suffix)
 
 			ginkgo.By("creating a claim object with a suffix for gluster dynamic provisioner")
-			test.Claim = newClaim(test, ns, suffix)
+			test.Claim = framework.MakePersistentVolumeClaim(framework.PersistentVolumeClaimConfig{
-			test.Claim.Spec.StorageClassName = &test.Class.Name
+				ClaimSize:        test.ClaimSize,
+				StorageClassName: &test.Class.Name,
+				VolumeMode:       &test.VolumeMode,
+			}, ns)
 
 			test.TestDynamicProvisioning()
 		})
@@ -889,8 +924,11 @@ var _ = utils.SIGDescribe("Dynamic Provisioning", func() {
 			}()
 
 			ginkgo.By("creating a claim object with a suffix for gluster dynamic provisioner")
-			claim := newClaim(test, ns, suffix)
+			claim := framework.MakePersistentVolumeClaim(framework.PersistentVolumeClaimConfig{
-			claim.Spec.StorageClassName = &class.Name
+				ClaimSize:        test.ClaimSize,
+				StorageClassName: &class.Name,
+				VolumeMode:       &test.VolumeMode,
+			}, ns)
 			claim, err = c.CoreV1().PersistentVolumeClaims(claim.Namespace).Create(claim)
 			framework.ExpectNoError(err)
 			defer func() {
@@ -967,8 +1005,11 @@ var _ = utils.SIGDescribe("Dynamic Provisioning", func() {
 				test.Class = newStorageClass(test, ns, suffix)
 				zone := getRandomClusterZone(c)
 				addSingleZoneAllowedTopologyToStorageClass(c, test.Class, zone)
-				test.Claim = newClaim(test, ns, suffix)
+				test.Claim = framework.MakePersistentVolumeClaim(framework.PersistentVolumeClaimConfig{
-				test.Claim.Spec.StorageClassName = &test.Class.Name
+					ClaimSize:        test.ClaimSize,
+					StorageClassName: &test.Class.Name,
+					VolumeMode:       &test.VolumeMode,
+				}, ns)
 				pv := test.TestDynamicProvisioning()
 				checkZoneFromLabelAndAffinity(pv, zone, true)
 			}
@@ -1013,36 +1054,6 @@ func updateDefaultStorageClass(c clientset.Interface, scName string, defaultStr
 	verifyDefaultStorageClass(c, scName, expectedDefault)
 }
 
-func getClaim(claimSize string, ns string) *v1.PersistentVolumeClaim {
-	claim := v1.PersistentVolumeClaim{
-		ObjectMeta: metav1.ObjectMeta{
-			GenerateName: "pvc-",
-			Namespace:    ns,
-		},
-		Spec: v1.PersistentVolumeClaimSpec{
-			AccessModes: []v1.PersistentVolumeAccessMode{
-				v1.ReadWriteOnce,
-			},
-			Resources: v1.ResourceRequirements{
-				Requests: v1.ResourceList{
-					v1.ResourceName(v1.ResourceStorage): resource.MustParse(claimSize),
-				},
-			},
-		},
-	}
-
-	return &claim
-}
-
-func newClaim(t testsuites.StorageClassTest, ns, suffix string) *v1.PersistentVolumeClaim {
-	claim := getClaim(t.ClaimSize, ns)
-	if t.VolumeMode == v1.PersistentVolumeBlock {
-		blockVolumeMode := v1.PersistentVolumeBlock
-		claim.Spec.VolumeMode = &blockVolumeMode
-	}
-	return claim
-}
-
 func getDefaultPluginName() string {
 	switch {
 	case framework.ProviderIs("gke"), framework.ProviderIs("gce"):