ruby-libvirt 0.2.0 → 0.3.0

data/tests/test_interface.rb

@@ -2,34 +2,171 @@
 
 # Test the interface methods the bindings support
 
+$: << File.dirname(__FILE__)
+
 require 'libvirt'
+require 'test_utils.rb'
+
+def find_valid_iface(conn)
+  conn.list_interfaces.each do |ifname|
+    iface = conn.lookup_interface_by_name(ifname)
+    if iface.mac == "00:00:00:00:00:00"
+      next
+    end
+    return iface
+  end
+end
+
 
-conn = Libvirt::open
-puts "Number of Interfaces: #{conn.num_of_interfaces}"
-puts "Number of Defined Interfaces: #{conn.num_of_defined_interfaces}"
+conn = Libvirt::open("qemu:///system")
+
+begin
+  `rm -f /etc/sysconfig/network-scripts/ifcfg-ruby-libvirt-tester`
+  `brctl delbr ruby-libvirt-tester >& /dev/null`
+rescue
+end
 
 new_interface_xml = <<EOF
-<interface type='bridge' name='testbr7'>
-  <bridge>
-    <interface type='ethernet' name='dummy'>
-    </interface>
+<interface type="bridge" name="ruby-libvirt-tester">
+  <start mode="onboot"/>
+  <bridge delay="0">
   </bridge>
 </interface>
 EOF
 
-# FIXME: doesn't work at the moment
-#new_interface = conn.define_interface_xml(new_interface_xml)
-#new_interface.undefine
+# 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
 
-defined = conn.list_defined_interfaces
-running = conn.list_interfaces
+expect_success(conn, "name arg", "lookup_interface_by_name", "ruby-libvirt-tester")
 
-(defined+running).each do |intname|
-  interface = conn.lookup_interface_by_name(intname)
-  int2 = conn.lookup_interface_by_mac(interface.mac)
-  puts "Interface #{interface.name}:"
-  puts " MAC: #{interface.mac}"
-  puts " XML:"
-  puts interface.xml_desc
+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: iface.undefine
+newiface = conn.define_interface_xml(new_interface_xml)
+
+expect_too_many_args(newiface, "undefine", 1)
+
+expect_success(newiface, "no args", "undefine")
+
+# TESTGROUP: iface.create
+newiface = conn.define_interface_xml(new_interface_xml)
+
+expect_too_many_args(newiface, "create", 1, 2)
+expect_invalid_arg_type(newiface, "create", 'foo')
+
+#expect_success(newiface, "no args", "create")
+
+#expect_fail(newiface, Libvirt::Error, "on already running interface", "create")
+
+#newiface.destroy
+newiface.undefine
+
+# TESTGROUP: iface.destroy
+newiface = conn.define_interface_xml(new_interface_xml)
+
+expect_too_many_args(newiface, "destroy", 1, 2)
+expect_invalid_arg_type(newiface, "destroy", 'foo')
+
+expect_success(newiface, "no args", "destroy")
+
+newiface.undefine
+
+# TESTGROUP: iface.active?
+newiface = conn.define_interface_xml(new_interface_xml)
+
+expect_too_many_args(newiface, "active?", 1)
+
+expect_success(newiface, "no args", "active?") {|x| x == false}
+
+#newiface.create
+#expect_success(newiface, "no args", "active?") {|x| x == true}
+
+#newiface.destroy
+newiface.undefine
+
+# TESTGROUP: iface.name
+newiface = conn.define_interface_xml(new_interface_xml)
+
+expect_too_many_args(newiface, "name", 1)
+
+expect_success(newiface, "no args", "name") {|x| x == "ruby-libvirt-tester"}
+
+newiface.undefine
+
+# TESTGROUP: iface.mac
+testiface = find_valid_iface(conn)
+if not testiface.nil?
+  expect_too_many_args(testiface, "mac", 1)
+
+  expect_success(testiface, "no args", "mac") {|x| x == testiface.mac}
+end
+
+# TESTGROUP: iface.xml_desc
+testiface = find_valid_iface(conn)
+if not testiface.nil?
+  expect_too_many_args(testiface, "xml_desc", 1, 2)
+  expect_invalid_arg_type(testiface, "xml_desc", "foo")
+  expect_success(testiface, "no args", "xml_desc")
+end
+
+# TESTGROUP: iface.free
+newiface = conn.define_interface_xml(new_interface_xml)
+newiface.undefine
+expect_too_many_args(newiface, "free", 1)
+
+expect_success(newiface, "no args", "free")
+
 conn.close
+
+finish_tests

data/tests/test_network.rb

@@ -2,39 +2,250 @@
 
 # Test the network methods the bindings support
 
+$: << File.dirname(__FILE__)
+
 require 'libvirt'
+require 'test_utils.rb'
+
+UUID = "04068860-d9a2-47c5-bc9d-9e047ae901da"
 
-conn = Libvirt::open
-puts "Number of Networks: #{conn.num_of_networks}"
-puts "Number of Defined Networks: #{conn.num_of_defined_networks}"
+conn = Libvirt::open("qemu:///system")
 
-new_network_xml = <<EOF
+# initial cleanup for previous run
+begin
+  oldnet = conn.lookup_network_by_name("ruby-libvirt-tester")
+  oldnet.destroy
+  oldnet.undefine
+rescue
+  # in case we didn't find it, don't do anything
+end
+
+new_net_xml = <<EOF
 <network>
-  <name>testnetwork</name>
-  <uuid>e0eed9fa-cb64-433f-066c-257a29b1c13a</uuid>
+  <name>ruby-libvirt-tester</name>
+  <uuid>#{UUID}</uuid>
+  <forward mode='nat'/>
+  <bridge name='rubybr0' stp='on' delay='0' />
+  <ip address='192.168.134.1' netmask='255.255.255.0'>
+    <dhcp>
+      <range start='192.168.134.2' end='192.168.134.254' />
+    </dhcp>
+  </ip>
 </network>
 EOF
 
-newnetwork = conn.define_network_xml(new_network_xml)
-newnetwork.create
-newnetwork.destroy
-newnetwork.undefine
-
-defined = conn.list_defined_networks
-running = conn.list_networks
-
-(defined+running).each do |netname|
-  network = conn.lookup_network_by_name(netname)
-  net2 = conn.lookup_network_by_uuid(network.uuid)
-
-  puts "Network #{network.name}:"
-  puts " UUID: #{network.uuid}"
-  puts " Autostart?: #{network.autostart?}"
-  puts " Active?: #{network.active?}"
-  puts " Persistent?: #{network.persistent?}"
-  puts " Bridge Name: #{network.bridge_name}"
-  puts " XML:"
-  puts network.xml_desc
+# 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", UUID)
+newnet.destroy
+
+newnet = conn.define_network_xml(new_net_xml)
+expect_success(conn, "uuid arg", "lookup_network_by_uuid", 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: net.undefine
+newnet = conn.define_network_xml(new_net_xml)
+
+expect_too_many_args(newnet, "undefine", 1)
+
+expect_success(newnet, "no args", "undefine")
+
+# TESTGROUP: net.create
+newnet = conn.define_network_xml(new_net_xml)
+
+expect_too_many_args(newnet, "create", 1)
+
+expect_success(newnet, "no args", "create")
+
+expect_fail(newnet, Libvirt::Error, "on already running network", "create")
+
+newnet.destroy
+newnet.undefine
+
+# TESTGROUP: net.destroy
+newnet = conn.create_network_xml(new_net_xml)
+
+expect_too_many_args(newnet, "destroy", 1)
+
+expect_success(newnet, "no args", "destroy")
+
+# TESTGROUP: net.name
+newnet = conn.create_network_xml(new_net_xml)
+
+expect_too_many_args(newnet, "name", 1)
+
+expect_success(newnet, "no args", "name") {|x| x == "ruby-libvirt-tester"}
+
+newnet.destroy
+
+# TESTGROUP: net.uuid
+newnet = conn.create_network_xml(new_net_xml)
+
+expect_too_many_args(newnet, "uuid", 1)
+
+expect_success(newnet, "no args", "uuid") {|x| x == UUID}
+
+newnet.destroy
+
+# TESTGROUP: net.xml_desc
+newnet = conn.create_network_xml(new_net_xml)
+
+expect_too_many_args(newnet, "xml_desc", 1, 2)
+expect_invalid_arg_type(newnet, "xml_desc", "foo")
+
+expect_success(newnet, "no args", "xml_desc")
+
+newnet.destroy
+
+# TESTGROUP: net.bridge_name
+newnet = conn.create_network_xml(new_net_xml)
+
+expect_too_many_args(newnet, "bridge_name", 1)
+
+expect_success(newnet, "no args", "bridge_name") {|x| x == "rubybr0"}
+
+newnet.destroy
+
+# TESTGROUP: net.autostart?
+newnet = conn.define_network_xml(new_net_xml)
+
+expect_too_many_args(newnet, "autostart?", 1)
+
+expect_success(newnet, "no args", "autostart?") {|x| x == false}
+
+newnet.autostart = true
+
+expect_success(newnet, "no args", "autostart?") {|x| x == true}
+
+newnet.undefine
+
+# TESTGROUP: net.autostart=
+newnet = conn.define_network_xml(new_net_xml)
+
+expect_too_many_args(newnet, "autostart=", 1, 2)
+expect_invalid_arg_type(newnet, "autostart=", 'foo')
+expect_invalid_arg_type(newnet, "autostart=", nil)
+expect_invalid_arg_type(newnet, "autostart=", 1234)
+
+expect_success(newnet, "boolean arg", "autostart=", true)
+if not newnet.autostart?
+  puts_fail "net.autostart= did not set autostart to true"
+else
+  puts_ok "net.autostart= set autostart to true"
 end
 
+expect_success(newnet, "boolean arg", "autostart=", false)
+if newnet.autostart?
+  puts_fail "net.autostart= did not set autostart to false"
+else
+  puts_ok "net.autostart= set autostart to false"
+end
+
+newnet.undefine
+
+# TESTGROUP: net.free
+newnet = conn.define_network_xml(new_net_xml)
+newnet.undefine
+expect_too_many_args(newnet, "free", 1)
+
+expect_success(newnet, "no args", "free")
+
+# TESTGROUP: net.active?
+newnet = conn.create_network_xml(new_net_xml)
+
+expect_too_many_args(newnet, "active?", 1)
+
+expect_success(newnet, "no args", "active?") {|x| x == true}
+
+newnet.destroy
+
+newnet = conn.define_network_xml(new_net_xml)
+
+expect_success(newnet, "no args", "active?") {|x| x == false}
+
+newnet.create
+
+expect_success(newnet, "no args", "active?") {|x| x == true}
+
+newnet.destroy
+newnet.undefine
+
+# TESTGROUP: net.persistent?
+newnet = conn.create_network_xml(new_net_xml)
+
+expect_too_many_args(newnet, "persistent?", 1)
+
+expect_success(newnet, "no args", "persistent?") {|x| x == false}
+
+newnet.destroy
+
+newnet = conn.define_network_xml(new_net_xml)
+
+expect_success(newnet, "no args", "persistent?") {|x| x == true}
+
+newnet.undefine
+
+
 conn.close
+
+finish_tests