virtualbox 0.6.1 → 0.7.0

data/test/virtualbox/network_adapter_test.rb

@@ -98,6 +98,35 @@ class NetworkAdapterTest < Test::Unit::TestCase
       @instance = @klass.new(@parent, @interface)
     end
 
+    context "host interface object" do
+      setup do
+        @network_interfaces = []
+        @host = mock("host")
+        VirtualBox::Global.global.stubs(:host).returns(@host)
+        @host.stubs(:network_interfaces).returns(@network_interfaces)
+      end
+
+      def stub_interface(name)
+        interface = mock("interface")
+        interface.stubs(:name).returns(name)
+        @network_interfaces << interface
+        interface
+      end
+
+      should "return the network interface associated with the adapter" do
+        name = "foo"
+        result = stub_interface(name)
+        @instance.host_interface = name
+        assert_equal result, @instance.host_interface_object
+      end
+
+      should "return nil if the interface is not found" do
+        stub_interface("foo")
+        @instance.host_interface = "bar"
+        assert_nil @instance.host_interface_object
+      end
+    end
+
     context "saving" do
       setup do
         @adapter = mock("adapter")
@@ -157,4 +186,4 @@ class NetworkAdapterTest < Test::Unit::TestCase
       end
     end
   end
-end
+end

data/test/virtualbox/proxies/collection_test.rb

@@ -3,43 +3,85 @@ require File.join(File.dirname(__FILE__), '..', '..', 'test_helper')
 class CollectionTest < Test::Unit::TestCase
   setup do
     @parent = mock("parent")
-    @collection = VirtualBox::Proxies::Collection.new(@parent)
+    @item_klass = mock("item_klass")
+    @klass = VirtualBox::Proxies::Collection
+    @collection = @klass.new(@parent, @item_klass)
   end
 
   should "be a subclass of Array" do
     assert @collection.is_a?(Array)
   end
 
+  context "creating" do
+    should "call create on the item klass and put it in the array" do
+      result = mock("result")
+      @item_klass.expects(:create).with(@collection).returns(result)
+      @collection.create
+      assert @collection.include?(result)
+    end
+
+    should "pass in any additional arguments if given" do
+      blah = mock("some blah")
+      @collection = @klass.new(@parent, @item_klass, blah)
+      @item_klass.expects(:create).with(@collection, blah).returns(nil)
+      @collection.create
+    end
+
+    should "pass in additional arguments from the call" do
+      result = mock("result")
+      @item_klass.expects(:create).with(@collection, :foo).returns(result)
+      assert_equal result, @collection.create(:foo)
+    end
+
+    should "do nothing if klass doesn't respond to create" do
+      previous_length = @collection.length
+      assert_nothing_raised { assert_nil @collection.create }
+      assert_equal previous_length, @collection.length
+    end
+  end
+
   context "element callbacks" do
     setup do
       @item = mock("item")
     end
 
-    should "not call added_to_relationship if it doesn't exist" do
-      assert_nothing_raised { @collection << @item }
-    end
+    context "<<" do
+      should "not call added_to_relationship if it doesn't exist" do
+        assert_nothing_raised { @collection << @item }
+      end
 
-    should "not call removed_from_relationship if it doesn't exist" do
-      @collection << @item
-      assert_nothing_raised { @collection.delete(@item) }
+      should "call added_to_relationship on the item when its added to a collection" do
+        @item.expects(:added_to_relationship).with(@collection).once
+        @collection << @item
+      end
     end
 
-    should "call added_to_relationship on the item when its added to a collection" do
-      @item.expects(:added_to_relationship).with(@parent).once
-      @collection << @item
-    end
+    context "delete" do
+      should "not call removed_from_relationship if it doesn't exist" do
+        @collection << @item
+        assert_nothing_raised { @collection.delete(@item) }
+      end
+
+      should "call removed_from_relationship on the item when its deleted" do
+        @collection << @item
+        @item.expects(:removed_from_relationship).with(@collection).once
+        @collection.delete(@item)
+      end
 
-    should "call removed_from_relationship on the item when its deleted" do
-      @collection << @item
-      @item.expects(:removed_from_relationship).with(@parent).once
-      @collection.delete(@item)
+      should "not call removed_from_relationship if no_callback is set" do
+        @collection << @item
+        @item.expects(:removed_from_relationship).never
+        @collection.delete(@item, true)
+      end
     end
 
-    should "call removed_from_relationship if clear is called" do
-      @collection << @item
-      @item.expects(:removed_from_relationship).with(@parent).once
-      @collection.clear
-      assert @collection.empty?
+    context "clearing" do
+      should "call removed_from_relationship if clear is called" do
+        @collection << @item
+        @item.expects(:removed_from_relationship).with(@collection).once
+        @collection.clear
+        assert @collection.empty?
+      end
     end
   end
-end
+end

data/test/virtualbox/shared_folder_test.rb

@@ -9,8 +9,8 @@ class SharedFolderTest < Test::Unit::TestCase
 
   context "initializing" do
     should "load attributes from the machine" do
-      @klass.any_instance.expects(:initialize_attributes).with(@parent, @interface).once
-      @klass.new(@parent, @interface)
+      @klass.any_instance.expects(:initialize_attributes).with(@interface).once
+      @klass.new(@interface)
     end
 
     should "not load attributes if new record" do
@@ -27,21 +27,16 @@ class SharedFolderTest < Test::Unit::TestCase
 
     should "load interface attribtues" do
       @klass.any_instance.expects(:load_interface_attributes).with(@interface).once
-      @klass.new(@parent, @interface)
-    end
-
-    should "setup the parent" do
-      instance = @klass.new(@parent, @interface)
-      assert_equal @parent, instance.parent
+      @klass.new(@interface)
     end
 
     should "not be dirty" do
-      @instance = @klass.new(@parent, @interface)
+      @instance = @klass.new(@interface)
       assert !@instance.changed?
     end
 
     should "be existing record" do
-      @instance = @klass.new(@parent, @interface)
+      @instance = @klass.new(@interface)
       assert !@instance.new_record?
     end
   end
@@ -69,7 +64,7 @@ class SharedFolderTest < Test::Unit::TestCase
         new_seq = sequence("new_seq")
         @collection.each do |item|
           expected_value = "instance-#{item.inspect}"
-          @klass.expects(:new).with(nil, item).in_sequence(new_seq).returns(expected_value)
+          @klass.expects(:new).with(item).in_sequence(new_seq).returns(expected_value)
           expected_result << expected_value
         end
 
@@ -93,7 +88,9 @@ class SharedFolderTest < Test::Unit::TestCase
   context "instance methods" do
     setup do
       @klass.any_instance.stubs(:load_interface_attributes)
-      @instance = @klass.new(@parent, @interface)
+      @instance = @klass.new(@interface)
+      @collection = VirtualBox::Proxies::Collection.new(@parent)
+      @collection << @instance
 
       @parent_interface = mock("interface")
       @parent.stubs(:interface).returns(@parent_interface)
@@ -191,6 +188,12 @@ class SharedFolderTest < Test::Unit::TestCase
         @machine.stubs(:remove_shared_folder).with(@name)
       end
 
+      should "remove itself from it's collection" do
+        assert @collection.include?(@instance)
+        @instance.destroy
+        assert !@collection.include?(@instance)
+      end
+
       should "destroy the shared folder on the parent" do
         destroy_seq = sequence("destroy_seq")
         @machine.expects(:remove_shared_folder).with(@name).in_sequence(destroy_seq)
@@ -205,4 +208,4 @@ class SharedFolderTest < Test::Unit::TestCase
       end
     end
   end
-end
+end

data/test/virtualbox/snapshot_test.rb

@@ -0,0 +1,231 @@
+require File.join(File.dirname(__FILE__), '..', 'test_helper')
+
+class SnapshotTest < Test::Unit::TestCase
+  setup do
+    @klass = VirtualBox::Snapshot
+    @interface = mock("isnapshot")
+  end
+
+  context "class methods" do
+    context "populating relationships" do
+      setup do
+        @caller = mock("caller")
+      end
+
+      should "call populate_machine_relationship for VMs" do
+        vm = mock("vm")
+        vm.stubs(:is_a?).with(VirtualBox::COM::Util.versioned_interface(:Machine)).returns(true)
+        @klass.expects(:populate_machine_relationship).with(@caller, vm).once
+        @klass.populate_relationship(@caller, vm)
+      end
+
+      should "call populate_children_relationship for an array" do
+        @klass.expects(:populate_children_relationship).with(@caller, [1,2,3]).once
+        @klass.populate_relationship(@caller, [1,2,3])
+      end
+
+      should "call populate_parent_relationship for a snapshot" do
+        ss = mock("snapshot")
+        ss.stubs(:is_a?).returns(false)
+        ss.stubs(:is_a?).with(VirtualBox::COM::Util.versioned_interface(:Snapshot)).returns(true)
+        @klass.expects(:populate_parent_relationship).with(@caller, ss).once
+        @klass.populate_relationship(@caller, ss)
+      end
+
+      should "call populate_parent_relationship for nil" do
+        @klass.expects(:populate_parent_relationship).with(@caller, nil).once
+        @klass.populate_relationship(@caller, nil)
+      end
+    end
+
+    context "populating machine relationship" do
+      setup do
+        @caller = mock("caller")
+        @machine = mock("imachine")
+        @snapshot = mock("snapshot")
+        @machine.stubs(:current_snapshot).returns(@snapshot)
+      end
+
+      should "just initialize with machine" do
+        result = mock("result")
+        @klass.expects(:new).with(@snapshot).once.returns(result)
+        assert_equal result, @klass.populate_machine_relationship(@caller, @machine)
+      end
+
+      should "return nil if there is no current snapshot" do
+        @machine.expects(:current_snapshot).returns(nil)
+        assert_nil @klass.populate_machine_relationship(@caller, @machine)
+      end
+    end
+
+    context "populating parent relationship" do
+      setup do
+        @caller = mock("caller")
+        @parent = mock("parent")
+      end
+
+      should "just initialize with data" do
+        result = mock("result")
+        @klass.expects(:new).with(@parent).once.returns(result)
+        assert_equal result, @klass.populate_parent_relationship(@caller, @parent)
+      end
+
+      should "return nil if there is no parent" do
+        assert_nil @klass.populate_parent_relationship(@caller, nil)
+      end
+    end
+
+    context "populating children relationship" do
+      setup do
+        @instance = mock("instance")
+
+        @klass.stubs(:new).returns(@instance)
+      end
+
+      should "return a proxied collection" do
+        result = @klass.populate_children_relationship(nil, [])
+        assert result.is_a?(VirtualBox::Proxies::Collection)
+      end
+
+      should "call new for every machine" do
+        snapshots = []
+        5.times { |i| snapshots << mock("s#{i}") }
+
+        expected_result = []
+        new_seq = sequence("new_seq")
+        snapshots.each do |snapshot|
+          expected_value = "instance-#{snapshot.inspect}"
+          @klass.expects(:new).with(snapshot).in_sequence(new_seq).returns(expected_value)
+          expected_result << expected_value
+        end
+
+        assert_equal expected_result, @klass.populate_children_relationship(nil, snapshots)
+      end
+    end
+  end
+
+  context "initializing" do
+    should "load attributes from the snapshot" do
+      @klass.any_instance.expects(:initialize_attributes).with(@interface).once
+      @klass.new(@interface)
+    end
+
+    should "set the interface as the interface attribute" do
+      @klass.any_instance.stubs(:initialize_attributes)
+      instance = @klass.new(@interface)
+      assert_equal @interface, instance.interface
+    end
+  end
+
+  context "initializing attributes" do
+    setup do
+      @interface.stubs(:refresh_state)
+      @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(@interface)
+    end
+
+    should "not be dirty" do
+      @instance = @klass.new(@interface)
+      assert !@instance.changed?
+    end
+
+    should "be existing record" do
+      @instance = @klass.new(@interface)
+      assert !@instance.new_record?
+    end
+  end
+
+  context "with an instance" do
+    setup do
+      @klass.any_instance.stubs(:initialize_attributes)
+      @instance = @klass.new(@interface)
+    end
+
+    context "timestamp" do
+      setup do
+        @time = Time.at(Time.now.to_i, 0)
+        @timestamp = @time.to_i * 1000
+        @instance.stubs(:read_attribute).with(:time_stamp).returns(@timestamp)
+      end
+
+      should "convert to a Time object" do
+        assert @instance.time_stamp.is_a?(Time)
+      end
+
+      should "convert to a proper Time object" do
+        value = @instance.time_stamp
+        assert @time.eql?(value), "#{@time} != #{value}"
+      end
+    end
+
+    context "destroying" do
+      setup do
+        @machine = mock("machine")
+        @session = mock("session")
+        @console = mock("console")
+        @progress = mock("progress")
+        @uuid = "UUID!"
+
+        @instance.stubs(:uuid).returns(@uuid)
+        @instance.stubs(:machine).returns(@machine)
+        @machine.stubs(:with_open_session).yields(@session)
+        @session.stubs(:console).returns(@console)
+        @console.stubs(:delete_snapshot).returns(@progress)
+        @progress.stubs(:wait)
+      end
+
+      should "delete the proper snapshot" do
+        @console.expects(:delete_snapshot).with(@instance.uuid).once.returns(@progress)
+        @progress.expects(:wait)
+
+        @instance.destroy
+      end
+
+      should "pass in block to the wait method" do
+        foo = mock("foo")
+        @progress.expects(:wait).yields(foo)
+        foo.expects(:called).once
+
+        @instance.destroy do |obj|
+          obj.called
+        end
+      end
+    end
+
+    context "restoring" do
+      setup do
+        @machine = mock("machine")
+        @session = mock("session")
+        @console = mock("console")
+        @progress = mock("progress")
+
+        @instance.stubs(:machine).returns(@machine)
+        @machine.stubs(:with_open_session).yields(@session)
+        @session.stubs(:console).returns(@console)
+        @console.stubs(:restore_snapshot).returns(@progress)
+        @progress.stubs(:wait)
+      end
+
+      should "restore the proper snapshot" do
+        @console.expects(:restore_snapshot).with(@instance.interface).once.returns(@progress)
+        @progress.expects(:wait)
+
+        @instance.restore
+      end
+
+      should "pass in block to the wait method" do
+        foo = mock("foo")
+        @progress.expects(:wait).yields(foo)
+        foo.expects(:called).once
+
+        @instance.restore do |obj|
+          obj.called
+        end
+      end
+    end
+  end
+end

data/test/virtualbox/storage_controller_test.rb

@@ -16,7 +16,7 @@ class StorageControllerTest < Test::Unit::TestCase
       end
 
       should "populate array relationship if IMachine is given" do
-        @interface.expects(:is_a?).with(VirtualBox::COM::Interface::Machine).returns(true)
+        @interface.expects(:is_a?).with(VirtualBox::COM::Util.versioned_interface(:Machine)).returns(true)
         @klass.expects(:populate_array_relationship).once.with(@parent, @interface)
         @klass.populate_relationship(@parent, @interface)
       end

data/test/virtualbox/usb_controller_test.rb

@@ -16,6 +16,7 @@ class USBControllerTest < Test::Unit::TestCase
   context "initializing attributes" do
     setup do
       @klass.any_instance.stubs(:load_interface_attributes)
+      @klass.any_instance.stubs(:populate_relationships)
     end
 
     should "load interface attribtues" do
@@ -23,6 +24,11 @@ class USBControllerTest < Test::Unit::TestCase
       @klass.new(@parent, @interface)
     end
 
+    should "populate relationships" do
+      @klass.any_instance.expects(:populate_relationships).with(@interface).once
+      @klass.new(@parent, @interface)
+    end
+
     should "setup the parent" do
       instance = @klass.new(@parent, @interface)
       assert_equal @parent, instance.parent
@@ -82,6 +88,7 @@ class USBControllerTest < Test::Unit::TestCase
   context "instance methods" do
     setup do
       @klass.any_instance.stubs(:load_interface_attributes)
+      @klass.any_instance.stubs(:populate_relationship)
       @instance = @klass.new(@parent, @interface)
     end
 

data/test/virtualbox/usb_device_filter_test.rb

@@ -0,0 +1,93 @@
+require File.join(File.dirname(__FILE__), '..', 'test_helper')
+
+class USBDeviceFilterTestTest < Test::Unit::TestCase
+  setup do
+    @klass = VirtualBox::USBDeviceFilter
+    @interface = mock("interface")
+  end
+
+  context "class methods" do
+    context "populating relationships" do
+      setup do
+        @instance = mock("instance")
+
+        @interface.stubs(:device_filters).returns([])
+        @klass.stubs(:new).returns(@instance)
+      end
+
+      should "return a proxied collection" do
+        result = @klass.populate_relationship(nil, @interface)
+        assert result.is_a?(VirtualBox::Proxies::Collection)
+      end
+
+      should "call new for every interface" do
+        collection = []
+        @interface.stubs(:device_filters).returns(collection)
+        5.times { |i| collection << mock("a#{i}") }
+
+        expected_result = []
+        new_seq = sequence("new_seq")
+        collection.each do |item|
+          expected_value = "instance-#{item.inspect}"
+          @klass.expects(:new).with(item).in_sequence(new_seq).returns(expected_value)
+          expected_result << expected_value
+        end
+
+        assert_equal expected_result, @klass.populate_relationship(@parent, @interface)
+      end
+    end
+
+    context "saving relationship" do
+      setup do
+        @item = mock("item")
+      end
+
+      should "just call save on the item" do
+        @item.expects(:save)
+        @klass.save_relationship(nil, @item)
+      end
+    end
+  end
+
+  context "initializing" do
+    should "load attributes from the machine" do
+      @klass.any_instance.expects(:initialize_attributes).with(@interface).once
+      @klass.new(@interface)
+    end
+  end
+
+  context "initializing attributes" 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(@interface)
+    end
+
+    should "not be dirty" do
+      @instance = @klass.new(@interface)
+      assert !@instance.changed?
+    end
+
+    should "be existing record" do
+      @instance = @klass.new(@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(@interface)
+      @instance.stubs(:interface).returns(@interface)
+      @instance.stubs(:parent).returns(@parent)
+      @collection = VirtualBox::Proxies::Collection.new(@parent)
+      @collection << @instance
+    end
+  end
+end

data/test/virtualbox/version_test.rb

@@ -15,6 +15,18 @@ class VersionTest < Test::Unit::TestCase
     @module = VersionTestMod
   end
 
+  context "checking if supported version of VirtualBox" do
+    should "return true if version is not nil" do
+      @module.stubs(:version).returns(:foo)
+      assert @module.supported?
+    end
+
+    should "return false if version is nil" do
+      @module.stubs(:version).returns(nil)
+      assert !@module.supported?
+    end
+  end
+
   should "return the version" do
     version = mock("version")
     @vbox.expects(:version).returns(version)
@@ -31,4 +43,4 @@ class VersionTest < Test::Unit::TestCase
     @vbox.expects(:revision).returns(revision)
     assert_equal revision, @module.revision
   end
-end
+end