tnargav 1.3.5 → 1.3.6

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

data/test/unit/vagrant/action/builder_test.rb

@@ -0,0 +1,242 @@
+require File.expand_path("../../../base", __FILE__)
+
+describe Vagrant::Action::Builder do
+  let(:data) { { :data => [] } }
+
+  # This returns a proc that can be used with the builder
+  # that simply appends data to an array in the env.
+  def appender_proc(data)
+    result = Proc.new { |env| env[:data] << data }
+
+    # Define a to_s on it for helpful output
+    result.define_singleton_method(:to_s) do
+      "<Appender: #{data}>"
+    end
+
+    result
+  end
+
+  context "copying" do
+    it "should copy the stack" do
+      copy = subject.dup
+      copy.stack.object_id.should_not == subject.stack.object_id
+    end
+  end
+
+  context "build" do
+    it "should provide build as a shortcut for basic sequences" do
+      data = {}
+      proc = Proc.new { |env| env[:data] = true }
+
+      subject = described_class.build(proc)
+      subject.call(data)
+
+      data[:data].should == true
+    end
+  end
+
+  context "basic `use`" do
+    it "should add items to the stack and make them callable" do
+      data = {}
+      proc = Proc.new { |env| env[:data] = true }
+
+      subject.use proc
+      subject.call(data)
+
+      data[:data].should == true
+    end
+
+    it "should be able to add multiple items" do
+      data = {}
+      proc1 = Proc.new { |env| env[:one] = true }
+      proc2 = Proc.new { |env| env[:two] = true }
+
+      subject.use proc1
+      subject.use proc2
+      subject.call(data)
+
+      data[:one].should == true
+      data[:two].should == true
+    end
+
+    it "should be able to add another builder" do
+      data  = {}
+      proc1 = Proc.new { |env| env[:one] = true }
+
+      # Build the first builder
+      one   = described_class.new
+      one.use proc1
+
+      # Add it to this builder
+      two   = described_class.new
+      two.use one
+
+      # Call the 2nd and verify results
+      two.call(data)
+      data[:one].should == true
+    end
+  end
+
+  context "inserting" do
+    it "can insert at an index" do
+      subject.use appender_proc(1)
+      subject.insert(0, appender_proc(2))
+      subject.call(data)
+
+      data[:data].should == [2, 1]
+    end
+
+    it "can insert by name" do
+      # Create the proc then make sure it has a name
+      bar_proc = appender_proc(2)
+      def bar_proc.name; :bar; end
+
+      subject.use appender_proc(1)
+      subject.use bar_proc
+      subject.insert_before :bar, appender_proc(3)
+      subject.call(data)
+
+      data[:data].should == [1, 3, 2]
+    end
+
+    it "can insert next to a previous object" do
+      proc2 = appender_proc(2)
+      subject.use appender_proc(1)
+      subject.use proc2
+      subject.insert(proc2, appender_proc(3))
+      subject.call(data)
+
+      data[:data].should == [1, 3, 2]
+    end
+
+    it "can insert before" do
+      subject.use appender_proc(1)
+      subject.insert_before 0, appender_proc(2)
+      subject.call(data)
+
+      data[:data].should == [2, 1]
+    end
+
+    it "can insert after" do
+      subject.use appender_proc(1)
+      subject.use appender_proc(3)
+      subject.insert_after 0, appender_proc(2)
+      subject.call(data)
+
+      data[:data].should == [1, 2, 3]
+    end
+
+    it "merges middleware stacks of other builders" do
+      wrapper_class = Proc.new do |letter|
+        Class.new do
+          def initialize(app, env)
+            @app = app
+          end
+
+          define_method(:call) do |env|
+            env[:data] << "#{letter}1"
+            @app.call(env)
+            env[:data] << "#{letter}2"
+          end
+        end
+      end
+
+      proc2 = appender_proc(2)
+      subject.use appender_proc(1)
+      subject.use proc2
+
+      builder = described_class.new
+      builder.use wrapper_class.call("A")
+      builder.use wrapper_class.call("B")
+
+      subject.insert(proc2, builder)
+      subject.call(data)
+
+      data[:data].should == [1, "A1", "B1", 2, "B2", "A2"]
+    end
+
+    it "raises an exception if an invalid object given for insert" do
+      expect { subject.insert "object", appender_proc(1) }.
+        to raise_error(RuntimeError)
+    end
+
+    it "raises an exception if an invalid object given for insert_after" do
+      expect { subject.insert_after "object", appender_proc(1) }.
+        to raise_error(RuntimeError)
+    end
+  end
+
+  context "replace" do
+    it "can replace an object" do
+      proc1 = appender_proc(1)
+      proc2 = appender_proc(2)
+
+      subject.use proc1
+      subject.replace proc1, proc2
+      subject.call(data)
+
+      data[:data].should == [2]
+    end
+
+    it "can replace by index" do
+      proc1 = appender_proc(1)
+      proc2 = appender_proc(2)
+
+      subject.use proc1
+      subject.replace 0, proc2
+      subject.call(data)
+
+      data[:data].should == [2]
+    end
+  end
+
+  context "deleting" do
+    it "can delete by object" do
+      proc1 = appender_proc(1)
+
+      subject.use proc1
+      subject.use appender_proc(2)
+      subject.delete proc1
+      subject.call(data)
+
+      data[:data].should == [2]
+    end
+
+    it "can delete by index" do
+      proc1 = appender_proc(1)
+
+      subject.use proc1
+      subject.use appender_proc(2)
+      subject.delete 0
+      subject.call(data)
+
+      data[:data].should == [2]
+    end
+  end
+
+  describe "action hooks" do
+    it "applies them properly" do
+      hook = double("hook")
+      hook.stub(:apply) do |builder|
+        builder.use appender_proc(2)
+      end
+
+      data[:action_hooks] = [hook]
+
+      subject.use appender_proc(1)
+      subject.call(data)
+
+      data[:data].should == [1, 2]
+      data[:action_hooks_already_ran].should == true
+    end
+
+    it "applies without prepend/append if it has already" do
+      hook = double("hook")
+      hook.should_receive(:apply).with(anything, { :no_prepend_or_append => true }).once
+
+      data[:action_hooks] = [hook]
+      data[:action_hooks_already_ran] = true
+      subject.call(data)
+    end
+  end
+end