Skip to content

Commit 98f9e59

Browse files
Praveen005Praveen005
committed
test: enhance test coverage for controller server
Introduce Table Driven Tests
1 parent 0a4e842 commit 98f9e59

File tree

1 file changed

+215
-88
lines changed

1 file changed

+215
-88
lines changed

Diff for: ‎pkg/driver/controller_server_test.go

+215-88
Original file line numberDiff line numberDiff line change
@@ -11,112 +11,239 @@ import (
1111
)
1212

1313
func TestCreateVolume(t *testing.T) {
14-
t.Run("Create a default size volume", func(t *testing.T) {
15-
d, _ := driver.NewTestDriver(nil)
16-
17-
resp, err := d.CreateVolume(context.Background(), &csi.CreateVolumeRequest{
18-
Name: "foo",
19-
VolumeCapabilities: []*csi.VolumeCapability{
20-
{
21-
AccessType: &csi.VolumeCapability_Mount{},
22-
AccessMode: &csi.VolumeCapability_AccessMode{
23-
Mode: csi.VolumeCapability_AccessMode_SINGLE_NODE_WRITER,
14+
tests := []struct {
15+
name string
16+
req *csi.CreateVolumeRequest
17+
existingVolume *civogo.VolumeConfig
18+
expectedError bool
19+
expectedVolumeID string
20+
expectedSizeGB int
21+
expectedErrorMsg string
22+
}{
23+
{
24+
name: "Create a default size volume",
25+
req: &csi.CreateVolumeRequest{
26+
Name: "foo",
27+
VolumeCapabilities: []*csi.VolumeCapability{
28+
{
29+
AccessType: &csi.VolumeCapability_Mount{},
30+
AccessMode: &csi.VolumeCapability_AccessMode{
31+
Mode: csi.VolumeCapability_AccessMode_SINGLE_NODE_WRITER,
32+
},
2433
},
2534
},
2635
},
27-
})
28-
assert.Nil(t, err)
29-
30-
volumes, _ := d.CivoClient.ListVolumes()
31-
assert.Equal(t, "foo", volumes[0].Name)
32-
assert.Equal(t, 10, volumes[0].SizeGigabytes)
33-
assert.Equal(t, volumes[0].ID, resp.Volume.VolumeId)
34-
})
35-
36-
t.Run("Disallow block volumes", func(t *testing.T) {
37-
d, _ := driver.NewTestDriver(nil)
38-
39-
_, err := d.CreateVolume(context.Background(), &csi.CreateVolumeRequest{
40-
Name: "foo",
41-
VolumeCapabilities: []*csi.VolumeCapability{
42-
{
43-
AccessType: &csi.VolumeCapability_Block{},
44-
AccessMode: &csi.VolumeCapability_AccessMode{
45-
Mode: csi.VolumeCapability_AccessMode_SINGLE_NODE_WRITER,
36+
expectedError: false,
37+
expectedSizeGB: 10,
38+
},
39+
{
40+
name: "Disallow block volumes",
41+
req: &csi.CreateVolumeRequest{
42+
Name: "foo",
43+
VolumeCapabilities: []*csi.VolumeCapability{
44+
{
45+
AccessType: &csi.VolumeCapability_Block{},
46+
AccessMode: &csi.VolumeCapability_AccessMode{
47+
Mode: csi.VolumeCapability_AccessMode_SINGLE_NODE_WRITER,
48+
},
4649
},
4750
},
4851
},
49-
})
50-
assert.NotNil(t, err)
51-
})
52-
53-
t.Run("Create a specified size volume", func(t *testing.T) {
54-
d, _ := driver.NewTestDriver(nil)
55-
56-
_, err := d.CreateVolume(context.Background(), &csi.CreateVolumeRequest{
57-
Name: "foo",
58-
VolumeCapabilities: []*csi.VolumeCapability{
59-
{
60-
AccessMode: &csi.VolumeCapability_AccessMode{
61-
Mode: csi.VolumeCapability_AccessMode_SINGLE_NODE_WRITER,
52+
expectedError: true,
53+
expectedErrorMsg: "CreateVolume block types aren't supported, only mount types",
54+
},
55+
{
56+
name: "Create a specified size volume",
57+
req: &csi.CreateVolumeRequest{
58+
Name: "foo",
59+
VolumeCapabilities: []*csi.VolumeCapability{
60+
{
61+
AccessMode: &csi.VolumeCapability_AccessMode{
62+
Mode: csi.VolumeCapability_AccessMode_SINGLE_NODE_WRITER,
63+
},
6264
},
6365
},
66+
CapacityRange: &csi.CapacityRange{
67+
RequiredBytes: 26843545600, // 25GB
68+
},
6469
},
65-
CapacityRange: &csi.CapacityRange{
66-
RequiredBytes: 26843545600,
70+
expectedError: false,
71+
expectedSizeGB: 25,
72+
},
73+
{
74+
name: "Don't create if the volume already exists and just return it",
75+
req: &csi.CreateVolumeRequest{
76+
Name: "foo",
77+
VolumeCapabilities: []*csi.VolumeCapability{
78+
{
79+
AccessMode: &csi.VolumeCapability_AccessMode{
80+
Mode: csi.VolumeCapability_AccessMode_SINGLE_NODE_WRITER,
81+
},
82+
},
83+
},
6784
},
68-
})
69-
assert.Nil(t, err)
70-
71-
volumes, _ := d.CivoClient.ListVolumes()
72-
assert.Equal(t, 25, volumes[0].SizeGigabytes)
73-
})
74-
75-
t.Run("Don't create if the volume already exists and just return it", func(t *testing.T) {
76-
d, _ := driver.NewTestDriver(nil)
77-
78-
volume, err := d.CivoClient.NewVolume(&civogo.VolumeConfig{
79-
Name: "foo",
80-
SizeGigabytes: 10,
81-
})
82-
assert.Nil(t, err)
83-
84-
resp, err := d.CreateVolume(context.Background(), &csi.CreateVolumeRequest{
85-
Name: "foo",
86-
VolumeCapabilities: []*csi.VolumeCapability{
87-
{
88-
AccessMode: &csi.VolumeCapability_AccessMode{
89-
Mode: csi.VolumeCapability_AccessMode_SINGLE_NODE_WRITER,
85+
existingVolume: &civogo.VolumeConfig{
86+
Name: "foo",
87+
SizeGigabytes: 10,
88+
},
89+
expectedError: false,
90+
expectedSizeGB: 10,
91+
},
92+
{
93+
name: "Empty Name",
94+
req: &csi.CreateVolumeRequest{
95+
Name: "",
96+
VolumeCapabilities: []*csi.VolumeCapability{
97+
{
98+
AccessMode: &csi.VolumeCapability_AccessMode{
99+
Mode: csi.VolumeCapability_AccessMode_SINGLE_NODE_WRITER,
100+
},
101+
},
102+
},
103+
},
104+
expectedError: true,
105+
expectedErrorMsg: "CreateVolume Name must be provided",
106+
},
107+
{
108+
name: "Missing VolumeCapabilities",
109+
req: &csi.CreateVolumeRequest{
110+
Name: "foo",
111+
},
112+
expectedError: true,
113+
expectedErrorMsg: "CreateVolume Volume capabilities must be provided",
114+
},
115+
{
116+
name: "Unsupported Access Mode",
117+
req: &csi.CreateVolumeRequest{
118+
Name: "foo",
119+
VolumeCapabilities: []*csi.VolumeCapability{
120+
{
121+
AccessMode: &csi.VolumeCapability_AccessMode{
122+
Mode: csi.VolumeCapability_AccessMode_UNKNOWN,
123+
},
124+
},
125+
},
126+
},
127+
expectedError: true,
128+
expectedErrorMsg: "CreateVolume access mode isn't supported",
129+
},
130+
{
131+
name: "Desired volume capacity exceeding the DiskGigabytesLimit",
132+
req: &csi.CreateVolumeRequest{
133+
Name: "foo",
134+
VolumeCapabilities: []*csi.VolumeCapability{
135+
{
136+
AccessMode: &csi.VolumeCapability_AccessMode{
137+
Mode: csi.VolumeCapability_AccessMode_SINGLE_NODE_WRITER,
138+
},
90139
},
91140
},
141+
CapacityRange: &csi.CapacityRange{
142+
RequiredBytes: 161061273600, // 150GB, DiskGigabytesLimit: 100GB for fakeClient
143+
},
92144
},
145+
expectedError: true,
146+
expectedErrorMsg: "Requested volume would exceed volume space quota by 50 GB",
147+
},
148+
}
149+
150+
for _, tt := range tests {
151+
t.Run(tt.name, func(t *testing.T) {
152+
// Setup driver and environment
153+
d, _ := driver.NewTestDriver(nil)
154+
155+
// Create existing volume if needed
156+
if tt.existingVolume != nil {
157+
volume, err := d.CivoClient.NewVolume(tt.existingVolume)
158+
assert.Nil(t, err)
159+
tt.expectedVolumeID = volume.ID
160+
}
161+
162+
// Call CreateVolume
163+
resp, err := d.CreateVolume(context.Background(), tt.req)
164+
165+
if tt.expectedError {
166+
assert.NotNil(t, err)
167+
assert.Contains(t, err.Error(), tt.expectedErrorMsg)
168+
return
169+
}
170+
171+
assert.Nil(t, err)
172+
assert.NotNil(t, resp)
173+
assert.NotEmpty(t, resp.Volume.VolumeId)
174+
175+
if tt.expectedVolumeID != "" {
176+
assert.Equal(t, tt.expectedVolumeID, resp.Volume.VolumeId)
177+
}
178+
179+
// Validate volume creation
180+
volumes, _ := d.CivoClient.ListVolumes()
181+
assert.Equal(t, 1, len(volumes))
182+
assert.Equal(t, tt.req.Name, volumes[0].Name)
183+
assert.Equal(t, tt.expectedSizeGB, volumes[0].SizeGigabytes)
184+
assert.Equal(t, resp.Volume.VolumeId, volumes[0].ID)
93185
})
94-
assert.Nil(t, err)
95-
96-
assert.Equal(t, volume.ID, resp.Volume.VolumeId)
97-
98-
volumes, _ := d.CivoClient.ListVolumes()
99-
assert.Equal(t, 1, len(volumes))
100-
})
186+
}
101187
}
102188

103189
func TestDeleteVolume(t *testing.T) {
104-
t.Run("Delete a volume", func(t *testing.T) {
105-
d, _ := driver.NewTestDriver(nil)
106-
107-
volume, err := d.CivoClient.NewVolume(&civogo.VolumeConfig{
108-
Name: "foo",
109-
})
110-
assert.Nil(t, err)
111-
112-
_, err = d.DeleteVolume(context.Background(), &csi.DeleteVolumeRequest{
113-
VolumeId: volume.ID,
190+
tests := []struct{
191+
name string
192+
existingVolume *civogo.VolumeConfig
193+
req *csi.DeleteVolumeRequest
194+
expectedError bool
195+
expectedErrorMsg string
196+
}{
197+
{
198+
name: "Delete an existing volume",
199+
existingVolume: &civogo.VolumeConfig{
200+
Name: "civolume",
201+
},
202+
req: &csi.DeleteVolumeRequest{},
203+
expectedError: false,
204+
},
205+
{
206+
name: "Delete a non-existent volume",
207+
req: &csi.DeleteVolumeRequest{
208+
VolumeId: "non-existent-id",
209+
},
210+
expectedError: false, // Non-existance is treated as success
211+
},
212+
{
213+
name: "Delete with empty VolumeId",
214+
req: &csi.DeleteVolumeRequest{VolumeId: ""},
215+
expectedError: true,
216+
expectedErrorMsg: "must provide a VolumeId to DeleteVolume",
217+
},
218+
}
219+
220+
for _, tt := range tests{
221+
t.Run(tt.name, func(t *testing.T) {
222+
d, _ := driver.NewTestDriver(nil)
223+
224+
// setup existing volume if specified
225+
if tt.existingVolume != nil{
226+
v, err := d.CivoClient.NewVolume(tt.existingVolume)
227+
assert.Nil(t, err)
228+
tt.req.VolumeId = v.ID // assign dynamically
229+
}
230+
231+
// Perform the delete operation
232+
_, err := d.DeleteVolume(context.Background(), tt.req)
233+
234+
// validate the error
235+
if tt.expectedError{
236+
assert.NotNil(t, err)
237+
assert.Contains(t, err.Error(), tt.expectedErrorMsg)
238+
}else{
239+
assert.Nil(t, err)
240+
}
241+
242+
// Check remaining volumes
243+
volumes, _ := d.CivoClient.ListVolumes()
244+
assert.Equal(t, 0, len(volumes))
114245
})
115-
assert.Nil(t, err)
116-
117-
volumes, _ := d.CivoClient.ListVolumes()
118-
assert.Equal(t, 0, len(volumes))
119-
})
246+
}
120247
}
121248

122249
func TestControllerPublishVolume(t *testing.T) {

0 commit comments

Comments
 (0)