vagrantup 0.8.10 → 0.9.0

data/test/unit/vagrant/action/builder_test.rb

@@ -1,207 +1,156 @@
-require "test_helper"
-require "logger"
+require File.expand_path("../../../base", __FILE__)
 
-class ActionBuilderTest < Test::Unit::TestCase
-  setup do
-    @klass = Vagrant::Action::Builder
+describe Vagrant::Action::Builder do
+  let(:data) { { :data => [] } }
+  let(:instance) { described_class.new }
+
+  # This returns a proc that can be used with the builder
+  # that simply appends data to an array in the env.
+  def appender_proc(data)
+    Proc.new { |env| env[:data] << data }
   end
 
-  context "initializing" do
-    should "setup empty middleware stack" do
-      builder = @klass.new
-      assert builder.stack.empty?
+  context "basic `use`" do
+    it "should add items to the stack and make them callable" do
+      data = {}
+      proc = Proc.new { |env| env[:data] = true }
+
+      instance.use proc
+      instance.call(data)
+
+      data[:data].should == true
+    end
+
+    it "should be able to add multiple items" do
+      data = {}
+      proc1 = Proc.new { |env| env[:one] = true }
+      proc2 = Proc.new { |env| env[:two] = true }
+
+      instance.use proc1
+      instance.use proc2
+      instance.call(data)
+
+      data[:one].should == true
+      data[:two].should == true
     end
 
-    should "take block to setup stack" do
-      builder = @klass.new do
-        use Hash
-        use lambda { |i| i }
-      end
+    it "should be able to add another builder" do
+      data  = {}
+      proc1 = Proc.new { |env| env[:one] = true }
+
+      # Build the first builder
+      one   = described_class.new
+      one.use proc1
+
+      # Add it to this builder
+      two   = described_class.new
+      two.use one
+
+      # Call the 2nd and verify results
+      two.call(data)
+      data[:one].should == true
+    end
+
+    it "should be able to set additional variables when using" do
+      data  = { }
+      proc1 = Proc.new { |env| env[:data] += 1 }
+
+      # Build the first builder
+      one   = described_class.new
+      one.use proc1, :data => 5
+      one.call(data)
 
-      assert !builder.stack.empty?
-      assert_equal 2, builder.stack.length
+      data[:data].should == 6
     end
   end
 
-  context "with an instance" do
-    setup do
-      @instance = @klass.new
+  context "inserting" do
+    it "can insert at an index" do
+      instance.use appender_proc(1)
+      instance.insert(0, appender_proc(2))
+      instance.call(data)
+
+      data[:data].should == [2, 1]
     end
 
-    context "adding to the stack" do
-      should "return self" do
-        assert @instance.equal?(@instance.use(1))
-      end
-
-      should "add to the end" do
-        @instance.use 1
-        @instance.use 2
-        assert_equal [2, [], nil], @instance.stack.last
-      end
-
-      should "merge in other builder's stack" do
-        other = @klass.new do
-          use 2
-          use 3
-        end
-
-        @instance.use 1
-        @instance.use other
-        assert_equal 3, @instance.stack.length
-      end
-
-      should "prepend a set environment task for merging middlewares if given" do
-        other = @klass.new do
-          use 1
-        end
-
-        @instance.use 0
-        @instance.use(other, :foo => :bar)
-        assert_equal 3, @instance.stack.length
-        assert_equal Vagrant::Action::Env::Set, @instance.stack[1].first
-      end
+    it "can insert next to a previous object" do
+      proc2 = appender_proc(2)
+      instance.use appender_proc(1)
+      instance.use proc2
+      instance.insert(proc2, appender_proc(3))
+      instance.call(data)
+
+      data[:data].should == [1, 3, 2]
     end
 
-    context "flatten" do
-      should "return the flattened format of the builder" do
-        env = Vagrant::Action::Environment.new(nil)
-        env["logger"] = Logger.new(nil)
-        env.expects(:foo).once
-
-        func = lambda { |x| x.foo }
-        @instance.use func
-        proc = @instance.flatten
-        assert proc.respond_to?(:call)
-        proc.call(env)
-      end
+    it "can insert before" do
+      instance.use appender_proc(1)
+      instance.insert_before 0, appender_proc(2)
+      instance.call(data)
+
+      data[:data].should == [2, 1]
     end
 
-    context "inserting" do
-      setup do
-        @instance.use "1"
-        @instance.use "2"
-      end
-
-      should "insert at the proper numeric index" do
-        @instance.insert(1, "3")
-        assert_equal "3", @instance.stack[1].first
-      end
-
-      should "insert next to the proper object if given" do
-        @instance.insert("2", "3")
-        assert_equal "3", @instance.stack[1].first
-      end
-
-      should "be able to call insert_before as well" do
-        @instance.insert_before("1", "0")
-        assert_equal "0", @instance.stack.first.first
-      end
-
-      should "be able to insert_after" do
-        @instance.insert_after("1", "0")
-        assert_equal "0", @instance.stack[1].first
-      end
-
-      should "be able to insert_after using numeric index" do
-        @instance.insert_after(1, "0")
-        assert_equal "0", @instance.stack[2].first
-      end
-
-      should "raise an exception if invalid index" do
-        assert_raises(RuntimeError) {
-          @instance.insert_after("15", "0")
-        }
-      end
+    it "can insert after" do
+      instance.use appender_proc(1)
+      instance.use appender_proc(3)
+      instance.insert_after 0, appender_proc(2)
+      instance.call(data)
+
+      data[:data].should == [1, 2, 3]
     end
 
-    context "swapping" do
-      setup do
-        @instance.use "1"
-        @instance.use "2"
-      end
-
-      should "be able to swap using the object" do
-        @instance.swap "1", "3"
-        assert_equal "3", @instance.stack.first.first
-      end
-
-      should "be able to swap using the index" do
-        @instance.swap 0, "3"
-        assert_equal "3", @instance.stack.first.first
-      end
+    it "raises an exception if an invalid object given" do
+      expect { instance.insert_after "object", appender_proc(1) }.
+        to raise_error(RuntimeError)
     end
+  end
 
-    context "deleting" do
-      setup do
-        @instance.use "1"
-      end
+  context "replace" do
+    it "can replace an object" do
+      proc1 = appender_proc(1)
+      proc2 = appender_proc(2)
 
-      should "delete the proper object" do
-        @instance.delete("1")
-        assert @instance.stack.empty?
-      end
+      instance.use proc1
+      instance.replace proc1, proc2
+      instance.call(data)
 
-      should "delete by index if given" do
-        @instance.delete(0)
-        assert @instance.stack.empty?
-      end
+      data[:data].should == [2]
     end
 
-    context "getting an index of an object" do
-      should "return the proper index if it exists" do
-        @instance.use 1
-        @instance.use 2
-        @instance.use 3
-        assert_equal 1, @instance.index(2)
-      end
+    it "can replace by index" do
+      proc1 = appender_proc(1)
+      proc2 = appender_proc(2)
+
+      instance.use proc1
+      instance.replace 0, proc2
+      instance.call(data)
+
+      data[:data].should == [2]
     end
+  end
+
+  context "deleting" do
+    it "can delete by object" do
+      proc1 = appender_proc(1)
 
-    context "converting to an app" do
-      should "make non-classes lambdas" do
-        env = Vagrant::Action::Environment.new(nil)
-        env["logger"] = Logger.new(nil)
-        env.expects(:foo).once
-
-        func = lambda { |x| x.foo }
-        @instance.use func
-        @instance.to_app(env).call(env)
-      end
-
-      should "raise exception if given invalid middleware" do
-        @instance.use 7
-        assert_raises(RuntimeError) {
-          @instance.to_app(nil)
-        }
-      end
+      instance.use proc1
+      instance.use appender_proc(2)
+      instance.delete proc1
+      instance.call(data)
+
+      data[:data].should == [2]
     end
 
-    context "calling" do
-      def mock_middleware
-        middleware = Class.new do
-          def initialize(app, env)
-            @app = app
-          end
-
-          def call(env)
-            @app.call(env)
-          end
-        end
-      end
-
-      should "convert to an app then call with the env" do
-        mw = mock_middleware
-        mw.any_instance.expects(:call).with() do |env|
-          assert env.has_key?(:key)
-          true
-        end
-
-        env = Vagrant::Action::Environment.new(nil)
-        env["logger"] = Logger.new(nil)
-        env[:key] = :value
-
-        @instance.use(mw)
-        @instance.call(env)
-      end
+    it "can delete by index" do
+      proc1 = appender_proc(1)
+
+      instance.use proc1
+      instance.use appender_proc(2)
+      instance.delete 0
+      instance.call(data)
+
+      data[:data].should == [2]
     end
   end
 end

data/test/unit/vagrant/action/environment_test.rb

@@ -1,27 +1,16 @@
-require "test_helper"
+require File.expand_path("../../../base", __FILE__)
 
-class ActionEnvironmentTest < Test::Unit::TestCase
-  setup do
-    @klass = Vagrant::Action::Environment
-    @instance = @klass.new(vagrant_env)
-  end
-
-  should "be a hash with indifferent access" do
-    assert @instance.is_a?(Vagrant::Util::HashWithIndifferentAccess)
-  end
-
-  should "default values to those on the env" do
-    @instance.env.stubs(:key).returns("value")
-    assert_equal "value", @instance["key"]
-  end
+describe Vagrant::Action::Environment do
+  let(:instance) { described_class.new }
 
-  should "setup the UI" do
-    assert_equal @instance.env.ui, @instance.ui
+  it "should be a hash" do
+    instance.should be_empty
+    instance["foo"] = "bar"
+    instance["foo"].should == "bar"
   end
 
-  should "report interrupted if interrupt error" do
-    assert !@instance.interrupted?
-    @instance.interrupt!
-    assert @instance.interrupted?
+  it "should be a hash accessible by string or symbol" do
+    instance["foo"] = "bar"
+    instance[:foo].should == "bar"
   end
 end

data/test/unit/vagrant/action/runner_test.rb

@@ -0,0 +1,65 @@
+require File.expand_path("../../../base", __FILE__)
+
+describe Vagrant::Action::Runner do
+  let(:registry) do
+    d = double("registry")
+    d.stub(:get)
+    d
+  end
+
+  let(:instance) { described_class.new(registry) }
+
+  it "should raise an error if an invalid callable is given" do
+    expect { instance.run(7) }.to raise_error(ArgumentError, /must be a callable/)
+  end
+
+  it "should be able to use a Proc as a callable" do
+    callable = Proc.new { raise Exception, "BOOM" }
+    expect { instance.run(callable) }.to raise_error(Exception, "BOOM")
+  end
+
+  it "should be able to use a Class as a callable" do
+    callable = Class.new do
+      def initialize(app, env)
+      end
+
+      def call(env)
+        raise Exception, "BOOM"
+      end
+    end
+
+    expect { instance.run(callable) }.to raise_error(Exception, "BOOM")
+  end
+
+  it "should pass options into hash given to callable" do
+    result = nil
+    callable = lambda do |env|
+      result = env["data"]
+    end
+
+    instance.run(callable, "data" => "foo")
+    result.should == "foo"
+  end
+
+  it "should pass global options into the hash" do
+    result = nil
+    callable = lambda do |env|
+      result = env["data"]
+    end
+
+    instance = described_class.new(registry, "data" => "bar")
+    instance.run(callable)
+    result.should == "bar"
+  end
+
+  it "should yield the block passed to the init method to get lazy loaded globals" do
+    result = nil
+    callable = lambda do |env|
+      result = env["data"]
+    end
+
+    instance = described_class.new(registry) { { "data" => "bar" } }
+    instance.run(callable)
+    result.should == "bar"
+  end
+end

data/test/unit/vagrant/action/warden_test.rb

@@ -1,125 +1,92 @@
-require "test_helper"
-require "logger"
+require File.expand_path("../../../base", __FILE__)
 
-class ActionWardenTest < Test::Unit::TestCase
-  setup do
-    @klass = Vagrant::Action::Warden
-    @instance = @klass.new([], {})
-  end
+describe Vagrant::Action::Warden do
+  let(:data) { { :data => [] } }
+  let(:instance) { described_class.new }
 
-  context "initializing" do
-    should "finalize the middleware" do
-      env = new_env
-      middleware = [1,2,3]
-      middleware.each do |m|
-        @klass.any_instance.expects(:finalize_action).with(m, env).returns(m)
-      end
-      @warden = @klass.new(middleware, env)
-      assert_equal @warden.actions, [1,2,3]
-    end
+  # This returns a proc that can be used with the builder
+  # that simply appends data to an array in the env.
+  def appender_proc(data)
+    Proc.new { |env| env[:data] << data }
   end
 
-  context "setting up middleware" do
-    should "make non-classes lambdas" do
-      env = new_env
-      env.expects(:foo).once
+  it "calls the actions like normal" do
+    instance = described_class.new([appender_proc(1), appender_proc(2)], data)
+    instance.call(data)
 
-      func = lambda { |x| x.foo }
-      @instance.finalize_action(func, env).call(env)
-    end
-
-    should "raise exception if given invalid middleware" do
-      assert_raises(RuntimeError) {
-        @instance.finalize_action(7, nil)
-      }
-    end
+    data[:data].should == [1, 2]
   end
 
-  context "calling" do
-    should "return if there are no actions to execute" do
-      @instance.actions.expects(:pop).never
-      assert !@instance.call(new_env)
-    end
+  it "starts a recovery sequence when an exception is raised" do
+    class Action
+      def initialize(app, env)
+        @app = app
+      end
 
-    should "move the last action to the front of the stack" do
-      @instance.actions << lambda { |env| }
-      assert @instance.stack.empty?
-      @instance.call(new_env)
-      assert !@instance.stack.empty?
-      assert @instance.actions.empty?
-    end
+      def call(env)
+        @app.call(env)
+      end
 
-    should "call the next action" do
-      env = new_env
-      action = mock('action')
-      action.expects(:call).with(env)
-      @instance.actions << action
-      @instance.call(env)
+      def recover(env)
+        env[:recover] << 1
+      end
     end
 
-    should "begin recovery sequence when the called action raises an exception" do
-      class Foo
-        def initialize(*args); end
-        def call(env)
-          raise "An exception"
-        end
+    class ActionTwo
+      def initialize(app, env)
+        @app = app
       end
 
-      @instance.actions << Foo.new
-      @instance.expects(:begin_rescue).with() do |env|
-        assert env["vagrant.error"].is_a?(RuntimeError)
-        true
+      def call(env)
+        @app.call(env)
       end
-      assert_raises(RuntimeError) { @instance.call(new_env) }
-    end
 
-    should "not begin recovery sequence if a SystemExit is raised" do
-      class Foo
-        def initialize(*args); end
-        def call(env)
-          # Raises a system exit
-          abort
-        end
+      def recover(env)
+        env[:recover] << 2
       end
-
-      @instance.actions << Foo.new
-      @instance.expects(:begin_rescue).never
-      assert_raises(SystemExit) { @instance.call(new_env) }
     end
 
-    should "raise interrupt if the environment is interupted" do
-      env = new_env
-      env.expects(:interrupted?).returns(true)
-      @instance.actions << lambda { |env| }
+    error_proc = Proc.new { raise "ERROR!" }
 
-      assert_raises(Vagrant::Errors::VagrantInterrupt) {
-        @instance.call(env)
-      }
-    end
+    data     = { :recover => [] }
+    instance = described_class.new([Action, ActionTwo, error_proc], data)
+
+    # The error should be raised back up
+    expect { instance.call(data) }.
+      to raise_error(RuntimeError)
+
+    # Verify the recovery process goes in reverse order
+    data[:recover].should == [2, 1]
+
+    # Verify that the error is available in the data
+    data["vagrant.error"].should be_kind_of(RuntimeError)
   end
 
-  context "recover" do
-    should "call recover on all items in the stack" do
-      env = new_env
-      seq = sequence("sequence")
-      @instance.stack = [rescueable_mock("action"), rescueable_mock("another")]
-      @instance.stack.each do |action|
-        action.expects(:recover).with(env).in_sequence(seq)
+  it "does not do a recovery sequence if SystemExit is raised" do
+    class Action
+      def initialize(app, env)
+        @app = app
+      end
+
+      def call(env)
+        @app.call(env)
       end
 
-      @instance.begin_rescue(env)
+      def recover(env)
+        env[:recover] = true
+      end
     end
-  end
 
-  def new_env
-    env = Vagrant::Action::Environment.new(nil)
-    env["logger"] = Logger.new(nil)
-    env
-  end
+    # Make a proc that just calls "abort" which raises a
+    # SystemExit exception.
+    error_proc = Proc.new { abort }
+
+    instance = described_class.new([Action, error_proc], data)
+
+    # The SystemExit should come through
+    expect { instance.call(data) }.to raise_error(SystemExit)
 
-  def rescueable_mock(name)
-    mock_action = mock(name)
-    mock_action.stubs(:respond_to?).with(:recover).returns(true)
-    mock_action
+    # The recover should not have been called
+    data.has_key?(:recover).should_not be
   end
 end