boxcar 0.10005.1

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

@@ -0,0 +1,30 @@
+require "test_helper"
+
+class VerifyBoxActionTest < Test::Unit::TestCase
+  setup do
+    @klass = Vagrant::Action::Box::Verify
+    @app, @env = action_env
+    @env["box"] = Vagrant::Box.new(vagrant_env, "foo")
+
+    @instance = @klass.new(@app, @env)
+  end
+
+  context "calling" do
+    should "continue fine if verification succeeds" do
+      seq = sequence("seq")
+      VirtualBox::Appliance.expects(:new).with(@env["box"].ovf_file.to_s).in_sequence(seq)
+      @app.expects(:call).with(@env).once.in_sequence(seq)
+      assert_nothing_raised {
+        @instance.call(@env)
+      }
+    end
+
+    should "halt chain if verification fails" do
+      VirtualBox::Appliance.expects(:new).with(@env["box"].ovf_file.to_s).raises(Exception)
+      @app.expects(:call).with(@env).never
+      assert_raises(Vagrant::Errors::BoxVerificationFailed) {
+        @instance.call(@env)
+      }
+    end
+  end
+end

data/test/unit_legacy/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 = action_env
+    @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/unit_legacy/vagrant/action/general/package_test.rb

@@ -0,0 +1,268 @@
+require "test_helper"
+
+class PackageGeneralActionTest < Test::Unit::TestCase
+  setup do
+    @klass = Vagrant::Action::General::Package
+    @app, @env = action_env
+
+    @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)
+    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 include 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_files_to_copy).in_sequence(seq).returns(true)
+        @instance.expects(:compress).in_sequence(seq)
+        @app.expects(:call).with(@env).in_sequence(seq)
+        @instance.call(@env)
+      end
+
+      should "halt the chain if the output file already exists" do
+        File.expects(:exist?).returns(true)
+        @app.expects(:call).never
+        assert_raises(Vagrant::Errors::PackageOutputExists) {
+          @instance.call(@env)
+        }
+      end
+
+      should "halt the chain if directory isn't set" do
+        @env["package.directory"] = nil
+        @app.expects(:call).never
+        assert_raises(Vagrant::Errors::PackageRequiresDirectory) {
+          @instance.call(@env)
+        }
+      end
+
+      should "halt the chain if directory doesn't exist" do
+        File.expects(:directory?).with(@env["package.directory"]).returns(false)
+        @app.expects(:call).never
+        assert_raises(Vagrant::Errors::PackageRequiresDirectory) {
+          @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.recover(@env)
+      end
+
+      should "delete the packaged box if it exists" do
+        File.expects(:exist?).returns(true)
+        File.expects(:delete).with(@instance.tar_path).once
+
+        @instance.recover(@env)
+      end
+    end
+
+    context "files to copy" do
+      setup do
+        @env["package.include"] = []
+        @package_dir = Pathname.new(@env["package.directory"]).join("include")
+      end
+
+      should "have included files whole path if relative" do
+        path = "lib/foo"
+        @env["package.include"] = [path]
+        result = @instance.files_to_copy
+        assert_equal @package_dir.join(path), result[path]
+      end
+
+      should "have the filename if an absolute path" do
+        path = "/foo/bar"
+        @env["package.include"] = [path]
+        result = @instance.files_to_copy
+        assert_equal @package_dir.join("bar"), result[path]
+      end
+
+      should "include the Vagrantfile if specified" do
+        @env["package.vagrantfile"] = "foo"
+        result = @instance.files_to_copy
+        assert_equal @package_dir.join("_Vagrantfile"), result["foo"]
+      end
+    end
+
+    context "verifying files to copy" 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_raises(Vagrant::Errors::PackageIncludeMissing) {
+          @instance.verify_files_to_copy
+        }
+      end
+
+      should "return true if all exist" do
+        assert_nothing_raised {
+          assert @instance.verify_files_to_copy
+        }
+      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
+        @env["package.include"] = ["/foo/bar", "lib/foo"]
+        seq = sequence("seq")
+        @instance.files_to_copy.each do |from, to|
+          FileUtils.expects(:mkdir_p).with(to.parent).in_sequence(seq)
+          File.expects(:directory?).with(from).returns(false).in_sequence(seq)
+          FileUtils.expects(:cp).with(from, to).in_sequence(seq)
+        end
+
+        @instance.copy_include_files
+      end
+
+      should "create the include directory and recursively copy globbed files to it" do
+        @env["package.include"] = ["foo*.txt"]
+        seq = sequence("seq")
+        @instance.files_to_copy.each do |from, to|
+          FileUtils.expects(:mkdir_p).with(to.parent).in_sequence(seq)
+          File.expects(:directory?).with(from).returns(true).in_sequence(seq)
+          Dir.expects(:glob).with(from).returns(from).in_sequence(seq)
+          FileUtils.expects(:cp_r).with(from, to.parent).in_sequence(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

data/test/unit_legacy/vagrant/action/general/validate_test.rb

@@ -0,0 +1,31 @@
+require "test_helper"
+
+class ValidateGeneralActionTest < Test::Unit::TestCase
+  setup do
+    @klass = Vagrant::Action::General::Validate
+    @app, @env = action_env
+  end
+
+  should "initialize fine" do
+    @klass.new(@app, @env)
+  end
+
+  should "validate and call up" do
+    @instance = @klass.new(@app, @env)
+
+    seq = sequence("seq")
+    @env["config"].expects(:validate!).once.in_sequence(seq)
+    @app.expects(:call).with(@env).once.in_sequence(seq)
+    @instance.call(@env)
+  end
+
+  should "not validate if env says not to" do
+    @env["validate"] = false
+    @instance = @klass.new(@app, @env)
+
+    seq = sequence("seq")
+    @env["config"].expects(:validate!).never
+    @app.expects(:call).with(@env).once.in_sequence(seq)
+    @instance.call(@env)
+  end
+end

data/test/unit_legacy/vagrant/action/vm/boot_test.rb

@@ -0,0 +1,66 @@
+require "test_helper"
+
+class BootVMActionTest < Test::Unit::TestCase
+  setup do
+    @klass = Vagrant::Action::VM::Boot
+    @app, @env = action_env
+
+    @vm = mock("vm")
+    @vm.stubs(:ssh).returns(mock("ssh"))
+    @env["vm"] = @vm
+
+    @internal_vm = mock("internal")
+    @vm.stubs(:vm).returns(@internal_vm)
+
+    @instance = @klass.new(@app, @env)
+  end
+
+  context "calling" do
+    should "run the proper methods on success" do
+      boot_seq = sequence("boot_seq")
+      @instance.expects(:boot).in_sequence(boot_seq)
+      @instance.expects(:wait_for_boot).returns(true).in_sequence(boot_seq)
+      @app.expects(:call).with(@env).once.in_sequence(boot_seq)
+      @instance.call(@env)
+    end
+
+    should "error and halt chain if boot failed" do
+      boot_seq = sequence("boot_seq")
+      @instance.expects(:boot).in_sequence(boot_seq)
+      @instance.expects(:wait_for_boot).returns(false).in_sequence(boot_seq)
+      @app.expects(:call).never
+      assert_raises(Vagrant::Errors::VMFailedToBoot) {
+        @instance.call(@env)
+      }
+    end
+  end
+
+  context "booting" do
+    should "start the VM in specified mode" do
+      mode = mock("boot_mode")
+      @env.env.config.vm.boot_mode = mode
+      @internal_vm.expects(:start).with(mode).once
+      @instance.boot
+    end
+  end
+
+  context "waiting for boot" do
+    should "repeatedly ping the SSH port and return false with no response" do
+      seq = sequence('pings')
+      @vm.ssh.expects(:up?).times(@env.env.config.ssh.max_tries.to_i - 1).returns(false).in_sequence(seq)
+      @vm.ssh.expects(:up?).once.returns(true).in_sequence(seq)
+      assert @instance.wait_for_boot
+    end
+
+    should "return right away if interrupted" do
+      @env.interrupt!
+      @vm.ssh.expects(:up?).times(1).returns(false)
+      assert @instance.wait_for_boot
+    end
+
+    should "ping the max number of times then just return" do
+      @vm.ssh.expects(:up?).times(@env.env.config.ssh.max_tries.to_i).returns(false)
+      assert !@instance.wait_for_boot
+    end
+  end
+end

data/test/unit_legacy/vagrant/action/vm/check_accessible_test.rb

@@ -0,0 +1,61 @@
+require 'test_helper'
+
+class CheckAccessibleVMActionTest < Test::Unit::TestCase
+  setup do
+    @klass = Vagrant::Action::VM::CheckAccessible
+  end
+
+  context "calling" do
+    setup do
+      @app, @env = action_env
+      @instance = @klass.new(@app, @env)
+    end
+
+    should "continue up the chain if the VM is nil" do
+      @env["vm"] = nil
+
+      @app.expects(:call).once
+
+      assert_nothing_raised {
+        @instance.call(@env)
+      }
+    end
+
+    should "continue up the chain if the VM is not created" do
+      @env["vm"] = mock("vm")
+      @env["vm"].stubs(:created?).returns(false)
+
+      @app.expects(:call).once
+
+      assert_nothing_raised {
+        @instance.call(@env)
+      }
+    end
+
+    should "continue up the chain if the VM is created and accessible" do
+      @env["vm"] = mock("vm")
+      @env["vm"].stubs(:created?).returns(true)
+      @env["vm"].stubs(:vm).returns(mock("real_vm"))
+      @env["vm"].vm.stubs(:accessible?).returns(true)
+
+      @app.expects(:call).once
+
+      assert_nothing_raised {
+        @instance.call(@env)
+      }
+    end
+
+    should "fail if the VM is not accessible" do
+      @env["vm"] = mock("vm")
+      @env["vm"].stubs(:created?).returns(true)
+      @env["vm"].stubs(:vm).returns(mock("real_vm"))
+      @env["vm"].vm.stubs(:accessible?).returns(false)
+
+      @app.expects(:call).never
+
+      assert_raises(Vagrant::Errors::VMInaccessible) {
+        @instance.call(@env)
+      }
+    end
+  end
+end