virtualbox 0.5.4 → 0.6.0

data/test/virtualbox/lib_test.rb

@@ -0,0 +1,93 @@
+require File.join(File.dirname(__FILE__), '..', 'test_helper')
+
+class LibTest < Test::Unit::TestCase
+  context "the virtualbox library file path" do
+    setup do
+      VirtualBox::Lib.lib_path = nil
+    end
+
+    should "return the path if its set" do
+      File.expects(:expand_path).with("foo").returns("expanded_foo")
+      VirtualBox::Lib.lib_path = "foo"
+      assert_equal "expanded_foo", VirtualBox::Lib.lib_path
+    end
+
+    should "return Mac-path if on mac" do
+      result = ["/Applications/VirtualBox.app/Contents/MacOS/VBoxXPCOMC.dylib"]
+      VirtualBox::Platform.stubs(:mac?).returns(true)
+
+      assert_equal result, VirtualBox::Lib.lib_path
+    end
+
+    should "return Windows-path if on windows" do
+      result = "Unknown"
+      VirtualBox::Platform.stubs(:mac?).returns(false)
+      VirtualBox::Platform.stubs(:linux?).returns(false)
+      VirtualBox::Platform.stubs(:windows?).returns(true)
+
+      assert_equal result, VirtualBox::Lib.lib_path
+    end
+
+    should "return Linux-path if on linux" do
+      result = ["/opt/VirtualBox/VBoxXPCOMC.so", "/usr/lib/virtualbox/VBoxXPCOMC.so"]
+      VirtualBox::Platform.stubs(:mac?).returns(false)
+      VirtualBox::Platform.stubs(:windows?).returns(false)
+      VirtualBox::Platform.stubs(:linux?).returns(true)
+
+      assert_equal result, VirtualBox::Lib.lib_path
+    end
+
+    should "return 'unknown' otherwise" do
+      result = "Unknown"
+      VirtualBox::Platform.stubs(:mac?).returns(false)
+      VirtualBox::Platform.stubs(:windows?).returns(false)
+      VirtualBox::Platform.stubs(:linux?).returns(false)
+
+      assert_equal result, VirtualBox::Lib.lib_path
+    end
+  end
+
+  context "accessing the lib" do
+    setup do
+      @lib_path = "foo"
+      VirtualBox::Lib.stubs(:lib_path).returns(@lib_path)
+      VirtualBox::Lib.reset!
+    end
+
+    should "create a new Lib instance with the lib path once" do
+      instance = mock("instance")
+      VirtualBox::Lib.expects(:new).once.returns(instance)
+      assert_equal instance, VirtualBox::Lib.lib
+      assert_equal instance, VirtualBox::Lib.lib
+      assert_equal instance, VirtualBox::Lib.lib
+    end
+  end
+
+  context "init-ing" do
+    setup do
+      @lib_path = "foo"
+
+      @virtualbox = mock("virtualbox")
+      @session = mock("session")
+      @interface = mock("interface")
+      @interface.stubs(:virtualbox).returns(@virtualbox)
+      @interface.stubs(:session).returns(@session)
+    end
+
+    should "call init on FFI with the lib path for mac" do
+      VirtualBox::Platform.stubs(:windows?).returns(false)
+      VirtualBox::COM::FFIInterface.expects(:create).with(@lib_path).once.returns(@interface)
+      lib = VirtualBox::Lib.new(@lib_path)
+      assert_equal @virtualbox, lib.virtualbox
+      assert_equal @session, lib.session
+    end
+
+    should "init MSCOM for windows" do
+      VirtualBox::Platform.stubs(:windows?).returns(true)
+      VirtualBox::COM::MSCOMInterface.expects(:new).once.returns(@interface)
+      lib = VirtualBox::Lib.new(@lib_path)
+      assert_equal @virtualbox, lib.virtualbox
+      assert_equal @session, lib.session
+    end
+  end
+end

data/test/virtualbox/medium_attachment_test.rb

@@ -0,0 +1,147 @@
+require File.join(File.dirname(__FILE__), '..', 'test_helper')
+
+class MediumAttachmentTest < Test::Unit::TestCase
+  setup do
+    @interface = mock("interface")
+    @interface.stubs(:medium)
+    @parent = mock("parent")
+
+    @klass = VirtualBox::MediumAttachment
+  end
+
+  context "class methods" do
+    context "populating relationships" do
+      setup do
+        @instance = mock("instance")
+
+        @interface.stubs(:medium_attachments).returns([])
+
+        @klass.stubs(:device_type).returns(:all)
+        @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 medium if device type is all" do
+        attachments = []
+        @interface.stubs(:medium_attachments).returns(attachments)
+        5.times { |i| attachments << mock("a#{i}") }
+
+        expected_result = []
+        new_seq = sequence("new_seq")
+        attachments.each do |attachment|
+          expected_value = "instance-#{attachment.inspect}"
+          @klass.expects(:new).with(@parent, attachment).in_sequence(new_seq).returns(expected_value)
+          expected_result << expected_value
+        end
+
+        assert_equal expected_result, @klass.populate_relationship(@parent, @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(@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 relationships" do
+      @klass.any_instance.expects(:populate_relationship).twice
+      @klass.new(@parent, @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 "instance methods" do
+    setup do
+      @klass.any_instance.stubs(:initialize_attributes)
+
+      @parent = mock("parent")
+      @interface = mock("interface")
+      @instance = @klass.new(@parent, @interface)
+    end
+
+    context "detaching" do
+      setup do
+        @machine = mock("machine")
+        @session = mock("session")
+        @session.stubs(:machine).returns(@machine)
+
+        @sc = mock("storage_controller")
+        @sc.stubs(:name).returns("foo")
+        @instance.stubs(:storage_controller).returns(@sc)
+        @instance.stubs(:port).returns(7)
+        @instance.stubs(:device).returns(12)
+      end
+
+      should "open session, detach, then save" do
+        det_seq = sequence("detach_seq")
+        @parent.expects(:with_open_session).yields(@session).in_sequence(det_seq)
+        @machine.expects(:detach_device).with(@sc.name, @instance.port, @instance.device).in_sequence(det_seq)
+
+        @instance.detach
+      end
+    end
+
+    context "destroying" do
+      setup do
+        @medium = mock("medium")
+        @instance.stubs(:medium).returns(@medium)
+      end
+
+      should "just detach" do
+        @instance.expects(:detach).once
+        @instance.destroy
+      end
+
+      should "not destroy medium if nil but specified" do
+        @instance.stubs(:medium).returns(nil)
+
+        @instance.expects(:detach).once
+        @medium.expects(:destroy).with(false).never
+        assert_nothing_raised {
+          @instance.destroy(:destroy_medium => true)
+        }
+      end
+
+      should "destroy medium if specified" do
+        destroy_seq = sequence("destroy_seq")
+        @instance.expects(:detach).once.in_sequence(destroy_seq)
+        @medium.expects(:destroy).with(false).once.in_sequence(destroy_seq)
+        @instance.destroy(:destroy_medium => true)
+      end
+
+      should "destroy medium and backing store if specified" do
+        destroy_seq = sequence("destroy_seq")
+        @instance.expects(:detach).once.in_sequence(destroy_seq)
+        @medium.expects(:destroy).with(true).once.in_sequence(destroy_seq)
+        @instance.destroy(:destroy_medium => :delete)
+      end
+    end
+  end
+end

data/test/virtualbox/medium_test.rb

@@ -0,0 +1,192 @@
+require File.join(File.dirname(__FILE__), '..', 'test_helper')
+
+class MediumTest < Test::Unit::TestCase
+  setup do
+    @klass = VirtualBox::Medium
+    @imedium = mock("IMedium")
+    @interface = @imedium
+    @imedium.stubs(:refresh_state)
+  end
+
+  context "class methods" do
+    context "device type" do
+      should "be all on the medium" do
+        assert_equal :all, @klass.device_type
+      end
+    end
+
+    context "populating relationships" do
+      setup do
+        @caller = mock("caller")
+      end
+
+      should "call populate_array_relationship for arrays" do
+        @klass.expects(:populate_array_relationship).with(@caller, []).once
+        @klass.populate_relationship(@caller, [])
+      end
+
+      should "call populate_single_relationship for non-arrays" do
+        @klass.expects(:populate_single_relationship).with(@caller, nil).once
+        @klass.populate_relationship(@caller, nil)
+      end
+    end
+
+    context "populating array relationship" do
+      setup do
+        @instance = mock("instance")
+
+        @klass.stubs(:device_type).returns(:all)
+        @klass.stubs(:new).returns(@instance)
+      end
+
+      def mock_medium(device_type)
+        medium = mock("medium")
+        medium.stubs(:device_type).returns(device_type)
+        medium
+      end
+
+      should "return a proxied collection" do
+        result = @klass.populate_array_relationship(nil, [])
+        assert result.is_a?(VirtualBox::Proxies::Collection)
+      end
+
+      should "call new for every medium if device type is all" do
+        media = []
+        5.times { |i| media << mock_medium("m#{i}") }
+
+        expected_result = []
+        new_seq = sequence("new_seq")
+        media.each do |medium|
+          expected_value = "instance-#{medium.inspect}"
+          @klass.expects(:new).with(medium).in_sequence(new_seq).returns(expected_value)
+          expected_result << expected_value
+        end
+
+        assert_equal expected_result, @klass.populate_array_relationship(nil, media)
+      end
+
+      should "ignore non-matching devices if device_type is not :all" do
+        @klass.stubs(:device_type).returns(:foo)
+
+        media = [mock_medium(:foo), mock_medium(:bar)]
+        result = @klass.populate_array_relationship(nil, media)
+        assert_equal 1, result.length
+      end
+    end
+
+    context "populating a single relationship" do
+      setup do
+        @subclasses = []
+        @klass.stubs(:subclasses).returns(@subclasses)
+        @imedium.stubs(:get_device_type).returns(nil)
+      end
+
+      def mock_subclass(device_type)
+        subclass = mock("subclass")
+        subclass.stubs(:device_type).returns(device_type)
+        subclass
+      end
+
+      should "instantiate the matching subclass" do
+        type = :foo
+        result = mock("result")
+        matching = mock_subclass(type)
+        matching.expects(:new).with(@imedium).once.returns(result)
+        @subclasses << matching
+        @imedium.stubs(:device_type).returns(type)
+
+        assert_equal result, @klass.populate_single_relationship(nil, @imedium)
+      end
+
+      should "return a Medium if nothing matches" do
+        result = mock("result")
+        @klass.expects(:new).with(@imedium).returns(result)
+        assert_equal result, @klass.populate_single_relationship(nil, @imedium)
+      end
+
+      should "return nil if medium given is nil" do
+        @klass.expects(:new).never
+        assert_nil @klass.populate_single_relationship(nil, nil)
+      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
+
+    should "set the interface as the interface attribute" do
+      @klass.any_instance.stubs(:initialize_attributes)
+      instance = @klass.new(@interface)
+      assert_equal @interface, instance.interface
+    end
+  end
+
+  context "initializing attributes" do
+    setup do
+      @interface.stubs(:refresh_state)
+      @klass.any_instance.stubs(:load_interface_attributes)
+    end
+
+    should "refresh state then load interface attribtues" do
+      init_seq = sequence("init_seq")
+      @interface.expects(:refresh_state).in_sequence(init_seq)
+      @klass.any_instance.expects(:load_interface_attributes).with(@interface).once.in_sequence(init_seq)
+      @klass.new(@interface)
+    end
+
+    should "not be dirty" do
+      @instance = @klass.new(@interface)
+      assert !@instance.changed?
+    end
+
+    should "be existing record" do
+      @instance = @klass.new(@interface)
+      assert !@instance.new_record?
+    end
+  end
+
+  context "with an instance" do
+    setup do
+      @klass.any_instance.stubs(:initialize_attributes)
+      @instance = @klass.new(@imedium)
+    end
+
+    context "filename" do
+      setup do
+        @location = "/foo/bar/baz.rb"
+        @instance.stubs(:location).returns(@location)
+      end
+
+      should "return the basename of the location" do
+        assert_equal File.basename(@location), @instance.filename
+      end
+    end
+
+    context "destroy storage" do
+      should "delete the storage then wait for it to complete" do
+        progress = mock("progress")
+
+        @imedium.expects(:delete_storage).once.returns(progress)
+        progress.expects(:wait_for_completion).with(-1).once
+
+        @instance.destroy_storage
+      end
+    end
+
+    context "destroying" do
+      should "just close the medium if first argument is not specified" do
+        @instance.expects(:destroy_storage).never
+        @imedium.expects(:close).once
+        @instance.destroy
+      end
+
+      should "destroy the storage if first argument is true" do
+        @instance.expects(:destroy_storage).once
+        @instance.destroy(true)
+      end
+    end
+  end
+end

data/test/virtualbox/network_adapter_test.rb

@@ -0,0 +1,160 @@
+require File.join(File.dirname(__FILE__), '..', 'test_helper')
+
+class NetworkAdapterTest < Test::Unit::TestCase
+  setup do
+    @klass = VirtualBox::NetworkAdapter
+    @interface = mock("interface")
+    @parent = mock("parent")
+  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_relationships)
+
+      @instance = @klass.new(@parent, @interface)
+    end
+
+    should "load interface attribtues" do
+      @klass.any_instance.expects(:load_interface_attributes).with(@interface).once
+      @klass.new(@parent, @interface)
+    end
+
+    should "setup the parent" do
+      assert_equal @parent, @instance.parent
+    end
+
+    should "setup the interface" do
+      assert_equal @interface, @instance.interface
+    end
+
+    should "not be dirty" do
+      assert !@instance.changed?
+    end
+
+    should "be existing record" do
+      assert !@instance.new_record?
+    end
+  end
+
+  context "class methods" do
+    context "populating relationship" do
+      setup do
+        @instance = mock("instance")
+        @klass.stubs(:new).returns(@instance)
+
+        @count = 5
+        @vbox = mock("vbox")
+        @system_properties = mock("sys_props")
+        @interface.stubs(:parent).returns(@vbox)
+        @vbox.stubs(:system_properties).returns(@system_properties)
+        @system_properties.stubs(:network_adapter_count).returns(@count)
+      end
+
+      should "return a proxied collection" do
+        @system_properties.stubs(:network_adapter_count).returns(0)
+        result = @klass.populate_relationship(nil, @interface)
+        assert result.is_a?(VirtualBox::Proxies::Collection)
+      end
+
+      should "call new for every shared folder" do
+        expected_result = []
+        new_seq = sequence("new_seq")
+        @count.times do |i|
+          expected_value = "instance-#{i}"
+          adapter = mock("adapter#{i}")
+          @interface.expects(:get_network_adapter).with(i).returns(adapter).in_sequence(new_seq)
+          @klass.expects(:new).with(@parent, adapter).in_sequence(new_seq).returns(expected_value)
+          expected_result << expected_value
+        end
+
+        assert_equal expected_result, @klass.populate_relationship(@parent, @interface)
+      end
+    end
+
+    context "saving relationship" do
+      should "call save on each item" do
+        items = (1..5).to_a.collect do |i|
+          item = mock("item-#{i}")
+          item.expects(:save).once
+          item
+        end
+
+        @klass.save_relationship(nil, items)
+      end
+    end
+  end
+
+  context "instance methods" do
+    setup do
+      @klass.any_instance.stubs(:load_interface_attributes)
+      @instance = @klass.new(@parent, @interface)
+    end
+
+    context "saving" do
+      setup do
+        @adapter = mock("adapter")
+        @instance.stubs(:modify_adapter).yields(@adapter)
+      end
+
+      should "save the attachment type and interface attributes on the open adapter" do
+        @instance.expects(:save_attachment_type).with(@adapter).once
+        @instance.expects(:save_changed_interface_attributes).with(@adapter).once
+        @instance.save
+      end
+    end
+
+    context "saving attachment type" do
+      setup do
+        @adapter = mock("adapter")
+        @instance.attachment_type = :nat
+      end
+
+      should "do nothing if attachment type is not changed" do
+        @instance.clear_dirty!
+        assert !@instance.attachment_type_changed?
+        @instance.expects(:attach_to_nat).never
+
+        @instance.save_attachment_type(@adapter)
+      end
+
+      should "run the proper method if it has changed" do
+        @adapter.expects(:attach_to_nat).once
+        @instance.save_attachment_type(@adapter)
+      end
+
+      should "clear the dirty state" do
+        @adapter.stubs(:attach_to_nat)
+        @instance.save_attachment_type(@adapter)
+        assert !@instance.attachment_type_changed?
+      end
+    end
+
+    context "modifying the adapter" do
+      setup do
+        @machine = mock("machine")
+        @session = mock("session")
+        @session.stubs(:machine).returns(@machine)
+
+        @adapter = mock("adapter")
+      end
+
+      should "open a session, yield the proper adapter, then save settings" do
+        seq = sequence("sequence")
+        @parent.expects(:with_open_session).yields(@session).in_sequence(seq)
+        @machine.expects(:get_network_adapter).with(@instance.slot).returns(@adapter).in_sequence(seq)
+
+        @instance.modify_adapter do |adapter|
+          assert_equal @adapter, adapter
+        end
+      end
+    end
+  end
+end