vagrant 1.0.7 → 2.4.4

data/test/acceptance/box_test.rb

@@ -1,99 +0,0 @@
-require File.expand_path("../base", __FILE__)
-
-describe "vagrant box" do
-  include_context "acceptance"
-
-  it "has no boxes by default" do
-    result = execute("vagrant", "box", "list")
-    result.stdout.should match_output(:no_boxes)
-  end
-
-  it "can add a box from a file" do
-    require_box("default")
-
-    # Add the box, which we expect to succeed
-    result = execute("vagrant", "box", "add", "foo", box_path("default"))
-    result.should succeed
-
-    # Verify that the box now shows up in the list of available boxes
-    result = execute("vagrant", "box", "list")
-    result.stdout.should match_output(:box_installed, "foo")
-  end
-
-  it "errors if attempting to add a box with the same name" do
-    require_box("default")
-
-    # Add the box, which we expect to succeed
-    assert_execute("vagrant", "box", "add", "foo", box_path("default"))
-
-    # Adding it again should not succeed
-    result = execute("vagrant", "box", "add", "foo", box_path("default"))
-    result.should_not succeed
-    result.stderr.should match_output(:box_already_exists, "foo")
-  end
-
-  it "overwrites a box when adding with `--force`" do
-    require_box("default")
-
-    # Add the box, which we expect to succeed
-    assert_execute("vagrant", "box", "add", "foo", box_path("default"))
-
-    # Adding it again should not succeed
-    assert_execute("vagrant", "box", "add", "foo", box_path("default"), "--force")
-  end
-
-  it "gives an error if the file doesn't exist" do
-    result = execute("vagrant", "box", "add", "foo", "/tmp/nope/nope/nope/nonono.box")
-    result.should_not succeed
-    result.stderr.should match_output(:box_path_doesnt_exist)
-  end
-
-  it "gives an error if the file is not a valid box" do
-    invalid = environment.workdir.join("nope.txt")
-    invalid.open("w+") do |f|
-      f.write("INVALID!")
-    end
-
-    result = execute("vagrant", "box", "add", "foo", invalid.to_s)
-    result.should_not succeed
-    result.stderr.should match_output(:box_invalid)
-  end
-
-  it "can add a box from an HTTP server" do
-    pending("Need to setup HTTP server functionality")
-  end
-
-  it "can remove a box" do
-    require_box("default")
-
-    # Add the box, remove the box, then verify that the box no longer
-    # shows up in the list of available boxes.
-    execute("vagrant", "box", "add", "foo", box_path("default"))
-    execute("vagrant", "box", "remove", "foo")
-    result = execute("vagrant", "box", "list")
-    result.should succeed
-    result.stdout.should match_output(:no_boxes)
-  end
-
-  it "can repackage a box" do
-    require_box("default")
-
-    original_size = File.size(box_path("default"))
-    logger.debug("Original package size: #{original_size}")
-
-    # Add the box, repackage it, and verify that a package.box is
-    # dumped of relatively similar size.
-    execute("vagrant", "box", "add", "foo", box_path("default"))
-    execute("vagrant", "box", "repackage", "foo")
-
-    # By default, repackage should dump into package.box into the CWD
-    repackaged_file = environment.workdir.join("package.box")
-    repackaged_file.file?.should be, "package.box should exist in cwd of environment"
-
-    # Compare the sizes
-    repackaged_size = repackaged_file.size
-    logger.debug("Repackaged size: #{repackaged_size}")
-    size_diff = (repackaged_size - original_size).abs
-    size_diff.should be < 1000, "Sizes should be very similar"
-  end
-end

data/test/acceptance/destroy_test.rb

@@ -1,37 +0,0 @@
-require File.expand_path("../base", __FILE__)
-require "acceptance/support/shared/command_examples"
-
-describe "vagrant destroy" do
-  include_context "acceptance"
-  it_behaves_like "a command that requires a Vagrantfile", ["vagrant", "destroy"]
-
-  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", "destroy")
-    result.stdout.should match_output(:vm_not_created_warning)
-  end
-
-  it "is able to destroy 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")
-
-    # Destroy the VM and assert that it worked properly (seemingly)
-    result = assert_execute("vagrant", "destroy")
-    result.stdout.should match_output(:vm_destroyed)
-
-    # Assert that the VM no longer is created
-    result = assert_execute("vagrant", "status")
-    result.stdout.should match_output(:status, "default", "not created")
-  end
-
-  # TODO:
-  # it is able to destroy a halted virtual machine
-  # it is able to destroy a suspended virtual machine
-end

data/test/acceptance/halt_test.rb

@@ -1,72 +0,0 @@
-require File.expand_path("../base", __FILE__)
-require "acceptance/support/shared/command_examples"
-
-describe "vagrant halt" do
-  include_context "acceptance"
-  it_behaves_like "a command that requires a Vagrantfile", ["vagrant", "halt"]
-
-  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", "halt")
-    result.stdout.should match_output(:vm_not_created_warning)
-  end
-
-  it "is able to halt 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")
-
-    # Halt the VM and assert that it worked properly (seemingly)
-    result = assert_execute("vagrant", "halt")
-    result.stdout.should match_output(:vm_halt_graceful)
-
-    # Assert that the VM is no longer running
-    result = assert_execute("vagrant", "status")
-    result.stdout.should match_output(:status, "default", "poweroff")
-  end
-
-  it "is able to force halt 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")
-
-    # Halt the VM and assert that it worked properly (seemingly)
-    result = assert_execute("vagrant", "halt", "--force")
-    result.stdout.should match_output(:vm_halt_force)
-
-    # Assert that the VM is no longer running
-    result = assert_execute("vagrant", "status")
-    result.stdout.should match_output(:status, "default", "poweroff")
-  end
-
-  it "is able to come back up after the machine has been halted" do
-    require_box("default")
-
-    assert_execute("vagrant", "box", "add", "base", box_path("default"))
-    assert_execute("vagrant", "init")
-    assert_execute("vagrant", "up")
-    assert_execute("vagrant", "halt")
-
-    # Assert that the VM is no longer running
-    result = assert_execute("vagrant", "status")
-    result.stdout.should match_output(:status, "default", "poweroff")
-
-    assert_execute("vagrant", "up")
-
-    # Assert that the VM is once again running
-    result = assert_execute("vagrant", "status")
-    result.stdout.should match_output(:status, "default", "running")
-  end
-
-  # TODO:
-  # halt behavior on suspend machine
-  # halt behavior if machine is already powered off
-end

data/test/acceptance/init_test.rb

@@ -1,33 +0,0 @@
-require File.expand_path("../base", __FILE__)
-
-describe "vagrant init" do
-  include_context "acceptance"
-
-  it "creates a Vagrantfile in the working directory" do
-    vagrantfile = environment.workdir.join("Vagrantfile")
-    vagrantfile.exist?.should_not be, "Vagrantfile shouldn't exist initially"
-
-    result = execute("vagrant", "init")
-    result.should succeed
-    vagrantfile.exist?.should be, "Vagrantfile should exist"
-  end
-
-  it "creates a Vagrantfile with the box set to the given argument" do
-    vagrantfile = environment.workdir.join("Vagrantfile")
-
-    result = execute("vagrant", "init", "foo")
-    result.should succeed
-    vagrantfile.read.should match(/config.vm.box = "foo"$/)
-  end
-
-  it "creates a Vagrantfile with the box URL set to the given argument" do
-    vagrantfile = environment.workdir.join("Vagrantfile")
-
-    result = execute("vagrant", "init", "foo", "bar")
-    result.should succeed
-
-    contents = vagrantfile.read
-    contents.should match(/config.vm.box = "foo"$/)
-    contents.should match(/config.vm.box_url = "bar"$/)
-  end
-end

data/test/acceptance/networking/host_only_test.rb

@@ -1,37 +0,0 @@
-require File.expand_path("../../base", __FILE__)
-
-require "net/http"
-require "uri"
-
-require "acceptance/support/network_tests"
-require "acceptance/support/shared/command_examples"
-require "support/tempdir"
-
-describe "vagrant host only networking" do
-  include Acceptance::NetworkTests
-
-  include_context "acceptance"
-
-  def initialize_environment(env=nil)
-    require_box("default")
-
-    env ||= environment
-    env.execute("vagrant", "box", "add", "base", box_path("default")).should succeed
-  end
-
-  it "creates a network with a static IP" do
-    initialize_environment
-
-    environment.workdir.join("Vagrantfile").open("w+") do |f|
-      f.puts(<<VFILE)
-Vagrant::Config.run do |config|
-  config.vm.box = "base"
-  config.vm.network :hostonly, "192.168.33.10"
-end
-VFILE
-    end
-
-    assert_execute("vagrant", "up")
-    assert_host_to_vm_network("http://192.168.33.10:8000/", 8000)
-  end
-end

data/test/acceptance/networking/port_forward_test.rb

@@ -1,125 +0,0 @@
-require File.expand_path("../../base", __FILE__)
-
-require "net/http"
-require "uri"
-
-require "acceptance/support/network_tests"
-require "acceptance/support/shared/command_examples"
-require "support/tempdir"
-
-describe "vagrant port forwarding" do
-  include Acceptance::NetworkTests
-
-  include_context "acceptance"
-
-  def initialize_environment(env=nil)
-    require_box("default")
-
-    env ||= environment
-    env.execute("vagrant", "box", "add", "base", box_path("default")).should succeed
-  end
-
-  it "forwards ports properly" do
-    initialize_environment
-
-    guest_port = 3000
-    host_port  = 5000
-
-    environment.workdir.join("Vagrantfile").open("w+") do |f|
-      f.puts(<<VFILE)
-Vagrant::Config.run do |config|
-  config.vm.box = "base"
-  config.vm.forward_port #{guest_port}, #{host_port}
-end
-VFILE
-    end
-
-    assert_execute("vagrant", "up")
-    assert_host_to_vm_network("http://localhost:#{host_port}/", guest_port)
-  end
-
-  it "properly overrides port forwarding from the same port" do
-    initialize_environment
-
-    guest_port = 3000
-    host_port  = 5000
-
-    environment.workdir.join("Vagrantfile").open("w+") do |f|
-      f.puts(<<VFILE)
-Vagrant::Config.run do |config|
-  config.vm.box = "base"
-  config.vm.forward_port #{guest_port}, #{host_port - 1}
-  config.vm.forward_port #{guest_port}, #{host_port}
-end
-VFILE
-    end
-
-    assert_execute("vagrant", "up")
-    assert_host_to_vm_network("http://localhost:#{host_port}/", guest_port)
-  end
-
-  it "detects and corrects port collisions" do
-    # The two environments need to share a VBOX_USER_HOME so that the
-    # VM's go into the same place.
-    env_vars     = { "VBOX_USER_HOME" => Tempdir.new("vagrant").to_s }
-    environment  = new_environment(env_vars)
-    environment2 = new_environment(env_vars)
-
-    # For this test we create two isolated environments and `vagrant up`
-    # in each. SSH would collide, so this verifies that it won't!
-    begin
-      initialize_environment(environment)
-      initialize_environment(environment2)
-
-      # Build both environments up.
-      environment.execute("vagrant", "init").should succeed
-      environment.execute("vagrant", "up").should succeed
-      environment2.execute("vagrant", "init").should succeed
-      environment2.execute("vagrant", "up").should succeed
-
-      # Touch files in both environments
-      environment.execute("vagrant", "ssh", "-c", "touch /vagrant/foo").should succeed
-      environment2.execute("vagrant", "ssh", "-c", "touch /vagrant/bar").should succeed
-
-      # Verify that the files exist in each folder, properly
-      environment.workdir.join("foo").exist?.should be
-      environment2.workdir.join("bar").exist?.should be
-    ensure
-      environment.close
-      environment2.close
-    end
-  end
-
-  it "refuses to resume if there is a port collision" do
-    # The two environments need to share a VBOX_USER_HOME so that the
-    # VM's go into the same place.
-    env_vars     = { "VBOX_USER_HOME" => Tempdir.new("vagrant").path }
-    environment  = new_environment(env_vars)
-    environment2 = new_environment(env_vars)
-
-    # For this test we `vagrant up` one environment, suspend it,
-    # `vagrant up` another environment, and then come back to the first
-    # and try to resume. SSH would collide so it should error.
-    begin
-      # Bring up the first environment and suspend it
-      initialize_environment(environment)
-      environment.execute("vagrant", "init").should succeed
-      environment.execute("vagrant", "up").should succeed
-      environment.execute("vagrant", "suspend").should succeed
-
-      # Bring up the second environment
-      initialize_environment(environment2)
-      environment2.execute("vagrant", "init").should succeed
-      environment2.execute("vagrant", "up").should succeed
-
-      # Attempt to bring up the first environment again, but it should
-      # result in an error.
-      result = environment.execute("vagrant", "up")
-      result.should_not succeed
-      result.stderr.should match_output(:resume_port_collision)
-    ensure
-      environment.close
-      environment2.close
-    end
-  end
-end

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