Skip to content

Commit 608c0fe

Browse files
author
Power Cloud Robot
authored
Merge pull request #94 from Madhan-SWE/volume_lock_tests
Volume lock tests added for controller and node plugins
2 parents f413f91 + c1b6b66 commit 608c0fe

File tree

2 files changed

+210
-24
lines changed

2 files changed

+210
-24
lines changed

‎pkg/driver/controller_test.go

Lines changed: 152 additions & 23 deletions
Original file line numberDiff line numberDiff line change
@@ -461,6 +461,35 @@ func TestCreateVolume(t *testing.T) {
461461
}
462462
},
463463
},
464+
{
465+
name: "fail locked volume request",
466+
testFunc: func(t *testing.T) {
467+
req := &csi.CreateVolumeRequest{
468+
Name: "random-vol-name",
469+
CapacityRange: stdCapRange,
470+
VolumeCapabilities: stdVolCap,
471+
Parameters: nil,
472+
}
473+
474+
ctx := context.Background()
475+
mockCtl := gomock.NewController(t)
476+
defer mockCtl.Finish()
477+
478+
mockCloud := mocks.NewMockCloud(mockCtl)
479+
480+
powervsDriver := controllerService{
481+
cloud: mockCloud,
482+
driverOptions: &Options{},
483+
volumeLocks: util.NewVolumeLocks(),
484+
}
485+
486+
powervsDriver.volumeLocks.TryAcquire(req.Name)
487+
defer powervsDriver.volumeLocks.Release(req.Name)
488+
489+
_, err := powervsDriver.CreateVolume(ctx, req)
490+
checkExpectedErrorCode(t, err, codes.Aborted)
491+
},
492+
},
464493
}
465494

466495
for _, tc := range testCases {
@@ -575,6 +604,32 @@ func TestDeleteVolume(t *testing.T) {
575604
}
576605
},
577606
},
607+
{
608+
name: "fail if volume is already locked",
609+
testFunc: func(t *testing.T) {
610+
req := &csi.DeleteVolumeRequest{
611+
VolumeId: "vol-test",
612+
}
613+
614+
ctx := context.Background()
615+
mockCtl := gomock.NewController(t)
616+
defer mockCtl.Finish()
617+
618+
mockCloud := mocks.NewMockCloud(mockCtl)
619+
620+
powervsDriver := controllerService{
621+
cloud: mockCloud,
622+
driverOptions: &Options{},
623+
volumeLocks: util.NewVolumeLocks(),
624+
}
625+
626+
powervsDriver.volumeLocks.TryAcquire(req.VolumeId)
627+
defer powervsDriver.volumeLocks.Release(req.VolumeId)
628+
629+
_, err := powervsDriver.DeleteVolume(ctx, req)
630+
checkExpectedErrorCode(t, err, codes.Aborted)
631+
},
632+
},
578633
}
579634

580635
for _, tc := range testCases {
@@ -855,6 +910,34 @@ func TestControllerPublishVolume(t *testing.T) {
855910
}
856911
},
857912
},
913+
{
914+
name: "fail if volume already locked",
915+
testFunc: func(t *testing.T) {
916+
req := &csi.ControllerPublishVolumeRequest{
917+
NodeId: expInstanceID,
918+
VolumeCapability: stdVolCap,
919+
VolumeId: volumeName,
920+
}
921+
922+
ctx := context.Background()
923+
mockCtl := gomock.NewController(t)
924+
defer mockCtl.Finish()
925+
926+
mockCloud := mocks.NewMockCloud(mockCtl)
927+
powervsDriver := controllerService{
928+
cloud: mockCloud,
929+
driverOptions: &Options{},
930+
volumeLocks: util.NewVolumeLocks(),
931+
}
932+
933+
powervsDriver.volumeLocks.TryAcquire(req.VolumeId)
934+
defer powervsDriver.volumeLocks.Release(req.VolumeId)
935+
936+
_, err := powervsDriver.ControllerPublishVolume(ctx, req)
937+
checkExpectedErrorCode(t, err, codes.Aborted)
938+
939+
},
940+
},
858941
}
859942

860943
for _, tc := range testCases {
@@ -1000,6 +1083,32 @@ func TestControllerUnpublishVolume(t *testing.T) {
10001083
}
10011084
},
10021085
},
1086+
{
1087+
name: "fail if volume already locked",
1088+
testFunc: func(t *testing.T) {
1089+
req := &csi.ControllerUnpublishVolumeRequest{
1090+
NodeId: expInstanceID,
1091+
VolumeId: "vol-test",
1092+
}
1093+
1094+
ctx := context.Background()
1095+
mockCtl := gomock.NewController(t)
1096+
defer mockCtl.Finish()
1097+
1098+
mockCloud := mocks.NewMockCloud(mockCtl)
1099+
powervsDriver := controllerService{
1100+
cloud: mockCloud,
1101+
driverOptions: &Options{},
1102+
volumeLocks: util.NewVolumeLocks(),
1103+
}
1104+
1105+
powervsDriver.volumeLocks.TryAcquire(req.VolumeId)
1106+
defer powervsDriver.volumeLocks.Release(req.VolumeId)
1107+
1108+
_, err := powervsDriver.ControllerUnpublishVolume(ctx, req)
1109+
checkExpectedErrorCode(t, err, codes.Aborted)
1110+
},
1111+
},
10031112
}
10041113

10051114
for _, tc := range testCases {
@@ -1009,11 +1118,12 @@ func TestControllerUnpublishVolume(t *testing.T) {
10091118

10101119
func TestControllerExpandVolume(t *testing.T) {
10111120
testCases := []struct {
1012-
name string
1013-
req *csi.ControllerExpandVolumeRequest
1014-
newSize int64
1015-
expResp *csi.ControllerExpandVolumeResponse
1016-
expError bool
1121+
name string
1122+
req *csi.ControllerExpandVolumeRequest
1123+
newSize int64
1124+
expResp *csi.ControllerExpandVolumeResponse
1125+
expError bool
1126+
volumeLock bool
10171127
}{
10181128
{
10191129
name: "success normal",
@@ -1043,6 +1153,16 @@ func TestControllerExpandVolume(t *testing.T) {
10431153
},
10441154
expError: true,
10451155
},
1156+
{
1157+
name: "fail if volume already locked",
1158+
req: &csi.ControllerExpandVolumeRequest{
1159+
VolumeId: "vol-test",
1160+
CapacityRange: &csi.CapacityRange{
1161+
RequiredBytes: 5 * util.GiB,
1162+
},
1163+
},
1164+
volumeLock: true,
1165+
},
10461166
}
10471167

10481168
for _, tc := range testCases {
@@ -1059,34 +1179,43 @@ func TestControllerExpandVolume(t *testing.T) {
10591179
}
10601180

10611181
mockCloud := mocks.NewMockCloud(mockCtl)
1062-
mockCloud.EXPECT().ResizeDisk(gomock.Eq(tc.req.VolumeId), gomock.Any()).Return(retSizeGiB, nil).AnyTimes()
1063-
10641182
powervsDriver := controllerService{
10651183
cloud: mockCloud,
10661184
driverOptions: &Options{},
10671185
volumeLocks: util.NewVolumeLocks(),
10681186
}
10691187

1070-
resp, err := powervsDriver.ControllerExpandVolume(ctx, tc.req)
1071-
if err != nil {
1072-
srvErr, ok := status.FromError(err)
1073-
if !ok {
1074-
t.Fatalf("Could not get error status code from error: %v", srvErr)
1075-
}
1076-
if !tc.expError {
1077-
t.Fatalf("Unexpected error: %v", err)
1078-
}
1188+
if tc.volumeLock {
1189+
powervsDriver.volumeLocks.TryAcquire(tc.req.VolumeId)
1190+
defer powervsDriver.volumeLocks.Release(tc.req.VolumeId)
1191+
1192+
_, err := powervsDriver.ControllerExpandVolume(ctx, tc.req)
1193+
checkExpectedErrorCode(t, err, codes.Aborted)
1194+
10791195
} else {
1080-
if tc.expError {
1081-
t.Fatalf("Expected error from ControllerExpandVolume, got nothing")
1196+
mockCloud.EXPECT().ResizeDisk(gomock.Eq(tc.req.VolumeId), gomock.Any()).Return(retSizeGiB, nil).AnyTimes()
1197+
resp, err := powervsDriver.ControllerExpandVolume(ctx, tc.req)
1198+
if err != nil {
1199+
srvErr, ok := status.FromError(err)
1200+
if !ok {
1201+
t.Fatalf("Could not get error status code from error: %v", srvErr)
1202+
}
1203+
if !tc.expError {
1204+
t.Fatalf("Unexpected error: %v", err)
1205+
}
1206+
} else {
1207+
if tc.expError {
1208+
t.Fatalf("Expected error from ControllerExpandVolume, got nothing")
1209+
}
10821210
}
1083-
}
10841211

1085-
sizeGiB := util.BytesToGiB(resp.GetCapacityBytes())
1086-
expSizeGiB := util.BytesToGiB(tc.expResp.GetCapacityBytes())
1087-
if sizeGiB != expSizeGiB {
1088-
t.Fatalf("Expected size %d GiB, got %d GiB", expSizeGiB, sizeGiB)
1212+
sizeGiB := util.BytesToGiB(resp.GetCapacityBytes())
1213+
expSizeGiB := util.BytesToGiB(tc.expResp.GetCapacityBytes())
1214+
if sizeGiB != expSizeGiB {
1215+
t.Fatalf("Expected size %d GiB, got %d GiB", expSizeGiB, sizeGiB)
1216+
}
10891217
}
1218+
10901219
})
10911220
}
10921221
}

‎pkg/driver/node_test.go

Lines changed: 58 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -80,6 +80,7 @@ func TestNodeStageVolume(t *testing.T) {
8080
request *csi.NodeStageVolumeRequest
8181
expectMock func(mockMounter mocks.MockMounter)
8282
expectedCode codes.Code
83+
volumeLock bool
8384
}{
8485

8586
{
@@ -270,6 +271,17 @@ func TestNodeStageVolume(t *testing.T) {
270271
},
271272
expectedCode: codes.InvalidArgument,
272273
},
274+
{
275+
name: "fail_if_volume_already_locked",
276+
request: &csi.NodeStageVolumeRequest{
277+
PublishContext: map[string]string{WWNKey: devicePath},
278+
StagingTargetPath: targetPath,
279+
VolumeCapability: stdVolCap,
280+
VolumeId: volumeID,
281+
},
282+
volumeLock: true,
283+
expectedCode: codes.Aborted,
284+
},
273285
}
274286

275287
for _, tc := range testCases {
@@ -284,6 +296,11 @@ func TestNodeStageVolume(t *testing.T) {
284296
volumeLocks: util.NewVolumeLocks(),
285297
}
286298

299+
if tc.volumeLock {
300+
powervsDriver.volumeLocks.TryAcquire(tc.request.VolumeId)
301+
defer powervsDriver.volumeLocks.Release(tc.request.VolumeId)
302+
}
303+
287304
if tc.expectMock != nil {
288305
tc.expectMock(*mockMounter)
289306
}
@@ -305,27 +322,42 @@ func TestNodeExpandVolume(t *testing.T) {
305322
mockMounter := mocks.NewMockMounter(mockCtl)
306323

307324
powervsDriver := &nodeService{
308-
mounter: mockMounter,
325+
mounter: mockMounter,
326+
volumeLocks: util.NewVolumeLocks(),
309327
}
310328

311329
tests := []struct {
312330
name string
313331
request csi.NodeExpandVolumeRequest
314332
expectResponseCode codes.Code
315333
expectMock func(mockMounter mocks.MockMounter)
334+
volumeLock bool
316335
}{
317336
{
318337
name: "fail missing volumeId",
319338
request: csi.NodeExpandVolumeRequest{},
320339
expectResponseCode: codes.InvalidArgument,
321340
},
341+
{
342+
name: "fail if volume already locked",
343+
request: csi.NodeExpandVolumeRequest{
344+
VolumeId: "test-volume-id",
345+
},
346+
expectResponseCode: codes.Aborted,
347+
volumeLock: true,
348+
},
322349
}
323350

324351
for _, test := range tests {
325352
t.Run(test.name, func(t *testing.T) {
326353
if test.expectMock != nil {
327354
test.expectMock(*mockMounter)
328355
}
356+
357+
if test.volumeLock {
358+
powervsDriver.volumeLocks.TryAcquire(test.request.VolumeId)
359+
defer powervsDriver.volumeLocks.Release(test.request.VolumeId)
360+
}
329361
_, err := powervsDriver.NodeExpandVolume(context.Background(), &test.request)
330362
if err != nil {
331363
if test.expectResponseCode != codes.OK {
@@ -706,6 +738,31 @@ func TestNodeUnpublishVolume(t *testing.T) {
706738
expectErr(t, err, codes.Internal)
707739
},
708740
},
741+
{
742+
name: "fail if volume already locked",
743+
testFunc: func(t *testing.T) {
744+
mockCtl := gomock.NewController(t)
745+
defer mockCtl.Finish()
746+
747+
mockMounter := mocks.NewMockMounter(mockCtl)
748+
749+
powervsDriver := &nodeService{
750+
mounter: mockMounter,
751+
volumeLocks: util.NewVolumeLocks(),
752+
}
753+
754+
req := &csi.NodeUnpublishVolumeRequest{
755+
TargetPath: targetPath,
756+
VolumeId: "vol-test",
757+
}
758+
759+
powervsDriver.volumeLocks.TryAcquire(req.TargetPath)
760+
defer powervsDriver.volumeLocks.Release(req.TargetPath)
761+
762+
_, err := powervsDriver.NodeUnpublishVolume(context.TODO(), req)
763+
checkExpectedErrorCode(t, err, codes.Aborted)
764+
},
765+
},
709766
}
710767

711768
for _, tc := range testCases {

0 commit comments

Comments
 (0)