vagrant 1.0.7 → 1.5.0

data/test/acceptance/package_test.rb

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

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

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

@@ -1,53 +0,0 @@
-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,17 +0,0 @@
-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

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

@@ -1,3 +0,0 @@
-# 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

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

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

@@ -1,3 +0,0 @@
-# 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

@@ -1,6 +0,0 @@
-# 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

@@ -1,3 +0,0 @@
-# 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

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

data/test/acceptance/ssh_test.rb

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

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

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