libvirt 0.1.0

data/test/libvirt/error_test.rb

@@ -0,0 +1,93 @@
+require "test_helper"
+
+Protest.describe("error") do
+  setup do
+    @klass = Libvirt::Error
+  end
+
+  context "getting the last error" do
+    setup do
+      # Reset the error manually so we're clear.
+      FFI::Libvirt.virResetLastError
+    end
+
+    should "be fine if there is no last error" do
+      result = nil
+      assert_nothing_raised { result = @klass.last_error }
+      assert result.nil?
+    end
+
+    should "report the last error" do
+      begin
+        FFI::Libvirt.virConnectOpen("NSEpicFailure")
+      rescue Libvirt::Exception::LibvirtError; end
+
+      # And now we verify the error is accessible
+      error = @klass.last_error
+      assert error
+    end
+  end
+
+  context "setting an error handling callback" do
+    teardown do
+      # Reset the error handler to nil
+      @klass.on_error
+    end
+
+    should "call the callback when an error occurs" do
+      called = false
+      @klass.on_error do |error|
+        called = true
+      end
+
+      FFI::Libvirt.virConnectOpen("foo") rescue nil
+      assert called
+    end
+  end
+
+  context "disable error raising" do
+    teardown do
+      # Make sure this gets reset
+      @klass.raise_errors = true
+    end
+
+    should "raise errors by default" do
+      assert @klass.raise_errors
+      assert_raise(Libvirt::Exception::LibvirtError) { FFI::Libvirt.virConnectOpen("fail") }
+    end
+
+    should "not raise errors if it is disabled" do
+      @klass.raise_errors = false
+      assert !@klass.raise_errors
+      assert_nothing_raised { FFI::Libvirt.virConnectOpen("fail") }
+    end
+  end
+
+  context "with an error instance" do
+    setup do
+      # Get an error instance...
+      @error = nil
+      begin
+        FFI::Libvirt.virConnectOpen("FailHard")
+      rescue Libvirt::Exception::LibvirtError => e
+        @error = e.error
+      end
+    end
+
+    should "allow access to the raw struct" do
+      assert @error.interface.is_a?(FFI::Libvirt::Error)
+    end
+
+    should "allow access to the error code" do
+      assert_equal :system_error, @error.code
+    end
+
+    should "allow access to the error domain" do
+      assert_equal :remote, @error.domain
+    end
+
+    should "allow access to the error message" do
+      assert @error.message
+    end
+  end
+end

data/test/libvirt/libvirt_test.rb

@@ -0,0 +1,16 @@
+require "test_helper"
+
+Protest.describe("libvirt") do
+  setup do
+    @klass = Libvirt
+  end
+
+  should "provide the version" do
+    assert @klass.version.is_a?(Array)
+  end
+
+  should "provide a shortcut to connecting" do
+    Libvirt::Connection.expects(:new).with(1,2,3)
+    @klass.connect(1,2,3)
+  end
+end

data/test/libvirt/network_test.rb

@@ -0,0 +1,76 @@
+require "test_helper"
+
+Protest.describe("network") do
+  setup do
+    @klass = Libvirt::Network
+
+    @data = {
+      :name => "vboxnet0",
+      :uuid => "786f6276-656e-4074-8000-0a0027000000"
+    }
+
+    @conn = Libvirt.connect("test:///default")
+    @instance = @klass.new(FFI::Libvirt.virNetworkDefineXML(@conn, <<-XML))
+<network>
+  <name>#{@data[:name]}</name>
+  <uuid>#{@data[:uuid]}</uuid>
+</network>
+XML
+  end
+
+  should "provide the name of the network" do
+    result = @instance.name
+    assert_equal @data[:name], result
+  end
+
+  should "provide the UUID of the network" do
+    result = @instance.uuid
+    assert result
+    assert_equal @data[:uuid], result
+  end
+
+  should "provide the bridge of the network" do
+    assert_raise(Libvirt::Exception::LibvirtError) { @instance.bridge }
+  end
+
+  should "control autostart" do
+    assert !@instance.autostart?
+    @instance.autostart = true
+    assert @instance.autostart?
+  end
+
+  should "provide an active check" do
+    assert !@instance.active?
+    @instance.start
+    assert @instance.active?
+  end
+
+  should "provide a persistence check" do
+    assert @instance.persistent?
+    # TODO: Check state change. Not sure how to trigger this at the moment.
+  end
+
+  should "provide ability to stop network" do
+    @instance.start
+    assert @instance.active?
+    @instance.stop
+    assert !@instance.active?
+  end
+
+  should "be able to undefine the network" do
+    assert @conn.networks.include?(@instance)
+    @instance.undefine
+    assert !@conn.networks.include?(@instance)
+  end
+
+  should "provide an equality comparison based on UUID" do
+    # TODO: Create multiple networks with uuids to compare
+  end
+
+  should "provide a `to_ptr` method to get the `virNetworkPtr`" do
+    result = nil
+    assert_nothing_raised { result = @instance.to_ptr }
+    assert result.is_a?(FFI::Pointer)
+    assert !result.null?
+  end
+end

data/test/libvirt/node_device_test.rb

@@ -0,0 +1,16 @@
+require "test_helper"
+
+Protest.describe("node device") do
+  setup do
+    @klass = Libvirt::NodeDevice
+    @instance = Libvirt.connect("test:///default").node.devices.first
+  end
+
+  should "provide the name" do
+    assert_equal "computer", @instance.name
+  end
+
+  should "provide the XML description" do
+    assert @instance.xml
+  end
+end

data/test/libvirt/node_test.rb

@@ -0,0 +1,24 @@
+require "test_helper"
+
+Protest.describe("node") do
+  setup do
+    @klass = Libvirt::Node
+
+    @connection = Libvirt.connect("test:///default")
+    @instance = @connection.node
+  end
+
+  should "provide access to the connection" do
+    assert_equal @connection, @instance.connection
+  end
+
+  should "be able to retrieve devices" do
+    result = nil
+    assert_nothing_raised { result = @instance.devices }
+    assert result
+    assert result.is_a?(Libvirt::Collection::NodeDeviceCollection)
+  end
+
+  # Note: This class is extremely hard to test since the results actually
+  # change computer to computer. Mocking/stubbing probably required.
+end

data/test/libvirt/spec/devices/disk_test.rb

@@ -0,0 +1,107 @@
+require "test_helper"
+
+Protest.describe("Disk device spec") do
+  setup do
+    @klass = Libvirt::Spec::Device::Disk
+  end
+
+  context "outputting XML" do
+    setup do
+      @instance = @klass.new(:file)
+    end
+
+    should "output given type for type in XML" do
+      assert_xpath @instance.type.to_s, @instance.to_xml, "//disk/@type"
+    end
+
+    context "source" do
+      should "not output source if not specified" do
+        @instance.source = nil
+        assert_not_element @instance.to_xml, "//disk/source"
+      end
+
+      should "output source attr as dev for block devices" do
+        @instance.type = :block
+        @instance.source = "foo"
+        assert_xpath @instance.source, @instance.to_xml, "//disk/source/@dev"
+      end
+
+      should "output source attr as file for other devices" do
+        @instance.type = :file
+        @instance.source = "foo"
+        assert_xpath @instance.source, @instance.to_xml, "//disk/source/@file"
+      end
+    end
+
+    context "target" do
+      should "not output target if not specified" do
+        @instance.target_dev = nil
+        assert_not_element @instance.to_xml, "//disk/target"
+      end
+
+      should "not output target if only bus is given" do
+        @instance.target_dev = nil
+        @instance.target_bus = "foo"
+        assert_not_element @instance.to_xml, "//disk/target"
+      end
+
+      should "output specified dev on target" do
+        @instance.target_dev = "foo"
+        assert_xpath @instance.target_dev, @instance.to_xml, "//disk/target/@dev"
+      end
+
+      should "output specified bus on target" do
+        @instance.target_dev = "foo"
+        @instance.target_bus = "bar"
+        assert_xpath @instance.target_bus, @instance.to_xml, "//disk/target/@bus"
+      end
+    end
+
+    context "driver" do
+      should "not output if no name is given" do
+        @instance.driver = nil
+        assert_not_element @instance.to_xml, "//disk/driver"
+      end
+
+      should "output with specified driver" do
+        @instance.driver = "foo"
+        assert_xpath @instance.driver, @instance.to_xml, "//disk/driver/@name"
+      end
+
+      should "output with specified type if given" do
+        @instance.driver = "foo"
+        @instance.driver_type = "bar"
+        assert_xpath @instance.driver_type, @instance.to_xml, "//disk/driver/@type"
+      end
+
+      should "output with specified cache if given" do
+        @instance.driver = "foo"
+        @instance.driver_cache = "bar"
+        assert_xpath @instance.driver_cache, @instance.to_xml, "//disk/driver/@cache"
+      end
+    end
+
+    context "shareable" do
+      should "not be sharable initially" do
+        assert_not_element @instance.to_xml, "//disk/shareable"
+      end
+
+      should "be shareable if specified" do
+        @instance.shareable = true
+        assert_element @instance.to_xml, "//disk/shareable"
+      end
+    end
+
+    context "serial" do
+      should "not have serial if not specified" do
+        @instance.serial = nil
+        assert_not_element @instance.to_xml, "//disk/serial"
+      end
+
+      should "have serial if specified" do
+        @instance.serial = "foobar"
+        assert_xpath @instance.serial, @instance.to_xml, "//disk/serial"
+      end
+    end
+  end
+end

data/test/libvirt/spec/devices/emulator_test.rb

@@ -0,0 +1,20 @@
+require "test_helper"
+
+Protest.describe("Emulator device spec") do
+  setup do
+    @klass = Libvirt::Spec::Device::Emulator
+  end
+
+  should "have the given path when initialized" do
+    path = "foo"
+    instance = @klass.new(path)
+    assert_equal path, instance.path
+  end
+
+  should "output XML with the given path" do
+    path = "foo"
+    instance = @klass.new(path)
+
+    assert_xpath path, instance.to_xml, "//emulator"
+  end
+end

data/test/libvirt/spec/domain_test.rb

@@ -0,0 +1,17 @@
+require 'test_helper'
+
+Protest.describe("Domain spec") do
+  setup do
+    @klass = Libvirt::Spec::Domain
+  end
+
+  context "initialization" do
+    setup do
+      @instance= @klass.new
+    end
+
+    should "not have any devices" do
+      assert @instance.devices.empty?
+    end
+  end
+end

data/test/libvirt/storage_pool_test.rb

@@ -0,0 +1,133 @@
+require "test_helper"
+
+Protest.describe("storage pool") do
+  setup do
+    @klass = Libvirt::StoragePool
+
+    @data = {
+      :name => "default-pool",
+      :uuid => "786f6276-656e-4074-8000-0a0027000000",
+      :capacity => "107374182400"
+    }
+
+    @conn = Libvirt.connect("test:///default")
+    @instance = @klass.new(FFI::Libvirt.virStoragePoolDefineXML(@conn, <<-XML, 0))
+<pool type='dir'>
+  <name>#{@data[:name]}</name>
+  <uuid>#{@data[:uuid]}</uuid>
+  <capacity>#{@data[:capacity]}</capacity>
+  <allocation>0</allocation>
+  <available>107374182400</available>
+  <source>
+  </source>
+  <target>
+    <path>/default-pool</path>
+    <permissions>
+      <mode>0700</mode>
+      <owner>-1</owner>
+      <group>-1</group>
+    </permissions>
+  </target>
+</pool>
+XML
+  end
+
+  should "be able to retrieve the connection" do
+    result = @instance.connection
+    assert result.is_a?(Libvirt::Connection)
+  end
+
+  should "provide the name" do
+    result = @instance.name
+    assert_equal @data[:name], result
+  end
+
+  should "provide the UUID" do
+    result = @instance.uuid
+    assert result
+    assert_equal 36, result.length
+  end
+
+  should "provide the state" do
+    assert_equal :running, @instance.state
+    @instance.stop
+    assert_equal :inactive, @instance.state
+  end
+
+  should "provide the capacity" do
+    assert_equal @data[:capacity].to_i, @instance.capacity
+  end
+
+  should "provide the current allocation" do
+    assert_equal 0, @instance.allocation
+  end
+
+  should "provide the available bytes remaining" do
+    assert_equal 107374182400, @instance.available
+  end
+
+  should "dump the XML" do
+    result = @instance.xml
+    assert result
+  end
+
+  should "provide an active check" do
+    @instance.start
+    assert @instance.active?
+  end
+
+  should "provide a persistence check" do
+    assert @instance.persistent?
+    # TODO: Check state change. Not sure how to trigger this at the moment.
+  end
+
+  should "not raise an exception if instance is already active and start is called" do
+    assert @instance.active?
+    assert_nothing_raised { @instance.start }
+  end
+
+  should "be able to build storage pool" do
+    @instance.stop
+    assert @instance.build
+  end
+
+  context "deleting underlying resources" do
+    setup do
+      @instance.stop
+    end
+
+    should "be able to delete underlying resources" do
+      assert @instance.delete
+    end
+
+    should "be able to specify type of delete" do
+      assert @instance.delete(:zeroed)
+    end
+  end
+
+  should "be able to be stopped" do
+    assert @instance.active?
+    @instance.stop
+    assert !@instance.active?
+  end
+
+  should "be able to undefine a storage pool" do
+    @instance.stop
+    assert @conn.storage_pools.include?(@instance)
+    @instance.undefine
+    assert !@conn.storage_pools.include?(@instance)
+  end
+
+  should "provide a collection of volumes" do
+    result = nil
+    assert_nothing_raised { result = @instance.volumes }
+    assert result.is_a?(Libvirt::Collection::StorageVolumeCollection)
+  end
+
+  should "provide a `to_ptr` method to get the pointer" do
+    result = nil
+    assert_nothing_raised { result = @instance.to_ptr }
+    assert result.is_a?(FFI::Pointer)
+    assert !result.null?
+  end
+end

data/test/libvirt/storage_volume_test.rb

@@ -0,0 +1,63 @@
+require "test_helper"
+
+Protest.describe("storage volume") do
+  setup do
+    @klass = Libvirt::StorageVolume
+
+    @data = {
+      :name => "test_vm_A.vdi",
+      :key => "f9eba311-ea76-4e4a-ad7b-401fa81e38c8"
+    }
+
+    @connection = Libvirt.connect("test:///default")
+    @pool = @connection.storage_pools.first
+    @instance = @pool.volumes.create(<<-XML)
+<volume>
+  <name>#{@data[:name]}</name>
+  <key>#{@data[:key]}</key>
+  <source>
+  </source>
+  <capacity>8589934592</capacity>
+  <allocation>33280</allocation>
+  <target>
+    <format type='raw'/>
+    <permissions>
+      <mode>00</mode>
+      <owner>0</owner>
+      <group>0</group>
+    </permissions>
+  </target>
+</volume>
+XML
+  end
+
+  should "be able to retrieve the key" do
+    assert @instance.uuid
+  end
+
+  should "be able to retrieve the name" do
+    assert_equal @data[:name], @instance.name
+  end
+
+  should "be able to retrieve the path" do
+    assert_equal "/default-pool/test_vm_A.vdi", @instance.path
+  end
+
+  should "be able to retrieve the type of this volume" do
+    assert_equal :file, @instance.type
+  end
+
+  should "be able to retrieve the capacity" do
+    assert_equal 8589934592, @instance.capacity
+  end
+
+  should "be able to retrieve the allocation" do
+    assert_equal 33280, @instance.allocation
+  end
+
+  should "be able to delete the storage volume" do
+    assert @pool.volumes.include?(@instance)
+    @instance.delete
+    assert !@pool.volumes.include?(@instance)
+  end
+end

data/test/support/xml_assertions.rb

@@ -0,0 +1,29 @@
+class Protest::TestCase
+  # Assert the value of an xpath expression is valid
+  def assert_xpath(expected, xml, xpath, msg = nil)
+    full_message = build_message(msg, '? at ? should be ?', xpath, xml, expected)
+    assert_block full_message do
+      value = Nokogiri::XML.parse(xml).at_xpath(xpath)
+      value && value.text == expected
+    end
+  end
+
+  # Assert an element exists
+  def assert_element(xml, xpath, msg = nil)
+    full_message = build_message(msg, 'element ? at ? not found', xpath, xml)
+    assert_block full_message do
+      element = Nokogiri::XML.parse(xml).at_xpath(xpath)
+      !element.nil? && element.element?
+    end
+  end
+
+  # Assert an element doesn't exist
+  def assert_not_element(xml, xpath)
+    assert_nil Nokogiri::XML.parse(xml).at_xpath(xpath)
+  end
+
+  # Assert a valid number of elements
+  def assert_elements(expected_size, xml, xpath, msg = nil)
+    assert_equal expected_size, Nokogiri::XML.parse(xml).xpath(xpath).size
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,23 @@
+require "test/unit/assertions"
+require "protest"
+require "mocha"
+require "libvirt"
+
+# Test helpers which monkey-patch Protest::TestCase directly
+require File.expand_path("../support/xml_assertions", __FILE__)
+
+class Protest::TestCase
+  include Test::Unit::Assertions
+  include Mocha::API
+
+  # Get Mocha integrated properly into the tests
+  alias :original_run :run
+  def run(report)
+    original_run(report)
+    mocha_verify
+  ensure
+    mocha_teardown
+  end
+end
+
+Protest.report_with(:progress)