virtualbox 0.5.4 → 0.6.0

data/test/virtualbox/forwarded_port_test.rb

@@ -2,7 +2,14 @@ require File.join(File.dirname(__FILE__), '..', 'test_helper')
 
 class ForwardedPortTest < Test::Unit::TestCase
   setup do
+    @nic = mock("nic")
+    @nic.stubs(:adapter_type).returns(:foo)
+    @nics = [@nic]
+
     @caller = mock("caller")
+    @caller.stubs(:network_adapters).returns(@nics)
+
+    @interface = mock("interface")
   end
 
   context "validations" do
@@ -55,6 +62,54 @@ class ForwardedPortTest < Test::Unit::TestCase
       @caller.stubs(:extra_data).returns(@ed)
     end
 
+    context "device" do
+      setup do
+        @port.new_record!
+        @port.added_to_relationship(@caller)
+      end
+
+      should "return the value set if it was set" do
+        @port.device = "foo"
+        assert_equal "foo", @port.device
+      end
+
+      should "return the default if parent is nil" do
+        @port.expects(:parent).returns(nil)
+        assert_equal "pcnet", @port.device
+      end
+
+      should "return the default if the record is existing" do
+        @nic.expects(:adapter_type).never
+        @port.existing_record!
+        assert_equal "pcnet", @port.device
+      end
+
+      should "return pcnet if card is a Am79C970A type" do
+        @nic.expects(:adapter_type).returns(:Am79C970A)
+        assert_equal "pcnet", @port.device
+      end
+
+      should "return pcnet if card is a Am79C973 type" do
+        @nic.expects(:adapter_type).returns(:Am79C973)
+        assert_equal "pcnet", @port.device
+      end
+
+      should "return e1000 if card is a 82540EM type" do
+        @nic.expects(:adapter_type).returns(:I82540EM)
+        assert_equal "e1000", @port.device
+      end
+
+      should "return e1000 if card is a 82543GC type" do
+        @nic.expects(:adapter_type).returns(:I82543GC)
+        assert_equal "e1000", @port.device
+      end
+
+      should "return e1000 if card is a 82545EM type" do
+        @nic.expects(:adapter_type).returns(:I82545EM)
+        assert_equal "e1000", @port.device
+      end
+    end
+
     context "saving" do
       context "an existing record" do
         setup do
@@ -87,6 +142,7 @@ class ForwardedPortTest < Test::Unit::TestCase
 
       context "a new record" do
         setup do
+          @port.stubs(:valid?).returns(true)
           assert @port.new_record!
         end
 
@@ -95,16 +151,10 @@ class ForwardedPortTest < Test::Unit::TestCase
           assert !@port.new_record?
         end
 
-        should "return false and do nothing if invalid" do
-          @caller.expects(:extra_data).never
-          @port.expects(:valid?).returns(false)
-          assert !@port.save
-        end
-
         should "raise a ValidationFailedException if invalid and raise_errors is true" do
           @port.expects(:valid?).returns(false)
           assert_raises(VirtualBox::Exceptions::ValidationFailedException) {
-            @port.save(true)
+            @port.save
           }
         end
 

data/test/virtualbox/global_test.rb

@@ -1,136 +1,46 @@
 require File.join(File.dirname(__FILE__), '..', 'test_helper')
 
 class GlobalTest < Test::Unit::TestCase
-  context "the virtualbox config file path" do
-    setup do
-      VirtualBox::Global.vboxconfig = nil
-    end
-
-    teardown do
-      VirtualBox::Global.vboxconfig = "foo"
-    end
-
-    should "return the path if its set" do
-      VirtualBox::Global.vboxconfig = "foo"
-      File.expects(:expand_path).with("foo").returns("foo")
-      assert_equal "foo", VirtualBox::Global.vboxconfig
-    end
-
-    should "return Mac-path if on mac" do
-      result = "~/Library/VirtualBox/VirtualBox.xml"
-      VirtualBox::Platform.stubs(:mac?).returns(true)
-      
-      expanded_result = result + result
-      File.expects(:expand_path).with(result).returns(expanded_result)
-      assert_equal expanded_result, VirtualBox::Global.vboxconfig
-    end
-
-    should "return Windows-path if on windows" do
-      result = "~/.VirtualBox/VirtualBox.xml"
-      VirtualBox::Platform.stubs(:mac?).returns(false)
-      VirtualBox::Platform.stubs(:windows?).returns(true)
-      
-      expanded_result = result + result
-      File.expects(:expand_path).with(result).returns(expanded_result)
-      assert_equal expanded_result, VirtualBox::Global.vboxconfig
-    end
-
-    should "return Linux-path if on linux" do
-      result = "~/.VirtualBox/VirtualBox.xml"
-      VirtualBox::Platform.stubs(:mac?).returns(false)
-      VirtualBox::Platform.stubs(:windows?).returns(false)
-      VirtualBox::Platform.stubs(:linux?).returns(true)
-      
-      expanded_result = result + result
-      File.expects(:expand_path).with(result).returns(expanded_result)
-      assert_equal expanded_result, VirtualBox::Global.vboxconfig
-    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)
-      
-      expanded_result = result + result
-      File.expects(:expand_path).with(result).returns(expanded_result)
-      assert_equal expanded_result, VirtualBox::Global.vboxconfig
-    end
-  end
-
-  context "getting the global config" do
-    should "only get it once, then cache" do
-      VirtualBox::Global.expects(:config).returns(mock_xml_doc).once
-      result = VirtualBox::Global.global(true)
-      assert result
-      assert result.equal?(VirtualBox::Global.global)
-    end
-
-    should "reload if reload is true" do
-      VirtualBox::Global.expects(:config).returns(mock_xml_doc).twice
-      result = VirtualBox::Global.global(true)
-      assert result
-      assert !result.equal?(VirtualBox::Global.global(true))
-    end
-
-    should "reload if global reload flag is set" do
-      VirtualBox::Global.reload!
-      VirtualBox::Global.expects(:config).returns(mock_xml_doc).once
-      VirtualBox::Global.global
-      assert !VirtualBox::Global.reload?
-    end
-  end
-  
-  context "testingn the config path" do
-    setup do
-      @result = "foo"
-      VirtualBox::Global.stubs(:vboxconfig).returns(@result)
-    end
-    
-    should "return true if it is a file" do
-      File.expects(:file?).with(@result).returns(true)
-      assert VirtualBox::Global.vboxconfig?
-    end
-    
-    should "return false if it is not a file" do
-      File.expects(:file?).with(@result).returns(false)
-      assert !VirtualBox::Global.vboxconfig?
-    end
+  setup do
+    @klass = VirtualBox::Global
   end
 
-  context "parsing configuration XML" do
+  context "getting the global object" do
     setup do
-      @vboxconfig = "foo"
-      VirtualBox::Global.stubs(:vboxconfig?).returns(true)
-      VirtualBox::Global.stubs(:vboxconfig).returns(@vboxconfig)
+      @lib = mock('lib')
+      VirtualBox::Lib.stubs(:lib).returns(@lib)
+      @klass.reset!
     end
 
-    should "raise an error if the config XML is invalid" do
-      VirtualBox::Command.stubs(:parse_xml)
-      VirtualBox::Global.expects(:vboxconfig?).returns(false)
-      assert_raises(VirtualBox::Exceptions::ConfigurationException) do
-        VirtualBox::Global.config
-      end
+    should "initialize the object with the lib once" do
+      instance =  mock("instance")
+      @klass.expects(:new).with(@lib).once.returns(instance)
+      assert_equal instance, @klass.global
+      assert_equal instance, @klass.global
+      assert_equal instance, @klass.global
     end
 
-    should "use Command.parse_xml to parse" do
-      VirtualBox::Command.expects(:parse_xml).with(@vboxconfig).once
-      VirtualBox::Global.config
+    should "initialize the object if reload is set" do
+      instance = mock("instance")
+      @klass.expects(:new).with(@lib).twice.returns(instance)
+      assert_equal instance, @klass.global
+      assert_equal instance, @klass.global(true)
+      assert_equal instance, @klass.global
     end
   end
 
-  context "expanding path" do
+  context "with an instance" do
     setup do
-      VirtualBox::Global.stubs(:vboxconfig).returns("/foo/bar/baz.rb")
+      @lib = mock("lib")
+      @instance = @klass.new(@lib)
     end
 
-    should "expand the path properly" do
-      assert_equal "/foo/bar/vroom/rawr.bak", VirtualBox::Global.expand_path("vroom/rawr.bak")
+    should "be an existing record, always" do
+      assert !@instance.new_record?
     end
 
-    should "expand the path relative to the vboxconfig directory" do
-      File.expects(:expand_path).with("foo", "/foo/bar").once
-      VirtualBox::Global.expand_path("foo")
+    should "setup the lib attribute on initialization" do
+      assert_equal @lib, @instance.lib
     end
   end
 end

data/test/virtualbox/hard_drive_test.rb

@@ -2,245 +2,82 @@ require File.join(File.dirname(__FILE__), '..', 'test_helper')
 
 class HardDriveTest < Test::Unit::TestCase
   setup do
-    VirtualBox::Command.stubs(:execute)
-
-    @find_raw = <<-raw
-UUID:                 11dedd14-57a1-4bdb-adeb-dd1d67f066e1
-Accessible:           yes
-Description:
-Logical size:         20480 MBytes
-Current size on disk: 1218 MBytes
-Type:                 normal (base)
-Storage format:       VDI
-In use by VMs:        FooVM (UUID: 696249ad-00b6-4087-b47f-9b82629efc31)
-Location:             /Users/mitchellh/Library/VirtualBox/HardDisks/foo.vdi
-raw
-    @name = "foo"
-    VirtualBox::Command.stubs(:vboxmanage).with("showhdinfo", @name).returns(@find_raw)
+    @klass = VirtualBox::HardDrive
+    @interface = mock("interface")
   end
 
-  context "populating relationship" do
-    setup do
-      @xml = <<-xml
-<MediaRegistry>
-  <HardDisks>
-    <HardDisk uuid="{9d2e4353-d1e9-466c-ac58-f2249264147b}" location="HardDisks/TestJeOS.vdi" format="VDI" type="Normal"/>
-    <HardDisk uuid="{5f7ccd06-78ef-47e9-b2bc-515aedd2f288}" location="HardDisks/hobobase.vdi" format="VDI" type="Normal"/>
-  </HardDisks>
-</MediaRegistry>
-xml
-      @doc = Nokogiri::XML(@xml)
-    end
-
-    should "create an object for each hard disk entry" do
-      result = VirtualBox::HardDrive.populate_relationship(nil, @doc)
-      assert_equal 2, result.length
-    end
-
-    should "properly extract uuid, location, and format" do
-      VirtualBox::Global.vboxconfig = "/foo/rawr.rb"
-      result = VirtualBox::HardDrive.populate_relationship(nil, @doc)
-      result = result[0]
-      assert_equal "9d2e4353-d1e9-466c-ac58-f2249264147b", result.uuid
-      assert_equal "VDI", result.format
-      assert_equal "/foo/HardDisks/TestJeOS.vdi", result.location
+  context "device type" do
+    should "be :hard_disk" do
+      assert_equal :hard_disk, @klass.device_type
     end
   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?
-      @hd.size = 700
-      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) {
-        @hd.destroy(true)
-      }
+  context "retrieving all hard drives" do
+    should "return an array of HardDrive objects" do
+      media = mock("media")
+      media.expects(:hard_drives).returns("foo")
+      global = mock("global")
+      global.expects(:media).returns(media)
+      VirtualBox::Global.expects(:global).returns(global)
+      assert_equal "foo", VirtualBox::HardDrive.all
     end
   end
 
-  context "cloning a hard drive" do
+  context "finding 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")
+      @all = []
+      @klass.stubs(:all).returns(@all)
     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")
+    def mock_drive(uuid)
+      drive = mock("hd-#{uuid}")
+      drive.stubs(:uuid).returns(uuid)
+      drive
     end
 
-    should "return false on failure" do
-      VirtualBox::Command.stubs(:vboxmanage).raises(VirtualBox::Exceptions::CommandFailedException)
-      assert @hd.clone("bar").nil?
+    should "return nil if it doesn't exist" do
+      @all << mock_drive("foo")
+      assert_nil @klass.find("bar")
     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)
-      }
+    should "return the matching drive if it is found" do
+      drive = mock_drive("foo")
+      @all << mock_drive("bar")
+      @all << drive
+      assert_equal drive, @klass.find("foo")
     end
   end
 
-  context "creating a hard drive" do
+  context "with an instance" 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")
+      @klass.any_instance.stubs(:initialize_attributes)
+      @instance = @klass.new(@interface)
     end
 
-    should "call create on save" do
-      @hd.expects(:create).once
+    context "cloning" do
+      setup do
+        @system_properties = mock("system_properties")
+        @virtualbox = mock("virtualbox")
+        @lib = mock("lib")
 
-      assert @hd.new_record?
-      @hd.save
-    end
+        @hard_disk_folder = "foobar"
 
-    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) {
-        @hd.save(true)
-      }
-    end
-  end
-
-  context "finding a single hard drive" do
-    should "parse proper fields" do
-      VirtualBox::Command.expects(:vboxmanage).with("showhdinfo", @name).returns(@find_raw)
-
-      @expected = {
-        :uuid => "11dedd14-57a1-4bdb-adeb-dd1d67f066e1",
-        :accessible => "yes",
-        :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)
+        VirtualBox::Lib.stubs(:lib).returns(@lib)
+        @lib.stubs(:virtualbox).returns(@virtualbox)
+        @virtualbox.stubs(:system_properties).returns(@system_properties)
+        @system_properties.stubs(:default_hard_disk_folder).returns(@hard_disk_folder)
       end
-    end
 
-    should "return nil if finding a non-existent hard drive" do
-      VirtualBox::Command.stubs(:vboxmanage).raises(VirtualBox::Exceptions::CommandFailedException)
+      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)
+        progress.expects(:wait_for_completion).with(-1)
 
-      assert_nothing_raised do
-        assert_nil VirtualBox::HardDrive.find(12)
+        @instance.clone("/foo.vdi")
       end
     end
-
-    should "raise an exception if flag is set" do
-      VirtualBox::Command.stubs(:vboxmanage).raises(VirtualBox::Exceptions::CommandFailedException)
-      assert_raises(VirtualBox::Exceptions::CommandFailedException) {
-        VirtualBox::HardDrive.find(12, true)
-      }
-    end
-  end
-
-  context "retrieving all hard drives" do
-    should "return an array of HardDrive objects" do
-      media = mock("media")
-      media.expects(:hard_drives).returns("foo")
-      global = mock("global")
-      global.expects(:media).returns(media)
-      VirtualBox::Global.expects(:global).returns(global)
-      assert_equal "foo", VirtualBox::HardDrive.all
-    end
   end
 end