bbrowning-virtualbox 0.7.6.dev

data/test/virtualbox/appliance_test.rb

@@ -0,0 +1,159 @@
+require File.expand_path("../../test_helper", __FILE__)
+
+class ApplianceTest < Test::Unit::TestCase
+  setup do
+    @klass = VirtualBox::Appliance
+    @interface = mock("interface")
+    @parent = mock("parent")
+    @path = "foo.rb"
+
+    @appliance = mock("appliance")
+    @virtualbox = mock("virtualbox")
+    @lib = mock("lib")
+    VirtualBox::Lib.stubs(:lib).returns(@lib)
+    @lib.stubs(:virtualbox).returns(@virtualbox)
+    @virtualbox.stubs(:create_appliance).returns(@appliance)
+  end
+
+  context "class methods" do
+
+  end
+
+  context "initializing" do
+    should "load interface attribtues" do
+      @klass.any_instance.expects(:initialize_from_path).with(@path).once
+      @klass.new(@path)
+    end
+
+    context "initializing from path" do
+      setup do
+        @progress = mock("progress")
+        @appliance.stubs(:read).returns(@progress)
+        @appliance.stubs(:interpret)
+        @appliance.stubs(:virtual_system_descriptions)
+        @progress.stubs(:wait_for_completion)
+
+        @klass.any_instance.stubs(:populate_relationship)
+        @klass.any_instance.stubs(:load_interface_attributes)
+      end
+
+      should "write the interface as the appliance" do
+        instance = @klass.new(@path)
+        assert_equal @appliance, instance.interface
+      end
+
+      should "mark as an existing record" do
+        instance = @klass.new(@path)
+        assert !instance.new_record?
+      end
+
+      should "read the appliance then interpret it" do
+        init_seq = sequence("init")
+        @appliance.expects(:read).with(@path).once.returns(@progress).in_sequence(init_seq)
+        @progress.expects(:wait_for_completion).with(-1).in_sequence(init_seq)
+        @appliance.expects(:interpret).once.in_sequence(init_seq)
+        @klass.any_instance.expects(:load_interface_attributes).with(@appliance).once.in_sequence(init_seq)
+
+        @klass.new(@path)
+      end
+    end
+
+    context "initialize without path" do
+      setup do
+        @instance = @klass.new
+      end
+
+      should "write the interface as the appliance" do
+        assert_equal @appliance, @instance.interface
+      end
+
+      should "be new record" do
+        assert @instance.new_record?
+      end
+
+      should "not be dirty" do
+        assert !@instance.changed?
+      end
+    end
+  end
+
+  context "instance methods" do
+    setup do
+      @klass.any_instance.stubs(:initialize_from_path)
+      @instance = @klass.new(@path)
+      @instance.stubs(:interface).returns(@interface)
+    end
+
+    context "importing" do
+      setup do
+        @progress = mock("progress")
+
+        @interface.stubs(:import_machines).returns(@progress)
+      end
+
+      should "call import on interface and wait for completion" do
+        @interface.expects(:import_machines).returns(@progress)
+        @progress.expects(:wait)
+
+        @instance.import
+      end
+
+      should "call wait with block given" do
+        proc = mock("proc")
+        @progress.expects(:wait).yields(proc)
+        proc.expects(:call)
+
+        @instance.import do |proc|
+          proc.call
+        end
+      end
+    end
+
+    context "exporting" do
+      setup do
+        @progress = mock("progress")
+
+        @instance.path = :foo
+        @interface.stubs(:write).returns(@progress)
+      end
+
+      should "call write on interface and wait for completion" do
+        @interface.expects(:write).with("ovf-1.0", @instance.path).once.returns(@progress)
+        @progress.expects(:wait)
+
+        @instance.export
+      end
+
+      should "call wait with block given" do
+        proc = mock("proc")
+        @progress.expects(:wait).yields(proc)
+        proc.expects(:call)
+
+        @instance.export do |proc|
+          proc.call
+        end
+      end
+    end
+
+    context "adding a machine" do
+      setup do
+        @machine = mock("machine")
+        @machine_interface = mock("machine_interface")
+        @machine.stubs(:interface).returns(@machine_interface)
+        @machine_interface.stubs(:export)
+      end
+
+      should "call export on the VM interface with the appliance" do
+        @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

data/test/virtualbox/audio_adapter_test.rb

@@ -0,0 +1,83 @@
+require File.expand_path("../../test_helper", __FILE__)
+
+class AudioAdapterTest < Test::Unit::TestCase
+  setup do
+    @klass = VirtualBox::AudioAdapter
+    @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)
+
+        @audio_adapter = mock("audio_adapter")
+        @interface.stubs(:audio_adapter).returns(@audio_adapter)
+      end
+
+      should "call new for the interface" do
+        @klass.expects(:new).with(nil, @audio_adapter).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
+        @audio_adapter = mock("audio_adapter")
+        @session = mock("session")
+        @machine = mock("machine")
+        @machine.stubs(:audio_adapter).returns(@audio_adapter)
+        @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(@audio_adapter).once.in_sequence(save_seq)
+        @instance.save
+      end
+    end
+  end
+end

data/test/virtualbox/bios_test.rb

@@ -0,0 +1,83 @@
+require File.expand_path("../../test_helper", __FILE__)
+
+class BIOSTest < Test::Unit::TestCase
+  setup do
+    @klass = VirtualBox::BIOS
+    @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)
+
+        @bios_settings = mock("bios_settings")
+        @interface.stubs(:bios_settings).returns(@bios_settings)
+      end
+
+      should "call new for the interface" do
+        @klass.expects(:new).with(nil, @bios_settings).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
+        @bios_settings = mock("bios_settings")
+        @session = mock("session")
+        @machine = mock("machine")
+        @machine.stubs(:bios_settings).returns(@bios_settings)
+        @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(@bios_settings).once.in_sequence(save_seq)
+        @instance.save
+      end
+    end
+  end
+end

data/test/virtualbox/com/abstract_enum_test.rb

@@ -0,0 +1,49 @@
+require File.expand_path("../../../test_helper", __FILE__)
+
+class COMAbstractEnumTest < Test::Unit::TestCase
+  context "setting up the map" do
+    setup do
+      @enum = VirtualBox::COM::AbstractEnum
+      @enum.reset!
+    end
+
+    should "set the map up and be able to access it" do
+      @enum.map([:a, :b, :c])
+      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
+      @enum.map([:a, :b, :c])
+      assert_equal 1, @enum.index(:b)
+    end
+
+    should "reset the map if another is given" do
+      @enum.map([:a])
+      @enum.map([:b])
+      assert_equal :b, @enum[0]
+    end
+
+    should "allow iterating over the enum" do
+      array = [:a, :b, :c]
+      other_array = []
+      @enum.map(array)
+      @enum.each do |item|
+        other_array << item
+      end
+
+      assert_equal array, other_array
+    end
+
+    should "include enumerable methods" do
+      array = [:a, :b, :c]
+      @enum.map(array)
+
+      @enum.each_with_index do |object, index|
+        assert_equal array[index], object
+      end
+    end
+  end
+end

data/test/virtualbox/com/abstract_implementer_test.rb

@@ -0,0 +1,40 @@
+require File.expand_path("../../../test_helper", __FILE__)
+
+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, @lib)
+      assert_equal @interface, instance.interface
+    end
+  end
+
+  context "base methods" do
+    setup do
+      @instance = @klass.new(@interface, @lib)
+    end
+
+    should "implement the read_property function" do
+      assert_nothing_raised {
+        @instance.read_property(:foo, :bar)
+      }
+    end
+
+    should "implement the write_property function" do
+      assert_nothing_raised {
+        @instance.write_property(:foo, :bar, :opts)
+      }
+    end
+
+    should "implement the call_function function" do
+      assert_nothing_raised {
+        @instance.call_function(:foo, [], :opts)
+      }
+    end
+  end
+end

data/test/virtualbox/com/abstract_interface_test.rb

@@ -0,0 +1,140 @@
+require File.expand_path("../../../test_helper", __FILE__)
+
+class AbstractInterfaceTest < Test::Unit::TestCase
+  class EmptyAITest < VirtualBox::COM::AbstractInterface
+  end
+
+  class BasicAITest < EmptyAITest
+    function :foo, :int, []
+    function :foo2, :int, []
+    property :bar, :int
+    property :bar2, :int
+    property :bar3, :int
+  end
+
+  setup do
+    @impl_instance = mock("impl_instance")
+    @impl = mock("implementer")
+    @impl.stubs(:new).returns(@impl_instance)
+  end
+
+  context "class methods" do
+    context "without any members defined" do
+      setup do
+        @klass = EmptyAITest
+        @klass.members.clear
+
+        @klass.stubs(:define_method)
+      end
+
+      should "put defined functions in the members hash" do
+        assert_nil @klass.member(:foo)
+        @klass.function(:foo, :int, :bar)
+        assert @klass.member(:foo)
+      end
+
+      should "define an method for functions" do
+        @klass.expects(:define_method).with(:foo)
+        @klass.function(:foo, :int, :bar)
+      end
+
+      should "put defined properties in the members hash" do
+        assert_nil @klass.member(:foo)
+        @klass.property(:foo, :bar)
+        assert @klass.member(:foo)
+      end
+
+      should "create methods for reading and writing properties" do
+        @klass.expects(:define_method).with(:foo).once
+        @klass.expects(:define_method).with(:foo=).once
+        @klass.property(:foo, :bar)
+      end
+
+      should "not creating writing method for property if its readonly" do
+        @klass.expects(:define_method).with(:foo=).never
+        @klass.property(:foo, :bar, :readonly => true)
+      end
+    end
+
+    context "with members defined" do
+      setup do
+        @klass = BasicAITest
+      end
+
+      should "return the properties in order" do
+        properties = @klass.properties
+        properties.collect! { |prop| prop[0] }
+
+        assert_equal [:bar, :bar2, :bar3], properties
+      end
+
+      should "return the functions in order" do
+        funcs = @klass.functions
+        funcs.collect! { |func| func[0] }
+
+        assert_equal [:foo, :foo2], funcs
+      end
+    end
+  end
+
+  context "initialization" do
+    should "instantiate the implementer" do
+      @impl.expects(:new).with() do |interface, extra|
+        assert interface.is_a?(VirtualBox::COM::AbstractInterface)
+        assert_equal :foo, extra
+        true
+      end
+
+      BasicAITest.new(@impl, :foo)
+    end
+  end
+
+  context "instance methods" do
+    setup do
+      @lib = VirtualBox::COM::NilInterface.new
+      @interface = BasicAITest.new(@impl, @lib)
+    end
+
+    context "checking for property existence" do
+      should "return true for existing properties" do
+        assert @interface.has_property?(:bar)
+      end
+
+      should "return false non-existent properties and methods" do
+        assert !@interface.has_property?(:foo)
+      end
+    end
+
+    context "checking for function existence" do
+      should "return true for existing functions" do
+        assert @interface.has_function?(:foo)
+      end
+
+      should "return false non-existent function and properties" do
+        assert !@interface.has_function?(:bar)
+      end
+    end
+
+    context "reading a property" do
+      should "call read property on the implementer and return result" do
+        result = mock("result")
+        @impl_instance.expects(:read_property).with(:bar, anything).returns(result)
+        assert_equal result, @interface.bar
+      end
+    end
+
+    context "calling a function" do
+      should "call the call function method on the implementer and return result" do
+        result = mock("result")
+        @impl_instance.expects(:call_function).with(:foo, [1, 2, 3], anything).returns(result)
+        assert_equal result, @interface.foo(1, 2, 3)
+      end
+    end
+
+    context "inspecting" do
+      should "be just the class name" do
+        assert_equal "#<AbstractInterfaceTest::BasicAITest>", @interface.inspect
+      end
+    end
+  end
+end