bbrowning-virtualbox 0.7.6.dev

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

@@ -0,0 +1,247 @@
+require File.expand_path("../../../../test_helper", __FILE__)
+
+class COMImplementerMSCOMTest < Test::Unit::TestCase
+  setup do
+    @klass = VirtualBox::COM::Implementer::MSCOM
+    @interface = mock("interface")
+    @lib = mock("lib")
+    @object = mock("object")
+  end
+
+  context "initializing" do
+    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
+      @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
+      context "with ruby 1.8" do
+        setup do
+          @instance.stubs(:ruby_version).returns(1.8)
+        end
+
+        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 "with ruby 1.9" do
+        setup do
+          @instance.stubs(:ruby_version).returns(1.9)
+        end
+
+        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(: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
+    end
+
+    context "writing a property" do
+      context "on ruby 1.8" do
+        setup do
+          @instance.stubs(:ruby_version).returns(1.8)
+        end
+
+        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 "on ruby 1.9" do
+        setup do
+          @instance.stubs(:ruby_version).returns(1.9)
+        end
+
+        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(:FooBar=).with(:modified).once
+
+          @instance.write_property(name, :value, opts)
+        end
+      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.expand_path("../../../test_helper", __FILE__)
+
+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.expand_path("../../../test_helper", __FILE__)
+
+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/cpu_test.rb

@@ -0,0 +1,103 @@
+require File.expand_path("../../test_helper", __FILE__)
+
+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

data/test/virtualbox/dhcp_server_test.rb

@@ -0,0 +1,165 @@
+require File.expand_path("../../test_helper", __FILE__)
+
+class DHCPServerTest < Test::Unit::TestCase
+  setup do
+    @interface = mock("interface")
+    @parent = mock("parent")
+
+    @klass = VirtualBox::DHCPServer
+  end
+
+  context "class methods" do
+    context "populating relationships" do
+      setup do
+        @instance = mock("instance")
+        @klass.stubs(:new).returns(@instance)
+      end
+
+      should "return a proxied collection" do
+        result = @klass.populate_relationship(nil, [])
+        assert result.is_a?(VirtualBox::Proxies::Collection)
+      end
+
+      should "call new for every interface" do
+        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, collection)
+      end
+    end
+
+    context "creating" do
+      setup do
+        @lib = mock("lib")
+        @virtualbox = mock("virtualbox")
+        @proxy = mock("proxy")
+
+        @lib.stubs(:virtualbox).returns(@virtualbox)
+        @parent.stubs(:lib).returns(@lib)
+        @proxy.stubs(:parent).returns(@parent)
+      end
+
+      should "create the dhcp server" do
+        name = :foo
+        interface = mock("interface")
+        result = mock("result")
+        @virtualbox.expects(:create_dhcp_server).with(name).once.returns(interface)
+        @klass.expects(:new).with(interface).returns(result)
+        assert_equal result, @klass.create(@proxy, name)
+      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 "be existing record" do
+      @instance = @klass.new(@interface)
+      assert !@instance.new_record?
+    end
+  end
+
+  context "instance methods" do
+    setup do
+      @klass.any_instance.stubs(:initialize_attributes)
+
+      @parent = mock("parent")
+      @interface = mock("interface")
+      @instance = @klass.new(@interface)
+      @instance.stubs(:interface).returns(@interface)
+      @collection = VirtualBox::Proxies::Collection.new(@parent)
+      @collection << @instance
+    end
+
+    context "saving" do
+      setup do
+        @instance.stubs(:save_changed_interface_attributes)
+      end
+
+      should "set configuration if something changed" do
+        @instance.ip_address = "7"
+        @interface.expects(:set_configuration).once
+        @instance.save
+      end
+
+      should "not set configuration if nothing changed" do
+        @interface.expects(:set_configuration).never
+        @instance.save
+      end
+
+      should "save the changed attributes" do
+        @instance.expects(:save_changed_interface_attributes).with(@instance.interface).once
+        @instance.save
+      end
+    end
+
+    context "destroying" do
+      setup do
+        @lib = mock("lib")
+        @virtualbox = mock("virtualbox")
+        @lib.stubs(:virtualbox).returns(@virtualbox)
+        @parent.stubs(:lib).returns(@lib)
+
+        @virtualbox.stubs(:remove_dhcp_server)
+      end
+
+      should "destroy the DHCP server" do
+        @virtualbox.expects(:remove_dhcp_server).with(@interface).once
+        @instance.destroy
+      end
+
+      should "remove from collection" do
+        assert @collection.include?(@instance)
+        @instance.destroy
+        assert !@collection.include?(@instance)
+      end
+    end
+
+    context "host network" do
+      setup do
+        @host = mock("host")
+        @network_interfaces = []
+        @parent.stubs(:host).returns(@host)
+        @host.stubs(:network_interfaces).returns(@network_interfaces)
+      end
+
+      should "do nothing if not a DHCP server for a host interface" do
+        @instance.stubs(:network_name).returns("foo")
+        assert_nil @instance.host_network
+      end
+
+      should "return the matching network interface" do
+        name = "foo"
+        ni = mock("net_interface")
+        ni.stubs(:interface_type).returns(:host_only)
+        ni.stubs(:name).returns(name)
+
+        @network_interfaces << ni
+        @instance.stubs(:network_name).returns("HostInterfaceNetworking-#{name}")
+        assert_equal ni, @instance.host_network
+      end
+    end
+  end
+end