libvirt 0.1.0

data/test/libvirt/collection/domain_collection_test.rb

@@ -0,0 +1,122 @@
+require "test_helper"
+
+Protest.describe("domain collection") do
+  setup do
+    @klass = Libvirt::Collection::DomainCollection
+    @instance = @klass.new(Libvirt::Connection.new("test:///default"))
+  end
+
+  should "provide a list of active domains" do
+    active = @instance.active
+    assert active.is_a?(Array)
+    assert_equal 1, active.length
+    assert active.all? { |a| a.is_a?(Libvirt::Domain) }
+  end
+
+  should "provide a list of inactive domains" do
+    inactive = @instance.inactive
+    assert inactive.is_a?(Array)
+    # TODO: Define inactive domains and test they're here?
+  end
+
+  should "provide a list of all domains" do
+    assert_equal (@instance.active + @instance.inactive), @instance.all
+  end
+
+  should "provide a length method" do
+    assert_equal @instance.all.length, @instance.length
+  end
+
+  should "provide a first method" do
+    assert_equal @instance.all.first, @instance.first
+  end
+
+  should "provide an each method" do
+    assert @instance.respond_to?(:each)
+  end
+
+  context "finding" do
+    should "find by name and UUID for `find`" do
+      assert @instance.find("test")
+      assert @instance.find(1)
+      assert @instance.find(@instance.first.uuid)
+
+      result = @instance.find("lksadjfkj") rescue nil
+      assert !result
+    end
+
+    should "find by name" do
+      result = @instance.find_by_name("test")
+      assert result
+
+      result = @instance.find_by_name("bar") rescue nil
+      assert !result
+    end
+
+    should "find by id" do
+      assert @instance.find_by_id(1)
+      assert_raises(Libvirt::Exception::LibvirtError) {  @instance.find_by_id(42) }
+    end
+
+    should "find by UUID" do
+      result = @instance.find_by_uuid(@instance.first.uuid)
+      assert result
+
+      result = @instance.find_by_uuid("dklf") rescue nil
+      assert !result
+    end
+  end
+
+  context "a new domain" do
+    setup do
+      @spec = Libvirt::Spec::Domain.new
+      @spec.hypervisor = :test
+      @spec.name = "My Test VM"
+      @spec.os.type = :hvm
+      @spec.memory = 123456 # KB
+    end
+
+    context "defining a new domain" do
+      should "define the new domain when the specification is valid" do
+        result = nil
+        assert_nothing_raised { result = @instance.define(@spec) }
+        assert result.is_a?(Libvirt::Domain)
+        assert !result.active?
+        assert_equal @spec.name, result.name
+      end
+
+      should "define the new domain when the specification is a string" do
+        result = nil
+        assert_nothing_raised { result = @instance.define(@spec.to_xml) }
+        assert result.is_a?(Libvirt::Domain)
+        assert !result.active?
+        assert_equal @spec.name, result.name
+      end
+
+      should "raise an error when the specification is not valid" do
+        @spec.hypervisor = nil
+        assert_raise(Libvirt::Exception::LibvirtError) {
+          @instance.define(@spec)
+        }
+      end
+    end
+
+    context "creating a new domain" do
+      should "create the new domain with the specification" do
+        result = nil
+        assert_nothing_raised { result = @instance.create(@spec) }
+        assert result.is_a?(Libvirt::Domain)
+        assert result.active?
+        assert_equal @spec.name, result.name
+      end
+
+      should "create a new domain with a string specification" do
+        result = nil
+        assert_nothing_raised { result = @instance.create(@spec.to_xml) }
+        assert result.is_a?(Libvirt::Domain)
+        assert result.active?
+        assert_equal @spec.name, result.name
+      end
+    end
+  end
+end

data/test/libvirt/collection/interface_collection_test.rb

@@ -0,0 +1,9 @@
+require "test_helper"
+
+Protest.describe("interface collection") do
+  setup do
+    @klass = Libvirt::Collection::InterfaceCollection
+  end
+
+  # TODO
+end

data/test/libvirt/collection/network_collection_test.rb

@@ -0,0 +1,41 @@
+require "test_helper"
+
+Protest.describe("network collection") do
+  setup do
+    @klass = Libvirt::Collection::NetworkCollection
+    @instance = @klass.new(Libvirt.connect("test:///default"))
+  end
+
+  context "finding" do
+    should "be able to find by name or UUID" do
+      assert @instance.find("default")
+      assert !@instance.find("foo")
+    end
+
+    should "be able to find by name" do
+      assert @instance.find_by_name("default")
+      assert_raises(Libvirt::Exception::LibvirtError) {  @instance.find_by_name("foo") }
+    end
+
+    should "be able to find by UUID" do
+      assert_raises(Libvirt::Exception::LibvirtError) { @instance.find_by_uuid("bad") }
+      # TODO: Test successful case
+    end
+  end
+
+  should "provide a list of active networks" do
+    active = @instance.active
+    assert active.is_a?(Array)
+    assert active.all? { |a| a.is_a?(Libvirt::Network) }
+  end
+
+  should "provide a list of inactive networks" do
+    inactive = @instance.inactive
+    assert inactive.is_a?(Array)
+    # TODO: Create inactive networks to test result
+  end
+
+  should "provide a list of all networks" do
+    assert_equal (@instance.active + @instance.inactive), @instance.all
+  end
+end

data/test/libvirt/collection/node_device_collection_test.rb

@@ -0,0 +1,24 @@
+require "test_helper"
+
+Protest.describe("node device collection") do
+  setup do
+    @klass = Libvirt::Collection::NodeDeviceCollection
+    @instance = Libvirt.connect("test:///default").node.devices
+  end
+
+  should "provide access to all nodes" do
+    result = nil
+    assert_nothing_raised { result = @instance.all }
+    assert result
+  end
+
+  should "be able to create a node device" do
+    assert_raises(Libvirt::Exception::LibvirtError) {
+      @instance.create(<<-XML)
+<device>
+  <name>computer2</name>
+</device>
+XML
+    }
+  end
+end

data/test/libvirt/collection/nwfilter_collection_test.rb

@@ -0,0 +1,7 @@
+require "test_helper"
+
+Protest.describe("nwfilter collection") do
+  setup do
+    @klass = Libvirt::Collection::NWFilterCollection
+  end
+end

data/test/libvirt/collection/storage_pool_collection_test.rb

@@ -0,0 +1,41 @@
+require "test_helper"
+
+Protest.describe("storage pool collection") do
+  setup do
+    @klass = Libvirt::Collection::StoragePoolCollection
+    @instance = @klass.new(Libvirt.connect("test:///default"))
+  end
+
+  context "finding" do
+    should "be able to generally find" do
+      assert @instance.find("default-pool")
+      assert !@instance.find("foo")
+    end
+
+    should "be able to find by name" do
+      assert @instance.find_by_name("default-pool")
+      assert_raises(Libvirt::Exception::LibvirtError) { @instance.find_by_name("foo") }
+    end
+
+    should "be able to find by UUID" do
+      # TODO: Test happy-path
+      assert_raises(Libvirt::Exception::LibvirtError) { @instance.find_by_uuid("foo") }
+    end
+  end
+
+  should "provide a list of active storage pools" do
+    active = @instance.active
+    assert active.is_a?(Array)
+    # assert active.all? { |a| a.is_a?(Libvirt::StoragePool) }
+  end
+
+  should "provide a list of inactive storage pools" do
+    inactive = @instance.inactive
+    assert inactive.is_a?(Array)
+    # TODO: Create inactive storage pools to test result
+  end
+
+  should "provide a list of all storage pools" do
+    assert_equal (@instance.active + @instance.inactive), @instance.all
+  end
+end

data/test/libvirt/collection/storage_volume_collection_test.rb

@@ -0,0 +1,86 @@
+require "test_helper"
+
+Protest.describe("storage volume collection") do
+  setup do
+    @klass = Libvirt::Collection::StorageVolumeCollection
+    @instance = @klass.new(Libvirt.connect("test:///default").storage_pools.first)
+
+    @single = @instance.create(<<-XML)
+<volume>
+  <name>test</name>
+  <key>g9eba311-ea76-4e4a-ad7b-401fa81e38c8</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
+
+  context "finding" do
+    should "find by any string" do
+      assert @instance.find("test")
+      assert @instance.find(@single.key)
+      assert @instance.find(@single.path)
+      assert !@instance.find("foo")
+    end
+
+    should "find by name" do
+      assert @instance.find_by_name("test")
+      assert_raises(Libvirt::Exception::LibvirtError) {
+        @instance.find_by_name("slkjfdlksa")
+      }
+    end
+
+    should "find by key" do
+      assert @instance.find_by_key(@single.key)
+      assert_raises(Libvirt::Exception::LibvirtError) {
+        @instance.find_by_key("foo")
+      }
+    end
+
+    should "find_by_path" do
+      assert @instance.find_by_path(@single.path)
+      assert_raises(Libvirt::Exception::LibvirtError) {
+        @instance.find_by_path("foo")
+      }
+    end
+  end
+
+  should "be able to create a new volume" do
+    result = @instance.create(<<-XML)
+<volume>
+  <name>test_vm_A.vdi</name>
+  <key>f9eba311-ea76-4e4a-ad7b-401fa81e38c8</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
+
+    assert result
+    assert @instance.all.include?(result)
+  end
+
+  should "provide a list of all volumes" do
+    all = @instance.all
+    assert all.is_a?(Array)
+  end
+end

data/test/libvirt/connection_test.rb

@@ -0,0 +1,133 @@
+require "test_helper"
+
+Protest.describe("connection") do
+  setup do
+    @klass = Libvirt::Connection
+  end
+
+  context "connecting" do
+    should "connect given a pointer to a connection" do
+      pointer = FFI::Libvirt.virConnectOpen("test:///default")
+      result = @klass.new(pointer)
+      assert_equal pointer, result.to_ptr
+    end
+
+    should "connect and return a connection" do
+      result = nil
+      assert_nothing_raised { result = @klass.new("test:///default") }
+      assert result.is_a?(@klass)
+    end
+
+    should "connect to a readonly connection" do
+      result = nil
+      assert_nothing_raised { result = @klass.new("test:///default", :readonly => true) }
+      assert result.is_a?(@klass)
+
+      # Test readonly-ness
+    end
+
+    should "raise an exception if the connection fails" do
+      assert_raise(Libvirt::Exception::LibvirtError) {
+        @klass.new("thisshouldneverpass:)")
+      }
+    end
+  end
+
+  context "with a valid connection" do
+    setup do
+      @cxn = @klass.new("test:///default")
+    end
+
+    should "provide the library version" do
+      # We rely on virsh to get the version of libvirt
+      version = @cxn.lib_version
+      actual = `virsh --version`.chomp.split(".").map { |s| s.to_i }
+      assert_equal actual, version
+    end
+
+    should "provide the node" do
+      result = @cxn.node
+      assert result
+      assert result.is_a?(Libvirt::Node)
+      assert result.connection.eql?(@cxn)
+    end
+
+    should "provide the capabilities of the connection" do
+      assert_nothing_raised { @cxn.capabilities }
+    end
+
+    should "provide the hostname of the connection" do
+      assert_nothing_raised { @cxn.hostname }
+    end
+
+    should "provide the uri of the connection" do
+      result = nil
+      assert_nothing_raised { result = @cxn.uri }
+      assert_equal "test:///default", result
+    end
+
+    should "provide the type of the connection" do
+      result = nil
+      assert_nothing_raised { result = @cxn.type }
+      assert_equal "Test", result
+    end
+
+    should "provide the max virtual CPUs" do
+      assert_equal 32, @cxn.max_virtual_cpus("test")
+    end
+
+    should "provide the hypervisor version of the connection" do
+      result = nil
+      assert_nothing_raised { result = @cxn.hypervisor_version }
+      assert_equal [0,0,2], result
+    end
+
+    should "provide a list of domains" do
+      result = nil
+      assert_nothing_raised { result = @cxn.domains }
+      assert result.is_a?(Libvirt::Collection::DomainCollection)
+      assert @cxn.equal?(result.interface)
+    end
+
+    should "provide a list of interfaces" do
+      result = nil
+      assert_nothing_raised { result = @cxn.interfaces }
+      assert result.is_a?(Libvirt::Collection::InterfaceCollection)
+      assert @cxn.equal?(result.interface)
+    end
+
+    should "providea list of networks" do
+      result = nil
+      assert_nothing_raised { result = @cxn.networks }
+      assert result.is_a?(Libvirt::Collection::NetworkCollection)
+      assert @cxn.equal?(result.interface)
+    end
+
+    should "provide a list of NW filters" do
+      result = nil
+      assert_nothing_raised { result = @cxn.nwfilters }
+      assert result.is_a?(Libvirt::Collection::NWFilterCollection)
+      assert @cxn.equal?(result.interface)
+    end
+
+    should "provide a list of storage pools" do
+      result = nil
+      assert_nothing_raised { result = @cxn.storage_pools }
+      assert result.is_a?(Libvirt::Collection::StoragePoolCollection)
+      assert @cxn.equal?(result.interface)
+    end
+
+    should "check if encrypted" do
+      assert !@cxn.encrypted?
+    end
+
+    should "check if secure" do
+      assert @cxn.secure?
+    end
+
+    should "garbage collect the connection" do
+      # TODO: Memprof this thing to figure out what is holding
+      # references to a connection so the GC actually works.
+    end
+  end
+end

data/test/libvirt/domain_test.rb

@@ -0,0 +1,221 @@
+require "test_helper"
+
+Protest.describe("domain") do
+  setup do
+    @klass = Libvirt::Domain
+
+    @spec = Libvirt::Spec::Domain.new
+    @spec.hypervisor = :test
+    @spec.name = "libvirt-rb-test"
+    @spec.os.type = :hvm
+    @spec.memory = 123456 # KB
+
+    @conn = Libvirt.connect("test:///default")
+    @instance = @conn.domains.define(@spec)
+  end
+
+  should "provide the name of the domain" do
+    assert_equal "libvirt-rb-test", @instance.name
+  end
+
+  should "provide the UUID of the domain" do
+    result = nil
+    assert_nothing_raised { result = @instance.uuid }
+    assert_equal 36, result.length
+  end
+
+  should "provide the ID of the domain" do
+    assert_equal 4294967295, @instance.id
+  end
+
+  should "provide the OS type of the domain" do
+    assert_equal "linux", @instance.os_type
+  end
+
+  should "provide the state of the domain" do
+    assert_equal :shutoff, @instance.state
+  end
+
+  context "maximum memory" do
+    should "be retrievable" do
+      assert_equal 123456, @instance.max_memory
+    end
+
+    should "be settable" do
+      @instance.max_memory = 234567
+      assert_equal 234567, @instance.max_memory
+    end
+  end
+
+  context "memory" do
+    should "be retrievable" do
+      assert_equal 123456, @instance.memory
+    end
+
+    should "be settable" do
+      @instance.memory = 7000
+      assert_equal 7000, @instance.memory
+    end
+  end
+
+  context "virtual CPUs" do
+    should "be retrievable" do
+      assert_equal 1, @instance.virtual_cpus
+    end
+
+    should "be able to retrieve maximum" do
+      @instance.start
+      assert_equal 1, @instance.max_virtual_cpus
+    end
+
+    should "be settable" do
+      @instance.start
+      @instance.virtual_cpus = 1
+      assert_equal 1, @instance.virtual_cpus
+    end
+  end
+
+  should "provide the CPU time used in nanoseconds" do
+    # This result is constantly changing so all we can really test is that
+    # its properly returned
+    result = nil
+    assert_nothing_raised { result = @instance.cpu_time_used }
+    assert result.is_a?(Integer)
+  end
+
+  should "provide an XML dump of the description of the domain" do
+    result = nil
+    assert_nothing_raised { result = @instance.xml }
+    assert result.is_a?(String)
+    assert !result.empty?
+  end
+
+  should "return result of active status" do
+    @instance.start
+    assert @instance.active?
+    @instance.destroy
+    assert !@instance.active?
+  end
+
+  should "return result of persistent status" do
+    # Instance domain is defined so should be persistent:
+    assert @instance.persistent?
+
+    # Create a new domain, shouldn't be persistent
+    @spec.name = "another"
+    other = @conn.domains.create(@spec)
+    assert !other.persistent?
+  end
+
+  context "autostart" do
+    should "check status" do
+      assert !@instance.autostart?
+    end
+
+    should "set status" do
+      @instance.autostart = true
+      assert @instance.autostart?
+    end
+  end
+
+  context "when creating" do
+    should "return true if succeeds" do
+      @instance.destroy
+      assert !@instance.active?
+      assert @instance.create
+      assert @instance.active?
+    end
+
+    should "not raise an error if the domain is already running" do
+      @instance.start
+      assert @instance.active? # pre-requisite
+      assert_nothing_raised { @instance.create }
+    end
+
+    should "also respond to `start`" do
+      assert !@instance.active?
+      assert @instance.start
+      assert @instance.active?
+    end
+  end
+
+  context "when destroying" do
+    should "return true if succeeds" do
+      assert @instance.destroy
+      assert !@instance.active?
+    end
+
+    should "not raise an error if the domain is already stopped" do
+      @instance.destroy
+      assert_nothing_raised { @instance.destroy }
+    end
+
+    should "also respond to `stop`" do
+      assert @instance.stop
+      assert !@instance.active?
+    end
+  end
+
+  context "when suspending" do
+    setup do
+      @instance.create
+    end
+
+    should "return true if succeeds" do
+      assert @instance.suspend
+    end
+
+    should "raise an error if the domain is already suspended" do
+      @instance.suspend
+      assert_raise(Libvirt::Exception::LibvirtError) {
+        @instance.suspend
+      }
+    end
+
+    should "raise an error if the domain is destroyed" do
+      @instance.destroy
+      assert_raise(Libvirt::Exception::LibvirtError) {
+        @instance.suspend
+      }
+    end
+  end
+
+  context "when resuming" do
+    setup do
+      @instance.create
+    end
+
+    should "return true if succeeds" do
+      assert @instance.suspend
+      assert @instance.resume
+    end
+
+    should "not raise an error if the domain is running" do
+      assert @instance.active?
+      assert @instance.resume
+    end
+
+    should "raise an error if the domain is destroyed" do
+      @instance.destroy
+      assert_raise(Libvirt::Exception::LibvirtError) {
+        @instance.resume
+      }
+    end
+  end
+
+  should "be able to reboot" do
+    assert_nothing_raised { @instance.reboot }
+  end
+
+  should "be able to shutdown" do
+    @instance.start
+    assert_nothing_raised { @instance.shutdown }
+  end
+
+  should "be able to undefine a domain" do
+    @instance.destroy
+    assert @conn.domains.include?(@instance)
+    @instance.undefine
+    assert !@conn.domains.include?(@instance)
+  end
+end