vagrant 0.5.2 → 0.5.3

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