Add unit test for ext4 and block node resize

Author: davidz627

pkg/gce-pd-csi-driver/node.go

@@ -388,15 +388,17 @@ func (ns *GCENodeServer) NodeExpandVolume(ctx context.Context, req *csi.NodeExpa
 	}
 
 	resizer := resizefs.NewResizeFs(ns.Mounter)
-	_, err = resizer.Resize(devicePath, "")
+	resized, err := resizer.Resize(devicePath, "")
 	if err != nil {
 		return nil, status.Error(codes.Internal, fmt.Sprintf("Error when resizing volume %s: %v", volKey.String(), err))
 
 	}
 
-	return &csi.NodeExpandVolumeResponse{
-		CapacityBytes: reqBytes,
-	}, nil
+	resp := &csi.NodeExpandVolumeResponse{}
+	if resized {
+		resp.CapacityBytes = reqBytes
+	}
+	return resp, nil
 }
 
 func (ns *GCENodeServer) GetVolumeLimits() (int64, error) {

pkg/gce-pd-csi-driver/node_test.go

@@ -15,12 +15,17 @@ limitations under the License.
 package gceGCEDriver
 
 import (
+	"errors"
+	"fmt"
 	"testing"
 
 	"context"
+
 	csi "github.com/container-storage-interface/spec/lib/go/csi"
 	"google.golang.org/grpc/codes"
 	"google.golang.org/grpc/status"
+	"k8s.io/kubernetes/pkg/util/mount"
+	utilexec "k8s.io/utils/exec"
 	metadataservice "sigs.k8s.io/gcp-compute-persistent-disk-csi-driver/pkg/gce-cloud-provider/metadata"
 	mountmanager "sigs.k8s.io/gcp-compute-persistent-disk-csi-driver/pkg/mount-manager"
 )
@@ -30,8 +35,16 @@ const defaultTargetPath = "/mnt/test"
 const defaultStagingPath = "/staging"
 
 func getTestGCEDriver(t *testing.T) *GCEDriver {
+	return getCustomTestGCEDriver(t, mountmanager.NewFakeSafeMounter(), mountmanager.NewFakeDeviceUtils(), metadataservice.NewFakeService())
+}
+
+func getTestGCEDriverWithCustomMounter(t *testing.T, mounter *mount.SafeFormatAndMount) *GCEDriver {
+	return getCustomTestGCEDriver(t, mounter, mountmanager.NewFakeDeviceUtils(), metadataservice.NewFakeService())
+}
+
+func getCustomTestGCEDriver(t *testing.T, mounter *mount.SafeFormatAndMount, deviceUtils mountmanager.DeviceUtils, metaService metadataservice.MetadataService) *GCEDriver {
 	gceDriver := GetGCEDriver()
-	err := gceDriver.SetupGCEDriver(nil, mountmanager.NewFakeSafeMounter(), mountmanager.NewFakeDeviceUtils(), metadataservice.NewFakeService(), driver, "test-vendor")
+	err := gceDriver.SetupGCEDriver(nil, mounter, deviceUtils, metaService, driver, "test-vendor")
 	if err != nil {
 		t.Fatalf("Failed to setup GCE Driver: %v", err)
 	}
@@ -328,6 +341,87 @@ func TestNodeStageVolume(t *testing.T) {
 	}
 }
 
+func TestNodeExpandVolume(t *testing.T) {
+	// TODO: Add tests/functionality for non-existant volume
+	var resizedBytes int64 = 2000000000
+	volumeID := "project/test001/zones/c1/disks/testDisk"
+	testCases := []struct {
+		name         string
+		req          *csi.NodeExpandVolumeRequest
+		blockDevice  bool
+		expRespBytes int64
+		expErrCode   codes.Code
+	}{
+		{
+			name: "ext4 fs expand",
+			req: &csi.NodeExpandVolumeRequest{
+				VolumeId:   volumeID,
+				VolumePath: "some-path",
+				CapacityRange: &csi.CapacityRange{
+					RequiredBytes: resizedBytes,
+				},
+			},
+			blockDevice:  false,
+			expRespBytes: resizedBytes,
+		},
+		{
+			name: "block device expand",
+			req: &csi.NodeExpandVolumeRequest{
+				VolumeId:   volumeID,
+				VolumePath: "some-path",
+				CapacityRange: &csi.CapacityRange{
+					RequiredBytes: resizedBytes,
+				},
+			},
+			blockDevice: true,
+		},
+	}
+	for _, tc := range testCases {
+		t.Logf("Test case: %s", tc.name)
+
+		execCallback := func(cmd string, args ...string) ([]byte, error) {
+			if cmd == "blkid" {
+				if tc.blockDevice {
+					// blkid returns exit code 2 when run on unformatted device
+					return nil, utilexec.CodeExitError{
+						Err:  errors.New("this is an exit error"),
+						Code: 2,
+					}
+				} else {
+					return []byte("DEVNAME=/dev/sdb\nTYPE=ext4"), nil
+				}
+			} else if cmd == "resize2fs" {
+				if tc.blockDevice {
+					t.Fatalf("resize fs called on block device")
+				}
+				return nil, nil
+			}
+			return nil, fmt.Errorf("fake exec got unknown call to %v %v", cmd, args)
+		}
+		mounter := mountmanager.NewFakeSafeMounterWithCustomExec(mount.NewFakeExec(execCallback))
+		gceDriver := getTestGCEDriverWithCustomMounter(t, mounter)
+
+		resp, err := gceDriver.ns.NodeExpandVolume(context.Background(), tc.req)
+		if err != nil {
+			serverError, ok := status.FromError(err)
+			if !ok {
+				t.Fatalf("Could not get error status code from err: %v", err)
+			}
+			if serverError.Code() != tc.expErrCode {
+				t.Fatalf("Expected error code: %v, got: %v. err : %v", tc.expErrCode, serverError.Code(), err)
+			}
+			continue
+		}
+		if tc.expErrCode != codes.OK {
+			t.Fatalf("Expected error: %v, got no error", tc.expErrCode)
+		}
+
+		if resp.CapacityBytes != tc.expRespBytes {
+			t.Fatalf("Expected bytes: %v, got: %v", tc.expRespBytes, resp.CapacityBytes)
+		}
+	}
+}
+
 func TestNodeUnstageVolume(t *testing.T) {
 	gceDriver := getTestGCEDriver(t)
 	ns := gceDriver.ns

pkg/mount-manager/fake-safe-mounter.go

@@ -44,9 +44,18 @@ func execCallback(cmd string, args ...string) ([]byte, error) {
 }
 
 func NewFakeSafeMounter() *mount.SafeFormatAndMount {
+	return NewCustomFakeSafeMounter(fakeMounter, fakeExec)
+}
+
+func NewFakeSafeMounterWithCustomExec(exec mount.Exec) *mount.SafeFormatAndMount {
+	fakeMounter := &mount.FakeMounter{MountPoints: []mount.MountPoint{}, Log: []mount.FakeAction{}}
+	return NewCustomFakeSafeMounter(fakeMounter, exec)
+}
+
+func NewCustomFakeSafeMounter(mounter mount.Interface, exec mount.Exec) *mount.SafeFormatAndMount {
 	return &mount.SafeFormatAndMount{
-		Interface: fakeMounter,
-		Exec:      fakeExec,
+		Interface: mounter,
+		Exec:      exec,
 	}
 }
 
@@ -84,6 +93,5 @@ func NewFakeSafeBlockingMounter(mountToRun chan MountSourceAndTarget, readyToMou
 	}
 	return &mount.SafeFormatAndMount{
 		Interface: fakeBlockingMounter,
-		Exec:      fakeExec,
 	}
 }