vagrant 0.8.10 → 0.9.0

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

@@ -1,13 +1,13 @@
-require "support/isolated_environment"
-require "support/output"
-require "support/virtualbox"
+require "acceptance/support/isolated_environment"
+require "acceptance/support/output"
+require "acceptance/support/virtualbox"
 
 shared_context "acceptance" do
   # Setup variables for the loggers of this test. These can be used to
   # create more verbose logs for tests which can be useful in the case
   # that a test fails.
   let(:logger_name) { "logger" }
-  let(:logger) { Log4r::Logger.new("acceptance::#{logger_name}") }
+  let(:logger) { Log4r::Logger.new("test::acceptance::#{logger_name}") }
 
   # This is the global configuration given by the acceptance test
   # configurations.
@@ -18,10 +18,7 @@ shared_context "acceptance" do
   # to replace "vagrant" with the proper path to Vagrant as well
   # as tell the isolated environment about custom environmental
   # variables to pass in.
-  let!(:environment) do
-    apps = { "vagrant" => config.vagrant_path }
-    Acceptance::IsolatedEnvironment.new(apps, config.env)
-  end
+  let!(:environment) { new_environment }
 
   before(:each) do
     # Wait for VBoxSVC to disappear, since each test requires its
@@ -33,6 +30,16 @@ shared_context "acceptance" do
     environment.close
   end
 
+  # Creates a new isolated environment instance each time it is called.
+  #
+  # @return [Acceptance::IsolatedEnvironment]
+  def new_environment(env=nil)
+    apps = { "vagrant" => config.vagrant_path }
+    env  = config.env.merge(env || {})
+
+    Acceptance::IsolatedEnvironment.new(apps, env)
+  end
+
   # Executes the given command in the context of the isolated environment.
   #
   # @return [Object]
@@ -45,7 +52,7 @@ shared_context "acceptance" do
   # exit status was successful.
   def assert_execute(*args, &block)
     result = execute(*args, &block)
-    assert(result.success?, "expected '#{args.join(" ")}' to succeed")
+    assert(result.exit_code == 0, "expected '#{args.join(" ")}' to succeed")
     result
   end
 

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

@@ -9,8 +9,8 @@ shared_examples "a command that requires a Vagrantfile" do |*args|
 
   it "fails if no Vagrantfile is found" do
     result = execute(*command)
-    result.should_not be_success
-    result.stdout.should match_output(:no_vagrantfile)
+    result.should_not succeed
+    result.stderr.should match_output(:no_vagrantfile)
   end
 end
 
@@ -27,7 +27,7 @@ shared_examples "a command that requires a virtual machine" do |*args|
     assert_execute("vagrant", "init")
 
     result = execute(*command)
-    result.should_not be_success
-    result.stdout.should match_output(:error_vm_must_be_created)
+    result.should_not succeed
+    result.stderr.should match_output(:error_vm_must_be_created)
   end
 end

data/test/acceptance/suspend_test.rb

@@ -1,5 +1,5 @@
 require File.expand_path("../base", __FILE__)
-require "support/shared/command_examples"
+require "acceptance/support/shared/command_examples"
 
 describe "vagrant suspend" do
   include_context "acceptance"

data/test/acceptance/up_basic_test.rb

@@ -1,5 +1,5 @@
 require File.expand_path("../base", __FILE__)
-require "support/shared/command_examples"
+require "acceptance/support/shared/command_examples"
 
 describe "vagrant up", "basics" do
   include_context "acceptance"
@@ -46,13 +46,32 @@ describe "vagrant up", "basics" do
     foofile.exist?.should be, "'foo' should exist since it was touched in the shared folder"
   end
 
-=begin
+  it "should create a shared folder if the :create flag is set" do
+    initialize_valid_environment
+
+    # Setup the custom Vagrantfile
+    environment.workdir.join("Vagrantfile").open("w+") do |f|
+      f.write(<<-VF)
+Vagrant::Config.run do |config|
+  config.vm.box = "base"
+  config.vm.share_folder "v-root", "/vagrant", "./data", :create => true
+end
+VF
+    end
+
+    data_dir = environment.workdir.join("data")
 
-TODO:
+    # Verify the directory doesn't exist prior, for sanity
+    data_dir.exist?.should_not be
 
-  should "destroy a running virtual machine"
-  should "save then restore a virtual machine using `vagrant up`"
-  should "halt then start a virtual machine using `vagrant up`"
+    # Bring up the VM
+    assert_execute("vagrant", "up")
+
+    # Verify the directory exists
+    data_dir.should be_directory
 
-=end
+    # Touch a file and verify it is shared
+    assert_execute("vagrant", "ssh", "-c", "touch /vagrant/foo")
+    data_dir.join("foo").exist?.should be
+  end
 end

data/test/acceptance/up_with_box_url.rb

@@ -1,5 +1,5 @@
 require File.expand_path("../base", __FILE__)
-require "support/shared/command_examples"
+require "acceptance/support/shared/command_examples"
 
 describe "vagrant up", "with a box URL set" do
   include_context "acceptance"

data/test/acceptance/vagrant_test.rb

@@ -1,5 +1,5 @@
 require File.expand_path("../base", __FILE__)
-require "support/matchers/have_color"
+require "acceptance/support/matchers/have_color"
 
 describe "vagrant and color output" do
   include_context "acceptance"

data/test/acceptance/version_test.rb

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

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/unit/base.rb

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

data/test/unit/support/isolated_environment.rb

@@ -0,0 +1,39 @@
+require "fileutils"
+require "pathname"
+
+require "log4r"
+
+require "support/isolated_environment"
+
+module Unit
+  class IsolatedEnvironment < ::IsolatedEnvironment
+    def create_vagrant_env(options=nil)
+      options = {
+        :cwd => @workdir,
+        :home_path => @homedir
+      }.merge(options || {})
+
+      Vagrant::Environment.new(options)
+    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="")
+      box_dir = boxes_dir.join(name)
+      box_dir.mkpath
+      vagrantfile(vagrantfile_contents, box_dir)
+      box_dir
+    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,30 @@
+require "tempfile"
+
+require "unit/support/isolated_environment"
+
+shared_context "unit" do
+  # 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 helper creates a temporary file and returns a Pathname
+  # object pointed to it.
+  def temporary_file(contents=nil)
+    f = Tempfile.new("vagrant-unit")
+
+    if contents
+      f.write(contents)
+      f.flush
+    end
+
+    return Pathname.new(f.path)
+  end
+end

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

@@ -1,207 +1,156 @@
-require "test_helper"
-require "logger"
+require File.expand_path("../../../base", __FILE__)
 
-class ActionBuilderTest < Test::Unit::TestCase
-  setup do
-    @klass = Vagrant::Action::Builder
+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.
+  def appender_proc(data)
+    Proc.new { |env| env[:data] << data }
   end
 
-  context "initializing" do
-    should "setup empty middleware stack" do
-      builder = @klass.new
-      assert builder.stack.empty?
+  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)
+
+      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 }
+
+      instance.use proc1
+      instance.use proc2
+      instance.call(data)
+
+      data[:one].should == true
+      data[:two].should == true
     end
 
-    should "take block to setup stack" do
-      builder = @klass.new do
-        use Hash
-        use lambda { |i| i }
-      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
+
+    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)
 
-      assert !builder.stack.empty?
-      assert_equal 2, builder.stack.length
+      data[:data].should == 6
     end
   end
 
-  context "with an instance" do
-    setup do
-      @instance = @klass.new
+  context "inserting" do
+    it "can insert at an index" do
+      instance.use appender_proc(1)
+      instance.insert(0, appender_proc(2))
+      instance.call(data)
+
+      data[:data].should == [2, 1]
     end
 
-    context "adding to the stack" do
-      should "return self" do
-        assert @instance.equal?(@instance.use(1))
-      end
-
-      should "add to the end" do
-        @instance.use 1
-        @instance.use 2
-        assert_equal [2, [], nil], @instance.stack.last
-      end
-
-      should "merge in other builder's stack" do
-        other = @klass.new do
-          use 2
-          use 3
-        end
-
-        @instance.use 1
-        @instance.use other
-        assert_equal 3, @instance.stack.length
-      end
-
-      should "prepend a set environment task for merging middlewares if given" do
-        other = @klass.new do
-          use 1
-        end
-
-        @instance.use 0
-        @instance.use(other, :foo => :bar)
-        assert_equal 3, @instance.stack.length
-        assert_equal Vagrant::Action::Env::Set, @instance.stack[1].first
-      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)
+
+      data[:data].should == [1, 3, 2]
     end
 
-    context "flatten" do
-      should "return the flattened format of the builder" do
-        env = Vagrant::Action::Environment.new(nil)
-        env["logger"] = Logger.new(nil)
-        env.expects(:foo).once
-
-        func = lambda { |x| x.foo }
-        @instance.use func
-        proc = @instance.flatten
-        assert proc.respond_to?(:call)
-        proc.call(env)
-      end
+    it "can insert before" do
+      instance.use appender_proc(1)
+      instance.insert_before 0, appender_proc(2)
+      instance.call(data)
+
+      data[:data].should == [2, 1]
     end
 
-    context "inserting" do
-      setup do
-        @instance.use "1"
-        @instance.use "2"
-      end
-
-      should "insert at the proper numeric index" do
-        @instance.insert(1, "3")
-        assert_equal "3", @instance.stack[1].first
-      end
-
-      should "insert next to the proper object if given" do
-        @instance.insert("2", "3")
-        assert_equal "3", @instance.stack[1].first
-      end
-
-      should "be able to call insert_before as well" do
-        @instance.insert_before("1", "0")
-        assert_equal "0", @instance.stack.first.first
-      end
-
-      should "be able to insert_after" do
-        @instance.insert_after("1", "0")
-        assert_equal "0", @instance.stack[1].first
-      end
-
-      should "be able to insert_after using numeric index" do
-        @instance.insert_after(1, "0")
-        assert_equal "0", @instance.stack[2].first
-      end
-
-      should "raise an exception if invalid index" do
-        assert_raises(RuntimeError) {
-          @instance.insert_after("15", "0")
-        }
-      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)
+
+      data[:data].should == [1, 2, 3]
     end
 
-    context "swapping" do
-      setup do
-        @instance.use "1"
-        @instance.use "2"
-      end
-
-      should "be able to swap using the object" do
-        @instance.swap "1", "3"
-        assert_equal "3", @instance.stack.first.first
-      end
-
-      should "be able to swap using the index" do
-        @instance.swap 0, "3"
-        assert_equal "3", @instance.stack.first.first
-      end
+    it "raises an exception if an invalid object given" do
+      expect { instance.insert_after "object", appender_proc(1) }.
+        to raise_error(RuntimeError)
     end
+  end
 
-    context "deleting" do
-      setup do
-        @instance.use "1"
-      end
+  context "replace" do
+    it "can replace an object" do
+      proc1 = appender_proc(1)
+      proc2 = appender_proc(2)
 
-      should "delete the proper object" do
-        @instance.delete("1")
-        assert @instance.stack.empty?
-      end
+      instance.use proc1
+      instance.replace proc1, proc2
+      instance.call(data)
 
-      should "delete by index if given" do
-        @instance.delete(0)
-        assert @instance.stack.empty?
-      end
+      data[:data].should == [2]
     end
 
-    context "getting an index of an object" do
-      should "return the proper index if it exists" do
-        @instance.use 1
-        @instance.use 2
-        @instance.use 3
-        assert_equal 1, @instance.index(2)
-      end
+    it "can replace by index" do
+      proc1 = appender_proc(1)
+      proc2 = appender_proc(2)
+
+      instance.use proc1
+      instance.replace 0, proc2
+      instance.call(data)
+
+      data[:data].should == [2]
     end
+  end
+
+  context "deleting" do
+    it "can delete by object" do
+      proc1 = appender_proc(1)
 
-    context "converting to an app" do
-      should "make non-classes lambdas" do
-        env = Vagrant::Action::Environment.new(nil)
-        env["logger"] = Logger.new(nil)
-        env.expects(:foo).once
-
-        func = lambda { |x| x.foo }
-        @instance.use func
-        @instance.to_app(env).call(env)
-      end
-
-      should "raise exception if given invalid middleware" do
-        @instance.use 7
-        assert_raises(RuntimeError) {
-          @instance.to_app(nil)
-        }
-      end
+      instance.use proc1
+      instance.use appender_proc(2)
+      instance.delete proc1
+      instance.call(data)
+
+      data[:data].should == [2]
     end
 
-    context "calling" do
-      def mock_middleware
-        middleware = Class.new do
-          def initialize(app, env)
-            @app = app
-          end
-
-          def call(env)
-            @app.call(env)
-          end
-        end
-      end
-
-      should "convert to an app then call with the env" do
-        mw = mock_middleware
-        mw.any_instance.expects(:call).with() do |env|
-          assert env.has_key?(:key)
-          true
-        end
-
-        env = Vagrant::Action::Environment.new(nil)
-        env["logger"] = Logger.new(nil)
-        env[:key] = :value
-
-        @instance.use(mw)
-        @instance.call(env)
-      end
+    it "can delete by index" do
+      proc1 = appender_proc(1)
+
+      instance.use proc1
+      instance.use appender_proc(2)
+      instance.delete 0
+      instance.call(data)
+
+      data[:data].should == [2]
     end
   end
 end