ruby-libvirt-catphish 0.7.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -0,0 +1,818 @@
1
+ #!/usr/bin/ruby
2
+
3
+ # Test the conn methods the bindings support
4
+
5
+ $: << File.dirname(__FILE__)
6
+
7
+ require 'libvirt'
8
+ require 'test_utils.rb'
9
+
10
+ set_test_object("connect")
11
+
12
+ conn = Libvirt::open("qemu:///system")
13
+
14
+ cleanup_test_domain(conn)
15
+ cleanup_test_network(conn)
16
+
17
+ # test setup
18
+ begin
19
+ `rm -f /etc/sysconfig/network-scripts/ifcfg-rb-libvirt-test`
20
+ `brctl delbr rb-libvirt-test >& /dev/null`
21
+ rescue
22
+ end
23
+ `qemu-img create -f qcow2 #{$GUEST_DISK} 5G`
24
+ `rm -rf #{$POOL_PATH}; mkdir #{$POOL_PATH} ; echo $?`
25
+
26
+ cpu_xml = <<EOF
27
+ <cpu>
28
+ <arch>x86_64</arch>
29
+ <model>athlon</model>
30
+ </cpu>
31
+ EOF
32
+
33
+ # TESTGROUP: conn.close
34
+ conn2 = Libvirt::open("qemu:///system")
35
+ expect_too_many_args(conn2, "close", 1)
36
+ expect_success(conn2, "no args", "close")
37
+
38
+ # TESTGROUP: conn.closed?
39
+ conn2 = Libvirt::open("qemu:///system")
40
+
41
+ expect_too_many_args(conn2, "closed?", 1)
42
+ expect_success(conn2, "no args", "closed?") {|x| x == false }
43
+ conn2.close
44
+ expect_success(conn2, "no args", "closed?") {|x| x == true }
45
+
46
+ # TESTGROUP: conn.type
47
+ expect_too_many_args(conn, "type", 1)
48
+
49
+ expect_success(conn, "no args", "type") {|x| x == "QEMU"}
50
+
51
+ # TESTGROUP: conn.version
52
+ expect_too_many_args(conn, "version", 1)
53
+
54
+ expect_success(conn, "no args", "version")
55
+
56
+ # TESTGROUP: conn.libversion
57
+ expect_too_many_args(conn, "libversion", 1)
58
+
59
+ expect_success(conn, "no args", "libversion")
60
+
61
+ # TESTGROUP: conn.hostname
62
+ expect_too_many_args(conn, "hostname", 1)
63
+
64
+ expect_success(conn, "no args", "hostname")
65
+
66
+ # TESTGROUP: conn.uri
67
+ expect_too_many_args(conn, "uri", 1)
68
+
69
+ expect_success(conn, "no args", "uri") {|x| x == "qemu:///system" }
70
+
71
+ # TESTGROUP: conn.max_vcpus
72
+ expect_too_many_args(conn, "max_vcpus", 'kvm', 1)
73
+ expect_fail(conn, Libvirt::RetrieveError, "invalid arg", "max_vcpus", "foo")
74
+
75
+ expect_success(conn, "no args", "max_vcpus")
76
+ expect_success(conn, "nil arg", "max_vcpus")
77
+ expect_success(conn, "kvm arg", "max_vcpus")
78
+ expect_success(conn, "qemu arg", "max_vcpus")
79
+
80
+ # TESTGROUP: conn.node_get_info
81
+ expect_too_many_args(conn, "node_get_info", 1)
82
+
83
+ expect_success(conn, "no args", "node_get_info")
84
+
85
+ # TESTGROUP: conn.node_free_memory
86
+ expect_too_many_args(conn, "node_free_memory", 1)
87
+
88
+ expect_success(conn, "no args", "node_free_memory")
89
+
90
+ # TESTGROUP: conn.node_cells_free_memory
91
+ expect_too_many_args(conn, "node_cells_free_memory", 1, 2, 3)
92
+ expect_invalid_arg_type(conn, "node_cells_free_memory", 'start')
93
+ expect_invalid_arg_type(conn, "node_cells_free_memory", 0, 'end')
94
+
95
+ expect_success(conn, "no args", "node_cells_free_memory")
96
+ expect_success(conn, "start cell", "node_cells_free_memory", 0)
97
+ expect_success(conn, "start cell and max cells", "node_cells_free_memory", 0, 1)
98
+
99
+ # TESTGROUP: conn.node_get_security_model
100
+ expect_too_many_args(conn, "node_get_security_model", 1)
101
+ expect_success(conn, "no args", "node_get_security_model")
102
+
103
+ # TESTGROUP: conn.encrypted?
104
+ expect_too_many_args(conn, "encrypted?", 1)
105
+ expect_success(conn, "no args", "encrypted?")
106
+
107
+ # TESTGROUP: conn.secure?
108
+ expect_too_many_args(conn, "secure?", 1)
109
+ expect_success(conn, "no args", "secure?") {|x| x == true}
110
+
111
+ # TESTGROUP: conn.capabilities
112
+ expect_too_many_args(conn, "capabilities", 1)
113
+ expect_success(conn, "no args", "capabilities")
114
+
115
+ # TESTGROUP: conn.compare_cpu
116
+ expect_too_many_args(conn, "compare_cpu", 1, 2, 3)
117
+ expect_too_few_args(conn, "compare_cpu")
118
+ expect_invalid_arg_type(conn, "compare_cpu", 1)
119
+ expect_invalid_arg_type(conn, "compare_cpu", "hello", 'bar')
120
+ expect_fail(conn, Libvirt::RetrieveError, "invalid XML", "compare_cpu", "hello")
121
+ expect_success(conn, "CPU XML", "compare_cpu", cpu_xml)
122
+
123
+ # TESTGROUP: conn.baseline_cpu
124
+ expect_too_many_args(conn, "baseline_cpu", 1, 2, 3)
125
+ expect_too_few_args(conn, "baseline_cpu")
126
+ expect_invalid_arg_type(conn, "baseline_cpu", 1)
127
+ expect_invalid_arg_type(conn, "baseline_cpu", [cpu_xml], "foo")
128
+ expect_fail(conn, ArgumentError, "empty array", "baseline_cpu", [])
129
+ expect_success(conn, "CPU XML", "baseline_cpu", [cpu_xml])
130
+
131
+ # TESTGROUP: conn.domain_event_register_any
132
+ dom_event_callback_proc = lambda {|connect, dom, event, detail, opaque|
133
+ }
134
+
135
+ # def dom_event_callback_symbol(conn, dom, event, detail, opaque)
136
+ # end
137
+
138
+ expect_too_many_args(conn, "domain_event_register_any", 1, 2, 3, 4, 5)
139
+ expect_too_few_args(conn, "domain_event_register_any")
140
+ expect_too_few_args(conn, "domain_event_register_any", 1)
141
+ expect_invalid_arg_type(conn, "domain_event_register_any", "hello", 1)
142
+ expect_invalid_arg_type(conn, "domain_event_register_any", Libvirt::Connect::DOMAIN_EVENT_ID_LIFECYCLE, 1)
143
+ expect_invalid_arg_type(conn, "domain_event_register_any", Libvirt::Connect::DOMAIN_EVENT_ID_LIFECYCLE, dom_event_callback_proc, 1)
144
+ expect_fail(conn, ArgumentError, "invalid event ID", "domain_event_register_any", 456789, dom_event_callback_proc)
145
+
146
+ # callbackID = expect_success(conn, "eventID and proc", "domain_event_register_any", Libvirt::Connect::DOMAIN_EVENT_ID_LIFECYCLE, dom_event_callback_proc)
147
+ # conn.domain_event_deregister_any(callbackID)
148
+
149
+ # callbackID = expect_success(conn, "eventID and symbol", "domain_event_register_any", Libvirt::Connect::DOMAIN_EVENT_ID_LIFECYCLE, :dom_event_callback_symbol)
150
+ # conn.domain_event_deregister_any(callbackID)
151
+
152
+ # callbackID = expect_success(conn, "eventID, proc, nil domain", "domain_event_register_any", Libvirt::Connect::DOMAIN_EVENT_ID_LIFECYCLE, dom_event_callback_proc, nil)
153
+ # conn.domain_event_deregister_any(callbackID)
154
+
155
+ # callbackID = expect_success(conn, "eventID, proc, nil domain, opaque", "domain_event_register_any", Libvirt::Connect::DOMAIN_EVENT_ID_LIFECYCLE, dom_event_callback_proc, nil, "opaque user data")
156
+ # conn.domain_event_deregister_any(callbackID)
157
+
158
+ # # TESTGROUP: conn.domain_event_deregister_any
159
+ # dom_event_callback_proc = lambda {|conn, dom, event, detail, opaque|
160
+ # }
161
+
162
+ # callbackID = conn.domain_event_register_any(Libvirt::Connect::DOMAIN_EVENT_ID_LIFECYCLE, dom_event_callback_proc)
163
+
164
+ expect_too_many_args(conn, "domain_event_deregister_any", 1, 2)
165
+ expect_too_few_args(conn, "domain_event_deregister_any")
166
+ expect_invalid_arg_type(conn, "domain_event_deregister_any", "hello")
167
+
168
+ # expect_success(conn, "callbackID", "domain_event_deregister_any", callbackID)
169
+
170
+ # TESTGROUP: conn.domain_event_register
171
+ # dom_event_callback_proc = lambda {|conn, dom, event, detail, opaque|
172
+ # }
173
+
174
+ # def dom_event_callback_symbol(conn, dom, event, detail, opaque)
175
+ # end
176
+
177
+ expect_too_many_args(conn, "domain_event_register", 1, 2, 3)
178
+ expect_too_few_args(conn, "domain_event_register")
179
+ expect_invalid_arg_type(conn, "domain_event_register", "hello")
180
+
181
+ # expect_success(conn, "proc", "domain_event_register", dom_event_callback_proc)
182
+ # conn.domain_event_deregister
183
+
184
+ # expect_success(conn, "symbol", "domain_event_register", :dom_event_callback_symbol)
185
+ # conn.domain_event_deregister
186
+
187
+ # expect_success(conn, "proc and opaque", "domain_event_register", dom_event_callback_proc, "opaque user data")
188
+ # conn.domain_event_deregister
189
+
190
+ # # TESTGROUP: conn.domain_event_deregister
191
+ # dom_event_callback_proc = lambda {|conn, dom, event, detail, opaque|
192
+ # }
193
+
194
+ # conn.domain_event_register(dom_event_callback_proc)
195
+
196
+ expect_too_many_args(conn, "domain_event_deregister", 1)
197
+ # expect_success(conn, "no args", "domain_event_deregister")
198
+
199
+ # TESTGROUP: conn.num_of_domains
200
+ expect_too_many_args(conn, "num_of_domains", 1)
201
+ expect_success(conn, "no args", "num_of_domains")
202
+
203
+ # TESTGROUP: conn.list_domains
204
+ expect_too_many_args(conn, "list_domains", 1)
205
+ expect_success(conn, "no args", "list_domains")
206
+
207
+ newdom = conn.create_domain_xml($new_dom_xml)
208
+ sleep 1
209
+
210
+ expect_success(conn, "no args", "list_domains")
211
+
212
+ newdom.destroy
213
+
214
+ # TESTGROUP: conn.num_of_defined_domains
215
+ expect_too_many_args(conn, "num_of_defined_domains", 1)
216
+ expect_success(conn, "no args", "num_of_defined_domains")
217
+
218
+ # TESTGROUP: conn.list_defined_domains
219
+ expect_too_many_args(conn, "list_defined_domains", 1)
220
+ expect_success(conn, "no args", "list_defined_domains")
221
+
222
+ # TESTGROUP: conn.create_domain_linux
223
+ expect_too_many_args(conn, "create_domain_linux", $new_dom_xml, 0, 1)
224
+ expect_too_few_args(conn, "create_domain_linux")
225
+ expect_invalid_arg_type(conn, "create_domain_linux", nil)
226
+ expect_invalid_arg_type(conn, "create_domain_linux", 1)
227
+ expect_invalid_arg_type(conn, "create_domain_linux", $new_dom_xml, "foo")
228
+ expect_fail(conn, Libvirt::Error, "invalid xml", "create_domain_linux", "hello")
229
+ newdom = expect_success(conn, "domain xml", "create_domain_linux", $new_dom_xml) {|x| x.class == Libvirt::Domain}
230
+ sleep 1
231
+
232
+ expect_fail(conn, Libvirt::Error, "already existing domain", "create_domain_linux", $new_dom_xml)
233
+
234
+ newdom.destroy
235
+
236
+ # TESTGROUP: conn.create_domain_xml
237
+ expect_too_many_args(conn, "create_domain_xml", $new_dom_xml, 0, 1)
238
+ expect_too_few_args(conn, "create_domain_xml")
239
+ expect_invalid_arg_type(conn, "create_domain_xml", nil)
240
+ expect_invalid_arg_type(conn, "create_domain_xml", 1)
241
+ expect_invalid_arg_type(conn, "create_domain_xml", $new_dom_xml, "foo")
242
+ expect_fail(conn, Libvirt::Error, "invalid xml", "create_domain_xml", "hello")
243
+ newdom = expect_success(conn, "domain xml", "create_domain_xml", $new_dom_xml) {|x| x.class == Libvirt::Domain}
244
+ sleep 1
245
+
246
+ expect_fail(conn, Libvirt::Error, "already existing domain", "create_domain_xml", $new_dom_xml)
247
+
248
+ newdom.destroy
249
+
250
+ # TESTGROUP: conn.lookup_domain_by_name
251
+ newdom = conn.create_domain_xml($new_dom_xml)
252
+ sleep 1
253
+
254
+ expect_too_many_args(conn, "lookup_domain_by_name", 1, 2)
255
+ expect_too_few_args(conn, "lookup_domain_by_name")
256
+ expect_invalid_arg_type(conn, "lookup_domain_by_name", 1)
257
+ expect_fail(conn, Libvirt::RetrieveError, "non-existent name arg", "lookup_domain_by_name", "foobarbazsucker")
258
+
259
+ expect_success(conn, "name arg for running domain", "lookup_domain_by_name", "rb-libvirt-test") {|x| x.name == "rb-libvirt-test"}
260
+ newdom.destroy
261
+
262
+ newdom = conn.define_domain_xml($new_dom_xml)
263
+ expect_success(conn, "name arg for defined domain", "lookup_domain_by_name", "rb-libvirt-test") {|x| x.name == "rb-libvirt-test"}
264
+ newdom.undefine
265
+
266
+ # TESTGROUP: conn.lookup_domain_by_id
267
+ newdom = conn.create_domain_xml($new_dom_xml)
268
+ sleep 1
269
+
270
+ expect_too_many_args(conn, "lookup_domain_by_id", 1, 2)
271
+ expect_too_few_args(conn, "lookup_domain_by_id")
272
+ expect_invalid_arg_type(conn, "lookup_domain_by_id", "foo")
273
+ expect_fail(conn, Libvirt::Error, "with negative value", "lookup_domain_by_id", -1)
274
+
275
+ expect_success(conn, "id arg for running domain", "lookup_domain_by_id", newdom.id)
276
+ newdom.destroy
277
+
278
+ # TESTGROUP: conn.lookup_domain_by_uuid
279
+ newdom = conn.create_domain_xml($new_dom_xml)
280
+ sleep 1
281
+
282
+ expect_too_many_args(conn, "lookup_domain_by_uuid", 1, 2)
283
+ expect_too_few_args(conn, "lookup_domain_by_uuid")
284
+ expect_invalid_arg_type(conn, "lookup_domain_by_uuid", 1)
285
+ expect_fail(conn, Libvirt::RetrieveError, "invalid UUID", "lookup_domain_by_uuid", "abcd")
286
+
287
+ expect_success(conn, "UUID arg for running domain", "lookup_domain_by_uuid", newdom.uuid) {|x| x.uuid == $GUEST_UUID}
288
+ newdom.destroy
289
+
290
+ newdom = conn.define_domain_xml($new_dom_xml)
291
+ expect_success(conn, "UUID arg for defined domain", "lookup_domain_by_uuid", newdom.uuid) {|x| x.uuid == $GUEST_UUID}
292
+ newdom.undefine
293
+
294
+ # TESTGROUP: conn.define_domain_xml
295
+ expect_too_many_args(conn, "define_domain_xml", 1, 2, 3)
296
+ expect_too_few_args(conn, "define_domain_xml")
297
+ expect_invalid_arg_type(conn, "define_domain_xml", 1)
298
+ expect_invalid_arg_type(conn, "define_domain_xml", nil)
299
+ expect_fail(conn, Libvirt::DefinitionError, "invalid XML", "define_domain_xml", "hello")
300
+
301
+ newdom = expect_success(conn, "domain xml arg", "define_domain_xml", $new_dom_xml)
302
+ newdom.undefine
303
+
304
+ # TESTGROUP: conn.domain_xml_from_native
305
+ expect_too_many_args(conn, "domain_xml_from_native", 1, 2, 3, 4)
306
+ expect_too_few_args(conn, "domain_xml_from_native")
307
+ expect_too_few_args(conn, "domain_xml_from_native", 1)
308
+ expect_invalid_arg_type(conn, "domain_xml_from_native", 1, 2)
309
+ expect_invalid_arg_type(conn, "domain_xml_from_native", nil, 2)
310
+ expect_invalid_arg_type(conn, "domain_xml_from_native", "qemu-argv", 2)
311
+ expect_invalid_arg_type(conn, "domain_xml_from_native", "qemu-argv", nil)
312
+ expect_invalid_arg_type(conn, "domain_xml_from_native", "qemu-argv", "foo", "bar")
313
+ expect_fail(conn, Libvirt::Error, "unsupported first arg", "domain_xml_from_native", "foo", "bar")
314
+
315
+ expect_success(conn, "qemu-argv and qemu_cmd_line", "domain_xml_from_native", "qemu-argv", $qemu_cmd_line)
316
+
317
+ # TESTGROUP: conn.domain_xml_to_native
318
+ expect_too_many_args(conn, "domain_xml_to_native", 1, 2, 3, 4)
319
+ expect_too_few_args(conn, "domain_xml_to_native")
320
+ expect_too_few_args(conn, "domain_xml_to_native", 1)
321
+ expect_invalid_arg_type(conn, "domain_xml_to_native", 1, 2)
322
+ expect_invalid_arg_type(conn, "domain_xml_to_native", nil, 2)
323
+ expect_invalid_arg_type(conn, "domain_xml_to_native", "qemu-argv", 2)
324
+ expect_invalid_arg_type(conn, "domain_xml_to_native", "qemu-argv", nil)
325
+ expect_invalid_arg_type(conn, "domain_xml_to_native", "qemu-argv", "foo", "bar")
326
+ expect_fail(conn, Libvirt::Error, "unsupported first arg", "domain_xml_to_native", "foo", "bar")
327
+
328
+ expect_success(conn, "qemu-argv and domain XML", "domain_xml_to_native", "qemu-argv", $new_dom_xml)
329
+
330
+ # TESTGROUP: conn.num_of_interfaces
331
+ expect_too_many_args(conn, "num_of_interfaces", 1)
332
+ expect_success(conn, "no args", "num_of_interfaces")
333
+
334
+ # TESTGROUP: conn.list_interfaces
335
+ expect_too_many_args(conn, "list_interfaces", 1)
336
+ expect_success(conn, "no args", "list_interfaces")
337
+
338
+ # TESTGROUP: conn.num_of_defined_interfaces
339
+ expect_too_many_args(conn, "num_of_defined_interfaces", 1)
340
+ expect_success(conn, "no args", "num_of_defined_interfaces")
341
+
342
+ # TESTGROUP: conn.list_defined_interfaces
343
+ expect_too_many_args(conn, "list_defined_interfaces", 1)
344
+ expect_success(conn, "no args", "list_defined_interfaces")
345
+
346
+ # TESTGROUP: conn.lookup_interface_by_name
347
+ newiface = conn.define_interface_xml($new_interface_xml)
348
+
349
+ expect_too_many_args(conn, "lookup_interface_by_name", 1, 2)
350
+ expect_too_few_args(conn, "lookup_interface_by_name")
351
+ expect_invalid_arg_type(conn, "lookup_interface_by_name", 1)
352
+ expect_fail(conn, Libvirt::RetrieveError, "non-existent name arg", "lookup_interface_by_name", "foobarbazsucker")
353
+
354
+ expect_success(conn, "name arg", "lookup_interface_by_name", "rb-libvirt-test")
355
+
356
+ expect_success(conn, "name arg", "lookup_interface_by_name", "rb-libvirt-test")
357
+
358
+ newiface.undefine
359
+
360
+ # TESTGROUP: conn.lookup_interface_by_mac
361
+ newiface = conn.define_interface_xml($new_interface_xml)
362
+
363
+ expect_too_many_args(conn, "lookup_interface_by_mac", 1, 2)
364
+ expect_too_few_args(conn, "lookup_interface_by_mac")
365
+ expect_invalid_arg_type(conn, "lookup_interface_by_mac", 1)
366
+ expect_fail(conn, Libvirt::RetrieveError, "non-existent mac arg", "lookup_interface_by_mac", "foobarbazsucker")
367
+
368
+ # FIXME: we can't look up an interface by MAC address on an inactive interface,
369
+ # but we also can't start up the interface without a /etc/sysconfig file.
370
+ #expect_success(conn, "mac arg", "lookup_interface_by_mac", $NEW_INTERFACE_MAC) {|x| x.mac == $NEW_INTERFACE_MAC}
371
+
372
+ newiface.undefine
373
+
374
+ # TESTGROUP: conn.define_interface_xml
375
+ expect_too_many_args(conn, "define_interface_xml", 1, 2, 3)
376
+ expect_too_few_args(conn, "define_interface_xml")
377
+ expect_invalid_arg_type(conn, "define_interface_xml", 1)
378
+ expect_invalid_arg_type(conn, "define_interface_xml", nil)
379
+ expect_invalid_arg_type(conn, "define_interface_xml", "hello", 'foo')
380
+ expect_fail(conn, Libvirt::DefinitionError, "invalid XML", "define_interface_xml", "hello")
381
+
382
+ expect_success(conn, "interface XML", "define_interface_xml", $new_interface_xml)
383
+ newiface.undefine
384
+
385
+ # TESTGROUP: conn.num_of_networks
386
+ expect_too_many_args(conn, "num_of_networks", 1)
387
+ expect_success(conn, "no args", "num_of_networks")
388
+
389
+ # TESTGROUP: conn.list_networks
390
+ expect_too_many_args(conn, "list_networks", 1)
391
+ expect_success(conn, "no args", "list_networks")
392
+
393
+ # TESTGROUP: conn.num_of_defined_networks
394
+ expect_too_many_args(conn, "num_of_defined_networks", 1)
395
+ expect_success(conn, "no args", "num_of_defined_networks")
396
+
397
+ # TESTGROUP: conn.list_defined_networks
398
+ expect_too_many_args(conn, "list_defined_networks", 1)
399
+ expect_success(conn, "no args", "list_defined_networks")
400
+
401
+ # TESTGROUP: conn.lookup_network_by_name
402
+ newnet = conn.create_network_xml($new_net_xml)
403
+
404
+ expect_too_many_args(conn, "lookup_network_by_name", 1, 2)
405
+ expect_too_few_args(conn, "lookup_network_by_name")
406
+ expect_invalid_arg_type(conn, "lookup_network_by_name", 1)
407
+ expect_fail(conn, Libvirt::RetrieveError, "non-existent name arg", "lookup_network_by_name", "foobarbazsucker")
408
+
409
+ expect_success(conn, "name arg", "lookup_network_by_name", "rb-libvirt-test")
410
+ newnet.destroy
411
+
412
+ newnet = conn.define_network_xml($new_net_xml)
413
+ expect_success(conn, "name arg", "lookup_network_by_name", "rb-libvirt-test")
414
+ newnet.undefine
415
+
416
+ # TESTGROUP: conn.lookup_network_by_uuid
417
+ newnet = conn.create_network_xml($new_net_xml)
418
+
419
+ expect_too_many_args(conn, "lookup_network_by_uuid", 1, 2)
420
+ expect_too_few_args(conn, "lookup_network_by_uuid")
421
+ expect_invalid_arg_type(conn, "lookup_network_by_uuid", 1)
422
+ expect_fail(conn, Libvirt::RetrieveError, "non-existent uuid arg", "lookup_network_by_uuid", "foobarbazsucker")
423
+
424
+ expect_success(conn, "uuid arg", "lookup_network_by_uuid", $NETWORK_UUID)
425
+ newnet.destroy
426
+
427
+ newnet = conn.define_network_xml($new_net_xml)
428
+ expect_success(conn, "uuid arg", "lookup_network_by_uuid", $NETWORK_UUID)
429
+ newnet.undefine
430
+
431
+ # TESTGROUP: conn.create_network_xml
432
+ expect_too_many_args(conn, "create_network_xml", $new_net_xml, 0)
433
+ expect_too_few_args(conn, "create_network_xml")
434
+ expect_invalid_arg_type(conn, "create_network_xml", nil)
435
+ expect_invalid_arg_type(conn, "create_network_xml", 1)
436
+ expect_fail(conn, Libvirt::Error, "invalid xml", "create_network_xml", "hello")
437
+
438
+ newnet = expect_success(conn, "network XML", "create_network_xml", $new_net_xml)
439
+
440
+ expect_fail(conn, Libvirt::Error, "already existing network", "create_network_xml", $new_net_xml)
441
+
442
+ newnet.destroy
443
+
444
+ # TESTGROUP: conn.define_network_xml
445
+ expect_too_many_args(conn, "define_network_xml", 1, 2)
446
+ expect_too_few_args(conn, "define_network_xml")
447
+ expect_invalid_arg_type(conn, "define_network_xml", 1)
448
+ expect_invalid_arg_type(conn, "define_network_xml", nil)
449
+ expect_fail(conn, Libvirt::DefinitionError, "invalid XML", "define_network_xml", "hello")
450
+
451
+ newnet = expect_success(conn, "network XML", "define_network_xml", $new_net_xml)
452
+ newnet.undefine
453
+
454
+ # TESTGROUP: conn.num_of_nodedevices
455
+ expect_too_many_args(conn, "num_of_nodedevices", 1, 2, 3)
456
+ expect_invalid_arg_type(conn, "num_of_nodedevices", 1)
457
+ expect_invalid_arg_type(conn, "num_of_nodedevices", 'foo', 'bar')
458
+ expect_success(conn, "no args", "num_of_nodedevices")
459
+
460
+ # TESTGROUP: conn.list_nodedevices
461
+ expect_too_many_args(conn, "list_nodedevices", 1, 2, 3)
462
+ expect_invalid_arg_type(conn, "list_nodedevices", 1)
463
+ expect_invalid_arg_type(conn, "list_nodedevices", 'foo', 'bar')
464
+ expect_success(conn, "no args", "list_nodedevices")
465
+
466
+ # TESTGROUP: conn.lookup_nodedevice_by_name
467
+ testnode = conn.lookup_nodedevice_by_name(conn.list_nodedevices[0])
468
+
469
+ expect_too_many_args(conn, "lookup_nodedevice_by_name", 1, 2)
470
+ expect_too_few_args(conn, "lookup_nodedevice_by_name")
471
+ expect_invalid_arg_type(conn, "lookup_nodedevice_by_name", 1)
472
+ expect_fail(conn, Libvirt::RetrieveError, "non-existent name arg", "lookup_nodedevice_by_name", "foobarbazsucker")
473
+
474
+ expect_success(conn, "name arg", "lookup_nodedevice_by_name", testnode.name)
475
+
476
+ # TESTGROUP: conn.create_nodedevice_xml
477
+ expect_too_many_args(conn, "create_nodedevice_xml", 1, 2, 3)
478
+ expect_too_few_args(conn, "create_nodedevice_xml")
479
+ expect_invalid_arg_type(conn, "create_nodedevice_xml", 1)
480
+ expect_invalid_arg_type(conn, "create_nodedevice_xml", "foo", 'bar')
481
+ expect_fail(conn, Libvirt::Error, "invalid XML", "create_nodedevice_xml", "hello")
482
+
483
+ #expect_success(conn, "nodedevice XML", "create_nodedevice_xml", "<nodedevice/>")
484
+
485
+ # TESTGROUP: conn.num_of_nwfilters
486
+ expect_too_many_args(conn, "num_of_nwfilters", 1)
487
+ expect_success(conn, "no args", "num_of_nwfilters")
488
+
489
+ # TESTGROUP: conn.list_nwfilters
490
+ expect_too_many_args(conn, "list_nwfilters", 1)
491
+ expect_success(conn, "no args", "list_nwfilters")
492
+
493
+ # TESTGROUP: conn.lookup_nwfilter_by_name
494
+ newnw = conn.define_nwfilter_xml($new_nwfilter_xml)
495
+
496
+ expect_too_many_args(conn, "lookup_nwfilter_by_name", 1, 2)
497
+ expect_too_few_args(conn, "lookup_nwfilter_by_name")
498
+ expect_invalid_arg_type(conn, "lookup_nwfilter_by_name", 1)
499
+
500
+ expect_success(conn, "name arg", "lookup_nwfilter_by_name", "rb-libvirt-test")
501
+
502
+ newnw.undefine
503
+
504
+ # TESTGROUP: conn.lookup_nwfilter_by_uuid
505
+ newnw = conn.define_nwfilter_xml($new_nwfilter_xml)
506
+
507
+ expect_too_many_args(conn, "lookup_nwfilter_by_uuid", 1, 2)
508
+ expect_too_few_args(conn, "lookup_nwfilter_by_uuid")
509
+ expect_invalid_arg_type(conn, "lookup_nwfilter_by_uuid", 1)
510
+
511
+ expect_success(conn, "uuid arg", "lookup_nwfilter_by_uuid", $NWFILTER_UUID) {|x| x.uuid == $NWFILTER_UUID}
512
+
513
+ newnw.undefine
514
+
515
+ # TESTGROUP: conn.define_nwfilter_xml
516
+ expect_too_many_args(conn, "define_nwfilter_xml", 1, 2)
517
+ expect_too_few_args(conn, "define_nwfilter_xml")
518
+ expect_invalid_arg_type(conn, "define_nwfilter_xml", 1)
519
+ expect_invalid_arg_type(conn, "define_nwfilter_xml", nil)
520
+ expect_fail(conn, Libvirt::DefinitionError, "invalid XML", "define_nwfilter_xml", "hello")
521
+
522
+ newnw = expect_success(conn, "nwfilter XML", "define_nwfilter_xml", $new_nwfilter_xml)
523
+
524
+ newnw.undefine
525
+
526
+ # TESTGROUP: conn.num_of_secrets
527
+ expect_too_many_args(conn, "num_of_secrets", 1)
528
+ expect_success(conn, "no args", "num_of_secrets")
529
+
530
+ # TESTGROUP: conn.list_secrets
531
+ expect_too_many_args(conn, "list_secrets", 1)
532
+ expect_success(conn, "no args", "list_secrets")
533
+
534
+ # TESTGROUP: conn.lookup_secret_by_uuid
535
+ newsecret = conn.define_secret_xml($new_secret_xml)
536
+
537
+ expect_too_many_args(conn, "lookup_secret_by_uuid", 1, 2)
538
+ expect_too_few_args(conn, "lookup_secret_by_uuid")
539
+ expect_invalid_arg_type(conn, "lookup_secret_by_uuid", 1)
540
+
541
+ expect_success(conn, "uuid arg", "lookup_secret_by_uuid", $SECRET_UUID) {|x| x.uuid == $SECRET_UUID}
542
+
543
+ newsecret.undefine
544
+
545
+ # TESTGROUP: conn.lookup_secret_by_usage
546
+ newsecret = conn.define_secret_xml($new_secret_xml)
547
+
548
+ expect_too_many_args(conn, "lookup_secret_by_usage", 1, 2, 3)
549
+ expect_too_few_args(conn, "lookup_secret_by_usage")
550
+ expect_invalid_arg_type(conn, "lookup_secret_by_usage", 'foo', 1)
551
+ expect_invalid_arg_type(conn, "lookup_secret_by_usage", 1, 2)
552
+ expect_fail(conn, Libvirt::RetrieveError, "invalid secret", "lookup_secret_by_usage", Libvirt::Secret::USAGE_TYPE_VOLUME, "foo")
553
+
554
+ expect_success(conn, "usage type and key", "lookup_secret_by_usage", Libvirt::Secret::USAGE_TYPE_VOLUME, "/var/lib/libvirt/images/mail.img")
555
+
556
+ newsecret.undefine
557
+
558
+ # TESTGROUP: conn.define_secret_xml
559
+ expect_too_many_args(conn, "define_secret_xml", 1, 2, 3)
560
+ expect_too_few_args(conn, "define_secret_xml")
561
+ expect_invalid_arg_type(conn, "define_secret_xml", 1)
562
+ expect_invalid_arg_type(conn, "define_secret_xml", nil)
563
+ expect_invalid_arg_type(conn, "define_secret_xml", "hello", 'foo')
564
+ expect_fail(conn, Libvirt::DefinitionError, "invalid XML", "define_secret_xml", "hello")
565
+
566
+ expect_success(conn, "secret XML", "define_secret_xml", $new_secret_xml)
567
+
568
+ newsecret.undefine
569
+
570
+ # TESTGROUP: conn.list_storage_pools
571
+ expect_too_many_args(conn, "list_storage_pools", 1)
572
+ expect_success(conn, "no args", "list_storage_pools")
573
+
574
+ # TESTGROUP: conn.num_of_storage_pools
575
+ expect_too_many_args(conn, "num_of_storage_pools", 1)
576
+ expect_success(conn, "no args", "num_of_storage_pools")
577
+
578
+ # TESTGROUP: conn.list_defined_storage_pools
579
+ expect_too_many_args(conn, "list_defined_storage_pools", 1)
580
+ expect_success(conn, "no args", "list_defined_storage_pools")
581
+
582
+ # TESTGROUP: conn.num_of_defined_storage_pools
583
+ expect_too_many_args(conn, "num_of_defined_storage_pools", 1)
584
+ expect_success(conn, "no args", "num_of_defined_storage_pools")
585
+
586
+ # TESTGROUP: conn.lookup_storage_pool_by_name
587
+ newpool = conn.create_storage_pool_xml($new_storage_pool_xml)
588
+
589
+ expect_too_many_args(conn, "lookup_storage_pool_by_name", 1, 2)
590
+ expect_too_few_args(conn, "lookup_storage_pool_by_name")
591
+ expect_invalid_arg_type(conn, "lookup_storage_pool_by_name", 1)
592
+ expect_fail(conn, Libvirt::RetrieveError, "non-existent name arg", "lookup_storage_pool_by_name", "foobarbazsucker")
593
+
594
+ expect_success(conn, "name arg", "lookup_storage_pool_by_name", "rb-libvirt-test")
595
+
596
+ newpool.destroy
597
+
598
+ newpool = conn.define_storage_pool_xml($new_storage_pool_xml)
599
+ expect_success(conn, "name arg", "lookup_storage_pool_by_name", "rb-libvirt-test")
600
+ newpool.undefine
601
+
602
+ # TESTGROUP: conn.lookup_storage_pool_by_uuid
603
+ newpool = conn.create_storage_pool_xml($new_storage_pool_xml)
604
+
605
+ expect_too_many_args(conn, "lookup_storage_pool_by_uuid", 1, 2)
606
+ expect_too_few_args(conn, "lookup_storage_pool_by_uuid")
607
+ expect_invalid_arg_type(conn, "lookup_storage_pool_by_uuid", 1)
608
+ expect_fail(conn, Libvirt::RetrieveError, "non-existent uuid arg", "lookup_storage_pool_by_uuid", "foobarbazsucker")
609
+
610
+ expect_success(conn, "uuid arg", "lookup_storage_pool_by_uuid", $POOL_UUID)
611
+
612
+ newpool.destroy
613
+
614
+ newpool = conn.define_storage_pool_xml($new_storage_pool_xml)
615
+
616
+ expect_success(conn, "uuid arg", "lookup_storage_pool_by_uuid", $POOL_UUID)
617
+
618
+ newpool.undefine
619
+
620
+ # TESTGROUP: conn.create_storage_pool_xml
621
+ expect_too_many_args(conn, "create_storage_pool_xml", $new_storage_pool_xml, 0, 1)
622
+ expect_too_few_args(conn, "create_storage_pool_xml")
623
+ expect_invalid_arg_type(conn, "create_storage_pool_xml", nil)
624
+ expect_invalid_arg_type(conn, "create_storage_pool_xml", 1)
625
+ expect_invalid_arg_type(conn, "create_storage_pool_xml", $new_storage_pool_xml, "foo")
626
+ expect_fail(conn, Libvirt::Error, "invalid xml", "create_storage_pool_xml", "hello")
627
+
628
+ expect_success(conn, "storage pool XML", "create_storage_pool_xml", $new_storage_pool_xml)
629
+
630
+ expect_fail(conn, Libvirt::Error, "already existing domain", "create_storage_pool_xml", $new_storage_pool_xml)
631
+
632
+ newpool.destroy
633
+
634
+ # TESTGROUP: conn.define_storage_pool_xml
635
+ expect_too_many_args(conn, "define_storage_pool_xml", $new_storage_pool_xml, 0, 1)
636
+ expect_too_few_args(conn, "define_storage_pool_xml")
637
+ expect_invalid_arg_type(conn, "define_storage_pool_xml", nil)
638
+ expect_invalid_arg_type(conn, "define_storage_pool_xml", 1)
639
+ expect_invalid_arg_type(conn, "define_storage_pool_xml", $new_storage_pool_xml, "foo")
640
+ expect_fail(conn, Libvirt::Error, "invalid xml", "define_storage_pool_xml", "hello")
641
+
642
+ expect_success(conn, "storage pool XML", "define_storage_pool_xml", $new_storage_pool_xml)
643
+
644
+ newpool.undefine
645
+
646
+ # TESTGROUP: conn.discover_storage_pool_sources
647
+ expect_too_many_args(conn, "discover_storage_pool_sources", 1, 2, 3, 4)
648
+ expect_too_few_args(conn, "discover_storage_pool_sources")
649
+ expect_invalid_arg_type(conn, "discover_storage_pool_sources", 1)
650
+ expect_invalid_arg_type(conn, "discover_storage_pool_sources", "foo", 1)
651
+ expect_invalid_arg_type(conn, "discover_storage_pool_sources", "foo", "bar", "baz")
652
+
653
+ expect_fail(conn, Libvirt::Error, "invalid pool type", "discover_storage_pool_sources", "foo")
654
+
655
+ expect_success(conn, "pool type", "discover_storage_pool_sources", "logical")
656
+
657
+ # TESTGROUP: conn.sys_info
658
+ expect_too_many_args(conn, "sys_info", 1, 2)
659
+ expect_invalid_arg_type(conn, "sys_info", "foo")
660
+
661
+ expect_success(conn, "system info", "sys_info")
662
+
663
+ # TESTGROUP: conn.interface_change_begin
664
+ expect_too_many_args(conn, "interface_change_begin", 1, 2)
665
+ expect_invalid_arg_type(conn, "interface_change_begin", 'hello')
666
+
667
+ expect_success(conn, "interface change begin", "interface_change_begin")
668
+
669
+ conn.interface_change_rollback
670
+
671
+ # TESTGROUP: conn.interface_change_commit
672
+ expect_too_many_args(conn, "interface_change_commit", 1, 2)
673
+ expect_invalid_arg_type(conn, "interface_change_commit", 'foo')
674
+
675
+ # FIXME: libvirt throws an error on commit with no changes. What changes can
676
+ # we do here?
677
+ #expect_success(conn, "interface change commit", "interface_change_commit")
678
+
679
+ # TESTGROUP: conn.interface_change_rollback
680
+ conn.interface_change_begin
681
+
682
+ expect_too_many_args(conn, "interface_change_rollback", 1, 2)
683
+ expect_invalid_arg_type(conn, "interface_change_rollback", 'foo')
684
+
685
+ expect_success(conn, "interface change rollback", "interface_change_rollback")
686
+
687
+ # TESTGROUP: conn.node_cpu_stats
688
+ expect_too_many_args(conn, "node_cpu_stats", 1, 2, 3)
689
+ expect_invalid_arg_type(conn, "node_cpu_stats", 'foo')
690
+ expect_invalid_arg_type(conn, "node_cpu_stats", 1, 'bar')
691
+
692
+ expect_success(conn, "node cpu stats", "node_cpu_stats")
693
+
694
+ # TESTGROUP: conn.node_memory_stats
695
+ expect_too_many_args(conn, "node_memory_stats", 1, 2, 3)
696
+ expect_invalid_arg_type(conn, "node_memory_stats", 'foo')
697
+ expect_invalid_arg_type(conn, "node_memory_stats", 1, 'bar')
698
+
699
+ expect_success(conn, "node memory status", "node_memory_stats")
700
+
701
+ # TESTGROUP: conn.save_image_xml_desc
702
+ newdom = conn.define_domain_xml($new_dom_xml)
703
+ newdom.create
704
+ sleep 1
705
+ newdom.save($GUEST_SAVE)
706
+
707
+ expect_too_many_args(conn, "save_image_xml_desc", 1, 2, 3)
708
+ expect_too_few_args(conn, "save_image_xml_desc")
709
+ expect_invalid_arg_type(conn, "save_image_xml_desc", nil)
710
+ expect_invalid_arg_type(conn, "save_image_xml_desc", 1)
711
+ expect_invalid_arg_type(conn, "save_image_xml_desc", 'foo', 'bar')
712
+
713
+ expect_success(conn, "save image path", "save_image_xml_desc", $GUEST_SAVE)
714
+ `rm -f #{$GUEST_SAVE}`
715
+
716
+ # TESTGROUP: conn.define_save_image_xml
717
+ expect_too_many_args(conn, "define_save_image_xml", 1, 2, 3, 4)
718
+ expect_too_few_args(conn, "define_save_image_xml")
719
+ expect_too_few_args(conn, "define_save_image_xml", 'foo')
720
+ expect_invalid_arg_type(conn, "define_save_image_xml", nil, 'foo')
721
+ expect_invalid_arg_type(conn, "define_save_image_xml", 1, 'foo')
722
+ expect_invalid_arg_type(conn, "define_save_image_xml", 'foo', nil)
723
+ expect_invalid_arg_type(conn, "define_save_image_xml", 'foo', 1)
724
+ expect_invalid_arg_type(conn, "define_save_image_xml", 'foo', 'bar', 'baz')
725
+
726
+ # TESTGROUP: conn.alive?
727
+ expect_too_many_args(conn, "alive?", 1)
728
+
729
+ expect_success(conn, "alive connection", "alive?") {|x| x == true}
730
+
731
+ # TESTGROUP: conn.list_all_nwfilters
732
+ expect_too_many_args(conn, "list_all_nwfilters", 1, 2)
733
+ expect_invalid_arg_type(conn, "list_all_nwfilters", "foo")
734
+
735
+ expect_success(conn, "no args", "list_all_nwfilters")
736
+
737
+ # TESTGROUP: conn.list_all_storage_pools
738
+ expect_too_many_args(conn, "list_all_storage_pools", 1, 2)
739
+ expect_invalid_arg_type(conn, "list_all_storage_pools", "foo")
740
+
741
+ expect_success(conn, "no args", "list_all_storage_pools")
742
+
743
+ # TESTGROUP: conn.list_all_nodedevices
744
+ expect_too_many_args(conn, "list_all_nodedevices", 1, 2)
745
+ expect_invalid_arg_type(conn, "list_all_nodedevices", "foo")
746
+
747
+ expect_success(conn, "no args", "list_all_nodedevices")
748
+
749
+ # TESTGROUP: conn.list_all_secrets
750
+ expect_too_many_args(conn, "list_all_secrets", 1, 2)
751
+ expect_invalid_arg_type(conn, "list_all_secrets", "foo")
752
+
753
+ expect_success(conn, "no args", "list_all_secrets")
754
+
755
+ # TESTGROUP: conn.list_all_interfaces
756
+ expect_too_many_args(conn, "list_all_interfaces", 1, 2)
757
+ expect_invalid_arg_type(conn, "list_all_interfaces", "foo")
758
+
759
+ expect_success(conn, "no args", "list_all_interfaces")
760
+
761
+ # TESTGROUP: conn.list_all_networks
762
+ expect_too_many_args(conn, "list_all_networks", 1, 2)
763
+ expect_invalid_arg_type(conn, "list_all_networks", "foo")
764
+
765
+ expect_success(conn, "no args", "list_all_networks")
766
+
767
+ # TESTGROUP: conn.list_all_domains
768
+ expect_too_many_args(conn, "list_all_domains", 1, 2)
769
+ expect_invalid_arg_type(conn, "list_all_domains", "foo")
770
+
771
+ expect_success(conn, "no args", "list_all_domains")
772
+
773
+ # TESTGROUP: conn.set_keepalive
774
+ expect_too_many_args(conn, "set_keepalive", 1, 2, 3, 4)
775
+ expect_too_few_args(conn, "set_keepalive")
776
+ expect_too_few_args(conn, "set_keepalive", 1)
777
+ expect_invalid_arg_type(conn, "set_keepalive", 'foo', 0)
778
+ expect_invalid_arg_type(conn, "set_keepalive", 0, 'foo')
779
+
780
+ # FIXME: somehow we need an event loop implementation for this to work
781
+ #expect_success(conn, "interval and count", "set_keepalive", 1, 10)
782
+
783
+ # TESTGROUP: conn.node_suspend_for_duration
784
+ expect_too_many_args(conn, "node_suspend_for_duration", 1, 2, 3, 4)
785
+ expect_too_few_args(conn, "node_suspend_for_duration")
786
+ expect_too_few_args(conn, "node_suspend_for_duration", 1)
787
+ expect_invalid_arg_type(conn, "node_suspend_for_duration", 'foo', 1)
788
+ expect_invalid_arg_type(conn, "node_suspend_for_duration", 1, 'foo')
789
+ expect_invalid_arg_type(conn, "node_suspend_for_duration", 1, 2, 'foo')
790
+
791
+ # TESTGROUP: conn.node_memory_parameters
792
+ expect_too_many_args(conn, "node_memory_parameters", 1, 2)
793
+ expect_invalid_arg_type(conn, "node_memory_parameters", 'foo')
794
+
795
+ expect_success(conn, "no args", "node_memory_parameters")
796
+
797
+ # TESTGROUP: conn.node_memory_paramters=
798
+ expect_too_many_args(conn, "node_memory_parameters=", 1, 2)
799
+ expect_invalid_arg_type(conn, "node_memory_parameters=", nil)
800
+ expect_invalid_arg_type(conn, "node_memory_parameters=", ['foo', 0])
801
+ expect_invalid_arg_type(conn, "node_memory_parameters=", [{}, 'foo'])
802
+
803
+ # TESTGROUP: conn.keepalive=
804
+ expect_too_many_args(conn, "keepalive=", 1, 2)
805
+ expect_too_few_args(conn, "keepalive=", [])
806
+ expect_too_few_args(conn, "keepalive=", [1])
807
+ expect_invalid_arg_type(conn, "keepalive=", 1)
808
+ expect_invalid_arg_type(conn, "keepalive=", ['foo', 1])
809
+ expect_invalid_arg_type(conn, "keepalive=", [1, 'foo'])
810
+
811
+ # FIXME: somehow we need an event loop implementation for this to work
812
+ #expect_success(conn, "interval and count", "keepalive=", 1, 10)
813
+
814
+ # END TESTS
815
+
816
+ conn.close
817
+
818
+ finish_tests