vagrantup 0.4.3.dev → 0.5.0

data/test/vagrant/actions/runner_test.rb

@@ -1,268 +0,0 @@
-require File.join(File.dirname(__FILE__), '..', '..', 'test_helper')
-
-class ActionRunnerTest < Test::Unit::TestCase
-  class MockAction; end
-  class MockActionOther; end
-
-  def mock_fake_action(action_klass = nil, runner = nil)
-    action = action_klass ? action_klass.new(runner) : mock("action")
-    action.stubs(:prepare)
-    action.stubs(:execute!)
-    action.stubs(:cleanup)
-    stub_default_action_dependecies(action)
-    action
-  end
-
-  context "callbacks" do
-    setup do
-      @runner = Vagrant::Actions::Runner.new
-    end
-
-    context "around callbacks" do
-      should "invoke before/after_name for around callbacks" do
-        block_obj = mock("block_obj")
-        around_seq = sequence("around_seq")
-        @runner.expects(:invoke_callback).with(:before_foo).once.in_sequence(around_seq)
-        block_obj.expects(:foo).once.in_sequence(around_seq)
-        @runner.expects(:invoke_callback).with(:after_foo).once.in_sequence(around_seq)
-
-        @runner.invoke_around_callback(:foo) do
-          block_obj.foo
-        end
-      end
-
-      should "forward arguments to invoke_callback" do
-        @runner.expects(:invoke_callback).with(:before_foo, "foo").once
-        @runner.expects(:invoke_callback).with(:after_foo, "foo").once
-        @runner.invoke_around_callback(:foo, "foo") do; end
-      end
-    end
-
-    should "not invoke callback on actions which don't respond to it" do
-      action = mock("action")
-      action.stubs(:respond_to?).with(:foo).returns(false)
-      action.expects(:foo).never
-
-      assert_nothing_raised do
-        @runner.actions << action
-        @runner.invoke_callback(:foo)
-      end
-    end
-
-    should "invoke callback on actions which do respond to the method" do
-      action = mock("action")
-      action.expects(:foo).once
-
-      @runner.actions << action
-      @runner.invoke_callback(:foo)
-    end
-
-    should "collect all the results and return them as an array" do
-      result = []
-      3.times do |i|
-        action = mock("action#{i}")
-        action.expects(:foo).returns("foo#{i}").once
-
-        @runner.actions << action
-        result << "foo#{i}"
-      end
-
-      assert_equal result, @runner.invoke_callback(:foo)
-    end
-  end
-
-  context "finding actions" do
-    setup do
-      @runner = Vagrant::Actions::Runner.new
-    end
-
-    should "return nil if the action could not be found" do
-      assert_nil @runner.find_action(Vagrant::Actions::VM::Export)
-    end
-
-    should "return the first instance of the action found" do
-      @runner.add_action(Vagrant::Actions::VM::Export)
-      @runner.add_action(Vagrant::Actions::VM::Export)
-
-      assert @runner.actions[0].equal?(@runner.find_action(Vagrant::Actions::VM::Export))
-    end
-  end
-
-  context "adding actions" do
-    setup do
-      @runner = Vagrant::Actions::Runner.new
-    end
-
-    should "initialize the action when added" do
-      action_klass = mock("action_class")
-      action_inst = mock("action_inst")
-      action_klass.expects(:new).once.returns(action_inst)
-      @runner.add_action(action_klass)
-      assert_equal 1, @runner.actions.length
-    end
-
-    should "initialize the action with given arguments when added" do
-      action_klass = mock("action_class")
-      action_klass.expects(:new).with(@runner, "foo", "bar").once
-      @runner.add_action(action_klass, "foo", "bar")
-    end
-  end
-
-  context "class method execute" do
-    should "run actions on class method execute!" do
-      vm = mock("vm")
-      execute_seq = sequence("execute_seq")
-      Vagrant::Actions::Runner.expects(:new).returns(vm).in_sequence(execute_seq)
-      vm.expects(:add_action).with("foo").in_sequence(execute_seq)
-      vm.expects(:execute!).once.in_sequence(execute_seq)
-
-      Vagrant::Actions::Runner.execute!("foo")
-    end
-
-    should "forward arguments to add_action on class method execute!" do
-      vm = mock("vm")
-      execute_seq = sequence("execute_seq")
-      Vagrant::Actions::Runner.expects(:new).returns(vm).in_sequence(execute_seq)
-      vm.expects(:add_action).with("foo", "bar", "baz").in_sequence(execute_seq)
-      vm.expects(:execute!).once.in_sequence(execute_seq)
-
-      Vagrant::Actions::Runner.execute!("foo", "bar", "baz")
-    end
-  end
-
-  context "instance method execute" do
-    setup do
-      @runner = Vagrant::Actions::Runner.new
-      @runner.stubs(:action_klasses).returns([Vagrant::Actions::Base])
-    end
-
-    should "clear the actions and run a single action if given to execute!" do
-      action = mock("action")
-      run_action = mock("action_run")
-      stub_default_action_dependecies(run_action)
-      run_class = mock("run_class")
-      run_class.expects(:new).once.returns(run_action)
-      @runner.actions << action
-
-      [:prepare, :execute!, :cleanup].each do |method|
-        action.expects(method).never
-        run_action.expects(method).once
-      end
-
-      @runner.execute!(run_class)
-    end
-
-    should "clear actions after running execute!" do
-      @runner.actions << mock_fake_action
-      assert !@runner.actions.empty? # sanity
-      @runner.execute!
-      assert @runner.actions.empty?
-    end
-
-    should "run #prepare on all actions, then #execute!" do
-      action_seq = sequence("action_seq")
-      actions = []
-      [MockAction, MockActionOther].each_with_index do |klass, i|
-        action = mock("action#{i}")
-        action.expects(:class).returns(klass)
-        stub_default_action_dependecies(action)
-        @runner.actions << action
-        actions << action
-      end
-
-      [:prepare, :execute!, :cleanup].each do |method|
-        actions.each do |action|
-          action.expects(method).once.in_sequence(action_seq)
-        end
-      end
-
-      @runner.execute!
-    end
-
-    context "exceptions" do
-      setup do
-        @actions = [MockAction, MockActionOther].map do |klass|
-          action = mock_fake_action
-          action.expects(:class).returns(klass)
-          action.stubs(:rescue)
-          @runner.actions << action
-          action
-        end
-
-        @exception = Exception.new
-      end
-
-      should "call #rescue on each action if an exception is raised during execute!" do
-        @actions.each do |a|
-          a.expects(:rescue).with(@exception).once
-        end
-
-        @actions[0].stubs(:execute!).raises(@exception)
-
-        @runner.expects(:error_and_exit).never
-        assert_raises(Exception) { @runner.execute! }
-      end
-
-      should "call #rescue on each action if an exception is raised during prepare" do
-        @actions.each do |a|
-          a.expects(:rescue).with(@exception).once
-        end
-
-        @actions[0].stubs(:prepare).raises(@exception)
-
-        @runner.expects(:error_and_exit).never
-        assert_raises(Exception) { @runner.execute! }
-      end
-
-      should "call error_and_exit if it is an ActionException" do
-        @exception = Vagrant::Actions::ActionException.new("foo")
-        @actions[0].stubs(:prepare).raises(@exception)
-
-        @runner.expects(:error_and_exit).with(@exception.key, @exception.data).once
-        @runner.execute!
-      end
-    end
-  end
-
-  context "actions" do
-    setup do
-      @runner = Vagrant::Actions::Runner.new
-    end
-
-    should "setup actions to be an array" do
-      assert_nil @runner.instance_variable_get(:@actions)
-      actions = @runner.actions
-      assert actions.is_a?(Array)
-      assert actions.equal?(@runner.actions)
-    end
-
-    should "be empty initially" do
-      assert @runner.actions.empty?
-    end
-  end
-
-  context "duplicate action exceptions" do
-    setup do
-      @runner = Vagrant::Actions::Runner.new
-    end
-
-    should "should be raised when a duplicate is added" do
-      action = mock_fake_action
-      2.times {@runner.actions << action }
-      assert_raise Vagrant::Actions::DuplicateActionException do
-        @runner.execute!
-      end
-    end
-
-    should "should not be raise when no duplicate actions are present" do
-      @runner.actions << mock_fake_action(Vagrant::Actions::Base, @runner)
-      @runner.actions << mock_fake_action(Vagrant::Actions::VM::Halt, @runner)
-
-      assert_nothing_raised { @runner.execute! }
-    end
-
-    should "should not raise when a single action is specified" do
-      assert_nothing_raised { @runner.execute!(Vagrant::Actions::Base) }
-    end
-  end
-end

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

@@ -1,49 +0,0 @@
-require File.join(File.dirname(__FILE__), '..', '..', '..', 'test_helper')
-
-class BootActionTest < Test::Unit::TestCase
-  setup do
-    @runner, @vm, @action = mock_action(Vagrant::Actions::VM::Boot)
-    @runner.stubs(:invoke_callback)
-  end
-
-  context "execution" do
-    should "invoke the 'boot' around callback" do
-      boot_seq = sequence("boot_seq")
-      @runner.expects(:invoke_around_callback).with(:boot).once.in_sequence(boot_seq).yields
-      @action.expects(:boot).in_sequence(boot_seq)
-      @action.expects(:wait_for_boot).returns(true).in_sequence(boot_seq)
-      @action.execute!
-    end
-
-    should "error and exit if the bootup failed" do
-      fail_boot_seq = sequence("fail_boot_seq")
-      @action.expects(:boot).once.in_sequence(fail_boot_seq)
-      @action.expects(:wait_for_boot).returns(false).in_sequence(fail_boot_seq)
-      @action.expects(:error_and_exit).with(:vm_failed_to_boot).once.in_sequence(fail_boot_seq)
-      @action.execute!
-    end
-  end
-
-  context "booting" do
-    should "start the VM in specified mode" do
-      mode = mock("boot_mode")
-      @runner.env.config.vm.boot_mode = mode
-      @vm.expects(:start).with(mode).once
-      @action.boot
-    end
-  end
-
-  context "waiting for boot" do
-    should "repeatedly ping the SSH port and return false with no response" do
-      seq = sequence('pings')
-      @runner.ssh.expects(:up?).times(@runner.env.config.ssh.max_tries.to_i - 1).returns(false).in_sequence(seq)
-      @runner.ssh.expects(:up?).once.returns(true).in_sequence(seq)
-      assert @action.wait_for_boot(0)
-    end
-
-    should "ping the max number of times then just return" do
-      @runner.ssh.expects(:up?).times(@runner.env.config.ssh.max_tries.to_i).returns(false)
-      assert !@action.wait_for_boot(0)
-    end
-  end
-end

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

@@ -1,21 +0,0 @@
-require File.join(File.dirname(__FILE__), '..', '..', '..', 'test_helper')
-
-class CustomizeActionTest < Test::Unit::TestCase
-  setup do
-    @runner, @vm, @action = mock_action(Vagrant::Actions::VM::Customize)
-  end
-
-  context "executing" do
-    should "run the VM customization procs then save the VM" do
-      @runner.env.config.vm.customize { |vm| }
-      @runner.env.config.vm.expects(:run_procs!).with(@vm)
-      @vm.expects(:save).once
-      @action.execute!
-    end
-
-    should "not run anything if no customize blocks exist" do
-      @vm.expects(:save).never
-      @action.execute!
-    end
-  end
-end

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

@@ -1,37 +0,0 @@
-require File.join(File.dirname(__FILE__), '..', '..', '..', 'test_helper')
-
-class DestroyActionTest < Test::Unit::TestCase
-  setup do
-    @runner, @vm, @action = mock_action(Vagrant::Actions::VM::Destroy)
-  end
-
-  context "executing" do
-    should "invoke an around callback around the destroy" do
-      @runner.expects(:invoke_around_callback).with(:destroy).once
-      @action.execute!
-    end
-
-    should "destroy VM and clear persist" do
-      @runner.stubs(:invoke_around_callback).yields
-      clear_seq = sequence("clear")
-      @action.expects(:destroy_vm).in_sequence(clear_seq)
-      @action.expects(:update_dotfile).in_sequence(clear_seq)
-      @action.execute!
-    end
-  end
-
-  context "destroying the VM" do
-    should "destroy VM and attached images" do
-      @vm.expects(:destroy).with(:destroy_medium => :delete).once
-      @runner.expects(:vm=).with(nil).once
-      @action.destroy_vm
-    end
-  end
-
-  context "updating the dotfile" do
-    should "update the environment dotfile" do
-      @runner.env.expects(:update_dotfile).once
-      @action.update_dotfile
-    end
-  end
-end

data/test/vagrant/actions/vm/down_test.rb

@@ -1,39 +0,0 @@
-require File.join(File.dirname(__FILE__), '..', '..', '..', 'test_helper')
-
-class DownActionTest < Test::Unit::TestCase
-  setup do
-    @runner, @vm, @action = mock_action(Vagrant::Actions::VM::Down)
-  end
-
-  context "preparing" do
-    setup do
-      @vm.stubs(:running?).returns(false)
-    end
-
-    def setup_action_expectations(order)
-      default_seq = sequence("default_seq")
-      order.each do |action|
-        action = [action] unless action.is_a?(Array)
-        @runner.expects(:add_action).with(action.shift, *action).once.in_sequence(default_seq)
-      end
-    end
-
-    should "add the destroy action alone if VM is not running" do
-      setup_action_expectations([Vagrant::Actions::VM::Network, Vagrant::Actions::VM::Destroy])
-      @action.prepare
-    end
-
-    should "add the halt action if the VM is running" do
-      @vm.expects(:running?).returns(true)
-      setup_action_expectations([[Vagrant::Actions::VM::Halt, {:force => true}], Vagrant::Actions::VM::Network, Vagrant::Actions::VM::Destroy])
-      @action.prepare
-    end
-  end
-
-  context "after halting" do
-    should "sleep" do
-      Kernel.expects(:sleep).once
-      @action.after_halt
-    end
-  end
-end

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

@@ -1,88 +0,0 @@
-require File.join(File.dirname(__FILE__), '..', '..', '..', 'test_helper')
-
-class ExportActionTest < Test::Unit::TestCase
-  setup do
-    @runner, @vm, @action = mock_action(Vagrant::Actions::VM::Export)
-    @action.stubs(:complete_progress)
-  end
-
-  context "executing" do
-    should "setup the temp dir then export" do
-      exec_seq = sequence('execute')
-      @action.expects(:setup_temp_dir).once.in_sequence(exec_seq)
-      @action.expects(:export).once.in_sequence(exec_seq)
-      @action.execute!
-    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"
-      @runner.env.stubs(:tmp_path).returns(@tmp_path)
-
-      @temp_dir = File.join(@runner.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
-      @action.setup_temp_dir
-    end
-
-    should "set the temporary directory to the temp_dir variable" do
-      @action.setup_temp_dir
-      assert_equal @temp_dir, @action.temp_dir
-    end
-  end
-
-  context "path to OVF file" do
-    setup do
-      @temp_dir = "foo"
-      @action.stubs(:temp_dir).returns(@temp_dir)
-    end
-
-    should "be the temporary directory joined with the OVF filename" do
-      assert_equal File.join(@temp_dir, @runner.env.config.vm.box_ovf), @action.ovf_path
-    end
-  end
-
-  context "exporting" do
-    setup do
-      @ovf_path = mock("ovf_path")
-      @action.stubs(:ovf_path).returns(@ovf_path)
-    end
-
-    should "call export on the runner with the ovf path" do
-      @vm.expects(:export).with(@ovf_path).once
-      @action.export
-    end
-  end
-
-  context "cleanup" do
-    setup do
-      @temp_dir = "foo"
-      @action.stubs(:temp_dir).returns(@temp_dir)
-    end
-
-    should "remove the temporary directory" do
-      FileUtils.expects(:rm_r).with(@temp_dir).once
-      @action.cleanup
-    end
-
-    should "not remove a directory if temp_dir is nil" do
-      FileUtils.expects(:rm_r).never
-      @action.stubs(:temp_dir).returns(nil)
-      @action.cleanup
-    end
-  end
-
-  context "rescue" do
-    should "call cleanup method" do
-      @action.expects(:cleanup).once
-      @action.rescue(nil)
-    end
-  end
-end