Refactor volume test in a similar way to csi tests

hack/.golint_failures

@@ -751,6 +751,8 @@ test/e2e/scalability
 test/e2e/scheduling
 test/e2e/servicecatalog
 test/e2e/storage
+test/e2e/storage/drivers
+test/e2e/storage/testsuites
 test/e2e/storage/utils
 test/e2e/storage/vsphere
 test/e2e/ui

test/e2e/framework/pv_util.go

@@ -507,7 +507,6 @@ func testPodSuccessOrFail(c clientset.Interface, ns string, pod *v1.Pod) error {
 // Deletes the passed-in pod and waits for the pod to be terminated. Resilient to the pod
 // not existing.
 func DeletePodWithWait(f *Framework, c clientset.Interface, pod *v1.Pod) error {
-	const maxWait = 5 * time.Minute
 	if pod == nil {
 		return nil
 	}
@@ -519,8 +518,8 @@ func DeletePodWithWait(f *Framework, c clientset.Interface, pod *v1.Pod) error {
 		}
 		return fmt.Errorf("pod Delete API error: %v", err)
 	}
-	Logf("Wait up to %v for pod %q to be fully deleted", maxWait, pod.Name)
-	err = f.WaitForPodNotFound(pod.Name, maxWait)
+	Logf("Wait up to %v for pod %q to be fully deleted", PodDeleteTimeout, pod.Name)
+	err = f.WaitForPodNotFound(pod.Name, PodDeleteTimeout)
 	if err != nil {
 		return fmt.Errorf("pod %q was not deleted: %v", pod.Name, err)
 	}
@@ -1006,11 +1005,19 @@ func CreateNginxPod(client clientset.Interface, namespace string, nodeSelector m
 
 // create security pod with given claims
 func CreateSecPod(client clientset.Interface, namespace string, pvclaims []*v1.PersistentVolumeClaim, isPrivileged bool, command string, hostIPC bool, hostPID bool, seLinuxLabel *v1.SELinuxOptions, fsGroup *int64, timeout time.Duration) (*v1.Pod, error) {
+	return CreateSecPodWithNodeName(client, namespace, pvclaims, isPrivileged, command, hostIPC, hostPID, seLinuxLabel, fsGroup, "", timeout)
+}
+
+// create security pod with given claims
+func CreateSecPodWithNodeName(client clientset.Interface, namespace string, pvclaims []*v1.PersistentVolumeClaim, isPrivileged bool, command string, hostIPC bool, hostPID bool, seLinuxLabel *v1.SELinuxOptions, fsGroup *int64, nodeName string, timeout time.Duration) (*v1.Pod, error) {
 	pod := MakeSecPod(namespace, pvclaims, isPrivileged, command, hostIPC, hostPID, seLinuxLabel, fsGroup)
 	pod, err := client.CoreV1().Pods(namespace).Create(pod)
 	if err != nil {
 		return nil, fmt.Errorf("pod Create API error: %v", err)
 	}
+	// Setting nodeName
+	pod.Spec.NodeName = nodeName
+
 	// Waiting for pod to be running
 	err = WaitTimeoutForPodRunningInNamespace(client, pod.Name, namespace, timeout)
 	if err != nil {

test/e2e/framework/volume_util.go

@@ -68,7 +68,7 @@ const (
 	TiB int64 = 1024 * GiB
 
 	// Waiting period for volume server (Ceph, ...) to initialize itself.
-	VolumeServerPodStartupTimeout = 1 * time.Minute
+	VolumeServerPodStartupTimeout = 3 * time.Minute
 
 	// Waiting period for pod to be cleaned up and unmount its volumes so we
 	// don't tear down containers with NFS/Ceph/Gluster server too early.
@@ -356,16 +356,42 @@ func StartVolumeServer(client clientset.Interface, config VolumeTestConfig) *v1.
 	return pod
 }
 
+// Wrapper of cleanup function for volume server without secret created by specific CreateStorageServer function.
+func CleanUpVolumeServer(f *Framework, serverPod *v1.Pod) {
+	CleanUpVolumeServerWithSecret(f, serverPod, nil)
+}
+
+// Wrapper of cleanup function for volume server with secret created by specific CreateStorageServer function.
+func CleanUpVolumeServerWithSecret(f *Framework, serverPod *v1.Pod, secret *v1.Secret) {
+	cs := f.ClientSet
+	ns := f.Namespace
+
+	if secret != nil {
+		Logf("Deleting server secret %q...", secret.Name)
+		err := cs.CoreV1().Secrets(ns.Name).Delete(secret.Name, &metav1.DeleteOptions{})
+		if err != nil {
+			Logf("Delete secret failed: %v", err)
+		}
+	}
+
+	Logf("Deleting server pod %q...", serverPod.Name)
+	err := DeletePodWithWait(f, cs, serverPod)
+	if err != nil {
+		Logf("Server pod delete failed: %v", err)
+	}
+}
+
 // Clean both server and client pods.
 func VolumeTestCleanup(f *Framework, config VolumeTestConfig) {
 	By(fmt.Sprint("cleaning the environment after ", config.Prefix))
 
 	defer GinkgoRecover()
 
-	client := f.ClientSet
-	podClient := client.CoreV1().Pods(config.Namespace)
+	cs := f.ClientSet
 
-	err := podClient.Delete(config.Prefix+"-client", nil)
+	pod, err := cs.CoreV1().Pods(config.Namespace).Get(config.Prefix+"-client", metav1.GetOptions{})
+	ExpectNoError(err, "Failed to get client pod: %v", err)
+	err = DeletePodWithWait(f, cs, pod)
 	if err != nil {
 		// Log the error before failing test: if the test has already failed,
 		// framework.ExpectNoError() won't print anything to logs!
@@ -374,15 +400,9 @@ func VolumeTestCleanup(f *Framework, config VolumeTestConfig) {
 	}
 
 	if config.ServerImage != "" {
-		if err := f.WaitForPodTerminated(config.Prefix+"-client", ""); !apierrs.IsNotFound(err) {
-			ExpectNoError(err, "Failed to wait client pod terminated: %v", err)
-		}
-		// See issue #24100.
-		// Prevent umount errors by making sure making sure the client pod exits cleanly *before* the volume server pod exits.
-		By("sleeping a bit so kubelet can unmount and detach the volume")
-		time.Sleep(PodCleanupTimeout)
-
-		err = podClient.Delete(config.Prefix+"-server", nil)
+		pod, err := cs.CoreV1().Pods(config.Namespace).Get(config.Prefix+"-server", metav1.GetOptions{})
+		ExpectNoError(err, "Failed to get server pod: %v", err)
+		err = DeletePodWithWait(f, cs, pod)
 		if err != nil {
 			glog.Warningf("Failed to delete server pod: %v", err)
 			ExpectNoError(err, "Failed to delete server pod: %v", err)
@@ -438,9 +458,7 @@ func TestVolumeClient(client clientset.Interface, config VolumeTestConfig, fsGro
 	}
 	podsNamespacer := client.CoreV1().Pods(config.Namespace)
 
-	if fsGroup != nil {
-		clientPod.Spec.SecurityContext.FSGroup = fsGroup
-	}
+	clientPod.Spec.SecurityContext.FSGroup = fsGroup
 
 	for i, test := range tests {
 		volumeName := fmt.Sprintf("%s-%s-%d", config.Prefix, "volume", i)
@@ -520,6 +538,7 @@ func InjectHtml(client clientset.Interface, config VolumeTestConfig, volume v1.V
 					VolumeSource: volume,
 				},
 			},
+			NodeName:     config.ClientNodeName,
 			NodeSelector: config.NodeSelector,
 		},
 	}

test/e2e/storage/BUILD

@@ -9,19 +9,18 @@ go_library(
         "ephemeral_volume.go",
         "flexvolume.go",
         "generic_persistent_volume-disruptive.go",
+        "in_tree_volumes.go",
         "mounted_volume_resize.go",
         "nfs_persistent_volume-disruptive.go",
         "pd.go",
         "persistent_volumes.go",
         "persistent_volumes-gce.go",
         "persistent_volumes-local.go",
-        "persistent_volumes-volumemode.go",
         "pv_protection.go",
         "pvc_protection.go",
         "regional_pd.go",
         "subpath.go",
         "volume_expand.go",
-        "volume_io.go",
         "volume_metrics.go",
         "volume_provisioning.go",
         "volumes.go",
@@ -67,8 +66,9 @@ go_library(
         "//test/e2e/framework/metrics:go_default_library",
         "//test/e2e/generated:go_default_library",
         "//test/e2e/manifest:go_default_library",
+        "//test/e2e/storage/drivers:go_default_library",
+        "//test/e2e/storage/testsuites:go_default_library",
         "//test/e2e/storage/utils:go_default_library",
-        "//test/e2e/storage/vsphere:go_default_library",
         "//test/utils/image:go_default_library",
         "//vendor/github.com/aws/aws-sdk-go/aws:go_default_library",
         "//vendor/github.com/aws/aws-sdk-go/aws/session:go_default_library",
@@ -92,6 +92,9 @@ filegroup(
     name = "all-srcs",
     srcs = [
         ":package-srcs",
+        "//test/e2e/storage/drivers:all-srcs",
+        "//test/e2e/storage/testpatterns:all-srcs",
+        "//test/e2e/storage/testsuites:all-srcs",
         "//test/e2e/storage/utils:all-srcs",
         "//test/e2e/storage/vsphere:all-srcs",
     ],

test/e2e/storage/drivers/BUILD

+load("@io_bazel_rules_go//go:def.bzl", "go_library")
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "base.go",
+        "in_tree.go",
+    ],
+    importpath = "k8s.io/kubernetes/test/e2e/storage/drivers",
+    visibility = ["//visibility:public"],
+    deps = [
+        "//pkg/kubelet/apis:go_default_library",
+        "//staging/src/k8s.io/api/core/v1:go_default_library",
+        "//staging/src/k8s.io/api/rbac/v1beta1:go_default_library",
+        "//staging/src/k8s.io/api/storage/v1:go_default_library",
+        "//staging/src/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",
+        "//staging/src/k8s.io/apimachinery/pkg/runtime/schema:go_default_library",
+        "//staging/src/k8s.io/apimachinery/pkg/util/sets:go_default_library",
+        "//staging/src/k8s.io/apiserver/pkg/authentication/serviceaccount:go_default_library",
+        "//staging/src/k8s.io/client-go/kubernetes:go_default_library",
+        "//test/e2e/framework:go_default_library",
+        "//test/e2e/storage/testpatterns:go_default_library",
+        "//test/e2e/storage/vsphere:go_default_library",
+        "//test/utils/image:go_default_library",
+        "//vendor/github.com/onsi/ginkgo:go_default_library",
+        "//vendor/github.com/onsi/gomega:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)

test/e2e/storage/drivers/base.go

+/*
+Copyright 2018 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package drivers
+
+import (
+	"fmt"
+
+	"k8s.io/api/core/v1"
+	storagev1 "k8s.io/api/storage/v1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/util/sets"
+	"k8s.io/kubernetes/test/e2e/framework"
+	"k8s.io/kubernetes/test/e2e/storage/testpatterns"
+)
+
+// TestDriver represents an interface for a driver to be tested in TestSuite
+type TestDriver interface {
+	// GetDriverInfo returns DriverInfo for the TestDriver
+	GetDriverInfo() *DriverInfo
+	// CreateDriver creates all driver resources that is required for TestDriver method
+	// except CreateVolume
+	CreateDriver()
+	// CreateDriver cleanup all the resources that is created in CreateDriver
+	CleanupDriver()
+	// SkipUnsupportedTest skips test in Testpattern is not suitable to test with the TestDriver
+	SkipUnsupportedTest(testpatterns.TestPattern)
+}
+
+// PreprovisionedVolumeTestDriver represents an interface for a TestDriver that has pre-provisioned volume
+type PreprovisionedVolumeTestDriver interface {
+	TestDriver
+	// CreateVolume creates a pre-provisioned volume.
+	CreateVolume(testpatterns.TestVolType)
+	// DeleteVolume deletes a volume that is created in CreateVolume
+	DeleteVolume(testpatterns.TestVolType)
+}
+
+// InlineVolumeTestDriver represents an interface for a TestDriver that supports InlineVolume
+type InlineVolumeTestDriver interface {
+	PreprovisionedVolumeTestDriver
+	// GetVolumeSource returns a volumeSource for inline volume.
+	// It will set readOnly and fsType to the volumeSource, if TestDriver supports both of them.
+	// It will return nil, if the TestDriver doesn't support either of the parameters.
+	GetVolumeSource(readOnly bool, fsType string) *v1.VolumeSource
+}
+
+// PreprovisionedPVTestDriver represents an interface for a TestDriver that supports PreprovisionedPV
+type PreprovisionedPVTestDriver interface {
+	PreprovisionedVolumeTestDriver
+	// GetPersistentVolumeSource returns a PersistentVolumeSource for pre-provisioned Persistent Volume.
+	// It will set readOnly and fsType to the PersistentVolumeSource, if TestDriver supports both of them.
+	// It will return nil, if the TestDriver doesn't support either of the parameters.
+	GetPersistentVolumeSource(readOnly bool, fsType string) *v1.PersistentVolumeSource
+}
+
+// DynamicPVTestDriver represents an interface for a TestDriver that supports DynamicPV
+type DynamicPVTestDriver interface {
+	TestDriver
+	// GetDynamicProvisionStorageClass returns a StorageClass dynamic provision Persistent Volume.
+	// It will set fsType to the StorageClass, if TestDriver supports it.
+	// It will return nil, if the TestDriver doesn't support it.
+	GetDynamicProvisionStorageClass(fsType string) *storagev1.StorageClass
+}
+
+// DriverInfo represents a combination of parameters to be used in implementation of TestDriver
+type DriverInfo struct {
+	Name       string // Name of the driver
+	FeatureTag string // FeatureTag for the driver
+
+	MaxFileSize        int64       // Max file size to be tested for this driver
+	SupportedFsType    sets.String // Map of string for supported fs type
+	IsPersistent       bool        // Flag to represent whether it provides persistency
+	IsFsGroupSupported bool        // Flag to represent whether it supports fsGroup
+	IsBlockSupported   bool        // Flag to represent whether it supports Block Volume
+
+	// Parameters below will be set inside test loop by using SetCommonDriverParameters.
+	// Drivers that implement TestDriver is required to set all the above parameters
+	// and return DriverInfo on GetDriverInfo() call.
+	Framework *framework.Framework       // Framework for the test
+	Config    framework.VolumeTestConfig // VolumeTestConfig for thet test
+}
+
+// GetDriverNameWithFeatureTags returns driver name with feature tags
+// For example)
+//  - [Driver: nfs]
+//  - [Driver: rbd][Feature:Volumes]
+func GetDriverNameWithFeatureTags(driver TestDriver) string {
+	dInfo := driver.GetDriverInfo()
+
+	return fmt.Sprintf("[Driver: %s]%s", dInfo.Name, dInfo.FeatureTag)
+}
+
+func CreateVolume(driver TestDriver, volType testpatterns.TestVolType) {
+	// Create Volume for test unless dynamicPV test
+	switch volType {
+	case testpatterns.InlineVolume:
+		fallthrough
+	case testpatterns.PreprovisionedPV:
+		if pDriver, ok := driver.(PreprovisionedVolumeTestDriver); ok {
+			pDriver.CreateVolume(volType)
+		}
+	case testpatterns.DynamicPV:
+		// No need to create volume
+	default:
+		framework.Failf("Invalid volType specified: %v", volType)
+	}
+}
+
+func DeleteVolume(driver TestDriver, volType testpatterns.TestVolType) {
+	// Delete Volume for test unless dynamicPV test
+	switch volType {
+	case testpatterns.InlineVolume:
+		fallthrough
+	case testpatterns.PreprovisionedPV:
+		if pDriver, ok := driver.(PreprovisionedVolumeTestDriver); ok {
+			pDriver.DeleteVolume(volType)
+		}
+	case testpatterns.DynamicPV:
+		// No need to delete volume
+	default:
+		framework.Failf("Invalid volType specified: %v", volType)
+	}
+}
+
+// SetCommonDriverParameters sets a common driver parameters to TestDriver
+// This function is intended to be called in BeforeEach() inside test loop.
+func SetCommonDriverParameters(
+	driver TestDriver,
+	f *framework.Framework,
+	config framework.VolumeTestConfig,
+) {
+	dInfo := driver.GetDriverInfo()
+
+	dInfo.Framework = f
+	dInfo.Config = config
+}
+
+func getStorageClass(
+	provisioner string,
+	parameters map[string]string,
+	bindingMode *storagev1.VolumeBindingMode,
+	ns string,
+	suffix string,
+) *storagev1.StorageClass {
+	if bindingMode == nil {
+		defaultBindingMode := storagev1.VolumeBindingImmediate
+		bindingMode = &defaultBindingMode
+	}
+	return &storagev1.StorageClass{
+		TypeMeta: metav1.TypeMeta{
+			Kind: "StorageClass",
+		},
+		ObjectMeta: metav1.ObjectMeta{
+			// Name must be unique, so let's base it on namespace name
+			Name: ns + "-" + suffix,
+		},
+		Provisioner:       provisioner,
+		Parameters:        parameters,
+		VolumeBindingMode: bindingMode,
+	}
+}

test/e2e/storage/ephemeral_volume.go

@@ -27,11 +27,18 @@ import (
 	clientset "k8s.io/client-go/kubernetes"
 	"k8s.io/kubernetes/test/e2e/framework"
 	"k8s.io/kubernetes/test/e2e/storage/utils"
+	imageutils "k8s.io/kubernetes/test/utils/image"
 
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
 )
 
+var (
+	volumePath = "/test-volume"
+	volumeName = "test-volume"
+	mountImage = imageutils.GetE2EImage(imageutils.Mounttest)
+)
+
 var _ = utils.SIGDescribe("Ephemeralstorage", func() {
 	var (
 		c clientset.Interface

test/e2e/storage/in_tree_volumes.go

+/*
+Copyright 2018 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package storage
+
+import (
+	"fmt"
+
+	. "github.com/onsi/ginkgo"
+	"k8s.io/api/core/v1"
+	"k8s.io/kubernetes/test/e2e/framework"
+	"k8s.io/kubernetes/test/e2e/storage/drivers"
+	"k8s.io/kubernetes/test/e2e/storage/testsuites"
+	"k8s.io/kubernetes/test/e2e/storage/utils"
+)
+
+// List of testDrivers to be executed in below loop
+var testDrivers = []func() drivers.TestDriver{
+	drivers.InitNFSDriver,
+	drivers.InitGlusterFSDriver,
+	drivers.InitISCSIDriver,
+	drivers.InitRbdDriver,
+	drivers.InitCephFSDriver,
+	drivers.InitHostpathDriver,
+	drivers.InitHostpathSymlinkDriver,
+	drivers.InitEmptydirDriver,
+	drivers.InitCinderDriver,
+	drivers.InitGceDriver,
+	drivers.InitVSphereDriver,
+	drivers.InitAzureDriver,
+	drivers.InitAwsDriver,
+}
+
+// List of testSuites to be executed in below loop
+var testSuites = []func() testsuites.TestSuite{
+	testsuites.InitVolumesTestSuite,
+	testsuites.InitVolumeIOTestSuite,
+	testsuites.InitVolumeModeTestSuite,
+	testsuites.InitSubPathTestSuite,
+}
+
+// This executes testSuites for in-tree volumes.
+var _ = utils.SIGDescribe("In-tree Volumes", func() {
+	f := framework.NewDefaultFramework("volumes")
+
+	var (
+		ns     *v1.Namespace
+		config framework.VolumeTestConfig
+	)
+
+	BeforeEach(func() {
+		ns = f.Namespace
+		config = framework.VolumeTestConfig{
+			Namespace: ns.Name,
+			Prefix:    "volume",
+		}
+	})
+
+	for _, initDriver := range testDrivers {
+		curDriver := initDriver()
+		Context(fmt.Sprintf(drivers.GetDriverNameWithFeatureTags(curDriver)), func() {
+			driver := curDriver
+
+			BeforeEach(func() {
+				// setupDriver
+				drivers.SetCommonDriverParameters(driver, f, config)
+				driver.CreateDriver()
+			})
+
+			AfterEach(func() {
+				// Cleanup driver
+				driver.CleanupDriver()
+			})
+
+			testsuites.RunTestSuite(f, config, driver, testSuites)
+		})
+	}
+})

test/e2e/storage/testpatterns/BUILD

+load("@io_bazel_rules_go//go:def.bzl", "go_library")
+
+go_library(
+    name = "go_default_library",
+    srcs = ["testpattern.go"],
+    importpath = "k8s.io/kubernetes/test/e2e/storage/testpatterns",
+    visibility = ["//visibility:public"],
+    deps = [
+        "//staging/src/k8s.io/api/core/v1:go_default_library",
+        "//test/e2e/framework:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)

test/e2e/storage/testpatterns/testpattern.go

+/*
+Copyright 2018 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package testpatterns
+
+import (
+	v1 "k8s.io/api/core/v1"
+	"k8s.io/kubernetes/test/e2e/framework"
+)
+
+const (
+	// MinFileSize represents minimum file size (1 MiB) for testing
+	MinFileSize = 1 * framework.MiB
+
+	// FileSizeSmall represents small file size (1 MiB) for testing
+	FileSizeSmall = 1 * framework.MiB
+	// FileSizeMedium represents medium file size (100 MiB) for testing
+	FileSizeMedium = 100 * framework.MiB
+	// FileSizeLarge represents large file size (1 GiB) for testing
+	FileSizeLarge = 1 * framework.GiB
+)
+
+// TestVolType represents a volume type to be tested in a TestSuite
+type TestVolType string
+
+var (
+	// InlineVolume represents a volume type that is used inline in volumeSource
+	InlineVolume TestVolType = "InlineVolume"
+	// PreprovisionedPV represents a volume type for pre-provisioned Persistent Volume
+	PreprovisionedPV TestVolType = "PreprovisionedPV"
+	// DynamicPV represents a volume type for dynamic provisioned Persistent Volume
+	DynamicPV TestVolType = "DynamicPV"
+)
+
+// TestPattern represents a combination of parameters to be tested in a TestSuite
+type TestPattern struct {
+	Name       string                  // Name of TestPattern
+	FeatureTag string                  // featureTag for the TestSuite
+	VolType    TestVolType             // Volume type of the volume
+	FsType     string                  // Fstype of the volume
+	VolMode    v1.PersistentVolumeMode // PersistentVolumeMode of the volume
+}
+
+var (
+	// Definitions for default fsType
+
+	// DefaultFsInlineVolume is TestPattern for "Inline-volume (default fs)"
+	DefaultFsInlineVolume = TestPattern{
+		Name:    "Inline-volume (default fs)",
+		VolType: InlineVolume,
+	}
+	// DefaultFsPreprovisionedPV is TestPattern for "Pre-provisioned PV (default fs)"
+	DefaultFsPreprovisionedPV = TestPattern{
+		Name:    "Pre-provisioned PV (default fs)",
+		VolType: PreprovisionedPV,
+	}
+	// DefaultFsDynamicPV is TestPattern for "Dynamic PV (default fs)"
+	DefaultFsDynamicPV = TestPattern{
+		Name:    "Dynamic PV (default fs)",
+		VolType: DynamicPV,
+	}
+
+	// Definitions for ext3
+
+	// Ext3InlineVolume is TestPattern for "Inline-volume (ext3)"
+	Ext3InlineVolume = TestPattern{
+		Name:    "Inline-volume (ext3)",
+		VolType: InlineVolume,
+		FsType:  "ext3",
+	}
+	// Ext3PreprovisionedPV is TestPattern for "Pre-provisioned PV (ext3)"
+	Ext3PreprovisionedPV = TestPattern{
+		Name:    "Pre-provisioned PV (ext3)",
+		VolType: PreprovisionedPV,
+		FsType:  "ext3",
+	}
+	// Ext3DynamicPV is TestPattern for "Dynamic PV (ext3)"
+	Ext3DynamicPV = TestPattern{
+		Name:    "Dynamic PV (ext3)",
+		VolType: DynamicPV,
+		FsType:  "ext3",
+	}
+
+	// Definitions for ext4
+
+	// Ext4InlineVolume is TestPattern for "Inline-volume (ext4)"
+	Ext4InlineVolume = TestPattern{
+		Name:    "Inline-volume (ext4)",
+		VolType: InlineVolume,
+		FsType:  "ext4",
+	}
+	// Ext4PreprovisionedPV is TestPattern for "Pre-provisioned PV (ext4)"
+	Ext4PreprovisionedPV = TestPattern{
+		Name:    "Pre-provisioned PV (ext4)",
+		VolType: PreprovisionedPV,
+		FsType:  "ext4",
+	}
+	// Ext4DynamicPV is TestPattern for "Dynamic PV (ext4)"
+	Ext4DynamicPV = TestPattern{
+		Name:    "Dynamic PV (ext4)",
+		VolType: DynamicPV,
+		FsType:  "ext4",
+	}
+
+	// Definitions for xfs
+
+	// XfsInlineVolume is TestPattern for "Inline-volume (xfs)"
+	XfsInlineVolume = TestPattern{
+		Name:    "Inline-volume (xfs)",
+		VolType: InlineVolume,
+		FsType:  "xfs",
+	}
+	// XfsPreprovisionedPV is TestPattern for "Pre-provisioned PV (xfs)"
+	XfsPreprovisionedPV = TestPattern{
+		Name:    "Pre-provisioned PV (xfs)",
+		VolType: PreprovisionedPV,
+		FsType:  "xfs",
+	}
+	// XfsDynamicPV is TestPattern for "Dynamic PV (xfs)"
+	XfsDynamicPV = TestPattern{
+		Name:    "Dynamic PV (xfs)",
+		VolType: DynamicPV,
+		FsType:  "xfs",
+	}
+
+	// Definitions for Filesystem volume mode
+
+	// FsVolModePreprovisionedPV is TestPattern for "Pre-provisioned PV (filesystem)"
+	FsVolModePreprovisionedPV = TestPattern{
+		Name:    "Pre-provisioned PV (filesystem volmode)",
+		VolType: PreprovisionedPV,
+		VolMode: v1.PersistentVolumeFilesystem,
+	}
+	// FsVolModeDynamicPV is TestPattern for "Dynamic PV (filesystem)"
+	FsVolModeDynamicPV = TestPattern{
+		Name:    "Dynamic PV (filesystem volmode)",
+		VolType: DynamicPV,
+		VolMode: v1.PersistentVolumeFilesystem,
+	}
+
+	// Definitions for block volume mode
+
+	// BlockVolModePreprovisionedPV is TestPattern for "Pre-provisioned PV (block)"
+	BlockVolModePreprovisionedPV = TestPattern{
+		Name:    "Pre-provisioned PV (block volmode)",
+		VolType: PreprovisionedPV,
+		VolMode: v1.PersistentVolumeBlock,
+	}
+	// BlockVolModeDynamicPV is TestPattern for "Dynamic PV (block)(immediate bind)"
+	BlockVolModeDynamicPV = TestPattern{
+		Name:    "Dynamic PV (block volmode)",
+		VolType: DynamicPV,
+		VolMode: v1.PersistentVolumeBlock,
+	}
+)

test/e2e/storage/testsuites/BUILD

+load("@io_bazel_rules_go//go:def.bzl", "go_library")
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "base.go",
+        "subpath.go",
+        "volume_io.go",
+        "volumemode.go",
+        "volumes.go",
+    ],
+    importpath = "k8s.io/kubernetes/test/e2e/storage/testsuites",
+    visibility = ["//visibility:public"],
+    deps = [
+        "//staging/src/k8s.io/api/core/v1:go_default_library",
+        "//staging/src/k8s.io/api/storage/v1:go_default_library",
+        "//staging/src/k8s.io/apimachinery/pkg/api/errors:go_default_library",
+        "//staging/src/k8s.io/apimachinery/pkg/api/resource:go_default_library",
+        "//staging/src/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",
+        "//staging/src/k8s.io/apimachinery/pkg/fields:go_default_library",
+        "//staging/src/k8s.io/apimachinery/pkg/util/errors:go_default_library",
+        "//staging/src/k8s.io/apimachinery/pkg/util/rand:go_default_library",
+        "//staging/src/k8s.io/apimachinery/pkg/util/wait:go_default_library",
+        "//staging/src/k8s.io/client-go/kubernetes:go_default_library",
+        "//test/e2e/framework:go_default_library",
+        "//test/e2e/storage/drivers:go_default_library",
+        "//test/e2e/storage/testpatterns:go_default_library",
+        "//test/e2e/storage/utils:go_default_library",
+        "//test/utils/image:go_default_library",
+        "//vendor/github.com/onsi/ginkgo:go_default_library",
+        "//vendor/github.com/onsi/gomega:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)

test/e2e/storage/testsuites/volumes.go

+/*
+Copyright 2018 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+// This test checks that various VolumeSources are working.
+
+// test/e2e/common/volumes.go duplicates the GlusterFS test from this file.  Any changes made to this
+// test should be made there as well.
+
+package testsuites
+
+import (
+	"fmt"
+
+	. "github.com/onsi/ginkgo"
+	"k8s.io/kubernetes/test/e2e/framework"
+	"k8s.io/kubernetes/test/e2e/storage/drivers"
+	"k8s.io/kubernetes/test/e2e/storage/testpatterns"
+)
+
+type volumesTestSuite struct {
+	tsInfo TestSuiteInfo
+}
+
+var _ TestSuite = &volumesTestSuite{}
+
+// InitVolumesTestSuite returns volumesTestSuite that implements TestSuite interface
+func InitVolumesTestSuite() TestSuite {
+	return &volumesTestSuite{
+		tsInfo: TestSuiteInfo{
+			name: "volumes",
+			testPatterns: []testpatterns.TestPattern{
+				// Default fsType
+				testpatterns.DefaultFsInlineVolume,
+				testpatterns.DefaultFsPreprovisionedPV,
+				testpatterns.DefaultFsDynamicPV,
+				// ext3
+				testpatterns.Ext3InlineVolume,
+				testpatterns.Ext3PreprovisionedPV,
+				testpatterns.Ext3DynamicPV,
+				// ext4
+				testpatterns.Ext4InlineVolume,
+				testpatterns.Ext4PreprovisionedPV,
+				testpatterns.Ext4DynamicPV,
+				// xfs
+				testpatterns.XfsInlineVolume,
+				testpatterns.XfsPreprovisionedPV,
+				testpatterns.XfsDynamicPV,
+			},
+		},
+	}
+}
+
+func (t *volumesTestSuite) getTestSuiteInfo() TestSuiteInfo {
+	return t.tsInfo
+}
+
+func (t *volumesTestSuite) skipUnsupportedTest(pattern testpatterns.TestPattern, driver drivers.TestDriver) {
+	dInfo := driver.GetDriverInfo()
+	if !dInfo.IsPersistent {
+		framework.Skipf("Driver %q does not provide persistency - skipping", dInfo.Name)
+	}
+}
+
+func createVolumesTestInput(pattern testpatterns.TestPattern, resource genericVolumeTestResource) volumesTestInput {
+	var fsGroup *int64
+	driver := resource.driver
+	dInfo := driver.GetDriverInfo()
+	f := dInfo.Framework
+	volSource := resource.volSource
+
+	if volSource == nil {
+		framework.Skipf("Driver %q does not define volumeSource - skipping", dInfo.Name)
+	}
+
+	if dInfo.IsFsGroupSupported {
+		fsGroupVal := int64(1234)
+		fsGroup = &fsGroupVal
+	}
+
+	return volumesTestInput{
+		f:       f,
+		name:    dInfo.Name,
+		config:  dInfo.Config,
+		fsGroup: fsGroup,
+		tests: []framework.VolumeTest{
+			{
+				Volume: *volSource,
+				File:   "index.html",
+				// Must match content
+				ExpectedContent: fmt.Sprintf("Hello from %s from namespace %s",
+					dInfo.Name, f.Namespace.Name),
+			},
+		},
+	}
+}
+
+func (t *volumesTestSuite) execTest(driver drivers.TestDriver, pattern testpatterns.TestPattern) {
+	Context(getTestNameStr(t, pattern), func() {
+		var (
+			resource     genericVolumeTestResource
+			input        volumesTestInput
+			needsCleanup bool
+		)
+
+		BeforeEach(func() {
+			needsCleanup = false
+			// Skip unsupported tests to avoid unnecessary resource initialization
+			skipUnsupportedTest(t, driver, pattern)
+			needsCleanup = true
+
+			// Setup test resource for driver and testpattern
+			resource := genericVolumeTestResource{}
+			resource.setupResource(driver, pattern)
+
+			// Create test input
+			input = createVolumesTestInput(pattern, resource)
+		})
+
+		AfterEach(func() {
+			if needsCleanup {
+				resource.cleanupResource(driver, pattern)
+			}
+		})
+
+		testVolumes(&input)
+	})
+}
+
+type volumesTestInput struct {
+	f       *framework.Framework
+	name    string
+	config  framework.VolumeTestConfig
+	fsGroup *int64
+	tests   []framework.VolumeTest
+}
+
+func testVolumes(input *volumesTestInput) {
+	It("should be mountable", func() {
+		f := input.f
+		cs := f.ClientSet
+		defer framework.VolumeTestCleanup(f, input.config)
+
+		volumeTest := input.tests
+		framework.InjectHtml(cs, input.config, volumeTest[0].Volume, volumeTest[0].ExpectedContent)
+		framework.TestVolumeClient(cs, input.config, input.fsGroup, input.tests)
+	})
+}

test/e2e/storage/volume_provisioning.go

@@ -1105,7 +1105,7 @@ func updateDefaultStorageClass(c clientset.Interface, scName string, defaultStr
 	verifyDefaultStorageClass(c, scName, expectedDefault)
 }
 
-func newClaim(t storageClassTest, ns, suffix string) *v1.PersistentVolumeClaim {
+func getClaim(claimSize string, ns string) *v1.PersistentVolumeClaim {
 	claim := v1.PersistentVolumeClaim{
 		ObjectMeta: metav1.ObjectMeta{
 			GenerateName: "pvc-",
@@ -1117,7 +1117,7 @@ func newClaim(t storageClassTest, ns, suffix string) *v1.PersistentVolumeClaim {
 			},
 			Resources: v1.ResourceRequirements{
 				Requests: v1.ResourceList{
-					v1.ResourceName(v1.ResourceStorage): resource.MustParse(t.claimSize),
+					v1.ResourceName(v1.ResourceStorage): resource.MustParse(claimSize),
 				},
 			},
 		},
@@ -1126,6 +1126,10 @@ func newClaim(t storageClassTest, ns, suffix string) *v1.PersistentVolumeClaim {
 	return &claim
 }
 
+func newClaim(t storageClassTest, ns, suffix string) *v1.PersistentVolumeClaim {
+	return getClaim(t.claimSize, ns)
+}
+
 // runInPodWithVolume runs a command in a pod with given claim mounted to /mnt directory.
 func runInPodWithVolume(c clientset.Interface, ns, claimName, nodeName, command string) {
 	pod := &v1.Pod{
@@ -1217,6 +1221,20 @@ func newStorageClass(t storageClassTest, ns string, suffix string) *storage.Stor
 	if t.delayBinding {
 		bindingMode = storage.VolumeBindingWaitForFirstConsumer
 	}
+	return getStorageClass(pluginName, t.parameters, &bindingMode, ns, suffix)
+}
+
+func getStorageClass(
+	provisioner string,
+	parameters map[string]string,
+	bindingMode *storage.VolumeBindingMode,
+	ns string,
+	suffix string,
+) *storage.StorageClass {
+	if bindingMode == nil {
+		defaultBindingMode := storage.VolumeBindingImmediate
+		bindingMode = &defaultBindingMode
+	}
 	return &storage.StorageClass{
 		TypeMeta: metav1.TypeMeta{
 			Kind: "StorageClass",
@@ -1225,9 +1243,9 @@ func newStorageClass(t storageClassTest, ns string, suffix string) *storage.Stor
 			// Name must be unique, so let's base it on namespace name
 			Name: ns + "-" + suffix,
 		},
-		Provisioner:       pluginName,
-		Parameters:        t.parameters,
-		VolumeBindingMode: &bindingMode,
+		Provisioner:       provisioner,
+		Parameters:        parameters,
+		VolumeBindingMode: bindingMode,
 	}
 }