Skip to content

Commit f205d62

Browse files
Mockery-LiMockery-Li
committed
Test publish
1 parent 8f291d2 commit f205d62

File tree

2 files changed

+270
-4
lines changed

2 files changed

+270
-4
lines changed

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

+1-4
Original file line numberDiff line numberDiff line change
@@ -296,10 +296,7 @@ func (ns *GCENodeServer) NodeGetInfo(ctx context.Context, req *csi.NodeGetInfoRe
296296
volumeLimits, err := ns.GetVolumeLimits()
297297

298298
resp := &csi.NodeGetInfoResponse{
299-
NodeId: nodeID,
300-
// TODO(#19): Set MaxVolumesPerNode based on Node Type
301-
// Default of 0 means that CO Decides how many nodes can be published
302-
// Can get from metadata server "machine-type"
299+
NodeId: nodeID,
303300
MaxVolumesPerNode: volumeLimits,
304301
AccessibleTopology: top,
305302
}

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

+269
Original file line numberDiff line numberDiff line change
@@ -19,6 +19,8 @@ import (
1919

2020
csi "github.com/container-storage-interface/spec/lib/go/csi"
2121
"golang.org/x/net/context"
22+
"google.golang.org/grpc/codes"
23+
"google.golang.org/grpc/status"
2224
metadataservice "sigs.k8s.io/gcp-compute-persistent-disk-csi-driver/pkg/gce-cloud-provider/metadata"
2325
mountmanager "sigs.k8s.io/gcp-compute-persistent-disk-csi-driver/pkg/mount-manager"
2426
)
@@ -86,3 +88,270 @@ func TestNodeGetVolumeLimits(t *testing.T) {
8688
}
8789
}
8890
}
91+
92+
func TestNodePublishVolume(t *testing.T) {
93+
gceDriver := getTestGCEDriver(t)
94+
ns := gceDriver.ns
95+
testCases := []struct {
96+
name string
97+
req *csi.NodePublishVolumeRequest
98+
expErrCode codes.Code
99+
}{
100+
{
101+
name: "Valid request",
102+
req: &csi.NodePublishVolumeRequest{
103+
VolumeId: "1",
104+
TargetPath: "/mnt/test",
105+
StagingTargetPath: "/staging",
106+
Readonly: false,
107+
VolumeCapability: &csi.VolumeCapability{},
108+
},
109+
},
110+
{
111+
name: "Invalid request (No VolumeId)",
112+
req: &csi.NodePublishVolumeRequest{
113+
TargetPath: "/mnt/test",
114+
StagingTargetPath: "/staging",
115+
Readonly: false,
116+
VolumeCapability: &csi.VolumeCapability{},
117+
},
118+
expErrCode: codes.InvalidArgument,
119+
},
120+
{
121+
name: "Invalid request (No TargetPath)",
122+
req: &csi.NodePublishVolumeRequest{
123+
VolumeId: "1",
124+
StagingTargetPath: "/staging",
125+
Readonly: false,
126+
VolumeCapability: &csi.VolumeCapability{},
127+
},
128+
expErrCode: codes.InvalidArgument,
129+
},
130+
{
131+
name: "Invalid request (No StagingTargetPath)",
132+
req: &csi.NodePublishVolumeRequest{
133+
VolumeId: "1",
134+
TargetPath: "/mnt/test",
135+
Readonly: false,
136+
VolumeCapability: &csi.VolumeCapability{},
137+
},
138+
expErrCode: codes.InvalidArgument,
139+
},
140+
{
141+
name: "Invalid request (Nil VolumeCapability)",
142+
req: &csi.NodePublishVolumeRequest{
143+
VolumeId: "1",
144+
TargetPath: "/mnt/test",
145+
StagingTargetPath: "/staging",
146+
Readonly: false,
147+
VolumeCapability: nil,
148+
},
149+
expErrCode: codes.InvalidArgument,
150+
},
151+
}
152+
for _, tc := range testCases {
153+
t.Logf("Test case: %s", tc.name)
154+
_, err := ns.NodePublishVolume(context.Background(), tc.req)
155+
if err != nil {
156+
serverError, ok := status.FromError(err)
157+
if !ok {
158+
t.Fatalf("Could not get error status code from err: %v", err)
159+
}
160+
if serverError.Code() != tc.expErrCode {
161+
t.Fatalf("Expected error code: %v, got: %v. err : %v", tc.expErrCode, serverError.Code(), err)
162+
}
163+
continue
164+
}
165+
if tc.expErrCode != codes.OK {
166+
t.Fatalf("Expected error: %v, got no error", tc.expErrCode)
167+
}
168+
}
169+
}
170+
171+
func TestNodeUnpublishVolume(t *testing.T) {
172+
gceDriver := getTestGCEDriver(t)
173+
ns := gceDriver.ns
174+
testCases := []struct {
175+
name string
176+
req *csi.NodeUnpublishVolumeRequest
177+
expErrCode codes.Code
178+
}{
179+
{
180+
name: "Valid request",
181+
req: &csi.NodeUnpublishVolumeRequest{
182+
VolumeId: "1",
183+
TargetPath: "/mnt/test",
184+
},
185+
},
186+
{
187+
name: "Invalid request (No VolumeId)",
188+
req: &csi.NodeUnpublishVolumeRequest{
189+
TargetPath: "/mnt/test",
190+
},
191+
expErrCode: codes.InvalidArgument,
192+
},
193+
{
194+
name: "Invalid request (No TargetPath)",
195+
req: &csi.NodeUnpublishVolumeRequest{
196+
VolumeId: "1",
197+
},
198+
expErrCode: codes.InvalidArgument,
199+
},
200+
}
201+
for _, tc := range testCases {
202+
t.Logf("Test case: %s", tc.name)
203+
_, err := ns.NodeUnpublishVolume(context.Background(), tc.req)
204+
if err != nil {
205+
serverError, ok := status.FromError(err)
206+
if !ok {
207+
t.Fatalf("Could not get error status code from err: %v", err)
208+
}
209+
if serverError.Code() != tc.expErrCode {
210+
t.Fatalf("Expected error code: %v, got: %v. err : %v", tc.expErrCode, serverError.Code(), err)
211+
}
212+
continue
213+
}
214+
if tc.expErrCode != codes.OK {
215+
t.Fatalf("Expected error: %v, got no error", tc.expErrCode)
216+
}
217+
}
218+
}
219+
220+
func TestNodeStageVolume(t *testing.T) {
221+
gceDriver := getTestGCEDriver(t)
222+
ns := gceDriver.ns
223+
volumeID := "project/test001/zones/c1/disks/testDisk"
224+
blockCap := &csi.VolumeCapability_Block{
225+
Block: &csi.VolumeCapability_BlockVolume{},
226+
}
227+
cap := &csi.VolumeCapability{
228+
AccessType: blockCap,
229+
}
230+
231+
testCases := []struct {
232+
name string
233+
req *csi.NodeStageVolumeRequest
234+
expErrCode codes.Code
235+
}{
236+
{
237+
name: "Valid request",
238+
req: &csi.NodeStageVolumeRequest{
239+
VolumeId: volumeID,
240+
StagingTargetPath: "/staging",
241+
VolumeCapability: &csi.VolumeCapability{},
242+
},
243+
},
244+
{
245+
name: "Invalid request (No VolumeId)",
246+
req: &csi.NodeStageVolumeRequest{
247+
StagingTargetPath: "/staging",
248+
VolumeCapability: &csi.VolumeCapability{},
249+
},
250+
expErrCode: codes.InvalidArgument,
251+
},
252+
{
253+
name: "Invalid request (No StagingTargetPath)",
254+
req: &csi.NodeStageVolumeRequest{
255+
VolumeId: volumeID,
256+
VolumeCapability: &csi.VolumeCapability{},
257+
},
258+
expErrCode: codes.InvalidArgument,
259+
},
260+
{
261+
name: "Invalid request (Nil VolumeCapability)",
262+
req: &csi.NodeStageVolumeRequest{
263+
VolumeId: volumeID,
264+
StagingTargetPath: "/staging",
265+
VolumeCapability: nil,
266+
},
267+
expErrCode: codes.InvalidArgument,
268+
},
269+
{
270+
name: "Invalid request (No Mount in capability)",
271+
req: &csi.NodeStageVolumeRequest{
272+
VolumeId: volumeID,
273+
StagingTargetPath: "/staging",
274+
VolumeCapability: cap,
275+
},
276+
expErrCode: codes.Unimplemented,
277+
},
278+
// Capability Mount. codes.Unimplemented
279+
}
280+
for _, tc := range testCases {
281+
t.Logf("Test case: %s", tc.name)
282+
_, err := ns.NodeStageVolume(context.Background(), tc.req)
283+
if err != nil {
284+
serverError, ok := status.FromError(err)
285+
if !ok {
286+
t.Fatalf("Could not get error status code from err: %v", err)
287+
}
288+
if serverError.Code() != tc.expErrCode {
289+
t.Fatalf("Expected error code: %v, got: %v. err : %v", tc.expErrCode, serverError.Code(), err)
290+
}
291+
continue
292+
}
293+
if tc.expErrCode != codes.OK {
294+
t.Fatalf("Expected error: %v, got no error", tc.expErrCode)
295+
}
296+
}
297+
}
298+
299+
func TestNodeUnstageVolume(t *testing.T) {
300+
gceDriver := getTestGCEDriver(t)
301+
ns := gceDriver.ns
302+
testCases := []struct {
303+
name string
304+
req *csi.NodeUnstageVolumeRequest
305+
expErrCode codes.Code
306+
}{
307+
{
308+
name: "Valid request",
309+
req: &csi.NodeUnstageVolumeRequest{
310+
VolumeId: "1",
311+
StagingTargetPath: "/staging",
312+
},
313+
},
314+
{
315+
name: "Invalid request (No VolumeId)",
316+
req: &csi.NodeUnstageVolumeRequest{
317+
StagingTargetPath: "/staging",
318+
},
319+
expErrCode: codes.InvalidArgument,
320+
},
321+
{
322+
name: "Invalid request (No StagingTargetPath)",
323+
req: &csi.NodeUnstageVolumeRequest{
324+
VolumeId: "1",
325+
},
326+
expErrCode: codes.InvalidArgument,
327+
},
328+
}
329+
for _, tc := range testCases {
330+
t.Logf("Test case: %s", tc.name)
331+
_, err := ns.NodeUnstageVolume(context.Background(), tc.req)
332+
if err != nil {
333+
serverError, ok := status.FromError(err)
334+
if !ok {
335+
t.Fatalf("Could not get error status code from err: %v", err)
336+
}
337+
if serverError.Code() != tc.expErrCode {
338+
t.Fatalf("Expected error code: %v, got: %v. err : %v", tc.expErrCode, serverError.Code(), err)
339+
}
340+
continue
341+
}
342+
if tc.expErrCode != codes.OK {
343+
t.Fatalf("Expected error: %v, got no error", tc.expErrCode)
344+
}
345+
}
346+
}
347+
348+
func TestNodeGetCapabilities(t *testing.T) {
349+
gceDriver := getTestGCEDriver(t)
350+
ns := gceDriver.ns
351+
req := &csi.NodeGetCapabilitiesRequest{}
352+
353+
_, err := ns.NodeGetCapabilities(context.Background(), req)
354+
if err != nil {
355+
t.Fatalf("Unexpedted error: %v", err)
356+
}
357+
}

0 commit comments

Comments
 (0)