virtualbox 0.6.1 → 0.7.0

data/test/virtualbox/vm_test.rb

@@ -78,7 +78,35 @@ class VMTest < Test::Unit::TestCase
       end
     end
 
-    context "populating relationship" do
+    context "populating relationships" do
+      setup do
+        @caller = mock("caller")
+      end
+
+      should "call populate_array_relationship for arrays" do
+        @klass.expects(:populate_array_relationship).with(@caller, []).once
+        @klass.populate_relationship(@caller, [])
+      end
+
+      should "call populate_single_relationship for non-arrays" do
+        @klass.expects(:populate_single_relationship).with(@caller, nil).once
+        @klass.populate_relationship(@caller, nil)
+      end
+    end
+
+    context "populating single relationships" do
+      setup do
+        @machine = mock("interface")
+      end
+
+      should "return a new machine" do
+        result = mock("result")
+        @klass.expects(:new).with(@machine).returns(result)
+        assert_equal result, @klass.populate_single_relationship(nil, @machine)
+      end
+    end
+
+    context "populating array relationship" do
       setup do
         @instance = mock("instance")
 
@@ -86,7 +114,7 @@ class VMTest < Test::Unit::TestCase
       end
 
       should "return a proxied collection" do
-        result = @klass.populate_relationship(nil, [])
+        result = @klass.populate_array_relationship(nil, [])
         assert result.is_a?(VirtualBox::Proxies::Collection)
       end
 
@@ -102,7 +130,7 @@ class VMTest < Test::Unit::TestCase
           expected_result << expected_value
         end
 
-        assert_equal expected_result, @klass.populate_relationship(nil, machines)
+        assert_equal expected_result, @klass.populate_array_relationship(nil, machines)
       end
     end
   end
@@ -165,6 +193,21 @@ class VMTest < Test::Unit::TestCase
       @instance.stubs(:running).returns(false)
     end
 
+    context "reloading" do
+      setup do
+        @instance.stubs(:initialize_attributes)
+      end
+
+      should "just reload the attributes" do
+        @instance.expects(:initialize_attributes).with(@interface).once
+        @instance.reload
+      end
+
+      should "return itself" do
+        assert @instance.equal?(@instance.reload)
+      end
+    end
+
     context "destroying" do
       setup do
         @instance.stubs(:uuid).returns(:foo)
@@ -173,8 +216,13 @@ class VMTest < Test::Unit::TestCase
         @interface.stubs(:parent).returns(@interface_parent)
       end
 
-      should "destroy relationships first, then the machine" do
+      should "destroy snapshots, relationships, then the machine" do
         destroy_seq = sequence("destroy_seq")
+        snapshot = mock("snapshot")
+        snapshot.stubs(:children).returns([])
+        @instance.stubs(:root_snapshot).returns(snapshot)
+        snapshot.expects(:destroy).once.in_sequence(destroy_seq)
+        @instance.expects(:reload).once.in_sequence(destroy_seq)
         VirtualBox::StorageController.expects(:destroy_relationship).in_sequence(destroy_seq)
         @interface_parent.expects(:unregister_machine).with(@instance.uuid).in_sequence(destroy_seq)
         @interface.expects(:delete_settings).once.in_sequence(destroy_seq)
@@ -186,15 +234,18 @@ class VMTest < Test::Unit::TestCase
     context "state" do
       setup do
         @state = mock("state")
+        @interface = mock("interface")
         @instance.stubs(:read_attribute).with(:state).returns(@state)
+        @instance.stubs(:interface).returns(@interface)
       end
 
-      should "just return the state" do
+      should "reload and return the state" do
+        @instance.expects(:load_interface_attribute).with(:state, @instance.interface).once
         assert_equal @state, @instance.state
       end
 
-      should "reload the state if reload is set" do
-        @instance.expects(:load_interface_attribute).with(:state).once
+      should "not reload the state if suppress is given" do
+        @instance.expects(:load_interface_attribute).never
         assert_equal @state, @instance.state(true)
       end
     end
@@ -202,6 +253,9 @@ class VMTest < Test::Unit::TestCase
     context "starting" do
       setup do
         setup_session_mocks
+
+        @instance.stubs(:running?).returns(false)
+        @session.stubs(:state).returns(:open)
       end
 
       should "open remote session using the given mode, wait for completion, then close" do
@@ -228,6 +282,7 @@ class VMTest < Test::Unit::TestCase
         @console = mock("console")
         @console.stubs(:send)
         @session.stubs(:console).returns(@console)
+        @session.stubs(:state).returns(:open)
 
         @method = :foo
       end
@@ -244,7 +299,7 @@ class VMTest < Test::Unit::TestCase
 
       should "wait for completion if an IProgress is returned" do
         progress = mock("IProgress")
-        progress.stubs(:is_a?).with(VirtualBox::COM::Interface::Progress).returns(true)
+        progress.stubs(:is_a?).with(VirtualBox::COM::Util.versioned_interface(:Progress)).returns(true)
         progress.expects(:wait_for_completion).with(-1).once
         @console.expects(:send).with(@method).returns(progress)
         @instance.control(@method)
@@ -281,17 +336,39 @@ class VMTest < Test::Unit::TestCase
         @session.stubs(:machine).returns(@parent)
 
         @locked_interface = mock("locked_interface")
+
+        @instance.stubs(:saved?).returns(false)
+        @instance.stubs(:valid?).returns(true)
+        @instance.stubs(:with_open_session)
       end
 
       should "open the session, save, and close" do
         save_seq = sequence("save_seq")
         @instance.expects(:with_open_session).once.yields(@session).in_sequence(save_seq)
         @session.expects(:machine).returns(@locked_interface).in_sequence(save_seq)
+        @instance.expects(:save_interface_attribute).with(:boot_order, @locked_interface).in_sequence(save_seq)
         @instance.expects(:save_changed_interface_attributes).with(@locked_interface).in_sequence(save_seq)
         @instance.expects(:save_relationships).in_sequence(save_seq)
 
         @instance.save
       end
+
+      should "raise an exception if saved" do
+        @instance.stubs(:saved?).returns(true)
+
+        assert_raises(VirtualBox::Exceptions::ReadonlyVMStateException) {
+          @instance.save
+        }
+      end
+
+      should "return false if not valid" do
+        @instance.stubs(:valid?).returns(false)
+        assert !@instance.save
+      end
+
+      should "return true if save succeeds" do
+        assert @instance.save
+      end
     end
 
     context "opening a session [direct]" do
@@ -299,8 +376,22 @@ class VMTest < Test::Unit::TestCase
         setup_session_mocks
 
         @locked_interface = mock("locked_interface")
+        @locked_interface.stubs(:state).returns(:powered_off)
         @session.stubs(:machine).returns(@locked_interface)
         @session.stubs(:state).returns(:closed)
+        @parent.stubs(:open_session)
+      end
+
+      should "close the session if an exception is raised" do
+        @locked_interface.expects(:save_settings).raises(Exception)
+        @session.expects(:close).once
+
+        assert_raises(Exception) do
+          @instance.with_open_session do
+            # After this point, state should be open
+            @session.stubs(:state).returns(:open)
+          end
+        end
       end
 
       should "open the session, save, and close" do
@@ -317,6 +408,17 @@ class VMTest < Test::Unit::TestCase
         end
       end
 
+      should "not save settings when the state is saved" do
+        @locked_interface.stubs(:state).returns(:saved)
+
+        save_seq = sequence("save_seq")
+        @parent.expects(:open_session).with(@session, @uuid).in_sequence(save_seq)
+        @locked_interface.expects(:save_settings).never
+        @session.expects(:close).in_sequence(save_seq)
+
+        @instance.with_open_session { |session| }
+      end
+
       should "only open the session and close once" do
         open_seq = sequence("open_seq")
 
@@ -337,6 +439,7 @@ class VMTest < Test::Unit::TestCase
     context "state methods" do
       should "check the proper results" do
         methods = {
+          :starting? => :starting,
           :running? => :running,
           :powered_off? => :powered_off,
           :paused? => :paused,
@@ -366,12 +469,13 @@ class VMTest < Test::Unit::TestCase
 
       should "create a new appliance with path and export" do
         result = mock("result")
+        options = mock("options")
         VirtualBox::Appliance.expects(:new).returns(@appliance)
         @appliance.expects(:path=).with(@path)
-        @appliance.expects(:add_machine).with(@instance)
+        @appliance.expects(:add_machine).with(@instance, options)
         @appliance.expects(:export)
 
-        @instance.export(@path)
+        @instance.export(@path, options)
       end
 
       should "forward any block to the appliance export method" do
@@ -384,5 +488,135 @@ class VMTest < Test::Unit::TestCase
         end
       end
     end
+
+    context "taking a snapshot" do
+      setup do
+        setup_session_mocks
+
+        @progress = mock("progress")
+        @progress.stubs(:wait)
+
+        @console = mock("console")
+        @console.stubs(:take_snapshot).returns(@progress)
+        @session.stubs(:console).returns(@console)
+
+        @instance.stubs(:with_open_session).yields(@session)
+      end
+
+      should "take a snapshot on the console and wait" do
+        name = "foo"
+        description = "baz"
+        @console.expects(:take_snapshot).with(name, description).returns(@progress)
+        @instance.take_snapshot(name, description)
+      end
+
+      should "wait and pass in the given block, if given" do
+        foo = mock("foo")
+        @progress.expects(:wait).yields(foo)
+        foo.expects(:called).once
+
+        @instance.take_snapshot(nil, nil) do |obj|
+          obj.called
+        end
+      end
+    end
+
+    context "root snapshot" do
+      should "return nil if the current snapshot is nil" do
+        @instance.stubs(:current_snapshot).returns(nil)
+        assert_nil @instance.root_snapshot
+      end
+
+      should "return the proper root snapshot" do
+        root = mock("root_snapshot")
+        root.stubs(:parent).returns(nil)
+
+        parent = mock("parent")
+        parent.stubs(:parent).returns(root)
+
+        snapshot = mock("snapshot")
+        snapshot.stubs(:parent).returns(parent)
+
+        @instance.stubs(:current_snapshot).returns(snapshot)
+        assert_equal root, @instance.root_snapshot
+      end
+    end
+
+    context "finding a snapshot" do
+      should "return nil if there is no root snapshot" do
+        @instance.stubs(:current_snapshot).returns(nil)
+        assert_nil @instance.find_snapshot("foo")
+      end
+
+      should "return nil if the snapshot is not found" do
+        snapshot = mock("snapshot")
+        snapshot.stubs(:name).returns("wrong")
+        snapshot.stubs(:uuid).returns(nil)
+        snapshot.stubs(:children).returns([])
+        @instance.stubs(:root_snapshot).returns(snapshot)
+
+        assert_nil @instance.find_snapshot("bar")
+      end
+
+      # TODO: Testing traversing the snapshot tree. Too many mocks :S
+    end
+
+    context "getting the boot order" do
+      setup do
+        @max = 4
+        @global = mock("global")
+        @sys_props = mock("system_properties")
+
+        @sys_props.stubs(:max_boot_position).returns(@max)
+        @global.stubs(:system_properties).returns(@sys_props)
+        VirtualBox::Global.stubs(:global).returns(@global)
+      end
+
+      should "get the boot order for each up to max" do
+        expected = (1..@max).inject([]) do |acc, pos|
+          result = mock("p#{pos}")
+          @interface.expects(:get_boot_order).with(pos).returns(result)
+          acc << result
+          acc
+        end
+
+        assert_equal expected, @instance.get_boot_order(@interface, nil)
+      end
+    end
+
+    context "setting the boot order" do
+      setup do
+        @max = 4
+        @global = mock("global")
+        @sys_props = mock("system_properties")
+
+        @sys_props.stubs(:max_boot_position).returns(@max)
+        @global.stubs(:system_properties).returns(@sys_props)
+        VirtualBox::Global.stubs(:global).returns(@global)
+      end
+
+      should "set the boot order for each up to max" do
+        expected = (1..@max).inject([]) do |acc, pos|
+          result = mock("p#{pos}")
+          @interface.expects(:set_boot_order).with(pos, result)
+          acc << result
+          acc
+        end
+
+        @instance.set_boot_order(@interface, nil, expected)
+      end
+
+      should "set the boot order for max items even if value has less than the proper amount" do
+        items = [1, 2]
+        items.concat(Array.new(@max - items.size))
+        items.each_with_index do |item, i|
+          @interface.expects(:set_boot_order).with(i + 1, item).once
+        end
+
+        assert_equal @max, items.size # sanity
+
+        @instance.set_boot_order(@interface, nil, items)
+      end
+    end
   end
-end
+end

data/test/virtualbox/vrdp_server_test.rb

@@ -0,0 +1,83 @@
+require File.join(File.dirname(__FILE__), '..', 'test_helper')
+
+class VRDPServerTest < Test::Unit::TestCase
+  setup do
+    @klass = VirtualBox::VRDPServer
+    @interface = mock("interface")
+    @parent = mock("parent")
+  end
+
+  context "class methods" do
+    context "populating relationship" do
+      setup do
+        @instance = mock("instance")
+        @klass.stubs(:new).returns(@instance)
+
+        @vrdp_server = mock("vrdp_server")
+        @interface.stubs(:vrdp_server).returns(@vrdp_server)
+      end
+
+      should "call new for the interface" do
+        @klass.expects(:new).with(nil, @vrdp_server).once.returns(@instance)
+        assert_equal @instance, @klass.populate_relationship(nil, @interface)
+      end
+    end
+
+    context "saving relationship" do
+      should "call save with the interface on the instance" do
+        instance = mock("instance")
+        instance.expects(:save).once
+
+        @klass.save_relationship(nil, instance)
+      end
+    end
+  end
+
+  context "initializing" do
+    setup do
+      @klass.any_instance.stubs(:load_interface_attributes)
+    end
+
+    should "load interface attribtues" do
+      @klass.any_instance.expects(:load_interface_attributes).with(@interface).once
+      @klass.new(@parent, @interface)
+    end
+
+    should "not be dirty" do
+      @instance = @klass.new(@parent, @interface)
+      assert !@instance.changed?
+    end
+
+    should "be existing record" do
+      @instance = @klass.new(@parent, @interface)
+      assert !@instance.new_record?
+    end
+  end
+
+  context "instance methods" do
+    setup do
+      @klass.any_instance.stubs(:load_interface_attributes)
+
+      @parent = mock("parent")
+      @interface = mock("interface")
+      @instance = @klass.new(@parent, @interface)
+    end
+
+    context "saving" do
+      setup do
+        @vrdp_server = mock("vrdp_server")
+        @session = mock("session")
+        @machine = mock("machine")
+        @machine.stubs(:vrdp_server).returns(@vrdp_server)
+        @session.stubs(:machine).returns(@machine)
+        @parent.stubs(:with_open_session).yields(@session)
+      end
+
+      should "save the interface settings with the new bios settings" do
+        save_seq = sequence("save_seq")
+        @instance.expects(:save_changed_interface_attributes).with(@vrdp_server).once.in_sequence(save_seq)
+        @instance.save
+      end
+    end
+  end
+end