vagrantup 0.6.9 → 0.7.0

data/test/vagrant/provisioners/chef_test.rb

@@ -4,24 +4,22 @@ class ChefProvisionerTest < Test::Unit::TestCase
   setup do
     @action_env = Vagrant::Action::Environment.new(vagrant_env.vms[:default].env)
 
-    @action = Vagrant::Provisioners::Chef.new(@action_env)
+    @klass = Vagrant::Provisioners::Chef
+    @config = @klass::Config.new
+    @action = @klass.new(@action_env, @config)
     @env = @action.env
     @vm = @action.vm
   end
 
   context "preparing" do
     should "error the environment" do
-      assert_raises(Vagrant::Provisioners::Chef::ChefError) {
+      assert_raises(@klass::ChefError) {
         @action.prepare
       }
     end
   end
 
   context "config" do
-    setup do
-      @config = Vagrant::Provisioners::Chef::ChefConfig.new
-    end
-
     should "not include the 'json' key in the config dump" do
       result = @config.to_json
       assert result !~ /"json":/
@@ -65,74 +63,6 @@ class ChefProvisionerTest < Test::Unit::TestCase
       @config.add_role("role[user]")
       assert_equal "role[user]", @config.run_list[0]
     end
-
-    context "validation" do
-      setup do
-        @errors = Vagrant::Config::ErrorRecorder.new
-        @top = @config.top = Vagrant::Config::Top.new(@env)
-      end
-
-      context "chef solo" do
-        setup do
-          @top.vm.provisioner = :chef_solo
-
-          @config.run_list = ["foo"]
-          @config.cookbooks_path = "cookbooks"
-        end
-
-        should "be valid if provisioner is not chef solo" do
-          @top.vm.provisioner = nil
-          @config.validate(@errors)
-          assert @errors.errors.empty?
-        end
-
-        should "be invalid if run list is empty" do
-          @config.run_list = []
-          @config.validate(@errors)
-          assert !@errors.errors.empty?
-        end
-
-        should "be invalid if cookbooks path is empty" do
-          @config.cookbooks_path = nil
-          @config.validate(@errors)
-          assert !@errors.errors.empty?
-        end
-      end
-
-      context "chef server" do
-        setup do
-          @top.vm.provisioner = :chef_server
-
-          @config.run_list = ["foo"]
-          @config.chef_server_url = "foo"
-          @config.validation_key_path = "foo"
-        end
-
-        should "be valid if provisioner is not chef solo" do
-          @top.vm.provisioner = nil
-          @config.validate(@errors)
-          assert @errors.errors.empty?
-        end
-
-        should "be invalid if run list is empty" do
-          @config.run_list = []
-          @config.validate(@errors)
-          assert !@errors.errors.empty?
-        end
-
-        should "be invalid if run list is empty" do
-          @config.chef_server_url = nil
-          @config.validate(@errors)
-          assert !@errors.errors.empty?
-        end
-
-        should "be invalid if run list is empty" do
-          @config.validation_key_path = nil
-          @config.validate(@errors)
-          assert !@errors.errors.empty?
-        end
-      end
-    end
   end
 
   context "verifying binary" do
@@ -143,7 +73,7 @@ class ChefProvisionerTest < Test::Unit::TestCase
 
     should "verify binary exists" do
       binary = "foo"
-      @ssh.expects(:exec!).with("which #{binary}", anything)
+      @ssh.expects(:exec!).with("sudo -i which #{binary}", anything)
       @action.verify_binary(binary)
     end
   end
@@ -152,8 +82,8 @@ class ChefProvisionerTest < Test::Unit::TestCase
     should "create and chown the folder to the ssh user" do
       ssh_seq = sequence("ssh_seq")
       ssh = mock("ssh")
-      ssh.expects(:exec!).with("sudo mkdir -p #{@env.config.chef.provisioning_path}").once.in_sequence(ssh_seq)
-      ssh.expects(:exec!).with("sudo chown #{@env.config.ssh.username} #{@env.config.chef.provisioning_path}").once.in_sequence(ssh_seq)
+      ssh.expects(:exec!).with("sudo mkdir -p #{@config.provisioning_path}").once.in_sequence(ssh_seq)
+      ssh.expects(:exec!).with("sudo chown #{@env.config.ssh.username} #{@config.provisioning_path}").once.in_sequence(ssh_seq)
       @vm.ssh.expects(:execute).yields(ssh)
       @action.chown_provisioning_folder
     end
@@ -174,7 +104,7 @@ class ChefProvisionerTest < Test::Unit::TestCase
       string_io = mock("string_io")
       Vagrant::Util::TemplateRenderer.expects(:render).with(@template, anything).returns(template_data)
       StringIO.expects(:new).with(template_data).returns(string_io)
-      File.expects(:join).with(@env.config.chef.provisioning_path, @filename).once.returns("bar")
+      File.expects(:join).with(@config.provisioning_path, @filename).once.returns("bar")
       @vm.ssh.expects(:upload!).with(string_io, "bar")
 
       @action.setup_config(@template, @filename, {})
@@ -183,7 +113,7 @@ class ChefProvisionerTest < Test::Unit::TestCase
     should "provide log level by default" do
       Vagrant::Util::TemplateRenderer.expects(:render).returns("foo").with() do |template, vars|
         assert vars.has_key?(:log_level)
-        assert_equal @env.config.chef.log_level.to_sym, vars[:log_level]
+        assert_equal @config.log_level.to_sym, vars[:log_level]
         true
       end
 
@@ -221,7 +151,7 @@ class ChefProvisionerTest < Test::Unit::TestCase
     end
 
     should "merge in the extra json specified in the config" do
-      @env.config.chef.json = { :foo => "BAR" }
+      @config.json = { :foo => "BAR" }
       assert_json do |data|
         assert_equal "BAR", data["foo"]
       end
@@ -241,7 +171,7 @@ class ChefProvisionerTest < Test::Unit::TestCase
 
     should "upload a StringIO to dna.json" do
       StringIO.expects(:new).with(anything).returns("bar")
-      File.expects(:join).with(@env.config.chef.provisioning_path, "dna.json").once.returns("baz")
+      File.expects(:join).with(@config.provisioning_path, "dna.json").once.returns("baz")
       @vm.ssh.expects(:upload!).with("bar", "baz").once
       @action.setup_json
     end

data/test/vagrant/provisioners/puppet_server_test.rb

@@ -0,0 +1,69 @@
+require "test_helper"
+
+class PuppetServerProvisionerTest < Test::Unit::TestCase
+  setup do
+    @klass = Vagrant::Provisioners::PuppetServer
+
+    @action_env = Vagrant::Action::Environment.new(vagrant_env.vms[:default].env)
+
+    @config = @klass::Config.new
+    @action = @klass.new(@action_env, @config)
+    @env = @action.env
+    @vm = @action.vm
+  end
+
+  context "provisioning" do
+    should "run the proper sequence of methods in order" do
+      prov_seq = sequence("prov_seq")
+      @action.expects(:verify_binary).with("puppetd").once.in_sequence(prov_seq)
+      @action.expects(:run_puppetd_client).once.in_sequence(prov_seq)
+      @action.provision!
+    end
+  end
+
+  context "verifying binary" do
+    setup do
+      @ssh = mock("ssh")
+      @shell = mock("shell")
+      @ssh.stubs(:shell).yields(@shell)
+      @vm.ssh.stubs(:execute).yields(@ssh)
+    end
+
+    should "verify binary exists" do
+      binary = "foo"
+      @shell.expects(:execute).with("sudo -i which #{binary}", anything)
+      @action.verify_binary(binary)
+    end
+  end
+
+  context "running puppetd client" do
+    setup do
+      @cn = "puppet_node"
+      @ssh = mock("ssh")
+      @vm.ssh.stubs(:execute).yields(@ssh)
+    end
+
+    should "run the puppetd client" do
+      @ssh.expects(:exec!).with("sudo -i puppetd  --server #{@config.puppet_server} --certname #{@cn}").once
+      @action.run_puppetd_client
+    end
+
+    should "run puppetd with given options when given as an array" do
+      @config.options = ["--modulepath", "modules", "--verbose"]
+      @ssh.expects(:exec!).with("sudo -i puppetd --modulepath modules --verbose --server #{@config.puppet_server} --certname #{@cn}").once
+      @action.run_puppetd_client
+    end
+
+    should "run puppetd with the options when given as a string" do
+      @config.options = "--modulepath modules --verbose"
+      @ssh.expects(:exec!).with("sudo -i puppetd --modulepath modules --verbose --server #{@config.puppet_server} --certname #{@cn}").once
+      @action.run_puppetd_client
+    end
+
+    should "check the exit status if that is given" do
+      @ssh.stubs(:exec!).yields(nil, :exit_status, :foo)
+      @ssh.expects(:check_exit_status).with(:foo, anything).once
+      @action.run_puppetd_client
+    end
+  end
+end

data/test/vagrant/provisioners/puppet_test.rb

@@ -2,17 +2,102 @@ require "test_helper"
 
 class PuppetProvisionerTest < Test::Unit::TestCase
   setup do
+    clean_paths
+
+    @klass = Vagrant::Provisioners::Puppet
+
     @action_env = Vagrant::Action::Environment.new(vagrant_env.vms[:default].env)
 
-    @action = Vagrant::Provisioners::Puppet.new(@action_env)
+    @config = @klass::Config.new
+    @config.top = Vagrant::Config::Top.new(@action_env.env)
+    @config.top.vm.box = "foo"
+    @action = @klass.new(@action_env, @config)
     @env = @action.env
     @vm = @action.vm
   end
 
+  context "config" do
+    setup do
+      @errors = Vagrant::Config::ErrorRecorder.new
+
+      # Set a box
+      @config.top.vm.box = "foo"
+
+      # Start in a valid state (verified by the first test)
+      @config.expanded_manifests_path.mkdir
+      File.open(@config.expanded_manifests_path.join(@config.computed_manifest_file), "w") { |f| f.puts "HELLO" }
+    end
+
+    should "expand the manifest path relative to the root path" do
+      assert_equal File.expand_path(@config.manifests_path, @env.root_path), @config.expanded_manifests_path.to_s
+    end
+
+    should "default the manifest file to the box name" do
+      assert_equal "#{@config.top.vm.box}.pp", @config.computed_manifest_file
+    end
+
+    should "use the custom manifest file if set" do
+      @config.manifest_file = "woot.pp"
+      assert_equal "woot.pp", @config.computed_manifest_file
+    end
+
+    should "return an empty array if no module path is set" do
+      @config.module_path = nil
+      assert_equal [], @config.expanded_module_paths
+    end
+
+    should "return array of module paths expanded relative to root path" do
+      @config.module_path = "foo"
+
+      result = @config.expanded_module_paths
+      assert result.is_a?(Array)
+      assert_equal 1, result.length
+      assert_equal File.expand_path(@config.module_path, @env.root_path), result[0].to_s
+    end
+
+    should "be valid" do
+      @config.validate(@errors)
+      assert @errors.errors.empty?
+    end
+
+    should "be invalid if the manifests path doesn't exist" do
+      @config.expanded_manifests_path.rmtree
+      @config.validate(@errors)
+      assert !@errors.errors.empty?
+    end
+
+    should "be invalid if a custom manifests path doesn't exist" do
+      @config.manifests_path = "dont_exist"
+      @config.validate(@errors)
+      assert !@errors.errors.empty?
+    end
+
+    should "be invalid if the manifest file doesn't exist" do
+      @config.expanded_manifests_path.join(@config.computed_manifest_file).unlink
+      @config.validate(@errors)
+      assert !@errors.errors.empty?
+    end
+
+    should "be invalid if a specified module path doesn't exist" do
+      @config.module_path = "foo"
+      @config.validate(@errors)
+      assert !@errors.errors.empty?
+    end
+
+    should "be valid if all module paths exist" do
+      @config.module_path = "foo"
+      @config.expanded_module_paths.first.mkdir
+      @config.validate(@errors)
+      assert @errors.errors.empty?
+    end
+  end
+
   context "preparing" do
     should "share manifests" do
-      @action.expects(:check_manifest_dir).once
-      @action.expects(:share_manifests).once
+      pre_seq = sequence("prepare")
+      @action.expects(:set_module_paths).once.in_sequence(pre_seq)
+      @action.expects(:share_manifests).once.in_sequence(pre_seq)
+      @action.expects(:share_module_paths).once.in_sequence(pre_seq)
       @action.prepare
     end
   end
@@ -21,41 +106,27 @@ class PuppetProvisionerTest < Test::Unit::TestCase
     should "run the proper sequence of methods in order" do
       prov_seq = sequence("prov_seq")
       @action.expects(:verify_binary).with("puppet").once.in_sequence(prov_seq)
-      @action.expects(:create_pp_path).once.in_sequence(prov_seq)
-      @action.expects(:set_manifest).once.in_sequence(prov_seq)
       @action.expects(:run_puppet_client).once.in_sequence(prov_seq)
       @action.provision!
     end
   end
 
-  context "check manifest_dir" do
-    setup do
-      @env.config.puppet.manifests_path = "manifests"
-    end
-
-    should "should not create the manifest directory if it exists" do
-      File.expects(:directory?).with(@env.config.puppet.manifests_path).returns(true)
-      @action.check_manifest_dir
-    end
-
-    should "create the manifest directory if it does not exist" do
-      File.stubs(:directory?).with(@env.config.puppet.manifests_path).returns(false)
-      Dir.expects(:mkdir).with(@env.config.puppet.manifests_path).once
-      @action.check_manifest_dir
+  context "share manifests folder" do
+    should "share manifest folder" do
+      @env.config.vm.expects(:share_folder).with("manifests", @action.manifests_guest_path, @config.expanded_manifests_path)
+      @action.share_manifests
     end
   end
 
-  context "share manifests folder" do
-    setup do
-      @manifests_path = "manifests"
-      @pp_path = "/tmp/vagrant-puppet"
-      @action.stubs(:manifests_path).returns(@manifests_path)
-      @action.stubs(:pp_path).returns(@pp_path)
-    end
+  context "sharing module paths" do
+    should "share all the module paths" do
+      @config.module_path = ["foo", "bar"]
+      @config.expanded_module_paths.each_with_index do |path, i|
+        @env.config.vm.expects(:share_folder).with("v-pp-m#{i}", File.join(@config.pp_path, "modules-#{i}"), path)
+      end
 
-    should "share manifest folder" do
-      @env.config.vm.expects(:share_folder).with("manifests", @pp_path, @manifests_path)
-      @action.share_manifests
+      @action.set_module_paths
+      @action.share_module_paths
     end
   end
 
@@ -67,68 +138,44 @@ class PuppetProvisionerTest < Test::Unit::TestCase
 
     should "verify binary exists" do
       binary = "foo"
-      @ssh.expects(:exec!).with("which #{binary}", anything)
+      @ssh.expects(:exec!).with("sudo -i which #{binary}", anything)
       @action.verify_binary(binary)
     end
   end
 
-  context "create pp path" do
-    should "create and chown the folder to the ssh user" do
-      ssh_seq = sequence("ssh_seq")
-      ssh = mock("ssh")
-      ssh.expects(:exec!).with("sudo mkdir -p #{@env.config.puppet.pp_path}").once.in_sequence(ssh_seq)
-      ssh.expects(:exec!).with("sudo chown #{@env.config.ssh.username} #{@env.config.puppet.pp_path}").once.in_sequence(ssh_seq)
-      @vm.ssh.expects(:execute).yields(ssh)
-      @action.create_pp_path
-    end
-  end
-
-  context "setting the manifest" do
-    setup do
-      @env.config.puppet.stubs(:manifests_path).returns("manifests")
-      @env.config.puppet.stubs(:manifest_file).returns("foo.pp")
-      @env.config.vm.stubs(:box).returns("base")
-    end
-
-    should "set the manifest if it exists" do
-      File.stubs(:exists?).with("#{@env.config.puppet.manifests_path}/#{@env.config.puppet.manifest_file}").returns(true)
-      @action.set_manifest
-    end
-
-    should "raise an error if the manifest does not exist" do
-      File.stubs(:exists?).with("#{@env.config.puppet.manifests_path}/#{@env.config.puppet.manifest_file}").returns(false)
-      assert_raises(Vagrant::Provisioners::PuppetError) {
-        @action.set_manifest
-      }
-    end
-  end
-
   context "running puppet client" do
     setup do
       @ssh = mock("ssh")
       @vm.ssh.stubs(:execute).yields(@ssh)
+      @action.set_module_paths
+    end
+
+    def expect_puppet_command(command)
+      @ssh.expects(:exec!).with("sudo -i 'cd #{@action.manifests_guest_path}; #{command}'")
     end
 
     should "cd into the pp_path directory and run puppet" do
-      @ssh.expects(:exec!).with("cd #{@env.config.puppet.pp_path} && sudo -E puppet  #{@manifest}").once
+      expect_puppet_command("puppet #{@config.computed_manifest_file}")
       @action.run_puppet_client
     end
 
     should "cd into the pp_path directory and run puppet with given options when given as an array" do
-      @env.config.puppet.options = ["--modulepath", "modules", "--verbose"]
-      @ssh.expects(:exec!).with("cd #{@env.config.puppet.pp_path} && sudo -E puppet --modulepath modules --verbose #{@manifest}").once
+      @config.options = ["--modulepath", "modules", "--verbose"]
+      expect_puppet_command("puppet --modulepath modules --verbose #{@config.computed_manifest_file}")
       @action.run_puppet_client
     end
 
     should "cd into the pp_path directory and run puppet with the options when given as a string" do
-      @env.config.puppet.options = "--modulepath modules --verbose"
-      @ssh.expects(:exec!).with("cd #{@env.config.puppet.pp_path} && sudo -E puppet --modulepath modules --verbose #{@manifest}").once
+      @config.options = "--modulepath modules --verbose"
+      expect_puppet_command("puppet --modulepath modules --verbose #{@config.computed_manifest_file}")
       @action.run_puppet_client
     end
 
-    should "check the exit status if that is given" do
-      @ssh.stubs(:exec!).yields(nil, :exit_status, :foo)
-      @ssh.expects(:check_exit_status).with(:foo, anything).once
+    should "cd into the pp_path and run puppet with module paths if set" do
+      @config.module_path = "foo"
+      expect_puppet_command("puppet --modulepath '#{File.join(@config.pp_path, 'modules-0')}' #{@config.computed_manifest_file}")
+
+      @action.set_module_paths
       @action.run_puppet_client
     end
   end

data/test/vagrant/ssh_test.rb

@@ -12,13 +12,14 @@ class SshTest < Test::Unit::TestCase
   end
 
   setup do
-    VirtualBox.stubs(:version).returns("3.2.4")
+    VirtualBox.stubs(:version).returns("4.0.0")
   end
 
   context "connecting to external SSH" do
     setup do
       mock_ssh
       @ssh.stubs(:check_key_permissions)
+      @ssh.stubs(:port).returns(2222)
       Kernel.stubs(:exec)
       Kernel.stubs(:system).returns(true)
 
@@ -53,8 +54,8 @@ class SshTest < Test::Unit::TestCase
     end
 
     should "call exec with supplied params" do
-      args = {:username => 'bar', :private_key_path => 'baz', :host => 'bak', :port => 'bag'}
-      ssh_exec_expect(args[:port], args[:private_key_path], args[:username], args[:host])
+      args = {:username => 'bar', :private_key_path => 'baz', :host => 'bak'}
+      ssh_exec_expect(@ssh.port, args[:private_key_path], args[:username], args[:host])
       @ssh.connect(args)
     end
 
@@ -69,6 +70,17 @@ class SshTest < Test::Unit::TestCase
       @ssh.connect
     end
 
+    should "add forward X11 option if enabled" do
+      @env.config.ssh.forward_x11 = true
+      ssh_exec_expect(@ssh.port,
+                      @env.config.ssh.private_key_path,
+                      @env.config.ssh.username,
+                      @env.config.ssh.host) do |args|
+        assert args =~ /-o ForwardX11=yes/
+      end
+      @ssh.connect
+    end
+
     context "on leopard" do
       setup do
         Vagrant::Util::Platform.stubs(:leopard?).returns(true)
@@ -105,10 +117,10 @@ class SshTest < Test::Unit::TestCase
 
     def ssh_exec_expect(port, key_path, uname, host)
       Kernel.expects(:exec).with() do |arg|
-        assert arg =~ /^ssh/
-        assert arg =~ /-p #{port}/
-        assert arg =~ /-i #{key_path}/
-        assert arg =~ /#{uname}@#{host}/
+        assert arg =~ /^ssh/, "ssh command expected"
+        assert arg =~ /-p #{port}/, "-p #{port} expected"
+        assert arg =~ /-i #{key_path}/, "-i #{key_path} expected"
+        assert arg =~ /#{uname}@#{host}/, "#{uname}@{host} expected"
         yield arg if block_given?
         true
       end
@@ -187,6 +199,7 @@ class SshTest < Test::Unit::TestCase
     setup do
       mock_ssh
       @ssh.stubs(:check_key_permissions)
+      @ssh.stubs(:port).returns(2222)
     end
 
     should "return true if SSH connection works" do

data/test/vagrant/systems/base_test.rb

@@ -0,0 +1,18 @@
+require "test_helper"
+
+class BaseSystemTest < Test::Unit::TestCase
+  setup do
+    @klass = Vagrant::Systems::Base
+
+    @vm = mock("vm")
+    @instance = @klass.new(@vm)
+  end
+
+  should "provide access to the VM" do
+    assert_equal @vm, @instance.vm
+  end
+
+  should "error on preparing host only network" do
+    assert_raises(@klass::BaseError) { @instance.prepare_host_only_network }
+  end
+end

data/test/vagrant/systems/linux_test.rb

@@ -61,7 +61,7 @@ class LinuxSystemTest < Test::Unit::TestCase
     end
 
     should "execute the proper mount command" do
-      @ssh.expects(:exec!).with("sudo mount -t vboxsf -o uid=#{@vm.env.config.ssh.username},gid=#{@vm.env.config.ssh.username} #{@name} #{@guestpath}").returns(@success_return)
+      @ssh.expects(:exec!).with("sudo mount -t vboxsf -o uid=`id -u #{@vm.env.config.ssh.username}`,gid=`id -g #{@vm.env.config.ssh.username}` #{@name} #{@guestpath}").returns(@success_return)
       mount_folder
     end
 
@@ -107,7 +107,7 @@ class LinuxSystemTest < Test::Unit::TestCase
 
       @vm.stubs(:env).returns(env)
 
-      @ssh.expects(:exec!).with("sudo mount -t vboxsf -o uid=#{uid},gid=#{gid} #{@name} #{@guestpath}").returns(@success_return)
+      @ssh.expects(:exec!).with("sudo mount -t vboxsf -o uid=`id -u #{uid}`,gid=`id -g #{gid}` #{@name} #{@guestpath}").returns(@success_return)
       mount_folder
     end
   end

data/test/vagrant/vm_test.rb

@@ -25,6 +25,7 @@ class VMTest < Test::Unit::TestCase
     setup do
       @vm_name = "foo"
       @mock_vm = mock("vm")
+      @mock_vm.stubs(:running?).returns(false)
       @vm = Vagrant::VM.new(:env => @env, :vm => @mock_vm, :name => @vm_name)
       @mock_vm.stubs(:uuid).returns("foo")
     end
@@ -96,11 +97,14 @@ class VMTest < Test::Unit::TestCase
         }
       end
 
-      context "with a class" do
-        class FakeSystemClass
-          def initialize(vm); end
-        end
+      should "load the given system if specified" do
+        fake_class = Class.new(Vagrant::Systems::Base)
 
+        assert_nothing_raised { @vm.load_system!(fake_class) }
+        assert @vm.system.is_a?(fake_class)
+      end
+
+      context "with a class" do
         should "initialize class if given" do
           @vm.env.config.vm.system = Vagrant::Systems::Linux
 
@@ -109,7 +113,7 @@ class VMTest < Test::Unit::TestCase
         end
 
         should "raise error if class has invalid parent" do
-          @vm.env.config.vm.system = FakeSystemClass
+          @vm.env.config.vm.system = Class.new
           assert_raises(Vagrant::Errors::VMSystemError) {
             @vm.load_system!
           }
@@ -140,6 +144,30 @@ class VMTest < Test::Unit::TestCase
           }
         end
       end
+
+      context "loading the distro" do
+        setup do
+          @vm.vm.stubs(:running?).returns(true)
+        end
+
+        should "not replace the distro if it is nil" do
+          @vm.env.config.vm.system = Class.new(Vagrant::Systems::Base)
+
+          @vm.load_system!
+          assert @vm.system.is_a?(@vm.env.config.vm.system)
+        end
+
+        should "replace the distro if it is not nil" do
+          @vm.env.config.vm.system = Class.new(Vagrant::Systems::Base) do
+            def distro_dispatch
+              :linux
+            end
+          end
+
+          @vm.load_system!
+          assert @vm.system.is_a?(Vagrant::Systems::Linux)
+        end
+      end
     end
 
     context "uuid" do

data/vagrant.gemspec

@@ -1,4 +1,5 @@
-require File.expand_path("../lib/vagrant/version", __FILE__)
+$:.unshift File.expand_path("../lib", __FILE__)
+require "vagrant/version"
 
 Gem::Specification.new do |s|
   s.name          = "vagrantup"
@@ -18,10 +19,10 @@ Gem::Specification.new do |s|
   s.add_dependency "json", "~> 1.4.6"
   s.add_dependency "mario", "~> 0.0.6"
   s.add_dependency "net-ssh", "~> 2.0.23"
-  s.add_dependency "net-scp", "~> 1.0.3"
-  s.add_dependency "i18n", "~> 0.4.1"
-  s.add_dependency "thor", "~> 0.14.2"
-  s.add_dependency "virtualbox", "~> 0.7.6"
+  s.add_dependency "net-scp", "~> 1.0.4"
+  s.add_dependency "i18n", "~> 0.5.0"
+  s.add_dependency "thor", "~> 0.14.6"
+  s.add_dependency "virtualbox", "~> 0.8.2"
 
   s.add_development_dependency "rake"
   s.add_development_dependency "contest", ">= 0.1.2"