bmabey-vagrant 0.2.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).once.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,131 @@
+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
+
+    @runner.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)
+
+      @downloader = mock("downloader")
+      Vagrant::Downloaders::File.any_instance.stubs(:prepare)
+      Vagrant::Downloaders::HTTP.any_instance.stubs(:prepare)
+    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 "call #prepare on the downloader" do
+      @downloader.expects(:prepare).with(@runner.uri).once
+      Vagrant::Downloaders::File.expects(:new).returns(@downloader)
+      @uri.stubs(:is_a?).with(URI::Generic).returns(true)
+      @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
+      File.expects(:open).with { |name, bitmask|
+        name =~ /#{Vagrant::Actions::Box::Download::BASENAME}/ &&  name =~ /#{@runner.env.tmp_path}/
+      }.once
+      @action.with_tempfile
+    end
+
+    should "yield the tempfile object" do
+      @tempfile = mock("tempfile")
+      File.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,100 @@
+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
+
+    @runner.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).with(:box_already_exists, :box_name => @runner.name).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
+      Archive::Tar::Minitar.stubs(:unpack)
+    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
+      Archive::Tar::Minitar.expects(:unpack).with(@runner.temp_path, @box_dir).once
+      @action.decompress
+    end
+  end
+end

data/test/vagrant/actions/collection_test.rb

@@ -0,0 +1,110 @@
+require File.join(File.dirname(__FILE__), '..', '..', 'test_helper')
+
+class CollectionTest < Test::Unit::TestCase
+  context "checking uniqueness" do
+    setup do
+      @actions = Vagrant::Actions::Collection.new([1])
+    end
+
+    should "return true if there are duplicate classes in the collection" do
+      @actions << 1
+      assert @actions.duplicates?
+    end
+    
+    should "return false it all the classes are unique" do
+      @actions << 1.0 << "foo"
+      assert !@actions.duplicates?
+    end
+
+    should "raise an exception when there are duplicates" do
+      @actions << 1 
+      assert_raise Vagrant::Actions::DuplicateActionException do
+        @actions.duplicates!
+      end
+    end
+
+    should "not raise an exception when there are no duplicates" do
+      @actions << 1.0 << "foo"
+      assert_nothing_raised do
+        @actions.duplicates!
+      end
+    end
+  end
+
+  context "verifying dependencies" do
+    setup do
+      @mock_action = mock('action')
+      @mock_action.stubs(:class).returns(MockAction)
+
+      @mock_action2 = mock('action2')
+      @mock_action2.stubs(:class).returns(MockActionOther)
+      # see test_helper
+      stub_default_action_dependecies(@mock_action)
+      stub_default_action_dependecies(@mock_action2)
+    end
+    
+    context "that come before an action" do
+      setup do
+        @mock_action.stubs(:follows).returns([MockActionOther])
+      end
+      should "raise an exception if they are not met" do
+        assert_raise Vagrant::Actions::DependencyNotSatisfiedException do
+          collection.new([@mock_action]).dependencies!
+        end
+      end
+    
+      should "not raise an exception if they are met" do
+        assert_nothing_raised do
+          collection.new([@mock_action2, @mock_action]).dependencies!
+        end
+      end
+    end
+
+    context "that follow an an action" do
+      setup do
+        @mock_action.stubs(:precedes).returns([MockActionOther])
+      end
+
+      should "raise an exception if they are not met" do
+        assert_raise Vagrant::Actions::DependencyNotSatisfiedException do
+          collection.new([@mock_action]).dependencies!
+        end
+      end
+
+      should "not raise an exception if they are met" do
+        assert_nothing_raised do
+          collection.new([@mock_action, @mock_action2]).dependencies!
+        end
+      end
+    end
+
+    context "that are before and after an action" do
+      setup do
+        @mock_action.stubs(:precedes).returns([MockActionOther])
+        @mock_action.stubs(:follows).returns([MockActionOther])
+      end
+
+      should "raise an exception if they are met" do
+        assert_raise Vagrant::Actions::DependencyNotSatisfiedException do
+          collection.new([@mock_action2, @mock_action]).dependencies!
+        end
+      end
+
+      should "not raise and exception if they are met" do
+        assert_nothing_raised do
+          collection.new([@mock_action2, @mock_action, @mock_action2]).dependencies!
+        end
+      end
+    end
+  end
+  
+  context "klasses" do
+    should "return a list of the collection element's classes" do
+      @action = mock('action')
+      assert_equal collection.new([@action]).klasses, [@action.class]
+      assert_equal collection.new([@action, 1.0, "foo"]).klasses, [@action.class, Float, String]
+    end
+  end
+
+  def collection; Vagrant::Actions::Collection end
+end

data/test/vagrant/actions/runner_test.rb

@@ -0,0 +1,265 @@
+require File.join(File.dirname(__FILE__), '..', '..', 'test_helper')
+
+class ActionRunnerTest < Test::Unit::TestCase
+  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, klass)
+        @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