vagrantup 0.5.2 → 0.5.3

data/test/vagrant/action/vm/boot_test.rb

@@ -0,0 +1,83 @@
+require "test_helper"
+
+class BootVMActionTest < Test::Unit::TestCase
+  setup do
+    @klass = Vagrant::Action::VM::Boot
+    @app, @env = mock_action_data
+
+    @vm = mock("vm")
+    @vm.stubs(:ssh).returns(mock("ssh"))
+    @env["vm"] = @vm
+
+    @internal_vm = mock("internal")
+    @vm.stubs(:vm).returns(@internal_vm)
+
+    @instance = @klass.new(@app, @env)
+  end
+
+  context "calling" do
+    should "do nothing if environment is erroneous" do
+      @env.error!(:foo)
+      @instance.expects(:boot).never
+      @app.expects(:call).never
+
+      @instance.call(@env)
+    end
+
+    should "run the proper methods on success" do
+      boot_seq = sequence("boot_seq")
+      @instance.expects(:boot).in_sequence(boot_seq)
+      @instance.expects(:wait_for_boot).returns(true).in_sequence(boot_seq)
+      @app.expects(:call).with(@env).once.in_sequence(boot_seq)
+      @instance.call(@env)
+    end
+
+    should "error and halt chain if boot failed" do
+      boot_seq = sequence("boot_seq")
+      @instance.expects(:boot).in_sequence(boot_seq)
+      @instance.expects(:wait_for_boot).returns(false).in_sequence(boot_seq)
+      @app.expects(:call).never
+      @instance.call(@env)
+    end
+
+    should "not continue chain if error occured" do
+      boot_seq = sequence("boot_seq")
+      @instance.expects(:boot).in_sequence(boot_seq)
+      @instance.expects(:wait_for_boot).returns(true).in_sequence(boot_seq).with() do
+        @env.error!(:interrupt)
+        true
+      end
+      @app.expects(:call).never
+      @instance.call(@env)
+    end
+  end
+
+  context "booting" do
+    should "start the VM in specified mode" do
+      mode = mock("boot_mode")
+      @env.env.config.vm.boot_mode = mode
+      @internal_vm.expects(:start).with(mode).once
+      @instance.boot
+    end
+  end
+
+  context "waiting for boot" do
+    should "repeatedly ping the SSH port and return false with no response" do
+      seq = sequence('pings')
+      @vm.ssh.expects(:up?).times(@env.env.config.ssh.max_tries.to_i - 1).returns(false).in_sequence(seq)
+      @vm.ssh.expects(:up?).once.returns(true).in_sequence(seq)
+      assert @instance.wait_for_boot
+    end
+
+    should "return right away if interrupted" do
+      @env.error!(:interrupt)
+      @vm.ssh.expects(:up?).times(1).returns(false)
+      assert @instance.wait_for_boot
+    end
+
+    should "ping the max number of times then just return" do
+      @vm.ssh.expects(:up?).times(@env.env.config.ssh.max_tries.to_i).returns(false)
+      assert !@instance.wait_for_boot
+    end
+  end
+end

data/test/vagrant/action/vm/check_box_test.rb

@@ -0,0 +1,48 @@
+require 'test_helper'
+
+class CheckBoxVMActionTest < Test::Unit::TestCase
+  setup do
+    @klass = Vagrant::Action::VM::CheckBox
+    @app, @env = mock_action_data
+    @instance = @klass.new(@app, @env)
+  end
+
+  context "calling" do
+    setup do
+      Vagrant::Box.stubs(:find)
+    end
+
+    should "return error if box not specified" do
+      @env.env.config.vm.box = nil
+
+      @app.expects(:call).never
+      @instance.call(@env)
+
+      assert @env.error?
+      assert_equal :box_not_specified, @env.error.first
+    end
+
+    should "error if box does not exist and URL not specified" do
+      @env.env.config.vm.box_url = nil
+      Vagrant::Box.expects(:find).with(@env.env, @env["config"].vm.box).returns(nil)
+
+      @app.expects(:call).never
+      @instance.call(@env)
+
+      assert @env.error?
+      assert_equal :box_specified_doesnt_exist, @env.error.first
+    end
+
+    should "attempt to download box and continue if URL specified" do
+      seq = sequence("seq")
+      @env.env.config.vm.box_url = "bar"
+      Vagrant::Box.expects(:find).returns(nil)
+      Vagrant::Box.expects(:add).with(@env.env, @env["config"].vm.box, @env["config"].vm.box_url).in_sequence(seq)
+      @env.env.expects(:load_box!).in_sequence(seq)
+      @app.expects(:call).with(@env).once.in_sequence(seq)
+
+      @instance.call(@env)
+      assert !@env.error?
+    end
+  end
+end

data/test/vagrant/action/vm/check_guest_additions_test.rb

@@ -0,0 +1,9 @@
+require "test_helper"
+
+class CheckGuestAdditionsVMActionTest < Test::Unit::TestCase
+  setup do
+    @klass = Vagrant::Action::VM::CheckGuestAdditions
+  end
+
+  # TODO: This isn't tested.
+end

data/test/vagrant/action/vm/clean_machine_folder_test.rb

@@ -0,0 +1,82 @@
+require "test_helper"
+
+class CleanMachineFolderVMActionTest < Test::Unit::TestCase
+  setup do
+    @klass = Vagrant::Action::VM::CleanMachineFolder
+    @app, @env = mock_action_data
+
+    @instance = @klass.new(@app, @env)
+  end
+
+  context "calling" do
+    should "clean machine folder then continue chain" do
+      seq = sequence("seq")
+      @instance.expects(:clean_machine_folder).in_sequence(seq)
+      @app.expects(:call).with(@env).in_sequence(seq)
+      @instance.call(@env)
+    end
+  end
+
+  context "cleaning the folder" do
+    setup do
+      @machine_folder = "/foo/bar/baz"
+      @folder = File.join(@machine_folder, "*")
+      VirtualBox::Global.global.system_properties.stubs(:default_machine_folder).returns(@machine_folder)
+      File.stubs(:file?).returns(true)
+    end
+
+    should "ignore all non-directories" do
+      folders = %W[foo bar baz]
+      Dir.expects(:[]).with(@folder).returns(folders)
+      folders.each do |f|
+        File.expects(:directory?).with(f).returns(false)
+      end
+
+      FileUtils.expects(:rm_rf).never
+
+      @instance.clean_machine_folder
+    end
+
+    should "delete directories with only .xml-prev files" do
+      folders = {
+        "sfoo" => %W[foo bar baz.xml-prev],
+        "sbar" => %W[foo.xml-prev]
+      }
+
+      Dir.expects(:[]).with(@folder).returns(folders.keys)
+      folders.each do |folder, subfolders|
+        File.expects(:directory?).with(folder).returns(true)
+        Dir.expects(:[]).with("#{folder}/**/*").returns(subfolders)
+      end
+
+      FileUtils.expects(:rm_rf).never
+      FileUtils.expects(:rm_rf).with("sbar").once
+      @instance.clean_machine_folder
+    end
+
+    should "delete directories with only subdirectories" do
+      folders = {
+        "sfoo" => %W[foo bar],
+        "sbar" => %W[foo.xml-prev]
+      }
+
+      File.stubs(:file?).returns(false)
+      Dir.expects(:[]).with(@folder).returns(folders.keys)
+      folders.each do |folder, subfolders|
+        File.expects(:directory?).with(folder).returns(true)
+        Dir.expects(:[]).with("#{folder}/**/*").returns(subfolders)
+      end
+
+      FileUtils.expects(:rm_rf).never
+      FileUtils.expects(:rm_rf).with("sfoo").once
+      FileUtils.expects(:rm_rf).with("sbar").once
+
+      @instance.clean_machine_folder
+    end
+
+    should "do nothing if folder is < 10 characters" do
+      VirtualBox::Global.global.system_properties.stubs(:default_machine_folder).returns("foo")
+      Dir.expects(:[]).never
+    end
+  end
+end

data/test/vagrant/action/vm/clear_forwarded_ports_test.rb

@@ -0,0 +1,72 @@
+require "test_helper"
+
+class ClearForwardedPortsVMActionTest < Test::Unit::TestCase
+  setup do
+    @klass = Vagrant::Action::VM::ClearForwardedPorts
+    @app, @env = mock_action_data
+
+    @vm = mock("vm")
+    @vm.stubs(:name).returns("foo")
+    @env["vm"] = @vm
+
+    @instance = @klass.new(@app, @env)
+  end
+
+  context "calling" do
+    should "call the proper methods and continue chain" do
+      seq = sequence('seq')
+      @instance.expects(:clear).in_sequence(seq)
+      @app.expects(:call).with(@env).in_sequence(seq)
+      @instance.call(@env)
+    end
+  end
+
+  context "clearing forwarded ports" do
+    setup do
+      @instance.stubs(:used_ports).returns([:a])
+      @instance.stubs(:clear_ports)
+    end
+
+    should "call destroy on all forwarded ports" do
+      @instance.expects(:clear_ports).once
+      @vm.expects(:reload!)
+      @instance.clear
+    end
+
+    should "do nothing if there are no forwarded ports" do
+      @instance.stubs(:used_ports).returns([])
+      @vm.expects(:reload!).never
+      @instance.clear
+    end
+  end
+
+  context "clearing ports" do
+    def mock_fp
+      fp = mock("fp")
+      fp.expects(:destroy).once
+      fp
+    end
+
+    setup do
+      VirtualBox.stubs(:version).returns("3.2.8")
+      @adapters = []
+      @internal_vm = mock("internal_vm")
+      @internal_vm.stubs(:network_adapters).returns(@adapters)
+      @vm.stubs(:vm).returns(@internal_vm)
+    end
+
+    def mock_adapter
+      na = mock("adapter")
+      engine = mock("engine")
+      engine.stubs(:forwarded_ports).returns([mock_fp])
+      na.stubs(:nat_driver).returns(engine)
+      na
+    end
+
+    should "destroy each forwarded port" do
+      @adapters << mock_adapter
+      @adapters << mock_adapter
+      @instance.clear_ports
+    end
+  end
+end

data/test/vagrant/action/vm/clear_nfs_exports_test.rb

@@ -0,0 +1,22 @@
+require "test_helper"
+
+class ClearNFSExportsActionTest < Test::Unit::TestCase
+  setup do
+    @klass = Vagrant::Action::VM::ClearNFSExports
+    @app, @env = mock_action_data
+    @env.env.stubs(:host).returns(Vagrant::Hosts::Base.new(@env))
+
+    @instance = @klass.new(@app, @env)
+  end
+
+  should "include the NFS helpers module" do
+    assert @klass.included_modules.include?(Vagrant::Action::VM::NFSHelpers)
+  end
+
+  should "clear NFS exports then continue chain" do
+    seq = sequence("seq")
+    @instance.expects(:clear_nfs_exports).with(@env).in_sequence(seq)
+    @app.expects(:call).with(@env).in_sequence(seq)
+    @instance.call(@env)
+  end
+end

data/test/vagrant/action/vm/clear_shared_folders_test.rb

@@ -0,0 +1,49 @@
+require "test_helper"
+
+class ClearSharedFoldersVMActionTest < Test::Unit::TestCase
+  setup do
+    @klass = Vagrant::Action::VM::ClearSharedFolders
+    @app, @env = mock_action_data
+
+    @vm = mock("vm")
+    @env["vm"] = @vm
+
+    @internal_vm = mock("internal")
+    @vm.stubs(:vm).returns(@internal_vm)
+
+    @instance = @klass.new(@app, @env)
+  end
+
+  context "calling" do
+    should "call the proper methods in sequence" do
+      seq = sequence("seq")
+      @instance.expects(:clear_shared_folders).once.in_sequence(seq)
+      @app.expects(:call).with(@env).once
+      @instance.call(@env)
+    end
+  end
+
+  context "clearing shared folders" do
+    setup do
+      @shared_folder = mock("shared_folder")
+      @shared_folders = [@shared_folder]
+      @internal_vm.stubs(:shared_folders).returns(@shared_folders)
+    end
+
+    should "call destroy on each shared folder then reload" do
+      destroy_seq = sequence("destroy")
+      @shared_folders.each do |sf|
+        sf.expects(:destroy).once.in_sequence(destroy_seq)
+      end
+
+      @vm.expects(:reload!).once.in_sequence(destroy_seq)
+      @instance.clear_shared_folders
+    end
+
+    should "do nothing if no shared folders existed" do
+      @shared_folders.clear
+      @vm.expects(:reload!).never
+      @instance.clear_shared_folders
+    end
+  end
+end

data/test/vagrant/action/vm/customize_test.rb

@@ -0,0 +1,29 @@
+require "test_helper"
+
+class CustomizeVMActionTest < Test::Unit::TestCase
+  setup do
+    @klass = Vagrant::Action::VM::Customize
+    @app, @env = mock_action_data
+    @instance = @klass.new(@app, @env)
+
+    @vm = mock("vm")
+    @env["vm"] = @vm
+
+    @internal_vm = mock("internal")
+    @vm.stubs(:vm).returns(@internal_vm)
+  end
+
+  should "not run anything if no customize blocks exist" do
+    @internal_vm.expects(:save).never
+    @app.expects(:call).with(@env).once
+    @instance.call(@env)
+  end
+
+  should "run the VM customization procs then save the VM" do
+    @env.env.config.vm.customize { |vm| }
+    @env.env.config.vm.expects(:run_procs!).with(@internal_vm)
+    @internal_vm.expects(:save).once
+    @app.expects(:call).with(@env).once
+    @instance.call(@env)
+  end
+end

data/test/vagrant/action/vm/destroy_test.rb

@@ -0,0 +1,26 @@
+require "test_helper"
+
+class DestroyVMActionTest < Test::Unit::TestCase
+  setup do
+    @klass = Vagrant::Action::VM::Destroy
+    @app, @env = mock_action_data
+
+    @vm = mock("vm")
+    @env["vm"] = @vm
+
+    @internal_vm = mock("internal")
+    @vm.stubs(:vm).returns(@internal_vm)
+
+    @instance = @klass.new(@app, @env)
+  end
+
+  context "destroying the VM" do
+    should "destroy VM and attached images" do
+      @internal_vm.expects(:destroy).with(:destroy_medium => :delete).once
+      @env["vm"].expects(:vm=).with(nil).once
+      @env.env.expects(:update_dotfile).once
+      @app.expects(:call).with(@env).once
+      @instance.call(@env)
+    end
+  end
+end

data/test/vagrant/action/vm/destroy_unused_network_interfaces_test.rb

@@ -0,0 +1,46 @@
+require "test_helper"
+
+class DestroyUnusedNetworkInterfacesVMActionTest < Test::Unit::TestCase
+  setup do
+    @klass = Vagrant::Action::VM::DestroyUnusedNetworkInterfaces
+    @app, @env = mock_action_data
+
+    @vm = mock("vm")
+    @env["vm"] = @vm
+
+    @internal_vm = mock("internal")
+    @vm.stubs(:vm).returns(@internal_vm)
+
+    @instance = @klass.new(@app, @env)
+  end
+
+  context "calling" do
+    setup do
+      @network_adapters = []
+      @internal_vm.stubs(:network_adapters).returns(@network_adapters)
+    end
+
+    def stub_interface(length=5)
+      interface = mock("interface")
+      adapter = mock("adapter")
+      adapter.stubs(:host_interface_object).returns(interface)
+      interface.stubs(:attached_vms).returns(Array.new(length))
+
+      @network_adapters << adapter
+      interface
+    end
+
+    should "destroy only the unused network interfaces" do
+      stub_interface(5)
+      stub_interface(7)
+      results = [stub_interface(1), stub_interface(1)]
+
+      results.each do |result|
+        result.expects(:destroy).once
+      end
+
+      @app.expects(:call).with(@env).once
+      @instance.call(@env)
+    end
+  end
+end

data/test/vagrant/action/vm/disable_networks_test.rb

@@ -0,0 +1,39 @@
+require "test_helper"
+
+class DisableNetworksVMActionTest < Test::Unit::TestCase
+  setup do
+    @klass = Vagrant::Action::VM::DisableNetworks
+    @app, @env = mock_action_data
+
+    @vm = mock("vm")
+    @env.env.stubs(:vm).returns(@vm)
+
+    @internal_vm = mock("internal")
+    @vm.stubs(:vm).returns(@internal_vm)
+    @internal_vm.stubs(:network_adapters).returns([])
+
+    @instance = @klass.new(@app, @env)
+  end
+
+  def mock_adapter(type)
+    adapter = mock("adapter")
+    adapter.stubs(:attachment_type).returns(type)
+
+    if type == :host_only
+      adapter.expects(:enabled=).with(false)
+      adapter.expects(:save)
+    end
+
+    @internal_vm.network_adapters << adapter
+  end
+
+  should "remove all network adapters and continue chain" do
+    mock_adapter(:bridged)
+    mock_adapter(:host_only)
+    mock_adapter(:host_only)
+
+    @app.expects(:call).with(@env).once
+
+    @instance.call(@env)
+  end
+end

data/test/vagrant/action/vm/discard_state_test.rb

@@ -0,0 +1,36 @@
+require "test_helper"
+
+class DiscardStateVMActionTest < Test::Unit::TestCase
+  setup do
+    @klass = Vagrant::Action::VM::DiscardState
+    @app, @env = mock_action_data
+
+    @vm = mock("vm")
+    @env["vm"] = @vm
+
+    @internal_vm = mock("internal")
+    @vm.stubs(:vm).returns(@internal_vm)
+
+    @instance = @klass.new(@app, @env)
+  end
+
+  context "calling" do
+    setup do
+      @internal_vm.stubs(:saved?).returns(false)
+    end
+
+    should "do nothing if not saved and continue chain" do
+      @internal_vm.expects(:saved?).returns(false)
+      @app.expects(:call).with(@env).once
+      @instance.call(@env)
+    end
+
+    should "discard state and continue chain" do
+      seq = sequence("sequence")
+      @internal_vm.expects(:saved?).returns(true).in_sequence(seq)
+      @internal_vm.expects(:discard_state).in_sequence(seq)
+      @app.expects(:call).with(@env).once.in_sequence(seq)
+      @instance.call(@env)
+    end
+  end
+end

data/test/vagrant/action/vm/export_test.rb

@@ -0,0 +1,135 @@
+require "test_helper"
+
+class ExportVMActionTest < Test::Unit::TestCase
+  setup do
+    @klass = Vagrant::Action::VM::Export
+    @app, @env = mock_action_data
+
+    @vm = mock("vm")
+    @env["vm"] = @vm
+
+    @internal_vm = mock("internal")
+    @vm.stubs(:vm).returns(@internal_vm)
+
+    @instance = @klass.new(@app, @env)
+  end
+
+  context "calling" do
+    setup do
+      @internal_vm.stubs(:powered_off?).returns(true)
+    end
+
+    should "call the proper methods then continue chain" do
+      seq = sequence("seq")
+      @instance.expects(:setup_temp_dir).in_sequence(seq)
+      @instance.expects(:export).in_sequence(seq)
+      @app.expects(:call).with(@env).in_sequence(seq)
+      @instance.expects(:cleanup).in_sequence(seq)
+
+      @instance.call(@env)
+    end
+
+    should "halt the chain if not powered off" do
+      @internal_vm.stubs(:powered_off?).returns(false)
+      @instance.expects(:setup_temp_dir).never
+      @instance.expects(:export).never
+      @app.expects(:call).with(@env).never
+      @instance.expects(:cleanup).never
+
+      @instance.call(@env)
+      assert @env.error?
+      assert_equal :vm_power_off_to_package, @env.error.first
+    end
+
+    should "halt the chain if env error" do
+      @internal_vm.stubs(:powered_off?).returns(true)
+      @instance.expects(:setup_temp_dir).never
+      @instance.expects(:export).never
+      @app.expects(:call).with(@env).never
+      @instance.expects(:cleanup).never
+
+      @env.error!(:interrupt)
+      @instance.call(@env)
+    end
+
+    should "halt the chain if env error when call is reached" do
+      @internal_vm.stubs(:powered_off?).returns(true)
+      @instance.expects(:setup_temp_dir).once
+      @instance.expects(:export).once.with() do
+        @env.error!(:interrupt)
+        true
+      end
+
+      @app.expects(:call).with(@env).never
+      @instance.expects(:cleanup).once
+
+      @instance.call(@env)
+    end
+  end
+
+  context "cleaning up" do
+    setup do
+      @temp_dir = "foo"
+      @instance.stubs(:temp_dir).returns(@temp_dir)
+      File.stubs(:exist?).returns(true)
+    end
+
+    should "delete the temporary file if it exists" do
+      File.expects(:unlink).with(@temp_dir).once
+      @instance.cleanup
+    end
+
+    should "not delete anything if it doesn't exist" do
+      File.stubs(:exist?).returns(false)
+      File.expects(:unlink).never
+      @instance.cleanup
+    end
+  end
+
+  context "setting up the temporary directory" do
+    setup do
+      @time_now = Time.now.to_i.to_s
+      Time.stubs(:now).returns(@time_now)
+
+      @tmp_path = "foo"
+      @env.env.stubs(:tmp_path).returns(@tmp_path)
+
+      @temp_dir = File.join(@env.env.tmp_path, @time_now)
+      FileUtils.stubs(:mkpath)
+    end
+
+    should "create the temporary directory using the current time" do
+      FileUtils.expects(:mkpath).with(@temp_dir).once
+      @instance.setup_temp_dir
+    end
+
+    should "set to the environment" do
+      @instance.setup_temp_dir
+      assert_equal @temp_dir, @env["export.temp_dir"]
+      assert_equal @temp_dir, @instance.temp_dir
+    end
+  end
+
+  context "exporting" do
+    setup do
+      @ovf_path = mock("ovf_path")
+      @instance.stubs(:ovf_path).returns(@ovf_path)
+    end
+
+    should "call export on the runner with the ovf path" do
+      @internal_vm.expects(:export).with(@ovf_path).once
+      @instance.export
+    end
+  end
+
+  context "path to OVF file" do
+    setup do
+      @temp_dir = "foo"
+      @env["export.temp_dir"] = @temp_dir
+    end
+
+    should "be the temporary directory joined with the OVF filename" do
+      assert_equal File.join(@temp_dir, @env.env.config.vm.box_ovf), @instance.ovf_path
+    end
+  end
+end