chef 10.34.6-x86-mingw32 → 11.6.2-x86-mingw32

data/spec/functional/resource/git_spec.rb

@@ -0,0 +1,259 @@
+#
+# Author:: Seth Falcon (<seth@opscode.com>)
+# Copyright:: Copyright (c) 2013 Opscode, Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require 'spec_helper'
+require 'chef/mixin/shell_out'
+require 'tmpdir'
+require 'shellwords'
+
+# Deploy relies heavily on symlinks, so it doesn't work on windows.
+describe Chef::Resource::Git do
+  include Chef::Mixin::ShellOut
+  let(:file_cache_path) { Dir.mktmpdir }
+  # Some versions of git complains when the deploy directory is
+  # already created. Here we intentionally don't create the deploy
+  # directory beforehand.
+  let(:base_dir_path) { Dir.mktmpdir }
+  let(:deploy_directory) { File.join(base_dir_path, make_tmpname("git_base")) }
+
+  let(:node) do
+    Chef::Node.new.tap do |n|
+      n.name "rspec-test"
+      n.consume_external_attrs(@ohai.data, {})
+    end
+  end
+
+  let(:event_dispatch) { Chef::EventDispatch::Dispatcher.new }
+  let(:run_context) { Chef::RunContext.new(node, {}, event_dispatch) }
+
+  # These tests use git's bundle feature, which is a way to export an entire
+  # git repo (or subset of commits) as a single file.
+  #
+  # Generally you can treat a git bundle as a regular git remote.
+  #
+  # See also: http://git-scm.com/2010/03/10/bundles.html
+  #
+  # Beware that git bundles don't behave exactly the same as real
+  # remotes. To get closer to real remotes, we'll create a local clone
+  # of the bundle to use as a remote for the tests. This at least
+  # gives the expected responses for ls-remote using git version
+  # 1.7.12.4
+  let(:git_bundle_repo) { File.expand_path("git_bundles/example-repo.gitbundle", CHEF_SPEC_DATA) }
+  let(:origin_repo_dir) { Dir.mktmpdir }
+  let(:origin_repo) { "#{origin_repo_dir}/example" }
+
+  # This is the fourth version
+  let(:v1_commit) { "bc5ec79931ae74089aeadca6edc173527613e6d9" }
+  let(:v1_tag) { "9b73fb5e316bfaff7b822b0ccb3e1e08f9885085" }
+  let(:rev_foo) { "ed181b3419b6f489bedab282348162a110d6d3a1" }
+  let(:rev_testing) { "972d153654503bccec29f630c5dd369854a561e8" }
+  let(:rev_head) { "d294fbfd05aa7709ad9a9b8ef6343b17d355bf5f"}
+
+  let(:git_user_config) do
+    <<-E
+[user]
+  name = frodoTbaggins
+  email = frodo@shire.org
+E
+  end
+
+  before(:each) do
+    Chef::Log.level = :warn # silence git command live streams
+    @old_file_cache_path = Chef::Config[:file_cache_path]
+    shell_out!("git clone \"#{git_bundle_repo}\" example", :cwd => origin_repo_dir)
+    File.open("#{origin_repo}/.git/config", "a+") {|f| f.print(git_user_config) }
+    Chef::Config[:file_cache_path] = file_cache_path
+  end
+
+  after(:each) do
+    Chef::Config[:file_cache_path] = @old_file_cache_path
+    FileUtils.remove_entry_secure deploy_directory if File.exist?(deploy_directory)
+    FileUtils.remove_entry_secure file_cache_path
+  end
+
+  after(:all) do
+    FileUtils.remove_entry_secure origin_repo_dir
+  end
+
+  before(:all) do
+    @ohai = Ohai::System.new
+    @ohai.require_plugin("os")
+  end
+
+  context "working with pathes with special characters" do
+    let(:path_with_spaces) { "#{origin_repo_dir}/path with spaces" }
+
+    before(:each) do
+      FileUtils.mkdir(path_with_spaces)
+      FileUtils.cp(git_bundle_repo, path_with_spaces)
+    end
+
+    it "clones a repository with a space in the path" do
+      Chef::Resource::Git.new(deploy_directory, run_context).tap do |r|
+        r.repository "#{path_with_spaces}/example-repo.gitbundle"
+      end.run_action(:sync)
+    end
+  end
+
+  context "when deploying from an annotated tag" do
+    let(:basic_git_resource) do
+      Chef::Resource::Git.new(deploy_directory, run_context).tap do |r|
+        r.repository origin_repo
+        r.revision "v1.0.0"
+      end
+    end
+
+    # We create a copy of the basic_git_resource so that we can run
+    # the resource again and verify that it doesn't update.
+    let(:copy_git_resource) do
+      Chef::Resource::Git.new(deploy_directory, run_context).tap do |r|
+        r.repository origin_repo
+        r.revision "v1.0.0"
+      end
+    end
+
+    it "checks out the revision pointed to by the tag commit, not the tag commit itself" do
+      basic_git_resource.run_action(:sync)
+      head_rev = shell_out!('git rev-parse HEAD', :cwd => deploy_directory, :returns => [0]).stdout.strip
+      head_rev.should == v1_commit
+      # also verify the tag commit itself is what we expect as an extra sanity check
+      rev = shell_out!('git rev-parse v1.0.0', :cwd => deploy_directory, :returns => [0]).stdout.strip
+      rev.should == v1_tag
+    end
+
+    it "doesn't update if up-to-date" do
+      # this used to fail because we didn't resolve the annotated tag
+      # properly to the pointed to commit.
+      basic_git_resource.run_action(:sync)
+      head_rev = shell_out!('git rev-parse HEAD', :cwd => deploy_directory, :returns => [0]).stdout.strip
+      head_rev.should == v1_commit
+
+      copy_git_resource.run_action(:sync)
+      copy_git_resource.should_not be_updated
+    end
+  end
+
+  context "when deploying from a SHA revision" do
+    let(:basic_git_resource) do
+      Chef::Resource::Git.new(deploy_directory, run_context).tap do |r|
+        r.repository git_bundle_repo
+      end
+    end
+
+    # We create a copy of the basic_git_resource so that we can run
+    # the resource again and verify that it doesn't update.
+    let(:copy_git_resource) do
+      Chef::Resource::Git.new(deploy_directory, run_context).tap do |r|
+        r.repository origin_repo
+      end
+    end
+
+    it "checks out the expected revision ed18" do
+      basic_git_resource.revision rev_foo
+      basic_git_resource.run_action(:sync)
+      head_rev = shell_out!('git rev-parse HEAD', :cwd => deploy_directory, :returns => [0]).stdout.strip
+      head_rev.should == rev_foo
+    end
+
+    it "doesn't update if up-to-date" do
+      basic_git_resource.revision rev_foo
+      basic_git_resource.run_action(:sync)
+      head_rev = shell_out!('git rev-parse HEAD', :cwd => deploy_directory, :returns => [0]).stdout.strip
+      head_rev.should == rev_foo
+
+      copy_git_resource.revision rev_foo
+      copy_git_resource.run_action(:sync)
+      copy_git_resource.should_not be_updated
+    end
+
+    it "checks out the expected revision 972d" do
+      basic_git_resource.revision rev_testing
+      basic_git_resource.run_action(:sync)
+      head_rev = shell_out!('git rev-parse HEAD', :cwd => deploy_directory, :returns => [0]).stdout.strip
+      head_rev.should == rev_testing
+    end
+  end
+
+  context "when deploying from a revision named 'HEAD'" do
+    let(:basic_git_resource) do
+      Chef::Resource::Git.new(deploy_directory, run_context).tap do |r|
+        r.repository origin_repo
+        r.revision 'HEAD'
+      end
+    end
+
+    it "checks out the expected revision" do
+      basic_git_resource.run_action(:sync)
+      head_rev = shell_out!('git rev-parse HEAD', :cwd => deploy_directory, :returns => [0]).stdout.strip
+      head_rev.should == rev_head
+    end
+  end
+
+  context "when deploying from the default revision" do
+    let(:basic_git_resource) do
+      Chef::Resource::Git.new(deploy_directory, run_context).tap do |r|
+        r.repository origin_repo
+        # use default
+      end
+    end
+
+    it "checks out HEAD as the default revision" do
+      basic_git_resource.run_action(:sync)
+      head_rev = shell_out!('git rev-parse HEAD', :cwd => deploy_directory, :returns => [0]).stdout.strip
+      head_rev.should == rev_head
+    end
+  end
+
+  context "when dealing with a repo with a degenerate tag named 'HEAD'" do
+    before do
+      shell_out!("git tag -m\"degenerate tag\" HEAD ed181b3419b6f489bedab282348162a110d6d3a1",
+                 :cwd => origin_repo)
+    end
+
+    let(:basic_git_resource) do
+      Chef::Resource::Git.new(deploy_directory, run_context).tap do |r|
+        r.repository origin_repo
+        r.revision 'HEAD'
+      end
+    end
+
+    let(:git_resource_default_rev) do
+      Chef::Resource::Git.new(deploy_directory, run_context).tap do |r|
+        r.repository origin_repo
+        # use default of revision
+      end
+    end
+
+    it "checks out the (master) HEAD revision and ignores the tag" do
+      basic_git_resource.run_action(:sync)
+      head_rev = shell_out!('git rev-parse HEAD',
+                            :cwd => deploy_directory,
+                            :returns => [0]).stdout.strip
+      head_rev.should == rev_head
+    end
+
+    it "checks out the (master) HEAD revision when no revision is specified (ignores tag)" do
+      git_resource_default_rev.run_action(:sync)
+      head_rev = shell_out!('git rev-parse HEAD',
+                            :cwd => deploy_directory,
+                            :returns => [0]).stdout.strip
+      head_rev.should == rev_head
+    end
+
+  end
+end

data/spec/functional/resource/link_spec.rb

@@ -22,35 +22,56 @@ if windows?
   require 'chef/win32/file' #probably need this in spec_helper
 end
 
-describe Chef::Resource::Link, :not_supported_on_win2k3 do
+describe Chef::Resource::Link do
   let(:file_base) { "file_spec" }
 
-  let(:base_dir) do
+  let(:expect_updated?) {true}
+
+  # We create the files in a different directory than tmp to exercise
+  # different file deployment strategies more completely.
+  let(:test_file_dir) do
     if windows?
-      Chef::ReservedNames::Win32::File.get_long_path_name(Dir.tmpdir.gsub('/', '\\'))
+      File.join(ENV['systemdrive'], "test-dir")
     else
-      Dir.tmpdir
+      File.join(CHEF_SPEC_DATA, "test-dir")
     end
   end
 
+  before do
+    FileUtils::mkdir_p(test_file_dir)
+  end
+
+  after do
+    FileUtils::rm_rf(test_file_dir)
+  end
+
   let(:to) do
-    File.join(base_dir, make_tmpname("to_spec", nil))
+    File.join(test_file_dir, make_tmpname("to_spec"))
   end
   let(:target_file) do
-    File.join(base_dir, make_tmpname("from_spec", nil))
+    File.join(test_file_dir, make_tmpname("from_spec"))
   end
 
   after(:each) do
-    # TODO Windows fails to clean up some symlinks.
     begin
-      FileUtils.rm_r(to) if File.exists?(to)
-      FileUtils.rm_r(target_file) if File.exists?(target_file)
-      FileUtils.rm_r(CHEF_SPEC_BACKUP_PATH) if File.exists?(CHEF_SPEC_BACKUP_PATH)
+      cleanup_link(to) if File.exists?(to)
+      cleanup_link(target_file) if File.exists?(target_file)
+      cleanup_link(CHEF_SPEC_BACKUP_PATH) if File.exists?(CHEF_SPEC_BACKUP_PATH)
     rescue
       puts "Could not remove a file: #{$!}"
     end
   end
 
+  def cleanup_link(path)
+    if windows? && File.directory?(path)
+      # If the link target is a directory rm_rf doesn't work all the
+      # time on windows.
+      system "rmdir '#{path}'"
+    else
+      FileUtils.rm_rf(path)
+    end
+  end
+
   def canonicalize(path)
     windows? ? path.gsub('/', '\\') : path
   end
@@ -95,478 +116,493 @@ describe Chef::Resource::Link, :not_supported_on_win2k3 do
     resource
   end
 
-  let!(:resource) do
+  let(:resource) do
     create_resource
   end
 
-  shared_examples_for 'delete errors out' do
-    it 'delete errors out' do
-      lambda { resource.run_action(:delete) }.should raise_error(Chef::Exceptions::Link)
-      (File.exist?(target_file) || symlink?(target_file)).should be_true
+  describe "when supported on platform", :not_supported_on_win2k3 do
+    shared_examples_for 'delete errors out' do
+      it 'delete errors out' do
+        lambda { resource.run_action(:delete) }.should raise_error(Chef::Exceptions::Link)
+        (File.exist?(target_file) || symlink?(target_file)).should be_true
+      end
     end
-  end
 
-  shared_context 'delete is noop' do
-    describe 'the :delete action' do
-      before(:each) do
-        @info = []
-        Chef::Log.stub!(:info) { |msg| @info << msg }
-        resource.run_action(:delete)
-      end
+    shared_context 'delete is noop' do
+      describe 'the :delete action' do
+        before(:each) do
+          @info = []
+          Chef::Log.stub!(:info) { |msg| @info << msg }
+          resource.run_action(:delete)
+        end
 
-      it 'leaves the file deleted' do
-        File.exist?(target_file).should be_false
-        symlink?(target_file).should be_false
-      end
-      it 'does not mark the resource updated' do
-        resource.should_not be_updated
-      end
-      it 'does not log that it deleted' do
-        @info.include?("link[#{target_file}] deleted").should be_false
+        it 'leaves the file deleted' do
+          File.exist?(target_file).should be_false
+          symlink?(target_file).should be_false
+        end
+        it 'does not mark the resource updated' do
+          resource.should_not be_updated
+        end
+        it 'does not log that it deleted' do
+          @info.include?("link[#{target_file}] deleted").should be_false
+        end
       end
     end
-  end
 
-  shared_context 'delete succeeds' do
-    describe 'the :delete action' do
-      before(:each) do
-        @info = []
-        Chef::Log.stub!(:info) { |msg| @info << msg }
-        resource.run_action(:delete)
-      end
+    shared_context 'delete succeeds' do
+      describe 'the :delete action' do
+        before(:each) do
+          @info = []
+          Chef::Log.stub!(:info) { |msg| @info << msg }
+          resource.run_action(:delete)
+        end
 
-      it 'deletes the file' do
-        File.exist?(target_file).should be_false
-        symlink?(target_file).should be_false
-      end
-      it 'marks the resource updated' do
-        resource.should be_updated
-      end
-      it 'logs that it deleted' do
-        @info.include?("link[#{target_file}] deleted").should be_true
+        it 'deletes the file' do
+          File.exist?(target_file).should be_false
+          symlink?(target_file).should be_false
+        end
+        it 'marks the resource updated' do
+          resource.should be_updated
+        end
+        it 'logs that it deleted' do
+          @info.include?("link[#{target_file}] deleted").should be_true
+        end
       end
     end
-  end
 
-  shared_context 'create symbolic link succeeds' do
-    describe 'the :create action' do
-      before(:each) do
-        @info = []
-        Chef::Log.stub!(:info) { |msg| @info << msg }
-        resource.run_action(:create)
-      end
+    shared_context 'create symbolic link succeeds' do
+      describe 'the :create action' do
+        before(:each) do
+          @info = []
+          Chef::Log.stub!(:info) { |msg| @info << msg }
+          resource.run_action(:create)
+        end
 
-      it 'links to the target file' do
-        symlink?(target_file).should be_true
-        readlink(target_file).should == canonicalize(to)
-      end
-      it 'marks the resource updated' do
-        resource.should be_updated
-      end
-      it 'logs that it created' do
-        @info.include?("link[#{target_file}] created").should be_true
+        it 'links to the target file' do
+          symlink?(target_file).should be_true
+          readlink(target_file).should == canonicalize(to)
+        end
+        it 'marks the resource updated' do
+          resource.should be_updated
+        end
+        it 'logs that it created' do
+          @info.include?("link[#{target_file}] created").should be_true
+        end
       end
     end
-  end
 
-  shared_context 'create symbolic link is noop' do
-    describe 'the :create action' do
-      before(:each) do
-        @info = []
-        Chef::Log.stub!(:info) { |msg| @info << msg }
-        resource.run_action(:create)
-      end
+    shared_context 'create symbolic link is noop' do
+      describe 'the :create action' do
+        before(:each) do
+          @info = []
+          Chef::Log.stub!(:info) { |msg| @info << msg }
+          resource.run_action(:create)
+        end
 
-      it 'leaves the file linked' do
-        symlink?(target_file).should be_true
-        readlink(target_file).should == canonicalize(to)
-      end
-      it 'does not mark the resource updated' do
-        resource.should_not be_updated
-      end
-      it 'does not log that it created' do
-        @info.include?("link[#{target_file}] created").should be_false
+        it 'leaves the file linked' do
+          symlink?(target_file).should be_true
+          readlink(target_file).should == canonicalize(to)
+        end
+        it 'does not mark the resource updated' do
+          resource.should_not be_updated
+        end
+        it 'does not log that it created' do
+          @info.include?("link[#{target_file}] created").should be_false
+        end
       end
     end
-  end
 
-  shared_context 'create hard link succeeds' do
-    describe 'the :create action' do
-      before(:each) do
-        @info = []
-        Chef::Log.stub!(:info) { |msg| @info << msg }
-        resource.run_action(:create)
-      end
-      it 'preserves the hard link' do
-        File.exists?(target_file).should be_true
-        symlink?(target_file).should be_false
-        # Writing to one hardlinked file should cause both
-        # to have the new value.
-        IO.read(to).should == IO.read(target_file)
-        File.open(to, "w") { |file| file.write('wowzers') }
-        IO.read(target_file).should == 'wowzers'
-      end
-      it 'marks the resource updated' do
-        resource.should be_updated
-      end
-      it 'logs that it created' do
-        @info.include?("link[#{target_file}] created").should be_true
+    shared_context 'create hard link succeeds' do
+      describe 'the :create action' do
+        before(:each) do
+          @info = []
+          Chef::Log.stub!(:info) { |msg| @info << msg }
+          resource.run_action(:create)
+        end
+        it 'preserves the hard link' do
+          File.exists?(target_file).should be_true
+          symlink?(target_file).should be_false
+          # Writing to one hardlinked file should cause both
+          # to have the new value.
+          IO.read(to).should == IO.read(target_file)
+          File.open(to, "w") { |file| file.write('wowzers') }
+          IO.read(target_file).should == 'wowzers'
+        end
+        it 'marks the resource updated' do
+          resource.should be_updated
+        end
+        it 'logs that it created' do
+          @info.include?("link[#{target_file}] created").should be_true
+        end
       end
     end
-  end
 
-  shared_context 'create hard link is noop' do
-    describe 'the :create action' do
-      before(:each) do
-        @info = []
-        Chef::Log.stub!(:info) { |msg| @info << msg }
-        resource.run_action(:create)
-      end
-      it 'links to the target file' do
-        File.exists?(target_file).should be_true
-        symlink?(target_file).should be_false
-        # Writing to one hardlinked file should cause both
-        # to have the new value.
-        IO.read(to).should == IO.read(target_file)
-        File.open(to, "w") { |file| file.write('wowzers') }
-        IO.read(target_file).should == 'wowzers'
-      end
-      it 'does not mark the resource updated' do
-        resource.should_not be_updated
-      end
-      it 'does not log that it created' do
-        @info.include?("link[#{target_file}] created").should be_false
+    shared_context 'create hard link is noop' do
+      describe 'the :create action' do
+        before(:each) do
+          @info = []
+          Chef::Log.stub!(:info) { |msg| @info << msg }
+          resource.run_action(:create)
+        end
+        it 'links to the target file' do
+          File.exists?(target_file).should be_true
+          symlink?(target_file).should be_false
+          # Writing to one hardlinked file should cause both
+          # to have the new value.
+          IO.read(to).should == IO.read(target_file)
+          File.open(to, "w") { |file| file.write('wowzers') }
+          IO.read(target_file).should == 'wowzers'
+        end
+        it 'does not mark the resource updated' do
+          resource.should_not be_updated
+        end
+        it 'does not log that it created' do
+          @info.include?("link[#{target_file}] created").should be_false
+        end
       end
     end
-  end
 
-  context "is symbolic" do
+    context "is symbolic" do
 
-    context 'when the link destination is a file' do
-      before(:each) do
-        File.open(to, "w") do |file|
-          file.write('woohoo')
+      context 'when the link destination is a file' do
+        before(:each) do
+          File.open(to, "w") do |file|
+            file.write('woohoo')
+          end
         end
-      end
-      context 'and the link does not yet exist' do
-        include_context 'create symbolic link succeeds'
-        include_context 'delete is noop'
-      end
-      context 'and the link already exists and is a symbolic link' do
-        context 'pointing at the target' do
-          before(:each) do
-            symlink(to, target_file)
-            symlink?(target_file).should be_true
-            readlink(target_file).should == canonicalize(to)
+        context 'and the link does not yet exist' do
+          include_context 'create symbolic link succeeds'
+          include_context 'delete is noop'
+        end
+        context 'and the link already exists and is a symbolic link' do
+          context 'pointing at the target' do
+            before(:each) do
+              symlink(to, target_file)
+              symlink?(target_file).should be_true
+              readlink(target_file).should == canonicalize(to)
+            end
+            include_context 'create symbolic link is noop'
+            include_context 'delete succeeds'
+            it 'the :delete action does not delete the target file' do
+              resource.run_action(:delete)
+              File.exists?(to).should be_true
+            end
           end
-          include_context 'create symbolic link is noop'
-          include_context 'delete succeeds'
-          it 'the :delete action does not delete the target file' do
-            resource.run_action(:delete)
-            File.exists?(to).should be_true
+          context 'pointing somewhere else' do
+            before(:each) do
+              @other_target = File.join(test_file_dir, make_tmpname('other_spec'))
+              File.open(@other_target, 'w') { |file| file.write('eek') }
+              symlink(@other_target, target_file)
+              symlink?(target_file).should be_true
+              readlink(target_file).should == canonicalize(@other_target)
+            end
+            after(:each) do
+              File.delete(@other_target)
+            end
+            include_context 'create symbolic link succeeds'
+            include_context 'delete succeeds'
+            it 'the :delete action does not delete the target file' do
+              resource.run_action(:delete)
+              File.exists?(to).should be_true
+            end
+          end
+          context 'pointing nowhere' do
+            before(:each) do
+              nonexistent = File.join(test_file_dir, make_tmpname('nonexistent_spec'))
+              symlink(nonexistent, target_file)
+              symlink?(target_file).should be_true
+              readlink(target_file).should == canonicalize(nonexistent)
+            end
+            include_context 'create symbolic link succeeds'
+            include_context 'delete succeeds'
           end
         end
-        context 'pointing somewhere else' do
+        context 'and the link already exists and is a hard link to the file' do
           before(:each) do
-            @other_target = File.join(base_dir, make_tmpname('other_spec', nil))
-            File.open(@other_target, 'w') { |file| file.write('eek') }
-            symlink(@other_target, target_file)
-            symlink?(target_file).should be_true
-            readlink(target_file).should == @other_target
-          end
-          after(:each) do
-            File.delete(@other_target)
+            link(to, target_file)
+            File.exists?(target_file).should be_true
+            symlink?(target_file).should be_false
           end
           include_context 'create symbolic link succeeds'
-          include_context 'delete succeeds'
-          it 'the :delete action does not delete the target file' do
-            resource.run_action(:delete)
-            File.exists?(to).should be_true
-          end
+          it_behaves_like 'delete errors out'
         end
-        context 'pointing nowhere' do
+        context 'and the link already exists and is a file' do
           before(:each) do
-            nonexistent = File.join(base_dir, make_tmpname('nonexistent_spec', nil))
-            symlink(nonexistent, target_file)
-            symlink?(target_file).should be_true
-            readlink(target_file).should == nonexistent
+            File.open(target_file, 'w') { |file| file.write('eek') }
           end
           include_context 'create symbolic link succeeds'
-          include_context 'delete succeeds'
+          it_behaves_like 'delete errors out'
         end
-      end
-      context 'and the link already exists and is a hard link to the file' do
-        before(:each) do
-          link(to, target_file)
-          File.exists?(target_file).should be_true
-          symlink?(target_file).should be_false
+        context 'and the link already exists and is a directory' do
+          before(:each) do
+            Dir.mkdir(target_file)
+          end
+          it 'create errors out' do
+            if windows?
+              lambda { resource.run_action(:create) }.should raise_error(Errno::EACCES)
+            elsif os_x? or solaris? or freebsd?
+              lambda { resource.run_action(:create) }.should raise_error(Errno::EPERM)
+            else
+              lambda { resource.run_action(:create) }.should raise_error(Errno::EISDIR)
+            end
+          end
+          it_behaves_like 'delete errors out'
         end
-        include_context 'create symbolic link succeeds'
-        it_behaves_like 'delete errors out'
-      end
-      context 'and the link already exists and is a file' do
-        before(:each) do
-          File.open(target_file, 'w') { |file| file.write('eek') }
+        context 'and the link already exists and is not writeable to this user', :pending do
+        end
+        it_behaves_like 'a securable resource without existing target' do
+          let(:path) { target_file }
+          def allowed_acl(sid, expected_perms)
+            [ ACE.access_allowed(sid, expected_perms[:specific]) ]
+          end
+          def denied_acl(sid, expected_perms)
+            [ ACE.access_denied(sid, expected_perms[:specific]) ]
+          end
+          def parent_inheritable_acls
+            dummy_file_path = File.join(test_file_dir, "dummy_file")
+            dummy_file = FileUtils.touch(dummy_file_path)
+            dummy_desc = get_security_descriptor(dummy_file_path)
+            FileUtils.rm_rf(dummy_file_path)
+            dummy_desc
+          end
         end
-        include_context 'create symbolic link succeeds'
-        it_behaves_like 'delete errors out'
       end
-      context 'and the link already exists and is a directory' do
+      context 'when the link destination is a directory' do
         before(:each) do
-          Dir.mkdir(target_file)
+          Dir.mkdir(to)
         end
-        it 'create errors out' do
-          if windows?
-            lambda { resource.run_action(:create) }.should raise_error(Errno::EACCES)
-          elsif os_x? or solaris? or freebsd?
-            lambda { resource.run_action(:create) }.should raise_error(Errno::EPERM)
-          else
-            lambda { resource.run_action(:create) }.should raise_error(Errno::EISDIR)
-          end
+        # On Windows, readlink fails to open the link.  FILE_FLAG_OPEN_REPARSE_POINT
+        # might help, from http://msdn.microsoft.com/en-us/library/windows/desktop/aa363858(v=vs.85).aspx
+        context 'and the link does not yet exist' do
+          include_context 'create symbolic link succeeds'
+          include_context 'delete is noop'
         end
-        it_behaves_like 'delete errors out'
       end
-      context 'and the link already exists and is not writeable to this user', :pending do
-      end
-      it_behaves_like 'a securable resource' do
-        let(:path) { target_file }
-        def allowed_acl(sid, expected_perms)
-          [ ACE.access_allowed(sid, expected_perms[:specific]) ]
+      context "when the link destination is a symbolic link" do
+        context 'to a file that exists' do
+          before(:each) do
+            @other_target = File.join(test_file_dir, make_tmpname("other_spec"))
+            File.open(@other_target, "w") { |file| file.write("eek") }
+            symlink(@other_target, to)
+            symlink?(to).should be_true
+            readlink(to).should == canonicalize(@other_target)
+          end
+          after(:each) do
+            File.delete(@other_target)
+          end
+          context 'and the link does not yet exist' do
+            include_context 'create symbolic link succeeds'
+            include_context 'delete is noop'
+          end
         end
-        def denied_acl(sid, expected_perms)
-          [ ACE.access_denied(sid, expected_perms[:specific]) ]
+        context 'to a file that does not exist' do
+          before(:each) do
+            @other_target = File.join(test_file_dir, make_tmpname("other_spec"))
+            symlink(@other_target, to)
+            symlink?(to).should be_true
+            readlink(to).should == canonicalize(@other_target)
+          end
+          context 'and the link does not yet exist' do
+            include_context 'create symbolic link succeeds'
+            include_context 'delete is noop'
+          end
         end
       end
-    end
-    context 'when the link destination is a directory' do
-      before(:each) do
-        Dir.mkdir(to)
+      context "when the link destination is not readable to this user", :pending do
       end
-      # On Windows, readlink fails to open the link.  FILE_FLAG_OPEN_REPARSE_POINT
-      # might help, from http://msdn.microsoft.com/en-us/library/windows/desktop/aa363858(v=vs.85).aspx
-      context 'and the link does not yet exist' do
+      context "when the link destination does not exist" do
         include_context 'create symbolic link succeeds'
         include_context 'delete is noop'
       end
-    end
-    context "when the link destination is a symbolic link" do
-      context 'to a file that exists' do
-        before(:each) do
-          @other_target = File.join(base_dir, make_tmpname("other_spec", nil))
-          File.open(@other_target, "w") { |file| file.write("eek") }
-          symlink(@other_target, to)
-          symlink?(to).should be_true
-          readlink(to).should == @other_target
-        end
-        after(:each) do
-          File.delete(@other_target)
-        end
-        context 'and the link does not yet exist' do
-          include_context 'create symbolic link succeeds'
-          include_context 'delete is noop'
-        end
-      end
-      context 'to a file that does not exist' do
-        before(:each) do
-          @other_target = File.join(base_dir, make_tmpname("other_spec", nil))
-          symlink(@other_target, to)
-          symlink?(to).should be_true
-          readlink(to).should == @other_target
-        end
-        context 'and the link does not yet exist' do
-          include_context 'create symbolic link succeeds'
-          include_context 'delete is noop'
+
+      {
+        '../' => 'with a relative link destination',
+        '' => 'with a bare filename for the link destination'
+      }.each do |prefix, desc|
+        context desc do
+          let(:to) { "#{prefix}#{File.basename(absolute_to)}" }
+          let(:absolute_to) { File.join(test_file_dir, make_tmpname("to_spec")) }
+          before(:each) do
+            resource.to(to)
+          end
+          context 'when the link does not yet exist' do
+            include_context 'create symbolic link succeeds'
+            include_context 'delete is noop'
+          end
+          context 'when the link already exists and points at the target' do
+            before(:each) do
+              symlink(to, target_file)
+              symlink?(target_file).should be_true
+              readlink(target_file).should == canonicalize(to)
+            end
+            include_context 'create symbolic link is noop'
+            include_context 'delete succeeds'
+          end
+          context 'when the link already exists and points at the target with an absolute path' do
+            before(:each) do
+              symlink(absolute_to, target_file)
+              symlink?(target_file).should be_true
+              readlink(target_file).should == canonicalize(absolute_to)
+            end
+            include_context 'create symbolic link succeeds'
+            include_context 'delete succeeds'
+          end
         end
       end
     end
-    context "when the link destination is not readable to this user", :pending do
-    end
-    context "when the link destination does not exist" do
-      include_context 'create symbolic link succeeds'
-      include_context 'delete is noop'
-    end
 
-    {
-      '../' => 'with a relative link destination',
-      '' => 'with a bare filename for the link destination'
-    }.each do |prefix, desc|
-      context desc do
-        let(:to) { "#{prefix}#{File.basename(absolute_to)}" }
-        let(:absolute_to) { File.join(base_dir, make_tmpname("to_spec", nil)) }
+    context "is a hard link" do
+      before(:each) do
+        resource.link_type(:hard)
+      end
+
+      context "when the link destination is a file" do
         before(:each) do
-          resource.to(to)
+          File.open(to, "w") do |file|
+            file.write('woohoo')
+          end
         end
-        context 'when the link does not yet exist' do
-          include_context 'create symbolic link succeeds'
+        context "and the link does not yet exist" do
+          include_context 'create hard link succeeds'
           include_context 'delete is noop'
         end
-        context 'when the link already exists and points at the target' do
+        context "and the link already exists and is a symbolic link pointing at the same file" do
           before(:each) do
             symlink(to, target_file)
             symlink?(target_file).should be_true
             readlink(target_file).should == canonicalize(to)
           end
-          include_context 'create symbolic link is noop'
-          include_context 'delete succeeds'
+          include_context 'create hard link succeeds'
+          it_behaves_like 'delete errors out'
         end
-        context 'when the link already exists and points at the target with an absolute path' do
+        context 'and the link already exists and is a hard link to the file' do
           before(:each) do
-            symlink(absolute_to, target_file)
-            symlink?(target_file).should be_true
-            readlink(target_file).should == canonicalize(absolute_to)
+            link(to, target_file)
+            File.exists?(target_file).should be_true
+            symlink?(target_file).should be_false
           end
-          include_context 'create symbolic link succeeds'
+          include_context 'create hard link is noop'
           include_context 'delete succeeds'
+          it 'the :delete action does not delete the target file' do
+            resource.run_action(:delete)
+            File.exists?(to).should be_true
+          end
         end
-      end
-    end
-  end
-
-  context "is a hard link" do
-    before(:each) do
-      resource.link_type(:hard)
-    end
-
-    context "when the link destination is a file" do
-      before(:each) do
-        File.open(to, "w") do |file|
-          file.write('woohoo')
-        end
-      end
-      context "and the link does not yet exist" do
-        include_context 'create hard link succeeds'
-        include_context 'delete is noop'
-      end
-      context "and the link already exists and is a symbolic link pointing at the same file" do
-        before(:each) do
-          symlink(to, target_file)
-          symlink?(target_file).should be_true
-          readlink(target_file).should == to
-        end
-        include_context 'create hard link succeeds'
-        it_behaves_like 'delete errors out'
-      end
-      context 'and the link already exists and is a hard link to the file' do
-        before(:each) do
-          link(to, target_file)
-          File.exists?(target_file).should be_true
-          symlink?(target_file).should be_false
-        end
-        include_context 'create hard link is noop'
-        include_context 'delete succeeds'
-        it 'the :delete action does not delete the target file' do
-          resource.run_action(:delete)
-          File.exists?(to).should be_true
-        end
-      end
-      context "and the link already exists and is a file" do
-        before(:each) do
-          File.open(target_file, 'w') { |file| file.write('tomfoolery') }
-        end
-        include_context 'create hard link succeeds'
-        it_behaves_like 'delete errors out'
-      end
-      context "and the link already exists and is a directory" do
-        before(:each) do
-          Dir.mkdir(target_file)
+        context "and the link already exists and is a file" do
+          before(:each) do
+            File.open(target_file, 'w') { |file| file.write('tomfoolery') }
+          end
+          include_context 'create hard link succeeds'
+          it_behaves_like 'delete errors out'
         end
-        it 'errors out' do
-          if windows?
-            lambda { resource.run_action(:create) }.should raise_error(Errno::EACCES)
-          elsif os_x? or solaris? or freebsd?
-            lambda { resource.run_action(:create) }.should raise_error(Errno::EPERM)
-          else
-            lambda { resource.run_action(:create) }.should raise_error(Errno::EISDIR)
+        context "and the link already exists and is a directory" do
+          before(:each) do
+            Dir.mkdir(target_file)
+          end
+          it 'errors out' do
+            if windows?
+              lambda { resource.run_action(:create) }.should raise_error(Errno::EACCES)
+            elsif os_x? or solaris? or freebsd?
+              lambda { resource.run_action(:create) }.should raise_error(Errno::EPERM)
+            else
+              lambda { resource.run_action(:create) }.should raise_error(Errno::EISDIR)
+            end
           end
+          it_behaves_like 'delete errors out'
         end
-        it_behaves_like 'delete errors out'
-      end
-      context "and the link already exists and is not writeable to this user", :pending do
-      end
-      context "and specifies security attributes" do
-        before(:each) do
-          resource.owner(windows? ? 'Guest' : 'nobody')
+        context "and the link already exists and is not writeable to this user", :pending do
         end
-        it 'ignores them' do
-          resource.run_action(:create)
-          if windows?
-            Chef::ReservedNames::Win32::Security.get_named_security_info(target_file).owner.should_not == SID.Guest
-          else
-            File.lstat(target_file).uid.should_not == Etc.getpwnam('nobody').uid
+        context "and specifies security attributes" do
+          before(:each) do
+            resource.owner(windows? ? 'Guest' : 'nobody')
+          end
+          it 'ignores them' do
+            resource.run_action(:create)
+            if windows?
+              Chef::ReservedNames::Win32::Security.get_named_security_info(target_file).owner.should_not == SID.Guest
+            else
+              File.lstat(target_file).uid.should_not == Etc.getpwnam('nobody').uid
+            end
           end
         end
       end
-    end
-    context "when the link destination is a directory" do
-      before(:each) do
-        Dir.mkdir(to)
-      end
-      context 'and the link does not yet exist' do
-        it 'create errors out' do
-          lambda { resource.run_action(:create) }.should raise_error(windows? ? Chef::Exceptions::Win32APIError : Errno::EPERM)
-        end
-        include_context 'delete is noop'
-      end
-    end
-    context "when the link destination is a symbolic link" do
-      context 'to a real file' do
+      context "when the link destination is a directory" do
         before(:each) do
-          @other_target = File.join(base_dir, make_tmpname("other_spec", nil))
-          File.open(@other_target, "w") { |file| file.write("eek") }
-          symlink(@other_target, to)
-          symlink?(to).should be_true
-          readlink(to).should == @other_target
-        end
-        after(:each) do
-          File.delete(@other_target)
+          Dir.mkdir(to)
         end
         context 'and the link does not yet exist' do
-          it 'links to the target file' do
-            resource.run_action(:create)
-            File.exists?(target_file).should be_true
-            # OS X gets angry about this sort of link.  Bug in OS X, IMO.
-            pending('OS X/FreeBSD symlink? and readlink working on hard links to symlinks', :if => (os_x? or freebsd?)) do
-              symlink?(target_file).should be_true
-              readlink(target_file).should == @other_target
-            end
+          it 'create errors out' do
+            lambda { resource.run_action(:create) }.should raise_error(windows? ? Chef::Exceptions::Win32APIError : Errno::EPERM)
           end
           include_context 'delete is noop'
         end
       end
-      context 'to a nonexistent file' do
-        before(:each) do
-          @other_target = File.join(base_dir, make_tmpname("other_spec", nil))
-          symlink(@other_target, to)
-          symlink?(to).should be_true
-          readlink(to).should == @other_target
-        end
-        context 'and the link does not yet exist' do
-          it 'links to the target file' do
-            pending('OS X/FreeBSD fails to create hardlinks to broken symlinks', :if => (os_x? or freebsd?)) do
+      context "when the link destination is a symbolic link" do
+        context 'to a real file' do
+          before(:each) do
+            @other_target = File.join(test_file_dir, make_tmpname("other_spec"))
+            File.open(@other_target, "w") { |file| file.write("eek") }
+            symlink(@other_target, to)
+            symlink?(to).should be_true
+            readlink(to).should == canonicalize(@other_target)
+          end
+          after(:each) do
+            File.delete(@other_target)
+          end
+          context 'and the link does not yet exist' do
+            it 'links to the target file' do
               resource.run_action(:create)
-              # Windows and Unix have different definitions of exists? here, and that's OK.
-              if windows?
-                File.exists?(target_file).should be_true
-              else
-                File.exists?(target_file).should be_false
+              File.exists?(target_file).should be_true
+              # OS X gets angry about this sort of link.  Bug in OS X, IMO.
+              pending('OS X/FreeBSD symlink? and readlink working on hard links to symlinks', :if => (os_x? or freebsd?)) do
+                symlink?(target_file).should be_true
+                readlink(target_file).should == canonicalize(@other_target)
               end
-              symlink?(target_file).should be_true
-              readlink(target_file).should == @other_target
             end
+            include_context 'delete is noop'
+          end
+        end
+        context 'to a nonexistent file' do
+          before(:each) do
+            @other_target = File.join(test_file_dir, make_tmpname("other_spec"))
+            symlink(@other_target, to)
+            symlink?(to).should be_true
+            readlink(to).should == canonicalize(@other_target)
+          end
+          context 'and the link does not yet exist' do
+            it 'links to the target file' do
+              pending('OS X/FreeBSD fails to create hardlinks to broken symlinks', :if => (os_x? or freebsd?)) do
+                resource.run_action(:create)
+                # Windows and Unix have different definitions of exists? here, and that's OK.
+                if windows?
+                  File.exists?(target_file).should be_true
+                else
+                  File.exists?(target_file).should be_false
+                end
+                symlink?(target_file).should be_true
+                readlink(target_file).should == canonicalize(@other_target)
+              end
+            end
+            include_context 'delete is noop'
           end
-          include_context 'delete is noop'
         end
       end
-    end
-    context "when the link destination is not readable to this user", :pending do
-    end
-    context "when the link destination does not exist" do
-      context 'and the link does not yet exist' do
-        it 'create errors out' do
-          lambda { resource.run_action(:create) }.should raise_error(Errno::ENOENT)
+      context "when the link destination is not readable to this user", :pending do
+      end
+      context "when the link destination does not exist" do
+        context 'and the link does not yet exist' do
+          it 'create errors out' do
+            lambda { resource.run_action(:create) }.should raise_error(Errno::ENOENT)
+          end
+          include_context 'delete is noop'
         end
-        include_context 'delete is noop'
       end
     end
   end
+
+  describe "when not supported on platform", :win2k3_only do
+    it "raises error" do
+      lambda {resource}.should raise_error(Chef::Exceptions::Win32APIFunctionNotImplemented)
+    end
+  end
 end