ruby-libvirt-0.7.1/0000775000175000017500000000000013242276413015477 5ustar clalancetteclalancetteruby-libvirt-0.7.1/README0000664000175000017500000001325312532716214016362 0ustar clalancetteclalancetteruby-libvirt ============ Ruby bindings for libvirt (http://libvirt.org) Usage ----- In your ruby code, do a "require 'libvirt'"; to obtain a connection, use 'Libvirt::open' or 'Libvirt::open_read_only'. See tests/*.rb for more examples. Hacking ------- On a Fedora machine, run yum install libvirt-devel ruby-devel rubygem-rake and then rake build rake test To run against the checkout, make sure you set RUBYLIB (assuming DIR is the toplevel of your source checkout): export RUBYLIB=$dir/lib:$dir/ext/libvirt ruby -rlibvirt -e 'puts Libvirt::version[0]' Notes ----- As of October 26, 2013, the ruby-libvirt bindings support all of the libvirt APIs up to libvirt commit hash b695aeebd52bcbd0d260893bddd5bfe1e486e980 with the following exceptions: VIR_DOMAIN_LAST VIR_DOMAIN_NOSTATE_LAST VIR_DOMAIN_RUNNING_LAST VIR_DOMAIN_BLOCKED_LAST VIR_DOMAIN_PAUSED_LAST VIR_DOMAIN_SHUTDOWN_LAST VIR_DOMAIN_SHUTOFF_LAST VIR_DOMAIN_CRASHED_LAST VIR_DOMAIN_PMSUSPENDED_LAST VIR_DOMAIN_PMSUSPENDED_DISK_LAST VIR_DOMAIN_CONTROL_LAST VIR_DOMAIN_NONE VIR_NODE_SUSPEND_TARGET_LAST VIR_TYPED_PARAM_LAST VIR_TYPED_PARAM_STRING_OKAY VIR_DOMAIN_MEMORY_STAT_NR VIR_DOMAIN_MEMORY_STAT_LAST VIR_CRED_LAST VIR_EXPORT_VAR VIR_CONNECT_CLOSE_REASON_ERROR VIR_CONNECT_CLOSE_REASON_EOF VIR_CONNECT_CLOSE_REASON_KEEPALIVE VIR_CONNECT_CLOSE_REASON_CLIENT VIR_CONNECT_CLOSE_REASON_LAST VIR_DOMAIN_NUMATUNE_MEM_STRICT VIR_DOMAIN_NUMATUNE_MEM_PREFERRED VIR_DOMAIN_NUMATUNE_MEM_INTERLEAVE VIR_DOMAIN_NUMATUNE_MEM_LAST VIR_DOMAIN_METADATA_LAST VIR_VCPU_LAST VIR_DOMAIN_BLOCK_JOB_TYPE_LAST VIR_DOMAIN_DISK_ERROR_LAST VIR_NETWORK_UPDATE_COMMAND_LAST VIR_NETWORK_SECTION_LAST VIR_STORAGE_POOL_STATE_LAST VIR_STORAGE_VOL_LAST VIR_STORAGE_VOL_WIPE_ALG_LAST VIR_KEYCODE_SET_LAST VIR_DOMAIN_PROCESS_SIGNAL_LAST VIR_DOMAIN_EVENT_LAST VIR_DOMAIN_EVENT_DEFINED_LAST VIR_DOMAIN_EVENT_UNDEFINED_LAST VIR_DOMAIN_EVENT_STARTED_LAST VIR_DOMAIN_EVENT_SUSPENDED_LAST VIR_DOMAIN_EVENT_RESUMED_LAST VIR_DOMAIN_EVENT_STOPPED_LAST VIR_DOMAIN_EVENT_SHUTDOWN_LAST VIR_DOMAIN_EVENT_PMSUSPENDED_LAST VIR_DOMAIN_EVENT_CRASHED_LAST VIR_SECRET_USAGE_TYPE_LAST VIR_CPU_COMPARE_LAST VIR_DOMAIN_JOB_LAST VIR_DOMAIN_EVENT_WATCHDOG_LAST VIR_DOMAIN_EVENT_IO_ERROR_LAST VIR_DOMAIN_EVENT_GRAPHICS_LAST VIR_DOMAIN_EVENT_GRAPHICS_ADDRESS_LAST VIR_DOMAIN_BLOCK_JOB_LAST VIR_DOMAIN_EVENT_DISK_CHANGE_MISSING_ON_START VIR_DOMAIN_EVENT_DISK_DROP_MISSING_ON_START VIR_DOMAIN_EVENT_DISK_CHANGE_LAST VIR_DOMAIN_EVENT_TRAY_CHANGE_OPEN VIR_DOMAIN_EVENT_TRAY_CHANGE_CLOSE VIR_DOMAIN_EVENT_TRAY_CHANGE_LAST VIR_DOMAIN_EVENT_ID_BLOCK_JOB VIR_DOMAIN_EVENT_ID_DISK_CHANGE VIR_DOMAIN_EVENT_ID_TRAY_CHANGE VIR_DOMAIN_EVENT_ID_PMWAKEUP VIR_DOMAIN_EVENT_ID_PMSUSPEND VIR_DOMAIN_EVENT_ID_BALLOON_CHANGE VIR_DOMAIN_EVENT_ID_PMSUSPEND_DISK VIR_DOMAIN_EVENT_ID_DEVICE_REMOVED VIR_DOMAIN_EVENT_ID_LAST VIR_DOMAIN_BLKIO_PARAM_INT VIR_DOMAIN_BLKIO_PARAM_UINT VIR_DOMAIN_BLKIO_PARAM_LLONG VIR_DOMAIN_BLKIO_PARAM_ULLONG VIR_DOMAIN_BLKIO_PARAM_DOUBLE VIR_DOMAIN_BLKIO_PARAM_BOOLEAN VIR_DOMAIN_MEMORY_PARAM_INT VIR_DOMAIN_MEMORY_PARAM_UINT VIR_DOMAIN_MEMORY_PARAM_LLONG VIR_DOMAIN_MEMORY_PARAM_ULLONG VIR_DOMAIN_MEMORY_PARAM_DOUBLE VIR_DOMAIN_MEMORY_PARAM_BOOLEAN VIR_DEPRECATED VIR_DEPRECATED VIR_EXPORT_VAR VIR_EXPORT_VAR VIR_EXPORT_VAR VIR_EXPORT_VAR VIR_SECURITY_LABEL_BUFLEN VIR_SECURITY_MODEL_BUFLEN VIR_SECURITY_DOI_BUFLEN VIR_NODE_CPU_STATS_FIELD_LENGTH VIR_NODE_CPU_STATS_KERNEL VIR_NODE_CPU_STATS_USER VIR_NODE_CPU_STATS_IDLE VIR_NODE_CPU_STATS_IOWAIT VIR_NODE_CPU_STATS_UTILIZATION VIR_NODE_MEMORY_STATS_FIELD_LENGTH VIR_NODE_MEMORY_STATS_TOTAL VIR_NODE_MEMORY_STATS_FREE VIR_NODE_MEMORY_STATS_BUFFERS VIR_NODE_MEMORY_STATS_CACHED VIR_DOMAIN_BLOCK_STATS_FIELD_LENGTH VIR_DOMAIN_BLOCK_STATS_READ_BYTES VIR_DOMAIN_BLOCK_STATS_READ_REQ VIR_DOMAIN_BLOCK_STATS_READ_TOTAL_TIMES VIR_DOMAIN_BLOCK_STATS_WRITE_BYTES VIR_DOMAIN_BLOCK_STATS_WRITE_REQ VIR_DOMAIN_BLOCK_STATS_WRITE_TOTAL_TIMES VIR_DOMAIN_BLOCK_STATS_FLUSH_REQ VIR_DOMAIN_BLOCK_STATS_FLUSH_TOTAL_TIMES VIR_DOMAIN_BLOCK_STATS_ERRS VIR_UUID_BUFLEN LIBVIR_VERSION_NUMBER VIR_DOMAIN_CPU_STATS_CPUTIME VIR_DOMAIN_CPU_STATS_USERTIME VIR_DOMAIN_CPU_STATS_SYSTEMTIME VIR_DOMAIN_CPU_STATS_VCPUTIME VIR_UNUSE_CPU VIR_COPY_CPUMAP VIR_GET_CPUMAP VIR_DOMAIN_SEND_KEY_MAX_KEYS VIR_DOMAIN_JOB_TIME_ELAPSED VIR_DOMAIN_JOB_TIME_REMAINING VIR_DOMAIN_JOB_DOWNTIME VIR_DOMAIN_JOB_DATA_TOTAL VIR_DOMAIN_JOB_DATA_PROCESSED VIR_DOMAIN_JOB_DATA_REMAINING VIR_DOMAIN_JOB_MEMORY_TOTAL VIR_DOMAIN_JOB_MEMORY_PROCESSED VIR_DOMAIN_JOB_MEMORY_REMAINING VIR_DOMAIN_JOB_MEMORY_CONSTANT VIR_DOMAIN_JOB_MEMORY_NORMAL VIR_DOMAIN_JOB_MEMORY_NORMAL_BYTES VIR_DOMAIN_JOB_DISK_TOTAL VIR_DOMAIN_JOB_DISK_PROCESSED VIR_DOMAIN_JOB_DISK_REMAINING VIR_DOMAIN_JOB_COMPRESSION_CACHE VIR_DOMAIN_JOB_COMPRESSION_BYTES VIR_DOMAIN_JOB_COMPRESSION_PAGES VIR_DOMAIN_JOB_COMPRESSION_CACHE_MISSES VIR_DOMAIN_JOB_COMPRESSION_OVERFLOW VIR_DOMAIN_SCHED_FIELD_LENGTH VIR_DOMAIN_BLKIO_FIELD_LENGTH VIR_DOMAIN_MEMORY_FIELD_LENGTH virTypedParamsGet virTypedParamsGetInt virTypedParamsGetUInt virTypedParamsGetLLong virTypedParamsGetULLong virTypedParamsGetDouble virTypedParamsGetBoolean virTypedParamsGetString virTypedParamsAddInt virTypedParamsAddUInt virTypedParamsAddLLong virTypedParamsAddULLong virTypedParamsAddDouble virTypedParamsAddBoolean virTypedParamsAddString virTypedParamsAddFromString virTypedParamsClear virConnectRef virConnectRegisterCloseCallback virConnectUnregisterCloseCallback virDomainGetConnect virDomainRef virDomainRestoreFlags virNetworkGetConnect virNetworkRef virInterfaceGetConnect virInterfaceRef virStoragePoolGetConnect virStorageVolGetConnect virStorageVolRef virNodeDeviceRef virSecretGetConnect virSecretRef virStreamRef virDomainSnapshotGetDomain virDomainSnapshotGetConnect virDomainSnapshotRef virNWFilterRef VIR_DOMAIN_QEMU_AGENT_COMMAND_MIN ruby-libvirt-0.7.1/tests/0000775000175000017500000000000013242276413016641 5ustar clalancetteclalancetteruby-libvirt-0.7.1/tests/test_conn.rb0000664000175000017500000007773613242273417021207 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 {|connect, 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, 3) 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.1/tests/test_open.rb0000664000175000017500000002376612532716436021211 0ustar clalancetteclalancette#!/usr/bin/ruby # Test the open calls that the bindings support $: << File.dirname(__FILE__) require 'libvirt' require 'test_utils.rb' set_test_object("Libvirt") def expect_connect_error(func, args) expect_fail(Libvirt, Libvirt::ConnectionError, "invalid driver", func, *args) end # TESTGROUP: Libvirt::version expect_too_many_args(Libvirt, "version", "test", 1) expect_invalid_arg_type(Libvirt, "version", 1) expect_success(Libvirt, "no args", "version") {|x| x.class == Array and x.length == 2} expect_success(Libvirt, "nil arg", "version", nil) {|x| x.class == Array and x.length == 2} expect_success(Libvirt, "Test arg", "version", "Test") {|x| x.class == Array and x.length == 2} # TESTGROUP: Libvirt::open expect_too_many_args(Libvirt, "open", URI, 1) expect_connect_error("open", "foo:///system") conn = expect_success(Libvirt, "no args", "open") {|x| x.class == Libvirt::Connect } conn.close conn = expect_success(Libvirt, URI, "open", URI) {|x| x.class == Libvirt::Connect } conn.close conn = expect_success(Libvirt, "nil arg", "open", nil) {|x| x.class == Libvirt::Connect } conn.close # TESTGROUP: Libvirt::open_read_only expect_too_many_args(Libvirt, "open_read_only", URI, 1) expect_connect_error("open_read_only", "foo:///system") conn = expect_success(Libvirt, "no args", "open_read_only") {|x| x.class == Libvirt::Connect } conn.close conn = expect_success(Libvirt, URI, "open_read_only", URI) {|x| x.class == Libvirt::Connect } conn.close conn = expect_success(Libvirt, "nil arg", "open_read_only", nil) {|x| x.class == Libvirt::Connect } conn.close # TESTGROUP: Libvirt::open_auth expect_too_many_args(Libvirt, "open_auth", URI, [], "hello there", 1, 2) expect_connect_error("open_auth", "foo:///system") expect_invalid_arg_type(Libvirt, "open_auth", 1) expect_invalid_arg_type(Libvirt, "open_auth", URI, [], "hello", "foo") conn = expect_success(Libvirt, "no args", "open_auth") {|x| x.class == Libvirt::Connect } conn.close conn = expect_success(Libvirt, "uri arg", "open_auth", URI) {|x| x.class == Libvirt::Connect } conn.close conn = expect_success(Libvirt, "uri and empty cred args", "open_auth", URI, []) {|x| x.class == Libvirt::Connect } conn.close conn = expect_success(Libvirt, "uri and full cred args", "open_auth", URI, [Libvirt::CRED_AUTHNAME, Libvirt::CRED_PASSPHRASE]) {|x| x.class == Libvirt::Connect } conn.close conn = expect_success(Libvirt, "uri, full cred, and user args", "open_auth", URI, [Libvirt::CRED_AUTHNAME, Libvirt::CRED_PASSPHRASE], "hello") {|x| x.class == Libvirt::Connect } conn.close # equivalent to expect_invalid_arg_type begin conn = Libvirt::open_auth(URI, {}) do |cred| end rescue TypeError => e puts_ok "#{$test_object}.open_auth invalid arg type threw #{TypeError.to_s}" else puts_fail "#{$test_object}.open_auth invalid arg type expected to throw #{TypeError.to_s}, but threw nothing" end # equivalent to expect_invalid_arg_type begin conn = Libvirt::open_auth(URI, 1) do |cred| end rescue TypeError => e puts_ok "#{$test_object}.open_auth invalid arg type threw #{TypeError.to_s}" else puts_fail "#{$test_object}.open_auth invalid arg type expected to throw #{TypeError.to_s}, but threw nothing" end # equivalent to expect_invalid_arg_type begin conn = Libvirt::open_auth(URI, 'foo') do |cred| end rescue TypeError => e puts_ok "#{$test_object}.open_auth invalid arg type threw #{TypeError.to_s}" else puts_fail "#{$test_object}.open_auth invalid arg type expected to throw #{TypeError.to_s}, but threw nothing" end # equivalent to "expect_success" begin conn = Libvirt::open_auth(URI, [Libvirt::CRED_AUTHNAME, Libvirt::CRED_PASSPHRASE], "hello") do |cred| if not cred["userdata"].nil? puts "userdata is #{cred["userdata"]}" end if cred["type"] == Libvirt::CRED_AUTHNAME print "#{cred['prompt']}: " res = gets # strip off the \n res = res[0..-2] elsif cred["type"] == Libvirt::CRED_PASSPHRASE print "#{cred['prompt']}: " res = gets res = res[0..-2] else raise "Unsupported credential #{cred['type']}" end res end puts_ok "Libvirt.open_auth uri, creds, userdata, auth block succeeded" conn.close rescue NoMethodError puts_skipped "Libvirt.open_auth does not exist" rescue => e puts_fail "Libvirt.open_auth uri, creds, userdata, auth block expected to succeed, threw #{e.class.to_s}: #{e.to_s}" end # equivalent to "expect_success" begin conn = Libvirt::open_auth(URI) do |cred| end puts_ok "Libvirt.open_auth uri, succeeded" conn.close rescue NoMethodError puts_skipped "Libvirt.open_auth does not exist" rescue => e puts_fail "Libvirt.open_auth uri expected to succeed, threw #{e.class.to_s}: #{e.to_s}" end # equivalent to "expect_success" begin conn = Libvirt::open_auth(URI, [Libvirt::CRED_AUTHNAME, Libvirt::CRED_PASSPHRASE], "hello", Libvirt::CONNECT_RO) do |cred| if not cred["userdata"].nil? puts "userdata is #{cred["userdata"]}" end if cred["type"] == Libvirt::CRED_AUTHNAME print "#{cred['prompt']}: " res = gets # strip off the \n res = res[0..-2] elsif cred["type"] == Libvirt::CRED_PASSPHRASE print "#{cred['prompt']}: " res = gets res = res[0..-2] else raise "Unsupported credential #{cred['type']}" end res end puts_ok "Libvirt.open_auth uri, creds, userdata, R/O flag, auth block succeeded" conn.close rescue NoMethodError puts_skipped "Libvirt.open_auth does not exist" rescue => e puts_fail "Libvirt.open_auth uri, creds, userdata, R/O flag, auth block expected to succeed, threw #{e.class.to_s}: #{e.to_s}" end # TESTGROUP: Libvirt::event_invoke_handle_callback conn = Libvirt::open(URI) expect_too_many_args(Libvirt, "event_invoke_handle_callback", 1, 2, 3, 4, 5) expect_too_few_args(Libvirt, "event_invoke_handle_callback") expect_too_few_args(Libvirt, "event_invoke_handle_callback", 1) expect_too_few_args(Libvirt, "event_invoke_handle_callback", 1, 2) expect_too_few_args(Libvirt, "event_invoke_handle_callback", 1, 2, 3) expect_invalid_arg_type(Libvirt, "event_invoke_handle_callback", "hello", 1, 1, 1) expect_invalid_arg_type(Libvirt, "event_invoke_handle_callback", "hello", 1, 1, []) expect_invalid_arg_type(Libvirt, "event_invoke_handle_callback", "hello", 1, 1, nil) # this is a bit bizarre; I am constructing a bogus hash to pass as the 4th # parameter to event_invoke_handle_callback. In a real situation, I would # have been given this hash from libvirt earlier, and just pass it on. I # don't want all of that complexity here, though, so I create the bogus hash. # One caveat; the data inside the hash *must* be of type T_DATA, so I pass in # a fake conn object just to appease the type checker (so I can test out the # other arguments properly) expect_invalid_arg_type(Libvirt, "event_invoke_handle_callback", "hello", 1, 1, { "libvirt_cb" => conn, "opaque" => conn }) expect_invalid_arg_type(Libvirt, "event_invoke_handle_callback", 1, "hello", 1, { "libvirt_cb" => conn, "opaque" => conn }) expect_invalid_arg_type(Libvirt, "event_invoke_handle_callback", 1, 1, "hello", { "libvirt_cb" => conn, "opaque" => conn }) expect_invalid_arg_type(Libvirt, "event_invoke_handle_callback", 1, 1, 1, { "libvirt_cb" => "hello", "opaque" => conn }) expect_invalid_arg_type(Libvirt, "event_invoke_handle_callback", 1, 1, 1, { "libvirt_cb" => conn, "opaque" => "hello" }) conn.close # TESTGROUP: Libvirt::event_invoke_timeout_callback conn = Libvirt::open(URI) expect_too_many_args(Libvirt, "event_invoke_timeout_callback", 1, 2, 3) expect_too_few_args(Libvirt, "event_invoke_timeout_callback") expect_too_few_args(Libvirt, "event_invoke_timeout_callback", 1) expect_invalid_arg_type(Libvirt, "event_invoke_timeout_callback", "hello", 1) expect_invalid_arg_type(Libvirt, "event_invoke_timeout_callback", "hello", []) expect_invalid_arg_type(Libvirt, "event_invoke_timeout_callback", "hello", nil) # this is a bit bizarre; I am constructing a bogus hash to pass as the 4th # parameter to event_invoke_handle_callback. In a real situation, I would # have been given this hash from libvirt earlier, and just pass it on. I # don't want all of that complexity here, though, so I create the bogus hash. # One caveat; the data inside the hash *must* be of type T_DATA, so I pass in # a fake conn object just to appease the type checker (so I can test out the # other arguments properly) expect_invalid_arg_type(Libvirt, "event_invoke_timeout_callback", "hello", { "libvirt_cb" => conn, "opaque" => conn }) expect_invalid_arg_type(Libvirt, "event_invoke_timeout_callback", 1, { "libvirt_cb" => "hello", "opaque" => conn }) expect_invalid_arg_type(Libvirt, "event_invoke_timeout_callback", 1, { "libvirt_cb" => conn, "opaque" => "hello" }) conn.close # TESTGROUP: Libvirt::event_register_impl expect_too_many_args(Libvirt, "event_register_impl", 1, 2, 3, 4, 5, 6, 7) expect_invalid_arg_type(Libvirt, "event_register_impl", 1) # symbol callbacks def virEventAddHandleImpl(fd, events, opaque) end def virEventUpdateHandleImpl(watch, event) end def virEventRemoveHandleImpl(handleID) end def virEventAddTimerImpl(interval, opaque) end def virEventUpdateTimerImpl(timer, timeout) end def virEventRemoveTimerImpl(timerID) end # proc callbacks virEventAddHandleProc = lambda {|fd, events, opaque| } virEventUpdateHandleProc = lambda {|watch, event| } virEventRemoveHandleProc = lambda {|handleID| } virEventAddTimerProc = lambda {|interval, opaque| } virEventUpdateTimerProc = lambda {|timer, timeout| } virEventRemoveTimerProc = lambda {|timerID| } expect_success(Libvirt, "all Symbol callbacks", "event_register_impl", :virEventAddHandleImpl, :virEventUpdateHandleImpl, :virEventRemoveHandleImpl, :virEventAddTimerImpl, :virEventUpdateTimerImpl, :virEventRemoveTimerImpl) expect_success(Libvirt, "unregister all callbacks", "event_register_impl", nil, nil, nil, nil, nil, nil) expect_success(Libvirt, "all Proc callbacks", "event_register_impl", virEventAddHandleProc, virEventUpdateHandleProc, virEventRemoveHandleProc, virEventAddTimerProc, virEventUpdateTimerProc, virEventRemoveTimerProc) expect_success(Libvirt, "unregister all callbacks", "event_register_impl") # END TESTS finish_tests ruby-libvirt-0.7.1/tests/test_secret.rb0000664000175000017500000000575312450406160021516 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.1/tests/test_utils.rb0000664000175000017500000001511613242272273021371 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" $GUEST_RAW_DISK = $GUEST_BASE + '.raw' # 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.1/tests/test_nwfilter.rb0000664000175000017500000000234312623645477022075 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.1/tests/test_stream.rb0000664000175000017500000001156013242275131021517 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 {|stream,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.1/tests/test_nodedevice.rb0000664000175000017500000000476412532716436022352 0ustar clalancetteclalancette#!/usr/bin/ruby # Test the nodedevice methods the bindings support $: << File.dirname(__FILE__) require 'libvirt' require 'test_utils.rb' set_test_object("nodedevice") conn = Libvirt::open(URI) # TESTGROUP: nodedevice.name testnode = conn.lookup_nodedevice_by_name(conn.list_nodedevices[0]) expect_too_many_args(testnode, "name", 1) expect_success(testnode, "no args", "name") # TESTGROUP: nodedevice.parent testnode = conn.lookup_nodedevice_by_name(conn.list_nodedevices[0]) expect_too_many_args(testnode, "parent", 1) expect_success(testnode, "no args", "parent") # TESTGROUP: nodedevice.num_of_caps testnode = conn.lookup_nodedevice_by_name(conn.list_nodedevices[0]) expect_too_many_args(testnode, "num_of_caps", 1) expect_success(testnode, "no args", "num_of_caps") # TESTGROUP: nodedevice.list_caps testnode = conn.lookup_nodedevice_by_name(conn.list_nodedevices[0]) expect_too_many_args(testnode, "list_caps", 1) expect_success(testnode, "no args", "list_caps") # TESTGROUP: nodedevice.xml_desc testnode = conn.lookup_nodedevice_by_name(conn.list_nodedevices[0]) expect_too_many_args(testnode, "xml_desc", 1, 2) expect_invalid_arg_type(testnode, "xml_desc", 'foo') expect_success(testnode, "no args", "xml_desc") # TESTGROUP: nodedevice.detach testnode = conn.lookup_nodedevice_by_name(conn.list_nodedevices[0]) expect_too_many_args(testnode, "detach", 1, 2, 3) expect_invalid_arg_type(testnode, "detach", 1) expect_invalid_arg_type(testnode, "detach", []) expect_invalid_arg_type(testnode, "detach", {}) expect_invalid_arg_type(testnode, "detach", nil, 'foo') expect_invalid_arg_type(testnode, "detach", nil, []) expect_invalid_arg_type(testnode, "detach", nil, {}) #expect_success(testnode, "no args", "detach") # TESTGROUP: nodedevice.reattach testnode = conn.lookup_nodedevice_by_name(conn.list_nodedevices[0]) expect_too_many_args(testnode, "reattach", 1) #expect_success(testnode, "no args", "reattach") # TESTGROUP: nodedevice.reset testnode = conn.lookup_nodedevice_by_name(conn.list_nodedevices[0]) expect_too_many_args(testnode, "reset", 1) #expect_success(testnode, "no args", "reset") # TESTGROUP: nodedevice.destroy testnode = conn.lookup_nodedevice_by_name(conn.list_nodedevices[0]) expect_too_many_args(testnode, "destroy", 1) #expect_success(testnode, "no args", "destroy") # TESTGROUP: nodedevice.free testnode = conn.lookup_nodedevice_by_name(conn.list_nodedevices[0]) expect_too_many_args(testnode, "free", 1) expect_success(testnode, "no args", "free") # END TESTS conn.close finish_tests ruby-libvirt-0.7.1/tests/test_interface.rb0000664000175000017500000000441712623646251022176 0ustar clalancetteclalancette#!/usr/bin/ruby # Test the interface methods the bindings support $: << File.dirname(__FILE__) require 'libvirt' require 'test_utils.rb' set_test_object("interface") conn = Libvirt::open("qemu:///system") # test setup begin `rm -f /etc/sysconfig/network-scripts/ifcfg-rb-libvirt-test` `brctl delbr rb-libvirt-test >& /dev/null` rescue end # 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 == "rb-libvirt-test"} 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") 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") # END TESTS conn.close finish_tests ruby-libvirt-0.7.1/tests/test_domain.rb0000664000175000017500000012651013242274672021506 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` `qemu-img create -f raw #{$GUEST_RAW_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 1 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_fail(newdom, Libvirt::Error, "already running", "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_RAW_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