vagrantup 0.8.10 → 0.9.0

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)

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