boxcar 0.10005.1

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

@@ -0,0 +1,9 @@
+RSpec::Matchers.define :have_color do
+  match do |actual|
+    actual.index("\e[31m")
+  end
+
+  failure_message_for_should do |actual|
+    "expected output to contain color, but didn't"
+  end
+end

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

@@ -0,0 +1,14 @@
+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,
+# so all that state is hidden away in Acceptance::Output.
+RSpec::Matchers.define :match_output do |expected, *args|
+  match do |actual|
+    Acceptance::Output.new(actual).send(expected, *args)
+  end
+
+  failure_message_for_should do |actual|
+    "expected output to match: #{expected} #{args.inspect}"
+  end
+end

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

@@ -0,0 +1,95 @@
+module Acceptance
+  # This class helps with matching against output so that every
+  # test isn't inherently tied to the output format of Vagrant.
+  class Output
+    DEFAULT_VM = "default"
+
+    def initialize(text)
+      @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
+      @text =~ /^The box file you're attempting to add is invalid./
+    end
+
+    # Checks that an error message was outputted about the path
+    # not existing to the box.
+    def box_path_doesnt_exist
+      @text =~ /^The specified path to a file doesn't exist.$/
+    end
+
+    # Tests that the box with given name is installed.
+    def box_installed(name)
+      @text =~ /^#{name}$/
+    end
+
+    # Tests that the output says there are no installed boxes.
+    def no_boxes
+      @text =~ /There are no installed boxes!/
+    end
+
+    # 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 =~ /^A Vagrant environment is required/
+    end
+
+    # Tests that the output contains a specific Vagrant version.
+    def version(version)
+      @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)
+      @text =~ /^#{vm_name}\s+#{status}$/
+    end
+
+    # This checks that an error message that the VM must be created
+    # is shown.
+    def error_vm_must_be_created
+      @text =~ /^VM must be created/
+    end
+
+    # This checks that the warning that the VM is not created is emitted.
+    def vm_not_created_warning
+      @text =~ /VM not created. Moving on...$/
+    end
+
+    # This checks that the VM is destroyed.
+    def vm_destroyed
+      @text =~ /Destroying VM and associated drives...$/
+    end
+
+    # This checks that the "up" output properly contains text showing that
+    # it is downloading the box during the up process.
+    def up_fetching_box(name, vm=DEFAULT_VM)
+      @text =~ /^\[#{vm}\] Box #{name} was not found. Fetching box from specified URL...$/
+    end
+
+    # Check that the output shows that the VM was shut down gracefully
+    def vm_halt_graceful
+      @text =~ /Attempting graceful shutdown of/
+    end
+
+    # Output shows a forceful VM shutdown.
+    def vm_halt_force
+      @text =~ /Forcing shutdown of VM...$/
+    end
+
+    # Output shows the VM is in the process of suspending
+    def vm_suspending
+      @text =~ /Saving VM state and suspending execution...$/
+    end
+  end
+end

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

@@ -0,0 +1,72 @@
+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("test::acceptance::#{logger_name}") }
+
+  # This is the global configuration given by the acceptance test
+  # configurations.
+  let(:config) { $acceptance_options }
+
+  # Setup the environment so that we have an isolated area
+  # to run Vagrant. We do some configuration here as well in order
+  # 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) { new_environment }
+
+  before(:each) do
+    # Wait for VBoxSVC to disappear, since each test requires its
+    # own isolated VirtualBox process.
+    Acceptance::VirtualBox.wait_for_vboxsvc
+  end
+
+  after(:each) 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]
+  def execute(*args, &block)
+    environment.execute(*args, &block)
+  end
+
+  # This method is an assertion helper for asserting that a process
+  # succeeds. It is a wrapper around `execute` that asserts that the
+  # exit status was successful.
+  def assert_execute(*args, &block)
+    result = execute(*args, &block)
+    assert(result.exit_code == 0, "expected '#{args.join(" ")}' to succeed")
+    result
+  end
+
+  # This can be added to the beginning of a test to verify that the
+  # box with the given name is available to a test. This will raise
+  # an exception if the box is not found.
+  def require_box(name)
+    if !File.exist?(box_path(name))
+      raise ArgumentError, "The tests should have a '#{name}' box."
+    end
+  end
+
+  # This is used to get the path to a box of a specific name.
+  def box_path(name)
+    File.join(config.box_directory, "#{name}.box")
+  end
+end

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

@@ -0,0 +1,33 @@
+# This is a shared example that tests that a command requires a
+# Vagrant environment to run properly. The exact command to run
+# should be given as a parameter to the shared examples.
+shared_examples "a command that requires a Vagrantfile" do |*args|
+  let(:command) do
+    raise ArgumentError, "A command must be set for the shared example." if args.empty?
+    args[0]
+  end
+
+  it "fails if no Vagrantfile is found" do
+    result = execute(*command)
+    result.should_not succeed
+    result.stderr.should match_output(:no_vagrantfile)
+  end
+end
+
+# This is a shared example that tests that the command requires a
+# virtual machine to be created, and additionally to be in one of
+# many states.
+shared_examples "a command that requires a virtual machine" do |*args|
+  let(:command) do
+    raise ArgumentError, "A command must be set for the shared example." if args.empty?
+    args[0]
+  end
+
+  it "fails if the virtual machine is not created" do
+    assert_execute("vagrant", "init")
+
+    result = execute(*command)
+    result.should_not succeed
+    result.stderr.should match_output(:error_vm_must_be_created)
+  end
+end

data/test/acceptance/support/virtualbox.rb

@@ -0,0 +1,36 @@
+require 'sys/proctable'
+
+module Acceptance
+  module VirtualBox
+    extend self
+
+    # This method will wait for the "VBoxSVC" process to end. This will
+    # block during that time period. The reason for this is because only
+    # one "VBoxSVC" can run per user and manages all state within VirtualBox.
+    # Before you can run VirtualBox with a custom home directory, you must
+    # wait for this VBoxSVC process to die.
+    def wait_for_vboxsvc
+      time_passed = 0
+      while find_vboxsvc
+        if time_passed > 5
+          raise Exception, "VBoxSVC process is not going away."
+        end
+
+        sleep 1
+        time_passed += 1
+      end
+    end
+
+    # This method finds the VBoxSVC process and returns information about it.
+    # This will return "nil" if VBoxSVC is not found.
+    def find_vboxsvc
+      Sys::ProcTable.ps do |process|
+        if process.comm == "VBoxSVC"
+          return process
+        end
+      end
+
+      nil
+    end
+  end
+end

data/test/acceptance/suspend_test.rb

@@ -0,0 +1,56 @@
+require File.expand_path("../base", __FILE__)
+require "acceptance/support/shared/command_examples"
+
+describe "vagrant suspend" do
+  include_context "acceptance"
+  it_behaves_like "a command that requires a Vagrantfile", ["vagrant", "suspend"]
+
+  it "succeeds and ignores if the VM is not created" do
+    require_box("default")
+
+    assert_execute("vagrant", "box", "add", "base", box_path("default"))
+    assert_execute("vagrant", "init")
+
+    result = assert_execute("vagrant", "suspend")
+    result.stdout.should match_output(:vm_not_created_warning)
+  end
+
+  it "is able to suspend a running virtual machine" do
+    require_box("default")
+
+    assert_execute("vagrant", "box", "add", "base", box_path("default"))
+    assert_execute("vagrant", "init")
+    assert_execute("vagrant", "up")
+
+    # Suspend the VM and assert that it worked properly (seemingly)
+    result = assert_execute("vagrant", "suspend")
+    result.stdout.should match_output(:vm_suspending)
+
+    # Assert that the VM is no longer running
+    result = assert_execute("vagrant", "status")
+    result.stdout.should match_output(:status, "default", "saved")
+  end
+
+  # These tests are parameterized since both "vagrant resume" and
+  # "vagrant up" should achieve the same result.
+  ["resume", "up"].each do |command|
+    it "is able to resume after the machine has been suspended using #{command}" do
+      require_box("default")
+
+      assert_execute("vagrant", "box", "add", "base", box_path("default"))
+      assert_execute("vagrant", "init")
+      assert_execute("vagrant", "up")
+      assert_execute("vagrant", "suspend")
+
+      # Assert that the VM is no longer running
+      result = assert_execute("vagrant", "status")
+      result.stdout.should match_output(:status, "default", "saved")
+
+      assert_execute("vagrant", command)
+
+      # Assert that the VM is once again running
+      result = assert_execute("vagrant", "status")
+      result.stdout.should match_output(:status, "default", "running")
+    end
+  end
+end

data/test/acceptance/up_basic_test.rb

@@ -0,0 +1,33 @@
+require File.expand_path("../base", __FILE__)
+require "acceptance/support/shared/command_examples"
+
+describe "vagrant up", "basics" do
+  include_context "acceptance"
+  it_behaves_like "a command that requires a Vagrantfile", ["vagrant", "up"]
+
+  # This creates an initial environment that is ready for a "vagrant up"
+  def initialize_valid_environment
+    require_box("default")
+
+    assert_execute("vagrant", "box", "add", "base", box_path("default"))
+    assert_execute("vagrant", "init")
+  end
+
+  it "brings up a running virtual machine" do
+    initialize_valid_environment
+
+    assert_execute("vagrant", "up")
+    result = assert_execute("vagrant", "status")
+    result.stdout.should match_output(:status, "default", "running")
+  end
+
+  it "is able to run if Vagrantfile is in a parent directory" do
+    initialize_valid_environment
+
+    # Create a subdirectory in the working directory and use
+    # that as the CWD for `vagrant up` and verify it still works
+    foodir = environment.workdir.join("foo")
+    foodir.mkdir
+    assert_execute("vagrant", "up", :chdir => foodir.to_s)
+  end
+end

data/test/acceptance/up_with_box_url.rb

@@ -0,0 +1,40 @@
+require File.expand_path("../base", __FILE__)
+require "acceptance/support/shared/command_examples"
+
+describe "vagrant up", "with a box URL set" do
+  include_context "acceptance"
+
+  it "downloads and brings up the VM if the box doesn't exist" do
+    require_box("default")
+
+    assert_execute("vagrant", "init", "base", box_path("default"))
+    result = assert_execute("vagrant", "up")
+    result.stdout.should match_output(:up_fetching_box, "base")
+  end
+
+  it "downloads the file only once and works if shared by multiple VMs", :issue => "GH-564" do
+    require_box("default")
+
+    environment.workdir.join("Vagrantfile").open("w+") do |f|
+      f.puts(<<-VFILE)
+Vagrant::Config.run do |config|
+  config.vm.define :machine1 do |vm_config|
+    vm_config.vm.box = "base"
+    vm_config.vm.box_url = "#{box_path("default")}"
+  end
+
+  config.vm.define :machine2 do |vm_config|
+    vm_config.vm.box = "base"
+    vm_config.vm.box_url = "#{box_path("default")}"
+  end
+end
+VFILE
+    end
+
+    # Bring up the environment, which should work. `machine1` should download
+    # the box while `machine2` doesn't.
+    result = assert_execute("vagrant", "up")
+    result.stdout.should match_output(:up_fetching_box, "base", "machine1")
+    result.stdout.should_not match_output(:up_fetching_box, "base", "machine2")
+  end
+end

data/test/acceptance/vagrant_test.rb

@@ -0,0 +1,47 @@
+require File.expand_path("../base", __FILE__)
+require "acceptance/support/matchers/have_color"
+
+describe "vagrant and color output" do
+  include_context "acceptance"
+
+  # This is a check to see if the `expect` program is installed on this
+  # computer. Some tests require this and if this doesn't exist then the
+  # test itself will be skipped.
+  def self.has_expect?
+    `which expect`
+    $?.success?
+  end
+
+  it "outputs color if there is a TTY", :if => has_expect? do
+    environment.workdir.join("color.exp").open("w+") do |f|
+      f.puts(<<-SCRIPT)
+spawn #{environment.replace_command("vagrant")} status
+expect default {}
+SCRIPT
+    end
+
+    result = execute("expect", "color.exp")
+    result.stdout.should have_color
+  end
+
+  it "doesn't output color if there is a TTY but --no-color is present", :if => has_expect? do
+    environment.workdir.join("color.exp").open("w+") do |f|
+      f.puts(<<-SCRIPT)
+spawn #{environment.replace_command("vagrant")} status --no-color
+expect default {}
+SCRIPT
+    end
+
+    result = execute("expect", "color.exp")
+    result.stdout.should_not have_color
+  end
+
+  it "doesn't output color in the absense of a TTY" do
+    # This should always output an error, which on a TTY would
+    # output color. We check that this doesn't output color.
+    # If `vagrant status` itself is broken, another acceptance test
+    # should catch that. We just assume it works here.
+    result = execute("vagrant", "status")
+    result.stdout.should_not have_color
+  end
+end