tnargav 1.2.2

data/test/acceptance/support/shared/command_examples.rb

@@ -0,0 +1,33 @@
+# This is a shared example that tests that a command requires a
+# Vagrant environment to run properly. The exact command to run
+# should be given as a parameter to the shared examples.
+shared_examples "a command that requires a Vagrantfile" do |*args|
+  let(:command) do
+    raise ArgumentError, "A command must be set for the shared example." if args.empty?
+    args[0]
+  end
+
+  it "fails if no Vagrantfile is found" do
+    result = execute(*command)
+    result.should_not succeed
+    result.stderr.should match_output(:no_vagrantfile)
+  end
+end
+
+# This is a shared example that tests that the command requires a
+# virtual machine to be created, and additionally to be in one of
+# many states.
+shared_examples "a command that requires a virtual machine" do |*args|
+  let(:command) do
+    raise ArgumentError, "A command must be set for the shared example." if args.empty?
+    args[0]
+  end
+
+  it "fails if the virtual machine is not created" do
+    assert_execute("vagrant", "init")
+
+    result = execute(*command)
+    result.should_not succeed
+    result.stderr.should match_output(:error_vm_must_be_created)
+  end
+end

data/test/acceptance/support/virtualbox.rb

@@ -0,0 +1,36 @@
+require 'sys/proctable'
+
+module Acceptance
+  module VirtualBox
+    extend self
+
+    # This method will wait for the "VBoxSVC" process to end. This will
+    # block during that time period. The reason for this is because only
+    # one "VBoxSVC" can run per user and manages all state within VirtualBox.
+    # Before you can run VirtualBox with a custom home directory, you must
+    # wait for this VBoxSVC process to die.
+    def wait_for_vboxsvc
+      time_passed = 0
+      while find_vboxsvc
+        if time_passed > 5
+          raise Exception, "VBoxSVC process is not going away."
+        end
+
+        sleep 1
+        time_passed += 1
+      end
+    end
+
+    # This method finds the VBoxSVC process and returns information about it.
+    # This will return "nil" if VBoxSVC is not found.
+    def find_vboxsvc
+      Sys::ProcTable.ps do |process|
+        if process.comm == "VBoxSVC"
+          return process
+        end
+      end
+
+      nil
+    end
+  end
+end

data/test/acceptance/suspend_test.rb

@@ -0,0 +1,56 @@
+require File.expand_path("../base", __FILE__)
+require "acceptance/support/shared/command_examples"
+
+describe "vagrant suspend" do
+  include_context "acceptance"
+  it_behaves_like "a command that requires a Vagrantfile", ["vagrant", "suspend"]
+
+  it "succeeds and ignores if the VM is not created" do
+    require_box("default")
+
+    assert_execute("vagrant", "box", "add", "base", box_path("default"))
+    assert_execute("vagrant", "init")
+
+    result = assert_execute("vagrant", "suspend")
+    result.stdout.should match_output(:vm_not_created_warning)
+  end
+
+  it "is able to suspend a running virtual machine" do
+    require_box("default")
+
+    assert_execute("vagrant", "box", "add", "base", box_path("default"))
+    assert_execute("vagrant", "init")
+    assert_execute("vagrant", "up")
+
+    # Suspend the VM and assert that it worked properly (seemingly)
+    result = assert_execute("vagrant", "suspend")
+    result.stdout.should match_output(:vm_suspending)
+
+    # Assert that the VM is no longer running
+    result = assert_execute("vagrant", "status")
+    result.stdout.should match_output(:status, "default", "saved")
+  end
+
+  # These tests are parameterized since both "vagrant resume" and
+  # "vagrant up" should achieve the same result.
+  ["resume", "up"].each do |command|
+    it "is able to resume after the machine has been suspended using #{command}" do
+      require_box("default")
+
+      assert_execute("vagrant", "box", "add", "base", box_path("default"))
+      assert_execute("vagrant", "init")
+      assert_execute("vagrant", "up")
+      assert_execute("vagrant", "suspend")
+
+      # Assert that the VM is no longer running
+      result = assert_execute("vagrant", "status")
+      result.stdout.should match_output(:status, "default", "saved")
+
+      assert_execute("vagrant", command)
+
+      # Assert that the VM is once again running
+      result = assert_execute("vagrant", "status")
+      result.stdout.should match_output(:status, "default", "running")
+    end
+  end
+end

data/test/acceptance/up_basic_test.rb

@@ -0,0 +1,33 @@
+require File.expand_path("../base", __FILE__)
+require "acceptance/support/shared/command_examples"
+
+describe "vagrant up", "basics" do
+  include_context "acceptance"
+  it_behaves_like "a command that requires a Vagrantfile", ["vagrant", "up"]
+
+  # This creates an initial environment that is ready for a "vagrant up"
+  def initialize_valid_environment
+    require_box("default")
+
+    assert_execute("vagrant", "box", "add", "base", box_path("default"))
+    assert_execute("vagrant", "init")
+  end
+
+  it "brings up a running virtual machine" do
+    initialize_valid_environment
+
+    assert_execute("vagrant", "up")
+    result = assert_execute("vagrant", "status")
+    result.stdout.should match_output(:status, "default", "running")
+  end
+
+  it "is able to run if Vagrantfile is in a parent directory" do
+    initialize_valid_environment
+
+    # Create a subdirectory in the working directory and use
+    # that as the CWD for `vagrant up` and verify it still works
+    foodir = environment.workdir.join("foo")
+    foodir.mkdir
+    assert_execute("vagrant", "up", :chdir => foodir.to_s)
+  end
+end

data/test/acceptance/up_with_box_url.rb

@@ -0,0 +1,40 @@
+require File.expand_path("../base", __FILE__)
+require "acceptance/support/shared/command_examples"
+
+describe "vagrant up", "with a box URL set" do
+  include_context "acceptance"
+
+  it "downloads and brings up the VM if the box doesn't exist" do
+    require_box("default")
+
+    assert_execute("vagrant", "init", "base", box_path("default"))
+    result = assert_execute("vagrant", "up")
+    result.stdout.should match_output(:up_fetching_box, "base")
+  end
+
+  it "downloads the file only once and works if shared by multiple VMs", :issue => "GH-564" do
+    require_box("default")
+
+    environment.workdir.join("Vagrantfile").open("w+") do |f|
+      f.puts(<<-VFILE)
+Vagrant::Config.run do |config|
+  config.vm.define :machine1 do |vm_config|
+    vm_config.vm.box = "base"
+    vm_config.vm.box_url = "#{box_path("default")}"
+  end
+
+  config.vm.define :machine2 do |vm_config|
+    vm_config.vm.box = "base"
+    vm_config.vm.box_url = "#{box_path("default")}"
+  end
+end
+VFILE
+    end
+
+    # Bring up the environment, which should work. `machine1` should download
+    # the box while `machine2` doesn't.
+    result = assert_execute("vagrant", "up")
+    result.stdout.should match_output(:up_fetching_box, "base", "machine1")
+    result.stdout.should_not match_output(:up_fetching_box, "base", "machine2")
+  end
+end

data/test/acceptance/vagrant_test.rb

@@ -0,0 +1,47 @@
+require File.expand_path("../base", __FILE__)
+require "acceptance/support/matchers/have_color"
+
+describe "vagrant and color output" do
+  include_context "acceptance"
+
+  # This is a check to see if the `expect` program is installed on this
+  # computer. Some tests require this and if this doesn't exist then the
+  # test itself will be skipped.
+  def self.has_expect?
+    `which expect`
+    $?.success?
+  end
+
+  it "outputs color if there is a TTY", :if => has_expect? do
+    environment.workdir.join("color.exp").open("w+") do |f|
+      f.puts(<<-SCRIPT)
+spawn #{environment.replace_command("vagrant")} status
+expect default {}
+SCRIPT
+    end
+
+    result = execute("expect", "color.exp")
+    result.stdout.should have_color
+  end
+
+  it "doesn't output color if there is a TTY but --no-color is present", :if => has_expect? do
+    environment.workdir.join("color.exp").open("w+") do |f|
+      f.puts(<<-SCRIPT)
+spawn #{environment.replace_command("vagrant")} status --no-color
+expect default {}
+SCRIPT
+    end
+
+    result = execute("expect", "color.exp")
+    result.stdout.should_not have_color
+  end
+
+  it "doesn't output color in the absense of a TTY" do
+    # This should always output an error, which on a TTY would
+    # output color. We check that this doesn't output color.
+    # If `vagrant status` itself is broken, another acceptance test
+    # should catch that. We just assume it works here.
+    result = execute("vagrant", "status")
+    result.stdout.should_not have_color
+  end
+end

data/test/acceptance/version_test.rb

@@ -0,0 +1,15 @@
+require File.expand_path("../base", __FILE__)
+
+describe "vagrant version" do
+  include_context "acceptance"
+
+  it "prints the version when called with '-v'" do
+    result = execute("vagrant", "-v")
+    result.stdout.should match_output(:version, config.vagrant_version)
+  end
+
+  it "prints the version when called with '--version'" do
+    result = execute("vagrant", "--version")
+    result.stdout.should match_output(:version, config.vagrant_version)
+  end
+end

data/test/config/acceptance_boxes.yml

@@ -0,0 +1,7 @@
+# This is the list of required boxes for acceptance tests, and
+# their locations. The locations are used to download the boxes
+# on the fly, if necessary. Additionally, a SHA1 checksum is
+# given to determine if the box needs to be updated.
+- name: default
+  url: http://files.vagrantup.com/test/boxes/default.box
+  checksum: 1b0a7eb6e152c5b43f45485654ff4965a7f9f604

data/test/support/isolated_environment.rb

@@ -0,0 +1,46 @@
+require "fileutils"
+require "pathname"
+
+require "log4r"
+
+require "support/tempdir"
+
+# This class manages an isolated environment for Vagrant to
+# run in. It creates a temporary directory to act as the
+# working directory as well as sets a custom home directory.
+#
+# This class also provides various helpers to create Vagrantfiles,
+# boxes, etc.
+class IsolatedEnvironment
+  attr_reader :homedir
+  attr_reader :workdir
+
+  # Initializes an isolated environment. You can pass in some
+  # options here to configure runing custom applications in place
+  # of others as well as specifying environmental variables.
+  #
+  # @param [Hash] apps A mapping of application name (such as "vagrant")
+  #   to an alternate full path to the binary to run.
+  # @param [Hash] env Additional environmental variables to inject
+  #   into the execution environments.
+  def initialize
+    @logger = Log4r::Logger.new("test::isolated_environment")
+
+    # Create a temporary directory for our work
+    @tempdir = Tempdir.new("vagrant")
+    @logger.info("Initialize isolated environment: #{@tempdir.path}")
+
+    # Setup the home and working directories
+    @homedir = Pathname.new(File.join(@tempdir.path, "home"))
+    @workdir = Pathname.new(File.join(@tempdir.path, "work"))
+
+    @homedir.mkdir
+    @workdir.mkdir
+  end
+
+  # This closes the environment by cleaning it up.
+  def close
+    @logger.info("Removing isolated environment: #{@tempdir.path}")
+    FileUtils.rm_rf(@tempdir.path)
+  end
+end

data/test/support/tempdir.rb

@@ -0,0 +1,43 @@
+require 'fileutils'
+require 'tempfile'
+
+# This class provides an easy way of creating a temporary
+# directory and having it removed when the application exits.
+class Tempdir
+  attr_reader :path
+
+  def initialize(basename="vagrant")
+    @path = nil
+
+    # Loop and attempt to create a temporary directory until
+    # it succeeds.
+    while @path.nil?
+      file = Tempfile.new(basename)
+      @path = file.path
+      file.unlink
+
+      begin
+        Dir.mkdir(@path)
+      rescue
+        @path = nil
+      end
+    end
+
+    # Setup a finalizer to delete the directory. This is the same way
+    # that Tempfile and friends do this...
+    @cleanup_proc = lambda do
+      FileUtils.rm_rf(@path) if File.directory?(@path)
+    end
+
+    ObjectSpace.define_finalizer(self, @cleanup_proc)
+  end
+
+  # This deletes the temporary directory.
+  def unlink
+    # Delete the directory
+    @cleanup_proc.call
+
+    # Undefine the finalizer since we're all cleaned up
+    ObjectSpace.undefine_finalizer(self)
+  end
+end

data/test/unit/base.rb

@@ -0,0 +1,27 @@
+require "rubygems"
+require "rspec/autorun"
+
+# Require Vagrant itself so we can reference the proper
+# classes to test.
+require "vagrant"
+
+# Add the test directory to the load path
+$:.unshift File.expand_path("../../", __FILE__)
+
+# Load in helpers
+require "support/tempdir"
+require "unit/support/dummy_provider"
+require "unit/support/shared/base_context"
+
+# Do not buffer output
+$stdout.sync = true
+$stderr.sync = true
+
+# Configure RSpec
+RSpec.configure do |c|
+  c.expect_with :rspec, :stdlib
+end
+
+# Configure VAGRANT_CWD so that the tests never find an actual
+# Vagrantfile anywhere, or at least this minimizes those chances.
+ENV["VAGRANT_CWD"] = Tempdir.new.path

data/test/unit/support/dummy_provider.rb

@@ -0,0 +1,16 @@
+module VagrantTests
+  class DummyProviderPlugin < Vagrant.plugin("2")
+    name "Dummy Provider"
+    description <<-EOF
+    This creates a provider named "dummy" which does nothing, so that
+    the unit tests aren't reliant on VirtualBox (or any other real
+    provider for that matter).
+    EOF
+
+    provider(:dummy) { DummyProvider }
+  end
+
+  class DummyProvider < Vagrant.plugin("2", :provider)
+    # No-op
+  end
+end

data/test/unit/support/isolated_environment.rb

@@ -0,0 +1,179 @@
+require "fileutils"
+require "pathname"
+require "tempfile"
+
+require "json"
+require "log4r"
+
+require "vagrant/util/platform"
+require "vagrant/util/subprocess"
+
+require "support/isolated_environment"
+require "support/tempdir"
+
+module Unit
+  class IsolatedEnvironment < ::IsolatedEnvironment
+    def create_vagrant_env(options=nil)
+      options = {
+        :cwd => @workdir,
+        :home_path => @homedir
+      }.merge(options || {})
+
+      Vagrant::Environment.new(options)
+    end
+
+    # This creates a file in the isolated environment. By default this file
+    # will be created in the working directory of the isolated environment.
+    def file(name, contents)
+      @workdir.join(name).open("w+") do |f|
+        f.write(contents)
+      end
+    end
+
+    def vagrantfile(contents, root=nil)
+      root ||= @workdir
+      root.join("Vagrantfile").open("w+") do |f|
+        f.write(contents)
+      end
+    end
+
+    def box(name, vagrantfile_contents="")
+      # Create the box directory
+      box_dir = boxes_dir.join(name)
+      box_dir.mkpath
+
+      # Create the "box.ovf" file because that is how Vagrant heuristically
+      # determines a box is a V1 box.
+      box_dir.join("box.ovf").open("w") { |f| f.write("") }
+
+      # Populate the vagrantfile
+      vagrantfile(vagrantfile_contents, box_dir)
+
+      # Return the directory
+      box_dir
+    end
+
+    # Create an alias because "box" makes a V1 box, so "box1"
+    alias :box1 :box
+
+    # Creates a fake box to exist in this environment.
+    #
+    # @param [String] name Name of the box
+    # @param [Symbol] provider Provider the box was built for.
+    # @return [Pathname] Path to the box directory.
+    def box2(name, provider, options=nil)
+      # Default options
+      options = {
+        :vagrantfile => ""
+      }.merge(options || {})
+
+      # Make the box directory
+      box_dir = boxes_dir.join(name, provider.to_s)
+      box_dir.mkpath
+
+      # Create a metadata.json file
+      box_metadata_file = box_dir.join("metadata.json")
+      box_metadata_file.open("w") do |f|
+        f.write(JSON.generate({
+          :provider => provider.to_s
+        }))
+      end
+
+      # Create a Vagrantfile
+      box_vagrantfile = box_dir.join("Vagrantfile")
+      box_vagrantfile.open("w") do |f|
+        f.write(options[:vagrantfile])
+      end
+
+      # Return the box directory
+      box_dir
+    end
+
+    # This creates a "box" file that is a valid V1 box.
+    #
+    # @return [Pathname] Path to the newly created box.
+    def box1_file
+      # Create a temporary directory to store our data we will tar up
+      td_source = Tempdir.new
+      td_dest   = Tempdir.new
+
+      # Store the temporary directory so it is not deleted until
+      # this instance is garbage collected.
+      @_box2_file_temp ||= []
+      @_box2_file_temp << td_dest
+
+      # The source as a Pathname, which is easier to work with
+      source = Pathname.new(td_source.path)
+
+      # The destination file
+      result = Pathname.new(td_dest.path).join("temporary.box")
+
+      # Put a "box.ovf" in there.
+      source.join("box.ovf").open("w") do |f|
+        f.write("FOO!")
+      end
+
+      Dir.chdir(source) do
+        # Find all the files in our current directory and tar it up!
+        files = Dir.glob(File.join(".", "**", "*"))
+
+        # Package!
+        Vagrant::Util::Subprocess.execute("bsdtar", "-czf", result.to_s, *files)
+      end
+
+      # Resulting box
+      result
+    end
+
+    # This creates a "box" file with the given provider.
+    #
+    # @param [Symbol] provider Provider for the box.
+    # @return [Pathname] Path to the newly created box.
+    def box2_file(provider, options=nil)
+      options ||= {}
+
+      # This is the metadata we want to store in our file
+      metadata = {
+        "type"     => "v2_box",
+        "provider" => provider
+      }.merge(options[:metadata] || {})
+
+      # Create a temporary directory to store our data we will tar up
+      td_source = Tempdir.new
+      td_dest   = Tempdir.new
+
+      # Store the temporary directory so it is not deleted until
+      # this instance is garbage collected.
+      @_box2_file_temp ||= []
+      @_box2_file_temp << td_dest
+
+      # The source as a Pathname, which is easier to work with
+      source = Pathname.new(td_source.path)
+
+      # The destination file
+      result = Pathname.new(td_dest.path).join("temporary.box")
+
+      # Put the metadata.json in here.
+      source.join("metadata.json").open("w") do |f|
+        f.write(JSON.generate(metadata))
+      end
+
+      Dir.chdir(source) do
+        # Find all the files in our current directory and tar it up!
+        files = Dir.glob(File.join(".", "**", "*"))
+
+        # Package!
+        Vagrant::Util::Subprocess.execute("bsdtar", "-czf", result.to_s, *files)
+      end
+
+      # Resulting box
+      result
+    end
+
+    def boxes_dir
+      dir = @homedir.join("boxes")
+      dir.mkpath
+      dir
+    end
+  end
+end

data/test/unit/support/shared/base_context.rb

@@ -0,0 +1,104 @@
+require "tempfile"
+
+require "support/tempdir"
+require "unit/support/isolated_environment"
+
+shared_context "unit" do
+  before(:each) do
+    # State to store the list of registered plugins that we have to
+    # unregister later.
+    @_plugins = []
+
+    # Create a thing to store our temporary files so that they aren't
+    # unlinked right away.
+    @_temp_files = []
+  end
+
+  after(:each) do
+    # Unregister each of the plugins we have may have temporarily
+    # registered for the duration of this test.
+    @_plugins.each do |plugin|
+      Vagrant.plugin("1").manager.unregister(plugin)
+      Vagrant.plugin("2").manager.unregister(plugin)
+    end
+  end
+
+  # This creates an isolated environment so that Vagrant doesn't
+  # muck around with your real system during unit tests.
+  #
+  # The returned isolated environment has a variety of helper
+  # methods on it to easily create files, Vagrantfiles, boxes,
+  # etc.
+  def isolated_environment
+    env = Unit::IsolatedEnvironment.new
+    yield env if block_given?
+    env
+  end
+
+  # This registers a Vagrant plugin for the duration of a single test.
+  # This will yield a new plugin class that you can then call the
+  # public plugin methods on.
+  #
+  # @yield [plugin] Yields the plugin class for you to call the public
+  #   API that you need to.
+  def register_plugin(version=nil)
+    version ||= Vagrant::Config::CURRENT_VERSION
+    plugin = Class.new(Vagrant.plugin(version))
+    plugin.name("Test Plugin #{plugin.inspect}")
+    yield plugin if block_given?
+    @_plugins << plugin
+    plugin
+  end
+
+  # This helper creates a temporary file and returns a Pathname
+  # object pointed to it.
+  #
+  # @return [Pathname]
+  def temporary_file(contents=nil)
+    f = Tempfile.new("vagrant-unit")
+
+    if contents
+      f.write(contents)
+      f.flush
+    end
+
+    # Store the tempfile in an instance variable so that it is not
+    # garbage collected, so that the tempfile is not unlinked.
+    @_temp_files << f
+
+    return Pathname.new(f.path)
+  end
+
+  # This creates a temporary directory and returns a {Pathname}
+  # pointing to it.
+  #
+  # @return [Pathname]
+  def temporary_dir
+    # Create a temporary directory and append it to the instance
+    # variabe so that it isn't garbage collected and deleted
+    d = Tempdir.new("vagrant-unit")
+    @_temp_files << d
+
+    # Return the pathname
+    return Pathname.new(d.path)
+  end
+
+  # This helper provides temporary environmental variable changes.
+  def with_temp_env(environment)
+    # Build up the new environment, preserving the old values so we
+    # can replace them back in later.
+    old_env = {}
+    environment.each do |key, value|
+      old_env[key] = ENV[key]
+      ENV[key]     = value
+    end
+
+    # Call the block, returning its return value
+    return yield
+  ensure
+    # Reset the environment no matter what
+    old_env.each do |key, value|
+      ENV[key] = value
+    end
+  end
+end