vagrant 0.7.8 → 0.8.1

data/test/vagrant/action/warden_test.rb

@@ -1,4 +1,5 @@
 require "test_helper"
+require "logger"
 
 class ActionWardenTest < Test::Unit::TestCase
   setup do
@@ -8,11 +9,12 @@ class ActionWardenTest < Test::Unit::TestCase
 
   context "initializing" do
     should "finalize the middleware" do
+      env = new_env
       middleware = [1,2,3]
       middleware.each do |m|
-        @klass.any_instance.expects(:finalize_action).with(m, {}).returns(m)
+        @klass.any_instance.expects(:finalize_action).with(m, env).returns(m)
       end
-      @warden = @klass.new(middleware, new_env)
+      @warden = @klass.new(middleware, env)
       assert_equal @warden.actions, [1,2,3]
     end
   end
@@ -48,10 +50,11 @@ class ActionWardenTest < Test::Unit::TestCase
     end
 
     should "call the next action" do
+      env = new_env
       action = mock('action')
-      action.expects(:call).with({})
+      action.expects(:call).with(env)
       @instance.actions << action
-      @instance.call(new_env)
+      @instance.call(env)
     end
 
     should "begin recovery sequence when the called action raises an exception" do
@@ -97,18 +100,21 @@ class ActionWardenTest < Test::Unit::TestCase
 
   context "recover" do
     should "call recover on all items in the stack" do
+      env = new_env
       seq = sequence("sequence")
       @instance.stack = [rescueable_mock("action"), rescueable_mock("another")]
       @instance.stack.each do |action|
-        action.expects(:recover).with(new_env).in_sequence(seq)
+        action.expects(:recover).with(env).in_sequence(seq)
       end
 
-      @instance.begin_rescue(new_env)
+      @instance.begin_rescue(env)
     end
   end
 
   def new_env
-    Vagrant::Action::Environment.new(nil)
+    env = Vagrant::Action::Environment.new(nil)
+    env["logger"] = Logger.new(nil)
+    env
   end
 
   def rescueable_mock(name)

data/test/vagrant/config/vm_test.rb

@@ -54,28 +54,6 @@ class ConfigVMTest < Test::Unit::TestCase
     end
   end
 
-  context "uid/gid" do
-    should "return the shared folder UID if set" do
-      @config.shared_folder_uid = "foo"
-      assert_equal "foo", @config.shared_folder_uid
-    end
-
-    should "return the SSH username if UID not set" do
-      @config.shared_folder_uid = nil
-      assert_equal @username, @config.shared_folder_uid
-    end
-
-    should "return the shared folder GID if set" do
-      @config.shared_folder_gid = "foo"
-      assert_equal "foo", @config.shared_folder_gid
-    end
-
-    should "return the SSH username if GID not set" do
-      @config.shared_folder_gid = nil
-      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) {

data/test/vagrant/downloaders/http_test.rb

@@ -42,6 +42,8 @@ class HttpDownloaderTest < Test::Unit::TestCase
       h = mock("http")
       response = mock("response")
       response.stubs(:content_length)
+      response.stubs(:is_a?).with(anything).returns(false)
+      response.stubs(:is_a?).with(Net::HTTPOK).returns(true)
       segment = mock("segment")
       segment.stubs(:length).returns(7)
 

data/test/vagrant/environment_test.rb

@@ -1,5 +1,6 @@
 require "test_helper"
 require "pathname"
+require "tempfile"
 
 class EnvironmentTest < Test::Unit::TestCase
   setup do
@@ -57,6 +58,12 @@ class EnvironmentTest < Test::Unit::TestCase
     context "home path" do
       setup do
         @env = @klass.new
+
+        # Make a fake home directory for helping with tests
+        @home_path = tmp_path.join("home")
+        ENV["HOME"] = @home_path.to_s
+        FileUtils.rm_rf(@home_path)
+        FileUtils.mkdir_p(@home_path)
       end
 
       should "return the home path if it loaded" do
@@ -72,6 +79,36 @@ class EnvironmentTest < Test::Unit::TestCase
         expected = Pathname.new(File.expand_path(ENV["VAGRANT_HOME"]))
         assert_equal expected, @env.home_path
       end
+
+      should "move the old home directory to the new location" do
+        new_path = @home_path.join(".vagrant.d")
+        old_path = @home_path.join(".vagrant")
+        old_path.mkdir
+
+        # Get the home path
+        ENV["VAGRANT_HOME"] = new_path.to_s
+
+        assert !new_path.exist?
+        assert_equal new_path, @env.home_path
+        assert !old_path.exist?
+        assert new_path.exist?
+      end
+
+      should "not move the old home directory if the new one already exists" do
+        new_path = @home_path.join(".vagrant.d")
+        new_path.mkdir
+
+        old_path = @home_path.join(".vagrant")
+        old_path.mkdir
+
+        # Get the home path
+        ENV["VAGRANT_HOME"] = new_path.to_s
+
+        assert new_path.exist?
+        assert_equal new_path, @env.home_path
+        assert old_path.exist?
+        assert new_path.exist?
+      end
     end
 
     context "temp path" do
@@ -219,12 +256,9 @@ class EnvironmentTest < Test::Unit::TestCase
 
   context "loading logger" do
     should "lazy load the logger only once" do
-      result = Vagrant::Util::ResourceLogger.new("vagrant", vagrant_env)
-      Vagrant::Util::ResourceLogger.expects(:new).returns(result).once
       env = vagrant_env
-      assert_equal result, env.logger
-      assert_equal result, env.logger
-      assert_equal result, env.logger
+      result = env.logger
+      assert result === env.logger
     end
 
     should "return the parent's logger if a parent exists" do
@@ -233,10 +267,7 @@ class EnvironmentTest < Test::Unit::TestCase
         config.vm.define :db
       vf
 
-      result = env.logger
-
-      Vagrant::Util::ResourceLogger.expects(:new).never
-      assert env.vms[:web].env.logger.equal?(result)
+      assert env.logger === env.vms[:web].env.logger
     end
   end
 
@@ -248,20 +279,23 @@ class EnvironmentTest < Test::Unit::TestCase
                Pathname.new("/")
               ]
 
+      rootfile = "Foo"
+
       search_seq = sequence("search_seq")
       paths.each do |path|
-        File.expects(:exist?).with(path.join(@klass::ROOTFILE_NAME).to_s).returns(false).in_sequence(search_seq)
+        File.expects(:exist?).with(path.join(rootfile).to_s).returns(false).in_sequence(search_seq)
         File.expects(:exist?).with(path).returns(true).in_sequence(search_seq) if !path.root?
       end
 
-      assert !@klass.new(:cwd => paths.first).root_path
+      assert !@klass.new(:cwd => paths.first, :vagrantfile_name => rootfile).root_path
     end
 
     should "should set the path for the rootfile" do
+      rootfile = "Foo"
       path = Pathname.new(File.expand_path("/foo"))
-      File.expects(:exist?).with(path.join(@klass::ROOTFILE_NAME).to_s).returns(true)
+      File.expects(:exist?).with(path.join(rootfile).to_s).returns(true)
 
-      assert_equal path, @klass.new(:cwd => path).root_path
+      assert_equal path, @klass.new(:cwd => path, :vagrantfile_name => rootfile).root_path
     end
 
     should "not infinite loop on relative paths" do
@@ -269,8 +303,9 @@ class EnvironmentTest < Test::Unit::TestCase
     end
 
     should "only load the root path once" do
-      env = @klass.new
-      File.expects(:exist?).with(env.cwd.join(@klass::ROOTFILE_NAME).to_s).returns(true).once
+      rootfile = "foo"
+      env = @klass.new(:vagrantfile_name => rootfile)
+      File.expects(:exist?).with(env.cwd.join(rootfile).to_s).returns(true).once
 
       assert_equal env.cwd, env.root_path
       assert_equal env.cwd, env.root_path
@@ -287,6 +322,66 @@ class EnvironmentTest < Test::Unit::TestCase
     end
   end
 
+  context "locking" do
+    setup do
+      @instance = @klass.new(:lock_path => Tempfile.new('vagrant-test').path)
+    end
+
+    should "allow nesting locks" do
+      assert_nothing_raised do
+        @instance.lock do
+          @instance.lock do
+            # Nothing
+          end
+        end
+      end
+    end
+
+    should "raise an exception if an environment already has a lock" do
+      @another = @klass.new(:lock_path => @instance.lock_path)
+
+      # Create first locked thread which should succeed
+      first = Thread.new do
+        begin
+          @instance.lock do
+            Thread.current[:locked] = true
+            loop { sleep 1000 }
+          end
+        rescue Vagrant::Errors::EnvironmentLockedError
+          Thread.current[:locked] = false
+        end
+      end
+
+      # Wait until the first thread has acquired the lock
+      loop do
+        break if first[:locked] || !first.alive?
+        Thread.pass
+      end
+
+      # Verify that the fist got the lock
+      assert first[:locked]
+
+      # Create second locked thread which should fail
+      second = Thread.new do
+        begin
+          @another.lock do
+            Thread.current[:error] = false
+          end
+        rescue Vagrant::Errors::EnvironmentLockedError
+          Thread.current[:error] = true
+        end
+      end
+
+      # Wait for the second to end and verify it failed
+      second.join
+      assert second[:error]
+
+      # Make sure both threads are killed
+      first.kill
+      second.kill
+    end
+  end
+
   context "accessing the configuration" do
     should "load the environment if its not already loaded" do
       env = @klass.new(:cwd => vagrantfile)
@@ -430,11 +525,6 @@ class EnvironmentTest < Test::Unit::TestCase
         assert_equal "set", @env.vms[:web].env.config.vm.base_mac
       end
 
-      should "reload the logger after executing" do
-        @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'")
 

data/test/vagrant/provisioners/{chef_server_test.rb → chef_client_test.rb}

@@ -1,8 +1,8 @@
 require "test_helper"
 
-class ChefServerProvisionerTest < Test::Unit::TestCase
+class ChefClientProvisionerTest < Test::Unit::TestCase
   setup do
-    @klass = Vagrant::Provisioners::ChefServer
+    @klass = Vagrant::Provisioners::ChefClient
 
     @action_env = Vagrant::Action::Environment.new(vagrant_env.vms[:default].env)
 

data/test/vagrant/provisioners/chef_solo_test.rb

@@ -32,23 +32,6 @@ class ChefSoloProvisionerTest < Test::Unit::TestCase
     end
   end
 
-  context "preparing" do
-    should "share cookbook folders" do
-      @action.expects(:share_cookbook_folders).once
-      @action.prepare
-    end
-
-    should "share role folders" do
-      @action.expects(:share_role_folders).once
-      @action.prepare
-    end
-
-    should "share data bag folders" do
-      @action.expects(:share_data_bags_folders).once
-      @action.prepare
-    end
-  end
-
   context "provisioning" do
     should "run the proper sequence of methods in order" do
       prov_seq = sequence("prov_seq")
@@ -60,165 +43,24 @@ class ChefSoloProvisionerTest < Test::Unit::TestCase
       @action.provision!
     end
   end
-  context "sharing cookbook folders" do
-    setup do
-      @host_cookbook_paths = ["foo", "bar"]
-      @action.stubs(:host_cookbook_paths).returns(@host_cookbook_paths)
-    end
-
-    should "share each cookbook folder" do
-      share_seq = sequence("share_seq")
-      @host_cookbook_paths.each_with_index do |cookbook, i|
-        @env.config.vm.expects(:share_folder).with("v-csc-#{i}", @action.cookbook_path(i), cookbook, :nfs => false).in_sequence(share_seq)
-      end
-
-      @action.share_cookbook_folders
-    end
-  end
-
-  context "sharing role folders" do
-    setup do
-      @host_role_paths = ["foo", "bar"]
-      @action.stubs(:host_role_paths).returns(@host_role_paths)
-    end
-
-    should "share each role folder" do
-      share_seq = sequence("share_seq")
-      @host_role_paths.each_with_index do |role, i|
-        @env.config.vm.expects(:share_folder).with("v-csr-#{i}", @action.role_path(i), role, :nfs => false).in_sequence(share_seq)
-      end
-
-      @action.share_role_folders
-    end
-  end
-
-  context "sharing data bag folders" do
-    setup do
-      @host_data_bag_paths = ["foo", "bar"]
-      @action.stubs(:host_data_bag_paths).returns(@host_data_bag_paths)
-    end
-
-    should "share each data bag folder" do
-      share_seq = sequence("share_seq")
-      @host_data_bag_paths.each_with_index do |data_bag, i|
-        @env.config.vm.expects(:share_folder).with("v-csdb-#{i}", @action.data_bag_path(i), data_bag, :nfs => false).in_sequence(share_seq)
-      end
-
-      @action.share_data_bags_folders
-    end
-  end
-
-  context "host folder paths" do
-    should "ignore VM paths" do
-      assert @action.host_folder_paths([:vm, "foo"]).empty?
-    end
-
-    should "return as an array if was originally a string" do
-      folder = "foo"
-      File.stubs(:expand_path).returns("bar")
-      assert_equal ["bar"], @action.host_folder_paths(folder)
-    end
-
-    should "return the array of folders if its an array" do
-      folders = ["foo", "bar"]
-      expand_seq = sequence('expand_seq')
-      folders.collect! { |folder| File.expand_path(folder, @env.root_path) }
-
-      assert_equal folders, @action.host_folder_paths(folders)
-    end
-  end
 
-  context "host cookbooks paths" do
-    should "get folders path for configured cookbooks path" do
-      result = mock("result")
-      @config.stubs(:cookbooks_path).returns("foo")
-      @action.expects(:host_folder_paths).with(@config.cookbooks_path).returns(result)
-      assert_equal result, @action.host_cookbook_paths
+  context "creating expanded folder sets" do
+    should "expand VM folders properly" do
+      assert_equal [[:vm, nil, "/foo"]], @action.expanded_folders([:vm, "/foo"])
     end
-  end
-
-  context "host roles paths" do
-    should "get folders path for configured roles path" do
-      result = mock("result")
-      @config.stubs(:roles_path).returns("foo")
-      @action.expects(:host_folder_paths).with(@config.roles_path).returns(result)
-      assert_equal result, @action.host_role_paths
-    end
-  end
 
-  context "host data bags paths" do
-    should "get folders path for configured data bag path" do
-      result = mock("result")
-      @config.stubs(:data_bags_path).returns("foo")
-      @action.expects(:host_folder_paths).with(@config.data_bags_path).returns(result)
-      assert_equal result, @action.host_data_bag_paths
+    should "expand host folders properly" do
+      path = "foo"
+      local_path = File.expand_path(path, @env.root_path)
+      remote_path = "#{@action.config.provisioning_path}/chef-solo-0"
+      assert_equal [[:host, local_path, remote_path]], @action.expanded_folders([:host, path])
     end
   end
 
-  context "folder path" do
-    should "return a proper path to a single folder" do
-      expected = File.join(@config.provisioning_path, "cookbooks-5")
-      assert_equal expected, @action.folder_path("cookbooks", 5)
-    end
-
-    should "return array-representation of folder paths if multiple" do
-      @folders = (0..5).to_a
-      @cookbooks = @folders.inject([]) do |acc, i|
-        acc << @action.cookbook_path(i)
-      end
-
-      assert_equal @cookbooks, @action.folders_path(@folders, "cookbooks")
-    end
-
-    should "return a single string representation if folder paths is single" do
-      @folder = "cookbooks"
-      @cookbooks = @action.folder_path(@folder, 0)
-
-      assert_equal @cookbooks, @action.folders_path([0], @folder)
-    end
-
-    should "properly format VM folder paths" do
-      @config.provisioning_path = "/foo"
-      assert_equal "/foo/bar", @action.folders_path([:vm, "bar"], nil)
-    end
-  end
-
-  context "cookbooks path" do
-    should "return a proper path to a single cookbook" do
-      expected = File.join(@config.provisioning_path, "cookbooks-5")
-      assert_equal expected, @action.cookbook_path(5)
-    end
-
-    should "properly call folders path and return result" do
-      result = [:a, :b, :c]
-      @action.expects(:folders_path).with(@config.cookbooks_path, "cookbooks").once.returns(result)
-      assert_equal result.to_json, @action.cookbooks_path
-    end
-  end
-
-  context "roles path" do
-    should "return a proper path to a single role" do
-      expected = File.join(@config.provisioning_path, "roles-5")
-      assert_equal expected, @action.role_path(5)
-    end
-
-    should "properly call folders path and return result" do
-      result = [:a, :b, :c]
-      @action.expects(:folders_path).with(@config.roles_path, "roles").once.returns(result)
-      assert_equal result.to_json, @action.roles_path
-    end
-  end
-
-  context "data bags path" do
-    should "return a proper path to a single data bag" do
-      expected = File.join(@config.provisioning_path, "data_bags-5")
-      assert_equal expected, @action.data_bag_path(5)
-    end
-
-    should "properly call folders path and return result" do
-      result = [:a, :b, :c]
-      @action.expects(:folders_path).with(@config.data_bags_path, "data_bags").once.returns(result)
-      assert_equal result.to_json, @action.data_bags_path
+  context "guest paths" do
+    should "extract the parts properly" do
+      structure = [[1,2,3],[1,2,3]]
+      assert_equal [3,3], @action.guest_paths(structure)
     end
   end
 
@@ -227,16 +69,17 @@ class ChefSoloProvisionerTest < Test::Unit::TestCase
       @vm.ssh.stubs(:upload!)
 
       @config.recipe_url = "foo/bar/baz"
+      @action.prepare
     end
 
     should "call setup_config with proper variables" do
       @action.expects(:setup_config).with("chef_solo_solo", "solo.rb", {
         :node_name => @config.node_name,
         :provisioning_path => @config.provisioning_path,
-        :cookbooks_path => @action.cookbooks_path,
+        :cookbooks_path => @action.guest_paths(@action.cookbook_folders),
         :recipe_url => @config.recipe_url,
-        :roles_path => @action.roles_path,
-        :data_bags_path => @action.data_bags_path
+        :roles_path => @action.guest_paths(@action.role_folders),
+        :data_bags_path => @action.guest_paths(@action.data_bags_folders)
       })
 
       @action.setup_solo_config