bbrowning-virtualbox 0.7.6.dev

data/features/support/env.rb

@@ -0,0 +1,61 @@
+# Before everything, load virtualbox, of course
+require 'spec'
+require File.join(File.dirname(__FILE__), %W[.. .. lib virtualbox])
+
+# Configuration settings/info
+IntegrationInfo = {
+  :test_unsafe => !!ENV["TEST_UNSAFE"],
+  :vm_name => "test_vm"
+}
+
+# Mapping of VirtualBox::VM property keys to attributes in the
+# `showvminfo` output.
+VM_MAPPINGS = {
+  :uuid => "UUID",
+  :name => "name",
+  :os_type_id => "ostype",
+  :memory_size => "memory",
+  :vram_size => "vram",
+  :cpu_count => "cpus",
+  :accelerate_3d_enabled => "accelerate3d",
+  :accelerate_2d_video_enabled => "accelerate2dvideo",
+  :clipboard_mode => "clipboard",
+  :monitor_count => "monitorcount"
+}
+
+BIOS_MAPPINGS = {
+  :acpi_enabled => "acpi",
+  :io_apic_enabled => "ioapic"
+}
+
+HWVIRT_MAPPINGS = {
+  :enabled => "hwvirtex",
+  :exclusive => "hwvirtexexcl",
+  :nested_paging => "nestedpaging",
+  :vpid => "vtxvpid"
+}
+
+CPU_MAPPINGS = {
+  :pae => "pae",
+  :synthetic => "synthcpu"
+}
+
+STORAGE_MAPPINGS = {
+  :port_count => "portcount",
+  :controller_type => "type"
+}
+
+SHARED_FOLDER_MAPPINGS = {
+  :host_path => "path"
+}
+
+NETWORK_ADAPTER_MAPPINGS = {
+  :mac_address => "macaddress",
+  :cable_connected => "cableconnected"
+}
+
+FORWARDED_PORT_MAPPINGS = {
+  :protocol => "protocol",
+  :hostport => "hostport",
+  :guestport => "guestport"
+}

data/features/support/helpers.rb

@@ -0,0 +1,38 @@
+module VirtualBox
+  module IntegrationHelpers
+    # 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)
+      mappings.each do |model_key, output_key|
+        value = model.send(model_key)
+
+        if [TrueClass, FalseClass].include?(value.class)
+          # Convert true/false to VirtualBox-style string boolean values
+          value = value ? "on" : "off"
+        end
+
+        output_value = output[output_key.to_sym] || output[output_key]
+        value, output_value = yield value, output_value if block_given?
+        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
+
+World(VirtualBox::IntegrationHelpers)

data/features/support/hooks.rb

@@ -0,0 +1,30 @@
+#------------------------------------------------------------
+# Hooks
+#------------------------------------------------------------
+# Unsafe tags specify that a test modifies (writes or deletes)
+# actual data in VirtualBox.
+Around('@unsafe') do |scenario, block|
+  block.call if IntegrationInfo[:test_unsafe]
+end
+
+Around('@pending') do |scenario, block|
+  # Don't run the block
+end
+
+#------------------------------------------------------------
+# Warning/Info messages about settings.
+#------------------------------------------------------------
+if !IntegrationInfo[:test_unsafe]
+  puts <<-MSG
+========================================================================
+
+For your own safety, unsafe tests (tests which modify actual VirtualBox
+data), are disabled unless the environmental variable TEST_UNSAFE is
+set. To enable unsafe tests, the easiest way is to do the following:
+
+    TEST_UNSAFE=yes rake test:integration
+
+========================================================================
+MSG
+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

@@ -0,0 +1,191 @@
+class VBoxManage
+  class << self
+    def command(*args)
+      args = args.dup.flatten
+      args.unshift("-q")
+      "VBoxManage #{args.join(" ")}"
+    end
+
+    def execute(*args)
+      cmd = command(*args)
+      result = `#{cmd}`.chomp
+      raise Exception.new("Failed command: #{cmd}") if $?.exitstatus != 0
+      result
+    end
+
+    # Gets the extra data for a VM of the given ID and returns it in
+    # hash format.
+    def extra_data(name)
+      output = execute("getextradata", name, "enumerate")
+
+      output.split("\n").inject({}) do |acc, line|
+        acc[$1.to_s] = $2.to_s if line =~ /^Key: (.+?), Value: (.+?)$/
+        acc
+      end
+    end
+
+    # Gets the info for a VM and returns it in hash format.
+    def vm_info(name)
+      output = begin
+        execute("showvminfo", name, "--machinereadable")
+      rescue Exception
+        ""
+      end
+
+      output.split("\n").inject(OrderedHash.new) do |acc, line|
+        if line =~ /^"?(.+?)"?=(.+?)$/
+          key = $1.to_s
+          value = $2.to_s
+          value = $1.to_s if value =~ /^"(.*?)"$/
+          acc[key] = value
+        end
+
+        acc
+      end
+    end
+
+    # Parses the storage controllers out of VM info output and returns
+    # it in a programmer-friendly hash.
+    def storage_controllers(info)
+      raw = info.inject({}) do |acc, data|
+        k,v = data
+
+        if k =~ /^storagecontroller(.+?)(\d+)$/
+          subkey = $2.to_s
+          acc[subkey] ||= {}
+          acc[subkey][$1.to_s.to_sym] = v
+        end
+
+        acc
+      end
+
+      raw.inject({}) do |acc, data|
+        k,v = data
+        acc[v.delete(:name)] = v
+        acc
+      end
+    end
+
+    # Parses the shared folders out of the VM info output and returns
+    # it in a programmer-friendly hash.
+    def shared_folders(info)
+      raw = info.inject({}) do |acc, data|
+        k,v = data
+
+        if k =~ /^SharedFolder(.+?)MachineMapping(\d+)$/
+          subkey = $2.to_s
+          acc[subkey] ||= {}
+          acc[subkey][$1.to_s.downcase.to_sym] = v
+        end
+
+        acc
+      end
+
+      raw.inject({}) do |acc, data|
+        k,v = data
+        acc[v.delete(:name)] = v
+        acc
+      end
+    end
+
+    # Parses the network adapters out of the VM info output and
+    # returns it in a hash.
+    def network_adapters(info)
+      valid_keys = %W[natnet macaddress cableconnected hostonlyadapter]
+
+      info.inject({}) do |acc, data|
+        k,v = data
+        if k =~ /^nic(\d+)$/
+          acc[$1.to_i] ||= {}
+          acc[$1.to_i][:type] = v
+        elsif k=~ /^(.+?)(\d+)$/ && valid_keys.include?($1.to_s)
+          acc[$2.to_i] ||= {}
+          acc[$2.to_i][$1.to_s.to_sym] = v
+        end
+
+        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/version.feature

@@ -0,0 +1,16 @@
+Feature: VirtualBox version information
+  As a virtualbox library user
+  I want to access information about the installed version
+  In order to determine if I support this version of VirtualBox
+
+  Scenario: Reading the version
+    When I try to read the virtualbox "version"
+    Then the result should match version output
+
+  Scenario: Reading the revision
+    When I try to read the virtualbox "revision"
+    Then the result should match version output
+
+  Scenario: Checking if VirtualBox supported
+    When I try to read the virtualbox "supported?"
+    Then the result should match version output

data/features/vm.feature

@@ -0,0 +1,13 @@
+Feature: Virtual Machine
+  As a virtualbox library user
+  I want to access information about specific virtual machines
+  In order to get information about VMs in VirtualBox
+
+  Scenario: Finding a non-existent VM
+    When I find a VM identified by "this_should_never_exist1234"
+    Then the VM should not exist
+
+  Scenario: Finding a VM
+    When I find a VM identified by "test_vm_A"
+    Then the VM should exist
+    And the "VM" properties should match

data/features/vm_bios.feature

@@ -0,0 +1,29 @@
+Feature: Virtual Machine BIOS Settings
+  As a virtualbox library user
+  I want to read and update VM BIOS
+
+  Background:
+    Given I find a VM identified by "test_vm_A"
+    And I set the VM properties:
+      | name   | value |
+      | acpi   | off   |
+      | ioapic | off   |
+    And I reload the VM
+    And the "bios" relationship
+
+  Scenario: Reading BIOS
+    Then the "BIOS" properties should match
+
+  @unsafe
+  Scenario: Updating the BIOS
+    When I set the relationship property "acpi_enabled" to "true"
+    And I save the relationship
+    And I reload the VM info
+    Then the "BIOS" properties should match
+
+  @unsafe
+  Scenario: Updating the BIOS via the VM
+    When I set the relationship property "io_apic_enabled" to "true"
+    And I save the model
+    And I reload the VM info
+    Then the "BIOS" properties should match

data/features/vm_cpu.feature

@@ -0,0 +1,29 @@
+Feature: Virtual Machine CPU Settings
+  As a virtualbox library user
+  I want to read and update VM CPU settings
+
+  Background:
+    Given I find a VM identified by "test_vm_A"
+    And I set the VM properties:
+      | name     | value |
+      | pae      | off   |
+      | synthcpu | off   |
+    And I reload the VM
+    And the "cpu" relationship
+
+  Scenario: Reading CPU settings
+    Then the "CPU" properties should match
+
+  @unsafe
+  Scenario: Updating the CPU settings
+    When I set the relationship property "pae" to "true"
+    And I save the relationship
+    And I reload the VM info
+    Then the "CPU" properties should match
+
+  @unsafe
+  Scenario: Updating the CPU settings via the VM
+    When I set the relationship property "synthetic" to "true"
+    And I save the model
+    And I reload the VM info
+    Then the "CPU" properties should match