velir_virtualbox 0.8.4

data/test/virtualbox/nat_engine_test.rb

@@ -0,0 +1,106 @@
+require File.expand_path("../../test_helper", __FILE__)
+
+class NATEngineTest < Test::Unit::TestCase
+  setup do
+    @klass = VirtualBox::NATEngine
+    @interface = mock("interface")
+    @parent = mock("parent")
+  end
+
+  context "initializing" do
+    should "load attributes from the machine" do
+      @klass.any_instance.expects(:initialize_attributes).with(@parent, @interface).once
+      @klass.new(@parent, @interface)
+    end
+  end
+
+  context "initializing attributes" do
+    setup do
+      @klass.any_instance.stubs(:load_interface_attributes)
+      @klass.any_instance.stubs(:populate_relationships)
+
+      @instance = @klass.new(@parent, @interface)
+    end
+
+    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
+      assert_equal @parent, @instance.parent
+    end
+
+    should "setup the interface" do
+      assert_equal @interface, @instance.interface
+    end
+
+    should "not be dirty" do
+      assert !@instance.changed?
+    end
+
+    should "be existing record" do
+      assert !@instance.new_record?
+    end
+  end
+
+  context "class methods" do
+    context "populating relationship" do
+      should "return nil if the interface is nil" do
+        assert_nil @klass.populate_relationship(@parent, nil)
+      end
+
+      should "return an initialized NATEngine" do
+        @klass.any_instance.stubs(:load_interface_attributes)
+        @klass.any_instance.stubs(:populate_relationships)
+        result = @klass.populate_relationship(@parent, @interface)
+        assert result.is_a?(@klass)
+        assert_equal @parent, result.parent
+        assert_equal @interface, result.interface
+      end
+    end
+
+    context "saving relationship" do
+      should "call save on each item" do
+        item = mock("item")
+        item.expects(:save)
+        @klass.save_relationship(nil, item)
+      end
+    end
+  end
+
+  context "instance methods" do
+    setup do
+      @klass.any_instance.stubs(:load_interface_attributes)
+      @klass.any_instance.stubs(:populate_relationships)
+      @instance = @klass.new(@parent, @interface)
+    end
+
+    context "saving" do
+      setup do
+        @engine = mock("engine")
+        @instance.stubs(:modify_engine).yields(@engine)
+      end
+
+      should "save the interface attributes and relationships" do
+        @instance.expects(:save_changed_interface_attributes).with(@engine).once
+        @instance.expects(:save_relationships).once
+        @instance.save
+      end
+    end
+
+    context "modify engine" do
+      setup do
+        @adapter = mock("adapter")
+        @adapter.stubs(:nat_driver).returns(mock("nat_driver"))
+        @parent.stubs(:modify_adapter).yields(@adapter)
+      end
+
+      should "yield the NAT engine" do
+        @instance.modify_engine do |engine|
+          assert_equal @adapter.nat_driver, engine
+        end
+      end
+    end
+  end
+end

data/test/virtualbox/nat_forwarded_port_test.rb

@@ -0,0 +1,222 @@
+require File.expand_path("../../test_helper", __FILE__)
+
+class NATForwardedPortTest < Test::Unit::TestCase
+  setup do
+    @klass = VirtualBox::NATForwardedPort
+
+    @interface = mock("interface")
+    @caller = mock("caller")
+    @caller.stubs(:interface).returns(@interface)
+  end
+
+  context "validations" do
+    setup do
+      @collection = VirtualBox::Proxies::Collection.new(@caller)
+
+      @port = @klass.new
+      @port.name = "foo"
+      @port.guestport = "22"
+      @port.hostport = "2222"
+      @port.added_to_relationship(@collection)
+    end
+
+    should "be valid with all fields" do
+      assert @port.valid?
+    end
+
+    should "be invalid with no name" do
+      @port.name = nil
+      assert !@port.valid?
+    end
+
+    should "be invalid with no guest port" do
+      @port.guestport = nil
+      assert !@port.valid?
+    end
+
+    should "be invalid with no host port" do
+      @port.hostport = nil
+      assert !@port.valid?
+    end
+
+    should "be invalid if not in a relationship" do
+      @port.write_attribute(:parent, nil)
+      assert !@port.valid?
+    end
+  end
+
+  context "with an instance" do
+    setup do
+      @port = @klass.new({
+        :name => "foo",
+        :guestport => "22",
+        :hostport => "2222"
+      })
+
+      @collection = VirtualBox::Proxies::Collection.new(@caller)
+      @collection << @port
+
+      @port.clear_dirty!
+    end
+
+    context "initializing a new record" do
+      setup do
+        @port = @klass.new
+      end
+
+      should "be a new record" do
+        assert @port.new_record?
+      end
+
+      should "not be dirty" do
+        assert !@port.changed?
+      end
+    end
+
+    context "saving" do
+      setup do
+        @interface.stubs(:add_redirect)
+        @port.stubs(:destroy)
+      end
+
+      context "an existing record" do
+        setup do
+          @port.existing_record!
+          @caller.stubs(:modify_engine)
+        end
+
+        should "not do anything and return true if its unchanged" do
+          @caller.expects(:modify_engine).never
+          assert @port.save
+        end
+
+        should "clear the dirty state after saving" do
+          @port.name = "diff"
+          @port.save
+          assert !@port.changed?
+        end
+
+        should "call destroy if not a new record" do
+          @port.name = "diff"
+          @port.expects(:destroy).with(false).once
+          @port.save
+        end
+      end
+
+      context "a new record" do
+        setup do
+          @port.stubs(:valid?).returns(true)
+          @port.new_record!
+          assert @port.new_record?
+
+          @caller.stubs(:modify_engine)
+        end
+
+        should "no longer be a new record after saving" do
+          @port.save
+          assert !@port.new_record?
+        end
+
+        should "not call destroy" do
+          @port.expects(:destroy).never
+          @port.save
+        end
+
+        should "raise a ValidationFailedException if invalid and raise_errors is true" do
+          @port.expects(:valid?).returns(false)
+          assert_raises(VirtualBox::Exceptions::ValidationFailedException) {
+            @port.save
+          }
+        end
+
+        should "add the redirect to the nat engine" do
+          nat = mock("nat")
+          @caller.stubs(:modify_engine).yields(nat)
+          nat.expects(:add_redirect).with(@port.name,
+                                                 @port.protocol,
+                                                 "", @port.hostport,
+                                                 "", @port.guestport)
+          @port.save
+        end
+      end
+    end
+
+    context "destroying" do
+      setup do
+        @interface.stubs(:remove_redirect)
+        @nat = mock("nat")
+        @nat.stubs(:remove_redirect)
+        @caller.stubs(:modify_engine).yields(@nat)
+      end
+
+      should "remove itself from it's collection" do
+        assert @collection.include?(@port)
+        @port.destroy
+        assert !@collection.include?(@port)
+      end
+
+      should "not remove itself from collection if specified" do
+        assert @collection.include?(@port)
+        @port.destroy(false)
+        assert @collection.include?(@port)
+      end
+
+      should "remove the redirect from the nat engine interface" do
+        @nat.expects(:remove_redirect).with(@port.name).once
+        @port.destroy
+      end
+
+      should "do nothing if the record is new" do
+        @port.new_record!
+        @nat.expects(:remove_redirect).never
+        @port.destroy
+      end
+
+      should "be a new record after destroying" do
+        @port.destroy
+        assert @port.new_record?
+      end
+    end
+  end
+
+  context "relationships" do
+    context "saving" do
+      should "call #save on every object" do
+        objects = []
+        5.times do |i|
+          object = mock("object#{i}")
+          object.expects(:save).once
+          objects.push(object)
+        end
+
+        @klass.save_relationship(@caller, objects)
+      end
+    end
+
+    context "populating" do
+      setup do
+        @interface.stubs(:redirects).returns([
+                                              "foo,1,,2222,,22"
+                                              ])
+        @objects = @klass.populate_relationship(@caller, @interface)
+      end
+
+      should "return an array of ForwardedPorts" do
+        assert @objects.is_a?(VirtualBox::Proxies::Collection)
+        assert @objects.all? { |o| o.is_a?(@klass) }
+      end
+
+      should "have the proper data" do
+        object = @objects.first
+        assert_equal 22, object.guestport
+        assert_equal 2222, object.hostport
+        assert_equal :tcp, object.protocol
+        assert_equal @objects, object.parent_collection
+      end
+
+      should "be existing records" do
+        assert !@objects.first.new_record?
+      end
+    end
+  end
+end

data/test/virtualbox/network_adapter_test.rb

@@ -0,0 +1,191 @@
+require File.expand_path("../../test_helper", __FILE__)
+
+class NetworkAdapterTest < Test::Unit::TestCase
+  setup do
+    @klass = VirtualBox::NetworkAdapter
+    @interface = mock("interface")
+    @parent = mock("parent")
+  end
+
+  context "initializing" do
+    should "load attributes from the machine" do
+      @klass.any_instance.expects(:initialize_attributes).with(@parent, @interface).once
+      @klass.new(@parent, @interface)
+    end
+  end
+
+  context "initializing attributes" do
+    setup do
+      @klass.any_instance.stubs(:load_interface_attributes)
+      @klass.any_instance.stubs(:populate_relationships)
+
+      @instance = @klass.new(@parent, @interface)
+    end
+
+    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
+      assert_equal @parent, @instance.parent
+    end
+
+    should "setup the interface" do
+      assert_equal @interface, @instance.interface
+    end
+
+    should "not be dirty" do
+      assert !@instance.changed?
+    end
+
+    should "be existing record" do
+      assert !@instance.new_record?
+    end
+  end
+
+  context "class methods" do
+    context "populating relationship" do
+      setup do
+        @instance = mock("instance")
+        @klass.stubs(:new).returns(@instance)
+
+        @count = 5
+        @vbox = mock("vbox")
+        @system_properties = mock("sys_props")
+        @interface.stubs(:parent).returns(@vbox)
+        @vbox.stubs(:system_properties).returns(@system_properties)
+        @system_properties.stubs(:network_adapter_count).returns(@count)
+      end
+
+      should "return a proxied collection" do
+        @system_properties.stubs(:network_adapter_count).returns(0)
+        result = @klass.populate_relationship(nil, @interface)
+        assert result.is_a?(VirtualBox::Proxies::Collection)
+      end
+
+      should "call new for every shared folder" do
+        expected_result = []
+        new_seq = sequence("new_seq")
+        @count.times do |i|
+          expected_value = "instance-#{i}"
+          adapter = mock("adapter#{i}")
+          @interface.expects(:get_network_adapter).with(i).returns(adapter).in_sequence(new_seq)
+          @klass.expects(:new).with(@parent, adapter).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
+      should "call save on each item" do
+        items = (1..5).to_a.collect do |i|
+          item = mock("item-#{i}")
+          item.expects(:save).once
+          item
+        end
+
+        @klass.save_relationship(nil, items)
+      end
+    end
+  end
+
+  context "instance methods" do
+    setup do
+      @klass.any_instance.stubs(:load_interface_attributes)
+      @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")
+        @instance.stubs(:modify_adapter).yields(@adapter)
+      end
+
+      should "save the attachment type and interface attributes on the open adapter" do
+        @instance.expects(:save_attachment_type).with(@adapter).once
+        @instance.expects(:save_changed_interface_attributes).with(@adapter).once
+        @instance.expects(:save_relationships).once
+        @instance.save
+      end
+    end
+
+    context "saving attachment type" do
+      setup do
+        @adapter = mock("adapter")
+        @instance.attachment_type = :nat
+      end
+
+      should "do nothing if attachment type is not changed" do
+        @instance.clear_dirty!
+        assert !@instance.attachment_type_changed?
+        @instance.expects(:attach_to_nat).never
+
+        @instance.save_attachment_type(@adapter)
+      end
+
+      should "run the proper method if it has changed" do
+        @adapter.expects(:attach_to_nat).once
+        @instance.save_attachment_type(@adapter)
+      end
+
+      should "clear the dirty state" do
+        @adapter.stubs(:attach_to_nat)
+        @instance.save_attachment_type(@adapter)
+        assert !@instance.attachment_type_changed?
+      end
+    end
+
+    context "modifying the adapter" do
+      setup do
+        @machine = mock("machine")
+        @session = mock("session")
+        @session.stubs(:machine).returns(@machine)
+        @instance.expects(:parent_machine).returns(@parent)
+
+        @adapter = mock("adapter")
+      end
+
+      should "open a session, yield the proper adapter, then save settings" do
+        seq = sequence("sequence")
+        @parent.expects(:with_open_session).yields(@session).in_sequence(seq)
+        @machine.expects(:get_network_adapter).with(@instance.slot).returns(@adapter).in_sequence(seq)
+
+        @instance.modify_adapter do |adapter|
+          assert_equal @adapter, adapter
+        end
+      end
+    end
+  end
+end