vagrant 0.1.0

data/test/vagrant/actions/base_test.rb

@@ -0,0 +1,32 @@
+require File.join(File.dirname(__FILE__), '..', '..', 'test_helper')
+
+class BaseActionTest < Test::Unit::TestCase
+  should "include the util class so subclasses have access to it" do
+    assert Vagrant::Actions::Base.include?(Vagrant::Util)
+  end
+
+  context "base instance" do
+    setup do
+      @mock_vm = mock("vm")
+      @base = Vagrant::Actions::Base.new(@mock_vm)
+    end
+
+    should "allow read-only access to the runner" do
+      assert_equal @mock_vm, @base.runner
+    end
+
+    should "implement prepare which does nothing" do
+      assert_nothing_raised do
+        assert @base.respond_to?(:prepare)
+        @base.prepare
+      end
+    end
+
+    should "implement the execute! method which does nothing" do
+      assert_nothing_raised do
+        assert @base.respond_to?(:execute!)
+        @base.execute!
+      end
+    end
+  end
+end

data/test/vagrant/actions/box/add_test.rb

@@ -0,0 +1,37 @@
+require File.join(File.dirname(__FILE__), '..', '..', '..', 'test_helper')
+
+class AddBoxActionTest < Test::Unit::TestCase
+  setup do
+    @runner, @vm, @action = mock_action(Vagrant::Actions::Box::Add)
+    mock_config
+  end
+
+  context "prepare" do
+    setup do
+      @default_order = [Vagrant::Actions::Box::Download, Vagrant::Actions::Box::Unpackage]
+      @runner.stubs(:directory).returns("foo")
+      File.stubs(:exists?).returns(false)
+    end
+
+    def setup_action_expectations
+      default_seq = sequence("default_seq")
+      @default_order.each do |action|
+        @runner.expects(:add_action).with(action).once.in_sequence(default_seq)
+      end
+    end
+
+    should "setup the proper sequence of actions" do
+      setup_action_expectations
+      @action.prepare
+    end
+
+    should "result in an action exception if the box already exists" do
+      File.expects(:exists?).once.returns(true)
+      @runner.expects(:name).twice.returns('foo')
+      @runner.expects(:add_action).never
+      assert_raise Vagrant::Actions::ActionException do
+        @action.prepare
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+require File.join(File.dirname(__FILE__), '..', '..', '..', 'test_helper')
+
+class DestroyBoxActionTest < Test::Unit::TestCase
+  setup do
+    @name = "foo"
+    @dir = "foo"
+    @runner, @vm, @action = mock_action(Vagrant::Actions::Box::Destroy)
+    @runner.stubs(:directory).returns(@dir)
+    mock_config
+  end
+
+  context "executing" do
+    should "rm_rf the directory" do
+      FileUtils.expects(:rm_rf).with(@dir).once
+      @action.execute!
+    end
+  end
+end

data/test/vagrant/actions/box/download_test.rb

@@ -0,0 +1,118 @@
+require File.join(File.dirname(__FILE__), '..', '..', '..', 'test_helper')
+
+class DownloadBoxActionTest < Test::Unit::TestCase
+  setup do
+    @uri = "foo.com"
+    @runner, @vm, @action = mock_action(Vagrant::Actions::Box::Download)
+    @runner.stubs(:uri).returns(@uri)
+    @runner.stubs(:temp_path=)
+    mock_config
+
+    Vagrant::Env.stubs(:tmp_path).returns("foo")
+  end
+
+  context "preparing" do
+    setup do
+      @uri = mock("uri")
+      @uri.stubs(:is_a?).returns(false)
+      URI.stubs(:parse).returns(@uri)
+    end
+
+    should "raise an exception if no URI type is matched" do
+      @uri.stubs(:is_a?).returns(false)
+      assert_raises(Vagrant::Actions::ActionException) {
+        @action.prepare
+      }
+    end
+
+    should "set the downloader to file if URI is generic" do
+      @uri.stubs(:is_a?).with(URI::Generic).returns(true)
+      @action.prepare
+      assert @action.downloader.is_a?(Vagrant::Downloaders::File)
+    end
+
+    should "set the downloader to HTTP if URI is HTTP" do
+      @uri.stubs(:is_a?).with(URI::HTTP).returns(true)
+      @action.prepare
+      assert @action.downloader.is_a?(Vagrant::Downloaders::HTTP)
+    end
+  end
+
+  context "executing" do
+    setup do
+      @path = "foo"
+
+      @tempfile = mock("tempfile")
+      @tempfile.stubs(:path).returns(@path)
+
+      @action.stubs(:with_tempfile).yields(@tempfile)
+      @action.stubs(:download_to)
+    end
+
+    should "make a tempfile and copy the URI contents to it" do
+      @action.expects(:with_tempfile).yields(@tempfile)
+      @action.expects(:download_to).with(@tempfile)
+      @action.execute!
+    end
+
+    should "save the tempfile path" do
+      @runner.expects(:temp_path=).with(@path).once
+      @action.execute!
+    end
+  end
+
+  context "rescue" do
+    should "call cleanup method" do
+      @action.expects(:cleanup).once
+      @action.rescue(nil)
+    end
+  end
+
+  context "tempfile" do
+    should "create a tempfile in the vagrant tmp directory" do
+      Tempfile.expects(:open).with(Vagrant::Actions::Box::Download::BASENAME, Vagrant::Env.tmp_path).once
+      @action.with_tempfile
+    end
+
+    should "yield the tempfile object" do
+      @tempfile = mock("tempfile")
+      Tempfile.expects(:open).yields(@tempfile)
+
+      @action.with_tempfile do |otherfile|
+        assert @tempfile.equal?(otherfile)
+      end
+    end
+  end
+
+  context "cleaning up" do
+    setup do
+      @temp_path = "foo"
+      @runner.stubs(:temp_path).returns(@temp_path)
+      File.stubs(:exist?).returns(true)
+    end
+
+    should "delete the temporary file if it exists" do
+      File.expects(:unlink).with(@temp_path).once
+      @action.cleanup
+    end
+
+    should "not delete anything if it doesn't exist" do
+      File.stubs(:exist?).returns(false)
+      File.expects(:unlink).never
+      @action.cleanup
+    end
+  end
+
+  context "downloading" do
+    setup do
+      @downloader = mock("downloader")
+      @action.stubs(:downloader).returns(@downloader)
+    end
+
+    should "call download! on the download with the URI and tempfile" do
+      tempfile = "foo"
+      @downloader.expects(:download!).with(@runner.uri, tempfile)
+      @action.download_to(tempfile)
+    end
+  end
+end

data/test/vagrant/actions/box/unpackage_test.rb

@@ -0,0 +1,101 @@
+require File.join(File.dirname(__FILE__), '..', '..', '..', 'test_helper')
+
+class UnpackageBoxActionTest < Test::Unit::TestCase
+  setup do
+    @runner, @vm, @action = mock_action(Vagrant::Actions::Box::Unpackage)
+    @runner.stubs(:name).returns("foo")
+    @runner.stubs(:temp_path).returns("bar")
+    mock_config
+
+    Vagrant::Env.stubs(:boxes_path).returns("bar")
+  end
+
+  context "executing" do
+    setup do
+      @runner.stubs(:invoke_around_callback).yields
+    end
+
+    should "execute the proper actions in the proper order" do
+      exec_seq = sequence("exec_seq")
+      @action.expects(:setup_box_dir).in_sequence(exec_seq)
+      @action.expects(:decompress).in_sequence(exec_seq)
+      @action.execute!
+    end
+
+    should "execute it in a around block" do
+      @runner.expects(:invoke_around_callback).with(:unpackage).once
+      @action.execute!
+    end
+  end
+
+  context "rescuing" do
+    setup do
+      File.stubs(:directory?).returns(false)
+      FileUtils.stubs(:rm_rf)
+
+      @box_dir = mock("foo")
+      @action.stubs(:box_dir).returns(@box_dir)
+    end
+
+    should "do nothing if a directory doesn't exist" do
+      FileUtils.expects(:rm_rf).never
+      @action.rescue(nil)
+    end
+
+    should "remove the box directory if it exists" do
+      File.expects(:directory?).returns(true)
+      FileUtils.expects(:rm_rf).with(@box_dir).once
+      @action.rescue(nil)
+    end
+  end
+
+  context "box directory" do
+    should "return the runner directory" do
+      result = mock("object")
+      @runner.expects(:directory).once.returns(result)
+      assert result.equal?(@action.box_dir)
+    end
+  end
+
+  context "setting up the box directory" do
+    setup do
+      File.stubs(:directory?).returns(false)
+      FileUtils.stubs(:mkdir_p)
+
+      @box_dir = "foo"
+      @action.stubs(:box_dir).returns(@box_dir)
+    end
+
+    should "error and exit if the directory exists" do
+      File.expects(:directory?).returns(true)
+      @action.expects(:error_and_exit).once
+      @action.setup_box_dir
+    end
+
+    should "create the directory" do
+      FileUtils.expects(:mkdir_p).with(@box_dir).once
+      @action.setup_box_dir
+    end
+  end
+
+  context "decompressing" do
+    setup do
+      @box_dir = "foo"
+
+      @action.stubs(:box_dir).returns(@box_dir)
+      Dir.stubs(:chdir).yields
+    end
+
+    should "change to the box directory" do
+      Dir.expects(:chdir).with(@box_dir)
+      @action.decompress
+    end
+
+    should "open the tar file within the new directory, and extract it all" do
+      @tar = mock("tar")
+      @tar.expects(:extract_all).once
+      Tar.expects(:open).with(@runner.temp_path, anything, anything, anything).yields(@tar)
+      @action.decompress
+    end
+  end
+end

data/test/vagrant/actions/runner_test.rb

@@ -0,0 +1,236 @@
+require File.join(File.dirname(__FILE__), '..', '..', 'test_helper')
+
+class ActionRunnerTest < Test::Unit::TestCase
+  def mock_fake_action
+    action = mock("action")
+    action.stubs(:prepare)
+    action.stubs(:execute!)
+    action.stubs(:cleanup)
+    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
+    end
+
+    should "clear the actions and run a single action if given to execute!" do
+      action = mock("action")
+      run_action = mock("action_run")
+      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
+      @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 = []
+      5.times do |i|
+        action = mock("action#{i}")
+
+        @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 = [mock_fake_action, mock_fake_action]
+        @actions.each do |a|
+          a.stubs(:rescue)
+          @runner.actions << a
+        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
+        msg = "Message"
+        @exception = Vagrant::Actions::ActionException.new(msg)
+        @actions[0].stubs(:prepare).raises(@exception)
+
+        @runner.expects(:error_and_exit).with(msg).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
+end