vagrantup 1.0.7 → 1.1.0

data/templates/rgloader.rb

@@ -0,0 +1,9 @@
+# This file loads the proper rgloader/loader.rb file that comes packaged
+# with Vagrant so that encoded files can properly run with Vagrant.
+
+if ENV["VAGRANT_INSTALLER_EMBEDDED_DIR"]
+  require File.expand_path(
+    "rgloader/loader", ENV["VAGRANT_INSTALLER_EMBEDDED_DIR"])
+else
+  raise "Encoded files can't be read outside of the Vagrant installer."
+end

data/test/acceptance/support/isolated_environment.rb

@@ -51,7 +51,8 @@ module Acceptance
       options = argN.last.is_a?(Hash) ? argN.pop : {}
       options = {
         :workdir => @workdir,
-        :env     => @env
+        :env     => @env,
+        :notify  => [:stdin, :stderr, :stdout]
       }.merge(options)
 
       # Add the options to be passed on
@@ -59,7 +60,7 @@ module Acceptance
 
       # Execute, logging out the stdout/stderr as we get it
       @logger.info("Executing: #{[command].concat(argN).inspect}")
-      Vagrant::Util::Subprocess.execute(command, *argN) do |type, data|
+      Vagrant::Util::Subprocess.execute(command *argN) do |type, data|
         @logger.debug("#{type}: #{data}") if type == :stdout || type == :stderr
         yield type, data if block_given?
       end

data/test/support/tempdir.rb

@@ -3,9 +3,6 @@ require 'tempfile'
 
 # This class provides an easy way of creating a temporary
 # directory and having it removed when the application exits.
-#
-# TODO: This class doesn't currently delete the temporary
-# directory on exit.
 class Tempdir
   attr_reader :path
 
@@ -25,10 +22,22 @@ class Tempdir
         @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
-    FileUtils.rm_rf(@path)
+    # 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

@@ -9,6 +9,8 @@ require "vagrant"
 $:.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
@@ -19,3 +21,7 @@ $stderr.sync = true
 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

@@ -1,9 +1,15 @@
 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
@@ -32,12 +38,138 @@ module Unit
     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

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

@@ -1,8 +1,28 @@
 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.
   #
@@ -15,8 +35,25 @@ shared_context "unit" do
     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")
 
@@ -25,6 +62,43 @@ shared_context "unit" do
       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

@@ -2,7 +2,6 @@ require File.expand_path("../../../base", __FILE__)
 
 describe Vagrant::Action::Builder do
   let(:data) { { :data => [] } }
-  let(:instance) { described_class.new }
 
   # This returns a proc that can be used with the builder
   # that simply appends data to an array in the env.
@@ -10,13 +9,32 @@ describe Vagrant::Action::Builder do
     Proc.new { |env| env[:data] << data }
   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 }
 
-      instance.use proc
-      instance.call(data)
+      subject.use proc
+      subject.call(data)
 
       data[:data].should == true
     end
@@ -26,9 +44,9 @@ describe Vagrant::Action::Builder do
       proc1 = Proc.new { |env| env[:one] = true }
       proc2 = Proc.new { |env| env[:two] = true }
 
-      instance.use proc1
-      instance.use proc2
-      instance.call(data)
+      subject.use proc1
+      subject.use proc2
+      subject.call(data)
 
       data[:one].should == true
       data[:two].should == true
@@ -50,58 +68,64 @@ describe Vagrant::Action::Builder do
       two.call(data)
       data[:one].should == true
     end
-
-    it "should be able to set additional variables when using" do
-      data  = { }
-      proc1 = Proc.new { |env| env[:data] += 1 }
-
-      # Build the first builder
-      one   = described_class.new
-      one.use proc1, :data => 5
-      one.call(data)
-
-      data[:data].should == 6
-    end
   end
 
   context "inserting" do
     it "can insert at an index" do
-      instance.use appender_proc(1)
-      instance.insert(0, appender_proc(2))
-      instance.call(data)
+      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)
-      instance.use appender_proc(1)
-      instance.use proc2
-      instance.insert(proc2, appender_proc(3))
-      instance.call(data)
+      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
-      instance.use appender_proc(1)
-      instance.insert_before 0, appender_proc(2)
-      instance.call(data)
+      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
-      instance.use appender_proc(1)
-      instance.use appender_proc(3)
-      instance.insert_after 0, appender_proc(2)
-      instance.call(data)
+      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 "raises an exception if an invalid object given" do
-      expect { instance.insert_after "object", appender_proc(1) }.
+    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
@@ -111,9 +135,9 @@ describe Vagrant::Action::Builder do
       proc1 = appender_proc(1)
       proc2 = appender_proc(2)
 
-      instance.use proc1
-      instance.replace proc1, proc2
-      instance.call(data)
+      subject.use proc1
+      subject.replace proc1, proc2
+      subject.call(data)
 
       data[:data].should == [2]
     end
@@ -122,9 +146,9 @@ describe Vagrant::Action::Builder do
       proc1 = appender_proc(1)
       proc2 = appender_proc(2)
 
-      instance.use proc1
-      instance.replace 0, proc2
-      instance.call(data)
+      subject.use proc1
+      subject.replace 0, proc2
+      subject.call(data)
 
       data[:data].should == [2]
     end
@@ -134,10 +158,10 @@ describe Vagrant::Action::Builder do
     it "can delete by object" do
       proc1 = appender_proc(1)
 
-      instance.use proc1
-      instance.use appender_proc(2)
-      instance.delete proc1
-      instance.call(data)
+      subject.use proc1
+      subject.use appender_proc(2)
+      subject.delete proc1
+      subject.call(data)
 
       data[:data].should == [2]
     end
@@ -145,12 +169,28 @@ describe Vagrant::Action::Builder do
     it "can delete by index" do
       proc1 = appender_proc(1)
 
-      instance.use proc1
-      instance.use appender_proc(2)
-      instance.delete 0
-      instance.call(data)
+      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]
+    end
+  end
 end