chef 15.0.300-universal-mingw32 → 15.1.36-universal-mingw32

data/spec/support/shared/functional/execute_resource.rb

@@ -1,150 +1,150 @@
-#
-# Author:: Adam Edwards (<adamed@chef.io>)
-# Copyright:: Copyright (c) 2015 Chef Software, 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.
-#
-
-shared_context "a non-admin Windows user" do
-  include Chef::Mixin::ShellOut
-
-  let(:windows_nonadmin_user_domain) { ENV["COMPUTERNAME"] }
-  let(:windows_nonadmin_user_qualified) { "#{windows_nonadmin_user_domain}\\#{windows_nonadmin_user}" }
-  let(:temp_profile_path) { "#{ENV['USERPROFILE']}\\..\\cheftesttempuser" }
-  before do
-    shell_out!("net.exe user /delete #{windows_nonadmin_user}", returns: [0, 2])
-
-    # Supply a profile path when creating a user to avoid an apparent Windows bug where deleting
-    # the user actually creates the profile when it did not immediately exist before executing
-    # net user /delete! For some reason, specifying an explicit path ensures that the path
-    # profile doesn't get created at deletion.
-    shell_out!("net.exe user /add #{windows_nonadmin_user} \"#{windows_nonadmin_user_password}\" /profilepath:#{temp_profile_path}")
-  end
-
-  after do
-    shell_out!("net.exe user /delete #{windows_nonadmin_user}", returns: [0, 2])
-  end
-end
-
-shared_context "alternate user identity" do
-  let(:windows_alternate_user) { "chef%02d%02d%02d" % [Time.now.year % 100, Time.now.month, Time.now.day] }
-  let(:windows_alternate_user_password) { "lj28;fx3T!x,2" }
-  let(:windows_alternate_user_qualified) { "#{ENV['COMPUTERNAME']}\\#{windows_alternate_user}" }
-
-  let(:windows_nonadmin_user) { windows_alternate_user }
-  let(:windows_nonadmin_user_password) { windows_alternate_user_password }
-
-  include_context "a non-admin Windows user"
-end
-
-shared_context "a command that can be executed as an alternate user" do
-  include_context "alternate user identity"
-
-  let(:script_output_dir) { Dir.mktmpdir }
-  let(:script_output_path) { File.join(script_output_dir, make_tmpname("chef_execute_identity_test")) }
-  let(:script_output) { File.read(script_output_path) }
-
-  include Chef::Mixin::ShellOut
-
-  before do
-    shell_out!("icacls \"#{script_output_dir.gsub(/\//, '\\')}\" /grant \"authenticated users:(F)\"")
-  end
-
-  after do
-    File.delete(script_output_path) if File.exists?(script_output_path)
-    Dir.rmdir(script_output_dir) if Dir.exist?(script_output_dir)
-  end
-end
-
-shared_examples_for "an execute resource that supports alternate user identity" do
-  context "when running on Windows", :windows_only, :windows_service_requires_assign_token do
-
-    include_context "a command that can be executed as an alternate user"
-
-    let(:windows_current_user) { ENV["USERNAME"] }
-    let(:windows_current_user_qualified) { "#{ENV['USERDOMAIN'] || ENV['COMPUTERNAME']}\\#{windows_current_user}" }
-    let(:resource_identity_command) { "powershell.exe -noprofile -command \"import-module microsoft.powershell.utility;([Security.Principal.WindowsPrincipal]([Security.Principal.WindowsIdentity]::GetCurrent())).identity.name | out-file -encoding ASCII '#{script_output_path}'\"" }
-
-    let(:execute_resource) do
-      resource.user(windows_alternate_user)
-      resource.password(windows_alternate_user_password)
-      resource.send(resource_command_property, resource_identity_command)
-      resource
-    end
-
-    it "executes the process as an alternate user" do
-      expect(windows_current_user.length).to be > 0
-      expect { execute_resource.run_action(:run) }.not_to raise_error
-      expect(script_output.chomp.length).to be > 0
-      expect(script_output.chomp.downcase).to eq(windows_alternate_user_qualified.downcase)
-      expect(script_output.chomp.downcase).not_to eq(windows_current_user.downcase)
-      expect(script_output.chomp.downcase).not_to eq(windows_current_user_qualified.downcase)
-    end
-
-    let(:windows_alternate_user_password_invalid) { "#{windows_alternate_user_password}x" }
-
-    it "raises an exception if the user's password is invalid" do
-      execute_resource.password(windows_alternate_user_password_invalid)
-      expect { execute_resource.run_action(:run) }.to raise_error(SystemCallError)
-    end
-  end
-end
-
-shared_examples_for "a resource with a guard specifying an alternate user identity" do
-  context "when running on Windows", :windows_only, :windows_service_requires_assign_token do
-    include_context "alternate user identity"
-
-    let(:resource_command_property) { :command }
-
-    let(:powershell_equal_to_alternate_user) { "-eq" }
-    let(:powershell_not_equal_to_alternate_user) { "-ne" }
-    let(:guard_identity_command) { "powershell.exe -noprofile -command \"import-module microsoft.powershell.utility;exit @(392,0)[[int32](([Security.Principal.WindowsPrincipal]([Security.Principal.WindowsIdentity]::GetCurrent())).Identity.Name #{comparison_to_alternate_user} '#{windows_alternate_user_qualified}')]\"" }
-
-    before do
-      resource.guard_interpreter(guard_interpreter_resource)
-    end
-
-    context "when the guard expression is true if the user is alternate and false otherwise" do
-      let(:comparison_to_alternate_user) { powershell_equal_to_alternate_user }
-
-      it "causes the resource to be updated for only_if" do
-        resource.only_if(guard_identity_command, { user: windows_alternate_user, password: windows_alternate_user_password })
-        resource.run_action(:run)
-        expect(resource).to be_updated_by_last_action
-      end
-
-      it "causes the resource to not be updated for not_if" do
-        resource.not_if(guard_identity_command, { user: windows_alternate_user, password: windows_alternate_user_password })
-        resource.run_action(:run)
-        expect(resource).not_to be_updated_by_last_action
-      end
-    end
-
-    context "when the guard expression is false if the user is alternate and true otherwise" do
-      let(:comparison_to_alternate_user) { powershell_not_equal_to_alternate_user }
-
-      it "causes the resource not to be updated for only_if" do
-        resource.only_if(guard_identity_command, { user: windows_alternate_user, password: windows_alternate_user_password })
-        resource.run_action(:run)
-        expect(resource).not_to be_updated_by_last_action
-      end
-
-      it "causes the resource to be updated for not_if" do
-        resource.not_if(guard_identity_command, { user: windows_alternate_user, password: windows_alternate_user_password })
-        resource.run_action(:run)
-        expect(resource).to be_updated_by_last_action
-      end
-    end
-  end
-end
+#
+# Author:: Adam Edwards (<adamed@chef.io>)
+# Copyright:: Copyright (c) 2015 Chef Software, 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.
+#
+
+shared_context "a non-admin Windows user" do
+  include Chef::Mixin::ShellOut
+
+  let(:windows_nonadmin_user_domain) { ENV["COMPUTERNAME"] }
+  let(:windows_nonadmin_user_qualified) { "#{windows_nonadmin_user_domain}\\#{windows_nonadmin_user}" }
+  let(:temp_profile_path) { "#{ENV['USERPROFILE']}\\..\\cheftesttempuser" }
+  before do
+    shell_out!("net.exe user /delete #{windows_nonadmin_user}", returns: [0, 2])
+
+    # Supply a profile path when creating a user to avoid an apparent Windows bug where deleting
+    # the user actually creates the profile when it did not immediately exist before executing
+    # net user /delete! For some reason, specifying an explicit path ensures that the path
+    # profile doesn't get created at deletion.
+    shell_out!("net.exe user /add #{windows_nonadmin_user} \"#{windows_nonadmin_user_password}\" /profilepath:#{temp_profile_path}")
+  end
+
+  after do
+    shell_out!("net.exe user /delete #{windows_nonadmin_user}", returns: [0, 2])
+  end
+end
+
+shared_context "alternate user identity" do
+  let(:windows_alternate_user) { "chef%02d%02d%02d" % [Time.now.year % 100, Time.now.month, Time.now.day] }
+  let(:windows_alternate_user_password) { "lj28;fx3T!x,2" }
+  let(:windows_alternate_user_qualified) { "#{ENV['COMPUTERNAME']}\\#{windows_alternate_user}" }
+
+  let(:windows_nonadmin_user) { windows_alternate_user }
+  let(:windows_nonadmin_user_password) { windows_alternate_user_password }
+
+  include_context "a non-admin Windows user"
+end
+
+shared_context "a command that can be executed as an alternate user" do
+  include_context "alternate user identity"
+
+  let(:script_output_dir) { Dir.mktmpdir }
+  let(:script_output_path) { File.join(script_output_dir, make_tmpname("chef_execute_identity_test")) }
+  let(:script_output) { File.read(script_output_path) }
+
+  include Chef::Mixin::ShellOut
+
+  before do
+    shell_out!("icacls \"#{script_output_dir.gsub(/\//, '\\')}\" /grant \"authenticated users:(F)\"")
+  end
+
+  after do
+    File.delete(script_output_path) if File.exists?(script_output_path)
+    Dir.rmdir(script_output_dir) if Dir.exist?(script_output_dir)
+  end
+end
+
+shared_examples_for "an execute resource that supports alternate user identity" do
+  context "when running on Windows", :windows_only, :windows_service_requires_assign_token do
+
+    include_context "a command that can be executed as an alternate user"
+
+    let(:windows_current_user) { ENV["USERNAME"] }
+    let(:windows_current_user_qualified) { "#{ENV['USERDOMAIN'] || ENV['COMPUTERNAME']}\\#{windows_current_user}" }
+    let(:resource_identity_command) { "powershell.exe -noprofile -command \"import-module microsoft.powershell.utility;([Security.Principal.WindowsPrincipal]([Security.Principal.WindowsIdentity]::GetCurrent())).identity.name | out-file -encoding ASCII '#{script_output_path}'\"" }
+
+    let(:execute_resource) do
+      resource.user(windows_alternate_user)
+      resource.password(windows_alternate_user_password)
+      resource.send(resource_command_property, resource_identity_command)
+      resource
+    end
+
+    it "executes the process as an alternate user" do
+      expect(windows_current_user.length).to be > 0
+      expect { execute_resource.run_action(:run) }.not_to raise_error
+      expect(script_output.chomp.length).to be > 0
+      expect(script_output.chomp.downcase).to eq(windows_alternate_user_qualified.downcase)
+      expect(script_output.chomp.downcase).not_to eq(windows_current_user.downcase)
+      expect(script_output.chomp.downcase).not_to eq(windows_current_user_qualified.downcase)
+    end
+
+    let(:windows_alternate_user_password_invalid) { "#{windows_alternate_user_password}x" }
+
+    it "raises an exception if the user's password is invalid" do
+      execute_resource.password(windows_alternate_user_password_invalid)
+      expect { execute_resource.run_action(:run) }.to raise_error(SystemCallError)
+    end
+  end
+end
+
+shared_examples_for "a resource with a guard specifying an alternate user identity" do
+  context "when running on Windows", :windows_only, :windows_service_requires_assign_token do
+    include_context "alternate user identity"
+
+    let(:resource_command_property) { :command }
+
+    let(:powershell_equal_to_alternate_user) { "-eq" }
+    let(:powershell_not_equal_to_alternate_user) { "-ne" }
+    let(:guard_identity_command) { "powershell.exe -noprofile -command \"import-module microsoft.powershell.utility;exit @(392,0)[[int32](([Security.Principal.WindowsPrincipal]([Security.Principal.WindowsIdentity]::GetCurrent())).Identity.Name #{comparison_to_alternate_user} '#{windows_alternate_user_qualified}')]\"" }
+
+    before do
+      resource.guard_interpreter(guard_interpreter_resource)
+    end
+
+    context "when the guard expression is true if the user is alternate and false otherwise" do
+      let(:comparison_to_alternate_user) { powershell_equal_to_alternate_user }
+
+      it "causes the resource to be updated for only_if" do
+        resource.only_if(guard_identity_command, { user: windows_alternate_user, password: windows_alternate_user_password })
+        resource.run_action(:run)
+        expect(resource).to be_updated_by_last_action
+      end
+
+      it "causes the resource to not be updated for not_if" do
+        resource.not_if(guard_identity_command, { user: windows_alternate_user, password: windows_alternate_user_password })
+        resource.run_action(:run)
+        expect(resource).not_to be_updated_by_last_action
+      end
+    end
+
+    context "when the guard expression is false if the user is alternate and true otherwise" do
+      let(:comparison_to_alternate_user) { powershell_not_equal_to_alternate_user }
+
+      it "causes the resource not to be updated for only_if" do
+        resource.only_if(guard_identity_command, { user: windows_alternate_user, password: windows_alternate_user_password })
+        resource.run_action(:run)
+        expect(resource).not_to be_updated_by_last_action
+      end
+
+      it "causes the resource to be updated for not_if" do
+        resource.not_if(guard_identity_command, { user: windows_alternate_user, password: windows_alternate_user_password })
+        resource.run_action(:run)
+        expect(resource).to be_updated_by_last_action
+      end
+    end
+  end
+end

data/spec/support/shared/functional/file_resource.rb

@@ -1,1050 +1,1050 @@
-#
-# Author:: Seth Chisamore (<schisamo@chef.io>)
-# Copyright:: Copyright 2011-2018, Chef Software 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.
-#
-
-shared_context "deploying with move" do
-  before do
-    Chef::Config[:file_backup_path] = CHEF_SPEC_BACKUP_PATH
-    Chef::Config[:file_atomic_update] = true
-  end
-end
-
-shared_context "deploying with copy" do
-  before do
-    Chef::Config[:file_backup_path] = CHEF_SPEC_BACKUP_PATH
-    Chef::Config[:file_atomic_update] = false
-  end
-end
-
-shared_context "deploying via tmpdir" do
-  before do
-    Chef::Config[:file_staging_uses_destdir] = false
-    Chef::Config[:file_backup_path] = CHEF_SPEC_BACKUP_PATH
-  end
-end
-
-shared_context "deploying via destdir" do
-  before do
-    Chef::Config[:file_staging_uses_destdir] = true
-    Chef::Config[:file_backup_path] = CHEF_SPEC_BACKUP_PATH
-  end
-end
-
-shared_examples_for "a file with the wrong content" do
-  before do
-    # Assert starting state is as expected
-    expect(File).to exist(path)
-    # Kinda weird, in this case @expected_checksum is the cksum of the file
-    # with incorrect content.
-    expect(sha256_checksum(path)).to eq(@expected_checksum)
-  end
-
-  describe "when diff is disabled" do
-
-    include_context "diff disabled"
-
-    context "when running action :create" do
-      context "with backups enabled" do
-        before do
-          resource.run_action(:create)
-        end
-
-        it "overwrites the file with the updated content when the :create action is run" do
-          expect(File.stat(path).mtime).to be > @expected_mtime
-          expect(sha256_checksum(path)).not_to eq(@expected_checksum)
-        end
-
-        it "backs up the existing file" do
-          expect(Dir.glob(backup_glob).size).to equal(1)
-        end
-
-        it "is marked as updated by last action" do
-          expect(resource).to be_updated_by_last_action
-        end
-
-        it "should restore the security contexts on selinux", :selinux_only do
-          expect(selinux_security_context_restored?(path)).to be_truthy
-        end
-      end
-
-      context "with backups disabled" do
-        before do
-          resource.backup(0)
-          resource.run_action(:create)
-        end
-
-        it "should not attempt to backup the existing file if :backup == 0" do
-          expect(Dir.glob(backup_glob).size).to equal(0)
-        end
-
-        it "should restore the security contexts on selinux", :selinux_only do
-          expect(selinux_security_context_restored?(path)).to be_truthy
-        end
-      end
-
-      context "with a checksum that does not match the content to deploy" do
-        before do
-          resource.checksum("aAaAaAaAaAaAaAaAaAaAaAaAaAaAaAaAaAaAaAaAaAaAaAaAaAaAaAaAaAaAaAaA")
-        end
-
-        it "raises an exception" do
-          expect { resource.run_action(:create) }.to raise_error(Chef::Exceptions::ChecksumMismatch)
-        end
-      end
-    end
-
-    describe "when running action :create_if_missing" do
-      before do
-        resource.run_action(:create_if_missing)
-      end
-
-      it "doesn't overwrite the file when the :create_if_missing action is run" do
-        expect(File.stat(path).mtime).to eq(@expected_mtime)
-        expect(sha256_checksum(path)).to eq(@expected_checksum)
-      end
-
-      it "is not marked as updated" do
-        expect(resource).not_to be_updated_by_last_action
-      end
-
-      it "should restore the security contexts on selinux", :selinux_only do
-        expect(selinux_security_context_restored?(path)).to be_truthy
-      end
-    end
-
-    describe "when running action :delete" do
-      before do
-        resource.run_action(:delete)
-      end
-
-      it "deletes the file" do
-        expect(File).not_to exist(path)
-      end
-
-      it "is marked as updated by last action" do
-        expect(resource).to be_updated_by_last_action
-      end
-    end
-
-  end
-
-  context "when diff is enabled" do
-    describe "sensitive attribute" do
-      context "should be insensitive by default" do
-        it { expect(resource.sensitive).to(be_falsey) }
-      end
-
-      context "when set" do
-        before { resource.sensitive(true) }
-
-        it "should be set on the resource" do
-          expect(resource.sensitive).to(be_truthy)
-        end
-
-        context "when running :create action" do
-          let(:provider) { resource.provider_for_action(:create) }
-          let(:reporter_messages) { provider.instance_variable_get("@converge_actions").actions[0][0] }
-
-          before do
-            provider.run_action
-          end
-
-          it "should suppress the diff" do
-            expect(resource.diff).to(include("suppressed sensitive resource"))
-            expect(reporter_messages[1]).to eq("suppressed sensitive resource")
-          end
-
-          it "should still include the updated checksums" do
-            expect(reporter_messages[0]).to include("update content in file")
-          end
-        end
-      end
-    end
-  end
-end
-
-shared_examples_for "a file with the correct content" do
-  before do
-    # Assert starting state is as expected
-    expect(File).to exist(path)
-    expect(sha256_checksum(path)).to eq(@expected_checksum)
-  end
-
-  include_context "diff disabled"
-
-  describe "when running action :create" do
-    before do
-      resource.run_action(:create)
-    end
-    it "does not overwrite the original when the :create action is run" do
-      expect(sha256_checksum(path)).to eq(@expected_checksum)
-    end
-
-    it "does not update the mtime of the file when the :create action is run" do
-      expect(File.stat(path).mtime).to eq(@expected_mtime)
-    end
-
-    it "is not marked as updated by last action" do
-      expect(resource).not_to be_updated_by_last_action
-    end
-
-    it "should restore the security contexts on selinux", :selinux_only do
-      expect(selinux_security_context_restored?(path)).to be_truthy
-    end
-  end
-
-  describe "when running action :create_if_missing" do
-    before do
-      resource.run_action(:create_if_missing)
-    end
-
-    it "doesn't overwrite the file when the :create_if_missing action is run" do
-      expect(sha256_checksum(path)).to eq(@expected_checksum)
-    end
-
-    it "is not marked as updated by last action" do
-      expect(resource).not_to be_updated_by_last_action
-    end
-
-    it "should restore the security contexts on selinux", :selinux_only do
-      expect(selinux_security_context_restored?(path)).to be_truthy
-    end
-  end
-
-  describe "when running action :delete" do
-    before do
-      resource.run_action(:delete)
-    end
-
-    it "deletes the file when the :delete action is run" do
-      expect(File).not_to exist(path)
-    end
-
-    it "is marked as updated by last action" do
-      expect(resource).to be_updated_by_last_action
-    end
-  end
-end
-
-shared_examples_for "a file resource" do
-  describe "when deploying with :move" do
-
-    include_context "deploying with move"
-
-    describe "when deploying via tmpdir" do
-
-      include_context "deploying via tmpdir"
-
-      it_behaves_like "a configured file resource"
-    end
-
-    describe "when deploying via destdir" do
-
-      include_context "deploying via destdir"
-
-      it_behaves_like "a configured file resource"
-    end
-  end
-
-  describe "when deploying with :copy" do
-
-    include_context "deploying with copy"
-
-    describe "when deploying via tmpdir" do
-
-      include_context "deploying via tmpdir"
-
-      it_behaves_like "a configured file resource"
-    end
-
-    describe "when deploying via destdir" do
-
-      include_context "deploying via destdir"
-
-      it_behaves_like "a configured file resource"
-    end
-  end
-
-  describe "when running under why run" do
-
-    before do
-      Chef::Config[:why_run] = true
-      Chef::Config[:ssl_verify_mode] = :verify_none
-    end
-
-    after do
-      Chef::Config[:why_run] = false
-    end
-
-    context "and the resource has a path with a missing intermediate directory" do
-      # CHEF-3978
-
-      let(:path) do
-        File.join(test_file_dir, "intermediate_dir", make_tmpname(file_base))
-      end
-
-      it "successfully doesn't create the file" do
-        resource.run_action(:create) # should not raise
-        expect(File).not_to exist(path)
-      end
-    end
-
-  end
-
-  describe "when setting atomic_update" do
-    it "booleans should work" do
-      expect { resource.atomic_update(true) }.not_to raise_error
-      expect { resource.atomic_update(false) }.not_to raise_error
-    end
-
-    it "anything else should raise an error" do
-      expect { resource.atomic_update(:copy) }.to raise_error(ArgumentError)
-      expect { resource.atomic_update(:move) }.to raise_error(ArgumentError)
-      expect { resource.atomic_update(958) }.to raise_error(ArgumentError)
-    end
-  end
-
-end
-
-shared_examples_for "file resource not pointing to a real file" do
-  def symlink?(file_path)
-    if windows?
-      Chef::ReservedNames::Win32::File.symlink?(file_path)
-    else
-      File.symlink?(file_path)
-    end
-  end
-
-  def real_file?(file_path)
-    !symlink?(file_path) && File.file?(file_path)
-  end
-
-  before do
-    Chef::Config[:ssl_verify_mode] = :verify_none
-  end
-
-  describe "when force_unlink is set to true" do
-    it ":create unlinks the target" do
-      expect(real_file?(path)).to be_falsey
-      resource.force_unlink(true)
-      resource.run_action(:create)
-      expect(real_file?(path)).to be_truthy
-      expect(binread(path)).to eq(expected_content)
-      expect(resource).to be_updated_by_last_action
-    end
-  end
-
-  describe "when force_unlink is set to false" do
-    it ":create raises an error" do
-      expect { resource.run_action(:create) }.to raise_error(Chef::Exceptions::FileTypeMismatch)
-    end
-  end
-
-  describe "when force_unlink is not set (default)" do
-    it ":create raises an error" do
-      expect { resource.run_action(:create) }.to raise_error(Chef::Exceptions::FileTypeMismatch)
-    end
-  end
-end
-
-shared_examples_for "a configured file resource" do
-
-  include_context "diff disabled"
-
-  before do
-    Chef::Log.level = :info
-    Chef::Config[:ssl_verify_mode] = :verify_none
-  end
-
-   # note the stripping of the drive letter from the tmpdir on windows
-  let(:backup_glob) { File.join(CHEF_SPEC_BACKUP_PATH, test_file_dir.sub(/^([A-Za-z]:)/, ""), "#{file_base}*") }
-
-  # Most tests update the resource, but a few do not. We need to test that the
-  # resource is marked updated or not correctly, but the test contexts are
-  # composed between correct/incorrect content and correct/incorrect
-  # permissions. We override this "let" definition in the context where content
-  # and permissions are correct.
-  let(:expect_updated?) { true }
-
-  include Chef::Mixin::ShellOut
-
-  def selinux_security_context_restored?(path)
-    @restorecon_path = which("restorecon") if @restorecon_path.nil?
-    restorecon_test_command = "#{@restorecon_path} -n -v #{path}"
-    cmdresult = shell_out!(restorecon_test_command)
-    # restorecon will print the required changes to stdout if any is
-    # needed
-    cmdresult.stdout.empty?
-  end
-
-  def binread(file)
-    content = File.open(file, "rb") do |f|
-      f.read
-    end
-    content.force_encoding(Encoding::BINARY) if "".respond_to?(:force_encoding)
-    content
-  end
-
-  context "when the target file is a symlink" do
-    let(:symlink_target) do
-      File.join(CHEF_SPEC_DATA, "file-test-target")
-    end
-
-    describe "when configured not to manage symlink's target" do
-      before(:each) do
-        # configure not to manage symlink source
-        resource.manage_symlink_source(false)
-
-        # create symlinks for test context
-        FileUtils.touch(symlink_target)
-
-        if windows?
-          Chef::ReservedNames::Win32::File.symlink(symlink_target, path)
-        else
-          File.symlink(symlink_target, path)
-        end
-      end
-
-      after(:each) do
-        FileUtils.rm_rf(symlink_target)
-        FileUtils.rm_rf(path)
-      end
-
-      describe "when symlink target has correct content" do
-        before(:each) do
-          File.open(symlink_target, "wb") { |f| f.print expected_content }
-        end
-
-        it_behaves_like "file resource not pointing to a real file"
-      end
-
-      describe "when symlink target has the wrong content" do
-        before(:each) do
-          File.open(symlink_target, "wb") { |f| f.print "This is so wrong!!!" }
-        end
-
-        after(:each) do
-          # symlink should never be followed
-          expect(binread(symlink_target)).to eq("This is so wrong!!!")
-        end
-
-        it_behaves_like "file resource not pointing to a real file"
-      end
-    end
-
-    # Unix-only for now. Windows behavior may differ because of how ACL
-    # management handles symlinks. Since symlinks are rare on Windows and this
-    # feature primarily exists to support the case where a well-known file
-    # (e.g., resolv.conf) has been converted to a symlink, we're okay with the
-    # discrepancy.
-    context "when configured to manage the symlink source", :unix_only do
-
-      before do
-        resource.manage_symlink_source(true)
-      end
-
-      context "but the symlink is part of a loop" do
-        let(:link1_path) { File.join(CHEF_SPEC_DATA, "points-to-link2") }
-        let(:link2_path) { File.join(CHEF_SPEC_DATA, "points-to-link1") }
-
-        before do
-          # point resource at link1:
-          resource.path(link1_path)
-          # create symlinks for test context
-          File.symlink(link1_path, link2_path)
-          File.symlink(link2_path, link1_path)
-        end
-
-        after(:each) do
-          FileUtils.rm_rf(link1_path)
-          FileUtils.rm_rf(link2_path)
-        end
-
-        it "raises an InvalidSymlink error" do
-          expect { resource.run_action(:create) }.to raise_error(Chef::Exceptions::InvalidSymlink)
-        end
-
-        it "issues a warning/assumption in whyrun mode" do
-          begin
-            Chef::Config[:why_run] = true
-            resource.run_action(:create) # should not raise
-          ensure
-            Chef::Config[:why_run] = false
-          end
-        end
-      end
-
-      context "but the symlink points to a nonexistent file" do
-        let(:link_path) { File.join(CHEF_SPEC_DATA, "points-to-nothing") }
-        let(:not_existent_source) { File.join(CHEF_SPEC_DATA, "i-am-not-here") }
-
-        before do
-          resource.path(link_path)
-          # create symlinks for test context
-          File.symlink(not_existent_source, link_path)
-          FileUtils.rm_rf(not_existent_source)
-        end
-
-        after(:each) do
-          FileUtils.rm_rf(link_path)
-        end
-        it "raises an InvalidSymlink error" do
-          expect { resource.run_action(:create) }.to raise_error(Chef::Exceptions::InvalidSymlink)
-        end
-
-        it "issues a warning/assumption in whyrun mode" do
-          begin
-            Chef::Config[:why_run] = true
-            resource.run_action(:create) # should not raise
-          ensure
-            Chef::Config[:why_run] = false
-          end
-        end
-      end
-
-      context "but the symlink is points to a non-file fs entry" do
-        let(:link_path) { File.join(CHEF_SPEC_DATA, "points-to-dir") }
-        let(:not_a_file_path) { File.join(CHEF_SPEC_DATA, "dir-at-end-of-symlink") }
-
-        before do
-          # point resource at link1:
-          resource.path(link_path)
-          # create symlinks for test context
-          File.symlink(not_a_file_path, link_path)
-          Dir.mkdir(not_a_file_path)
-        end
-
-        after(:each) do
-          FileUtils.rm_rf(link_path)
-          FileUtils.rm_rf(not_a_file_path)
-        end
-
-        it "raises an InvalidSymlink error" do
-          expect { resource.run_action(:create) }.to raise_error(Chef::Exceptions::FileTypeMismatch)
-        end
-
-        it "issues a warning/assumption in whyrun mode" do
-          begin
-            Chef::Config[:why_run] = true
-            resource.run_action(:create) # should not raise
-          ensure
-            Chef::Config[:why_run] = false
-          end
-        end
-      end
-
-      context "when the symlink source is a real file" do
-
-        let(:wrong_content) { "this is the wrong content" }
-        let(:link_path) { File.join(CHEF_SPEC_DATA, "points-to-real-file") }
-
-        before do
-          # point resource at link:
-          resource.path(link_path)
-          # create symlinks for test context
-          File.symlink(path, link_path)
-        end
-
-        after(:each) do
-          # shared examples should not change our test setup of a file resource
-          # pointing at a symlink:
-          expect(resource.path).to eq(link_path)
-          FileUtils.rm_rf(link_path)
-        end
-
-        context "and the permissions are incorrect" do
-          before do
-            # Create source (real) file
-            File.open(path, "wb") { |f| f.write(expected_content) }
-          end
-
-          include_context "setup broken permissions"
-
-          include_examples "a securable resource with existing target"
-
-          it "does not replace the symlink with a real file" do
-            resource.run_action(:create)
-            expect(File).to be_symlink(link_path)
-          end
-
-        end
-
-        context "and the content is incorrect" do
-          before do
-            # Create source (real) file
-            File.open(path, "wb") { |f| f.write(wrong_content) }
-          end
-
-          it "marks the resource as updated" do
-            resource.run_action(:create)
-            expect(resource).to be_updated_by_last_action
-          end
-
-          it "does not replace the symlink with a real file" do
-            resource.run_action(:create)
-            expect(File).to be_symlink(link_path)
-          end
-        end
-
-        context "and the content and permissions are correct" do
-          let(:expect_updated?) { false }
-
-          before do
-            # Create source (real) file
-            File.open(path, "wb") { |f| f.write(expected_content) }
-          end
-          include_context "setup correct permissions"
-
-          include_examples "a securable resource with existing target"
-
-        end
-
-      end
-
-      context "when the symlink points to a symlink which points to a real file" do
-
-        let(:wrong_content) { "this is the wrong content" }
-        let(:link_to_file_path) { File.join(CHEF_SPEC_DATA, "points-to-real-file") }
-        let(:link_to_link_path) { File.join(CHEF_SPEC_DATA, "points-to-next-link") }
-
-        before do
-          # point resource at link:
-          resource.path(link_to_link_path)
-          # create symlinks for test context
-          File.symlink(path, link_to_file_path)
-          File.symlink(link_to_file_path, link_to_link_path)
-
-          # Create source (real) file
-          File.open(path, "wb") { |f| f.write(wrong_content) }
-        end
-
-        include_context "setup broken permissions"
-
-        include_examples "a securable resource with existing target"
-
-        after(:each) do
-          # shared examples should not change our test setup of a file resource
-          # pointing at a symlink:
-          expect(resource.path).to eq(link_to_link_path)
-          FileUtils.rm_rf(link_to_file_path)
-          FileUtils.rm_rf(link_to_link_path)
-        end
-
-        it "does not replace the symlink with a real file" do
-          resource.run_action(:create)
-          expect(File).to be_symlink(link_to_link_path)
-          expect(File).to be_symlink(link_to_file_path)
-        end
-
-      end
-    end
-  end
-
-  context "when the target file does not exist" do
-    before(:each) do
-      FileUtils.rm_rf(path)
-    end
-
-    after(:each) do
-      FileUtils.rm_rf(path)
-    end
-
-    def symlink?(file_path)
-      if windows?
-        Chef::ReservedNames::Win32::File.symlink?(file_path)
-      else
-        File.symlink?(file_path)
-      end
-    end
-
-    def real_file?(file_path)
-      !symlink?(file_path) && File.file?(file_path)
-    end
-
-    describe "when force_unlink is set to true" do
-      it ":create updates the target" do
-        resource.force_unlink(true)
-        resource.run_action(:create)
-        expect(real_file?(path)).to be_truthy
-        expect(binread(path)).to eq(expected_content)
-        expect(resource).to be_updated_by_last_action
-      end
-    end
-
-    describe "when force_unlink is set to false" do
-      it ":create updates the target" do
-        resource.force_unlink(true)
-        resource.run_action(:create)
-        expect(real_file?(path)).to be_truthy
-        expect(binread(path)).to eq(expected_content)
-        expect(resource).to be_updated_by_last_action
-      end
-    end
-
-    describe "when force_unlink is not set (default)" do
-      it ":create updates the target" do
-        resource.force_unlink(true)
-        resource.run_action(:create)
-        expect(real_file?(path)).to be_truthy
-        expect(binread(path)).to eq(expected_content)
-        expect(resource).to be_updated_by_last_action
-      end
-    end
-  end
-
-  context "when the target file is a directory" do
-    before(:each) do
-      FileUtils.mkdir_p(path)
-    end
-
-    after(:each) do
-      FileUtils.rm_rf(path)
-    end
-
-    it_behaves_like "file resource not pointing to a real file"
-  end
-
-  context "when the target file is a blockdev", :unix_only, :requires_root, :not_supported_on_solaris do
-    include Chef::Mixin::ShellOut
-    let(:path) do
-      File.join(CHEF_SPEC_DATA, "testdev")
-    end
-
-    before(:each) do
-      result = shell_out!("mknod #{path} b 1 2")
-      result.stderr.empty?
-    end
-
-    after(:each) do
-      FileUtils.rm_rf(path)
-    end
-
-    it_behaves_like "file resource not pointing to a real file"
-  end
-
-  context "when the target file is a chardev", :unix_only, :requires_root, :not_supported_on_solaris do
-    include Chef::Mixin::ShellOut
-    let(:path) do
-      File.join(CHEF_SPEC_DATA, "testdev")
-    end
-
-    before(:each) do
-      result = shell_out!("mknod #{path} c 1 2")
-      result.stderr.empty?
-    end
-
-    after(:each) do
-      FileUtils.rm_rf(path)
-    end
-
-    it_behaves_like "file resource not pointing to a real file"
-  end
-
-  context "when the target file is a pipe", :unix_only do
-    include Chef::Mixin::ShellOut
-    let(:path) do
-      File.join(CHEF_SPEC_DATA, "testpipe")
-    end
-
-    before(:each) do
-      result = shell_out!("mkfifo #{path}")
-      result.stderr.empty?
-    end
-
-    after(:each) do
-      FileUtils.rm_rf(path)
-    end
-
-    it_behaves_like "file resource not pointing to a real file"
-  end
-
-  context "when the target file is a socket", :unix_only do
-    require "socket"
-
-    # It turns out that the path to a socket can have at most ~104
-    # bytes. Therefore we are creating our sockets in tmpdir so that
-    # they have a shorter path.
-    let(:test_socket_dir) { File.join(Dir.tmpdir, "sockets") }
-
-    before do
-      FileUtils.mkdir_p(test_socket_dir)
-    end
-
-    after do
-      FileUtils.rm_rf(test_socket_dir)
-    end
-
-    let(:path) do
-      File.join(test_socket_dir, "testsocket")
-    end
-
-    before(:each) do
-      expect(path.bytesize).to be <= 104
-      UNIXServer.new(path)
-    end
-
-    after(:each) do
-      FileUtils.rm_rf(path)
-    end
-
-    it_behaves_like "file resource not pointing to a real file"
-  end
-
-  # Regression test for http://tickets.opscode.com/browse/CHEF-4082
-  context "when notification is configured" do
-    describe "when path is specified with normal separator" do
-      before do
-        @notified_resource = Chef::Resource.new("punk", resource.run_context)
-        resource.notifies(:run, @notified_resource, :immediately)
-        resource.run_action(:create)
-      end
-
-      it "should notify the other resources correctly" do
-        expect(resource).to be_updated_by_last_action
-        expect(resource.run_context.immediate_notifications(resource).length).to eq(1)
-      end
-    end
-
-    describe "when path is specified with windows separator", :windows_only do
-      let(:path) do
-        File.join(test_file_dir, make_tmpname(file_base)).gsub(::File::SEPARATOR, ::File::ALT_SEPARATOR)
-      end
-
-      before do
-        @notified_resource = Chef::Resource.new("punk", resource.run_context)
-        resource.notifies(:run, @notified_resource, :immediately)
-        resource.run_action(:create)
-      end
-
-      it "should notify the other resources correctly" do
-        expect(resource).to be_updated_by_last_action
-        expect(resource.run_context.immediate_notifications(resource).length).to eq(1)
-      end
-    end
-  end
-
-  context "when the target file does not exist" do
-    before do
-      # Assert starting state is expected
-      expect(File).not_to exist(path)
-    end
-
-    describe "when running action :create" do
-      before do
-        resource.run_action(:create)
-      end
-
-      it "creates the file when the :create action is run" do
-        expect(File).to exist(path)
-      end
-
-      it "creates the file with the correct content when the :create action is run" do
-        expect(binread(path)).to eq(expected_content)
-      end
-
-      it "is marked as updated by last action" do
-        expect(resource).to be_updated_by_last_action
-      end
-
-      it "should restore the security contexts on selinux", :selinux_only do
-        expect(selinux_security_context_restored?(path)).to be_truthy
-      end
-    end
-
-    describe "when running action :create_if_missing" do
-      before do
-        resource.run_action(:create_if_missing)
-      end
-
-      it "creates the file with the correct content" do
-        expect(binread(path)).to eq(expected_content)
-      end
-
-      it "is marked as updated by last action" do
-        expect(resource).to be_updated_by_last_action
-      end
-
-      it "should restore the security contexts on selinux", :selinux_only do
-        expect(selinux_security_context_restored?(path)).to be_truthy
-      end
-    end
-
-    describe "when running action :delete" do
-      before do
-        resource.run_action(:delete)
-      end
-
-      it "deletes the file when the :delete action is run" do
-        expect(File).not_to exist(path)
-      end
-
-      it "is not marked updated by last action" do
-        expect(resource).not_to be_updated_by_last_action
-      end
-    end
-  end
-
-  # Set up the context for security tests
-  def allowed_acl(sid, expected_perms, _flags = 0)
-    [ ACE.access_allowed(sid, expected_perms[:specific]) ]
-  end
-
-  def denied_acl(sid, expected_perms, _flags = 0)
-    [ ACE.access_denied(sid, expected_perms[:specific]) ]
-  end
-
-  def parent_inheritable_acls
-    dummy_file_path = File.join(test_file_dir, "dummy_file")
-    FileUtils.touch(dummy_file_path)
-    dummy_desc = get_security_descriptor(dummy_file_path)
-    FileUtils.rm_rf(dummy_file_path)
-    dummy_desc
-  end
-
-  it_behaves_like "a securable resource without existing target"
-
-  context "when the target file has the wrong content" do
-    before(:each) do
-      File.open(path, "wb") { |f| f.print "This is so wrong!!!" }
-      now = Time.now.to_i
-      File.utime(now - 9000, now - 9000, path)
-
-      @expected_mtime = File.stat(path).mtime
-      @expected_checksum = sha256_checksum(path)
-    end
-
-    describe "and the target file has the correct permissions" do
-      include_context "setup correct permissions"
-
-      it_behaves_like "a file with the wrong content"
-
-      it_behaves_like "a securable resource with existing target"
-    end
-
-    context "and the target file has incorrect permissions" do
-      include_context "setup broken permissions"
-
-      it_behaves_like "a file with the wrong content"
-
-      it_behaves_like "a securable resource with existing target"
-    end
-  end
-
-  context "when the target file has the correct content" do
-    before(:each) do
-      File.open(path, "wb") { |f| f.print expected_content }
-      now = Time.now.to_i
-      File.utime(now - 9000, now - 9000, path)
-
-      @expected_mtime = File.stat(path).mtime
-      @expected_checksum = sha256_checksum(path)
-    end
-
-    describe "and the target file has the correct permissions" do
-
-      # When permissions and content are correct, chef should do nothing and
-      # the resource should not be marked updated.
-      let(:expect_updated?) { false }
-
-      include_context "setup correct permissions"
-
-      it_behaves_like "a file with the correct content"
-
-      it_behaves_like "a securable resource with existing target"
-    end
-
-    context "and the target file has incorrect permissions" do
-      include_context "setup broken permissions"
-
-      it_behaves_like "a file with the correct content"
-
-      it_behaves_like "a securable resource with existing target"
-    end
-  end
-
-  # Regression test for http://tickets.opscode.com/browse/CHEF-4419
-  context "when the path starts with '/' and target file exists", :windows_only do
-    let(:path) do
-      File.join(test_file_dir[2..test_file_dir.length], make_tmpname(file_base))
-    end
-
-    before do
-      File.open(path, "wb") { |f| f.print expected_content }
-      now = Time.now.to_i
-      File.utime(now - 9000, now - 9000, path)
-
-      @expected_mtime = File.stat(path).mtime
-      @expected_checksum = sha256_checksum(path)
-    end
-
-    describe ":create action should run without any updates" do
-      before do
-        # Assert starting state is as expected
-        expect(File).to exist(path)
-        expect(sha256_checksum(path)).to eq(@expected_checksum)
-        resource.run_action(:create)
-      end
-
-      it "does not overwrite the original when the :create action is run" do
-        expect(sha256_checksum(path)).to eq(@expected_checksum)
-      end
-
-      it "does not update the mtime of the file when the :create action is run" do
-        expect(File.stat(path).mtime).to eq(@expected_mtime)
-      end
-
-      it "is not marked as updated by last action" do
-        expect(resource).not_to be_updated_by_last_action
-      end
-    end
-  end
-
-end
-
-shared_context Chef::Resource::File do
-  if windows?
-    require "chef/win32/file"
-  end
-
-  # 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?
-      File.join(ENV["systemdrive"], "test-dir")
-    else
-      File.join(CHEF_SPEC_DATA, "test-dir")
-    end
-  end
-
-  let(:path) do
-    File.join(test_file_dir, make_tmpname(file_base))
-  end
-
-  before do
-    FileUtils.rm_rf(test_file_dir)
-    FileUtils.mkdir_p(test_file_dir)
-  end
-
-  after(:each) do
-    FileUtils.rm_r(path) if File.exists?(path)
-    FileUtils.rm_r(CHEF_SPEC_BACKUP_PATH) if File.exists?(CHEF_SPEC_BACKUP_PATH)
-  end
-
-  after do
-    FileUtils.rm_rf(test_file_dir)
-  end
-end
+#
+# Author:: Seth Chisamore (<schisamo@chef.io>)
+# Copyright:: Copyright 2011-2018, Chef Software 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.
+#
+
+shared_context "deploying with move" do
+  before do
+    Chef::Config[:file_backup_path] = CHEF_SPEC_BACKUP_PATH
+    Chef::Config[:file_atomic_update] = true
+  end
+end
+
+shared_context "deploying with copy" do
+  before do
+    Chef::Config[:file_backup_path] = CHEF_SPEC_BACKUP_PATH
+    Chef::Config[:file_atomic_update] = false
+  end
+end
+
+shared_context "deploying via tmpdir" do
+  before do
+    Chef::Config[:file_staging_uses_destdir] = false
+    Chef::Config[:file_backup_path] = CHEF_SPEC_BACKUP_PATH
+  end
+end
+
+shared_context "deploying via destdir" do
+  before do
+    Chef::Config[:file_staging_uses_destdir] = true
+    Chef::Config[:file_backup_path] = CHEF_SPEC_BACKUP_PATH
+  end
+end
+
+shared_examples_for "a file with the wrong content" do
+  before do
+    # Assert starting state is as expected
+    expect(File).to exist(path)
+    # Kinda weird, in this case @expected_checksum is the cksum of the file
+    # with incorrect content.
+    expect(sha256_checksum(path)).to eq(@expected_checksum)
+  end
+
+  describe "when diff is disabled" do
+
+    include_context "diff disabled"
+
+    context "when running action :create" do
+      context "with backups enabled" do
+        before do
+          resource.run_action(:create)
+        end
+
+        it "overwrites the file with the updated content when the :create action is run" do
+          expect(File.stat(path).mtime).to be > @expected_mtime
+          expect(sha256_checksum(path)).not_to eq(@expected_checksum)
+        end
+
+        it "backs up the existing file" do
+          expect(Dir.glob(backup_glob).size).to equal(1)
+        end
+
+        it "is marked as updated by last action" do
+          expect(resource).to be_updated_by_last_action
+        end
+
+        it "should restore the security contexts on selinux", :selinux_only do
+          expect(selinux_security_context_restored?(path)).to be_truthy
+        end
+      end
+
+      context "with backups disabled" do
+        before do
+          resource.backup(0)
+          resource.run_action(:create)
+        end
+
+        it "should not attempt to backup the existing file if :backup == 0" do
+          expect(Dir.glob(backup_glob).size).to equal(0)
+        end
+
+        it "should restore the security contexts on selinux", :selinux_only do
+          expect(selinux_security_context_restored?(path)).to be_truthy
+        end
+      end
+
+      context "with a checksum that does not match the content to deploy" do
+        before do
+          resource.checksum("aAaAaAaAaAaAaAaAaAaAaAaAaAaAaAaAaAaAaAaAaAaAaAaAaAaAaAaAaAaAaAaA")
+        end
+
+        it "raises an exception" do
+          expect { resource.run_action(:create) }.to raise_error(Chef::Exceptions::ChecksumMismatch)
+        end
+      end
+    end
+
+    describe "when running action :create_if_missing" do
+      before do
+        resource.run_action(:create_if_missing)
+      end
+
+      it "doesn't overwrite the file when the :create_if_missing action is run" do
+        expect(File.stat(path).mtime).to eq(@expected_mtime)
+        expect(sha256_checksum(path)).to eq(@expected_checksum)
+      end
+
+      it "is not marked as updated" do
+        expect(resource).not_to be_updated_by_last_action
+      end
+
+      it "should restore the security contexts on selinux", :selinux_only do
+        expect(selinux_security_context_restored?(path)).to be_truthy
+      end
+    end
+
+    describe "when running action :delete" do
+      before do
+        resource.run_action(:delete)
+      end
+
+      it "deletes the file" do
+        expect(File).not_to exist(path)
+      end
+
+      it "is marked as updated by last action" do
+        expect(resource).to be_updated_by_last_action
+      end
+    end
+
+  end
+
+  context "when diff is enabled" do
+    describe "sensitive attribute" do
+      context "should be insensitive by default" do
+        it { expect(resource.sensitive).to(be_falsey) }
+      end
+
+      context "when set" do
+        before { resource.sensitive(true) }
+
+        it "should be set on the resource" do
+          expect(resource.sensitive).to(be_truthy)
+        end
+
+        context "when running :create action" do
+          let(:provider) { resource.provider_for_action(:create) }
+          let(:reporter_messages) { provider.instance_variable_get("@converge_actions").actions[0][0] }
+
+          before do
+            provider.run_action
+          end
+
+          it "should suppress the diff" do
+            expect(resource.diff).to(include("suppressed sensitive resource"))
+            expect(reporter_messages[1]).to eq("suppressed sensitive resource")
+          end
+
+          it "should still include the updated checksums" do
+            expect(reporter_messages[0]).to include("update content in file")
+          end
+        end
+      end
+    end
+  end
+end
+
+shared_examples_for "a file with the correct content" do
+  before do
+    # Assert starting state is as expected
+    expect(File).to exist(path)
+    expect(sha256_checksum(path)).to eq(@expected_checksum)
+  end
+
+  include_context "diff disabled"
+
+  describe "when running action :create" do
+    before do
+      resource.run_action(:create)
+    end
+    it "does not overwrite the original when the :create action is run" do
+      expect(sha256_checksum(path)).to eq(@expected_checksum)
+    end
+
+    it "does not update the mtime of the file when the :create action is run" do
+      expect(File.stat(path).mtime).to eq(@expected_mtime)
+    end
+
+    it "is not marked as updated by last action" do
+      expect(resource).not_to be_updated_by_last_action
+    end
+
+    it "should restore the security contexts on selinux", :selinux_only do
+      expect(selinux_security_context_restored?(path)).to be_truthy
+    end
+  end
+
+  describe "when running action :create_if_missing" do
+    before do
+      resource.run_action(:create_if_missing)
+    end
+
+    it "doesn't overwrite the file when the :create_if_missing action is run" do
+      expect(sha256_checksum(path)).to eq(@expected_checksum)
+    end
+
+    it "is not marked as updated by last action" do
+      expect(resource).not_to be_updated_by_last_action
+    end
+
+    it "should restore the security contexts on selinux", :selinux_only do
+      expect(selinux_security_context_restored?(path)).to be_truthy
+    end
+  end
+
+  describe "when running action :delete" do
+    before do
+      resource.run_action(:delete)
+    end
+
+    it "deletes the file when the :delete action is run" do
+      expect(File).not_to exist(path)
+    end
+
+    it "is marked as updated by last action" do
+      expect(resource).to be_updated_by_last_action
+    end
+  end
+end
+
+shared_examples_for "a file resource" do
+  describe "when deploying with :move" do
+
+    include_context "deploying with move"
+
+    describe "when deploying via tmpdir" do
+
+      include_context "deploying via tmpdir"
+
+      it_behaves_like "a configured file resource"
+    end
+
+    describe "when deploying via destdir" do
+
+      include_context "deploying via destdir"
+
+      it_behaves_like "a configured file resource"
+    end
+  end
+
+  describe "when deploying with :copy" do
+
+    include_context "deploying with copy"
+
+    describe "when deploying via tmpdir" do
+
+      include_context "deploying via tmpdir"
+
+      it_behaves_like "a configured file resource"
+    end
+
+    describe "when deploying via destdir" do
+
+      include_context "deploying via destdir"
+
+      it_behaves_like "a configured file resource"
+    end
+  end
+
+  describe "when running under why run" do
+
+    before do
+      Chef::Config[:why_run] = true
+      Chef::Config[:ssl_verify_mode] = :verify_none
+    end
+
+    after do
+      Chef::Config[:why_run] = false
+    end
+
+    context "and the resource has a path with a missing intermediate directory" do
+      # CHEF-3978
+
+      let(:path) do
+        File.join(test_file_dir, "intermediate_dir", make_tmpname(file_base))
+      end
+
+      it "successfully doesn't create the file" do
+        resource.run_action(:create) # should not raise
+        expect(File).not_to exist(path)
+      end
+    end
+
+  end
+
+  describe "when setting atomic_update" do
+    it "booleans should work" do
+      expect { resource.atomic_update(true) }.not_to raise_error
+      expect { resource.atomic_update(false) }.not_to raise_error
+    end
+
+    it "anything else should raise an error" do
+      expect { resource.atomic_update(:copy) }.to raise_error(ArgumentError)
+      expect { resource.atomic_update(:move) }.to raise_error(ArgumentError)
+      expect { resource.atomic_update(958) }.to raise_error(ArgumentError)
+    end
+  end
+
+end
+
+shared_examples_for "file resource not pointing to a real file" do
+  def symlink?(file_path)
+    if windows?
+      Chef::ReservedNames::Win32::File.symlink?(file_path)
+    else
+      File.symlink?(file_path)
+    end
+  end
+
+  def real_file?(file_path)
+    !symlink?(file_path) && File.file?(file_path)
+  end
+
+  before do
+    Chef::Config[:ssl_verify_mode] = :verify_none
+  end
+
+  describe "when force_unlink is set to true" do
+    it ":create unlinks the target" do
+      expect(real_file?(path)).to be_falsey
+      resource.force_unlink(true)
+      resource.run_action(:create)
+      expect(real_file?(path)).to be_truthy
+      expect(binread(path)).to eq(expected_content)
+      expect(resource).to be_updated_by_last_action
+    end
+  end
+
+  describe "when force_unlink is set to false" do
+    it ":create raises an error" do
+      expect { resource.run_action(:create) }.to raise_error(Chef::Exceptions::FileTypeMismatch)
+    end
+  end
+
+  describe "when force_unlink is not set (default)" do
+    it ":create raises an error" do
+      expect { resource.run_action(:create) }.to raise_error(Chef::Exceptions::FileTypeMismatch)
+    end
+  end
+end
+
+shared_examples_for "a configured file resource" do
+
+  include_context "diff disabled"
+
+  before do
+    Chef::Log.level = :info
+    Chef::Config[:ssl_verify_mode] = :verify_none
+  end
+
+   # note the stripping of the drive letter from the tmpdir on windows
+  let(:backup_glob) { File.join(CHEF_SPEC_BACKUP_PATH, test_file_dir.sub(/^([A-Za-z]:)/, ""), "#{file_base}*") }
+
+  # Most tests update the resource, but a few do not. We need to test that the
+  # resource is marked updated or not correctly, but the test contexts are
+  # composed between correct/incorrect content and correct/incorrect
+  # permissions. We override this "let" definition in the context where content
+  # and permissions are correct.
+  let(:expect_updated?) { true }
+
+  include Chef::Mixin::ShellOut
+
+  def selinux_security_context_restored?(path)
+    @restorecon_path = which("restorecon") if @restorecon_path.nil?
+    restorecon_test_command = "#{@restorecon_path} -n -v #{path}"
+    cmdresult = shell_out!(restorecon_test_command)
+    # restorecon will print the required changes to stdout if any is
+    # needed
+    cmdresult.stdout.empty?
+  end
+
+  def binread(file)
+    content = File.open(file, "rb") do |f|
+      f.read
+    end
+    content.force_encoding(Encoding::BINARY) if "".respond_to?(:force_encoding)
+    content
+  end
+
+  context "when the target file is a symlink" do
+    let(:symlink_target) do
+      File.join(CHEF_SPEC_DATA, "file-test-target")
+    end
+
+    describe "when configured not to manage symlink's target" do
+      before(:each) do
+        # configure not to manage symlink source
+        resource.manage_symlink_source(false)
+
+        # create symlinks for test context
+        FileUtils.touch(symlink_target)
+
+        if windows?
+          Chef::ReservedNames::Win32::File.symlink(symlink_target, path)
+        else
+          File.symlink(symlink_target, path)
+        end
+      end
+
+      after(:each) do
+        FileUtils.rm_rf(symlink_target)
+        FileUtils.rm_rf(path)
+      end
+
+      describe "when symlink target has correct content" do
+        before(:each) do
+          File.open(symlink_target, "wb") { |f| f.print expected_content }
+        end
+
+        it_behaves_like "file resource not pointing to a real file"
+      end
+
+      describe "when symlink target has the wrong content" do
+        before(:each) do
+          File.open(symlink_target, "wb") { |f| f.print "This is so wrong!!!" }
+        end
+
+        after(:each) do
+          # symlink should never be followed
+          expect(binread(symlink_target)).to eq("This is so wrong!!!")
+        end
+
+        it_behaves_like "file resource not pointing to a real file"
+      end
+    end
+
+    # Unix-only for now. Windows behavior may differ because of how ACL
+    # management handles symlinks. Since symlinks are rare on Windows and this
+    # feature primarily exists to support the case where a well-known file
+    # (e.g., resolv.conf) has been converted to a symlink, we're okay with the
+    # discrepancy.
+    context "when configured to manage the symlink source", :unix_only do
+
+      before do
+        resource.manage_symlink_source(true)
+      end
+
+      context "but the symlink is part of a loop" do
+        let(:link1_path) { File.join(CHEF_SPEC_DATA, "points-to-link2") }
+        let(:link2_path) { File.join(CHEF_SPEC_DATA, "points-to-link1") }
+
+        before do
+          # point resource at link1:
+          resource.path(link1_path)
+          # create symlinks for test context
+          File.symlink(link1_path, link2_path)
+          File.symlink(link2_path, link1_path)
+        end
+
+        after(:each) do
+          FileUtils.rm_rf(link1_path)
+          FileUtils.rm_rf(link2_path)
+        end
+
+        it "raises an InvalidSymlink error" do
+          expect { resource.run_action(:create) }.to raise_error(Chef::Exceptions::InvalidSymlink)
+        end
+
+        it "issues a warning/assumption in whyrun mode" do
+          begin
+            Chef::Config[:why_run] = true
+            resource.run_action(:create) # should not raise
+          ensure
+            Chef::Config[:why_run] = false
+          end
+        end
+      end
+
+      context "but the symlink points to a nonexistent file" do
+        let(:link_path) { File.join(CHEF_SPEC_DATA, "points-to-nothing") }
+        let(:not_existent_source) { File.join(CHEF_SPEC_DATA, "i-am-not-here") }
+
+        before do
+          resource.path(link_path)
+          # create symlinks for test context
+          File.symlink(not_existent_source, link_path)
+          FileUtils.rm_rf(not_existent_source)
+        end
+
+        after(:each) do
+          FileUtils.rm_rf(link_path)
+        end
+        it "raises an InvalidSymlink error" do
+          expect { resource.run_action(:create) }.to raise_error(Chef::Exceptions::InvalidSymlink)
+        end
+
+        it "issues a warning/assumption in whyrun mode" do
+          begin
+            Chef::Config[:why_run] = true
+            resource.run_action(:create) # should not raise
+          ensure
+            Chef::Config[:why_run] = false
+          end
+        end
+      end
+
+      context "but the symlink is points to a non-file fs entry" do
+        let(:link_path) { File.join(CHEF_SPEC_DATA, "points-to-dir") }
+        let(:not_a_file_path) { File.join(CHEF_SPEC_DATA, "dir-at-end-of-symlink") }
+
+        before do
+          # point resource at link1:
+          resource.path(link_path)
+          # create symlinks for test context
+          File.symlink(not_a_file_path, link_path)
+          Dir.mkdir(not_a_file_path)
+        end
+
+        after(:each) do
+          FileUtils.rm_rf(link_path)
+          FileUtils.rm_rf(not_a_file_path)
+        end
+
+        it "raises an InvalidSymlink error" do
+          expect { resource.run_action(:create) }.to raise_error(Chef::Exceptions::FileTypeMismatch)
+        end
+
+        it "issues a warning/assumption in whyrun mode" do
+          begin
+            Chef::Config[:why_run] = true
+            resource.run_action(:create) # should not raise
+          ensure
+            Chef::Config[:why_run] = false
+          end
+        end
+      end
+
+      context "when the symlink source is a real file" do
+
+        let(:wrong_content) { "this is the wrong content" }
+        let(:link_path) { File.join(CHEF_SPEC_DATA, "points-to-real-file") }
+
+        before do
+          # point resource at link:
+          resource.path(link_path)
+          # create symlinks for test context
+          File.symlink(path, link_path)
+        end
+
+        after(:each) do
+          # shared examples should not change our test setup of a file resource
+          # pointing at a symlink:
+          expect(resource.path).to eq(link_path)
+          FileUtils.rm_rf(link_path)
+        end
+
+        context "and the permissions are incorrect" do
+          before do
+            # Create source (real) file
+            File.open(path, "wb") { |f| f.write(expected_content) }
+          end
+
+          include_context "setup broken permissions"
+
+          include_examples "a securable resource with existing target"
+
+          it "does not replace the symlink with a real file" do
+            resource.run_action(:create)
+            expect(File).to be_symlink(link_path)
+          end
+
+        end
+
+        context "and the content is incorrect" do
+          before do
+            # Create source (real) file
+            File.open(path, "wb") { |f| f.write(wrong_content) }
+          end
+
+          it "marks the resource as updated" do
+            resource.run_action(:create)
+            expect(resource).to be_updated_by_last_action
+          end
+
+          it "does not replace the symlink with a real file" do
+            resource.run_action(:create)
+            expect(File).to be_symlink(link_path)
+          end
+        end
+
+        context "and the content and permissions are correct" do
+          let(:expect_updated?) { false }
+
+          before do
+            # Create source (real) file
+            File.open(path, "wb") { |f| f.write(expected_content) }
+          end
+          include_context "setup correct permissions"
+
+          include_examples "a securable resource with existing target"
+
+        end
+
+      end
+
+      context "when the symlink points to a symlink which points to a real file" do
+
+        let(:wrong_content) { "this is the wrong content" }
+        let(:link_to_file_path) { File.join(CHEF_SPEC_DATA, "points-to-real-file") }
+        let(:link_to_link_path) { File.join(CHEF_SPEC_DATA, "points-to-next-link") }
+
+        before do
+          # point resource at link:
+          resource.path(link_to_link_path)
+          # create symlinks for test context
+          File.symlink(path, link_to_file_path)
+          File.symlink(link_to_file_path, link_to_link_path)
+
+          # Create source (real) file
+          File.open(path, "wb") { |f| f.write(wrong_content) }
+        end
+
+        include_context "setup broken permissions"
+
+        include_examples "a securable resource with existing target"
+
+        after(:each) do
+          # shared examples should not change our test setup of a file resource
+          # pointing at a symlink:
+          expect(resource.path).to eq(link_to_link_path)
+          FileUtils.rm_rf(link_to_file_path)
+          FileUtils.rm_rf(link_to_link_path)
+        end
+
+        it "does not replace the symlink with a real file" do
+          resource.run_action(:create)
+          expect(File).to be_symlink(link_to_link_path)
+          expect(File).to be_symlink(link_to_file_path)
+        end
+
+      end
+    end
+  end
+
+  context "when the target file does not exist" do
+    before(:each) do
+      FileUtils.rm_rf(path)
+    end
+
+    after(:each) do
+      FileUtils.rm_rf(path)
+    end
+
+    def symlink?(file_path)
+      if windows?
+        Chef::ReservedNames::Win32::File.symlink?(file_path)
+      else
+        File.symlink?(file_path)
+      end
+    end
+
+    def real_file?(file_path)
+      !symlink?(file_path) && File.file?(file_path)
+    end
+
+    describe "when force_unlink is set to true" do
+      it ":create updates the target" do
+        resource.force_unlink(true)
+        resource.run_action(:create)
+        expect(real_file?(path)).to be_truthy
+        expect(binread(path)).to eq(expected_content)
+        expect(resource).to be_updated_by_last_action
+      end
+    end
+
+    describe "when force_unlink is set to false" do
+      it ":create updates the target" do
+        resource.force_unlink(true)
+        resource.run_action(:create)
+        expect(real_file?(path)).to be_truthy
+        expect(binread(path)).to eq(expected_content)
+        expect(resource).to be_updated_by_last_action
+      end
+    end
+
+    describe "when force_unlink is not set (default)" do
+      it ":create updates the target" do
+        resource.force_unlink(true)
+        resource.run_action(:create)
+        expect(real_file?(path)).to be_truthy
+        expect(binread(path)).to eq(expected_content)
+        expect(resource).to be_updated_by_last_action
+      end
+    end
+  end
+
+  context "when the target file is a directory" do
+    before(:each) do
+      FileUtils.mkdir_p(path)
+    end
+
+    after(:each) do
+      FileUtils.rm_rf(path)
+    end
+
+    it_behaves_like "file resource not pointing to a real file"
+  end
+
+  context "when the target file is a blockdev", :unix_only, :requires_root, :not_supported_on_solaris do
+    include Chef::Mixin::ShellOut
+    let(:path) do
+      File.join(CHEF_SPEC_DATA, "testdev")
+    end
+
+    before(:each) do
+      result = shell_out!("mknod #{path} b 1 2")
+      result.stderr.empty?
+    end
+
+    after(:each) do
+      FileUtils.rm_rf(path)
+    end
+
+    it_behaves_like "file resource not pointing to a real file"
+  end
+
+  context "when the target file is a chardev", :unix_only, :requires_root, :not_supported_on_solaris do
+    include Chef::Mixin::ShellOut
+    let(:path) do
+      File.join(CHEF_SPEC_DATA, "testdev")
+    end
+
+    before(:each) do
+      result = shell_out!("mknod #{path} c 1 2")
+      result.stderr.empty?
+    end
+
+    after(:each) do
+      FileUtils.rm_rf(path)
+    end
+
+    it_behaves_like "file resource not pointing to a real file"
+  end
+
+  context "when the target file is a pipe", :unix_only do
+    include Chef::Mixin::ShellOut
+    let(:path) do
+      File.join(CHEF_SPEC_DATA, "testpipe")
+    end
+
+    before(:each) do
+      result = shell_out!("mkfifo #{path}")
+      result.stderr.empty?
+    end
+
+    after(:each) do
+      FileUtils.rm_rf(path)
+    end
+
+    it_behaves_like "file resource not pointing to a real file"
+  end
+
+  context "when the target file is a socket", :unix_only do
+    require "socket"
+
+    # It turns out that the path to a socket can have at most ~104
+    # bytes. Therefore we are creating our sockets in tmpdir so that
+    # they have a shorter path.
+    let(:test_socket_dir) { File.join(Dir.tmpdir, "sockets") }
+
+    before do
+      FileUtils.mkdir_p(test_socket_dir)
+    end
+
+    after do
+      FileUtils.rm_rf(test_socket_dir)
+    end
+
+    let(:path) do
+      File.join(test_socket_dir, "testsocket")
+    end
+
+    before(:each) do
+      expect(path.bytesize).to be <= 104
+      UNIXServer.new(path)
+    end
+
+    after(:each) do
+      FileUtils.rm_rf(path)
+    end
+
+    it_behaves_like "file resource not pointing to a real file"
+  end
+
+  # Regression test for http://tickets.opscode.com/browse/CHEF-4082
+  context "when notification is configured" do
+    describe "when path is specified with normal separator" do
+      before do
+        @notified_resource = Chef::Resource.new("punk", resource.run_context)
+        resource.notifies(:run, @notified_resource, :immediately)
+        resource.run_action(:create)
+      end
+
+      it "should notify the other resources correctly" do
+        expect(resource).to be_updated_by_last_action
+        expect(resource.run_context.immediate_notifications(resource).length).to eq(1)
+      end
+    end
+
+    describe "when path is specified with windows separator", :windows_only do
+      let(:path) do
+        File.join(test_file_dir, make_tmpname(file_base)).gsub(::File::SEPARATOR, ::File::ALT_SEPARATOR)
+      end
+
+      before do
+        @notified_resource = Chef::Resource.new("punk", resource.run_context)
+        resource.notifies(:run, @notified_resource, :immediately)
+        resource.run_action(:create)
+      end
+
+      it "should notify the other resources correctly" do
+        expect(resource).to be_updated_by_last_action
+        expect(resource.run_context.immediate_notifications(resource).length).to eq(1)
+      end
+    end
+  end
+
+  context "when the target file does not exist" do
+    before do
+      # Assert starting state is expected
+      expect(File).not_to exist(path)
+    end
+
+    describe "when running action :create" do
+      before do
+        resource.run_action(:create)
+      end
+
+      it "creates the file when the :create action is run" do
+        expect(File).to exist(path)
+      end
+
+      it "creates the file with the correct content when the :create action is run" do
+        expect(binread(path)).to eq(expected_content)
+      end
+
+      it "is marked as updated by last action" do
+        expect(resource).to be_updated_by_last_action
+      end
+
+      it "should restore the security contexts on selinux", :selinux_only do
+        expect(selinux_security_context_restored?(path)).to be_truthy
+      end
+    end
+
+    describe "when running action :create_if_missing" do
+      before do
+        resource.run_action(:create_if_missing)
+      end
+
+      it "creates the file with the correct content" do
+        expect(binread(path)).to eq(expected_content)
+      end
+
+      it "is marked as updated by last action" do
+        expect(resource).to be_updated_by_last_action
+      end
+
+      it "should restore the security contexts on selinux", :selinux_only do
+        expect(selinux_security_context_restored?(path)).to be_truthy
+      end
+    end
+
+    describe "when running action :delete" do
+      before do
+        resource.run_action(:delete)
+      end
+
+      it "deletes the file when the :delete action is run" do
+        expect(File).not_to exist(path)
+      end
+
+      it "is not marked updated by last action" do
+        expect(resource).not_to be_updated_by_last_action
+      end
+    end
+  end
+
+  # Set up the context for security tests
+  def allowed_acl(sid, expected_perms, _flags = 0)
+    [ ACE.access_allowed(sid, expected_perms[:specific]) ]
+  end
+
+  def denied_acl(sid, expected_perms, _flags = 0)
+    [ ACE.access_denied(sid, expected_perms[:specific]) ]
+  end
+
+  def parent_inheritable_acls
+    dummy_file_path = File.join(test_file_dir, "dummy_file")
+    FileUtils.touch(dummy_file_path)
+    dummy_desc = get_security_descriptor(dummy_file_path)
+    FileUtils.rm_rf(dummy_file_path)
+    dummy_desc
+  end
+
+  it_behaves_like "a securable resource without existing target"
+
+  context "when the target file has the wrong content" do
+    before(:each) do
+      File.open(path, "wb") { |f| f.print "This is so wrong!!!" }
+      now = Time.now.to_i
+      File.utime(now - 9000, now - 9000, path)
+
+      @expected_mtime = File.stat(path).mtime
+      @expected_checksum = sha256_checksum(path)
+    end
+
+    describe "and the target file has the correct permissions" do
+      include_context "setup correct permissions"
+
+      it_behaves_like "a file with the wrong content"
+
+      it_behaves_like "a securable resource with existing target"
+    end
+
+    context "and the target file has incorrect permissions" do
+      include_context "setup broken permissions"
+
+      it_behaves_like "a file with the wrong content"
+
+      it_behaves_like "a securable resource with existing target"
+    end
+  end
+
+  context "when the target file has the correct content" do
+    before(:each) do
+      File.open(path, "wb") { |f| f.print expected_content }
+      now = Time.now.to_i
+      File.utime(now - 9000, now - 9000, path)
+
+      @expected_mtime = File.stat(path).mtime
+      @expected_checksum = sha256_checksum(path)
+    end
+
+    describe "and the target file has the correct permissions" do
+
+      # When permissions and content are correct, chef should do nothing and
+      # the resource should not be marked updated.
+      let(:expect_updated?) { false }
+
+      include_context "setup correct permissions"
+
+      it_behaves_like "a file with the correct content"
+
+      it_behaves_like "a securable resource with existing target"
+    end
+
+    context "and the target file has incorrect permissions" do
+      include_context "setup broken permissions"
+
+      it_behaves_like "a file with the correct content"
+
+      it_behaves_like "a securable resource with existing target"
+    end
+  end
+
+  # Regression test for http://tickets.opscode.com/browse/CHEF-4419
+  context "when the path starts with '/' and target file exists", :windows_only do
+    let(:path) do
+      File.join(test_file_dir[2..test_file_dir.length], make_tmpname(file_base))
+    end
+
+    before do
+      File.open(path, "wb") { |f| f.print expected_content }
+      now = Time.now.to_i
+      File.utime(now - 9000, now - 9000, path)
+
+      @expected_mtime = File.stat(path).mtime
+      @expected_checksum = sha256_checksum(path)
+    end
+
+    describe ":create action should run without any updates" do
+      before do
+        # Assert starting state is as expected
+        expect(File).to exist(path)
+        expect(sha256_checksum(path)).to eq(@expected_checksum)
+        resource.run_action(:create)
+      end
+
+      it "does not overwrite the original when the :create action is run" do
+        expect(sha256_checksum(path)).to eq(@expected_checksum)
+      end
+
+      it "does not update the mtime of the file when the :create action is run" do
+        expect(File.stat(path).mtime).to eq(@expected_mtime)
+      end
+
+      it "is not marked as updated by last action" do
+        expect(resource).not_to be_updated_by_last_action
+      end
+    end
+  end
+
+end
+
+shared_context Chef::Resource::File do
+  if windows?
+    require "chef/win32/file"
+  end
+
+  # 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?
+      File.join(ENV["systemdrive"], "test-dir")
+    else
+      File.join(CHEF_SPEC_DATA, "test-dir")
+    end
+  end
+
+  let(:path) do
+    File.join(test_file_dir, make_tmpname(file_base))
+  end
+
+  before do
+    FileUtils.rm_rf(test_file_dir)
+    FileUtils.mkdir_p(test_file_dir)
+  end
+
+  after(:each) do
+    FileUtils.rm_r(path) if File.exists?(path)
+    FileUtils.rm_r(CHEF_SPEC_BACKUP_PATH) if File.exists?(CHEF_SPEC_BACKUP_PATH)
+  end
+
+  after do
+    FileUtils.rm_rf(test_file_dir)
+  end
+end