vagrant 0.5.2 → 0.5.3

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

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

@@ -0,0 +1,83 @@
+require "test_helper"
+
+class BootVMActionTest < Test::Unit::TestCase
+  setup do
+    @klass = Vagrant::Action::VM::Boot
+    @app, @env = mock_action_data
+
+    @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 "do nothing if environment is erroneous" do
+      @env.error!(:foo)
+      @instance.expects(:boot).never
+      @app.expects(:call).never
+
+      @instance.call(@env)
+    end
+
+    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
+      @instance.call(@env)
+    end
+
+    should "not continue chain if error occured" do
+      boot_seq = sequence("boot_seq")
+      @instance.expects(:boot).in_sequence(boot_seq)
+      @instance.expects(:wait_for_boot).returns(true).in_sequence(boot_seq).with() do
+        @env.error!(:interrupt)
+        true
+      end
+      @app.expects(:call).never
+      @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.error!(: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/vagrant/action/vm/check_box_test.rb

@@ -0,0 +1,48 @@
+require 'test_helper'
+
+class CheckBoxVMActionTest < Test::Unit::TestCase
+  setup do
+    @klass = Vagrant::Action::VM::CheckBox
+    @app, @env = mock_action_data
+    @instance = @klass.new(@app, @env)
+  end
+
+  context "calling" do
+    setup do
+      Vagrant::Box.stubs(:find)
+    end
+
+    should "return error if box not specified" do
+      @env.env.config.vm.box = nil
+
+      @app.expects(:call).never
+      @instance.call(@env)
+
+      assert @env.error?
+      assert_equal :box_not_specified, @env.error.first
+    end
+
+    should "error if box does not exist and URL not specified" do
+      @env.env.config.vm.box_url = nil
+      Vagrant::Box.expects(:find).with(@env.env, @env["config"].vm.box).returns(nil)
+
+      @app.expects(:call).never
+      @instance.call(@env)
+
+      assert @env.error?
+      assert_equal :box_specified_doesnt_exist, @env.error.first
+    end
+
+    should "attempt to download box and continue if URL specified" do
+      seq = sequence("seq")
+      @env.env.config.vm.box_url = "bar"
+      Vagrant::Box.expects(:find).returns(nil)
+      Vagrant::Box.expects(:add).with(@env.env, @env["config"].vm.box, @env["config"].vm.box_url).in_sequence(seq)
+      @env.env.expects(:load_box!).in_sequence(seq)
+      @app.expects(:call).with(@env).once.in_sequence(seq)
+
+      @instance.call(@env)
+      assert !@env.error?
+    end
+  end
+end

data/test/vagrant/action/vm/check_guest_additions_test.rb

@@ -0,0 +1,9 @@
+require "test_helper"
+
+class CheckGuestAdditionsVMActionTest < Test::Unit::TestCase
+  setup do
+    @klass = Vagrant::Action::VM::CheckGuestAdditions
+  end
+
+  # TODO: This isn't tested.
+end

data/test/vagrant/action/vm/clean_machine_folder_test.rb

@@ -0,0 +1,82 @@
+require "test_helper"
+
+class CleanMachineFolderVMActionTest < Test::Unit::TestCase
+  setup do
+    @klass = Vagrant::Action::VM::CleanMachineFolder
+    @app, @env = mock_action_data
+
+    @instance = @klass.new(@app, @env)
+  end
+
+  context "calling" do
+    should "clean machine folder then continue chain" do
+      seq = sequence("seq")
+      @instance.expects(:clean_machine_folder).in_sequence(seq)
+      @app.expects(:call).with(@env).in_sequence(seq)
+      @instance.call(@env)
+    end
+  end
+
+  context "cleaning the folder" do
+    setup do
+      @machine_folder = "/foo/bar/baz"
+      @folder = File.join(@machine_folder, "*")
+      VirtualBox::Global.global.system_properties.stubs(:default_machine_folder).returns(@machine_folder)
+      File.stubs(:file?).returns(true)
+    end
+
+    should "ignore all non-directories" do
+      folders = %W[foo bar baz]
+      Dir.expects(:[]).with(@folder).returns(folders)
+      folders.each do |f|
+        File.expects(:directory?).with(f).returns(false)
+      end
+
+      FileUtils.expects(:rm_rf).never
+
+      @instance.clean_machine_folder
+    end
+
+    should "delete directories with only .xml-prev files" do
+      folders = {
+        "sfoo" => %W[foo bar baz.xml-prev],
+        "sbar" => %W[foo.xml-prev]
+      }
+
+      Dir.expects(:[]).with(@folder).returns(folders.keys)
+      folders.each do |folder, subfolders|
+        File.expects(:directory?).with(folder).returns(true)
+        Dir.expects(:[]).with("#{folder}/**/*").returns(subfolders)
+      end
+
+      FileUtils.expects(:rm_rf).never
+      FileUtils.expects(:rm_rf).with("sbar").once
+      @instance.clean_machine_folder
+    end
+
+    should "delete directories with only subdirectories" do
+      folders = {
+        "sfoo" => %W[foo bar],
+        "sbar" => %W[foo.xml-prev]
+      }
+
+      File.stubs(:file?).returns(false)
+      Dir.expects(:[]).with(@folder).returns(folders.keys)
+      folders.each do |folder, subfolders|
+        File.expects(:directory?).with(folder).returns(true)
+        Dir.expects(:[]).with("#{folder}/**/*").returns(subfolders)
+      end
+
+      FileUtils.expects(:rm_rf).never
+      FileUtils.expects(:rm_rf).with("sfoo").once
+      FileUtils.expects(:rm_rf).with("sbar").once
+
+      @instance.clean_machine_folder
+    end
+
+    should "do nothing if folder is < 10 characters" do
+      VirtualBox::Global.global.system_properties.stubs(:default_machine_folder).returns("foo")
+      Dir.expects(:[]).never
+    end
+  end
+end