virtualbox 0.4.1 → 0.4.2

data/test/virtualbox/hard_drive_test.rb

@@ -3,15 +3,11 @@ require File.join(File.dirname(__FILE__), '..', 'test_helper')
 class HardDriveTest < Test::Unit::TestCase
   setup do
     VirtualBox::Command.stubs(:execute)
-    
-    @find_raw = <<-raw
-VirtualBox Command Line Management Interface Version 3.1.2
-(C) 2005-2009 Sun Microsystems, Inc.
-All rights reserved.
 
+    @find_raw = <<-raw
 UUID:                 11dedd14-57a1-4bdb-adeb-dd1d67f066e1
 Accessible:           yes
-Description:          
+Description:
 Logical size:         20480 MBytes
 Current size on disk: 1218 MBytes
 Type:                 normal (base)
@@ -22,22 +18,22 @@ raw
     @name = "foo"
     VirtualBox::Command.stubs(:vboxmanage).with("showhdinfo #{@name}").returns(@find_raw)
   end
-  
+
   context "validations" do
     setup do
       @hd = VirtualBox::HardDrive.new
       @hd.size = 2000
     end
-    
+
     should "be valid with a size and format" do
       assert @hd.valid?
     end
-    
+
     should "be invalid if size is nil" do
       @hd.size = nil
       assert !@hd.valid?
     end
-    
+
     should "clear validations when rechecking" do
       @hd.size = nil
       assert !@hd.valid?
@@ -45,22 +41,22 @@ raw
       assert @hd.valid?
     end
   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) {
@@ -68,29 +64,29 @@ raw
       }
     end
   end
-  
+
   context "cloning a hard drive" do
     setup do
       @hd = VirtualBox::HardDrive.find(@name)
       VirtualBox::Command.stubs(:vboxmanage).with("clonehd #{@hd.uuid} bar --format VDI --remember").returns(@find_raw)
     end
-    
+
     should "call vboxmanage with the clone command" do
       VirtualBox::HardDrive.expects(:find).returns(nil)
       @hd.clone("bar")
     end
-    
+
     should "return the newly cloned hard drive" do
       @new_hd = mock("hd")
       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) {
@@ -98,74 +94,74 @@ raw
       }
     end
   end
-  
+
   context "creating a hard drive" do
     setup do
       @location = "foo.foo"
       @size = "758"
       @format = "VDI"
-      
+
       @hd = VirtualBox::HardDrive.new
       @hd.location = @location
       @hd.size = @size
-      
+
       @fake_hd = mock("hd")
       @fake_hd.stubs(:attributes).returns({
         :uuid => "foo"
       })
-      
+
       VirtualBox::HardDrive.stubs(:find).returns(@fake_hd)
       VirtualBox::Command.stubs(:vboxmanage).returns("UUID: FOO")
     end
-    
+
     should "call create on save" do
       @hd.expects(:create).once
-      
+
       assert @hd.new_record?
       @hd.save
     end
-    
+
     should "call not call create on existing records" do
       @hd.save
       assert !@hd.new_record?
-      
+
       @hd.expects(:create).never
       @hd.save
     end
-    
+
     should "call createhd" do
       VirtualBox::Command.expects(:vboxmanage).with("createhd --filename #{@location} --size #{@size} --format #{@format} --remember")
       @hd.save
     end
-    
+
     should "replace attributes with those of the newly created hard drive" do
       @hd.save
-      
+
       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
-    
+
     should "not run if invalid" do
       @hd.expects(:valid?).returns(false)
       VirtualBox::Command.expects(:vboxmanage).never
       assert !@hd.save
     end
-    
+
     should "raise a ValidationFailedException if invalid and raise_errors is true" do
       @hd.expects(:valid?).returns(false)
       assert_raises(VirtualBox::Exceptions::ValidationFailedException) {
@@ -173,7 +169,7 @@ raw
       }
     end
   end
-  
+
   context "finding a single hard drive" do
     should "parse proper fields" do
       VirtualBox::Command.expects(:vboxmanage).with("showhdinfo #{@name}").returns(@find_raw)
@@ -184,31 +180,27 @@ raw
         :size => "20480",
         :location => "/Users/mitchellh/Library/VirtualBox/HardDisks/foo.vdi"
       }
-      
+
       hd = VirtualBox::HardDrive.find(@name)
       assert hd.is_a?(VirtualBox::HardDrive)
-      
+
       @expected.each do |k,v|
         assert_equal v, hd.send(k)
       end
     end
-    
+
     should "return nil if finding a non-existent hard drive" do
       VirtualBox::Command.expects(:vboxmanage).with("showhdinfo 12").returns("UH OH (VERR_FILE_NOT_FOUND)")
-      
+
       assert_nothing_raised do
         assert_nil VirtualBox::HardDrive.find(12)
       end
     end
   end
-  
+
   context "retrieving all hard drives" do
     setup do
       @valid = <<-valid
-VirtualBox Command Line Management Interface Version 3.1.2
-(C) 2005-2009 Sun Microsystems, Inc.
-All rights reserved.
-      
 UUID:       9d2e4353-d1e9-466c-ac58-f2249264147b
 Format:     VDI
 Location:   /Users/mitchellh/Library/VirtualBox/HardDisks/foo.vdi
@@ -232,16 +224,16 @@ Usage:      foo (UUID: 8710d3db-d96a-46ed-9004-59fa891fda90)
 valid
 
       VirtualBox::Command.expects(:vboxmanage).with("list hdds").returns(@valid)
-      
+
       @hd = mock("hd")
       @hd.stubs(:is_a?).with(VirtualBox::HardDrive).returns(true)
       VirtualBox::HardDrive.expects(:find).at_least(0).returns(@hd)
     end
-    
+
     should "return an array of HardDrive objects" do
       result = VirtualBox::HardDrive.all
       assert result.is_a?(Array)
-      
+
       result.each { |v| assert v.is_a?(VirtualBox::HardDrive) }
     end
   end

data/test/virtualbox/image_test.rb

@@ -5,61 +5,61 @@ class ImageTest < Test::Unit::TestCase
     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) {
@@ -79,20 +79,16 @@ class ImageTest < Test::Unit::TestCase
       end
     end
   end
-  
+
   context "recording subclasses" do
     should "list all subclasses" do
       assert_nothing_raised { VirtualBox::Image.subclasses }
     end
   end
-  
+
   context "parsing raw" do
     setup do
       @raw = <<-raw
-VirtualBox Command Line Management Interface Version 3.1.2
-(C) 2005-2009 Sun Microsystems, Inc.
-All rights reserved.
-
 UUID:       9d2e4353-d1e9-466c-ac58-f2249264147b
 Format:     VDI
 Location:   /Users/mitchellh/Library/VirtualBox/HardDisks/TestJeOS.vdi
@@ -112,21 +108,28 @@ Format:     VMDK
 Location:   /Users/mitchellh/Library/VirtualBox/HardDisks/HoboBase.vmdk
 Accessible: yes
 Type:       normal
-Usage:      HoboBase_2 (UUID: 3cc36c5d-562a-4030-8acf-f061f44170c4)      
+Usage:      HoboBase_2 (UUID: 3cc36c5d-562a-4030-8acf-f061f44170c4)
 raw
     end
-    
+
     should "call parse block the correct number of times" do
-      VirtualBox::Image.expects(:parse_block).times(4).returns({})
+      VirtualBox::Image.expects(:parse_block).times(3).returns({})
       VirtualBox::Image.parse_raw(@raw)
     end
-    
+
     should "remove nil (invalid) blocks from result" do
       result = VirtualBox::Image.parse_raw(@raw)
       assert_equal 3, result.length
     end
+
+    should "be able to extract the filename from the location" do
+      result = VirtualBox::Image.parse_raw(@raw)
+      assert_equal "TestJeOS.vdi", result[0].filename
+      assert_equal "HoboBase.vdi", result[1].filename
+      assert_equal "HoboBase.vmdk", result[2].filename
+    end
   end
-  
+
   context "parsing multiple blocks" do
     setup do
       @raw = <<-raw
@@ -137,7 +140,7 @@ two
 three
 raw
     end
-    
+
     should "call parse block for each multiline" do
       parse_seq = sequence("parse")
       VirtualBox::Image.expects(:parse_block).with("one").in_sequence(parse_seq)
@@ -145,19 +148,19 @@ raw
       VirtualBox::Image.expects(:parse_block).with("three").in_sequence(parse_seq)
       VirtualBox::Image.parse_blocks(@raw)
     end
-    
+
     should "return an array of the parses with nil ignored" do
       parse_seq = sequence("parse")
       VirtualBox::Image.expects(:parse_block).with("one").returns({}).in_sequence(parse_seq)
       VirtualBox::Image.expects(:parse_block).with("two").returns(nil).in_sequence(parse_seq)
       VirtualBox::Image.expects(:parse_block).with("three").returns({}).in_sequence(parse_seq)
       result = VirtualBox::Image.parse_blocks(@raw)
-      
+
       assert result.is_a?(Array)
       assert_equal 2, result.length
     end
   end
-  
+
   context "parsing a single block" do
     setup do
       @expected = {
@@ -165,24 +168,24 @@ raw
         :path => "foo",
         :accessible => "yes"
       }
-        
+
       @block = ""
       @expected.each { |k,v| @block += "#{k}: #{v}\n" }
     end
-    
+
     should "return nil for an invalid block" do
       assert VirtualBox::Image.parse_block("HI").nil?
     end
-    
+
     should "mirror location to path" do
       result = VirtualBox::Image.parse_block(@block)
       assert_equal "foo", result[:location]
     end
-      
+
     should "properly parse if all properties are available" do
       result = VirtualBox::Image.parse_block(@block)
       assert !result.nil?
-      
+
       @expected.each do |k,v|
         k = :location if k == :path
         assert_equal v, result[k]