diff --git a/lib/puppet/type/file.rb b/lib/puppet/type/file.rb
index 64533cda2..1d08b6773 100644
--- a/lib/puppet/type/file.rb
+++ b/lib/puppet/type/file.rb
@@ -1,936 +1,932 @@
 require 'digest/md5'
 require 'cgi'
 require 'etc'
 require 'uri'
 require 'fileutils'
 require 'enumerator'
 require 'pathname'
 require 'puppet/parameter/boolean'
 require 'puppet/util/diff'
 require 'puppet/util/checksums'
 require 'puppet/util/backups'
 require 'puppet/util/symbolic_file_mode'
 
 Puppet::Type.newtype(:file) do
   include Puppet::Util::MethodHelper
   include Puppet::Util::Checksums
   include Puppet::Util::Backups
   include Puppet::Util::SymbolicFileMode
 
   @doc = "Manages files, including their content, ownership, and permissions.
 
     The `file` type can manage normal files, directories, and symlinks; the
     type should be specified in the `ensure` attribute.
 
     File contents can be managed directly with the `content` attribute, or
     downloaded from a remote source using the `source` attribute; the latter
     can also be used to recursively serve directories (when the `recurse`
     attribute is set to `true` or `local`). On Windows, note that file
     contents are managed in binary mode; Puppet never automatically translates
     line endings.
 
     **Autorequires:** If Puppet is managing the user or group that owns a
     file, the file resource will autorequire them. If Puppet is managing any
     parent directories of a file, the file resource will autorequire them."
 
   feature :manages_symlinks,
     "The provider can manage symbolic links."
 
   def self.title_patterns
     [ [ /^(.*?)\/*\Z/m, [ [ :path ] ] ] ]
   end
 
   newparam(:path) do
     desc <<-'EOT'
       The path to the file to manage.  Must be fully qualified.
 
       On Windows, the path should include the drive letter and should use `/` as
       the separator character (rather than `\\`).
     EOT
     isnamevar
 
     validate do |value|
       unless Puppet::Util.absolute_path?(value)
         fail Puppet::Error, "File paths must be fully qualified, not '#{value}'"
       end
     end
 
     munge do |value|
       if value.start_with?('//') and ::File.basename(value) == "/"
         # This is a UNC path pointing to a share, so don't add a trailing slash
         ::File.expand_path(value)
       else
         ::File.join(::File.split(::File.expand_path(value)))
       end
     end
   end
 
   newparam(:backup) do
     desc <<-EOT
       Whether (and how) file content should be backed up before being replaced.
       This attribute works best as a resource default in the site manifest
       (`File { backup => main }`), so it can affect all file resources.
 
       * If set to `false`, file content won't be backed up.
       * If set to a string beginning with `.` (e.g., `.puppet-bak`), Puppet will
         use copy the file in the same directory with that value as the extension
         of the backup. (A value of `true` is a synonym for `.puppet-bak`.)
       * If set to any other string, Puppet will try to back up to a filebucket
         with that title. See the `filebucket` resource type for more details.
         (This is the preferred method for backup, since it can be centralized
         and queried.)
 
       Default value: `puppet`, which backs up to a filebucket of the same name.
       (Puppet automatically creates a **local** filebucket named `puppet` if one
       doesn't already exist.)
 
       Backing up to a local filebucket isn't particularly useful. If you want
       to make organized use of backups, you will generally want to use the
       puppet master server's filebucket service. This requires declaring a
       filebucket resource and a resource default for the `backup` attribute
       in site.pp:
 
           # /etc/puppet/manifests/site.pp
           filebucket { 'main':
             path   => false,                # This is required for remote filebuckets.
             server => 'puppet.example.com', # Optional; defaults to the configured puppet master.
           }
 
           File { backup => main, }
 
       If you are using multiple puppet master servers, you will want to
       centralize the contents of the filebucket. Either configure your load
       balancer to direct all filebucket traffic to a single master, or use
       something like an out-of-band rsync task to synchronize the content on all
       masters.
     EOT
 
     defaultto "puppet"
 
     munge do |value|
       # I don't really know how this is happening.
       value = value.shift if value.is_a?(Array)
 
       case value
       when false, "false", :false
         false
       when true, "true", ".puppet-bak", :true
         ".puppet-bak"
       when String
         value
       else
         self.fail "Invalid backup type #{value.inspect}"
       end
     end
   end
 
   newparam(:recurse) do
     desc "Whether to recursively manage the _contents_ of a directory. This attribute
       is only used when `ensure => directory` is set. The allowed values are:
 
       * `false` --- The default behavior. The contents of the directory will not be
         automatically managed.
       * `remote` --- If the `source` attribute is set, Puppet will automatically
         manage the contents of the source directory (or directories), ensuring
         that equivalent files and directories exist on the target system and
         that their contents match.
 
         Using `remote` will disable the `purge` attribute, but results in faster
         catalog application than `recurse => true`.
 
         The `source` attribute is mandatory when `recurse => remote`.
       * `true` --- If the `source` attribute is set, this behaves similarly to
         `recurse => remote`, automatically managing files from the source directory.
 
         This also enables the `purge` attribute, which can delete unmanaged
         files from a directory. See the description of `purge` for more details.
 
         The `source` attribute is not mandatory when using `recurse => true`, so you
         can enable purging in directories where all files are managed individually.
 
       By default, setting recurse to `remote` or `true` will manage _all_
       subdirectories. You can use the `recurselimit` attribute to limit the
       recursion depth.
     "
 
     newvalues(:true, :false, :remote)
 
     validate { |arg| }
     munge do |value|
       newval = super(value)
       case newval
       when :true; true
       when :false; false
       when :remote; :remote
       else
         self.fail "Invalid recurse value #{value.inspect}"
       end
     end
   end
 
   newparam(:recurselimit) do
     desc "How far Puppet should descend into subdirectories, when using
       `ensure => directory` and either `recurse => true` or `recurse => remote`.
       The recursion limit affects which files will be copied from the `source`
       directory, as well as which files can be purged when `purge => true`.
 
       Setting `recurselimit => 0` is the same as setting `recurse => false` ---
       Puppet will manage the directory, but all of its contents will be treated
       as unmanaged.
 
       Setting `recurselimit => 1` will manage files and directories that are
       directly inside the directory, but will not manage the contents of any
       subdirectories.
 
       Setting `recurselimit => 2` will manage the direct contents of the
       directory, as well as the contents of the _first_ level of subdirectories.
 
       And so on --- 3 will manage the contents of the second level of
       subdirectories, etc."
 
     newvalues(/^[0-9]+$/)
 
     munge do |value|
       newval = super(value)
       case newval
       when Integer, Fixnum, Bignum; value
       when /^\d+$/; Integer(value)
       else
         self.fail "Invalid recurselimit value #{value.inspect}"
       end
     end
   end
 
   newparam(:replace, :boolean => true, :parent => Puppet::Parameter::Boolean) do
     desc "Whether to replace a file or symlink that already exists on the local system but
       whose content doesn't match what the `source` or `content` attribute
       specifies.  Setting this to false allows file resources to initialize files
       without overwriting future changes.  Note that this only affects content;
       Puppet will still manage ownership and permissions. Defaults to `true`."
     defaultto :true
   end
 
   newparam(:force, :boolean => true, :parent => Puppet::Parameter::Boolean) do
     desc "Perform the file operation even if it will destroy one or more directories.
       You must use `force` in order to:
 
       * `purge` subdirectories
       * Replace directories with files or links
       * Remove a directory when `ensure => absent`"
     defaultto false
   end
 
   newparam(:ignore) do
     desc "A parameter which omits action on files matching
       specified patterns during recursion.  Uses Ruby's builtin globbing
       engine, so shell metacharacters are fully supported, e.g. `[a-z]*`.
       Matches that would descend into the directory structure are ignored,
       e.g., `*/*`."
 
     validate do |value|
       unless value.is_a?(Array) or value.is_a?(String) or value == false
         self.devfail "Ignore must be a string or an Array"
       end
     end
   end
 
   newparam(:links) do
     desc "How to handle links during file actions.  During file copying,
       `follow` will copy the target file instead of the link, `manage`
       will copy the link itself, and `ignore` will just pass it by.
       When not copying, `manage` and `ignore` behave equivalently
       (because you cannot really ignore links entirely during local
       recursion), and `follow` will manage the file to which the link points."
 
     newvalues(:follow, :manage)
 
     defaultto :manage
   end
 
   newparam(:purge, :boolean => true, :parent => Puppet::Parameter::Boolean) do
     desc "Whether unmanaged files should be purged. This option only makes
       sense when `ensure => directory` and `recurse => true`.
 
       * When recursively duplicating an entire directory with the `source`
         attribute, `purge => true` will automatically purge any files
         that are not in the source directory.
       * When managing files in a directory as individual resources,
         setting `purge => true` will purge any files that aren't being
         specifically managed.
 
       If you have a filebucket configured, the purged files will be uploaded,
       but if you do not, this will destroy data.
 
       Unless `force => true` is set, purging will **not** delete directories,
       although it will delete the files they contain.
 
       If `recurselimit` is set and you aren't using `force => true`, purging
       will obey the recursion limit; files in any subdirectories deeper than the
       limit will be treated as unmanaged and left alone."
 
     defaultto :false
   end
 
   newparam(:sourceselect) do
     desc "Whether to copy all valid sources, or just the first one.  This parameter
       only affects recursive directory copies; by default, the first valid
       source is the only one used, but if this parameter is set to `all`, then
       all valid sources will have all of their contents copied to the local
       system. If a given file exists in more than one source, the version from
       the earliest source in the list will be used."
 
     defaultto :first
 
     newvalues(:first, :all)
   end
 
   newparam(:show_diff, :boolean => true, :parent => Puppet::Parameter::Boolean) do
     desc "Whether to display differences when the file changes, defaulting to
         true.  This parameter is useful for files that may contain passwords or
         other secret data, which might otherwise be included in Puppet reports or
         other insecure outputs.  If the global `show_diff` setting
         is false, then no diffs will be shown even if this parameter is true."
 
     defaultto :true
   end
 
   newparam(:validate_cmd) do
     desc "A command for validating the file's syntax before replacing it. If
       Puppet would need to rewrite a file due to new `source` or `content`, it
       will check the new content's validity first. If validation fails, the file
       resource will fail.
 
       This command must have a fully qualified path, and should contain a
       percent (`%`) token where it would expect an input file. It must exit `0`
       if the syntax is correct, and non-zero otherwise. The command will be
       run on the target system while applying the catalog, not on the puppet master.
 
       Example:
 
           file { '/etc/apache2/apache2.conf':
             content      => 'example',
             validate_cmd => '/usr/sbin/apache2 -t -f %',
           }
 
       This would replace apache2.conf only if the test returned true.
 
       Note that if a validation command requires a `%` as part of its text,
       you can specify a different placeholder token with the
       `validate_replacement` attribute."
   end
 
   newparam(:validate_replacement) do
     desc "The replacement string in a `validate_cmd` that will be replaced
       with an input file name. Defaults to: `%`"
 
     defaultto '%'
   end
 
   # Autorequire the nearest ancestor directory found in the catalog.
   autorequire(:file) do
     req = []
     path = Pathname.new(self[:path])
     if !path.root?
       # Start at our parent, to avoid autorequiring ourself
       parents = path.parent.enum_for(:ascend)
       if found = parents.find { |p| catalog.resource(:file, p.to_s) }
         req << found.to_s
       end
     end
     # if the resource is a link, make sure the target is created first
     req << self[:target] if self[:target]
     req
   end
 
   # Autorequire the owner and group of the file.
   {:user => :owner, :group => :group}.each do |type, property|
     autorequire(type) do
       if @parameters.include?(property)
         # The user/group property automatically converts to IDs
         next unless should = @parameters[property].shouldorig
         val = should[0]
         if val.is_a?(Integer) or val =~ /^\d+$/
           nil
         else
           val
         end
       end
     end
   end
 
   CREATORS = [:content, :source, :target]
   SOURCE_ONLY_CHECKSUMS = [:none, :ctime, :mtime]
 
   validate do
     creator_count = 0
     CREATORS.each do |param|
       creator_count += 1 if self.should(param)
     end
     creator_count += 1 if @parameters.include?(:source)
     self.fail "You cannot specify more than one of #{CREATORS.collect { |p| p.to_s}.join(", ")}" if creator_count > 1
 
     self.fail "You cannot specify a remote recursion without a source" if !self[:source] and self[:recurse] == :remote
 
     self.fail "You cannot specify source when using checksum 'none'" if self[:checksum] == :none && !self[:source].nil?
 
     SOURCE_ONLY_CHECKSUMS.each do |checksum_type|
       self.fail "You cannot specify content when using checksum '#{checksum_type}'" if self[:checksum] == checksum_type && !self[:content].nil?
     end
 
     self.warning "Possible error: recurselimit is set but not recurse, no recursion will happen" if !self[:recurse] and self[:recurselimit]
 
     if @parameters[:content] && @parameters[:content].actual_content
       # Now that we know the checksum, update content (in case it was created before checksum was known).
       @parameters[:content].value = @parameters[:checksum].sum(@parameters[:content].actual_content)
     end
 
     provider.validate if provider.respond_to?(:validate)
   end
 
   def self.[](path)
     return nil unless path
     super(path.gsub(/\/+/, '/').sub(/\/$/, ''))
   end
 
   def self.instances
     return []
   end
 
   # Determine the user to write files as.
   def asuser
     if self.should(:owner) and ! self.should(:owner).is_a?(Symbol)
       writeable = Puppet::Util::SUIDManager.asuser(self.should(:owner)) {
         FileTest.writable?(::File.dirname(self[:path]))
       }
 
       # If the parent directory is writeable, then we execute
       # as the user in question.  Otherwise we'll rely on
       # the 'owner' property to do things.
       asuser = self.should(:owner) if writeable
     end
 
     asuser
   end
 
   def bucket
     return @bucket if @bucket
 
     backup = self[:backup]
     return nil unless backup
     return nil if backup =~ /^\./
 
     unless catalog or backup == "puppet"
       fail "Can not find filebucket for backups without a catalog"
     end
 
     unless catalog and filebucket = catalog.resource(:filebucket, backup) or backup == "puppet"
       fail "Could not find filebucket #{backup} specified in backup"
     end
 
     return default_bucket unless filebucket
 
     @bucket = filebucket.bucket
 
     @bucket
   end
 
   def default_bucket
     Puppet::Type.type(:filebucket).mkdefaultbucket.bucket
   end
 
   # Does the file currently exist?  Just checks for whether
   # we have a stat
   def exist?
     stat ? true : false
   end
 
   def present?(current_values)
     super && current_values[:ensure] != :false
   end
 
   # We have to do some extra finishing, to retrieve our bucket if
   # there is one.
   def finish
     # Look up our bucket, if there is one
     bucket
     super
   end
 
   # Create any children via recursion or whatever.
   def eval_generate
     return [] unless self.recurse?
 
     recurse
   end
 
   def ancestors
     ancestors = Pathname.new(self[:path]).enum_for(:ascend).map(&:to_s)
     ancestors.delete(self[:path])
     ancestors
   end
 
   def flush
     # We want to make sure we retrieve metadata anew on each transaction.
     @parameters.each do |name, param|
       param.flush if param.respond_to?(:flush)
     end
     @stat = :needs_stat
   end
 
   def initialize(hash)
     # Used for caching clients
     @clients = {}
 
     super
 
     # If they've specified a source, we get our 'should' values
     # from it.
     unless self[:ensure]
       if self[:target]
         self[:ensure] = :link
       elsif self[:content]
         self[:ensure] = :file
       end
     end
 
     @stat = :needs_stat
   end
 
   # Configure discovered resources to be purged.
   def mark_children_for_purging(children)
     children.each do |name, child|
       next if child[:source]
       child[:ensure] = :absent
     end
   end
 
   # Create a new file or directory object as a child to the current
   # object.
   def newchild(path)
     full_path = ::File.join(self[:path], path)
 
     # Add some new values to our original arguments -- these are the ones
     # set at initialization.  We specifically want to exclude any param
     # values set by the :source property or any default values.
     # LAK:NOTE This is kind of silly, because the whole point here is that
     # the values set at initialization should live as long as the resource
     # but values set by default or by :source should only live for the transaction
     # or so.  Unfortunately, we don't have a straightforward way to manage
     # the different lifetimes of this data, so we kludge it like this.
     # The right-side hash wins in the merge.
     options = @original_parameters.merge(:path => full_path).reject { |param, value| value.nil? }
 
     # These should never be passed to our children.
     [:parent, :ensure, :recurse, :recurselimit, :target, :alias, :source].each do |param|
       options.delete(param) if options.include?(param)
     end
 
     self.class.new(options)
   end
 
   # Files handle paths specially, because they just lengthen their
   # path names, rather than including the full parent's title each
   # time.
   def pathbuilder
     # We specifically need to call the method here, so it looks
     # up our parent in the catalog graph.
     if parent = parent()
       # We only need to behave specially when our parent is also
       # a file
       if parent.is_a?(self.class)
         # Remove the parent file name
         list = parent.pathbuilder
         list.pop # remove the parent's path info
         return list << self.ref
       else
         return super
       end
     else
       return [self.ref]
     end
   end
 
   # Recursively generate a list of file resources, which will
   # be used to copy remote files, manage local files, and/or make links
   # to map to another directory.
   def recurse
     children = (self[:recurse] == :remote) ? {} : recurse_local
 
     if self[:target]
       recurse_link(children)
     elsif self[:source]
       recurse_remote(children)
     end
 
     # If we're purging resources, then delete any resource that isn't on the
     # remote system.
     mark_children_for_purging(children) if self.purge?
 
     # REVISIT: sort_by is more efficient?
     result = children.values.sort { |a, b| a[:path] <=> b[:path] }
     remove_less_specific_files(result)
   end
 
   # This is to fix bug #2296, where two files recurse over the same
   # set of files.  It's a rare case, and when it does happen you're
   # not likely to have many actual conflicts, which is good, because
   # this is a pretty inefficient implementation.
   def remove_less_specific_files(files)
     # REVISIT: is this Windows safe?  AltSeparator?
     mypath = self[:path].split(::File::Separator)
     other_paths = catalog.vertices.
       select  { |r| r.is_a?(self.class) and r[:path] != self[:path] }.
       collect { |r| r[:path].split(::File::Separator) }.
       select  { |p| p[0,mypath.length]  == mypath }
 
     return files if other_paths.empty?
 
     files.reject { |file|
       path = file[:path].split(::File::Separator)
       other_paths.any? { |p| path[0,p.length] == p }
       }
   end
 
   # A simple method for determining whether we should be recursing.
   def recurse?
     self[:recurse] == true or self[:recurse] == :remote
   end
 
   # Recurse the target of the link.
   def recurse_link(children)
     perform_recursion(self[:target]).each do |meta|
       if meta.relative_path == "."
         self[:ensure] = :directory
         next
       end
 
       children[meta.relative_path] ||= newchild(meta.relative_path)
       if meta.ftype == "directory"
         children[meta.relative_path][:ensure] = :directory
       else
         children[meta.relative_path][:ensure] = :link
         children[meta.relative_path][:target] = meta.full_path
       end
     end
     children
   end
 
   # Recurse the file itself, returning a Metadata instance for every found file.
   def recurse_local
     result = perform_recursion(self[:path])
     return {} unless result
     result.inject({}) do |hash, meta|
       next hash if meta.relative_path == "."
 
       hash[meta.relative_path] = newchild(meta.relative_path)
       hash
     end
   end
 
   # Recurse against our remote file.
   def recurse_remote(children)
     sourceselect = self[:sourceselect]
 
     total = self[:source].collect do |source|
       next unless result = perform_recursion(source)
       return if top = result.find { |r| r.relative_path == "." } and top.ftype != "directory"
       result.each { |data| data.source = "#{source}/#{data.relative_path}" }
       break result if result and ! result.empty? and sourceselect == :first
       result
     end.flatten.compact
 
     # This only happens if we have sourceselect == :all
     unless sourceselect == :first
       found = []
       total.reject! do |data|
         result = found.include?(data.relative_path)
         found << data.relative_path unless found.include?(data.relative_path)
         result
       end
     end
 
     total.each do |meta|
       if meta.relative_path == "."
         parameter(:source).metadata = meta
         next
       end
       children[meta.relative_path] ||= newchild(meta.relative_path)
       children[meta.relative_path][:source] = meta.source
-      if meta.ftype == "file"
-        children[meta.relative_path][:checksum] = Puppet[:digest_algorithm].to_sym
-      end
-
       children[meta.relative_path].parameter(:source).metadata = meta
     end
 
     children
   end
 
   def perform_recursion(path)
     Puppet::FileServing::Metadata.indirection.search(
       path,
       :links => self[:links],
       :recurse => (self[:recurse] == :remote ? true : self[:recurse]),
       :recurselimit => self[:recurselimit],
       :ignore => self[:ignore],
       :checksum_type => (self[:source] || self[:content]) ? self[:checksum] : :none,
       :environment => catalog.environment_instance
     )
   end
 
   # Back up and remove the file or directory at `self[:path]`.
   #
   # @param  [Symbol] should The file type replacing the current content.
   # @return [Boolean] True if the file was removed, else False
   # @raises [fail???] If the current file isn't one of %w{file link directory} and can't be removed.
   def remove_existing(should)
     wanted_type = should.to_s
     current_type = read_current_type
 
     if current_type.nil?
       return false
     end
 
     if can_backup?(current_type)
       backup_existing
     end
 
     if wanted_type != "link" and current_type == wanted_type
       return false
     end
 
     case current_type
     when "directory"
       return remove_directory(wanted_type)
     when "link", "file"
       return remove_file(current_type, wanted_type)
     else
       self.fail "Could not back up files of type #{current_type}"
     end
   end
 
   def retrieve
     if source = parameter(:source)
       source.copy_source_values
     end
     super
   end
 
   # Set the checksum, from another property.  There are multiple
   # properties that modify the contents of a file, and they need the
   # ability to make sure that the checksum value is in sync.
   def setchecksum(sum = nil)
     if @parameters.include? :checksum
       if sum
         @parameters[:checksum].checksum = sum
       else
         # If they didn't pass in a sum, then tell checksum to
         # figure it out.
         currentvalue = @parameters[:checksum].retrieve
         @parameters[:checksum].checksum = currentvalue
       end
     end
   end
 
   # Should this thing be a normal file?  This is a relatively complex
   # way of determining whether we're trying to create a normal file,
   # and it's here so that the logic isn't visible in the content property.
   def should_be_file?
     return true if self[:ensure] == :file
 
     # I.e., it's set to something like "directory"
     return false if e = self[:ensure] and e != :present
 
     # The user doesn't really care, apparently
     if self[:ensure] == :present
       return true unless s = stat
       return(s.ftype == "file" ? true : false)
     end
 
     # If we've gotten here, then :ensure isn't set
     return true if self[:content]
     return true if stat and stat.ftype == "file"
     false
   end
 
   # Stat our file.  Depending on the value of the 'links' attribute, we
   # use either 'stat' or 'lstat', and we expect the properties to use the
   # resulting stat object accordingly (mostly by testing the 'ftype'
   # value).
   #
   # We use the initial value :needs_stat to ensure we only stat the file once,
   # but can also keep track of a failed stat (@stat == nil). This also allows
   # us to re-stat on demand by setting @stat = :needs_stat.
   def stat
     return @stat unless @stat == :needs_stat
 
     method = :stat
 
     # Files are the only types that support links
     if (self.class.name == :file and self[:links] != :follow) or self.class.name == :tidy
       method = :lstat
     end
 
     @stat = begin
       Puppet::FileSystem.send(method, self[:path])
     rescue Errno::ENOENT => error
       nil
     rescue Errno::ENOTDIR => error
       nil
     rescue Errno::EACCES => error
       warning "Could not stat; permission denied"
       nil
     end
   end
 
   def to_resource
     resource = super
     resource.delete(:target) if resource[:target] == :notlink
     resource
   end
 
   # Write out the file.  Requires the property name for logging.
   # Write will be done by the content property, along with checksum computation
   def write(property)
     remove_existing(:file)
 
     mode = self.should(:mode) # might be nil
     mode_int = mode ? symbolic_mode_to_int(mode, Puppet::Util::DEFAULT_POSIX_MODE) : nil
 
     if write_temporary_file?
       Puppet::Util.replace_file(self[:path], mode_int) do |file|
         file.binmode
         content_checksum = write_content(file)
         file.flush
         fail_if_checksum_is_wrong(file.path, content_checksum) if validate_checksum?
         if self[:validate_cmd]
           output = Puppet::Util::Execution.execute(self[:validate_cmd].gsub(self[:validate_replacement], file.path), :failonfail => true, :combine => true)
           output.split(/\n/).each { |line|
             self.debug(line)
           }
         end
       end
     else
       umask = mode ? 000 : 022
       Puppet::Util.withumask(umask) { ::File.open(self[:path], 'wb', mode_int ) { |f| write_content(f) } }
     end
 
     # make sure all of the modes are actually correct
     property_fix
   end
 
   private
 
   # @return [String] The type of the current file, cast to a string.
   def read_current_type
     stat_info = stat
     if stat_info
       stat_info.ftype.to_s
     else
       nil
     end
   end
 
   # @return [Boolean] If the current file can be backed up and needs to be backed up.
   def can_backup?(type)
     if type == "directory" and not force?
       # (#18110) Directories cannot be removed without :force, so it doesn't
       # make sense to back them up.
       false
     else
       true
     end
   end
 
   # @return [Boolean] True if the directory was removed
   # @api private
   def remove_directory(wanted_type)
     if force?
       debug "Removing existing directory for replacement with #{wanted_type}"
       FileUtils.rmtree(self[:path])
       stat_needed
       true
     else
       notice "Not removing directory; use 'force' to override"
       false
     end
   end
 
   # @return [Boolean] if the file was removed (which is always true currently)
   # @api private
   def remove_file(current_type, wanted_type)
     debug "Removing existing #{current_type} for replacement with #{wanted_type}"
     Puppet::FileSystem.unlink(self[:path])
     stat_needed
     true
   end
 
   def stat_needed
     @stat = :needs_stat
   end
 
   # Back up the existing file at a given prior to it being removed
   # @api private
   # @raise [Puppet::Error] if the file backup failed
   # @return [void]
   def backup_existing
     unless perform_backup
       raise Puppet::Error, "Could not back up; will not replace"
     end
   end
 
   # Should we validate the checksum of the file we're writing?
   def validate_checksum?
     self[:checksum] !~ /time/
   end
 
   # Make sure the file we wrote out is what we think it is.
   def fail_if_checksum_is_wrong(path, content_checksum)
     newsum = parameter(:checksum).sum_file(path)
     return if [:absent, nil, content_checksum].include?(newsum)
 
     self.fail "File written to disk did not match checksum; discarding changes (#{content_checksum} vs #{newsum})"
   end
 
   # write the current content. Note that if there is no content property
   # simply opening the file with 'w' as done in write is enough to truncate
   # or write an empty length file.
   def write_content(file)
     (content = property(:content)) && content.write(file)
   end
 
   def write_temporary_file?
     # unfortunately we don't know the source file size before fetching it
     # so let's assume the file won't be empty
     (c = property(:content) and c.length) || @parameters[:source]
   end
 
   # There are some cases where all of the work does not get done on
   # file creation/modification, so we have to do some extra checking.
   def property_fix
     properties.each do |thing|
       next unless [:mode, :owner, :group, :seluser, :selrole, :seltype, :selrange].include?(thing.name)
 
       # Make sure we get a new stat objct
       @stat = :needs_stat
       currentvalue = thing.retrieve
       thing.sync unless thing.safe_insync?(currentvalue)
     end
   end
 end
 
 # We put all of the properties in separate files, because there are so many
 # of them.  The order these are loaded is important, because it determines
 # the order they are in the property lit.
 require 'puppet/type/file/checksum'
 require 'puppet/type/file/content'     # can create the file
 require 'puppet/type/file/source'      # can create the file
 require 'puppet/type/file/target'      # creates a different type of file
 require 'puppet/type/file/ensure'      # can create the file
 require 'puppet/type/file/owner'
 require 'puppet/type/file/group'
 require 'puppet/type/file/mode'
 require 'puppet/type/file/type'
 require 'puppet/type/file/selcontext'  # SELinux file context
 require 'puppet/type/file/ctime'
 require 'puppet/type/file/mtime'
diff --git a/spec/integration/type/file_spec.rb b/spec/integration/type/file_spec.rb
index e78c20f95..413354847 100755
--- a/spec/integration/type/file_spec.rb
+++ b/spec/integration/type/file_spec.rb
@@ -1,1319 +1,1349 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet_spec/files'
 
 if Puppet.features.microsoft_windows?
   require 'puppet/util/windows'
   class WindowsSecurity
     extend Puppet::Util::Windows::Security
   end
 end
 
 describe Puppet::Type.type(:file), :uses_checksums => true do
   include PuppetSpec::Files
   include_context 'with supported checksum types'
 
   let(:catalog) { Puppet::Resource::Catalog.new }
   let(:path) do
     # we create a directory first so backups of :path that are stored in
     # the same directory will also be removed after the tests
     parent = tmpdir('file_spec')
     File.join(parent, 'file_testing')
   end
 
   let(:dir) do
     # we create a directory first so backups of :path that are stored in
     # the same directory will also be removed after the tests
     parent = tmpdir('file_spec')
     File.join(parent, 'dir_testing')
   end
 
   if Puppet.features.posix?
     def set_mode(mode, file)
       File.chmod(mode, file)
     end
 
     def get_mode(file)
       Puppet::FileSystem.lstat(file).mode
     end
 
     def get_owner(file)
       Puppet::FileSystem.lstat(file).uid
     end
 
     def get_group(file)
       Puppet::FileSystem.lstat(file).gid
     end
   else
     class SecurityHelper
       extend Puppet::Util::Windows::Security
     end
 
     def set_mode(mode, file)
       SecurityHelper.set_mode(mode, file)
     end
 
     def get_mode(file)
       SecurityHelper.get_mode(file)
     end
 
     def get_owner(file)
       SecurityHelper.get_owner(file)
     end
 
     def get_group(file)
       SecurityHelper.get_group(file)
     end
 
     def get_aces_for_path_by_sid(path, sid)
       SecurityHelper.get_aces_for_path_by_sid(path, sid)
     end
   end
 
   around :each do |example|
     Puppet.override(:environments => Puppet::Environments::Static.new) do
       example.run
     end
   end
 
   before do
     # stub this to not try to create state.yaml
     Puppet::Util::Storage.stubs(:store)
   end
 
   it "should not attempt to manage files that do not exist if no means of creating the file is specified" do
     source = tmpfile('source')
 
     catalog.add_resource described_class.new :path => source, :mode => '0755'
 
     status = catalog.apply.report.resource_statuses["File[#{source}]"]
     expect(status).not_to be_failed
     expect(status).not_to be_changed
     expect(Puppet::FileSystem.exist?(source)).to be_falsey
   end
 
   describe "when ensure is absent" do
     it "should remove the file if present" do
       FileUtils.touch(path)
       catalog.add_resource(described_class.new(:path => path, :ensure => :absent, :backup => :false))
       report = catalog.apply.report
       expect(report.resource_statuses["File[#{path}]"]).not_to be_failed
       expect(Puppet::FileSystem.exist?(path)).to be_falsey
     end
 
     it "should do nothing if file is not present" do
       catalog.add_resource(described_class.new(:path => path, :ensure => :absent, :backup => :false))
       report = catalog.apply.report
       expect(report.resource_statuses["File[#{path}]"]).not_to be_failed
       expect(Puppet::FileSystem.exist?(path)).to be_falsey
     end
 
     # issue #14599
     it "should not fail if parts of path aren't directories" do
       FileUtils.touch(path)
       catalog.add_resource(described_class.new(:path => File.join(path,'no_such_file'), :ensure => :absent, :backup => :false))
       report = catalog.apply.report
       expect(report.resource_statuses["File[#{File.join(path,'no_such_file')}]"]).not_to be_failed
     end
   end
 
   describe "when setting permissions" do
     it "should set the owner" do
       target = tmpfile_with_contents('target', '')
       owner = get_owner(target)
 
       catalog.add_resource described_class.new(
         :name    => target,
         :owner   => owner
       )
 
       catalog.apply
 
       expect(get_owner(target)).to eq(owner)
     end
 
     it "should set the group" do
       target = tmpfile_with_contents('target', '')
       group = get_group(target)
 
       catalog.add_resource described_class.new(
         :name    => target,
         :group   => group
       )
 
       catalog.apply
 
       expect(get_group(target)).to eq(group)
     end
 
     describe "when setting mode" do
       describe "for directories" do
         let(:target) { tmpdir('dir_mode') }
 
         it "should set executable bits for newly created directories" do
           catalog.add_resource described_class.new(:path => target, :ensure => :directory, :mode => '0600')
 
           catalog.apply
 
           expect(get_mode(target) & 07777).to eq(0700)
         end
 
         it "should set executable bits for existing readable directories" do
           set_mode(0600, target)
 
           catalog.add_resource described_class.new(:path => target, :ensure => :directory, :mode => '0644')
           catalog.apply
 
           expect(get_mode(target) & 07777).to eq(0755)
         end
 
         it "should not set executable bits for unreadable directories" do
           begin
             catalog.add_resource described_class.new(:path => target, :ensure => :directory, :mode => '0300')
 
             catalog.apply
 
             expect(get_mode(target) & 07777).to eq(0300)
           ensure
             # so we can cleanup
             set_mode(0700, target)
           end
         end
 
         it "should set user, group, and other executable bits" do
           catalog.add_resource described_class.new(:path => target, :ensure => :directory, :mode => '0664')
 
           catalog.apply
 
           expect(get_mode(target) & 07777).to eq(0775)
         end
 
         it "should set executable bits when overwriting a non-executable file" do
           target_path = tmpfile_with_contents('executable', '')
           set_mode(0444, target_path)
 
           catalog.add_resource described_class.new(:path => target_path, :ensure => :directory, :mode => '0666', :backup => false)
           catalog.apply
 
           expect(get_mode(target_path) & 07777).to eq(0777)
           expect(File).to be_directory(target_path)
         end
       end
 
       describe "for files" do
         it "should not set executable bits" do
           catalog.add_resource described_class.new(:path => path, :ensure => :file, :mode => '0666')
           catalog.apply
 
           expect(get_mode(path) & 07777).to eq(0666)
         end
 
         it "should not set executable bits when replacing an executable directory (#10365)" do
           pending("bug #10365")
 
           FileUtils.mkdir(path)
           set_mode(0777, path)
 
           catalog.add_resource described_class.new(:path => path, :ensure => :file, :mode => 0666, :backup => false, :force => true)
           catalog.apply
 
           expect(get_mode(path) & 07777).to eq(0666)
         end
       end
 
       describe "for links", :if => described_class.defaultprovider.feature?(:manages_symlinks) do
         let(:link) { tmpfile('link_mode') }
 
         describe "when managing links" do
           let(:link_target) { tmpfile('target') }
 
           before :each do
             FileUtils.touch(link_target)
             File.chmod(0444, link_target)
 
             Puppet::FileSystem.symlink(link_target, link)
           end
 
           it "should not set the executable bit on the link nor the target" do
             catalog.add_resource described_class.new(:path => link, :ensure => :link, :mode => '0666', :target => link_target, :links => :manage)
 
             catalog.apply
 
             (Puppet::FileSystem.stat(link).mode & 07777) == 0666
             (Puppet::FileSystem.lstat(link_target).mode & 07777) == 0444
           end
 
           it "should ignore dangling symlinks (#6856)" do
             File.delete(link_target)
 
             catalog.add_resource described_class.new(:path => link, :ensure => :link, :mode => '0666', :target => link_target, :links => :manage)
             catalog.apply
 
             expect(Puppet::FileSystem.exist?(link)).to be_falsey
           end
 
           it "should create a link to the target if ensure is omitted" do
             FileUtils.touch(link_target)
             catalog.add_resource described_class.new(:path => link, :target => link_target)
             catalog.apply
 
             expect(Puppet::FileSystem.exist?(link)).to be_truthy
             expect(Puppet::FileSystem.lstat(link).ftype).to eq('link')
             expect(Puppet::FileSystem.readlink(link)).to eq(link_target)
           end
         end
 
         describe "when following links" do
           it "should ignore dangling symlinks (#6856)" do
             target = tmpfile('dangling')
 
             FileUtils.touch(target)
             Puppet::FileSystem.symlink(target, link)
             File.delete(target)
 
             catalog.add_resource described_class.new(:path => path, :source => link, :mode => '0600', :links => :follow)
             catalog.apply
           end
 
           describe "to a directory" do
             let(:link_target) { tmpdir('dir_target') }
 
             before :each do
               File.chmod(0600, link_target)
 
               Puppet::FileSystem.symlink(link_target, link)
             end
 
             after :each do
               File.chmod(0750, link_target)
             end
 
             describe "that is readable" do
               it "should set the executable bits when creating the destination (#10315)" do
                 catalog.add_resource described_class.new(:path => path, :source => link, :mode => '0666', :links => :follow)
                 catalog.apply
 
                 expect(File).to be_directory(path)
                 expect(get_mode(path) & 07777).to eq(0777)
               end
 
               it "should set the executable bits when overwriting the destination (#10315)" do
                 FileUtils.touch(path)
 
                 catalog.add_resource described_class.new(:path => path, :source => link, :mode => '0666', :links => :follow, :backup => false)
                 catalog.apply
 
                 expect(File).to be_directory(path)
                 expect(get_mode(path) & 07777).to eq(0777)
               end
             end
 
             describe "that is not readable" do
               before :each do
                 set_mode(0300, link_target)
               end
 
               # so we can cleanup
               after :each do
                 set_mode(0700, link_target)
               end
 
               it "should set executable bits when creating the destination (#10315)" do
                 catalog.add_resource described_class.new(:path => path, :source => link, :mode => '0666', :links => :follow)
                 catalog.apply
 
                 expect(File).to be_directory(path)
                 expect(get_mode(path) & 07777).to eq(0777)
               end
 
               it "should set executable bits when overwriting the destination" do
                 FileUtils.touch(path)
 
                 catalog.add_resource described_class.new(:path => path, :source => link, :mode => '0666', :links => :follow, :backup => false)
                 catalog.apply
 
                 expect(File).to be_directory(path)
                 expect(get_mode(path) & 07777).to eq(0777)
               end
             end
           end
 
           describe "to a file" do
             let(:link_target) { tmpfile('file_target') }
 
             before :each do
               FileUtils.touch(link_target)
 
               Puppet::FileSystem.symlink(link_target, link)
             end
 
             it "should create the file, not a symlink (#2817, #10315)" do
               catalog.add_resource described_class.new(:path => path, :source => link, :mode => '0600', :links => :follow)
               catalog.apply
 
               expect(File).to be_file(path)
               expect(get_mode(path) & 07777).to eq(0600)
             end
 
             it "should overwrite the file" do
               FileUtils.touch(path)
 
               catalog.add_resource described_class.new(:path => path, :source => link, :mode => '0600', :links => :follow)
               catalog.apply
 
               expect(File).to be_file(path)
               expect(get_mode(path) & 07777).to eq(0600)
             end
           end
 
           describe "to a link to a directory" do
             let(:real_target) { tmpdir('real_target') }
             let(:target) { tmpfile('target') }
 
             before :each do
               File.chmod(0666, real_target)
 
               # link -> target -> real_target
               Puppet::FileSystem.symlink(real_target, target)
               Puppet::FileSystem.symlink(target, link)
             end
 
             after :each do
               File.chmod(0750, real_target)
             end
 
             describe "when following all links" do
               it "should create the destination and apply executable bits (#10315)" do
                 catalog.add_resource described_class.new(:path => path, :source => link, :mode => '0600', :links => :follow)
                 catalog.apply
 
                 expect(File).to be_directory(path)
                 expect(get_mode(path) & 07777).to eq(0700)
               end
 
               it "should overwrite the destination and apply executable bits" do
                 FileUtils.mkdir(path)
 
                 catalog.add_resource described_class.new(:path => path, :source => link, :mode => '0600', :links => :follow)
                 catalog.apply
 
                 expect(File).to be_directory(path)
                 expect(get_mode(path) & 0111).to eq(0100)
               end
             end
           end
         end
       end
     end
   end
 
   describe "when writing files" do
     shared_examples "files are backed up" do |resource_options|
       it "should backup files to a filebucket when one is configured" do
         filebucket = Puppet::Type.type(:filebucket).new :path => tmpfile("filebucket"), :name => "mybucket"
         file = described_class.new({:path => path, :backup => "mybucket", :content => "foo"}.merge(resource_options))
         catalog.add_resource file
         catalog.add_resource filebucket
 
         File.open(file[:path], "w") { |f| f.write("bar") }
 
         d = filebucket_digest.call(IO.binread(file[:path]))
 
         catalog.apply
 
         expect(filebucket.bucket.getfile(d)).to eq("bar")
       end
 
       it "should backup files in the local directory when a backup string is provided" do
         file = described_class.new({:path => path, :backup => ".bak", :content => "foo"}.merge(resource_options))
         catalog.add_resource file
 
         File.open(file[:path], "w") { |f| f.puts "bar" }
 
         catalog.apply
 
         backup = file[:path] + ".bak"
         expect(Puppet::FileSystem.exist?(backup)).to be_truthy
         expect(File.read(backup)).to eq("bar\n")
       end
 
       it "should fail if no backup can be performed" do
         dir = tmpdir("backups")
 
         file = described_class.new({:path => File.join(dir, "testfile"), :backup => ".bak", :content => "foo"}.merge(resource_options))
         catalog.add_resource file
 
         File.open(file[:path], 'w') { |f| f.puts "bar" }
 
         # Create a directory where the backup should be so that writing to it fails
         Dir.mkdir(File.join(dir, "testfile.bak"))
 
         Puppet::Util::Log.stubs(:newmessage)
 
         catalog.apply
 
         expect(File.read(file[:path])).to eq("bar\n")
       end
 
       it "should not backup symlinks", :if => described_class.defaultprovider.feature?(:manages_symlinks) do
         link = tmpfile("link")
         dest1 = tmpfile("dest1")
         dest2 = tmpfile("dest2")
         bucket = Puppet::Type.type(:filebucket).new :path => tmpfile("filebucket"), :name => "mybucket"
         file = described_class.new({:path => link, :target => dest2, :ensure => :link, :backup => "mybucket"}.merge(resource_options))
         catalog.add_resource file
         catalog.add_resource bucket
 
         File.open(dest1, "w") { |f| f.puts "whatever" }
         Puppet::FileSystem.symlink(dest1, link)
 
         d = filebucket_digest.call(File.read(file[:path]))
 
         catalog.apply
 
         expect(Puppet::FileSystem.readlink(link)).to eq(dest2)
         expect(Puppet::FileSystem.exist?(bucket[:path])).to be_falsey
       end
 
       it "should backup directories to the local filesystem by copying the whole directory" do
         file = described_class.new({:path => path, :backup => ".bak", :content => "foo", :force => true}.merge(resource_options))
         catalog.add_resource file
 
         Dir.mkdir(path)
 
         otherfile = File.join(path, "foo")
         File.open(otherfile, "w") { |f| f.print "yay" }
 
         catalog.apply
 
         backup = "#{path}.bak"
         expect(FileTest).to be_directory(backup)
 
         expect(File.read(File.join(backup, "foo"))).to eq("yay")
       end
 
       it "should backup directories to filebuckets by backing up each file separately" do
         bucket = Puppet::Type.type(:filebucket).new :path => tmpfile("filebucket"), :name => "mybucket"
         file = described_class.new({:path => tmpfile("bucket_backs"), :backup => "mybucket", :content => "foo", :force => true}.merge(resource_options))
         catalog.add_resource file
         catalog.add_resource bucket
 
         Dir.mkdir(file[:path])
         foofile = File.join(file[:path], "foo")
         barfile = File.join(file[:path], "bar")
         File.open(foofile, "w") { |f| f.print "fooyay" }
         File.open(barfile, "w") { |f| f.print "baryay" }
 
 
         food = filebucket_digest.call(File.read(foofile))
         bard = filebucket_digest.call(File.read(barfile))
 
         catalog.apply
 
         expect(bucket.bucket.getfile(food)).to eq("fooyay")
         expect(bucket.bucket.getfile(bard)).to eq("baryay")
       end
     end
 
     with_digest_algorithms do
       it_should_behave_like "files are backed up", {} do
         let(:filebucket_digest) { method(:digest) }
       end
     end
 
     CHECKSUM_TYPES_TO_TRY.each do |checksum_type, checksum|
       describe "when checksum_type is #{checksum_type}" do
         # FileBucket uses the globally configured default for lookup by digest, which right now is MD5.
         it_should_behave_like "files are backed up", {:checksum => checksum_type} do
           let(:filebucket_digest) { Proc.new {|x| Puppet::Util::Checksums.md5(x)} }
         end
       end
     end
   end
 
   describe "when recursing" do
     def build_path(dir)
       Dir.mkdir(dir)
       File.chmod(0750, dir)
 
       @dirs = [dir]
       @files = []
 
       %w{one two}.each do |subdir|
         fdir = File.join(dir, subdir)
         Dir.mkdir(fdir)
         File.chmod(0750, fdir)
         @dirs << fdir
 
         %w{three}.each do |file|
           ffile = File.join(fdir, file)
           @files << ffile
           File.open(ffile, "w") { |f| f.puts "test #{file}" }
           File.chmod(0640, ffile)
         end
       end
     end
 
     it "should be able to recurse over a nonexistent file" do
       @file = described_class.new(
         :name    => path,
         :mode    => '0644',
         :recurse => true,
         :backup  => false
       )
 
       catalog.add_resource @file
 
       expect { @file.eval_generate }.not_to raise_error
     end
 
     it "should be able to recursively set properties on existing files" do
       path = tmpfile("file_integration_tests")
 
       build_path(path)
 
       file = described_class.new(
         :name    => path,
         :mode    => '0644',
         :recurse => true,
         :backup  => false
       )
 
       catalog.add_resource file
 
       catalog.apply
 
       expect(@dirs).not_to be_empty
       @dirs.each do |path|
         expect(get_mode(path) & 007777).to eq(0755)
       end
 
       expect(@files).not_to be_empty
       @files.each do |path|
         expect(get_mode(path) & 007777).to eq(0644)
       end
     end
 
     it "should be able to recursively make links to other files", :if => described_class.defaultprovider.feature?(:manages_symlinks) do
       source = tmpfile("file_link_integration_source")
 
       build_path(source)
 
       dest = tmpfile("file_link_integration_dest")
 
       @file = described_class.new(:name => dest, :target => source, :recurse => true, :ensure => :link, :backup => false)
 
       catalog.add_resource @file
 
       catalog.apply
 
       @dirs.each do |path|
         link_path = path.sub(source, dest)
 
         expect(Puppet::FileSystem.lstat(link_path)).to be_directory
       end
 
       @files.each do |path|
         link_path = path.sub(source, dest)
 
         expect(Puppet::FileSystem.lstat(link_path).ftype).to eq("link")
       end
     end
 
     it "should be able to recursively copy files" do
       source = tmpfile("file_source_integration_source")
 
       build_path(source)
 
       dest = tmpfile("file_source_integration_dest")
 
       @file = described_class.new(:name => dest, :source => source, :recurse => true, :backup => false)
 
       catalog.add_resource @file
 
       catalog.apply
 
       @dirs.each do |path|
         newpath = path.sub(source, dest)
 
         expect(Puppet::FileSystem.lstat(newpath)).to be_directory
       end
 
       @files.each do |path|
         newpath = path.sub(source, dest)
 
         expect(Puppet::FileSystem.lstat(newpath).ftype).to eq("file")
       end
     end
 
     it "should not recursively manage files managed by a more specific explicit file" do
       dir = tmpfile("recursion_vs_explicit_1")
 
       subdir = File.join(dir, "subdir")
       file = File.join(subdir, "file")
 
       FileUtils.mkdir_p(subdir)
       File.open(file, "w") { |f| f.puts "" }
 
       base = described_class.new(:name => dir, :recurse => true, :backup => false, :mode => "755")
       sub = described_class.new(:name => subdir, :recurse => true, :backup => false, :mode => "644")
 
       catalog.add_resource base
       catalog.add_resource sub
 
       catalog.apply
 
       expect(get_mode(file) & 007777).to eq(0644)
     end
 
     it "should recursively manage files even if there is an explicit file whose name is a prefix of the managed file" do
       managed      = File.join(path, "file")
       generated    = File.join(path, "file_with_a_name_starting_with_the_word_file")
 
       FileUtils.mkdir_p(path)
       FileUtils.touch(managed)
       FileUtils.touch(generated)
 
       catalog.add_resource described_class.new(:name => path,    :recurse => true, :backup => false, :mode => '0700')
       catalog.add_resource described_class.new(:name => managed, :recurse => true, :backup => false, :mode => "644")
 
       catalog.apply
 
       expect(get_mode(generated) & 007777).to eq(0700)
     end
 
     describe "when recursing remote directories" do
+      describe "for the 2nd time" do
+        with_checksum_types "one", "x" do
+          it "should not update the target directory" do
+            options = {
+              :path => path,
+              :ensure => :directory,
+              :backup => false,
+              :recurse => true,
+              :checksum => checksum_type,
+              :source => env_path
+            }
+            target_file = File.join(path, 'x')
+
+            first_catalog = Puppet::Resource::Catalog.new
+            first_catalog.add_resource Puppet::Type.send(:newfile, options)
+            first_catalog.apply
+            expect(File).to be_directory(path)
+            expect(Puppet::FileSystem.exist?(target_file)).to be_truthy
+
+            # The 2nd time the resource should not change.
+            second_catalog = Puppet::Resource::Catalog.new
+            second_catalog.add_resource Puppet::Type.send(:newfile, options)
+            result = second_catalog.apply
+            status = result.report.resource_statuses["File[#{target_file}]"]
+            expect(status).not_to be_failed
+            expect(status).not_to be_changed
+          end
+        end
+      end
+
       describe "when sourceselect first" do
         describe "for a directory" do
           it "should recursively copy the first directory that exists" do
             one = File.expand_path('thisdoesnotexist')
             two = tmpdir('two')
 
             FileUtils.mkdir_p(File.join(two, 'three'))
             FileUtils.touch(File.join(two, 'three', 'four'))
 
             catalog.add_resource Puppet::Type.newfile(
                                :path    => path,
                                :ensure  => :directory,
                                :backup  => false,
                                :recurse => true,
                                :sourceselect => :first,
                                :source => [one, two]
                                )
 
             catalog.apply
 
             expect(File).to be_directory(path)
             expect(Puppet::FileSystem.exist?(File.join(path, 'one'))).to be_falsey
             expect(Puppet::FileSystem.exist?(File.join(path, 'three', 'four'))).to be_truthy
           end
 
           it "should recursively copy an empty directory" do
             one = File.expand_path('thisdoesnotexist')
             two = tmpdir('two')
             three = tmpdir('three')
             file_in_dir_with_contents(three, 'a', '')
 
             catalog.add_resource Puppet::Type.newfile(
                                :path    => path,
                                :ensure  => :directory,
                                :backup  => false,
                                :recurse => true,
                                :sourceselect => :first,
                                :source => [one, two, three]
                                )
 
             catalog.apply
 
             expect(File).to be_directory(path)
             expect(Puppet::FileSystem.exist?(File.join(path, 'a'))).to be_falsey
           end
 
           it "should only recurse one level" do
             one = tmpdir('one')
             FileUtils.mkdir_p(File.join(one, 'a', 'b'))
             FileUtils.touch(File.join(one, 'a', 'b', 'c'))
 
             two = tmpdir('two')
             FileUtils.mkdir_p(File.join(two, 'z'))
             FileUtils.touch(File.join(two, 'z', 'y'))
 
             catalog.add_resource Puppet::Type.newfile(
                                :path    => path,
                                :ensure  => :directory,
                                :backup  => false,
                                :recurse => true,
                                :recurselimit => 1,
                                :sourceselect => :first,
                                :source => [one, two]
                                )
 
             catalog.apply
 
             expect(Puppet::FileSystem.exist?(File.join(path, 'a'))).to be_truthy
             expect(Puppet::FileSystem.exist?(File.join(path, 'a', 'b'))).to be_falsey
             expect(Puppet::FileSystem.exist?(File.join(path, 'z'))).to be_falsey
           end
         end
 
         describe "for a file" do
           it "should copy the first file that exists" do
             one = File.expand_path('thisdoesnotexist')
             two = tmpfile_with_contents('two', 'yay')
             three = tmpfile_with_contents('three', 'no')
 
             catalog.add_resource Puppet::Type.newfile(
                                :path    => path,
                                :ensure  => :file,
                                :backup  => false,
                                :sourceselect => :first,
                                :source => [one, two, three]
                                )
 
             catalog.apply
 
             expect(File.read(path)).to eq('yay')
           end
 
           it "should copy an empty file" do
             one = File.expand_path('thisdoesnotexist')
             two = tmpfile_with_contents('two', '')
             three = tmpfile_with_contents('three', 'no')
 
             catalog.add_resource Puppet::Type.newfile(
                                :path    => path,
                                :ensure  => :file,
                                :backup  => false,
                                :sourceselect => :first,
                                :source => [one, two, three]
                                )
 
             catalog.apply
 
             expect(File.read(path)).to eq('')
           end
         end
       end
 
       describe "when sourceselect all" do
         describe "for a directory" do
           it "should recursively copy all sources from the first valid source" do
             dest = tmpdir('dest')
             one = tmpdir('one')
             two = tmpdir('two')
             three = tmpdir('three')
             four = tmpdir('four')
 
             file_in_dir_with_contents(one, 'a', one)
             file_in_dir_with_contents(two, 'a', two)
             file_in_dir_with_contents(two, 'b', two)
             file_in_dir_with_contents(three, 'a', three)
             file_in_dir_with_contents(three, 'c', three)
 
             obj = Puppet::Type.newfile(
                                :path    => dest,
                                :ensure  => :directory,
                                :backup  => false,
                                :recurse => true,
                                :sourceselect => :all,
                                :source => [one, two, three, four]
                                )
 
             catalog.add_resource obj
             catalog.apply
 
             expect(File.read(File.join(dest, 'a'))).to eq(one)
             expect(File.read(File.join(dest, 'b'))).to eq(two)
             expect(File.read(File.join(dest, 'c'))).to eq(three)
           end
 
           it "should only recurse one level from each valid source" do
             one = tmpdir('one')
             FileUtils.mkdir_p(File.join(one, 'a', 'b'))
             FileUtils.touch(File.join(one, 'a', 'b', 'c'))
 
             two = tmpdir('two')
             FileUtils.mkdir_p(File.join(two, 'z'))
             FileUtils.touch(File.join(two, 'z', 'y'))
 
             obj = Puppet::Type.newfile(
                                :path    => path,
                                :ensure  => :directory,
                                :backup  => false,
                                :recurse => true,
                                :recurselimit => 1,
                                :sourceselect => :all,
                                :source => [one, two]
                                )
 
             catalog.add_resource obj
             catalog.apply
 
             expect(Puppet::FileSystem.exist?(File.join(path, 'a'))).to be_truthy
             expect(Puppet::FileSystem.exist?(File.join(path, 'a', 'b'))).to be_falsey
             expect(Puppet::FileSystem.exist?(File.join(path, 'z'))).to be_truthy
             expect(Puppet::FileSystem.exist?(File.join(path, 'z', 'y'))).to be_falsey
           end
         end
       end
     end
   end
 
   describe "when generating resources" do
     before do
       source = tmpdir("generating_in_catalog_source")
 
       s1 = file_in_dir_with_contents(source, "one", "uno")
       s2 = file_in_dir_with_contents(source, "two", "dos")
 
       @file = described_class.new(
         :name => path,
         :source => source,
         :recurse => true,
         :backup => false
       )
 
       catalog.add_resource @file
     end
 
     it "should add each generated resource to the catalog" do
       catalog.apply do |trans|
         expect(catalog.resource(:file, File.join(path, "one"))).to be_a(described_class)
         expect(catalog.resource(:file, File.join(path, "two"))).to be_a(described_class)
       end
     end
 
     it "should have an edge to each resource in the relationship graph" do
       catalog.apply do |trans|
         one = catalog.resource(:file, File.join(path, "one"))
         expect(catalog.relationship_graph).to be_edge(@file, one)
 
         two = catalog.resource(:file, File.join(path, "two"))
         expect(catalog.relationship_graph).to be_edge(@file, two)
       end
     end
   end
 
   describe "when copying files" do
     it "should be able to copy files with pound signs in their names (#285)" do
       source = tmpfile_with_contents("filewith#signs", "foo")
       dest = tmpfile("destwith#signs")
       catalog.add_resource described_class.new(:name => dest, :source => source)
 
       catalog.apply
 
       expect(File.read(dest)).to eq("foo")
     end
 
     it "should be able to copy files with spaces in their names" do
       dest = tmpfile("destwith spaces")
       source = tmpfile_with_contents("filewith spaces", "foo")
       catalog.add_resource described_class.new(:path => dest, :source => source)
 
       catalog.apply
 
       expect(File.read(dest)).to eq("foo")
     end
 
     it "should be able to copy individual files even if recurse has been specified" do
       source = tmpfile_with_contents("source", "foo")
       dest = tmpfile("dest")
       catalog.add_resource described_class.new(:name => dest, :source => source, :recurse => true)
 
       catalog.apply
 
       expect(File.read(dest)).to eq("foo")
     end
   end
 
   it "should create a file with content if ensure is omitted" do
     catalog.add_resource described_class.new(
       :path => path,
       :content => "this is some content, yo"
     )
 
     catalog.apply
 
     expect(File.read(path)).to eq("this is some content, yo")
   end
 
   it "should create files with content if both content and ensure are set" do
     file = described_class.new(
       :path    => path,
       :ensure  => "file",
       :content => "this is some content, yo"
     )
 
     catalog.add_resource file
     catalog.apply
 
     expect(File.read(path)).to eq("this is some content, yo")
   end
 
   it "should delete files with sources but that are set for deletion" do
     source = tmpfile_with_contents("source_source_with_ensure", "yay")
     dest = tmpfile_with_contents("source_source_with_ensure", "boo")
 
     file = described_class.new(
       :path   => dest,
       :ensure => :absent,
       :source => source,
       :backup => false
     )
 
     catalog.add_resource file
     catalog.apply
 
     expect(Puppet::FileSystem.exist?(dest)).to be_falsey
   end
 
   describe "when sourcing" do
     with_checksum_types "source", "default_values" do
       describe "on POSIX systems", :if => Puppet.features.posix? do
         it "should apply the source metadata values" do
           set_mode(0770, checksum_file)
 
           file = described_class.new(
             :path   => path,
             :ensure => :file,
             :source => checksum_file,
             :source_permissions => :use,
             :checksum => checksum_type,
             :backup => false
           )
 
           catalog.add_resource file
           catalog.apply
 
           expect(get_owner(path)).to eq(get_owner(checksum_file))
           expect(get_group(path)).to eq(get_group(checksum_file))
           expect(get_mode(path) & 07777).to eq(0770)
         end
       end
 
       it "should override the default metadata values" do
         set_mode(0770, checksum_file)
 
         file = described_class.new(
           :path   => path,
           :ensure => :file,
           :source => checksum_file,
           :checksum => checksum_type,
           :backup => false,
           :mode => '0440'
         )
 
         catalog.add_resource file
         catalog.apply
 
         expect(get_mode(path) & 07777).to eq(0440)
       end
     end
 
     let(:source) { tmpfile_with_contents("source_default_values", "yay") }
     describe "on Windows systems", :if => Puppet.features.microsoft_windows? do
       def expects_sid_granted_full_access_explicitly(path, sid)
         inherited_ace = Puppet::Util::Windows::AccessControlEntry::INHERITED_ACE
 
         aces = get_aces_for_path_by_sid(path, sid)
         expect(aces).not_to be_empty
 
         aces.each do |ace|
           expect(ace.mask).to eq(Puppet::Util::Windows::File::FILE_ALL_ACCESS)
           expect(ace.flags & inherited_ace).not_to eq(inherited_ace)
         end
       end
 
       def expects_system_granted_full_access_explicitly(path)
         expects_sid_granted_full_access_explicitly(path, @sids[:system])
       end
 
       def expects_at_least_one_inherited_ace_grants_full_access(path, sid)
         inherited_ace = Puppet::Util::Windows::AccessControlEntry::INHERITED_ACE
 
         aces = get_aces_for_path_by_sid(path, sid)
         expect(aces).not_to be_empty
 
         expect(aces.any? do |ace|
           ace.mask == Puppet::Util::Windows::File::FILE_ALL_ACCESS &&
             (ace.flags & inherited_ace) == inherited_ace
         end).to be_truthy
       end
 
       def expects_at_least_one_inherited_system_ace_grants_full_access(path)
         expects_at_least_one_inherited_ace_grants_full_access(path, @sids[:system])
       end
 
       describe "when processing SYSTEM ACEs" do
         before do
           @sids = {
             :current_user => Puppet::Util::Windows::SID.name_to_sid(Puppet::Util::Windows::ADSI::User.current_user_name),
             :system => Win32::Security::SID::LocalSystem,
             :admin => Puppet::Util::Windows::SID.name_to_sid("Administrator"),
             :guest => Puppet::Util::Windows::SID.name_to_sid("Guest"),
             :users => Win32::Security::SID::BuiltinUsers,
             :power_users => Win32::Security::SID::PowerUsers,
             :none => Win32::Security::SID::Nobody
           }
         end
 
         describe "on files" do
           before :each do
             @file = described_class.new(
               :path   => path,
               :ensure => :file,
               :source => source,
               :backup => false
             )
             catalog.add_resource @file
           end
 
           describe "when permissions are not insync?" do
             before :each do
               @file[:owner] = 'None'
               @file[:group] = 'None'
             end
 
             it "preserves the inherited SYSTEM ACE for an existing file" do
               FileUtils.touch(path)
 
               expects_at_least_one_inherited_system_ace_grants_full_access(path)
 
               catalog.apply
 
               expects_at_least_one_inherited_system_ace_grants_full_access(path)
             end
 
             it "applies the inherited SYSTEM ACEs for a new file" do
               catalog.apply
 
               expects_at_least_one_inherited_system_ace_grants_full_access(path)
             end
           end
 
           describe "created with SYSTEM as the group" do
             before :each do
               @file[:owner] = @sids[:users]
               @file[:group] = @sids[:system]
               @file[:mode] = '0644'
 
               catalog.apply
             end
 
             it "should allow the user to explicitly set the mode to 4" do
               system_aces = get_aces_for_path_by_sid(path, @sids[:system])
               expect(system_aces).not_to be_empty
 
               system_aces.each do |ace|
                 expect(ace.mask).to eq(Puppet::Util::Windows::File::FILE_GENERIC_READ)
               end
             end
 
             it "prepends SYSTEM ace when changing group from system to power users" do
               @file[:group] = @sids[:power_users]
               catalog.apply
 
               system_aces = get_aces_for_path_by_sid(path, @sids[:system])
               expect(system_aces.size).to eq(1)
             end
           end
 
           describe "with :links set to :follow" do
             it "should not fail to apply" do
               # at minimal, we need an owner and/or group
               @file[:owner] = @sids[:users]
               @file[:links] = :follow
 
               catalog.apply do |transaction|
                 if transaction.any_failed?
                   pretty_transaction_error(transaction)
                 end
               end
             end
           end
         end
 
         describe "on directories" do
           before :each do
             @directory = described_class.new(
               :path   => dir,
               :ensure => :directory
             )
             catalog.add_resource @directory
           end
 
           def grant_everyone_full_access(path)
             sd = Puppet::Util::Windows::Security.get_security_descriptor(path)
             sd.dacl.allow(
               'S-1-1-0', #everyone
               Puppet::Util::Windows::File::FILE_ALL_ACCESS,
               Puppet::Util::Windows::AccessControlEntry::OBJECT_INHERIT_ACE |
               Puppet::Util::Windows::AccessControlEntry::CONTAINER_INHERIT_ACE)
             Puppet::Util::Windows::Security.set_security_descriptor(path, sd)
           end
 
           after :each do
             grant_everyone_full_access(dir)
           end
 
           describe "when permissions are not insync?" do
             before :each do
               @directory[:owner] = 'None'
               @directory[:group] = 'None'
             end
 
             it "preserves the inherited SYSTEM ACEs for an existing directory" do
               FileUtils.mkdir(dir)
 
               expects_at_least_one_inherited_system_ace_grants_full_access(dir)
 
               catalog.apply
 
               expects_at_least_one_inherited_system_ace_grants_full_access(dir)
             end
 
             it "applies the inherited SYSTEM ACEs for a new directory" do
               catalog.apply
 
               expects_at_least_one_inherited_system_ace_grants_full_access(dir)
             end
 
             describe "created with SYSTEM as the group" do
               before :each do
                 @directory[:owner] = @sids[:users]
                 @directory[:group] = @sids[:system]
                 @directory[:mode] = '0644'
 
                 catalog.apply
               end
 
               it "should allow the user to explicitly set the mode to 4" do
                 system_aces = get_aces_for_path_by_sid(dir, @sids[:system])
                 expect(system_aces).not_to be_empty
 
                 system_aces.each do |ace|
                   # unlike files, Puppet sets execute bit on directories that are readable
                   expect(ace.mask).to eq(Puppet::Util::Windows::File::FILE_GENERIC_READ | Puppet::Util::Windows::File::FILE_GENERIC_EXECUTE)
                 end
               end
 
               it "prepends SYSTEM ace when changing group from system to power users" do
                 @directory[:group] = @sids[:power_users]
                 catalog.apply
 
                 system_aces = get_aces_for_path_by_sid(dir, @sids[:system])
                 expect(system_aces.size).to eq(1)
               end
             end
 
             describe "with :links set to :follow" do
               it "should not fail to apply" do
                 # at minimal, we need an owner and/or group
                 @directory[:owner] = @sids[:users]
                 @directory[:links] = :follow
 
                 catalog.apply do |transaction|
                   if transaction.any_failed?
                     pretty_transaction_error(transaction)
                   end
                 end
               end
             end
           end
         end
       end
     end
   end
 
   describe "when purging files" do
     before do
       sourcedir = tmpdir("purge_source")
       destdir = tmpdir("purge_dest")
       sourcefile = File.join(sourcedir, "sourcefile")
 
       @copiedfile = File.join(destdir, "sourcefile")
       @localfile  = File.join(destdir, "localfile")
       @purgee     = File.join(destdir, "to_be_purged")
 
       File.open(@localfile, "w") { |f| f.print "oldtest" }
       File.open(sourcefile, "w") { |f| f.print "funtest" }
       # this file should get removed
       File.open(@purgee, "w") { |f| f.print "footest" }
 
       lfobj = Puppet::Type.newfile(
         :title   => "localfile",
         :path    => @localfile,
         :content => "rahtest",
         :ensure  => :file,
         :backup  => false
       )
 
       destobj = Puppet::Type.newfile(
         :title   => "destdir",
         :path    => destdir,
         :source  => sourcedir,
         :backup  => false,
         :purge   => true,
         :recurse => true
       )
 
       catalog.add_resource lfobj, destobj
       catalog.apply
     end
 
     it "should still copy remote files" do
       expect(File.read(@copiedfile)).to eq('funtest')
     end
 
     it "should not purge managed, local files" do
       expect(File.read(@localfile)).to eq('rahtest')
     end
 
     it "should purge files that are neither remote nor otherwise managed" do
       expect(Puppet::FileSystem.exist?(@purgee)).to be_falsey
     end
   end
 
   describe "when using validate_cmd" do
     it "should fail the file resource if command fails" do
       catalog.add_resource(described_class.new(:path => path, :content => "foo", :validate_cmd => "/usr/bin/env false"))
       Puppet::Util::Execution.expects(:execute).with("/usr/bin/env false", {:combine => true, :failonfail => true}).raises(Puppet::ExecutionFailure, "Failed")
       report = catalog.apply.report
       expect(report.resource_statuses["File[#{path}]"]).to be_failed
       expect(Puppet::FileSystem.exist?(path)).to be_falsey
     end
 
     it "should succeed the file resource if command succeeds" do
       catalog.add_resource(described_class.new(:path => path, :content => "foo", :validate_cmd => "/usr/bin/env true"))
       Puppet::Util::Execution.expects(:execute).with("/usr/bin/env true", {:combine => true, :failonfail => true}).returns ''
       report = catalog.apply.report
       expect(report.resource_statuses["File[#{path}]"]).not_to be_failed
       expect(Puppet::FileSystem.exist?(path)).to be_truthy
     end
   end
 
   def tmpfile_with_contents(name, contents)
     file = tmpfile(name)
     File.open(file, "w") { |f| f.write contents }
     file
   end
 
   def file_in_dir_with_contents(dir, name, contents)
     full_name = File.join(dir, name)
     File.open(full_name, "w") { |f| f.write contents }
     full_name
   end
 
   def pretty_transaction_error(transaction)
     report = transaction.report
     status_failures = report.resource_statuses.values.select { |r| r.failed? }
     status_fail_msg = status_failures.
       collect(&:events).
       flatten.
       select { |event| event.status == 'failure' }.
       collect { |event| "#{event.resource}: #{event.message}" }.join("; ")
 
     raise "Got #{status_failures.length} failure(s) while applying: #{status_fail_msg}"
   end
 end
diff --git a/spec/unit/type/file_spec.rb b/spec/unit/type/file_spec.rb
index f57a0fba6..2b22aae31 100755
--- a/spec/unit/type/file_spec.rb
+++ b/spec/unit/type/file_spec.rb
@@ -1,1509 +1,1505 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
 
 describe Puppet::Type.type(:file) do
   include PuppetSpec::Files
 
   let(:path) { tmpfile('file_testing') }
   let(:file) { described_class.new(:path => path, :catalog => catalog) }
   let(:provider) { file.provider }
   let(:catalog) { Puppet::Resource::Catalog.new }
 
   before do
     Puppet.features.stubs("posix?").returns(true)
   end
 
   describe "the path parameter" do
     describe "on POSIX systems", :if => Puppet.features.posix? do
       it "should remove trailing slashes" do
         file[:path] = "/foo/bar/baz/"
         expect(file[:path]).to eq("/foo/bar/baz")
       end
 
       it "should remove double slashes" do
         file[:path] = "/foo/bar//baz"
         expect(file[:path]).to eq("/foo/bar/baz")
       end
 
       it "should remove triple slashes" do
         file[:path] = "/foo/bar///baz"
         expect(file[:path]).to eq("/foo/bar/baz")
       end
 
       it "should remove trailing double slashes" do
         file[:path] = "/foo/bar/baz//"
         expect(file[:path]).to eq("/foo/bar/baz")
       end
 
       it "should leave a single slash alone" do
         file[:path] = "/"
         expect(file[:path]).to eq("/")
       end
 
       it "should accept and collapse a double-slash at the start of the path" do
         file[:path] = "//tmp/xxx"
         expect(file[:path]).to eq('/tmp/xxx')
       end
 
       it "should accept and collapse a triple-slash at the start of the path" do
         file[:path] = "///tmp/xxx"
         expect(file[:path]).to eq('/tmp/xxx')
       end
     end
 
     describe "on Windows systems", :if => Puppet.features.microsoft_windows? do
       it "should remove trailing slashes" do
         file[:path] = "X:/foo/bar/baz/"
         expect(file[:path]).to eq("X:/foo/bar/baz")
       end
 
       it "should remove double slashes" do
         file[:path] = "X:/foo/bar//baz"
         expect(file[:path]).to eq("X:/foo/bar/baz")
       end
 
       it "should remove trailing double slashes" do
         file[:path] = "X:/foo/bar/baz//"
         expect(file[:path]).to eq("X:/foo/bar/baz")
       end
 
       it "should leave a drive letter with a slash alone" do
         file[:path] = "X:/"
         expect(file[:path]).to eq("X:/")
       end
 
       it "should not accept a drive letter without a slash" do
         expect { file[:path] = "X:" }.to raise_error(/File paths must be fully qualified/)
       end
 
       describe "when using UNC filenames", :if => Puppet.features.microsoft_windows? do
         it "should remove trailing slashes" do
           file[:path] = "//localhost/foo/bar/baz/"
           expect(file[:path]).to eq("//localhost/foo/bar/baz")
         end
 
         it "should remove double slashes" do
           file[:path] = "//localhost/foo/bar//baz"
           expect(file[:path]).to eq("//localhost/foo/bar/baz")
         end
 
         it "should remove trailing double slashes" do
           file[:path] = "//localhost/foo/bar/baz//"
           expect(file[:path]).to eq("//localhost/foo/bar/baz")
         end
 
         it "should remove a trailing slash from a sharename" do
           file[:path] = "//localhost/foo/"
           expect(file[:path]).to eq("//localhost/foo")
         end
 
         it "should not modify a sharename" do
           file[:path] = "//localhost/foo"
           expect(file[:path]).to eq("//localhost/foo")
         end
       end
     end
   end
 
   describe "the backup parameter" do
     [false, 'false', :false].each do |value|
       it "should disable backup if the value is #{value.inspect}" do
         file[:backup] = value
         expect(file[:backup]).to eq(false)
       end
     end
 
     [true, 'true', '.puppet-bak'].each do |value|
       it "should use .puppet-bak if the value is #{value.inspect}" do
         file[:backup] = value
         expect(file[:backup]).to eq('.puppet-bak')
       end
     end
 
     it "should use the provided value if it's any other string" do
       file[:backup] = "over there"
       expect(file[:backup]).to eq("over there")
     end
 
     it "should fail if backup is set to anything else" do
       expect do
         file[:backup] = 97
       end.to raise_error(Puppet::Error, /Invalid backup type 97/)
     end
   end
 
   describe "the recurse parameter" do
     it "should default to recursion being disabled" do
       expect(file[:recurse]).to be_falsey
     end
 
     [true, "true", "remote"].each do |value|
       it "should consider #{value} to enable recursion" do
         file[:recurse] = value
         expect(file[:recurse]).to be_truthy
       end
     end
 
     it "should not allow numbers" do
       expect { file[:recurse] = 10 }.to raise_error(
         Puppet::Error, /Parameter recurse failed on File\[[^\]]+\]: Invalid recurse value 10/)
     end
 
     [false, "false"].each do |value|
       it "should consider #{value} to disable recursion" do
         file[:recurse] = value
         expect(file[:recurse]).to be_falsey
       end
     end
   end
 
   describe "the recurselimit parameter" do
     it "should accept integers" do
       file[:recurselimit] = 12
       expect(file[:recurselimit]).to eq(12)
     end
 
     it "should munge string numbers to number numbers" do
       file[:recurselimit] = '12'
       expect(file[:recurselimit]).to eq(12)
     end
 
     it "should fail if given a non-number" do
       expect do
         file[:recurselimit] = 'twelve'
       end.to raise_error(Puppet::Error, /Invalid value "twelve"/)
     end
   end
 
   describe "the replace parameter" do
     [true, :true, :yes].each do |value|
       it "should consider #{value} to be true" do
         file[:replace] = value
         expect(file[:replace]).to be_truthy
       end
     end
 
     [false, :false, :no].each do |value|
       it "should consider #{value} to be false" do
         file[:replace] = value
         expect(file[:replace]).to be_falsey
       end
     end
   end
 
   describe ".instances" do
     it "should return an empty array" do
       expect(described_class.instances).to eq([])
     end
   end
 
   describe "#bucket" do
     it "should return nil if backup is off" do
       file[:backup] = false
       expect(file.bucket).to eq(nil)
     end
 
     it "should not return a bucket if using a file extension for backup" do
       file[:backup] = '.backup'
 
       expect(file.bucket).to eq(nil)
     end
 
     it "should return the default filebucket if using the 'puppet' filebucket" do
       file[:backup] = 'puppet'
       bucket = stub('bucket')
       file.stubs(:default_bucket).returns bucket
 
       expect(file.bucket).to eq(bucket)
     end
 
     it "should fail if using a remote filebucket and no catalog exists" do
       file.catalog = nil
       file[:backup] = 'my_bucket'
 
       expect { file.bucket }.to raise_error(Puppet::Error, "Can not find filebucket for backups without a catalog")
     end
 
     it "should fail if the specified filebucket isn't in the catalog" do
       file[:backup] = 'my_bucket'
 
       expect { file.bucket }.to raise_error(Puppet::Error, "Could not find filebucket my_bucket specified in backup")
     end
 
     it "should use the specified filebucket if it is in the catalog" do
       file[:backup] = 'my_bucket'
       filebucket = Puppet::Type.type(:filebucket).new(:name => 'my_bucket')
       catalog.add_resource(filebucket)
 
       expect(file.bucket).to eq(filebucket.bucket)
     end
   end
 
   describe "#asuser" do
     before :each do
       # Mocha won't let me just stub SUIDManager.asuser to yield and return,
       # but it will do exactly that if we're not root.
       Puppet::Util::SUIDManager.stubs(:root?).returns false
     end
 
     it "should return the desired owner if they can write to the parent directory" do
       file[:owner] = 1001
       FileTest.stubs(:writable?).with(File.dirname file[:path]).returns true
 
       expect(file.asuser).to eq(1001)
     end
 
     it "should return nil if the desired owner can't write to the parent directory" do
       file[:owner] = 1001
       FileTest.stubs(:writable?).with(File.dirname file[:path]).returns false
 
       expect(file.asuser).to eq(nil)
     end
 
     it "should return nil if not managing owner" do
       expect(file.asuser).to eq(nil)
     end
   end
 
   describe "#exist?" do
     it "should be considered existent if it can be stat'ed" do
       file.expects(:stat).returns mock('stat')
       expect(file).to be_exist
     end
 
     it "should be considered nonexistent if it can not be stat'ed" do
       file.expects(:stat).returns nil
       expect(file).to_not be_exist
     end
   end
 
   describe "#eval_generate" do
     before do
       @graph = stub 'graph', :add_edge => nil
       catalog.stubs(:relationship_graph).returns @graph
     end
 
     it "should recurse if recursion is enabled" do
       resource = stub('resource', :[] => 'resource')
       file.expects(:recurse).returns [resource]
 
       file[:recurse] = true
 
       expect(file.eval_generate).to eq([resource])
     end
 
     it "should not recurse if recursion is disabled" do
       file.expects(:recurse).never
 
       file[:recurse] = false
 
       expect(file.eval_generate).to eq([])
     end
   end
 
   describe "#ancestors" do
     it "should return the ancestors of the file, in ascending order" do
       file = described_class.new(:path => make_absolute("/tmp/foo/bar/baz/qux"))
 
       pieces = %W[#{make_absolute('/')} tmp foo bar baz]
 
       ancestors = file.ancestors
 
       expect(ancestors).not_to be_empty
       ancestors.reverse.each_with_index do |path,i|
         expect(path).to eq(File.join(*pieces[0..i]))
       end
     end
   end
 
   describe "#flush" do
     it "should flush all properties that respond to :flush" do
       file[:source] = File.expand_path(__FILE__)
       file.parameter(:source).expects(:flush)
       file.flush
     end
 
     it "should reset its stat reference" do
       FileUtils.touch(path)
       stat1 = file.stat
 
       expect(file.stat).to equal(stat1)
 
       file.flush
 
       expect(file.stat).not_to equal(stat1)
     end
   end
 
   describe "#initialize" do
     it "should remove a trailing slash from the title to create the path" do
       title = File.expand_path("/abc/\n\tdef/")
       file = described_class.new(:title => title)
       expect(file[:path]).to eq(title)
     end
 
     it "should set a desired 'ensure' value if none is set and 'content' is set" do
       file = described_class.new(:path => path, :content => "/foo/bar")
       expect(file[:ensure]).to eq(:file)
     end
 
     it "should set a desired 'ensure' value if none is set and 'target' is set", :if => described_class.defaultprovider.feature?(:manages_symlinks) do
       file = described_class.new(:path => path, :target => File.expand_path(__FILE__))
       expect(file[:ensure]).to eq(:link)
     end
   end
 
   describe "#mark_children_for_purging" do
     it "should set each child's ensure to absent" do
       paths = %w[foo bar baz]
       children = paths.inject({}) do |children,child|
         children.merge child => described_class.new(:path => File.join(path, child), :ensure => :present)
       end
 
       file.mark_children_for_purging(children)
 
       expect(children.length).to eq(3)
       children.values.each do |child|
         expect(child[:ensure]).to eq(:absent)
       end
     end
 
     it "should skip children which have a source" do
       child = described_class.new(:path => path, :ensure => :present, :source => File.expand_path(__FILE__))
 
       file.mark_children_for_purging('foo' => child)
 
       expect(child[:ensure]).to eq(:present)
     end
   end
 
   describe "#newchild" do
     it "should create a new resource relative to the parent" do
       child = file.newchild('bar')
 
       expect(child).to be_a(described_class)
       expect(child[:path]).to eq(File.join(file[:path], 'bar'))
     end
 
     {
       :ensure => :present,
       :recurse => true,
       :recurselimit => 5,
       :target => "some_target",
       :source => File.expand_path("some_source"),
     }.each do |param, value|
       it "should omit the #{param} parameter", :if => described_class.defaultprovider.feature?(:manages_symlinks) do
         # Make a new file, because we have to set the param at initialization
         # or it wouldn't be copied regardless.
         file = described_class.new(:path => path, param => value)
         child = file.newchild('bar')
         expect(child[param]).not_to eq(value)
       end
     end
 
     it "should copy all of the parent resource's 'should' values that were set at initialization" do
       parent = described_class.new(:path => path, :owner => 'root', :group => 'wheel')
 
       child = parent.newchild("my/path")
 
       expect(child[:owner]).to eq('root')
       expect(child[:group]).to eq('wheel')
     end
 
     it "should not copy default values to the new child" do
       child = file.newchild("my/path")
       expect(child.original_parameters).not_to include(:backup)
     end
 
     it "should not copy values to the child which were set by the source" do
       source = File.expand_path(__FILE__)
       file[:source] = source
       metadata = stub 'metadata', :owner => "root", :group => "root", :mode => '0755', :ftype => "file", :checksum => "{md5}whatever", :source => source
       file.parameter(:source).stubs(:metadata).returns metadata
 
       file.parameter(:source).copy_source_values
 
       file.class.expects(:new).with { |params| params[:group].nil? }
       file.newchild("my/path")
     end
   end
 
   describe "#purge?" do
     it "should return false if purge is not set" do
       expect(file).to_not be_purge
     end
 
     it "should return true if purge is set to true" do
       file[:purge] = true
 
       expect(file).to be_purge
     end
 
     it "should return false if purge is set to false" do
       file[:purge] = false
 
       expect(file).to_not be_purge
     end
   end
 
   describe "#recurse" do
     before do
       file[:recurse] = true
       @metadata = Puppet::FileServing::Metadata
     end
 
     describe "and a source is set" do
       it "should pass the already-discovered resources to recurse_remote" do
         file[:source] = File.expand_path(__FILE__)
         file.stubs(:recurse_local).returns(:foo => "bar")
         file.expects(:recurse_remote).with(:foo => "bar").returns []
         file.recurse
       end
     end
 
     describe "and a target is set" do
       it "should use recurse_link" do
         file[:target] = File.expand_path(__FILE__)
         file.stubs(:recurse_local).returns(:foo => "bar")
         file.expects(:recurse_link).with(:foo => "bar").returns []
         file.recurse
       end
     end
 
     it "should use recurse_local if recurse is not remote" do
       file.expects(:recurse_local).returns({})
       file.recurse
     end
 
     it "should not use recurse_local if recurse is remote" do
       file[:recurse] = :remote
       file.expects(:recurse_local).never
       file.recurse
     end
 
     it "should return the generated resources as an array sorted by file path" do
       one = stub 'one', :[] => "/one"
       two = stub 'two', :[] => "/one/two"
       three = stub 'three', :[] => "/three"
       file.expects(:recurse_local).returns(:one => one, :two => two, :three => three)
       expect(file.recurse).to eq([one, two, three])
     end
 
     describe "and purging is enabled" do
       before do
         file[:purge] = true
       end
 
       it "should mark each file for removal" do
         local = described_class.new(:path => path, :ensure => :present)
         file.expects(:recurse_local).returns("local" => local)
 
         file.recurse
         expect(local[:ensure]).to eq(:absent)
       end
 
       it "should not remove files that exist in the remote repository" do
         file[:source] = File.expand_path(__FILE__)
         file.expects(:recurse_local).returns({})
 
         remote = described_class.new(:path => path, :source => File.expand_path(__FILE__), :ensure => :present)
 
         file.expects(:recurse_remote).with { |hash| hash["remote"] = remote }
 
         file.recurse
 
         expect(remote[:ensure]).not_to eq(:absent)
       end
     end
 
   end
 
   describe "#remove_less_specific_files" do
     it "should remove any nested files that are already in the catalog" do
       foo = described_class.new :path => File.join(file[:path], 'foo')
       bar = described_class.new :path => File.join(file[:path], 'bar')
       baz = described_class.new :path => File.join(file[:path], 'baz')
 
       catalog.add_resource(foo)
       catalog.add_resource(bar)
 
       expect(file.remove_less_specific_files([foo, bar, baz])).to eq([baz])
     end
   end
 
   describe "#remove_less_specific_files" do
     it "should remove any nested files that are already in the catalog" do
       foo = described_class.new :path => File.join(file[:path], 'foo')
       bar = described_class.new :path => File.join(file[:path], 'bar')
       baz = described_class.new :path => File.join(file[:path], 'baz')
 
       catalog.add_resource(foo)
       catalog.add_resource(bar)
 
       expect(file.remove_less_specific_files([foo, bar, baz])).to eq([baz])
     end
 
   end
 
   describe "#recurse?" do
     it "should be true if recurse is true" do
       file[:recurse] = true
       expect(file).to be_recurse
     end
 
     it "should be true if recurse is remote" do
       file[:recurse] = :remote
       expect(file).to be_recurse
     end
 
     it "should be false if recurse is false" do
       file[:recurse] = false
       expect(file).to_not be_recurse
     end
   end
 
   describe "#recurse_link" do
     before do
       @first = stub 'first', :relative_path => "first", :full_path => "/my/first", :ftype => "directory"
       @second = stub 'second', :relative_path => "second", :full_path => "/my/second", :ftype => "file"
 
       @resource = stub 'file', :[]= => nil
     end
 
     it "should pass its target to the :perform_recursion method" do
       file[:target] = "mylinks"
       file.expects(:perform_recursion).with("mylinks").returns [@first]
       file.stubs(:newchild).returns @resource
       file.recurse_link({})
     end
 
     it "should ignore the recursively-found '.' file and configure the top-level file to create a directory" do
       @first.stubs(:relative_path).returns "."
       file[:target] = "mylinks"
       file.expects(:perform_recursion).with("mylinks").returns [@first]
       file.stubs(:newchild).never
       file.expects(:[]=).with(:ensure, :directory)
       file.recurse_link({})
     end
 
     it "should create a new child resource for each generated metadata instance's relative path that doesn't already exist in the children hash" do
       file.expects(:perform_recursion).returns [@first, @second]
       file.expects(:newchild).with(@first.relative_path).returns @resource
       file.recurse_link("second" => @resource)
     end
 
     it "should not create a new child resource for paths that already exist in the children hash" do
       file.expects(:perform_recursion).returns [@first]
       file.expects(:newchild).never
       file.recurse_link("first" => @resource)
     end
 
     it "should set the target to the full path of discovered file and set :ensure to :link if the file is not a directory", :if => described_class.defaultprovider.feature?(:manages_symlinks) do
       file.stubs(:perform_recursion).returns [@first, @second]
       file.recurse_link("first" => @resource, "second" => file)
 
       expect(file[:ensure]).to eq(:link)
       expect(file[:target]).to eq("/my/second")
     end
 
     it "should :ensure to :directory if the file is a directory" do
       file.stubs(:perform_recursion).returns [@first, @second]
       file.recurse_link("first" => file, "second" => @resource)
 
       expect(file[:ensure]).to eq(:directory)
     end
 
     it "should return a hash with both created and existing resources with the relative paths as the hash keys" do
       file.expects(:perform_recursion).returns [@first, @second]
       file.stubs(:newchild).returns file
       expect(file.recurse_link("second" => @resource)).to eq({"second" => @resource, "first" => file})
     end
   end
 
   describe "#recurse_local" do
     before do
       @metadata = stub 'metadata', :relative_path => "my/file"
     end
 
     it "should pass its path to the :perform_recursion method" do
       file.expects(:perform_recursion).with(file[:path]).returns [@metadata]
       file.stubs(:newchild)
       file.recurse_local
     end
 
     it "should return an empty hash if the recursion returns nothing" do
       file.expects(:perform_recursion).returns nil
       expect(file.recurse_local).to eq({})
     end
 
     it "should create a new child resource with each generated metadata instance's relative path" do
       file.expects(:perform_recursion).returns [@metadata]
       file.expects(:newchild).with(@metadata.relative_path).returns "fiebar"
       file.recurse_local
     end
 
     it "should not create a new child resource for the '.' directory" do
       @metadata.stubs(:relative_path).returns "."
 
       file.expects(:perform_recursion).returns [@metadata]
       file.expects(:newchild).never
       file.recurse_local
     end
 
     it "should return a hash of the created resources with the relative paths as the hash keys" do
       file.expects(:perform_recursion).returns [@metadata]
       file.expects(:newchild).with("my/file").returns "fiebar"
       expect(file.recurse_local).to eq({"my/file" => "fiebar"})
     end
 
     it "should set checksum_type to none if this file checksum is none" do
       file[:checksum] = :none
       Puppet::FileServing::Metadata.indirection.expects(:search).with { |path,params| params[:checksum_type] == :none }.returns [@metadata]
       file.expects(:newchild).with("my/file").returns "fiebar"
       file.recurse_local
     end
   end
 
-  describe "#recurse_remote", :uses_checksums => true do
+  describe "#recurse_remote" do
     let(:my) { File.expand_path('/my') }
 
     before do
       file[:source] = "puppet://foo/bar"
 
       @first = Puppet::FileServing::Metadata.new(my, :relative_path => "first")
       @second = Puppet::FileServing::Metadata.new(my, :relative_path => "second")
       @first.stubs(:ftype).returns "directory"
       @second.stubs(:ftype).returns "directory"
 
       @parameter = stub 'property', :metadata= => nil
       @resource = stub 'file', :[]= => nil, :parameter => @parameter
     end
 
     it "should pass its source to the :perform_recursion method" do
       data = Puppet::FileServing::Metadata.new(File.expand_path("/whatever"), :relative_path => "foobar")
       file.expects(:perform_recursion).with("puppet://foo/bar").returns [data]
       file.stubs(:newchild).returns @resource
       file.recurse_remote({})
     end
 
     it "should not recurse when the remote file is not a directory" do
       data = Puppet::FileServing::Metadata.new(File.expand_path("/whatever"), :relative_path => ".")
       data.stubs(:ftype).returns "file"
       file.expects(:perform_recursion).with("puppet://foo/bar").returns [data]
       file.expects(:newchild).never
       file.recurse_remote({})
     end
 
     it "should set the source of each returned file to the searched-for URI plus the found relative path" do
       @first.expects(:source=).with File.join("puppet://foo/bar", @first.relative_path)
       file.expects(:perform_recursion).returns [@first]
       file.stubs(:newchild).returns @resource
       file.recurse_remote({})
     end
 
     it "should create a new resource for any relative file paths that do not already have a resource" do
       file.stubs(:perform_recursion).returns [@first]
       file.expects(:newchild).with("first").returns @resource
       expect(file.recurse_remote({})).to eq({"first" => @resource})
     end
 
     it "should not create a new resource for any relative file paths that do already have a resource" do
       file.stubs(:perform_recursion).returns [@first]
       file.expects(:newchild).never
       file.recurse_remote("first" => @resource)
     end
 
     it "should set the source of each resource to the source of the metadata" do
       file.stubs(:perform_recursion).returns [@first]
       @resource.stubs(:[]=)
       @resource.expects(:[]=).with(:source, File.join("puppet://foo/bar", @first.relative_path))
       file.recurse_remote("first" => @resource)
     end
 
-    # LAK:FIXME This is a bug, but I can't think of a fix for it.  Fortunately it's already
-    # filed, and when it's fixed, we'll just fix the whole flow.
-    with_digest_algorithms do
-      it "it should set the checksum type to #{metadata[:digest_algorithm]} if the remote file is a file" do
-        @first.stubs(:ftype).returns "file"
-        file.stubs(:perform_recursion).returns [@first]
-        @resource.stubs(:[]=)
-        @resource.expects(:[]=).with(:checksum, digest_algorithm.intern)
-        file.recurse_remote("first" => @resource)
-      end
-    end
-
     it "should store the metadata in the source property for each resource so the source does not have to requery the metadata" do
       file.stubs(:perform_recursion).returns [@first]
       @resource.expects(:parameter).with(:source).returns @parameter
 
       @parameter.expects(:metadata=).with(@first)
 
       file.recurse_remote("first" => @resource)
     end
 
     it "should not create a new resource for the '.' file" do
       @first.stubs(:relative_path).returns "."
       file.stubs(:perform_recursion).returns [@first]
 
       file.expects(:newchild).never
 
       file.recurse_remote({})
     end
 
     it "should store the metadata in the main file's source property if the relative path is '.'" do
       @first.stubs(:relative_path).returns "."
       file.stubs(:perform_recursion).returns [@first]
 
       file.parameter(:source).expects(:metadata=).with @first
 
       file.recurse_remote("first" => @resource)
     end
 
     describe "and multiple sources are provided" do
       let(:sources) do
         h = {}
         %w{/a /b /c /d}.each do |key|
           h[key] = URI.unescape(Puppet::Util.path_to_uri(File.expand_path(key)).to_s)
         end
         h
       end
 
       describe "and :sourceselect is set to :first" do
         it "should create file instances for the results for the first source to return any values" do
           data = Puppet::FileServing::Metadata.new(File.expand_path("/whatever"), :relative_path => "foobar")
           file[:source] = sources.keys.sort.map { |key| File.expand_path(key) }
           file.expects(:perform_recursion).with(sources['/a']).returns nil
           file.expects(:perform_recursion).with(sources['/b']).returns []
           file.expects(:perform_recursion).with(sources['/c']).returns [data]
           file.expects(:perform_recursion).with(sources['/d']).never
           file.expects(:newchild).with("foobar").returns @resource
           file.recurse_remote({})
         end
       end
 
       describe "and :sourceselect is set to :all" do
         before do
           file[:sourceselect] = :all
         end
 
         it "should return every found file that is not in a previous source" do
           klass = Puppet::FileServing::Metadata
 
           file[:source] = abs_path = %w{/a /b /c /d}.map {|f| File.expand_path(f) }
           file.stubs(:newchild).returns @resource
 
           one = [klass.new(abs_path[0], :relative_path => "a")]
           file.expects(:perform_recursion).with(sources['/a']).returns one
           file.expects(:newchild).with("a").returns @resource
 
           two = [klass.new(abs_path[1], :relative_path => "a"), klass.new(abs_path[1], :relative_path => "b")]
           file.expects(:perform_recursion).with(sources['/b']).returns two
           file.expects(:newchild).with("b").returns @resource
 
           three = [klass.new(abs_path[2], :relative_path => "a"), klass.new(abs_path[2], :relative_path => "c")]
           file.expects(:perform_recursion).with(sources['/c']).returns three
           file.expects(:newchild).with("c").returns @resource
 
           file.expects(:perform_recursion).with(sources['/d']).returns []
 
           file.recurse_remote({})
         end
       end
     end
   end
 
-  describe "#perform_recursion" do
+  describe "#perform_recursion", :uses_checksums => true do
     it "should use Metadata to do its recursion" do
       Puppet::FileServing::Metadata.indirection.expects(:search)
       file.perform_recursion(file[:path])
     end
 
     it "should use the provided path as the key to the search" do
       Puppet::FileServing::Metadata.indirection.expects(:search).with { |key, options| key == "/foo" }
       file.perform_recursion("/foo")
     end
 
     it "should return the results of the metadata search" do
       Puppet::FileServing::Metadata.indirection.expects(:search).returns "foobar"
       expect(file.perform_recursion(file[:path])).to eq("foobar")
     end
 
     it "should pass its recursion value to the search" do
       file[:recurse] = true
       Puppet::FileServing::Metadata.indirection.expects(:search).with { |key, options| options[:recurse] == true }
       file.perform_recursion(file[:path])
     end
 
     it "should pass true if recursion is remote" do
       file[:recurse] = :remote
       Puppet::FileServing::Metadata.indirection.expects(:search).with { |key, options| options[:recurse] == true }
       file.perform_recursion(file[:path])
     end
 
     it "should pass its recursion limit value to the search" do
       file[:recurselimit] = 10
       Puppet::FileServing::Metadata.indirection.expects(:search).with { |key, options| options[:recurselimit] == 10 }
       file.perform_recursion(file[:path])
     end
 
     it "should configure the search to ignore or manage links" do
       file[:links] = :manage
       Puppet::FileServing::Metadata.indirection.expects(:search).with { |key, options| options[:links] == :manage }
       file.perform_recursion(file[:path])
     end
 
     it "should pass its 'ignore' setting to the search if it has one" do
       file[:ignore] = %w{.svn CVS}
       Puppet::FileServing::Metadata.indirection.expects(:search).with { |key, options| options[:ignore] == %w{.svn CVS} }
       file.perform_recursion(file[:path])
     end
+
+    with_digest_algorithms do
+      it "it should pass its 'checksum' setting #{metadata[:digest_algorithm]} to the search" do
+        file[:source] = File.expand_path('/foo')
+        Puppet::FileServing::Metadata.indirection.expects(:search).with { |key, options| options[:checksum_type] == digest_algorithm.intern }
+        file.perform_recursion(file[:path])
+      end
+    end
   end
 
   describe "#remove_existing" do
     it "should do nothing if the file doesn't exist" do
       expect(file.remove_existing(:file)).to eq(false)
     end
 
     it "should fail if it can't backup the file" do
       file.stubs(:stat).returns stub('stat', :ftype => 'file')
       file.stubs(:perform_backup).returns false
 
       expect { file.remove_existing(:file) }.to raise_error(Puppet::Error, /Could not back up; will not replace/)
     end
 
     describe "backing up directories" do
       it "should not backup directories if force is false" do
         file[:force] = false
         file.stubs(:stat).returns stub('stat', :ftype => 'directory')
         file.expects(:perform_backup).never
         expect(file.remove_existing(:file)).to eq(false)
       end
 
       it "should backup directories if force is true" do
         file[:force] = true
         FileUtils.expects(:rmtree).with(file[:path])
 
         file.stubs(:stat).returns stub('stat', :ftype => 'directory')
         file.expects(:perform_backup).once.returns(true)
 
         expect(file.remove_existing(:file)).to eq(true)
       end
     end
 
     it "should not do anything if the file is already the right type and not a link" do
       file.stubs(:stat).returns stub('stat', :ftype => 'file')
 
       expect(file.remove_existing(:file)).to eq(false)
     end
 
     it "should not remove directories and should not invalidate the stat unless force is set" do
       # Actually call stat to set @needs_stat to nil
       file.stat
       file.stubs(:stat).returns stub('stat', :ftype => 'directory')
 
       file.remove_existing(:file)
 
       expect(file.instance_variable_get(:@stat)).to eq(nil)
       expect(@logs).to be_any {|log| log.level == :notice and log.message =~ /Not removing directory; use 'force' to override/}
     end
 
     it "should remove a directory if force is set" do
       file[:force] = true
       file.stubs(:stat).returns stub('stat', :ftype => 'directory')
 
       FileUtils.expects(:rmtree).with(file[:path])
 
       expect(file.remove_existing(:file)).to eq(true)
     end
 
     it "should remove an existing file" do
       file.stubs(:perform_backup).returns true
       FileUtils.touch(path)
 
       expect(file.remove_existing(:directory)).to eq(true)
 
       expect(Puppet::FileSystem.exist?(file[:path])).to eq(false)
     end
 
     it "should remove an existing link", :if => described_class.defaultprovider.feature?(:manages_symlinks) do
       file.stubs(:perform_backup).returns true
 
       target = tmpfile('link_target')
       FileUtils.touch(target)
       Puppet::FileSystem.symlink(target, path)
       file[:target] = target
 
       expect(file.remove_existing(:directory)).to eq(true)
 
       expect(Puppet::FileSystem.exist?(file[:path])).to eq(false)
     end
 
     it "should fail if the file is not a file, link, or directory" do
       file.stubs(:stat).returns stub('stat', :ftype => 'socket')
 
       expect { file.remove_existing(:file) }.to raise_error(Puppet::Error, /Could not back up files of type socket/)
     end
 
     it "should invalidate the existing stat of the file" do
       # Actually call stat to set @needs_stat to nil
       file.stat
       file.stubs(:stat).returns stub('stat', :ftype => 'file')
 
       Puppet::FileSystem.stubs(:unlink)
 
       expect(file.remove_existing(:directory)).to eq(true)
       expect(file.instance_variable_get(:@stat)).to eq(:needs_stat)
     end
   end
 
   describe "#retrieve" do
     it "should copy the source values if the 'source' parameter is set" do
       file[:source] = File.expand_path('/foo/bar')
       file.parameter(:source).expects(:copy_source_values)
       file.retrieve
     end
   end
 
   describe "#should_be_file?" do
     it "should have a method for determining if the file should be a normal file" do
       expect(file).to respond_to(:should_be_file?)
     end
 
     it "should be a file if :ensure is set to :file" do
       file[:ensure] = :file
       expect(file).to be_should_be_file
     end
 
     it "should be a file if :ensure is set to :present and the file exists as a normal file" do
       file.stubs(:stat).returns(mock('stat', :ftype => "file"))
       file[:ensure] = :present
       expect(file).to be_should_be_file
     end
 
     it "should not be a file if :ensure is set to something other than :file" do
       file[:ensure] = :directory
       expect(file).to_not be_should_be_file
     end
 
     it "should not be a file if :ensure is set to :present and the file exists but is not a normal file" do
       file.stubs(:stat).returns(mock('stat', :ftype => "directory"))
       file[:ensure] = :present
       expect(file).to_not be_should_be_file
     end
 
     it "should be a file if :ensure is not set and :content is" do
       file[:content] = "foo"
       expect(file).to be_should_be_file
     end
 
     it "should be a file if neither :ensure nor :content is set but the file exists as a normal file" do
       file.stubs(:stat).returns(mock("stat", :ftype => "file"))
       expect(file).to be_should_be_file
     end
 
     it "should not be a file if neither :ensure nor :content is set but the file exists but not as a normal file" do
       file.stubs(:stat).returns(mock("stat", :ftype => "directory"))
       expect(file).to_not be_should_be_file
     end
   end
 
   describe "#stat", :if => described_class.defaultprovider.feature?(:manages_symlinks) do
     before do
       target = tmpfile('link_target')
       FileUtils.touch(target)
       Puppet::FileSystem.symlink(target, path)
 
       file[:target] = target
       file[:links] = :manage # so we always use :lstat
     end
 
     it "should stat the target if it is following links" do
       file[:links] = :follow
 
       expect(file.stat.ftype).to eq('file')
     end
 
     it "should stat the link if is it not following links" do
       file[:links] = :manage
 
       expect(file.stat.ftype).to eq('link')
     end
 
     it "should return nil if the file does not exist" do
       file[:path] = make_absolute('/foo/bar/baz/non-existent')
 
       expect(file.stat).to be_nil
     end
 
     it "should return nil if the file cannot be stat'ed" do
       dir = tmpfile('link_test_dir')
       child = File.join(dir, 'some_file')
       Dir.mkdir(dir)
       File.chmod(0, dir)
 
       file[:path] = child
 
       expect(file.stat).to be_nil
 
       # chmod it back so we can clean it up
       File.chmod(0777, dir)
     end
 
     it "should return nil if parts of path are no directories" do
       regular_file = tmpfile('ENOTDIR_test')
       FileUtils.touch(regular_file)
       impossible_child = File.join(regular_file, 'some_file')
 
       file[:path] = impossible_child
       expect(file.stat).to be_nil
     end
 
     it "should return the stat instance" do
       expect(file.stat).to be_a(File::Stat)
     end
 
     it "should cache the stat instance" do
       expect(file.stat).to equal(file.stat)
     end
   end
 
   describe "#write" do
     describe "when validating the checksum" do
       before { file.stubs(:validate_checksum?).returns(true) }
 
       it "should fail if the checksum parameter and content checksums do not match" do
         checksum = stub('checksum_parameter',  :sum => 'checksum_b', :sum_file => 'checksum_b')
         file.stubs(:parameter).with(:checksum).returns(checksum)
 
         property = stub('content_property', :actual_content => "something", :length => "something".length, :write => 'checksum_a')
         file.stubs(:property).with(:content).returns(property)
 
         expect { file.write :NOTUSED }.to raise_error(Puppet::Error)
       end
     end
 
     describe "when not validating the checksum" do
       before { file.stubs(:validate_checksum?).returns(false) }
 
       it "should not fail if the checksum property and content checksums do not match" do
         checksum = stub('checksum_parameter',  :sum => 'checksum_b')
         file.stubs(:parameter).with(:checksum).returns(checksum)
 
         property = stub('content_property', :actual_content => "something", :length => "something".length, :write => 'checksum_a')
         file.stubs(:property).with(:content).returns(property)
 
         expect { file.write :NOTUSED }.to_not raise_error
       end
     end
 
     describe "when resource mode is supplied" do
       before { file.stubs(:property_fix) }
 
       context "and writing temporary files" do
         before { file.stubs(:write_temporary_file?).returns(true) }
 
         it "should convert symbolic mode to int" do
           file[:mode] = 'oga=r'
           Puppet::Util.expects(:replace_file).with(file[:path], 0444)
           file.write :NOTUSED
         end
 
         it "should support int modes" do
           file[:mode] = '0444'
           Puppet::Util.expects(:replace_file).with(file[:path], 0444)
           file.write :NOTUSED
         end
       end
 
       context "and not writing temporary files" do
         before { file.stubs(:write_temporary_file?).returns(false) }
 
         it "should set a umask of 0" do
           file[:mode] = 'oga=r'
           Puppet::Util.expects(:withumask).with(0)
           file.write :NOTUSED
         end
 
         it "should convert symbolic mode to int" do
           file[:mode] = 'oga=r'
           File.expects(:open).with(file[:path], anything, 0444)
           file.write :NOTUSED
         end
 
         it "should support int modes" do
           file[:mode] = '0444'
           File.expects(:open).with(file[:path], anything, 0444)
           file.write :NOTUSED
         end
       end
     end
 
     describe "when resource mode is not supplied" do
       context "and content is supplied" do
         it "should default to 0644 mode" do
           file = described_class.new(:path => path, :content => "file content")
 
           file.write :NOTUSED
 
           expect(File.stat(file[:path]).mode & 0777).to eq(0644)
         end
       end
 
       context "and no content is supplied" do
         it "should use puppet's default umask of 022" do
           file = described_class.new(:path => path)
 
           umask_from_the_user = 0777
           Puppet::Util.withumask(umask_from_the_user) do
             file.write :NOTUSED
           end
 
           expect(File.stat(file[:path]).mode & 0777).to eq(0644)
         end
       end
     end
   end
 
   describe "#fail_if_checksum_is_wrong" do
     it "should fail if the checksum of the file doesn't match the expected one" do
       expect do
         file.instance_eval do
           parameter(:checksum).stubs(:sum_file).returns('wrong!!')
           fail_if_checksum_is_wrong(self[:path], 'anything!')
         end
       end.to raise_error(Puppet::Error, /File written to disk did not match checksum/)
     end
 
     it "should not fail if the checksum is correct" do
       expect do
         file.instance_eval do
           parameter(:checksum).stubs(:sum_file).returns('anything!')
           fail_if_checksum_is_wrong(self[:path], 'anything!')
         end
       end.not_to raise_error
     end
 
     it "should not fail if the checksum is absent" do
       expect do
         file.instance_eval do
           parameter(:checksum).stubs(:sum_file).returns(nil)
           fail_if_checksum_is_wrong(self[:path], 'anything!')
         end
       end.not_to raise_error
     end
   end
 
   describe "#write_content" do
     it "should delegate writing the file to the content property" do
       io = stub('io')
       file[:content] = "some content here"
       file.property(:content).expects(:write).with(io)
 
       file.send(:write_content, io)
     end
   end
 
   describe "#write_temporary_file?" do
     it "should be true if the file has specified content" do
       file[:content] = 'some content'
 
       expect(file.send(:write_temporary_file?)).to be_truthy
     end
 
     it "should be true if the file has specified source" do
       file[:source] = File.expand_path('/tmp/foo')
 
       expect(file.send(:write_temporary_file?)).to be_truthy
     end
 
     it "should be false if the file has neither content nor source" do
       expect(file.send(:write_temporary_file?)).to be_falsey
     end
   end
 
   describe "#property_fix" do
     {
       :mode     => '0777',
       :owner    => 'joeuser',
       :group    => 'joeusers',
       :seluser  => 'seluser',
       :selrole  => 'selrole',
       :seltype  => 'seltype',
       :selrange => 'selrange'
     }.each do |name,value|
       it "should sync the #{name} property if it's not in sync" do
         file[name] = value
 
         prop = file.property(name)
         prop.expects(:retrieve)
         prop.expects(:safe_insync?).returns false
         prop.expects(:sync)
 
         file.send(:property_fix)
       end
     end
   end
 
   describe "when autorequiring" do
     describe "target" do
       it "should require file resource when specified with the target property", :if => described_class.defaultprovider.feature?(:manages_symlinks) do
         file = described_class.new(:path => File.expand_path("/foo"), :ensure => :directory)
         link = described_class.new(:path => File.expand_path("/bar"), :ensure => :link, :target => File.expand_path("/foo"))
         catalog.add_resource file
         catalog.add_resource link
         reqs = link.autorequire
         expect(reqs.size).to eq(1)
         expect(reqs[0].source).to eq(file)
         expect(reqs[0].target).to eq(link)
       end
 
       it "should require file resource when specified with the ensure property" do
         file = described_class.new(:path => File.expand_path("/foo"), :ensure => :directory)
         link = described_class.new(:path => File.expand_path("/bar"), :ensure => File.expand_path("/foo"))
         catalog.add_resource file
         catalog.add_resource link
         reqs = link.autorequire
         expect(reqs.size).to eq(1)
         expect(reqs[0].source).to eq(file)
         expect(reqs[0].target).to eq(link)
       end
 
       it "should not require target if target is not managed", :if => described_class.defaultprovider.feature?(:manages_symlinks) do
         link = described_class.new(:path => File.expand_path('/foo'), :ensure => :link, :target => '/bar')
         catalog.add_resource link
         expect(link.autorequire.size).to eq(0)
       end
     end
 
     describe "directories" do
       it "should autorequire its parent directory" do
         dir = described_class.new(:path => File.dirname(path))
         catalog.add_resource file
         catalog.add_resource dir
         reqs = file.autorequire
         expect(reqs[0].source).to eq(dir)
         expect(reqs[0].target).to eq(file)
       end
 
       it "should autorequire its nearest ancestor directory" do
         dir = described_class.new(:path => File.dirname(path))
         grandparent = described_class.new(:path => File.dirname(File.dirname(path)))
         catalog.add_resource file
         catalog.add_resource dir
         catalog.add_resource grandparent
         reqs = file.autorequire
         expect(reqs.length).to eq(1)
         expect(reqs[0].source).to eq(dir)
         expect(reqs[0].target).to eq(file)
       end
 
       it "should not autorequire anything when there is no nearest ancestor directory" do
         catalog.add_resource file
         expect(file.autorequire).to be_empty
       end
 
       it "should not autorequire its parent dir if its parent dir is itself" do
         file[:path] = File.expand_path('/')
         catalog.add_resource file
         expect(file.autorequire).to be_empty
       end
 
       describe "on Windows systems", :if => Puppet.features.microsoft_windows? do
         describe "when using UNC filenames" do
           it "should autorequire its parent directory" do
             file[:path] = '//localhost/foo/bar/baz'
             dir = described_class.new(:path => "//localhost/foo/bar")
             catalog.add_resource file
             catalog.add_resource dir
             reqs = file.autorequire
             expect(reqs[0].source).to eq(dir)
             expect(reqs[0].target).to eq(file)
           end
 
           it "should autorequire its nearest ancestor directory" do
             file = described_class.new(:path => "//localhost/foo/bar/baz/qux")
             dir = described_class.new(:path => "//localhost/foo/bar/baz")
             grandparent = described_class.new(:path => "//localhost/foo/bar")
             catalog.add_resource file
             catalog.add_resource dir
             catalog.add_resource grandparent
             reqs = file.autorequire
             expect(reqs.length).to eq(1)
             expect(reqs[0].source).to eq(dir)
             expect(reqs[0].target).to eq(file)
           end
 
           it "should not autorequire anything when there is no nearest ancestor directory" do
             file = described_class.new(:path => "//localhost/foo/bar/baz/qux")
             catalog.add_resource file
             expect(file.autorequire).to be_empty
           end
 
           it "should not autorequire its parent dir if its parent dir is itself" do
             file = described_class.new(:path => "//localhost/foo")
             catalog.add_resource file
             puts file.autorequire
             expect(file.autorequire).to be_empty
           end
         end
       end
     end
   end
 
   describe "when managing links", :if => Puppet.features.manages_symlinks? do
     require 'tempfile'
 
     before :each do
       Dir.mkdir(path)
       @target = File.join(path, "target")
       @link   = File.join(path, "link")
 
       target = described_class.new(
         :ensure => :file, :path => @target,
         :catalog => catalog, :content => 'yayness',
         :mode => '0644')
       catalog.add_resource target
 
       @link_resource = described_class.new(
         :ensure => :link, :path => @link,
         :target => @target, :catalog => catalog,
         :mode => '0755')
       catalog.add_resource @link_resource
 
       # to prevent the catalog from trying to write state.yaml
       Puppet::Util::Storage.stubs(:store)
     end
 
     it "should preserve the original file mode and ignore the one set by the link" do
       @link_resource[:links] = :manage # default
       catalog.apply
 
       # I convert them to strings so they display correctly if there's an error.
       expect((Puppet::FileSystem.stat(@target).mode & 007777).to_s(8)).to eq('644')
     end
 
     it "should manage the mode of the followed link" do
       if Puppet.features.microsoft_windows?
         skip "Windows cannot presently manage the mode when following symlinks"
       else
         @link_resource[:links] = :follow
         catalog.apply
 
         expect((Puppet::FileSystem.stat(@target).mode & 007777).to_s(8)).to eq('755')
       end
     end
   end
 
   describe "when using source" do
     before do
       file[:source] = File.expand_path('/one')
     end
     Puppet::Type::File::ParameterChecksum.value_collection.values.reject {|v| v == :none}.each do |checksum_type|
       describe "with checksum '#{checksum_type}'" do
         before do
           file[:checksum] = checksum_type
         end
 
         it 'should validate' do
 
           expect { file.validate }.to_not raise_error
         end
       end
     end
 
     describe "with checksum 'none'" do
       before do
         file[:checksum] = :none
       end
 
       it 'should raise an exception when validating' do
         expect { file.validate }.to raise_error(/You cannot specify source when using checksum 'none'/)
       end
     end
   end
 
   describe "when using content" do
     before do
       file[:content] = 'file contents'
     end
 
     (Puppet::Type::File::ParameterChecksum.value_collection.values - SOURCE_ONLY_CHECKSUMS).each do |checksum_type|
       describe "with checksum '#{checksum_type}'" do
         before do
           file[:checksum] = checksum_type
         end
 
         it 'should validate' do
           expect { file.validate }.to_not raise_error
         end
       end
     end
 
     SOURCE_ONLY_CHECKSUMS.each do |checksum_type|
       describe "with checksum '#{checksum_type}'" do
         it 'should raise an exception when validating' do
           file[:checksum] = checksum_type
 
           expect { file.validate }.to raise_error(/You cannot specify content when using checksum '#{checksum_type}'/)
         end
       end
     end
   end
 
   describe "when auditing" do
     before :each do
       # to prevent the catalog from trying to write state.yaml
       Puppet::Util::Storage.stubs(:store)
     end
 
     it "should not fail if creating a new file if group is not set" do
       file = described_class.new(:path => path, :audit => 'all', :content => 'content')
       catalog.add_resource(file)
 
       report = catalog.apply.report
 
       expect(report.resource_statuses["File[#{path}]"]).not_to be_failed
       expect(File.read(path)).to eq('content')
     end
 
     it "should not log errors if creating a new file with ensure present and no content" do
       file[:audit]  = 'content'
       file[:ensure] = 'present'
       catalog.add_resource(file)
 
       catalog.apply
 
       expect(Puppet::FileSystem.exist?(path)).to be_truthy
       expect(@logs).not_to be_any {|l| l.level != :notice }
     end
   end
 
   describe "when specifying both source and checksum" do
     it 'should use the specified checksum when source is first' do
       file[:source] = File.expand_path('/foo')
       file[:checksum] = :md5lite
 
       expect(file[:checksum]).to eq(:md5lite)
     end
 
     it 'should use the specified checksum when source is last' do
       file[:checksum] = :md5lite
       file[:source] = File.expand_path('/foo')
 
       expect(file[:checksum]).to eq(:md5lite)
     end
   end
 
   describe "when validating" do
     [[:source, :target], [:source, :content], [:target, :content]].each do |prop1,prop2|
       it "should fail if both #{prop1} and #{prop2} are specified" do
           file[prop1] = prop1 == :source ? File.expand_path("prop1 value") : "prop1 value"
           file[prop2] = "prop2 value"
         expect do
           file.validate
         end.to raise_error(Puppet::Error, /You cannot specify more than one of/)
       end
     end
   end
 
 end