vagrant 0.7.0.beta → 0.7.0.beta2

data/test/vagrant/action/vm/share_folders_test.rb

@@ -116,6 +116,7 @@ class ShareFoldersVMActionTest < Test::Unit::TestCase
       @folders = stub_shared_folders(<<-sf)
         config.vm.share_folder("foo", "fooguest", "foohost")
         config.vm.share_folder("bar", "barguest", "barhost")
+        config.vm.share_folder("foo_no_mount", nil, "foohost2")
       sf
       @ssh = mock("ssh")
       @vm.ssh.stubs(:execute).yields(@ssh)
@@ -125,7 +126,11 @@ class ShareFoldersVMActionTest < Test::Unit::TestCase
     should "mount all shared folders to the VM" do
       mount_seq = sequence("mount_seq")
       @folders.each do |name, data|
-        @vm.system.expects(:mount_shared_folder).with(@ssh, name, data[:guestpath]).in_sequence(mount_seq)
+        if data[:guestpath]
+          @vm.system.expects(:mount_shared_folder).with(@ssh, name, data[:guestpath]).in_sequence(mount_seq)
+        else
+          @vm.system.expects(:mount_shared_folder).with(@ssh, name, anything).never
+        end
       end
 
       @instance.mount_shared_folders

data/test/vagrant/command/helpers_test.rb

@@ -52,7 +52,7 @@ class CommandHelpersTest < Test::Unit::TestCase
       should "return the VM if no name is specified" do
         instance = command([], @env)
         assert_nothing_raised {
-          assert_equal @env.vms.values, instance.target_vms
+          assert_equal @env.vms.values.sort, instance.target_vms.sort
         }
       end
     end
@@ -64,7 +64,7 @@ class CommandHelpersTest < Test::Unit::TestCase
 
       should "return all the VMs if no name is specified" do
         instance = command([], @env)
-        assert_equal @env.vms.values, instance.target_vms
+        assert_equal @env.vms.values.sort, instance.target_vms.sort
       end
 
       should "return only the specified VM if a name is given" do

data/test/vagrant/config/base_test.rb

@@ -42,12 +42,6 @@ class ConfigBaseTest < Test::Unit::TestCase
         assert_equal @json, @base.to_json
       end
 
-      should "not include env in the JSON hash" do
-        @base.env = "FOO"
-        hash = @base.instance_variables_hash
-        assert !hash.has_key?(:env)
-      end
-
       should "not include top in the JSON hash" do
         @base.top = "FOO"
         hash = @base.instance_variables_hash

data/test/vagrant/config/vagrant_test.rb

@@ -8,7 +8,6 @@ class ConfigVagrantTest < Test::Unit::TestCase
   context "validation" do
     setup do
       @config.dotfile_name = "foo"
-      @config.home = "foo"
       @config.host = "foo"
 
       @errors = Vagrant::Config::ErrorRecorder.new
@@ -26,13 +25,6 @@ class ConfigVagrantTest < Test::Unit::TestCase
       assert !@errors.errors.empty?
     end
 
-    should "be invalid with no home" do
-      @config.home = nil
-
-      @config.validate(@errors)
-      assert !@errors.errors.empty?
-    end
-
     should "be invalid with no host" do
       @config.host = nil
 

data/test/vagrant/config/vm/provisioner_test.rb

@@ -0,0 +1,92 @@
+require "test_helper"
+
+class ConfigVMProvisionerTest < Test::Unit::TestCase
+  setup do
+    @klass = Vagrant::Config::VMConfig::Provisioner
+    @top = Vagrant::Config::Top.new(nil)
+  end
+
+  context "initializing" do
+    should "expose the top instance that the provisioner belongs to" do
+      instance = @klass.new(@top, :chef_solo)
+      assert_equal @top, instance.top
+    end
+
+    should "expose the shortcut used" do
+      instance = @klass.new(@top, :chef_solo)
+      assert_equal :chef_solo, instance.shortcut
+    end
+
+    should "expose the provisioner class if its a valid shortcut" do
+      instance = @klass.new(@top, :chef_solo)
+      assert_equal Vagrant::Provisioners::ChefSolo, instance.provisioner
+    end
+
+    should "expose the provisioner class if its a valid class" do
+      instance = @klass.new(@top, Vagrant::Provisioners::ChefSolo)
+      assert_equal Vagrant::Provisioners::ChefSolo, instance.provisioner
+    end
+
+    should "have a nil provisioner class if invalid" do
+      instance = @klass.new(@top, :i_shall_never_exist)
+      assert_nil instance.provisioner
+    end
+
+    should "have a nil config instance if invalid" do
+      instance = @klass.new(@top, :i_shall_never_exist)
+      assert_nil instance.config
+    end
+
+    should "set the top of the config object to the given top" do
+      instance = @klass.new(@top, :chef_solo)
+      assert_equal @top, instance.config.top
+    end
+
+    should "configure the provisioner if valid" do
+      instance = @klass.new(@top, :chef_solo) do |chef|
+        chef.cookbooks_path = "foo"
+      end
+
+      assert_equal "foo", instance.config.cookbooks_path
+    end
+
+    should "configure the provisioner with a hash if valid" do
+      instance = @klass.new(@top, :chef_solo, :cookbooks_path => "foo")
+      assert_equal "foo", instance.config.cookbooks_path
+    end
+  end
+
+  context "validation" do
+    setup do
+      @errors = Vagrant::Config::ErrorRecorder.new
+    end
+
+    should "be invalid if provisioner is valid" do
+      instance = @klass.new(@top, :i_shall_never_exist)
+      instance.validate(@errors)
+      assert !@errors.errors.empty?
+    end
+
+    should "be invalid if provisioner doesn't inherit from provisioners base" do
+      klass = Class.new
+      instance = @klass.new(@top, klass)
+      instance.validate(@errors)
+      assert !@errors.errors.empty?
+    end
+
+    should "be valid with a valid provisioner" do
+      instance = @klass.new(@top, :chef_solo) do |chef|
+        chef.add_recipe "foo"
+      end
+
+      instance.validate(@errors)
+      assert @errors.errors.empty?
+    end
+
+    should "be invalid if a provisioner's config is invalid" do
+      instance = @klass.new(@top, :chef_solo)
+      instance.validate(@errors)
+      assert !@errors.errors.empty?
+    end
+  end
+end

data/test/vagrant/config/vm_test.rb

@@ -75,4 +75,12 @@ class ConfigVMTest < Test::Unit::TestCase
       assert_equal @username, @config.shared_folder_gid
     end
   end
+
+  context "deprecated config" do
+    should "raise an error for provisioner=" do
+      assert_raises(Vagrant::Errors::VagrantError) {
+        @config.provisioner = :chef_solo
+      }
+    end
+  end
 end

data/test/vagrant/config_test.rb

@@ -5,117 +5,79 @@ class ConfigTest < Test::Unit::TestCase
     @klass = Vagrant::Config
   end
 
-  context "with an instance" do
-    setup do
-      @env = vagrant_env
-      @instance = @klass.new(@env)
-    end
+  context "with the class" do
+    should "allow access to the last proc" do
+      foo = mock("object")
+      foo.expects(:call).once
 
-    should "initially have an empty queue" do
-      assert @instance.queue.empty?
-    end
+      @klass.run { |config| foo.call }
+      value = @klass.last_proc.first
+      assert value.is_a?(Proc)
+      value.call(nil)
 
-    should "reset the config class on load, then execute" do
-      seq = sequence("sequence")
-      @klass.expects(:reset!).with(@env).in_sequence(seq)
-      @klass.expects(:execute!).in_sequence(seq)
-      @instance.load!
+      assert @klass.last_proc.nil?
     end
+  end
 
-    should "run the queue in the order given" do
-      @instance.queue << Proc.new { |config| config.vm.box = "foo" }
-      @instance.queue << Proc.new { |config| config.vm.box = "bar" }
-      result = @instance.load!
-
-      assert_equal "bar", result.vm.box
+  context "with an instance" do
+    setup do
+      @instance = @klass.new
     end
 
-    should "allow nested arrays" do
-      queue = []
-      queue << Proc.new { |config| config.vm.box = "foo" }
-      queue << Proc.new { |config| config.vm.box = "bar" }
-      @instance.queue << queue
-      result = @instance.load!
+    should "load the config files in the given order" do
+      names = %w{alpha beta gamma}
 
-      assert_equal "bar", result.vm.box
-    end
+      @instance.load_order = [:alpha, :beta]
 
-    should "load a file if it exists" do
-      filename = "foo"
-      File.expects(:exist?).with(filename).returns(true)
-      @instance.expects(:load).with(filename).once
+      names.each do |name|
+        vagrantfile(vagrant_box(name), "config.vm.box = '#{name}'")
+        @instance.set(name.to_sym, vagrant_box(name).join("Vagrantfile"))
+      end
 
-      @instance.queue << filename
-      @instance.load!
+      config = @instance.load(nil)
+      assert_equal "beta", config.vm.box
     end
 
-    should "not load a file if it doesn't exist" do
-      filename = "foo"
-      File.expects(:exist?).with(filename).returns(false)
-      @instance.expects(:load).with(filename).never
+    should "load the config as procs" do
+      @instance.set(:proc, Proc.new { |config| config.vm.box = "proc" })
+      @instance.load_order = [:proc]
+      config = @instance.load(nil)
 
-      @instance.queue << filename
-      @instance.load!
+      assert_equal "proc", config.vm.box
     end
 
-    should "raise an exception if there is a syntax error in a file" do
-      @instance.queue << "foo"
-      File.expects(:exist?).with("foo").returns(true)
-      @instance.expects(:load).with("foo").raises(SyntaxError.new)
+    should "load an array of procs" do
+      @instance.set(:proc, [Proc.new { |config| config.vm.box = "proc" },
+                            Proc.new { |config| config.vm.box = "proc2" }])
+      @instance.load_order = [:proc]
+      config = @instance.load(nil)
 
-      assert_raises(Vagrant::Errors::VagrantfileSyntaxError) {
-        @instance.load!
-      }
+      assert_equal "proc2", config.vm.box
     end
-  end
 
-  context "resetting" do
-    setup do
-      @klass.reset!(vagrant_env)
-      @klass::Top.any_instance.stubs(:validate!)
-      @klass.run { |config| }
-      @klass.execute!
+    should "not care if a file doesn't exist" do
+      @instance.load_order = [:foo]
+      assert_nothing_raised { @instance.set(:foo, "i/dont/exist") }
+      assert_nothing_raised { @instance.load(nil) }
     end
 
-    should "return the same config object typically" do
-      config = @klass.config
-      assert config.equal?(@klass.config)
-    end
+    should "not reload a file" do
+      foo_path = vagrant_box("foo").join("Vagrantfile")
 
-    should "create a new object if cleared" do
-      config = @klass.config
-      @klass.reset!
-      assert !config.equal?(@klass.config)
-    end
+      vagrantfile(vagrant_box("foo"))
+      @instance.set(:foo, foo_path)
 
-    should "empty the proc stack" do
-      assert !@klass.proc_stack.empty?
-      @klass.reset!
-      assert @klass.proc_stack.empty?
+      # Nothing should be raised in this case because the file isn't reloaded
+      vagrantfile(vagrant_box("foo"), "^%&8318")
+      assert_nothing_raised { @instance.set(:foo, foo_path) }
     end
 
-    should "reload the config object based on the given environment" do
-      env = mock("env")
-      @klass.expects(:config).with(env).once
-      @klass.reset!(env)
-    end
-  end
-
-  context "initializing" do
-    setup do
-      @klass.reset!(vagrant_env)
-    end
-
-    should "add the given block to the proc stack" do
-      proc = Proc.new {}
-      @klass.run(&proc)
-      assert_equal [proc], @klass.proc_stack
-    end
+    should "raise an exception if there is a syntax error in a file" do
+      vagrantfile(vagrant_box("foo"), "^%&8318")
 
-    should "return the configuration on execute!" do
-      @klass.run {}
-      result = @klass.execute!
-      assert result.is_a?(@klass::Top)
+      assert_raises(Vagrant::Errors::VagrantfileSyntaxError) {
+        @instance.set(:foo, vagrant_box("foo").join("Vagrantfile"))
+      }
     end
   end
 
@@ -149,7 +111,6 @@ class ConfigTest < Test::Unit::TestCase
           key = "key#{i}"
           klass = mock("klass#{i}")
           instance = mock("instance#{i}")
-          instance.expects(:env=).with(env)
           instance.expects(:top=).with() do |top|
             assert top.is_a?(@klass::Top)
             true
@@ -165,7 +126,6 @@ class ConfigTest < Test::Unit::TestCase
         key = "my_foo_bar_key"
         klass = mock("klass")
         instance = mock("instance")
-        instance.stubs(:env=)
         instance.stubs(:top=)
         klass.expects(:new).returns(instance)
         @klass::Top.configures(key, klass)

data/test/vagrant/downloaders/file_test.rb

@@ -17,11 +17,25 @@ class FileDownloaderTest < Test::Unit::TestCase
   end
 
   context "downloading" do
+    setup do
+      clean_paths
+    end
+
     should "cp the file" do
-      path = '/path'
-      @tempfile.expects(:path).returns(path)
-      FileUtils.expects(:cp).with(@uri, path)
-      @downloader.download!(@uri, @tempfile)
+      uri = tmp_path.join("foo_source")
+      dest = tmp_path.join("foo_dest")
+
+      # Create the source file, then "download" it
+      File.open(uri, "w+") { |f| f.write("FOO") }
+      File.open(dest, "w+") do |dest_file|
+        @downloader.download!(uri, dest_file)
+      end
+
+      # Finally, verify the destination file was properly created
+      assert File.file?(dest)
+      File.open(dest) do |f|
+        assert_equal "FOO", f.read
+      end
     end
   end
 

data/test/vagrant/environment_test.rb

@@ -4,15 +4,17 @@ require "pathname"
 class EnvironmentTest < Test::Unit::TestCase
   setup do
     @klass = Vagrant::Environment
+
+    clean_paths
   end
 
   context "class method check virtualbox version" do
     setup do
-      VirtualBox.stubs(:version).returns("3.1.4")
+      VirtualBox.stubs(:version).returns("4.0.0")
     end
 
     should "not error and exit if everything is good" do
-      VirtualBox.expects(:version).returns("3.2.4")
+      VirtualBox.expects(:version).returns("4.0.0")
       assert_nothing_raised { @klass.check_virtualbox! }
     end
 
@@ -21,17 +23,11 @@ class EnvironmentTest < Test::Unit::TestCase
       assert_raises(Vagrant::Errors::VirtualBoxNotDetected) { @klass.check_virtualbox! }
     end
 
-    should "error and exit if VirtualBox is lower than version 3.2" do
-      version = "3.1.12r1041"
+    should "error and exit if VirtualBox is lower than version 4.0" do
+      version = "3.2.12r1041"
       VirtualBox.expects(:version).returns(version)
       assert_raises(Vagrant::Errors::VirtualBoxInvalidVersion) { @klass.check_virtualbox! }
     end
-
-    should "error and exit for OSE VirtualBox" do
-      version = "3.2.6_OSE"
-      VirtualBox.expects(:version).returns(version)
-      assert_raises(Vagrant::Errors::VirtualBoxInvalidOSE) { @klass.check_virtualbox! }
-    end
   end
 
   context "initialization" do
@@ -59,8 +55,21 @@ class EnvironmentTest < Test::Unit::TestCase
     end
 
     context "home path" do
+      setup do
+        @env = @klass.new
+      end
+
       should "return the home path if it loaded" do
-        expected = Pathname.new(File.expand_path(@env.config.vagrant.home, @env.root_path))
+        ENV["VAGRANT_HOME"] = nil
+
+        expected = Pathname.new(File.expand_path(@klass::DEFAULT_HOME))
+        assert_equal expected, @env.home_path
+      end
+
+      should "return the home path set by the environmental variable" do
+        ENV["VAGRANT_HOME"] = "foo"
+
+        expected = Pathname.new(File.expand_path(ENV["VAGRANT_HOME"]))
         assert_equal expected, @env.home_path
       end
     end
@@ -391,7 +400,7 @@ class EnvironmentTest < Test::Unit::TestCase
         create_box_vagrantfile
         vagrantfile(@env.root_path, "config.vm.box = 'box'")
 
-        assert_equal "box.box", @env.config.package.name
+        assert_equal "box.box", @env.primary_vm.env.config.package.name
       end
 
       should "load from home path if exists" do
@@ -425,6 +434,21 @@ class EnvironmentTest < Test::Unit::TestCase
         @env.load_config!
         assert @env.instance_variable_get(:@logger).nil?
       end
+
+      should "be able to reload config" do
+        vagrantfile(@env.root_path, "config.vm.box = 'box'")
+
+        # First load the config normally
+        @env.load_config!
+        assert_equal "box", @env.config.vm.box
+        assert_not_equal "set", @env.config.vm.base_mac
+
+        # Modify the Vagrantfile and reload it, then verify new results
+        # are available
+        vagrantfile(@env.root_path, "config.vm.base_mac = 'set'")
+        @env.reload_config!
+        assert_equal "set", @env.config.vm.base_mac
+      end
     end
 
     context "loading home directory" do