ruby-libvirt 0.8.1 → 0.8.3

data/ext/libvirt/nodedevice.c

@@ -260,6 +260,7 @@ static VALUE libvirt_nodedevice_lookup_scsi_host_by_wwn(int argc, VALUE *argv,
 void ruby_libvirt_nodedevice_init(void)
 {
     c_nodedevice = rb_define_class_under(m_libvirt, "NodeDevice", rb_cObject);
+    rb_undef_alloc_func(c_nodedevice);
 
     rb_define_attr(c_nodedevice, "connection", 1, 0);
 

data/ext/libvirt/nwfilter.c

@@ -123,6 +123,8 @@ static VALUE libvirt_nwfilter_free(VALUE n)
 void ruby_libvirt_nwfilter_init(void)
 {
     c_nwfilter = rb_define_class_under(m_libvirt, "NWFilter", rb_cObject);
+    rb_undef_alloc_func(c_nwfilter);
+
     rb_define_attr(c_nwfilter, "connection", 1, 0);
 
     /* NWFilter object methods */

data/ext/libvirt/secret.c

@@ -230,6 +230,7 @@ static VALUE libvirt_secret_free(VALUE s)
 void ruby_libvirt_secret_init(void)
 {
     c_secret = rb_define_class_under(m_libvirt, "Secret", rb_cObject);
+    rb_undef_alloc_func(c_secret);
 
     rb_define_attr(c_secret, "connection", 1, 0);
 

data/ext/libvirt/storage.c

@@ -442,8 +442,8 @@ static VALUE libvirt_storage_pool_list_all_volumes(int argc, VALUE *argv,
 {
     ruby_libvirt_generate_call_list_all(virStorageVolPtr, argc, argv,
                                         virStoragePoolListAllVolumes,
-                                        pool_get(p), p, vol_new,
-                                        virStorageVolFree);
+                                        pool_get(p), ruby_libvirt_conn_attr(p),
+                                        vol_new, virStorageVolFree);
 }
 
 /*
@@ -752,6 +752,7 @@ void ruby_libvirt_storage_init(void)
 
     c_storage_pool = rb_define_class_under(m_libvirt, "StoragePool",
                                            rb_cObject);
+    rb_undef_alloc_func(c_storage_pool);
 
     rb_define_attr(c_storage_pool, "connection", 1, 0);
 
@@ -864,6 +865,7 @@ void ruby_libvirt_storage_init(void)
 
     c_storage_vol = rb_define_class_under(m_libvirt, "StorageVol",
                                           rb_cObject);
+    rb_undef_alloc_func(c_storage_vol);
 
     rb_define_const(c_storage_vol, "XML_INACTIVE",
                     INT2NUM(VIR_STORAGE_XML_INACTIVE));

data/ext/libvirt/stream.c

@@ -360,6 +360,7 @@ static VALUE libvirt_stream_free(VALUE s)
 void ruby_libvirt_stream_init(void)
 {
     c_stream = rb_define_class_under(m_libvirt, "Stream", rb_cObject);
+    rb_undef_alloc_func(c_stream);
 
     rb_define_attr(c_stream, "connection", 1, 0);
 

data/tests/test_conn.rb

@@ -9,19 +9,21 @@ require 'test_utils.rb'
 
 set_test_object("connect")
 
-conn = Libvirt::open("qemu:///system")
+conn = Libvirt::open(URI)
 
 cleanup_test_domain(conn)
 cleanup_test_network(conn)
 
 # test setup
-begin
-  `rm -f /etc/sysconfig/network-scripts/ifcfg-rb-libvirt-test`
-  `brctl delbr rb-libvirt-test >& /dev/null`
-rescue
+if !test_default_uri?
+  begin
+    `rm -f /etc/sysconfig/network-scripts/ifcfg-rb-libvirt-test`
+    `brctl delbr rb-libvirt-test >& /dev/null`
+  rescue
+  end
+  `qemu-img create -f qcow2 #{$GUEST_DISK} 5G`
+  `rm -rf #{$POOL_PATH}; mkdir #{$POOL_PATH} ; echo $?`
 end
-`qemu-img create -f qcow2 #{$GUEST_DISK} 5G`
-`rm -rf #{$POOL_PATH}; mkdir #{$POOL_PATH} ; echo $?`
 
 cpu_xml = <<EOF
 <cpu>
@@ -31,12 +33,12 @@ cpu_xml = <<EOF
 EOF
 
 # TESTGROUP: conn.close
-conn2 = Libvirt::open("qemu:///system")
+conn2 = Libvirt::open(URI)
 expect_too_many_args(conn2, "close", 1)
 expect_success(conn2, "no args", "close")
 
 # TESTGROUP: conn.closed?
-conn2 = Libvirt::open("qemu:///system")
+conn2 = Libvirt::open(URI)
 
 expect_too_many_args(conn2, "closed?", 1)
 expect_success(conn2, "no args", "closed?") {|x| x == false }
@@ -46,7 +48,11 @@ expect_success(conn2, "no args", "closed?") {|x| x == true }
 # TESTGROUP: conn.type
 expect_too_many_args(conn, "type", 1)
 
-expect_success(conn, "no args", "type") {|x| x == "QEMU"}
+if test_default_uri?
+  expect_success(conn, "no args", "type") {|x| x == "TEST"}
+else
+  expect_success(conn, "no args", "type") {|x| x == "QEMU"}
+end
 
 # TESTGROUP: conn.version
 expect_too_many_args(conn, "version", 1)
@@ -66,11 +72,14 @@ expect_success(conn, "no args", "hostname")
 # TESTGROUP: conn.uri
 expect_too_many_args(conn, "uri", 1)
 
-expect_success(conn, "no args", "uri") {|x| x == "qemu:///system" }
+expect_success(conn, "no args", "uri") {|x| x == URI }
 
 # TESTGROUP: conn.max_vcpus
 expect_too_many_args(conn, "max_vcpus", 'kvm', 1)
-expect_fail(conn, Libvirt::RetrieveError, "invalid arg", "max_vcpus", "foo")
+
+if !test_default_uri?
+  expect_fail(conn, Libvirt::RetrieveError, "invalid arg", "max_vcpus", "foo")
+end
 
 expect_success(conn, "no args", "max_vcpus")
 expect_success(conn, "nil arg", "max_vcpus")
@@ -113,12 +122,14 @@ expect_too_many_args(conn, "capabilities", 1)
 expect_success(conn, "no args", "capabilities")
 
 # TESTGROUP: conn.compare_cpu
-expect_too_many_args(conn, "compare_cpu", 1, 2, 3)
-expect_too_few_args(conn, "compare_cpu")
-expect_invalid_arg_type(conn, "compare_cpu", 1)
-expect_invalid_arg_type(conn, "compare_cpu", "hello", 'bar')
-expect_fail(conn, Libvirt::RetrieveError, "invalid XML", "compare_cpu", "hello")
-expect_success(conn, "CPU XML", "compare_cpu", cpu_xml)
+if !test_default_uri?
+  expect_too_many_args(conn, "compare_cpu", 1, 2, 3)
+  expect_too_few_args(conn, "compare_cpu")
+  expect_invalid_arg_type(conn, "compare_cpu", 1)
+  expect_invalid_arg_type(conn, "compare_cpu", "hello", 'bar')
+  expect_fail(conn, Libvirt::RetrieveError, "invalid XML", "compare_cpu", "hello")
+  expect_success(conn, "CPU XML", "compare_cpu", cpu_xml)
+end
 
 # TESTGROUP: conn.baseline_cpu
 expect_too_many_args(conn, "baseline_cpu", 1, 2, 3)
@@ -205,7 +216,7 @@ expect_too_many_args(conn, "list_domains", 1)
 expect_success(conn, "no args", "list_domains")
 
 newdom = conn.create_domain_xml($new_dom_xml)
-sleep 1
+test_sleep 1
 
 expect_success(conn, "no args", "list_domains")
 
@@ -227,7 +238,7 @@ 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
+test_sleep 1
 
 expect_fail(conn, Libvirt::Error, "already existing domain", "create_domain_linux", $new_dom_xml)
 
@@ -241,7 +252,7 @@ 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
+test_sleep 1
 
 expect_fail(conn, Libvirt::Error, "already existing domain", "create_domain_xml", $new_dom_xml)
 
@@ -249,7 +260,7 @@ newdom.destroy
 
 # TESTGROUP: conn.lookup_domain_by_name
 newdom = conn.create_domain_xml($new_dom_xml)
-sleep 1
+test_sleep 1
 
 expect_too_many_args(conn, "lookup_domain_by_name", 1, 2)
 expect_too_few_args(conn, "lookup_domain_by_name")
@@ -265,7 +276,7 @@ newdom.undefine
 
 # TESTGROUP: conn.lookup_domain_by_id
 newdom = conn.create_domain_xml($new_dom_xml)
-sleep 1
+test_sleep 1
 
 expect_too_many_args(conn, "lookup_domain_by_id", 1, 2)
 expect_too_few_args(conn, "lookup_domain_by_id")
@@ -277,7 +288,7 @@ newdom.destroy
 
 # TESTGROUP: conn.lookup_domain_by_uuid
 newdom = conn.create_domain_xml($new_dom_xml)
-sleep 1
+test_sleep 1
 
 expect_too_many_args(conn, "lookup_domain_by_uuid", 1, 2)
 expect_too_few_args(conn, "lookup_domain_by_uuid")
@@ -301,32 +312,6 @@ expect_fail(conn, Libvirt::DefinitionError, "invalid XML", "define_domain_xml",
 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")
@@ -483,89 +468,109 @@ 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")
+if !test_default_uri?
+  expect_too_many_args(conn, "num_of_nwfilters", 1)
+  expect_success(conn, "no args", "num_of_nwfilters")
+end
 
 # TESTGROUP: conn.list_nwfilters
-expect_too_many_args(conn, "list_nwfilters", 1)
-expect_success(conn, "no args", "list_nwfilters")
+if !test_default_uri?
+  expect_too_many_args(conn, "list_nwfilters", 1)
+  expect_success(conn, "no args", "list_nwfilters")
+end
 
 # TESTGROUP: conn.lookup_nwfilter_by_name
-newnw = conn.define_nwfilter_xml($new_nwfilter_xml)
+if !test_default_uri?
+  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_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", "rb-libvirt-test")
+  expect_success(conn, "name arg", "lookup_nwfilter_by_name", "rb-libvirt-test")
 
-newnw.undefine
+  newnw.undefine
+end
 
 # TESTGROUP: conn.lookup_nwfilter_by_uuid
-newnw = conn.define_nwfilter_xml($new_nwfilter_xml)
+if !test_default_uri?
+  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_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}
+  expect_success(conn, "uuid arg", "lookup_nwfilter_by_uuid", $NWFILTER_UUID) {|x| x.uuid == $NWFILTER_UUID}
 
-newnw.undefine
+  newnw.undefine
+end
 
 # 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")
+if !test_default_uri?
+  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 = expect_success(conn, "nwfilter XML", "define_nwfilter_xml", $new_nwfilter_xml)
 
-newnw.undefine
+  newnw.undefine
+end
 
 # TESTGROUP: conn.num_of_secrets
-expect_too_many_args(conn, "num_of_secrets", 1)
-expect_success(conn, "no args", "num_of_secrets")
+if !test_default_uri?
+  expect_too_many_args(conn, "num_of_secrets", 1)
+  expect_success(conn, "no args", "num_of_secrets")
+end
 
 # TESTGROUP: conn.list_secrets
-expect_too_many_args(conn, "list_secrets", 1)
-expect_success(conn, "no args", "list_secrets")
+if !test_default_uri?
+  expect_too_many_args(conn, "list_secrets", 1)
+  expect_success(conn, "no args", "list_secrets")
+end
 
 # TESTGROUP: conn.lookup_secret_by_uuid
-newsecret = conn.define_secret_xml($new_secret_xml)
+if !test_default_uri?
+  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_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}
+  expect_success(conn, "uuid arg", "lookup_secret_by_uuid", $SECRET_UUID) {|x| x.uuid == $SECRET_UUID}
 
-newsecret.undefine
+  newsecret.undefine
+end
 
 # TESTGROUP: conn.lookup_secret_by_usage
-newsecret = conn.define_secret_xml($new_secret_xml)
+if !test_default_uri?
+  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_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")
+  expect_success(conn, "usage type and key", "lookup_secret_by_usage", Libvirt::Secret::USAGE_TYPE_VOLUME, "/var/lib/libvirt/images/mail.img")
 
-newsecret.undefine
+  newsecret.undefine
+end
 
 # 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")
+if !test_default_uri?
+  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)
+  expect_success(conn, "secret XML", "define_secret_xml", $new_secret_xml)
 
-newsecret.undefine
+  newsecret.undefine
+end
 
 # TESTGROUP: conn.list_storage_pools
 expect_too_many_args(conn, "list_storage_pools", 1)
@@ -692,26 +697,30 @@ expect_invalid_arg_type(conn, "node_cpu_stats", 1, 'bar')
 expect_success(conn, "node cpu stats", "node_cpu_stats")
 
 # TESTGROUP: conn.node_memory_stats
-expect_too_many_args(conn, "node_memory_stats", 1, 2, 3)
-expect_invalid_arg_type(conn, "node_memory_stats", 'foo')
-expect_invalid_arg_type(conn, "node_memory_stats", 1, 'bar')
+if !test_default_uri?
+  expect_too_many_args(conn, "node_memory_stats", 1, 2, 3)
+  expect_invalid_arg_type(conn, "node_memory_stats", 'foo')
+  expect_invalid_arg_type(conn, "node_memory_stats", 1, 'bar')
 
-expect_success(conn, "node memory status", "node_memory_stats")
+  expect_success(conn, "node memory status", "node_memory_stats")
+end
 
 # TESTGROUP: conn.save_image_xml_desc
-newdom = conn.define_domain_xml($new_dom_xml)
-newdom.create
-sleep 1
-newdom.save($GUEST_SAVE)
-
-expect_too_many_args(conn, "save_image_xml_desc", 1, 2, 3)
-expect_too_few_args(conn, "save_image_xml_desc")
-expect_invalid_arg_type(conn, "save_image_xml_desc", nil)
-expect_invalid_arg_type(conn, "save_image_xml_desc", 1)
-expect_invalid_arg_type(conn, "save_image_xml_desc", 'foo', 'bar')
-
-expect_success(conn, "save image path", "save_image_xml_desc", $GUEST_SAVE)
-`rm -f #{$GUEST_SAVE}`
+if !test_default_uri?
+  newdom = conn.define_domain_xml($new_dom_xml)
+  newdom.create
+  test_sleep 1
+  newdom.save($GUEST_SAVE)
+
+  expect_too_many_args(conn, "save_image_xml_desc", 1, 2, 3)
+  expect_too_few_args(conn, "save_image_xml_desc")
+  expect_invalid_arg_type(conn, "save_image_xml_desc", nil)
+  expect_invalid_arg_type(conn, "save_image_xml_desc", 1)
+  expect_invalid_arg_type(conn, "save_image_xml_desc", 'foo', 'bar')
+
+  expect_success(conn, "save image path", "save_image_xml_desc", $GUEST_SAVE)
+  `rm -f #{$GUEST_SAVE}`
+end
 
 # TESTGROUP: conn.define_save_image_xml
 expect_too_many_args(conn, "define_save_image_xml", 1, 2, 3, 4)
@@ -729,10 +738,12 @@ expect_too_many_args(conn, "alive?", 1)
 expect_success(conn, "alive connection", "alive?") {|x| x == true}
 
 # TESTGROUP: conn.list_all_nwfilters
-expect_too_many_args(conn, "list_all_nwfilters", 1, 2)
-expect_invalid_arg_type(conn, "list_all_nwfilters", "foo")
+if !test_default_uri?
+  expect_too_many_args(conn, "list_all_nwfilters", 1, 2)
+  expect_invalid_arg_type(conn, "list_all_nwfilters", "foo")
 
-expect_success(conn, "no args", "list_all_nwfilters")
+  expect_success(conn, "no args", "list_all_nwfilters")
+end
 
 # TESTGROUP: conn.list_all_storage_pools
 expect_too_many_args(conn, "list_all_storage_pools", 1, 2)
@@ -747,10 +758,12 @@ expect_invalid_arg_type(conn, "list_all_nodedevices", "foo")
 expect_success(conn, "no args", "list_all_nodedevices")
 
 # TESTGROUP: conn.list_all_secrets
-expect_too_many_args(conn, "list_all_secrets", 1, 2)
-expect_invalid_arg_type(conn, "list_all_secrets", "foo")
+if !test_default_uri?
+  expect_too_many_args(conn, "list_all_secrets", 1, 2)
+  expect_invalid_arg_type(conn, "list_all_secrets", "foo")
 
-expect_success(conn, "no args", "list_all_secrets")
+  expect_success(conn, "no args", "list_all_secrets")
+end
 
 # TESTGROUP: conn.list_all_interfaces
 expect_too_many_args(conn, "list_all_interfaces", 1, 2)
@@ -789,10 +802,12 @@ expect_invalid_arg_type(conn, "node_suspend_for_duration", 1, 'foo')
 expect_invalid_arg_type(conn, "node_suspend_for_duration", 1, 2, 'foo')
 
 # TESTGROUP: conn.node_memory_parameters
-expect_too_many_args(conn, "node_memory_parameters", 1, 2)
-expect_invalid_arg_type(conn, "node_memory_parameters", 'foo')
+if !test_default_uri?
+  expect_too_many_args(conn, "node_memory_parameters", 1, 2)
+  expect_invalid_arg_type(conn, "node_memory_parameters", 'foo')
 
-expect_success(conn, "no args", "node_memory_parameters")
+  expect_success(conn, "no args", "node_memory_parameters")
+end
 
 # TESTGROUP: conn.node_memory_paramters=
 expect_too_many_args(conn, "node_memory_parameters=", 1, 2)