virtualbox 0.4.1 → 0.4.2

data/test/virtualbox/vm_test.rb

@@ -3,10 +3,6 @@ require File.join(File.dirname(__FILE__), '..', 'test_helper')
 class VMTest < Test::Unit::TestCase
   setup do
     @raw = <<-showvminfo
-VirtualBox Command Line Management Interface Version 3.1.2
-(C) 2005-2009 Sun Microsystems, Inc.
-All rights reserved.
-
 name="foo"
 ostype="Ubuntu"
 UUID="8710d3db-d96a-46ed-9004-59fa891fda90"
@@ -77,13 +73,13 @@ SharedFolderPathMachineMapping1="/virtualbox"
 SharedFolderNameMachineMapping2="otherfolder"
 SharedFolderPathMachineMapping2="/virtualbox/lib"
 showvminfo
-    
+
     @name = "foo"
-    
+
     # Just to be sure nothing is executed
     VirtualBox::Command.stubs(:execute).returns('')
   end
-  
+
   def create_vm
     VirtualBox::Command.expects(:vboxmanage).with("showvminfo #{@name} --machinereadable").returns(@raw)
     VirtualBox::Command.expects(:vboxmanage).with("showvminfo #{@name}").returns("")
@@ -94,65 +90,87 @@ showvminfo
     assert vm
     vm
   end
-  
+
   context "human readable info" do
     should "not pass --machinereadable into the showvminfo command" do
       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
     setup do
       @vm = create_vm
     end
-    
+
     should "read the initial state when loading the VM" do
       assert_equal "poweroff", @vm.state
     end
-    
+
     should "reload the state if true is passed as a parameter" do
       VirtualBox::VM.expects(:raw_info).returns({ :vmstate => "on" })
       assert_equal "on", @vm.state(true)
       assert_equal "on", @vm.state
     end
+
+    should "provide conveniance methods for determining VM state" do
+      VirtualBox::VM.expects(:raw_info).returns({ :vmstate => "poweroff" })
+      assert_equal "poweroff", @vm.state(true)
+      assert @vm.powered_off?
+
+      VirtualBox::VM.expects(:raw_info).returns({ :vmstate => "running" })
+      assert_equal "running", @vm.state(true)
+      assert @vm.running?
+
+      VirtualBox::VM.expects(:raw_info).returns({ :vmstate => "paused" })
+      assert_equal "paused", @vm.state(true)
+      assert @vm.paused?
+
+      VirtualBox::VM.expects(:raw_info).returns({ :vmstate => "saved" })
+      assert_equal "saved", @vm.state(true)
+      assert @vm.saved?
+
+      VirtualBox::VM.expects(:raw_info).returns({ :vmstate => "aborted" })
+      assert_equal "aborted", @vm.state(true)
+      assert @vm.aborted?
+    end
   end
-  
+
   context "exporting a VM" do
     setup do
       @vm = create_vm
     end
-    
+
     should "export the VM with no options if none are passed" do
       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")
       @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")
       @vm.export("foo", :foo => "a space")
     end
-    
+
     should "return true if the export succeeded" do
       VirtualBox::Command.expects(:vboxmanage).once
       assert @vm.export("foo")
     end
-    
+
     should "return false if the export failed" do
       VirtualBox::Command.stubs(:vboxmanage).raises(VirtualBox::Exceptions::CommandFailedException)
       assert !@vm.export("foo")
     end
-    
+
     should "raise an exception on failure if raise_error is true" do
       VirtualBox::Command.stubs(:vboxmanage).raises(VirtualBox::Exceptions::CommandFailedException)
       assert_raises(VirtualBox::Exceptions::CommandFailedException) {
@@ -160,23 +178,29 @@ showvminfo
       }
     end
   end
-  
+
   context "controlling a VM (start, stop, pause, etc.)" do
     setup do
       @vm = create_vm
     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")
         assert @vm.control(:foo)
       end
-      
+
       should "return false if the command failed" do
         VirtualBox::Command.stubs(:vboxmanage).raises(VirtualBox::Exceptions::CommandFailedException)
         assert !@vm.control(:foo)
       end
-      
+
       should "raise an exception if flag is set" do
         VirtualBox::Command.stubs(:vboxmanage).raises(VirtualBox::Exceptions::CommandFailedException)
         assert_raises(VirtualBox::Exceptions::CommandFailedException) {
@@ -184,50 +208,68 @@ showvminfo
         }
       end
     end
-    
+
     should "start a VM with the given type" do
       VirtualBox::Command.expects(:vboxmanage).with("startvm #{@name} --type FOO")
       assert @vm.start(:FOO)
     end
-    
+
     should "return false if start failed" do
       VirtualBox::Command.stubs(:vboxmanage).raises(VirtualBox::Exceptions::CommandFailedException)
       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) {
         @vm.start(:foo, true)
       }
     end
-    
+
+    should "stop a VM with a 'poweroff'" do
+      @vm.expects(:control).with(:acpipowerbutton, false).returns(true)
+      assert @vm.shutdown
+    end
+
     should "stop a VM with a 'poweroff'" do
       @vm.expects(:control).with(:poweroff, false).returns(true)
       assert @vm.stop
     end
-    
+
     should "pause a VM" do
       @vm.expects(:control).with(:pause, false).returns(true)
       assert @vm.pause
     end
-    
+
     should "resume a VM" do
       @vm.expects(:control).with(:resume, false).returns(true)
       assert @vm.resume
     end
-    
+
     should "save the state of a VM" do
       @vm.expects(:control).with(:savestate, false).returns(true)
       assert @vm.save_state
     end
   end
-  
+
   context "destroying" do
     setup do
       @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)
@@ -235,7 +277,7 @@ showvminfo
       @vm.destroy
     end
   end
-  
+
   context "finding all VMs" do
     setup do
       @raw = <<-raw
@@ -243,26 +285,26 @@ showvminfo
 "bar"  {zefaldf}
 raw
     end
-    
+
     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::VM.expects(:parse_vm_list).with(@raw).in_sequence(all_seq)
       VirtualBox::VM.all
     end
-    
+
     context "parser" do
       should "ignore non-matching lines" do
         assert VirtualBox::VM.parse_vm_list("HEY YOU").empty?
       end
-      
+
       should "return VM objects for valid lines" do
         vm_foo = mock("vm_foo")
         vm_bar = mock("vm_bar")
         parse_seq = sequence("parse")
         VirtualBox::VM.expects(:find).with("foo").returns(vm_foo).in_sequence(parse_seq)
         VirtualBox::VM.expects(:find).with("bar").returns(vm_bar).in_sequence(parse_seq)
-        
+
         result = VirtualBox::VM.parse_vm_list(@raw)
         assert !result.empty?
         assert_equal 2, result.length
@@ -271,14 +313,10 @@ raw
       end
     end
   end
-  
+
   context "importing a VM" do
     setup do
       @raw = <<-raw
-VirtualBox Command Line Management Interface Version 3.1.2
-(C) 2005-2009 Sun Microsystems, Inc.
-All rights reserved.
-
 0%...10%...20%...30%...40%...50%...60%...70%...80%...90%...100%
 Interpreting /Users/mitchellh/base.ovf...
 OK.
@@ -288,79 +326,87 @@ Virtual system 0:
     (change with "--vsys 0 --ostype <type>"; use "list ostypes" to list all possible values)
  1: Suggested VM name "Base_1"
     (change with "--vsys 0 --vmname <name>")
- 2: Number of CPUs: 1      
+ 2: Number of CPUs: 1
 raw
     end
-    
+
     should "attempt to find the imported VM" do
       VirtualBox::Command.expects(:vboxmanage).with("import whatever").returns(@raw)
       VirtualBox::VM.expects(:find).with("Base_1").once
       VirtualBox::VM.import("whatever")
     end
 
-    should "parse the VM name from the raw string" do      
+    should "parse the VM name from the raw string" do
       assert_equal "Base_1", VirtualBox::VM.parse_vm_name(@raw)
     end
-    
+
     should "return nil on parsing the VM name if its invalid" do
       assert_nil VirtualBox::VM.parse_vm_name("Name foo")
     end
   end
-  
+
   context "saving a changed VM" do
     setup do
       @vm = create_vm
       VirtualBox::AttachedDevice.any_instance.stubs(:save)
     end
-    
+
     should "return false if saving fails" do
       VirtualBox::Command.stubs(:vboxmanage).raises(VirtualBox::Exceptions::CommandFailedException)
-      
+
       @vm.ostype = "Zubuntu"
       assert !@vm.save
     end
-    
+
     should "raise an error if saving fails and flag to true" do
       VirtualBox::Command.stubs(:vboxmanage).raises(VirtualBox::Exceptions::CommandFailedException)
-      
+
       @vm.ostype = "Zubuntu"
       assert_raises(VirtualBox::Exceptions::CommandFailedException) {
         @vm.save(true)
       }
     end
-    
+
     should "save only the attributes which saved" do
       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)
-      
+
       @vm.name = new_name
       @vm.ostype = "Zubuntu"
       assert @vm.save
     end
-    
+
     should "save the relationships as well" do
       VirtualBox::Nic.expects(:save_relationship).once
       VirtualBox::StorageController.expects(:save_relationship).once
@@ -370,7 +416,7 @@ raw
       assert @vm.save
     end
   end
-  
+
   context "finding a VM by name" do
     setup do
 
@@ -379,57 +425,62 @@ raw
         :ostype => "Ubuntu",
         :uuid   => "8710d3db-d96a-46ed-9004-59fa891fda90"
       }
-      
+
       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)
       @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      
+
+    should "return a VM object with proper attributes" do
       @expected.each do |k,v|
         assert_equal v, @vm.read_attribute(k)
       end
     end
-    
+
+    should "return nil if the VM doesn't exist" do
+      VirtualBox::Command.expects(:vboxmanage).raises(VirtualBox::Exceptions::CommandFailedException)
+      assert_nil VirtualBox::VM.find("dont exist")
+    end
+
     should "properly load nic relationship" do
       assert @vm.nics
       assert @vm.nics.is_a?(Array)
       assert_equal 8, @vm.nics.length
     end
-    
+
     should "properly load storage controller relationship" do
       assert @vm.storage_controllers
       assert @vm.storage_controllers.is_a?(Array)
       assert_equal 2, @vm.storage_controllers.length
     end
-    
+
     should "properly load shared folder relationship" do
       assert @vm.shared_folders
       assert @vm.shared_folders.is_a?(Array)
       assert_equal 2, @vm.shared_folders.length
     end
   end
-  
+
   context "parsing the showvminfo output" do
     should "lowercase and symbolize the keys" do
       result = VirtualBox::VM.parse_vm_info("ZING=Zam")
       assert_equal 1, result.length
       assert_equal "Zam", result[:zing]
     end
-    
+
     should "ignore quotes for multi-word keys or values" do
       result = VirtualBox::VM.parse_vm_info('"foo bar"="baz"')
       assert_equal 1, result.length
       assert_equal "baz", result[:"foo bar"]
     end
-    
+
     should "ignore the lines which aren't the proper format" do
       result = VirtualBox::VM.parse_vm_info(<<-block)
 This should not be parsed