ruby-libvirt 0.2.0 → 0.3.0

data/tests/test_nodedevice.rb

@@ -2,22 +2,110 @@
 
 # Test the nodedevice methods the bindings support
 
+$: << File.dirname(__FILE__)
+
 require 'libvirt'
+require 'test_utils.rb'
+
+conn = Libvirt::open("qemu:///system")
+
+# 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: nodedevice.name
+testnode = conn.lookup_nodedevice_by_name(conn.list_nodedevices[0])
+
+expect_too_many_args(testnode, "name", 1)
+expect_success(testnode, "no args", "name")
+
+# TESTGROUP: nodedevice.parent
+testnode = conn.lookup_nodedevice_by_name(conn.list_nodedevices[0])
+
+expect_too_many_args(testnode, "parent", 1)
+expect_success(testnode, "no args", "parent")
+
+# TESTGROUP: nodedevice.num_of_caps
+testnode = conn.lookup_nodedevice_by_name(conn.list_nodedevices[0])
+
+expect_too_many_args(testnode, "num_of_caps", 1)
+expect_success(testnode, "no args", "num_of_caps")
+
+# TESTGROUP: nodedevice.list_caps
+testnode = conn.lookup_nodedevice_by_name(conn.list_nodedevices[0])
+
+expect_too_many_args(testnode, "list_caps", 1)
+expect_success(testnode, "no args", "list_caps")
 
-conn = Libvirt::open
-puts "Number of NodeDevices: #{conn.num_of_nodedevices}"
-
-conn.list_nodedevices.each do |nodename|
-  nodedevice = conn.lookup_nodedevice_by_name(nodename)
-  puts "NodeDevice #{nodedevice.name}:"
-  puts " Parent: #{nodedevice.parent}"
-  puts " Number Caps: #{nodedevice.num_of_caps}"
-  puts " Caps:"
-  nodedevice.list_caps.each do |cap|
-    puts "  #{cap}"
-  end
-  puts " XML:"
-  puts nodedevice.xml_desc
-end
+# TESTGROUP: nodedevice.xml_desc
+testnode = conn.lookup_nodedevice_by_name(conn.list_nodedevices[0])
+
+expect_too_many_args(testnode, "xml_desc", 1, 2)
+expect_invalid_arg_type(testnode, "xml_desc", 'foo')
+expect_success(testnode, "no args", "xml_desc")
+
+# TESTGROUP: nodedevice.detach
+testnode = conn.lookup_nodedevice_by_name(conn.list_nodedevices[0])
+
+expect_too_many_args(testnode, "detach", 1)
+
+#expect_success(testnode, "no args", "detach")
+
+# TESTGROUP: nodedevice.reattach
+testnode = conn.lookup_nodedevice_by_name(conn.list_nodedevices[0])
+
+expect_too_many_args(testnode, "reattach", 1)
+
+#expect_success(testnode, "no args", "reattach")
+
+# TESTGROUP: nodedevice.reset
+testnode = conn.lookup_nodedevice_by_name(conn.list_nodedevices[0])
+
+expect_too_many_args(testnode, "reset", 1)
+
+#expect_success(testnode, "no args", "reset")
+
+# TESTGROUP: nodedevice.destroy
+testnode = conn.lookup_nodedevice_by_name(conn.list_nodedevices[0])
+
+expect_too_many_args(testnode, "destroy", 1)
+
+#expect_success(testnode, "no args", "destroy")
+
+# TESTGROUP: nodedevice.free
+testnode = conn.lookup_nodedevice_by_name(conn.list_nodedevices[0])
+
+expect_too_many_args(testnode, "free", 1)
+
+expect_success(testnode, "no args", "free")
 
 conn.close
+
+finish_tests

data/tests/test_nwfilter.rb

@@ -2,27 +2,110 @@
 
 # Test the nwfilter methods the bindings support
 
+$: << File.dirname(__FILE__)
+
 require 'libvirt'
+require 'test_utils.rb'
+
+UUID = "bd339530-134c-6d07-441a-17fb90dad807"
 
-conn = Libvirt::open
-puts "Number of NWFilters: #{conn.num_of_nwfilters}"
+conn = Libvirt::open("qemu:///system")
 
 new_nwfilter_xml = <<EOF
-<filter name='no-spamming'>
-  <uuid>d217f2d7-5a04-0e01-8b90-ec274a436b74</uuid>
+<filter name='ruby-libvirt-tester' chain='ipv4'>
+  <uuid>#{UUID}</uuid>
+  <rule action='accept' direction='out' priority='100'>
+    <ip srcipaddr='0.0.0.0' dstipaddr='255.255.255.255' protocol='tcp' srcportstart='63000' dstportstart='62000'/>
+  </rule>
+  <rule action='accept' direction='in' priority='100'>
+    <ip protocol='tcp' srcportstart='63000' dstportstart='62000'/>
+  </rule>
 </filter>
 EOF
 
-newnwfilter = conn.define_nwfilter_xml(new_nwfilter_xml)
-newnwfilter.undefine
+# 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", UUID) {|x| x.uuid == 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: nwfilter.undefine
+newnw = conn.define_nwfilter_xml(new_nwfilter_xml)
+
+expect_too_many_args(newnw, "undefine", 1)
 
-conn.list_nwfilters.each do |nwfname|
-  nwfilter = conn.lookup_nwfilter_by_name(nwfname)
-  nwf2 = conn.lookup_nwfilter_by_uuid(nwfilter.uuid)
-  puts "NWFilter #{nwfilter.name}:"
-  puts " UUID: #{nwfilter.uuid}"
-  puts " XML:"
-  puts nwfilter.xml_desc
-end
+expect_success(newnw, "no args", "undefine")
+
+# TESTGROUP: nwfilter.name
+newnw = conn.define_nwfilter_xml(new_nwfilter_xml)
+
+expect_too_many_args(newnw, "name", 1)
+
+expect_success(newnw, "no args", "name") {|x| x == "ruby-libvirt-tester"}
+
+newnw.undefine
+
+# TESTGROUP: nwfilter.uuid
+newnw = conn.define_nwfilter_xml(new_nwfilter_xml)
+
+expect_too_many_args(newnw, "uuid", 1)
+
+expect_success(newnw, "no args", "uuid") {|x| x == UUID}
+
+newnw.undefine
+
+# TESTGROUP: nwfilter.xml_desc
+newnw = conn.define_nwfilter_xml(new_nwfilter_xml)
+
+expect_too_many_args(newnw, "xml_desc", 1, 2)
+expect_invalid_arg_type(newnw, "xml_desc", "foo")
+
+expect_success(newnw, "no args", "xml_desc")
+
+newnw.undefine
+
+# TESTGROUP: nwfilter.free
+newnw = conn.define_nwfilter_xml(new_nwfilter_xml)
+newnw.undefine
+expect_too_many_args(newnw, "free", 1)
+
+expect_success(newnw, "no args", "free")
 
 conn.close
+
+finish_tests

data/tests/test_open.rb

@@ -2,22 +2,202 @@
 
 # Test the open calls that the bindings support
 
+$: << File.dirname(__FILE__)
+
 require 'libvirt'
+require 'test_utils.rb'
+
+def expect_connect_error(func, args)
+  expect_fail(Libvirt, Libvirt::ConnectionError, "invalid driver", func, *args)
+end
 
-conn = Libvirt::open
+# TESTGROUP: Libvirt::version
+expect_too_many_args(Libvirt, "version", "test", 1)
+expect_invalid_arg_type(Libvirt, "version", 1)
+expect_success(Libvirt, "no args", "version") {|x| x.class == Array and x.length == 2}
+expect_success(Libvirt, "nil arg", "version", nil) {|x| x.class == Array and x.length == 2}
+expect_success(Libvirt, "Test arg", "version", "Test") {|x| x.class == Array and x.length == 2}
+
+# TESTGROUP: Libvirt::open
+expect_too_many_args(Libvirt, "open", "qemu:///system", 1)
+expect_connect_error("open", "foo:///system")
+conn = expect_success(Libvirt, "no args", "open") {|x| x.class == Libvirt::Connect }
+conn.close
+conn = expect_success(Libvirt, "qemu:///system", "open", "qemu:///system") {|x| x.class == Libvirt::Connect }
+conn.close
+conn = expect_success(Libvirt, "nil arg", "open", nil) {|x| x.class == Libvirt::Connect }
 conn.close
 
-conn = Libvirt::open("qemu:///system")
+# TESTGROUP: Libvirt::open_read_only
+expect_too_many_args(Libvirt, "open_read_only", "qemu:///system", 1)
+expect_connect_error("open_read_only", "foo:///system")
+conn = expect_success(Libvirt, "no args", "open_read_only") {|x| x.class == Libvirt::Connect }
+conn.close
+conn = expect_success(Libvirt, "qemu:///system", "open_read_only", "qemu:///system") {|x| x.class == Libvirt::Connect }
+conn.close
+conn = expect_success(Libvirt, "nil arg", "open_read_only", nil) {|x| x.class == Libvirt::Connect }
+conn.close
+
+# TESTGROUP: Libvirt::open_auth
+expect_too_many_args(Libvirt, "open_auth", "qemu:///system", [], "hello there", 1, 2)
+expect_connect_error("open_auth", "foo:///system")
+expect_invalid_arg_type(Libvirt, "open_auth", 1)
+expect_invalid_arg_type(Libvirt, "open_auth", "qemu:///system", [], "hello", "foo")
+
+conn = expect_success(Libvirt, "no args", "open_auth")  {|x| x.class == Libvirt::Connect }
+conn.close
+
+conn = expect_success(Libvirt, "uri arg", "open_auth", "qemu:///system") {|x| x.class == Libvirt::Connect }
+conn.close
+
+conn = expect_success(Libvirt, "uri and empty cred args", "open_auth", "qemu:///system", []) {|x| x.class == Libvirt::Connect }
 conn.close
 
-conn = Libvirt::open(nil)
+conn = expect_success(Libvirt, "uri and full cred args", "open_auth", "qemu:///system", [Libvirt::CRED_AUTHNAME, Libvirt::CRED_PASSPHRASE]) {|x| x.class == Libvirt::Connect }
 conn.close
 
-conn = Libvirt::open_read_only
+conn = expect_success(Libvirt, "uri, full cred, and user args", "open_auth", "qemu:///system", [Libvirt::CRED_AUTHNAME, Libvirt::CRED_PASSPHRASE], "hello") {|x| x.class == Libvirt::Connect }
 conn.close
 
-conn = Libvirt::open_read_only("qemu:///system")
+# equivalent to "expect_success"
+begin
+  conn = Libvirt::open_auth("qemu:///system", [Libvirt::CRED_AUTHNAME, Libvirt::CRED_PASSPHRASE], "hello") do |cred|
+    if not cred["userdata"].nil?
+      puts "userdata is #{cred["userdata"]}"
+    end
+    if cred["type"] == Libvirt::CRED_AUTHNAME
+      print "#{cred['prompt']}: "
+      res = gets
+      # strip off the \n
+      res = res[0..-2]
+    elsif cred["type"] == Libvirt::CRED_PASSPHRASE
+      print "#{cred['prompt']}: "
+      res = gets
+      res = res[0..-2]
+    else
+      raise "Unsupported credential #{cred['type']}"
+    end
+    res
+  end
+
+  puts "OK: open_auth uri, creds, userdata, auth block succeeded"
+  $SUCCESS = $SUCCESS + 1
+  conn.close
+rescue NoMethodError
+  puts "SKIPPED: open_auth does not exist"
+  $SKIPPED = $SKIPPED + 1
+rescue => e
+  puts "FAIL: open_auth uri, creds, userdata, auth block expected to succeed, threw #{e.class.to_s}: #{e.to_s}"
+  $FAIL = $FAIL + 1
+end
+
+# equivalent to "expect_success"
+begin
+  conn = Libvirt::open_auth("qemu:///system", [Libvirt::CRED_AUTHNAME, Libvirt::CRED_PASSPHRASE], "hello", Libvirt::CONNECT_RO) do |cred|
+    if not cred["userdata"].nil?
+      puts "userdata is #{cred["userdata"]}"
+    end
+    if cred["type"] == Libvirt::CRED_AUTHNAME
+      print "#{cred['prompt']}: "
+      res = gets
+      # strip off the \n
+      res = res[0..-2]
+    elsif cred["type"] == Libvirt::CRED_PASSPHRASE
+      print "#{cred['prompt']}: "
+      res = gets
+      res = res[0..-2]
+    else
+      raise "Unsupported credential #{cred['type']}"
+    end
+    res
+  end
+
+  puts "OK: open_auth uri, creds, userdata, R/O flag, auth block succeeded"
+  $SUCCESS = $SUCCESS + 1
+  conn.close
+rescue NoMethodError
+  puts "SKIPPED: open_auth does not exist"
+  $SKIPPED = $SKIPPED + 1
+rescue => e
+  puts "FAIL: open_auth uri, creds, userdata, R/O flag, auth block expected to succeed, threw #{e.class.to_s}: #{e.to_s}"
+  $FAIL = $FAIL + 1
+end
+
+# TESTGROUP: Libvirt::event_register_impl
+expect_too_many_args(Libvirt, "event_register_impl", 1, 2, 3, 4, 5, 6, 7)
+expect_invalid_arg_type(Libvirt, "event_register_impl", 1)
+
+# symbol callbacks
+def virEventAddHandleImpl(fd, events, opaque)
+end
+def virEventUpdateHandleImpl(watch, event)
+end
+def virEventRemoveHandleImpl(handleID)
+end
+def virEventAddTimerImpl(interval, opaque)
+end
+def virEventUpdateTimerImpl(timer, timeout)
+end
+def virEventRemoveTimerImpl(timerID)
+end
+
+# proc callbacks
+virEventAddHandleProc = lambda {|fd, events, opaque|
+}
+virEventUpdateHandleProc = lambda {|watch, event|
+}
+virEventRemoveHandleProc = lambda {|handleID|
+}
+virEventAddTimerProc = lambda {|interval, opaque|
+}
+virEventUpdateTimerProc = lambda {|timer, timeout|
+}
+virEventRemoveTimerProc = lambda {|timerID|
+}
+
+expect_success(Libvirt, "all Symbol callbacks", "event_register_impl", :virEventAddHandleImpl, :virEventUpdateHandleImpl, :virEventRemoveHandleImpl, :virEventAddTimerImpl, :virEventUpdateTimerImpl, :virEventRemoveTimerImpl)
+expect_success(Libvirt, "unregister all callbacks", "event_register_impl", nil, nil, nil, nil, nil, nil)
+expect_success(Libvirt, "all Proc callbacks", "event_register_impl", virEventAddHandleProc, virEventUpdateHandleProc, virEventRemoveHandleProc, virEventAddTimerProc, virEventUpdateTimerProc, virEventRemoveTimerProc)
+expect_success(Libvirt, "unregister all callbacks", "event_register_impl")
+
+# TESTGROUP: Libvirt::event_invoke_handle_callback
+conn = Libvirt::open("qemu:///system")
+
+expect_too_many_args(Libvirt, "event_invoke_handle_callback", 1, 2, 3, 4, 5)
+expect_too_few_args(Libvirt, "event_invoke_handle_callback")
+expect_too_few_args(Libvirt, "event_invoke_handle_callback", 1)
+expect_too_few_args(Libvirt, "event_invoke_handle_callback", 1, 2)
+expect_too_few_args(Libvirt, "event_invoke_handle_callback", 1, 2, 3)
+# this is a bit bizarre; I am constructing a bogus hash to pass as the 4th
+# parameter to event_invoke_handle_callback.  In a real situation, I would
+# have been given this hash from libvirt earlier, and just pass it on.  I
+# don't want all of that complexity here, though, so I create the bogus hash.
+# One caveat; the data inside the hash *must* be of type T_DATA, so I pass in
+# a fake conn object just to appease the type checker (so I can test out the
+# other arguments properly)
+expect_invalid_arg_type(Libvirt, "event_invoke_handle_callback", "hello", 1, 1, { "libvirt_cb" => conn, "opaque" => conn })
+expect_invalid_arg_type(Libvirt, "event_invoke_handle_callback", 1, "hello", 1, { "libvirt_cb" => conn, "opaque" => conn })
+expect_invalid_arg_type(Libvirt, "event_invoke_handle_callback", 1, 1, "hello", { "libvirt_cb" => conn, "opaque" => conn })
+expect_invalid_arg_type(Libvirt, "event_invoke_handle_callback", 1, 1, 1, { "libvirt_cb" => "hello", "opaque" => conn })
+expect_invalid_arg_type(Libvirt, "event_invoke_handle_callback", 1, 1, 1, { "libvirt_cb" => conn, "opaque" => "hello" })
 conn.close
 
-conn = Libvirt::open_read_only(nil)
+# TESTGROUP: Libvirt::event_invoke_timeout_callback
+conn = Libvirt::open("qemu:///system")
+
+expect_too_many_args(Libvirt, "event_invoke_timeout_callback", 1, 2, 3)
+expect_too_few_args(Libvirt, "event_invoke_timeout_callback")
+expect_too_few_args(Libvirt, "event_invoke_timeout_callback", 1)
+# this is a bit bizarre; I am constructing a bogus hash to pass as the 4th
+# parameter to event_invoke_handle_callback.  In a real situation, I would
+# have been given this hash from libvirt earlier, and just pass it on.  I
+# don't want all of that complexity here, though, so I create the bogus hash.
+# One caveat; the data inside the hash *must* be of type T_DATA, so I pass in
+# a fake conn object just to appease the type checker (so I can test out the
+# other arguments properly)
+expect_invalid_arg_type(Libvirt, "event_invoke_timeout_callback", "hello", { "libvirt_cb" => conn, "opaque" => conn })
+expect_invalid_arg_type(Libvirt, "event_invoke_timeout_callback", 1, { "libvirt_cb" => "hello", "opaque" => conn })
+expect_invalid_arg_type(Libvirt, "event_invoke_timeout_callback", 1, { "libvirt_cb" => conn, "opaque" => "hello" })
 conn.close
+
+finish_tests