velir_virtualbox 0.8.4

data/features/step_definitions/abstract_model_steps.rb

@@ -0,0 +1,39 @@
+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
+
+When /I read the "(.+?)"/ do |property|
+  @value = @model.send(property)
+end
+
+When /I set the property "(.+?)" to "(.+?)"/ do |key, value|
+  value = value == "true" if %W[true false].include?(value)
+  @model.send("#{key}=", value)
+end
+
+When /I set the relationship property "(.+?)" to "(.+?)"/ do |key, value|
+  old = @model
+  @model = @relationship
+  When %Q[I set the property "#{key}" to "#{value}"]
+  @model = old
+end
+
+When /I add the new record to the relationship/ do
+  @relationship << @new_record
+end
+
+When /I save the relationship/ do
+  @relationship.save
+end
+
+When /I save the model/ do
+  @model.save
+end

data/features/step_definitions/extra_data_steps.rb

@@ -0,0 +1,36 @@
+Given /I set the "(.+?)" extra data "(.+?)" to "(.*?)"/ do |name, key, value|
+  name = @name if name == "VM"
+  VBoxManage.execute("setextradata", name, key, value)
+end
+
+Given /I delete the "(.+?)" extra data "(.+?)"/ do |name, key|
+  # Same as setting to empty
+  Given %Q[I set the "#{name}" extra data "#{key}" to ""]
+end
+
+When /I get the extra data of "(.+?)"/ do |name|
+  @extra_data = VBoxManage.extra_data(name)
+end
+
+When /I set the extra data "(.+?)" to "(.+?)"/ do |key, value|
+  @relationship[key] = value
+end
+
+When /I delete the extra data "(.+?)"/ do |key|
+  @relationship.delete(key)
+end
+
+Then /all the extra data should match/ do
+  @relationship.length.should == @extra_data.length
+  @extra_data.each do |k,v|
+    @relationship[k].should == v
+  end
+end
+
+Then /the extra data should include "(.+?)" as "(.+?)"/ do |key, value|
+  @extra_data[key].should == value
+end
+
+Then /the extra data should not include "(.+?)"/ do |key|
+  @extra_data.should_not have_key(key)
+end

data/features/step_definitions/global_steps.rb

@@ -0,0 +1,29 @@
+Given /the global object/ do
+  @model = VirtualBox::Global.global(true)
+end
+
+When /I read the media "(.+?)"/ do |property|
+  @media = property.gsub(" ", "_").to_sym
+  @value = @model.media.send(@media)
+end
+
+Then /I should get a matching length for "vms"/ do
+  output = VBoxManage.execute("list", "vms")
+  @value.length.should == output.split("\n").length
+end
+
+Then /I should get a matching length of media items/ do
+  mapping = {
+    :hard_drives => "hdds",
+    :dvds => "dvds",
+    :floppies => "floppies"
+  }
+
+  output = VBoxManage.execute("list", mapping[@media])
+  count = output.split("\n").inject(0) do |acc, line|
+    acc += 1 if line =~ /^UUID:/
+    acc
+  end
+
+  @value.length.should == count
+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/network_adapter_steps.rb

@@ -0,0 +1,38 @@
+Given /the adapters are reset/ do
+  VBoxManage.network_adapters(@output).each_with_index do |obj, i|
+    VBoxManage.execute("modifyvm", @name, "--nic#{i+1}", "none")
+  end
+end
+
+Given /the adapter in slot "(.+?)" is type "(.+?)"/ do |slot, type|
+  VBoxManage.execute("modifyvm", @name, "--nic#{slot}", type)
+end
+
+Given /the following adapters are set:/ do |table|
+  table.hashes.each do |hash|
+    Given %Q[the adapter in slot "#{hash["slot"]}" is type "#{hash["type"]}"]
+  end
+end
+
+When /I update the adapter in slot "(.+?)"/ do |slot|
+  adapter = @relationship.find { |na| na.slot == (slot.to_i - 1) }
+  adapter.should_not be_nil
+
+  @model = adapter
+end
+
+Then /the network adapter properties should match/ do
+  adapters = VBoxManage.network_adapters(@output)
+  @relationship.length.should == adapters.length
+
+  @relationship.each do |na|
+    adapter = adapters[na.slot + 1]
+    adapter.should_not be_nil
+
+    if na.enabled?
+      test_mappings(NETWORK_ADAPTER_MAPPINGS, na, adapter)
+    else
+      adapter[:type].should == "none"
+    end
+  end
+end

data/features/step_definitions/shared_folder_steps.rb

@@ -0,0 +1,76 @@
+Given /I add a shared folder "(.+?)" with path "(.+?)" via VBoxManage/ do |name,hostpath|
+  VBoxManage.execute("sharedfolder", "add", @name,
+                     "--name", 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)
+end
+
+Given /a shared folder "(.+?)" exists/ do |name|
+  folders = VBoxManage.shared_folders(@output)
+
+  if !folders.keys.include?(name)
+    Given %Q[I add a shared folder "#{name}" with path "/#{name}" via VBoxManage]
+    Given %Q[I reload the VM]
+    Given %Q[the "shared_folders" relationship]
+  end
+end
+
+Given /no shared folder "(.+?)" exists/ do |name|
+  folders = VBoxManage.shared_folders(@output)
+
+  if folders.keys.include?(name)
+    Given %Q[I delete the shared folder "#{name}" via VBoxManage]
+    Given %Q[I reload the VM]
+    Given %Q[the "shared_folders" relationship]
+  end
+end
+
+When /I create a new shared folder "(.+?)" with path "(.+?)"/ do |name,hostpath|
+  @new_record = VirtualBox::SharedFolder.new
+  @new_record.name = name
+  @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
+
+Then /the shared folder properties should match/ do
+  folders = VBoxManage.shared_folders(@output)
+
+  @relationship.length.should == folders.length
+
+  @relationship.each do |sf|
+    folder = folders[sf.name]
+    test_mappings(SHARED_FOLDER_MAPPINGS, sf, folder)
+  end
+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/step_definitions/storage_controller_steps.rb

@@ -0,0 +1,16 @@
+Then /the number of storage controllers should match/ do
+  @relationship.length.should == VBoxManage.storage_controllers(@output).length
+end
+
+Then /the storage controller properties should match/ do
+  controllers = VBoxManage.storage_controllers(@output)
+
+  @relationship.each do |sc|
+    controller = controllers[sc.name]
+    controller.should_not be_nil
+
+    test_mappings(STORAGE_MAPPINGS, sc, controller) do |value, output|
+      [value.to_s.downcase.gsub("_",""), output.downcase]
+    end
+  end
+end

data/features/step_definitions/virtualbox_steps.rb

@@ -0,0 +1,17 @@
+# Testing VBoxManage -v output
+When /I try to read the virtualbox "(.+?)"/ do |item|
+  @key = item.to_sym
+  @result = VirtualBox.send(item)
+end
+
+Then /the result should match version output/ do
+  data = VBoxManage.execute("-v").split("r")
+  results = {
+    :version => data[0],
+    :revision => data[1],
+    :supported? => !!data
+  }
+
+  @result.should == results[@key]
+end
+

data/features/step_definitions/vm_steps.rb

@@ -0,0 +1,50 @@
+Given /I set the VM "(.+?)" to "(.+?)"/ do |key, value|
+  VBoxManage.execute("modifyvm", @name, "--#{key}", value)
+end
+
+Given /I set the VM properties:/ do |properties|
+  properties.hashes.each do |hash|
+    Given %Q[I set the VM "#{hash["name"]}" to "#{hash["value"]}"]
+  end
+end
+
+Given /I reload the VM$/ do
+  Given %Q[I find a VM identified by "#{@name}"]
+end
+
+When /I find a VM identified by "(.+?)"/ do |name|
+  @name = name
+  @output = VBoxManage.vm_info(name)
+  @vm = VirtualBox::VM.find(name)
+  @model = @vm
+end
+
+When /I reload the VM info$/ do
+  @output = VBoxManage.vm_info(@name)
+end
+
+When /I save the VM/ do
+  @vm.save
+end
+
+Then /the VM should not exist/ do
+  @output.should be_empty
+  @vm.should be_nil
+end
+
+Then /the VM should exist/ do
+  @output.should have_key("UUID")
+  @vm.should_not be_nil
+end
+
+Then /the "(.+?)" properties should match/ do |type|
+  map = {
+    "BIOS" => BIOS_MAPPINGS,
+    "CPU" => CPU_MAPPINGS,
+    "HW virt" => HWVIRT_MAPPINGS,
+    "VM" => VM_MAPPINGS
+  }
+
+  object = type == "VM" ? @vm : @relationship
+  test_mappings(map[type], object, @output)
+end