virtualbox 0.5.4 → 0.6.0

data/test/virtualbox/com/implementer/mscom_test.rb

@@ -0,0 +1,208 @@
+require File.join(File.dirname(__FILE__), '..', '..', '..', 'test_helper')
+
+class COMImplementerMSCOMTest < Test::Unit::TestCase
+  setup do
+    @klass = VirtualBox::COM::Implementer::MSCOM
+  end
+
+  context "initializing" do
+    setup do
+      @interface = mock("interface")
+      @lib = mock("lib")
+      @object = mock("object")
+    end
+
+    should "make the lib base and object accessible" do
+      instance = @klass.new(@interface, @lib, @object)
+      assert_equal @lib, instance.lib
+      assert_equal @object, instance.object
+    end
+  end
+
+  context "with an instance" do
+    setup do
+      @lib = mock("lib")
+      @object = mock("object")
+      @instance = @klass.new(@interface, @lib, @object)
+    end
+
+    context "spec to formal argument list" do
+      should "replace primitives with their types" do
+        assert_equal [7], @instance.spec_to_args([:int], [7])
+      end
+
+      should "replace booleans with 1/0" do
+        bool = VirtualBox::COM::T_BOOL
+        assert_equal [1,0], @instance.spec_to_args([bool, bool], [true, false])
+      end
+
+      should "convert interfaces with nil arguments to nil" do
+        spec = [:Machine]
+        args = [nil]
+
+        assert_equal [nil], @instance.spec_to_args(spec, args)
+      end
+
+      should "convert enums to their property indices" do
+        spec = [:FirmwareType]
+        args = [:efi]
+
+        assert_equal [1], @instance.spec_to_args(spec, args)
+      end
+
+      should "ignore out parameters" do
+        spec = [[:out, :hey], :int]
+        args = [7]
+
+        assert_equal [7], @instance.spec_to_args(spec, args)
+      end
+    end
+
+    context "reading a property" do
+      should "read the property on the object and return it" do
+        name = :foo_bar
+        value = mock("value")
+        result = mock("result")
+        opts = { :value_type => :foo }
+        @object.expects(:[]).with('FooBar').once.returns(value)
+        @instance.expects(:returnable_value).with(value, opts[:value_type]).returns(result)
+
+        assert_equal result, @instance.read_property(name, opts)
+      end
+    end
+
+    context "writing a property" do
+      should "convert the args and set it on the object" do
+        name = :foo_bar
+        opts = { :value_type => :foo }
+        @instance.expects(:spec_to_args).with([:foo], [:value]).returns([:modified])
+        @object.expects(:[]=).with('FooBar', :modified).once
+
+        @instance.write_property(name, :value, opts)
+      end
+    end
+
+    context "calling a function" do
+      should "send the method and args to the object and return the value" do
+        name = :foo_bar
+        args = [1,2,3]
+        formal_args = [4,5,6]
+        result = mock("result")
+        value = mock("value")
+        opts = { :value_type => :foo, :spec => :foo }
+        @object.expects(:send).with('FooBar', *formal_args).once.returns(value)
+        @instance.expects(:spec_to_args).with(opts[:spec], args).returns(formal_args)
+        @instance.expects(:returnable_value).with(value, opts[:value_type]).returns(result)
+
+        assert_equal result, @instance.call_function(name, args, opts)
+      end
+    end
+
+    context "returnable values" do
+      should "just return nil if type is nil" do
+        assert_nil @instance.returnable_value(7, nil)
+      end
+
+      should "just return nil if type is void" do
+        assert_nil @instance.returnable_value(7, :void)
+      end
+
+      should "infer the type then attempt to read that type" do
+        @instance.expects(:infer_type).with(:bar).returns([nil, :foo])
+        @instance.expects(:read_foo).with(7, :bar).once
+        @instance.returnable_value(7, :bar)
+      end
+
+      should "infer type and call array method for arrays" do
+        @instance.expects(:infer_type).with(:bar).returns([nil, :foo])
+        @instance.expects(:read_array_of_foo).with(7, [:bar]).once
+        @instance.returnable_value(7, [:bar])
+      end
+
+      should "return the value of the read method" do
+        result = mock("result")
+        @instance.expects(:infer_type).with(:bar).returns([nil, :foo])
+        @instance.expects(:read_foo).with(7, :bar).once.returns(result)
+        assert_equal result, @instance.returnable_value(7, :bar)
+      end
+    end
+
+    context "reading primitive values" do
+      # Yes, it typically avoid meta-programming, but this is such a
+      # repetitive and simple case that I am doing it
+      [:ushort, :uint, :ulong, :int, :long].each do |prim|
+        should "read #{prim} and convert to int" do
+          assert_equal 7, @instance.send("read_#{prim}".to_sym, "7", prim)
+        end
+      end
+
+      should "return strings as is" do
+        assert_equal "foo", @instance.read_unicode_string("foo", :unicode_string)
+      end
+
+      should "read char as a boolean value" do
+        assert_equal true, @instance.read_char('1', :char)
+        assert_equal false, @instance.read_char('0', :char)
+        assert_equal true, @instance.read_char(1, :char)
+        assert_equal false, @instance.read_char(0, :char)
+      end
+    end
+
+    context "reading enums" do
+      setup do
+        @interface_klass = mock("klass")
+
+        @type = :foo
+        @value = :bar
+        @result = mock("result")
+      end
+
+      should "index the value on the interface class" do
+        @instance.expects(:interface_klass).with(@type).returns(@interface_klass)
+        @interface_klass.expects(:[]).with(@value).returns(@result)
+
+        assert_equal @result, @instance.read_enum(@value, @type)
+      end
+    end
+
+    context "reading interfaces" do
+      setup do
+        @interface_klass = mock("klass")
+
+        @type = :foo
+        @value = :bar
+        @result = mock("result")
+      end
+
+      should "instantiate the klass properly" do
+        @instance.expects(:interface_klass).with(@type).returns(@interface_klass)
+        @interface_klass.expects(:new).with(@instance.class, @instance.lib, @value).returns(@result)
+
+        assert_equal @result, @instance.read_interface(@value, @type)
+      end
+    end
+
+    context "reading an array of strings" do
+      should "just return as is" do
+        assert_equal ["foo", "bar"], @instance.read_array_of_unicode_string(["foo", "bar"], :unicode_string)
+      end
+    end
+
+    context "read array of interface" do
+      setup do
+        @interface_klass = mock("klass")
+
+        @type = :foo
+        @value = [:foo, nil]
+        @result = mock("result")
+      end
+
+      should "instantiate the klass properly for non-nil values" do
+        @instance.expects(:interface_klass).with(@type).returns(@interface_klass)
+        @interface_klass.expects(:new).with(@instance.class, @instance.lib, @value[0]).returns(@result)
+
+        assert_equal [@result, nil], @instance.read_array_of_interface(@value, [@type])
+      end
+    end
+  end
+end

data/test/virtualbox/com/mscom_interface_test.rb

@@ -0,0 +1,17 @@
+require File.join(File.dirname(__FILE__), '..', '..', 'test_helper')
+
+class COMMSCOMInterfaceBaseTest < Test::Unit::TestCase
+  setup do
+    @klass = VirtualBox::COM::MSCOMInterface
+  end
+  context "initialization" do
+    should "initialize MSCOM interface" do
+      @klass.any_instance.expects(:initialize_mscom).once
+      @klass.new
+    end
+  end
+
+  context "initializing mscom interface" do
+    # TODO
+  end
+end

data/test/virtualbox/com/util_test.rb

@@ -0,0 +1,17 @@
+require File.join(File.dirname(__FILE__), '..', '..', 'test_helper')
+
+class COMUtilTest < Test::Unit::TestCase
+  setup do
+    @klass = VirtualBox::COM::Util
+  end
+
+  context "checking for interfaces" do
+    should "return true for existing interfaces" do
+      assert @klass.interface?(:VirtualBox)
+    end
+
+    should "return false for non-existing interfaces" do
+      assert !@klass.interface?(:IDontExist)
+    end
+  end
+end

data/test/virtualbox/dvd_test.rb

@@ -2,51 +2,12 @@ require File.join(File.dirname(__FILE__), '..', 'test_helper')
 
 class DVDTest < Test::Unit::TestCase
   setup do
-    VirtualBox::Command.stubs(:execute)
+    @klass = VirtualBox::DVD
   end
 
-  context "destroying a dvd" do
-    setup do
-      @dvd = VirtualBox::DVD.new
-      VirtualBox::DVD.reloaded!
-    end
-
-    should "return false if attempting to destroy an empty drive" do
-      assert !VirtualBox::DVD.empty_drive.destroy
-    end
-
-    should "call vboxmanage to destroy it" do
-      VirtualBox::Command.expects(:vboxmanage).with("closemedium", "dvd", @dvd.uuid, "--delete")
-      assert @dvd.destroy
-    end
-
-    should "return false if destroy failed" do
-      VirtualBox::Command.stubs(:vboxmanage).raises(VirtualBox::Exceptions::CommandFailedException)
-      assert !@dvd.destroy
-    end
-
-    should "raise an exception if failed and flag is set" do
-      VirtualBox::Command.stubs(:vboxmanage).raises(VirtualBox::Exceptions::CommandFailedException)
-      assert_raises(VirtualBox::Exceptions::CommandFailedException) {
-        @dvd.destroy(true)
-      }
-    end
-
-    should "mark the global class for reloading" do
-      VirtualBox::Global.expects(:reload!)
-      assert @dvd.destroy
-    end
-  end
-
-  context "empty drive" do
-    should "return an empty drive instance by calling new with :empty_drive" do
-      dvd = VirtualBox::DVD.new(:empty_drive)
-      assert dvd.empty_drive?
-    end
-
-    should "call new with :empty_drive with empty_drive class method" do
-      dvd = VirtualBox::DVD.empty_drive
-      assert dvd.empty_drive?
+  context "device type" do
+    should "be :dvd" do
+      assert_equal :dvd, @klass.device_type
     end
   end
 
@@ -64,56 +25,4 @@ class DVDTest < Test::Unit::TestCase
       assert result.is_a?(Array)
     end
   end
-
-  context "retrieving all dvds by command" do
-      setup do
-        @expectations = {
-          "d3252617-8176-4f8c-9d73-1c9c82b23960" => {
-            :location   => "/Users/mitchellh/Downloads/jeos-8.04.3-jeos-i386.iso",
-            :accessible => "yes"
-          },
-
-          "4a08f52c-bca3-4908-8da4-4f48aaa4ebba" => {
-            :location   => "/Applications/VirtualBox.app/Contents/MacOS/VBoxGuestAdditions.iso",
-            :accessible => "yes"
-          }
-        }
-
-        @valid = <<-valid
-UUID:       d3252617-8176-4f8c-9d73-1c9c82b23960
-Path:       /Users/mitchellh/Downloads/jeos-8.04.3-jeos-i386.iso
-Accessible: yes
-
-UUID:       4a08f52c-bca3-4908-8da4-4f48aaa4ebba
-Path:       /Applications/VirtualBox.app/Contents/MacOS/VBoxGuestAdditions.iso
-Accessible: yes
-Usage:      TestJeOS (UUID: 3d0f87b4-50f7-4fc5-ad89-93375b1b32a3)
-valid
-
-        VirtualBox::Command.expects(:vboxmanage).with("list", "dvds").returns(@valid).once
-      end
-
-      should "return an array of DVD objects" do
-        result = VirtualBox::DVD.all_from_command
-        assert result.is_a?(Array)
-        assert_equal @expectations.length, result.length
-
-        result.each { |v| assert v.is_a?(VirtualBox::DVD) }
-      end
-
-      should "return the proper results" do
-        result = VirtualBox::DVD.all_from_command
-        assert result.is_a?(Array)
-        assert_equal @expectations.length, result.length
-
-        result.each do |image|
-          expected_image = @expectations[image.uuid]
-          assert expected_image
-
-          expected_image.each do |k,v|
-            assert_equal v, image.read_attribute(k)
-          end
-        end
-      end
-    end
 end

data/test/virtualbox/ext/platform_test.rb

@@ -28,6 +28,14 @@ class PlatformTest < Test::Unit::TestCase
         assert VirtualBox::Platform.windows?
       end
     end
+
+    should "return true if it contains cygwin" do
+      success = ["i386-cygwin", "i686-cygwin64", "cygwin"]
+      success.each do |item|
+        VirtualBox::Platform.stubs(:platform).returns(item)
+        assert VirtualBox::Platform.windows?
+      end
+    end
   end
 
   context "linux" do

data/test/virtualbox/extra_data_test.rb

@@ -2,38 +2,13 @@ require File.join(File.dirname(__FILE__), '..', 'test_helper')
 
 class ExtraDataTest < Test::Unit::TestCase
   setup do
-    @raw = <<-raw
-.
-Key: GUI/LastVMSelected, Value: 02573b8e-f628-43ed-b688-e488414e07ac
-Key: GUI/LastWindowPostion, Value: 99,457,770,550
-Key: GUI/SUNOnlineData, Value: triesLeft=0
-Key: GUI/SuppressMessages, Value: ,confirmInputCapture,remindAboutAutoCapture,confirmRemoveMedium,remindAboutInaccessibleMedia,confirmGoingFullscreen,remindAboutMouseIntegrationOn
-Key: GUI/UpdateCheckCount, Value: 13
-Key: GUI/UpdateDate, Value: 1 d, 2010-01-29, stable
-raw
-
-    VirtualBox::Command.stubs(:execute)
-
-    @ed = VirtualBox::ExtraData.new
+    @parent = mock("parent")
+    @interface = mock("interface")
+    @ed = VirtualBox::ExtraData.new(@parent, @interface)
     @ed["foo"] = "bar"
     @ed.clear_dirty!
   end
 
-  context "attributes" do
-    should "return parent name if its a VM object" do
-      vm = mock("vm")
-      vm.stubs(:is_a?).with(VirtualBox::VM).returns(true)
-      vm.stubs(:name).returns("FOO")
-
-      @ed.parent = vm
-      assert_equal "FOO", @ed.parent_name
-    end
-
-    should "return default otherwise" do
-      assert_equal "global", @ed.parent_name
-    end
-  end
-
   context "relationships" do
     setup do
       @caller = mock("caller")
@@ -41,10 +16,35 @@ raw
     end
 
     context "populating" do
+      setup do
+        @interface = mock("interface")
+        @interface.stubs(:get_extra_data_keys).returns([])
+      end
+
       should "return a ExtraData object" do
-        result = VirtualBox::ExtraData.populate_relationship(@caller, mock_xml_doc)
+        result = VirtualBox::ExtraData.populate_relationship(@caller, @interface)
         assert result.is_a?(VirtualBox::ExtraData)
       end
+
+      should "not be dirty" do
+        result = VirtualBox::ExtraData.populate_relationship(@caller, @interface)
+        assert !result.changed?
+      end
+
+      should "add the value of each key to the ED hash" do
+        expected_hash = { :a => 1, :b => 2, :c => 4 }
+        @interface.expects(:get_extra_data_keys).returns(expected_hash.keys)
+
+        expected_hash.each do |k, v|
+          @interface.expects(:get_extra_data).with(k).returns(v)
+        end
+
+        result = VirtualBox::ExtraData.populate_relationship(@caller, @interface)
+        assert_equal expected_hash.length, result.length
+        result.each do |k, v|
+          assert_equal expected_hash[k], v
+        end
+      end
     end
 
     context "saving" do
@@ -57,75 +57,9 @@ raw
     end
   end
 
-  context "destroying (deleting)" do
-    setup do
-      @key = "foo"
-    end
-
-    should "call the proper vbox command" do
-      VirtualBox::Command.expects(:vboxmanage).with("setextradata", "global", "foo")
-      assert @ed.delete(@key)
-    end
-
-    should "remove the key from the hash" do
-      assert @ed.has_key?(@key)
-      assert @ed.delete(@key)
-      assert !@ed.has_key?(@key)
-    end
-
-    should "raise an exception if true sent to save and error occured" do
-      VirtualBox::Command.stubs(:vboxmanage).raises(VirtualBox::Exceptions::CommandFailedException)
-      assert_raises(VirtualBox::Exceptions::CommandFailedException) {
-        @ed.delete(@key, true)
-      }
-    end
-
-    should "return false if the command failed" do
-      VirtualBox::Command.stubs(:vboxmanage).raises(VirtualBox::Exceptions::CommandFailedException)
-      assert !@ed.delete(@key)
-    end
-  end
-
-  context "saving" do
-    setup do
-      @ed["foo"] = "BAR"
-      assert @ed.changed?
-    end
-
-    should "do nothing if there are no changes" do
-      @ed.clear_dirty!
-      VirtualBox::Command.expects(:vboxmanage).never
-      assert @ed.save
-    end
-
-    should "call the proper vbox command" do
-      VirtualBox::Command.expects(:vboxmanage).with("setextradata", "global", "foo", "BAR")
-      assert @ed.save
-    end
-
-    should "return false if the command failed" do
-      VirtualBox::Command.stubs(:vboxmanage).raises(VirtualBox::Exceptions::CommandFailedException)
-      assert !@ed.save
-    end
-
-    should "raise an exception if true sent to save and error occured" do
-      VirtualBox::Command.stubs(:vboxmanage).raises(VirtualBox::Exceptions::CommandFailedException)
-      assert_raises(VirtualBox::Exceptions::CommandFailedException) {
-        @ed.save(true)
-      }
-    end
-
-    should "clear dirty state" do
-      @ed["value"] = "rawr"
-      assert @ed.changed?
-      assert @ed.save
-      assert !@ed.changed?
-    end
-  end
-
   context "setting dirty state" do
     setup do
-      @ed = VirtualBox::ExtraData.new
+      @ed = VirtualBox::ExtraData.new(@parent, @interface)
     end
 
     should "not be dirty initially" do
@@ -135,7 +69,7 @@ raw
     should "be dirty when setting a value" do
       @ed["foo"] = "bar"
       assert @ed.changed?
-      assert @ed.changes.has_key?("foo")
+      assert @ed.changes.has_key?(:foo)
     end
   end
 
@@ -165,14 +99,56 @@ raw
   end
 
   context "constructor" do
-    should "set the parent with the given argument" do
-      ed = VirtualBox::ExtraData.new("JOEY")
+    should "set the parent and interface with the given argument" do
+      ed = VirtualBox::ExtraData.new("JOEY", @interface)
       assert_equal "JOEY", ed.parent
+      assert_equal @interface, ed.interface
     end
+  end
+
+  context "saving extra data" do
+    setup do
+      @interface.stubs(:set_extra_data)
+    end
+
+    should "only save changed keys" do
+      @interface.expects(:set_extra_data).never
+      @interface.expects(:set_extra_data).with("bar", "baz").once
+
+      @ed["bar"] = "baz"
+      @ed.save
+    end
+
+    should "convert values to strings" do
+      @interface.expects(:set_extra_data).never
+      @interface.expects(:set_extra_data).with("bar", "7").once
+
+      @ed["bar"] = 7
+      @ed.save
+    end
+
+    should "clear the dirty status of keys" do
+      @ed["bar"] = "baz"
+      assert @ed.bar_changed?
+      @ed.save
+      assert !@ed.bar_changed?
+    end
+
+    should "remove nil keys from the hash" do
+      @ed["bar"] = "baz"
+      @ed.save
+      @ed["bar"] = nil
+      assert @ed.bar_changed?
+      @ed.save
+      assert !@ed.keys.include?("bar")
+    end
+  end
 
-    should "be global by default" do
-      ed = VirtualBox::ExtraData.new
-      assert_equal "global", ed.parent
+  context "deleteting extra data" do
+    should "call set its value to nil" do
+      key = :foo
+      @ed.expects(:[]=).with(key, nil).once
+      @ed.delete(key)
     end
   end
 end