virtualbox 0.1.1 → 0.2.0

data/test/virtualbox/attached_device_test.rb

@@ -19,6 +19,161 @@ class AttachedDeviceTest < Test::Unit::TestCase
     VirtualBox::Command.stubs(:execute).returns('')
   end
   
+  context "medium" do
+    setup do
+      @ad = VirtualBox::AttachedDevice.new
+      @hd = VirtualBox::HardDrive.new
+      @hd.write_attribute(:uuid, @uuid)
+    end
+    
+    should "be 'none' when image is nil" do
+      assert_equal "none", @ad.medium
+    end
+    
+    should "be the uuid of the image if its not nil" do
+      @ad.image = @hd
+      assert_equal @hd.uuid, @ad.medium
+    end
+    
+    should "be 'emptydrive' if the image is an empty drive" do
+      @ad.image = VirtualBox::DVD.empty_drive
+      assert_equal "emptydrive", @ad.medium
+    end
+  end
+  
+  context "saving an existing device" do
+    setup do
+      @value = VirtualBox::AttachedDevice.populate_relationship(@caller, @data)
+      @value = @value[0]
+      @value.image = VirtualBox::DVD.empty_drive
+      assert @value.changed?
+    end
+    
+    should "not do anything if the device isn't change" do
+      @value.clear_dirty!
+      assert !@value.changed?
+      
+      VirtualBox::Command.expects(:vboxmanage).never
+      @value.save
+    end
+    
+    should "call vboxmanage" do
+      VirtualBox::Command.expects(:vboxmanage).once
+      @value.save
+    end
+    
+    should "not call destroy if the port didn't change" do
+      @value.expects(:destroy).never
+      assert !@value.port_changed?
+      assert @value.save
+    end
+    
+    should "call destroy with the old port if the port changed" do
+      @value.expects(:destroy).with({:port => @value.port}, false)
+      @value.port = 7
+      assert @value.port_changed?
+      assert @value.save
+    end
+    
+    should "call destroy with the raise errors flag" do
+      @value.expects(:destroy).with(anything, true).once
+      @value.port = 7
+      @value.save(true)
+    end
+  end
+  
+  context "creating a new attached device" do
+    setup do
+      @image = VirtualBox::HardDrive.new
+      @ad = VirtualBox::AttachedDevice.new
+      @ad.image = @image
+      @ad.port = 3
+    end
+    
+    should "raise a NoParentException if it wasn't added to a relationship" do
+      assert_raises(VirtualBox::Exceptions::NoParentException) {
+        @ad.save
+      }
+    end
+    
+    context "has a parent" do
+      setup do
+        @ad.added_to_relationship(@caller)
+        VirtualBox::Command.stubs(:vboxmanage)
+      end
+      
+      should "not call destroy since its a new record" do
+        @ad.expects(:destroy).never
+        assert @ad.save
+      end
+      
+      should "not raise an InvalidObjectException if no image is set" do
+        @ad.image = nil
+        assert_raises(VirtualBox::Exceptions::InvalidObjectException) {
+          @ad.save
+        }
+      end
+
+      should "call the proper vboxcommand" do
+        VirtualBox::Command.expects(:vboxmanage).with("storageattach #{@vm.name} --storagectl #{VirtualBox::Command.shell_escape(@caller.name)} --port #{@ad.port} --device 0 --type #{@image.image_type} --medium #{@ad.medium}")
+        @ad.save
+      end
+
+      should "return false if the command failed" do
+        VirtualBox::Command.stubs(:vboxmanage).raises(VirtualBox::Exceptions::CommandFailedException)
+        assert !@ad.save
+      end
+
+      should "return true if the command was a success" do
+        assert @ad.save
+      end
+      
+      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) {
+          @ad.save(true)
+        }
+      end
+      
+      should "not be a new record after saving" do
+        assert @ad.new_record?
+        assert @ad.save
+        assert !@ad.new_record?
+      end
+      
+      should "not be changed after saving" do
+        assert @ad.changed?
+        assert @ad.save
+        assert !@ad.changed?
+      end
+    end
+  end
+  
+  context "constructor" do
+    should "call populate_from_data if 3 args are given" do
+      VirtualBox::AttachedDevice.any_instance.expects(:populate_from_data).with(1,2,3).once
+      VirtualBox::AttachedDevice.new(1,2,3)
+    end
+    
+    should "call populate_attributes if 1 arg is given" do
+      VirtualBox::AttachedDevice.any_instance.expects(:populate_attributes).with(1).once
+      ad = VirtualBox::AttachedDevice.new(1)
+      assert ad.new_record?
+    end
+    
+    should "raise a NoMethodError if anything other than 0,1,or 3 arguments" do
+      # 9 seems like a reasonable max (maybe just a bit unreasonable!)
+      2.upto(9) do |i|
+        next if i == 3
+        args = Array.new(i, "A")
+        
+        assert_raises(NoMethodError) {
+          VirtualBox::AttachedDevice.new(*args)
+        }
+      end
+    end
+  end
+  
   context "destroying" do
     setup do
       @value = VirtualBox::AttachedDevice.populate_relationship(@caller, @data)
@@ -48,6 +203,16 @@ class AttachedDeviceTest < Test::Unit::TestCase
       @value.destroy
     end
     
+    should "destroy with the specified port if set" do
+      VirtualBox::Command.expects(:vboxmanage).with("storageattach #{VirtualBox::Command.shell_escape(@vm.name)} --storagectl #{VirtualBox::Command.shell_escape(@caller.name)} --port 80 --device 0 --medium none")
+      @value.destroy(:port => 80)
+    end
+    
+    should "destroy with the default port if not other port is specified" do
+      VirtualBox::Command.expects(:vboxmanage).with("storageattach #{VirtualBox::Command.shell_escape(@vm.name)} --storagectl #{VirtualBox::Command.shell_escape(@caller.name)} --port #{@value.port} --device 0 --medium none")
+      @value.destroy
+    end
+    
     should "not destroy image by default" do
       @image.expects(:destroy).never
       @value.destroy
@@ -66,6 +231,23 @@ class AttachedDeviceTest < Test::Unit::TestCase
         :destroy_image => true
       })
     end
+    
+    should "return false if destroy failed" do
+      VirtualBox::Command.stubs(:vboxmanage).raises(VirtualBox::Exceptions::CommandFailedException)
+      assert !@value.destroy
+    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 "forward raise_errors flag to image.destroy" do
+      @image.expects(:destroy).with(true).once
+      @value.destroy({:destroy_image => true}, true)
+    end
   end
   
   context "populating relationships" do
@@ -79,12 +261,12 @@ class AttachedDeviceTest < Test::Unit::TestCase
     
     should "create objects with proper values" do
       obj = @value[0]
-      assert_equal "foomedium", obj.medium
+      assert_equal "none", obj.medium
       assert_equal "322f79fd-7da6-416f-a16f-e70066ccf165", obj.uuid
       assert_equal 0, obj.port
       
       obj = @value[1]
-      assert_equal "barmedium", obj.medium
+      assert_equal "none", obj.medium
       assert_nil obj.uuid
       assert_equal 1, obj.port
     end

data/test/virtualbox/command_test.rb

@@ -9,6 +9,42 @@ class CommandTest < Test::Unit::TestCase
     end
   end
   
+  context "executing commands" do
+    should "use backticks to execute the command" do
+      VirtualBox::Command.expects(:`).with("foo").once
+      VirtualBox::Command.execute("foo")
+    end
+    
+    should "return the result of the execution" do
+      VirtualBox::Command.expects(:`).with("foo").returns("bar").once
+      assert_equal "bar", VirtualBox::Command.execute("foo")
+    end
+  end
+  
+  context "vbox commands" do
+    should "call 'vboxmanage' followed by command" do
+      VirtualBox::Command.expects(:execute).with("VBoxManage foo")
+      VirtualBox::Command.stubs(:success?).returns(true)
+      VirtualBox::Command.vboxmanage("foo")
+    end
+    
+    should "call the custom vboxmanage executable if set" do
+      VirtualBox::Command.vboxmanage = "barf"
+      VirtualBox::Command.expects(:execute).with("barf foo")
+      VirtualBox::Command.stubs(:success?).returns(true)
+      VirtualBox::Command.vboxmanage("foo")
+      VirtualBox::Command.vboxmanage = "VBoxManage"
+    end
+    
+    should "raise a CommandFailedException if it failed" do
+      VirtualBox::Command.expects(:execute).with("VBoxManage foo")
+      VirtualBox::Command.stubs(:success?).returns(false)
+      assert_raises(VirtualBox::Exceptions::CommandFailedException) {
+        VirtualBox::Command.vboxmanage("foo")
+      }
+    end
+  end
+  
   context "testing command results" do
     setup do
       @command = "foo"

data/test/virtualbox/dvd_test.rb

@@ -1,6 +1,49 @@
 require File.join(File.dirname(__FILE__), '..', 'test_helper')
 
 class DVDTest < Test::Unit::TestCase
+  setup do
+    VirtualBox::Command.stubs(:execute)
+  end
+  
+  context "destroying a dvd" do
+    setup do
+      @dvd = VirtualBox::DVD.new
+    end
+    
+    should "return false if attempting to destroy an empty drive" do
+      assert !VirtualBox::DVD.empty_drive.destroy
+    end
+    
+    should "call vboxmanage to destroy it" do
+      VirtualBox::Command.expects(:vboxmanage).with("closemedium dvd #{@dvd.uuid} --delete")
+      assert @dvd.destroy
+    end
+    
+    should "return false if destroy failed" do
+      VirtualBox::Command.stubs(:vboxmanage).raises(VirtualBox::Exceptions::CommandFailedException)
+      assert !@dvd.destroy
+    end
+    
+    should "raise an exception if failed and flag is set" do
+      VirtualBox::Command.stubs(:vboxmanage).raises(VirtualBox::Exceptions::CommandFailedException)
+      assert_raises(VirtualBox::Exceptions::CommandFailedException) {
+        @dvd.destroy(true)
+      }
+    end
+  end
+  
+  context "empty drive" do
+    should "return an empty drive instance by calling new with :empty_drive" do
+      dvd = VirtualBox::DVD.new(:empty_drive)
+      assert dvd.empty_drive?
+    end
+    
+    should "call new with :empty_drive with empty_drive class method" do
+      dvd = VirtualBox::DVD.empty_drive
+      assert dvd.empty_drive?
+    end
+  end
+  
   context "retrieving all dvds" do
     setup do
       @expectations = {

data/test/virtualbox/hard_drive_test.rb

@@ -23,10 +23,33 @@ raw
     VirtualBox::Command.stubs(:vboxmanage).with("showhdinfo #{@name}").returns(@find_raw)
   end
   
+  context "destroying a hard drive" do
+    setup do
+      @hd = VirtualBox::HardDrive.find(@name)
+    end
+    
+    should "call vboxmanage to destroy it" do
+      VirtualBox::Command.expects(:vboxmanage).with("closemedium disk #{@hd.uuid} --delete")
+      assert @hd.destroy
+    end
+    
+    should "return false if destroy failed" do
+      VirtualBox::Command.stubs(:vboxmanage).raises(VirtualBox::Exceptions::CommandFailedException)
+      assert !@hd.destroy
+    end
+    
+    should "raise an exception if failed and flag is set" do
+      VirtualBox::Command.stubs(:vboxmanage).raises(VirtualBox::Exceptions::CommandFailedException)
+      assert_raises(VirtualBox::Exceptions::CommandFailedException) {
+        @hd.destroy(true)
+      }
+    end
+  end
+  
   context "cloning a hard drive" do
     setup do
       @hd = VirtualBox::HardDrive.find(@name)
-      VirtualBox::Command.expects(:vboxmanage).with("clonehd #{@hd.uuid} bar --format VDI --remember").returns(@find_raw)
+      VirtualBox::Command.stubs(:vboxmanage).with("clonehd #{@hd.uuid} bar --format VDI --remember").returns(@find_raw)
     end
     
     should "call vboxmanage with the clone command" do
@@ -39,6 +62,18 @@ raw
       VirtualBox::HardDrive.expects(:find).returns(@new_hd)
       assert_equal @new_hd, @hd.clone("bar")
     end
+    
+    should "return false on failure" do
+      VirtualBox::Command.stubs(:vboxmanage).raises(VirtualBox::Exceptions::CommandFailedException)
+      assert @hd.clone("bar").nil?
+    end
+    
+    should "raise an exception if raise_errors is true and failed" do
+      VirtualBox::Command.stubs(:vboxmanage).raises(VirtualBox::Exceptions::CommandFailedException)
+      assert_raises(VirtualBox::Exceptions::CommandFailedException) {
+        @hd.clone("bar", "VDI", true)
+      }
+    end
   end
   
   context "creating a hard drive" do
@@ -85,6 +120,22 @@ raw
       
       assert_equal "foo", @hd.uuid
     end
+    
+    should "return true if the command was a success" do
+      assert @hd.save
+    end
+    
+    should "return failure if the command failed" do
+      VirtualBox::Command.stubs(:vboxmanage).raises(VirtualBox::Exceptions::CommandFailedException)
+      assert !@hd.save
+    end
+    
+    should "raise an exception if flag is set" do
+      VirtualBox::Command.stubs(:vboxmanage).raises(VirtualBox::Exceptions::CommandFailedException)
+      assert_raises(VirtualBox::Exceptions::CommandFailedException) {
+        @hd.save(true)
+      }
+    end
   end
   
   context "finding a single hard drive" do

data/test/virtualbox/image_test.rb

@@ -1,6 +1,85 @@
 require File.join(File.dirname(__FILE__), '..', 'test_helper')
 
 class ImageTest < Test::Unit::TestCase
+  context "image type and empty drive" do
+    setup do
+      @image = VirtualBox::Image.new
+    end
+    
+    should "raise an exception if image_type is called on Image" do
+      assert_raises(RuntimeError) { @image.image_type }
+    end
+    
+    should "return false by default on empty_drive?" do
+      assert !@image.empty_drive?
+    end
+  end
+  
+  context "in a relationship" do
+    class ImageRelationshipModel < VirtualBox::AbstractModel
+      relationship :image, VirtualBox::Image
+    end
+    
+    setup do
+      @model = ImageRelationshipModel.new
+    end
+    
+    context "populating a relationship" do
+      should "return 'emptydrive' if the medium is an empty drive" do
+        result = VirtualBox::Image.populate_relationship(@model, {
+          :medium => "emptydrive"
+        })
+        
+        assert result.is_a?(VirtualBox::DVD)
+        assert result.empty_drive?
+      end
+      
+      should "return nil if uuid is nil and medium isn't empty" do
+        result = VirtualBox::Image.populate_relationship(@model, {})
+        assert result.nil?
+      end
+      
+      should "result a matching image from subclasses if uuid" do
+        uuid = "foo'"
+
+        subobject = mock("subobject")
+        subobject.stubs(:uuid).returns(uuid)
+        
+        subclass = mock("subclass")
+        subclass.stubs(:all).returns([subobject])
+        
+        VirtualBox::Image.expects(:subclasses).returns([subclass])
+        
+        result = VirtualBox::Image.populate_relationship(@model, { :uuid => uuid })
+        assert_equal subobject, result
+      end
+      
+      should "result in nil if suboject can't be found" do
+        VirtualBox::Image.expects(:subclasses).returns([])
+        assert_nil VirtualBox::Image.populate_relationship(@model, { :uuid => "foo" })
+      end
+    end
+    
+    context "setting relationship object" do
+      should "raise an InvalidRelationshipObjectException if new value is not an image" do
+        assert_raises(VirtualBox::Exceptions::InvalidRelationshipObjectException) {
+          @model.image = "foo"
+        }
+      end
+
+      should "not raise an exception if setting to nil" do
+        assert_nothing_raised { @model.image = nil }
+      end
+
+      should "just return the new value if it is an image" do
+        image = VirtualBox::Image.new
+        assert_nil @model.image
+        assert_nothing_raised { @model.image = image }
+        assert_equal image, @model.image
+      end
+    end
+  end
+  
   context "recording subclasses" do
     should "list all subclasses" do
       assert_nothing_raised { VirtualBox::Image.subclasses }

data/test/virtualbox/nic_test.rb

@@ -48,6 +48,16 @@ raw
       assert nic.nictype_changed?
       nic.save(@vmname)
     end
+    
+    should "raise a CommandFailedException if it fails" do
+      VirtualBox::Command.stubs(:vboxmanage).raises(VirtualBox::Exceptions::CommandFailedException)
+      
+      nic = @nic[0]
+      nic.nictype = "ZOO"
+      assert_raises(VirtualBox::Exceptions::CommandFailedException) {
+        nic.save(@vmname)
+      }
+    end
   end
   
   context "populating relationships" do

data/test/virtualbox/proxies/collection_test.rb

@@ -0,0 +1,45 @@
+require File.join(File.dirname(__FILE__), '..', '..', 'test_helper')
+
+class CollectionTest < Test::Unit::TestCase
+  setup do
+    @parent = mock("parent")
+    @collection = VirtualBox::Proxies::Collection.new(@parent)
+  end
+
+  should "be a subclass of Array" do
+    assert @collection.is_a?(Array)
+  end
+  
+  context "element callbacks" do
+    setup do
+      @item = mock("item")
+    end
+    
+    should "not call added_to_relationship if it doesn't exist" do
+      assert_nothing_raised { @collection << @item }
+    end
+    
+    should "not call removed_from_relationship if it doesn't exist" do
+      @collection << @item
+      assert_nothing_raised { @collection.delete(@item) }
+    end
+    
+    should "call added_to_relationship on the item when its added to a collection" do
+      @item.expects(:added_to_relationship).with(@parent).once
+      @collection << @item
+    end
+    
+    should "call removed_from_relationship on the item when its deleted" do
+      @collection << @item
+      @item.expects(:removed_from_relationship).with(@parent).once
+      @collection.delete(@item)
+    end
+    
+    should "call removed_from_relationship if clear is called" do
+      @collection << @item
+      @item.expects(:removed_from_relationship).with(@parent).once
+      @collection.clear
+      assert @collection.empty?
+    end
+  end
+end

data/test/virtualbox/storage_controller_test.rb

@@ -15,6 +15,18 @@ class StorageControllerTest < Test::Unit::TestCase
     @caller = mock("caller")
   end
   
+  context "saving" do
+    setup do
+      @value = VirtualBox::StorageController.populate_relationship(@caller, @data)
+      @value = @value[0]
+    end
+    
+    should "save relationship" do
+      VirtualBox::AttachedDevice.expects(:save_relationship).once
+      @value.save
+    end
+  end
+  
   context "destroying" do
     setup do
       @value = VirtualBox::StorageController.populate_relationship(@caller, @data)