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

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

@@ -0,0 +1,70 @@
+#
+# Author:: John Keiser (<jkeiser@opscode.com>)
+# Copyright:: Copyright (c) 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.
+#
+
+require 'chef/chef_fs/file_system'
+require 'chef/chef_fs/file_system/memory_root'
+require 'chef/chef_fs/file_system/memory_dir'
+require 'chef/chef_fs/file_system/memory_file'
+
+module FileSystemSupport
+  def memory_fs(pretty_name, value, cannot_be_in_regex = nil)
+    if !value.is_a?(Hash)
+      raise "memory_fs() must take a Hash"
+    end
+    dir = Chef::ChefFS::FileSystem::MemoryRoot.new(pretty_name, cannot_be_in_regex)
+    value.each do |key, child|
+      dir.add_child(memory_fs_value(child, key.to_s, dir))
+    end
+    dir
+  end
+
+  def memory_fs_value(value, name = '', parent = nil)
+    if value.is_a?(Hash)
+      dir = Chef::ChefFS::FileSystem::MemoryDir.new(name, parent)
+      value.each do |key, child|
+        dir.add_child(memory_fs_value(child, key.to_s, dir))
+      end
+      dir
+    else
+      Chef::ChefFS::FileSystem::MemoryFile.new(name, parent, value || "#{name}\n")
+    end
+  end
+
+  def pattern(p)
+    Chef::ChefFS::FilePattern.new(p)
+  end
+
+  def return_paths(*expected)
+    ReturnPaths.new(expected)
+  end
+
+  def no_blocking_calls_allowed
+    [ Chef::ChefFS::FileSystem::MemoryFile, Chef::ChefFS::FileSystem::MemoryDir ].each do |c|
+      [ :children, :exists?, :read ].each do |m|
+        c.any_instance.stub(m).and_raise("#{m.to_s} should not be called")
+      end
+    end
+  end
+
+  def list_should_yield_paths(fs, pattern_str, *expected_paths)
+    result_paths = []
+    Chef::ChefFS::FileSystem.list(fs, pattern(pattern_str)).each { |result| result_paths << result.path }
+    result_paths.should =~ expected_paths
+  end
+end
+

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

@@ -0,0 +1,162 @@
+#
+# 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"
+
+    @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
+    platform_introspector.value_for_platform(@platform_hash).should == "default"
+  end
+
+  it "returns a default value when there is no known platform family" do
+    platform_introspector.value_for_platform_family(@platform_family_hash).should == "default value"
+  end
+
+  it "returns a default value when the current platform doesn't match" do
+    node.automatic_attrs[:platform] = "not-a-known-platform"
+    platform_introspector.value_for_platform(@platform_hash).should == "default"
+  end
+
+  it "returns a default value when current platform_family doesn't match" do
+    node.automatic_attrs[:platform_family] = "ultra-derived-linux"
+    platform_introspector.value_for_platform_family(@platform_family_hash).should == "default value"
+  end
+
+  it "returns a value based on the current platform" do
+    node.automatic_attrs[:platform] = "openbsd"
+    platform_introspector.value_for_platform(@platform_hash).should == "openbsd"
+  end
+
+  it "returns a value based on the current platform family" do
+    node.automatic_attrs[:platform_family] = "debian"
+    platform_introspector.value_for_platform_family(@platform_family_hash).should == "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"
+    platform_introspector.value_for_platform(@platform_hash).should == "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"
+    platform_introspector.value_for_platform(@platform_hash).should == "openbsd"
+  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"
+      platform_introspector.value_for_platform(@platform_hash).should == "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"
+      platform_introspector.value_for_platform(@platform_hash).should == "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'
+      platform_introspector.platform?([:redhat, :ubuntu]).should == true
+    end
+
+    it "returns true if the node is a provided platform and platforms are provided as strings" do
+      node.automatic_attrs[:platform] = 'ubuntu'
+      platform_introspector.platform?(["redhat", "ubuntu"]).should == true
+    end
+
+    it "returns false if the node is not of the provided platforms" do
+      node.automatic_attrs[:platform] = 'ubuntu'
+      platform_introspector.platform?(:splatlinux).should == 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'
+      platform_introspector.platform_family?([:rhel, :debian]).should == 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'
+      platform_introspector.platform_family?(["rhel", "debian"]).should == true
+    end
+
+    it "returns false if the node is not of the provided platforms" do
+      node.automatic_attrs[:platform_family] = 'suse'
+      platform_introspector.platform_family?(:splatlinux).should == false
+    end
+
+    it "returns false if the node is not of the provided platforms and platform_family is not set" do
+      platform_introspector.platform_family?(:splatlinux).should == 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'
+      platform_introspector.value_for_platform(@platform_hash).should == [ :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'
+      platform_introspector.value_for_platform(@platform_hash).should == [:restart, :reload]
+    end
+  end
+
+end
+

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

@@ -0,0 +1,609 @@
+#
+# 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
+
+def setup_normal_file
+  File.stub!(:exists?).with(resource_path).and_return(true)
+  File.stub!(:directory?).with(resource_path).and_return(false)
+  File.stub!(:directory?).with(enclosing_directory).and_return(true)
+  File.stub!(:writable?).with(resource_path).and_return(true)
+  file_symlink_class.stub!(:symlink?).with(resource_path).and_return(false)
+  file_symlink_class.stub!(:symlink?).with(normalized_path).and_return(false)
+end
+
+def setup_missing_file
+  File.stub!(:exists?).with(resource_path).and_return(false)
+  File.stub!(:directory?).with(resource_path).and_return(false)
+  File.stub!(:directory?).with(enclosing_directory).and_return(true)
+  File.stub!(:writable?).with(resource_path).and_return(false)
+  file_symlink_class.stub!(:symlink?).with(resource_path).and_return(false)
+end
+
+def setup_symlink
+  File.stub!(:exists?).with(resource_path).and_return(true)
+  File.stub!(:directory?).with(normalized_path).and_return(false)
+  File.stub!(:directory?).with(enclosing_directory).and_return(true)
+  File.stub!(:writable?).with(resource_path).and_return(true)
+  file_symlink_class.stub!(:symlink?).with(resource_path).and_return(true)
+  file_symlink_class.stub!(:symlink?).with(normalized_path).and_return(true)
+end
+
+def setup_unwritable_file
+  File.stub!(:exists?).with(resource_path).and_return(true)
+  File.stub!(:directory?).with(resource_path).and_return(false)
+  File.stub!(:directory?).with(enclosing_directory).and_return(true)
+  File.stub!(:writable?).with(resource_path).and_return(false)
+  file_symlink_class.stub!(:symlink?).with(resource_path).and_return(false)
+end
+
+def setup_missing_enclosing_directory
+  File.stub!(:exists?).with(resource_path).and_return(false)
+  File.stub!(:directory?).with(resource_path).and_return(false)
+  File.stub!(:directory?).with(enclosing_directory).and_return(false)
+  File.stub!(:writable?).with(resource_path).and_return(false)
+  file_symlink_class.stub!(:symlink?).with(resource_path).and_return(false)
+end
+
+shared_examples_for Chef::Provider::File do
+
+  it "should return a #{described_class}" do
+    provider.should be_a_kind_of(described_class)
+  end
+
+  it "should store the resource passed to new as new_resource" do
+    provider.new_resource.should eql(resource)
+  end
+
+  it "should store the node passed to new as node" do
+    provider.node.should eql(node)
+  end
+
+  context "when loading the current resource" do
+
+    context "when running load_current_resource and the file exists" do
+      before do
+        setup_normal_file
+        provider.load_current_resource
+      end
+
+      it "should load a current resource based on the one specified at construction" do
+        provider.current_resource.should be_a_kind_of(Chef::Resource::File)
+      end
+
+      it "the loaded current_resource name should be the same as the resource name" do
+        provider.current_resource.name.should eql(resource.name)
+      end
+
+      it "the loaded current_resource path should be the same as the resoure path" do
+        provider.current_resource.path.should eql(resource.path)
+      end
+
+      it "the loaded current_resource content should be nil" do
+        provider.current_resource.content.should eql(nil)
+      end
+    end
+
+    context "when running load_current_resource and the file does not exist" do
+      before do
+        setup_missing_file
+        provider.load_current_resource
+      end
+
+      it "the current_resource should be a Chef::Resource::File" do
+        provider.current_resource.should be_a_kind_of(Chef::Resource::File)
+      end
+
+      it "the current_resource name should be the same as the resource name" do
+        provider.current_resource.name.should eql(resource.name)
+      end
+
+      it "the current_resource path should be the same as the resource path" do
+        provider.current_resource.path.should eql(resource.path)
+      end
+
+      it "the loaded current_resource content should be nil" do
+        provider.current_resource.content.should eql(nil)
+      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
+        Chef::Platform.stub!(:windows?).and_return(false)
+        # mock up the filesystem to behave like unix
+        setup_normal_file
+        stat_struct = mock("::File.stat", :mode => 0600, :uid => 0, :gid => 0, :mtime => 10000)
+        resource_real_path = File.realpath(resource.path)
+        File.should_receive(:stat).with(resource_real_path).at_least(:once).and_return(stat_struct)
+        Etc.stub!(:getgrgid).with(0).and_return(mock("Group Ent", :name => "wheel"))
+        Etc.stub!(:getpwuid).with(0).and_return(mock("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
+          provider.current_resource.mode.should == "0600"
+          provider.current_resource.owner.should == "root"
+          provider.current_resource.group.should == "wheel"
+        end
+
+        it "should not set the new_resource permissions" do
+          provider.new_resource.group.should be_nil
+          provider.new_resource.owner.should be_nil
+          provider.new_resource.mode.should 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.
+          provider.current_resource.mode.should == "0600"
+          provider.current_resource.owner.should == 0
+          provider.current_resource.group.should == 0
+        end
+
+        it "should not set the new_resource permissions" do
+          provider.new_resource.group.should == 1
+          provider.new_resource.owner.should == 1
+          provider.new_resource.mode.should == 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
+          provider.current_resource.mode.should == "0600"
+          provider.current_resource.owner.should == "root"
+          provider.current_resource.group.should == "wheel"
+        end
+
+        it "should not set the new_resource permissions" do
+          provider.new_resource.group.should == "seattlehiphop"
+          provider.new_resource.owner.should == "macklemore"
+          provider.new_resource.mode.should == "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
+        Chef::Platform.stub!(: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
+          provider.current_resource.mode.should be_nil
+          provider.current_resource.owner.should be_nil
+          provider.current_resource.group.should be_nil
+        end
+
+        it "should not set the new_resource permissions" do
+          provider.new_resource.group.should be_nil
+          provider.new_resource.owner.should be_nil
+          provider.new_resource.mode.should 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
+          provider.current_resource.mode.should be_nil
+          provider.current_resource.owner.should be_nil
+          provider.current_resource.group.should be_nil
+        end
+
+        it "should not set the new_resource permissions" do
+          provider.new_resource.group.should == 51948
+          provider.new_resource.owner.should == 63945
+          provider.new_resource.mode.should == 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
+      Chef::Platform.stub!(:windows?).and_return(false)
+      # mock up the filesystem to behave like unix
+      setup_normal_file
+      stat_struct = mock("::File.stat", :mode => 0600, :uid => 0, :gid => 0, :mtime => 10000)
+      resource_real_path = File.realpath(resource.path)
+      File.stub!(:stat).with(resource_real_path).and_return(stat_struct)
+      Etc.stub!(:getgrgid).with(0).and_return(mock("Group Ent", :name => "wheel"))
+      Etc.stub!(:getpwuid).with(0).and_return(mock("User Ent", :name => "root"))
+      provider.send(:load_resource_attributes_from_file, resource)
+    end
+
+    it "new_resource should record the new permission information" do
+      provider.new_resource.group.should == "wheel"
+      provider.new_resource.owner.should == "root"
+      provider.new_resource.mode.should == "0600"
+    end
+  end
+
+  context "when reporting security metadata on windows" do
+    it "records the file owner" do
+      pending
+    end
+
+    it "records rights for each user in the ACL" do
+      pending
+    end
+
+    it "records deny_rights for each user in the ACL" do
+      pending
+    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
+            lambda {provider.run_action(action)}.should raise_error(Chef::Exceptions::EnclosingDirectoryDoesNotExist)
+          end
+
+          it "does not raise an exception in why-run mode" do
+            Chef::Config[:why_run] = true
+            lambda {provider.run_action(action)}.should_not raise_error(Chef::Exceptions::EnclosingDirectoryDoesNotExist)
+            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
+        lambda {provider.run_action(:delete)}.should raise_error(Chef::Exceptions::InsufficientPermissions)
+      end
+
+      it "action delete also raises InsufficientPermissions in why-run mode" do
+        Chef::Config[:why_run] = true
+        lambda {provider.run_action(:delete)}.should 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
+      provider.should_receive(:do_create_file)
+      provider.should_receive(:do_contents_changes)
+      provider.should_receive(:do_acl_changes)
+      provider.should_receive(:load_resource_attributes_from_file)
+      provider.run_action(:create)
+    end
+
+    context "do_create_file" do
+      context "when the file exists" do
+        before { setup_normal_file }
+        it "should not create the file" do
+          provider.deployment_strategy.should_not_receive(:create).with(resource_path)
+          provider.send(:do_create_file)
+          provider.send(:file_created?).should == false
+        end
+      end
+      context "when the file does not exist" do
+        before { setup_missing_file }
+        it "should create the file" do
+          provider.deployment_strategy.should_receive(:create).with(resource_path)
+          provider.send(:do_create_file)
+          provider.send(:file_created?).should == 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")
+          content.stub!(:tempfile).and_return(tempfile)
+          File.should_receive(:exists?).with("/tmp/foo-bar-baz").and_return(true)
+          tempfile.should_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
+            provider.stub!(:contents_changed?).and_return(true)
+            diff = double('Diff', :for_output => ['+++','---','+foo','-bar'],
+                                  :for_reporting => diff_for_reporting )
+            diff.stub!(:diff).with(resource_path, tempfile_path).and_return(true)
+            provider.should_receive(:diff).at_least(:once).and_return(diff)
+            provider.should_receive(:checksum).with(tempfile_path).and_return(tempfile_sha256)
+            provider.should_receive(:checksum).with(resource_path).and_return(tempfile_sha256)
+            provider.deployment_strategy.should_receive(:deploy).with(tempfile_path, normalized_path)
+          end
+          context "when the file was created" do
+            before { provider.should_receive(:file_created?).at_least(:once).and_return(true) }
+            it "does not backup the file and does not produce a diff for reporting" do
+              provider.should_not_receive(:do_backup)
+              provider.send(:do_contents_changes)
+              resource.diff.should be_nil
+            end
+          end
+          context "when the file was not created" do
+            before { provider.should_receive(:file_created?).at_least(:once).and_return(false) }
+            it "backs up the file and produces a diff for reporting" do
+              provider.should_receive(:do_backup)
+              provider.send(:do_contents_changes)
+              resource.diff.should == diff_for_reporting
+            end
+          end
+        end
+
+        it "does nothing when the contents have not changed"  do
+          provider.stub!(:contents_changed?).and_return(false)
+          provider.should_not_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
+        provider.send(:content).should_receive(:tempfile).at_least(:once).and_return(nil)
+        provider.should_not_receive(:diff)
+        lambda{ provider.send(:do_contents_changes) }.should_not raise_error
+      end
+
+      it "raises an exception when the content object returns a tempfile with a nil path" do
+        tempfile = double('Tempfile', :path => nil)
+        provider.send(:content).should_receive(:tempfile).at_least(:once).and_return(tempfile)
+        lambda{ provider.send(:do_contents_changes) }.should 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")
+        provider.send(:content).should_receive(:tempfile).at_least(:once).and_return(tempfile)
+        File.should_receive(:exists?).with("/tmp/foo-bar-baz").and_return(false)
+        lambda{ provider.send(:do_contents_changes) }.should raise_error
+      end
+    end
+
+    context "do_acl_changes" do
+      it "needs tests" do
+        pending
+      end
+    end
+
+    context "do_selinux" do
+      context "when resource is updated" do
+        before do
+          setup_normal_file
+          provider.load_current_resource
+          provider.stub!(:resource_updated?).and_return(true)
+        end
+
+        it "should check for selinux_enabled? by default" do
+          provider.should_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
+              provider.should_receive(:selinux_enabled?).and_return(true)
+            end
+
+            it "restores security context on the file" do
+              provider.should_receive(:restore_security_context).with(normalized_path, false)
+              provider.send(:do_selinux)
+            end
+
+            it "restores security context recursively when told so" do
+              provider.should_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
+              provider.should_receive(:selinux_enabled?).and_return(false)
+            end
+
+            it "should not restore security context" do
+              provider.should_not_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
+            provider.should_not_receive(:selinux_enabled?)
+            provider.send(:do_selinux)
+          end
+        end
+      end
+
+      context "when resource is not updated" do
+        before do
+          provider.stub!(:resource_updated?).and_return(false)
+        end
+
+        it "should not check for selinux_enabled?" do
+          provider.should_not_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
+            provider.should_receive(:do_backup).at_least(:once).and_return(true)
+            File.should_receive(:delete).with(resource_path).and_return(true)
+            provider.run_action(:delete)
+            resource.should 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
+            provider.should_not_receive(:do_backup)
+            File.should_receive(:delete).with(resource_path).and_return(true)
+            provider.run_action(:delete)
+            resource.should 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
+          provider.should_not_receive(:do_backup)
+          File.should_not_receive(:delete)
+          lambda { provider.run_action(:delete) }.should raise_error()
+          resource.should_not 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
+        provider.should_not_receive(:do_backup)
+        File.should_not_receive(:delete)
+        lambda { provider.run_action(:delete) }.should_not raise_error()
+        resource.should_not 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
+        File.should_receive(:utime).once
+        provider.should_receive(:action_create)
+        provider.run_action(:touch)
+        resource.should 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
+        File.should_receive(:utime).once
+        provider.should_receive(:action_create)
+        provider.run_action(:touch)
+        resource.should 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
+        provider.should_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
+        provider.should_not_receive(:action_create)
+        provider.run_action(:create_if_missing)
+      end
+    end
+
+  end
+
+end
+