virtualbox 0.6.1 → 0.7.0

data/test/virtualbox/dhcp_server_test.rb

@@ -0,0 +1,165 @@
+require File.join(File.dirname(__FILE__), '..', 'test_helper')
+
+class DHCPServerTest < Test::Unit::TestCase
+  setup do
+    @interface = mock("interface")
+    @parent = mock("parent")
+
+    @klass = VirtualBox::DHCPServer
+  end
+
+  context "class methods" do
+    context "populating relationships" do
+      setup do
+        @instance = mock("instance")
+        @klass.stubs(:new).returns(@instance)
+      end
+
+      should "return a proxied collection" do
+        result = @klass.populate_relationship(nil, [])
+        assert result.is_a?(VirtualBox::Proxies::Collection)
+      end
+
+      should "call new for every interface" do
+        collection = []
+        5.times { |i| collection << mock("a#{i}") }
+
+        expected_result = []
+        new_seq = sequence("new_seq")
+        collection.each do |item|
+          expected_value = "instance-#{item.inspect}"
+          @klass.expects(:new).with(item).in_sequence(new_seq).returns(expected_value)
+          expected_result << expected_value
+        end
+
+        assert_equal expected_result, @klass.populate_relationship(@parent, collection)
+      end
+    end
+
+    context "creating" do
+      setup do
+        @lib = mock("lib")
+        @virtualbox = mock("virtualbox")
+        @proxy = mock("proxy")
+
+        @lib.stubs(:virtualbox).returns(@virtualbox)
+        @parent.stubs(:lib).returns(@lib)
+        @proxy.stubs(:parent).returns(@parent)
+      end
+
+      should "create the dhcp server" do
+        name = :foo
+        interface = mock("interface")
+        result = mock("result")
+        @virtualbox.expects(:create_dhcp_server).with(name).once.returns(interface)
+        @klass.expects(:new).with(interface).returns(result)
+        assert_equal result, @klass.create(@proxy, name)
+      end
+    end
+  end
+
+  context "initializing" do
+    should "load attributes from the machine" do
+      @klass.any_instance.expects(:initialize_attributes).with(@interface).once
+      @klass.new(@interface)
+    end
+  end
+
+  context "initializing attributes" do
+    setup do
+      @klass.any_instance.stubs(:load_interface_attributes)
+    end
+
+    should "load interface attribtues" do
+      @klass.any_instance.expects(:load_interface_attributes).with(@interface).once
+      @klass.new(@interface)
+    end
+
+    should "be existing record" do
+      @instance = @klass.new(@interface)
+      assert !@instance.new_record?
+    end
+  end
+
+  context "instance methods" do
+    setup do
+      @klass.any_instance.stubs(:initialize_attributes)
+
+      @parent = mock("parent")
+      @interface = mock("interface")
+      @instance = @klass.new(@interface)
+      @instance.stubs(:interface).returns(@interface)
+      @collection = VirtualBox::Proxies::Collection.new(@parent)
+      @collection << @instance
+    end
+
+    context "saving" do
+      setup do
+        @instance.stubs(:save_changed_interface_attributes)
+      end
+
+      should "set configuration if something changed" do
+        @instance.ip_address = "7"
+        @interface.expects(:set_configuration).once
+        @instance.save
+      end
+
+      should "not set configuration if nothing changed" do
+        @interface.expects(:set_configuration).never
+        @instance.save
+      end
+
+      should "save the changed attributes" do
+        @instance.expects(:save_changed_interface_attributes).with(@instance.interface).once
+        @instance.save
+      end
+    end
+
+    context "destroying" do
+      setup do
+        @lib = mock("lib")
+        @virtualbox = mock("virtualbox")
+        @lib.stubs(:virtualbox).returns(@virtualbox)
+        @parent.stubs(:lib).returns(@lib)
+
+        @virtualbox.stubs(:remove_dhcp_server)
+      end
+
+      should "destroy the DHCP server" do
+        @virtualbox.expects(:remove_dhcp_server).with(@interface).once
+        @instance.destroy
+      end
+
+      should "remove from collection" do
+        assert @collection.include?(@instance)
+        @instance.destroy
+        assert !@collection.include?(@instance)
+      end
+    end
+
+    context "host network" do
+      setup do
+        @host = mock("host")
+        @network_interfaces = []
+        @parent.stubs(:host).returns(@host)
+        @host.stubs(:network_interfaces).returns(@network_interfaces)
+      end
+
+      should "do nothing if not a DHCP server for a host interface" do
+        @instance.stubs(:network_name).returns("foo")
+        assert_nil @instance.host_network
+      end
+
+      should "return the matching network interface" do
+        name = "foo"
+        ni = mock("net_interface")
+        ni.stubs(:interface_type).returns(:host_only)
+        ni.stubs(:name).returns(name)
+
+        @network_interfaces << ni
+        @instance.stubs(:network_name).returns("HostInterfaceNetworking-#{name}")
+        assert_equal ni, @instance.host_network
+      end
+    end
+  end
+end

data/test/virtualbox/extra_data_test.rb

@@ -145,10 +145,11 @@ class ExtraDataTest < Test::Unit::TestCase
   end
 
   context "deleteting extra data" do
-    should "call set its value to nil" do
+    should "remove it from the interface and the hash" do
       key = :foo
-      @ed.expects(:[]=).with(key, nil).once
+      @interface.expects(:set_extra_data).with(key.to_s, nil).once
+      @ed.expects(:hash_delete).with(key.to_s)
       @ed.delete(key)
     end
   end
-end
+end

data/test/virtualbox/forwarded_port_test.rb

@@ -14,11 +14,13 @@ class ForwardedPortTest < Test::Unit::TestCase
 
   context "validations" do
     setup do
+      @collection = VirtualBox::Proxies::Collection.new(@caller)
+
       @port = VirtualBox::ForwardedPort.new
       @port.name = "foo"
       @port.guestport = "22"
       @port.hostport = "2222"
-      @port.added_to_relationship(@caller)
+      @port.added_to_relationship(@collection)
     end
 
     should "be valid with all fields" do
@@ -49,12 +51,16 @@ class ForwardedPortTest < Test::Unit::TestCase
   context "with an instance" do
     setup do
       @port = VirtualBox::ForwardedPort.new({
-        :parent => @caller,
         :name => "foo",
         :guestport => "22",
         :hostport => "2222"
       })
 
+      @collection = VirtualBox::Proxies::Collection.new(@caller)
+      @collection << @port
+
+      @port.clear_dirty!
+
       @ed = mock("extradata")
       @ed.stubs(:[]=)
       @ed.stubs(:save)
@@ -65,7 +71,7 @@ class ForwardedPortTest < Test::Unit::TestCase
     context "device" do
       setup do
         @port.new_record!
-        @port.added_to_relationship(@caller)
+        @port.added_to_relationship(@collection)
       end
 
       should "return the value set if it was set" do
@@ -190,6 +196,12 @@ class ForwardedPortTest < Test::Unit::TestCase
         @port.existing_record!
       end
 
+      should "remove itself from it's collection" do
+        assert @collection.include?(@port)
+        @port.destroy
+        assert !@collection.include?(@port)
+      end
+
       should "call delete on the extra data for each key" do
         @ed = mock("ed")
         @ed.expects(:delete).times(3)
@@ -246,6 +258,7 @@ class ForwardedPortTest < Test::Unit::TestCase
         assert_equal "22", object.guestport
         assert_equal "2222", object.hostport
         assert_equal "TCP", object.protocol
+        assert_equal @objects, object.parent_collection
       end
 
       should "be existing records" do
@@ -253,4 +266,4 @@ class ForwardedPortTest < Test::Unit::TestCase
       end
     end
   end
-end
+end

data/test/virtualbox/hard_drive_test.rb

@@ -68,25 +68,74 @@ class HardDriveTest < Test::Unit::TestCase
         @system_properties = mock("system_properties")
         @virtualbox = mock("virtualbox")
         @lib = mock("lib")
+        @new_medium = mock("new_medium")
 
+        @hard_disk_format = "VDI"
         @hard_disk_folder = "foobar"
 
         VirtualBox::Lib.stubs(:lib).returns(@lib)
         @lib.stubs(:virtualbox).returns(@virtualbox)
         @virtualbox.stubs(:system_properties).returns(@system_properties)
+        @system_properties.stubs(:default_hard_disk_format).returns(@hard_disk_format)
         @system_properties.stubs(:default_hard_disk_folder).returns(@hard_disk_folder)
       end
 
       should "clone the hard drive" do
-        format = "VDI"
-        new_medium = mock("new_medium")
         progress = mock("progress")
-        @virtualbox.expects(:create_hard_disk).with(format, "/foo.vdi").returns(new_medium)
-        @interface.expects(:clone_to).with(new_medium, :standard, nil).returns(progress)
+        @instance.expects(:create_hard_disk_medium).with("/foo.vdi", nil).returns(@new_medium)
+        @interface.expects(:clone_to).with(@new_medium, :standard, nil).returns(progress)
         progress.expects(:wait_for_completion).with(-1)
 
         @instance.clone("/foo.vdi")
       end
     end
   end
-end
+
+  context "creating a hard drive" do
+    setup do
+      @klass.any_instance.stubs(:initialize_attributes)
+      @instance = @klass.new
+      @instance.stubs(:validate)
+
+      @system_properties = mock("system_properties")
+      @virtualbox = mock("virtualbox")
+      @lib = mock("lib")
+      @new_medium = mock("new_medium")
+
+      @hard_disk_format = "VDI"
+      @hard_disk_folder = "foobar"
+
+      VirtualBox::Lib.stubs(:lib).returns(@lib)
+      @lib.stubs(:virtualbox).returns(@virtualbox)
+      @virtualbox.stubs(:system_properties).returns(@system_properties)
+      @system_properties.stubs(:default_hard_disk_format).returns(@hard_disk_format)
+      @system_properties.stubs(:default_hard_disk_folder).returns(@hard_disk_folder)
+    end
+
+    should "return false unless the record is new" do
+      @instance.stubs(:new_record?).returns(false)
+      assert_equal false, @instance.create
+    end
+
+    should "raise exception unless the record is valid" do
+      @instance.stubs(:valid?).returns(false)
+      assert_raises(VirtualBox::Exceptions::ValidationFailedException) do
+        @instance.create
+      end
+    end
+
+    should "create the hard drive" do
+      logical_size = 1000
+      progress = mock("progress")
+      @instance.stubs(:location).returns(@hard_disk_folder)
+      @instance.stubs(:format).returns(@hard_disk_format)
+      @instance.stubs(:logical_size).returns(logical_size)
+      @instance.expects(:create_hard_disk_medium).with(@hard_disk_folder, @hard_disk_format).returns(@new_medium)
+      @new_medium.expects(:create_base_storage).with(logical_size, :standard).returns(progress)
+      progress.expects(:wait_for_completion).with(-1)
+
+      @instance.create
+    end
+  end
+
+end

data/test/virtualbox/host_network_interface_test.rb

@@ -0,0 +1,254 @@
+require File.join(File.dirname(__FILE__), '..', 'test_helper')
+
+class HostNetworkInterfaceTest < Test::Unit::TestCase
+  setup do
+    @interface = mock("interface")
+    @parent = mock("parent")
+
+    @klass = VirtualBox::HostNetworkInterface
+  end
+
+  context "class methods" do
+    context "populating relationships" do
+      setup do
+        @instance = mock("instance")
+
+        @interface.stubs(:network_interfaces).returns([])
+        @klass.stubs(:new).returns(@instance)
+      end
+
+      should "return a proxied collection" do
+        result = @klass.populate_relationship(nil, @interface)
+        assert result.is_a?(VirtualBox::Proxies::Collection)
+      end
+
+      should "call new for every interface" do
+        collection = []
+        @interface.stubs(:network_interfaces).returns(collection)
+        5.times { |i| collection << mock("a#{i}") }
+
+        expected_result = []
+        new_seq = sequence("new_seq")
+        collection.each do |item|
+          expected_value = "instance-#{item.inspect}"
+          @klass.expects(:new).with(item).in_sequence(new_seq).returns(expected_value)
+          expected_result << expected_value
+        end
+
+        assert_equal expected_result, @klass.populate_relationship(@parent, @interface)
+      end
+    end
+
+    context "creating" do
+      setup do
+        @interface = mock("interface")
+        @inet = mock("inet")
+        @progress = mock("progress")
+      end
+
+      should "create and return new instance" do
+        result = mock("result")
+        @interface.expects(:create_host_only_network_interface).returns([@inet, @progress]).once
+        @progress.expects(:wait)
+        @klass.expects(:new).with(@inet).returns(result)
+
+        assert_equal result, @klass.create(nil, @interface)
+      end
+    end
+  end
+
+  context "initializing" do
+    should "load attributes from the machine" do
+      @klass.any_instance.expects(:initialize_attributes).with(@interface).once
+      @klass.new(@interface)
+    end
+  end
+
+  context "initializing attributes" do
+    setup do
+      @klass.any_instance.stubs(:load_interface_attributes)
+    end
+
+    should "load interface attribtues" do
+      @klass.any_instance.expects(:load_interface_attributes).with(@interface).once
+      @klass.new(@interface)
+    end
+
+    should "be existing record" do
+      @instance = @klass.new(@interface)
+      assert !@instance.new_record?
+    end
+  end
+
+  context "instance methods" do
+    setup do
+      @klass.any_instance.stubs(:initialize_attributes)
+
+      @parent = mock("parent")
+      @interface = mock("interface")
+      @instance = @klass.new(@interface)
+      @instance.stubs(:interface).returns(@interface)
+      @instance.stubs(:parent).returns(@parent)
+      @collection = VirtualBox::Proxies::Collection.new(@parent)
+      @collection << @instance
+    end
+
+    context "attached VMs" do
+      setup do
+        @parent_parent = mock("parentparent")
+        @parent.stubs(:parent).returns(@parent_parent)
+
+        @vms = []
+        @parent_parent.stubs(:vms).returns(@vms)
+      end
+
+      def stub_vm(*interfaces)
+        adapters = []
+        vm = mock("vm")
+        vm.stubs(:network_adapters).returns(adapters)
+
+        interfaces.each do |name|
+          adapter = mock("adapter")
+          adapter.stubs(:host_interface).returns(name)
+          adapters << adapter
+        end
+
+        vm
+      end
+
+      should "return no VMs if none are using the interface" do
+        assert @instance.attached_vms.empty?
+      end
+
+      should "return only the VMs which are using the interface" do
+        name = "foo"
+        @instance.stubs(:name).returns(name)
+        result = stub_vm(name)
+        @vms << stub_vm("bar")
+        @vms << result
+        @vms << stub_vm("baz")
+
+        assert_equal [result], @instance.attached_vms
+      end
+    end
+
+    context "dhcp server" do
+      setup do
+        @host = mock("host")
+        @dhcp_servers = []
+        @parent.stubs(:parent).returns(@host)
+        @host.stubs(:dhcp_servers).returns(@dhcp_servers)
+        @instance.stubs(:interface_type).returns(:host_only)
+
+        @name = "foo"
+        @instance.stubs(:name).returns(@name)
+      end
+
+      def stub_dhcp_server(name, prefix=true)
+        name = "HostInterfaceNetworking-#{name}" if prefix
+
+        dhcp = mock("dhcp")
+        dhcp.stubs(:network_name).returns(name)
+        dhcp
+      end
+
+      should "return nil if interface type isn't host only" do
+        @instance.stubs(:interface_type).returns(:bridged)
+        assert_nil @instance.dhcp_server
+      end
+
+      should "return the DHCP server if it finds one" do
+        server = stub_dhcp_server(@name)
+        @dhcp_servers << server
+        assert_equal server, @instance.dhcp_server
+      end
+
+      should "create a DHCP server if it can't find one" do
+        result = mock("result")
+      end
+
+      should "not create a DHCP if specified and not found" do
+        @dhcp_servers.expects(:create).never
+        assert_nil @instance.dhcp_server(false)
+      end
+    end
+
+    context "enabling static IPV4" do
+      setup do
+        @interface.stubs(:enable_static_ip_config)
+        @instance.stubs(:reload)
+      end
+
+      should "enable the ip config" do
+        ip = :foo
+        netmask = :bar
+        @interface.expects(:enable_static_ip_config).with(ip, netmask).once
+        @instance.enable_static(ip, netmask)
+      end
+
+      should "by default use the current network mask" do
+        ip = :foo
+        @interface.expects(:enable_static_ip_config).with(ip, @instance.network_mask).once
+        @instance.enable_static(ip)
+      end
+
+      should "reload the instance" do
+        result = mock("result")
+        @instance.expects(:reload).returns(result)
+        assert_equal result, @instance.enable_static(:foo)
+      end
+    end
+
+    context "reloading" do
+      setup do
+        @interface = mock("parent_interface")
+        @parent.stubs(:interface).returns(@interface)
+      end
+
+      should "reload based on the interface found by the parent" do
+        result = mock("result")
+        @interface.expects(:find_host_network_interface_by_id).with(@instance.uuid).once.returns(result)
+        @instance.expects(:initialize_attributes).with(result).once
+        assert_equal @instance, @instance.reload
+      end
+    end
+
+    context "destroying" do
+      setup do
+        @interface = mock("parent_interface")
+        @progress = mock("progress")
+        @progress.stubs(:wait)
+        @parent.stubs(:interface).returns(@interface)
+        @interface.stubs(:remove_host_only_network_interface).returns(@progress)
+        @instance.stubs(:dhcp_server).returns(nil)
+        @instance.stubs(:interface_type).returns(:host_only)
+      end
+
+      should "do nothing if bridged" do
+        @instance.stubs(:interface_type).returns(:bridged)
+        @interface.expects(:remove_host_only_network_interface).never
+        assert !@instance.destroy
+      end
+
+      should "remove the network interface from VirtualBox" do
+        @interface.expects(:remove_host_only_network_interface).with(@instance.uuid).returns(@progress)
+
+        @instance.destroy
+      end
+
+      should "destroy the DHCP server if it exists" do
+        server = mock("server")
+        @instance.stubs(:dhcp_server).returns(server)
+        server.expects(:destroy).once
+
+        @instance.destroy
+      end
+
+      should "remove the instance from it's collection" do
+        assert @collection.include?(@instance)
+        @instance.destroy
+        assert !@collection.include?(@instance)
+      end
+    end
+  end
+end

data/test/virtualbox/host_test.rb

@@ -0,0 +1,94 @@
+require File.join(File.dirname(__FILE__), '..', 'test_helper')
+
+class HostTest < Test::Unit::TestCase
+  setup do
+    @parent = mock("parent")
+    @klass = VirtualBox::Host
+    @interface = mock("interface")
+  end
+
+  context "initializing" do
+    should "load attributes from the machine" do
+      @klass.any_instance.expects(:initialize_attributes).with(@parent, @interface).once
+      @klass.new(@parent, @interface)
+    end
+  end
+
+  context "initializing attributes" do
+    setup do
+      @klass.any_instance.stubs(:load_interface_attributes)
+      @klass.any_instance.stubs(:populate_relationship)
+    end
+
+    should "load interface attribtues" do
+      @klass.any_instance.expects(:load_interface_attributes).with(@interface).once
+      @klass.new(@parent, @interface)
+    end
+
+    should "populate the relationships" do
+      @klass.any_instance.expects(:populate_relationship).with(:network_interfaces, @interface).once
+      @klass.new(@parent, @interface)
+    end
+
+    should "setup the interface" do
+      instance = @klass.new(@parent, @interface)
+      assert_equal @interface, instance.interface
+    end
+
+    should "not be dirty" do
+      @instance = @klass.new(@parent, @interface)
+      assert !@instance.changed?
+    end
+
+    should "be existing record" do
+      @instance = @klass.new(@parent, @interface)
+      assert !@instance.new_record?
+    end
+  end
+
+  context "class methods" do
+    context "populating relationship" do
+      setup do
+        @instance = mock("instance")
+        @klass.stubs(:new).returns(@instance)
+      end
+
+      should "return a SystemProperties instance" do
+        result = @klass.populate_relationship(nil, @interface)
+        assert_equal @instance, result
+      end
+
+      should "call new for every shared folder" do
+        @klass.expects(:new).with(nil, @interface).returns(@instance)
+        result = @klass.populate_relationship(nil, @interface)
+        assert_equal @instance, result
+      end
+    end
+
+    context "saving relationship" do
+      setup do
+        @item = mock("item")
+      end
+
+      should "just call save on the item" do
+        @item.expects(:save)
+        @klass.save_relationship(nil, @item)
+      end
+    end
+  end
+
+  context "instance methods" do
+    setup do
+      @klass.any_instance.stubs(:load_interface_attributes)
+      @klass.any_instance.stubs(:populate_relationship)
+      @instance = @klass.new(@parent, @interface)
+    end
+
+    context "saving" do
+      should "save changed interface attributes" do
+        @instance.expects(:save_changed_interface_attributes).with(@interface)
+        @instance.save
+      end
+    end
+  end
+end