Add tests for capabilities

Author: gnufied

pkg/controller/controller_test.go

@@ -28,10 +28,10 @@ func TestController(t *testing.T) {
 		PVC  *v1.PersistentVolumeClaim
 		PV   *v1.PersistentVolume
 
-		CreateObjects bool
-		NodeResize    bool
-		CallCSIExpand bool
-		blockVolume   bool
+		CreateObjects     bool
+		NodeResize        bool
+		CallCSIExpand     bool
+		expectBlockVolume bool
 	}{
 		{
 			Name:          "Invalid key",
@@ -89,13 +89,13 @@ func TestController(t *testing.T) {
 			CallCSIExpand: true,
 		},
 		{
-			Name:          "Block Resize PVC with FS resize",
-			PVC:           createPVC(2, 1),
-			PV:            createPV(1, "testPVC", "test", "foobar", &blockVolumeMode),
-			CreateObjects: true,
-			NodeResize:    true,
-			CallCSIExpand: true,
-			blockVolume:   true,
+			Name:              "Block Resize PVC with FS resize",
+			PVC:               createPVC(2, 1),
+			PV:                createPV(1, "testPVC", "test", "foobar", &blockVolumeMode),
+			CreateObjects:     true,
+			NodeResize:        true,
+			CallCSIExpand:     true,
+			expectBlockVolume: true,
 		},
 	} {
 		client := csi.NewMockClient("mock", test.NodeResize, true, true)
@@ -150,17 +150,14 @@ func TestController(t *testing.T) {
 			t.Fatalf("for %s: expected no csi expand call, received csi expansion request", test.Name)
 		}
 
-		if test.CallCSIExpand {
-			usedCapability := client.GetCapability()
-			if test.blockVolume {
-				if usedCapability.GetBlock() == nil {
-					t.Errorf("For %s: expected block accesstype got: %v", test.Name, usedCapability)
-				}
-			} else {
-				if usedCapability.GetMount() == nil {
-					t.Errorf("For %s: expected mount accesstype got: %v", test.Name, usedCapability)
-				}
-			}
+		usedCapability := client.GetCapability()
+
+		if test.CallCSIExpand && test.expectBlockVolume && usedCapability.GetBlock() == nil {
+			t.Errorf("For %s: expected block accesstype got: %v", test.Name, usedCapability)
+		}
+
+		if test.CallCSIExpand && !test.expectBlockVolume && usedCapability.GetMount() == nil {
+			t.Errorf("For %s: expected mount accesstype got: %v", test.Name, usedCapability)
 		}
 	}
 }

pkg/resizer/csi_resizer_test.go

@@ -3,9 +3,11 @@ package resizer
 import (
 	"errors"
 	"fmt"
+	"reflect"
 	"testing"
 	"time"
 
+	csilib "github.com/container-storage-interface/spec/lib/go/csi"
 	"github.com/kubernetes-csi/csi-lib-utils/metrics"
 	"github.com/kubernetes-csi/external-resizer/pkg/csi"
 	"github.com/kubernetes-csi/external-resizer/pkg/util"
@@ -187,6 +189,138 @@ func TestResizeMigratedPV(t *testing.T) {
 	}
 }
 
+func TestGetVolumeCapabilities(t *testing.T) {
+	blockVolumeMode := v1.PersistentVolumeMode(v1.PersistentVolumeBlock)
+	filesystemVolumeMode := v1.PersistentVolumeMode(v1.PersistentVolumeFilesystem)
+
+	tests := []struct {
+		name               string
+		volumeMode         *v1.PersistentVolumeMode
+		fsType             string
+		modes              []v1.PersistentVolumeAccessMode
+		mountOptions       []string
+		expectedCapability *csilib.VolumeCapability
+		expectError        bool
+	}{
+		{
+			name:               "RWX",
+			volumeMode:         &filesystemVolumeMode,
+			modes:              []v1.PersistentVolumeAccessMode{v1.ReadWriteMany},
+			expectedCapability: createMountCapability(defaultFSType, csilib.VolumeCapability_AccessMode_MULTI_NODE_MULTI_WRITER, nil),
+			expectError:        false,
+		},
+		{
+			name:               "Block RWX",
+			volumeMode:         &blockVolumeMode,
+			modes:              []v1.PersistentVolumeAccessMode{v1.ReadWriteMany},
+			expectedCapability: createBlockCapability(csilib.VolumeCapability_AccessMode_MULTI_NODE_MULTI_WRITER),
+			expectError:        false,
+		},
+		{
+			name:               "RWX + specified fsType",
+			fsType:             "ext3",
+			modes:              []v1.PersistentVolumeAccessMode{v1.ReadWriteMany},
+			expectedCapability: createMountCapability("ext3", csilib.VolumeCapability_AccessMode_MULTI_NODE_MULTI_WRITER, nil),
+			expectError:        false,
+		},
+		{
+			name:               "RWO",
+			modes:              []v1.PersistentVolumeAccessMode{v1.ReadWriteOnce},
+			expectedCapability: createMountCapability(defaultFSType, csilib.VolumeCapability_AccessMode_SINGLE_NODE_WRITER, nil),
+			expectError:        false,
+		},
+		{
+			name:               "Block RWO",
+			volumeMode:         &blockVolumeMode,
+			modes:              []v1.PersistentVolumeAccessMode{v1.ReadWriteOnce},
+			expectedCapability: createBlockCapability(csilib.VolumeCapability_AccessMode_SINGLE_NODE_WRITER),
+			expectError:        false,
+		},
+		{
+			name:               "ROX",
+			modes:              []v1.PersistentVolumeAccessMode{v1.ReadOnlyMany},
+			expectedCapability: createMountCapability(defaultFSType, csilib.VolumeCapability_AccessMode_MULTI_NODE_READER_ONLY, nil),
+			expectError:        false,
+		},
+		{
+			name:               "RWX + anytyhing",
+			modes:              []v1.PersistentVolumeAccessMode{v1.ReadWriteMany, v1.ReadOnlyMany, v1.ReadWriteOnce},
+			expectedCapability: createMountCapability(defaultFSType, csilib.VolumeCapability_AccessMode_MULTI_NODE_MULTI_WRITER, nil),
+			expectError:        false,
+		},
+		{
+			name:               "mount options",
+			modes:              []v1.PersistentVolumeAccessMode{v1.ReadWriteMany},
+			expectedCapability: createMountCapability(defaultFSType, csilib.VolumeCapability_AccessMode_MULTI_NODE_MULTI_WRITER, []string{"first", "second"}),
+			mountOptions:       []string{"first", "second"},
+			expectError:        false,
+		},
+		{
+			name:               "ROX+RWO",
+			modes:              []v1.PersistentVolumeAccessMode{v1.ReadWriteOnce, v1.ReadOnlyMany},
+			expectedCapability: nil,
+			expectError:        true, // not possible in CSI
+		},
+		{
+			name:               "nothing",
+			modes:              []v1.PersistentVolumeAccessMode{},
+			expectedCapability: nil,
+			expectError:        true,
+		},
+	}
+
+	for _, test := range tests {
+		pv := &v1.PersistentVolume{
+			Spec: v1.PersistentVolumeSpec{
+				VolumeMode:   test.volumeMode,
+				AccessModes:  test.modes,
+				MountOptions: test.mountOptions,
+				PersistentVolumeSource: v1.PersistentVolumeSource{
+					CSI: &v1.CSIPersistentVolumeSource{
+						FSType: test.fsType,
+					},
+				},
+			},
+		}
+		cap, err := GetVolumeCapabilities(pv.Spec)
+
+		if err == nil && test.expectError {
+			t.Errorf("test %s: expected error, got none", test.name)
+		}
+		if err != nil && !test.expectError {
+			t.Errorf("test %s: got error: %s", test.name, err)
+		}
+		if !test.expectError && !reflect.DeepEqual(cap, test.expectedCapability) {
+			t.Errorf("test %s: unexpected VolumeCapability: %+v", test.name, cap)
+		}
+	}
+}
+
+func createBlockCapability(mode csilib.VolumeCapability_AccessMode_Mode) *csilib.VolumeCapability {
+	return &csilib.VolumeCapability{
+		AccessType: &csilib.VolumeCapability_Block{
+			Block: &csilib.VolumeCapability_BlockVolume{},
+		},
+		AccessMode: &csilib.VolumeCapability_AccessMode{
+			Mode: mode,
+		},
+	}
+}
+
+func createMountCapability(fsType string, mode csilib.VolumeCapability_AccessMode_Mode, mountOptions []string) *csilib.VolumeCapability {
+	return &csilib.VolumeCapability{
+		AccessType: &csilib.VolumeCapability_Mount{
+			Mount: &csilib.VolumeCapability_MountVolume{
+				FsType:     fsType,
+				MountFlags: mountOptions,
+			},
+		},
+		AccessMode: &csilib.VolumeCapability_AccessMode{
+			Mode: mode,
+		},
+	}
+}
+
 func TestCanSupport(t *testing.T) {
 	testCases := []struct {
 		name       string