ruby-libvirt 0.3.0 → 0.4.0

data/ext/libvirt/stream.h

@@ -0,0 +1,7 @@
+#ifndef STREAM_H
+#define STREAM_H
+
+virStreamPtr stream_get(VALUE s);
+void init_stream();
+
+#endif

data/tests/test_conn.rb

@@ -7,6 +7,16 @@ $: << File.dirname(__FILE__)
 require 'libvirt'
 require 'test_utils.rb'
 
+# test setup
+begin
+  `rm -f /etc/sysconfig/network-scripts/ifcfg-ruby-libvirt-tester`
+  `brctl delbr ruby-libvirt-tester >& /dev/null`
+rescue
+end
+`rm -f #{$GUEST_DISK} ; qemu-img create -f qcow2 #{$GUEST_DISK} 5G`
+`rm -f /var/lib/libvirt/images/ruby-libvirt-test.save`
+`rm -rf #{$POOL_PATH}; mkdir #{$POOL_PATH} ; echo $?`
+
 conn = Libvirt::open("qemu:///system")
 
 cpu_xml = <<EOF
@@ -198,6 +208,466 @@ conn.domain_event_register(dom_event_callback_proc)
 expect_too_many_args(conn, "domain_event_deregister", 1)
 expect_success(conn, "no args", "domain_event_deregister")
 
+# TESTGROUP: conn.num_of_domains
+expect_too_many_args(conn, "num_of_domains", 1)
+expect_success(conn, "no args", "num_of_domains")
+
+# TESTGROUP: conn.list_domains
+expect_too_many_args(conn, "list_domains", 1)
+expect_success(conn, "no args", "list_domains")
+
+# TESTGROUP: conn.num_of_defined_domains
+expect_too_many_args(conn, "num_of_defined_domains", 1)
+expect_success(conn, "no args", "num_of_defined_domains")
+
+# TESTGROUP: conn.list_defined_domains
+expect_too_many_args(conn, "list_defined_domains", 1)
+expect_success(conn, "no args", "list_defined_domains")
+
+# TESTGROUP: conn.create_domain_linux
+expect_too_many_args(conn, "create_domain_linux", $new_dom_xml, 0, 1)
+expect_too_few_args(conn, "create_domain_linux")
+expect_invalid_arg_type(conn, "create_domain_linux", nil)
+expect_invalid_arg_type(conn, "create_domain_linux", 1)
+expect_invalid_arg_type(conn, "create_domain_linux", $new_dom_xml, "foo")
+expect_fail(conn, Libvirt::Error, "invalid xml", "create_domain_linux", "hello")
+newdom = expect_success(conn, "domain xml", "create_domain_linux", $new_dom_xml) {|x| x.class == Libvirt::Domain}
+sleep 1
+
+expect_fail(conn, Libvirt::Error, "already existing domain", "create_domain_linux", $new_dom_xml)
+
+newdom.destroy
+
+# TESTGROUP: conn.create_domain_xml
+expect_too_many_args(conn, "create_domain_xml", $new_dom_xml, 0, 1)
+expect_too_few_args(conn, "create_domain_xml")
+expect_invalid_arg_type(conn, "create_domain_xml", nil)
+expect_invalid_arg_type(conn, "create_domain_xml", 1)
+expect_invalid_arg_type(conn, "create_domain_xml", $new_dom_xml, "foo")
+expect_fail(conn, Libvirt::Error, "invalid xml", "create_domain_xml", "hello")
+newdom = expect_success(conn, "domain xml", "create_domain_xml", $new_dom_xml) {|x| x.class == Libvirt::Domain}
+sleep 1
+
+expect_fail(conn, Libvirt::Error, "already existing domain", "create_domain_xml", $new_dom_xml)
+
+newdom.destroy
+
+# TESTGROUP: conn.lookup_domain_by_name
+newdom = conn.create_domain_xml($new_dom_xml)
+sleep 1
+
+expect_too_many_args(conn, "lookup_domain_by_name", 1, 2)
+expect_too_few_args(conn, "lookup_domain_by_name")
+expect_invalid_arg_type(conn, "lookup_domain_by_name", 1)
+expect_fail(conn, Libvirt::RetrieveError, "non-existent name arg", "lookup_domain_by_name", "foobarbazsucker")
+
+expect_success(conn, "name arg for running domain", "lookup_domain_by_name", "ruby-libvirt-tester") {|x| x.name == "ruby-libvirt-tester"}
+newdom.destroy
+
+newdom = conn.define_domain_xml($new_dom_xml)
+expect_success(conn, "name arg for defined domain", "lookup_domain_by_name", "ruby-libvirt-tester") {|x| x.name == "ruby-libvirt-tester"}
+newdom.undefine
+
+# TESTGROUP: conn.lookup_domain_by_id
+newdom = conn.create_domain_xml($new_dom_xml)
+sleep 1
+
+expect_too_many_args(conn, "lookup_domain_by_id", 1, 2)
+expect_too_few_args(conn, "lookup_domain_by_id")
+expect_invalid_arg_type(conn, "lookup_domain_by_id", "foo")
+expect_fail(conn, Libvirt::Error, "with negative value", "lookup_domain_by_id", -1)
+
+expect_success(conn, "id arg for running domain", "lookup_domain_by_id", newdom.id)
+newdom.destroy
+
+# TESTGROUP: conn.lookup_domain_by_uuid
+newdom = conn.create_domain_xml($new_dom_xml)
+sleep 1
+
+expect_too_many_args(conn, "lookup_domain_by_uuid", 1, 2)
+expect_too_few_args(conn, "lookup_domain_by_uuid")
+expect_invalid_arg_type(conn, "lookup_domain_by_uuid", 1)
+expect_fail(conn, Libvirt::RetrieveError, "invalid UUID", "lookup_domain_by_uuid", "abcd")
+
+expect_success(conn, "UUID arg for running domain", "lookup_domain_by_uuid", newdom.uuid) {|x| x.uuid == $GUEST_UUID}
+newdom.destroy
+
+newdom = conn.define_domain_xml($new_dom_xml)
+expect_success(conn, "UUID arg for defined domain", "lookup_domain_by_uuid", newdom.uuid) {|x| x.uuid == $GUEST_UUID}
+newdom.undefine
+
+# TESTGROUP: conn.define_domain_xml
+expect_too_many_args(conn, "define_domain_xml", 1, 2)
+expect_too_few_args(conn, "define_domain_xml")
+expect_invalid_arg_type(conn, "define_domain_xml", 1)
+expect_invalid_arg_type(conn, "define_domain_xml", nil)
+expect_fail(conn, Libvirt::DefinitionError, "invalid XML", "define_domain_xml", "hello")
+
+newdom = expect_success(conn, "domain xml arg", "define_domain_xml", $new_dom_xml)
+newdom.undefine
+
+# TESTGROUP: conn.domain_xml_from_native
+expect_too_many_args(conn, "domain_xml_from_native", 1, 2, 3, 4)
+expect_too_few_args(conn, "domain_xml_from_native")
+expect_too_few_args(conn, "domain_xml_from_native", 1)
+expect_invalid_arg_type(conn, "domain_xml_from_native", 1, 2)
+expect_invalid_arg_type(conn, "domain_xml_from_native", nil, 2)
+expect_invalid_arg_type(conn, "domain_xml_from_native", "qemu-argv", 2)
+expect_invalid_arg_type(conn, "domain_xml_from_native", "qemu-argv", nil)
+expect_invalid_arg_type(conn, "domain_xml_from_native", "qemu-argv", "foo", "bar")
+expect_fail(conn, Libvirt::Error, "unsupported first arg", "domain_xml_from_native", "foo", "bar")
+
+expect_success(conn, "qemu-argv and qemu_cmd_line", "domain_xml_from_native", "qemu-argv", $qemu_cmd_line)
+
+# TESTGROUP: conn.domain_xml_to_native
+expect_too_many_args(conn, "domain_xml_to_native", 1, 2, 3, 4)
+expect_too_few_args(conn, "domain_xml_to_native")
+expect_too_few_args(conn, "domain_xml_to_native", 1)
+expect_invalid_arg_type(conn, "domain_xml_to_native", 1, 2)
+expect_invalid_arg_type(conn, "domain_xml_to_native", nil, 2)
+expect_invalid_arg_type(conn, "domain_xml_to_native", "qemu-argv", 2)
+expect_invalid_arg_type(conn, "domain_xml_to_native", "qemu-argv", nil)
+expect_invalid_arg_type(conn, "domain_xml_to_native", "qemu-argv", "foo", "bar")
+expect_fail(conn, Libvirt::Error, "unsupported first arg", "domain_xml_to_native", "foo", "bar")
+
+expect_success(conn, "qemu-argv and domain XML", "domain_xml_to_native", "qemu-argv", $new_dom_xml)
+
+# TESTGROUP: conn.num_of_interfaces
+expect_too_many_args(conn, "num_of_interfaces", 1)
+expect_success(conn, "no args", "num_of_interfaces")
+
+# TESTGROUP: conn.list_interfaces
+expect_too_many_args(conn, "list_interfaces", 1)
+expect_success(conn, "no args", "list_interfaces")
+
+# TESTGROUP: conn.num_of_defined_interfaces
+expect_too_many_args(conn, "num_of_defined_interfaces", 1)
+expect_success(conn, "no args", "num_of_defined_interfaces")
+
+# TESTGROUP: conn.list_defined_interfaces
+expect_too_many_args(conn, "list_defined_interfaces", 1)
+expect_success(conn, "no args", "list_defined_interfaces")
+
+# TESTGROUP: conn.lookup_interface_by_name
+newiface = conn.define_interface_xml($new_interface_xml)
+
+expect_too_many_args(conn, "lookup_interface_by_name", 1, 2)
+expect_too_few_args(conn, "lookup_interface_by_name")
+expect_invalid_arg_type(conn, "lookup_interface_by_name", 1)
+expect_fail(conn, Libvirt::RetrieveError, "non-existent name arg", "lookup_interface_by_name", "foobarbazsucker")
+
+expect_success(conn, "name arg", "lookup_interface_by_name", "ruby-libvirt-tester")
+
+newiface.destroy
+
+expect_success(conn, "name arg", "lookup_interface_by_name", "ruby-libvirt-tester")
+
+newiface.undefine
+
+# TESTGROUP: conn.lookup_interface_by_mac
+newiface = conn.define_interface_xml($new_interface_xml)
+
+expect_too_many_args(conn, "lookup_interface_by_mac", 1, 2)
+expect_too_few_args(conn, "lookup_interface_by_mac")
+expect_invalid_arg_type(conn, "lookup_interface_by_mac", 1)
+expect_fail(conn, Libvirt::RetrieveError, "non-existent mac arg", "lookup_interface_by_mac", "foobarbazsucker")
+
+testiface = find_valid_iface(conn)
+if not testiface.nil?
+  expect_success(conn, "name arg", "lookup_interface_by_mac", testiface.mac) {|x| x.mac == testiface.mac}
+end
+
+newiface.undefine
+
+# TESTGROUP: conn.define_interface_xml
+expect_too_many_args(conn, "define_interface_xml", 1, 2, 3)
+expect_too_few_args(conn, "define_interface_xml")
+expect_invalid_arg_type(conn, "define_interface_xml", 1)
+expect_invalid_arg_type(conn, "define_interface_xml", nil)
+expect_invalid_arg_type(conn, "define_interface_xml", "hello", 'foo')
+expect_fail(conn, Libvirt::DefinitionError, "invalid XML", "define_interface_xml", "hello")
+
+expect_success(conn, "interface XML", "define_interface_xml", $new_interface_xml)
+newiface.undefine
+
+# TESTGROUP: conn.num_of_networks
+expect_too_many_args(conn, "num_of_networks", 1)
+expect_success(conn, "no args", "num_of_networks")
+
+# TESTGROUP: conn.list_networks
+expect_too_many_args(conn, "list_networks", 1)
+expect_success(conn, "no args", "list_networks")
+
+# TESTGROUP: conn.num_of_defined_networks
+expect_too_many_args(conn, "num_of_defined_networks", 1)
+expect_success(conn, "no args", "num_of_defined_networks")
+
+# TESTGROUP: conn.list_defined_networks
+expect_too_many_args(conn, "list_defined_networks", 1)
+expect_success(conn, "no args", "list_defined_networks")
+
+# TESTGROUP: conn.lookup_network_by_name
+newnet = conn.create_network_xml($new_net_xml)
+
+expect_too_many_args(conn, "lookup_network_by_name", 1, 2)
+expect_too_few_args(conn, "lookup_network_by_name")
+expect_invalid_arg_type(conn, "lookup_network_by_name", 1)
+expect_fail(conn, Libvirt::RetrieveError, "non-existent name arg", "lookup_network_by_name", "foobarbazsucker")
+
+expect_success(conn, "name arg", "lookup_network_by_name", "ruby-libvirt-tester")
+newnet.destroy
+
+newnet = conn.define_network_xml($new_net_xml)
+expect_success(conn, "name arg", "lookup_network_by_name", "ruby-libvirt-tester")
+newnet.undefine
+
+# TESTGROUP: conn.lookup_network_by_uuid
+newnet = conn.create_network_xml($new_net_xml)
+
+expect_too_many_args(conn, "lookup_network_by_uuid", 1, 2)
+expect_too_few_args(conn, "lookup_network_by_uuid")
+expect_invalid_arg_type(conn, "lookup_network_by_uuid", 1)
+expect_fail(conn, Libvirt::RetrieveError, "non-existent uuid arg", "lookup_network_by_uuid", "foobarbazsucker")
+
+expect_success(conn, "uuid arg", "lookup_network_by_uuid", $NETWORK_UUID)
+newnet.destroy
+
+newnet = conn.define_network_xml($new_net_xml)
+expect_success(conn, "uuid arg", "lookup_network_by_uuid", $NETWORK_UUID)
+newnet.undefine
+
+# TESTGROUP: conn.create_network_xml
+expect_too_many_args(conn, "create_network_xml", $new_net_xml, 0)
+expect_too_few_args(conn, "create_network_xml")
+expect_invalid_arg_type(conn, "create_network_xml", nil)
+expect_invalid_arg_type(conn, "create_network_xml", 1)
+expect_fail(conn, Libvirt::Error, "invalid xml", "create_network_xml", "hello")
+
+newnet = expect_success(conn, "network XML", "create_network_xml", $new_net_xml)
+
+expect_fail(conn, Libvirt::Error, "already existing network", "create_network_xml", $new_net_xml)
+
+newnet.destroy
+
+# TESTGROUP: conn.define_network_xml
+expect_too_many_args(conn, "define_network_xml", 1, 2)
+expect_too_few_args(conn, "define_network_xml")
+expect_invalid_arg_type(conn, "define_network_xml", 1)
+expect_invalid_arg_type(conn, "define_network_xml", nil)
+expect_fail(conn, Libvirt::DefinitionError, "invalid XML", "define_network_xml", "hello")
+
+newnet = expect_success(conn, "network XML", "define_network_xml", $new_net_xml)
+newnet.undefine
+
+# TESTGROUP: conn.num_of_nodedevices
+expect_too_many_args(conn, "num_of_nodedevices", 1, 2, 3)
+expect_invalid_arg_type(conn, "num_of_nodedevices", 1)
+expect_invalid_arg_type(conn, "num_of_nodedevices", 'foo', 'bar')
+expect_success(conn, "no args", "num_of_nodedevices")
+
+# TESTGROUP: conn.list_nodedevices
+expect_too_many_args(conn, "list_nodedevices", 1, 2, 3)
+expect_invalid_arg_type(conn, "list_nodedevices", 1)
+expect_invalid_arg_type(conn, "list_nodedevices", 'foo', 'bar')
+expect_success(conn, "no args", "list_nodedevices")
+
+# TESTGROUP: conn.lookup_nodedevice_by_name
+testnode = conn.lookup_nodedevice_by_name(conn.list_nodedevices[0])
+
+expect_too_many_args(conn, "lookup_nodedevice_by_name", 1, 2)
+expect_too_few_args(conn, "lookup_nodedevice_by_name")
+expect_invalid_arg_type(conn, "lookup_nodedevice_by_name", 1)
+expect_fail(conn, Libvirt::RetrieveError, "non-existent name arg", "lookup_nodedevice_by_name", "foobarbazsucker")
+
+expect_success(conn, "name arg", "lookup_nodedevice_by_name", testnode.name)
+
+# TESTGROUP: conn.create_nodedevice_xml
+expect_too_many_args(conn, "create_nodedevice_xml", 1, 2, 3)
+expect_too_few_args(conn, "create_nodedevice_xml")
+expect_invalid_arg_type(conn, "create_nodedevice_xml", 1)
+expect_invalid_arg_type(conn, "create_nodedevice_xml", "foo", 'bar')
+expect_fail(conn, Libvirt::Error, "invalid XML", "create_nodedevice_xml", "hello")
+
+#expect_success(conn, "nodedevice XML", "create_nodedevice_xml", "<nodedevice/>")
+
+# TESTGROUP: conn.num_of_nwfilters
+expect_too_many_args(conn, "num_of_nwfilters", 1)
+expect_success(conn, "no args", "num_of_nwfilters")
+
+# TESTGROUP: conn.list_nwfilters
+expect_too_many_args(conn, "list_nwfilters", 1)
+expect_success(conn, "no args", "list_nwfilters")
+
+# TESTGROUP: conn.lookup_nwfilter_by_name
+newnw = conn.define_nwfilter_xml($new_nwfilter_xml)
+
+expect_too_many_args(conn, "lookup_nwfilter_by_name", 1, 2)
+expect_too_few_args(conn, "lookup_nwfilter_by_name")
+expect_invalid_arg_type(conn, "lookup_nwfilter_by_name", 1)
+
+expect_success(conn, "name arg", "lookup_nwfilter_by_name", "ruby-libvirt-tester")
+
+newnw.undefine
+
+# TESTGROUP: conn.lookup_nwfilter_by_uuid
+newnw = conn.define_nwfilter_xml($new_nwfilter_xml)
+
+expect_too_many_args(conn, "lookup_nwfilter_by_uuid", 1, 2)
+expect_too_few_args(conn, "lookup_nwfilter_by_uuid")
+expect_invalid_arg_type(conn, "lookup_nwfilter_by_uuid", 1)
+
+expect_success(conn, "uuid arg", "lookup_nwfilter_by_uuid", $NWFILTER_UUID) {|x| x.uuid == $NWFILTER_UUID}
+
+newnw.undefine
+
+# TESTGROUP: conn.define_nwfilter_xml
+expect_too_many_args(conn, "define_nwfilter_xml", 1, 2)
+expect_too_few_args(conn, "define_nwfilter_xml")
+expect_invalid_arg_type(conn, "define_nwfilter_xml", 1)
+expect_invalid_arg_type(conn, "define_nwfilter_xml", nil)
+expect_fail(conn, Libvirt::DefinitionError, "invalid XML", "define_nwfilter_xml", "hello")
+
+newnw = expect_success(conn, "nwfilter XML", "define_nwfilter_xml", $new_nwfilter_xml)
+
+newnw.undefine
+
+# TESTGROUP: conn.num_of_secrets
+expect_too_many_args(conn, "num_of_secrets", 1)
+expect_success(conn, "no args", "num_of_secrets")
+
+# TESTGROUP: conn.list_secrets
+expect_too_many_args(conn, "list_secrets", 1)
+expect_success(conn, "no args", "list_secrets")
+
+# TESTGROUP: conn.lookup_secret_by_uuid
+newsecret = conn.define_secret_xml($new_secret_xml)
+
+expect_too_many_args(conn, "lookup_secret_by_uuid", 1, 2)
+expect_too_few_args(conn, "lookup_secret_by_uuid")
+expect_invalid_arg_type(conn, "lookup_secret_by_uuid", 1)
+
+expect_success(conn, "uuid arg", "lookup_secret_by_uuid", $SECRET_UUID) {|x| x.uuid == $SECRET_UUID}
+
+newsecret.undefine
+
+# TESTGROUP: conn.lookup_secret_by_usage
+newsecret = conn.define_secret_xml($new_secret_xml)
+
+expect_too_many_args(conn, "lookup_secret_by_usage", 1, 2, 3)
+expect_too_few_args(conn, "lookup_secret_by_usage")
+expect_invalid_arg_type(conn, "lookup_secret_by_usage", 'foo', 1)
+expect_invalid_arg_type(conn, "lookup_secret_by_usage", 1, 2)
+expect_fail(conn, Libvirt::RetrieveError, "invalid secret", "lookup_secret_by_usage", Libvirt::Secret::USAGE_TYPE_VOLUME, "foo")
+
+expect_success(conn, "usage type and key", "lookup_secret_by_usage", Libvirt::Secret::USAGE_TYPE_VOLUME, "/var/lib/libvirt/images/mail.img")
+
+newsecret.undefine
+
+# TESTGROUP: conn.define_secret_xml
+expect_too_many_args(conn, "define_secret_xml", 1, 2, 3)
+expect_too_few_args(conn, "define_secret_xml")
+expect_invalid_arg_type(conn, "define_secret_xml", 1)
+expect_invalid_arg_type(conn, "define_secret_xml", nil)
+expect_invalid_arg_type(conn, "define_secret_xml", "hello", 'foo')
+expect_fail(conn, Libvirt::DefinitionError, "invalid XML", "define_secret_xml", "hello")
+
+expect_success(conn, "secret XML", "define_secret_xml", $new_secret_xml)
+
+newsecret.undefine
+
+# TESTGROUP: conn.list_storage_pools
+expect_too_many_args(conn, "list_storage_pools", 1)
+expect_success(conn, "no args", "list_storage_pools")
+
+# TESTGROUP: conn.num_of_storage_pools
+expect_too_many_args(conn, "num_of_storage_pools", 1)
+expect_success(conn, "no args", "num_of_storage_pools")
+
+# TESTGROUP: conn.list_defined_storage_pools
+expect_too_many_args(conn, "list_defined_storage_pools", 1)
+expect_success(conn, "no args", "list_defined_storage_pools")
+
+# TESTGROUP: conn.num_of_defined_storage_pools
+expect_too_many_args(conn, "num_of_defined_storage_pools", 1)
+expect_success(conn, "no args", "num_of_defined_storage_pools")
+
+# TESTGROUP: conn.lookup_storage_pool_by_name
+newpool = conn.create_storage_pool_xml($new_storage_pool_xml)
+
+expect_too_many_args(conn, "lookup_storage_pool_by_name", 1, 2)
+expect_too_few_args(conn, "lookup_storage_pool_by_name")
+expect_invalid_arg_type(conn, "lookup_storage_pool_by_name", 1)
+expect_fail(conn, Libvirt::RetrieveError, "non-existent name arg", "lookup_storage_pool_by_name", "foobarbazsucker")
+
+expect_success(conn, "name arg", "lookup_storage_pool_by_name", "ruby-libvirt-tester")
+
+newpool.destroy
+
+newpool = conn.define_storage_pool_xml($new_storage_pool_xml)
+expect_success(conn, "name arg", "lookup_storage_pool_by_name", "ruby-libvirt-tester")
+newpool.undefine
+
+# TESTGROUP: conn.lookup_storage_pool_by_uuid
+newpool = conn.create_storage_pool_xml($new_storage_pool_xml)
+
+expect_too_many_args(conn, "lookup_storage_pool_by_uuid", 1, 2)
+expect_too_few_args(conn, "lookup_storage_pool_by_uuid")
+expect_invalid_arg_type(conn, "lookup_storage_pool_by_uuid", 1)
+expect_fail(conn, Libvirt::RetrieveError, "non-existent uuid arg", "lookup_storage_pool_by_uuid", "foobarbazsucker")
+
+expect_success(conn, "uuid arg", "lookup_storage_pool_by_uuid", $POOL_UUID)
+
+newpool.destroy
+
+newpool = conn.define_storage_pool_xml($new_storage_pool_xml)
+
+expect_success(conn, "uuid arg", "lookup_storage_pool_by_uuid", $POOL_UUID)
+
+newpool.undefine
+
+# TESTGROUP: conn.create_storage_pool_xml
+expect_too_many_args(conn, "create_storage_pool_xml", $new_storage_pool_xml, 0, 1)
+expect_too_few_args(conn, "create_storage_pool_xml")
+expect_invalid_arg_type(conn, "create_storage_pool_xml", nil)
+expect_invalid_arg_type(conn, "create_storage_pool_xml", 1)
+expect_invalid_arg_type(conn, "create_storage_pool_xml", $new_storage_pool_xml, "foo")
+expect_fail(conn, Libvirt::Error, "invalid xml", "create_storage_pool_xml", "hello")
+
+expect_success(conn, "storage pool XML", "create_storage_pool_xml", $new_storage_pool_xml)
+
+expect_fail(conn, Libvirt::Error, "already existing domain", "create_storage_pool_xml", $new_storage_pool_xml)
+
+newpool.destroy
+
+# TESTGROUP: conn.define_storage_pool_xml
+expect_too_many_args(conn, "define_storage_pool_xml", $new_storage_pool_xml, 0, 1)
+expect_too_few_args(conn, "define_storage_pool_xml")
+expect_invalid_arg_type(conn, "define_storage_pool_xml", nil)
+expect_invalid_arg_type(conn, "define_storage_pool_xml", 1)
+expect_invalid_arg_type(conn, "define_storage_pool_xml", $new_storage_pool_xml, "foo")
+expect_fail(conn, Libvirt::Error, "invalid xml", "define_storage_pool_xml", "hello")
+
+expect_success(conn, "storage pool XML", "define_storage_pool_xml", $new_storage_pool_xml)
+
+newpool.undefine
+
+# TESTGROUP: conn.discover_storage_pool_sources
+expect_too_many_args(conn, "discover_storage_pool_sources", 1, 2, 3, 4)
+expect_too_few_args(conn, "discover_storage_pool_sources")
+expect_invalid_arg_type(conn, "discover_storage_pool_sources", 1)
+expect_invalid_arg_type(conn, "discover_storage_pool_sources", "foo", 1)
+expect_invalid_arg_type(conn, "discover_storage_pool_sources", "foo", "bar", "baz")
+
+expect_fail(conn, Libvirt::Error, "invalid pool type", "discover_storage_pool_sources", "foo")
+
+expect_success(conn, "pool type", "discover_storage_pool_sources", "logical")
+
+# TESTGROUP: conn.sys_info
+expect_too_many_args(conn, "sys_info", 1, 2)
+expect_invalid_arg_type(conn, "sys_info", "foo")
+
+expect_success(conn, "system info", "sys_info")
+
 conn.close
 
 finish_tests