virtualbox 0.6.1 → 0.7.0

data/test/virtualbox/abstract_model/validatable_test.rb

@@ -38,6 +38,17 @@ class ValidatableTest < Test::Unit::TestCase
       @model.clear_errors
       assert @model.errors.empty?
     end
+
+    should "be able to get full error messages" do
+      @model.add_error(:foo, "should be bar.")
+      assert_equal ['Foo should be bar.'], @model.full_error_messages
+    end
+
+    should "be able to get the errors on a specific field" do
+      @model.add_error(:foo, "an error.")
+      assert @model.errors_on(:bar).nil?
+      assert @model.errors_on(:foo)
+    end
   end
 
   context "validity" do
@@ -64,6 +75,30 @@ class ValidatableTest < Test::Unit::TestCase
     end
   end
 
+  context "extracting options hash from multi-param functions" do
+    setup do
+      @model = ValidatableModel.new
+    end
+
+    should "modify the initial fields array" do
+      fields = [{}]
+      @model.__validates_extract_options(fields, {})
+      assert fields.empty?
+    end
+
+    should "not modify the initial fields array if not a hash at the end" do
+      fields = [:foo]
+      @model.__validates_extract_options(fields, {})
+      assert_equal [:foo], fields
+    end
+
+    should "return the defaults hash merged with the given options" do
+      fields = [{ :foo => :bar }]
+      result = @model.__validates_extract_options(fields, { :foo => 0, :bar => :baz })
+      assert_equal({ :foo => :bar, :bar => :baz }, result)
+    end
+  end
+
   context "specific validations" do
     setup do
       @model = ValidatableModel.new
@@ -94,7 +129,7 @@ class ValidatableTest < Test::Unit::TestCase
 
       should "validate multiple fields" do
         @model.bars = nil
-        @model.validates_presence_of([:foos, :bars])
+        @model.validates_presence_of(:foos, :bars)
 
         assert !@model.valid?
         assert @model.errors[:bars]
@@ -112,13 +147,161 @@ class ValidatableTest < Test::Unit::TestCase
 
       should "return false if any are invalid on multiple fields" do
         @model.bars = nil
-        assert !@model.validates_presence_of([:foos, :bars])
+        assert !@model.validates_presence_of(:foos, :bars)
       end
 
       should "return true if all fields are valid" do
         @model.foos = "foo"
         @model.bars = "bar"
-        assert @model.validates_presence_of([:foos, :bars])
+        assert @model.validates_presence_of(:foos, :bars)
+      end
+
+      should "add error message if invalid" do
+        @model.foos = nil
+        assert !@model.validates_presence_of(:foos)
+        assert_equal "can't be blank.", @model.errors[:foos].first
+      end
+
+      should "use custom error message if given" do
+        @model.foos = nil
+        assert !@model.validates_presence_of(:foos, :message => "can't be nil.")
+        assert_equal "can't be nil.", @model.errors[:foos].first
+      end
+    end
+
+    context "validates_format_of" do
+      setup do
+        @model.foos = "foo"
+        @model.bars = "bar"
+      end
+
+      should "not add an error if formatted properly" do
+        @model.validates_format_of(:foos, :with => /^foo$/)
+        assert @model.valid?
+      end
+
+      should "add an error if not formatted properly" do
+        @model.validates_format_of(:bars, :with => /^foo$/)
+        assert !@model.valid?
+      end
+
+      should "not add an error for a nil field" do
+        @model.foos = nil
+        @model.validates_format_of(:foos, :with => /^foo$/)
+        assert @model.valid?
+      end
+
+      should "validate multiple fields" do
+        @model.validates_format_of(:foos, :bars, :with => /^foo$/)
+        assert !@model.valid?
+        assert @model.errors[:bars]
+      end
+
+      should "return false on invalid" do
+        assert !@model.validates_format_of(:bars, :with => /^foo$/)
+      end
+
+      should "return true on valid" do
+        assert @model.validates_format_of(:foos, :with => /^foo$/)
+      end
+
+      should "return false if any are invalid on multiple fields" do
+        assert !@model.validates_format_of(:foos, :bars, :with => /^foo$/)
+      end
+
+      should "return true if all fields are valid" do
+        assert @model.validates_format_of(:foos, :bars, :with => /^\w+$/)
+      end
+    end
+
+    context "validates_numericality_of" do
+      setup do
+        @model.foos = 1
+        @model.bars = "1"
+      end
+
+      should "not add an error if a number" do
+        @model.validates_numericality_of(:foos)
+        assert @model.valid?
+      end
+
+      should "add an error if not a number" do
+        @model.validates_numericality_of(:bars)
+        assert !@model.valid?
+      end
+
+      should "not add an error for a nil field" do
+        @model.foos = nil
+        @model.validates_numericality_of(:foos)
+        assert @model.valid?
+      end
+
+      should "validate multiple fields" do
+        @model.validates_numericality_of(:foos, :bars)
+        assert !@model.valid?
+        assert @model.errors[:bars]
+      end
+
+      should "return false on invalid" do
+        assert !@model.validates_numericality_of(:bars)
+      end
+
+      should "return true on valid" do
+        assert @model.validates_numericality_of(:foos)
+      end
+
+      should "return false if any are invalid on multiple fields" do
+        assert !@model.validates_numericality_of(:foos, :bars)
+      end
+
+      should "return true if all fields are valid" do
+        @model.bars = 2
+        assert @model.validates_numericality_of(:foos, :bars)
+      end
+    end
+
+    context "validates_inclusion_of" do
+      setup do
+        @model.foos = 1
+        @model.bars = 2
+      end
+
+      should "not add an error if value is included" do
+        @model.validates_inclusion_of(:foos, :in => [1])
+        assert @model.valid?
+      end
+
+      should "add an error if value is not included" do
+        @model.validates_inclusion_of(:bars, :in => [1])
+        assert !@model.valid?
+      end
+
+      should "not add an error for a nil field" do
+        @model.foos = nil
+        @model.validates_inclusion_of(:foos, :in => [1,2])
+        assert @model.valid?
+      end
+
+      should "validate multiple fields" do
+        @model.validates_inclusion_of(:foos, :bars, :in => [1,3])
+        assert !@model.valid?
+        assert @model.errors[:bars]
+      end
+
+      should "return false on invalid" do
+        assert !@model.validates_inclusion_of(:bars, :in => [1])
+      end
+
+      should "return true on valid" do
+        assert @model.validates_inclusion_of(:foos, :in => [1])
+      end
+
+      should "return false if any are invalid on multiple fields" do
+        assert !@model.validates_inclusion_of(:foos, :bars, :in => [1,3])
+      end
+
+      should "return true if all fields are valid" do
+        assert @model.validates_inclusion_of(:foos, :bars, :in => [1,2])
       end
     end
   end

data/test/virtualbox/abstract_model_test.rb

@@ -111,8 +111,8 @@ class AbstractModelTest < Test::Unit::TestCase
     end
 
     should "turn attributes which are AbstractInterfaces into classes" do
-      @model.foo = VirtualBox::COM::Interface::VirtualBox.new(VirtualBox::COM::Implementer::Nil)
-      assert_equal "#<AbstractModelTest::FakeModel :bar=nil, :bars=..., :foo=#<VirtualBox::COM::Interface::VirtualBox>, :foos=...>", @model.inspect
+      @model.foo = VirtualBox::COM::Util.versioned_interface(:VirtualBox).new(VirtualBox::COM::Implementer::Nil, nil)
+      assert_equal "#<AbstractModelTest::FakeModel :bar=nil, :bars=..., :foo=#<VirtualBox::COM::Interface::Version_3_1_X::VirtualBox>, :foos=...>", @model.inspect
     end
   end
 
@@ -400,4 +400,4 @@ class AbstractModelTest < Test::Unit::TestCase
       @model.write_attribute(:foo, "foo2")
     end
   end
-end
+end

data/test/virtualbox/appliance_test.rb

@@ -147,6 +147,13 @@ class ApplianceTest < Test::Unit::TestCase
         @machine_interface.expects(:export).with(@interface).once
         @instance.add_machine(@machine)
       end
+
+      should "add to the description for each option given" do
+        sys = mock("sys")
+        @machine_interface.expects(:export).with(@interface).once.returns(sys)
+        sys.expects(:add_description).with(:foo, :bar, :bar)
+        @instance.add_machine(@machine, { :foo => :bar })
+      end
     end
   end
-end
+end

data/test/virtualbox/com/abstract_enum_test.rb

@@ -12,6 +12,7 @@ class COMAbstractEnumTest < Test::Unit::TestCase
       assert_equal :a, @enum[0]
       assert_equal :b, @enum[1]
       assert_equal :c, @enum[2]
+      assert_equal [:a, :b, :c], @enum.map
     end
 
     should "do the reverse mapping of value to index" do

data/test/virtualbox/com/abstract_implementer_test.rb

@@ -4,18 +4,19 @@ class AbstractImplementerTest < Test::Unit::TestCase
   setup do
     @klass = VirtualBox::COM::AbstractImplementer
     @interface = mock("interface")
+    @lib = mock("lib")
   end
 
   context "initialization" do
     should "make the interface accessible" do
-      instance = @klass.new(@interface)
+      instance = @klass.new(@interface, @lib)
       assert_equal @interface, instance.interface
     end
   end
 
   context "base methods" do
     setup do
-      @instance = @klass.new(@interface)
+      @instance = @klass.new(@interface, @lib)
     end
 
     should "implement the read_property function" do
@@ -36,4 +37,4 @@ class AbstractImplementerTest < Test::Unit::TestCase
       }
     end
   end
-end
+end

data/test/virtualbox/com/abstract_interface_test.rb

@@ -91,7 +91,8 @@ class AbstractInterfaceTest < Test::Unit::TestCase
 
   context "instance methods" do
     setup do
-      @interface = BasicAITest.new(@impl)
+      @lib = VirtualBox::COM::NilInterface.new
+      @interface = BasicAITest.new(@impl, @lib)
     end
 
     context "checking for property existence" do
@@ -136,4 +137,4 @@ class AbstractInterfaceTest < Test::Unit::TestCase
       end
     end
   end
-end
+end

data/test/virtualbox/com/ffi/interface_test.rb

@@ -10,13 +10,13 @@ class COMFFIInterfaceTest < Test::Unit::TestCase
   context "specifying a com interface" do
     setup do
       @com_interface = mock("com_interface")
-      VirtualBox::COM::Interface.stubs(:const_get).returns(@com_interface)
+      VirtualBox::COM::Util.stubs(:versioned_interface).returns(@com_interface)
       @klass.stubs(:define_vtbl_parent_for_interface)
       @klass.stubs(:define_vtbl_for_interface)
     end
 
     should "get the interface with respect to the COM interfaces" do
-      VirtualBox::COM::Interface.expects(:const_get).with(@interface).returns(@com_interface)
+      VirtualBox::COM::Util.expects(:versioned_interface).with(@interface).returns(@com_interface)
       @klass.com_interface(@interface, @parent)
     end
 
@@ -94,7 +94,7 @@ class COMFFIInterfaceTest < Test::Unit::TestCase
     should "get the class in the context of the FFI namespace" do
       name = :foo
       klass = mock("klass")
-      Object.expects(:module_eval).with("::VirtualBox::COM::FFI::#{name}::Vtbl").returns(klass)
+      Object.expects(:module_eval).with("::VirtualBox::COM::FFI::#{VirtualBox::COM::Util.version_const}::#{name}::Vtbl").returns(klass)
       @klass.layout_args.expects(:<<).with([:superklass, klass])
       @klass.define_interface_parent(name)
     end
@@ -228,7 +228,7 @@ class COMFFIInterfaceTest < Test::Unit::TestCase
   context "initializing vtbl" do
     setup do
       @pointer = mock("pointer")
-      @klass = VirtualBox::COM::FFI::VirtualBox
+      @klass = VirtualBox::COM::FFI::Util.versioned_interface(:VirtualBox)
     end
 
     should "initialize the VtblParent then the Vtbl" do

data/test/virtualbox/com/ffi/util_test.rb

@@ -5,6 +5,26 @@ class COMFFIUtilTest < Test::Unit::TestCase
     @klass = VirtualBox::COM::FFI::Util
   end
 
+  context "interface class" do
+    should "return the result from getting from the COM util" do
+      interface = mock("interface")
+      result = mock("result")
+      VirtualBox::COM::Util.expects(:versioned_interface).with(interface).returns(result)
+      assert_equal result, @klass.interface_klass(interface)
+    end
+  end
+
+  context "versioned interface" do
+    should "get the current FFI interface associated with the current version" do
+      result = mock("result")
+      version_module = mock("vmod")
+      interface = mock("interface")
+      VirtualBox::COM::FFI.expects(:const_get).with(::VirtualBox::COM::Util.version_const).returns(version_module)
+      version_module.expects(:const_get).with(interface).returns(result)
+      assert_equal result, @klass.versioned_interface(interface)
+    end
+  end
+
   context "converting function specs to FFI parameter lists" do
     def assert_spec(spec, expected)
       result = @klass.spec_to_ffi(spec)
@@ -75,7 +95,9 @@ class COMFFIUtilTest < Test::Unit::TestCase
         "ip_address" => "IPAddress",
         "max_vdi_size" => "MaxVDISize",
         "cpu_count" => "CPUCount",
-        "recommended_hdd" => "RecommendedHDD"
+        "recommended_hdd" => "RecommendedHDD",
+        "rtc_use_utc" => "RTCUseUTC",
+        "use_host_io_cache" => "UseHostIOCache"
       }
 
       tests.each do |arg, expected|

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

@@ -4,11 +4,12 @@ class COMImplementerBaseTest < Test::Unit::TestCase
   setup do
     @klass = VirtualBox::COM::Implementer::Base
     @interface = mock("interface")
+    @lib = mock("lib")
   end
 
   context "with an instance" do
     setup do
-      @instance = @klass.new(@interface)
+      @instance = @klass.new(@interface, @lib)
     end
 
     context "inferring types" do
@@ -29,9 +30,9 @@ class COMImplementerBaseTest < Test::Unit::TestCase
       should "get from COM::Interface and return" do
         result = mock("result")
         type_name = :foo
-        VirtualBox::COM::Interface.expects(:const_get).with(type_name).returns(result)
+        VirtualBox::COM::FFI::Util.expects(:interface_klass).with(type_name).returns(result)
         assert_equal result, @instance.interface_klass(type_name)
       end
     end
   end
-end
+end

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

@@ -8,7 +8,7 @@ class COMImplementerFFITest < Test::Unit::TestCase
   context "initializing" do
     setup do
       @interface = mock("interface")
-      @interface.stubs(:class).returns(VirtualBox::COM::Interface::Session)
+      @interface.stubs(:class).returns(VirtualBox::COM::Util.versioned_interface(:Session))
 
       @ffi = mock("ffi")
 
@@ -17,7 +17,7 @@ class COMImplementerFFITest < Test::Unit::TestCase
 
     should "initialize the FFI interface associated with the AbstractInterface" do
       result = mock("result")
-      VirtualBox::COM::FFI::Session.expects(:new).with(@pointer).once.returns(result)
+      VirtualBox::COM::FFI::Util.versioned_interface(:Session).expects(:new).with(@pointer).once.returns(result)
       instance = @klass.new(@interface, @ffi, @pointer)
       assert_equal result, instance.ffi_interface
     end
@@ -79,8 +79,7 @@ class COMImplementerFFITest < Test::Unit::TestCase
         @formal = [:foo]
 
         @instance.expects(:spec_to_args).with(@spec, @args).returns(@formal)
-        @vtbl.expects(:[]).with(@name).returns(@proc)
-        @instance.expects(:call_and_check).with(@proc, @vtbl_parent, *@formal)
+        @instance.expects(:call_and_check).with(@name, @vtbl_parent, *@formal)
         @instance.expects(:values_from_formal_args).with(@spec, @formal).returns(result)
         assert_equal result, @instance.call_vtbl_function(@name, @spec, @args)
       end
@@ -90,33 +89,37 @@ class COMImplementerFFITest < Test::Unit::TestCase
       setup do
         @function = mock("function")
         @function.stubs(:call).returns(0)
+
+        @name = :foo
+        @vtbl = { @name => @function}
+        @ffi_interface.stubs(:vtbl).returns(@vtbl)
       end
 
       should "raise an exception if an error occurred" do
         @function.expects(:call).returns(0x8000_4002)
         assert_raises(VirtualBox::Exceptions::FFIException) {
-          @instance.call_and_check(@function)
+          @instance.call_and_check(@name)
         }
       end
 
       should "not raise an exception if an error did not occur" do
         @function.expects(:call).returns(0x0000_0000)
         assert_nothing_raised {
-          @instance.call_and_check(@function)
+          @instance.call_and_check(@name)
         }
       end
 
       should "not raise an exception for NS_ERROR_NOT_IMPLEMENTED" do
         @function.expects(:call).returns(0x8000_4001)
         assert_nothing_raised {
-          @instance.call_and_check(@function)
+          @instance.call_and_check(@name)
         }
       end
 
       should "forward arguments" do
         @function.expects(:call).with(1,2,3).returns(0)
         assert_nothing_raised {
-          @instance.call_and_check(@function, 1, 2, 3)
+          @instance.call_and_check(@name, 1, 2, 3)
         }
       end
     end
@@ -173,7 +176,12 @@ class COMImplementerFFITest < Test::Unit::TestCase
         assert_equal [1], @instance.spec_to_args(spec, args)
       end
 
-      should "replace array types with two parameters" do
+      should "replace in array types with two parameters" do
+        @array = [true, false, false]
+        assert_equal [@array.length, [1, 0, 0]], @instance.spec_to_args([[VirtualBox::COM::T_BOOL]], [@array])
+      end
+
+      should "replace out array types with two parameters" do
         @counter_pointer = mock("count_pointer")
         @pointer = mock("pointer")
 
@@ -516,4 +524,4 @@ class COMImplementerFFITest < Test::Unit::TestCase
       end
     end
   end
-end
+end

data/test/virtualbox/cpu_test.rb

@@ -0,0 +1,103 @@
+require File.join(File.dirname(__FILE__), '..', 'test_helper')
+
+class CPUTest < Test::Unit::TestCase
+  setup do
+    @klass = VirtualBox::CPU
+    @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)
+      end
+
+      should "call new for the interface" do
+        @klass.expects(:new).with(nil, @interface).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 "getting a property" do
+      setup do
+        @key = :foo
+      end
+
+      should "call proper function on interface" do
+        result = mock("result")
+        @interface.expects(:get_cpu_property).with(@key).returns(result)
+        assert_equal result, @instance.get_property(@interface, @key)
+      end
+    end
+
+    context "setting a property" do
+      setup do
+        @key = :foo
+        @value = :bar
+      end
+
+      should "call proper function on interface" do
+        @interface.expects(:set_cpu_property).with(@key, @value).once
+        @instance.set_property(@interface, @key, @value)
+      end
+    end
+
+    context "saving" do
+      setup do
+        @bios_settings = mock("bios_settings")
+        @session = mock("session")
+        @machine = mock("machine")
+        @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(@machine).once.in_sequence(save_seq)
+        @instance.save
+      end
+    end
+  end
+end