vagrant 0.5.2 → 0.5.3

data/test/vagrant/action/box/package_test.rb

@@ -0,0 +1,25 @@
+require "test_helper"
+
+class PackageBoxActionTest < Test::Unit::TestCase
+  setup do
+    @klass = Vagrant::Action::Box::Package
+    @app, @env = mock_action_data
+    @env["box"] = Vagrant::Box.new(mock_environment, "foo")
+
+    @instance = @klass.new(@app, @env)
+  end
+
+  should "be a subclass of general packaging middleware" do
+    assert @instance.is_a?(Vagrant::Action::General::Package)
+  end
+
+  should "set the package directory then call parent" do
+    @instance.expects(:general_call).once.with() do |env|
+      assert env["package.directory"]
+      assert_equal env["package.directory"], @env["box"].directory
+      true
+    end
+
+    @instance.call(@env)
+  end
+end

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

@@ -0,0 +1,103 @@
+require "test_helper"
+
+class UnpackageBoxActionTest < Test::Unit::TestCase
+  setup do
+    @klass = Vagrant::Action::Box::Unpackage
+    @app, @env = mock_action_data
+
+    @vm = mock("vm")
+    @env["vm"] = @vm
+    @env["box"] = Vagrant::Box.new(mock_environment, "foo")
+
+    @internal_vm = mock("internal")
+    @vm.stubs(:vm).returns(@internal_vm)
+
+    @instance = @klass.new(@app, @env)
+  end
+
+  context "calling" do
+    should "call the proper chain" do
+      seq = sequence("sequence")
+      @instance.expects(:setup_box_directory).in_sequence(seq).returns(true)
+      @instance.expects(:decompress).in_sequence(seq)
+      @app.expects(:call).with(@env)
+      @instance.expects(:cleanup).never
+      @instance.call(@env)
+    end
+
+    should "halt the chain if setting up the box directory fails" do
+      @instance.expects(:setup_box_directory).returns(false)
+      @instance.expects(:decompress).never
+      @app.expects(:call).never
+      @instance.expects(:cleanup).never
+      @instance.call(@env)
+    end
+
+    should "cleanup if there was an error" do
+      @env.error!(:foo)
+
+      seq = sequence("sequence")
+      @instance.expects(:setup_box_directory).in_sequence(seq).returns(true)
+      @instance.expects(:decompress).in_sequence(seq)
+      @app.expects(:call).with(@env)
+      @instance.expects(:cleanup).once
+      @instance.call(@env)
+    end
+  end
+
+  context "cleaning up" do
+    setup do
+      @instance.stubs(:box_directory).returns("foo")
+      File.stubs(:directory?).returns(false)
+      FileUtils.stubs(:rm_rf)
+    end
+
+    should "do nothing if not a directory" do
+      FileUtils.expects(:rm_rf).never
+      @instance.cleanup
+    end
+
+    should "remove the directory if exists" do
+      File.expects(:directory?).with(@instance.box_directory).once.returns(true)
+      FileUtils.expects(:rm_rf).with(@instance.box_directory).once
+      @instance.cleanup
+    end
+  end
+
+  context "setting up the box directory" do
+    setup do
+      File.stubs(:directory?).returns(false)
+      FileUtils.stubs(:mkdir_p)
+    end
+
+    should "error the environment if the box already exists" do
+      File.expects(:directory?).returns(true)
+      assert !@instance.setup_box_directory
+      assert @env.error?
+      assert_equal :box_already_exists, @env.error.first
+    end
+
+    should "create the directory" do
+      FileUtils.expects(:mkdir_p).with(@env["box"].directory).once
+      @instance.setup_box_directory
+    end
+  end
+
+  context "decompressing" do
+    setup do
+      @env["download.temp_path"] = "bar"
+
+      Dir.stubs(:chdir).yields
+    end
+
+    should "change to the box directory" do
+      Dir.expects(:chdir).with(@env["box"].directory)
+      @instance.decompress
+    end
+
+    should "open the tar file within the new directory, and extract it all" do
+      Archive::Tar::Minitar.expects(:unpack).with(@env["download.temp_path"], @env["box"].directory).once
+      @instance.decompress
+    end
+  end
+end

data/test/vagrant/action/box/verify_test.rb

@@ -0,0 +1,39 @@
+require "test_helper"
+
+class VerifyBoxActionTest < Test::Unit::TestCase
+  setup do
+    @klass = Vagrant::Action::Box::Verify
+    @app, @env = mock_action_data
+
+    @vm = mock("vm")
+    @env["vm"] = @vm
+    @env["box"] = Vagrant::Box.new(mock_environment, "foo")
+
+    @internal_vm = mock("internal")
+    @vm.stubs(:vm).returns(@internal_vm)
+
+    @instance = @klass.new(@app, @env)
+  end
+
+  context "calling" do
+    setup do
+      @env.logger.stubs(:info)
+    end
+
+    should "continue fine if verification succeeds" do
+      seq = sequence("seq")
+      VirtualBox::Appliance.expects(:new).with(@env["box"].ovf_file).in_sequence(seq)
+      @app.expects(:call).with(@env).once.in_sequence(seq)
+      @instance.call(@env)
+      assert !@env.error?
+    end
+
+    should "halt chain if verification fails" do
+      VirtualBox::Appliance.expects(:new).with(@env["box"].ovf_file).raises(Exception)
+      @app.expects(:call).with(@env).never
+      @instance.call(@env)
+      assert @env.error?
+      assert_equal :box_verification_failed, @env.error.first
+    end
+  end
+end

data/test/vagrant/action/builder_test.rb

@@ -0,0 +1,218 @@
+require "test_helper"
+
+class ActionBuilderTest < Test::Unit::TestCase
+  setup do
+    @klass = Vagrant::Action::Builder
+  end
+
+  context "initializing" do
+    should "setup empty middleware stack" do
+      builder = @klass.new
+      assert builder.stack.empty?
+    end
+
+    should "take block to setup stack" do
+      builder = @klass.new do
+        use Hash
+        use lambda { |i| i }
+      end
+
+      assert !builder.stack.empty?
+      assert_equal 2, builder.stack.length
+    end
+  end
+
+  context "with an instance" do
+    setup do
+      @instance = @klass.new
+    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
+    end
+
+    context "flatten" do
+      should "return the flattened format of the builder" do
+        env = Vagrant::Action::Environment.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
+    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
+    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
+    end
+
+    context "deleting" do
+      setup do
+        @instance.use "1"
+      end
+
+      should "delete the proper object" do
+        @instance.delete("1")
+        assert @instance.stack.empty?
+      end
+
+      should "delete by index if given" do
+        @instance.delete(0)
+        assert @instance.stack.empty?
+      end
+    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
+    end
+
+    context "converting to an app" do
+      teardown do
+        Vagrant::Action.actions.clear
+      end
+
+      should "preprend error halt to the chain" do
+        result = mock("result")
+        env = {:a => :b}
+        middleware = mock("middleware")
+        middleware.stubs(:is_a?).with(Class).returns(true)
+        middleware.expects(:new).with(anything, env).returns(result)
+        @instance.use middleware
+        result = @instance.to_app(env)
+        assert result.kind_of?(Vagrant::Action::Env::ErrorHalt)
+      end
+
+      should "make non-classes lambdas" do
+        env = Vagrant::Action::Environment.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
+    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[:key] = :value
+
+        @instance.use(mw)
+        @instance.call(env)
+      end
+    end
+  end
+end

data/test/vagrant/action/env/error_halt_test.rb

@@ -0,0 +1,21 @@
+require "test_helper"
+
+class ErrorHaltEnvActionTest < Test::Unit::TestCase
+  setup do
+    @klass = Vagrant::Action::Env::ErrorHalt
+    @app, @env = mock_action_data
+    @instance = @klass.new(@app, @env)
+  end
+
+  should "continue the chain if no error" do
+    assert !@env.error?
+    @app.expects(:call).with(@env).once
+    @instance.call(@env)
+  end
+
+  should "halt the chain if an error occured" do
+    @env.error!(:foo)
+    @app.expects(:call).never
+    @instance.call(@env)
+  end
+end

data/test/vagrant/action/env/set_test.rb

@@ -0,0 +1,24 @@
+require "test_helper"
+
+class SetEnvActionTest < Test::Unit::TestCase
+  setup do
+    @klass = Vagrant::Action::Env::Set
+    @app, @env = mock_action_data
+    @env.clear
+  end
+
+  should "merge in the given options" do
+    @klass.new(@app, @env, :foo => :bar)
+    assert_equal :bar, @env[:foo]
+  end
+
+  should "not merge in anything if not given" do
+    @klass.new(@app, @env)
+    assert @env.empty?
+  end
+
+  should "just continue the chain" do
+    @app.expects(:call).with(@env)
+    @klass.new(@app, @env).call(@env)
+  end
+end

data/test/vagrant/action/environment_test.rb

@@ -0,0 +1,45 @@
+require "test_helper"
+
+class ActionEnvironmentTest < Test::Unit::TestCase
+  setup do
+    @klass = Vagrant::Action::Environment
+    @instance = @klass.new(mock_environment)
+  end
+
+  should "default values to those on the env" do
+    @instance.env.stubs(:key).returns("value")
+    assert_equal "value", @instance["key"]
+  end
+
+  should "setup the logger" do
+    assert_equal @instance.env.logger, @instance.logger
+  end
+
+  should "not be erroneous initially" do
+    assert !@instance.error?
+  end
+
+  should "mark as erroneous" do
+    @instance.error!(:key)
+    assert_equal [:key, {}], @instance.error
+  end
+
+  should "properly report erroneous" do
+    @instance.error!(:key)
+    assert @instance.error?
+  end
+
+  should "report interrupted if interrupt error" do
+    assert !@instance.interrupted?
+    @instance.error!(:interrupt)
+    assert @instance.interrupted?
+  end
+
+  should "have indifferent access" do
+    @instance[:foo] = :bar
+    @instance["bar"] = :baz
+
+    assert_equal :bar, @instance["foo"]
+    assert_equal :baz, @instance[:bar]
+  end
+end