vagrant 1.0.7 → 2.4.4

data/test/unit_legacy/vagrant/action/vm/check_accessible_test.rb

@@ -1,61 +0,0 @@
-require 'test_helper'
-
-class CheckAccessibleVMActionTest < Test::Unit::TestCase
-  setup do
-    @klass = Vagrant::Action::VM::CheckAccessible
-  end
-
-  context "calling" do
-    setup do
-      @app, @env = action_env
-      @instance = @klass.new(@app, @env)
-    end
-
-    should "continue up the chain if the VM is nil" do
-      @env["vm"] = nil
-
-      @app.expects(:call).once
-
-      assert_nothing_raised {
-        @instance.call(@env)
-      }
-    end
-
-    should "continue up the chain if the VM is not created" do
-      @env["vm"] = mock("vm")
-      @env["vm"].stubs(:created?).returns(false)
-
-      @app.expects(:call).once
-
-      assert_nothing_raised {
-        @instance.call(@env)
-      }
-    end
-
-    should "continue up the chain if the VM is created and accessible" do
-      @env["vm"] = mock("vm")
-      @env["vm"].stubs(:created?).returns(true)
-      @env["vm"].stubs(:vm).returns(mock("real_vm"))
-      @env["vm"].vm.stubs(:accessible?).returns(true)
-
-      @app.expects(:call).once
-
-      assert_nothing_raised {
-        @instance.call(@env)
-      }
-    end
-
-    should "fail if the VM is not accessible" do
-      @env["vm"] = mock("vm")
-      @env["vm"].stubs(:created?).returns(true)
-      @env["vm"].stubs(:vm).returns(mock("real_vm"))
-      @env["vm"].vm.stubs(:accessible?).returns(false)
-
-      @app.expects(:call).never
-
-      assert_raises(Vagrant::Errors::VMInaccessible) {
-        @instance.call(@env)
-      }
-    end
-  end
-end

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

@@ -1,61 +0,0 @@
-require 'test_helper'
-
-class CheckBoxVMActionTest < Test::Unit::TestCase
-  setup do
-    @klass = Vagrant::Action::VM::CheckBox
-  end
-
-  context "calling" do
-    should "raise error if box not specified" do
-      app, env = action_env(vagrant_env(vagrantfile(<<-vf)))
-        config.vm.box = nil
-      vf
-
-      instance = @klass.new(app, env)
-      app.expects(:call).never
-
-      assert_raises(Vagrant::Errors::BoxNotSpecified) {
-        instance.call(env)
-      }
-    end
-
-    should "error if box does not exist and URL not specified" do
-      app, env = action_env(vagrant_env(vagrantfile(<<-vf)))
-        config.vm.box = "yo"
-        config.vm.box_url = nil
-      vf
-
-      instance = @klass.new(app, env)
-      app.expects(:call).never
-      env.env.boxes.expects(:find).with(env["config"].vm.box).returns(nil)
-
-      assert_raises(Vagrant::Errors::BoxSpecifiedDoesntExist) {
-        instance.call(env)
-      }
-    end
-
-    should "attempt to download box and continue if URL specified" do
-      app, env = action_env(vagrant_env(vagrantfile(<<-vf)))
-        config.vm.box = "yo"
-        config.vm.box_url = "http://google.com"
-      vf
-
-      # Save this for later because the expecations below clobber it
-      vms = env.env.vms
-
-      instance = @klass.new(app, env)
-      seq = sequence("seq")
-      env.env.boxes.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.boxes.expects(:reload!).in_sequence(seq)
-      vms.each do |name, vm|
-        vm.env.expects(:reload_config!).in_sequence(seq)
-      end
-      app.expects(:call).with(env).once.in_sequence(seq)
-
-      assert_nothing_raised {
-        instance.call(env)
-      }
-    end
-  end
-end

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

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

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

@@ -1,84 +0,0 @@
-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/unit_legacy/vagrant/action/vm/clear_forwarded_ports_test.rb

@@ -1,52 +0,0 @@
-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
-    @env["vm.modify"] = mock("proc")
-
-    @instance = @klass.new(@app, @env)
-  end
-
-  context "calling" do
-    def mock_fp
-      fp = mock("fp")
-      fp.expects(:destroy).once
-      fp
-    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
-
-    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
-
-    should "call the proper methods and continue chain" do
-      @adapters << mock_adapter
-      @adapters << mock_adapter
-
-      @env["vm.modify"].expects(:call).with() do |proc|
-        proc.call(@internal_vm)
-        true
-      end
-
-      @app.expects(:call).with(@env)
-      @instance.call(@env)
-    end
-  end
-end

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

@@ -1,22 +0,0 @@
-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/unit_legacy/vagrant/action/vm/clear_shared_folders_test.rb

@@ -1,40 +0,0 @@
-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
-    @env["vm.modify"] = mock("proc")
-
-    @internal_vm = mock("internal")
-    @vm.stubs(:vm).returns(@internal_vm)
-
-    @instance = @klass.new(@app, @env)
-  end
-
-  context "calling" 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
-
-      @env["vm.modify"].expects(:call).with() do |proc|
-        proc.call(@internal_vm)
-        true
-      end
-
-      @app.expects(:call).with(@env).once
-      @instance.call(@env)
-    end
-  end
-end

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

@@ -1,37 +0,0 @@
-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
-    @env["vm.modify"] = mock("proc")
-
-    @internal_vm = mock("internal")
-    @vm.stubs(:vm).returns(@internal_vm)
-  end
-
-  should "not run anything if no customize blocks exist" do
-    @env["config"].vm.proc_stack.clear
-    @env["vm.modify"].expects(:call).never
-    @app.expects(:call).with(@env).once
-    @instance.call(@env)
-  end
-
-  should "run the VM customization procs then save the VM" do
-    ran = false
-    @env["config"].vm.customize { |vm| }
-    @env["config"].vm.expects(:run_procs!).with(@internal_vm)
-
-    @env["vm.modify"].expects(:call).with() do |proc|
-      proc.call(@internal_vm)
-      true
-    end
-
-    @app.expects(:call).with(@env).once
-    @instance.call(@env)
-  end
-end

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

@@ -1,25 +0,0 @@
-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/unit_legacy/vagrant/action/vm/destroy_unused_network_interfaces_test.rb

@@ -1,49 +0,0 @@
-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/unit_legacy/vagrant/action/vm/discard_state_test.rb

@@ -1,45 +0,0 @@
-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/unit_legacy/vagrant/action/vm/export_test.rb

@@ -1,107 +0,0 @@
-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

data/test/unit_legacy/vagrant/action/vm/forward_ports_helpers_test.rb

@@ -1,77 +0,0 @@
-require "test_helper"
-
-class ForwardPortsHelpersVMActionTest < Test::Unit::TestCase
-  setup do
-    @klass = Class.new do
-      include Vagrant::Action::VM::ForwardPortsHelpers
-      def initialize(env); @env = env; end
-    end
-
-    @app, @env = action_env
-
-    @vm = mock("vm")
-    @vm.stubs(:name).returns("foo")
-    @env["vm"] = @vm
-
-    @instance = @klass.new(@env)
-  end
-
-  context "getting list of used ports" do
-    setup do
-      @vms = []
-      VirtualBox::VM.stubs(:all).returns(@vms)
-      VirtualBox.stubs(:version).returns("3.1.0")
-      @vm.stubs(:uuid).returns(:bar)
-    end
-
-    def mock_vm(options={})
-      options = {
-        :running? => true,
-        :accessible? => true,
-        :uuid => :foo
-      }.merge(options)
-
-      vm = mock("vm")
-      options.each do |k,v|
-        vm.stubs(k).returns(v)
-      end
-
-      vm
-    end
-
-    def mock_fp(hostport)
-      fp = mock("fp")
-      fp.stubs(:hostport).returns(hostport.to_s)
-      fp
-    end
-
-    should "ignore VMs which aren't running" do
-      @vms << mock_vm(:running? => false)
-      @vms[0].expects(:forwarded_ports).never
-      @instance.used_ports
-    end
-
-    should "ignore VMs which aren't accessible" do
-      @vms << mock_vm(:accessible? => false)
-      @vms[0].expects(:forwarded_ports).never
-      @instance.used_ports
-    end
-
-    should "ignore VMs of the same uuid" do
-      @vms << mock_vm(:uuid => @vm.uuid)
-      @vms[0].expects(:forwarded_ports).never
-      @instance.used_ports
-    end
-
-    should "return the forwarded ports for VB 3.2.x" do
-      VirtualBox.stubs(:version).returns("3.2.4")
-      fps = [mock_fp(2222), mock_fp(80)]
-      na = mock("na")
-      ne = mock("ne")
-      na.stubs(:nat_driver).returns(ne)
-      ne.stubs(:forwarded_ports).returns(fps)
-      @vms << mock_vm(:network_adapters => [na])
-      assert_equal [2222, 80], @instance.used_ports
-    end
-  end
-end