ruby-libvirt-catphish 0.7.1

Sign up to get free protection for your applications and to get access to all the features.
@@ -0,0 +1,114 @@
1
+ #!/usr/bin/ruby
2
+
3
+ # Test the secret methods the bindings support
4
+
5
+ $: << File.dirname(__FILE__)
6
+
7
+ require 'libvirt'
8
+ require 'test_utils.rb'
9
+
10
+ set_test_object("secret")
11
+
12
+ conn = Libvirt::open("qemu:///system")
13
+
14
+ # TESTGROUP: secret.uuid
15
+ newsecret = conn.define_secret_xml($new_secret_xml)
16
+
17
+ expect_too_many_args(newsecret, "uuid", 1)
18
+
19
+ expect_success(newsecret, "no args", "uuid") {|x| x == $SECRET_UUID}
20
+
21
+ newsecret.undefine
22
+
23
+ # TESTGROUP: secret.usagetype
24
+ newsecret = conn.define_secret_xml($new_secret_xml)
25
+
26
+ expect_too_many_args(newsecret, "usagetype", 1)
27
+
28
+ expect_success(newsecret, "no args", "usagetype") {|x| x == Libvirt::Secret::USAGE_TYPE_VOLUME}
29
+
30
+ newsecret.undefine
31
+
32
+ # TESTGROUP: secret.usageid
33
+ newsecret = conn.define_secret_xml($new_secret_xml)
34
+
35
+ expect_too_many_args(newsecret, "usageid", 1)
36
+
37
+ expect_success(newsecret, "no args", "usageid")
38
+
39
+ newsecret.undefine
40
+
41
+ # TESTGROUP: secret.xml_desc
42
+ newsecret = conn.define_secret_xml($new_secret_xml)
43
+
44
+ expect_too_many_args(newsecret, "xml_desc", 1, 2)
45
+ expect_invalid_arg_type(newsecret, "xml_desc", "foo")
46
+
47
+ expect_success(newsecret, "no args", "xml_desc")
48
+
49
+ newsecret.undefine
50
+
51
+ # TESTGROUP: secret.set_value
52
+ newsecret = conn.define_secret_xml($new_secret_xml)
53
+
54
+ expect_too_many_args(newsecret, "set_value", 1, 2, 3)
55
+ expect_too_few_args(newsecret, "set_value")
56
+ expect_invalid_arg_type(newsecret, "set_value", 1)
57
+ expect_invalid_arg_type(newsecret, "set_value", "foo", "bar")
58
+
59
+ expect_success(newsecret, "value arg", "set_value", "foo")
60
+
61
+ newsecret.undefine
62
+
63
+ # TESTGROUP: secret.value=
64
+ newsecret = conn.define_secret_xml($new_secret_xml)
65
+
66
+ expect_too_many_args(newsecret, "value=", 1, 2)
67
+ expect_too_few_args(newsecret, "value=")
68
+ expect_invalid_arg_type(newsecret, "value=", {})
69
+ expect_invalid_arg_type(newsecret, "value=", nil)
70
+ expect_invalid_arg_type(newsecret, "value=", 1)
71
+ expect_invalid_arg_type(newsecret, "value=", [1, 1])
72
+ expect_invalid_arg_type(newsecret, "value=", [nil, 1])
73
+ expect_invalid_arg_type(newsecret, "value=", [[], 1])
74
+ expect_invalid_arg_type(newsecret, "value=", [{}, 1])
75
+ expect_invalid_arg_type(newsecret, "value=", ['foo', nil])
76
+ expect_invalid_arg_type(newsecret, "value=", ['foo', 'foo'])
77
+ expect_invalid_arg_type(newsecret, "value=", ['foo', []])
78
+ expect_invalid_arg_type(newsecret, "value=", ['foo', {}])
79
+
80
+ expect_success(newsecret, "value arg", "value=", "foo")
81
+
82
+ newsecret.undefine
83
+
84
+ # TESTGROUP: secret.get_value
85
+ newsecret = conn.define_secret_xml($new_secret_xml)
86
+ newsecret.set_value("foo")
87
+
88
+ expect_too_many_args(newsecret, "get_value", 1, 2)
89
+ expect_invalid_arg_type(newsecret, "get_value", 'foo')
90
+
91
+ expect_success(newsecret, "no args", "get_value") {|x| x == 'foo'}
92
+
93
+ newsecret.undefine
94
+
95
+ # TESTGROUP: secret.undefine
96
+ newsecret = conn.define_secret_xml($new_secret_xml)
97
+
98
+ expect_too_many_args(newsecret, "undefine", 1)
99
+
100
+ expect_success(newsecret, "no args", "undefine")
101
+
102
+ # TESTGROUP: secret.free
103
+ newsecret = conn.define_secret_xml($new_secret_xml)
104
+ newsecret.undefine
105
+
106
+ expect_too_many_args(newsecret, "free", 1)
107
+
108
+ expect_success(newsecret, "no args", "free")
109
+
110
+ # END TESTS
111
+
112
+ conn.close
113
+
114
+ finish_tests
@@ -0,0 +1,527 @@
1
+ #!/usr/bin/ruby
2
+
3
+ # Test the storage methods the bindings support
4
+
5
+ $: << File.dirname(__FILE__)
6
+
7
+ require 'libvirt'
8
+ require 'test_utils.rb'
9
+
10
+ set_test_object("storage_pool")
11
+
12
+ conn = Libvirt::open("qemu:///system")
13
+
14
+ begin
15
+ oldpool = conn.lookup_storage_pool_by_name("rb-libvirt-test")
16
+ oldpool.destroy
17
+ oldpool.undefine
18
+ rescue
19
+ # in case we didn't find it, don't do anything
20
+ end
21
+
22
+ # test setup
23
+ `rm -rf #{$POOL_PATH}; mkdir -p #{$POOL_PATH} ; echo $?`
24
+
25
+ new_storage_vol_xml = <<EOF
26
+ <volume>
27
+ <name>test.img</name>
28
+ <allocation>0</allocation>
29
+ <capacity unit="G">1</capacity>
30
+ <target>
31
+ <path>/tmp/rb-libvirt-test/test.img</path>
32
+ </target>
33
+ </volume>
34
+ EOF
35
+
36
+ new_storage_vol_xml_2 = <<EOF
37
+ <volume>
38
+ <name>test2.img</name>
39
+ <allocation>0</allocation>
40
+ <capacity unit="G">5</capacity>
41
+ <target>
42
+ <path>/tmp/rb-libvirt-test/test2.img</path>
43
+ </target>
44
+ </volume>
45
+ EOF
46
+
47
+ # TESTGROUP: vol.pool
48
+ newpool = conn.create_storage_pool_xml($new_storage_pool_xml)
49
+
50
+ newvol = newpool.create_volume_xml(new_storage_vol_xml)
51
+
52
+ expect_too_many_args(newvol, "pool", 1)
53
+
54
+ expect_success(newvol, "no args", "pool")
55
+
56
+ newvol.delete
57
+
58
+ newpool.destroy
59
+
60
+ # TESTGROUP: pool.build
61
+ newpool = conn.define_storage_pool_xml($new_storage_pool_xml)
62
+
63
+ expect_too_many_args(newpool, "build", 1, 2)
64
+ expect_invalid_arg_type(newpool, "build", 'foo')
65
+
66
+ expect_success(newpool, "no args", "build")
67
+
68
+ newpool.undefine
69
+
70
+ # TESTGROUP: pool.undefine
71
+ newpool = conn.define_storage_pool_xml($new_storage_pool_xml)
72
+
73
+ expect_too_many_args(newpool, "undefine", 1)
74
+
75
+ expect_success(newpool, "no args", "undefine")
76
+
77
+ # TESTGROUP: pool.create
78
+ newpool = conn.define_storage_pool_xml($new_storage_pool_xml)
79
+
80
+ expect_too_many_args(newpool, "create", 1, 2)
81
+ expect_invalid_arg_type(newpool, "create", 'foo')
82
+
83
+ expect_success(newpool, "no args", "create")
84
+
85
+ newpool.destroy
86
+ newpool.undefine
87
+
88
+ # TESTGROUP: pool.destroy
89
+ newpool = conn.create_storage_pool_xml($new_storage_pool_xml)
90
+
91
+ expect_too_many_args(newpool, "destroy", 1)
92
+
93
+ expect_success(newpool, "no args", "destroy")
94
+
95
+ # TESTGROUP: pool.delete
96
+ newpool = conn.define_storage_pool_xml($new_storage_pool_xml)
97
+
98
+ expect_too_many_args(newpool, "delete", 1, 2)
99
+ expect_invalid_arg_type(newpool, "delete", 'foo')
100
+
101
+ expect_success(newpool, "no args", "delete")
102
+
103
+ `mkdir -p /tmp/rb-libvirt-test`
104
+
105
+ newpool.undefine
106
+ `mkdir -p #{$POOL_PATH}`
107
+
108
+ # TESTGROUP: pool.refresh
109
+ newpool = conn.create_storage_pool_xml($new_storage_pool_xml)
110
+
111
+ expect_too_many_args(newpool, "refresh", 1, 2)
112
+ expect_invalid_arg_type(newpool, "refresh", 'foo')
113
+
114
+ expect_success(newpool, "no args", "refresh")
115
+
116
+ newpool.destroy
117
+
118
+ # TESTGROUP: pool.name
119
+ newpool = conn.create_storage_pool_xml($new_storage_pool_xml)
120
+
121
+ expect_too_many_args(newpool, "name", 1)
122
+
123
+ expect_success(newpool, "no args", "name") {|x| x == "rb-libvirt-test"}
124
+
125
+ newpool.destroy
126
+
127
+ # TESTGROUP: pool.uuid
128
+ newpool = conn.create_storage_pool_xml($new_storage_pool_xml)
129
+
130
+ expect_too_many_args(newpool, "uuid", 1)
131
+
132
+ expect_success(newpool, "no args", "uuid") {|x| x == $POOL_UUID}
133
+
134
+ newpool.destroy
135
+
136
+ # TESTGROUP: pool.info
137
+ newpool = conn.create_storage_pool_xml($new_storage_pool_xml)
138
+
139
+ expect_too_many_args(newpool, "info", 1)
140
+
141
+ expect_success(newpool, "no args", "info")
142
+
143
+ newpool.destroy
144
+
145
+ # TESTGROUP: pool.xml_desc
146
+ newpool = conn.create_storage_pool_xml($new_storage_pool_xml)
147
+
148
+ expect_too_many_args(newpool, "xml_desc", 1, 2)
149
+ expect_invalid_arg_type(newpool, "xml_desc", "foo")
150
+
151
+ expect_success(newpool, "no args", "xml_desc")
152
+
153
+ newpool.destroy
154
+
155
+ # TESTGROUP: pool.autostart?
156
+ newpool = conn.define_storage_pool_xml($new_storage_pool_xml)
157
+
158
+ expect_too_many_args(newpool, "autostart?", 1)
159
+
160
+ expect_success(newpool, "no args", "autostart?") {|x| x == false}
161
+
162
+ newpool.autostart = true
163
+
164
+ expect_success(newpool, "no args", "autostart?") {|x| x == true}
165
+
166
+ newpool.undefine
167
+
168
+ # TESTGROUP: pool.autostart=
169
+ newpool = conn.define_storage_pool_xml($new_storage_pool_xml)
170
+
171
+ expect_too_many_args(newpool, "autostart=", 1, 2)
172
+ expect_invalid_arg_type(newpool, "autostart=", 'foo')
173
+ expect_invalid_arg_type(newpool, "autostart=", nil)
174
+ expect_invalid_arg_type(newpool, "autostart=", 1234)
175
+
176
+ expect_success(newpool, "no args", "autostart=", true)
177
+ if not newpool.autostart?
178
+ puts_fail "storage_pool.autostart= did not set autostart to true"
179
+ else
180
+ puts_ok "storage_pool.autostart= set autostart to true"
181
+ end
182
+
183
+ expect_success(newpool, "no args", "autostart=", false)
184
+ if newpool.autostart?
185
+ puts_fail "storage_pool.autostart= did not set autostart to false"
186
+ else
187
+ puts_ok "storage_pool.autostart= set autostart to false"
188
+ end
189
+
190
+ newpool.undefine
191
+
192
+ # TESTGROUP: pool.num_of_volumes
193
+ newpool = conn.create_storage_pool_xml($new_storage_pool_xml)
194
+
195
+ expect_too_many_args(newpool, "num_of_volumes", 1)
196
+
197
+ expect_success(newpool, "no args", "num_of_volumes") {|x| x == 0}
198
+
199
+ newpool.destroy
200
+
201
+ # TESTGROUP: pool.list_volumes
202
+ newpool = conn.create_storage_pool_xml($new_storage_pool_xml)
203
+
204
+ expect_too_many_args(newpool, "list_volumes", 1)
205
+
206
+ expect_success(newpool, "no args", "list_volumes")
207
+ newvol = newpool.create_volume_xml(new_storage_vol_xml)
208
+ expect_success(newpool, "no args", "list_volumes")
209
+
210
+ newvol.delete
211
+ newpool.destroy
212
+
213
+ # TESTGROUP: pool.free
214
+ newpool = conn.define_storage_pool_xml($new_storage_pool_xml)
215
+ newpool.undefine
216
+ expect_too_many_args(newpool, "free", 1)
217
+
218
+ expect_success(newpool, "no args", "free")
219
+
220
+ # TESTGROUP: pool.lookup_volume_by_name
221
+ newpool = conn.create_storage_pool_xml($new_storage_pool_xml)
222
+ newvol = newpool.create_volume_xml(new_storage_vol_xml)
223
+
224
+ expect_too_many_args(newpool, "lookup_volume_by_name", 1, 2)
225
+ expect_too_few_args(newpool, "lookup_volume_by_name")
226
+ expect_invalid_arg_type(newpool, "lookup_volume_by_name", 1);
227
+ expect_invalid_arg_type(newpool, "lookup_volume_by_name", nil);
228
+ expect_fail(newpool, Libvirt::RetrieveError, "non-existent name arg", "lookup_volume_by_name", "foobarbazsucker")
229
+
230
+ expect_success(newpool, "name arg", "lookup_volume_by_name", "test.img")
231
+
232
+ newvol.delete
233
+ newpool.destroy
234
+
235
+ # TESTGROUP: pool.lookup_volume_by_key
236
+ newpool = conn.create_storage_pool_xml($new_storage_pool_xml)
237
+ newvol = newpool.create_volume_xml(new_storage_vol_xml)
238
+
239
+ expect_too_many_args(newpool, "lookup_volume_by_key", 1, 2)
240
+ expect_too_few_args(newpool, "lookup_volume_by_key")
241
+ expect_invalid_arg_type(newpool, "lookup_volume_by_key", 1);
242
+ expect_invalid_arg_type(newpool, "lookup_volume_by_key", nil);
243
+ expect_fail(newpool, Libvirt::RetrieveError, "non-existent key arg", "lookup_volume_by_key", "foobarbazsucker")
244
+
245
+ expect_success(newpool, "name arg", "lookup_volume_by_key", newvol.key)
246
+
247
+ newvol.delete
248
+ newpool.destroy
249
+
250
+ # TESTGROUP: pool.lookup_volume_by_path
251
+ newpool = conn.create_storage_pool_xml($new_storage_pool_xml)
252
+ newvol = newpool.create_volume_xml(new_storage_vol_xml)
253
+
254
+ expect_too_many_args(newpool, "lookup_volume_by_path", 1, 2)
255
+ expect_too_few_args(newpool, "lookup_volume_by_path")
256
+ expect_invalid_arg_type(newpool, "lookup_volume_by_path", 1);
257
+ expect_invalid_arg_type(newpool, "lookup_volume_by_path", nil);
258
+ expect_fail(newpool, Libvirt::RetrieveError, "non-existent path arg", "lookup_volume_by_path", "foobarbazsucker")
259
+
260
+ expect_success(newpool, "name arg", "lookup_volume_by_path", newvol.path)
261
+
262
+ newvol.delete
263
+ newpool.destroy
264
+
265
+ # TESTGROUP: pool.create_volume_xml
266
+ newpool = conn.create_storage_pool_xml($new_storage_pool_xml)
267
+
268
+ expect_too_many_args(newpool, "create_volume_xml", new_storage_vol_xml, 0, 1)
269
+ expect_too_few_args(newpool, "create_volume_xml")
270
+ expect_invalid_arg_type(newpool, "create_volume_xml", nil)
271
+ expect_invalid_arg_type(newpool, "create_volume_xml", 1)
272
+ expect_invalid_arg_type(newpool, "create_volume_xml", new_storage_vol_xml, "foo")
273
+ expect_fail(newpool, Libvirt::Error, "invalid xml", "create_volume_xml", "hello")
274
+
275
+ expect_success(newpool, "storage volume XML", "create_volume_xml", new_storage_vol_xml)
276
+
277
+ expect_fail(newpool, Libvirt::Error, "already existing domain", "create_volume_xml", new_storage_vol_xml)
278
+
279
+ newvol.delete
280
+ newpool.destroy
281
+
282
+ # TESTGROUP: pool.create_volume_xml_from
283
+ newpool = conn.create_storage_pool_xml($new_storage_pool_xml)
284
+ newvol = newpool.create_volume_xml(new_storage_vol_xml)
285
+
286
+ expect_too_many_args(newpool, "create_volume_xml_from", new_storage_vol_xml_2, 0, 1, 2)
287
+ expect_too_few_args(newpool, "create_volume_xml_from")
288
+ expect_invalid_arg_type(newpool, "create_volume_xml_from", 1, 2)
289
+ expect_invalid_arg_type(newpool, "create_volume_xml_from", "foo", 2)
290
+ expect_invalid_arg_type(newpool, "create_volume_xml_from", "foo", newvol, "bar")
291
+ expect_fail(newpool, Libvirt::Error, "invalid xml", "create_volume_xml_from", "hello", newvol)
292
+
293
+ newvol2 = expect_success(newpool, "storage volume XML", "create_volume_xml_from", new_storage_vol_xml_2, newvol)
294
+
295
+ expect_fail(newpool, Libvirt::Error, "already existing domain", "create_volume_xml_from", new_storage_vol_xml_2, newvol)
296
+
297
+ newvol2.delete
298
+ newvol.delete
299
+ newpool.destroy
300
+
301
+ # TESTGROUP: pool.active?
302
+ newpool = conn.create_storage_pool_xml($new_storage_pool_xml)
303
+
304
+ expect_too_many_args(newpool, "active?", 1)
305
+
306
+ expect_success(newpool, "no args", "active?") {|x| x == true}
307
+
308
+ newpool.destroy
309
+
310
+ newpool = conn.define_storage_pool_xml($new_storage_pool_xml)
311
+
312
+ expect_success(newpool, "no args", "active?") {|x| x == false}
313
+
314
+ newpool.create
315
+
316
+ expect_success(newpool, "no args", "active?") {|x| x == true}
317
+
318
+ newpool.destroy
319
+ newpool.undefine
320
+
321
+ # TESTGROUP: pool.persistent?
322
+ newpool = conn.create_storage_pool_xml($new_storage_pool_xml)
323
+ sleep 1
324
+
325
+ expect_too_many_args(newpool, "persistent?", 1)
326
+
327
+ expect_success(newpool, "no args", "persistent?") {|x| x == false}
328
+
329
+ newpool.destroy
330
+
331
+ newpool = conn.define_storage_pool_xml($new_storage_pool_xml)
332
+
333
+ expect_success(newpool, "no args", "persistent?") {|x| x == true}
334
+
335
+ newpool.undefine
336
+
337
+ # TESTGROUP:
338
+ newpool = conn.create_storage_pool_xml($new_storage_pool_xml)
339
+ sleep 1
340
+
341
+ expect_too_many_args(newpool, "list_all_volumes", 1, 2)
342
+ expect_invalid_arg_type(newpool, "list_all_volumes", 'foo')
343
+ expect_invalid_arg_type(newpool, "list_all_volumes", [])
344
+ expect_invalid_arg_type(newpool, "list_all_volumes", {})
345
+
346
+ expect_success(newpool, "no args", "list_all_volumes")
347
+
348
+ newpool.destroy
349
+
350
+ set_test_object("storage_volume")
351
+
352
+ # TESTGROUP: vol.name
353
+ newpool = conn.create_storage_pool_xml($new_storage_pool_xml)
354
+ newvol = newpool.create_volume_xml(new_storage_vol_xml)
355
+
356
+ expect_too_many_args(newvol, "name", 1)
357
+
358
+ expect_success(newvol, "no args", "name")
359
+
360
+ newvol.delete
361
+ newpool.destroy
362
+
363
+ # TESTGROUP: vol.key
364
+ newpool = conn.create_storage_pool_xml($new_storage_pool_xml)
365
+ newvol = newpool.create_volume_xml(new_storage_vol_xml)
366
+
367
+ expect_too_many_args(newvol, "key", 1)
368
+
369
+ expect_success(newvol, "no args", "key")
370
+
371
+ newvol.delete
372
+ newpool.destroy
373
+
374
+ # TESTGROUP: vol.delete
375
+ newpool = conn.create_storage_pool_xml($new_storage_pool_xml)
376
+ newvol = newpool.create_volume_xml(new_storage_vol_xml)
377
+
378
+ expect_too_many_args(newvol, "delete", 1, 2)
379
+ expect_invalid_arg_type(newvol, "delete", 'foo')
380
+
381
+ expect_success(newvol, "no args", "delete")
382
+
383
+ newpool.destroy
384
+
385
+ # TESTGROUP: vol.wipe
386
+ newpool = conn.create_storage_pool_xml($new_storage_pool_xml)
387
+ newvol = newpool.create_volume_xml(new_storage_vol_xml)
388
+
389
+ expect_too_many_args(newvol, "wipe", 1, 2)
390
+ expect_invalid_arg_type(newvol, "wipe", 'foo')
391
+
392
+ expect_success(newvol, "no args", "wipe")
393
+
394
+ newvol.delete
395
+ newpool.destroy
396
+
397
+ # TESTGROUP: vol.info
398
+ newpool = conn.create_storage_pool_xml($new_storage_pool_xml)
399
+ newvol = newpool.create_volume_xml(new_storage_vol_xml)
400
+
401
+ expect_too_many_args(newvol, "info", 1)
402
+
403
+ expect_success(newvol, "no args", "info")
404
+
405
+ newvol.delete
406
+ newpool.destroy
407
+
408
+ # TESTGROUP: vol.xml_desc
409
+ newpool = conn.create_storage_pool_xml($new_storage_pool_xml)
410
+ newvol = newpool.create_volume_xml(new_storage_vol_xml)
411
+
412
+ expect_too_many_args(newvol, "xml_desc", 1, 2)
413
+ expect_invalid_arg_type(newvol, "xml_desc", "foo")
414
+
415
+ expect_success(newvol, "no args", "xml_desc")
416
+
417
+ newvol.delete
418
+ newpool.destroy
419
+
420
+ # TESTGROUP: vol.path
421
+ newpool = conn.create_storage_pool_xml($new_storage_pool_xml)
422
+ newvol = newpool.create_volume_xml(new_storage_vol_xml)
423
+
424
+ expect_too_many_args(newvol, "path", 1)
425
+
426
+ expect_success(newvol, "no args", "path")
427
+
428
+ newvol.delete
429
+ newpool.destroy
430
+
431
+ # TESTGROUP: vol.free
432
+ newpool = conn.create_storage_pool_xml($new_storage_pool_xml)
433
+ newvol = newpool.create_volume_xml(new_storage_vol_xml)
434
+ newvol.delete
435
+
436
+ expect_too_many_args(newvol, "free", 1)
437
+
438
+ expect_success(newvol, "no args", "free")
439
+
440
+ newpool.destroy
441
+
442
+ # TESTGROUP: vol.download
443
+ newpool = conn.create_storage_pool_xml($new_storage_pool_xml)
444
+ newvol = newpool.create_volume_xml(new_storage_vol_xml)
445
+ stream = conn.stream
446
+
447
+ expect_too_many_args(newvol, "download", 1, 2, 3, 4, 5)
448
+ expect_too_few_args(newvol, "download")
449
+ expect_too_few_args(newvol, "download", 1)
450
+ expect_too_few_args(newvol, "download", 1, 2)
451
+ expect_invalid_arg_type(newvol, "download", nil, 1, 1)
452
+ expect_invalid_arg_type(newvol, "download", 'foo', 1, 1)
453
+ expect_invalid_arg_type(newvol, "download", 1, 1, 1)
454
+ expect_invalid_arg_type(newvol, "download", [], 1, 1)
455
+ expect_invalid_arg_type(newvol, "download", {}, 1, 1)
456
+ expect_invalid_arg_type(newvol, "download", stream, nil, 1)
457
+ expect_invalid_arg_type(newvol, "download", stream, 'foo', 1)
458
+ expect_invalid_arg_type(newvol, "download", stream, [], 1)
459
+ expect_invalid_arg_type(newvol, "download", stream, {}, 1)
460
+ expect_invalid_arg_type(newvol, "download", stream, 1, nil)
461
+ expect_invalid_arg_type(newvol, "download", stream, 1, 'foo')
462
+ expect_invalid_arg_type(newvol, "download", stream, 1, [])
463
+ expect_invalid_arg_type(newvol, "download", stream, 1, {})
464
+ expect_invalid_arg_type(newvol, "download", stream, 1, 1, 'foo')
465
+ expect_invalid_arg_type(newvol, "download", stream, 1, 1, [])
466
+ expect_invalid_arg_type(newvol, "download", stream, 1, 1, {})
467
+
468
+ expect_success(newvol, "stream, offset, and length args", "download", stream, 0, 10)
469
+
470
+ newvol.delete
471
+ newpool.destroy
472
+
473
+ # TESTGROUP: vol.upload
474
+ newpool = conn.create_storage_pool_xml($new_storage_pool_xml)
475
+ newvol = newpool.create_volume_xml(new_storage_vol_xml)
476
+ stream = conn.stream
477
+
478
+ expect_too_many_args(newvol, "upload", 1, 2, 3, 4, 5)
479
+ expect_too_few_args(newvol, "upload")
480
+ expect_too_few_args(newvol, "upload", 1)
481
+ expect_too_few_args(newvol, "upload", 1, 2)
482
+ expect_invalid_arg_type(newvol, "upload", nil, 1, 1)
483
+ expect_invalid_arg_type(newvol, "upload", 'foo', 1, 1)
484
+ expect_invalid_arg_type(newvol, "upload", 1, 1, 1)
485
+ expect_invalid_arg_type(newvol, "upload", [], 1, 1)
486
+ expect_invalid_arg_type(newvol, "upload", {}, 1, 1)
487
+ expect_invalid_arg_type(newvol, "upload", stream, nil, 1)
488
+ expect_invalid_arg_type(newvol, "upload", stream, 'foo', 1)
489
+ expect_invalid_arg_type(newvol, "upload", stream, [], 1)
490
+ expect_invalid_arg_type(newvol, "upload", stream, {}, 1)
491
+ expect_invalid_arg_type(newvol, "upload", stream, 1, nil)
492
+ expect_invalid_arg_type(newvol, "upload", stream, 1, 'foo')
493
+ expect_invalid_arg_type(newvol, "upload", stream, 1, [])
494
+ expect_invalid_arg_type(newvol, "upload", stream, 1, {})
495
+ expect_invalid_arg_type(newvol, "upload", stream, 1, 1, 'foo')
496
+ expect_invalid_arg_type(newvol, "upload", stream, 1, 1, [])
497
+ expect_invalid_arg_type(newvol, "upload", stream, 1, 1, {})
498
+
499
+ expect_success(newvol, "stream, offset, and length args", "upload", stream, 0, 10)
500
+
501
+ newvol.delete
502
+ newpool.destroy
503
+
504
+ # TESTGROUP: vol.upload
505
+ newpool = conn.create_storage_pool_xml($new_storage_pool_xml)
506
+ newvol = newpool.create_volume_xml(new_storage_vol_xml)
507
+
508
+ expect_too_many_args(newvol, "wipe_pattern", 1, 2, 3)
509
+ expect_too_few_args(newvol, "wipe_pattern")
510
+ expect_invalid_arg_type(newvol, "wipe_pattern", nil)
511
+ expect_invalid_arg_type(newvol, "wipe_pattern", 'foo')
512
+ expect_invalid_arg_type(newvol, "wipe_pattern", [])
513
+ expect_invalid_arg_type(newvol, "wipe_pattern", {})
514
+ expect_invalid_arg_type(newvol, "wipe_pattern", 0, 'foo')
515
+ expect_invalid_arg_type(newvol, "wipe_pattern", 0, [])
516
+ expect_invalid_arg_type(newvol, "wipe_pattern", 0, {})
517
+
518
+ expect_success(newvol, "alg arg", "wipe_pattern", Libvirt::StorageVol::WIPE_ALG_ZERO)
519
+
520
+ newvol.delete
521
+ newpool.destroy
522
+
523
+ # END TESTS
524
+
525
+ conn.close
526
+
527
+ finish_tests