virtualbox 0.7.3 → 0.7.4

data/Gemfile

@@ -1,4 +1,4 @@
-source :gemcutter
+source "http://rubygems.org"
 
 # External Dependencies
 gem "ffi"

data/VERSION

@@ -1 +1 @@
-0.7.3
+0.7.4

data/features/step_definitions/abstract_model_steps.rb

@@ -1,7 +1,11 @@
-Given /the "(.+?)" relationship/ do |relationship|
+Given /the "(.+?)" relationship$/ do |relationship|
   @relationship = @model.send(relationship)
 end
 
+Given /the "(.+?)" relationship on collection item "(.+?)"/ do |key, index|
+  @relationship = @relationship[index.to_i - 1].send(key)
+end
+
 Given /I reload the model/ do
   @model.reload
 end

data/features/step_definitions/nat_engine_steps.rb

@@ -0,0 +1,76 @@
+Given /the forwarded ports are cleared/ do
+  VBoxManage.network_adapters(@output).each_with_index do |obj, i|
+    VBoxManage.forwarded_ports(@output, i+1).each do |name, data|
+      VBoxManage.execute("modifyvm", @name, "--natpf#{i+1}", "delete", name)
+    end
+  end
+end
+
+Given /I read the adapter in slot "(.+?)"$/ do |slot|
+  @slot = slot.to_i
+  @adapter = VBoxManage.network_adapters(@output)[slot.to_i]
+  @adapter.should_not be_nil
+
+  @relationship = @model.network_adapters[slot.to_i - 1].nat_driver
+end
+
+Given /I create a forwarded port named "(.+?)" from "(.+?)" to "(.+?)" via VBoxManage/ do |name, guest, host|
+  fp_string = "#{name},tcp,,#{host},,#{guest}"
+  VBoxManage.execute("modifyvm", @name, "--natpf#{@slot}", fp_string)
+end
+
+When /I create a forwarded port named "(.+?)" from "(.+?)" to "(.+?)"$/ do |name, guest, host|
+  @object = VirtualBox::NATForwardedPort.new
+  @object.name = name
+  @object.guestport = guest.to_i
+  @object.hostport = host.to_i
+
+  @relationship.forwarded_ports << @object
+end
+
+When /I update the forwarded port named "(.+?)":/ do |name, table|
+  fp = @relationship.forwarded_ports.find { |fp| fp.name == name }
+  fp.should_not be_nil
+
+  table.hashes.each do |hash|
+    value = hash["value"]
+    value = value.to_i if %W[hostport guestport].include?(hash["attribute"])
+    fp.send("#{hash["attribute"]}=", value)
+  end
+end
+
+When /I delete the forwarded port named "(.+?)"/ do |name|
+  @relationship.forwarded_ports.each do |fp|
+    if fp.name == name
+      fp.destroy
+      break
+    end
+  end
+end
+
+Then /the NAT network should exist/ do
+  # Temporary until we find something to really test
+  @relationship.should_not be_nil
+end
+
+Then /the forwarded port "(.+?)" should exist/ do |name|
+  ports = VBoxManage.forwarded_ports(@output, @slot)
+  ports.should have_key(name)
+end
+
+Then /the forwarded port "(.+?)" should not exist/ do |name|
+  ports = VBoxManage.forwarded_ports(@output, @slot)
+  ports.should_not have_key(name)
+end
+
+Then /the forwarded ports should match/ do
+  ports = VBoxManage.forwarded_ports(@output, @slot)
+
+  @relationship.forwarded_ports.length.should == ports.length
+  @relationship.forwarded_ports.each do |fp|
+    port = ports[fp.name]
+    port.should_not be_nil
+
+    test_mappings(FORWARDED_PORT_MAPPINGS, fp, port)
+  end
+end

data/features/step_definitions/shared_folder_steps.rb

@@ -4,6 +4,12 @@ Given /I add a shared folder "(.+?)" with path "(.+?)" via VBoxManage/ do |name,
                      "--hostpath", hostpath)
 end
 
+Given /I remove all shared folders/ do
+  VBoxManage.shared_folders(@output).each do |name, folder|
+    Given %Q[I delete the shared folder "#{name}" via VBoxManage]
+  end
+end
+
 Given /I delete the shared folder "(.+?)" via VBoxManage/ do |name|
   VBoxManage.execute("sharedfolder", "remove", @name,
                      "--name", name)
@@ -35,12 +41,25 @@ When /I create a new shared folder "(.+?)" with path "(.+?)"/ do |name,hostpath|
   @new_record.host_path = hostpath
 end
 
+When /I update the shared folder named "(.+?)":/ do |name, table|
+  object = @relationship.find { |o| o.name == name }
+  object.should_not be_nil
+
+  table.hashes.each do |hash|
+    object.send("#{hash["attribute"]}=", hash["value"])
+  end
+end
+
 When /I delete the shared folder "(.+?)"$/ do |name|
   @relationship.each do |sf|
     sf.destroy if sf.name == name
   end
 end
 
+Then /the shared folder "(.+?)" should exist/ do |name|
+  VBoxManage.shared_folders(@output).keys.should include(name)
+end
+
 Then /the shared folder "(.+?)" should not exist/ do |name|
   VBoxManage.shared_folders(@output).keys.should_not include(name)
 end

data/features/step_definitions/snapshot_steps.rb

@@ -0,0 +1,74 @@
+Given /the snapshots are cleared/ do
+  snapshot_map(VBoxManage.snapshots(@output)) do |snapshot|
+    VBoxManage.execute("snapshot", @name, "delete", snapshot[:name])
+  end
+end
+
+Given /the following snapshot tree is created:$/ do |tree|
+  tree.hashes.each do |hash|
+    restore_parent = lambda do
+      VBoxManage.execute("snapshot", @name, "restore", hash["key"])
+    end
+
+    begin
+      restore_parent.call
+    rescue Exception
+      VBoxManage.execute("snapshot", @name, "take", hash["key"])
+    end
+
+    hash["children"].split(",").each do |child|
+      VBoxManage.execute("snapshot", @name, "take", child)
+      restore_parent.call
+    end
+  end
+end
+
+Given /the snapshot "(.+?)" is created/ do |name|
+  VBoxManage.execute("snapshot", @name, "take", name)
+end
+
+When /I find the snapshot named "(.+?)"/ do |name|
+  @snapshot = @model.find_snapshot(name)
+  @snapshot.should be
+end
+
+When /I take a snapshot "(.+?)"/ do |name|
+  @model.take_snapshot(name)
+end
+
+When /I destroy the snapshot/ do
+  @snapshot.destroy
+end
+
+Then /the snapshot "(.+?)" should exist/ do |name|
+  result = false
+  snapshot_map(VBoxManage.snapshots(@output)) do |snapshot|
+    result = true if snapshot[:name] == name
+  end
+
+  result.should be
+end
+
+Then /the snapshot "(.+?)" should not exist/ do |name|
+  result = false
+  snapshot_map(VBoxManage.snapshots(@output)) do |snapshot|
+    result = true if snapshot[:name] == name
+  end
+
+  result.should_not be
+end
+
+Then /the snapshots should match/ do
+  @root = @model.root_snapshot
+
+  match_tester = lambda do |current, expected|
+    current.uuid.should == expected[:uuid]
+    current.children.length.should == expected[:children].length
+
+    current.children.each_with_index do |current_child, i|
+      match_tester.call(current_child, expected[:children][i])
+    end
+  end
+
+  match_tester.call(@root, VBoxManage.snapshots(@output))
+end

data/features/support/env.rb

@@ -54,3 +54,9 @@ NETWORK_ADAPTER_MAPPINGS = {
   :mac_address => "macaddress",
   :cable_connected => "cableconnected"
 }
+
+FORWARDED_PORT_MAPPINGS = {
+  :protocol => "protocol",
+  :hostport => "hostport",
+  :guestport => "guestport"
+}

data/features/support/helpers.rb

@@ -3,7 +3,7 @@ module VirtualBox
     # Tests that given a mappings hash (see `VM_MAPPINGS` in env.rb),
     # a model, and an output hash (string to string), that all the
     # mappings from model match output.
-    def test_mappings(mappings, model, output, match=true)
+    def test_mappings(mappings, model, output)
       mappings.each do |model_key, output_key|
         value = model.send(model_key)
 
@@ -17,6 +17,21 @@ module VirtualBox
         value.to_s.should == output_value
       end
     end
+
+    # Applies a function to every snapshot.
+    def snapshot_map(snapshots, &block)
+      applier = lambda do |snapshot|
+        return if !snapshot || snapshot.empty?
+
+        snapshot[:children].each do |child|
+          applier.call(child)
+        end
+
+        block.call(snapshot)
+      end
+
+      applier.call(snapshots)
+    end
   end
 end
 

data/features/support/ordered_hash.rb

@@ -0,0 +1,49 @@
+# A super simple ordered hash implementation. This class probably
+# isn't useful outside of these testing scripts, since only the bare
+# minimum is implemented.
+#
+# The ordered hash is implemented by keeping the key/values in an
+# array where each element is an array of format [key,value]. This
+# forces the keys to be in the proper order, paired with their
+# values.
+class OrderedHash
+  include Enumerable
+
+  def initialize
+    @items = []
+  end
+
+  def []=(key,value)
+    # Try to update it in the array if it exists
+    @items.each_with_index do |data, index|
+      return @items[index][1] = value if data[0] == key
+    end
+
+    # Otherwise just add it to the list
+    @items << [key, value]
+  end
+
+  def [](key)
+    @items.each do |k, v|
+      return v if k == key
+    end
+
+    nil
+  end
+
+  def each(&block)
+    @items.each(&block)
+  end
+
+  def empty?
+    @items.empty?
+  end
+
+  def has_key?(key)
+    @items.each do |k,v|
+      return true if k == key
+    end
+
+    false
+  end
+end

data/features/support/vboxmanage.rb

@@ -32,7 +32,7 @@ class VBoxManage
         ""
       end
 
-      output.split("\n").inject({}) do |acc, line|
+      output.split("\n").inject(OrderedHash.new) do |acc, line|
         if line =~ /^"?(.+?)"?=(.+?)$/
           key = $1.to_s
           value = $2.to_s
@@ -106,5 +106,86 @@ class VBoxManage
         acc
       end
     end
+
+    # Parses the forwarded ports out of the VM info output and returns
+    # it in a hash.
+    def forwarded_ports(info, slot)
+      seen = false
+      info.inject({}) do |acc, data|
+        k,v = data
+
+        seen = true if k == "nic#{slot}"
+        if seen && k =~ /^Forwarding\((\d+)\)$/
+          keys = [:name, :protocol, :hostip, :hostport, :guestip, :guestport]
+          v = v.split(",")
+
+          temp = {}
+          keys.each_with_index do |key, i|
+            temp[key] = v[i]
+          end
+
+          acc[temp.delete(:name)] = temp
+        end
+
+        acc
+      end
+    end
+
+    # Parses the snapshots out of the VM info output and returns it in
+    # a hash.
+    def snapshots(info)
+      info.inject({}) do |acc, data|
+        k,v = data
+
+        if k =~ /^Snapshot(.+?)(-(.+?))?$/
+          current = { $1.to_s.downcase.to_sym => v }
+
+          if $3
+            # This is a child snapshot
+            keys = $3.to_s.split("-").map do |key|
+              key.to_i - 1
+            end
+            final = keys.pop
+
+            location = acc
+            keys.each { |index| location = location[:children][index.to_i] }
+
+            parent = location
+            location = location[:children]
+            location[final] ||= {}
+            location[final].merge!(current)
+            location[final][:parent] = parent
+            location[final][:children] ||= []
+          else
+            acc ||= {}
+            acc.merge!(current)
+            acc[:children] ||= []
+          end
+        end
+
+        acc
+      end
+    end
+
+    # Gets the current snapshot.
+    def current_snapshot(info)
+      seen = false
+      uuid = nil
+      VBoxManage.execute("showvminfo", info["UUID"]).split("\n").each do |line|
+        seen = true if line =~ /^Snapshots:/
+        uuid = $2.to_s if seen && line =~ /Name:\s+(.+?)\s+\(UUID:\s+(.+?)\)\s+\*/
+      end
+
+      # The recursive sub-method which finds a snapshot by UUID
+      finder = lambda do |snapshot|
+        return snapshot if snapshot[:uuid] == uuid
+
+        snapshot[:children].find do |child|
+          finder.call(child)
+        end
+      end
+
+      finder.call(snapshots(info))
+    end
   end
 end

data/features/vm_nat_engine.feature

@@ -0,0 +1,57 @@
+Feature: Virtual Machine NAT Engine
+  As a virtualbox library user
+  I want to read and update the NAT engine on a network adapter
+
+  Background:
+    Given I find a VM identified by "test_vm_A"
+    And the forwarded ports are cleared
+    And the adapters are reset
+    And the following adapters are set:
+      | slot | type |
+      |    1 | nat  |
+    And the "network_adapters" relationship
+    And the "nat_driver" relationship on collection item "1"
+
+  Scenario: Reading the NAT engine
+    Then the NAT network should exist
+
+  @unsafe
+  Scenario: Reading Forwarded Ports
+    Given I read the adapter in slot "1"
+    And I create a forwarded port named "ssh" from "22" to "2222" via VBoxManage
+    And I reload the VM
+    And I read the adapter in slot "1"
+    Then the forwarded port "ssh" should exist
+    And the forwarded ports should match
+
+  @unsafe
+  Scenario: Creating Forwarded Ports
+    Given I read the adapter in slot "1"
+    When I create a forwarded port named "ssh" from "22" to "2222"
+    And I save the relationship
+    And I reload the VM info
+    Then the forwarded port "ssh" should exist
+    And the forwarded ports should match
+
+  @unsafe
+  Scenario: Updating Forwarded Ports
+    Given I read the adapter in slot "1"
+    And I create a forwarded port named "ssh" from "22" to "2222" via VBoxManage
+    And I reload the VM
+    And I read the adapter in slot "1"
+    When I update the forwarded port named "ssh":
+      | attribute | value |
+      | hostport  | 3333  |
+    And I save the relationship
+    And I reload the VM info
+    Then the forwarded ports should match
+
+  @unsafe
+  Scenario: Deleting Forwarded Ports
+    Given I read the adapter in slot "1"
+    And I create a forwarded port named "ssh" from "22" to "2222" via VBoxManage
+    And I reload the VM
+    And I read the adapter in slot "1"
+    When I delete the forwarded port named "ssh"
+    And I reload the VM info
+    Then the forwarded port "ssh" should not exist

data/features/vm_shared_folders.feature

@@ -4,6 +4,8 @@ Feature: Virtual Machine Shared Folders
 
   Background:
     Given I find a VM identified by "test_vm_A"
+    And I remove all shared folders
+    And I reload the VM
     And the "shared_folders" relationship
 
   @unsafe
@@ -18,6 +20,17 @@ Feature: Virtual Machine Shared Folders
     And I add the new record to the relationship
     And I save the model
     And I reload the VM info
+    Then the shared folder "bar" should exist
+    Then the shared folder properties should match
+
+  @unsafe
+  Scenario: Updating Shared Folders
+    Given a shared folder "foo" exists
+    When I update the shared folder named "foo":
+      | attribute | value     |
+      | host_path | /new_path |
+    And I save the model
+    And I reload the VM info
     Then the shared folder properties should match
 
   @unsafe

data/features/vm_snapshots.feature

@@ -0,0 +1,29 @@
+Feature: Virtual Machine Snapshots
+  As a virtualbox library user
+  I want to manage a VM's snapshots
+
+  Background:
+    Given I find a VM identified by "test_vm_A"
+    And the snapshots are cleared
+    And the "current_snapshot" relationship
+
+  Scenario: Reading the snapshots
+    Given the following snapshot tree is created:
+      | key | children  |
+      | foo | bar,baz   |
+      | bar | bar1,bar2 |
+    And I reload the VM
+    Then the snapshots should match
+
+  Scenario: Taking a snapshot
+    When I take a snapshot "foo"
+    And I reload the VM info
+    Then the snapshot "foo" should exist
+
+  Scenario: Deleting a snapshot
+    Given the snapshot "foo" is created
+    And I reload the VM
+    When I find the snapshot named "foo"
+    And I destroy the snapshot
+    And I reload the VM info
+    Then the snapshot "foo" should not exist

data/lib/virtualbox/abstract_model.rb

@@ -35,6 +35,13 @@ module VirtualBox
       def reloaded!
         @_reload = false
       end
+
+      # Default errors for relationship implementation, since this is
+      # a pretty stable method.
+      def errors_for_relationship(caller, data)
+        return data.errors if data.respond_to?(:errors)
+        nil
+      end
     end
 
     # Signals to the class that it should be reloaded. This simply toggles
@@ -70,16 +77,16 @@ module VirtualBox
 
     # Returns the errors for a model.
     def errors
-      error_hash = super
+      self.class.relationships.inject(super) do |acc, data|
+        name, options = data
 
-      self.class.relationships.each do |name, options|
-        next unless options && options[:klass].respond_to?(:errors_for_relationship)
-        relationship_errors = options[:klass].errors_for_relationship(self, relationship_data[name])
+        if options && options[:klass].respond_to?(:errors_for_relationship)
+          errors = options[:klass].errors_for_relationship(self, relationship_data[name])
+          acc.merge!(name => errors) if errors && !errors.empty?
+        end
 
-        error_hash.merge!({ :foos => relationship_errors }) if relationship_errors.length > 0
+        acc
       end
-
-      error_hash
     end
 
     # Validates the model and relationships.
@@ -116,6 +123,15 @@ module VirtualBox
 
       # No longer a new record
       @new_record = false
+
+      true
+    end
+
+    # Saves the model and raises an {Exceptions::ValidationFailedException}
+    # if the model is invalid, instead of returning false.
+    def save!(*args)
+      raise Exceptions::ValidationFailedException.new(errors.inspect) if !save(*args)
+      true
     end
 
     # Saves a single attribute of the model. This method on the abstract

data/lib/virtualbox/abstract_model/relatable.rb

@@ -206,9 +206,13 @@ module VirtualBox
       # In addition to those two args, any arbitrary args may be tacked on to the
       # end and they'll be pushed through to the `save_relationship` method.
       def save_relationships(*args)
-        self.class.relationships.each do |name, options|
-          save_relationship(name, *args)
+        # Can't use `all?` here since it short circuits
+        results = self.class.relationships.collect do |data|
+          name, options = data
+          !!save_relationship(name, *args)
         end
+
+        !results.include?(false)
       end
 
       # Saves a single relationship. It is up to the relationship class to

data/lib/virtualbox/abstract_model/validatable.rb

@@ -164,4 +164,4 @@ module VirtualBox
       end
     end
   end
-end
+end

data/lib/virtualbox/com/mscom_interface.rb

@@ -16,11 +16,30 @@ module VirtualBox
       def initialize_mscom
         require 'win32ole'
 
-        # TODO: Dynamic version finding
-        COM::Util.set_interface_version("3.1.x")
+        interface_dir = File.expand_path(File.join(File.dirname(__FILE__), "interface"))
+        Dir[File.join(interface_dir, "*")].each do |f|
+          p "Checking: #{f}"
+          return if File.directory?(f) && initialize_for_version(File.basename(f))
+        end
+      end
+
+      def initialize_for_version(version)
+        COM::Util.set_interface_version(version)
 
         @virtualbox = COM::Util.versioned_interface(:VirtualBox).new(Implementer::MSCOM, self, WIN32OLE.new("VirtualBox.VirtualBox"))
         @session = COM::Util.versioned_interface(:Session).new(Implementer::MSCOM, self, WIN32OLE.new("VirtualBox.Session"))
+
+        vb_version = @virtualbox.version
+
+        # Check if they match or not.
+        return false if vb_version.length == version.length
+        (0...(version.length)).each do |i|
+          p "Checking: #{version[i,1]} to #{vb_version[i,1]}"
+          next if version[i,1] == "x"
+          return false if version[i,1] != vb_version[i,1]
+        end
+
+        true
       end
     end
   end

data/lib/virtualbox/nat_forwarded_port.rb

@@ -91,8 +91,8 @@ module VirtualBox
             :parent_collection => relation,
             :name => parts[0],
             :protocol => COM::Util.versioned_interface(:NATProtocol).index(parts[1]),
-            :guestport => parts[5],
-            :hostport => parts[3]
+            :guestport => parts[5].to_i,
+            :hostport => parts[3].to_i
           })
 
           port.existing_record!
@@ -136,7 +136,7 @@ module VirtualBox
     def save
       return true if !new_record? && !changed?
       raise Exceptions::ValidationFailedException.new(errors) if !valid?
-      destroy if !new_record?
+      destroy(false) if !new_record?
 
       parent.modify_engine do |nat|
         nat.add_redirect(name, protocol, "", hostport, "", guestport)
@@ -150,13 +150,13 @@ module VirtualBox
     # Destroys the port forwarding mapping.
     #
     # @return [Boolean] True if command was successful, false otherwise.
-    def destroy
+    def destroy(update_collection=true)
       return if new_record?
       previous_name = name_changed? ? name_was : name
       parent.modify_engine do |nat|
         nat.remove_redirect(previous_name)
       end
-      parent_collection.delete(self, true) if parent_collection
+      parent_collection.delete(self, true) if parent_collection && update_collection
       new_record!
       true
     end

data/lib/virtualbox/network_adapter.rb

@@ -1,19 +1,30 @@
 module VirtualBox
   # Represents a single NIC (Network Interface Card) of a virtual machine.
   #
-  # **Currently, new NICs can't be created, so the only way to get this
-  # object is through a {VM}'s `nics` relationship.**
+  # # Create a Network Adapter
   #
-  # # Editing a NIC
+  # There is no need to have the ability to create a network adapter,
+  # since when creating a VM from scratch, all eight network adapter
+  # slots are created, but set to `attachment_type` `nil`. Simply
+  # modify the adapter you're interested in and save.
   #
-  # Nics can be modified directly in their relationship to other
+  #
+  # # Editing a Network Adapter
+  #
+  # Network adapters can be modified directly in their relationship to other
   # virtual machines. When {VM#save} is called, it will also save any
-  # changes to its relationships.
+  # changes to its relationships. Additionally, you may call {#save}
+  # on the relationship itself.
   #
   #     vm = VirtualBox::VM.find("foo")
-  #     vm.nics[0].macaddress = @new_mac_address
+  #     vm.network_adapters[0].macaddress = @new_mac_address
   #     vm.save
   #
+  # # Destroying a Network Adapter
+  #
+  # Network adapters can not actually be "destroyed" but can be
+  # removed by setting the `attachment_type` to `nil` and saving.
+  #
   # # Attributes
   #
   # Properties of the model are exposed using standard ruby instance
@@ -25,12 +36,16 @@ module VirtualBox
   # listed below. If you aren't sure what this means or you can't understand
   # why the below is listed, please read {Attributable}.
   #
-  #     attribute :parent, :readonly => :readonly
-  #     attribute :nic
-  #     attribute :nictype
-  #     attribute :macaddress
-  #     attribute :cableconnected
-  #     attribute :bridgeadapter
+  #     attribute :slot, :readonly => true
+  #     attribute :enabled, :boolean => true
+  #     attribute :attachment_type
+  #     attribute :adapter_type
+  #     attribute :mac_address
+  #     attribute :cable_connected, :boolean => true
+  #     attribute :nat_network
+  #     attribute :internal_network
+  #     attribute :host_interface
+  #     attribute :interface, :readonly => true, :property => false
   #
   class NetworkAdapter < AbstractModel
     attribute :parent, :readonly => true, :property => false

data/lib/virtualbox/proxies/collection.rb

@@ -29,6 +29,14 @@ module VirtualBox
         item
       end
 
+      # Returns the errors associated with all the items in this
+      # collection
+      def errors
+        collect do |item|
+          item.respond_to?(:errors) ? item.errors : {}
+        end
+      end
+
       def <<(item)
         item.added_to_relationship(self) if item.respond_to?(:added_to_relationship)
         push(item)

data/lib/virtualbox/shared_folder.rb

@@ -168,7 +168,7 @@ module VirtualBox
       if !new_record?
         # If its not a new record, any changes will require a new shared
         # folder to be created, so we first destroy it then recreate it.
-        destroy
+        destroy(false)
       end
 
       create
@@ -204,14 +204,14 @@ module VirtualBox
     # from the host system. Instead, it simply removes the mapping to the
     # virtual machine, meaning it will no longer be possible to mount it
     # from within the virtual machine.
-    def destroy
+    def destroy(update_collection=true)
       parent.with_open_session do |session|
         machine = session.machine
         machine.remove_shared_folder(name)
       end
 
       # Remove it from it's parent collection
-      parent_collection.delete(self, true) if parent_collection
+      parent_collection.delete(self, true) if parent_collection && update_collection
 
       # Mark as a new record so if it is saved again, it will create it
       new_record!

data/test/virtualbox/abstract_model/relatable_test.rb

@@ -209,11 +209,11 @@ class RelatableTest < Test::Unit::TestCase
     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
+      @model.expects(:save_relationship).with(:foos).returns(true)
+      @model.expects(:save_relationship).with(:bars).returns(true)
+      @model.expects(:save_relationship).with(:bazs).returns(true)
+      @model.expects(:save_relationship).with(:vers).returns(true)
+      assert @model.save_relationships
     end
 
     should "not call save_relationship on non-loaded relations" do
@@ -234,8 +234,8 @@ class RelatableTest < Test::Unit::TestCase
     end
 
     should "call save_relationship on the related class" do
-      Relatee.expects(:save_relationship).with(@model, @model.foos).once
-      @model.save_relationship(:foos)
+      Relatee.expects(:save_relationship).with(@model, @model.foos).once.returns(:r)
+      assert_equal :r, @model.save_relationship(:foos)
     end
 
     should "forward parameters through" do

data/test/virtualbox/abstract_model_test.rb

@@ -68,6 +68,23 @@ class AbstractModelTest < Test::Unit::TestCase
     end
   end
 
+  context "errors for relationship default implementation" do
+    setup do
+      @klass = FakeModel
+    end
+
+    should "return the errors on the item" do
+      errors = mock("errors")
+      item = mock("item")
+      item.stubs(:errors).returns(errors)
+      assert_equal errors, @klass.errors_for_relationship(nil, item)
+    end
+
+    should "return nil if the item doesn't respond to errors" do
+      assert_nil @klass.errors_for_relationship(nil, 7)
+    end
+  end
+
   context "lazy attributes and relationships" do
     class LazyModel < VirtualBox::AbstractModel
       attribute :foo, :lazy => true
@@ -285,6 +302,29 @@ class AbstractModelTest < Test::Unit::TestCase
       @model.foo = "foo2"
       @model.save("YES")
     end
+
+    should "return true if succeeds" do
+      assert @model.save
+    end
+  end
+
+  context "save!" do
+    setup do
+      @model = FakeModel.new
+    end
+
+    should "raise an exception if save failed" do
+      args = %W[foo bar baz]
+      @model.expects(:save).with(*args).returns(false)
+      assert_raises(VirtualBox::Exceptions::ValidationFailedException) {
+        @model.save!(*args)
+      }
+    end
+
+    should "not raise an exception if save succeeds" do
+      @model.expects(:save).returns(true)
+      assert_nothing_raised { @model.save! }
+    end
   end
 
   context "populating relationships and attributes" do

data/test/virtualbox/nat_forwarded_port_test.rb

@@ -98,7 +98,7 @@ class NATForwardedPortTest < Test::Unit::TestCase
 
         should "call destroy if not a new record" do
           @port.name = "diff"
-          @port.expects(:destroy).once
+          @port.expects(:destroy).with(false).once
           @port.save
         end
       end
@@ -155,6 +155,12 @@ class NATForwardedPortTest < Test::Unit::TestCase
         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
@@ -202,8 +208,8 @@ class NATForwardedPortTest < Test::Unit::TestCase
 
       should "have the proper data" do
         object = @objects.first
-        assert_equal "22", object.guestport
-        assert_equal "2222", object.hostport
+        assert_equal 22, object.guestport
+        assert_equal 2222, object.hostport
         assert_equal :tcp, object.protocol
         assert_equal @objects, object.parent_collection
       end

data/test/virtualbox/proxies/collection_test.rb

@@ -40,6 +40,21 @@ class CollectionTest < Test::Unit::TestCase
     end
   end
 
+  context "errors" do
+    should "return the errors of all the elements" do
+      errors = []
+      3.times do |i|
+        error = "error#{i}"
+        item = mock("item")
+        item.stubs(:errors).returns(error)
+        errors << error
+        @collection << item
+      end
+
+      assert_equal errors, @collection.errors
+    end
+  end
+
   context "element callbacks" do
     setup do
       @item = mock("item")

data/test/virtualbox/shared_folder_test.rb

@@ -130,7 +130,7 @@ class SharedFolderTest < Test::Unit::TestCase
         assert !@instance.new_record? # sanity
 
         save_seq = sequence("save_seq")
-        @instance.expects(:destroy).once.in_sequence(save_seq)
+        @instance.expects(:destroy).with(false).once.in_sequence(save_seq)
         @instance.expects(:create).once.in_sequence(save_seq)
 
         @instance.save
@@ -195,6 +195,12 @@ class SharedFolderTest < Test::Unit::TestCase
         assert !@collection.include?(@instance)
       end
 
+      should "not remove itself from it's collection if specified" do
+        assert @collection.include?(@instance)
+        @instance.destroy(false)
+        assert @collection.include?(@instance)
+      end
+
       should "destroy the shared folder on the parent" do
         destroy_seq = sequence("destroy_seq")
         @machine.expects(:remove_shared_folder).with(@name).in_sequence(destroy_seq)

data/virtualbox.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{virtualbox}
-  s.version = "0.7.3"
+  s.version = "0.7.4"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Mitchell Hashimoto"]
-  s.date = %q{2010-06-28}
+  s.date = %q{2010-07-19}
   s.description = %q{Create and modify virtual machines in VirtualBox using pure ruby.}
   s.email = %q{mitchell.hashimoto@gmail.com}
   s.extra_rdoc_files = [
@@ -31,14 +31,17 @@ Gem::Specification.new do |s|
      "features/step_definitions/abstract_model_steps.rb",
      "features/step_definitions/extra_data_steps.rb",
      "features/step_definitions/global_steps.rb",
+     "features/step_definitions/nat_engine_steps.rb",
      "features/step_definitions/network_adapter_steps.rb",
      "features/step_definitions/shared_folder_steps.rb",
+     "features/step_definitions/snapshot_steps.rb",
      "features/step_definitions/storage_controller_steps.rb",
      "features/step_definitions/virtualbox_steps.rb",
      "features/step_definitions/vm_steps.rb",
      "features/support/env.rb",
      "features/support/helpers.rb",
      "features/support/hooks.rb",
+     "features/support/ordered_hash.rb",
      "features/support/vboxmanage.rb",
      "features/version.feature",
      "features/vm.feature",
@@ -46,8 +49,10 @@ Gem::Specification.new do |s|
      "features/vm_cpu.feature",
      "features/vm_extra_data.feature",
      "features/vm_hw_virt.feature",
+     "features/vm_nat_engine.feature",
      "features/vm_network_adapters.feature",
      "features/vm_shared_folders.feature",
+     "features/vm_snapshots.feature",
      "features/vm_storage_controllers.feature",
      "lib/virtualbox.rb",
      "lib/virtualbox/abstract_model.rb",
@@ -298,69 +303,69 @@ Gem::Specification.new do |s|
   s.homepage = %q{http://github.com/mitchellh/virtualbox}
   s.rdoc_options = ["--charset=UTF-8"]
   s.require_paths = ["lib"]
-  s.rubygems_version = %q{1.3.6}
+  s.rubygems_version = %q{1.3.7}
   s.summary = %q{Create and modify virtual machines in VirtualBox using pure ruby.}
   s.test_files = [
-    "test/virtualbox_test.rb",
-     "test/test_helper.rb",
-     "test/virtualbox/network_adapter_test.rb",
-     "test/virtualbox/storage_controller_test.rb",
-     "test/virtualbox/host_test.rb",
-     "test/virtualbox/vm_test.rb",
-     "test/virtualbox/virtual_system_description_test.rb",
-     "test/virtualbox/vrdp_server_test.rb",
-     "test/virtualbox/nat_forwarded_port_test.rb",
-     "test/virtualbox/appliance_test.rb",
-     "test/virtualbox/medium_attachment_test.rb",
-     "test/virtualbox/audio_adapter_test.rb",
-     "test/virtualbox/cpu_test.rb",
-     "test/virtualbox/abstract_model/version_matcher_test.rb",
-     "test/virtualbox/abstract_model/validatable_test.rb",
+    "test/test_helper.rb",
      "test/virtualbox/abstract_model/attributable_test.rb",
-     "test/virtualbox/abstract_model/relatable_test.rb",
      "test/virtualbox/abstract_model/dirty_test.rb",
      "test/virtualbox/abstract_model/interface_attributes_test.rb",
-     "test/virtualbox/host_network_interface_test.rb",
-     "test/virtualbox/lib_test.rb",
-     "test/virtualbox/system_properties_test.rb",
-     "test/virtualbox/snapshot_test.rb",
-     "test/virtualbox/usb_controller_test.rb",
-     "test/virtualbox/forwarded_port_test.rb",
-     "test/virtualbox/dvd_test.rb",
-     "test/virtualbox/hard_drive_test.rb",
+     "test/virtualbox/abstract_model/relatable_test.rb",
+     "test/virtualbox/abstract_model/validatable_test.rb",
+     "test/virtualbox/abstract_model/version_matcher_test.rb",
      "test/virtualbox/abstract_model_test.rb",
-     "test/virtualbox/dhcp_server_test.rb",
-     "test/virtualbox/proxies/collection_test.rb",
-     "test/virtualbox/com/implementer/base_test.rb",
-     "test/virtualbox/com/implementer/mscom_test.rb",
-     "test/virtualbox/com/implementer/ffi_test.rb",
-     "test/virtualbox/com/ffi/util_test.rb",
+     "test/virtualbox/appliance_test.rb",
+     "test/virtualbox/audio_adapter_test.rb",
+     "test/virtualbox/bios_test.rb",
+     "test/virtualbox/com/abstract_enum_test.rb",
+     "test/virtualbox/com/abstract_implementer_test.rb",
+     "test/virtualbox/com/abstract_interface_test.rb",
      "test/virtualbox/com/ffi/interface_test.rb",
+     "test/virtualbox/com/ffi/util_test.rb",
      "test/virtualbox/com/ffi_interface_test.rb",
-     "test/virtualbox/com/util_test.rb",
-     "test/virtualbox/com/abstract_interface_test.rb",
+     "test/virtualbox/com/implementer/base_test.rb",
+     "test/virtualbox/com/implementer/ffi_test.rb",
+     "test/virtualbox/com/implementer/mscom_test.rb",
      "test/virtualbox/com/mscom_interface_test.rb",
-     "test/virtualbox/com/abstract_enum_test.rb",
-     "test/virtualbox/com/abstract_implementer_test.rb",
-     "test/virtualbox/shared_folder_test.rb",
-     "test/virtualbox/global_test.rb",
+     "test/virtualbox/com/util_test.rb",
+     "test/virtualbox/cpu_test.rb",
+     "test/virtualbox/dhcp_server_test.rb",
+     "test/virtualbox/dvd_test.rb",
+     "test/virtualbox/ext/byte_normalizer_test.rb",
+     "test/virtualbox/ext/platform_test.rb",
+     "test/virtualbox/ext/subclass_listing_test.rb",
      "test/virtualbox/extra_data_test.rb",
-     "test/virtualbox/bios_test.rb",
+     "test/virtualbox/forwarded_port_test.rb",
+     "test/virtualbox/global_test.rb",
+     "test/virtualbox/hard_drive_test.rb",
+     "test/virtualbox/host_network_interface_test.rb",
+     "test/virtualbox/host_test.rb",
      "test/virtualbox/hw_virtualization_test.rb",
+     "test/virtualbox/lib_test.rb",
+     "test/virtualbox/medium_attachment_test.rb",
      "test/virtualbox/medium_test.rb",
+     "test/virtualbox/nat_engine_test.rb",
+     "test/virtualbox/nat_forwarded_port_test.rb",
+     "test/virtualbox/network_adapter_test.rb",
+     "test/virtualbox/proxies/collection_test.rb",
+     "test/virtualbox/shared_folder_test.rb",
+     "test/virtualbox/snapshot_test.rb",
+     "test/virtualbox/storage_controller_test.rb",
+     "test/virtualbox/system_properties_test.rb",
+     "test/virtualbox/usb_controller_test.rb",
      "test/virtualbox/usb_device_filter_test.rb",
-     "test/virtualbox/ext/byte_normalizer_test.rb",
-     "test/virtualbox/ext/subclass_listing_test.rb",
-     "test/virtualbox/ext/platform_test.rb",
      "test/virtualbox/version_test.rb",
-     "test/virtualbox/nat_engine_test.rb"
+     "test/virtualbox/virtual_system_description_test.rb",
+     "test/virtualbox/vm_test.rb",
+     "test/virtualbox/vrdp_server_test.rb",
+     "test/virtualbox_test.rb"
   ]
 
   if s.respond_to? :specification_version then
     current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
     s.specification_version = 3
 
-    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
       s.add_runtime_dependency(%q<ffi>, [">= 0.6.3"])
     else
       s.add_dependency(%q<ffi>, [">= 0.6.3"])

metadata

@@ -1,12 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: virtualbox
 version: !ruby/object:Gem::Version 
+  hash: 11
   prerelease: false
   segments: 
   - 0
   - 7
-  - 3
-  version: 0.7.3
+  - 4
+  version: 0.7.4
 platform: ruby
 authors: 
 - Mitchell Hashimoto
@@ -14,16 +15,18 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-06-28 00:00:00 -07:00
+date: 2010-07-19 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: ffi
   prerelease: false
   requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        hash: 1
         segments: 
         - 0
         - 6
@@ -55,14 +58,17 @@ files:
 - features/step_definitions/abstract_model_steps.rb
 - features/step_definitions/extra_data_steps.rb
 - features/step_definitions/global_steps.rb
+- features/step_definitions/nat_engine_steps.rb
 - features/step_definitions/network_adapter_steps.rb
 - features/step_definitions/shared_folder_steps.rb
+- features/step_definitions/snapshot_steps.rb
 - features/step_definitions/storage_controller_steps.rb
 - features/step_definitions/virtualbox_steps.rb
 - features/step_definitions/vm_steps.rb
 - features/support/env.rb
 - features/support/helpers.rb
 - features/support/hooks.rb
+- features/support/ordered_hash.rb
 - features/support/vboxmanage.rb
 - features/version.feature
 - features/vm.feature
@@ -70,8 +76,10 @@ files:
 - features/vm_cpu.feature
 - features/vm_extra_data.feature
 - features/vm_hw_virt.feature
+- features/vm_nat_engine.feature
 - features/vm_network_adapters.feature
 - features/vm_shared_folders.feature
+- features/vm_snapshots.feature
 - features/vm_storage_controllers.feature
 - lib/virtualbox.rb
 - lib/virtualbox/abstract_model.rb
@@ -328,77 +336,81 @@ rdoc_options:
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
       segments: 
       - 0
       version: "0"
 required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
       segments: 
       - 0
       version: "0"
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.6
+rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
 summary: Create and modify virtual machines in VirtualBox using pure ruby.
 test_files: 
-- test/virtualbox_test.rb
 - test/test_helper.rb
-- test/virtualbox/network_adapter_test.rb
-- test/virtualbox/storage_controller_test.rb
-- test/virtualbox/host_test.rb
-- test/virtualbox/vm_test.rb
-- test/virtualbox/virtual_system_description_test.rb
-- test/virtualbox/vrdp_server_test.rb
-- test/virtualbox/nat_forwarded_port_test.rb
-- test/virtualbox/appliance_test.rb
-- test/virtualbox/medium_attachment_test.rb
-- test/virtualbox/audio_adapter_test.rb
-- test/virtualbox/cpu_test.rb
-- test/virtualbox/abstract_model/version_matcher_test.rb
-- test/virtualbox/abstract_model/validatable_test.rb
 - test/virtualbox/abstract_model/attributable_test.rb
-- test/virtualbox/abstract_model/relatable_test.rb
 - test/virtualbox/abstract_model/dirty_test.rb
 - test/virtualbox/abstract_model/interface_attributes_test.rb
-- test/virtualbox/host_network_interface_test.rb
-- test/virtualbox/lib_test.rb
-- test/virtualbox/system_properties_test.rb
-- test/virtualbox/snapshot_test.rb
-- test/virtualbox/usb_controller_test.rb
-- test/virtualbox/forwarded_port_test.rb
-- test/virtualbox/dvd_test.rb
-- test/virtualbox/hard_drive_test.rb
+- test/virtualbox/abstract_model/relatable_test.rb
+- test/virtualbox/abstract_model/validatable_test.rb
+- test/virtualbox/abstract_model/version_matcher_test.rb
 - test/virtualbox/abstract_model_test.rb
-- test/virtualbox/dhcp_server_test.rb
-- test/virtualbox/proxies/collection_test.rb
-- test/virtualbox/com/implementer/base_test.rb
-- test/virtualbox/com/implementer/mscom_test.rb
-- test/virtualbox/com/implementer/ffi_test.rb
-- test/virtualbox/com/ffi/util_test.rb
+- test/virtualbox/appliance_test.rb
+- test/virtualbox/audio_adapter_test.rb
+- test/virtualbox/bios_test.rb
+- test/virtualbox/com/abstract_enum_test.rb
+- test/virtualbox/com/abstract_implementer_test.rb
+- test/virtualbox/com/abstract_interface_test.rb
 - test/virtualbox/com/ffi/interface_test.rb
+- test/virtualbox/com/ffi/util_test.rb
 - test/virtualbox/com/ffi_interface_test.rb
-- test/virtualbox/com/util_test.rb
-- test/virtualbox/com/abstract_interface_test.rb
+- test/virtualbox/com/implementer/base_test.rb
+- test/virtualbox/com/implementer/ffi_test.rb
+- test/virtualbox/com/implementer/mscom_test.rb
 - test/virtualbox/com/mscom_interface_test.rb
-- test/virtualbox/com/abstract_enum_test.rb
-- test/virtualbox/com/abstract_implementer_test.rb
-- test/virtualbox/shared_folder_test.rb
-- test/virtualbox/global_test.rb
+- test/virtualbox/com/util_test.rb
+- test/virtualbox/cpu_test.rb
+- test/virtualbox/dhcp_server_test.rb
+- test/virtualbox/dvd_test.rb
+- test/virtualbox/ext/byte_normalizer_test.rb
+- test/virtualbox/ext/platform_test.rb
+- test/virtualbox/ext/subclass_listing_test.rb
 - test/virtualbox/extra_data_test.rb
-- test/virtualbox/bios_test.rb
+- test/virtualbox/forwarded_port_test.rb
+- test/virtualbox/global_test.rb
+- test/virtualbox/hard_drive_test.rb
+- test/virtualbox/host_network_interface_test.rb
+- test/virtualbox/host_test.rb
 - test/virtualbox/hw_virtualization_test.rb
+- test/virtualbox/lib_test.rb
+- test/virtualbox/medium_attachment_test.rb
 - test/virtualbox/medium_test.rb
+- test/virtualbox/nat_engine_test.rb
+- test/virtualbox/nat_forwarded_port_test.rb
+- test/virtualbox/network_adapter_test.rb
+- test/virtualbox/proxies/collection_test.rb
+- test/virtualbox/shared_folder_test.rb
+- test/virtualbox/snapshot_test.rb
+- test/virtualbox/storage_controller_test.rb
+- test/virtualbox/system_properties_test.rb
+- test/virtualbox/usb_controller_test.rb
 - test/virtualbox/usb_device_filter_test.rb
-- test/virtualbox/ext/byte_normalizer_test.rb
-- test/virtualbox/ext/subclass_listing_test.rb
-- test/virtualbox/ext/platform_test.rb
 - test/virtualbox/version_test.rb
-- test/virtualbox/nat_engine_test.rb
+- test/virtualbox/virtual_system_description_test.rb
+- test/virtualbox/vm_test.rb
+- test/virtualbox/vrdp_server_test.rb
+- test/virtualbox_test.rb