virtualbox 0.7.1 → 0.7.2

data/lib/virtualbox/network_adapter.rb

@@ -44,6 +44,7 @@ module VirtualBox
     attribute :internal_network
     attribute :host_interface
     attribute :interface, :readonly => true, :property => false
+    relationship :nat_driver, :NATEngine, :version => "3.2", :lazy => true
 
     class << self
       # Populates the nic relationship for anything which is related to it.
@@ -98,6 +99,13 @@ module VirtualBox
       existing_record!
     end
 
+    def load_relationship(name)
+      # Lazy load the NAT driver. This is only supported by VirtualBox
+      # 3.2 and higher. This restriction is checked when the
+      # relationship attribute is accessed.
+      populate_relationship(:nat_driver, interface.nat_driver)
+    end
+
     # Gets the host interface object associated with the class if it
     # exists.
     def host_interface_object
@@ -111,6 +119,7 @@ module VirtualBox
       modify_adapter do |adapter|
         save_attachment_type(adapter)
         save_changed_interface_attributes(adapter)
+        save_relationships
       end
     end
 
@@ -133,7 +142,7 @@ module VirtualBox
     # Opens a session, yields the adapter and then saves the machine at
     # the end
     def modify_adapter
-      parent.with_open_session do |session|
+      parent_machine.with_open_session do |session|
         machine = session.machine
         yield machine.get_network_adapter(slot)
       end

data/lib/virtualbox/shared_folder.rb

@@ -179,7 +179,7 @@ module VirtualBox
     def create
       return unless new_record?
 
-      parent.with_open_session do |session|
+      parent_machine.with_open_session do |session|
         machine = session.machine
         machine.create_shared_folder(name, host_path, writable)
       end

data/lib/virtualbox/vm.rb

@@ -174,7 +174,7 @@ module VirtualBox
     relationship :medium_attachments, :MediumAttachment
     relationship :shared_folders, :SharedFolder
     relationship :extra_data, :ExtraData
-    relationship :forwarded_ports, :ForwardedPort
+    relationship :forwarded_ports, :ForwardedPort, :version => "3.1"
     relationship :network_adapters, :NetworkAdapter
     relationship :usb_controller, :USBController
     relationship :current_snapshot, :Snapshot
@@ -529,7 +529,12 @@ module VirtualBox
     #
     # @return [Boolean] True if command was successful, false otherwise.
     def discard_state
-      control(:forget_saved_state, true)
+      # Since the VM should be saved as it is, we don't open an
+      # existing session like the other control methods. We open a new
+      # session.
+      with_open_session do |session|
+        session.console.forget_saved_state(true)
+      end
     end
 
     # Controls the virtual machine. This method is used by {#stop},

data/test/test_helper.rb

@@ -24,4 +24,4 @@ end
 # FFI is initialized (on non-windows machines). Since the tests test
 # the FFI classes, we force initialize a specific version here. It
 # doesn't matter what version, since no actual FFI calls are made.
-VirtualBox::COM::FFI.setup("3.1.x") unless defined?(VirtualBox::COM::FFI::Version_3_1_X)
+VirtualBox::COM::FFI.setup("3.2.x") unless defined?(VirtualBox::COM::FFI::Version_3_2_X)

data/test/virtualbox/abstract_model/attributable_test.rb

@@ -195,11 +195,16 @@ class AttributableTest < Test::Unit::TestCase
   end
 
   context "reading and writing attributes" do
+    class VersionedAttributeModel < AttributeModel
+      attribute :ver, :version => "3.1"
+    end
+
     setup do
-      @model = AttributeModel.new
+      @model = VersionedAttributeModel.new
       @model.populate_attributes({
         :foo => "foo",
-        :bar => false
+        :bar => false,
+        :ver => "ver"
       })
 
       @checkstring = "HEY"
@@ -231,6 +236,22 @@ class AttributableTest < Test::Unit::TestCase
       }
     end
 
+    should "raise an exception if version not supported" do
+      VirtualBox.stubs(:version).returns("3.0.14")
+
+      assert_raises(VirtualBox::Exceptions::UnsupportedVersionException) {
+        @model.ver
+      }
+    end
+
+    should "read value if version supported" do
+      VirtualBox.stubs(:version).returns("3.1.8")
+
+      assert_nothing_raised {
+        assert_equal "ver", @model.ver
+      }
+    end
+
     should "understand false values" do
       assert_nothing_raised {
         assert_equal false, @model.bar
@@ -245,4 +266,4 @@ class AttributableTest < Test::Unit::TestCase
       assert_raises(NoMethodError) { @model.baz }
     end
   end
-end
+end

data/test/virtualbox/abstract_model/interface_attributes_test.rb

@@ -12,6 +12,7 @@ class InterfaceAttributesTest < Test::Unit::TestCase
     attribute :foo3, :property => :grab_foo3, :readonly => true
     attribute :foo4, :property => :put_foo4
     attribute :bar, :property => false
+    attribute :ver, :version => "3.1.3"
   end
 
   context "converting spec to a proc" do
@@ -64,6 +65,18 @@ class InterfaceAttributesTest < Test::Unit::TestCase
       @instance.load_interface_attribute(:bar, @interface)
     end
 
+    should "return immediately if version mismatch" do
+      VirtualBox.stubs(:version).returns("3.2.4")
+      @interface.expects(:ver).never
+      @instance.load_interface_attribute(:ver, @interface)
+    end
+
+    should "load the attribute if version matches" do
+      VirtualBox.stubs(:version).returns("3.1.3")
+      @interface.expects(:ver).returns("foo")
+      @instance.load_interface_attribute(:ver, @interface)
+    end
+
     should "use the getter specified if exists" do
       key = :foo2
       @interface.expects(:get_foo).returns(:bar)
@@ -111,6 +124,18 @@ class InterfaceAttributesTest < Test::Unit::TestCase
       @instance.save_interface_attribute(:bar, @interface)
     end
 
+    should "return immediately if version mismatch" do
+      VirtualBox.stubs(:version).returns("3.2.4")
+      @interface.expects(:ver).never
+      @instance.save_interface_attribute(:ver, @interface)
+    end
+
+    should "load the attribute if version matches" do
+      VirtualBox.stubs(:version).returns("3.1.3")
+      @interface.expects(:ver=)
+      @instance.save_interface_attribute(:ver, @interface)
+    end
+
     should "save the attribute with the value of the proc" do
       key = :foo
       @interface.expects(:foo=).with(@value).once
@@ -166,4 +191,4 @@ class InterfaceAttributesTest < Test::Unit::TestCase
       @instance.save_interface_attributes(@interface)
     end
   end
-end
+end

data/test/virtualbox/abstract_model/relatable_test.rb

@@ -194,16 +194,45 @@ class RelatableTest < Test::Unit::TestCase
   end
 
   context "saving relationships" do
+    class RelatableWithLazyModel < RelatableModel
+      relationship :bazs, RelatableTest::Relatee, :lazy => true
+      relationship :vers, RelatableTest::Relatee, :version => "3.1"
+
+      def load_relationship(name)
+        populate_relationship(:bazs, "foo")
+      end
+    end
+
     setup do
-      @model = RelatableModel.new
+      @model = RelatableWithLazyModel.new
+      VirtualBox.stubs(:version).returns("3.1.3")
     end
 
     should "call save_relationship for all relationships" do
       @model.expects(:save_relationship).with(:foos)
       @model.expects(:save_relationship).with(:bars)
+      @model.expects(:save_relationship).with(:bazs)
+      @model.expects(:save_relationship).with(:vers)
       @model.save_relationships
     end
 
+    should "not call save_relationship on non-loaded relations" do
+      Relatee.expects(:save_relationship).never
+      @model.save_relationship(:bazs)
+    end
+
+    should "not call save_relationship on relationships with mismatched versions" do
+      VirtualBox.stubs(:version).returns("3.2.4")
+      Relatee.expects(:save_relationship).never
+      @model.save_relationship(:vers)
+    end
+
+    should "call save_relationship on loaded lazy relationships" do
+      @model.load_relationship(:bazs)
+      Relatee.expects(:save_relationship).once
+      @model.save_relationship(:bazs)
+    end
+
     should "call save_relationship on the related class" do
       Relatee.expects(:save_relationship).with(@model, @model.foos).once
       @model.save_relationship(:foos)
@@ -216,13 +245,31 @@ class RelatableTest < Test::Unit::TestCase
   end
 
   context "reading relationships" do
+    class VersionedRelatableModel < RelatableModel
+      relationship :ver, :Ver, :version => "3.1"
+    end
+
     setup do
-      @model = RelatableModel.new
+      @model = VersionedRelatableModel.new
     end
 
     should "provide a read method for relationships" do
       assert_nothing_raised { @model.foos }
     end
+
+    should "raise an exception if invalid version for versioned relationships" do
+      VirtualBox.stubs(:version).returns("3.0.14")
+      assert_raises(VirtualBox::Exceptions::UnsupportedVersionException) {
+        @model.ver
+      }
+    end
+
+    should "not raise an exception if valid version for versioned relationship" do
+      VirtualBox.stubs(:version).returns("3.1.8")
+      assert_nothing_raised {
+        @model.ver
+      }
+    end
   end
 
   context "checking for relationships" do
@@ -264,8 +311,13 @@ class RelatableTest < Test::Unit::TestCase
   end
 
   context "populating relationships" do
+    class PopulatingRelatableModel < RelatableModel
+      relationship :bazs, RelatableTest::Relatee, :version => "3.1"
+    end
+
     setup do
-      @model = RelatableModel.new
+      @model = PopulatingRelatableModel.new
+      VirtualBox.stubs(:version).returns("3.1.4")
     end
 
     should "be able to populate a single relationship" do
@@ -273,17 +325,24 @@ class RelatableTest < Test::Unit::TestCase
       @model.populate_relationship(:foos, @data)
     end
 
+    should "not populate versioned relationships if version mismatch" do
+      VirtualBox.stubs(:version).returns("3.0.4")
+      Relatee.expects(:populate_relationship).never
+      @model.populate_relationship(:bazs, @data)
+    end
+
     should "call populate_relationship on the related class" do
       populate_seq = sequence("populate_seq")
       @model.expects(:populate_relationship).with(:foos, @data).once.in_sequence(populate_seq)
       @model.expects(:populate_relationship).with(:bars, @data).once.in_sequence(populate_seq)
+      @model.expects(:populate_relationship).with(:bazs, @data).once.in_sequence(populate_seq)
       @model.populate_relationships(@data)
     end
 
     should "properly save returned value as the value for the relationship" do
-      Relatee.expects(:populate_relationship).once.returns("HEY")
+      Relatee.expects(:populate_relationship).twice.returns("HEY")
       @model.populate_relationships(@data)
       assert_equal "HEY", @model.foos
     end
   end
-end
+end

data/test/virtualbox/abstract_model/version_matcher_test.rb

@@ -0,0 +1,37 @@
+require File.join(File.dirname(__FILE__), '..', '..', 'test_helper')
+
+class VersionMatcherTest < Test::Unit::TestCase
+  setup do
+    @module = VirtualBox::AbstractModel::VersionMatcher
+    @klass = Class.new
+    @klass.send(:extend, @module)
+  end
+
+  context "asserting version matches" do
+    should "raise an exception if versions do not match" do
+      assert_raises(VirtualBox::Exceptions::UnsupportedVersionException) {
+        @klass.assert_version_match("3.1", "3.2.4")
+      }
+    end
+
+    should "not raise an exception if versions do match" do
+      assert_nothing_raised {
+        @klass.assert_version_match("3.0", "3.0.14")
+      }
+    end
+  end
+
+  context "version matching" do
+    should "return true if versions match" do
+      assert @klass.version_match?("3.2", "3.2.4")
+      assert !@klass.version_match?("3.1", "3.2.4")
+    end
+  end
+
+  context "splitting version" do
+    should "split into a max of two parts by period" do
+      assert_equal %W[3 2], @klass.split_version("3.2.0")
+      assert_equal %W[3 1], @klass.split_version("3.1.1.1.1")
+    end
+  end
+end

data/test/virtualbox/abstract_model_test.rb

@@ -84,16 +84,6 @@ class AbstractModelTest < Test::Unit::TestCase
       assert !@model.lazy_attribute?(:foo)
       assert !@model.lazy_relationship?(:foos)
     end
-
-    should "only save loaded relationships" do
-      @model.existing_record!
-      assert @model.lazy_relationship?(:foos)
-      assert @model.lazy_relationship?(:bars)
-      @model.stubs(:loaded_relationship?).with(:foos).returns(false)
-      @model.stubs(:loaded_relationship?).with(:bars).returns(true)
-      @model.expects(:save_relationship).with(:bars).once
-      @model.save
-    end
   end
 
   context "inspecting" do
@@ -112,7 +102,7 @@ class AbstractModelTest < Test::Unit::TestCase
 
     should "turn attributes which are AbstractInterfaces into classes" do
       @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
+      assert_equal "#<AbstractModelTest::FakeModel :bar=nil, :bars=..., :foo=#<VirtualBox::COM::Interface::Version_3_2_X::VirtualBox>, :foos=...>", @model.inspect
     end
   end
 
@@ -197,6 +187,34 @@ class AbstractModelTest < Test::Unit::TestCase
     end
   end
 
+  context "parent machine" do
+    setup do
+      # Create a subclass of VM and no-op the initialize so it doesn't
+      # try to populate VM attributes or relationships
+      @root = Class.new(VirtualBox::VM)
+      @root.class_eval("def initialize; end")
+      @root = @root.new
+
+      @leaf = @root
+      3.times do |i|
+        child = Class.new(VirtualBox::AbstractModel)
+        child.attribute(:parent, :readonly => true, :property => false)
+        child = child.new
+        child.write_attribute(:parent, @leaf)
+        @leaf = child
+      end
+    end
+
+    should "get the parent" do
+      # Sanity test
+      assert_equal @root, @leaf.parent.parent.parent
+      assert @root.is_a?(VirtualBox::VM)
+
+      # Actual test
+      assert_equal @root, @leaf.parent_machine
+    end
+  end
+
   context "subclasses" do
     class FakeTwoModel < FakeModel
       attribute :baz

data/test/virtualbox/forwarded_port_test.rb

@@ -2,6 +2,8 @@ require File.join(File.dirname(__FILE__), '..', 'test_helper')
 
 class ForwardedPortTest < Test::Unit::TestCase
   setup do
+    @klass = VirtualBox::ForwardedPort
+
     @nic = mock("nic")
     @nic.stubs(:adapter_type).returns(:foo)
     @nics = [@nic]
@@ -16,7 +18,7 @@ class ForwardedPortTest < Test::Unit::TestCase
     setup do
       @collection = VirtualBox::Proxies::Collection.new(@caller)
 
-      @port = VirtualBox::ForwardedPort.new
+      @port = @klass.new
       @port.name = "foo"
       @port.guestport = "22"
       @port.hostport = "2222"
@@ -50,7 +52,7 @@ class ForwardedPortTest < Test::Unit::TestCase
 
   context "with an instance" do
     setup do
-      @port = VirtualBox::ForwardedPort.new({
+      @port = @klass.new({
         :name => "foo",
         :guestport => "22",
         :hostport => "2222"
@@ -68,6 +70,20 @@ class ForwardedPortTest < Test::Unit::TestCase
       @caller.stubs(:extra_data).returns(@ed)
     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 "device" do
       setup do
         @port.new_record!
@@ -149,7 +165,8 @@ class ForwardedPortTest < Test::Unit::TestCase
       context "a new record" do
         setup do
           @port.stubs(:valid?).returns(true)
-          assert @port.new_record!
+          @port.new_record!
+          assert @port.new_record?
         end
 
         should "no longer be a new record after saving" do