vagrantup 1.0.7 → 1.1.0

data/test/unit/vagrant/data_store_test.rb

@@ -1,79 +0,0 @@
-require File.expand_path("../../base", __FILE__)
-
-require 'pathname'
-
-describe Vagrant::DataStore do
-  include_context "unit"
-
-  let(:db_file) do
-    # We create a tempfile and force an explicit close/unlink
-    # but save the path so that we can re-use it multiple times
-    temp = Tempfile.new("vagrant")
-    result = Pathname.new(temp.path)
-    temp.close
-    temp.unlink
-
-    result
-  end
-
-  let(:instance)    { described_class.new(db_file) }
-
-  it "initializes a new DB file" do
-    instance[:data] = true
-    instance.commit
-    instance[:data].should == true
-
-    test = described_class.new(db_file)
-    test[:data].should == true
-  end
-
-  it "initializes empty if the file contains invalid data" do
-    db_file.open("w+") { |f| f.write("NOPE!") }
-    described_class.new(db_file).should be_empty
-  end
-
-  it "initializes empty if the file doesn't exist" do
-    described_class.new("NOPENOPENOPENOPENPEPEPEPE").should be_empty
-  end
-
-  it "raises an error if the path given is a directory" do
-    db_file.delete if db_file.exist?
-    db_file.mkdir
-
-    expect { described_class.new(db_file) }.
-      to raise_error(Vagrant::Errors::DotfileIsDirectory)
-  end
-
-  it "cleans nil and empties when committing" do
-    instance[:data] = { :bar => nil }
-    instance[:another] = {}
-    instance.commit
-
-    # The instance is now empty because the data was nil
-    instance.should be_empty
-  end
-
-  it "deletes the data file if the store is empty when saving" do
-    instance[:data] = true
-    instance.commit
-
-    another = described_class.new(db_file)
-    another[:data] = nil
-    another.commit
-
-    # The file should no longer exist
-    db_file.should_not be_exist
-  end
-
-  it "works if the DB file is nil" do
-    store = described_class.new(nil)
-    store[:foo] = "bar"
-    store[:foo].should == "bar"
-  end
-
-  it "throws an exception if attempting to commit a data store with no file" do
-    store = described_class.new(nil)
-    expect { store.commit }.
-      to raise_error(StandardError)
-  end
-end

data/test/unit_legacy/locales/en.yml

@@ -1,8 +0,0 @@
-en:
-  vagrant:
-    test:
-      errors:
-        test_key: This is a test key
-        test_key_with_interpolation: This is a test key that says %{key}
-      alternate:
-        test_key: This is an alternate

data/test/unit_legacy/test_helper.rb

@@ -1,32 +0,0 @@
-# Add this folder to the load path for "test_helper"
-$:.unshift(File.dirname(__FILE__))
-
-require 'vagrant'
-require 'contest'
-require 'mocha'
-
-# Try to load ruby debug since its useful if it is available.
-# But not a big deal if its not available (probably on a non-MRI
-# platform)
-begin
-  require 'ruby-debug'
-rescue LoadError
-end
-
-# Do not buffer output for tests
-$stdout.sync = true
-$stderr.sync = true
-
-# Set the home directory to some temporary directory
-ENV["HOME"] = Vagrant.source_root.join("test", "tmp", "home").to_s
-
-# Set the log output to nothing
-ENV["VAGRANT_LOG"] = "NULL"
-
-# Add the I18n locale for tests
-I18n.load_path << File.expand_path("../locales/en.yml", __FILE__)
-
-class Test::Unit::TestCase
-  include Vagrant::TestHelpers
-end
-

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

@@ -1,18 +0,0 @@
-require "test_helper"
-
-class DestroyBoxActionTest < Test::Unit::TestCase
-  setup do
-    @klass = Vagrant::Action::Box::Destroy
-    @app, @env = action_env
-    @env["box"] = Vagrant::Box.new(vagrant_env, "foo")
-
-    @instance = @klass.new(@app, @env)
-  end
-
-  should "delete the box directory" do
-    seq = sequence("seq")
-    FileUtils.expects(:rm_rf).with(@env["box"].directory).in_sequence(seq)
-    @app.expects(:call).with(@env).once.in_sequence(seq)
-    @instance.call(@env)
-  end
-end

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

@@ -1,125 +0,0 @@
-require "test_helper"
-
-class DownloadBoxActionTest < Test::Unit::TestCase
-  setup do
-    @klass = Vagrant::Action::Box::Download
-    @app, @env = action_env
-    @env["box"] = Vagrant::Box.new(vagrant_env, "foo")
-    @env["box"].uri = "http://google.com"
-  end
-
-  context "initializing" do
-    should "initialize download classes" do
-      @klass.new(@app, @env)
-      assert_equal [Vagrant::Downloaders::HTTP, Vagrant::Downloaders::File], @env["download.classes"]
-    end
-  end
-
-  context "with an instance" do
-    setup do
-      @instance = @klass.new(@app, @env)
-    end
-
-    context "calling" do
-      should "call the proper methods in sequence" do
-        seq = sequence("seq")
-        @instance.expects(:instantiate_downloader).in_sequence(seq).returns(true)
-        @instance.expects(:download).in_sequence(seq)
-        @app.expects(:call).with(@env).in_sequence(seq)
-        @instance.expects(:recover).with(@env).in_sequence(seq)
-        @instance.call(@env)
-      end
-    end
-
-    context "instantiating downloader" do
-      should "instantiate the proper class" do
-        instance = mock("instance")
-        Vagrant::Downloaders::HTTP.expects(:new).with(@env).returns(instance)
-        instance.expects(:prepare).with(@env["box"].uri).once
-        assert @instance.instantiate_downloader
-      end
-
-      should "complain that the file doesn't exist if the URI is invalid for any downloaders" do
-        @env["box"].uri = "foobar"
-        assert_raises(Vagrant::Errors::DownloaderFileDoesntExist) {
-          @instance.instantiate_downloader
-        }
-      end
-    end
-
-    context "downloading" do
-      setup do
-        @path = "foo"
-
-        @tempfile = mock("tempfile")
-        @tempfile.stubs(:path).returns(@path)
-
-        @instance.stubs(:with_tempfile).yields(@tempfile)
-        @instance.stubs(:download_to)
-      end
-
-      should "make a tempfile and copy the URI contents to it" do
-        @instance.expects(:with_tempfile).yields(@tempfile)
-        @instance.expects(:download_to).with(@tempfile)
-        @instance.download
-      end
-
-      should "save the tempfile path" do
-        @instance.download
-        assert @env.has_key?("download.temp_path")
-        assert_equal @tempfile.path, @env["download.temp_path"]
-        assert_equal @tempfile.path, @instance.temp_path
-      end
-    end
-
-    context "tempfile" do
-      should "create a tempfile in the vagrant tmp directory" do
-        File.expects(:open).with { |name, bitmask|
-          name.to_s =~ /#{Vagrant::Action::Box::Download::BASENAME}/ &&  name.to_s =~ /#{@env.env.tmp_path}/
-        }.once
-        @instance.with_tempfile
-      end
-
-      should "yield the tempfile object" do
-        @tempfile = mock("tempfile")
-        File.expects(:open).yields(@tempfile)
-
-        @instance.with_tempfile do |otherfile|
-          assert @tempfile.equal?(otherfile)
-        end
-      end
-    end
-
-    context "cleaning up" do
-      setup do
-        @temp_path = "foo"
-        @instance.stubs(:temp_path).returns(@temp_path)
-        File.stubs(:exist?).returns(true)
-      end
-
-      should "delete the temporary file if it exists" do
-        File.expects(:unlink).with(@temp_path).once
-        @instance.recover(@env)
-      end
-
-      should "not delete anything if it doesn't exist" do
-        File.stubs(:exist?).returns(false)
-        File.expects(:unlink).never
-        @instance.recover(@env)
-      end
-    end
-
-    context "downloading to" do
-      setup do
-        @downloader = mock("downloader")
-        @instance.instance_variable_set(:@downloader, @downloader)
-      end
-
-      should "call download! on the download with the URI and tempfile" do
-        tempfile = "foo"
-        @downloader.expects(:download!).with(@env["box"].uri, tempfile)
-        @instance.download_to(tempfile)
-      end
-    end
-  end
-end

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

@@ -1,25 +0,0 @@
-require "test_helper"
-
-class PackageBoxActionTest < Test::Unit::TestCase
-  setup do
-    @klass = Vagrant::Action::Box::Package
-    @app, @env = action_env
-    @env["box"] = Vagrant::Box.new(vagrant_env, "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/unit_legacy/vagrant/action/box/unpackage_test.rb

@@ -1,84 +0,0 @@
-require "test_helper"
-
-class UnpackageBoxActionTest < Test::Unit::TestCase
-  setup do
-    @klass = Vagrant::Action::Box::Unpackage
-    @app, @env = action_env
-    @env["box"] = Vagrant::Box.new(vagrant_env, "foo")
-
-    @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.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 box directory is not set" do
-      @instance.stubs(:box_directory).returns(nil)
-      File.expects(:directory?).never
-      FileUtils.expects(:rm_rf).never
-      @instance.recover(nil)
-    end
-
-    should "do nothing if not a directory" do
-      FileUtils.expects(:rm_rf).never
-      @instance.recover(nil)
-    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.recover(nil)
-    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_raises(Vagrant::Errors::BoxAlreadyExists) {
-        @instance.setup_box_directory
-      }
-    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.to_s).once
-      @instance.decompress
-    end
-  end
-end

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

@@ -1,30 +0,0 @@
-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

@@ -1,24 +0,0 @@
-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

@@ -1,268 +0,0 @@
-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