vagrant 0.8.10 → 0.9.0

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

data/test/unit/vagrant/box_collection_test.rb

@@ -1,45 +1,56 @@
-require "test_helper"
+require File.expand_path("../../base", __FILE__)
 
-class BoxCollectionTest < Test::Unit::TestCase
-  setup do
-    clean_paths
+describe Vagrant::BoxCollection do
+  include_context "unit"
 
-    @klass = Vagrant::BoxCollection
-  end
-
-  should "load all the boxes from the box path" do
-    vagrant_box("foo")
-    vagrant_box("bar")
-
-    result = @klass.new(vagrant_env)
-    names = result.collect { |b| b.name }.sort
-    assert result.length >= 2
-    assert names.include?("foo")
-    assert names.include?("bar")
-  end
-
-  should "reload the box list" do
-    instance = @klass.new(vagrant_env)
-    amount = instance.length
+  let(:environment) { isolated_environment }
+  let(:action_runner) { double("action runner") }
+  let(:instance)    { described_class.new(environment.boxes_dir, action_runner) }
 
-    vagrant_box("foo")
+  it "should list all available boxes" do
+    # No boxes yet.
+    instance.length.should == 0
 
+    # Add some boxes to the environment and try again
+    environment.box("foo")
+    environment.box("bar")
     instance.reload!
-    assert_equal (amount + 1), instance.length
+    instance.length.should == 2
   end
 
-  should "find a specific box" do
-    vagrant_box("foo")
-    vagrant_box("bar")
+  describe "finding" do
+    it "should return nil if it can't find the box" do
+      instance.find("foo").should be_nil
+    end
+
+    it "should return a box instance for any boxes it does find" do
+      environment.box("foo")
+      result = instance.find("foo")
+      result.should be_kind_of(Vagrant::Box)
+      result.name.should == "foo"
+    end
+  end
 
-    instance = @klass.new(vagrant_env)
-    result = instance.find("foo")
-    assert result
-    assert_equal "foo", result.name
+  it "should throw an error if the box already exists when adding" do
+    environment.box("foo")
+    expect { instance.add("foo", "bar") }.to raise_error(Vagrant::Errors::BoxAlreadyExists)
   end
 
-  should "return nil if it couldn't find a specific box" do
-    instance = @klass.new(vagrant_env)
-    assert_nil instance.find("thisshouldnotexist")
+  it "should add the box" do
+    name = "foo"
+    url  = "bar"
+
+    # Test the invocation of the action runner with the proper name
+    # and parameters. We leave the testing of the actual stack to
+    # acceptance tests, and individual pieces to unit tests of each
+    # step.
+    options = {
+      :box_name => name,
+      :box_url => url,
+      :box_directory => instance.directory.join(name)
+    }
+    action_runner.should_receive(:run).with(:box_add, options)
+
+    instance.add(name, url)
   end
 end

data/test/unit/vagrant/box_test.rb

@@ -1,74 +1,34 @@
-require "test_helper"
+require File.expand_path("../../base", __FILE__)
 
-class BoxTest < Test::Unit::TestCase
-  context "class methods" do
-    setup do
-      @env = vagrant_env
-    end
+describe Vagrant::Box do
+  let(:name)          { "foo" }
+  let(:directory)     { "bar" }
+  let(:action_runner) { double("action_runner") }
+  let(:instance)      { described_class.new(name, directory, action_runner) }
 
-    context "adding" do
-      setup do
-        @name = "foo"
-        @uri = "bar"
-      end
-
-      should "create a new instance, set the variables, and add it" do
-        box = mock("box")
-        box.expects(:uri=).with(@uri)
-        box.expects(:add).once
-        Vagrant::Box.expects(:new).with(@env, @name).returns(box)
-        Vagrant::Box.add(@env, @name, @uri)
-      end
-    end
+  it "provides the name" do
+    instance.name.should == name
   end
 
-  context "instance methods" do
-    setup do
-      @box = Vagrant::Box.new(vagrant_env, "foo")
-    end
-
-    should "raise an exception if a box exists with the name we're attempting to add" do
-      vagrant_box(@box.name)
-
-      assert_raises(Vagrant::Errors::BoxAlreadyExists) {
-        @box.add
-      }
-    end
-
-    should "execute the Add action when add is called" do
-      @box.env.actions.expects(:run).with(:box_add, { "box" => @box, "validate" => false })
-      @box.add
-    end
+  it "can destroy itself" do
+    # Simply test the messages to the action runner
+    options = {
+      :box_name => name,
+      :box_directory => directory
+    }
+    action_runner.should_receive(:run).with(:box_remove, options)
 
-    context "box directory" do
-      should "return the boxes_path joined with the name" do
-        assert_equal @box.env.boxes_path.join(@box.name), @box.directory
-      end
-    end
-
-    context "destroying" do
-      should "execute the destroy action" do
-        @box.env.actions.expects(:run).with(:box_remove, { "box" => @box, "validate" => false })
-        @box.destroy
-      end
-    end
-
-    context "repackaging" do
-      should "execute the repackage action" do
-        @box.env.actions.expects(:run).with(:box_repackage, { "box" => @box, "validate" => false })
-        @box.repackage
-      end
+    instance.destroy
+  end
 
-      should "forward given options into the action" do
-        @box.env.actions.expects(:run).with(:box_repackage, { "box" => @box, "foo" => "bar", "validate" => false })
-        @box.repackage("foo" => "bar")
-      end
-    end
+  it "can repackage itself" do
+    # Simply test the messages to the action runner
+    options = {
+      :box_name => name,
+      :box_directory => directory
+    }
+    action_runner.should_receive(:run).with(:box_repackage, options)
 
-    context "ovf file" do
-      should "be the directory joined with the config ovf file" do
-        assert_equal @box.directory.join(@box.env.config.vm.box_ovf), @box.ovf_file
-      end
-    end
+    instance.repackage
   end
 end