virtualbox 0.5.4 → 0.6.0

data/test/virtualbox/command_test.rb

@@ -1,152 +0,0 @@
-require File.join(File.dirname(__FILE__), '..', 'test_helper')
-
-class CommandTest < Test::Unit::TestCase
-  context "getting the version" do
-    setup do
-      VirtualBox::Command.stubs(:execute).returns("foo")
-      VirtualBox::Command.stubs(:success?).returns(true)
-    end
-
-    should "be able to call version on VirtualBox and it calls the class method" do
-      version = "foo"
-      assert_equal version, VirtualBox.version
-    end
-
-    should "run the command with the version flag" do
-      VirtualBox::Command.expects(:execute).with("VBoxManage --version").once.returns("7")
-      VirtualBox::Command.version
-    end
-
-    should "return the value of the command if it succeeded" do
-      version = "3.1.4r1940"
-      VirtualBox::Command.expects(:execute).returns(version)
-      assert_equal version, VirtualBox::Command.version
-    end
-
-    should "return the value of nil if the command failed" do
-      VirtualBox::Command.expects(:success?).returns(false)
-      assert_nil VirtualBox::Command.version
-    end
-
-    should "strip the newlines from the result" do
-      version = "3.1.4r1940"
-      VirtualBox::Command.expects(:execute).returns(version + "\n")
-      assert_equal version, VirtualBox::Command.version
-    end
-  end
-
-  context "parsing XML" do
-    should "open the file, parse it, and close the file" do
-      arg = "foo"
-      file = mock("file")
-      seq = sequence("seq")
-      File.expects(:open).with(arg, "r").returns(file).in_sequence(seq)
-      Nokogiri.expects(:XML).in_sequence(seq)
-      file.expects(:close).in_sequence(seq)
-
-      VirtualBox::Command.parse_xml(arg)
-    end
-  end
-
-  context "shell escaping" do
-    should "convert value to string" do
-      assert_nothing_raised do
-        assert_equal "400", VirtualBox::Command.shell_escape(400)
-      end
-    end
-
-    context "unix" do
-      setup do
-        VirtualBox::Platform.stubs(:windows?).returns(false)
-      end
-
-      should "convert properly" do
-        assert_equal "foo\\ bar", VirtualBox::Command.shell_escape("foo bar")
-      end
-    end
-
-    context "windows" do
-      setup do
-        VirtualBox::Platform.stubs(:windows?).returns(true)
-      end
-
-      should "wrap strings with spaces in quotes" do
-        assert_equal '"foo bar"', VirtualBox::Command.shell_escape("foo bar")
-      end
-
-      should "just return the string if it has no spaces" do
-        assert_equal "foo:bar", VirtualBox::Command.shell_escape('foo:bar')
-      end
-    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 -q 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 -q 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 -q foo")
-      VirtualBox::Command.stubs(:success?).returns(false)
-      assert_raises(VirtualBox::Exceptions::CommandFailedException) {
-        VirtualBox::Command.vboxmanage("foo")
-      }
-    end
-
-    should "call vboxmanage with multiple arguments" do
-      VirtualBox::Command.expects(:execute).with("VBoxManage -q foo bar baz --bak bax")
-      VirtualBox::Command.vboxmanage("foo", "bar", "baz", "--bak", "bax")
-    end
-
-    should "shell escape all arguments" do
-      VirtualBox::Command.expects(:execute).with("VBoxManage -q foo\\ bar baz another\\ string")
-      VirtualBox::Command.vboxmanage("foo bar", "baz", "another string")
-    end
-
-    should "convert arguments to strings" do
-      VirtualBox::Command.expects(:execute).with("VBoxManage -q isastring 8")
-      VirtualBox::Command.vboxmanage(:isastring, 8)
-    end
-  end
-
-  context "testing command results" do
-    setup do
-      @command = "foo"
-      VirtualBox::Command.stubs(:execute)
-    end
-
-    should "return true if the exit code is 0" do
-      system("echo 'hello' 1>/dev/null")
-      assert_equal 0, $?.to_i
-      assert VirtualBox::Command.test(@command)
-    end
-
-    should "return false if the exit code is 1" do
-      system("there_is_no_way_this_can_exist_1234567890")
-      assert_not_equal 0, $?.to_i
-      assert !VirtualBox::Command.test(@command)
-    end
-  end
-end

data/test/virtualbox/image_test.rb

@@ -1,190 +0,0 @@
-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 "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 }
-    end
-  end
-
-  context "parsing raw" do
-    setup do
-      @raw = <<-raw
-UUID:       9d2e4353-d1e9-466c-ac58-f2249264147b
-Format:     VDI
-Location:   /Users/mitchellh/Library/VirtualBox/HardDisks/TestJeOS.vdi
-Accessible: yes
-Type:       normal
-Usage:      TestJeOS (UUID: 3d0f87b4-50f7-4fc5-ad89-93375b1b32a3)
-
-UUID:       11dedd14-57a1-4bdb-adeb-dd1d67f066e1
-Format:     VDI
-Location:   /Users/mitchellh/Library/VirtualBox/HardDisks/HoboBase.vdi
-Accessible: yes
-Type:       normal
-Usage:      HoboBase (UUID: 696249ad-00b6-4087-b47f-9b82629efc31)
-
-UUID:       322f79fd-7da6-416f-a16f-e70066ccf165
-Format:     VMDK
-Location:   /Users/mitchellh/Library/VirtualBox/HardDisks/HoboBase.vmdk
-Accessible: yes
-Type:       normal
-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(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
-one
-
-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)
-      VirtualBox::Image.expects(:parse_block).with("two").in_sequence(parse_seq)
-      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 = {
-        :uuid => "1234567890",
-        :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]
-      end
-    end
-  end
-end

data/test/virtualbox/nic_test.rb

@@ -1,76 +0,0 @@
-require File.join(File.dirname(__FILE__), '..', 'test_helper')
-
-class NicTest < Test::Unit::TestCase
-  setup do
-    @caller = mock("caller")
-    @caller.stubs(:name).returns("foo")
-  end
-
-  context "saving" do
-    setup do
-      @nic = VirtualBox::Nic.populate_relationship(@caller, mock_xml_doc)
-      @vmname = "myvm"
-    end
-
-    should "use the vmname strung through the save" do
-      VirtualBox::Command.expects(:vboxmanage).with("modifyvm", @vmname, "--nic1", "foo")
-
-      nic = @nic[0]
-      nic.nic = "foo"
-      nic.save(@vmname)
-    end
-
-    should "use the proper index" do
-      VirtualBox::Command.expects(:vboxmanage).with("modifyvm", @vmname, "--nic2", "far")
-
-      nic = @nic[1]
-      nic.nic = "far"
-      nic.save(@vmname)
-    end
-
-    should "save the nictype" do
-      VirtualBox::Command.expects(:vboxmanage).with("modifyvm", @vmname, "--nictype1", "ZOO")
-
-      nic = @nic[0]
-      nic.nictype = "ZOO"
-      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
-    setup do
-      @value = VirtualBox::Nic.populate_relationship(@caller, mock_xml_doc)
-    end
-
-    should "create the correct amount of objects" do
-      assert_equal 8, @value.length
-    end
-
-    should "not be dirty initially" do
-      assert !@value[0].changed?
-    end
-
-    should "be an existing record" do
-      assert !@value[0].new_record?
-    end
-
-    should "parse the type" do
-      assert_equal "Am79C973", @value[0].nictype
-    end
-
-    should "correctly turn adapters which aren't enabled into 'none'" do
-      assert_equal "none", @value[2].nic
-    end
-  end
-end

data/test/virtualbox/system_property_test.rb

@@ -1,71 +0,0 @@
-require File.join(File.dirname(__FILE__), '..', 'test_helper')
-
-class SystemPropertyTest < Test::Unit::TestCase
-  setup do
-    @raw = <<-raw
-VirtualBox Command Line Management Interface Version 3.1.2
-(C) 2005-2009 Sun Microsystems, Inc.
-All rights reserved.
-
-Minimum guest RAM size:          4 Megabytes
-Maximum guest RAM size:          3584 Megabytes
-Minimum video RAM size:          1 Megabytes
-Maximum video RAM size:          128 Megabytes
-Minimum guest CPU count:         1
-Maximum guest CPU count:         32
-Maximum VDI size:                2097151 Megabytes
-Maximum Network Adapter count:   8
-Maximum Serial Port count:       2
-Maximum Parallel Port count:     2
-Maximum Boot Position:           4
-Maximum IDE Controllers:         1
-Maximum IDE Port count:          2
-Maximum Devices per IDE Port:    2
-Maximum SATA Controllers:        1
-Maximum SATA Port count:         30
-Maximum Devices per SATA Port:   1
-Maximum SCSI Controllers:        1
-Maximum SCSI Port count:         16
-Maximum Devices per SCSI Port:   1
-Maximum Floppy Controllers:      1
-Maximum Floppy Port count:       1
-Maximum Devices per Floppy Port: 2
-Default machine folder:          /Users/mitchellh/Library/VirtualBox/Machines
-Default hard disk folder:        /Users/mitchellh/Library/VirtualBox/HardDisks
-VRDP authentication library:     VRDPAuth
-Webservice auth. library:        VRDPAuth
-Log history count:               3
-raw
-  end
-
-  context "getting all system properties" do
-    setup do
-      VirtualBox::Command.stubs(:vboxmanage).returns(@raw)
-    end
-
-    should "return a new SystemProperty object" do
-      result = VirtualBox::SystemProperty.all
-      assert result.is_a?(VirtualBox::SystemProperty)
-    end
-
-    should "run the vboxmanage command and parse its output" do
-      raw = mock("raw")
-      VirtualBox::Command.expects(:vboxmanage).with("list", "systemproperties").returns(raw)
-      VirtualBox::SystemProperty.expects(:parse_raw).with(raw).returns("foo")
-      VirtualBox::SystemProperty.all
-    end
-  end
-
-  context "parsing the raw output" do
-    should "return a hash with the proper number of values" do
-      result = VirtualBox::SystemProperty.parse_raw(@raw)
-      assert result.is_a?(Hash)
-      assert_equal 28, result.length
-    end
-
-    should "lowercase and convert each key to a symbol" do
-      result = VirtualBox::SystemProperty.parse_raw(@raw)
-      assert_equal "30", result[:maximum_sata_port_count]
-    end
-  end
-end