fixed-vagrant 0.7.4.dev

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,84 @@
+require "test_helper"
+
+class CleanMachineFolderVMActionTest < Test::Unit::TestCase
+  setup do
+    @klass = Vagrant::Action::VM::CleanMachineFolder
+    @app, @env = action_env
+
+    @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 .vbox-prev files" do
+      folders = {
+        "sfoo" => %W[foo bar baz.vbox-prev],
+        "sbar" => %W[foo.vbox-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.vbox-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
+
+      @instance.clean_machine_folder
+    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 = action_env
+
+    @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 = action_env
+    @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 = action_env
+
+    @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,30 @@
+require "test_helper"
+
+class CustomizeVMActionTest < Test::Unit::TestCase
+  setup do
+    @klass = Vagrant::Action::VM::Customize
+    @app, @env = action_env
+    @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
+    @env.env.config.vm.proc_stack.clear
+    @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,25 @@
+require "test_helper"
+
+class DestroyVMActionTest < Test::Unit::TestCase
+  setup do
+    @klass = Vagrant::Action::VM::Destroy
+    @app, @env = action_env
+
+    @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).once
+      @env["vm"].expects(:vm=).with(nil).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,49 @@
+require "test_helper"
+
+class DestroyUnusedNetworkInterfacesVMActionTest < Test::Unit::TestCase
+  setup do
+    @klass = Vagrant::Action::VM::DestroyUnusedNetworkInterfaces
+    @app, @env = action_env
+
+    @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
+      @interfaces = []
+      global = mock("global")
+      host = mock("host")
+      VirtualBox::Global.stubs(:global).returns(global)
+      global.stubs(:host).returns(host)
+      host.stubs(:network_interfaces).returns(@interfaces)
+    end
+
+    def stub_interface(length=5, type=:host_only)
+      interface = mock("interface")
+      interface.stubs(:interface_type).returns(type)
+      interface.stubs(:attached_vms).returns(Array.new(length))
+
+      @interfaces << interface
+      interface
+    end
+
+    should "destroy only the unused network interfaces" do
+      stub_interface(5)
+      stub_interface(7)
+      results = [stub_interface(0), stub_interface(0)]
+
+      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/discard_state_test.rb

@@ -0,0 +1,45 @@
+require "test_helper"
+
+class DiscardStateVMActionTest < Test::Unit::TestCase
+  setup do
+    @klass = Vagrant::Action::VM::DiscardState
+    @app, @env = action_env
+
+    @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
+      @vm.stubs(:created?).returns(true)
+      @internal_vm.stubs(:saved?).returns(false)
+    end
+
+    should "do nothing if the VM is not created" do
+      @vm.stubs(:created?).returns(false)
+      @internal_vm.expects(:discard_state).never
+      @app.expects(:call).with(@env).once
+      @instance.call(@env)
+    end
+
+    should "do nothing if not saved and continue chain" do
+      @internal_vm.expects(:saved?).returns(false)
+      @internal_vm.expects(:discard_state).never
+      @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,107 @@
+require "test_helper"
+
+class ExportVMActionTest < Test::Unit::TestCase
+  setup do
+    @klass = Vagrant::Action::VM::Export
+    @app, @env = action_env
+
+    @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(:recover).in_sequence(seq).with(@env)
+
+      @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(:recover).never
+
+      assert_raises(Vagrant::Errors::VMPowerOffToPackage) {
+        @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.recover(nil)
+    end
+
+    should "not delete anything if it doesn't exist" do
+      File.stubs(:exist?).returns(false)
+      File.expects(:unlink).never
+      @instance.recover(nil)
+    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)
+
+      @temp_dir = @env.env.tmp_path.join(@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