diff --git a/lib/puppet.rb b/lib/puppet.rb
index 9105f7f62..73704b7e1 100644
--- a/lib/puppet.rb
+++ b/lib/puppet.rb
@@ -1,159 +1,129 @@
 # Try to load rubygems.  Hey rubygems, I hate you.
 begin
   require 'rubygems'
 rescue LoadError
 end
 
 # see the bottom of the file for further inclusions
 require 'singleton'
 require 'facter'
 require 'puppet/error'
 require 'puppet/util'
 require 'puppet/util/autoload'
 require 'puppet/util/settings'
 require 'puppet/util/feature'
 require 'puppet/util/suidmanager'
 require 'puppet/util/run_mode'
 
 #------------------------------------------------------------
 # the top-level module
 #
 # all this really does is dictate how the whole system behaves, through
 # preferences for things like debugging
 #
 # it's also a place to find top-level commands like 'debug'
 
 module Puppet
   PUPPETVERSION = '2.7.10'
 
   def Puppet.version
     PUPPETVERSION
   end
 
   class << self
     include Puppet::Util
     attr_reader :features
     attr_writer :name
   end
 
   # the hash that determines how our system behaves
   @@settings = Puppet::Util::Settings.new
 
   # The services running in this process.
   @services ||= []
 
   require 'puppet/util/logging'
 
   extend Puppet::Util::Logging
 
   # The feature collection
   @features = Puppet::Util::Feature.new('puppet/feature')
 
   # Load the base features.
   require 'puppet/feature/base'
 
   # Store a new default value.
   def self.setdefaults(section, hash)
     @@settings.setdefaults(section, hash)
   end
 
   # configuration parameter access and stuff
   def self.[](param)
     if param == :debug
       return Puppet::Util::Log.level == :debug
     else
       return @@settings[param]
     end
   end
 
   # configuration parameter access and stuff
   def self.[]=(param,value)
     @@settings[param] = value
   end
 
   def self.clear
     @@settings.clear
   end
 
   def self.debug=(value)
     if value
       Puppet::Util::Log.level=(:debug)
     else
       Puppet::Util::Log.level=(:notice)
     end
   end
 
   def self.settings
     @@settings
   end
 
   def self.run_mode
     $puppet_application_mode || Puppet::Util::RunMode[:user]
   end
 
   def self.application_name
     $puppet_application_name ||= "apply"
   end
 
   # Load all of the configuration parameters.
   require 'puppet/defaults'
 
   def self.genmanifest
     if Puppet[:genmanifest]
       puts Puppet.settings.to_manifest
       exit(0)
     end
   end
 
   # Parse the config file for this process.
   def self.parse_config
     Puppet.settings.parse
   end
 
-  # XXX this should all be done using puppet objects, not using
-  # normal mkdir
-  def self.recmkdir(dir,mode = 0755)
-    if FileTest.exist?(dir)
-      return false
-    else
-      tmp = dir.sub(/^\//,'')
-      path = [File::SEPARATOR]
-      tmp.split(File::SEPARATOR).each { |dir|
-        path.push dir
-        if ! FileTest.exist?(File.join(path))
-          begin
-            Dir.mkdir(File.join(path), mode)
-          rescue Errno::EACCES => detail
-            Puppet.err detail.to_s
-            return false
-          rescue => detail
-            Puppet.err "Could not create #{path}: #{detail}"
-            return false
-          end
-        elsif FileTest.directory?(File.join(path))
-          next
-        else FileTest.exist?(File.join(path))
-          raise Puppet::Error, "Cannot create #{dir}: basedir #{File.join(path)} is a file"
-        end
-      }
-      return true
-    end
-  end
-
   # Create a new type.  Just proxy to the Type class.  The mirroring query
   # code was deprecated in 2008, but this is still in heavy use.  I suppose
   # this can count as a soft deprecation for the next dev. --daniel 2011-04-12
   def self.newtype(name, options = {}, &block)
     Puppet::Type.newtype(name, options, &block)
   end
 end
 
 require 'puppet/type'
 require 'puppet/parser'
 require 'puppet/resource'
 require 'puppet/network'
 require 'puppet/ssl'
 require 'puppet/module'
 require 'puppet/util/storage'
 require 'puppet/status'
 require 'puppet/file_bucket/file'
diff --git a/lib/puppet/file_serving/base.rb b/lib/puppet/file_serving/base.rb
index e936b5e75..b14c51c81 100644
--- a/lib/puppet/file_serving/base.rb
+++ b/lib/puppet/file_serving/base.rb
@@ -1,87 +1,88 @@
 require 'puppet/file_serving'
+require 'puppet/util'
 
 # The base class for Content and Metadata; provides common
 # functionality like the behaviour around links.
 class Puppet::FileServing::Base
   # This is for external consumers to store the source that was used
   # to retrieve the metadata.
   attr_accessor :source
 
   # Does our file exist?
   def exist?
       stat
       return true
   rescue => detail
       return false
   end
 
   # Return the full path to our file.  Fails if there's no path set.
   def full_path(dummy_argument=:work_arround_for_ruby_GC_bug)
     (if relative_path.nil? or relative_path == "" or relative_path == "."
       path
     else
       File.join(path, relative_path)
     end).gsub(%r{/+}, "/")
   end
 
   def initialize(path, options = {})
     self.path = path
     @links = :manage
 
     options.each do |param, value|
       begin
         send param.to_s + "=", value
       rescue NoMethodError
         raise ArgumentError, "Invalid option #{param} for #{self.class}"
       end
     end
   end
 
   # Determine how we deal with links.
   attr_reader :links
   def links=(value)
     value = value.to_sym
     value = :manage if value == :ignore
     raise(ArgumentError, ":links can only be set to :manage or :follow") unless [:manage, :follow].include?(value)
     @links = value
   end
 
   # Set our base path.
   attr_reader :path
   def path=(path)
-    unless path =~ /^#{::File::SEPARATOR}/ or path =~ /^[a-z]:[\/\\]/i
+    unless Puppet::Util.absolute_path?(path)
       raise ArgumentError.new("Paths must be fully qualified")
     end
 
     @path = path
   end
 
   # Set a relative path; this is used for recursion, and sets
   # the file's path relative to the initial recursion point.
   attr_reader :relative_path
   def relative_path=(path)
-    raise ArgumentError.new("Relative paths must not be fully qualified") if path =~ /^#{::File::SEPARATOR}/
+    raise ArgumentError.new("Relative paths must not be fully qualified") if Puppet::Util.absolute_path?(path)
     @relative_path = path
   end
 
   # Stat our file, using the appropriate link-sensitive method.
   def stat
     @stat_method ||= self.links == :manage ? :lstat : :stat
     File.send(@stat_method, full_path)
   end
 
   def to_pson_data_hash
     {
       # No 'document_type' since we don't send these bare
       'data'       => {
         'path'          => @path,
         'relative_path' => @relative_path,
         'links'         => @links
         },
       'metadata' => {
         'api_version' => 1
         }
     }
   end
 
 end
diff --git a/lib/puppet/indirector/exec.rb b/lib/puppet/indirector/exec.rb
index e6325adaa..63809e0f7 100644
--- a/lib/puppet/indirector/exec.rb
+++ b/lib/puppet/indirector/exec.rb
@@ -1,48 +1,48 @@
 require 'puppet/indirector/terminus'
 require 'puppet/util'
 
 class Puppet::Indirector::Exec < Puppet::Indirector::Terminus
   # Look for external node definitions.
   def find(request)
     # Run the command.
     unless output = query(request.key)
       return nil
     end
 
     # Translate the output to ruby.
     output
   end
 
   private
 
   # Proxy the execution, so it's easier to test.
   def execute(command, arguments)
     Puppet::Util.execute(command,arguments)
   end
 
   # Call the external command and see if it returns our output.
   def query(name)
     external_command = command
 
     # Make sure it's an arry
     raise Puppet::DevError, "Exec commands must be an array" unless external_command.is_a?(Array)
 
     # Make sure it's fully qualified.
-    raise ArgumentError, "You must set the exec parameter to a fully qualified command" unless external_command[0][0] == File::SEPARATOR[0]
+    raise ArgumentError, "You must set the exec parameter to a fully qualified command" unless Puppet::Util.absolute_path?(external_command[0])
 
     # Add our name to it.
     external_command << name
     begin
       output = execute(external_command, :combine => false)
     rescue Puppet::ExecutionFailure => detail
       raise Puppet::Error, "Failed to find #{name} via exec: #{detail}"
     end
 
     if output =~ /\A\s*\Z/ # all whitespace
       Puppet.debug "Empty response for #{name} from #{self.name} terminus"
       return nil
     else
       return output
     end
   end
 end
diff --git a/lib/puppet/node/environment.rb b/lib/puppet/node/environment.rb
index 326809050..06be16d89 100644
--- a/lib/puppet/node/environment.rb
+++ b/lib/puppet/node/environment.rb
@@ -1,189 +1,186 @@
+require 'puppet/util'
 require 'puppet/util/cacher'
 require 'monitor'
 
 # Just define it, so this class has fewer load dependencies.
 class Puppet::Node
 end
 
 # Model the environment that a node can operate in.  This class just
 # provides a simple wrapper for the functionality around environments.
 class Puppet::Node::Environment
   module Helper
     def environment
       Puppet::Node::Environment.new(@environment)
     end
 
     def environment=(env)
       if env.is_a?(String) or env.is_a?(Symbol)
         @environment = env
       else
         @environment = env.name
       end
     end
   end
 
   include Puppet::Util::Cacher
 
   @seen = {}
 
   # Return an existing environment instance, or create a new one.
   def self.new(name = nil)
     return name if name.is_a?(self)
     name ||= Puppet.settings.value(:environment)
 
     raise ArgumentError, "Environment name must be specified" unless name
 
     symbol = name.to_sym
 
     return @seen[symbol] if @seen[symbol]
 
     obj = self.allocate
     obj.send :initialize, symbol
     @seen[symbol] = obj
   end
 
   def self.current
     Thread.current[:environment] || root
   end
 
   def self.current=(env)
     Thread.current[:environment] = new(env)
   end
 
   def self.root
     @root
   end
 
   def self.clear
     @seen.clear
   end
 
   attr_reader :name
 
   # Return an environment-specific setting.
   def [](param)
     Puppet.settings.value(param, self.name)
   end
 
   def initialize(name)
     @name = name
     extend MonitorMixin
   end
 
   def known_resource_types
     # This makes use of short circuit evaluation to get the right thread-safe
     # per environment semantics with an efficient most common cases; we almost
     # always just return our thread's known-resource types.  Only at the start
     # of a compilation (after our thread var has been set to nil) or when the
     # environment has changed do we delve deeper.
     Thread.current[:known_resource_types] = nil if (krt = Thread.current[:known_resource_types]) && krt.environment != self
     Thread.current[:known_resource_types] ||= synchronize {
       if @known_resource_types.nil? or @known_resource_types.require_reparse?
         @known_resource_types = Puppet::Resource::TypeCollection.new(self)
         @known_resource_types.import_ast(perform_initial_import, '')
       end
       @known_resource_types
     }
   end
 
   def module(name)
     mod = Puppet::Module.new(name, :environment => self)
     return nil unless mod.exist?
     mod
   end
 
   # Cache the modulepath, so that we aren't searching through
   # all known directories all the time.
   cached_attr(:modulepath, Puppet[:filetimeout]) do
     dirs = self[:modulepath].split(File::PATH_SEPARATOR)
     dirs = ENV["PUPPETLIB"].split(File::PATH_SEPARATOR) + dirs if ENV["PUPPETLIB"]
     validate_dirs(dirs)
   end
 
   # Return all modules from this environment.
   # Cache the list, because it can be expensive to create.
   cached_attr(:modules, Puppet[:filetimeout]) do
     module_names = modulepath.collect { |path| Dir.entries(path) }.flatten.uniq
     module_names.collect do |path|
       begin
         Puppet::Module.new(path, :environment => self)
       rescue Puppet::Module::Error => e
         nil
       end
     end.compact
   end
 
   # Modules broken out by directory in the modulepath
   def modules_by_path
     modules_by_path = {}
     modulepath.each do |path|
       Dir.chdir(path) do
         module_names = Dir.glob('*').select { |d| FileTest.directory? d }
         modules_by_path[path] = module_names.map do |name|
           Puppet::Module.new(name, :environment => self, :path => File.join(path, name))
         end
       end
     end
     modules_by_path
   end
 
   def to_s
     name.to_s
   end
 
   def to_sym
     to_s.to_sym
   end
 
   # The only thing we care about when serializing an environment is its
   # identity; everything else is ephemeral and should not be stored or
   # transmitted.
   def to_zaml(z)
     self.to_s.to_zaml(z)
   end
 
   def validate_dirs(dirs)
-    dir_regex = Puppet.features.microsoft_windows? ? /^[A-Za-z]:#{File::SEPARATOR}/ : /^#{File::SEPARATOR}/
-    # REMIND: Dir.getwd on windows returns a path containing backslashes, which when joined with
-    # dir containing forward slashes, breaks our regex matching. In general, path validation needs
-    # to be refactored which will be handled in a future commit.
     dirs.collect do |dir|
-      if dir !~ dir_regex
+      unless Puppet::Util.absolute_path?(dir)
         File.expand_path(File.join(Dir.getwd, dir))
       else
         dir
       end
     end.find_all do |p|
-      p =~ dir_regex && FileTest.directory?(p)
+      Puppet::Util.absolute_path?(p) && FileTest.directory?(p)
     end
   end
 
   private
 
   def perform_initial_import
     return empty_parse_result if Puppet.settings[:ignoreimport]
     parser = Puppet::Parser::Parser.new(self)
     if code = Puppet.settings.uninterpolated_value(:code, name.to_s) and code != ""
       parser.string = code
     else
       file = Puppet.settings.value(:manifest, name.to_s)
       parser.file = file
     end
     parser.parse
   rescue => detail
     known_resource_types.parse_failed = true
 
     msg = "Could not parse for environment #{self}: #{detail}"
     error = Puppet::Error.new(msg)
     error.set_backtrace(detail.backtrace)
     raise error
   end
 
   def empty_parse_result
     # Return an empty toplevel hostclass to use as the result of
     # perform_initial_import when no file was actually loaded.
     return Puppet::Parser::AST::Hostclass.new('')
   end
 
   @root = new(:'*root*')
 end
diff --git a/lib/puppet/parameter/path.rb b/lib/puppet/parameter/path.rb
index 26e4933c7..11d0969db 100644
--- a/lib/puppet/parameter/path.rb
+++ b/lib/puppet/parameter/path.rb
@@ -1,38 +1,34 @@
 require 'puppet/parameter'
 
 class Puppet::Parameter::Path < Puppet::Parameter
   def self.accept_arrays(bool = true)
     @accept_arrays = !!bool
   end
   def self.arrays?
     @accept_arrays
   end
 
   def validate_path(paths)
     if paths.is_a?(Array) and ! self.class.arrays? then
       fail "#{name} only accepts a single path, not an array of paths"
     end
 
-    # We *always* support Unix path separators, as Win32 does now too.
-    absolute = "[/#{::Regexp.quote(::File::SEPARATOR)}]"
-    win32    = Puppet.features.microsoft_windows?
-
     fail("#{name} must be a fully qualified path") unless Array(paths).all? {|path| absolute_path?(path)}
 
     paths
   end
 
   # This will be overridden if someone uses the validate option, which is why
   # it just delegates to the other, useful, method.
   def unsafe_validate(paths)
     validate_path(paths)
   end
 
   # Likewise, this might be overridden, but by default...
   def unsafe_munge(paths)
     if paths.is_a?(Array) and ! self.class.arrays? then
       fail "#{name} only accepts a single path, not an array of paths"
     end
     paths
   end
 end
diff --git a/lib/puppet/parser/functions/file.rb b/lib/puppet/parser/functions/file.rb
index 19ab9ba2e..d7bf5a1f8 100644
--- a/lib/puppet/parser/functions/file.rb
+++ b/lib/puppet/parser/functions/file.rb
@@ -1,23 +1,23 @@
 # Returns the contents of a file
 
       Puppet::Parser::Functions::newfunction(
         :file, :type => :rvalue,
 
     :doc => "Return the contents of a file.  Multiple files
     can be passed, and the first file that exists will be read in.") do |vals|
       ret = nil
       vals.each do |file|
-        unless file =~ /^#{File::SEPARATOR}/
+        unless Puppet::Util.absolute_path?(file)
           raise Puppet::ParseError, "Files must be fully qualified"
         end
         if FileTest.exists?(file)
           ret = File.read(file)
           break
         end
       end
       if ret
         ret
       else
         raise Puppet::ParseError, "Could not find any files from #{vals.join(", ")}"
       end
 end
diff --git a/lib/puppet/parser/functions/generate.rb b/lib/puppet/parser/functions/generate.rb
index 91f7b2240..226a5b7e1 100644
--- a/lib/puppet/parser/functions/generate.rb
+++ b/lib/puppet/parser/functions/generate.rb
@@ -1,31 +1,37 @@
 # Runs an external command and returns the results
 Puppet::Parser::Functions::newfunction(:generate, :type => :rvalue,
     :doc => "Calls an external command on the Puppet master and returns
     the results of the command.  Any arguments are passed to the external command as
     arguments.  If the generator does not exit with return code of 0,
     the generator is considered to have failed and a parse error is
     thrown.  Generators can only have file separators, alphanumerics, dashes,
     and periods in them.  This function will attempt to protect you from
     malicious generator calls (e.g., those with '..' in them), but it can
     never be entirely safe.  No subshell is used to execute
     generators, so all shell metacharacters are passed directly to
     the generator.") do |args|
 
-      raise Puppet::ParseError, "Generators must be fully qualified" unless args[0] =~ /^#{File::SEPARATOR}/
+      raise Puppet::ParseError, "Generators must be fully qualified" unless Puppet::Util.absolute_path?(args[0])
 
-      unless args[0] =~ /^[-#{File::SEPARATOR}\w.]+$/
+      if Puppet.features.microsoft_windows?
+        valid = args[0] =~ /^[a-z]:(?:[\/\\][\w.-]+)+$/i
+      else
+        valid = args[0] =~ /^[-\/\w.]+$/
+      end
+
+      unless valid
         raise Puppet::ParseError,
           "Generators can only contain alphanumerics, file separators, and dashes"
       end
 
       if args[0] =~ /\.\./
         raise Puppet::ParseError,
           "Can not use generators with '..' in them."
       end
 
       begin
         Dir.chdir(File.dirname(args[0])) { Puppet::Util.execute(args) }
       rescue Puppet::ExecutionFailure => detail
         raise Puppet::ParseError, "Failed to execute generator #{args[0]}: #{detail}"
       end
 end
diff --git a/lib/puppet/parser/type_loader.rb b/lib/puppet/parser/type_loader.rb
index 3cba89515..65579a820 100644
--- a/lib/puppet/parser/type_loader.rb
+++ b/lib/puppet/parser/type_loader.rb
@@ -1,174 +1,173 @@
 require 'puppet/node/environment'
 
 class Puppet::Parser::TypeLoader
   include Puppet::Node::Environment::Helper
 
   # Helper class that makes sure we don't try to import the same file
   # more than once from either the same thread or different threads.
   class Helper
     include MonitorMixin
     def initialize
       super
       # These hashes are indexed by filename
       @state = {} # :doing or :done
       @thread = {} # if :doing, thread that's doing the parsing
       @cond_var = {} # if :doing, condition var that will be signaled when done.
     end
 
     # Execute the supplied block exactly once per file, no matter how
     # many threads have asked for it to run.  If another thread is
     # already executing it, wait for it to finish.  If this thread is
     # already executing it, return immediately without executing the
     # block.
     #
     # Note: the reason for returning immediately if this thread is
     # already executing the block is to handle the case of a circular
     # import--when this happens, we attempt to recursively re-parse a
     # file that we are already in the process of parsing.  To prevent
     # an infinite regress we need to simply do nothing when the
     # recursive import is attempted.
     def do_once(file)
       need_to_execute = synchronize do
         case @state[file]
         when :doing
           if @thread[file] != Thread.current
             @cond_var[file].wait
           end
           false
         when :done
           false
         else
           @state[file] = :doing
           @thread[file] = Thread.current
           @cond_var[file] = new_cond
           true
         end
       end
       if need_to_execute
         begin
           yield
         ensure
           synchronize do
             @state[file] = :done
             @thread.delete(file)
             @cond_var.delete(file).broadcast
           end
         end
       end
     end
   end
 
   # Import our files.
   def import(file, current_file = nil)
     return if Puppet[:ignoreimport]
 
     # use a path relative to the file doing the importing
     if current_file
       dir = current_file.sub(%r{[^/]+$},'').sub(/\/$/, '')
     else
       dir = "."
     end
     if dir == ""
       dir = "."
     end
 
     pat = file
     modname, files = Puppet::Parser::Files.find_manifests(pat, :cwd => dir, :environment => environment)
     if files.size == 0
       raise Puppet::ImportError.new("No file(s) found for import of '#{pat}'")
     end
 
     loaded_asts = []
     files.each do |file|
-      regex = Puppet.features.microsoft_windows? ? /^[A-Za-z]:#{File::SEPARATOR}/ : /^#{File::SEPARATOR}/
-      unless file =~ regex
+      unless Puppet::Util.absolute_path?(file)
         file = File.join(dir, file)
       end
       @loading_helper.do_once(file) do
         loaded_asts << parse_file(file)
       end
     end
     loaded_asts.inject([]) do |loaded_types, ast|
       loaded_types + known_resource_types.import_ast(ast, modname)
     end
   end
 
   def import_all
     require 'find'
 
     module_names = []
     # Collect the list of all known modules
     environment.modulepath.each do |path|
       Dir.chdir(path) do
         Dir.glob("*").each do |dir|
           next unless FileTest.directory?(dir)
           module_names << dir
         end
       end
     end
 
     module_names.uniq!
     # And then load all files from each module, but (relying on system
     # behavior) only load files from the first module of a given name.  E.g.,
     # given first/foo and second/foo, only files from first/foo will be loaded.
     module_names.each do |name|
       mod = Puppet::Module.new(name, :environment => environment)
       Find.find(File.join(mod.path, "manifests")) do |path|
         if path =~ /\.pp$/ or path =~ /\.rb$/
           import(path)
         end
       end
     end
   end
 
   def known_resource_types
     environment.known_resource_types
   end
 
   def initialize(env)
     self.environment = env
     @loading_helper = Helper.new
   end
 
   # Try to load the object with the given fully qualified name.
   def try_load_fqname(type, fqname)
     return nil if fqname == "" # special-case main.
     name2files(fqname).each do |filename|
       begin
         imported_types = import(filename)
         if result = imported_types.find { |t| t.type == type and t.name == fqname }
           Puppet.debug "Automatically imported #{fqname} from #{filename} into #{environment}"
           return result
         end
       rescue Puppet::ImportError => detail
         # We couldn't load the item
         # I'm not convienced we should just drop these errors, but this
         # preserves existing behaviours.
       end
     end
     # Nothing found.
     return nil
   end
 
   def parse_file(file)
     Puppet.debug("importing '#{file}' in environment #{environment}")
     parser = Puppet::Parser::Parser.new(environment)
     parser.file = file
     return parser.parse
   end
 
   private
 
   # Return a list of all file basenames that should be tried in order
   # to load the object with the given fully qualified name.
   def name2files(fqname)
     result = []
     ary = fqname.split("::")
     while ary.length > 0
       result << ary.join(File::SEPARATOR)
       ary.pop
     end
     return result
   end
 
 end
diff --git a/lib/puppet/type/k5login.rb b/lib/puppet/type/k5login.rb
index 09114e977..e7fbac042 100644
--- a/lib/puppet/type/k5login.rb
+++ b/lib/puppet/type/k5login.rb
@@ -1,87 +1,87 @@
 # Plug-in type for handling k5login files
 
 Puppet::Type.newtype(:k5login) do
   @doc = "Manage the `.k5login` file for a user.  Specify the full path to
     the `.k5login` file as the name, and an array of principals as the
     `principals` attribute."
 
   ensurable
 
   # Principals that should exist in the file
   newproperty(:principals, :array_matching => :all) do
     desc "The principals present in the `.k5login` file. This should be specified as an array."
   end
 
   # The path/name of the k5login file
   newparam(:path) do
     isnamevar
     desc "The path to the `.k5login` file to manage.  Must be fully qualified."
 
     validate do |value|
-      unless value =~ /^#{File::SEPARATOR}/
+      unless absolute_path?(value)
         raise Puppet::Error, "File paths must be fully qualified."
       end
     end
   end
 
   # To manage the mode of the file
   newproperty(:mode) do
     desc "The desired permissions mode of the `.k5login` file. Defaults to `644`."
     defaultto { "644" }
   end
 
   provide(:k5login) do
     desc "The k5login provider is the only provider for the k5login
       type."
 
     # Does this file exist?
     def exists?
       File.exists?(@resource[:name])
     end
 
     # create the file
     def create
       write(@resource.should(:principals))
       should_mode = @resource.should(:mode)
       unless self.mode == should_mode
         self.mode = should_mode
       end
     end
 
     # remove the file
     def destroy
       File.unlink(@resource[:name])
     end
 
     # Return the principals
     def principals(dummy_argument=:work_arround_for_ruby_GC_bug)
       if File.exists?(@resource[:name])
         File.readlines(@resource[:name]).collect { |line| line.chomp }
       else
         :absent
       end
     end
 
     # Write the principals out to the k5login file
     def principals=(value)
       write(value)
     end
 
     # Return the mode as an octal string, not as an integer
     def mode
       "%o" % (File.stat(@resource[:name]).mode & 007777)
     end
 
     # Set the file mode, converting from a string to an integer.
     def mode=(value)
       File.chmod(Integer("0#{value}"), @resource[:name])
     end
 
     private
     def write(value)
       Puppet::Util.secure_open(@resource[:name], "w") do |f|
         f.puts value.join("\n")
       end
     end
   end
 end
diff --git a/lib/puppet/type/package.rb b/lib/puppet/type/package.rb
index d0bdfdba1..ed797f5f7 100644
--- a/lib/puppet/type/package.rb
+++ b/lib/puppet/type/package.rb
@@ -1,337 +1,335 @@
 # Define the different packaging systems.  Each package system is implemented
 # in a module, which then gets used to individually extend each package object.
 # This allows packages to exist on the same machine using different packaging
 # systems.
 
 module Puppet
   newtype(:package) do
     @doc = "Manage packages.  There is a basic dichotomy in package
       support right now:  Some package types (e.g., yum and apt) can
       retrieve their own package files, while others (e.g., rpm and sun)
       cannot.  For those package formats that cannot retrieve their own files,
       you can use the `source` parameter to point to the correct file.
 
       Puppet will automatically guess the packaging format that you are
       using based on the platform you are on, but you can override it
       using the `provider` parameter; each provider defines what it
       requires in order to function, and you must meet those requirements
       to use a given provider.
 
       **Autorequires:** If Puppet is managing the files specified as a
       package's `adminfile`, `responsefile`, or `source`, the package
       resource will autorequire those files."
 
     feature :installable, "The provider can install packages.",
       :methods => [:install]
     feature :uninstallable, "The provider can uninstall packages.",
       :methods => [:uninstall]
     feature :upgradeable, "The provider can upgrade to the latest version of a
         package.  This feature is used by specifying `latest` as the
         desired value for the package.",
       :methods => [:update, :latest]
     feature :purgeable, "The provider can purge packages.  This generally means
         that all traces of the package are removed, including
         existing configuration files.  This feature is thus destructive
         and should be used with the utmost care.",
       :methods => [:purge]
     feature :versionable, "The provider is capable of interrogating the
         package database for installed version(s), and can select
         which out of a set of available versions of a package to
         install if asked."
     feature :holdable, "The provider is capable of placing packages on hold
         such that they are not automatically upgraded as a result of
         other package dependencies unless explicit action is taken by
         a user or another package. Held is considered a superset of
         installed.",
       :methods => [:hold]
     feature :install_options, "The provider accepts options to be
       passed to the installer command."
 
     ensurable do
       desc <<-EOT
         What state the package should be in. On packaging systems that can
         retrieve new packages on their own, you can choose which package to
         retrieve by specifying a version number or `latest` as the ensure
         value. On packaging systems that manage configuration files separately
         from "normal" system files, you can uninstall config files by
         specifying `purged` as the ensure value.
       EOT
 
       attr_accessor :latest
 
       newvalue(:present, :event => :package_installed) do
         provider.install
       end
 
       newvalue(:absent, :event => :package_removed) do
         provider.uninstall
       end
 
       newvalue(:purged, :event => :package_purged, :required_features => :purgeable) do
         provider.purge
       end
 
       newvalue(:held, :event => :package_held, :required_features => :holdable) do
         provider.hold
       end
 
       # Alias the 'present' value.
       aliasvalue(:installed, :present)
 
       newvalue(:latest, :required_features => :upgradeable) do
         # Because yum always exits with a 0 exit code, there's a retrieve
         # in the "install" method.  So, check the current state now,
         # to compare against later.
         current = self.retrieve
         begin
           provider.update
         rescue => detail
           self.fail "Could not update: #{detail}"
         end
 
         if current == :absent
           :package_installed
         else
           :package_changed
         end
       end
 
       newvalue(/./, :required_features => :versionable) do
         begin
           provider.install
         rescue => detail
           self.fail "Could not update: #{detail}"
         end
 
         if self.retrieve == :absent
           :package_installed
         else
           :package_changed
         end
       end
 
       defaultto :installed
 
       # Override the parent method, because we've got all kinds of
       # funky definitions of 'in sync'.
       def insync?(is)
         @latest ||= nil
         @lateststamp ||= (Time.now.to_i - 1000)
         # Iterate across all of the should values, and see how they
         # turn out.
 
         @should.each { |should|
           case should
           when :present
             return true unless [:absent, :purged, :held].include?(is)
           when :latest
             # Short-circuit packages that are not present
             return false if is == :absent or is == :purged
 
             # Don't run 'latest' more than about every 5 minutes
             if @latest and ((Time.now.to_i - @lateststamp) / 60) < 5
               #self.debug "Skipping latest check"
             else
               begin
                 @latest = provider.latest
                 @lateststamp = Time.now.to_i
               rescue => detail
                 error = Puppet::Error.new("Could not get latest version: #{detail}")
                 error.set_backtrace(detail.backtrace)
                 raise error
               end
             end
 
             case is
             when @latest
               return true
             when :present
               # This will only happen on retarded packaging systems
               # that can't query versions.
               return true
             else
               self.debug "#{@resource.name} #{is.inspect} is installed, latest is #{@latest.inspect}"
             end
           when :absent
             return true if is == :absent or is == :purged
           when :purged
             return true if is == :purged
           when is
             return true
           end
         }
 
         false
       end
 
       # This retrieves the current state. LAK: I think this method is unused.
       def retrieve
         provider.properties[:ensure]
       end
 
       # Provide a bit more information when logging upgrades.
       def should_to_s(newvalue = @should)
         if @latest
           @latest.to_s
         else
           super(newvalue)
         end
       end
     end
 
     newparam(:name) do
       desc "The package name.  This is the name that the packaging
       system uses internally, which is sometimes (especially on Solaris)
       a name that is basically useless to humans.  If you want to
       abstract package installation, then you can use aliases to provide
       a common name to packages:
 
           # In the 'openssl' class
           $ssl = $operatingsystem ? {
             solaris => SMCossl,
             default => openssl
           }
 
           # It is not an error to set an alias to the same value as the
           # object name.
           package { $ssl:
             ensure => installed,
             alias  => openssl
           }
 
           . etc. .
 
           $ssh = $operatingsystem ? {
             solaris => SMCossh,
             default => openssh
           }
 
           # Use the alias to specify a dependency, rather than
           # having another selector to figure it out again.
           package { $ssh:
             ensure  => installed,
             alias   => openssh,
             require => Package[openssl]
           }
 
       "
       isnamevar
     end
 
     newparam(:source) do
       desc "Where to find the actual package.  This must be a local file
         (or on a network file system) or a URL that your specific
         packaging type understands; Puppet will not retrieve files for you,
         although you can manage packages as `file` resources."
 
       validate do |value|
         provider.validate_source(value)
       end
     end
 
     newparam(:instance) do
       desc "A read-only parameter set by the package."
     end
 
     newparam(:status) do
       desc "A read-only parameter set by the package."
     end
 
     newparam(:type) do
       desc "Deprecated form of `provider`."
 
       munge do |value|
         warning "'type' is deprecated; use 'provider' instead"
         @resource[:provider] = value
 
         @resource[:provider]
       end
     end
 
     newparam(:adminfile) do
       desc "A file containing package defaults for installing packages.
         This is currently only used on Solaris.  The value will be
         validated according to system rules, which in the case of
         Solaris means that it should either be a fully qualified path
         or it should be in `/var/sadm/install/admin`."
     end
 
     newparam(:responsefile) do
       desc "A file containing any necessary answers to questions asked by
         the package.  This is currently used on Solaris and Debian.  The
         value will be validated according to system rules, but it should
         generally be a fully qualified path."
     end
 
     newparam(:configfiles) do
       desc "Whether configfiles should be kept or replaced.  Most packages
         types do not support this parameter. Defaults to `keep`."
 
       defaultto :keep
 
       newvalues(:keep, :replace)
     end
 
     newparam(:category) do
       desc "A read-only parameter set by the package."
     end
     newparam(:platform) do
       desc "A read-only parameter set by the package."
     end
     newparam(:root) do
       desc "A read-only parameter set by the package."
     end
     newparam(:vendor) do
       desc "A read-only parameter set by the package."
     end
     newparam(:description) do
       desc "A read-only parameter set by the package."
     end
 
     newparam(:allowcdrom) do
       desc "Tells apt to allow cdrom sources in the sources.list file.
         Normally apt will bail if you try this."
 
       newvalues(:true, :false)
     end
 
     newparam(:flavor) do
       desc "Newer versions of OpenBSD support 'flavors', which are
         further specifications for which type of package you want."
     end
 
     newparam(:install_options, :required_features => :install_options) do
       desc "A hash of options to be handled by the provider when
         installing a package."
     end
 
     autorequire(:file) do
       autos = []
       [:responsefile, :adminfile].each { |param|
         if val = self[param]
           autos << val
         end
       }
 
-      if source = self[:source]
-        if source =~ /^#{File::SEPARATOR}/
-          autos << source
-        end
+      if source = self[:source] and absolute_path?(source)
+        autos << source
       end
       autos
     end
 
     # This only exists for testing.
     def clear
       if obj = @parameters[:ensure]
         obj.latest = nil
       end
     end
 
     # The 'query' method returns a hash of info if the package
     # exists and returns nil if it does not.
     def exists?
       @provider.get(:ensure) != :absent
     end
   end
 end
diff --git a/lib/puppet/util.rb b/lib/puppet/util.rb
index 39b596434..82e3b27bb 100644
--- a/lib/puppet/util.rb
+++ b/lib/puppet/util.rb
@@ -1,522 +1,500 @@
 # A module to collect utility functions.
 
 require 'English'
 require 'puppet/util/monkey_patches'
 require 'sync'
 require 'tempfile'
 require 'puppet/external/lock'
 require 'monitor'
 require 'puppet/util/execution_stub'
 require 'uri'
 
 module Puppet
   # A command failed to execute.
   require 'puppet/error'
   class ExecutionFailure < Puppet::Error
   end
 module Util
   require 'benchmark'
 
   # These are all for backward compatibility -- these are methods that used
   # to be in Puppet::Util but have been moved into external modules.
   require 'puppet/util/posix'
   extend Puppet::Util::POSIX
 
   @@sync_objects = {}.extend MonitorMixin
 
   def self.activerecord_version
     if (defined?(::ActiveRecord) and defined?(::ActiveRecord::VERSION) and defined?(::ActiveRecord::VERSION::MAJOR) and defined?(::ActiveRecord::VERSION::MINOR))
       ([::ActiveRecord::VERSION::MAJOR, ::ActiveRecord::VERSION::MINOR].join('.').to_f)
     else
       0
     end
   end
 
   def self.synchronize_on(x,type)
     sync_object,users = 0,1
     begin
       @@sync_objects.synchronize {
         (@@sync_objects[x] ||= [Sync.new,0])[users] += 1
       }
       @@sync_objects[x][sync_object].synchronize(type) { yield }
     ensure
       @@sync_objects.synchronize {
         @@sync_objects.delete(x) unless (@@sync_objects[x][users] -= 1) > 0
       }
     end
   end
 
   # Change the process to a different user
   def self.chuser
     if group = Puppet[:group]
       begin
         Puppet::Util::SUIDManager.change_group(group, true)
       rescue => detail
         Puppet.warning "could not change to group #{group.inspect}: #{detail}"
         $stderr.puts "could not change to group #{group.inspect}"
 
         # Don't exit on failed group changes, since it's
         # not fatal
         #exit(74)
       end
     end
 
     if user = Puppet[:user]
       begin
         Puppet::Util::SUIDManager.change_user(user, true)
       rescue => detail
         $stderr.puts "Could not change to user #{user}: #{detail}"
         exit(74)
       end
     end
   end
 
   # Create instance methods for each of the log levels.  This allows
   # the messages to be a little richer.  Most classes will be calling this
   # method.
   def self.logmethods(klass, useself = true)
     Puppet::Util::Log.eachlevel { |level|
       klass.send(:define_method, level, proc { |args|
         args = args.join(" ") if args.is_a?(Array)
         if useself
 
           Puppet::Util::Log.create(
             :level => level,
             :source => self,
             :message => args
           )
         else
 
           Puppet::Util::Log.create(
             :level => level,
             :message => args
           )
         end
       })
     }
   end
 
   # Proxy a bunch of methods to another object.
   def self.classproxy(klass, objmethod, *methods)
     classobj = class << klass; self; end
     methods.each do |method|
       classobj.send(:define_method, method) do |*args|
         obj = self.send(objmethod)
 
         obj.send(method, *args)
       end
     end
   end
 
   # Proxy a bunch of methods to another object.
   def self.proxy(klass, objmethod, *methods)
     methods.each do |method|
       klass.send(:define_method, method) do |*args|
         obj = self.send(objmethod)
 
         obj.send(method, *args)
       end
     end
   end
 
-  # XXX this should all be done using puppet objects, not using
-  # normal mkdir
-  def self.recmkdir(dir,mode = 0755)
-    if FileTest.exist?(dir)
-      return false
-    else
-      tmp = dir.sub(/^\//,'')
-      path = [File::SEPARATOR]
-      tmp.split(File::SEPARATOR).each { |dir|
-        path.push dir
-        if ! FileTest.exist?(File.join(path))
-          Dir.mkdir(File.join(path), mode)
-        elsif FileTest.directory?(File.join(path))
-          next
-        else FileTest.exist?(File.join(path))
-          raise "Cannot create #{dir}: basedir #{File.join(path)} is a file"
-        end
-      }
-      return true
-    end
-  end
-
   # Execute a given chunk of code with a new umask.
   def self.withumask(mask)
     cur = File.umask(mask)
 
     begin
       yield
     ensure
       File.umask(cur)
     end
   end
 
   def benchmark(*args)
     msg = args.pop
     level = args.pop
     object = nil
 
     if args.empty?
       if respond_to?(level)
         object = self
       else
         object = Puppet
       end
     else
       object = args.pop
     end
 
     raise Puppet::DevError, "Failed to provide level to :benchmark" unless level
 
     unless level == :none or object.respond_to? level
       raise Puppet::DevError, "Benchmarked object does not respond to #{level}"
     end
 
     # Only benchmark if our log level is high enough
     if level != :none and Puppet::Util::Log.sendlevel?(level)
       result = nil
       seconds = Benchmark.realtime {
         yield
       }
       object.send(level, msg + (" in %0.2f seconds" % seconds))
       return seconds
     else
       yield
     end
   end
 
   def which(bin)
     if absolute_path?(bin)
       return bin if FileTest.file? bin and FileTest.executable? bin
     else
       ENV['PATH'].split(File::PATH_SEPARATOR).each do |dir|
         dest = File.expand_path(File.join(dir, bin))
         if Puppet.features.microsoft_windows? && File.extname(dest).empty?
           exts = ENV['PATHEXT']
           exts = exts ? exts.split(File::PATH_SEPARATOR) : %w[.COM .EXE .BAT .CMD]
           exts.each do |ext|
             destext = File.expand_path(dest + ext)
             return destext if FileTest.file? destext and FileTest.executable? destext
           end
         end
         return dest if FileTest.file? dest and FileTest.executable? dest
       end
     end
     nil
   end
   module_function :which
 
   # Determine in a platform-specific way whether a path is absolute. This
   # defaults to the local platform if none is specified.
   def absolute_path?(path, platform=nil)
     # Escape once for the string literal, and once for the regex.
     slash = '[\\\\/]'
     name = '[^\\\\/]+'
     regexes = {
       :windows => %r!^(([A-Z]:#{slash})|(#{slash}#{slash}#{name}#{slash}#{name})|(#{slash}#{slash}\?#{slash}#{name}))!i,
       :posix   => %r!^/!,
     }
     require 'puppet'
     platform ||= Puppet.features.microsoft_windows? ? :windows : :posix
 
     !! (path =~ regexes[platform])
   end
   module_function :absolute_path?
 
   # Convert a path to a file URI
   def path_to_uri(path)
     return unless path
 
     params = { :scheme => 'file' }
 
     if Puppet.features.microsoft_windows?
       path = path.gsub(/\\/, '/')
 
       if unc = /^\/\/([^\/]+)(\/[^\/]+)/.match(path)
         params[:host] = unc[1]
         path = unc[2]
       elsif path =~ /^[a-z]:\//i
         path = '/' + path
       end
     end
 
     params[:path] = URI.escape(path)
 
     begin
       URI::Generic.build(params)
     rescue => detail
       raise Puppet::Error, "Failed to convert '#{path}' to URI: #{detail}"
     end
   end
   module_function :path_to_uri
 
   # Get the path component of a URI
   def uri_to_path(uri)
     return unless uri.is_a?(URI)
 
     path = URI.unescape(uri.path)
 
     if Puppet.features.microsoft_windows? and uri.scheme == 'file'
       if uri.host
         path = "//#{uri.host}" + path # UNC
       else
         path.sub!(/^\//, '')
       end
     end
 
     path
   end
   module_function :uri_to_path
 
   # Execute the provided command in a pipe, yielding the pipe object.
   def execpipe(command, failonfail = true)
     if respond_to? :debug
       debug "Executing '#{command}'"
     else
       Puppet.debug "Executing '#{command}'"
     end
 
     command_str = command.respond_to?(:join) ? command.join('') : command
     output = open("| #{command_str} 2>&1") do |pipe|
       yield pipe
     end
 
     if failonfail
       unless $CHILD_STATUS == 0
         raise ExecutionFailure, output
       end
     end
 
     output
   end
 
   def execfail(command, exception)
       output = execute(command)
       return output
   rescue ExecutionFailure
       raise exception, output
   end
 
   def execute_posix(command, arguments, stdin, stdout, stderr)
     child_pid = Kernel.fork do
       # We can't just call Array(command), and rely on it returning
       # things like ['foo'], when passed ['foo'], because
       # Array(command) will call command.to_a internally, which when
       # given a string can end up doing Very Bad Things(TM), such as
       # turning "/tmp/foo;\r\n /bin/echo" into ["/tmp/foo;\r\n", " /bin/echo"]
       command = [command].flatten
       Process.setsid
       begin
         $stdin.reopen(stdin)
         $stdout.reopen(stdout)
         $stderr.reopen(stderr)
 
         3.upto(256){|fd| IO::new(fd).close rescue nil}
 
         Puppet::Util::SUIDManager.change_group(arguments[:gid], true) if arguments[:gid]
         Puppet::Util::SUIDManager.change_user(arguments[:uid], true)  if arguments[:uid]
 
         ENV['LANG'] = ENV['LC_ALL'] = ENV['LC_MESSAGES'] = ENV['LANGUAGE'] = 'C'
         Kernel.exec(*command)
       rescue => detail
         puts detail.to_s
         exit!(1)
       end
     end
     child_pid
   end
   module_function :execute_posix
 
   def execute_windows(command, arguments, stdin, stdout, stderr)
     command = command.map do |part|
       part.include?(' ') ? %Q["#{part.gsub(/"/, '\"')}"] : part
     end.join(" ") if command.is_a?(Array)
 
     process_info = Process.create( :command_line => command, :startup_info => {:stdin => stdin, :stdout => stdout, :stderr => stderr} )
     process_info.process_id
   end
   module_function :execute_windows
 
   # Execute the desired command, and return the status and output.
   # def execute(command, failonfail = true, uid = nil, gid = nil)
   # :combine sets whether or not to combine stdout/stderr in the output
   # :stdinfile sets a file that can be used for stdin. Passing a string
   # for stdin is not currently supported.
   def execute(command, arguments = {:failonfail => true, :combine => true})
     if command.is_a?(Array)
       command = command.flatten.map(&:to_s)
       str = command.join(" ")
     elsif command.is_a?(String)
       str = command
     end
 
     if respond_to? :debug
       debug "Executing '#{str}'"
     else
       Puppet.debug "Executing '#{str}'"
     end
 
     null_file = Puppet.features.microsoft_windows? ? 'NUL' : '/dev/null'
 
     stdin = File.open(arguments[:stdinfile] || null_file, 'r')
     stdout = arguments[:squelch] ? File.open(null_file, 'w') : Tempfile.new('puppet')
     stderr = arguments[:combine] ? stdout : File.open(null_file, 'w')
 
     exec_args = [command, arguments, stdin, stdout, stderr]
 
     if execution_stub = Puppet::Util::ExecutionStub.current_value
       return execution_stub.call(*exec_args)
     elsif Puppet.features.posix?
       child_pid = execute_posix(*exec_args)
       exit_status = Process.waitpid2(child_pid).last.exitstatus
     elsif Puppet.features.microsoft_windows?
       child_pid = execute_windows(*exec_args)
       exit_status = Process.waitpid2(child_pid).last
       # $CHILD_STATUS is not set when calling win32/process Process.create
       # and since it's read-only, we can't set it. But we can execute a
       # a shell that simply returns the desired exit status, which has the
       # desired effect.
       %x{#{ENV['COMSPEC']} /c exit #{exit_status}}
     end
 
     [stdin, stdout, stderr].each {|io| io.close rescue nil}
 
     # read output in if required
     unless arguments[:squelch]
       output = wait_for_output(stdout)
       Puppet.warning "Could not get output" unless output
     end
 
     if arguments[:failonfail] and exit_status != 0
       raise ExecutionFailure, "Execution of '#{str}' returned #{exit_status}: #{output}"
     end
 
     output
   end
 
   module_function :execute
 
   def wait_for_output(stdout)
     # Make sure the file's actually been written.  This is basically a race
     # condition, and is probably a horrible way to handle it, but, well, oh
     # well.
     2.times do |try|
       if File.exists?(stdout.path)
         output = stdout.open.read
 
         stdout.close(true)
 
         return output
       else
         time_to_sleep = try / 2.0
         Puppet.warning "Waiting for output; will sleep #{time_to_sleep} seconds"
         sleep(time_to_sleep)
       end
     end
     nil
   end
   module_function :wait_for_output
 
   # Create an exclusive lock.
   def threadlock(resource, type = Sync::EX)
     Puppet::Util.synchronize_on(resource,type) { yield }
   end
 
   # Because some modules provide their own version of this method.
   alias util_execute execute
 
   module_function :benchmark
 
   def memory
     unless defined?(@pmap)
       @pmap = which('pmap')
     end
     if @pmap
       %x{#{@pmap} #{Process.pid}| grep total}.chomp.sub(/^\s*total\s+/, '').sub(/K$/, '').to_i
     else
       0
     end
   end
 
   def symbolize(value)
     if value.respond_to? :intern
       value.intern
     else
       value
     end
   end
 
   def symbolizehash(hash)
     newhash = {}
     hash.each do |name, val|
       if name.is_a? String
         newhash[name.intern] = val
       else
         newhash[name] = val
       end
     end
   end
 
   def symbolizehash!(hash)
     hash.each do |name, val|
       if name.is_a? String
         hash[name.intern] = val
         hash.delete(name)
       end
     end
 
     hash
   end
   module_function :symbolize, :symbolizehash, :symbolizehash!
 
   # Just benchmark, with no logging.
   def thinmark
     seconds = Benchmark.realtime {
       yield
     }
 
     seconds
   end
 
   module_function :memory, :thinmark
 
   def secure_open(file,must_be_w,&block)
     raise Puppet::DevError,"secure_open only works with mode 'w'" unless must_be_w == 'w'
     raise Puppet::DevError,"secure_open only requires a block"    unless block_given?
     Puppet.warning "#{file} was a symlink to #{File.readlink(file)}" if File.symlink?(file)
     if File.exists?(file) or File.symlink?(file)
       wait = File.symlink?(file) ? 5.0 : 0.1
       File.delete(file)
       sleep wait # give it a chance to reappear, just in case someone is actively trying something.
     end
     begin
       File.open(file,File::CREAT|File::EXCL|File::TRUNC|File::WRONLY,&block)
     rescue Errno::EEXIST
       desc = File.symlink?(file) ? "symlink to #{File.readlink(file)}" : File.stat(file).ftype
       puts "Warning: #{file} was apparently created by another process (as"
       puts "a #{desc}) as soon as it was deleted by this process.  Someone may be trying"
       puts "to do something objectionable (such as tricking you into overwriting system"
       puts "files if you are running as root)."
       raise
     end
   end
   module_function :secure_open
 
   # Because IO#binread is only available in 1.9
   def binread(file)
     File.open(file, 'rb') { |f| f.read }
   end
   module_function :binread
 end
 end
 
 require 'puppet/util/errors'
 require 'puppet/util/methodhelper'
 require 'puppet/util/metaid'
 require 'puppet/util/classgen'
 require 'puppet/util/docs'
 require 'puppet/util/execution'
 require 'puppet/util/logging'
 require 'puppet/util/package'
 require 'puppet/util/warnings'
diff --git a/lib/puppet/util/log/destinations.rb b/lib/puppet/util/log/destinations.rb
index 5aaf7c782..0ba036cef 100644
--- a/lib/puppet/util/log/destinations.rb
+++ b/lib/puppet/util/log/destinations.rb
@@ -1,237 +1,239 @@
 Puppet::Util::Log.newdesttype :syslog do
   def self.suitable?(obj)
     Puppet.features.syslog?
   end
 
   def close
     Syslog.close
   end
 
   def initialize
     Syslog.close if Syslog.opened?
     name = Puppet[:name]
     name = "puppet-#{name}" unless name =~ /puppet/
 
     options = Syslog::LOG_PID | Syslog::LOG_NDELAY
 
     # XXX This should really be configurable.
     str = Puppet[:syslogfacility]
     begin
       facility = Syslog.const_get("LOG_#{str.upcase}")
     rescue NameError
       raise Puppet::Error, "Invalid syslog facility #{str}"
     end
 
     @syslog = Syslog.open(name, options, facility)
   end
 
   def handle(msg)
     # XXX Syslog currently has a bug that makes it so you
     # cannot log a message with a '%' in it.  So, we get rid
     # of them.
     if msg.source == "Puppet"
       @syslog.send(msg.level, msg.to_s.gsub("%", '%%'))
     else
       @syslog.send(msg.level, "(%s) %s" % [msg.source.to_s.gsub("%", ""),
           msg.to_s.gsub("%", '%%')
         ]
       )
     end
   end
 end
 
 Puppet::Util::Log.newdesttype :file do
+  require 'fileutils'
+
   def self.match?(obj)
     Puppet::Util.absolute_path?(obj)
   end
 
   def close
     if defined?(@file)
       @file.close
       @file = nil
     end
   end
 
   def flush
     @file.flush if defined?(@file)
   end
 
   attr_accessor :autoflush
 
   def initialize(path)
     @name = path
     # first make sure the directory exists
     # We can't just use 'Config.use' here, because they've
     # specified a "special" destination.
     unless FileTest.exist?(File.dirname(path))
-      Puppet.recmkdir(File.dirname(path))
+      FileUtils.mkdir_p(File.dirname(path), :mode => 0755)
       Puppet.info "Creating log directory #{File.dirname(path)}"
     end
 
     # create the log file, if it doesn't already exist
     file = File.open(path, File::WRONLY|File::CREAT|File::APPEND)
 
     @file = file
 
     @autoflush = Puppet[:autoflush]
   end
 
   def handle(msg)
     @file.puts("#{msg.time} #{msg.source} (#{msg.level}): #{msg}")
 
     @file.flush if @autoflush
   end
 end
 
 Puppet::Util::Log.newdesttype :console do
 
 
   RED     = {:console => "", :html => "FFA0A0"}
   GREEN   = {:console => "", :html => "00CD00"}
   YELLOW  = {:console => "", :html => "FFFF60"}
   BLUE    = {:console => "", :html => "80A0FF"}
   PURPLE  = {:console => "", :html => "FFA500"}
   CYAN    = {:console => "", :html => "40FFFF"}
   WHITE   = {:console => "", :html => "FFFFFF"}
   HRED    = {:console => "", :html => "FFA0A0"}
   HGREEN  = {:console => "", :html => "00CD00"}
   HYELLOW = {:console => "", :html => "FFFF60"}
   HBLUE   = {:console => "", :html => "80A0FF"}
   HPURPLE = {:console => "", :html => "FFA500"}
   HCYAN   = {:console => "", :html => "40FFFF"}
   HWHITE  = {:console => "", :html => "FFFFFF"}
   RESET   = {:console => "",    :html => ""      }
 
   Colormap = {
     :debug => WHITE,
     :info => GREEN,
     :notice => CYAN,
     :warning => YELLOW,
     :err => HPURPLE,
     :alert => RED,
     :emerg => HRED,
     :crit => HRED
   }
 
   def colorize(level, str)
     case Puppet[:color]
     when true, :ansi, "ansi", "yes"; console_color(level, str)
     when :html, "html"; html_color(level, str)
     else
       str
     end
   end
 
   def console_color(level, str)
     Colormap[level][:console] + str + RESET[:console]
   end
 
   def html_color(level, str)
     %{<span style="color: %s">%s</span>} % [Colormap[level][:html], str]
   end
 
   def initialize
     # Flush output immediately.
     $stdout.sync = true
   end
 
   def handle(msg)
     if msg.source == "Puppet"
       puts colorize(msg.level, "#{msg.level}: #{msg}")
     else
       puts colorize(msg.level, "#{msg.level}: #{msg.source}: #{msg}")
     end
   end
 end
 
 Puppet::Util::Log.newdesttype :host do
   def initialize(host)
     Puppet.info "Treating #{host} as a hostname"
     args = {}
     if host =~ /:(\d+)/
       args[:Port] = $1
       args[:Server] = host.sub(/:\d+/, '')
     else
       args[:Server] = host
     end
 
     @name = host
 
     @driver = Puppet::Network::Client::LogClient.new(args)
   end
 
   def handle(msg)
     unless msg.is_a?(String) or msg.remote
       @hostname ||= Facter["hostname"].value
       unless defined?(@domain)
         @domain = Facter["domain"].value
         @hostname += ".#{@domain}" if @domain
       end
-      if msg.source =~ /^\//
+      if Puppet::Util.absolute_path?(msg.source)
         msg.source = @hostname + ":#{msg.source}"
       elsif msg.source == "Puppet"
         msg.source = @hostname + " #{msg.source}"
       else
         msg.source = @hostname + " #{msg.source}"
       end
       begin
         #puts "would have sent #{msg}"
         #puts "would have sent %s" %
         #    CGI.escape(YAML.dump(msg))
         begin
           tmp = CGI.escape(YAML.dump(msg))
         rescue => detail
           puts "Could not dump: #{detail}"
           return
         end
         # Add the hostname to the source
         @driver.addlog(tmp)
       rescue => detail
         puts detail.backtrace if Puppet[:trace]
         Puppet.err detail
         Puppet::Util::Log.close(self)
       end
     end
   end
 end
 
 # Log to a transaction report.
 Puppet::Util::Log.newdesttype :report do
   attr_reader :report
 
   match "Puppet::Transaction::Report"
 
   def initialize(report)
     @report = report
   end
 
   def handle(msg)
     @report << msg
   end
 end
 
 # Log to an array, just for testing.
 module Puppet::Test
   class LogCollector
     def initialize(logs)
       @logs = logs
     end
 
     def <<(value)
       @logs << value
     end
   end
 end
 
 Puppet::Util::Log.newdesttype :array do
   match "Puppet::Test::LogCollector"
 
   def initialize(messages)
     @messages = messages
   end
 
   def handle(msg)
     @messages << msg
   end
 end
 
diff --git a/spec/unit/file_serving/base_spec.rb b/spec/unit/file_serving/base_spec.rb
index 17d59460e..91e6962e5 100755
--- a/spec/unit/file_serving/base_spec.rb
+++ b/spec/unit/file_serving/base_spec.rb
@@ -1,131 +1,130 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 require 'puppet/file_serving/base'
 
 describe Puppet::FileServing::Base do
+  let(:path) { File.expand_path('/module/dir/file') }
+  let(:file) { File.expand_path('/my/file') }
+
   it "should accept a path" do
-    Puppet::FileServing::Base.new("/module/dir/file").path.should == "/module/dir/file"
+    Puppet::FileServing::Base.new(path).path.should == path
   end
 
   it "should require that paths be fully qualified" do
     lambda { Puppet::FileServing::Base.new("module/dir/file") }.should raise_error(ArgumentError)
   end
 
   it "should allow specification of whether links should be managed" do
-    Puppet::FileServing::Base.new("/module/dir/file", :links => :manage).links.should == :manage
+    Puppet::FileServing::Base.new(path, :links => :manage).links.should == :manage
   end
 
   it "should have a :source attribute" do
-    file = Puppet::FileServing::Base.new("/module/dir/file")
+    file = Puppet::FileServing::Base.new(path)
     file.should respond_to(:source)
     file.should respond_to(:source=)
   end
 
   it "should consider :ignore links equivalent to :manage links" do
-    Puppet::FileServing::Base.new("/module/dir/file", :links => :ignore).links.should == :manage
+    Puppet::FileServing::Base.new(path, :links => :ignore).links.should == :manage
   end
 
   it "should fail if :links is set to anything other than :manage, :follow, or :ignore" do
-    proc { Puppet::FileServing::Base.new("/module/dir/file", :links => :else) }.should raise_error(ArgumentError)
+    proc { Puppet::FileServing::Base.new(path, :links => :else) }.should raise_error(ArgumentError)
   end
 
   it "should allow links values to be set as strings" do
-    Puppet::FileServing::Base.new("/module/dir/file", :links => "follow").links.should == :follow
+    Puppet::FileServing::Base.new(path, :links => "follow").links.should == :follow
   end
 
   it "should default to :manage for :links" do
-    Puppet::FileServing::Base.new("/module/dir/file").links.should == :manage
+    Puppet::FileServing::Base.new(path).links.should == :manage
   end
 
   it "should allow specification of a path" do
     FileTest.stubs(:exists?).returns(true)
-    Puppet::FileServing::Base.new("/module/dir/file", :path => "/my/file").path.should == "/my/file"
+    Puppet::FileServing::Base.new(path, :path => file).path.should == file
   end
 
   it "should allow specification of a relative path" do
     FileTest.stubs(:exists?).returns(true)
-    Puppet::FileServing::Base.new("/module/dir/file", :relative_path => "my/file").relative_path.should == "my/file"
+    Puppet::FileServing::Base.new(path, :relative_path => "my/file").relative_path.should == "my/file"
   end
 
   it "should have a means of determining if the file exists" do
-    Puppet::FileServing::Base.new("/blah").should respond_to(:exist?)
+    Puppet::FileServing::Base.new(file).should respond_to(:exist?)
   end
 
   it "should correctly indicate if the file is present" do
-    File.expects(:lstat).with("/my/file").returns(mock("stat"))
-    Puppet::FileServing::Base.new("/my/file").exist?.should be_true
+    File.expects(:lstat).with(file).returns(mock("stat"))
+    Puppet::FileServing::Base.new(file).exist?.should be_true
   end
 
   it "should correctly indicate if the file is absent" do
-    File.expects(:lstat).with("/my/file").raises RuntimeError
-    Puppet::FileServing::Base.new("/my/file").exist?.should be_false
+    File.expects(:lstat).with(file).raises RuntimeError
+    Puppet::FileServing::Base.new(file).exist?.should be_false
   end
 
   describe "when setting the relative path" do
     it "should require that the relative path be unqualified" do
-      @file = Puppet::FileServing::Base.new("/module/dir/file")
+      @file = Puppet::FileServing::Base.new(path)
       FileTest.stubs(:exists?).returns(true)
-      proc { @file.relative_path = "/qualified/file" }.should raise_error(ArgumentError)
+      proc { @file.relative_path = File.expand_path("/qualified/file") }.should raise_error(ArgumentError)
     end
   end
 
   describe "when determining the full file path" do
-    before do
-      @file = Puppet::FileServing::Base.new("/this/file")
-    end
+    let(:path) { File.expand_path('/this/file') }
+    let(:file) { Puppet::FileServing::Base.new(path) }
 
     it "should return the path if there is no relative path" do
-      @file.full_path.should == "/this/file"
+      file.full_path.should == path
     end
 
     it "should return the path if the relative_path is set to ''" do
-      @file.relative_path = ""
-      @file.full_path.should == "/this/file"
+      file.relative_path = ""
+      file.full_path.should == path
     end
 
     it "should return the path if the relative_path is set to '.'" do
-      @file.relative_path = "."
-      @file.full_path.should == "/this/file"
+      file.relative_path = "."
+      file.full_path.should == path
     end
 
     it "should return the path joined with the relative path if there is a relative path and it is not set to '/' or ''" do
-      @file.relative_path = "not/qualified"
-      @file.full_path.should == "/this/file/not/qualified"
+      file.relative_path = "not/qualified"
+      file.full_path.should == File.join(path, "not/qualified")
     end
 
     it "should strip extra slashes" do
-      file = Puppet::FileServing::Base.new("//this//file")
-      file.full_path.should == "/this/file"
+      file = Puppet::FileServing::Base.new(File.join(File.expand_path('/'), "//this//file"))
+      file.full_path.should == path
     end
   end
 
   describe "when stat'ing files" do
-    before do
-      @file = Puppet::FileServing::Base.new("/this/file")
-    end
+    let(:path) { File.expand_path('/this/file') }
+    let(:file) { Puppet::FileServing::Base.new(path) }
 
     it "should stat the file's full path" do
-      @file.stubs(:full_path).returns("/this/file")
-      File.expects(:lstat).with("/this/file").returns stub("stat", :ftype => "file")
-      @file.stat
+      File.expects(:lstat).with(path).returns stub("stat", :ftype => "file")
+      file.stat
     end
 
     it "should fail if the file does not exist" do
-      @file.stubs(:full_path).returns("/this/file")
-      File.expects(:lstat).with("/this/file").raises(Errno::ENOENT)
-      proc { @file.stat }.should raise_error(Errno::ENOENT)
+      File.expects(:lstat).with(path).raises(Errno::ENOENT)
+      proc { file.stat }.should raise_error(Errno::ENOENT)
     end
 
     it "should use :lstat if :links is set to :manage" do
-      File.expects(:lstat).with("/this/file").returns stub("stat", :ftype => "file")
-      @file.stat
+      File.expects(:lstat).with(path).returns stub("stat", :ftype => "file")
+      file.stat
     end
 
     it "should use :stat if :links is set to :follow" do
-      File.expects(:stat).with("/this/file").returns stub("stat", :ftype => "file")
-      @file.links = :follow
-      @file.stat
+      File.expects(:stat).with(path).returns stub("stat", :ftype => "file")
+      file.links = :follow
+      file.stat
     end
   end
 end
diff --git a/spec/unit/file_serving/content_spec.rb b/spec/unit/file_serving/content_spec.rb
index c1627c18f..99295e1ba 100755
--- a/spec/unit/file_serving/content_spec.rb
+++ b/spec/unit/file_serving/content_spec.rb
@@ -1,117 +1,117 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 require 'puppet/file_serving/content'
 
 describe Puppet::FileServing::Content do
+  let(:path) { File.expand_path('/path') }
+
   it "should should be a subclass of Base" do
     Puppet::FileServing::Content.superclass.should equal(Puppet::FileServing::Base)
   end
 
   it "should indirect file_content" do
     Puppet::FileServing::Content.indirection.name.should == :file_content
   end
 
   it "should should include the IndirectionHooks module in its indirection" do
     Puppet::FileServing::Content.indirection.singleton_class.included_modules.should include(Puppet::FileServing::IndirectionHooks)
   end
 
   it "should only support the raw format" do
     Puppet::FileServing::Content.supported_formats.should == [:raw]
   end
 
   it "should have a method for collecting its attributes" do
-    Puppet::FileServing::Content.new("/path").should respond_to(:collect)
+    Puppet::FileServing::Content.new(path).should respond_to(:collect)
   end
 
   it "should not retrieve and store its contents when its attributes are collected if the file is a normal file" do
-    content = Puppet::FileServing::Content.new("/path")
+    content = Puppet::FileServing::Content.new(path)
 
     result = "foo"
     File.stubs(:lstat).returns(stub("stat", :ftype => "file"))
-    File.expects(:read).with("/path").never
+    File.expects(:read).with(path).never
     content.collect
 
     content.instance_variable_get("@content").should be_nil
   end
 
   it "should not attempt to retrieve its contents if the file is a directory" do
-    content = Puppet::FileServing::Content.new("/path")
+    content = Puppet::FileServing::Content.new(path)
 
     result = "foo"
     File.stubs(:lstat).returns(stub("stat", :ftype => "directory"))
-    File.expects(:read).with("/path").never
+    File.expects(:read).with(path).never
     content.collect
 
     content.instance_variable_get("@content").should be_nil
   end
 
   it "should have a method for setting its content" do
-    content = Puppet::FileServing::Content.new("/path")
+    content = Puppet::FileServing::Content.new(path)
     content.should respond_to(:content=)
   end
 
   it "should make content available when set externally" do
-    content = Puppet::FileServing::Content.new("/path")
+    content = Puppet::FileServing::Content.new(path)
     content.content = "foo/bar"
     content.content.should == "foo/bar"
   end
 
   it "should be able to create a content instance from raw file contents" do
     Puppet::FileServing::Content.should respond_to(:from_raw)
   end
 
   it "should create an instance with a fake file name and correct content when converting from raw" do
     instance = mock 'instance'
     Puppet::FileServing::Content.expects(:new).with("/this/is/a/fake/path").returns instance
 
     instance.expects(:content=).with "foo/bar"
 
     Puppet::FileServing::Content.from_raw("foo/bar").should equal(instance)
   end
 
   it "should return an opened File when converted to raw" do
-    content = Puppet::FileServing::Content.new("/path")
+    content = Puppet::FileServing::Content.new(path)
 
-    File.expects(:new).with("/path","rb").returns :file
+    File.expects(:new).with(path, "rb").returns :file
 
     content.to_raw.should == :file
   end
 end
 
 describe Puppet::FileServing::Content, "when returning the contents" do
-  before do
-    @path = "/my/path"
-    @content = Puppet::FileServing::Content.new(@path, :links => :follow)
-  end
+  let(:path) { File.expand_path('/my/path') }
+  let(:content) { Puppet::FileServing::Content.new(path, :links => :follow) }
 
   it "should fail if the file is a symlink and links are set to :manage" do
-    @content.links = :manage
-    File.expects(:lstat).with(@path).returns stub("stat", :ftype => "symlink")
-    proc { @content.content }.should raise_error(ArgumentError)
+    content.links = :manage
+    File.expects(:lstat).with(path).returns stub("stat", :ftype => "symlink")
+    proc { content.content }.should raise_error(ArgumentError)
   end
 
   it "should fail if a path is not set" do
-    proc { @content.content }.should raise_error(Errno::ENOENT)
+    proc { content.content }.should raise_error(Errno::ENOENT)
   end
 
   it "should raise Errno::ENOENT if the file is absent" do
-    @content.path = "/there/is/absolutely/no/chance/that/this/path/exists"
-    proc { @content.content }.should raise_error(Errno::ENOENT)
+    content.path = File.expand_path("/there/is/absolutely/no/chance/that/this/path/exists")
+    proc { content.content }.should raise_error(Errno::ENOENT)
   end
 
   it "should return the contents of the path if the file exists" do
-    File.expects(:stat).with(@path).returns stub("stat", :ftype => "file")
-    Puppet::Util.expects(:binread).with(@path).returns(:mycontent)
-    @content.content.should == :mycontent
+    File.expects(:stat).with(path).returns stub("stat", :ftype => "file")
+    Puppet::Util.expects(:binread).with(path).returns(:mycontent)
+    content.content.should == :mycontent
   end
 
   it "should cache the returned contents" do
-    File.expects(:stat).with(@path).returns stub("stat", :ftype => "file")
-    Puppet::Util.expects(:binread).with(@path).returns(:mycontent)
-    @content.content
+    File.expects(:stat).with(path).returns stub("stat", :ftype => "file")
+    Puppet::Util.expects(:binread).with(path).returns(:mycontent)
+    content.content
 
     # The second run would throw a failure if the content weren't being cached.
-    @content.content
+    content.content
   end
 end
diff --git a/spec/unit/file_serving/metadata_spec.rb b/spec/unit/file_serving/metadata_spec.rb
index 3842b05bc..b458c1292 100755
--- a/spec/unit/file_serving/metadata_spec.rb
+++ b/spec/unit/file_serving/metadata_spec.rb
@@ -1,356 +1,357 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 require 'puppet/file_serving/metadata'
 
 describe Puppet::FileServing::Metadata do
+  let(:foobar) { File.expand_path('/foo/bar') }
+
   it "should should be a subclass of Base" do
     Puppet::FileServing::Metadata.superclass.should equal(Puppet::FileServing::Base)
   end
 
   it "should indirect file_metadata" do
     Puppet::FileServing::Metadata.indirection.name.should == :file_metadata
   end
 
   it "should should include the IndirectionHooks module in its indirection" do
     Puppet::FileServing::Metadata.indirection.singleton_class.included_modules.should include(Puppet::FileServing::IndirectionHooks)
   end
 
   it "should have a method that triggers attribute collection" do
-    Puppet::FileServing::Metadata.new("/foo/bar").should respond_to(:collect)
+    Puppet::FileServing::Metadata.new(foobar).should respond_to(:collect)
   end
 
   it "should support pson serialization" do
-    Puppet::FileServing::Metadata.new("/foo/bar").should respond_to(:to_pson)
+    Puppet::FileServing::Metadata.new(foobar).should respond_to(:to_pson)
   end
 
   it "should support to_pson_data_hash" do
-    Puppet::FileServing::Metadata.new("/foo/bar").should respond_to(:to_pson_data_hash)
+    Puppet::FileServing::Metadata.new(foobar).should respond_to(:to_pson_data_hash)
   end
 
   it "should support pson deserialization" do
     Puppet::FileServing::Metadata.should respond_to(:from_pson)
   end
 
   describe "when serializing" do
-    before do
-      @metadata = Puppet::FileServing::Metadata.new("/foo/bar")
-    end
+    let(:metadata) { Puppet::FileServing::Metadata.new(foobar) }
+
     it "should perform pson serialization by calling to_pson on it's pson_data_hash" do
       pdh = mock "data hash"
       pdh_as_pson = mock "data as pson"
-      @metadata.expects(:to_pson_data_hash).returns pdh
+      metadata.expects(:to_pson_data_hash).returns pdh
       pdh.expects(:to_pson).returns pdh_as_pson
-      @metadata.to_pson.should == pdh_as_pson
+      metadata.to_pson.should == pdh_as_pson
     end
 
     it "should serialize as FileMetadata" do
-      @metadata.to_pson_data_hash['document_type'].should == "FileMetadata"
+      metadata.to_pson_data_hash['document_type'].should == "FileMetadata"
     end
 
     it "the data should include the path, relative_path, links, owner, group, mode, checksum, type, and destination" do
-      @metadata.to_pson_data_hash['data'].keys.sort.should == %w{ path relative_path links owner group mode checksum type destination }.sort
+      metadata.to_pson_data_hash['data'].keys.sort.should == %w{ path relative_path links owner group mode checksum type destination }.sort
     end
 
     it "should pass the path in the hash verbatum" do
-      @metadata.to_pson_data_hash['data']['path'] == @metadata.path
+      metadata.to_pson_data_hash['data']['path'] == metadata.path
     end
 
     it "should pass the relative_path in the hash verbatum" do
-      @metadata.to_pson_data_hash['data']['relative_path'] == @metadata.relative_path
+      metadata.to_pson_data_hash['data']['relative_path'] == metadata.relative_path
     end
 
     it "should pass the links in the hash verbatum" do
-      @metadata.to_pson_data_hash['data']['links'] == @metadata.links
+      metadata.to_pson_data_hash['data']['links'] == metadata.links
     end
 
     it "should pass the path owner in the hash verbatum" do
-      @metadata.to_pson_data_hash['data']['owner'] == @metadata.owner
+      metadata.to_pson_data_hash['data']['owner'] == metadata.owner
     end
 
     it "should pass the group in the hash verbatum" do
-      @metadata.to_pson_data_hash['data']['group'] == @metadata.group
+      metadata.to_pson_data_hash['data']['group'] == metadata.group
     end
 
     it "should pass the mode in the hash verbatum" do
-      @metadata.to_pson_data_hash['data']['mode'] == @metadata.mode
+      metadata.to_pson_data_hash['data']['mode'] == metadata.mode
     end
 
     it "should pass the ftype in the hash verbatum as the 'type'" do
-      @metadata.to_pson_data_hash['data']['type'] == @metadata.ftype
+      metadata.to_pson_data_hash['data']['type'] == metadata.ftype
     end
 
     it "should pass the destination verbatum" do
-      @metadata.to_pson_data_hash['data']['destination'] == @metadata.destination
+      metadata.to_pson_data_hash['data']['destination'] == metadata.destination
     end
 
     it "should pass the checksum in the hash as a nested hash" do
-      @metadata.to_pson_data_hash['data']['checksum'].should be_is_a(Hash)
+      metadata.to_pson_data_hash['data']['checksum'].should be_is_a(Hash)
     end
 
     it "should pass the checksum_type in the hash verbatum as the checksum's type" do
-      @metadata.to_pson_data_hash['data']['checksum']['type'] == @metadata.checksum_type
+      metadata.to_pson_data_hash['data']['checksum']['type'] == metadata.checksum_type
     end
 
     it "should pass the checksum in the hash verbatum as the checksum's value" do
-      @metadata.to_pson_data_hash['data']['checksum']['value'] == @metadata.checksum
+      metadata.to_pson_data_hash['data']['checksum']['value'] == metadata.checksum
     end
 
   end
 end
 
 describe Puppet::FileServing::Metadata do
   include PuppetSpec::Files
 
   shared_examples_for "metadata collector" do
     let(:metadata) do
       data = described_class.new(path)
       data.collect
       data
     end
 
     describe "when collecting attributes" do
       describe "when managing files" do
         let(:path) { tmpfile('file_serving_metadata') }
 
         before :each do
           FileUtils.touch(path)
         end
 
         it "should be able to produce xmlrpc-style attribute information" do
           metadata.should respond_to(:attributes_with_tabs)
         end
 
         it "should set the owner to the file's current owner" do
           metadata.owner.should == owner
         end
 
         it "should set the group to the file's current group" do
           metadata.group.should == group
         end
 
         it "should set the mode to the file's masked mode" do
           set_mode(33261, path)
 
           metadata.mode.should == 0755
         end
 
         describe "#checksum" do
           let(:checksum) { Digest::MD5.hexdigest("some content\n") }
 
           before :each do
             File.open(path, "wb") {|f| f.print("some content\n")}
           end
 
           it "should default to a checksum of type MD5 with the file's current checksum" do
             metadata.checksum.should == "{md5}#{checksum}"
           end
 
           it "should give a mtime checksum when checksum_type is set" do
             time = Time.now
             metadata.checksum_type = "mtime"
             metadata.expects(:mtime_file).returns(@time)
             metadata.collect
             metadata.checksum.should == "{mtime}#{@time}"
           end
 
           it "should produce tab-separated mode, type, owner, group, and checksum for xmlrpc" do
             set_mode(0755, path)
 
             metadata.attributes_with_tabs.should == "#{0755.to_s}\tfile\t#{owner}\t#{group}\t{md5}#{checksum}"
           end
         end
       end
 
       describe "when managing directories" do
         let(:path) { tmpdir('file_serving_metadata_dir') }
         let(:time) { Time.now }
 
         before :each do
           metadata.expects(:ctime_file).returns(time)
         end
 
         it "should only use checksums of type 'ctime' for directories" do
           metadata.collect
           metadata.checksum.should == "{ctime}#{time}"
         end
 
         it "should only use checksums of type 'ctime' for directories even if checksum_type set" do
           metadata.checksum_type = "mtime"
           metadata.expects(:mtime_file).never
           metadata.collect
           metadata.checksum.should == "{ctime}#{time}"
         end
 
         it "should produce tab-separated mode, type, owner, group, and checksum for xmlrpc" do
           set_mode(0755, path)
           metadata.collect
 
           metadata.attributes_with_tabs.should == "#{0755.to_s}\tdirectory\t#{owner}\t#{group}\t{ctime}#{time.to_s}"
         end
       end
 
       describe "when managing links", :unless => Puppet.features.microsoft_windows? do
         # 'path' is a link that points to 'target'
         let(:path) { tmpfile('file_serving_metadata_link') }
         let(:target) { tmpfile('file_serving_metadata_target') }
         let(:checksum) { Digest::MD5.hexdigest("some content\n") }
         let(:fmode) { File.lstat(path).mode & 0777 }
 
         before :each do
           File.open(target, "wb") {|f| f.print("some content\n")}
           set_mode(0644, target)
 
           FileUtils.symlink(target, path)
         end
 
         it "should read links instead of returning their checksums" do
           metadata.destination.should == target
         end
 
         pending "should produce tab-separated mode, type, owner, group, and destination for xmlrpc" do
           # "We'd like this to be true, but we need to always collect the checksum because in the server/client/server round trip we lose the distintion between manage and follow."
           metadata.attributes_with_tabs.should == "#{0755}\tlink\t#{owner}\t#{group}\t#{target}"
         end
 
         it "should produce tab-separated mode, type, owner, group, checksum, and destination for xmlrpc" do
           metadata.attributes_with_tabs.should == "#{fmode}\tlink\t#{owner}\t#{group}\t{md5}eb9c2bf0eb63f3a7bc0ea37ef18aeba5\t#{target}"
         end
       end
     end
 
     describe Puppet::FileServing::Metadata, " when finding the file to use for setting attributes" do
       let(:path) { tmpfile('file_serving_metadata_find_file') }
 
       before :each do
         File.open(path, "wb") {|f| f.print("some content\n")}
         set_mode(0755, path)
       end
 
       it "should accept a base path to which the file should be relative" do
         dir = tmpdir('metadata_dir')
         metadata = described_class.new(dir)
         metadata.relative_path = 'relative_path'
 
         FileUtils.touch(metadata.full_path)
 
         metadata.collect
       end
 
       it "should use the set base path if one is not provided" do
         metadata.collect
       end
 
       it "should raise an exception if the file does not exist" do
         File.delete(path)
 
         proc { metadata.collect}.should raise_error(Errno::ENOENT)
       end
     end
   end
 
   describe "on POSIX systems", :if => Puppet.features.posix? do
     let(:owner) {10}
     let(:group) {20}
 
     before :each do
       File::Stat.any_instance.stubs(:uid).returns owner
       File::Stat.any_instance.stubs(:gid).returns group
     end
 
     it_should_behave_like "metadata collector"
 
     def set_mode(mode, path)
       File.chmod(mode, path)
     end
   end
 
   describe "on Windows systems", :if => Puppet.features.microsoft_windows? do
     let(:owner) {'S-1-1-50'}
     let(:group) {'S-1-1-51'}
 
     before :each do
       require 'puppet/util/windows/security'
       Puppet::Util::Windows::Security.stubs(:get_owner).returns owner
       Puppet::Util::Windows::Security.stubs(:get_group).returns group
     end
 
     it_should_behave_like "metadata collector"
 
     describe "if ACL metadata cannot be collected" do
       let(:path) { tmpdir('file_serving_metadata_acl') }
       let(:metadata) do
         data = described_class.new(path)
         data.collect
         data
       end
 
       it "should default owner" do
         Puppet::Util::Windows::Security.stubs(:get_owner).returns nil
 
         metadata.owner.should == 'S-1-5-32-544'
       end
 
       it "should default group" do
         Puppet::Util::Windows::Security.stubs(:get_group).returns nil
 
         metadata.group.should == 'S-1-0-0'
       end
 
       it "should default mode" do
         Puppet::Util::Windows::Security.stubs(:get_mode).returns nil
 
         metadata.mode.should == 0644
       end
     end
 
     def set_mode(mode, path)
       Puppet::Util::Windows::Security.set_mode(mode, path)
     end
   end
 end
 
 
 describe Puppet::FileServing::Metadata, " when pointing to a link", :unless => Puppet.features.microsoft_windows? do
   describe "when links are managed" do
     before do
       @file = Puppet::FileServing::Metadata.new("/base/path/my/file", :links => :manage)
       File.expects(:lstat).with("/base/path/my/file").returns stub("stat", :uid => 1, :gid => 2, :ftype => "link", :mode => 0755)
       File.expects(:readlink).with("/base/path/my/file").returns "/some/other/path"
 
       @checksum = Digest::MD5.hexdigest("some content\n") # Remove these when :managed links are no longer checksumed.
       @file.stubs(:md5_file).returns(@checksum)           #
     end
     it "should store the destination of the link in :destination if links are :manage" do
       @file.collect
       @file.destination.should == "/some/other/path"
     end
     pending "should not collect the checksum if links are :manage" do
       # We'd like this to be true, but we need to always collect the checksum because in the server/client/server round trip we lose the distintion between manage and follow.
       @file.collect
       @file.checksum.should be_nil
     end
     it "should collect the checksum if links are :manage" do # see pending note above
       @file.collect
       @file.checksum.should == "{md5}#{@checksum}"
     end
   end
 
   describe "when links are followed" do
     before do
       @file = Puppet::FileServing::Metadata.new("/base/path/my/file", :links => :follow)
       File.expects(:stat).with("/base/path/my/file").returns stub("stat", :uid => 1, :gid => 2, :ftype => "file", :mode => 0755)
       File.expects(:readlink).with("/base/path/my/file").never
       @checksum = Digest::MD5.hexdigest("some content\n")
       @file.stubs(:md5_file).returns(@checksum)
     end
     it "should not store the destination of the link in :destination if links are :follow" do
       @file.collect
       @file.destination.should be_nil
     end
     it "should collect the checksum if links are :follow" do
       @file.collect
       @file.checksum.should == "{md5}#{@checksum}"
     end
   end
 end
diff --git a/spec/unit/indirector/exec_spec.rb b/spec/unit/indirector/exec_spec.rb
index 87778cdeb..45a087abf 100755
--- a/spec/unit/indirector/exec_spec.rb
+++ b/spec/unit/indirector/exec_spec.rb
@@ -1,54 +1,56 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 require 'puppet/indirector/exec'
 
 describe Puppet::Indirector::Exec do
   before :all do
     @indirection = stub 'indirection', :name => :testing
     Puppet::Indirector::Indirection.expects(:instance).with(:testing).returns(@indirection)
     module Testing; end
     @exec_class = class Testing::MyTesting < Puppet::Indirector::Exec
       attr_accessor :command
       self
     end
   end
 
+  let(:path) { File.expand_path('/echo') }
+
   before :each do
     @searcher = @exec_class.new
-    @searcher.command = ["/echo"]
+    @searcher.command = [path]
 
     @request = stub 'request', :key => "foo"
   end
 
   it "should throw an exception if the command is not an array" do
-    @searcher.command = "/usr/bin/echo"
+    @searcher.command = path
     proc { @searcher.find(@request) }.should raise_error(Puppet::DevError)
   end
 
   it "should throw an exception if the command is not fully qualified" do
     @searcher.command = ["mycommand"]
     proc { @searcher.find(@request) }.should raise_error(ArgumentError)
   end
 
   it "should execute the command with the object name as the only argument" do
-    @searcher.expects(:execute).with(%w{/echo foo}, :combine => false)
+    @searcher.expects(:execute).with([path, 'foo'], :combine => false)
     @searcher.find(@request)
   end
 
   it "should return the output of the script" do
-    @searcher.expects(:execute).with(%w{/echo foo}, :combine => false).returns("whatever")
+    @searcher.expects(:execute).with([path, 'foo'], :combine => false).returns("whatever")
     @searcher.find(@request).should == "whatever"
   end
 
   it "should return nil when the command produces no output" do
-    @searcher.expects(:execute).with(%w{/echo foo}, :combine => false).returns(nil)
+    @searcher.expects(:execute).with([path, 'foo'], :combine => false).returns(nil)
     @searcher.find(@request).should be_nil
   end
 
   it "should raise an exception if there's an execution failure" do
-    @searcher.expects(:execute).with(%w{/echo foo}, :combine => false).raises(Puppet::ExecutionFailure.new("message"))
+    @searcher.expects(:execute).with([path, 'foo'], :combine => false).raises(Puppet::ExecutionFailure.new("message"))
 
     lambda {@searcher.find(@request)}.should raise_exception(Puppet::Error, 'Failed to find foo via exec: message')
   end
 end
diff --git a/spec/unit/indirector/node/exec_spec.rb b/spec/unit/indirector/node/exec_spec.rb
index 1dbfcd13a..79f325129 100755
--- a/spec/unit/indirector/node/exec_spec.rb
+++ b/spec/unit/indirector/node/exec_spec.rb
@@ -1,69 +1,69 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 require 'puppet/indirector/node/exec'
 
 describe Puppet::Node::Exec do
   before do
     @indirection = mock 'indirection'
-    Puppet.settings.stubs(:value).with(:external_nodes).returns("/echo")
+    Puppet.settings.stubs(:value).with(:external_nodes).returns(File.expand_path("/echo"))
     @searcher = Puppet::Node::Exec.new
   end
 
   describe "when constructing the command to run" do
     it "should use the external_node script as the command" do
       Puppet.expects(:[]).with(:external_nodes).returns("/bin/echo")
       @searcher.command.should == %w{/bin/echo}
     end
 
     it "should throw an exception if no external node command is set" do
       Puppet.expects(:[]).with(:external_nodes).returns("none")
       proc { @searcher.find(stub('request', :key => "foo")) }.should raise_error(ArgumentError)
     end
   end
 
   describe "when handling the results of the command" do
     before do
       @name = "yay"
       @node = Puppet::Node.new(@name)
       @node.stubs(:fact_merge)
       Puppet::Node.expects(:new).with(@name).returns(@node)
       @result = {}
       # Use a local variable so the reference is usable in the execute definition.
       result = @result
       @searcher.meta_def(:execute) do |command, arguments|
         return YAML.dump(result)
       end
 
       @request = stub 'request', :key => @name
     end
 
     it "should translate the YAML into a Node instance" do
       # Use an empty hash
       @searcher.find(@request).should equal(@node)
     end
 
     it "should set the resulting parameters as the node parameters" do
       @result[:parameters] = {"a" => "b", "c" => "d"}
       @searcher.find(@request)
       @node.parameters.should == {"a" => "b", "c" => "d"}
     end
 
     it "should set the resulting classes as the node classes" do
       @result[:classes] = %w{one two}
       @searcher.find(@request)
       @node.classes.should == [ 'one', 'two' ]
     end
 
     it "should merge the node's facts with its parameters" do
       @node.expects(:fact_merge)
       @searcher.find(@request)
     end
 
     it "should set the node's environment if one is provided" do
       @result[:environment] = "yay"
       @searcher.find(@request)
       @node.environment.to_s.should == 'yay'
     end
   end
 end
diff --git a/spec/unit/parser/functions/generate_spec.rb b/spec/unit/parser/functions/generate_spec.rb
index 6c90ae531..e50805393 100755
--- a/spec/unit/parser/functions/generate_spec.rb
+++ b/spec/unit/parser/functions/generate_spec.rb
@@ -1,43 +1,85 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 describe "the generate function" do
   before :all do
     Puppet::Parser::Functions.autoloader.loadall
   end
 
-  before :each do
-    @scope = Puppet::Parser::Scope.new
-  end
+  let(:scope) { Puppet::Parser::Scope.new }
 
   it "should exist" do
     Puppet::Parser::Functions.function("generate").should == "function_generate"
   end
 
-  it "should accept a fully-qualified path as a command" do
-    command = File::SEPARATOR + "command"
-    Puppet::Util.expects(:execute).with([command]).returns("yay")
-    lambda { @scope.function_generate([command]) }.should_not raise_error(Puppet::ParseError)
+  it " accept a fully-qualified path as a command" do
+    command = File.expand_path('/command/foo')
+    Dir.expects(:chdir).with(File.dirname(command)).returns("yay")
+    scope.function_generate([command]).should == "yay"
   end
 
   it "should not accept a relative path as a command" do
-    command = "command"
-    lambda { @scope.function_generate([command]) }.should raise_error(Puppet::ParseError)
+    lambda { scope.function_generate(["command"]) }.should raise_error(Puppet::ParseError)
+  end
+
+  it "should not accept a command containing illegal characters" do
+    lambda { scope.function_generate([File.expand_path('/##/command')]) }.should raise_error(Puppet::ParseError)
   end
 
-  # Really not sure how to implement this test, just sure it needs
-  # to be implemented.
-  it "should not accept a command containing illegal characters"
+  it "should not accept a command containing spaces" do
+    lambda { scope.function_generate([File.expand_path('/com mand')]) }.should raise_error(Puppet::ParseError)
+  end
 
   it "should not accept a command containing '..'" do
-    command = File::SEPARATOR + "command#{File::SEPARATOR}..#{File::SEPARATOR}"
-    lambda { @scope.function_generate([command]) }.should raise_error(Puppet::ParseError)
+    command = File.expand_path("/command/../")
+    lambda { scope.function_generate([command]) }.should raise_error(Puppet::ParseError)
   end
 
   it "should execute the generate script with the correct working directory" do
-    command = File::SEPARATOR + "command"
-    Dir.expects(:chdir).with(File.dirname(command)).yields
-    Puppet::Util.expects(:execute).with([command]).returns("yay")
-    lambda { @scope.function_generate([command]) }.should_not raise_error(Puppet::ParseError)
+    command = File.expand_path("/command")
+    Dir.expects(:chdir).with(File.dirname(command)).returns("yay")
+    scope.function_generate([command]).should == 'yay'
+  end
+
+  describe "on Windows" do
+    before :each do
+      Puppet.features.stubs(:microsoft_windows?).returns(true)
+    end
+
+    it "should accept lower-case drive letters" do
+      command = 'd:/command/foo'
+      Dir.expects(:chdir).with(File.dirname(command)).returns("yay")
+      scope.function_generate([command]).should == 'yay'
+    end
+
+    it "should accept upper-case drive letters" do
+      command = 'D:/command/foo'
+      Dir.expects(:chdir).with(File.dirname(command)).returns("yay")
+      scope.function_generate([command]).should == 'yay'
+    end
+
+    it "should accept forward and backslashes in the path" do
+      command = 'D:\command/foo\bar'
+      Dir.expects(:chdir).with(File.dirname(command)).returns("yay")
+      scope.function_generate([command]).should == 'yay'
+    end
+
+    it "should reject colons when not part of the drive letter" do
+      lambda { scope.function_generate(['C:/com:mand']) }.should raise_error(Puppet::ParseError)
+    end
+
+    it "should reject root drives" do
+      lambda { scope.function_generate(['C:/']) }.should raise_error(Puppet::ParseError)
+    end
+  end
+
+  describe "on non-Windows" do
+    before :each do
+      Puppet.features.stubs(:microsoft_windows?).returns(false)
+    end
+
+    it "should reject backslashes" do
+      lambda { scope.function_generate(['/com\\mand']) }.should raise_error(Puppet::ParseError)
+    end
   end
 end
diff --git a/spec/unit/type/file_spec.rb b/spec/unit/type/file_spec.rb
index d4df006b3..fee7e552c 100755
--- a/spec/unit/type/file_spec.rb
+++ b/spec/unit/type/file_spec.rb
@@ -1,1520 +1,1523 @@
 #!/usr/bin/env rspec
 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
     @real_posix = Puppet.features.posix?
     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/"
         file[:path].should == "/foo/bar/baz"
       end
 
       it "should remove double slashes" do
         file[:path] = "/foo/bar//baz"
         file[:path].should == "/foo/bar/baz"
       end
 
       it "should remove trailing double slashes" do
         file[:path] = "/foo/bar/baz//"
         file[:path].should == "/foo/bar/baz"
       end
 
       it "should leave a single slash alone" do
         file[:path] = "/"
         file[:path].should == "/"
       end
 
       it "should accept a double-slash at the start of the path" do
         expect {
           file[:path] = "//tmp/xxx"
           # REVISIT: This should be wrong, later.  See the next test.
           # --daniel 2011-01-31
           file[:path].should == '/tmp/xxx'
         }.should_not raise_error
       end
 
       # REVISIT: This is pending, because I don't want to try and audit the
       # entire codebase to make sure we get this right.  POSIX treats two (and
       # exactly two) '/' characters at the start of the path specially.
       #
       # See sections 3.2 and 4.11, which allow DomainOS to be all special like
       # and still have the POSIX branding and all. --daniel 2011-01-31
       it "should preserve the double-slash at the start of the path"
     end
 
     describe "on Windows systems", :if => Puppet.features.microsoft_windows? do
       it "should remove trailing slashes" do
         file[:path] = "X:/foo/bar/baz/"
         file[:path].should == "X:/foo/bar/baz"
       end
 
       it "should remove double slashes" do
         file[:path] = "X:/foo/bar//baz"
         file[:path].should == "X:/foo/bar/baz"
       end
 
       it "should remove trailing double slashes" do
         file[:path] = "X:/foo/bar/baz//"
         file[:path].should == "X:/foo/bar/baz"
       end
 
       it "should leave a drive letter with a slash alone", :'fails_on_ruby_1.9.2' => true do
         file[:path] = "X:/"
         file[:path].should == "X:/"
       end
 
       it "should not accept a drive letter without a slash", :'fails_on_ruby_1.9.2' => true do
         lambda { file[:path] = "X:" }.should raise_error(/File paths must be fully qualified/)
       end
 
       describe "when using UNC filenames", :if => Puppet.features.microsoft_windows?, :'fails_on_ruby_1.9.2' => true do
         before :each do
           pending("UNC file paths not yet supported")
         end
 
         it "should remove trailing slashes" do
           file[:path] = "//server/foo/bar/baz/"
           file[:path].should == "//server/foo/bar/baz"
         end
 
         it "should remove double slashes" do
           file[:path] = "//server/foo/bar//baz"
           file[:path].should == "//server/foo/bar/baz"
         end
 
         it "should remove trailing double slashes" do
           file[:path] = "//server/foo/bar/baz//"
           file[:path].should == "//server/foo/bar/baz"
         end
 
         it "should remove a trailing slash from a sharename" do
           file[:path] = "//server/foo/"
           file[:path].should == "//server/foo"
         end
 
         it "should not modify a sharename" do
           file[:path] = "//server/foo"
           file[:path].should == "//server/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
         file[:backup].should == 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
         file[:backup].should == '.puppet-bak'
       end
     end
 
     it "should use the provided value if it's any other string" do
       file[:backup] = "over there"
       file[:backup].should == "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
       file[:recurse].should be_false
     end
 
     [true, "true", 10, "inf", "remote"].each do |value|
       it "should consider #{value} to enable recursion" do
         file[:recurse] = value
         file[:recurse].should be_true
       end
     end
 
     [false, "false", 0].each do |value|
       it "should consider #{value} to disable recursion" do
         file[:recurse] = value
         file[:recurse].should be_false
       end
     end
 
     it "should warn if recurse is specified as a number" do
       file[:recurse] = 3
       message = /Setting recursion depth with the recurse parameter is now deprecated, please use recurselimit/
       @logs.find { |log| log.level == :warning and log.message =~ message}.should_not be_nil
     end
   end
 
   describe "the recurselimit parameter" do
     it "should accept integers" do
       file[:recurselimit] = 12
       file[:recurselimit].should == 12
     end
 
     it "should munge string numbers to number numbers" do
       file[:recurselimit] = '12'
       file[:recurselimit].should == 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
         file[:replace].should == :true
       end
     end
 
     [false, :false, :no].each do |value|
       it "should consider #{value} to be false" do
         file[:replace] = value
         file[:replace].should == :false
       end
     end
   end
 
   describe "#[]" do
     it "should raise an exception" do
       expect do
         described_class['anything']
       end.to raise_error("Global resource access is deprecated")
     end
   end
 
   describe ".instances" do
     it "should return an empty array" do
       described_class.instances.should == []
     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.features.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
 
       file.asuser.should == 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
 
       file.asuser.should == nil
     end
 
     it "should return nil if not managing owner" do
       file.asuser.should == nil
     end
   end
 
   describe "#bucket" do
     it "should return nil if backup is off" do
       file[:backup] = false
       file.bucket.should == nil
     end
 
     it "should not return a bucket if using a file extension for backup" do
       file[:backup] = '.backup'
 
       file.bucket.should == 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
 
       file.bucket.should == 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)
 
       file.bucket.should == 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.features.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
 
       file.asuser.should == 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
 
       file.asuser.should == nil
     end
 
     it "should return nil if not managing owner" do
       file.asuser.should == nil
     end
   end
 
   describe "#bucket" do
     it "should return nil if backup is off" do
       file[:backup] = false
       file.bucket.should == nil
     end
 
     it "should return nil if using a file extension for backup" do
       file[:backup] = '.backup'
 
       file.bucket.should == 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
 
       file.bucket.should == 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)
 
       file.bucket.should == filebucket.bucket
     end
   end
 
   describe "#exist?" do
     it "should be considered existent if it can be stat'ed" do
       file.expects(:stat).returns mock('stat')
       file.must be_exist
     end
 
     it "should be considered nonexistent if it can not be stat'ed" do
       file.expects(:stat).returns nil
       file.must_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
 
       file.eval_generate.should == [resource]
     end
 
     it "should not recurse if recursion is disabled" do
       file.expects(:recurse).never
 
       file[:recurse] = false
 
       file.eval_generate.should == []
     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
 
       ancestors.should_not be_empty
       ancestors.reverse.each_with_index do |path,i|
         path.should == 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
 
       file.stat.should equal(stat1)
 
       file.flush
 
       file.stat.should_not 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)
       file[:path].should == 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")
       file[:ensure].should == :file
     end
 
     it "should set a desired 'ensure' value if none is set and 'target' is set" do
       file = described_class.new(:path => path, :target => File.expand_path(__FILE__))
       file[:ensure].should == :symlink
     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)
 
       children.length.should == 3
       children.values.each do |child|
         child[:ensure].should == :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)
 
       child[:ensure].should == :present
     end
   end
 
   describe "#newchild" do
     it "should create a new resource relative to the parent" do
       child = file.newchild('bar')
 
       child.should be_a(described_class)
       child[:path].should == 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" 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')
         child[param].should_not == 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")
 
       child[:owner].should == 'root'
       child[:group].should == 'wheel'
     end
 
     it "should not copy default values to the new child" do
       child = file.newchild("my/path")
       child.original_parameters.should_not 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
       file.must_not be_purge
     end
 
     it "should return true if purge is set to true" do
       file[:purge] = true
 
       file.must be_purge
     end
 
     it "should return false if purge is set to false" do
       file[:purge] = false
 
       file.must_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)
       file.recurse.should == [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
         local[:ensure].should == :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
 
         remote[:ensure].should_not == :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)
 
       file.remove_less_specific_files([foo, bar, baz]).should == [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)
 
       file.remove_less_specific_files([foo, bar, baz]).should == [baz]
     end
 
   end
 
   describe "#recurse?" do
     it "should be true if recurse is true" do
       file[:recurse] = true
       file.must be_recurse
     end
 
     it "should be true if recurse is remote" do
       file[:recurse] = :remote
       file.must be_recurse
     end
 
     it "should be false if recurse is false" do
       file[:recurse] = false
       file.must_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" do
       file.stubs(:perform_recursion).returns [@first, @second]
       file.recurse_link("first" => @resource, "second" => file)
 
       file[:ensure].should == :link
       file[:target].should == "/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)
 
       file[:ensure].should == :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
       file.recurse_link("second" => @resource).should == {"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
       file.recurse_local.should == {}
     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"
       file.recurse_local.should == {"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" 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 = 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("/whatever", :relative_path => "foobar")
+      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("/whatever", :relative_path => ".")
+      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
       file.recurse_remote({}).should == {"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.
     it "should set the checksum type to :md5 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, :md5)
       file.recurse_remote("first" => @resource)
     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("/whatever", :relative_path => "foobar")
+          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] = %w{/a /b /c /d}.map {|f| File.expand_path(f) }
+
+          file[:source] = abs_path = %w{/a /b /c /d}.map {|f| File.expand_path(f) }
           file.stubs(:newchild).returns @resource
 
-          one = [klass.new("/a", :relative_path => "a")]
+          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("/b", :relative_path => "a"), klass.new("/b", :relative_path => "b")]
+          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("/c", :relative_path => "a"), klass.new("/c", :relative_path => "c")]
+          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
     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"
       file.perform_recursion(file[:path]).should == "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
   end
 
   describe "#remove_existing" do
     it "should do nothing if the file doesn't exist" do
       file.remove_existing(:file).should == nil
     end
 
     it "should fail if it can't backup the file" do
       file.stubs(:stat).returns stub('stat')
       file.stubs(:perform_backup).returns false
 
       expect { file.remove_existing(:file) }.to raise_error(Puppet::Error, /Could not back up; will not replace/)
     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')
 
       file.remove_existing(:file).should == nil
     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)
 
       file.instance_variable_get(:@stat).should == nil
       @logs.should 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])
 
       file.remove_existing(:file).should == true
     end
 
     it "should remove an existing file" do
       file.stubs(:perform_backup).returns true
       FileUtils.touch(path)
 
       file.remove_existing(:directory).should == true
 
       File.exists?(file[:path]).should == false
     end
 
     it "should remove an existing link", :unless => Puppet.features.microsoft_windows? do
       file.stubs(:perform_backup).returns true
 
       target = tmpfile('link_target')
       FileUtils.touch(target)
       FileUtils.symlink(target, path)
       file[:target] = target
 
       file.remove_existing(:directory).should == true
 
       File.exists?(file[:path]).should == 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')
 
       File.stubs(:unlink)
 
       file.remove_existing(:directory).should == true
       file.instance_variable_get(:@stat).should == :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
       file.must respond_to(:should_be_file?)
     end
 
     it "should be a file if :ensure is set to :file" do
       file[:ensure] = :file
       file.must 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
       file.must be_should_be_file
     end
 
     it "should not be a file if :ensure is set to something other than :file" do
       file[:ensure] = :directory
       file.must_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
       file.must_not be_should_be_file
     end
 
     it "should be a file if :ensure is not set and :content is" do
       file[:content] = "foo"
       file.must 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"))
       file.must 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"))
       file.must_not be_should_be_file
     end
   end
 
   describe "#stat", :unless => Puppet.features.microsoft_windows? do
     before do
       target = tmpfile('link_target')
       FileUtils.touch(target)
       FileUtils.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
 
       file.stat.ftype.should == 'file'
     end
 
     it "should stat the link if is it not following links" do
       file[:links] = :manage
 
       file.stat.ftype.should == 'link'
     end
 
     it "should return nil if the file does not exist" do
       file[:path] = '/foo/bar/baz/non-existent'
 
       file.stat.should 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
 
       file.stat.should be_nil
 
       # chmod it back so we can clean it up
       File.chmod(0777, dir)
     end
 
     it "should return the stat instance" do
       file.stat.should be_a(File::Stat)
     end
 
     it "should cache the stat instance" do
       file.stat.should equal(file.stat)
     end
   end
 
   describe "#write" do
     it "should propagate failures encountered when renaming the temporary file" do
       File.stubs(:open)
       File.expects(:rename).raises ArgumentError
 
       file[:backup] = 'puppet'
 
       file.stubs(:validate_checksum?).returns(false)
 
       property = stub('content_property', :actual_content => "something", :length => "something".length)
       file.stubs(:property).with(:content).returns(property)
 
       lambda { file.write(:content) }.should raise_error(Puppet::Error)
     end
 
     it "should delegate writing to the content property" do
       filehandle = stub_everything 'fh'
       File.stubs(:open).yields(filehandle)
       File.stubs(:rename)
       property = stub('content_property', :actual_content => "something", :length => "something".length)
       file[:backup] = 'puppet'
 
       file.stubs(:validate_checksum?).returns(false)
       file.stubs(:property).with(:content).returns(property)
 
       property.expects(:write).with(filehandle)
 
       file.write(:content)
     end
 
     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)
 
         lambda { file.write :NOTUSED }.should 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)
 
         lambda { file.write :NOTUSED }.should_not raise_error(Puppet::Error)
       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
       file.instance_eval do
         parameter(:checksum).stubs(:sum_file).returns('anything!')
         fail_if_checksum_is_wrong(self[:path], 'anything!').should == nil
       end
     end
 
     it "should not fail if the checksum is absent" do
       file.instance_eval do
         parameter(:checksum).stubs(:sum_file).returns(nil)
         fail_if_checksum_is_wrong(self[:path], 'anything!').should == nil
       end
     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'
 
       file.send(:write_temporary_file?).should be_true
     end
 
     it "should be true if the file has specified source" do
       file[:source] = File.expand_path('/tmp/foo')
 
       file.send(:write_temporary_file?).should be_true
     end
 
     it "should be false if the file has neither content nor source" do
       file.send(:write_temporary_file?).should be_false
     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" do
         file = described_class.new(:path => File.expand_path("/foo"), :ensure => :directory)
         link = described_class.new(:path => File.expand_path("/bar"), :ensure => :symlink, :target => File.expand_path("/foo"))
         catalog.add_resource file
         catalog.add_resource link
         reqs = link.autorequire
         reqs.size.must == 1
         reqs[0].source.must == file
         reqs[0].target.must == 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
         reqs.size.must == 1
         reqs[0].source.must == file
         reqs[0].target.must == link
       end
 
       it "should not require target if target is not managed" do
         link = described_class.new(:path => File.expand_path('/foo'), :ensure => :symlink, :target => '/bar')
         catalog.add_resource link
         link.autorequire.size.should == 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
         reqs[0].source.must == dir
         reqs[0].target.must == 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
         reqs.length.must == 1
         reqs[0].source.must == dir
         reqs[0].target.must == file
       end
 
       it "should not autorequire anything when there is no nearest ancestor directory" do
         catalog.add_resource file
         file.autorequire.should 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
         file.autorequire.should 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] = '//server/foo/bar/baz'
             dir = described_class.new(:path => "//server/foo/bar")
             catalog.add_resource file
             catalog.add_resource dir
             reqs = file.autorequire
             reqs[0].source.must == dir
             reqs[0].target.must == file
           end
 
           it "should autorequire its nearest ancestor directory" do
             file = described_class.new(:path => "//server/foo/bar/baz/qux")
             dir = described_class.new(:path => "//server/foo/bar/baz")
             grandparent = described_class.new(:path => "//server/foo/bar")
             catalog.add_resource file
             catalog.add_resource dir
             catalog.add_resource grandparent
             reqs = file.autorequire
             reqs.length.must == 1
             reqs[0].source.must == dir
             reqs[0].target.must == file
           end
 
           it "should not autorequire anything when there is no nearest ancestor directory" do
             file = described_class.new(:path => "//server/foo/bar/baz/qux")
             catalog.add_resource file
             file.autorequire.should be_empty
           end
 
           it "should not autorequire its parent dir if its parent dir is itself" do
             file = described_class.new(:path => "//server/foo")
             catalog.add_resource file
             puts file.autorequire
             file.autorequire.should be_empty
           end
         end
       end
     end
   end
 
   describe "when managing links" do
     require 'tempfile'
 
     if @real_posix
       describe "on POSIX systems" do
         before do
           Dir.mkdir(path)
           @target = File.join(path, "target")
           @link   = File.join(path, "link")
 
           File.open(@target, "w", 0644) { |f| f.puts "yayness" }
           File.symlink(@target, @link)
 
           file[:path] = @link
           file[:mode] = 0755
 
           catalog.add_resource file
         end
 
         it "should default to managing the link" do
           catalog.apply
           # I convert them to strings so they display correctly if there's an error.
           (File.stat(@target).mode & 007777).to_s(8).should == '644'
         end
 
         it "should be able to follow links" do
           file[:links] = :follow
           catalog.apply
 
           (File.stat(@target).mode & 007777).to_s(8).should == '755'
         end
       end
     else # @real_posix
       # should recode tests using expectations instead of using the filesystem
     end
 
     describe "on Microsoft Windows systems" do
       before do
         Puppet.features.stubs(:posix?).returns(false)
         Puppet.features.stubs(:microsoft_windows?).returns(true)
       end
 
       it "should refuse to work with links"
     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
 
           lambda { file.validate }.should_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
         lambda { file.validate }.should 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
           lambda { file.validate }.should_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
 
           lambda { file.validate }.should 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
 
       report.resource_statuses["File[#{path}]"].should_not be_failed
       File.read(path).should == '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
 
       File.should be_exist(path)
       @logs.should_not 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
 
       file[:checksum].should == :md5lite
     end
 
     it 'should use the specified checksum when source is last' do
       file[:checksum] = :md5lite
       file[:source] = File.expand_path('/foo')
 
       file[:checksum].should == :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