Improved Unit-Test Coverage for Issue #703 (#736)

* copied files from unit-test branch (due to one of the commits not using userid for some reason)

* updating blob.go, controllerserver.go, and nodeserver.go back to the origin master files

* init.sh and dockerfile set back to master

* reran go mod vendor

* Fixing the gofmt issue

* fixing boilerplate errors

Co-authored-by: Akash Mukhopadhyay <[email protected]>

Author: aarongalang

pkg/blob/blob_test.go

@@ -24,6 +24,43 @@ import (
 	mount "k8s.io/mount-utils"
 )
 
+func TestMount(t *testing.T) {
+	tests := []struct {
+		desc        string
+		source      string
+		target      string
+		fstype      string
+		options     []string
+		expectedErr error
+	}{
+		{
+			desc:        "source error",
+			source:      "error_mount",
+			expectedErr: fmt.Errorf("fake Mount: source error"),
+		},
+		{
+			desc:        "target error",
+			target:      "error_mount",
+			expectedErr: fmt.Errorf("fake Mount: target error"),
+		},
+		{
+			desc:        "Success",
+			expectedErr: nil,
+		},
+	}
+	for _, test := range tests {
+		d := NewFakeDriver()
+		fakeMounter := &fakeMounter{}
+		d.mounter = &mount.SafeFormatAndMount{
+			Interface: fakeMounter,
+		}
+		err := d.mounter.Mount(test.source, test.target, test.fstype, test.options)
+		if !reflect.DeepEqual(err, test.expectedErr) {
+			t.Errorf("actualErr: (%v), expectedErr: (%v)", err, test.expectedErr)
+		}
+	}
+}
+
 func TestMountSensitive(t *testing.T) {
 	tests := []struct {
 		desc        string

pkg/blob/controllerserver_test.go

@@ -30,8 +30,11 @@ import (
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/codes"
 	"google.golang.org/grpc/status"
+	"sigs.k8s.io/cloud-provider-azure/pkg/provider"
 
+	"github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2021-09-01/storage"
 	"github.com/container-storage-interface/spec/lib/go/csi"
+	"github.com/golang/mock/gomock"
 	"github.com/stretchr/testify/assert"
 
 	mount "k8s.io/mount-utils"
@@ -235,6 +238,7 @@ func TestNodePublishVolume(t *testing.T) {
 	_ = makeDir(sourceTest)
 	_ = makeDir(targetTest)
 	d := NewFakeDriver()
+	d.cloud = provider.GetTestCloud(gomock.NewController(t))
 	fakeMounter := &fakeMounter{}
 	fakeExec := &testingexec.FakeExec{ExactOrder: true}
 	d.mounter = &mount.SafeFormatAndMount{
@@ -243,6 +247,7 @@ func TestNodePublishVolume(t *testing.T) {
 	}
 
 	for _, test := range tests {
+		d.cloud.ResourceGroup = "rg"
 		if test.setup != nil {
 			test.setup(d)
 		}
@@ -456,6 +461,102 @@ func TestNodeStageVolume(t *testing.T) {
 				}
 			},
 		},
+		{
+			name: "[Error] Could not mount to target",
+			testFunc: func(t *testing.T) {
+				req := &csi.NodeStageVolumeRequest{
+					VolumeId:          "unit-test",
+					StagingTargetPath: "error_is_likely",
+					VolumeCapability:  &csi.VolumeCapability{AccessMode: &volumeCap},
+					VolumeContext: map[string]string{
+						mountPermissionsField: "0755",
+					},
+				}
+				d := NewFakeDriver()
+				fakeMounter := &fakeMounter{}
+				fakeExec := &testingexec.FakeExec{}
+				d.mounter = &mount.SafeFormatAndMount{
+					Interface: fakeMounter,
+					Exec:      fakeExec,
+				}
+				_, err := d.NodeStageVolume(context.TODO(), req)
+				expectedErr := status.Error(codes.Internal, fmt.Sprintf("Could not mount target %q: %v", req.StagingTargetPath, fmt.Errorf("fake IsLikelyNotMountPoint: fake error")))
+				if !reflect.DeepEqual(err, expectedErr) {
+					t.Errorf("actualErr: (%v), expectedErr: (%v)", err, expectedErr)
+				}
+			},
+		},
+		{
+			name: "protocol = nfs",
+			testFunc: func(t *testing.T) {
+				req := &csi.NodeStageVolumeRequest{
+					VolumeId:          "rg#acc#cont#ns",
+					StagingTargetPath: targetTest,
+					VolumeCapability:  &csi.VolumeCapability{AccessMode: &volumeCap},
+					VolumeContext: map[string]string{
+						mountPermissionsField: "0755",
+						protocolField:         "nfs",
+					},
+					Secrets: map[string]string{},
+				}
+				d := NewFakeDriver()
+				d.cloud = provider.GetTestCloud(gomock.NewController(t))
+				d.cloud.ResourceGroup = "rg"
+				d.enableBlobMockMount = true
+				fakeMounter := &fakeMounter{}
+				fakeExec := &testingexec.FakeExec{}
+				d.mounter = &mount.SafeFormatAndMount{
+					Interface: fakeMounter,
+					Exec:      fakeExec,
+				}
+
+				_, err := d.NodeStageVolume(context.TODO(), req)
+				//expectedErr := nil
+				if !reflect.DeepEqual(err, nil) {
+					t.Errorf("actualErr: (%v), expectedErr: (%v)", err, nil)
+				}
+			},
+		},
+		{
+			name: "BlobMockMount Enabled",
+			testFunc: func(t *testing.T) {
+				req := &csi.NodeStageVolumeRequest{
+					VolumeId:          "rg#acc#cont#ns",
+					StagingTargetPath: targetTest,
+					VolumeCapability:  &csi.VolumeCapability{AccessMode: &volumeCap},
+					VolumeContext: map[string]string{
+						mountPermissionsField: "0755",
+						protocolField:         "protocol",
+					},
+					Secrets: map[string]string{},
+				}
+				d := NewFakeDriver()
+				d.cloud = provider.GetTestCloud(gomock.NewController(t))
+				d.cloud.ResourceGroup = "rg"
+				d.enableBlobMockMount = true
+				fakeMounter := &fakeMounter{}
+				fakeExec := &testingexec.FakeExec{}
+				d.mounter = &mount.SafeFormatAndMount{
+					Interface: fakeMounter,
+					Exec:      fakeExec,
+				}
+
+				keyList := make([]storage.AccountKey, 1)
+				fakeKey := "fakeKey"
+				fakeValue := "fakeValue"
+				keyList[0] = (storage.AccountKey{
+					KeyName: &fakeKey,
+					Value:   &fakeValue,
+				})
+				d.cloud.StorageAccountClient = NewMockSAClient(context.Background(), gomock.NewController(t), "subID", "unit-test", "unit-test", &keyList)
+
+				_, err := d.NodeStageVolume(context.TODO(), req)
+				//expectedErr := nil
+				if !reflect.DeepEqual(err, nil) {
+					t.Errorf("actualErr: (%v), expectedErr: (%v)", err, nil)
+				}
+			},
+		},
 	}
 	for _, tc := range testCases {
 		t.Run(tc.name, tc.testFunc)
@@ -520,6 +621,12 @@ func TestNodeUnstageVolume(t *testing.T) {
 					StagingTargetPath: "./unit-test",
 				}
 				d := NewFakeDriver()
+				fakeMounter := &fakeMounter{}
+				fakeExec := &testingexec.FakeExec{}
+				d.mounter = &mount.SafeFormatAndMount{
+					Interface: fakeMounter,
+					Exec:      fakeExec,
+				}
 				_, err := d.NodeUnstageVolume(context.TODO(), req)
 				expectedErr := error(nil)
 				if !reflect.DeepEqual(err, expectedErr) {

pkg/blob/fake_mount_test.go

@@ -68,4 +68,4 @@ then
   sed -i 's/PRUNEFS="NFS/PRUNEFS="fuse blobfuse NFS/g' ${updateDBConfigPath}
   echo "after change:"
   cat ${updateDBConfigPath}
-fi
+fi

pkg/blob/nodeserver_test.go

@@ -39,4 +39,3 @@ LABEL maintainers="andyzhangx"
 LABEL description="Azure Blob Storage CSI driver"
 
 ENTRYPOINT ["/blobplugin"]
-

pkg/blobfuse-proxy/init.sh

@@ -124,3 +124,11 @@ func TestValidateControllerServiceRequest(t *testing.T) {
 	assert.NoError(t, err)
 
 }
+
+func TestAddNodeServiceCapabilities(t *testing.T) {
+	d := NewFakeDriver()
+	nl := []csi.NodeServiceCapability_RPC_Type{csi.NodeServiceCapability_RPC_UNKNOWN, csi.NodeServiceCapability_RPC_EXPAND_VOLUME}
+	d.AddNodeServiceCapabilities(nl)
+	expectedOutput := []*csi.NodeServiceCapability{NewNodeServiceCapability(nl[0]), NewNodeServiceCapability(nl[1])}
+	assert.Equal(t, expectedOutput, d.NSCap, "NS Capabilities must Match")
+}

pkg/blobplugin/Dockerfile

@@ -17,6 +17,7 @@ limitations under the License.
 package util
 
 import (
+	"fmt"
 	"os"
 	"testing"
 	"time"
@@ -147,7 +148,7 @@ func TestGetMountOptions(t *testing.T) {
 			expected: "",
 		},
 		{
-			options:  []string{},
+			options:  make([]string, 0),
 			expected: "",
 		},
 	}
@@ -172,6 +173,39 @@ func TestMakeDir(t *testing.T) {
 }
 
 func TestConvertTagsToMap(t *testing.T) {
+	tests := []struct {
+		desc        string
+		tags        string
+		expectedOut map[string]string
+		expectedErr error
+	}{
+		{
+			desc:        "Improper KeyValuePair",
+			tags:        "foo=bar=gar,lorem=ipsum",
+			expectedOut: nil,
+			expectedErr: fmt.Errorf("Tags '%s' are invalid, the format should like: 'key1=value1,key2=value2'", "foo=bar=gar,lorem=ipsum"),
+		},
+		{
+			desc:        "Missing Key",
+			tags:        "=bar,lorem=ipsum",
+			expectedOut: nil,
+			expectedErr: fmt.Errorf("Tags '%s' are invalid, the format should like: 'key1=value1,key2=value2'", "=bar,lorem=ipsum"),
+		},
+		{
+			desc:        "Successful Input/Output",
+			tags:        "foo=bar,lorem=ipsum",
+			expectedOut: map[string]string{"foo": "bar", "lorem": "ipsum"},
+			expectedErr: nil,
+		},
+	}
+
+	for _, test := range tests {
+		output, err := ConvertTagsToMap(test.tags)
+		assert.Equal(t, test.expectedOut, output, test.desc)
+		assert.Equal(t, test.expectedErr, err, test.desc)
+	}
+}
+func TestConvertTagsToMap2(t *testing.T) {
 	type StringMap map[string]string
 	tests := []struct {
 		tags     string