ruby-libvirt 0.2.0 → 0.3.0

data/tests/test_secret.rb

@@ -2,32 +2,144 @@
 
 # Test the secret methods the bindings support
 
+$: << File.dirname(__FILE__)
+
 require 'libvirt'
+require 'test_utils.rb'
+
+UUID = "bd339530-134c-6d07-4410-17fb90dad805"
 
-conn = Libvirt::open
-puts "Number of Secrets: #{conn.num_of_secrets}"
+conn = Libvirt::open("qemu:///system")
 
 new_secret_xml = <<EOF
 <secret ephemeral='no' private='no'>
   <description>test secret</description>
+  <uuid>#{UUID}</uuid>
+  <usage type='volume'>
+    <volume>/var/lib/libvirt/images/mail.img</volume>
+  </usage>
 </secret>
 EOF
 
+# 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", UUID) {|x| x.uuid == UUID}
+
+newsecret.undefine
+
+# TESTGROUP: conn.lookup_secret_by_usage
 newsecret = conn.define_secret_xml(new_secret_xml)
-newsecret.set_value("hello")
-puts newsecret.get_value
-newsecret.set_value("bob", 0)
-puts newsecret.get_value
 
-conn.list_secrets.each do |secuuid|
-  secret = conn.lookup_secret_by_uuid(secuuid)
-  puts "Secret #{secret.uuid}:"
-  puts " UsageType: #{secret.usagetype}"
-  puts " UsageId:   #{secret.usageid}"
-  puts " XML:"
-  puts secret.xml_desc
-end
+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: secret.uuid
+newsecret = conn.define_secret_xml(new_secret_xml)
+
+expect_too_many_args(newsecret, "uuid", 1)
+
+expect_success(newsecret, "no args", "uuid") {|x| x == UUID}
+
+newsecret.undefine
+
+# TESTGROUP: secret.usagetype
+newsecret = conn.define_secret_xml(new_secret_xml)
+
+expect_too_many_args(newsecret, "usagetype", 1)
+
+expect_success(newsecret, "no args", "usagetype") {|x| x == Libvirt::Secret::USAGE_TYPE_VOLUME}
+
+newsecret.undefine
+
+# TESTGROUP: secret.usageid
+newsecret = conn.define_secret_xml(new_secret_xml)
+
+expect_too_many_args(newsecret, "usageid", 1)
+
+expect_success(newsecret, "no args", "usageid")
+
+newsecret.undefine
+
+# TESTGROUP: secret.xml_desc
+newsecret = conn.define_secret_xml(new_secret_xml)
+
+expect_too_many_args(newsecret, "xml_desc", 1, 2)
+expect_invalid_arg_type(newsecret, "xml_desc", "foo")
+
+expect_success(newsecret, "no args", "xml_desc")
+
+newsecret.undefine
+
+# TESTGROUP: secret.set_value
+newsecret = conn.define_secret_xml(new_secret_xml)
+
+expect_too_many_args(newsecret, "set_value", 1, 2, 3)
+expect_too_few_args(newsecret, "set_value")
+expect_invalid_arg_type(newsecret, "set_value", 1)
+expect_invalid_arg_type(newsecret, "set_value", "foo", "bar")
+
+expect_success(newsecret, "value arg", "set_value", "foo")
+
+newsecret.undefine
+
+# TESTGROUP: secret.get_value
+newsecret = conn.define_secret_xml(new_secret_xml)
+newsecret.set_value("foo")
+
+expect_too_many_args(newsecret, "get_value", 1, 2)
+expect_invalid_arg_type(newsecret, "get_value", 'foo')
+
+expect_success(newsecret, "no args", "get_value") {|x| x == 'foo'}
+
+newsecret.undefine
+
+# TESTGROUP: secret.undefine
+newsecret = conn.define_secret_xml(new_secret_xml)
+
+expect_too_many_args(newsecret, "undefine", 1)
+
+expect_success(newsecret, "no args", "undefine")
+
+# TESTGROUP: secret.free
+newsecret = conn.define_secret_xml(new_secret_xml)
+newsecret.undefine
+
+expect_too_many_args(newsecret, "free", 1)
+
+expect_success(newsecret, "no args", "free")
+
 conn.close
+
+finish_tests

data/tests/test_storage.rb

@@ -2,48 +2,521 @@
 
 # Test the storage methods the bindings support
 
+$: << File.dirname(__FILE__)
+
 require 'libvirt'
+require 'test_utils.rb'
+
+UUID = "33a5c045-645a-2c00-e56b-927cdf34e17a"
+
+conn = Libvirt::open("qemu:///system")
+
+begin
+  oldpool = conn.lookup_storage_pool_by_name("ruby-libvirt-tester")
+  oldpool.destroy
+  oldpool.undefine
+rescue
+  # in case we didn't find it, don't do anything
+end
+
+# test setup
+`rm -rf /tmp/ruby-libvirt-tester; mkdir /tmp/ruby-libvirt-tester`
+
+new_storage_pool_xml = <<EOF
+<pool type="dir">
+  <name>ruby-libvirt-tester</name>
+  <uuid>#{UUID}</uuid>
+  <target>
+    <path>/tmp/ruby-libvirt-tester</path>
+  </target>
+</pool>
+EOF
+
+new_storage_vol_xml = <<EOF
+<volume>
+  <name>test.img</name>
+  <allocation>0</allocation>
+  <capacity unit="G">1</capacity>
+  <target>
+    <path>/tmp/ruby-libvirt-tester/test.img</path>
+  </target>
+</volume>
+EOF
+
+new_storage_vol_xml_2 = <<EOF
+<volume>
+  <name>test2.img</name>
+  <allocation>0</allocation>
+  <capacity unit="G">5</capacity>
+  <target>
+    <path>/tmp/ruby-libvirt-tester/test2.img</path>
+  </target>
+</volume>
+EOF
+
+# 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", UUID)
+
+newpool.destroy
+
+newpool = conn.define_storage_pool_xml(new_storage_pool_xml)
+
+expect_success(conn, "uuid arg", "lookup_storage_pool_by_uuid", UUID)
+
+newpool.undefine
+
+# TESTGROUP: vol.pool
+newpool = conn.create_storage_pool_xml(new_storage_pool_xml)
+
+newvol = newpool.create_volume_xml(new_storage_vol_xml)
+
+expect_too_many_args(newvol, "pool", 1)
+
+expect_success(newvol, "no args", "pool")
+
+newvol.delete
+
+newpool.destroy
+
+# 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: pool.build
+newpool = conn.define_storage_pool_xml(new_storage_pool_xml)
+
+expect_too_many_args(newpool, "build", 1, 2)
+expect_invalid_arg_type(newpool, "build", 'foo')
+
+expect_success(newpool, "no args", "build")
+
+newpool.undefine
+
+# TESTGROUP: pool.undefine
+newpool = conn.define_storage_pool_xml(new_storage_pool_xml)
+
+expect_too_many_args(newpool, "undefine", 1)
+
+expect_success(newpool, "no args", "undefine")
+
+# TESTGROUP: pool.create
+newpool = conn.define_storage_pool_xml(new_storage_pool_xml)
+
+expect_too_many_args(newpool, "create", 1, 2)
+expect_invalid_arg_type(newpool, "create", 'foo')
+
+expect_success(newpool, "no args", "create")
+
+newpool.destroy
+newpool.undefine
+
+# TESTGROUP: pool.destroy
+newpool = conn.create_storage_pool_xml(new_storage_pool_xml)
+
+expect_too_many_args(newpool, "destroy", 1)
+
+expect_success(newpool, "no args", "destroy")
+
+# TESTGROUP: pool.delete
+newpool = conn.define_storage_pool_xml(new_storage_pool_xml)
+
+expect_too_many_args(newpool, "delete", 1, 2)
+expect_invalid_arg_type(newpool, "delete", 'foo')
+
+expect_success(newpool, "no args", "delete")
+
+`mkdir /tmp/ruby-libvirt-tester`
+
+newpool.undefine
+
+# TESTGROUP: pool.refresh
+newpool = conn.create_storage_pool_xml(new_storage_pool_xml)
+
+expect_too_many_args(newpool, "refresh", 1, 2)
+expect_invalid_arg_type(newpool, "refresh", 'foo')
+
+expect_success(newpool, "no args", "refresh")
+
+newpool.destroy
+
+# TESTGROUP: pool.name
+newpool = conn.create_storage_pool_xml(new_storage_pool_xml)
+
+expect_too_many_args(newpool, "name", 1)
+
+expect_success(newpool, "no args", "name") {|x| x == "ruby-libvirt-tester"}
+
+newpool.destroy
+
+# TESTGROUP: pool.uuid
+newpool = conn.create_storage_pool_xml(new_storage_pool_xml)
+
+expect_too_many_args(newpool, "uuid", 1)
+
+expect_success(newpool, "no args", "uuid") {|x| x == UUID}
+
+newpool.destroy
+
+# TESTGROUP: pool.info
+newpool = conn.create_storage_pool_xml(new_storage_pool_xml)
+
+expect_too_many_args(newpool, "info", 1)
+
+expect_success(newpool, "no args", "info")
+
+newpool.destroy
+
+# TESTGROUP: pool.xml_desc
+newpool = conn.create_storage_pool_xml(new_storage_pool_xml)
+
+expect_too_many_args(newpool, "xml_desc", 1, 2)
+expect_invalid_arg_type(newpool, "xml_desc", "foo")
+
+expect_success(newpool, "no args", "xml_desc")
+
+newpool.destroy
+
+# TESTGROUP: pool.autostart?
+newpool = conn.define_storage_pool_xml(new_storage_pool_xml)
+
+expect_too_many_args(newpool, "autostart?", 1)
+
+expect_success(newpool, "no args", "autostart?") {|x| x == false}
+
+newpool.autostart = true
+
+expect_success(newpool, "no args", "autostart?") {|x| x == true}
+
+newpool.undefine
 
-conn = Libvirt::open
-puts "Number of Storage Pools: #{conn.num_of_storage_pools}"
-puts "Number of Defined Storage Pools: #{conn.num_of_defined_storage_pools}"
-
-defined = conn.list_defined_storage_pools
-running = conn.list_storage_pools
-
-(defined+running).each do |storagename|
-  storagepool = conn.lookup_storage_pool_by_name(storagename)
-  store2 = conn.lookup_storage_pool_by_uuid(storagepool.uuid)
-  storagepool.refresh
-  puts "StoragePool #{storagepool.name}:"
-  puts " UUID: #{storagepool.uuid}"
-  puts " Autostart?: #{storagepool.autostart?}"
-  puts " Active?: #{storagepool.active?}"
-  puts " Persistent?: #{storagepool.persistent?}"
-  info = storagepool.info
-  puts " Info:"
-  puts "  State:      #{info.state}"
-  puts "  Capacity:   #{info.capacity}"
-  puts "  Allocation: #{info.allocation}"
-  puts "  Available:  #{info.available}"
-  puts " XML:"
-  puts storagepool.xml_desc
-  puts " Number of Volumes: #{storagepool.num_of_volumes}"
-  puts " Volumes:"
-  storagepool.list_volumes.each do |volname|
-    storagevolume = storagepool.lookup_volume_by_name(volname)
-    vol2 = storagepool.lookup_volume_by_key(storagevolume.key)
-    vol3 = storagepool.lookup_volume_by_path(storagevolume.path)
-    puts "  Volume #{storagevolume.name}:"
-    puts "   Pool: #{storagevolume.pool.name}"
-    puts "   Key:  #{storagevolume.key}"
-    puts "   Path: #{storagevolume.path}"
-    info = storagevolume.info
-    puts "   Info:"
-    puts "    Type:       #{info.type}"
-    puts "    Capacity:   #{info.capacity}"
-    puts "    Allocation: #{info.allocation}"
-  end
+# TESTGROUP: pool.autostart=
+newpool = conn.define_storage_pool_xml(new_storage_pool_xml)
+
+expect_too_many_args(newpool, "autostart=", 1, 2)
+expect_invalid_arg_type(newpool, "autostart=", 'foo')
+expect_invalid_arg_type(newpool, "autostart=", nil)
+expect_invalid_arg_type(newpool, "autostart=", 1234)
+
+expect_success(newpool, "no args", "autostart=", true)
+if not newpool.autostart?
+  puts_fail "pool.autostart= did not set autostart to true"
+else
+  puts_ok "pool.autostart= set autostart to true"
+end
+
+expect_success(newpool, "no args", "autostart=", false)
+if newpool.autostart?
+  puts_fail "pool.autostart= did not set autostart to false"
+else
+  puts_ok "pool.autostart= set autostart to false"
 end
 
+newpool.undefine
+
+# TESTGROUP: pool.num_of_volumes
+newpool = conn.create_storage_pool_xml(new_storage_pool_xml)
+
+expect_too_many_args(newpool, "num_of_volumes", 1)
+
+expect_success(newpool, "no args", "num_of_volumes") {|x| x == 0}
+
+newpool.destroy
+
+# TESTGROUP: pool.list_volumes
+newpool = conn.create_storage_pool_xml(new_storage_pool_xml)
+
+expect_too_many_args(newpool, "list_volumes", 1)
+
+expect_success(newpool, "no args", "list_volumes")
+
+newpool.destroy
+
+# TESTGROUP: pool.free
+newpool = conn.define_storage_pool_xml(new_storage_pool_xml)
+newpool.undefine
+expect_too_many_args(newpool, "free", 1)
+
+expect_success(newpool, "no args", "free")
+
+# TESTGROUP: pool.lookup_volume_by_name
+newpool = conn.create_storage_pool_xml(new_storage_pool_xml)
+newvol = newpool.create_volume_xml(new_storage_vol_xml)
+
+expect_too_many_args(newpool, "lookup_volume_by_name", 1, 2)
+expect_too_few_args(newpool, "lookup_volume_by_name")
+expect_invalid_arg_type(newpool, "lookup_volume_by_name", 1);
+expect_invalid_arg_type(newpool, "lookup_volume_by_name", nil);
+expect_fail(newpool, Libvirt::RetrieveError, "non-existent name arg", "lookup_volume_by_name", "foobarbazsucker")
+
+expect_success(newpool, "name arg", "lookup_volume_by_name", "test.img")
+
+newvol.delete
+newpool.destroy
+
+# TESTGROUP: pool.lookup_volume_by_key
+newpool = conn.create_storage_pool_xml(new_storage_pool_xml)
+newvol = newpool.create_volume_xml(new_storage_vol_xml)
+
+expect_too_many_args(newpool, "lookup_volume_by_key", 1, 2)
+expect_too_few_args(newpool, "lookup_volume_by_key")
+expect_invalid_arg_type(newpool, "lookup_volume_by_key", 1);
+expect_invalid_arg_type(newpool, "lookup_volume_by_key", nil);
+expect_fail(newpool, Libvirt::RetrieveError, "non-existent key arg", "lookup_volume_by_key", "foobarbazsucker")
+
+expect_success(newpool, "name arg", "lookup_volume_by_key", newvol.key)
+
+newvol.delete
+newpool.destroy
+
+# TESTGROUP: pool.lookup_volume_by_path
+newpool = conn.create_storage_pool_xml(new_storage_pool_xml)
+newvol = newpool.create_volume_xml(new_storage_vol_xml)
+
+expect_too_many_args(newpool, "lookup_volume_by_path", 1, 2)
+expect_too_few_args(newpool, "lookup_volume_by_path")
+expect_invalid_arg_type(newpool, "lookup_volume_by_path", 1);
+expect_invalid_arg_type(newpool, "lookup_volume_by_path", nil);
+expect_fail(newpool, Libvirt::RetrieveError, "non-existent path arg", "lookup_volume_by_path", "foobarbazsucker")
+
+expect_success(newpool, "name arg", "lookup_volume_by_path", newvol.path)
+
+newvol.delete
+newpool.destroy
+
+# TESTGROUP: vol.name
+newpool = conn.create_storage_pool_xml(new_storage_pool_xml)
+newvol = newpool.create_volume_xml(new_storage_vol_xml)
+
+expect_too_many_args(newvol, "name", 1)
+
+expect_success(newvol, "no args", "name")
+
+newvol.delete
+newpool.destroy
+
+# TESTGROUP: vol.key
+newpool = conn.create_storage_pool_xml(new_storage_pool_xml)
+newvol = newpool.create_volume_xml(new_storage_vol_xml)
+
+expect_too_many_args(newvol, "key", 1)
+
+expect_success(newvol, "no args", "key")
+
+newvol.delete
+newpool.destroy
+
+# TESTGROUP: pool.create_volume_xml
+newpool = conn.create_storage_pool_xml(new_storage_pool_xml)
+
+expect_too_many_args(newpool, "create_volume_xml", new_storage_vol_xml, 0, 1)
+expect_too_few_args(newpool, "create_volume_xml")
+expect_invalid_arg_type(newpool, "create_volume_xml", nil)
+expect_invalid_arg_type(newpool, "create_volume_xml", 1)
+expect_invalid_arg_type(newpool, "create_volume_xml", new_storage_vol_xml, "foo")
+expect_fail(newpool, Libvirt::Error, "invalid xml", "create_volume_xml", "hello")
+
+expect_success(newpool, "storage volume XML", "create_volume_xml", new_storage_vol_xml)
+
+expect_fail(newpool, Libvirt::Error, "already existing domain", "create_volume_xml", new_storage_vol_xml)
+
+newvol.delete
+newpool.destroy
+
+# TESTGROUP: pool.create_volume_xml_from
+newpool = conn.create_storage_pool_xml(new_storage_pool_xml)
+newvol = newpool.create_volume_xml(new_storage_vol_xml)
+
+expect_too_many_args(newpool, "create_volume_xml_from", new_storage_vol_xml_2, 0, 1, 2)
+expect_too_few_args(newpool, "create_volume_xml_from")
+expect_invalid_arg_type(newpool, "create_volume_xml_from", 1, 2)
+expect_invalid_arg_type(newpool, "create_volume_xml_from", "foo", 2)
+expect_invalid_arg_type(newpool, "create_volume_xml_from", "foo", newvol, "bar")
+expect_fail(newpool, Libvirt::Error, "invalid xml", "create_volume_xml_from", "hello", newvol)
+
+newvol2 = expect_success(newpool, "storage volume XML", "create_volume_xml_from", new_storage_vol_xml_2, newvol)
+
+expect_fail(newpool, Libvirt::Error, "already existing domain", "create_volume_xml_from", new_storage_vol_xml_2, newvol)
+
+newvol2.delete
+newvol.delete
+newpool.destroy
+
+# TESTGROUP: pool.active?
+newpool = conn.create_storage_pool_xml(new_storage_pool_xml)
+
+expect_too_many_args(newpool, "active?", 1)
+
+expect_success(newpool, "no args", "active?") {|x| x == true}
+
+newpool.destroy
+
+newpool = conn.define_storage_pool_xml(new_storage_pool_xml)
+
+expect_success(newpool, "no args", "active?") {|x| x == false}
+
+newpool.create
+
+expect_success(newpool, "no args", "active?") {|x| x == true}
+
+newpool.destroy
+newpool.undefine
+
+# TESTGROUP: pool.persistent?
+newpool = conn.create_storage_pool_xml(new_storage_pool_xml)
+sleep 1
+
+expect_too_many_args(newpool, "persistent?", 1)
+
+expect_success(newpool, "no args", "persistent?") {|x| x == false}
+
+newpool.destroy
+
+newpool = conn.define_storage_pool_xml(new_storage_pool_xml)
+
+expect_success(newpool, "no args", "persistent?") {|x| x == true}
+
+newpool.undefine
+
+# TESTGROUP: vol.delete
+newpool = conn.create_storage_pool_xml(new_storage_pool_xml)
+newvol = newpool.create_volume_xml(new_storage_vol_xml)
+
+expect_too_many_args(newvol, "delete", 1, 2)
+expect_invalid_arg_type(newvol, "delete", 'foo')
+
+expect_success(newvol, "no args", "delete")
+
+newpool.destroy
+
+# TESTGROUP: vol.wipe
+newpool = conn.create_storage_pool_xml(new_storage_pool_xml)
+newvol = newpool.create_volume_xml(new_storage_vol_xml)
+
+expect_too_many_args(newvol, "wipe", 1, 2)
+expect_invalid_arg_type(newvol, "wipe", 'foo')
+
+expect_success(newvol, "no args", "wipe")
+
+newvol.delete
+newpool.destroy
+
+# TESTGROUP: vol.info
+newpool = conn.create_storage_pool_xml(new_storage_pool_xml)
+newvol = newpool.create_volume_xml(new_storage_vol_xml)
+
+expect_too_many_args(newvol, "info", 1)
+
+expect_success(newvol, "no args", "info")
+
+newvol.delete
+newpool.destroy
+
+# TESTGROUP: vol.xml_desc
+newpool = conn.create_storage_pool_xml(new_storage_pool_xml)
+newvol = newpool.create_volume_xml(new_storage_vol_xml)
+
+expect_too_many_args(newvol, "xml_desc", 1, 2)
+expect_invalid_arg_type(newvol, "xml_desc", "foo")
+
+expect_success(newvol, "no args", "xml_desc")
+
+newvol.delete
+newpool.destroy
+
+# TESTGROUP: vol.path
+newpool = conn.create_storage_pool_xml(new_storage_pool_xml)
+newvol = newpool.create_volume_xml(new_storage_vol_xml)
+
+expect_too_many_args(newvol, "path", 1)
+
+expect_success(newvol, "no args", "path")
+
+newvol.delete
+newpool.destroy
+
+# TESTGROUP: vol.free
+newpool = conn.create_storage_pool_xml(new_storage_pool_xml)
+newvol = newpool.create_volume_xml(new_storage_vol_xml)
+newvol.delete
+
+expect_too_many_args(newvol, "free", 1)
+
+expect_success(newvol, "no args", "free")
+
+newpool.destroy
+
 conn.close
+
+finish_tests