vagrant 0.8.10 → 0.9.0

data/test/acceptance/provisioning/shell_test.rb

@@ -0,0 +1,53 @@
+require File.expand_path("../../base", __FILE__)
+
+describe "vagrant provisioning with shell" do
+  include_context "acceptance"
+
+  it "runs a script on boot" do
+    require_box("default")
+
+    assert_execute("vagrant", "box", "add", "base", box_path("default"))
+
+    environment.workdir.join("Vagrantfile").open("w+") do |f|
+      f.write(<<-vf)
+Vagrant::Config.run do |config|
+  config.vm.box = "base"
+  config.vm.provision :shell, :path => "script.sh"
+end
+vf
+    end
+
+    environment.workdir.join("script.sh").open("w+") do |f|
+      f.write(<<-vf)
+echo success > /vagrant/results
+vf
+    end
+
+    assert_execute("vagrant", "up")
+
+    result_file = environment.workdir.join("results")
+    result_file.exist?.should be
+    result_file.read.should == "success\n"
+  end
+
+  it "runs an inline script" do
+    require_box("default")
+
+    assert_execute("vagrant", "box", "add", "base", box_path("default"))
+
+    environment.workdir.join("Vagrantfile").open("w+") do |f|
+      f.write(<<-vf)
+Vagrant::Config.run do |config|
+  config.vm.box = "base"
+  config.vm.provision :shell, :inline => "echo success > /vagrant/results"
+end
+vf
+    end
+
+    assert_execute("vagrant", "up")
+
+    result_file = environment.workdir.join("results")
+    result_file.exist?.should be
+    result_file.read.should == "success\n"
+  end
+end

data/test/acceptance/resume_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 resume" do
   include_context "acceptance"

data/test/acceptance/skeletons/chef_solo_basic/README.md

@@ -0,0 +1,3 @@
+# Chef Solo Basic Skeleton
+
+This is a skeleton that contains a basic chef solo setup.

data/test/acceptance/skeletons/chef_solo_basic/cookbooks/basic/recipes/default.rb

@@ -0,0 +1,5 @@
+# Just create a file
+file "/tmp/chef_solo_basic" do
+  mode    0644
+  content "success"
+end

data/test/acceptance/skeletons/chef_solo_json/README.md

@@ -0,0 +1,3 @@
+# Chef Solo Basic Skeleton
+
+This is a skeleton that contains a basic chef solo setup.

data/test/acceptance/skeletons/chef_solo_json/cookbooks/basic/recipes/default.rb

@@ -0,0 +1,6 @@
+# Create a file where the contents is the data we set with
+# the Vagrantfile.
+file "/tmp/chef_solo_basic" do
+  mode    0644
+  content node[:test][:data]
+end

data/test/acceptance/skeletons/provisioner_multi/README.md

@@ -0,0 +1,3 @@
+# Chef Solo Basic Skeleton
+
+This is a skeleton that contains a basic chef solo setup.

data/test/acceptance/skeletons/provisioner_multi/cookbooks/basic/recipes/default.rb

@@ -0,0 +1,5 @@
+# Just create a file
+file "/vagrant/chef_solo" do
+  mode    0644
+  content "success"
+end

data/test/acceptance/ssh_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 ssh" do
   include_context "acceptance"
@@ -32,8 +32,13 @@ describe "vagrant ssh" do
     assert_execute("vagrant", "init")
     assert_execute("vagrant", "up")
 
-    result = assert_execute("vagrant", "ssh", "-c", "echo foo")
+    result = execute("vagrant", "ssh", "-c", "echo foo")
+    result.exit_code.should == 0
     result.stdout.should == "foo\n"
+
+    result = execute("vagrant", "ssh", "-c", "foooooooooo")
+    result.exit_code.should == 127
+    result.stderr.should =~ /foooooooooo: command not found/
   end
 
   # TODO:

data/test/acceptance/support/config.rb

@@ -11,7 +11,7 @@ module Acceptance
     attr_reader :box_directory
 
     def initialize(path)
-      @logger = Log4r::Logger.new("acceptance::config")
+      @logger = Log4r::Logger.new("test::acceptance::config")
       @logger.info("Loading configuration from: #{path}")
       options = YAML.load_file(path)
       @logger.info("Loaded: #{options.inspect}")

data/test/acceptance/support/isolated_environment.rb

@@ -4,142 +4,65 @@ require "pathname"
 require "log4r"
 require "childprocess"
 
-require File.expand_path("../tempdir", __FILE__)
-require File.expand_path("../virtualbox", __FILE__)
+require "vagrant/util/subprocess"
+
+require "acceptance/support/virtualbox"
+require "support/isolated_environment"
 
 module Acceptance
   # 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.
-  class IsolatedEnvironment
-    attr_reader :homedir
-    attr_reader :workdir
+  class IsolatedEnvironment < ::IsolatedEnvironment
+    SKELETON_DIR = Pathname.new(File.expand_path("../../skeletons", __FILE__))
 
-    # 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(apps=nil, env=nil)
-      @logger = Log4r::Logger.new("acceptance::isolated_environment")
-
-      @apps = apps || {}
-      @env  = env || {}
-
-      # Create a temporary directory for our work
-      @tempdir = Tempdir.new("vagrant")
-      @logger.info("Initialize isolated environment: #{@tempdir.path}")
+      super()
 
-      # Setup the home and working directories
-      @homedir = Pathname.new(File.join(@tempdir.path, "home"))
-      @workdir = Pathname.new(File.join(@tempdir.path, "work"))
+      @logger = Log4r::Logger.new("test::acceptance::isolated_environment")
 
-      @homedir.mkdir
-      @workdir.mkdir
+      @apps = apps.clone || {}
+      @env  = env.clone || {}
 
       # Set the home directory and virtualbox home directory environmental
       # variables so that Vagrant and VirtualBox see the proper paths here.
-      @env["HOME"] = @homedir.to_s
-      @env["VBOX_USER_HOME"] = @homedir.to_s
+      @env["HOME"] ||= @homedir.to_s
+      @env["VBOX_USER_HOME"] ||= @homedir.to_s
+    end
+
+    # Copies a skeleton into this isolated environment. This is useful
+    # for testing environments that require a complex setup.
+    #
+    # @param [String] name Name of the skeleton in the skeletons/ directory.
+    def skeleton!(name)
+      # Copy all the files into the home directory
+      source = Dir.glob(SKELETON_DIR.join(name).join("*").to_s)
+      FileUtils.cp_r(source, @workdir.to_s)
     end
 
     # Executes a command in the context of this isolated environment.
     # Any command executed will therefore see our temporary directory
     # as the home directory.
     def execute(command, *argN)
+      # Create the command
       command = replace_command(command)
 
-      # Get the hash options passed to this method
+      # Determine the options
       options = argN.last.is_a?(Hash) ? argN.pop : {}
-      timeout = options.delete(:timeout)
-
-      # Build a child process to run this command. For the stdout/stderr
-      # we use pipes so that we can select() on it and block and stream
-      # data in as it comes.
-      @logger.info("Executing: #{command} #{argN.inspect}. Output will stream in...")
-      process = ChildProcess.build(command, *argN)
-      stdout, stdout_writer = IO.pipe
-      process.io.stdout = stdout_writer
-
-      stderr, stderr_writer = IO.pipe
-      process.io.stderr = stderr_writer
-      process.duplex = true
-
-      @env.each do |k, v|
-        process.environment[k] = v
-      end
-
-      Dir.chdir(@workdir.to_s) do
-        process.start
-        process.io.stdin.sync = true
-      end
-
-      # Close our side of the pipes, since we're just reading
-      stdout_writer.close
-      stderr_writer.close
-
-      # Create a hash to store all the data we see.
-      io_data = { stdout => "", stderr => "" }
-
-      # Record the start time for timeout purposes
-      start_time = Time.now.to_i
-
-      @logger.debug("Selecting on IO...")
-      while true
-        results = IO.select([stdout, stderr],
-                            [process.io.stdin], nil, timeout || 5)
-
-        # Check if we have exceeded our timeout from waiting on a select()
-        raise TimeoutExceeded, process.pid if timeout && (Time.now.to_i - start_time) > timeout
-
-        # Check the readers first to see if they're ready
-        readers = results[0]
-        if !readers.empty?
-          begin
-            readers.each do |r|
-              data = r.read_nonblock(1024)
-              io_data[r] += data
-              io_name = r == stdout ? "stdout" : "stderr"
-              @logger.debug(data)
-              yield io_name.to_sym, data if block_given?
-            end
-          rescue IO::WaitReadable
-            # This just means the IO wasn't actually ready and we should
-            # wait some more. So we just let this pass through.
-          rescue EOFError
-            # Process exited, so break out of this while loop
-            break
-          end
-        end
-
-        # Check if the process exited in order to break the loop before
-        # we try to see if any stdin is ready.
-        break if process.exited?
-
-        # Check the writers to see if they're ready, and notify any listeners
-        if !results[1].empty?
-          yield :stdin, process.io.stdin if block_given?
-        end
+      options = {
+        :workdir => @workdir,
+        :env     => @env
+      }.merge(options)
+
+      # Add the options to be passed on
+      argN << options
+
+      # 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|
+        @logger.debug("#{type}: #{data}") if type == :stdout || type == :stderr
+        yield type, data if block_given?
       end
-
-      # Continually try to wait for the process to end, but do so asynchronously
-      # so that we can also check to see if we have exceeded a timeout.
-      begin
-        # If a timeout is not set, we set a very large timeout to
-        # simulate "forever"
-        @logger.debug("Waiting for process to exit...")
-        remaining = (timeout || 32000) - (Time.now.to_i - start_time)
-        remaining = 0 if remaining < 0
-        process.poll_for_exit(remaining)
-      rescue ChildProcess::TimeoutError
-        raise TimeoutExceeded, process.pid
-      end
-
-      @logger.debug("Exit status: #{process.exit_code}")
-      return ExecuteProcess.new(process.exit_code, io_data[stdout], io_data[stderr])
     end
 
     # Closes the environment, cleans up the temporary directories, etc.
@@ -149,9 +72,8 @@ module Acceptance
       # environment.
       delete_virtual_machines if VirtualBox.find_vboxsvc
 
-      # Delete the temporary directory
-      @logger.info("Removing isolated environment: #{@tempdir.path}")
-      FileUtils.rm_rf(@tempdir.path)
+      # Let the parent handle cleaning up
+      super
     end
 
     def delete_virtual_machines
@@ -167,7 +89,7 @@ module Acceptance
           # reason it will simply freeze, although the VM is successfully
           # "aborted." The timeout gets around this strange behavior.
           execute("VBoxManage", "controlvm", data[:uuid], "poweroff", :timeout => 5)
-        rescue TimeoutExceeded => e
+        rescue Vagrant::Util::Subprocess::TimeoutExceeded => e
           @logger.info("Failed to poweroff VM '#{data[:uuid]}'. Killing process.")
 
           # Kill the process and wait a bit for it to disappear
@@ -178,7 +100,7 @@ module Acceptance
         sleep 0.5
 
         result = execute("VBoxManage", "unregistervm", data[:uuid], "--delete")
-        raise Exception, "VM unregistration failed!" if result.exit_status != 0
+        raise Exception, "VM unregistration failed!" if result.exit_code != 0
       end
 
       @logger.info("Removed all virtual machines")
@@ -192,35 +114,4 @@ module Acceptance
       return command
     end
   end
-
-  # This class represents a process which has run via the IsolatedEnvironment.
-  # This is a readonly structure that can be used to inspect the exit status,
-  # stdout, stderr, etc. from the process which ran.
-  class ExecuteProcess
-    attr_reader :exit_status
-    attr_reader :stdout
-    attr_reader :stderr
-
-    def initialize(exit_status, stdout, stderr)
-      @exit_status = exit_status
-      @stdout      = stdout
-      @stderr      = stderr
-    end
-
-    def success?
-      @exit_status == 0
-    end
-  end
-
-  # This exception is raised if the timeout for a process is exceeded.
-  class TimeoutExceeded < StandardError
-    attr_reader :pid
-
-    def initialize(pid)
-      @pid = pid
-
-      super()
-    end
-  end
 end
-

data/test/acceptance/support/matchers/match_output.rb

@@ -1,4 +1,4 @@
-require "support/output"
+require "acceptance/support/output"
 
 # This creates a matcher that is used to match against certain
 # Vagrant output. Vagrant output is not what is being tested,

data/test/acceptance/support/matchers/succeed.rb

@@ -0,0 +1,14 @@
+# Matcher that verifies that a process succeeds.
+RSpec::Matchers.define :succeed do
+  match do |thing|
+    thing.exit_code.should == 0
+  end
+
+  failure_message_for_should do |actual|
+    "expected process to succeed. exit code: #{actual.exit_code}"
+  end
+
+  failure_message_for_should_not do |actual|
+    "expected process to fail. exit code: #{actual.exit_code}"
+  end
+end

data/test/acceptance/support/network_tests.rb

@@ -0,0 +1,29 @@
+require "vagrant/util/retryable"
+
+module Acceptance
+  module NetworkTests
+    include Vagrant::Util::Retryable
+
+    # Tests that the host can access the VM through the network.
+    #
+    # @param [String] url URL to request from the host.
+    # @param [Integer] guest_port Port to run a web server on the guest.
+    def assert_host_to_vm_network(url, guest_port)
+      # Start up a web server in another thread by SSHing into the VM.
+      thr = Thread.new do
+        assert_execute("vagrant", "ssh", "-c", "python -m SimpleHTTPServer #{guest_port}")
+      end
+
+      # Verify that port forwarding works by making a simple HTTP request
+      # to the port. We should get a 200 response. We retry this a few times
+      # as we wait for the HTTP server to come online.
+      retryable(:tries => 5, :sleep => 2) do
+        result = Net::HTTP.get_response(URI.parse(url))
+        result.code.should == "200"
+      end
+    ensure
+      # The server needs to die. This is how.
+      thr.kill if thr
+    end
+  end
+end

data/test/acceptance/support/output.rb

@@ -8,6 +8,10 @@ module Acceptance
       @text = text
     end
 
+    def box_already_exists(name)
+      @text =~ /^A box already exists under the name of '#{name}'/
+    end
+
     # Checks that an error message was outputted about the box
     # being added being invalid.
     def box_invalid
@@ -33,7 +37,7 @@ module Acceptance
     # Tests that the output says there is no Vagrantfile, and as such
     # can't do whatever we requested Vagrant to do.
     def no_vagrantfile
-      @text =~ /^No Vagrant environment detected/
+      @text =~ /^A Vagrant environment is required/
     end
 
     # Tests that the output contains a specific Vagrant version.
@@ -41,6 +45,10 @@ module Acceptance
       @text =~ /^Vagrant version #{version}$/
     end
 
+    def resume_port_collision
+      @text =~ /^This VM cannot be resumed, because the forwarded ports/
+    end
+
     # This checks that the VM with the given `vm_name` has the
     # status of `status`.
     def status(vm_name, status)