vagrant 0.8.10 → 0.9.0

data/test/acceptance/base.rb

@@ -3,15 +3,15 @@ require "rspec/autorun"
 
 require "log4r"
 
-# Add this directory to the load path, since it just makes
-# everything else so much easier.
-$:.unshift File.expand_path("../", __FILE__)
+# Add the test directory to the load path
+$:.unshift File.expand_path("../../", __FILE__)
 
 # Load in the supporting files for our tests
-require "support/shared/base_context"
-require "support/config"
-require "support/virtualbox"
-require "support/matchers/match_output"
+require "acceptance/support/shared/base_context"
+require "acceptance/support/config"
+require "acceptance/support/virtualbox"
+require "acceptance/support/matchers/match_output"
+require "acceptance/support/matchers/succeed"
 
 # Do not buffer output
 $stdout.sync = true
@@ -24,10 +24,10 @@ if Acceptance::VirtualBox.find_vboxsvc
 end
 
 # Enable logging if requested
-if ENV["ACCEPTANCE_LOGGING"]
-  logger = Log4r::Logger.new("acceptance")
+if ENV["ACCEPTANCE_LOG"]
+  logger = Log4r::Logger.new("test")
   logger.outputters = Log4r::Outputter.stdout
-  logger.level = Log4r.const_get(ENV["ACCEPTANCE_LOGGING"].upcase)
+  logger.level = Log4r.const_get(ENV["ACCEPTANCE_LOG"].upcase)
   logger = nil
 end
 

data/test/acceptance/box_test.rb

@@ -13,17 +13,39 @@ describe "vagrant box" do
 
     # Add the box, which we expect to succeed
     result = execute("vagrant", "box", "add", "foo", box_path("default"))
-    result.should be_success
+    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 be_success
-    result.stdout.should match_output(:box_path_doesnt_exist)
+    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
@@ -33,8 +55,8 @@ describe "vagrant box" do
     end
 
     result = execute("vagrant", "box", "add", "foo", invalid.to_s)
-    result.should_not be_success
-    result.stdout.should match_output(:box_invalid)
+    result.should_not succeed
+    result.stderr.should match_output(:box_invalid)
   end
 
   it "can add a box from an HTTP server" do
@@ -49,7 +71,7 @@ describe "vagrant box" do
     execute("vagrant", "box", "add", "foo", box_path("default"))
     execute("vagrant", "box", "remove", "foo")
     result = execute("vagrant", "box", "list")
-    result.should be_success
+    result.should succeed
     result.stdout.should match_output(:no_boxes)
   end
 

data/test/acceptance/destroy_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 destroy" do
   include_context "acceptance"

data/test/acceptance/halt_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 halt" do
   include_context "acceptance"
@@ -28,7 +28,7 @@ describe "vagrant halt" do
 
     # Assert that the VM is no longer running
     result = assert_execute("vagrant", "status")
-    result.stdout.should match_output(:status, "default", "powered off")
+    result.stdout.should match_output(:status, "default", "poweroff")
   end
 
   it "is able to force halt a running virtual machine" do
@@ -44,7 +44,7 @@ describe "vagrant halt" do
 
     # Assert that the VM is no longer running
     result = assert_execute("vagrant", "status")
-    result.stdout.should match_output(:status, "default", "powered off")
+    result.stdout.should match_output(:status, "default", "poweroff")
   end
 
   it "is able to come back up after the machine has been halted" do
@@ -57,7 +57,7 @@ describe "vagrant halt" do
 
     # Assert that the VM is no longer running
     result = assert_execute("vagrant", "status")
-    result.stdout.should match_output(:status, "default", "powered off")
+    result.stdout.should match_output(:status, "default", "poweroff")
 
     assert_execute("vagrant", "up")
 

data/test/acceptance/init_test.rb

@@ -8,7 +8,7 @@ describe "vagrant init" do
     vagrantfile.exist?.should_not be, "Vagrantfile shouldn't exist initially"
 
     result = execute("vagrant", "init")
-    result.should be_success
+    result.should succeed
     vagrantfile.exist?.should be, "Vagrantfile should exist"
   end
 
@@ -16,7 +16,7 @@ describe "vagrant init" do
     vagrantfile = environment.workdir.join("Vagrantfile")
 
     result = execute("vagrant", "init", "foo")
-    result.should be_success
+    result.should succeed
     vagrantfile.read.should match(/config.vm.box = "foo"$/)
   end
 
@@ -24,7 +24,7 @@ describe "vagrant init" do
     vagrantfile = environment.workdir.join("Vagrantfile")
 
     result = execute("vagrant", "init", "foo", "bar")
-    result.should be_success
+    result.should succeed
 
     contents = vagrantfile.read
     contents.should match(/config.vm.box = "foo"$/)

data/test/acceptance/networking/host_only_test.rb

@@ -0,0 +1,37 @@
+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, "33.33.33.10"
+end
+VFILE
+    end
+
+    assert_execute("vagrant", "up")
+    assert_host_to_vm_network("http://33.33.33.10:8000/", 8000)
+  end
+end

data/test/acceptance/networking/port_forward_test.rb

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

@@ -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