virtualbox 0.4.2 → 0.4.3

data/VERSION

@@ -1 +1 @@
-0.4.2
+0.4.3

data/lib/virtualbox/abstract_model.rb

@@ -160,7 +160,7 @@ module VirtualBox
         values.push("#{name.inspect}=...")
       end
 
-      "#<#{self.class} #{values.join(", ")}>".strip
+      "#<#{self.class} #{values.sort.join(", ")}>".strip
     end
   end
 end

data/lib/virtualbox/attached_device.rb

@@ -166,7 +166,7 @@ module VirtualBox
       # a new one
       destroy({:port => port_was}, raise_errors) if port_changed? && !port_was.nil?
 
-      Command.vboxmanage("storageattach #{Command.shell_escape(parent.parent.name)} --storagectl #{Command.shell_escape(parent.name)} --port #{port} --device 0 --type #{image.image_type} --medium #{medium}")
+      Command.vboxmanage("storageattach", parent.parent.name, "--storagectl", parent.name, "--port", port, "--device", "0", "--type", image.image_type, "--medium", medium)
       existing_record!
       clear_dirty!
 
@@ -209,7 +209,7 @@ module VirtualBox
       # parent = storagecontroller
       # parent.parent = vm
       destroy_port = options[:port] || port
-      Command.vboxmanage("storageattach #{Command.shell_escape(parent.parent.name)} --storagectl #{Command.shell_escape(parent.name)} --port #{destroy_port} --device 0 --medium none")
+      Command.vboxmanage("storageattach", parent.parent.name, "--storagectl", parent.name, "--port", destroy_port, "--device", "0", "--medium", "none")
       image.destroy(raise_errors) if options[:destroy_image] && image
     rescue Exceptions::CommandFailedException
       raise if raise_errors

data/lib/virtualbox/command.rb

@@ -23,13 +23,25 @@ module VirtualBox
 
       # Sets the path to VBoxManage, which is required for this gem to
       # work.
+      #
+      # @param [String] Full path to `VBoxManage`.
       def vboxmanage=(path)
         @@vboxmanage = path
       end
 
-      # Runs a VBoxManage command and returns the output.
-      def vboxmanage(command)
-        result = execute("#{@@vboxmanage} -q #{command}")
+      # Runs a VBoxManage command and returns the output. This method will automatically
+      # shell escape all args passed to it. There is no way to avoid this at the moment
+      # (since it hasn't been necessary to). This will raise an {Exceptions::CommandFailedException}
+      # if the exit status of the command is nonzero. It is up to the caller to figure
+      # out how to handle this; there is no way to suppress it via a parameter to this
+      # call.
+      #
+      # Upon success, {vboxmanage} returns the stdout output from the command.
+      #
+      # @return [String] The data from stdout of the command.
+      def vboxmanage(*args)
+        args.collect! { |arg| shell_escape(arg.to_s) }
+        result = execute("#{@@vboxmanage} -q #{args.join(" ")}")
         raise Exceptions::CommandFailedException.new(result) if !Command.success?
         result
       end

data/lib/virtualbox/dvd.rb

@@ -22,7 +22,7 @@ module VirtualBox
     class <<self
       # Returns an array of all available DVDs as DVD objects
       def all
-        raw = Command.vboxmanage("list dvds")
+        raw = Command.vboxmanage("list", "dvds")
         parse_raw(raw)
       end
 
@@ -69,7 +69,7 @@ module VirtualBox
     def destroy(raise_errors=false)
       return false if empty_drive?
 
-      Command.vboxmanage("closemedium dvd #{uuid} --delete")
+      Command.vboxmanage("closemedium", "dvd", uuid, "--delete")
       true
     rescue Exceptions::CommandFailedException
       raise if raise_errors

data/lib/virtualbox/extra_data.rb

@@ -46,7 +46,7 @@ module VirtualBox
       # @return [Array<ExtraData>]
       def global(reload=false)
         if !@@global_data || reload
-          raw = Command.vboxmanage("getextradata global enumerate")
+          raw = Command.vboxmanage("getextradata", "global", "enumerate")
           @@global_data = parse_kv_pairs(raw)
         end
 
@@ -75,7 +75,7 @@ module VirtualBox
       #
       # @return [Array<ExtraData>]
       def populate_relationship(caller, data)
-        raw = Command.vboxmanage("getextradata #{Command.shell_escape(caller.name)} enumerate")
+        raw = Command.vboxmanage("getextradata", caller.name, "enumerate")
         parse_kv_pairs(raw, caller)
       end
 
@@ -124,7 +124,7 @@ module VirtualBox
     # @return [Boolean] True if command was successful, false otherwise.
     def save(raise_errors=false)
       changes.each do |key, value|
-        Command.vboxmanage("setextradata #{Command.shell_escape(parent_name)} #{Command.shell_escape(key)} #{Command.shell_escape(value[1])}")
+        Command.vboxmanage("setextradata", parent_name, key, value[1])
         clear_dirty!(key)
       end
 
@@ -140,7 +140,7 @@ module VirtualBox
     #   will be raised if the command failed.
     # @return [Boolean] True if command was successful, false otherwise.
     def delete(key, raise_errors=false)
-      Command.vboxmanage("setextradata #{Command.shell_escape(parent_name)} #{Command.shell_escape(key)}")
+      Command.vboxmanage("setextradata", parent_name, key)
       super(key)
       true
     rescue Exceptions::CommandFailedException

data/lib/virtualbox/hard_drive.rb

@@ -84,21 +84,26 @@ module VirtualBox
       # Returns an array of all available hard drives as HardDrive
       # objects.
       #
+      # @param [Boolean] raise_errors If true, {Exceptions::CommandFailedException}
+      #   will be raised if the command failed.
       # @return [Array<HardDrive>]
-      def all
-        raw = Command.vboxmanage("list hdds")
-        parse_blocks(raw).collect { |v| find(v[:uuid]) }
+      def all(raise_errors=false)
+        raw = Command.vboxmanage("list", "hdds")
+        parse_blocks(raw).collect { |v| find(v[:uuid], raise_errors) }
+      rescue Exceptions::CommandFailedException
+        raise if raise_errors
+        false
       end
 
       # Finds one specific hard drive by UUID or file name. If the
       # hard drive can not be found, will return `nil`.
       #
+      # @param [String] id The UUID or name of the hard drive
+      # @param [Boolean] raise_errors If true, {Exceptions::CommandFailedException}
+      #   will be raised if the command failed.
       # @return [HardDrive]
-      def find(id)
-        raw = Command.vboxmanage("showhdinfo #{id}")
-
-        # Return nil if the hard drive doesn't exist
-        return nil if raw =~ /VERR_FILE_NOT_FOUND/
+      def find(id, raise_errors=false)
+        raw = Command.vboxmanage("showhdinfo", id)
 
         data = raw.split(/\n\n/).collect { |v| parse_block(v) }.find { |v| !v.nil? }
 
@@ -108,6 +113,9 @@ module VirtualBox
 
         # Return new object
         new(data)
+      rescue Exceptions::CommandFailedException
+        raise if raise_errors
+        nil
       end
     end
 
@@ -124,7 +132,7 @@ module VirtualBox
     #   will be raised if the command failed.
     # @return [HardDrive] The new, cloned hard drive, or nil on failure.
     def clone(outputfile, format="VDI", raise_errors=false)
-      raw = Command.vboxmanage("clonehd #{uuid} #{Command.shell_escape(outputfile)} --format #{format} --remember")
+      raw = Command.vboxmanage("clonehd", uuid, outputfile, "--format", format, "--remember")
       return nil unless raw =~ /UUID: (.+?)$/
 
       self.class.find($1.to_s)
@@ -159,7 +167,7 @@ module VirtualBox
         return false
       end
 
-      raw = Command.vboxmanage("createhd --filename #{location} --size #{size} --format #{read_attribute(:format)} --remember")
+      raw = Command.vboxmanage("createhd", "--filename", location, "--size", size, "--format", read_attribute(:format), "--remember")
       return nil unless raw =~ /UUID: (.+?)$/
 
       # Just replace our attributes with the newly created ones. This also
@@ -201,7 +209,7 @@ module VirtualBox
     #   will be raised if the command failed.
     # @return [Boolean] True if command was successful, false otherwise.
     def destroy(raise_errors=false)
-      Command.vboxmanage("closemedium disk #{uuid} --delete")
+      Command.vboxmanage("closemedium", "disk", uuid, "--delete")
       true
     rescue Exceptions::CommandFailedException
       raise if raise_errors

data/lib/virtualbox/nic.rb

@@ -143,7 +143,7 @@ module VirtualBox
     #
     # **This method typically won't be used except internally.**
     def save_attribute(key, value, vmname)
-      Command.vboxmanage("modifyvm #{Command.shell_escape(vmname)} --#{key}#{@index} #{Command.shell_escape(value)}")
+      Command.vboxmanage("modifyvm", vmname, "--#{key}#{@index}", value)
       super
     end
   end

data/lib/virtualbox/shared_folder.rb

@@ -204,7 +204,7 @@ module VirtualBox
       # If this isn't a new record, we destroy it first
       destroy(raise_errors) if !new_record?
 
-      Command.vboxmanage("sharedfolder add #{Command.shell_escape(parent.name)} --name #{Command.shell_escape(name)} --hostpath #{Command.shell_escape(hostpath)}")
+      Command.vboxmanage("sharedfolder", "add", parent.name, "--name", name, "--hostpath", hostpath)
       existing_record!
       clear_dirty!
 
@@ -233,7 +233,7 @@ module VirtualBox
       # one.
       name_value = name_changed? ? name_was : name
 
-      Command.vboxmanage("sharedfolder remove #{Command.shell_escape(parent.name)} --name #{Command.shell_escape(name_value)}")
+      Command.vboxmanage("sharedfolder", "remove", parent.name, "--name", name_value)
       true
     rescue Exceptions::CommandFailedException
       raise if raise_errors

data/lib/virtualbox/vm.rb

@@ -120,7 +120,7 @@ module VirtualBox
       #
       # @return [Array<VM>]
       def all
-        raw = Command.vboxmanage("list vms")
+        raw = Command.vboxmanage("list", "vms")
         parse_vm_list(raw)
       end
 
@@ -141,7 +141,7 @@ module VirtualBox
       #
       # @return [VM] The newly imported virtual machine
       def import(source_path)
-        raw = Command.vboxmanage("import #{Command.shell_escape(source_path)}")
+        raw = Command.vboxmanage("import", source_path)
         return nil unless raw
 
         find(parse_vm_name(raw))
@@ -154,7 +154,7 @@ module VirtualBox
       #
       # @return [String]
       def human_info(name)
-        Command.vboxmanage("showvminfo #{Command.shell_escape(name)}")
+        Command.vboxmanage("showvminfo", name)
       end
 
       # Gets the VM info (machine readable) for a given VM and returns it
@@ -162,7 +162,7 @@ module VirtualBox
       #
       # @return [Hash] Parsed VM info.
       def raw_info(name)
-        raw = Command.vboxmanage("showvminfo #{Command.shell_escape(name)} --machinereadable")
+        raw = Command.vboxmanage("showvminfo", name, "--machinereadable")
         parse_vm_info(raw)
       end
 
@@ -259,7 +259,7 @@ module VirtualBox
     #
     # **This method typically won't be used except internally.**
     def save_attribute(key, value)
-      Command.vboxmanage("modifyvm #{Command.shell_escape(@original_name)} --#{key} #{Command.shell_escape(value.to_s)}")
+      Command.vboxmanage("modifyvm", @original_name, "--#{key}", value)
       super
     end
 
@@ -287,12 +287,13 @@ module VirtualBox
     # @option options [String] :eulafile (nil) License file
     def export(filename, options={}, raise_error=false)
       options = options.inject([]) do |acc, kv|
-        acc.push("--#{kv[0]} #{Command.shell_escape(kv[1])}")
+        acc.push("--#{kv[0]}")
+        acc.push(kv[1])
       end
 
-      options.unshift("--vsys 0") unless options.empty?
+      options.unshift("0").unshift("--vsys") unless options.empty?
 
-      raw = Command.vboxmanage("export #{Command.shell_escape(@original_name)} -o #{Command.shell_escape(filename)} #{options.join(" ")}".strip)
+      raw = Command.vboxmanage("export", @original_name, "-o", filename, *options)
       true
     rescue Exceptions::CommandFailedException
       raise if raise_error
@@ -314,7 +315,7 @@ module VirtualBox
     #   will be raised if the command failed.
     # @return [Boolean] True if command was successful, false otherwise.
     def start(mode=:gui, raise_errors=false)
-      Command.vboxmanage("startvm #{Command.shell_escape(@original_name)} --type #{mode}")
+      Command.vboxmanage("startvm", @original_name, "--type", mode)
       true
     rescue Exceptions::CommandFailedException
       raise if raise_errors
@@ -364,7 +365,7 @@ module VirtualBox
     end
 
     # Saves the state of a VM and stops it. The VM can be resumed
-    # again by calling "start" again.
+    # again by calling "{#start}" again.
     #
     # @param [Boolean] raise_errors If true, {Exceptions::CommandFailedException}
     #   will be raised if the command failed.
@@ -373,6 +374,20 @@ module VirtualBox
       control(:savestate, raise_errors)
     end
 
+    # Discards any saved state on the current VM. The VM is not destroyed though
+    # and can still be started by calling {#start}.
+    #
+    # @param [Boolean] raise_errors If true, {Exceptions::CommandFailedException}
+    #   will be raised if the command failed.
+    # @return [Boolean] True if command was successful, false otherwise.
+    def discard_state(raise_errors=false)
+      Command.vboxmanage("discardstate", @original_name)
+      true
+    rescue Exceptions::CommandFailedException
+      raise if raise_errors
+      false
+    end
+
     # Controls the virtual machine. This method is used by {#stop},
     # {#pause}, {#resume}, and {#save_state} to control the virtual machine.
     # Typically, you won't ever have to call this method and should
@@ -383,7 +398,7 @@ module VirtualBox
     #   will be raised if the command failed.
     # @return [Boolean] True if command was successful, false otherwise.
     def control(command, raise_errors=false)
-      Command.vboxmanage("controlvm #{Command.shell_escape(@original_name)} #{command}")
+      Command.vboxmanage("controlvm", @original_name, command)
       true
     rescue Exceptions::CommandFailedException
       raise if raise_errors
@@ -405,7 +420,7 @@ module VirtualBox
       # unregistering a VM
       super
 
-      Command.vboxmanage("unregistervm #{Command.shell_escape(@original_name)} --delete")
+      Command.vboxmanage("unregistervm", @original_name, "--delete")
     end
 
     # Returns true if the virtual machine state is running

data/test/virtualbox/abstract_model_test.rb

@@ -25,7 +25,7 @@ class AbstractModelTest < Test::Unit::TestCase
     end
 
     should "generate the proper inspect string" do
-      assert_equal "#<AbstractModelTest::FakeModel :foo=nil, :bar=nil, :foos=..., :bars=...>", @model.inspect
+      assert_equal "#<AbstractModelTest::FakeModel :bar=nil, :bars=..., :foo=nil, :foos=...>", @model.inspect
     end
   end
 

data/test/virtualbox/attached_device_test.rb

@@ -149,7 +149,7 @@ class AttachedDeviceTest < Test::Unit::TestCase
       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}")
+        VirtualBox::Command.expects(:vboxmanage).with("storageattach", @vm.name, "--storagectl", @caller.name, "--port", @ad.port, "--device", "0", "--type", @image.image_type, "--medium", @ad.medium)
         @ad.save
       end
 
@@ -229,21 +229,13 @@ class AttachedDeviceTest < Test::Unit::TestCase
       VirtualBox::AttachedDevice.destroy_relationship(self, [obj_one, obj_two], "HELLO")
     end
 
-    should "shell escape VM name and storage controller name" do
-      shell_seq = sequence("shell_seq")
-      VirtualBox::Command.expects(:shell_escape).with(@vm.name).in_sequence(shell_seq)
-      VirtualBox::Command.expects(:shell_escape).with(@caller.name).in_sequence(shell_seq)
-      VirtualBox::Command.expects(:vboxmanage).in_sequence(shell_seq)
-      @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")
+      VirtualBox::Command.expects(:vboxmanage).with("storageattach", @vm.name, "--storagectl", @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")
+      VirtualBox::Command.expects(:vboxmanage).with("storageattach", @vm.name, "--storagectl", @caller.name, "--port", @value.port, "--device", "0", "--medium", "none")
       @value.destroy
     end
 

data/test/virtualbox/command_test.rb

@@ -43,6 +43,21 @@ class CommandTest < Test::Unit::TestCase
         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

data/test/virtualbox/dvd_test.rb

@@ -15,7 +15,7 @@ class DVDTest < Test::Unit::TestCase
     end
 
     should "call vboxmanage to destroy it" do
-      VirtualBox::Command.expects(:vboxmanage).with("closemedium dvd #{@dvd.uuid} --delete")
+      VirtualBox::Command.expects(:vboxmanage).with("closemedium", "dvd", @dvd.uuid, "--delete")
       assert @dvd.destroy
     end
 
@@ -69,7 +69,7 @@ Accessible: yes
 Usage:      TestJeOS (UUID: 3d0f87b4-50f7-4fc5-ad89-93375b1b32a3)
 valid
 
-      VirtualBox::Command.expects(:vboxmanage).with("list dvds").returns(@valid)
+      VirtualBox::Command.expects(:vboxmanage).with("list", "dvds").returns(@valid)
     end
 
     should "return an array of DVD objects" do

data/test/virtualbox/extra_data_test.rb

@@ -44,7 +44,7 @@ raw
 
     context "populating" do
       should "call VBoxManage for the caller" do
-        VirtualBox::Command.expects(:vboxmanage).with("getextradata #{@caller.name} enumerate").returns(@raw)
+        VirtualBox::Command.expects(:vboxmanage).with("getextradata", @caller.name, "enumerate").returns(@raw)
         VirtualBox::ExtraData.populate_relationship(@caller, {})
       end
 
@@ -75,7 +75,7 @@ raw
     end
 
     should "call the proper vbox command" do
-      VirtualBox::Command.expects(:vboxmanage).with("setextradata global foo")
+      VirtualBox::Command.expects(:vboxmanage).with("setextradata", "global", "foo")
       assert @ed.delete(@key)
     end
 
@@ -111,7 +111,7 @@ raw
     end
 
     should "call the proper vbox command" do
-      VirtualBox::Command.expects(:vboxmanage).with("setextradata global foo BAR")
+      VirtualBox::Command.expects(:vboxmanage).with("setextradata", "global", "foo", "BAR")
       assert @ed.save
     end
 
@@ -154,7 +154,7 @@ raw
   context "global extra data" do
     setup do
       get_seq = sequence("get_seq")
-      VirtualBox::Command.expects(:vboxmanage).with("getextradata global enumerate").once.in_sequence(get_seq)
+      VirtualBox::Command.expects(:vboxmanage).with("getextradata", "global", "enumerate").once.in_sequence(get_seq)
       VirtualBox::ExtraData.expects(:parse_kv_pairs).returns(@ed).once.in_sequence(get_seq)
       @global = VirtualBox::ExtraData.global(true)
     end

data/test/virtualbox/hard_drive_test.rb

@@ -16,7 +16,7 @@ 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)
+    VirtualBox::Command.stubs(:vboxmanage).with("showhdinfo", @name).returns(@find_raw)
   end
 
   context "validations" do
@@ -48,7 +48,7 @@ raw
     end
 
     should "call vboxmanage to destroy it" do
-      VirtualBox::Command.expects(:vboxmanage).with("closemedium disk #{@hd.uuid} --delete")
+      VirtualBox::Command.expects(:vboxmanage).with("closemedium", "disk", @hd.uuid, "--delete")
       assert @hd.destroy
     end
 
@@ -68,7 +68,7 @@ raw
   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)
+      VirtualBox::Command.stubs(:vboxmanage).with("clonehd", @hd.uuid, "bar", "--format", "VDI", "--remember").returns(@find_raw)
     end
 
     should "call vboxmanage with the clone command" do
@@ -130,7 +130,7 @@ raw
     end
 
     should "call createhd" do
-      VirtualBox::Command.expects(:vboxmanage).with("createhd --filename #{@location} --size #{@size} --format #{@format} --remember")
+      VirtualBox::Command.expects(:vboxmanage).with("createhd", "--filename", @location, "--size", @size, "--format", @format, "--remember")
       @hd.save
     end
 
@@ -172,7 +172,7 @@ raw
 
   context "finding a single hard drive" do
     should "parse proper fields" do
-      VirtualBox::Command.expects(:vboxmanage).with("showhdinfo #{@name}").returns(@find_raw)
+      VirtualBox::Command.expects(:vboxmanage).with("showhdinfo", @name).returns(@find_raw)
 
       @expected = {
         :uuid => "11dedd14-57a1-4bdb-adeb-dd1d67f066e1",
@@ -190,12 +190,19 @@ raw
     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)")
+      VirtualBox::Command.stubs(:vboxmanage).raises(VirtualBox::Exceptions::CommandFailedException)
 
       assert_nothing_raised do
         assert_nil VirtualBox::HardDrive.find(12)
       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
@@ -223,7 +230,7 @@ Type:       normal
 Usage:      foo (UUID: 8710d3db-d96a-46ed-9004-59fa891fda90)
 valid
 
-      VirtualBox::Command.expects(:vboxmanage).with("list hdds").returns(@valid)
+      VirtualBox::Command.stubs(:vboxmanage).with("list", "hdds").returns(@valid)
 
       @hd = mock("hd")
       @hd.stubs(:is_a?).with(VirtualBox::HardDrive).returns(true)
@@ -236,5 +243,27 @@ valid
 
       result.each { |v| assert v.is_a?(VirtualBox::HardDrive) }
     end
+
+    should "forward the raise_error flag to find" do
+      VirtualBox::HardDrive.expects(:find).with(anything, true).raises(VirtualBox::Exceptions::CommandFailedException)
+      assert_raises(VirtualBox::Exceptions::CommandFailedException) {
+        VirtualBox::HardDrive.all(true)
+      }
+    end
+
+    should "return false if an error occured" do
+      VirtualBox::Command.stubs(:vboxmanage).raises(VirtualBox::Exceptions::CommandFailedException)
+
+      assert_nothing_raised do
+        assert !VirtualBox::HardDrive.all
+      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.all(true)
+      }
+    end
   end
 end

data/test/virtualbox/nic_test.rb

@@ -25,7 +25,7 @@ raw
     end
 
     should "use the vmname strung through the save" do
-      VirtualBox::Command.expects(:vboxmanage).with("modifyvm #{@vmname} --nic1 foo")
+      VirtualBox::Command.expects(:vboxmanage).with("modifyvm", @vmname, "--nic1", "foo")
 
       nic = @nic[0]
       nic.nic = "foo"
@@ -33,7 +33,7 @@ raw
     end
 
     should "use the proper index" do
-      VirtualBox::Command.expects(:vboxmanage).with("modifyvm #{@vmname} --nic2 far")
+      VirtualBox::Command.expects(:vboxmanage).with("modifyvm", @vmname, "--nic2", "far")
 
       nic = @nic[1]
       nic.nic = "far"
@@ -41,7 +41,7 @@ raw
     end
 
     should "save the nictype" do
-      VirtualBox::Command.expects(:vboxmanage).with("modifyvm #{@vmname} --nictype1 ZOO")
+      VirtualBox::Command.expects(:vboxmanage).with("modifyvm", @vmname, "--nictype1", "ZOO")
 
       nic = @nic[0]
       nic.nictype = "ZOO"

data/test/virtualbox/shared_folder_test.rb

@@ -96,7 +96,7 @@ class SharedFolderTest < Test::Unit::TestCase
       end
 
       should "call the proper vboxcommand" do
-        VirtualBox::Command.expects(:vboxmanage).with("sharedfolder add #{@caller.name} --name #{@sf.name} --hostpath #{@sf.hostpath}")
+        VirtualBox::Command.expects(:vboxmanage).with("sharedfolder", "add", @caller.name, "--name", @sf.name, "--hostpath", @sf.hostpath)
         assert @sf.save
       end
 
@@ -175,15 +175,7 @@ class SharedFolderTest < Test::Unit::TestCase
     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 "shell escape VM name and storage controller name" do
-      shell_seq = sequence("shell_seq")
-      VirtualBox::Command.expects(:shell_escape).with(@caller.name).in_sequence(shell_seq)
-      VirtualBox::Command.expects(:shell_escape).with(@value.name).in_sequence(shell_seq)
-      VirtualBox::Command.expects(:vboxmanage).in_sequence(shell_seq)
+      VirtualBox::Command.expects(:vboxmanage).with("sharedfolder", "remove", @caller.name, "--name", @value.name).once
       assert @value.destroy
     end
 
@@ -201,10 +193,7 @@ class SharedFolderTest < Test::Unit::TestCase
 
     should "use the old name if it was changed" do
       @value.name = "DIFFERENT"
-      shell_seq = sequence("shell_seq")
-      VirtualBox::Command.expects(:shell_escape).with(@caller.name).in_sequence(shell_seq)
-      VirtualBox::Command.expects(:shell_escape).with(@value.name_was).in_sequence(shell_seq)
-      VirtualBox::Command.expects(:vboxmanage).in_sequence(shell_seq)
+      VirtualBox::Command.expects(:vboxmanage)
       assert @value.destroy
     end
   end

data/test/virtualbox/vm_test.rb

@@ -81,11 +81,11 @@ showvminfo
   end
 
   def create_vm
-    VirtualBox::Command.expects(:vboxmanage).with("showvminfo #{@name} --machinereadable").returns(@raw)
-    VirtualBox::Command.expects(:vboxmanage).with("showvminfo #{@name}").returns("")
-    VirtualBox::Command.expects(:vboxmanage).with("list hdds").returns("")
-    VirtualBox::Command.expects(:vboxmanage).with("list dvds").returns("")
-    VirtualBox::Command.expects(:vboxmanage).with("getextradata #{@name} enumerate").returns("")
+    VirtualBox::Command.expects(:vboxmanage).with("showvminfo", @name, "--machinereadable").returns(@raw)
+    VirtualBox::Command.expects(:vboxmanage).with("showvminfo", @name).returns("")
+    VirtualBox::Command.expects(:vboxmanage).with("list", "hdds").returns("")
+    VirtualBox::Command.expects(:vboxmanage).with("list", "dvds").returns("")
+    VirtualBox::Command.expects(:vboxmanage).with("getextradata", @name, "enumerate").returns("")
     vm = VirtualBox::VM.find(@name)
     assert vm
     vm
@@ -93,14 +93,9 @@ showvminfo
 
   context "human readable info" do
     should "not pass --machinereadable into the showvminfo command" do
-      VirtualBox::Command.expects(:vboxmanage).with("showvminfo #{@name}").once
+      VirtualBox::Command.expects(:vboxmanage).with("showvminfo", @name).once
       VirtualBox::VM.human_info(@name)
     end
-
-    should "shell escape parameter" do
-      VirtualBox::Command.expects(:vboxmanage).with("showvminfo hello\\ world").once
-      VirtualBox::VM.human_info("hello world")
-    end
   end
 
   context "reading the VM state" do
@@ -147,17 +142,17 @@ showvminfo
     end
 
     should "export the VM with no options if none are passed" do
-      VirtualBox::Command.expects(:vboxmanage).with("export #{@name} -o foo")
+      VirtualBox::Command.expects(:vboxmanage).with("export", @name, "-o", "foo")
       @vm.export("foo")
     end
 
     should "export the VM with specified options" do
-      VirtualBox::Command.expects(:vboxmanage).with("export #{@name} -o foo --vsys 0 --foo bar")
+      VirtualBox::Command.expects(:vboxmanage).with("export", @name, "-o", "foo", "--vsys", "0", "--foo", :bar)
       @vm.export("foo", :foo => :bar)
     end
 
     should "shell escape all the options" do
-      VirtualBox::Command.expects(:vboxmanage).with("export #{@name} -o foo --vsys 0 --foo a\\ space")
+      VirtualBox::Command.expects(:vboxmanage).with("export", @name, "-o", "foo", "--vsys", "0", "--foo", "a space")
       @vm.export("foo", :foo => "a space")
     end
 
@@ -185,14 +180,8 @@ showvminfo
     end
 
     context "control method" do
-      should "shell escape the vm name" do
-        VirtualBox::Command.expects(:vboxmanage).with("controlvm hello\\ world FOO")
-        @vm.instance_variable_set(:@original_name, "hello world")
-        assert @vm.control(:FOO)
-      end
-
       should "run the given command when 'control' is called" do
-        VirtualBox::Command.expects(:vboxmanage).with("controlvm #{@name} foo")
+        VirtualBox::Command.expects(:vboxmanage).with("controlvm", @name, :foo)
         assert @vm.control(:foo)
       end
 
@@ -210,7 +199,7 @@ showvminfo
     end
 
     should "start a VM with the given type" do
-      VirtualBox::Command.expects(:vboxmanage).with("startvm #{@name} --type FOO")
+      VirtualBox::Command.expects(:vboxmanage).with("startvm", @name, "--type", :FOO)
       assert @vm.start(:FOO)
     end
 
@@ -219,12 +208,6 @@ showvminfo
       assert !@vm.start
     end
 
-    should "shell escape the VM name on start" do
-      VirtualBox::Command.expects(:vboxmanage).with("startvm hello\\ world --type FOO")
-      @vm.instance_variable_set(:@original_name, "hello world")
-      assert @vm.start(:FOO)
-    end
-
     should "raise an exception if start fails and flag is set" do
       VirtualBox::Command.stubs(:vboxmanage).raises(VirtualBox::Exceptions::CommandFailedException)
       assert_raises(VirtualBox::Exceptions::CommandFailedException) {
@@ -232,7 +215,7 @@ showvminfo
       }
     end
 
-    should "stop a VM with a 'poweroff'" do
+    should "stop a VM with a 'acpipowerbutton'" do
       @vm.expects(:control).with(:acpipowerbutton, false).returns(true)
       assert @vm.shutdown
     end
@@ -256,6 +239,23 @@ showvminfo
       @vm.expects(:control).with(:savestate, false).returns(true)
       assert @vm.save_state
     end
+
+    should "discard a saved state of a VM" do
+      VirtualBox::Command.expects(:vboxmanage).with("discardstate", @name)
+      assert @vm.discard_state
+    end
+
+    should "return false if discarding state failed" do
+      VirtualBox::Command.stubs(:vboxmanage).raises(VirtualBox::Exceptions::CommandFailedException)
+      assert !@vm.discard_state
+    end
+
+    should "raise an exception if discarding state fails and flag is set" do
+      VirtualBox::Command.stubs(:vboxmanage).raises(VirtualBox::Exceptions::CommandFailedException)
+      assert_raises(VirtualBox::Exceptions::CommandFailedException) {
+        @vm.discard_state(true)
+      }
+    end
   end
 
   context "destroying" do
@@ -263,17 +263,10 @@ showvminfo
       @vm = create_vm
     end
 
-    should "shell escape the name" do
-      VirtualBox::StorageController.expects(:destroy_relationship)
-      VirtualBox::Command.expects(:vboxmanage).with("unregistervm hello\\ world --delete")
-      @vm.instance_variable_set(:@original_name, "hello world")
-      @vm.destroy
-    end
-
     should "destroy all storage controllers before destroying VM" do
       destroy_seq = sequence("destroy_seq")
       VirtualBox::StorageController.expects(:destroy_relationship).in_sequence(destroy_seq)
-      VirtualBox::Command.expects(:vboxmanage).with("unregistervm #{@name} --delete").in_sequence(destroy_seq)
+      VirtualBox::Command.expects(:vboxmanage).with("unregistervm", @name, "--delete").in_sequence(destroy_seq)
       @vm.destroy
     end
   end
@@ -288,7 +281,7 @@ raw
 
     should "list VMs then parse them" do
       all_seq = sequence("all")
-      VirtualBox::Command.expects(:vboxmanage).with("list vms").returns(@raw).in_sequence(all_seq)
+      VirtualBox::Command.expects(:vboxmanage).with("list", "vms").returns(@raw).in_sequence(all_seq)
       VirtualBox::VM.expects(:parse_vm_list).with(@raw).in_sequence(all_seq)
       VirtualBox::VM.all
     end
@@ -331,7 +324,7 @@ raw
     end
 
     should "attempt to find the imported VM" do
-      VirtualBox::Command.expects(:vboxmanage).with("import whatever").returns(@raw)
+      VirtualBox::Command.expects(:vboxmanage).with("import", "whatever").returns(@raw)
       VirtualBox::VM.expects(:find).with("Base_1").once
       VirtualBox::VM.import("whatever")
     end
@@ -368,39 +361,17 @@ raw
     end
 
     should "save only the attributes which saved" do
-      VirtualBox::Command.expects(:vboxmanage).with("modifyvm #{@name} --ostype Zubuntu")
+      VirtualBox::Command.expects(:vboxmanage).with("modifyvm", @name, "--ostype", "Zubuntu")
 
       @vm.ostype = "Zubuntu"
       assert @vm.save
     end
 
-    should "shell escape saved values" do
-      VirtualBox::Command.expects(:vboxmanage).with("modifyvm #{@name} --ostype My\\ Value")
-
-      @vm.ostype = "My Value"
-      assert @vm.save
-    end
-
-    should "shell escape the string value of a value" do
-      VirtualBox::Command.expects(:vboxmanage).with("modifyvm #{@name} --memory 400")
-
-      @vm.memory = 400
-      assert_nothing_raised { @vm.save }
-    end
-
-    should "shell escape the VM name when saving an attribute" do
-      VirtualBox::Command.expects(:vboxmanage).with("modifyvm hello\\ world --memory 400")
-
-      @vm.memory = 400
-      @vm.instance_variable_set(:@original_name, "hello world")
-      assert @vm.save
-    end
-
     should "save name first if changed, then following values should modify new VM" do
       save_seq = sequence("save_seq")
       new_name = "foo2"
-      VirtualBox::Command.expects(:vboxmanage).with("modifyvm #{@name} --name #{new_name}").in_sequence(save_seq)
-      VirtualBox::Command.expects(:vboxmanage).with("modifyvm #{new_name} --ostype Zubuntu").in_sequence(save_seq)
+      VirtualBox::Command.expects(:vboxmanage).with("modifyvm", @name, "--name", new_name).in_sequence(save_seq)
+      VirtualBox::Command.expects(:vboxmanage).with("modifyvm", new_name, "--ostype", "Zubuntu").in_sequence(save_seq)
 
       @vm.name = new_name
       @vm.ostype = "Zubuntu"
@@ -427,17 +398,12 @@ raw
       }
 
       command_seq = sequence("command_seq)")
-      VirtualBox::Command.expects(:vboxmanage).with("showvminfo #{@name} --machinereadable").returns(@raw).in_sequence(command_seq)
-      VirtualBox::Command.expects(:vboxmanage).with(anything).returns("").at_least(0).in_sequence(command_seq)
+      VirtualBox::Command.expects(:vboxmanage).with("showvminfo", @name, "--machinereadable").returns(@raw).in_sequence(command_seq)
+      VirtualBox::Command.expects(:vboxmanage).returns("").at_least(0).in_sequence(command_seq)
       @vm = VirtualBox::VM.find(@name)
       assert @vm
     end
 
-    should "shell escape the VM name" do
-      VirtualBox::Command.expects(:vboxmanage).with("showvminfo hello\\ world --machinereadable").returns(@raw)
-      assert VirtualBox::VM.find("hello world")
-    end
-
     should "return a VM object with proper attributes" do
       @expected.each do |k,v|
         assert_equal v, @vm.read_attribute(k)

data/virtualbox.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{virtualbox}
-  s.version = "0.4.2"
+  s.version = "0.4.3"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Mitchell Hashimoto"]
-  s.date = %q{2010-01-31}
+  s.date = %q{2010-02-02}
   s.description = %q{Create and modify virtual machines in VirtualBox using pure ruby.}
   s.email = %q{mitchell.hashimoto@gmail.com}
   s.extra_rdoc_files = [

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: virtualbox
 version: !ruby/object:Gem::Version 
-  version: 0.4.2
+  version: 0.4.3
 platform: ruby
 authors: 
 - Mitchell Hashimoto
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-01-31 00:00:00 -08:00
+date: 2010-02-02 00:00:00 -08:00
 default_executable: 
 dependencies: []