boxcar 0.10005.1

data/test/acceptance/package_test.rb

@@ -0,0 +1,46 @@
+require File.expand_path("../base", __FILE__)
+require "acceptance/support/shared/command_examples"
+
+describe "vagrant package" do
+  include_context "acceptance"
+
+  # 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 "can package a running virtual machine" do
+    initialize_valid_environment
+
+    assert_execute("vagrant", "up")
+    assert_execute("vagrant", "package")
+    environment.workdir.join("package.box").should be_file
+  end
+
+  it "can package a `base` VM directly from VirtualBox" do
+    initialize_valid_environment
+
+    # Use a custom Vagrantfile that sets the VM name to `foo`
+    environment.workdir.join("Vagrantfile").open("w+") do |f|
+      f.write(<<-vf)
+Vagrant::Config.run do |config|
+  config.vm.box = "base"
+  config.vm.customize ["modifyvm", :id, "--name", "foo"]
+end
+vf
+    end
+
+    # Bring up the VM
+    assert_execute("vagrant", "up")
+
+    # Remove the Vagrantfile so it doesn't use that
+    environment.workdir.join("Vagrantfile").unlink
+
+    # Now package the base VM
+    assert_execute("vagrant", "package", "--base", "foo")
+    environment.workdir.join("package.box").should be_file
+  end
+end

data/test/acceptance/provisioning/basic_test.rb

@@ -0,0 +1,61 @@
+require File.expand_path("../../base", __FILE__)
+
+describe "vagrant provisioning basics" do
+  include_context "acceptance"
+
+  it "doesn't provision with `--no-provision` set" 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
+
+    # Bring the VM up without enabling provisioning
+    assert_execute("vagrant", "up", "--no-provision")
+
+    # Verify the file that the script creates does NOT exist
+    result_file = environment.workdir.join("results")
+    result_file.exist?.should_not be
+  end
+
+  it "can provision with multiple provisioners" do
+    # Skeleton for multiple provisioners
+    environment.skeleton!("provisioner_multi")
+
+    # Setup the basic environment
+    require_box("default")
+    assert_execute("vagrant", "box", "add", "base", box_path("default"))
+
+    # Bring up the VM
+    assert_execute("vagrant", "up")
+
+    # Verify the file the shell provisioner made is there, but not the
+    # Chef one.
+    environment.workdir.join("shell").exist?.should be
+    environment.workdir.join("chef_solo").exist?.should be
+  end
+
+  it "only uses the provisioners specified with `--provision-with`" do
+    # Skeleton for multiple provisioners
+    environment.skeleton!("provisioner_multi")
+
+    # Setup the basic environment
+    require_box("default")
+    assert_execute("vagrant", "box", "add", "base", box_path("default"))
+
+    # Bring up the VM, only using the shell provisioner
+    assert_execute("vagrant", "up", "--provision-with", "shell")
+
+    # Verify the file the shell provisioner made is there, but not the
+    # Chef one.
+    environment.workdir.join("shell").exist?.should be
+    environment.workdir.join("chef_solo").exist?.should_not be
+  end
+end

data/test/acceptance/provisioning/chef_solo_test.rb

@@ -0,0 +1,37 @@
+require File.expand_path("../../base", __FILE__)
+
+describe "vagrant provisioning with chef solo" do
+  include_context "acceptance"
+
+  it "runs basic cookbooks" do
+    # Create the chef solo basic skeleton
+    environment.skeleton!("chef_solo_basic")
+
+    # Setup the basic environment
+    require_box("default")
+    assert_execute("vagrant", "box", "add", "base", box_path("default"))
+
+    # Bring up the VM
+    assert_execute("vagrant", "up")
+
+    # Check for the file it should have created
+    results = assert_execute("vagrant", "ssh", "-c", "cat /tmp/chef_solo_basic")
+    results.stdout.should == "success"
+  end
+
+  it "merges JSON into the attributes" do
+    # Copy the skeleton
+    environment.skeleton!("chef_solo_json")
+
+    # Setup the basic environment
+    require_box("default")
+    assert_execute("vagrant", "box", "add", "base", box_path("default"))
+
+    # Bring up the VM
+    assert_execute("vagrant", "up")
+
+    # Check for the file it should have created
+    results = assert_execute("vagrant", "ssh", "-c", "cat /tmp/chef_solo_basic")
+    results.stdout.should == "json_data"
+  end
+end

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

@@ -0,0 +1,17 @@
+require File.expand_path("../base", __FILE__)
+require "acceptance/support/shared/command_examples"
+
+describe "vagrant resume" do
+  include_context "acceptance"
+  it_behaves_like "a command that requires a Vagrantfile", ["vagrant", "resume"]
+
+  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", "resume")
+    result.stdout.should match_output(:vm_not_created_warning)
+  end
+end

data/test/acceptance/shared_folders_test.rb

@@ -0,0 +1,84 @@
+require File.expand_path("../base", __FILE__)
+require "acceptance/support/shared/command_examples"
+
+describe "vagrant shared folders" do
+  include_context "acceptance"
+
+  # 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 "should have a '/vagrant' shared folder" do
+    initialize_valid_environment
+
+    # This is the file that will be created from the VM,
+    # but should then exist on the host machine
+    foofile = environment.workdir.join("foo")
+
+    assert_execute("vagrant", "up")
+    foofile.exist?.should_not be,
+        "'foo' should not exist yet."
+
+    assert_execute("vagrant", "ssh", "-c", "touch /vagrant/foo")
+    foofile.exist?.should be, "'foo' should exist since it was touched in the shared folder"
+  end
+
+  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")
+
+    # Verify the directory doesn't exist prior, for sanity
+    data_dir.exist?.should_not be
+
+    # Bring up the VM
+    assert_execute("vagrant", "up")
+
+    # Verify the directory exists
+    data_dir.should be_directory
+
+    # Touch a file and verify it is shared
+    assert_execute("vagrant", "ssh", "-c", "touch /vagrant/foo")
+    data_dir.join("foo").exist?.should be
+  end
+
+  it "should properly shell expand relative directories on the guest" 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", "~/data", "."
+end
+VF
+    end
+
+    # Sanity
+    foo_file = environment.workdir.join("foo")
+    foo_file.exist?.should_not be
+
+    # Bring up the VM
+    assert_execute("vagrant", "up")
+
+    # Touch a file in the shared folder we expect and verify
+    # it is shared.
+    assert_execute("vagrant", "ssh", "-c", "touch ~/data/foo")
+    foo_file.exist?.should be
+  end
+end

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

@@ -0,0 +1,46 @@
+require File.expand_path("../base", __FILE__)
+require "acceptance/support/shared/command_examples"
+
+describe "vagrant ssh" do
+  include_context "acceptance"
+  it_behaves_like "a command that requires a Vagrantfile", ["vagrant", "ssh"]
+  it_behaves_like "a command that requires a virtual machine", ["vagrant", "ssh"]
+
+  it "is able to SSH into 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")
+
+    outputted = false
+    result = assert_execute("vagrant", "ssh") do |io_type, data|
+      if io_type == :stdin and !outputted
+        data.puts("echo hello")
+        data.puts("exit")
+        outputted = true
+      end
+    end
+
+    result.stdout.chomp.should eql("hello"), "Vagrant should bring up a VM to be able to SSH into."
+  end
+
+  it "is able to execute a single command via the command line" do
+    require_box("default")
+
+    assert_execute("vagrant", "box", "add", "base", box_path("default"))
+    assert_execute("vagrant", "init")
+    assert_execute("vagrant", "up")
+
+    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:
+  # SSH should fail if the VM is not running
+end

data/test/acceptance/support/config.rb

@@ -0,0 +1,42 @@
+require "yaml"
+
+require "log4r"
+
+module Acceptance
+  # This represents a configuration object for acceptance tests.
+  class Config
+    attr_reader :vagrant_path
+    attr_reader :vagrant_version
+    attr_reader :env
+    attr_reader :box_directory
+
+    def initialize(path)
+      @logger = Log4r::Logger.new("test::acceptance::config")
+      @logger.info("Loading configuration from: #{path}")
+      options = YAML.load_file(path)
+      @logger.info("Loaded: #{options.inspect}")
+
+      @vagrant_path    = options["vagrant_path"]
+      @vagrant_version = options["vagrant_version"]
+      @env             = options["env"]
+      @box_directory   = options["box_directory"]
+
+      # Verify the configuration object.
+      validate
+    end
+
+    # This method verifies the configuration and makes sure that
+    # all the configuration is available and appears good. This
+    # method will raise an ArgumentError in the case that anything
+    # is wrong.
+    def validate
+      if !@vagrant_path || !File.file?(@vagrant_path)
+        raise ArgumentError, "'vagrant_path' must point to the `vagrant` executable"
+      elsif !@vagrant_version
+        raise ArgumentError, "`vagrant_version' must be set to the version of the `vagrant` executable"
+      elsif !@box_directory || !File.directory?(@box_directory)
+        raise ArgumentError, "`box_directory` must be set to a folder containing boxes for the tests."
+      end
+    end
+  end
+end

data/test/acceptance/support/isolated_environment.rb

@@ -0,0 +1,117 @@
+require "fileutils"
+require "pathname"
+
+require "log4r"
+require "childprocess"
+
+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 < ::IsolatedEnvironment
+    SKELETON_DIR = Pathname.new(File.expand_path("../../skeletons", __FILE__))
+
+    def initialize(apps=nil, env=nil)
+      super()
+
+      @logger = Log4r::Logger.new("test::acceptance::isolated_environment")
+
+      @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
+    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)
+
+      # Determine the options
+      options = argN.last.is_a?(Hash) ? argN.pop : {}
+      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
+    end
+
+    # Closes the environment, cleans up the temporary directories, etc.
+    def close
+      # Only delete virtual machines if VBoxSVC is running, meaning
+      # that something related to VirtualBox started running in this
+      # environment.
+      delete_virtual_machines if VirtualBox.find_vboxsvc
+
+      # Let the parent handle cleaning up
+      super
+    end
+
+    def delete_virtual_machines
+      # Delete all virtual machines
+      @logger.debug("Finding all virtual machines")
+      execute("VBoxManage", "list", "vms").stdout.lines.each do |line|
+        data = /^"(?<name>.+?)" {(?<uuid>.+?)}$/.match(line)
+
+        begin
+          @logger.debug("Removing VM: #{data[:name]}")
+
+          # We add a timeout onto this because sometimes for seemingly no
+          # 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 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
+          Process.kill('KILL', e.pid)
+          Process.waitpid2(e.pid)
+        end
+
+        sleep 0.5
+
+        result = execute("VBoxManage", "unregistervm", data[:uuid], "--delete")
+        raise Exception, "VM unregistration failed!" if result.exit_code != 0
+      end
+
+      @logger.info("Removed all virtual machines")
+    end
+
+    # This replaces a command with a replacement defined when this
+    # isolated environment was initialized. If nothing was defined,
+    # then the command itself is returned.
+    def replace_command(command)
+      return @apps[command] if @apps.has_key?(command)
+      return command
+    end
+  end
+end