virtualbox 0.5.4 → 0.6.0

data/lib/virtualbox/nic.rb

@@ -1,111 +0,0 @@
-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.**
-  #
-  # # Editing a NIC
-  #
-  # Nics 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.
-  #
-  #     vm = VirtualBox::VM.find("foo")
-  #     vm.nics[0].macaddress = @new_mac_address
-  #     vm.save
-  #
-  # # Attributes
-  #
-  # 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. 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
-  #
-  class Nic < AbstractModel
-    attribute :parent, :readonly => :readonly
-    attribute :nic
-    attribute :nictype, :populate_key => "type"
-    attribute :macaddress, :populate_key => "MACAddress"
-    attribute :cableconnected, :populate_key => "cable"
-    attribute :bridgeadapter
-
-    class <<self
-      # Populates the nic relationship for anything which is related to it.
-      #
-      # **This method typically won't be used except internally.**
-      #
-      # @return [Array<Nic>]
-      def populate_relationship(caller, doc)
-        relation = Proxies::Collection.new(caller)
-
-        doc.css("Hardware Network Adapter").each do |adapter|
-          relation << new(caller, adapter)
-        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 nic with the VM
-        data.each do |nic|
-          nic.save(caller.name)
-        end
-      end
-    end
-
-    # Since there is currently no way to create a _new_ nic, this is
-    # only used internally. Developers should NOT try to initialize their
-    # own nic objects.
-    def initialize(caller, data)
-      super()
-
-      @index = data["slot"].to_i + 1
-
-      # Set the parent
-      write_attribute(:parent, caller)
-
-      # Convert each attribute value to a string
-      attrs = {}
-      data.attributes.each do |key, value|
-        attrs[key] = value.to_s
-      end
-
-      populate_attributes(attrs)
-
-      # The `nic` attribute is a bit more complicated, but not by
-      # much
-      if data["enabled"] == "true"
-        write_attribute(:nic, data.children[1].name.downcase)
-      else
-        write_attribute(:nic, "none")
-      end
-
-      # Clear dirtiness
-      clear_dirty!
-    end
-
-    # Saves a single attribute of the nic. This method is automatically
-    # called on {#save}.
-    #
-    # **This method typically won't be used except internally.**
-    def save_attribute(key, value, vmname)
-      Command.vboxmanage("modifyvm", vmname, "--#{key}#{@index}", value)
-      super
-    end
-  end
-end

data/lib/virtualbox/system_property.rb

@@ -1,55 +0,0 @@
-module VirtualBox
-  # Represents the system properties of the system which VirtualBox
-  # is running on. These system properties are immutable values which
-  # are typically limits or specs of the host system. Some examples
-  # of available properties are `Maximum guest RAM size` or
-  # `Maximum Devices per SATA Port`.
-  #
-  # # Retrieving the System Properties
-  #
-  # Retrieving the system properties is done by calling the {all} method.
-  # Since {SystemProperty} inherits from `Hash`, you can treat it just like
-  # one. The keys are simply the typical keys downcased with spaces replaced
-  # with underscores, and converted to a symbol. An example of accessing
-  # system properties is shown below:
-  #
-  #     properties = VirtualBox::SystemProperty.all
-  #     puts properties[:log_history_count]
-  #     puts properties[:maximum_guest_ram_size]
-  #
-  # Since {SystemProperty} is simply a hash, you can also iterate over it,
-  # convert it easily to an array, etc.
-  class SystemProperty < Hash
-    class <<self
-      # Returns the hash of all system properties. Each call will invoke a
-      # system call to retrieve the properties (as in they're not cached
-      # on the class), so if you need to access them many times, please
-      # cache them yourself.
-      #
-      # @return [SystemProperty]
-      def all
-        raw = Command.vboxmanage("list", "systemproperties")
-        parse_raw(raw)
-      end
-
-      # Parses the raw output of vboxmanage. This parses the raw output from
-      # VBoxManage to parse the system properties.
-      #
-      # **This method typically won't be used except internally.**
-      #
-      # @param [String] data The raw output from vboxmanage.
-      # @return [SystemProperty]
-      def parse_raw(data)
-        result = new
-        data.split("\n").each do |line|
-          next unless line =~ /^(.+?):\s+(.+?)$/
-          value = $2.to_s
-          key = $1.to_s.downcase.gsub(/\s/, "_")
-          result[key.to_sym] = value
-        end
-
-        result
-      end
-    end
-  end
-end

data/lib/virtualbox/usb.rb

@@ -1,72 +0,0 @@
-module VirtualBox
-  # Represents a single USB device of a virtual machine.
-  #
-  # **Currently, new USB devices can't be created, so the only way to get this
-  # object is through a {VM}'s `usbs` relationship.**
-  #
-  # # Attributes
-  #
-  # 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. 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 :name
-  #     attribute :active
-  #     attribute :manufacturer
-  #     attribute :product
-  #     attribute :remote
-  #
-  class USB < AbstractModel
-    attribute :parent, :readonly => :readonly
-    attribute :name
-    attribute :active
-    attribute :manufacturer
-    attribute :product
-    attribute :remote
-
-    class <<self
-      # Populates the usb device relationship for anything which is related to it.
-      #
-      # **This method typically won't be used except internally.**
-      #
-      # @return [Array<USB>]
-      def populate_relationship(caller, doc)
-        relation = Proxies::Collection.new(caller)
-
-        doc.css("Hardware USBController DeviceFilter").each do |device|
-          relation << new(caller, device)
-        end
-
-        relation
-      end
-    end
-
-    # Since there is currently no way to create a _new_ usb device, this is
-    # only used internally. Developers should NOT try to initialize their
-    # own usb device objects.
-    def initialize(caller, data)
-      super()
-
-      # Set the parent
-      write_attribute(:parent, caller)
-
-      # Convert each attribute value to a string
-      attrs = {}
-
-      data.attributes.each do |key, value|
-        attrs[key.to_sym] = value.to_s
-      end
-
-      populate_attributes(attrs)
-
-      # Clear dirtiness
-      clear_dirty!
-    end
-  end
-end

data/test/virtualbox/attached_device_test.rb

@@ -1,303 +0,0 @@
-require File.join(File.dirname(__FILE__), '..', 'test_helper')
-
-class AttachedDeviceTest < Test::Unit::TestCase
-  setup do
-    @data = {
-      :"foo controller-0-0" => "foomedium",
-      :"foo controller-imageuuid-0-0" => "322f79fd-7da6-416f-a16f-e70066ccf165",
-      :"foo controller-1-0" => "barmedium"
-    }
-
-    @vm = mock("vm")
-    @vm.stubs(:name).returns("foo")
-
-    @caller = mock("caller")
-    @caller.stubs(:parent).returns(@vm)
-    @caller.stubs(:name).returns("Foo Controller")
-
-    # Stub execute to make sure nothing actually happens
-    VirtualBox::Command.stubs(:execute).returns('')
-
-    # Stub the config
-    VirtualBox::Global.stubs(:config).returns(mock_xml_doc)
-  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
-      @hd = VirtualBox::HardDrive.new
-      @hd.write_attribute(:uuid, @uuid)
-    end
-
-    should "be 'none' when image is nil" do
-      assert_equal "none", @ad.medium
-    end
-
-    should "be the uuid of the image if its not nil" do
-      @ad.image = @hd
-      assert_equal @hd.uuid, @ad.medium
-    end
-
-    should "be 'emptydrive' if the image is an empty drive" do
-      @ad.image = VirtualBox::DVD.empty_drive
-      assert_equal "emptydrive", @ad.medium
-    end
-  end
-
-  context "saving an existing device" do
-    setup do
-      @value = VirtualBox::AttachedDevice.populate_relationship(@caller, mock_xml_doc)
-      @value = @value[0]
-      @value.image = VirtualBox::DVD.empty_drive
-      assert @value.changed?
-    end
-
-    should "not do anything if the device isn't change" do
-      @value.clear_dirty!
-      assert !@value.changed?
-
-      VirtualBox::Command.expects(:vboxmanage).never
-      @value.save
-    end
-
-    should "call vboxmanage" do
-      VirtualBox::Command.expects(:vboxmanage).once
-      @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?
-      assert @value.save
-    end
-
-    should "call destroy with the old port if the port changed" do
-      @value.expects(:destroy).with({:port => @value.port}, false)
-      @value.port = 7
-      assert @value.port_changed?
-      assert @value.save
-    end
-
-    should "call destroy with the raise errors flag" do
-      @value.expects(:destroy).with(anything, true).once
-      @value.port = 7
-      @value.save(true)
-    end
-  end
-
-  context "creating a new attached device" do
-    setup do
-      @image = VirtualBox::HardDrive.new
-      @ad = VirtualBox::AttachedDevice.new
-      @ad.image = @image
-      @ad.port = 3
-    end
-
-    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
-
-    context "has a parent" do
-      setup do
-        @ad.added_to_relationship(@caller)
-        VirtualBox::Command.stubs(:vboxmanage)
-      end
-
-      should "not call destroy since its a new record" do
-        @ad.expects(:destroy).never
-        assert @ad.save
-      end
-
-      should "call the proper vboxcommand" do
-        VirtualBox::Command.expects(:vboxmanage).with("storageattach", @vm.name, "--storagectl", @caller.name, "--port", @ad.port, "--device", "0", "--type", @image.image_type, "--medium", @ad.medium)
-        @ad.save
-      end
-
-      should "return false if the command failed" do
-        VirtualBox::Command.stubs(:vboxmanage).raises(VirtualBox::Exceptions::CommandFailedException)
-        assert !@ad.save
-      end
-
-      should "return true if the command was a success" do
-        assert @ad.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) {
-          @ad.save(true)
-        }
-      end
-
-      should "not be a new record after saving" do
-        assert @ad.new_record?
-        assert @ad.save
-        assert !@ad.new_record?
-      end
-
-      should "not be changed after saving" do
-        assert @ad.changed?
-        assert @ad.save
-        assert !@ad.changed?
-      end
-    end
-  end
-
-  context "constructor" do
-    should "call populate_from_data if 3 args are given" do
-      VirtualBox::AttachedDevice.any_instance.expects(:populate_from_data).with(1,2,3).once
-      VirtualBox::AttachedDevice.new(1,2,3)
-    end
-
-    should "call populate_attributes if 1 arg is given" do
-      VirtualBox::AttachedDevice.any_instance.expects(:populate_attributes).with(1).once
-      ad = VirtualBox::AttachedDevice.new(1)
-      assert ad.new_record?
-    end
-
-    should "raise a NoMethodError if anything other than 0,1,or 3 arguments" do
-      # 9 seems like a reasonable max (maybe just a bit unreasonable!)
-      2.upto(9) do |i|
-        next if i == 3
-        args = Array.new(i, "A")
-
-        assert_raises(NoMethodError) {
-          VirtualBox::AttachedDevice.new(*args)
-        }
-      end
-    end
-  end
-
-  context "destroying" do
-    setup do
-      @value = VirtualBox::AttachedDevice.populate_relationship(@caller, mock_xml_doc)
-      @value = @value[0]
-
-      @image = mock("image")
-      @value.stubs(:image).returns(@image)
-
-      VirtualBox::Command.stubs(:execute)
-    end
-
-    should "simply call destroy on each object when destroying the relationship" do
-      obj_one = mock("one")
-      obj_two = mock("two")
-
-      obj_one.expects(:destroy).with("HELLO").once
-      obj_two.expects(:destroy).with("HELLO").once
-
-      VirtualBox::AttachedDevice.destroy_relationship(self, [obj_one, obj_two], "HELLO")
-    end
-
-    should "destroy with the specified port if set" do
-      VirtualBox::Command.expects(:vboxmanage).with("storageattach", @vm.name, "--storagectl", @caller.name, "--port", 80, "--device", "0", "--medium", "none")
-      @value.destroy(:port => 80)
-    end
-
-    should "destroy with the default port if not other port is specified" do
-      VirtualBox::Command.expects(:vboxmanage).with("storageattach", @vm.name, "--storagectl", @caller.name, "--port", @value.port, "--device", "0", "--medium", "none")
-      @value.destroy
-    end
-
-    should "not destroy image by default" do
-      @image.expects(:destroy).never
-      @value.destroy
-    end
-
-    should "destroy image if flag is set" do
-      @image.expects(:destroy).once
-      @value.destroy({
-        :destroy_image => true
-      })
-    end
-
-    should "ignore destroy image flag if image is nil" do
-      @value.expects(:image).once.returns(nil)
-      @value.destroy({
-        :destroy_image => true
-      })
-    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 "forward raise_errors flag to image.destroy" do
-      @image.expects(:destroy).with(true).once
-      @value.destroy({:destroy_image => true}, true)
-    end
-  end
-
-  context "populating relationships" do
-    setup do
-      @value = VirtualBox::AttachedDevice.populate_relationship(@caller, mock_xml_doc)
-    end
-
-    should "create the correct amount of objects" do
-      assert_equal 2, @value.length
-    end
-
-    should "create objects with proper values" do
-      obj = @value[0]
-      assert_equal "none", obj.medium
-      assert_equal "2c16dd48-4cf1-497e-98fa-84ed55cfe71f", obj.uuid
-      assert_equal "0", obj.port
-
-      obj = @value[1]
-      assert_equal "emptydrive", obj.medium
-      assert_nil obj.uuid
-      assert_equal "1", obj.port
-    end
-  end
-end