vagrantup 0.5.2 → 0.5.3

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

data/test/vagrant/action/exception_catcher_test.rb

@@ -0,0 +1,30 @@
+require "test_helper"
+
+class ExceptionCatcherTest < Test::Unit::TestCase
+  setup do
+    @klass = Class.new
+    @klass.send(:include, Vagrant::Action::ExceptionCatcher)
+    @env = Vagrant::Action::Environment.new(mock_environment)
+
+    @instance = @klass.new
+  end
+
+  should "run block and return result if no exception" do
+    result = @instance.catch_action_exception(@env) do
+      true
+    end
+
+    assert result
+    assert !@env.error?
+  end
+
+  should "run block and return false with error environment on exception" do
+    result = @instance.catch_action_exception(@env) do
+      raise Vagrant::Action::ActionException.new(:foo, :foo => :bar)
+    end
+
+    assert !result
+    assert @env.error?
+    assert_equal :foo, @env.error.first
+  end
+end

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

@@ -0,0 +1,254 @@
+require "test_helper"
+
+class PackageGeneralActionTest < Test::Unit::TestCase
+  setup do
+    @klass = Vagrant::Action::General::Package
+    @app, @env = mock_action_data
+
+    @vm = mock("vm")
+    @env["vm"] = @vm
+  end
+
+  context "initializing" do
+    setup do
+      @tar_path = "foo"
+      File.stubs(:exist?).returns(false)
+      @klass.any_instance.stubs(:tar_path).returns(@tar_path)
+    end
+
+    should "initialize fine" do
+      @klass.new(@app, @env)
+      assert !@env.error?
+    end
+
+    should "set the output path to configured by default" do
+      @klass.new(@app, @env)
+      assert_equal @env["config"].package.name, @env["package.output"]
+    end
+
+    should "not set the output path if it is already set" do
+      @env["package.output"] = "foo"
+      @klass.new(@app, @env)
+      assert_equal "foo", @env["package.output"]
+    end
+
+    should "set the included files to empty by default" do
+      @klass.new(@app, @env)
+      assert_equal [], @env["package.include"]
+    end
+
+    should "not set the output path if it is already set" do
+      @env["package.include"] = "foo"
+      @klass.new(@app, @env)
+      assert_equal "foo", @env["package.include"]
+    end
+  end
+
+  context "with an instance" do
+    setup do
+      File.stubs(:exist?).returns(false)
+      File.stubs(:directory?).returns(true)
+      @instance = @klass.new(@app, @env)
+
+      @env["package.directory"] = "foo"
+    end
+
+    context "calling" do
+      should "call the proper methods then continue chain" do
+        seq = sequence("seq")
+        @instance.expects(:verify_included_files).in_sequence(seq).returns(true)
+        @instance.expects(:compress).in_sequence(seq)
+        @app.expects(:call).with(@env).in_sequence(seq)
+        @instance.expects(:cleanup).never
+
+        @instance.call(@env)
+      end
+
+      should "halt the chain if verify failed" do
+        @instance.expects(:verify_included_files).returns(false)
+        @instance.expects(:compress).never
+        @app.expects(:call).never
+
+        @instance.call(@env)
+      end
+
+      should "halt the chain if the output file already exists" do
+        File.expects(:exist?).returns(true)
+        @app.expects(:call).never
+        @instance.call(@env)
+
+        assert @env.error?
+        assert_equal :package_output_exists, @env.error.first
+      end
+
+      should "halt the chain if directory isn't set" do
+        @env["package.directory"] = nil
+        @app.expects(:call).never
+        @instance.call(@env)
+
+        assert @env.error?
+        assert_equal :package_requires_directory, @env.error.first
+      end
+
+      should "halt the chain if directory doesn't exist" do
+        File.expects(:directory?).with(@env["package.directory"]).returns(false)
+        @app.expects(:call).never
+        @instance.call(@env)
+
+        assert @env.error?
+        assert_equal :package_requires_directory, @env.error.first
+      end
+
+      should "run cleanup if environment errors" do
+        seq = sequence("seq")
+        @instance.expects(:verify_included_files).in_sequence(seq).returns(true)
+        @instance.expects(:compress).in_sequence(seq)
+        @app.expects(:call).with(@env).in_sequence(seq)
+        @instance.expects(:cleanup).in_sequence(seq)
+
+        @env.error!(:foo)
+        @instance.call(@env)
+      end
+    end
+
+    context "cleaning up" do
+      setup do
+        File.stubs(:exist?).returns(false)
+        File.stubs(:delete)
+
+        @instance.stubs(:tar_path).returns("foo")
+      end
+
+      should "do nothing if the file doesn't exist" do
+        File.expects(:exist?).with(@instance.tar_path).returns(false)
+        File.expects(:delete).never
+
+        @instance.cleanup
+      end
+
+      should "delete the packaged box if it exists" do
+        File.expects(:exist?).returns(true)
+        File.expects(:delete).with(@instance.tar_path).once
+
+        @instance.cleanup
+      end
+    end
+
+    context "verifying included files" do
+      setup do
+        @env["package.include"] = ["foo"]
+        File.stubs(:exist?).returns(true)
+      end
+
+      should "error if included file is not found" do
+        File.expects(:exist?).with("foo").returns(false)
+        assert !@instance.verify_included_files
+        assert @env.error?
+        assert_equal :package_include_file_doesnt_exist, @env.error.first
+      end
+
+      should "return true if all exist" do
+        assert @instance.verify_included_files
+        assert !@env.error?
+      end
+    end
+
+    context "copying include files" do
+      setup do
+        @env["package.include"] = []
+      end
+
+      should "do nothing if no include files are specified" do
+        assert @env["package.include"].empty?
+        FileUtils.expects(:mkdir_p).never
+        FileUtils.expects(:cp).never
+        @instance.copy_include_files
+      end
+
+      should "create the include directory and copy files to it" do
+        include_dir = File.join(@env["package.directory"], "include")
+        copy_seq = sequence("copy_seq")
+        FileUtils.expects(:mkdir_p).with(include_dir).once.in_sequence(copy_seq)
+
+        5.times do |i|
+          file = mock("f#{i}")
+          @env["package.include"] << file
+          FileUtils.expects(:cp).with(file, include_dir).in_sequence(copy_seq)
+        end
+
+        @instance.copy_include_files
+      end
+    end
+
+    context "compression" do
+      setup do
+        @env["package.include"] = []
+
+        @tar_path = "foo"
+        @instance.stubs(:tar_path).returns(@tar_path)
+
+        @pwd = "bar"
+        FileUtils.stubs(:pwd).returns(@pwd)
+        FileUtils.stubs(:cd)
+
+        @file = mock("file")
+        File.stubs(:open).yields(@file)
+
+        @output = mock("output")
+        @tar = Archive::Tar::Minitar
+        Archive::Tar::Minitar::Output.stubs(:open).yields(@output)
+        @tar.stubs(:pack_file)
+
+        @instance.stubs(:copy_include_files)
+      end
+
+      should "open the tar file with the tar path properly" do
+        File.expects(:open).with(@tar_path, Vagrant::Util::Platform.tar_file_options).once
+        @instance.compress
+      end
+
+      should "open tar file" do
+        Archive::Tar::Minitar::Output.expects(:open).with(@file).once
+        @instance.compress
+      end
+
+      #----------------------------------------------------------------
+      # Methods below this comment test the block yielded by Minitar open
+      #----------------------------------------------------------------
+      should "cd to the directory and append the directory" do
+        @files = []
+        compress_seq = sequence("compress_seq")
+
+        FileUtils.expects(:pwd).once.returns(@pwd).in_sequence(compress_seq)
+        @instance.expects(:copy_include_files).once.in_sequence(compress_seq)
+        FileUtils.expects(:cd).with(@env["package.directory"]).in_sequence(compress_seq)
+        Dir.expects(:glob).returns(@files).in_sequence(compress_seq)
+
+        5.times do |i|
+          file = mock("file#{i}")
+          @tar.expects(:pack_file).with(file, @output).once.in_sequence(compress_seq)
+          @files << file
+        end
+
+        FileUtils.expects(:cd).with(@pwd).in_sequence(compress_seq)
+        @instance.compress
+      end
+
+      should "pop back to the current directory even if an exception is raised" do
+        cd_seq = sequence("cd_seq")
+        FileUtils.expects(:cd).with(@env["package.directory"]).raises(Exception).in_sequence(cd_seq)
+        FileUtils.expects(:cd).with(@pwd).in_sequence(cd_seq)
+
+        assert_raises(Exception) {
+          @instance.compress
+        }
+      end
+    end
+
+    context "tar path" do
+      should "return proper path" do
+        assert_equal File.join(FileUtils.pwd, @env["package.output"]), @instance.tar_path
+      end
+    end
+  end
+end