virtualbox 0.2.0 → 0.3.0

data/.yardopts

@@ -1,3 +1,4 @@
 -
 docs/GettingStarted.md
+docs/WhatsNew.md
 TODO

data/TODO

@@ -5,6 +5,5 @@ But they will definitely all make it for version 1.0.
 
 * Creating a VM from scratch (non-import)
 * Parsing bridged IFs
-* Shared folders
 * Snapshots
 * Getting/Setting guest properties

data/VERSION

@@ -1 +1 @@
-0.2.0
+0.3.0

data/docs/WhatsNew.md

@@ -0,0 +1,41 @@
+# What's New in 0.3.x?
+
+## Shared Folders
+
+Shared folders are a great feature of VirtualBox which allows the host system
+to share data with guest systems easily using the native filesystem. Attaching,
+modifying, and removing these shared folders are now supported. A quick example
+below:
+
+    vm = VirtualBox::VM.find("FooVM")
+    folder = VirtualBox::SharedFolder.new
+    folder.name = "hosthome"
+    folder.hostpath = "/home/username"
+    vm.shared_folders << folder
+    vm.save
+
+For full documentation on this new feature, read about them at
+{VirtualBox::SharedFolder}.
+
+## Validations
+
+Many of the models for the virtualbox library now come complete with data
+validations. These validations are performed within the library itself prior to
+calling the virtualbox commands. They work very much the same was as ActiveRecord
+validations:
+
+    sf = VirtualBox::SharedFolder.new(hash_of_values)
+    if !sf.valid?
+      puts "#{sf.errors.length} errors with the folder"
+    else
+      sf.save
+    end
+
+In addition to `valid?` there is `errors` which returns a hash of all the errors,
+including errors on relationships. There is also the `validate` method which
+runs the validations, but you really shouldn't have the need to call that directly.
+
+All validations are run automatically on `save`, which will return `false` if
+they fail. If you choose to raise errors on the save, a `ValidationFailedException`
+will be raised (in contrast to a `CommandFailedException`, which serves its own
+role).

data/lib/virtualbox.rb

@@ -8,5 +8,6 @@ require 'virtualbox/attached_device'
 require 'virtualbox/dvd'
 require 'virtualbox/hard_drive'
 require 'virtualbox/nic'
+require 'virtualbox/shared_folder'
 require 'virtualbox/storage_controller'
 require 'virtualbox/vm'

data/lib/virtualbox/abstract_model.rb

@@ -1,6 +1,7 @@
 require 'virtualbox/abstract_model/attributable'
 require 'virtualbox/abstract_model/dirty'
 require 'virtualbox/abstract_model/relatable'
+require 'virtualbox/abstract_model/validatable'
 
 module VirtualBox
   # AbstractModel is the base class used for most of virtualbox's classes.
@@ -11,6 +12,7 @@ module VirtualBox
     include Attributable
     include Dirty
     include Relatable
+    include Validatable
     
     # Returns a boolean denoting if the record is new or existing. This
     # method is provided for subclasses to use to differentiate between
@@ -36,6 +38,35 @@ module VirtualBox
       @new_record = false
     end
     
+    # Returns the errors for a model.
+    def errors
+      error_hash = super
+      
+      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])
+        
+        error_hash.merge!({ :foos => relationship_errors }) if relationship_errors.length > 0
+      end
+      
+      error_hash
+    end
+    
+    # Validates the model and relationships.
+    def validate(*args)
+      # First clear all previous errors
+      clear_errors
+      
+      # Then do the validations
+      failed = false
+      self.class.relationships.each do |name, options|
+        next unless options && options[:klass].respond_to?(:validate_relationship)
+        failed = true if !options[:klass].validate_relationship(self, relationship_data[name], *args)
+      end
+      
+      return !failed
+    end
+    
     # Saves the model attributes and relationships.
     #
     # The method can be passed any arbitrary arguments, which are 

data/lib/virtualbox/abstract_model/validatable.rb

@@ -0,0 +1,44 @@
+module VirtualBox
+  class AbstractModel
+    # Provides validation methods for a class. Unlike ActiveRecord,
+    # validations are instance-level rather than class-level.
+    module Validatable
+      def errors
+        @errors ||= {}
+      end
+      
+      def add_error(field, error)
+        errors[field] ||= []
+        errors[field].push(error)
+      end
+      
+      def clear_errors
+        @errors = {}
+      end
+
+      def valid?
+        validate
+        errors.empty?
+      end
+      
+      # Subclasses should override this method.
+      def validate
+        true
+      end
+      
+      def validates_presence_of(field)
+        if field.is_a?(Array)
+          field.map { |v| validates_presence_of(v) }.all? { |v| v == true }
+        else
+          value = send(field)
+          if value.nil? || value == ""
+            add_error(field, "must not be blank.")
+            return false
+          else
+            return true
+          end
+        end
+      end
+    end
+  end
+end

data/lib/virtualbox/attached_device.rb

@@ -140,16 +140,28 @@ module VirtualBox
       end
     end
     
+    # Validates an attached device.
+    def validate
+      super
+      
+      validates_presence_of :parent
+      validates_presence_of :image
+      validates_presence_of :port
+    end
+    
     # Saves or creates an attached device.
     #
     # @param [Boolean] raise_errors If true, {Exceptions::CommandFailedException}
     #   will be raised if the command failed.
     # @return [Boolean] True if command was successful, false otherwise.
-    def save(raise_errors=false)
-      raise Exceptions::NoParentException.new if parent.nil?
-      raise Exceptions::InvalidObjectException.new("Image must be set") if image.nil?
+    def save(raise_errors=false)      
       return true unless changed?
       
+      if !valid?
+        raise Exceptions::ValidationFailedException.new(errors) if raise_errors
+        return false
+      end
+      
       # If the port changed, we have to destroy the old one, then create
       # a new one
       destroy({:port => port_was}, raise_errors) if port_changed? && !port_was.nil?

data/lib/virtualbox/exceptions.rb

@@ -5,9 +5,8 @@ module VirtualBox
     class Exception < ::Exception; end
 
     class CommandFailedException < Exception; end
-    class InvalidObjectException < Exception; end
     class InvalidRelationshipObjectException < Exception; end
     class NonSettableRelationshipException < Exception; end
-    class NoParentException < Exception; end
+    class ValidationFailedException < Exception; end
   end
 end

data/lib/virtualbox/hard_drive.rb

@@ -138,6 +138,14 @@ module VirtualBox
       "hdd"
     end
     
+    # Validates a hard drive.
+    def validate
+      super
+      
+      validates_presence_of :format
+      validates_presence_of :size
+    end
+    
     # Creates a new hard drive. 
     #
     # **This method should NEVER be called. Call {#save} instead.**
@@ -146,6 +154,11 @@ module VirtualBox
     #   will be raised if the command failed.
     # @return [Boolean] True if command was successful, false otherwise.
     def create(raise_errors=false)
+      if !valid?
+        raise Exceptions::ValidationFailedException.new(errors) if raise_errors
+        return false
+      end
+      
       raw = Command.vboxmanage("createhd --filename #{location} --size #{size} --format #{read_attribute(:format)} --remember")
       return nil unless raw =~ /UUID: (.+?)$/
       

data/lib/virtualbox/shared_folder.rb

@@ -0,0 +1,243 @@
+module VirtualBox
+  # Represents a shared folder in VirtualBox. In VirtualBox, shared folders are a
+  # method for basically "symlinking" a folder on the guest system to a folder which
+  # exists on the host system. This allows for sharing of files across the virtual
+  # machine. 
+  #
+  # **Note:** Whenever modifying shared folders on a VM, the changes won't take
+  # effect until a _cold reboot_ occurs. This means actually closing the virtual
+  # machine _completely_, then restarting it. You can't just hit "Start > Restart"
+  # or do a `sudo reboot`. It doesn't work that way!
+  #
+  # # Getting Shared Folders
+  #
+  # All shared folders are attached to a {VM} object, by definition. Therefore, to
+  # get a list of the shared folders, first {VM.find find} the VM you need, then
+  # use the `shared_folders` relationship to access an array of the shared folders.
+  # With this array, you can create, modify, update, and delete the shared folders
+  # for that virtual machine.
+  #
+  # # Creating a Shared Folder
+  #
+  # **This whole section will assume you already looked up a {VM} and assigned it to
+  # a local variable named `vm`.**
+  #
+  # With a VM found, creating a shared folder is just a few lines of code:
+  #
+  #     folder = VirtualBox::SharedFolder.new
+  #     folder.name = "desktop-images"
+  #     folder.hostpath = File.expand_path("~/Desktop/images")
+  #     vm.shared_folders << folder
+  #     folder.save # Or you can call vm.save, which works too!
+  #
+  # # Modifying an Existing Shared Folder
+  #
+  # **This whole section will assume you already looked up a {VM} and assigned it to
+  # a local variable named `vm`.**
+  #
+  # Nothing tricky here: You treat existing shared folder objects just as if they
+  # were new ones. Assign a new name and/or a new path, then save. 
+  #
+  #     folder = vm.shared_folders.first
+  #     folder.name = "rufus"
+  #     folder.save # Or vm.save
+  #
+  # **Note**: The VirtualBox-saavy will know that VirtualBox doesn't actually
+  # expose a way to edit shared folders. Under the hood, the virtualbox ruby
+  # library is actually deleting the old shared folder, then creating a new
+  # one with the new details. This shouldn't affect the way anything works for
+  # the VM itself.
+  #
+  # # Deleting a Shared Folder
+  #
+  # **This whole section will assume you already looked up a {VM} and assigned it to
+  # a local variable named `vm`.**
+  #
+  #     folder = vm.shared_folder.first
+  #     folder.destroy
+  #
+  # Poof! It'll be gone. This is usually the place where I warn you about this
+  # being non-reversable, but since no _data_ was actually destroyed, this is
+  # not too risky. You could always just recreate the shared folder with the
+  # same name and path and it'll be like nothing happened.
+  #
+  # # Attributes and Relationships
+  #
+  # Properties of the model are exposed using standard ruby instance
+  # methods which are generated on the fly. Because of this, they are not listed
+  # below as available instance methods. 
+  #
+  # These attributes can be accessed and modified via standard ruby-style
+  # `instance.attribute` and `instance.attribute=` methods. The attributes are
+  # listed below.
+  #
+  # Relationships are also accessed like attributes but can't be set. Instead,
+  # they are typically references to other objects such as an {AttachedDevice} which
+  # in turn have their own attributes which can be modified.
+  #
+  # ## Attributes
+  #
+  # This is copied directly from the class header, but lists all available
+  # attributes. If you don't understand what this means, read {Attributable}.
+  #
+  #     attribute :parent, :readonly => :readonly
+  #     attribute :name
+  #     attribute :hostpath
+  #
+  class SharedFolder < AbstractModel
+    attribute :parent, :readonly => :readonly
+    attribute :name, :populate_key => "SharedFolderNameMachineMapping"
+    attribute :hostpath, :populate_key => "SharedFolderPathMachineMapping"
+    
+    class <<self
+      # Populates the shared folder relationship for anything which is related to it.
+      #
+      # **This method typically won't be used except internally.**
+      #
+      # @return [Array<SharedFolder>]
+      def populate_relationship(caller, data)
+        relation = []
+        
+        counter = 1
+        loop do
+          break unless data["SharedFolderNameMachineMapping#{counter}".downcase.to_sym]
+          
+          folder = new(counter, caller, data)
+          relation.push(folder)
+          counter += 1
+        end
+        
+        relation
+      end
+      
+      # Saves the relationship. This simply calls {#save} on every
+      # member of the relationship.
+      #
+      # **This method typically won't be used except internally.**
+      def save_relationship(caller, data)
+        # Just call save on each folder with the VM
+        data.each do |sf|
+          sf.save
+        end
+      end
+    end
+    
+    # @overload initialize(data={})
+    #   Creates a new SharedFolder which is a new record. This
+    #   should be attached to a VM and saved.
+    #   @param [Hash] data (optional) A hash which contains initial attribute
+    #     values for the SharedFolder.
+    # @overload initialize(index, caller, data)
+    #   Creates an SharedFolder for a relationship. **This should
+    #   never be called except internally.**
+    #   @param [Integer] index Index of the shared folder
+    #   @param [Object] caller The parent
+    #   @param [Hash] data A hash of data which must be used
+    #     to extract the relationship data.
+    def initialize(*args)
+      super()
+      
+      if args.length == 3
+        initialize_for_relationship(*args)
+      elsif args.length == 1
+        initialize_for_data(*args)
+      elsif args.length == 0
+        return
+      else
+        raise NoMethodError.new
+      end
+    end
+    
+    # Initializes the record for use in a relationship. This
+    # is automatically called by {#initialize} if it has three
+    # parameters.
+    #
+    # **This method typically won't be used except internally.**
+    def initialize_for_relationship(index, caller, data)
+      # Setup the index specific attributes
+      populate_data = {}
+      self.class.attributes.each do |name, options|
+        key = options[:populate_key] || name
+        value = data["#{key}#{index}".downcase.to_sym]
+        populate_data[key] = value
+      end
+      
+      populate_attributes(populate_data.merge({
+        :parent => caller
+      }))
+    end
+    
+    # Initializes a record with initial data but keeping it a "new
+    # record." This is called automatically if {#initialize} is given
+    # only a single parameter. View {#initialize} for documentation.
+    def initialize_for_data(data)
+      self.class.attributes.each do |name, options|
+        data[options[:populate_key]] = data[name]
+      end
+      
+      populate_attributes(data)
+      new_record!
+    end
+    
+    # Validates a shared folder.
+    def validate
+      super
+      
+      validates_presence_of :parent
+      validates_presence_of :name
+      validates_presence_of :hostpath
+    end
+    
+    # Saves or creates a shared folder.
+    #
+    # @param [Boolean] raise_errors If true, {Exceptions::CommandFailedException}
+    #   will be raised if the command failed.
+    # @return [Boolean] True if command was successful, false otherwise.
+    def save(raise_errors=false)      
+      return true unless changed?
+      
+      if !valid?
+        raise Exceptions::ValidationFailedException.new(errors) if raise_errors
+        return false
+      end
+      
+      # If this isn't a new record, we destroy it first
+      destroy(raise_errors) if !new_record?
+      
+      Command.vboxmanage("sharedfolder add #{Command.shell_escape(parent.name)} --name #{Command.shell_escape(name)} --hostpath #{Command.shell_escape(hostpath)}")
+      existing_record!
+      clear_dirty!
+      
+      true
+    rescue Exceptions::CommandFailedException
+      raise if raise_errors
+      false
+    end
+    
+    # Relationship callback when added to a collection. This is automatically
+    # called by any relationship collection when this object is added.
+    def added_to_relationship(parent)
+      write_attribute(:parent, parent)
+    end
+    
+    # Destroys the shared folder. This doesn't actually delete the folder
+    # 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.
+    #
+    # @param [Boolean] raise_errors If true, {Exceptions::CommandFailedException}
+    #   will be raised if the command failed.
+    # @return [Boolean] True if command was successful, false otherwise.
+    def destroy(raise_errors=false)
+      # If the name changed, we have to be sure to use the previous
+      # one.
+      name_value = name_changed? ? name_was : name
+      
+      Command.vboxmanage("sharedfolder remove #{Command.shell_escape(parent.name)} --name #{Command.shell_escape(name_value)}")
+      true
+    rescue Exceptions::CommandFailedException
+      raise if raise_errors
+      false
+    end
+  end
+end

data/lib/virtualbox/vm.rb

@@ -74,6 +74,7 @@ module VirtualBox
   #
   #     relationship :nics, Nic
   #     relationship :storage_controllers, StorageController, :dependent => :destroy
+  #     relationship :shared_folders, SharedFolder
   #
   class VM < AbstractModel
     attribute :uuid, :readonly => true
@@ -104,6 +105,7 @@ module VirtualBox
     attribute :state, :populate_key => :vmstate, :readonly => true
     relationship :nics, Nic
     relationship :storage_controllers, StorageController, :dependent => :destroy
+    relationship :shared_folders, SharedFolder
     
     class <<self
       # Returns an array of all available VMs.

data/test/virtualbox/abstract_model/validatable_test.rb

@@ -0,0 +1,125 @@
+require File.join(File.dirname(__FILE__), '..', '..', 'test_helper')
+
+class ValidatableTest < Test::Unit::TestCase
+  class ValidatableModel
+    include VirtualBox::AbstractModel::Validatable
+    
+    attr_accessor :foos
+    attr_accessor :bars
+  end
+  
+  context "errors" do
+    setup do
+      @model = ValidatableModel.new
+    end
+  
+    should "have no errors by default" do
+      assert @model.errors.empty?
+    end
+    
+    should "be able to add errors" do
+      @model.add_error(:foo, "is blank")
+      assert !@model.errors.empty?
+      assert !@model.errors[:foo].nil?
+      assert_equal "is blank", @model.errors[:foo].first
+    end
+    
+    should "be able to add multiple errors" do
+      @model.add_error(:foo, "foo")
+      @model.add_error(:foo, "bar")
+      assert !@model.errors.empty?
+      assert !@model.errors[:foo].nil?
+      assert_equal 2, @model.errors[:foo].length
+    end
+    
+    should "be able to clear errors" do
+      @model.add_error(:foo, "foo")
+      assert !@model.errors.empty?
+      @model.clear_errors
+      assert @model.errors.empty?
+    end
+  end
+  
+  context "validity" do
+    setup do
+      @model = ValidatableModel.new
+    end
+    
+    should "call validate on valid?" do
+      @model.expects(:validate)
+      assert @model.valid?
+    end
+    
+    should "be valid if there are no errors" do
+      assert @model.valid?
+    end
+    
+    should "be invalid if there are any errors" do
+      @model.add_error(:foo, "foo")
+      assert !@model.valid?
+    end
+    
+    should "have a validate method by default which returns true" do
+      assert @model.validate
+    end
+  end
+  
+  context "specific validations" do
+    setup do
+      @model = ValidatableModel.new
+    end
+    
+    context "validates_presence_of" do
+      setup do
+        @model.foos = "foo"
+        @model.bars = "bar"
+      end
+      
+      should "not add an error if not blank" do
+        @model.validates_presence_of(:foos)
+        assert @model.valid?
+      end
+      
+      should "add an error if blank field" do
+        @model.foos = ""
+        @model.validates_presence_of(:foos)
+        assert !@model.valid?
+      end
+      
+      should "add an error for a nil field" do
+        @model.foos = nil
+        @model.validates_presence_of(:foos)
+        assert !@model.valid?
+      end
+      
+      should "validate multiple fields" do
+        @model.bars = nil
+        @model.validates_presence_of([:foos, :bars])
+        
+        assert !@model.valid?
+        assert @model.errors[:bars]
+      end
+      
+      should "return false on invalid" do
+        @model.bars =  nil
+        assert !@model.validates_presence_of(:bars)
+      end
+      
+      should "return true on valid" do
+        @model.bars = "foo"
+        assert @model.validates_presence_of(:bars)
+      end
+      
+      should "return false if any are invalid on multiple fields" do
+        @model.bars = nil
+        assert !@model.validates_presence_of([:foos, :bars])
+      end
+      
+      should "return true if all fields are valid" do
+        @model.foos = "foo"
+        @model.bars = "bar"
+        assert @model.validates_presence_of([:foos, :bars])
+      end
+    end
+  end
+end

data/test/virtualbox/abstract_model_test.rb

@@ -5,6 +5,9 @@ class AbstractModelTest < Test::Unit::TestCase
     def self.set_relationship(caller, old_value, new_value)
       new_value
     end
+    
+    def self.validate_relationship(caller, data)
+    end
   end
   
   class Bar; end
@@ -16,6 +19,52 @@ class AbstractModelTest < Test::Unit::TestCase
     relationship :bars, Bar, :dependent => :destroy
   end
   
+  context "validation" do
+    setup do
+      @model = FakeModel.new
+    end
+    
+    should "clear all previous errors" do
+      @model.expects(:clear_errors).once
+      @model.validate
+    end
+    
+    should "call validate_relationship on each relationship class" do
+      Foo.expects(:validate_relationship).once.with(@model, nil)
+      @model.validate
+    end
+    
+    should "forward arguments to validate_relationship" do
+      Foo.expects(:validate_relationship).once.with(@model, nil, "HELLO")
+      @model.validate("HELLO")
+    end
+    
+    should "succeed if all relationships succeeded" do
+      Foo.expects(:validate_relationship).returns(true)
+      assert @model.validate
+    end
+    
+    should "fail if one relationship failed to validate" do
+      Foo.expects(:validate_relationship).returns(true)
+      Bar.expects(:validate_relationship).returns(false)
+      assert !@model.validate
+    end
+    
+    context "errors" do
+      should "return the errors of the relationships, as well as the model itself" do
+        @model.foo = nil
+        assert !@model.validate
+
+        @model.validates_presence_of(:foo)
+        Foo.expects(:errors_for_relationship).with(@model, nil).returns("BAD")
+        errors = @model.errors
+        assert errors.has_key?(:foos)
+        assert_equal "BAD", errors[:foos]
+        assert errors.has_key?(:foo)
+      end
+    end
+  end
+  
   context "new/existing records" do
     setup do
       @model = FakeModel.new

data/test/virtualbox/attached_device_test.rb

@@ -19,6 +19,34 @@ class AttachedDeviceTest < Test::Unit::TestCase
     VirtualBox::Command.stubs(:execute).returns('')
   end
   
+  context "validations" do
+    setup do
+      @ad = VirtualBox::AttachedDevice.new
+      @ad.image = VirtualBox::DVD.empty_drive
+      @ad.port = 7
+      @ad.added_to_relationship(@caller)
+    end
+    
+    should "be valid with all fields" do
+      assert @ad.valid?
+    end
+    
+    should "be invalid with no image" do
+      @ad.image = nil
+      assert !@ad.valid?
+    end
+    
+    should "be invalid with no port" do
+      @ad.port = nil
+      assert !@ad.valid?
+    end
+    
+    should "be invalid if not in a relationship" do
+      @ad.write_attribute(:parent, nil)
+      assert !@ad.valid?
+    end
+  end
+  
   context "medium" do
     setup do
       @ad = VirtualBox::AttachedDevice.new
@@ -62,6 +90,12 @@ class AttachedDeviceTest < Test::Unit::TestCase
       @value.save
     end
     
+    should "return false and not call vboxmanage if invalid" do
+      VirtualBox::Command.expects(:vboxmanage).never
+      @value.expects(:valid?).returns(false)
+      assert !@value.save
+    end
+    
     should "not call destroy if the port didn't change" do
       @value.expects(:destroy).never
       assert !@value.port_changed?
@@ -90,9 +124,16 @@ class AttachedDeviceTest < Test::Unit::TestCase
       @ad.port = 3
     end
     
-    should "raise a NoParentException if it wasn't added to a relationship" do
-      assert_raises(VirtualBox::Exceptions::NoParentException) {
-        @ad.save
+    should "return false and not call vboxmanage if invalid" do
+      VirtualBox::Command.expects(:vboxmanage).never
+      @ad.expects(:valid?).returns(false)
+      assert !@ad.save
+    end
+    
+    should "raise a ValidationFailedException if invalid and raise_errors is true" do
+      @ad.expects(:valid?).returns(false)
+      assert_raises(VirtualBox::Exceptions::ValidationFailedException) {
+        @ad.save(true)
       }
     end
     
@@ -106,13 +147,6 @@ class AttachedDeviceTest < Test::Unit::TestCase
         @ad.expects(:destroy).never
         assert @ad.save
       end
-      
-      should "not raise an InvalidObjectException if no image is set" do
-        @ad.image = nil
-        assert_raises(VirtualBox::Exceptions::InvalidObjectException) {
-          @ad.save
-        }
-      end
 
       should "call the proper vboxcommand" do
         VirtualBox::Command.expects(:vboxmanage).with("storageattach #{@vm.name} --storagectl #{VirtualBox::Command.shell_escape(@caller.name)} --port #{@ad.port} --device 0 --type #{@image.image_type} --medium #{@ad.medium}")

data/test/virtualbox/hard_drive_test.rb

@@ -23,6 +23,29 @@ raw
     VirtualBox::Command.stubs(:vboxmanage).with("showhdinfo #{@name}").returns(@find_raw)
   end
   
+  context "validations" do
+    setup do
+      @hd = VirtualBox::HardDrive.new
+      @hd.size = 2000
+    end
+    
+    should "be valid with a size and format" do
+      assert @hd.valid?
+    end
+    
+    should "be invalid if size is nil" do
+      @hd.size = nil
+      assert !@hd.valid?
+    end
+    
+    should "clear validations when rechecking" do
+      @hd.size = nil
+      assert !@hd.valid?
+      @hd.size = 700
+      assert @hd.valid?
+    end
+  end
+  
   context "destroying a hard drive" do
     setup do
       @hd = VirtualBox::HardDrive.find(@name)
@@ -136,6 +159,19 @@ raw
         @hd.save(true)
       }
     end
+    
+    should "not run if invalid" do
+      @hd.expects(:valid?).returns(false)
+      VirtualBox::Command.expects(:vboxmanage).never
+      assert !@hd.save
+    end
+    
+    should "raise a ValidationFailedException if invalid and raise_errors is true" do
+      @hd.expects(:valid?).returns(false)
+      assert_raises(VirtualBox::Exceptions::ValidationFailedException) {
+        @hd.save(true)
+      }
+    end
   end
   
   context "finding a single hard drive" do

data/test/virtualbox/shared_folder_test.rb

@@ -0,0 +1,231 @@
+require File.join(File.dirname(__FILE__), '..', 'test_helper')
+
+class SharedFolderTest < Test::Unit::TestCase
+  setup do
+    @data = {
+      :sharedfoldernamemachinemapping1 => "foofolder",
+      :sharedfolderpathmachinemapping1 => "/foo",
+      :sharedfoldernamemachinemapping2 => "barfolder",
+      :sharedfolderpathmachinemapping2 => "/bar"
+    }
+    
+    @caller = mock("caller")
+    @caller.stubs(:name).returns("foo")
+    
+    VirtualBox::Command.stubs(:execute)
+  end
+  
+  context "validations" do
+    setup do
+      @sf = VirtualBox::SharedFolder.new
+      @sf.name = "foo"
+      @sf.hostpath = "bar"
+      @sf.added_to_relationship(@caller)
+    end
+    
+    should "be valid with all fields" do
+      assert @sf.valid?
+    end
+    
+    should "be invalid with no name" do
+      @sf.name = nil
+      assert !@sf.valid?
+    end
+    
+    should "be invalid with no hostpath" do
+      @sf.hostpath = nil
+      assert !@sf.valid?
+    end
+    
+    should "be invalid if not in a relationship" do
+      @sf.write_attribute(:parent, nil)
+      assert !@sf.valid?
+    end
+  end
+  
+  context "saving an existing shared folder" do
+    setup do
+      @value = VirtualBox::SharedFolder.populate_relationship(@caller, @data)
+      @value = @value[0]
+      @value.name = "different"
+      assert @value.changed?
+    end
+    
+    should "first destroy the shared folder then recreate it" do
+      seq = sequence("create_seq")
+      @value.expects(:destroy).in_sequence(seq)
+      VirtualBox::Command.expects(:vboxmanage).in_sequence(seq)
+      assert @value.save
+    end
+    
+    should "call destroy with raise errors if set" do
+      @value.expects(:destroy).with(true).once
+      assert @value.save(true)
+    end
+  end
+  
+  context "creating a new shared folder" do
+    setup do
+      @sf = VirtualBox::SharedFolder.new
+      @sf.name = "foo"
+      @sf.hostpath = "bar"
+    end
+    
+    should "return false and not call vboxmanage if invalid" do
+      VirtualBox::Command.expects(:vboxmanage).never
+      @sf.expects(:valid?).returns(false)
+      assert !@sf.save
+    end
+    
+    should "raise a ValidationFailedException if invalid and raise_errors is true" do
+      @sf.expects(:valid?).returns(false)
+      assert_raises(VirtualBox::Exceptions::ValidationFailedException) {
+        @sf.save(true)
+      }
+    end
+    
+    context "has a parent" do
+      setup do
+        @sf.added_to_relationship(@caller)
+        VirtualBox::Command.stubs(:vboxmanage)
+      end
+      
+      should "not call destroy since its a new record" do
+        @sf.expects(:destroy).never
+        assert @sf.save
+      end
+
+      should "call the proper vboxcommand" do
+        VirtualBox::Command.expects(:vboxmanage).with("sharedfolder add #{@caller.name} --name #{@sf.name} --hostpath #{@sf.hostpath}")
+        assert @sf.save
+      end
+
+      should "return false if the command failed" do
+        VirtualBox::Command.stubs(:vboxmanage).raises(VirtualBox::Exceptions::CommandFailedException)
+        assert !@sf.save
+      end
+
+      should "return true if the command was a success" do
+        assert @sf.save
+      end
+      
+      should "raise an exception if true sent to save and error occured" do
+        VirtualBox::Command.stubs(:vboxmanage).raises(VirtualBox::Exceptions::CommandFailedException)
+        assert_raises(VirtualBox::Exceptions::CommandFailedException) {
+          @sf.save(true)
+        }
+      end
+      
+      should "not be a new record after saving" do
+        assert @sf.new_record?
+        assert @sf.save
+        assert !@sf.new_record?
+      end
+      
+      should "not be changed after saving" do
+        assert @sf.changed?
+        assert @sf.save
+        assert !@sf.changed?
+      end
+    end
+  end
+  
+  context "constructor" do
+    should "call initialize_for_relationship if 3 args are given" do
+      VirtualBox::SharedFolder.any_instance.expects(:initialize_for_relationship).with(1,2,3).once
+      VirtualBox::SharedFolder.new(1,2,3)
+    end
+    
+    should "raise a NoMethodError if anything other than 0,1,or 3 arguments" do
+      2.upto(9) do |i|
+        next if i == 3
+        args = Array.new(i, "A")
+        
+        assert_raises(NoMethodError) {
+          VirtualBox::SharedFolder.new(*args)
+        }
+      end
+    end
+    
+    should "populate from a hash if one argument is given" do
+      VirtualBox::SharedFolder.any_instance.expects(:initialize_for_data).with("HI").once
+      VirtualBox::SharedFolder.new("HI")
+    end
+    
+    context "initializing from data" do
+      setup do
+        @sf = VirtualBox::SharedFolder.new({:name => "foo", :hostpath => "bar"})
+      end
+      
+      should "allow the use of :name and :hostpath in the hash" do
+        assert_equal "foo", @sf.name
+        assert_equal "bar", @sf.hostpath
+      end
+      
+      should "keep the record new" do
+        assert @sf.new_record?
+      end
+    end
+  end
+  
+  context "destroying" do
+    setup do
+      @value = VirtualBox::SharedFolder.populate_relationship(@caller, @data)
+      @value = @value[0]
+    end
+    
+    should "call the proper command" do
+      VirtualBox::Command.expects(:vboxmanage).with("sharedfolder remove #{@caller.name} --name #{@value.name}").once
+      assert @value.destroy
+    end
+    
+    should "shell escape VM name and storage controller name" do
+      shell_seq = sequence("shell_seq")
+      VirtualBox::Command.expects(:shell_escape).with(@caller.name).in_sequence(shell_seq)
+      VirtualBox::Command.expects(:shell_escape).with(@value.name).in_sequence(shell_seq)
+      VirtualBox::Command.expects(:vboxmanage).in_sequence(shell_seq)
+      assert @value.destroy
+    end
+    
+    should "return false if destroy failed" do
+      VirtualBox::Command.stubs(:vboxmanage).raises(VirtualBox::Exceptions::CommandFailedException)
+      assert !@value.destroy
+    end
+    
+    should "raise an exception if destroy failed and an error occured" do
+      VirtualBox::Command.stubs(:vboxmanage).raises(VirtualBox::Exceptions::CommandFailedException)
+      assert_raises(VirtualBox::Exceptions::CommandFailedException) {
+        @value.destroy(true)
+      }
+    end
+    
+    should "use the old name if it was changed" do 
+      @value.name = "DIFFERENT"
+      shell_seq = sequence("shell_seq")
+      VirtualBox::Command.expects(:shell_escape).with(@caller.name).in_sequence(shell_seq)
+      VirtualBox::Command.expects(:shell_escape).with(@value.name_was).in_sequence(shell_seq)
+      VirtualBox::Command.expects(:vboxmanage).in_sequence(shell_seq)
+      assert @value.destroy
+    end
+  end
+  
+  context "populating relationships" do
+    setup do
+      @value = VirtualBox::SharedFolder.populate_relationship(@caller, @data)
+    end
+
+    should "create the correct amount of objects" do
+      assert_equal 2, @value.length
+    end
+    
+    should "parse the proper data" do
+      value = @value[0]
+      assert_equal "foofolder", value.name
+      assert_equal "/foo", value.hostpath
+      
+      value = @value[1]
+      assert_equal "barfolder", value.name
+      assert_equal "/bar", value.hostpath
+    end
+  end
+end

data/test/virtualbox/vm_test.rb

@@ -71,7 +71,11 @@ uart2="off"
 audio="none"
 clipboard="bidirectional"
 vrdp="off"
-usb="off"      
+usb="off"
+SharedFolderNameMachineMapping1="mysharedfolder"
+SharedFolderPathMachineMapping1="/virtualbox"
+SharedFolderNameMachineMapping2="otherfolder"
+SharedFolderPathMachineMapping2="/virtualbox/lib"
 showvminfo
     
     @name = "foo"
@@ -354,6 +358,7 @@ raw
     should "save the relationships as well" do
       VirtualBox::Nic.expects(:save_relationship).once
       VirtualBox::StorageController.expects(:save_relationship).once
+      VirtualBox::SharedFolder.expects(:save_relationship).once
       assert @vm.save
     end
   end
@@ -391,6 +396,12 @@ raw
       assert @vm.storage_controllers.is_a?(Array)
       assert_equal 2, @vm.storage_controllers.length
     end
+    
+    should "properly load shared folder relationship" do
+      assert @vm.shared_folders
+      assert @vm.shared_folders.is_a?(Array)
+      assert_equal 2, @vm.shared_folders.length
+    end
   end
   
   context "parsing the showvminfo output" do

data/virtualbox.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{virtualbox}
-  s.version = "0.2.0"
+  s.version = "0.3.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Mitchell Hashimoto"]
-  s.date = %q{2010-01-26}
+  s.date = %q{2010-01-28}
   s.description = %q{Create and modify virtual machines in VirtualBox using pure ruby.}
   s.email = %q{mitchell.hashimoto@gmail.com}
   s.extra_rdoc_files = [
@@ -24,11 +24,13 @@ Gem::Specification.new do |s|
      "TODO",
      "VERSION",
      "docs/GettingStarted.md",
+     "docs/WhatsNew.md",
      "lib/virtualbox.rb",
      "lib/virtualbox/abstract_model.rb",
      "lib/virtualbox/abstract_model/attributable.rb",
      "lib/virtualbox/abstract_model/dirty.rb",
      "lib/virtualbox/abstract_model/relatable.rb",
+     "lib/virtualbox/abstract_model/validatable.rb",
      "lib/virtualbox/attached_device.rb",
      "lib/virtualbox/command.rb",
      "lib/virtualbox/dvd.rb",
@@ -38,12 +40,14 @@ Gem::Specification.new do |s|
      "lib/virtualbox/image.rb",
      "lib/virtualbox/nic.rb",
      "lib/virtualbox/proxies/collection.rb",
+     "lib/virtualbox/shared_folder.rb",
      "lib/virtualbox/storage_controller.rb",
      "lib/virtualbox/vm.rb",
      "test/test_helper.rb",
      "test/virtualbox/abstract_model/attributable_test.rb",
      "test/virtualbox/abstract_model/dirty_test.rb",
      "test/virtualbox/abstract_model/relatable_test.rb",
+     "test/virtualbox/abstract_model/validatable_test.rb",
      "test/virtualbox/abstract_model_test.rb",
      "test/virtualbox/attached_device_test.rb",
      "test/virtualbox/command_test.rb",
@@ -53,6 +57,7 @@ Gem::Specification.new do |s|
      "test/virtualbox/image_test.rb",
      "test/virtualbox/nic_test.rb",
      "test/virtualbox/proxies/collection_test.rb",
+     "test/virtualbox/shared_folder_test.rb",
      "test/virtualbox/storage_controller_test.rb",
      "test/virtualbox/vm_test.rb",
      "virtualbox.gemspec"
@@ -67,6 +72,7 @@ Gem::Specification.new do |s|
      "test/virtualbox/abstract_model/attributable_test.rb",
      "test/virtualbox/abstract_model/dirty_test.rb",
      "test/virtualbox/abstract_model/relatable_test.rb",
+     "test/virtualbox/abstract_model/validatable_test.rb",
      "test/virtualbox/abstract_model_test.rb",
      "test/virtualbox/attached_device_test.rb",
      "test/virtualbox/command_test.rb",
@@ -76,6 +82,7 @@ Gem::Specification.new do |s|
      "test/virtualbox/image_test.rb",
      "test/virtualbox/nic_test.rb",
      "test/virtualbox/proxies/collection_test.rb",
+     "test/virtualbox/shared_folder_test.rb",
      "test/virtualbox/storage_controller_test.rb",
      "test/virtualbox/vm_test.rb"
   ]

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: virtualbox
 version: !ruby/object:Gem::Version 
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors: 
 - Mitchell Hashimoto
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-01-26 00:00:00 -08:00
+date: 2010-01-28 00:00:00 -08:00
 default_executable: 
 dependencies: []
 
@@ -30,11 +30,13 @@ files:
 - TODO
 - VERSION
 - docs/GettingStarted.md
+- docs/WhatsNew.md
 - lib/virtualbox.rb
 - lib/virtualbox/abstract_model.rb
 - lib/virtualbox/abstract_model/attributable.rb
 - lib/virtualbox/abstract_model/dirty.rb
 - lib/virtualbox/abstract_model/relatable.rb
+- lib/virtualbox/abstract_model/validatable.rb
 - lib/virtualbox/attached_device.rb
 - lib/virtualbox/command.rb
 - lib/virtualbox/dvd.rb
@@ -44,12 +46,14 @@ files:
 - lib/virtualbox/image.rb
 - lib/virtualbox/nic.rb
 - lib/virtualbox/proxies/collection.rb
+- lib/virtualbox/shared_folder.rb
 - lib/virtualbox/storage_controller.rb
 - lib/virtualbox/vm.rb
 - test/test_helper.rb
 - test/virtualbox/abstract_model/attributable_test.rb
 - test/virtualbox/abstract_model/dirty_test.rb
 - test/virtualbox/abstract_model/relatable_test.rb
+- test/virtualbox/abstract_model/validatable_test.rb
 - test/virtualbox/abstract_model_test.rb
 - test/virtualbox/attached_device_test.rb
 - test/virtualbox/command_test.rb
@@ -59,6 +63,7 @@ files:
 - test/virtualbox/image_test.rb
 - test/virtualbox/nic_test.rb
 - test/virtualbox/proxies/collection_test.rb
+- test/virtualbox/shared_folder_test.rb
 - test/virtualbox/storage_controller_test.rb
 - test/virtualbox/vm_test.rb
 - virtualbox.gemspec
@@ -95,6 +100,7 @@ test_files:
 - test/virtualbox/abstract_model/attributable_test.rb
 - test/virtualbox/abstract_model/dirty_test.rb
 - test/virtualbox/abstract_model/relatable_test.rb
+- test/virtualbox/abstract_model/validatable_test.rb
 - test/virtualbox/abstract_model_test.rb
 - test/virtualbox/attached_device_test.rb
 - test/virtualbox/command_test.rb
@@ -104,5 +110,6 @@ test_files:
 - test/virtualbox/image_test.rb
 - test/virtualbox/nic_test.rb
 - test/virtualbox/proxies/collection_test.rb
+- test/virtualbox/shared_folder_test.rb
 - test/virtualbox/storage_controller_test.rb
 - test/virtualbox/vm_test.rb