Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func DefineTestSuite

func DefineTestSuite(driver TestDriver, tsInits []func() TestSuite)

    DefineTestSuite defines tests for all testpatterns and all testSuites for a driver

    func GetDriverNameWithFeatureTags

    func GetDriverNameWithFeatureTags(driver TestDriver) string

      GetDriverNameWithFeatureTags returns driver name with feature tags For example)

      - [Driver: nfs]
      - [Driver: rbd][Feature:Volumes]
      

      func GetSnapshotClass

      func GetSnapshotClass(
      	snapshotter string,
      	parameters map[string]string,
      	ns string,
      	suffix string,
      ) *unstructured.Unstructured

        GetSnapshotClass constructs a new SnapshotClass instance with a unique name that is based on namespace + suffix.

        func GetStorageClass

        func GetStorageClass(
        	provisioner string,
        	parameters map[string]string,
        	bindingMode *storagev1.VolumeBindingMode,
        	ns string,
        	suffix string,
        ) *storagev1.StorageClass

          GetStorageClass constructs a new StorageClass instance with a unique name that is based on namespace + suffix.

          func PVMultiNodeCheck

          func PVMultiNodeCheck(client clientset.Interface, claim *v1.PersistentVolumeClaim, volume *v1.PersistentVolume, node NodeSelection)

            PVMultiNodeCheck checks that a PV retains data when moved between nodes.

            It starts these pods: - The first pod writes 'hello word' to the /mnt/test (= the volume) on one node. - The second pod runs grep 'hello world' on /mnt/test on another node.

            The first node is selected by Kubernetes when scheduling the first pod. The second pod uses the same criteria, except that a special anti-affinity for the first node gets added. This test can only pass if the cluster has more than one suitable node. The caller has to ensure that.

            If all succeeds, Kubernetes actually allocated something that is persistent across pods and across nodes.

            This is a common test that can be called from a StorageClassTest.PvCheck.

            func PVWriteReadSingleNodeCheck

            func PVWriteReadSingleNodeCheck(client clientset.Interface, claim *v1.PersistentVolumeClaim, volume *v1.PersistentVolume, node NodeSelection)

              PVWriteReadSingleNodeCheck checks that a PV retains data on a single node.

              It starts two pods: - The first pod writes 'hello word' to the /mnt/test (= the volume) on one node. - The second pod runs grep 'hello world' on /mnt/test on the same node.

              The node is selected by Kubernetes when scheduling the first pod. It's then selected via its name for the second pod.

              If both succeed, Kubernetes actually allocated something that is persistent across pods.

              This is a common test that can be called from a StorageClassTest.PvCheck.

              func RunInPodWithVolume

              func RunInPodWithVolume(c clientset.Interface, ns, claimName, podName, command string, node NodeSelection)

                RunInPodWithVolume runs a command in a pod with given claim mounted to /mnt directory. It starts, checks, collects output and stops it.

                func StartInPodWithVolume

                func StartInPodWithVolume(c clientset.Interface, ns, claimName, podName, command string, node NodeSelection) *v1.Pod

                  StartInPodWithVolume starts a command in a pod with given claim mounted to /mnt directory The caller is responsible for checking the pod and deleting it.

                  func StartPodLogs

                  func StartPodLogs(f *framework.Framework) func()

                    StartPodLogs begins capturing log output and events from current and future pods running in the namespace of the framework. That ends when the returned cleanup function is called.

                    The output goes to log files (when using --report-dir, as in the CI) or the output stream (otherwise).

                    func StopPod

                    func StopPod(c clientset.Interface, pod *v1.Pod)

                      StopPod first tries to log the output of the pod's container, then deletes the pod.

                      func SubpathTestPod

                      func SubpathTestPod(f *framework.Framework, subpath, volumeType string, source *v1.VolumeSource, privilegedSecurityContext bool) *v1.Pod

                        SubpathTestPod returns a pod spec for subpath tests

                        func TestBasicSubpath

                        func TestBasicSubpath(f *framework.Framework, contents string, pod *v1.Pod)

                          TestBasicSubpath runs basic subpath test

                          func TestBasicSubpathFile

                          func TestBasicSubpathFile(f *framework.Framework, contents string, pod *v1.Pod, filepath string)

                            TestBasicSubpathFile runs basic subpath file test

                            func WaitForSnapshotReady

                            func WaitForSnapshotReady(c dynamic.Interface, ns string, snapshotName string, Poll, timeout time.Duration) error

                              WaitForSnapshotReady waits for a VolumeSnapshot to be ready to use or until timeout occurs, whichever comes first.

                              Types

                              type Capability

                              type Capability string

                                Capability represents a feature that a volume plugin supports

                                const (
                                	CapPersistence Capability = "persistence" // data is persisted across pod restarts
                                	CapBlock       Capability = "block"       // raw block mode
                                	CapFsGroup     Capability = "fsGroup"     // volume ownership via fsGroup
                                	CapExec        Capability = "exec"        // exec a file in the volume
                                	CapDataSource  Capability = "dataSource"  // support populate data from snapshot
                                
                                	// multiple pods on a node can use the same volume concurrently;
                                	// for CSI, see:
                                	// - https://github.com/container-storage-interface/spec/pull/150
                                	// - https://github.com/container-storage-interface/spec/issues/178
                                	// - NodeStageVolume in the spec
                                	CapMultiPODs Capability = "multipods"
                                )

                                type DriverInfo

                                type DriverInfo struct {
                                	Name       string // Name of the driver, aka the provisioner name.
                                	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
                                	SupportedMountOption sets.String         // Map of string for supported mount option
                                	RequiredMountOption  sets.String         // Map of string for required mount option (Optional)
                                	Capabilities         map[Capability]bool // Map that represents plugin capabilities
                                }

                                  DriverInfo represents static information about a TestDriver.

                                  type DynamicPVTestDriver

                                  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(config *PerTestConfig, fsType string) *storagev1.StorageClass
                                  
                                  	// GetClaimSize returns the size of the volume that is to be provisioned ("5Gi", "1Mi").
                                  	// The size must be chosen so that the resulting volume is large enough for all
                                  	// enabled tests and within the range supported by the underlying storage.
                                  	GetClaimSize() string
                                  }

                                    DynamicPVTestDriver represents an interface for a TestDriver that supports DynamicPV

                                    type InlineVolumeTestDriver

                                    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, testVolume TestVolume) *v1.VolumeSource
                                    }

                                      InlineVolumeTestDriver represents an interface for a TestDriver that supports InlineVolume

                                      type NodeSelection

                                      type NodeSelection struct {
                                      	Name     string
                                      	Selector map[string]string
                                      	Affinity *v1.Affinity
                                      }

                                        NodeSelection specifies where to run a pod, using a combination of fixed node name, node selector and/or affinity.

                                        type PerTestConfig

                                        type PerTestConfig struct {
                                        	// The test driver for the test.
                                        	Driver TestDriver
                                        
                                        	// Some short word that gets inserted into dynamically
                                        	// generated entities (pods, paths) as first part of the name
                                        	// to make debugging easier. Can be the same for different
                                        	// tests inside the test suite.
                                        	Prefix string
                                        
                                        	// The framework instance allocated for the current test.
                                        	Framework *framework.Framework
                                        
                                        	// If non-empty, then pods using a volume will be scheduled
                                        	// onto the node with this name. Otherwise Kubernetes will
                                        	// pick a node.
                                        	ClientNodeName string
                                        
                                        	// Some tests also support scheduling pods onto nodes with
                                        	// these label/value pairs. As not all tests use this field,
                                        	// a driver that absolutely needs the pods on a specific
                                        	// node must use ClientNodeName.
                                        	ClientNodeSelector map[string]string
                                        
                                        	// Some test drivers initialize a storage server. This is
                                        	// the configuration that then has to be used to run tests.
                                        	// The values above are ignored for such tests.
                                        	ServerConfig *framework.VolumeTestConfig
                                        }

                                          PerTestConfig represents parameters that control test execution. One instance gets allocated for each test and is then passed via pointer to functions involved in the test.

                                          func (*PerTestConfig) GetUniqueDriverName

                                          func (config *PerTestConfig) GetUniqueDriverName() string

                                            GetUniqueDriverName returns unique driver name that can be used parallelly in tests

                                            type PreprovisionedPVTestDriver

                                            type PreprovisionedPVTestDriver interface {
                                            	PreprovisionedVolumeTestDriver
                                            	// GetPersistentVolumeSource returns a PersistentVolumeSource with volume node affinity 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, testVolume TestVolume) (*v1.PersistentVolumeSource, *v1.VolumeNodeAffinity)
                                            }

                                              PreprovisionedPVTestDriver represents an interface for a TestDriver that supports PreprovisionedPV

                                              type PreprovisionedVolumeTestDriver

                                              type PreprovisionedVolumeTestDriver interface {
                                              	TestDriver
                                              	// CreateVolume creates a pre-provisioned volume of the desired volume type.
                                              	CreateVolume(config *PerTestConfig, volumeType testpatterns.TestVolType) TestVolume
                                              }

                                                PreprovisionedVolumeTestDriver represents an interface for a TestDriver that has pre-provisioned volume

                                                type SnapshotClassTest

                                                type SnapshotClassTest struct {
                                                	Name           string
                                                	CloudProviders []string
                                                	Snapshotter    string
                                                	Parameters     map[string]string
                                                	NodeName       string
                                                	NodeSelector   map[string]string // NodeSelector for the pod
                                                }

                                                type SnapshottableTestDriver

                                                type SnapshottableTestDriver interface {
                                                	TestDriver
                                                	// GetSnapshotClass returns a SnapshotClass to create snapshot.
                                                	// It will return nil, if the TestDriver doesn't support it.
                                                	GetSnapshotClass(config *PerTestConfig) *unstructured.Unstructured
                                                }

                                                  SnapshottableTestDriver represents an interface for a TestDriver that supports DynamicSnapshot

                                                  type StorageClassTest

                                                  type StorageClassTest struct {
                                                  	Client               clientset.Interface
                                                  	Claim                *v1.PersistentVolumeClaim
                                                  	Class                *storage.StorageClass
                                                  	Name                 string
                                                  	CloudProviders       []string
                                                  	Provisioner          string
                                                  	StorageClassName     string
                                                  	Parameters           map[string]string
                                                  	DelayBinding         bool
                                                  	ClaimSize            string
                                                  	ExpectedSize         string
                                                  	PvCheck              func(claim *v1.PersistentVolumeClaim, volume *v1.PersistentVolume)
                                                  	VolumeMode           *v1.PersistentVolumeMode
                                                  	AllowVolumeExpansion bool
                                                  }

                                                    StorageClassTest represents parameters to be used by provisioning tests. Not all parameters are used by all tests.

                                                    func (StorageClassTest) TestBindingWaitForFirstConsumer

                                                    func (t StorageClassTest) TestBindingWaitForFirstConsumer(nodeSelector map[string]string, expectUnschedulable bool) (*v1.PersistentVolume, *v1.Node)

                                                    func (StorageClassTest) TestBindingWaitForFirstConsumerMultiPVC

                                                    func (t StorageClassTest) TestBindingWaitForFirstConsumerMultiPVC(claims []*v1.PersistentVolumeClaim, nodeSelector map[string]string, expectUnschedulable bool) ([]*v1.PersistentVolume, *v1.Node)

                                                    func (StorageClassTest) TestDynamicProvisioning

                                                    func (t StorageClassTest) TestDynamicProvisioning() *v1.PersistentVolume

                                                      TestDynamicProvisioning tests dynamic provisioning with specified StorageClassTest

                                                      type TestDriver

                                                      type TestDriver interface {
                                                      	// GetDriverInfo returns DriverInfo for the TestDriver. This must be static
                                                      	// information.
                                                      	GetDriverInfo() *DriverInfo
                                                      
                                                      	// SkipUnsupportedTest skips test if Testpattern is not
                                                      	// suitable to test with the TestDriver. It gets called after
                                                      	// parsing parameters of the test suite and before the
                                                      	// framework is initialized. Cheap tests that just check
                                                      	// parameters like the cloud provider can and should be
                                                      	// done in SkipUnsupportedTest to avoid setting up more
                                                      	// expensive resources like framework.Framework. Tests that
                                                      	// depend on a connection to the cluster can be done in
                                                      	// PrepareTest once the framework is ready.
                                                      	SkipUnsupportedTest(testpatterns.TestPattern)
                                                      
                                                      	// PrepareTest is called at test execution time each time a new test case is about to start.
                                                      	// It sets up all necessary resources and returns the per-test configuration
                                                      	// plus a cleanup function that frees all allocated resources.
                                                      	PrepareTest(f *framework.Framework) (*PerTestConfig, func())
                                                      }

                                                        TestDriver represents an interface for a driver to be tested in TestSuite. Except for GetDriverInfo, all methods will be called at test runtime and thus can use framework.Skipf, framework.Fatal, Gomega assertions, etc.

                                                        type TestResource

                                                        type TestResource interface {
                                                        	// contains filtered or unexported methods
                                                        }

                                                          TestResource represents an interface for resources that is used by TestSuite

                                                          type TestSuite

                                                          type TestSuite interface {
                                                          	// contains filtered or unexported methods
                                                          }

                                                            TestSuite represents an interface for a set of tests which works with TestDriver

                                                            func InitProvisioningTestSuite

                                                            func InitProvisioningTestSuite() TestSuite

                                                              InitProvisioningTestSuite returns provisioningTestSuite that implements TestSuite interface

                                                              func InitSnapshottableTestSuite

                                                              func InitSnapshottableTestSuite() TestSuite

                                                                InitSnapshottableTestSuite returns snapshottableTestSuite that implements TestSuite interface

                                                                func InitSubPathTestSuite

                                                                func InitSubPathTestSuite() TestSuite

                                                                  InitSubPathTestSuite returns subPathTestSuite that implements TestSuite interface

                                                                  func InitVolumeIOTestSuite

                                                                  func InitVolumeIOTestSuite() TestSuite

                                                                    InitVolumeIOTestSuite returns volumeIOTestSuite that implements TestSuite interface

                                                                    func InitVolumeModeTestSuite

                                                                    func InitVolumeModeTestSuite() TestSuite

                                                                      InitVolumeModeTestSuite returns volumeModeTestSuite that implements TestSuite interface

                                                                      func InitVolumesTestSuite

                                                                      func InitVolumesTestSuite() TestSuite

                                                                        InitVolumesTestSuite returns volumesTestSuite that implements TestSuite interface

                                                                        type TestSuiteInfo

                                                                        type TestSuiteInfo struct {
                                                                        	// contains filtered or unexported fields
                                                                        }

                                                                          TestSuiteInfo represents a set of parameters for TestSuite

                                                                          type TestVolume

                                                                          type TestVolume interface {
                                                                          	DeleteVolume()
                                                                          }

                                                                            TestVolume is the result of PreprovisionedVolumeTestDriver.CreateVolume. The only common functionality is to delete it. Individual driver interfaces have additional methods that work with volumes created by them.

                                                                            func CreateVolume

                                                                            func CreateVolume(driver TestDriver, config *PerTestConfig, volType testpatterns.TestVolType) TestVolume

                                                                              CreateVolume creates volume for test unless dynamicPV test