virtualbox 0.5.4 → 0.6.0

data/test/virtualbox/shared_folder_test.rb

@@ -2,223 +2,207 @@ require File.join(File.dirname(__FILE__), '..', 'test_helper')
 
 class SharedFolderTest < Test::Unit::TestCase
   setup do
-    @data = {
-      :sharedfoldernamemachinemapping1 => "foofolder",
-      :sharedfolderpathmachinemapping1 => "/foo",
-      :sharedfoldernamemachinemapping2 => "barfolder",
-      :sharedfolderpathmachinemapping2 => "/bar"
-    }
+    @klass = VirtualBox::SharedFolder
+    @interface = mock("interface")
+    @parent = mock("parent")
+  end
 
-    @caller = mock("caller")
-    @caller.stubs(:name).returns("foo")
+  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
 
-    VirtualBox::Command.stubs(:execute)
+    should "not load attributes if new record" do
+      @klass.any_instance.expects(:initialize_attributes).never
+      @klass.new
+    end
   end
 
-  context "validations" do
+  context "initializing attributes" do
     setup do
-      @sf = VirtualBox::SharedFolder.new
-      @sf.name = "foo"
-      @sf.hostpath = "bar"
-      @sf.added_to_relationship(@caller)
+      @klass.any_instance.stubs(:load_interface_attributes)
+      @klass.any_instance.stubs(:populate_relationships)
     end
 
-    should "be valid with all fields" do
-      assert @sf.valid?
+    should "load interface attribtues" do
+      @klass.any_instance.expects(:load_interface_attributes).with(@interface).once
+      @klass.new(@parent, @interface)
     end
 
-    should "be invalid with no name" do
-      @sf.name = nil
-      assert !@sf.valid?
+    should "setup the parent" do
+      instance = @klass.new(@parent, @interface)
+      assert_equal @parent, instance.parent
     end
 
-    should "be invalid with no hostpath" do
-      @sf.hostpath = nil
-      assert !@sf.valid?
+    should "not be dirty" do
+      @instance = @klass.new(@parent, @interface)
+      assert !@instance.changed?
     end
 
-    should "be invalid if not in a relationship" do
-      @sf.write_attribute(:parent, nil)
-      assert !@sf.valid?
+    should "be existing record" do
+      @instance = @klass.new(@parent, @interface)
+      assert !@instance.new_record?
     end
   end
 
-  context "saving an existing shared folder" do
-    setup do
-      @value = VirtualBox::SharedFolder.populate_relationship(@caller, mock_xml_doc)
-      @value = @value[0]
-      @value.name = "different"
-      assert @value.changed?
-    end
+  context "class methods" do
+    context "populating relationship" do
+      setup do
+        @instance = mock("instance")
 
-    should "first destroy the shared folder then recreate it" do
-      seq = sequence("create_seq")
-      @value.expects(:destroy).in_sequence(seq)
-      VirtualBox::Command.expects(:vboxmanage).in_sequence(seq)
-      assert @value.save
+        @klass.stubs(:new).returns(@instance)
+
+        @collection = []
+        @interface.stubs(:shared_folders).returns(@collection)
+      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 shared folder" do
+        5.times { |i| @collection << mock("#{i}") }
+
+        expected_result = []
+        new_seq = sequence("new_seq")
+        @collection.each do |item|
+          expected_value = "instance-#{item.inspect}"
+          @klass.expects(:new).with(nil, item).in_sequence(new_seq).returns(expected_value)
+          expected_result << expected_value
+        end
+
+        assert_equal expected_result, @klass.populate_relationship(nil, @interface)
+      end
     end
 
-    should "call destroy with raise errors if set" do
-      @value.expects(:destroy).with(true).once
-      assert @value.save(true)
+    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 "creating a new shared folder" do
+  context "instance methods" do
     setup do
-      @sf = VirtualBox::SharedFolder.new
-      @sf.name = "foo"
-      @sf.hostpath = "bar"
-    end
+      @klass.any_instance.stubs(:load_interface_attributes)
+      @instance = @klass.new(@parent, @interface)
 
-    should "return false and not call vboxmanage if invalid" do
-      VirtualBox::Command.expects(:vboxmanage).never
-      @sf.expects(:valid?).returns(false)
-      assert !@sf.save
-    end
+      @parent_interface = mock("interface")
+      @parent.stubs(:interface).returns(@parent_interface)
+
+      @machine = mock("machine")
+      @machine.stubs(:remove_shared_folder).with(@name)
 
-    should "raise a ValidationFailedException if invalid and raise_errors is true" do
-      @sf.expects(:valid?).returns(false)
-      assert_raises(VirtualBox::Exceptions::ValidationFailedException) {
-        @sf.save(true)
-      }
+      @session = mock("session")
+      @session.stubs(:machine).returns(@machine)
+
+      @parent.stubs(:with_open_session).yields(@session)
     end
 
-    context "has a parent" do
+    context "saving" do
       setup do
-        @sf.added_to_relationship(@caller)
-        VirtualBox::Command.stubs(:vboxmanage)
+        @instance.stubs(:valid?).returns(true)
       end
 
-      should "not call destroy since its a new record" do
-        @sf.expects(:destroy).never
-        assert @sf.save
+      should "do nothing if its not a new record and its not changed" do
+        assert !@instance.new_record?
+        assert !@instance.changed?
+        assert @instance.save
       end
 
-      should "call the proper vboxcommand" do
-        VirtualBox::Command.expects(:vboxmanage).with("sharedfolder", "add", @caller.name, "--name", @sf.name, "--hostpath", @sf.hostpath)
-        assert @sf.save
-      end
+      should "raise an exception if invalid" do
+        @instance.name = "foo_bar" # To set the changed flag
+        @instance.expects(:valid?).returns(false)
 
-      should "return false if the command failed" do
-        VirtualBox::Command.stubs(:vboxmanage).raises(VirtualBox::Exceptions::CommandFailedException)
-        assert !@sf.save
+        assert_raises(VirtualBox::Exceptions::ValidationFailedException) {
+          @instance.save
+        }
       end
 
-      should "return true if the command was a success" do
-        assert @sf.save
-      end
+      should "destroy then create" do
+        @instance.name = "foo_bar"
+        assert !@instance.new_record? # sanity
 
-      should "raise an exception if true sent to save and error occured" do
-        VirtualBox::Command.stubs(:vboxmanage).raises(VirtualBox::Exceptions::CommandFailedException)
-        assert_raises(VirtualBox::Exceptions::CommandFailedException) {
-          @sf.save(true)
-        }
-      end
+        save_seq = sequence("save_seq")
+        @instance.expects(:destroy).once.in_sequence(save_seq)
+        @instance.expects(:create).once.in_sequence(save_seq)
 
-      should "not be a new record after saving" do
-        assert @sf.new_record?
-        assert @sf.save
-        assert !@sf.new_record?
+        @instance.save
       end
 
-      should "not be changed after saving" do
-        assert @sf.changed?
-        assert @sf.save
-        assert !@sf.changed?
-      end
-    end
-  end
+      should "just create (not destroy) if its a new record" do
+        @instance.new_record!
 
-  context "constructor" do
-    should "call initialize_for_relationship if 3 args are given" do
-      VirtualBox::SharedFolder.any_instance.expects(:initialize_for_relationship).with(1,2,3).once
-      VirtualBox::SharedFolder.new(1,2,3)
-    end
+        @instance.expects(:destroy).never
+        @instance.expects(:create).once
 
-    should "raise a NoMethodError if anything other than 0,1,or 3 arguments" do
-      2.upto(9) do |i|
-        next if i == 3
-        args = Array.new(i, "A")
-
-        assert_raises(NoMethodError) {
-          VirtualBox::SharedFolder.new(*args)
-        }
+        @instance.save
       end
     end
 
-    should "populate from a hash if one argument is given" do
-      VirtualBox::SharedFolder.any_instance.expects(:initialize_for_data).with("HI").once
-      VirtualBox::SharedFolder.new("HI")
-    end
-
-    context "initializing from data" do
+    context "creating" do
       setup do
-        @sf = VirtualBox::SharedFolder.new({:name => "foo", :hostpath => "bar"})
-      end
+        @instance.new_record!
 
-      should "allow the use of :name and :hostpath in the hash" do
-        assert_equal "foo", @sf.name
-        assert_equal "bar", @sf.hostpath
-      end
+        @instance.name = "foo"
+        @instance.host_path = "/bar"
+        @instance.writable = true
 
-      should "keep the record new" do
-        assert @sf.new_record?
+        @machine.stubs(:create_shared_folder)
       end
-    end
-  end
 
-  context "destroying" do
-    setup do
-      @value = VirtualBox::SharedFolder.populate_relationship(@caller, mock_xml_doc)
-      @value = @value[0]
-    end
-
-    should "call the proper command" do
-      VirtualBox::Command.expects(:vboxmanage).with("sharedfolder", "remove", @caller.name, "--name", @value.name).once
-      assert @value.destroy
-    end
-
-    should "return false if destroy failed" do
-      VirtualBox::Command.stubs(:vboxmanage).raises(VirtualBox::Exceptions::CommandFailedException)
-      assert !@value.destroy
-    end
+      should "do nothing if its an existing record" do
+        @instance.existing_record!
+        @machine.expects(:create_shared_folder).never
+        @instance.create
+      end
 
-    should "raise an exception if destroy failed and an error occured" do
-      VirtualBox::Command.stubs(:vboxmanage).raises(VirtualBox::Exceptions::CommandFailedException)
-      assert_raises(VirtualBox::Exceptions::CommandFailedException) {
-        @value.destroy(true)
-      }
-    end
+      should "create the shared folder" do
+        create_seq = sequence("create_seq")
+        @machine.expects(:create_shared_folder).with(@instance.name, @instance.host_path, @instance.writable).once.in_sequence(create_seq)
+        @instance.create
+      end
 
-    should "use the old name if it was changed" do
-      @value.name = "DIFFERENT"
-      VirtualBox::Command.expects(:vboxmanage)
-      assert @value.destroy
-    end
-  end
+      should "not be a new record after saving" do
+        assert @instance.new_record?
+        @instance.create
+        assert !@instance.new_record?
+      end
 
-  context "populating relationships" do
-    setup do
-      @value = VirtualBox::SharedFolder.populate_relationship(@caller, mock_xml_doc)
+      should "not be dirty after saving" do
+        assert @instance.changed?
+        @instance.create
+        assert !@instance.changed?
+      end
     end
 
-    should "be a 'collection'" do
-      assert @value.is_a?(VirtualBox::Proxies::Collection)
-    end
+    context "destroying" do
+      setup do
+        @name = "foo"
+        @instance.stubs(:name).returns(@name)
+        @machine.stubs(:remove_shared_folder).with(@name)
+      end
 
-    should "create the correct amount of objects" do
-      assert_equal 2, @value.length
-    end
+      should "destroy the shared folder on the parent" do
+        destroy_seq = sequence("destroy_seq")
+        @machine.expects(:remove_shared_folder).with(@name).in_sequence(destroy_seq)
 
-    should "parse the proper data" do
-      value = @value[0]
-      assert_equal "foo", value.name
-      assert_equal "/foo", value.hostpath
+        @instance.destroy
+      end
 
-      value = @value[1]
-      assert_equal "bar", value.name
-      assert_equal "/bar", value.hostpath
+      should "mark as a new record" do
+        assert !@instance.new_record?
+        @instance.destroy
+        assert @instance.new_record?
+      end
     end
   end
 end

data/test/virtualbox/storage_controller_test.rb

@@ -2,75 +2,196 @@ require File.join(File.dirname(__FILE__), '..', 'test_helper')
 
 class StorageControllerTest < Test::Unit::TestCase
   setup do
-    @data = {
-      :storagecontrollername0 => "foo",
-      :storagecontrollermaxportcount0 => 7,
-      :storagecontrollername1 => "bar",
-      :storagecontrollermaxportcount1 => 4,
-      :"foo-0-0" => "yay",
-      :"foo-1-0" => "again",
-      :"bar-0-0" => "rawr"
-    }
-
-    @caller = mock("caller")
+    @interface = mock("interface")
+    @parent = mock("parent")
+
+    @klass = VirtualBox::StorageController
   end
 
-  context "saving" do
-    setup do
-      @value = VirtualBox::StorageController.populate_relationship(@caller, mock_xml_doc)
-      @value = @value[0]
+  context "class methods" do
+    context "populating relationship" do
+      setup do
+        # Defaulting for non-specified parameters
+        @interface.stubs(:is_a?).returns(false)
+      end
+
+      should "populate array relationship if IMachine is given" do
+        @interface.expects(:is_a?).with(VirtualBox::COM::Interface::Machine).returns(true)
+        @klass.expects(:populate_array_relationship).once.with(@parent, @interface)
+        @klass.populate_relationship(@parent, @interface)
+      end
+
+      should "populate attachment relationship if MediumAttachment is given" do
+        @interface.expects(:is_a?).with(VirtualBox::MediumAttachment).returns(true)
+        @klass.expects(:populate_attachment_relationship).once.with(@parent, @interface)
+        @klass.populate_relationship(@parent, @interface)
+      end
+    end
+
+    context "populating array (has many) relationship" do
+      setup do
+        @instance = mock("instance")
+
+        @interface.stubs(:storage_controllers).returns([])
+
+        @klass.stubs(:device_type).returns(:all)
+        @klass.stubs(:new).returns(@instance)
+      end
+
+      def mock_controller(name)
+        controller = mock(name)
+        controller
+      end
+
+      should "return a proxied collection" do
+        result = @klass.populate_array_relationship(nil, @interface)
+        assert result.is_a?(VirtualBox::Proxies::Collection)
+      end
+
+      should "call new for every medium if device type is all" do
+        controllers = []
+        @interface.stubs(:storage_controllers).returns(controllers)
+        5.times { |i| controllers << mock_controller("c#{i}") }
+
+        expected_result = []
+        new_seq = sequence("new_seq")
+        controllers.each do |controller|
+          expected_value = "instance-#{controller.inspect}"
+          @klass.expects(:new).with(@parent, controller).in_sequence(new_seq).returns(expected_value)
+          expected_result << expected_value
+        end
+
+        assert_equal expected_result, @klass.populate_array_relationship(@parent, @interface)
+      end
+    end
+
+    context "populating relationship for a MediumAttachment" do
+      setup do
+        @controllers = []
+
+        @machine = mock("machine")
+        @machine.stubs(:storage_controllers).returns(@controllers)
+
+        @interface.stubs(:parent).returns(@machine)
+      end
+
+      should "return nil if no controllers match" do
+        assert_nil @klass.populate_attachment_relationship(@parent, @interface)
+      end
+
+      should "return the controller with matching name" do
+        name = :foo
+        @interface.stubs(:controller_name).returns(name)
+
+        controller = mock("controller")
+        controller.stubs(:name).returns(:foo)
+        @controllers << controller
+
+        assert_equal controller, @klass.populate_attachment_relationship(@parent, @interface)
+      end
     end
 
-    should "save relationship" do
-      VirtualBox::AttachedDevice.expects(:save_relationship).once
-      @value.save
+    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 "destroying" do
+  context "initializing" do
     setup do
-      @value = VirtualBox::StorageController.populate_relationship(@caller, mock_xml_doc)
-      @value = @value[0]
+      @klass.any_instance.stubs(:load_interface_attributes)
     end
 
-    should "simply call destroy on each object when destroying the relationship" do
-      obj_one = mock("one")
-      obj_two = mock("two")
+    should "load interface attribtues" do
+      @klass.any_instance.expects(:load_interface_attributes).with(@interface).once
+      @klass.new(@parent, @interface)
+    end
 
-      obj_one.expects(:destroy).with("HELLO").once
-      obj_two.expects(:destroy).with("HELLO").once
+    should "not be dirty" do
+      @instance = @klass.new(@parent, @interface)
+      assert !@instance.changed?
+    end
 
-      VirtualBox::StorageController.destroy_relationship(self, [obj_one, obj_two], "HELLO")
+    should "be existing record" do
+      @instance = @klass.new(@parent, @interface)
+      assert !@instance.new_record?
     end
 
-    should "call destroy_relationship on AttachedDevices when destroyed" do
-      assert !@value.devices.empty?
+    should "setup parent" do
+      @instance = @klass.new(@parent, @interface)
+      assert_equal @parent, @instance.parent
+    end
 
-      VirtualBox::AttachedDevice.expects(:destroy_relationship).once
-      @value.destroy
+    should "setup interface" do
+      @instance = @klass.new(@parent, @interface)
+      assert_equal @interface, @instance.interface
     end
   end
 
-  context "populating relationships" do
+  context "instance methods" do
     setup do
-      @sc = mock_xml_doc.css("StorageControllers StorageController").first
-    end
+      @klass.any_instance.stubs(:load_interface_attributes)
 
-    should "create a collection proxy" do
-      value = VirtualBox::StorageController.populate_relationship(@caller, mock_xml_doc)
-      assert value.is_a?(VirtualBox::Proxies::Collection)
+      @parent = mock("parent")
+      @interface = mock("interface")
+      @instance = @klass.new(@parent, @interface)
     end
 
-    should "create the correct amount of objects" do
-      value = VirtualBox::StorageController.populate_relationship(@caller, mock_xml_doc)
-      assert_equal 1, value.length
+    context "medium attachments" do
+      setup do
+        @medium_attachments = []
+        @parent.stubs(:medium_attachments).returns(@medium_attachments)
+      end
+
+      def mock_medium_attachment(sc)
+        ma = mock("ma-#{sc.inspect}")
+        ma.stubs(:storage_controller).returns(sc)
+        ma
+      end
+
+      should "return all medium attachments which match the storage controller" do
+        foo_ma = mock_medium_attachment(@instance)
+        @medium_attachments << foo_ma
+        @medium_attachments << mock_medium_attachment(:bar)
+
+        assert_equal [foo_ma], @instance.medium_attachments
+      end
     end
 
-    should "use populate keys when extracting keys" do
-      value = VirtualBox::StorageController.new(0, @caller, @sc)
-      assert_equal "foo", value.name
-      assert_equal "2", value.ports
-      assert_equal "PIIX4", value.type
+    context "destroying" do
+      setup do
+        @ma = []
+        @instance.stubs(:medium_attachments).returns(@ma)
+
+        @machine = mock("machine")
+        @session = mock("session")
+        @session.stubs(:machine).returns(@machine)
+        @parent.stubs(:with_open_session).yields(@session)
+      end
+
+      should "remove all the attachments" do
+        ma = mock("medium_attachment")
+        @ma << ma
+
+        destroy_seq = sequence("destroy_seq")
+        ma.expects(:destroy).with(1,2,3).once.in_sequence(destroy_seq)
+        @machine.expects(:remove_storage_controller).with(@instance.name).in_sequence(destroy_seq)
+
+        @instance.destroy(1,2,3)
+      end
+
+      should "remove from the parent and save" do
+        destroy_seq = sequence("destroy_seq")
+        @machine.expects(:remove_storage_controller).with(@instance.name).in_sequence(destroy_seq)
+        @instance.destroy
+      end
     end
   end
 end