chef 12.4.0.rc.0-universal-mingw32

data/spec/support/shared/unit/platform_introspector.rb

@@ -0,0 +1,184 @@
+#
+# Author:: Seth Falcon (<seth@opscode.com>)
+# Author:: Daniel DeLeo (<dan@opscode.com>)
+# Copyright:: Copyright (c) 2010, 2012 Opscode, Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+
+shared_examples_for "a platform introspector" do
+  before(:each) do
+    @platform_hash = {}
+    %w{openbsd freebsd}.each do |x|
+      @platform_hash[x] = {
+        "default" => x,
+        "1.2.3" => "#{x}-1.2.3"
+      }
+    end
+    @platform_hash["debian"] = {["5", "6"] => "debian-5/6", "default" => "debian"}
+    @platform_hash["default"] = "default"
+    # The following @platform_hash keys are used for testing version constraints
+    @platform_hash['exact_match'] = { '1.2.3' => 'exact', '>= 1.0' => 'not exact'}
+    @platform_hash['multiple_matches'] = { '~> 2.3.4' => 'matched ~> 2.3.4', '>= 2.3' => 'matched >=2.3' }
+    @platform_hash['successful_matches'] = { '< 3.0' => 'matched < 3.0', '>= 3.0' => 'matched >= 3.0' }
+
+    @platform_family_hash = {
+      "debian" => "debian value",
+      [:rhel, :fedora] => "redhatty value",
+      "suse" => "suse value",
+      :default => "default value"
+    }
+  end
+
+  it "returns a default value when there is no known platform" do
+    node = Hash.new
+    expect(platform_introspector.value_for_platform(@platform_hash)).to eq("default")
+  end
+
+  it "returns a default value when there is no known platform family" do
+    expect(platform_introspector.value_for_platform_family(@platform_family_hash)).to eq("default value")
+  end
+
+  it "returns a default value when the current platform doesn't match" do
+    node.automatic_attrs[:platform] = "not-a-known-platform"
+    expect(platform_introspector.value_for_platform(@platform_hash)).to eq("default")
+  end
+
+  it "returns a default value when current platform_family doesn't match" do
+    node.automatic_attrs[:platform_family] = "ultra-derived-linux"
+    expect(platform_introspector.value_for_platform_family(@platform_family_hash)).to eq("default value")
+  end
+
+  it "returns a value based on the current platform" do
+    node.automatic_attrs[:platform] = "openbsd"
+    expect(platform_introspector.value_for_platform(@platform_hash)).to eq("openbsd")
+  end
+
+  it "returns a value based on the current platform family" do
+    node.automatic_attrs[:platform_family] = "debian"
+    expect(platform_introspector.value_for_platform_family(@platform_family_hash)).to eq("debian value")
+  end
+
+  it "returns a version-specific value based on the current platform" do
+    node.automatic_attrs[:platform] = "openbsd"
+    node.automatic_attrs[:platform_version] = "1.2.3"
+    expect(platform_introspector.value_for_platform(@platform_hash)).to eq("openbsd-1.2.3")
+  end
+
+  it "returns a value based on the current platform if version not found" do
+    node.automatic_attrs[:platform] = "openbsd"
+    node.automatic_attrs[:platform_version] = "0.0.0"
+    expect(platform_introspector.value_for_platform(@platform_hash)).to eq("openbsd")
+  end
+
+  it 'returns the exact match' do
+    node.automatic_attrs[:platform] = 'exact_match'
+    node.automatic_attrs[:platform_version] = '1.2.3'
+    expect(platform_introspector.value_for_platform(@platform_hash)).to eq('exact')
+  end
+
+  it 'raises RuntimeError' do
+    node.automatic_attrs[:platform] = 'multiple_matches'
+    node.automatic_attrs[:platform_version] = '2.3.4'
+    expect {platform_introspector.value_for_platform(@platform_hash)}.to raise_error(RuntimeError)
+  end
+
+  it 'should return the value for that match' do
+    node.automatic_attrs[:platform] = 'successful_matches'
+    node.automatic_attrs[:platform_version] = '2.9'
+    expect(platform_introspector.value_for_platform(@platform_hash)).to eq('matched < 3.0')
+  end
+
+  describe "when platform versions is an array" do
+    it "returns a version-specific value based on the current platform" do
+      node.automatic_attrs[:platform] = "debian"
+      node.automatic_attrs[:platform_version] = "6"
+      expect(platform_introspector.value_for_platform(@platform_hash)).to eq("debian-5/6")
+    end
+
+    it "returns a value based on the current platform if version not found" do
+      node.automatic_attrs[:platform] = "debian"
+      node.automatic_attrs[:platform_version] = "0.0.0"
+      expect(platform_introspector.value_for_platform(@platform_hash)).to eq("debian")
+    end
+  end
+
+  describe "when checking platform?" do
+
+    it "returns true if the node is a provided platform and platforms are provided as symbols" do
+      node.automatic_attrs[:platform] = 'ubuntu'
+      expect(platform_introspector.platform?([:redhat, :ubuntu])).to eq(true)
+    end
+
+    it "returns true if the node is a provided platform and platforms are provided as strings" do
+      node.automatic_attrs[:platform] = 'ubuntu'
+      expect(platform_introspector.platform?(["redhat", "ubuntu"])).to eq(true)
+    end
+
+    it "returns false if the node is not of the provided platforms" do
+      node.automatic_attrs[:platform] = 'ubuntu'
+      expect(platform_introspector.platform?(:splatlinux)).to eq(false)
+    end
+  end
+
+  describe "when checking platform_family?" do
+
+    it "returns true if the node is in a provided platform family and families are provided as symbols" do
+      node.automatic_attrs[:platform_family] = 'debian'
+      expect(platform_introspector.platform_family?([:rhel, :debian])).to eq(true)
+    end
+
+    it "returns true if the node is a provided platform and platforms are provided as strings" do
+      node.automatic_attrs[:platform_family] = 'rhel'
+      expect(platform_introspector.platform_family?(["rhel", "debian"])).to eq(true)
+    end
+
+    it "returns false if the node is not of the provided platforms" do
+      node.automatic_attrs[:platform_family] = 'suse'
+      expect(platform_introspector.platform_family?(:splatlinux)).to eq(false)
+    end
+
+    it "returns false if the node is not of the provided platforms and platform_family is not set" do
+      expect(platform_introspector.platform_family?(:splatlinux)).to eq(false)
+    end
+
+  end
+  # NOTE: this is a regression test for bug CHEF-1514
+  describe "when the value is an array" do
+    before do
+      @platform_hash = {
+        "debian" => { "4.0" => [ :restart, :reload ], "default" => [ :restart, :reload, :status ] },
+        "ubuntu" => { "default" => [ :restart, :reload, :status ] },
+        "centos" => { "default" => [ :restart, :reload, :status ] },
+        "redhat" => { "default" => [ :restart, :reload, :status ] },
+        "fedora" => { "default" => [ :restart, :reload, :status ] },
+        "default" => { "default" => [:restart, :reload ] }}
+    end
+
+    it "returns the correct default for a given platform" do
+      node.automatic_attrs[:platform] = "debian"
+      node.automatic_attrs[:platform_version] = '9000'
+      expect(platform_introspector.value_for_platform(@platform_hash)).to eq([ :restart, :reload, :status ])
+    end
+
+    it "returns the correct platform+version specific value " do
+      node.automatic_attrs[:platform] = "debian"
+      node.automatic_attrs[:platform_version] = '4.0'
+      expect(platform_introspector.value_for_platform(@platform_hash)).to eq([:restart, :reload])
+    end
+  end
+
+end
+

data/spec/support/shared/unit/provider/file.rb

@@ -0,0 +1,840 @@
+#
+# Author:: Lamont Granquist (<lamont@opscode.com>)
+# Copyright:: Copyright (c) 2013 Opscode, Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require 'spec_helper'
+require 'tmpdir'
+if windows?
+  require 'chef/win32/file'
+end
+
+# Filesystem stubs
+def file_symlink_class
+  if windows?
+    Chef::ReservedNames::Win32::File
+  else
+    File
+  end
+end
+
+def normalized_path
+  File.expand_path(resource_path)
+end
+
+# forwards-vs-reverse slashes on windows sucks
+def windows_path
+  windows? ? normalized_path.gsub(/\\/, '/') : normalized_path
+end
+
+# this is all getting a bit stupid, CHEF-4802 cut to remove all this
+def setup_normal_file
+  [ resource_path, normalized_path, windows_path].each do |path|
+    allow(File).to receive(:file?).with(path).and_return(true)
+    allow(File).to receive(:exists?).with(path).and_return(true)
+    allow(File).to receive(:exist?).with(path).and_return(true)
+    allow(File).to receive(:directory?).with(path).and_return(false)
+    allow(File).to receive(:writable?).with(path).and_return(true)
+    allow(file_symlink_class).to receive(:symlink?).with(path).and_return(false)
+    allow(File).to receive(:realpath?).with(path).and_return(normalized_path)
+  end
+  allow(File).to receive(:directory?).with(enclosing_directory).and_return(true)
+end
+
+def setup_missing_file
+  [ resource_path, normalized_path, windows_path].each do |path|
+    allow(File).to receive(:file?).with(path).and_return(false)
+    allow(File).to receive(:realpath?).with(path).and_return(resource_path)
+    allow(File).to receive(:exists?).with(path).and_return(false)
+    allow(File).to receive(:exist?).with(path).and_return(false)
+    allow(File).to receive(:directory?).with(path).and_return(false)
+    allow(File).to receive(:writable?).with(path).and_return(false)
+    allow(file_symlink_class).to receive(:symlink?).with(path).and_return(false)
+  end
+  allow(File).to receive(:directory?).with(enclosing_directory).and_return(true)
+end
+
+def setup_symlink
+  [ resource_path, normalized_path, windows_path].each do |path|
+    allow(File).to receive(:file?).with(path).and_return(true)
+    allow(File).to receive(:realpath?).with(path).and_return(normalized_path)
+    allow(File).to receive(:exists?).with(path).and_return(true)
+    allow(File).to receive(:exist?).with(path).and_return(true)
+    allow(File).to receive(:directory?).with(path).and_return(false)
+    allow(File).to receive(:writable?).with(path).and_return(true)
+    allow(file_symlink_class).to receive(:symlink?).with(path).and_return(true)
+  end
+  allow(File).to receive(:directory?).with(enclosing_directory).and_return(true)
+end
+
+def setup_unwritable_file
+  [ resource_path, normalized_path, windows_path].each do |path|
+    allow(File).to receive(:file?).with(path).and_return(false)
+    allow(File).to receive(:realpath?).with(path).and_raise(Errno::ENOENT)
+    allow(File).to receive(:exists?).with(path).and_return(true)
+    allow(File).to receive(:exist?).with(path).and_return(true)
+    allow(File).to receive(:directory?).with(path).and_return(false)
+    allow(File).to receive(:writable?).with(path).and_return(false)
+    allow(file_symlink_class).to receive(:symlink?).with(path).and_return(false)
+  end
+  allow(File).to receive(:directory?).with(enclosing_directory).and_return(true)
+end
+
+def setup_missing_enclosing_directory
+  [ resource_path, normalized_path, windows_path].each do |path|
+    allow(File).to receive(:file?).with(path).and_return(false)
+    allow(File).to receive(:realpath?).with(path).and_raise(Errno::ENOENT)
+    allow(File).to receive(:exists?).with(path).and_return(false)
+    allow(File).to receive(:exist?).with(path).and_return(false)
+    allow(File).to receive(:directory?).with(path).and_return(false)
+    allow(File).to receive(:writable?).with(path).and_return(false)
+    allow(file_symlink_class).to receive(:symlink?).with(path).and_return(false)
+  end
+  allow(File).to receive(:directory?).with(enclosing_directory).and_return(false)
+end
+
+# A File subclass that we use as a replacement for Tempfile. Some versions of
+# Tempfile call `File.exist?()` internally which will cause test failures if
+# `File.exist?()` has been stubbed.
+class BasicTempfile < ::File
+
+  def self.make_tmp_path(basename)
+    slug = "#{basename}-#{rand(1 << 128)}"
+    File.join(Dir.tmpdir, slug)
+  end
+
+  def self.new(basename)
+    super(make_tmp_path(basename), File::RDWR|File::CREAT|File::EXCL, 0600)
+  end
+
+  def unlink
+    self.class.unlink(path)
+  end
+
+end
+
+shared_examples_for Chef::Provider::File do
+
+  let(:tempfile_path) do
+  end
+
+  let!(:tempfile) do
+    BasicTempfile.new("rspec-shared-file-provider")
+  end
+
+  before(:each) do
+    allow(content).to receive(:tempfile).and_return(tempfile)
+    allow(File).to receive(:exist?).with(tempfile.path).and_call_original
+    allow(File).to receive(:exists?).with(tempfile.path).and_call_original
+  end
+
+  after do
+    tempfile.close if (tempfile && !tempfile.closed?)
+    File.unlink(tempfile.path) rescue nil
+  end
+
+  it "should return a #{described_class}" do
+    expect(provider).to be_a_kind_of(described_class)
+  end
+
+  it "should store the resource passed to new as new_resource" do
+    expect(provider.new_resource).to eql(resource)
+  end
+
+  it "should store the node passed to new as node" do
+    expect(provider.node).to eql(node)
+  end
+
+  context "when loading the current resource" do
+
+    context "when running load_current_resource" do
+      #
+      # the content objects need the current_resource to be loaded (esp remote_file), so calling
+      # for content inside of load_current_resource is totally crossing the streams...
+      #
+      it "should not try to load the content when the file is present" do
+        setup_normal_file
+        expect(provider).not_to receive(:tempfile)
+        expect(provider).not_to receive(:content)
+        provider.load_current_resource
+      end
+
+      it "should not try to load the content when the file is missing" do
+        setup_missing_file
+        expect(provider).not_to receive(:tempfile)
+        expect(provider).not_to receive(:content)
+        provider.load_current_resource
+      end
+    end
+
+    context "when running load_current_resource and the file exists" do
+      before do
+        setup_normal_file
+      end
+
+      let(:tempfile_sha256) { "42971f0ddce0cb20cf7660a123ffa1a1543beb2f1e7cd9d65858764a27f3201d" }
+
+      it "should load a current resource based on the one specified at construction" do
+        provider.load_current_resource
+        expect(provider.current_resource).to be_a_kind_of(Chef::Resource::File)
+      end
+
+      it "the loaded current_resource name should be the same as the resource name" do
+        provider.load_current_resource
+        expect(provider.current_resource.name).to eql(resource.name)
+      end
+
+      it "the loaded current_resource path should be the same as the resoure path" do
+        provider.load_current_resource
+        expect(provider.current_resource.path).to eql(resource.path)
+      end
+
+      it "the loaded current_resource content should be nil" do
+        provider.load_current_resource
+        expect(provider.current_resource.content).to eql(nil)
+      end
+
+      it "it should call checksum if we are managing content" do
+        expect(provider).to receive(:managing_content?).at_least(:once).and_return(true)
+        expect(provider).to receive(:checksum).with(resource.path).and_return(tempfile_sha256)
+        provider.load_current_resource
+      end
+
+      it "it should not call checksum if we are not managing content" do
+        expect(provider).to receive(:managing_content?).at_least(:once).and_return(false)
+        expect(provider).not_to receive(:checksum)
+        provider.load_current_resource
+      end
+    end
+
+    context "when running load_current_resource and the file does not exist" do
+      before do
+        setup_missing_file
+      end
+
+      it "the current_resource should be a Chef::Resource::File" do
+        provider.load_current_resource
+        expect(provider.current_resource).to be_a_kind_of(Chef::Resource::File)
+      end
+
+      it "the current_resource name should be the same as the resource name" do
+        provider.load_current_resource
+        expect(provider.current_resource.name).to eql(resource.name)
+      end
+
+      it "the current_resource path should be the same as the resource path" do
+        provider.load_current_resource
+        expect(provider.current_resource.path).to eql(resource.path)
+      end
+
+      it "the loaded current_resource content should be nil" do
+        provider.load_current_resource
+        expect(provider.current_resource.content).to eql(nil)
+      end
+
+      it "it should not call checksum if we are not managing content" do
+        expect(provider).not_to receive(:managing_content?)
+        expect(provider).not_to receive(:checksum)
+        provider.load_current_resource
+      end
+    end
+
+    context "examining file security metadata on Unix with a file that exists" do
+      before do
+        # fake that we're on unix even if we're on windows
+        allow(ChefConfig).to receive(:windows?).and_return(false)
+        # mock up the filesystem to behave like unix
+        setup_normal_file
+        stat_struct = double("::File.stat", :mode => 0600, :uid => 0, :gid => 0, :mtime => 10000)
+        resource_real_path = File.realpath(resource.path)
+        expect(File).to receive(:stat).with(resource_real_path).at_least(:once).and_return(stat_struct)
+        allow(Etc).to receive(:getgrgid).with(0).and_return(double("Group Ent", :name => "wheel"))
+        allow(Etc).to receive(:getpwuid).with(0).and_return(double("User Ent", :name => "root"))
+      end
+
+      context "when the new_resource does not specify any state" do
+        before do
+          provider.load_current_resource
+        end
+
+        it "should load the permissions into the current_resource" do
+          expect(provider.current_resource.mode).to eq("0600")
+          expect(provider.current_resource.owner).to eq("root")
+          expect(provider.current_resource.group).to eq("wheel")
+        end
+
+        it "should not set the new_resource permissions" do
+          expect(provider.new_resource.group).to be_nil
+          expect(provider.new_resource.owner).to be_nil
+          expect(provider.new_resource.mode).to be_nil
+        end
+      end
+
+      context "when the new_resource explicitly specifies resource state as numbers" do
+        before do
+          resource.owner(1)
+          resource.group(1)
+          resource.mode(0644)
+          provider.load_current_resource
+        end
+
+        it "should load the permissions into the current_resource as numbers" do
+          # Mode is always loaded as string for reporting purposes.
+          expect(provider.current_resource.mode).to eq("0600")
+          expect(provider.current_resource.owner).to eq(0)
+          expect(provider.current_resource.group).to eq(0)
+        end
+
+        it "should not set the new_resource permissions" do
+          expect(provider.new_resource.group).to eq(1)
+          expect(provider.new_resource.owner).to eq(1)
+          expect(provider.new_resource.mode).to eq(0644)
+        end
+      end
+
+      context "when the new_resource explicitly specifies resource state as symbols" do
+        before do
+          resource.owner("macklemore")
+          resource.group("seattlehiphop")
+          resource.mode("0321")
+          provider.load_current_resource
+        end
+
+        it "should load the permissions into the current_resource as symbols" do
+          expect(provider.current_resource.mode).to eq("0600")
+          expect(provider.current_resource.owner).to eq("root")
+          expect(provider.current_resource.group).to eq("wheel")
+        end
+
+        it "should not set the new_resource permissions" do
+          expect(provider.new_resource.group).to eq("seattlehiphop")
+          expect(provider.new_resource.owner).to eq("macklemore")
+          expect(provider.new_resource.mode).to eq("0321")
+        end
+      end
+
+    end
+
+    context "examining file security metadata on Unix with a file that does not exist" do
+      before do
+        # fake that we're on unix even if we're on windows
+        allow(ChefConfig).to receive(:windows?).and_return(false)
+        setup_missing_file
+      end
+
+      context "when the new_resource does not specify any state" do
+        before do
+          provider.load_current_resource
+        end
+
+        it "the current_resource permissions should be nil" do
+          expect(provider.current_resource.mode).to be_nil
+          expect(provider.current_resource.owner).to be_nil
+          expect(provider.current_resource.group).to be_nil
+        end
+
+        it "should not set the new_resource permissions" do
+          expect(provider.new_resource.group).to be_nil
+          expect(provider.new_resource.owner).to be_nil
+          expect(provider.new_resource.mode).to be_nil
+        end
+      end
+
+      context "when the new_resource explicitly specifies resource state" do
+        before do
+          resource.owner(63945)
+          resource.group(51948)
+          resource.mode(0123)
+          provider.load_current_resource
+        end
+
+        it "the current_resource permissions should be nil" do
+          expect(provider.current_resource.mode).to be_nil
+          expect(provider.current_resource.owner).to be_nil
+          expect(provider.current_resource.group).to be_nil
+        end
+
+        it "should not set the new_resource permissions" do
+          expect(provider.new_resource.group).to eq(51948)
+          expect(provider.new_resource.owner).to eq(63945)
+          expect(provider.new_resource.mode).to eq(0123)
+        end
+      end
+    end
+  end
+
+  context "when loading the new_resource after the run" do
+
+    before do
+      # fake that we're on unix even if we're on windows
+      allow(ChefConfig).to receive(:windows?).and_return(false)
+      # mock up the filesystem to behave like unix
+      setup_normal_file
+      stat_struct = double("::File.stat", :mode => 0600, :uid => 0, :gid => 0, :mtime => 10000)
+      resource_real_path = File.realpath(resource.path)
+      allow(File).to receive(:stat).with(resource_real_path).and_return(stat_struct)
+      allow(Etc).to receive(:getgrgid).with(0).and_return(double("Group Ent", :name => "wheel"))
+      allow(Etc).to receive(:getpwuid).with(0).and_return(double("User Ent", :name => "root"))
+      provider.send(:load_resource_attributes_from_file, resource)
+    end
+
+    it "new_resource should record the new permission information" do
+      expect(provider.new_resource.group).to eq("wheel")
+      expect(provider.new_resource.owner).to eq("root")
+      expect(provider.new_resource.mode).to eq("0600")
+    end
+  end
+
+  context "when reporting security metadata on windows" do
+    it "records the file owner" do
+      skip
+    end
+
+    it "records rights for each user in the ACL" do
+      skip
+    end
+
+    it "records deny_rights for each user in the ACL" do
+      skip
+    end
+  end
+
+  context "define_resource_requirements" do
+    context "when the enclosing directory does not exist" do
+      before { setup_missing_enclosing_directory }
+
+      [:create, :create_if_missing, :touch].each do |action|
+        context "action #{action}" do
+          it "raises EnclosingDirectoryDoesNotExist" do
+            expect {provider.run_action(action)}.to raise_error(Chef::Exceptions::EnclosingDirectoryDoesNotExist)
+          end
+
+          it "does not raise an exception in why-run mode" do
+            Chef::Config[:why_run] = true
+            expect {provider.run_action(action)}.not_to raise_error
+            Chef::Config[:why_run] = false
+          end
+        end
+      end
+    end
+
+    context "when the file exists but is not deletable" do
+      before { setup_unwritable_file }
+
+      it "action delete raises InsufficientPermissions" do
+        expect {provider.run_action(:delete)}.to raise_error(Chef::Exceptions::InsufficientPermissions)
+      end
+
+      it "action delete also raises InsufficientPermissions in why-run mode" do
+        Chef::Config[:why_run] = true
+        expect {provider.run_action(:delete)}.to raise_error(Chef::Exceptions::InsufficientPermissions)
+        Chef::Config[:why_run] = false
+      end
+    end
+  end
+
+  context "action create" do
+    it "should create the file, update its contents and then set the acls on the file"  do
+      setup_missing_file
+      expect(provider).to receive(:do_create_file)
+      expect(provider).to receive(:do_contents_changes)
+      expect(provider).to receive(:do_acl_changes)
+      expect(provider).to receive(:load_resource_attributes_from_file)
+      provider.run_action(:create)
+    end
+
+    context "do_validate_content" do
+      before { setup_normal_file }
+
+      let(:tempfile) {
+        t = double('Tempfile', :path => "/tmp/foo-bar-baz", :closed? => true)
+        allow(content).to receive(:tempfile).and_return(t)
+        t
+      }
+
+      let(:verification) { double("Verification") }
+
+      context "with user-supplied verifications" do
+        it "calls #verify on each verification with tempfile path" do
+          allow(Chef::Resource::File::Verification).to receive(:new).and_return(verification)
+          provider.new_resource.verify "true"
+          provider.new_resource.verify "true"
+          expect(verification).to receive(:verify).with(tempfile.path).twice.and_return(true)
+          provider.send(:do_validate_content)
+        end
+
+        it "raises an exception if any verification fails" do
+          provider.new_resource.verify "true"
+          provider.new_resource.verify "false"
+          allow(verification).to receive(:verify).with("true").and_return(true)
+          allow(verification).to receive(:verify).with("false").and_return(false)
+          expect{provider.send(:do_validate_content)}.to raise_error(Chef::Exceptions::ValidationFailed)
+        end
+      end
+    end
+
+    context "do_create_file" do
+      context "when the file exists" do
+        before { setup_normal_file }
+        it "should not create the file" do
+          provider.load_current_resource
+          expect(provider.deployment_strategy).not_to receive(:create).with(resource_path)
+          provider.send(:do_create_file)
+          expect(provider.send(:needs_creating?)).to eq(false)
+        end
+      end
+      context "when the file does not exist" do
+        before { setup_missing_file }
+        it "should create the file" do
+          provider.load_current_resource
+          expect(provider.deployment_strategy).to receive(:create).with(resource_path)
+          provider.send(:do_create_file)
+          expect(provider.send(:needs_creating?)).to eq(true)
+        end
+      end
+    end
+
+    context "do_contents_changes" do
+      context "when there is content to deploy" do
+        before do
+          setup_normal_file
+          provider.load_current_resource
+          tempfile = double('Tempfile', :path => "/tmp/foo-bar-baz")
+          allow(content).to receive(:tempfile).and_return(tempfile)
+          expect(File).to receive(:exists?).with("/tmp/foo-bar-baz").and_return(true)
+          expect(tempfile).to receive(:close).once
+          expect(tempfile).to receive(:unlink).once
+        end
+
+        context "when the contents have changed" do
+          let(:tempfile_path) { "/tmp/foo-bar-baz" }
+          let(:tempfile_sha256) { "42971f0ddce0cb20cf7660a123ffa1a1543beb2f1e7cd9d65858764a27f3201d" }
+          let(:diff_for_reporting) { "+++\n---\n+foo\n-bar\n" }
+          before do
+            allow(provider).to receive(:contents_changed?).and_return(true)
+            diff = double('Diff', :for_output => ['+++','---','+foo','-bar'],
+                                  :for_reporting => diff_for_reporting )
+            allow(diff).to receive(:diff).with(resource_path, tempfile_path).and_return(true)
+            expect(provider).to receive(:diff).at_least(:once).and_return(diff)
+            expect(provider).to receive(:checksum).with(tempfile_path).and_return(tempfile_sha256)
+            allow(provider).to receive(:managing_content?).and_return(true)
+            allow(provider).to receive(:checksum).with(resource_path).and_return(tempfile_sha256)
+            expect(resource).not_to receive(:checksum).with(tempfile_sha256)  # do not mutate the new resource
+            expect(provider.deployment_strategy).to receive(:deploy).with(tempfile_path, normalized_path)
+          end
+          context "when the file was created" do
+            before { expect(provider).to receive(:needs_creating?).at_least(:once).and_return(true) }
+            it "does not backup the file" do
+              expect(provider).not_to receive(:do_backup)
+              provider.send(:do_contents_changes)
+            end
+
+            it "does not produce a diff for reporting" do
+              provider.send(:do_contents_changes)
+              expect(resource.diff).to be_nil
+            end
+
+            it "renders the final checksum correctly for reporting" do
+              provider.send(:do_contents_changes)
+              expect(resource.state_for_resource_reporter[:checksum]).to eql(tempfile_sha256)
+            end
+          end
+          context "when the file was not created" do
+            before do
+              allow(provider).to receive(:do_backup)  # stub do_backup
+              expect(provider).to receive(:needs_creating?).at_least(:once).and_return(false)
+            end
+
+            it "backs up the file" do
+              expect(provider).to receive(:do_backup)
+              provider.send(:do_contents_changes)
+            end
+
+            it "produces a diff for reporting" do
+              provider.send(:do_contents_changes)
+              expect(resource.diff).to eq(diff_for_reporting)
+            end
+
+            it "renders the final checksum correctly for reporting" do
+              provider.send(:do_contents_changes)
+              expect(resource.state_for_resource_reporter[:checksum]).to eql(tempfile_sha256)
+            end
+          end
+        end
+
+        it "does nothing when the contents have not changed"  do
+          allow(provider).to receive(:contents_changed?).and_return(false)
+          expect(provider).not_to receive(:diff)
+          provider.send(:do_contents_changes)
+        end
+      end
+
+      it "does nothing when there is no content to deploy (tempfile returned from contents is nil)" do
+        expect(provider.send(:content)).to receive(:tempfile).at_least(:once).and_return(nil)
+        expect(provider).not_to receive(:diff)
+        expect{ provider.send(:do_contents_changes) }.not_to raise_error
+      end
+
+      it "raises an exception when the content object returns a tempfile with a nil path" do
+        tempfile = double('Tempfile', :path => nil)
+        expect(provider.send(:content)).to receive(:tempfile).at_least(:once).and_return(tempfile)
+        expect{ provider.send(:do_contents_changes) }.to raise_error
+      end
+
+      it "raises an exception when the content object returns a tempfile that does not exist" do
+        tempfile = double('Tempfile', :path => "/tmp/foo-bar-baz")
+        expect(provider.send(:content)).to receive(:tempfile).at_least(:once).and_return(tempfile)
+        expect(File).to receive(:exists?).with("/tmp/foo-bar-baz").and_return(false)
+        expect{ provider.send(:do_contents_changes) }.to raise_error
+      end
+    end
+
+    context "do_acl_changes" do
+      it "needs tests" do
+        skip
+      end
+    end
+
+    context "do_selinux" do
+      context "when resource is updated" do
+        before do
+          setup_normal_file
+          provider.load_current_resource
+          allow(provider).to receive(:resource_updated?).and_return(true)
+        end
+
+        it "should check for selinux_enabled? by default" do
+          expect(provider).to receive(:selinux_enabled?)
+          provider.send(:do_selinux)
+        end
+
+        context "when selinux fixup is enabled in the config" do
+          before do
+            @original_selinux_fixup = Chef::Config[:enable_selinux_file_permission_fixup]
+            Chef::Config[:enable_selinux_file_permission_fixup] = true
+          end
+
+          after do
+            Chef::Config[:enable_selinux_file_permission_fixup] = @original_selinux_fixup
+          end
+
+          context "when selinux is enabled on the system" do
+            before do
+              expect(provider).to receive(:selinux_enabled?).and_return(true)
+            end
+
+            it "restores security context on the file" do
+              expect(provider).to receive(:restore_security_context).with(normalized_path, false)
+              provider.send(:do_selinux)
+            end
+
+            it "restores security context recursively when told so" do
+              expect(provider).to receive(:restore_security_context).with(normalized_path, true)
+              provider.send(:do_selinux, true)
+            end
+          end
+
+          context "when selinux is disabled on the system" do
+            before do
+              expect(provider).to receive(:selinux_enabled?).and_return(false)
+            end
+
+            it "should not restore security context" do
+              expect(provider).not_to receive(:restore_security_context)
+              provider.send(:do_selinux)
+            end
+          end
+        end
+
+        context "when selinux fixup is disabled in the config" do
+          before do
+            @original_selinux_fixup = Chef::Config[:enable_selinux_file_permission_fixup]
+            Chef::Config[:enable_selinux_file_permission_fixup] = false
+          end
+
+          after do
+            Chef::Config[:enable_selinux_file_permission_fixup] = @original_selinux_fixup
+          end
+
+          it "should not check for selinux_enabled?" do
+            expect(provider).not_to receive(:selinux_enabled?)
+            provider.send(:do_selinux)
+          end
+        end
+      end
+
+      context "when resource is not updated" do
+        before do
+          allow(provider).to receive(:resource_updated?).and_return(false)
+        end
+
+        it "should not check for selinux_enabled?" do
+          expect(provider).not_to receive(:selinux_enabled?)
+          provider.send(:do_selinux)
+        end
+      end
+    end
+
+  end
+
+  context "action delete" do
+    context "when the file exists" do
+      context "when the file is writable" do
+        context "when the file is not a symlink" do
+          before { setup_normal_file }
+          it "should backup and delete the file and be updated by the last action" do
+            expect(provider).to receive(:do_backup).at_least(:once).and_return(true)
+            expect(File).to receive(:delete).with(resource_path).and_return(true)
+            provider.run_action(:delete)
+            expect(resource).to be_updated_by_last_action
+          end
+        end
+        context "when the file is a symlink" do
+          before { setup_symlink }
+          it "should not backup the symlink" do
+            expect(provider).not_to receive(:do_backup)
+            expect(File).to receive(:delete).with(resource_path).and_return(true)
+            provider.run_action(:delete)
+            expect(resource).to be_updated_by_last_action
+          end
+        end
+      end
+      context "when the file is not writable" do
+        before { setup_unwritable_file }
+        it "should not try to backup or delete the file, and should not be updated by last action" do
+          expect(provider).not_to receive(:do_backup)
+          expect(File).not_to receive(:delete)
+          expect { provider.run_action(:delete) }.to raise_error()
+          expect(resource).not_to be_updated_by_last_action
+        end
+      end
+    end
+
+    context "when the file does not exist" do
+      before { setup_missing_file }
+
+      it "should not try to backup or delete the file, and should not be updated by last action" do
+        expect(provider).not_to receive(:do_backup)
+        expect(File).not_to receive(:delete)
+        expect { provider.run_action(:delete) }.not_to raise_error
+        expect(resource).not_to be_updated_by_last_action
+      end
+    end
+  end
+
+  context "action touch" do
+    context "when the file does not exist" do
+      before { setup_missing_file }
+      it "should update the atime/mtime on action_touch" do
+        expect(File).to receive(:utime).once
+        expect(provider).to receive(:action_create)
+        provider.run_action(:touch)
+        expect(resource).to be_updated_by_last_action
+      end
+    end
+    context "when the file exists" do
+      before { setup_normal_file }
+      it "should update the atime/mtime on action_touch" do
+        expect(File).to receive(:utime).once
+        expect(provider).to receive(:action_create)
+        provider.run_action(:touch)
+        expect(resource).to be_updated_by_last_action
+      end
+    end
+  end
+
+  context "action create_if_missing" do
+    context "when the file does not exist" do
+      before { setup_missing_file }
+      it "should call action_create" do
+        expect(provider).to receive(:action_create)
+        provider.run_action(:create_if_missing)
+      end
+    end
+
+    context "when the file exists" do
+      before { setup_normal_file }
+      it "should not call action_create" do
+        expect(provider).not_to receive(:action_create)
+        provider.run_action(:create_if_missing)
+      end
+    end
+
+  end
+
+end
+
+shared_examples_for "a file provider with content field" do
+  context "when testing managing_content?" do
+    it "should be false when creating a file without content" do
+      provider.action = :create
+      allow(resource).to receive(:content).and_return(nil)
+      allow(resource).to receive(:checksum).and_return(nil)
+      expect(provider.send(:managing_content?)).to be_falsey
+    end
+    it "should be true when creating a file with content" do
+      provider.action = :create
+      allow(resource).to receive(:content).and_return("flurbleblobbleblooble")
+      allow(resource).to receive(:checksum).and_return(nil)
+      expect(provider.send(:managing_content?)).to be_truthy
+    end
+    it "should be true when checksum is set on the content (no matter how crazy)" do
+      provider.action = :create_if_missing
+      allow(resource).to receive(:checksum).and_return("1234123234234234")
+      allow(resource).to receive(:content).and_return(nil)
+      expect(provider.send(:managing_content?)).to be_truthy
+    end
+    it "should be false when action is create_if_missing" do
+      provider.action = :create_if_missing
+      allow(resource).to receive(:content).and_return("flurbleblobbleblooble")
+      allow(resource).to receive(:checksum).and_return(nil)
+      expect(provider.send(:managing_content?)).to be_falsey
+    end
+  end
+end
+
+shared_examples_for "a file provider with source field" do
+  context "when testing managing_content?" do
+    it "should be false when creating a file without content" do
+      provider.action = :create
+      allow(resource).to receive(:content).and_return(nil)
+      allow(resource).to receive(:source).and_return(nil)
+      allow(resource).to receive(:checksum).and_return(nil)
+      expect(provider.send(:managing_content?)).to be_falsey
+    end
+    it "should be true when creating a file with content" do
+      provider.action = :create
+      allow(resource).to receive(:content).and_return(nil)
+      allow(resource).to receive(:source).and_return("http://somewhere.com/something.php")
+      allow(resource).to receive(:checksum).and_return(nil)
+      expect(provider.send(:managing_content?)).to be_truthy
+    end
+    it "should be true when checksum is set on the content (no matter how crazy)" do
+      provider.action = :create_if_missing
+      allow(resource).to receive(:content).and_return(nil)
+      allow(resource).to receive(:source).and_return(nil)
+      allow(resource).to receive(:checksum).and_return("1234123234234234")
+      expect(provider.send(:managing_content?)).to be_truthy
+    end
+    it "should be false when action is create_if_missing" do
+      provider.action = :create_if_missing
+      allow(resource).to receive(:content).and_return(nil)
+      allow(resource).to receive(:source).and_return("http://somewhere.com/something.php")
+      allow(resource).to receive(:checksum).and_return(nil)
+      expect(provider.send(:managing_content?)).to be_falsey
+    end
+  end
+end