chef 18.8.11 → 18.8.54

data/spec/unit/file_cache_spec.rb

@@ -1,178 +0,0 @@
-#
-# Author:: Adam Jacob (<adam@chef.io>)
-# Copyright:: Copyright (c) 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.
-#
-
-require "spec_helper"
-
-describe Chef::FileCache do
-  before do
-    @file_cache_path = Dir.mktmpdir
-    Chef::Config[:file_cache_path] = @file_cache_path
-    @io = StringIO.new
-  end
-
-  after do
-    FileUtils.rm_rf(Chef::Config[:file_cache_path])
-  end
-
-  describe "when the relative path to the cache file doesn't exist" do
-    it "creates intermediate directories as needed" do
-      Chef::FileCache.store("whiz/bang", "I found a poop")
-      expect(File).to exist(File.join(@file_cache_path, "whiz"))
-    end
-
-    it "creates the cached file at the correct relative path" do
-      expect(File).to receive(:open).with(File.join(@file_cache_path, "whiz", "bang"), "w", 416).and_yield(@io)
-      Chef::FileCache.store("whiz/bang", "borkborkbork")
-    end
-
-  end
-
-  describe "when storing a file" do
-    before do
-      allow(File).to receive(:open).and_yield(@io)
-    end
-
-    it "should print the contents to the file" do
-      Chef::FileCache.store("whiz/bang", "borkborkbork")
-      expect(@io.string).to eq("borkborkbork")
-    end
-
-  end
-
-  describe "when loading cached files" do
-    it "finds and reads the cached file" do
-      FileUtils.mkdir_p(File.join(@file_cache_path, "whiz"))
-      File.open(File.join(@file_cache_path, "whiz", "bang"), "w") { |f| f.print("borkborkbork") }
-      expect(Chef::FileCache.load("whiz/bang")).to eq("borkborkbork")
-    end
-
-    it "should raise a Chef::Exceptions::FileNotFound if the file doesn't exist" do
-      expect { Chef::FileCache.load("whiz/bang") }.to raise_error(Chef::Exceptions::FileNotFound)
-    end
-  end
-
-  describe "when deleting cached files" do
-    before(:each) do
-      FileUtils.mkdir_p(File.join(@file_cache_path, "whiz"))
-      File.open(File.join(@file_cache_path, "whiz", "bang"), "w") { |f| f.print("borkborkbork") }
-    end
-
-    it "unlinks the file" do
-      Chef::FileCache.delete("whiz/bang")
-      expect(File).not_to exist(File.join(@file_cache_path, "whiz", "bang"))
-    end
-
-  end
-
-  describe "when listing files in the cache" do
-    before(:each) do
-      FileUtils.mkdir_p(File.join(@file_cache_path, "whiz"))
-      FileUtils.touch(File.join(@file_cache_path, "whiz", "bang"))
-      FileUtils.mkdir_p(File.join(@file_cache_path, "snappy"))
-      FileUtils.touch(File.join(@file_cache_path, "snappy", "patter"))
-    end
-
-    it "should return the relative paths" do
-      expect(Chef::FileCache.list.sort).to eq(%w{snappy/patter whiz/bang})
-    end
-
-    it "searches for cached files by globbing" do
-      expect(Chef::FileCache.find("snappy/**/*")).to eq(%w{snappy/patter})
-    end
-  end
-
-  describe "#find handles regex-unsafe unix paths" do
-    before(:each) do
-      # Dir.mktmpdir doesn't allow regex unsafe characters (the nerve!), so we'll have to fake file lookups
-      @file_cache_path = "/tmp/[foo* ^bar]"
-      escaped_file_cache_path = '/tmp/\[foo\* ^bar\]'
-      Chef::Config[:file_cache_path] = @file_cache_path
-      allow(Chef::Util::PathHelper).to receive(:escape_glob_dir).and_return(escaped_file_cache_path)
-      allow(Dir).to receive(:[]).with(File.join(escaped_file_cache_path, "snappy/**/*")).and_return([
-        File.join(@file_cache_path, "snappy"),
-        File.join(@file_cache_path, "snappy", "patter"),
-      ])
-      allow(Dir).to receive(:[]).with(escaped_file_cache_path).and_return([
-        @file_cache_path,
-      ])
-      [
-        File.join(@file_cache_path, "snappy", "patter"),
-        File.join(@file_cache_path, "whiz", "bang"),
-      ].each do |f|
-        allow(File).to receive(:file?).with(f).and_return(true)
-      end
-      [
-        File.join(@file_cache_path, "snappy"),
-        File.join(@file_cache_path, "whiz"),
-      ].each do |f|
-        allow(File).to receive(:file?).with(f).and_return(false)
-      end
-    end
-
-    it "searches for cached files by globbing" do
-      expect(Chef::FileCache.find("snappy/**/*")).to eq(%w{snappy/patter})
-    end
-  end
-
-  describe "#find handles Windows paths" do
-    before(:each) do
-      allow(ChefUtils).to receive(:windows?).and_return(true)
-      @file_cache_path = 'C:\tmp\fakecache'
-      escaped_file_cache_path = "C:\\tmp\\fakecache"
-      Chef::Config[:file_cache_path] = @file_cache_path
-      allow(Chef::Util::PathHelper).to receive(:escape_glob_dir).and_return(escaped_file_cache_path)
-      allow(Dir).to receive(:[]).with(File.join(escaped_file_cache_path, "snappy/**/*")).and_return([
-        File.join(@file_cache_path, "snappy"),
-        File.join(@file_cache_path, "snappy", "patter"),
-      ])
-      allow(Dir).to receive(:[]).with(escaped_file_cache_path).and_return([
-        @file_cache_path,
-      ])
-      [
-        File.join(@file_cache_path, "snappy", "patter"),
-        File.join(@file_cache_path, "whiz", "bang"),
-      ].each do |f|
-        allow(File).to receive(:file?).with(f).and_return(true)
-      end
-      [
-        File.join(@file_cache_path, "snappy"),
-        File.join(@file_cache_path, "whiz"),
-      ].each do |f|
-        allow(File).to receive(:file?).with(f).and_return(false)
-      end
-    end
-    it "searches for cached files by globbing" do
-      expect(Chef::FileCache.find("snappy/**/*")).to eq(%w{snappy/patter})
-    end
-  end
-
-  describe "when checking for the existence of a file" do
-    before do
-      FileUtils.mkdir_p(File.join(@file_cache_path, "whiz"))
-    end
-
-    it "has a key if the corresponding cache file exists" do
-      FileUtils.touch(File.join(@file_cache_path, "whiz", "bang"))
-      expect(Chef::FileCache).to have_key("whiz/bang")
-    end
-
-    it "doesn't have a key if the corresponding cache file doesn't exist" do
-      expect(Chef::FileCache).not_to have_key("whiz/bang")
-    end
-  end
-end

data/spec/unit/file_content_management/deploy/cp_spec.rb

@@ -1,44 +0,0 @@
-#
-# Author:: Daniel DeLeo (<dan@chef.io>)
-# Copyright:: Copyright (c) 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.
-#
-
-require "spec_helper"
-
-describe Chef::FileContentManagement::Deploy::Cp do
-
-  let(:content_deployer) { described_class.new }
-  let(:target_file_path) { "/etc/my_app.conf" }
-
-  describe "creating the file" do
-
-    it "touches the file to create it" do
-      expect(FileUtils).to receive(:touch).with(target_file_path)
-      content_deployer.create(target_file_path)
-    end
-  end
-
-  describe "updating the file" do
-
-    let(:staging_file_path) { "/tmp/random-dir/staging-file.tmp" }
-
-    it "copies the staging file's content" do
-      expect(FileUtils).to receive(:cp).with(staging_file_path, target_file_path)
-      content_deployer.deploy(staging_file_path, target_file_path)
-    end
-
-  end
-end

data/spec/unit/file_content_management/deploy/mv_unix_spec.rb

@@ -1,113 +0,0 @@
-#
-# Author:: Daniel DeLeo (<dan@chef.io>)
-# Copyright:: Copyright (c) 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.
-#
-
-require "spec_helper"
-
-describe Chef::FileContentManagement::Deploy::MvUnix do
-
-  let(:content_deployer) { described_class.new }
-  let(:target_file_path) { "/etc/my_app.conf" }
-
-  describe "creating the file" do
-
-    it "touches the file to create it" do
-      expect(FileUtils).to receive(:touch).with(target_file_path)
-      content_deployer.create(target_file_path)
-    end
-  end
-
-  describe "updating the file" do
-
-    let(:staging_file_path) { "/tmp/random-dir/staging-file.tmp" }
-
-    let(:target_file_mode) { 0644 }
-    let(:target_file_stat) do
-      double "File::Stat struct for target file",
-        mode: target_file_mode,
-        uid: target_file_uid,
-        gid: target_file_gid
-    end
-
-    before do
-      expect(File).to receive(:stat).with(target_file_path).and_return(target_file_stat)
-      expect(File).to receive(:chmod).with(target_file_mode, staging_file_path).and_return(1)
-      expect(FileUtils).to receive(:mv).with(staging_file_path, target_file_path)
-    end
-
-    # This context represents the case where:
-    # * Chef runs as root
-    # * The owner and group of the target file match the owner and group of the
-    #   staging file.
-    context "when the user has permissions to set file ownership" do
-
-      # For the purposes of this test, the uid/gid can be anything. These
-      # values are just chosen because (assuming chef-client's euid == 1001 and
-      # egid == 1001), the `chown` call is allowed by the OS. See the
-      # description of `EPERM` in `man 2 chown` for reference.
-      let(:target_file_uid) { 1001 }
-      let(:target_file_gid) { 1001 }
-
-      before do
-        expect(File).to receive(:chown).with(target_file_uid, nil, staging_file_path).and_return(1)
-        expect(File).to receive(:chown).with(nil, target_file_gid, staging_file_path).and_return(1)
-      end
-
-      it "fixes up permissions and moves the file into place" do
-        content_deployer.deploy(staging_file_path, target_file_path)
-      end
-
-    end
-
-    context "when the user does not have permissions to set file ownership" do
-
-      # The test code does not care what these values are. These values are
-      # chosen because they're representative of the case that chef-client is
-      # running as non-root and is managing a file that got ownership set to
-      # root somehow. In this example, gid==20 is something like "staff" which
-      # the user running chef-client is a member of (but it's not that user's
-      # primary group).
-      let(:target_file_uid) { 0 }
-      let(:target_file_gid) { 20 }
-
-      before do
-        expect(File).to receive(:chown).with(target_file_uid, nil, staging_file_path).and_raise(Errno::EPERM)
-        expect(File).to receive(:chown).with(nil, target_file_gid, staging_file_path).and_raise(Errno::EPERM)
-
-        expect(Chef::Log).to receive(:warn).with(/^Could not set uid/)
-        expect(Chef::Log).to receive(:warn).with(/^Could not set gid/)
-      end
-
-      it "fixes up permissions and moves the file into place" do
-        content_deployer.deploy(staging_file_path, target_file_path)
-      end
-    end
-
-  end
-
-  describe "when testing against real files", unix_only: true do
-    it "preserves sticky bits" do
-      staging_file = Tempfile.new("staging_file")
-      target_file = Tempfile.new("target_file")
-      File.chmod(04755, target_file.path)
-      content_deployer.deploy(staging_file.path, target_file.path)
-      expect(::File.stat(target_file.path).mode & 07777).to eql(04755)
-      staging_file.unlink
-      target_file.unlink
-    end
-  end
-end

data/spec/unit/file_content_management/deploy/mv_windows_spec.rb

@@ -1,232 +0,0 @@
-#
-# Author:: Daniel DeLeo (<dan@chef.io>)
-# Copyright:: Copyright (c) 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.
-#
-
-require "spec_helper"
-
-unless ChefUtils.windows?
-  class Chef
-    module ReservedNames
-      module Win32
-        module Security
-          ACL = Object.new
-          SecurableObject = Object.new
-        end
-      end
-    end
-  end
-end
-
-require "chef/file_content_management/deploy/mv_windows"
-
-describe Chef::FileContentManagement::Deploy::MvWindows do
-
-  let(:content_deployer) { described_class.new }
-  let(:target_file_path) { "/etc/my_app.conf" }
-
-  describe "creating the file" do
-
-    it "touches the file to create it" do
-      expect(FileUtils).to receive(:touch).with(target_file_path)
-      content_deployer.create(target_file_path)
-    end
-  end
-
-  describe "updating the file" do
-
-    let(:staging_file_path) { "/tmp/random-dir/staging-file.tmp" }
-
-    let(:target_file_security_object) do
-      double "Securable Object for target file"
-    end
-
-    let(:updated_target_security_object) do
-      double "Securable Object for target file after staging file deploy"
-    end
-
-    before do
-      allow(Chef::ReservedNames::Win32::Security::SecurableObject)
-        .to receive(:new)
-        .with(target_file_path)
-        .and_return(target_file_security_object, updated_target_security_object)
-
-    end
-
-    context "when run without administrator privileges" do
-      before do
-        expect(target_file_security_object).to receive(:security_descriptor).and_raise(Chef::Exceptions::Win32APIError)
-      end
-
-      it "errors out with a WindowsNotAdmin error" do
-        expect { content_deployer.deploy(staging_file_path, target_file_path) }.to raise_error(Chef::Exceptions::WindowsNotAdmin)
-      end
-
-    end
-
-    context "when run with administrator privileges" do
-
-      let(:original_target_file_owner) { double("original target file owner") }
-      let(:original_target_file_group) { double("original target file group") }
-
-      let(:target_file_security_descriptor) do
-        double "security descriptor for target file",
-          group: original_target_file_group,
-          owner: original_target_file_owner
-      end
-
-      let(:updated_target_security_descriptor) do
-        double "security descriptor for target file"
-      end
-
-      before do
-        allow(target_file_security_object).to receive(:security_descriptor).and_return(target_file_security_descriptor)
-
-        expect(FileUtils).to receive(:mv).with(staging_file_path, target_file_path)
-
-        expect(updated_target_security_object).to receive(:group=).with(original_target_file_group)
-        expect(updated_target_security_object).to receive(:owner=).with(original_target_file_owner)
-      end
-
-      context "and the target file has no dacl or sacl" do
-
-        before do
-          allow(target_file_security_descriptor).to receive(:dacl_present?).and_return(false)
-          allow(target_file_security_descriptor).to receive(:sacl_present?).and_return(false)
-        end
-
-        it "fixes up permissions and moves the file into place" do
-          content_deployer.deploy(staging_file_path, target_file_path)
-        end
-
-      end
-
-      context "and the target file has null dacl and sacl" do
-
-        before do
-          allow(target_file_security_descriptor).to receive(:dacl_present?).and_return(true)
-          allow(target_file_security_descriptor).to receive(:dacl).and_return(nil)
-          allow(target_file_security_descriptor).to receive(:dacl_inherits?).and_return(false)
-
-          allow(target_file_security_descriptor).to receive(:sacl_present?).and_return(true)
-          allow(target_file_security_descriptor).to receive(:sacl).and_return(nil)
-          allow(target_file_security_descriptor).to receive(:sacl_inherits?).and_return(false)
-
-          expect(updated_target_security_object).to receive(:set_dacl).with(nil, false)
-          expect(updated_target_security_object).to receive(:set_sacl).with(nil, false)
-        end
-
-        it "fixes up permissions and moves the file into place" do
-          content_deployer.deploy(staging_file_path, target_file_path)
-        end
-
-      end
-
-      context "and the target has an empty dacl and sacl" do
-        let(:original_target_file_dacl) { [] }
-        let(:original_target_file_sacl) { [] }
-
-        let(:empty_dacl) { double("Windows ACL with no dacl ACEs") }
-        let(:empty_sacl) { double("Windows ACL with no sacl ACEs") }
-
-        before do
-          allow(target_file_security_descriptor).to receive(:dacl_present?).and_return(true)
-          allow(target_file_security_descriptor).to receive(:dacl_inherits?).and_return(false)
-
-          allow(target_file_security_descriptor).to receive(:dacl).and_return(original_target_file_dacl)
-          expect(Chef::ReservedNames::Win32::Security::ACL)
-            .to receive(:create)
-            .with([])
-            .and_return(empty_dacl)
-
-          allow(target_file_security_descriptor).to receive(:sacl_present?).and_return(true)
-          allow(target_file_security_descriptor).to receive(:sacl_inherits?).and_return(false)
-
-          allow(target_file_security_descriptor).to receive(:sacl).and_return(original_target_file_sacl)
-          expect(Chef::ReservedNames::Win32::Security::ACL)
-            .to receive(:create)
-            .with([])
-            .and_return(empty_sacl)
-
-          expect(updated_target_security_object).to receive(:set_dacl).with(empty_dacl, false)
-          expect(updated_target_security_object).to receive(:set_sacl).with(empty_sacl, false)
-        end
-
-        it "fixes up permissions and moves the file into place" do
-          content_deployer.deploy(staging_file_path, target_file_path)
-        end
-      end
-
-      context "and the target has a dacl and sacl" do
-        let(:inherited_dacl_ace) { double("Windows dacl ace (inherited)", inherited?: true) }
-        let(:not_inherited_dacl_ace) { double("Windows dacl ace (not inherited)", inherited?: false) }
-
-        let(:original_target_file_dacl) { [inherited_dacl_ace, not_inherited_dacl_ace] }
-
-        let(:inherited_sacl_ace) { double("Windows sacl ace (inherited)", inherited?: true) }
-        let(:not_inherited_sacl_ace) { double("Windows sacl ace (not inherited)", inherited?: false) }
-        let(:original_target_file_sacl) { [inherited_sacl_ace, not_inherited_sacl_ace] }
-
-        let(:custom_dacl) { double("Windows ACL for non-inherited dacl aces") }
-        let(:custom_sacl) { double("Windows ACL for non-inherited sacl aces") }
-
-        before do
-          allow(target_file_security_descriptor).to receive(:dacl_present?).and_return(true)
-          allow(target_file_security_descriptor).to receive(:dacl_inherits?).and_return(dacl_inherits?)
-
-          allow(target_file_security_descriptor).to receive(:dacl).and_return(original_target_file_dacl)
-          expect(Chef::ReservedNames::Win32::Security::ACL)
-            .to receive(:create)
-            .with([not_inherited_dacl_ace])
-            .and_return(custom_dacl)
-
-          allow(target_file_security_descriptor).to receive(:sacl_present?).and_return(true)
-          allow(target_file_security_descriptor).to receive(:sacl_inherits?).and_return(sacl_inherits?)
-
-          allow(target_file_security_descriptor).to receive(:sacl).and_return(original_target_file_sacl)
-          expect(Chef::ReservedNames::Win32::Security::ACL)
-            .to receive(:create)
-            .with([not_inherited_sacl_ace])
-            .and_return(custom_sacl)
-
-          expect(updated_target_security_object).to receive(:set_dacl).with(custom_dacl, dacl_inherits?)
-          expect(updated_target_security_object).to receive(:set_sacl).with(custom_sacl, sacl_inherits?)
-        end
-
-        context "and the dacl and sacl don't inherit" do
-          let(:dacl_inherits?) { false }
-          let(:sacl_inherits?) { false }
-
-          it "fixes up permissions and moves the file into place" do
-            content_deployer.deploy(staging_file_path, target_file_path)
-          end
-        end
-
-        context "and the dacl and sacl inherit" do
-          let(:dacl_inherits?) { true }
-          let(:sacl_inherits?) { true }
-
-          it "fixes up permissions and moves the file into place" do
-            content_deployer.deploy(staging_file_path, target_file_path)
-          end
-        end
-
-      end
-
-    end
-
-  end
-end

data/spec/unit/file_content_management/tempfile_spec.rb

@@ -1,115 +0,0 @@
-#
-# Author:: Thom May (<thom@chef.io>)
-# Copyright:: Copyright (c) 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.
-#
-
-require "spec_helper"
-
-describe Chef::FileContentManagement::Tempfile do
-
-  def tempfile_object_for_path(path)
-    r = Chef::Resource::File.new("decorative name that should not matter")
-    r.path path
-    Chef::FileContentManagement::Tempfile.new(r)
-  end
-
-  describe "#tempfile_basename" do
-    it "should return a dotfile", :unix_only do
-      subject = tempfile_object_for_path("/foo/bar/new_file")
-      expect(subject.send(:tempfile_basename)).to eql(".chef-new_file")
-    end
-
-    it "should return a file", :windows_only do
-      subject = tempfile_object_for_path("/foo/bar/new_file")
-      expect(subject.send(:tempfile_basename)).to eql("chef-new_file")
-    end
-
-    it "should strip the extension", :unix_only do
-      subject = tempfile_object_for_path("/foo/bar/new_file.html.erb")
-      expect(subject.send(:tempfile_basename)).to eql(".chef-new_file")
-    end
-
-    it "should strip the extension", :windows_only do
-      subject = tempfile_object_for_path("/foo/bar/new_file.html.erb")
-      expect(subject.send(:tempfile_basename)).to eql("chef-new_file")
-    end
-  end
-
-  describe "#tempfile_extension" do
-    it "should preserve the file extension" do
-      subject = tempfile_object_for_path("/foo/bar/new_file.html.erb")
-      expect(subject.send(:tempfile_extension)).to eql(".html.erb")
-    end
-  end
-
-  describe "#tempfile_dirnames" do
-
-    it "should select a temp dir" do
-      subject = tempfile_object_for_path("/foo/bar/new_file")
-      Chef::Config[:file_staging_uses_destdir] = false
-      expect(Dir).to receive(:tmpdir).and_return("/tmp/dir")
-      expect(subject.send(:tempfile_dirnames)).to eql(%w{ /tmp/dir })
-    end
-
-    it "should select the destdir" do
-      subject = tempfile_object_for_path("/foo/bar/new_file")
-      Chef::Config[:file_staging_uses_destdir] = true
-      expect(subject.send(:tempfile_dirnames)).to eql(%w{ /foo/bar })
-    end
-
-    it "should select the destdir and a temp dir" do
-      subject = tempfile_object_for_path("/foo/bar/new_file")
-      Chef::Config[:file_staging_uses_destdir] = :auto
-      expect(Dir).to receive(:tmpdir).and_return("/tmp/dir")
-      expect(subject.send(:tempfile_dirnames)).to eql(%w{ /foo/bar /tmp/dir })
-    end
-  end
-
-  describe "#tempfile_open" do
-    let(:tempfile) { instance_double("Tempfile") }
-    let(:tempname) { windows? ? "chef-new_file" : ".chef-new_file" }
-
-    before do
-      Chef::Config[:file_staging_uses_destdir] = :auto
-      allow(tempfile).to receive(:binmode).and_return(true)
-    end
-
-    it "should create a temporary file" do
-      subject = tempfile_object_for_path("/foo/bar/new_file")
-      expect(subject.send(:tempfile_open)).to be_a(Tempfile)
-    end
-
-    it "should preserve the extension in the tempfile path" do
-      subject = tempfile_object_for_path("/foo/bar/new_file.html.erb")
-      tempfile = subject.send(:tempfile_open)
-      expect(tempfile.path).to match(/chef-new_file.*\.html\.erb$/)
-    end
-
-    it "should pick the destdir preferentially" do
-      subject = tempfile_object_for_path("/foo/bar/new_file")
-      expect(Tempfile).to receive(:open).with([tempname, ""], "/foo/bar").and_return(tempfile)
-      subject.send(:tempfile_open)
-    end
-
-    it "should use ENV['TMP'] otherwise" do
-      subject = tempfile_object_for_path("/foo/bar/new_file")
-      expect(Dir).to receive(:tmpdir).and_return("/tmp/dir")
-      expect(Tempfile).to receive(:open).with([tempname, ""], "/foo/bar").and_raise(SystemCallError, "foo")
-      expect(Tempfile).to receive(:open).with([tempname, ""], "/tmp/dir").and_return(tempfile)
-      subject.send(:tempfile_open)
-    end
-  end
-end