ruby-libvirt-0.7.0/0000775000175000017500000000000012771053004015471 5ustar clalancetteclalancetteruby-libvirt-0.7.0/Rakefile0000664000175000017500000001114712771051617017152 0ustar clalancetteclalancette# -*- ruby -*- # Rakefile: build ruby libvirt bindings # # Copyright (C) 2007,2010 Red Hat, Inc. # Copyright (C) 2013,2014 Chris Lalancette # # Distributed under the GNU Lesser General Public License v2.1 or later. # See COPYING for details # # David Lutterkort # Rakefile for ruby-rpm -*- ruby -*- require 'rake/clean' begin require 'rdoc/task' rescue LoadError require 'rake/rdoctask' end require 'rake/testtask' require 'rubygems/package_task' require 'rbconfig' PKG_NAME='ruby-libvirt' PKG_VERSION='0.7.0' EXT_CONF='ext/libvirt/extconf.rb' MAKEFILE="ext/libvirt/Makefile" LIBVIRT_MODULE="ext/libvirt/_libvirt.so" SPEC_FILE="ruby-libvirt.spec" LIBVIRT_SRC=Dir.glob("ext/libvirt/*.c") LIBVIRT_SRC << MAKEFILE # # Additional files for clean/clobber # CLEAN.include [ "ext/**/*.o", LIBVIRT_MODULE, "ext/**/depend", "ext/**/*.gcda", "ext/**/*.gcno", "ext/**/*.gcov" ] CLOBBER.include [ "ext/**/mkmf.log", "ext/**/extconf.h", MAKEFILE ] task :default => :build # # Build locally # file MAKEFILE => EXT_CONF do |t| Dir::chdir(File::dirname(EXT_CONF)) do extra = "" args = ARGV.grep(/^--with-libvirt-include=/) extra += args[0].chomp unless args.empty? args = ARGV.grep(/^--with-libvirt-lib=/) extra += " " + args[0].chomp unless args.empty? unless sh "ruby #{File::basename(EXT_CONF)} #{extra}" $stderr.puts "Failed to run extconf" break end end end file LIBVIRT_MODULE => LIBVIRT_SRC do |t| Dir::chdir(File::dirname(EXT_CONF)) do unless sh "make" $stderr.puts "make failed" break end end end desc "Build the native library" task :build => LIBVIRT_MODULE # # Test task # Rake::TestTask.new(:test) do |t| t.test_files = [ 'tests/test_conn.rb', 'tests/test_domain.rb', 'tests/test_interface.rb', 'tests/test_network.rb', 'tests/test_nodedevice.rb', 'tests/test_nwfilter.rb', 'tests/test_open.rb', 'tests/test_secret.rb', 'tests/test_storage.rb', 'tests/test_stream.rb' ] t.libs = [ 'lib', 'ext/libvirt' ] end task :test => :build # # Documentation tasks # RDOC_FILES = FileList[ "README.rdoc", "lib/libvirt.rb", "ext/libvirt/_libvirt.c", "ext/libvirt/connect.c", "ext/libvirt/domain.c", "ext/libvirt/interface.c", "ext/libvirt/network.c", "ext/libvirt/nodedevice.c", "ext/libvirt/nwfilter.c", "ext/libvirt/secret.c", "ext/libvirt/storage.c", "ext/libvirt/stream.c" ] Rake::RDocTask.new do |rd| rd.main = "README.rdoc" rd.rdoc_dir = "doc/site/api" rd.rdoc_files.include(RDOC_FILES) end Rake::RDocTask.new(:ri) do |rd| rd.main = "README.rdoc" rd.rdoc_dir = "doc/ri" rd.options << "--ri-system" rd.rdoc_files.include(RDOC_FILES) end # # Splint task # task :splint => [ MAKEFILE ] do |t| Dir::chdir(File::dirname(EXT_CONF)) do unless sh "splint -I" + Config::CONFIG['vendorarchdir'] + " *.c" $stderr.puts "Failed to run splint" break end end end # # Package tasks # PKG_FILES = FileList[ "Rakefile", "COPYING", "README", "NEWS", "README.rdoc", "lib/**/*.rb", "ext/**/*.[ch]", "ext/**/MANIFEST", "ext/**/extconf.rb", "tests/**/*", "spec/**/*" ] DIST_FILES = FileList[ "pkg/*.src.rpm", "pkg/*.gem", "pkg/*.zip", "pkg/*.tgz" ] SPEC = Gem::Specification.new do |s| s.name = PKG_NAME s.version = PKG_VERSION s.email = "libvir-list@redhat.com" s.homepage = "http://libvirt.org/ruby/" s.summary = "Ruby bindings for LIBVIRT" s.files = PKG_FILES s.required_ruby_version = '>= 1.8.1' s.extensions = "ext/libvirt/extconf.rb" s.author = "David Lutterkort, Chris Lalancette" s.rubyforge_project = "None" s.description = "Ruby bindings for libvirt." s.license = "LGPLv2" end Gem::PackageTask.new(SPEC) do |pkg| pkg.need_tar = true pkg.need_zip = true end desc "Build (S)RPM for #{PKG_NAME}" task :rpm => [ :package ] do |t| system("sed -e 's/@VERSION@/#{PKG_VERSION}/' #{SPEC_FILE} > pkg/#{SPEC_FILE}") Dir::chdir("pkg") do |dir| dir = File::expand_path(".") system("rpmbuild --define '_topdir #{dir}' --define '_sourcedir #{dir}' --define '_srcrpmdir #{dir}' --define '_rpmdir #{dir}' --define '_builddir #{dir}' -ba #{SPEC_FILE} > rpmbuild.log 2>&1") if $? != 0 raise "rpmbuild failed" end end end ruby-libvirt-0.7.0/tests/0000775000175000017500000000000012771053004016633 5ustar clalancetteclalancetteruby-libvirt-0.7.0/tests/test_stream.rb0000664000175000017500000001155412532716436021532 0ustar clalancetteclalancette#!/usr/bin/ruby # Test the stream methods the bindings support $: << File.dirname(__FILE__) require 'libvirt' require 'test_utils.rb' set_test_object("stream") conn = Libvirt::open(URI) # TESTGROUP: stream.send st = conn.stream expect_too_many_args(st, "send", 1, 2) expect_too_few_args(st, "send") expect_invalid_arg_type(st, "send", 1) expect_invalid_arg_type(st, "send", nil) expect_invalid_arg_type(st, "send", []) expect_invalid_arg_type(st, "send", {}) # FIXME: we need to setup a proper stream for this to work #expect_success(st, "buffer arg", "send", buffer) st.free # TESTGROUP: stream.recv st = conn.stream expect_too_many_args(st, "recv", 1, 2) expect_too_few_args(st, "recv") expect_invalid_arg_type(st, "recv", nil) expect_invalid_arg_type(st, "recv", 'foo') expect_invalid_arg_type(st, "recv", []) expect_invalid_arg_type(st, "recv", {}) # FIXME: we need to setup a proper stream for this to work #expect_success(st, "bytes arg", "recv", 12) st.free # TESTGROUP: stream.sendall st = conn.stream # equivalent to expect_too_many_args begin st.sendall(1, 2) {|x,y| x = y} rescue NoMethodError puts_skipped "#{$test_object}.sendall does not exist" rescue ArgumentError => e puts_ok "#{$test_object}.sendall too many args threw #{ArgumentError.to_s}" rescue => e puts_fail "#{$test_object}.sendall too many args expected to throw #{ArgumentError.to_s}, but instead threw #{e.class.to_s}: #{e.to_s}" else puts_fail "#{$test_object}.sendall too many args expected to throw #{ArgumentError.to_s}, but threw nothing" end expect_fail(st, RuntimeError, "no block given", "sendall") # FIXME: we need to setup a proper stream for this to work #st.sendall {|opaque,nbytes| return opaque} st.free # TESTGROUP: stream.recvall st = conn.stream # equivalent to expect_too_many_args begin st.recvall(1, 2) {|x,y| x = y} rescue NoMethodError puts_skipped "#{$test_object}.recvall does not exist" rescue ArgumentError => e puts_ok "#{$test_object}.recvall too many args threw #{ArgumentError.to_s}" rescue => e puts_fail "#{$test_object}.recvall too many args expected to throw #{ArgumentError.to_s}, but instead threw #{e.class.to_s}: #{e.to_s}" else puts_fail "#{$test_object}.recvall too many args expected to throw #{ArgumentError.to_s}, but threw nothing" end expect_fail(st, RuntimeError, "no block given", "recvall") # FIXME: we need to setup a proper stream for this to work #st.recvall {|data,opaque| return opaque} st.free # TESTGROUP: stream.event_add_callback st_event_callback_proc = lambda {|st,events,opaque| } st = conn.stream expect_too_many_args(st, "event_add_callback", 1, 2, 3, 4) expect_too_few_args(st, "event_add_callback") expect_too_few_args(st, "event_add_callback", 1) expect_invalid_arg_type(st, "event_add_callback", nil, st_event_callback_proc) expect_invalid_arg_type(st, "event_add_callback", 'foo', st_event_callback_proc) expect_invalid_arg_type(st, "event_add_callback", [], st_event_callback_proc) expect_invalid_arg_type(st, "event_add_callback", {}, st_event_callback_proc) expect_invalid_arg_type(st, "event_add_callback", 1, nil) expect_invalid_arg_type(st, "event_add_callback", 1, 'foo') expect_invalid_arg_type(st, "event_add_callback", 1, 1) expect_invalid_arg_type(st, "event_add_callback", 1, []) expect_invalid_arg_type(st, "event_add_callback", 1, {}) # FIXME: I get "this function is not support by the connection driver" #expect_success(st, "events and callback arg", "event_add_callback", Libvirt::Stream::EVENT_READABLE, st_event_callback_proc) #st.event_remove_callback st.free # TESTGROUP: stream.event_update_callback st = conn.stream expect_too_many_args(st, "event_update_callback", 1, 2) expect_too_few_args(st, "event_update_callback") expect_invalid_arg_type(st, "event_update_callback", nil) expect_invalid_arg_type(st, "event_update_callback", 'foo') expect_invalid_arg_type(st, "event_update_callback", []) expect_invalid_arg_type(st, "event_update_callback", {}) # FIXME: we would need to get st.event_add_callback working to get this working #expect_success(st, "events arg", "event_update_callback", Libvirt::Stream::EVENT_WRITABLE) st.free # TESTGROUP: stream.remove_callback st = conn.stream expect_too_many_args(st, "event_remove_callback", 1) # FIXME: we would need to get st.event_add_callback working to get this working #expect_success(st, "no arg", "event_remove_callback") st.free # TESTGROUP: stream.finish st = conn.stream expect_too_many_args(st, "finish", 1) # FIXME: I get "this function is not support by the connection driver" #expect_success(st, "no arg", "finish") st.free # TESTGROUP: stream.abort st = conn.stream expect_too_many_args(st, "abort", 1) # FIXME: I get "this function is not support by the connection driver" #expect_success(st, "no arg", "abort") st.free # TESTGROUP: stream.abort st = conn.stream expect_too_many_args(st, "free", 1) expect_success(st, "no arg", "free") # END TESTS conn.close finish_tests ruby-libvirt-0.7.0/tests/test_nwfilter.rb0000664000175000017500000000234312623645477022074 0ustar clalancetteclalancette#!/usr/bin/ruby # Test the nwfilter methods the bindings support $: << File.dirname(__FILE__) require 'libvirt' require 'test_utils.rb' set_test_object("nwfilter") conn = Libvirt::open("qemu:///system") # TESTGROUP: nwfilter.undefine newnw = conn.define_nwfilter_xml($new_nwfilter_xml) expect_too_many_args(newnw, "undefine", 1) 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 == "rb-libvirt-test"} 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 == $NWFILTER_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") # END TESTS conn.close finish_tests ruby-libvirt-0.7.0/tests/test_secret.rb0000664000175000017500000000575312450406160021515 0ustar clalancetteclalancette#!/usr/bin/ruby # Test the secret methods the bindings support $: << File.dirname(__FILE__) require 'libvirt' require 'test_utils.rb' set_test_object("secret") conn = Libvirt::open("qemu:///system") # 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 == $SECRET_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.value= newsecret = conn.define_secret_xml($new_secret_xml) expect_too_many_args(newsecret, "value=", 1, 2) expect_too_few_args(newsecret, "value=") expect_invalid_arg_type(newsecret, "value=", {}) expect_invalid_arg_type(newsecret, "value=", nil) expect_invalid_arg_type(newsecret, "value=", 1) expect_invalid_arg_type(newsecret, "value=", [1, 1]) expect_invalid_arg_type(newsecret, "value=", [nil, 1]) expect_invalid_arg_type(newsecret, "value=", [[], 1]) expect_invalid_arg_type(newsecret, "value=", [{}, 1]) expect_invalid_arg_type(newsecret, "value=", ['foo', nil]) expect_invalid_arg_type(newsecret, "value=", ['foo', 'foo']) expect_invalid_arg_type(newsecret, "value=", ['foo', []]) expect_invalid_arg_type(newsecret, "value=", ['foo', {}]) expect_success(newsecret, "value arg", "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") # END TESTS conn.close finish_tests ruby-libvirt-0.7.0/tests/test_conn.rb0000664000175000017500000007773012623645602021201 0ustar clalancetteclalancette#!/usr/bin/ruby # Test the conn methods the bindings support $: << File.dirname(__FILE__) require 'libvirt' require 'test_utils.rb' set_test_object("connect") conn = Libvirt::open("qemu:///system") 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 end `qemu-img create -f qcow2 #{$GUEST_DISK} 5G` `rm -rf #{$POOL_PATH}; mkdir #{$POOL_PATH} ; echo $?` cpu_xml = < x86_64 athlon EOF # TESTGROUP: conn.close conn2 = Libvirt::open("qemu:///system") expect_too_many_args(conn2, "close", 1) expect_success(conn2, "no args", "close") # TESTGROUP: conn.closed? conn2 = Libvirt::open("qemu:///system") expect_too_many_args(conn2, "closed?", 1) expect_success(conn2, "no args", "closed?") {|x| x == false } conn2.close 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"} # TESTGROUP: conn.version expect_too_many_args(conn, "version", 1) expect_success(conn, "no args", "version") # TESTGROUP: conn.libversion expect_too_many_args(conn, "libversion", 1) expect_success(conn, "no args", "libversion") # TESTGROUP: conn.hostname expect_too_many_args(conn, "hostname", 1) 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" } # TESTGROUP: conn.max_vcpus expect_too_many_args(conn, "max_vcpus", 'kvm', 1) expect_fail(conn, Libvirt::RetrieveError, "invalid arg", "max_vcpus", "foo") expect_success(conn, "no args", "max_vcpus") expect_success(conn, "nil arg", "max_vcpus") expect_success(conn, "kvm arg", "max_vcpus") expect_success(conn, "qemu arg", "max_vcpus") # TESTGROUP: conn.node_get_info expect_too_many_args(conn, "node_get_info", 1) expect_success(conn, "no args", "node_get_info") # TESTGROUP: conn.node_free_memory expect_too_many_args(conn, "node_free_memory", 1) expect_success(conn, "no args", "node_free_memory") # TESTGROUP: conn.node_cells_free_memory expect_too_many_args(conn, "node_cells_free_memory", 1, 2, 3) expect_invalid_arg_type(conn, "node_cells_free_memory", 'start') expect_invalid_arg_type(conn, "node_cells_free_memory", 0, 'end') expect_success(conn, "no args", "node_cells_free_memory") expect_success(conn, "start cell", "node_cells_free_memory", 0) expect_success(conn, "start cell and max cells", "node_cells_free_memory", 0, 1) # TESTGROUP: conn.node_get_security_model expect_too_many_args(conn, "node_get_security_model", 1) expect_success(conn, "no args", "node_get_security_model") # TESTGROUP: conn.encrypted? expect_too_many_args(conn, "encrypted?", 1) expect_success(conn, "no args", "encrypted?") # TESTGROUP: conn.secure? expect_too_many_args(conn, "secure?", 1) expect_success(conn, "no args", "secure?") {|x| x == true} # TESTGROUP: conn.capabilities 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) # TESTGROUP: conn.baseline_cpu expect_too_many_args(conn, "baseline_cpu", 1, 2, 3) expect_too_few_args(conn, "baseline_cpu") expect_invalid_arg_type(conn, "baseline_cpu", 1) expect_invalid_arg_type(conn, "baseline_cpu", [cpu_xml], "foo") expect_fail(conn, ArgumentError, "empty array", "baseline_cpu", []) expect_success(conn, "CPU XML", "baseline_cpu", [cpu_xml]) # TESTGROUP: conn.domain_event_register_any dom_event_callback_proc = lambda {|conn, dom, event, detail, opaque| } # def dom_event_callback_symbol(conn, dom, event, detail, opaque) # end expect_too_many_args(conn, "domain_event_register_any", 1, 2, 3, 4, 5) expect_too_few_args(conn, "domain_event_register_any") expect_too_few_args(conn, "domain_event_register_any", 1) expect_invalid_arg_type(conn, "domain_event_register_any", "hello", 1) expect_invalid_arg_type(conn, "domain_event_register_any", Libvirt::Connect::DOMAIN_EVENT_ID_LIFECYCLE, 1) expect_invalid_arg_type(conn, "domain_event_register_any", Libvirt::Connect::DOMAIN_EVENT_ID_LIFECYCLE, dom_event_callback_proc, 1) expect_fail(conn, ArgumentError, "invalid event ID", "domain_event_register_any", 456789, dom_event_callback_proc) # callbackID = expect_success(conn, "eventID and proc", "domain_event_register_any", Libvirt::Connect::DOMAIN_EVENT_ID_LIFECYCLE, dom_event_callback_proc) # conn.domain_event_deregister_any(callbackID) # callbackID = expect_success(conn, "eventID and symbol", "domain_event_register_any", Libvirt::Connect::DOMAIN_EVENT_ID_LIFECYCLE, :dom_event_callback_symbol) # conn.domain_event_deregister_any(callbackID) # callbackID = expect_success(conn, "eventID, proc, nil domain", "domain_event_register_any", Libvirt::Connect::DOMAIN_EVENT_ID_LIFECYCLE, dom_event_callback_proc, nil) # conn.domain_event_deregister_any(callbackID) # callbackID = expect_success(conn, "eventID, proc, nil domain, opaque", "domain_event_register_any", Libvirt::Connect::DOMAIN_EVENT_ID_LIFECYCLE, dom_event_callback_proc, nil, "opaque user data") # conn.domain_event_deregister_any(callbackID) # # TESTGROUP: conn.domain_event_deregister_any # dom_event_callback_proc = lambda {|conn, dom, event, detail, opaque| # } # callbackID = conn.domain_event_register_any(Libvirt::Connect::DOMAIN_EVENT_ID_LIFECYCLE, dom_event_callback_proc) expect_too_many_args(conn, "domain_event_deregister_any", 1, 2) expect_too_few_args(conn, "domain_event_deregister_any") expect_invalid_arg_type(conn, "domain_event_deregister_any", "hello") # expect_success(conn, "callbackID", "domain_event_deregister_any", callbackID) # TESTGROUP: conn.domain_event_register # dom_event_callback_proc = lambda {|conn, dom, event, detail, opaque| # } # def dom_event_callback_symbol(conn, dom, event, detail, opaque) # end expect_too_many_args(conn, "domain_event_register", 1, 2, 3) expect_too_few_args(conn, "domain_event_register") expect_invalid_arg_type(conn, "domain_event_register", "hello") # expect_success(conn, "proc", "domain_event_register", dom_event_callback_proc) # conn.domain_event_deregister # expect_success(conn, "symbol", "domain_event_register", :dom_event_callback_symbol) # conn.domain_event_deregister # expect_success(conn, "proc and opaque", "domain_event_register", dom_event_callback_proc, "opaque user data") # conn.domain_event_deregister # # TESTGROUP: conn.domain_event_deregister # dom_event_callback_proc = lambda {|conn, dom, event, detail, opaque| # } # 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") newdom = conn.create_domain_xml($new_dom_xml) sleep 1 expect_success(conn, "no args", "list_domains") newdom.destroy # 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", "rb-libvirt-test") {|x| x.name == "rb-libvirt-test"} newdom.destroy newdom = conn.define_domain_xml($new_dom_xml) expect_success(conn, "name arg for defined domain", "lookup_domain_by_name", "rb-libvirt-test") {|x| x.name == "rb-libvirt-test"} 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", "rb-libvirt-test") expect_success(conn, "name arg", "lookup_interface_by_name", "rb-libvirt-test") 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") # FIXME: we can't look up an interface by MAC address on an inactive interface, # but we also can't start up the interface without a /etc/sysconfig file. #expect_success(conn, "mac arg", "lookup_interface_by_mac", $NEW_INTERFACE_MAC) {|x| x.mac == $NEW_INTERFACE_MAC} 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", "rb-libvirt-test") newnet.destroy newnet = conn.define_network_xml($new_net_xml) expect_success(conn, "name arg", "lookup_network_by_name", "rb-libvirt-test") 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", "") # 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", "rb-libvirt-test") 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", "rb-libvirt-test") newpool.destroy newpool = conn.define_storage_pool_xml($new_storage_pool_xml) expect_success(conn, "name arg", "lookup_storage_pool_by_name", "rb-libvirt-test") 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") # TESTGROUP: conn.interface_change_begin expect_too_many_args(conn, "interface_change_begin", 1, 2) expect_invalid_arg_type(conn, "interface_change_begin", 'hello') expect_success(conn, "interface change begin", "interface_change_begin") conn.interface_change_rollback # TESTGROUP: conn.interface_change_commit expect_too_many_args(conn, "interface_change_commit", 1, 2) expect_invalid_arg_type(conn, "interface_change_commit", 'foo') # FIXME: libvirt throws an error on commit with no changes. What changes can # we do here? #expect_success(conn, "interface change commit", "interface_change_commit") # TESTGROUP: conn.interface_change_rollback conn.interface_change_begin expect_too_many_args(conn, "interface_change_rollback", 1, 2) expect_invalid_arg_type(conn, "interface_change_rollback", 'foo') expect_success(conn, "interface change rollback", "interface_change_rollback") # TESTGROUP: conn.node_cpu_stats expect_too_many_args(conn, "node_cpu_stats", 1, 2, 3) expect_invalid_arg_type(conn, "node_cpu_stats", 'foo') 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') expect_success(conn, "node memory status", "node_memory_stats") # 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}` # TESTGROUP: conn.define_save_image_xml expect_too_many_args(conn, "define_save_image_xml", 1, 2, 3, 4) expect_too_few_args(conn, "define_save_image_xml") expect_too_few_args(conn, "define_save_image_xml", 'foo') expect_invalid_arg_type(conn, "define_save_image_xml", nil, 'foo') expect_invalid_arg_type(conn, "define_save_image_xml", 1, 'foo') expect_invalid_arg_type(conn, "define_save_image_xml", 'foo', nil) expect_invalid_arg_type(conn, "define_save_image_xml", 'foo', 1) expect_invalid_arg_type(conn, "define_save_image_xml", 'foo', 'bar', 'baz') # TESTGROUP: conn.alive? 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") expect_success(conn, "no args", "list_all_nwfilters") # TESTGROUP: conn.list_all_storage_pools expect_too_many_args(conn, "list_all_storage_pools", 1, 2) expect_invalid_arg_type(conn, "list_all_storage_pools", "foo") expect_success(conn, "no args", "list_all_storage_pools") # TESTGROUP: conn.list_all_nodedevices expect_too_many_args(conn, "list_all_nodedevices", 1, 2) 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") expect_success(conn, "no args", "list_all_secrets") # TESTGROUP: conn.list_all_interfaces expect_too_many_args(conn, "list_all_interfaces", 1, 2) expect_invalid_arg_type(conn, "list_all_interfaces", "foo") expect_success(conn, "no args", "list_all_interfaces") # TESTGROUP: conn.list_all_networks expect_too_many_args(conn, "list_all_networks", 1, 2) expect_invalid_arg_type(conn, "list_all_networks", "foo") expect_success(conn, "no args", "list_all_networks") # TESTGROUP: conn.list_all_domains expect_too_many_args(conn, "list_all_domains", 1, 2) expect_invalid_arg_type(conn, "list_all_domains", "foo") expect_success(conn, "no args", "list_all_domains") # TESTGROUP: conn.set_keepalive expect_too_many_args(conn, "set_keepalive", 1, 2, 3, 4) expect_too_few_args(conn, "set_keepalive") expect_too_few_args(conn, "set_keepalive", 1) expect_invalid_arg_type(conn, "set_keepalive", 'foo', 0) expect_invalid_arg_type(conn, "set_keepalive", 0, 'foo') # FIXME: somehow we need an event loop implementation for this to work #expect_success(conn, "interval and count", "set_keepalive", 1, 10) # TESTGROUP: conn.node_suspend_for_duration expect_too_many_args(conn, "node_suspend_for_duration", 1, 2, 3, 4) expect_too_few_args(conn, "node_suspend_for_duration") expect_too_few_args(conn, "node_suspend_for_duration", 1) expect_invalid_arg_type(conn, "node_suspend_for_duration", 'foo', 1) 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') expect_success(conn, "no args", "node_memory_parameters") # TESTGROUP: conn.node_memory_paramters= expect_too_many_args(conn, "node_memory_parameters=", 1, 2) expect_invalid_arg_type(conn, "node_memory_parameters=", nil) expect_invalid_arg_type(conn, "node_memory_parameters=", ['foo', 0]) expect_invalid_arg_type(conn, "node_memory_parameters=", [{}, 'foo']) # TESTGROUP: conn.keepalive= expect_too_many_args(conn, "keepalive=", 1, 2) expect_too_few_args(conn, "keepalive=", []) expect_too_few_args(conn, "keepalive=", [1]) expect_invalid_arg_type(conn, "keepalive=", 1) expect_invalid_arg_type(conn, "keepalive=", ['foo', 1]) expect_invalid_arg_type(conn, "keepalive=", [1, 'foo']) # FIXME: somehow we need an event loop implementation for this to work #expect_success(conn, "interval and count", "keepalive=", 1, 10) # END TESTS conn.close finish_tests ruby-libvirt-0.7.0/tests/test_network.rb0000664000175000017500000000774012623645504021730 0ustar clalancetteclalancette#!/usr/bin/ruby # Test the network methods the bindings support $: << File.dirname(__FILE__) require 'libvirt' require 'test_utils.rb' set_test_object("network") conn = Libvirt::open("qemu:///system") cleanup_test_network(conn) # 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.update newnet = conn.create_network_xml($new_net_xml) expect_too_few_args(newnet, "update", 1) command = Libvirt::Network::NETWORK_UPDATE_COMMAND_ADD_LAST section = Libvirt::Network::NETWORK_SECTION_IP_DHCP_HOST flags = Libvirt::Network::NETWORK_UPDATE_AFFECT_CURRENT expect_success(newnet, "dhcp ip", "update", command, section, -1, $new_network_dhcp_ip, flags) newnet.destroy # 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 == "rb-libvirt-test"} 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 == $NETWORK_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 "network.autostart= did not set autostart to true" else puts_ok "network.autostart= set autostart to true" end expect_success(newnet, "boolean arg", "autostart=", false) if newnet.autostart? puts_fail "network.autostart= did not set autostart to false" else puts_ok "network.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 # END TESTS conn.close finish_tests ruby-libvirt-0.7.0/tests/test_utils.rb0000664000175000017500000001504712623645455021403 0ustar clalancetteclalancette$FAIL = 0 $SUCCESS = 0 $SKIPPED = 0 URI = ENV['RUBY_LIBVIRT_TEST_URI'] || "qemu:///system" $GUEST_BASE = '/var/lib/libvirt/images/rb-libvirt-test' $GUEST_DISK = $GUEST_BASE + '.qcow2' $GUEST_SAVE = $GUEST_BASE + '.save' $GUEST_UUID = "93a5c045-6457-2c09-e56f-927cdf34e17a" # XML data for later tests $new_dom_xml = < Ruby Libvirt Tester rb-libvirt-test #{$GUEST_UUID} 1048576 1048576 2 hvm destroy restart restart EOF # qemu command-line that roughly corresponds to the above XML $qemu_cmd_line = "/usr/bin/qemu-kvm -S -M pc-0.13 -enable-kvm -m 1024 -smp 1,sockets=1,cores=1,threads=1 -name rb-libvirt-test -uuid #{$GUEST_UUID} -nodefconfig -nodefaults -chardev socket,id=monitor,path=/var/lib/libvirt/qemu/rb-libvirt-test.monitor,server,nowait -mon chardev=monitor,mode=readline -rtc base=utc -boot c -chardev pty,id=serial0 -device isa-serial,chardev=serial0 -usb -vnc 127.0.0.1:0 -k en-us -vga cirrus -device virtio-balloon-pci,id=balloon0,bus=pci.0,addr=0x5" $NEW_INTERFACE_MAC = 'aa:bb:cc:dd:ee:ff' $new_interface_xml = < EOF $NETWORK_UUID = "04068860-d9a2-47c5-bc9d-9e047ae901da" $new_net_xml = < rb-libvirt-test #{$NETWORK_UUID} EOF $new_network_dhcp_ip = < EOF $NWFILTER_UUID = "bd339530-134c-6d07-441a-17fb90dad807" $new_nwfilter_xml = < #{$NWFILTER_UUID} EOF $SECRET_UUID = "bd339530-134c-6d07-4410-17fb90dad805" $new_secret_xml = < test secret #{$SECRET_UUID} /var/lib/libvirt/images/mail.img EOF $POOL_UUID = "33a5c045-645a-2c00-e56b-927cdf34e17a" $POOL_PATH = "/var/lib/libvirt/images/rb-libvirt-test" $new_storage_pool_xml = < rb-libvirt-test #{$POOL_UUID} #{$POOL_PATH} EOF $test_object = "unknown" def set_test_object(obj) $test_object = obj end def expect_success(object, msg, func, *args) begin x = object.__send__(func, *args) if block_given? res = yield x if not res raise "block failed" end end puts_ok "#{$test_object}.#{func} #{msg} succeeded" x rescue NoMethodError puts_skipped "#{$test_object}.#{func} does not exist" rescue => e puts_fail "#{$test_object}.#{func} #{msg} expected to succeed, threw #{e.class.to_s}: #{e.to_s}" end end def expect_fail(object, errtype, errmsg, func, *args) begin object.__send__(func, *args) rescue NoMethodError puts_skipped "#{$test_object}.#{func} does not exist" rescue errtype => e puts_ok "#{$test_object}.#{func} #{errmsg} threw #{errtype.to_s}" rescue => e puts_fail "#{$test_object}.#{func} #{errmsg} expected to throw #{errtype.to_s}, but instead threw #{e.class.to_s}: #{e.to_s}" else puts_fail "#{$test_object}.#{func} #{errmsg} expected to throw #{errtype.to_s}, but threw nothing" end end def expect_too_many_args(object, func, *args) expect_fail(object, ArgumentError, "too many args", func, *args) end def expect_too_few_args(object, func, *args) expect_fail(object, ArgumentError, "too few args", func, *args) end def expect_invalid_arg_type(object, func, *args) expect_fail(object, TypeError, "invalid arg type", func, *args) end def puts_ok(str) puts "OK: " + str $SUCCESS = $SUCCESS + 1 end def puts_fail(str) puts "FAIL: " + str $FAIL = $FAIL + 1 end def puts_skipped(str) puts "SKIPPED: " + str $SKIPPED = $SKIPPED + 1 end def finish_tests puts "Successfully finished #{$SUCCESS} tests, failed #{$FAIL} tests, skipped #{$SKIPPED} tests" end 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 return nil end def cleanup_test_domain(conn) # cleanup from previous runs begin olddom = conn.lookup_domain_by_name("rb-libvirt-test") rescue # in case we didn't find it, don't do anything end begin olddom.destroy rescue # in case we didn't destroy it, don't do anything end begin olddom.undefine(Libvirt::Domain::UNDEFINE_SNAPSHOTS_METADATA) rescue # in case we didn't undefine it, don't do anything end `rm -f #{$GUEST_DISK}` `rm -f #{$GUEST_SAVE}` end def cleanup_test_network(conn) # initial cleanup for previous run begin oldnet = conn.lookup_network_by_name("rb-libvirt-test") rescue # in case we didn't find it, don't do anything end begin oldnet.destroy rescue # in case we didn't find it, don't do anything end begin oldnet.undefine rescue # in case we didn't find it, don't do anything end end ruby-libvirt-0.7.0/tests/test_domain.rb0000664000175000017500000012636712623646335021520 0ustar clalancetteclalancette#!/usr/bin/ruby # Test the domain methods the bindings support. Note that this tester requires # the qemu driver to be enabled and available for use. # Note that the order of the TESTGROUPs below match the order that the # functions are defined in the ext/libvirt/domain.c file $: << File.dirname(__FILE__) require 'libvirt' require 'test_utils.rb' set_test_object("domain") conn = Libvirt::open("qemu:///system") cleanup_test_domain(conn) # setup for later tests `qemu-img create -f qcow2 #{$GUEST_DISK} 5G` new_hostdev_xml = <
EOF # start tests # TESTGROUP: dom.migrate_max_speed newdom = conn.create_domain_xml($new_dom_xml) sleep 1 expect_too_many_args(newdom, "migrate_max_speed", 1, 2) expect_invalid_arg_type(newdom, "migrate_max_speed", 'foo') expect_invalid_arg_type(newdom, "migrate_max_speed", []) expect_invalid_arg_type(newdom, "migrate_max_speed", {}) expect_success(newdom, "no args", "migrate_max_speed") newdom.destroy # TESTGROUP: dom.reset newdom = conn.create_domain_xml($new_dom_xml) sleep 1 expect_too_many_args(newdom, "reset", 1, 2) expect_invalid_arg_type(newdom, "reset", 'foo') expect_invalid_arg_type(newdom, "reset", []) expect_invalid_arg_type(newdom, "reset", {}) expect_success(newdom, "no args", "reset") newdom.destroy # TESTGROUP: dom.hostname newdom = conn.create_domain_xml($new_dom_xml) sleep 1 expect_too_many_args(newdom, "hostname", 1, 2) expect_invalid_arg_type(newdom, "hostname", 'foo') expect_invalid_arg_type(newdom, "hostname", []) expect_invalid_arg_type(newdom, "hostname", {}) # FIXME: spits an error "this function is not supported by the connection driver" #expect_success(newdom, "no args", "hostname") newdom.destroy # TESTGROUP: dom.metadata newdom = conn.create_domain_xml($new_dom_xml) sleep 1 expect_too_many_args(newdom, "metadata", 1, 2, 3, 4) expect_too_few_args(newdom, "metadata") expect_invalid_arg_type(newdom, "metadata", 'foo') expect_invalid_arg_type(newdom, "metadata", nil) expect_invalid_arg_type(newdom, "metadata", []) expect_invalid_arg_type(newdom, "metadata", {}) expect_invalid_arg_type(newdom, "metadata", 1, 1) expect_invalid_arg_type(newdom, "metadata", 1, 'foo', 'bar') expect_success(newdom, "no args", "metadata", Libvirt::Domain::METADATA_DESCRIPTION) {|x| x == "Ruby Libvirt Tester"} newdom.destroy # TESTGROUP: dom.metadata= newdom = conn.create_domain_xml($new_dom_xml) sleep 1 expect_too_many_args(newdom, "metadata=", 1, 2, 3, 4, 5, 6) expect_too_few_args(newdom, "metadata=") expect_too_few_args(newdom, "metadata=", [1]) expect_invalid_arg_type(newdom, "metadata=", 1) expect_invalid_arg_type(newdom, "metadata=", 'foo') expect_invalid_arg_type(newdom, "metadata=", nil) expect_invalid_arg_type(newdom, "metadata=", {}) expect_invalid_arg_type(newdom, "metadata=", ['foo', nil]) expect_invalid_arg_type(newdom, "metadata=", [nil, nil]) expect_invalid_arg_type(newdom, "metadata=", [[], nil]) expect_invalid_arg_type(newdom, "metadata=", [{}, nil]) expect_invalid_arg_type(newdom, "metadata=", [1, 1]) expect_invalid_arg_type(newdom, "metadata=", [1, []]) expect_invalid_arg_type(newdom, "metadata=", [1, {}]) expect_success(newdom, "no args", "metadata=", [Libvirt::Domain::METADATA_DESCRIPTION, 'foo']) expect_success(newdom, "no args", "metadata=", [Libvirt::Domain::METADATA_DESCRIPTION, 'foo', nil, nil, 0]) expect_success(newdom, "no args", "metadata", Libvirt::Domain::METADATA_DESCRIPTION) {|x| x == "foo"} newdom.destroy # TESTGROUP: dom.updated? newdom = conn.create_domain_xml($new_dom_xml) sleep 1 expect_too_many_args(newdom, "updated?", 1) expect_success(newdom, "no args", "updated?") newdom.destroy # TESTGROUP: dom.inject_nmi newdom = conn.create_domain_xml($new_dom_xml) sleep 1 expect_too_many_args(newdom, "inject_nmi", 1, 2) expect_invalid_arg_type(newdom, "inject_nmi", 'foo') expect_success(newdom, "no args", "inject_nmi") newdom.destroy # TESTGROUP: dom.control_info newdom = conn.create_domain_xml($new_dom_xml) sleep 1 expect_too_many_args(newdom, "control_info", 1, 2) expect_invalid_arg_type(newdom, "control_info", 'foo') expect_success(newdom, "no args", "control_info") newdom.destroy # TESTGROUP: dom.send_key newdom = conn.create_domain_xml($new_dom_xml) sleep 30 expect_too_many_args(newdom, "send_key", 1, 2, 3, 4) expect_too_few_args(newdom, "send_key") expect_too_few_args(newdom, "send_key", 1) expect_too_few_args(newdom, "send_key", 1, 2) expect_invalid_arg_type(newdom, "send_key", nil, 0, []) expect_invalid_arg_type(newdom, "send_key", nil, 0, [1]) expect_invalid_arg_type(newdom, "send_key", 'foo', 0, []) expect_invalid_arg_type(newdom, "send_key", 0, nil, []) expect_invalid_arg_type(newdom, "send_key", 0, 'foo', []) expect_invalid_arg_type(newdom, "send_key", 0, 1, nil) expect_invalid_arg_type(newdom, "send_key", 0, 1, 'foo') expect_invalid_arg_type(newdom, "send_key", 0, 1, 2) expect_invalid_arg_type(newdom, "send_key", nil, 0, [nil]) expect_invalid_arg_type(newdom, "send_key", nil, 0, ['foo']) # FIXME: this fails for reasons that are unclear to me #expect_success(newdom, "codeset, holdtime, keycodes args", "send_key", 0, 1, []) newdom.destroy # TESTGROUP: dom.migrate newdom = conn.create_domain_xml($new_dom_xml) sleep 1 dconn = Libvirt::open("qemu:///system") expect_too_many_args(newdom, "migrate", 1, 2, 3, 4, 5, 6) expect_too_few_args(newdom, "migrate") expect_fail(newdom, ArgumentError, "invalid connection object", "migrate", "foo") expect_invalid_arg_type(newdom, "migrate", dconn, 'foo') expect_invalid_arg_type(newdom, "migrate", dconn, 0, 1) expect_invalid_arg_type(newdom, "migrate", dconn, 0, 'foo', 1) expect_invalid_arg_type(newdom, "migrate", dconn, 0, 'foo', 'bar', 'baz') # FIXME: how can we make this work? #expect_success(newdom, "conn arg", "migrate", dconn) dconn.close newdom.destroy # TESTGROUP: dom.migrate_to_uri newdom = conn.create_domain_xml($new_dom_xml) sleep 1 expect_too_many_args(newdom, "migrate_to_uri", 1, 2, 3, 4, 5) expect_too_few_args(newdom, "migrate_to_uri") expect_invalid_arg_type(newdom, "migrate_to_uri", 1) expect_invalid_arg_type(newdom, "migrate_to_uri", "qemu:///system", 'foo') expect_invalid_arg_type(newdom, "migrate_to_uri", "qemu:///system", 0, 1) expect_invalid_arg_type(newdom, "migrate_to_uri", "qemu:///system", 0, 'foo', 'bar') #expect_success(newdom, "URI arg", "migrate_to_uri", "qemu://remote/system") dconn.close newdom.destroy # TESTGROUP: dom.migrate_set_max_downtime newdom = conn.define_domain_xml($new_dom_xml) expect_too_many_args(newdom, "migrate_set_max_downtime", 1, 2, 3) expect_too_few_args(newdom, "migrate_set_max_downtime") expect_invalid_arg_type(newdom, "migrate_set_max_downtime", 'foo') expect_invalid_arg_type(newdom, "migrate_set_max_downtime", 10, 'foo') expect_fail(newdom, Libvirt::Error, "on off domain", "migrate_set_max_downtime", 10) newdom.undefine newdom = conn.create_domain_xml($new_dom_xml) sleep 1 #expect_fail(newdom, Libvirt::Error, "while no migration in progress", "migrate_set_max_downtime", 10) #newdom.migrate_to_uri("qemu://remote/system") #expect_success(newdom, "10 second downtime", "migrate_set_max_downtime", 10) newdom.destroy # TESTGROUP: dom.migrate2 newdom = conn.create_domain_xml($new_dom_xml) sleep 1 dconn = Libvirt::open("qemu:///system") expect_too_many_args(newdom, "migrate2", 1, 2, 3, 4, 5, 6, 7) expect_too_few_args(newdom, "migrate2") expect_fail(newdom, ArgumentError, "invalid connection object", "migrate2", "foo") expect_invalid_arg_type(newdom, "migrate2", dconn, 0) # FIXME: how can we make this work? #expect_success(newdom, "conn arg", "migrate2", dconn) dconn.close newdom.destroy # TESTGROUP: dom.migrate_to_uri2 newdom = conn.create_domain_xml($new_dom_xml) sleep 1 expect_too_many_args(newdom, "migrate_to_uri2", 1, 2, 3, 4, 5, 6, 7) expect_invalid_arg_type(newdom, "migrate_to_uri2", 1) expect_invalid_arg_type(newdom, "migrate_to_uri2", "qemu:///system", 1) expect_invalid_arg_type(newdom, "migrate_to_uri2", "qemu:///system", 'foo', 1) expect_invalid_arg_type(newdom, "migrate_to_uri2", "qemu:///system", 'foo', 'bar', 'baz') expect_invalid_arg_type(newdom, "migrate_to_uri2", "qemu:///system", 'foo', 'bar', 0, 1) expect_invalid_arg_type(newdom, "migrate_to_uri2", "qemu:///system", 'foo', 'bar', 0, 'foo', 'baz') #expect_success(newdom, "URI arg", "migrate_to_uri2", "qemu://remote/system") dconn.close newdom.destroy # TESTGROUP: dom.migrate_set_max_speed newdom = conn.create_domain_xml($new_dom_xml) sleep 1 expect_too_many_args(newdom, "migrate_set_max_speed", 1, 2, 3) expect_too_few_args(newdom, "migrate_set_max_speed") expect_invalid_arg_type(newdom, "migrate_set_max_speed", 'foo') expect_invalid_arg_type(newdom, "migrate_set_max_speed", 5, 'foo') #expect_success(newdom, "Bandwidth arg", "migrate_set_max_speed", 5) newdom.destroy # TESTGROUP: dom.shutdown newdom = conn.create_domain_xml($new_dom_xml) sleep 1 expect_too_many_args(newdom, "shutdown", 1, 2) expect_success(newdom, "no args", "shutdown") sleep 1 newdom.destroy # TESTGROUP: dom.reboot newdom = conn.create_domain_xml($new_dom_xml) sleep 1 expect_too_many_args(newdom, "reboot", 1, 2) expect_invalid_arg_type(newdom, "reboot", "hello") expect_success(newdom, "no args", "reboot") sleep 1 expect_success(newdom, "flags arg", "reboot", 0) sleep 1 newdom.destroy # TESTGROUP: dom.destroy newdom = conn.create_domain_xml($new_dom_xml) sleep 1 expect_too_many_args(newdom, "destroy", 1, 2) expect_success(newdom, "no args", "destroy") # TESTGROUP: dom.suspend newdom = conn.create_domain_xml($new_dom_xml) sleep 1 expect_too_many_args(newdom, "suspend", 1) expect_success(newdom, "no args", "suspend") newdom.destroy # TESTGROUP: dom.resume newdom = conn.create_domain_xml($new_dom_xml) sleep 1 expect_success(newdom, "no args running domain", "resume") newdom.suspend expect_too_many_args(newdom, "resume", 1) expect_success(newdom, "no args suspended domain", "resume") newdom.destroy # TESTGROUP: dom.save newdom = conn.create_domain_xml($new_dom_xml) sleep 1 expect_too_many_args(newdom, "save", 1, 2, 3, 4) expect_too_few_args(newdom, "save") expect_invalid_arg_type(newdom, "save", 1) expect_invalid_arg_type(newdom, "save", nil) expect_fail(newdom, Libvirt::Error, "non-existent path", "save", "/this/path/does/not/exist") expect_success(newdom, "path arg", "save", $GUEST_SAVE) `rm -f #{$GUEST_SAVE}` # TESTGROUP: dom.managed_save newdom = conn.define_domain_xml($new_dom_xml) newdom.create sleep 1 expect_too_many_args(newdom, "managed_save", 1, 2) expect_invalid_arg_type(newdom, "managed_save", "hello") expect_success(newdom, "no args", "managed_save") newdom.undefine(Libvirt::Domain::UNDEFINE_MANAGED_SAVE) # TESTGROUP: dom.has_managed_save? newdom = conn.define_domain_xml($new_dom_xml) newdom.create sleep 1 expect_too_many_args(newdom, "has_managed_save?", 1, 2) expect_invalid_arg_type(newdom, "has_managed_save?", "hello") if newdom.has_managed_save? puts_fail "domain.has_managed_save? reports true on a new domain" else puts_ok "domain.has_managed_save? not true on new domain" end newdom.managed_save if not newdom.has_managed_save? puts_fail "domain.has_managed_save? reports false after a managed save" else puts_ok "domain.has_managed_save? reports true after a managed save" end newdom.undefine(Libvirt::Domain::UNDEFINE_MANAGED_SAVE) # TESTGROUP: dom.managed_save_remove newdom = conn.define_domain_xml($new_dom_xml) newdom.create sleep 1 newdom.managed_save expect_too_many_args(newdom, "managed_save_remove", 1, 2) expect_invalid_arg_type(newdom, "managed_save_remove", "hello") if not newdom.has_managed_save? puts_fail "prior to domain.managed_save_remove, no managed save file" end expect_success(newdom, "no args", "managed_save_remove") if newdom.has_managed_save? puts_fail "after domain.managed_save_remove, managed save file still exists" else puts_ok "after domain.managed_save_remove, managed save file no longer exists" end newdom.undefine # TESTGROUP: dom.core_dump newdom = conn.define_domain_xml($new_dom_xml) newdom.create sleep 1 expect_too_many_args(newdom, "core_dump", 1, 2, 3) expect_too_few_args(newdom, "core_dump") expect_invalid_arg_type(newdom, "core_dump", 1, 2) expect_invalid_arg_type(newdom, "core_dump", "/path", "foo") expect_fail(newdom, Libvirt::Error, "invalid path", "core_dump", "/this/path/does/not/exist") expect_success(newdom, "live with path arg", "core_dump", "/var/lib/libvirt/images/ruby-libvirt-test.core") `rm -f /var/lib/libvirt/images/ruby-libvirt-test.core` expect_success(newdom, "crash with path arg", "core_dump", "/var/lib/libvirt/images/ruby-libvirt-test.core", Libvirt::Domain::DUMP_CRASH) expect_fail(newdom, Libvirt::Error, "of shut-off domain", "core_dump", "/var/lib/libvirt/images/ruby-libvirt-test.core", Libvirt::Domain::DUMP_CRASH) `rm -f /var/lib/libvirt/images/ruby-libvirt-test.core` newdom.undefine # TESTGROUP: Libvirt::Domain::restore newdom = conn.define_domain_xml($new_dom_xml) newdom.create sleep 1 newdom.save($GUEST_SAVE) expect_too_many_args(Libvirt::Domain, "restore", 1, 2, 3) expect_too_few_args(Libvirt::Domain, "restore") expect_invalid_arg_type(Libvirt::Domain, "restore", 1, 2) expect_invalid_arg_type(Libvirt::Domain, "restore", conn, 2) expect_fail(Libvirt::Domain, Libvirt::Error, "invalid path", "restore", conn, "/this/path/does/not/exist") `touch /tmp/foo` expect_fail(Libvirt::Domain, Libvirt::Error, "invalid save file", "restore", conn, "/tmp/foo") `rm -f /tmp/foo` expect_success(Libvirt::Domain, "2 args", "restore", conn, $GUEST_SAVE) `rm -f #{$GUEST_SAVE}` newdom.destroy newdom.undefine # TESTGROUP: dom.info newdom = conn.create_domain_xml($new_dom_xml) sleep 1 expect_too_many_args(newdom, "info", 1) expect_success(newdom, "no args", "info") {|x| x.state == Libvirt::Domain::RUNNING and x.max_mem == 1048576 and x.memory == 1048576 and x.nr_virt_cpu == 2} newdom.destroy # TESTGROUP: dom.security_label newdom = conn.create_domain_xml($new_dom_xml) sleep 1 expect_too_many_args(newdom, "security_label", 1) expect_success(newdom, "no args", "security_label") newdom.destroy # TESTGROUP: dom.block_stats newdom = conn.create_domain_xml($new_dom_xml) sleep 1 expect_too_many_args(newdom, "block_stats", 1, 2) expect_too_few_args(newdom, "block_stats") expect_invalid_arg_type(newdom, "block_stats", 1) expect_fail(newdom, Libvirt::RetrieveError, "invalid path", "block_stats", "foo") expect_success(newdom, "block device arg", "block_stats", "vda") newdom.destroy # TESTGROUP: dom.memory_stats newdom = conn.create_domain_xml($new_dom_xml) sleep 1 expect_too_many_args(newdom, "memory_stats", 1, 2) expect_invalid_arg_type(newdom, "memory_stats", "foo") expect_success(newdom, "no args", "memory_stats") newdom.destroy # TESTGROUP: dom.blockinfo newdom = conn.create_domain_xml($new_dom_xml) sleep 1 expect_too_many_args(newdom, "blockinfo", 1, 2, 3) expect_too_few_args(newdom, "blockinfo") expect_invalid_arg_type(newdom, "blockinfo", 1) expect_invalid_arg_type(newdom, "blockinfo", "foo", "bar") expect_fail(newdom, Libvirt::RetrieveError, "invalid path", "blockinfo", "foo") expect_success(newdom, "path arg", "blockinfo", $GUEST_DISK) newdom.destroy # TESTGROUP: dom.block_peek newdom = conn.create_domain_xml($new_dom_xml) sleep 1 expect_too_many_args(newdom, "block_peek", 1, 2, 3, 4, 5) expect_too_few_args(newdom, "block_peek") expect_too_few_args(newdom, "block_peek", 1) expect_too_few_args(newdom, "block_peek", 1, 2) expect_invalid_arg_type(newdom, "block_peek", 1, 2, 3) expect_invalid_arg_type(newdom, "block_peek", "foo", "bar", 3) expect_invalid_arg_type(newdom, "block_peek", "foo", 0, "bar") expect_invalid_arg_type(newdom, "block_peek", "foo", 0, 512, "baz") expect_fail(newdom, Libvirt::RetrieveError, "invalid path", "block_peek", "foo", 0, 512) blockpeek = newdom.block_peek($GUEST_DISK, 0, 512) # 0x51 0x46 0x49 0xfb are the first 4 bytes of a qcow2 image if blockpeek[0].unpack('C')[0] != 0x51 or blockpeek[1].unpack('C')[0] != 0x46 or blockpeek[2].unpack('C')[0] != 0x49 or blockpeek[3].unpack('C')[0] != 0xfb puts_fail "domain.block_peek read did not return valid data" else puts_ok "domain.block_peek read valid data" end newdom.destroy # TESTGROUP: dom.memory_peek newdom = conn.create_domain_xml($new_dom_xml) sleep 1 expect_too_many_args(newdom, "memory_peek", 1, 2, 3, 4) expect_too_few_args(newdom, "memory_peek") expect_too_few_args(newdom, "memory_peek", 1) expect_invalid_arg_type(newdom, "memory_peek", "foo", 2) expect_invalid_arg_type(newdom, "memory_peek", 0, "bar") expect_invalid_arg_type(newdom, "memory_peek", 0, 512, "baz") expect_success(newdom, "offset and size args", "memory_peek", 0, 512) newdom.destroy # TESTGROUP: dom.get_vcpus expect_too_many_args(newdom, "get_vcpus", 1) newdom = conn.define_domain_xml($new_dom_xml) expect_success(newdom, "get_vcpus on shutoff domain", "get_vcpus") {|x| x.length == 2} newdom.create sleep 1 expect_success(newdom, "no args", "get_vcpus") {|x| x.length == 2} newdom.destroy newdom.undefine # TESTGROUP: dom.active? expect_too_many_args(newdom, "active?", 1) newdom = conn.define_domain_xml($new_dom_xml) expect_success(newdom, "no args", "active?") {|x| x == false} newdom.create sleep 1 expect_success(newdom, "no args", "active?") {|x| x == true} newdom.destroy newdom.undefine # TESTGROUP: dom.persistent? newdom = conn.create_domain_xml($new_dom_xml) sleep 1 expect_too_many_args(newdom, "persistent?", 1) expect_success(newdom, "no args", "persistent?") {|x| x == false} newdom.destroy newdom = conn.define_domain_xml($new_dom_xml) expect_success(newdom, "no args", "persistent?") {|x| x == true} newdom.undefine # TESTGROUP: dom.ifinfo newdom = conn.create_domain_xml($new_dom_xml) sleep 1 expect_too_many_args(newdom, "ifinfo", 1, 2) expect_too_few_args(newdom, "ifinfo") expect_invalid_arg_type(newdom, "ifinfo", 1) expect_fail(newdom, Libvirt::RetrieveError, "invalid arg", "ifinfo", "foo") expect_success(newdom, "interface arg", "ifinfo", "rl556") newdom.destroy # TESTGROUP: dom.name newdom = conn.create_domain_xml($new_dom_xml) sleep 1 expect_too_many_args(newdom, "name", 1) expect_success(newdom, "no args", "name") {|x| x == "rb-libvirt-test"} newdom.destroy # TESTGROUP: dom.id newdom = conn.create_domain_xml($new_dom_xml) sleep 1 expect_too_many_args(newdom, "id", 1) expect_success(newdom, "no args", "id") newdom.destroy # TESTGROUP: dom.uuid newdom = conn.create_domain_xml($new_dom_xml) sleep 1 expect_too_many_args(newdom, "uuid", 1) expect_success(newdom, "no args", "uuid") {|x| x == $GUEST_UUID} newdom.destroy # TESTGROUP: dom.os_type newdom = conn.create_domain_xml($new_dom_xml) sleep 1 expect_too_many_args(newdom, "os_type", 1) expect_success(newdom, "no args", "os_type") {|x| x == "hvm"} newdom.destroy # TESTGROUP: dom.max_memory newdom = conn.create_domain_xml($new_dom_xml) sleep 1 expect_too_many_args(newdom, "max_memory", 1) expect_success(newdom, "no args", "max_memory") {|x| x == 1048576} newdom.destroy # TESTGROUP: dom.max_memory= newdom = conn.define_domain_xml($new_dom_xml) expect_too_many_args(newdom, "max_memory=", 1, 2) expect_too_few_args(newdom, "max_memory=") expect_invalid_arg_type(newdom, "max_memory=", 'foo') expect_success(newdom, "memory arg", "max_memory=", 200000) newdom.undefine # TESTGROUP: dom.memory= newdom = conn.define_domain_xml($new_dom_xml) expect_too_many_args(newdom, "memory=", 1, 2) expect_too_many_args(newdom, "memory=", [1, 2, 3]) expect_too_few_args(newdom, "memory=") expect_too_few_args(newdom, "memory=", []) expect_invalid_arg_type(newdom, "memory=", 'foo') expect_fail(newdom, Libvirt::Error, "shutoff domain", "memory=", [2, Libvirt::Domain::AFFECT_LIVE]) newdom.undefine newdom = conn.create_domain_xml($new_dom_xml) sleep 1 expect_success(newdom, "number arg", "memory=", 200000) newdom.destroy # TESTGROUP: dom.max_vcpus newdom = conn.create_domain_xml($new_dom_xml) sleep 1 expect_too_many_args(newdom, "max_vcpus", 1) expect_success(newdom, "no args", "max_vcpus") newdom.destroy # TESTGROUP: dom.vcpus= newdom = conn.define_domain_xml($new_dom_xml) expect_too_many_args(newdom, "vcpus=", 1, 2) expect_too_many_args(newdom, "vcpus=", [0, 1, 2]) expect_too_few_args(newdom, "vcpus=") expect_too_few_args(newdom, "vcpus=", []) expect_invalid_arg_type(newdom, "vcpus=", 'foo') expect_fail(newdom, Libvirt::Error, "shutoff domain", "vcpus=", [2, Libvirt::Domain::AFFECT_LIVE]) newdom.undefine newdom = conn.create_domain_xml($new_dom_xml) sleep 1 expect_success(newdom, "number arg", "vcpus=", 2) newdom.destroy # TESTGROUP: dom.pin_vcpu newdom = conn.create_domain_xml($new_dom_xml) sleep 1 expect_too_many_args(newdom, "pin_vcpu", 1, 2, 3, 4) expect_too_few_args(newdom, "pin_vcpu") expect_invalid_arg_type(newdom, "pin_vcpu", 'foo', [0]) expect_invalid_arg_type(newdom, "pin_vcpu", 0, 1) expect_success(newdom, "cpu args", "pin_vcpu", 0, [0]) newdom.destroy # TESTGROUP: dom.xml_desc newdom = conn.create_domain_xml($new_dom_xml) sleep 1 expect_too_many_args(newdom, "xml_desc", 1, 2) expect_invalid_arg_type(newdom, "xml_desc", "foo") expect_success(newdom, "no args", "xml_desc") newdom.destroy # TESTGROUP: dom.undefine newdom = conn.define_domain_xml($new_dom_xml) expect_too_many_args(newdom, "undefine", 1, 2) expect_success(newdom, "no args", "undefine") # TESTGROUP: dom.create newdom = conn.define_domain_xml($new_dom_xml) expect_too_many_args(newdom, "create", 1, 2) expect_invalid_arg_type(newdom, "create", "foo") expect_success(newdom, "no args", "create") expect_fail(newdom, Libvirt::Error, "on already running domain", "create") newdom.destroy newdom.undefine # TESTGROUP: dom.autostart? newdom = conn.define_domain_xml($new_dom_xml) expect_too_many_args(newdom, "autostart?", 1) expect_success(newdom, "no args", "autostart?") {|x| x == false} newdom.autostart = true expect_success(newdom, "no args", "autostart?") {|x| x == true} newdom.undefine # TESTGROUP: dom.autostart= newdom = conn.define_domain_xml($new_dom_xml) expect_too_many_args(newdom, "autostart=", 1, 2) expect_invalid_arg_type(newdom, "autostart=", 'foo') expect_invalid_arg_type(newdom, "autostart=", nil) expect_invalid_arg_type(newdom, "autostart=", 1234) expect_success(newdom, "true arg", "autostart=", true) if not newdom.autostart? puts_fail "domain.autostart= did not set autostart to true" else puts_ok "domain.autostart= set autostart to true" end expect_success(newdom, "false arg", "autostart=", false) if newdom.autostart? puts_fail "domain.autostart= did not set autostart to false" else puts_ok "domain.autostart= set autostart to false" end newdom.undefine # TESTGROUP: dom.attach_device newdom = conn.define_domain_xml($new_dom_xml) expect_too_many_args(newdom, "attach_device", 1, 2, 3) expect_too_few_args(newdom, "attach_device") expect_invalid_arg_type(newdom, "attach_device", 1) expect_invalid_arg_type(newdom, "attach_device", 'foo', 'bar') expect_fail(newdom, Libvirt::Error, "invalid XML", "attach_device", "hello") expect_fail(newdom, Libvirt::Error, "shut off domain", "attach_device", new_hostdev_xml) newdom.undefine newdom = conn.create_domain_xml($new_dom_xml) sleep 1 #expect_success(newdom, "hostdev XML", "attach_device", new_hostdev_xml) newdom.destroy # TESTGROUP: dom.detach_device newdom = conn.define_domain_xml($new_dom_xml) expect_too_many_args(newdom, "detach_device", 1, 2, 3) expect_too_few_args(newdom, "detach_device") expect_invalid_arg_type(newdom, "detach_device", 1) expect_invalid_arg_type(newdom, "detach_device", 'foo', 'bar') expect_fail(newdom, Libvirt::Error, "invalid XML", "detach_device", "hello") expect_fail(newdom, Libvirt::Error, "shut off domain", "detach_device", new_hostdev_xml) newdom.undefine newdom = conn.create_domain_xml($new_dom_xml) sleep 1 #expect_success(newdom, "hostdev XML", "detach_device", new_hostdev_xml) newdom.destroy # TESTGROUP: dom.update_device newdom = conn.define_domain_xml($new_dom_xml) expect_too_many_args(newdom, "update_device", 1, 2, 3) expect_too_few_args(newdom, "update_device") expect_invalid_arg_type(newdom, "update_device", 1) expect_invalid_arg_type(newdom, "update_device", 'foo', 'bar') expect_fail(newdom, Libvirt::Error, "invalid XML", "update_device", "hello") expect_fail(newdom, Libvirt::Error, "shut off domain", "update_device", new_hostdev_xml) newdom.undefine newdom = conn.create_domain_xml($new_dom_xml) sleep 1 #expect_success(newdom, "hostdev XML", "update_device", new_hostdev_xml) newdom.destroy # TESTGROUP: dom.free newdom = conn.define_domain_xml($new_dom_xml) newdom.undefine expect_too_many_args(newdom, "free", 1) expect_success(newdom, "free", "free") # TESTGROUP: dom.snapshot_create_xml newdom = conn.define_domain_xml($new_dom_xml) expect_too_many_args(newdom, "snapshot_create_xml", 1, 2, 3) expect_too_few_args(newdom, "snapshot_create_xml") expect_invalid_arg_type(newdom, "snapshot_create_xml", 1) expect_invalid_arg_type(newdom, "snapshot_create_xml", nil) expect_invalid_arg_type(newdom, "snapshot_create_xml", 'foo', 'bar') expect_success(newdom, "simple XML arg", "snapshot_create_xml", "") snaps = newdom.num_of_snapshots if snaps != 1 puts_fail "domain.snapshot_create_xml after one snapshot has #{snaps} snapshots" else puts_ok "domain.snapshot_create_xml after one snapshot has 1 snapshot" end newdom.undefine(Libvirt::Domain::UNDEFINE_SNAPSHOTS_METADATA) # TESTGROUP: dom.num_of_snapshots newdom = conn.define_domain_xml($new_dom_xml) expect_too_many_args(newdom, "num_of_snapshots", 1, 2) expect_invalid_arg_type(newdom, "num_of_snapshots", 'foo') expect_success(newdom, "no args", "num_of_snapshots") {|x| x == 0} newdom.snapshot_create_xml("") expect_success(newdom, "no args", "num_of_snapshots") {|x| x == 1} newdom.undefine(Libvirt::Domain::UNDEFINE_SNAPSHOTS_METADATA) # TESTGROUP: dom.list_snapshots newdom = conn.define_domain_xml($new_dom_xml) expect_too_many_args(newdom, "list_snapshots", 1, 2) expect_invalid_arg_type(newdom, "list_snapshots", 'foo') expect_success(newdom, "no args", "list_snapshots") {|x| x.length == 0} newdom.snapshot_create_xml("") expect_success(newdom, "no args", "list_snapshots") {|x| x.length == 1} newdom.undefine(Libvirt::Domain::UNDEFINE_SNAPSHOTS_METADATA) # TESTGROUP: dom.lookup_snapshot_by_name newdom = conn.define_domain_xml($new_dom_xml) newdom.snapshot_create_xml("foo") expect_too_many_args(newdom, "lookup_snapshot_by_name", 1, 2, 3) expect_too_few_args(newdom, "lookup_snapshot_by_name") expect_invalid_arg_type(newdom, "lookup_snapshot_by_name", 1) expect_invalid_arg_type(newdom, "lookup_snapshot_by_name", 'foo', 'bar') expect_success(newdom, "name arg", "lookup_snapshot_by_name", "foo") newdom.undefine(Libvirt::Domain::UNDEFINE_SNAPSHOTS_METADATA) # TESTGROUP: dom.has_current_snapshot? newdom = conn.define_domain_xml($new_dom_xml) expect_too_many_args(newdom, "has_current_snapshot?", 1, 2) expect_invalid_arg_type(newdom, "has_current_snapshot?", 'foo') expect_success(newdom, "no args", "has_current_snapshot?") {|x| x == false} newdom.snapshot_create_xml("foo") expect_success(newdom, "no args", "has_current_snapshot?") {|x| x == true} newdom.undefine(Libvirt::Domain::UNDEFINE_SNAPSHOTS_METADATA) # TESTGROUP: dom.revert_to_snapshot newdom = conn.define_domain_xml($new_dom_xml) expect_too_many_args(newdom, "revert_to_snapshot", 1, 2, 3) expect_too_few_args(newdom, "revert_to_snapshot") expect_invalid_arg_type(newdom, "revert_to_snapshot", 1) expect_invalid_arg_type(newdom, "revert_to_snapshot", nil) expect_invalid_arg_type(newdom, "revert_to_snapshot", 'foo') snap = newdom.snapshot_create_xml("foo") sleep 1 expect_invalid_arg_type(newdom, "revert_to_snapshot", snap, 'foo') expect_success(newdom, "snapshot arg", "revert_to_snapshot", snap) newdom.undefine(Libvirt::Domain::UNDEFINE_SNAPSHOTS_METADATA) # TESTGROUP: dom.current_snapshot newdom = conn.define_domain_xml($new_dom_xml) expect_too_many_args(newdom, "current_snapshot", 1, 2) expect_invalid_arg_type(newdom, "current_snapshot", 'foo') expect_fail(newdom, Libvirt::RetrieveError, "with no snapshots", "current_snapshot") newdom.snapshot_create_xml("foo") expect_success(newdom, "no args", "current_snapshot") newdom.undefine(Libvirt::Domain::UNDEFINE_SNAPSHOTS_METADATA) # TESTGROUP: dom.job_info newdom = conn.define_domain_xml($new_dom_xml) expect_too_many_args(newdom, "job_info", 1) expect_fail(newdom, Libvirt::RetrieveError, "shutoff domain", "job_info") newdom.undefine newdom = conn.create_domain_xml($new_dom_xml) sleep 1 expect_success(newdom, "no args", "job_info") newdom.destroy # TESTGROUP: dom.abort_job newdom = conn.define_domain_xml($new_dom_xml) expect_too_many_args(newdom, "abort_job", 1) expect_fail(newdom, Libvirt::Error, "not running domain", "abort_job") newdom.undefine newdom = conn.create_domain_xml($new_dom_xml) sleep 1 expect_fail(newdom, Libvirt::Error, "no active job", "abort_job") # FIXME: need to start long running job here #expect_success(newdom, "no args", "abort_job") newdom.destroy # TESTGROUP: dom.scheduler_type newdom = conn.define_domain_xml($new_dom_xml) expect_too_many_args(newdom, "scheduler_type", 1) expect_success(newdom, "no args", "scheduler_type") newdom.undefine # TESTGROUP: dom.scheduler_parameters newdom = conn.define_domain_xml($new_dom_xml) expect_too_many_args(newdom, "scheduler_parameters", 1, 1) expect_success(newdom, "no args", "scheduler_parameters") newdom.undefine # TESTGROUP: dom.scheduler_parameters= newdom = conn.define_domain_xml($new_dom_xml) expect_too_many_args(newdom, "scheduler_parameters=", 1, 2) expect_too_few_args(newdom, "scheduler_parameters=") expect_invalid_arg_type(newdom, "scheduler_parameters=", 0) expect_success(newdom, "cpu shares arg", "scheduler_parameters=", {"cpu_shares" => 512}) newdom.undefine # TESTGROUP: dom.qemu_monitor_command new_test_xml = < fc4 EF86180145B911CB88E3AFBFE5370493 xen /boot/vmlinuz-2.6.15-1.43_FC5guest /boot/initrd-2.6.15-1.43_FC5guest.img /dev/sda1 ro selinux=0 3 261072 131072 1