diff --git a/lib/puppet/type/file.rb b/lib/puppet/type/file.rb
index f35a26408..6523c99a0 100644
--- a/lib/puppet/type/file.rb
+++ b/lib/puppet/type/file.rb
@@ -1,798 +1,799 @@
 require 'digest/md5'
 require 'cgi'
 require 'etc'
 require 'uri'
 require 'fileutils'
 require 'puppet/network/handler'
 require 'puppet/util/diff'
 require 'puppet/util/checksums'
 require 'puppet/network/client'
 require 'puppet/util/backups'
 
 Puppet::Type.newtype(:file) do
   include Puppet::Util::MethodHelper
   include Puppet::Util::Checksums
   include Puppet::Util::Backups
   @doc = "Manages local files, including setting ownership and
     permissions, creation of both files and directories, and
     retrieving entire files from remote servers.  As Puppet matures, it
     expected that the `file` resource will be used less and less to
     manage content, and instead native resources will be used to do so.
 
     If you find that you are often copying files in from a central
     location, rather than using native resources, please contact
     Puppet Labs and we can hopefully work with you to develop a
     native resource to support what you are doing."
 
   def self.title_patterns
     [ [ /^(.*?)\/*\Z/m, [ [ :path, lambda{|x| x} ] ] ] ]
   end
 
   newparam(:path) do
     desc "The path to the file to manage.  Must be fully qualified."
     isnamevar
 
     validate do |value|
       # accept various path syntaxes: lone slash, posix, win32, unc
       unless (Puppet.features.posix? and (value =~ /^\/$/ or value =~ /^\/[^\/]/)) or (Puppet.features.microsoft_windows? and (value =~ /^.:\// or value =~ /^\/\/[^\/]+\/[^\/]+/))
         fail Puppet::Error, "File paths must be fully qualified, not '#{value}'"
       end
     end
 
     # convert the current path in an index into the collection and the last
     # path name. The aim is to use less storage for all common paths in a hierarchy
     munge do |value|
       path, name = File.split(value.gsub(/\/+/,'/'))
       { :index => Puppet::FileCollection.collection.index(path), :name => name }
     end
 
     # and the reverse
     unmunge do |value|
       basedir = Puppet::FileCollection.collection.path(value[:index])
       # a lone slash as :name indicates a root dir on windows
       if value[:name] == '/'
         basedir
       else
         File.join( basedir, value[:name] )
       end
     end
   end
 
   newparam(:backup) do
     desc "Whether files should be backed up before
       being replaced.  The preferred method of backing files up is via
       a `filebucket`, which stores files by their MD5 sums and allows
       easy retrieval without littering directories with backups.  You
       can specify a local filebucket or a network-accessible
       server-based filebucket by setting `backup => bucket-name`.
       Alternatively, if you specify any value that begins with a `.`
       (e.g., `.puppet-bak`), then Puppet will use copy the file in
       the same directory with that value as the extension of the
       backup. Setting `backup => false` disables all backups of the
       file in question.
 
       Puppet automatically creates a local filebucket named `puppet` and
       defaults to backing up there.  To use a server-based filebucket,
       you must specify one in your configuration
 
             filebucket { main:
               server => puppet
             }
 
       The `puppet master` daemon creates a filebucket by default,
       so you can usually back up to your main server with this
       configuration.  Once you've described the bucket in your
       configuration, you can use it in any file
 
             file { \"/my/file\":
               source => \"/path/in/nfs/or/something\",
               backup => main
             }
 
       This will back the file up to the central server.
 
       At this point, the benefits of using a filebucket are that you do not
       have backup files lying around on each of your machines, a given
       version of a file is only backed up once, and you can restore
       any given file manually, no matter how old.  Eventually,
       transactional support will be able to automatically restore
       filebucketed files.
       "
 
     defaultto "puppet"
 
     munge do |value|
       # I don't really know how this is happening.
       value = value.shift if value.is_a?(Array)
 
       case value
       when false, "false", :false
         false
       when true, "true", ".puppet-bak", :true
         ".puppet-bak"
       when String
         value
       else
         self.fail "Invalid backup type #{value.inspect}"
       end
     end
   end
 
   newparam(:recurse) do
     desc "Whether and how deeply to do recursive
       management."
 
     newvalues(:true, :false, :inf, :remote, /^[0-9]+$/)
 
     # Replace the validation so that we allow numbers in
     # addition to string representations of them.
     validate { |arg| }
     munge do |value|
       newval = super(value)
       case newval
       when :true, :inf; true
       when :false; false
       when :remote; :remote
       when Integer, Fixnum, Bignum
         self.warning "Setting recursion depth with the recurse parameter is now deprecated, please use recurselimit"
 
         # recurse == 0 means no recursion
         return false if value == 0
 
         resource[:recurselimit] = value
         true
       when /^\d+$/
         self.warning "Setting recursion depth with the recurse parameter is now deprecated, please use recurselimit"
         value = Integer(value)
 
         # recurse == 0 means no recursion
         return false if value == 0
 
         resource[:recurselimit] = value
         true
       else
         self.fail "Invalid recurse value #{value.inspect}"
       end
     end
   end
 
   newparam(:recurselimit) do
     desc "How deeply to do recursive management."
 
     newvalues(/^[0-9]+$/)
 
     munge do |value|
       newval = super(value)
       case newval
       when Integer, Fixnum, Bignum; value
       when /^\d+$/; Integer(value)
       else
         self.fail "Invalid recurselimit value #{value.inspect}"
       end
     end
   end
 
   newparam(:replace, :boolean => true) do
     desc "Whether or not to replace a file that is
       sourced but exists.  This is useful for using file sources
       purely for initialization."
     newvalues(:true, :false)
     aliasvalue(:yes, :true)
     aliasvalue(:no, :false)
     defaultto :true
   end
 
   newparam(:force, :boolean => true) do
     desc "Force the file operation.  Currently only used when replacing
       directories with links."
     newvalues(:true, :false)
     defaultto false
   end
 
   newparam(:ignore) do
     desc "A parameter which omits action on files matching
       specified patterns during recursion.  Uses Ruby's builtin globbing
       engine, so shell metacharacters are fully supported, e.g. `[a-z]*`.
       Matches that would descend into the directory structure are ignored,
       e.g., `*/*`."
 
     validate do |value|
       unless value.is_a?(Array) or value.is_a?(String) or value == false
         self.devfail "Ignore must be a string or an Array"
       end
     end
   end
 
   newparam(:links) do
     desc "How to handle links during file actions.  During file copying,
       `follow` will copy the target file instead of the link, `manage`
       will copy the link itself, and `ignore` will just pass it by.
       When not copying, `manage` and `ignore` behave equivalently
       (because you cannot really ignore links entirely during local recursion), and `follow` will manage the file to which the
       link points."
 
     newvalues(:follow, :manage)
 
     defaultto :manage
   end
 
   newparam(:purge, :boolean => true) do
     desc "Whether unmanaged files should be purged.  If you have a filebucket
       configured the purged files will be uploaded, but if you do not,
       this will destroy data.  Only use this option for generated
       files unless you really know what you are doing.  This option only
       makes sense when recursively managing directories.
 
       Note that when using `purge` with `source`, Puppet will purge any files
       that are not on the remote system."
 
     defaultto :false
 
     newvalues(:true, :false)
   end
 
   newparam(:sourceselect) do
     desc "Whether to copy all valid sources, or just the first one.  This parameter
       is only used in recursive copies; by default, the first valid source is the
       only one used as a recursive source, but if this parameter is set to `all`,
       then all valid sources will have all of their contents copied to the local host,
       and for sources that have the same file, the source earlier in the list will
       be used."
 
     defaultto :first
 
     newvalues(:first, :all)
   end
 
   # Autorequire any parent directories.
   autorequire(:file) do
     basedir = File.dirname(self[:path])
     if basedir != self[:path]
       basedir
     else
       nil
     end
   end
 
   # Autorequire the owner and group of the file.
   {:user => :owner, :group => :group}.each do |type, property|
     autorequire(type) do
       if @parameters.include?(property)
         # The user/group property automatically converts to IDs
         next unless should = @parameters[property].shouldorig
         val = should[0]
         if val.is_a?(Integer) or val =~ /^\d+$/
           nil
         else
           val
         end
       end
     end
   end
 
   CREATORS = [:content, :source, :target]
 
   validate do
     count = 0
     CREATORS.each do |param|
       count += 1 if self.should(param)
     end
     count += 1 if @parameters.include?(:source)
     self.fail "You cannot specify more than one of #{CREATORS.collect { |p| p.to_s}.join(", ")}" if count > 1
 
     self.fail "You cannot specify a remote recursion without a source" if !self[:source] and self[:recurse] == :remote
 
     self.warning "Possible error: recurselimit is set but not recurse, no recursion will happen" if !self[:recurse] and self[:recurselimit]
   end
 
   def self.[](path)
     return nil unless path
     super(path.gsub(/\/+/, '/').sub(/\/$/, ''))
   end
 
   # List files, but only one level deep.
   def self.instances(base = "/")
     return [] unless FileTest.directory?(base)
 
     files = []
     Dir.entries(base).reject { |e|
       e == "." or e == ".."
     }.each do |name|
       path = File.join(base, name)
       if obj = self[path]
         obj[:audit] = :all
         files << obj
       else
         files << self.new(
           :name => path, :audit => :all
         )
       end
     end
     files
   end
 
   @depthfirst = false
 
   # Determine the user to write files as.
   def asuser
     if self.should(:owner) and ! self.should(:owner).is_a?(Symbol)
       writeable = Puppet::Util::SUIDManager.asuser(self.should(:owner)) {
         FileTest.writable?(File.dirname(self[:path]))
       }
 
       # If the parent directory is writeable, then we execute
       # as the user in question.  Otherwise we'll rely on
       # the 'owner' property to do things.
       asuser = self.should(:owner) if writeable
     end
 
     asuser
   end
 
   def bucket
     return @bucket if @bucket
 
     backup = self[:backup]
     return nil unless backup
     return nil if backup =~ /^\./
 
     unless catalog or backup == "puppet"
       fail "Can not find filebucket for backups without a catalog"
     end
 
     unless catalog and filebucket = catalog.resource(:filebucket, backup) or backup == "puppet"
       fail "Could not find filebucket #{backup} specified in backup"
     end
 
     return default_bucket unless filebucket
 
     @bucket = filebucket.bucket
 
     @bucket
   end
 
   def default_bucket
     Puppet::Type.type(:filebucket).mkdefaultbucket.bucket
   end
 
   # Does the file currently exist?  Just checks for whether
   # we have a stat
   def exist?
     stat ? true : false
   end
 
   # We have to do some extra finishing, to retrieve our bucket if
   # there is one.
   def finish
     # Look up our bucket, if there is one
     bucket
     super
   end
 
   # Create any children via recursion or whatever.
   def eval_generate
     return [] unless self.recurse?
 
     recurse
     #recurse.reject do |resource|
     #    catalog.resource(:file, resource[:path])
     #end.each do |child|
     #    catalog.add_resource child
     #    catalog.relationship_graph.add_edge self, child
     #end
   end
 
   def flush
     # We want to make sure we retrieve metadata anew on each transaction.
     @parameters.each do |name, param|
       param.flush if param.respond_to?(:flush)
     end
     @stat = nil
   end
 
   def initialize(hash)
     # Used for caching clients
     @clients = {}
 
     super
 
     # If they've specified a source, we get our 'should' values
     # from it.
     unless self[:ensure]
       if self[:target]
         self[:ensure] = :symlink
       elsif self[:content]
         self[:ensure] = :file
       end
     end
 
     @stat = nil
   end
 
   # Configure discovered resources to be purged.
   def mark_children_for_purging(children)
     children.each do |name, child|
       next if child[:source]
       child[:ensure] = :absent
     end
   end
 
   # Create a new file or directory object as a child to the current
   # object.
   def newchild(path)
     full_path = File.join(self[:path], path)
 
     # Add some new values to our original arguments -- these are the ones
     # set at initialization.  We specifically want to exclude any param
     # values set by the :source property or any default values.
     # LAK:NOTE This is kind of silly, because the whole point here is that
     # the values set at initialization should live as long as the resource
     # but values set by default or by :source should only live for the transaction
     # or so.  Unfortunately, we don't have a straightforward way to manage
     # the different lifetimes of this data, so we kludge it like this.
     # The right-side hash wins in the merge.
     options = @original_parameters.merge(:path => full_path).reject { |param, value| value.nil? }
 
     # These should never be passed to our children.
     [:parent, :ensure, :recurse, :recurselimit, :target, :alias, :source].each do |param|
       options.delete(param) if options.include?(param)
     end
 
     self.class.new(options)
   end
 
   # Files handle paths specially, because they just lengthen their
   # path names, rather than including the full parent's title each
   # time.
   def pathbuilder
     # We specifically need to call the method here, so it looks
     # up our parent in the catalog graph.
     if parent = parent()
       # We only need to behave specially when our parent is also
       # a file
       if parent.is_a?(self.class)
         # Remove the parent file name
         list = parent.pathbuilder
         list.pop # remove the parent's path info
         return list << self.ref
       else
         return super
       end
     else
       return [self.ref]
     end
   end
 
   # Should we be purging?
   def purge?
     @parameters.include?(:purge) and (self[:purge] == :true or self[:purge] == "true")
   end
 
   # Recursively generate a list of file resources, which will
   # be used to copy remote files, manage local files, and/or make links
   # to map to another directory.
   def recurse
     children = {}
     children = recurse_local if self[:recurse] != :remote
 
     if self[:target]
       recurse_link(children)
     elsif self[:source]
       recurse_remote(children)
     end
 
     # If we're purging resources, then delete any resource that isn't on the
     # remote system.
     mark_children_for_purging(children) if self.purge?
 
     result = children.values.sort { |a, b| a[:path] <=> b[:path] }
     remove_less_specific_files(result)
   end
 
   # This is to fix bug #2296, where two files recurse over the same
   # set of files.  It's a rare case, and when it does happen you're
   # not likely to have many actual conflicts, which is good, because
   # this is a pretty inefficient implementation.
   def remove_less_specific_files(files)
     mypath = self[:path].split(File::Separator)
     other_paths = catalog.vertices.
       select  { |r| r.is_a?(self.class) and r[:path] != self[:path] }.
       collect { |r| r[:path].split(File::Separator) }.
       select  { |p| p[0,mypath.length]  == mypath }
 
     return files if other_paths.empty?
 
     files.reject { |file|
       path = file[:path].split(File::Separator)
       other_paths.any? { |p| path[0,p.length] == p }
       }
   end
 
   # A simple method for determining whether we should be recursing.
   def recurse?
     return false unless @parameters.include?(:recurse)
 
     val = @parameters[:recurse].value
 
     !!(val and (val == true or val == :remote))
   end
 
   # Recurse the target of the link.
   def recurse_link(children)
     perform_recursion(self[:target]).each do |meta|
       if meta.relative_path == "."
         self[:ensure] = :directory
         next
       end
 
       children[meta.relative_path] ||= newchild(meta.relative_path)
       if meta.ftype == "directory"
         children[meta.relative_path][:ensure] = :directory
       else
         children[meta.relative_path][:ensure] = :link
         children[meta.relative_path][:target] = meta.full_path
       end
     end
     children
   end
 
   # Recurse the file itself, returning a Metadata instance for every found file.
   def recurse_local
     result = perform_recursion(self[:path])
     return {} unless result
     result.inject({}) do |hash, meta|
       next hash if meta.relative_path == "."
 
       hash[meta.relative_path] = newchild(meta.relative_path)
       hash
     end
   end
 
   # Recurse against our remote file.
   def recurse_remote(children)
     sourceselect = self[:sourceselect]
 
     total = self[:source].collect do |source|
       next unless result = perform_recursion(source)
       return if top = result.find { |r| r.relative_path == "." } and top.ftype != "directory"
       result.each { |data| data.source = "#{source}/#{data.relative_path}" }
       break result if result and ! result.empty? and sourceselect == :first
       result
     end.flatten
 
     # This only happens if we have sourceselect == :all
     unless sourceselect == :first
       found = []
       total.reject! do |data|
         result = found.include?(data.relative_path)
         found << data.relative_path unless found.include?(data.relative_path)
         result
       end
     end
 
     total.each do |meta|
       if meta.relative_path == "."
         parameter(:source).metadata = meta
         next
       end
       children[meta.relative_path] ||= newchild(meta.relative_path)
       children[meta.relative_path][:source] = meta.source
       children[meta.relative_path][:checksum] = :md5 if meta.ftype == "file"
 
       children[meta.relative_path].parameter(:source).metadata = meta
     end
 
     children
   end
 
   def perform_recursion(path)
 
     Puppet::FileServing::Metadata.search(
 
       path,
       :links => self[:links],
       :recurse => (self[:recurse] == :remote ? true : self[:recurse]),
 
       :recurselimit => self[:recurselimit],
       :ignore => self[:ignore],
       :checksum_type => (self[:source] || self[:content]) ? self[:checksum] : :none
     )
   end
 
   # Remove any existing data.  This is only used when dealing with
   # links or directories.
   def remove_existing(should)
     return unless s = stat
 
     self.fail "Could not back up; will not replace" unless perform_backup
 
     unless should.to_s == "link"
       return if s.ftype.to_s == should.to_s
     end
 
     case s.ftype
     when "directory"
       if self[:force] == :true
         debug "Removing existing directory for replacement with #{should}"
         FileUtils.rmtree(self[:path])
       else
         notice "Not removing directory; use 'force' to override"
       end
     when "link", "file"
       debug "Removing existing #{s.ftype} for replacement with #{should}"
       File.unlink(self[:path])
     else
       self.fail "Could not back up files of type #{s.ftype}"
     end
     expire
   end
 
   def retrieve
     if source = parameter(:source)
       source.copy_source_values
     end
     super
   end
 
   # Set the checksum, from another property.  There are multiple
   # properties that modify the contents of a file, and they need the
   # ability to make sure that the checksum value is in sync.
   def setchecksum(sum = nil)
     if @parameters.include? :checksum
       if sum
         @parameters[:checksum].checksum = sum
       else
         # If they didn't pass in a sum, then tell checksum to
         # figure it out.
         currentvalue = @parameters[:checksum].retrieve
         @parameters[:checksum].checksum = currentvalue
       end
     end
   end
 
   # Should this thing be a normal file?  This is a relatively complex
   # way of determining whether we're trying to create a normal file,
   # and it's here so that the logic isn't visible in the content property.
   def should_be_file?
     return true if self[:ensure] == :file
 
     # I.e., it's set to something like "directory"
     return false if e = self[:ensure] and e != :present
 
     # The user doesn't really care, apparently
     if self[:ensure] == :present
       return true unless s = stat
       return(s.ftype == "file" ? true : false)
     end
 
     # If we've gotten here, then :ensure isn't set
     return true if self[:content]
     return true if stat and stat.ftype == "file"
     false
   end
 
   # Stat our file.  Depending on the value of the 'links' attribute, we
   # use either 'stat' or 'lstat', and we expect the properties to use the
   # resulting stat object accordingly (mostly by testing the 'ftype'
   # value).
   cached_attr(:stat) do
     method = :stat
 
     # Files are the only types that support links
     if (self.class.name == :file and self[:links] != :follow) or self.class.name == :tidy
       method = :lstat
     end
     path = self[:path]
 
     begin
       File.send(method, self[:path])
     rescue Errno::ENOENT => error
       return nil
     rescue Errno::EACCES => error
       warning "Could not stat; permission denied"
       return nil
     end
   end
 
   # We have to hack this just a little bit, because otherwise we'll get
   # an error when the target and the contents are created as properties on
   # the far side.
   def to_trans(retrieve = true)
     obj = super
     obj.delete(:target) if obj[:target] == :notlink
     obj
   end
 
   # Write out the file.  Requires the property name for logging.
   # Write will be done by the content property, along with checksum computation
   def write(property)
     remove_existing(:file)
 
     use_temporary_file = write_temporary_file?
     if use_temporary_file
       path = "#{self[:path]}.puppettmp_#{rand(10000)}"
       path = "#{self[:path]}.puppettmp_#{rand(10000)}" while File.exists?(path) or File.symlink?(path)
     else
       path = self[:path]
     end
 
     mode = self.should(:mode) # might be nil
     umask = mode ? 000 : 022
+    mode_int = mode ? mode.to_i(8) : nil
 
-    content_checksum = Puppet::Util.withumask(umask) { File.open(path, 'w', mode) { |f| write_content(f) } }
+    content_checksum = Puppet::Util.withumask(umask) { File.open(path, 'w', mode_int ) { |f| write_content(f) } }
 
     # And put our new file in place
     if use_temporary_file # This is only not true when our file is empty.
       begin
         fail_if_checksum_is_wrong(path, content_checksum) if validate_checksum?
         File.rename(path, self[:path])
       rescue => detail
         fail "Could not rename temporary file #{path} to #{self[:path]}: #{detail}"
       ensure
         # Make sure the created file gets removed
         File.unlink(path) if FileTest.exists?(path)
       end
     end
 
     # make sure all of the modes are actually correct
     property_fix
 
   end
 
   private
 
   # Should we validate the checksum of the file we're writing?
   def validate_checksum?
     self[:checksum] !~ /time/
   end
 
   # Make sure the file we wrote out is what we think it is.
   def fail_if_checksum_is_wrong(path, content_checksum)
     newsum = parameter(:checksum).sum_file(path)
     return if [:absent, nil, content_checksum].include?(newsum)
 
     self.fail "File written to disk did not match checksum; discarding changes (#{content_checksum} vs #{newsum})"
   end
 
   # write the current content. Note that if there is no content property
   # simply opening the file with 'w' as done in write is enough to truncate
   # or write an empty length file.
   def write_content(file)
     (content = property(:content)) && content.write(file)
   end
 
   private
 
   def write_temporary_file?
     # unfortunately we don't know the source file size before fetching it
     # so let's assume the file won't be empty
     (c = property(:content) and c.length) || (s = @parameters[:source] and 1)
   end
 
   # There are some cases where all of the work does not get done on
   # file creation/modification, so we have to do some extra checking.
   def property_fix
     properties.each do |thing|
       next unless [:mode, :owner, :group, :seluser, :selrole, :seltype, :selrange].include?(thing.name)
 
       # Make sure we get a new stat objct
       expire
       currentvalue = thing.retrieve
       thing.sync unless thing.insync?(currentvalue)
     end
   end
 end
 
 # We put all of the properties in separate files, because there are so many
 # of them.  The order these are loaded is important, because it determines
 # the order they are in the property lit.
 require 'puppet/type/file/checksum'
 require 'puppet/type/file/content'     # can create the file
 require 'puppet/type/file/source'      # can create the file
 require 'puppet/type/file/target'      # creates a different type of file
 require 'puppet/type/file/ensure'      # can create the file
 require 'puppet/type/file/owner'
 require 'puppet/type/file/group'
 require 'puppet/type/file/mode'
 require 'puppet/type/file/type'
 require 'puppet/type/file/selcontext'  # SELinux file context
diff --git a/lib/puppet/type/file/ensure.rb b/lib/puppet/type/file/ensure.rb
index 967e06aee..4a68551ee 100755
--- a/lib/puppet/type/file/ensure.rb
+++ b/lib/puppet/type/file/ensure.rb
@@ -1,170 +1,170 @@
 module Puppet
   Puppet::Type.type(:file).ensurable do
     require 'etc'
     desc "Whether to create files that don't currently exist.
       Possible values are *absent*, *present*, *file*, and *directory*.
       Specifying `present` will match any form of file existence, and
       if the file is missing will create an empty file. Specifying
       `absent` will delete the file (and directory if recurse => true).
 
       Anything other than those values will be considered to be a symlink.
       For instance, the following text creates a link:
 
           # Useful on solaris
           file { \"/etc/inetd.conf\":
             ensure => \"/etc/inet/inetd.conf\"
           }
 
       You can make relative links:
 
           # Useful on solaris
           file { \"/etc/inetd.conf\":
             ensure => \"inet/inetd.conf\"
           }
 
       If you need to make a relative link to a file named the same
       as one of the valid values, you must prefix it with `./` or
       something similar.
 
       You can also make recursive symlinks, which will create a
       directory structure that maps to the target directory,
       with directories corresponding to each directory
       and links corresponding to each file."
 
     # Most 'ensure' properties have a default, but with files we, um, don't.
     nodefault
 
     newvalue(:absent) do
       File.unlink(@resource[:path])
     end
 
     aliasvalue(:false, :absent)
 
     newvalue(:file, :event => :file_created) do
       # Make sure we're not managing the content some other way
       if property = @resource.property(:content)
         property.sync
       else
         @resource.write(:ensure)
         mode = @resource.should(:mode)
       end
     end
 
     #aliasvalue(:present, :file)
     newvalue(:present, :event => :file_created) do
       # Make a file if they want something, but this will match almost
       # anything.
       set_file
     end
 
     newvalue(:directory, :event => :directory_created) do
       mode = @resource.should(:mode)
       parent = File.dirname(@resource[:path])
       unless FileTest.exists? parent
         raise Puppet::Error,
           "Cannot create #{@resource[:path]}; parent directory #{parent} does not exist"
       end
       if mode
         Puppet::Util.withumask(000) do
-          Dir.mkdir(@resource[:path],mode)
+          Dir.mkdir(@resource[:path], mode.to_i(8))
         end
       else
         Dir.mkdir(@resource[:path])
       end
       @resource.send(:property_fix)
       return :directory_created
     end
 
 
     newvalue(:link, :event => :link_created) do
       fail "Cannot create a symlink without a target" unless property = resource.property(:target)
       property.retrieve
       property.mklink
     end
 
     # Symlinks.
     newvalue(/./) do
       # This code never gets executed.  We need the regex to support
       # specifying it, but the work is done in the 'symlink' code block.
     end
 
     munge do |value|
       value = super(value)
       value,resource[:target] = :link,value unless value.is_a? Symbol
       resource[:links] = :manage if value == :link and resource[:links] != :follow
       value
     end
 
     def change_to_s(currentvalue, newvalue)
       return super unless newvalue.to_s == "file"
 
       return super unless property = @resource.property(:content)
 
       # We know that content is out of sync if we're here, because
       # it's essentially equivalent to 'ensure' in the transaction.
       if source = @resource.parameter(:source)
         should = source.checksum
       else
         should = property.should
       end
       if should == :absent
         is = property.retrieve
       else
         is = :absent
       end
 
       property.change_to_s(is, should)
     end
 
     # Check that we can actually create anything
     def check
       basedir = File.dirname(@resource[:path])
 
       if ! FileTest.exists?(basedir)
         raise Puppet::Error,
           "Can not create #{@resource.title}; parent directory does not exist"
       elsif ! FileTest.directory?(basedir)
         raise Puppet::Error,
           "Can not create #{@resource.title}; #{dirname} is not a directory"
       end
     end
 
     # We have to treat :present specially, because it works with any
     # type of file.
     def insync?(currentvalue)
       unless currentvalue == :absent or resource.replace?
         return true
       end
 
       if self.should == :present
         return !(currentvalue.nil? or currentvalue == :absent)
       else
         return super(currentvalue)
       end
     end
 
     def retrieve
       if stat = @resource.stat(false)
         return stat.ftype.intern
       else
         if self.should == :false
           return :false
         else
           return :absent
         end
       end
     end
 
     def sync
       @resource.remove_existing(self.should)
       if self.should == :absent
         return :file_removed
       end
 
       event = super
 
       event
     end
   end
 end
 
diff --git a/lib/puppet/type/file/mode.rb b/lib/puppet/type/file/mode.rb
index 1ce56c843..2acd8b359 100755
--- a/lib/puppet/type/file/mode.rb
+++ b/lib/puppet/type/file/mode.rb
@@ -1,124 +1,90 @@
 # Manage file modes.  This state should support different formats
 # for specification (e.g., u+rwx, or -0011), but for now only supports
 # specifying the full mode.
 module Puppet
   Puppet::Type.type(:file).newproperty(:mode) do
     require 'etc'
     desc "Mode the file should be.  Currently relatively limited:
       you must specify the exact mode the file should be.
 
       Note that when you set the mode of a directory, Puppet always
       sets the search/traverse (1) bit anywhere the read (4) bit is set.
       This is almost always what you want: read allows you to list the
       entries in a directory, and search/traverse allows you to access
       (read/write/execute) those entries.)  Because of this feature, you
       can recursively make a directory and all of the files in it
       world-readable by setting e.g.:
 
           file { '/some/dir':
             mode => 644,
             recurse => true,
           }
 
       In this case all of the files underneath `/some/dir` will have
       mode 644, and all of the directories will have mode 755."
 
     @event = :file_changed
 
-    # Our modes are octal, so make sure they print correctly.  Other
-    # valid values are symbols, basically
-    def is_to_s(currentvalue)
-      case currentvalue
-      when Integer
-        return "%o" % currentvalue
-      when Symbol
-        return currentvalue
-      else
-        raise Puppet::DevError, "Invalid current value for mode: #{currentvalue.inspect}"
-      end
-    end
-
-    def should_to_s(newvalue = @should)
-      case newvalue
-      when Integer
-        return "%o" % newvalue
-      when Symbol
-        return newvalue
-      else
-        raise Puppet::DevError, "Invalid 'should' value for mode: #{newvalue.inspect}"
-      end
-    end
-
     munge do |should|
-      # this is pretty hackish, but i need to make sure the number is in
-      # octal, yet the number can only be specified as a string right now
-      value = should
-      if value.is_a?(String)
-        unless value =~ /^\d+$/
-          raise Puppet::Error, "File modes can only be numbers, not #{value.inspect}"
-        end
-        # Make sure our number looks like octal.
-        unless value =~ /^0/
-          value = "0#{value}"
-        end
-        old = value
-        begin
-          value = Integer(value)
-        rescue ArgumentError => detail
-          raise Puppet::DevError, "Could not convert #{old.inspect} to integer"
+      if should.is_a?(String)
+        unless should =~ /^[0-7]+$/
+          raise Puppet::Error, "File modes can only be octal numbers, not #{should.inspect}"
         end
+        should.to_i(8).to_s(8)
+      else
+        should.to_s(8)
       end
-
-      return value
     end
 
     # If we're a directory, we need to be executable for all cases
     # that are readable.  This should probably be selectable, but eh.
     def dirmask(value)
       if FileTest.directory?(@resource[:path])
+        value = value.to_i(8)
         value |= 0100 if value & 0400 != 0
         value |= 010 if value & 040 != 0
         value |= 01 if value & 04 != 0
+        value = value.to_s(8)
       end
 
       value
     end
 
     def insync?(currentvalue)
       if stat = @resource.stat and stat.ftype == "link" and @resource[:links] != :follow
         self.debug "Not managing symlink mode"
         return true
       else
         return super(currentvalue)
       end
     end
 
     def retrieve
       # If we're not following links and we're a link, then we just turn
       # off mode management entirely.
 
       if stat = @resource.stat(false)
         unless defined?(@fixed)
           @should &&= @should.collect { |s| self.dirmask(s) }
         end
-        return stat.mode & 007777
+        return (stat.mode & 007777).to_s(8)
       else
         return :absent
       end
     end
 
     def sync
       mode = self.should
 
       begin
-        File.chmod(mode, @resource[:path])
+        File.chmod(mode.to_i(8), @resource[:path])
       rescue => detail
         error = Puppet::Error.new("failed to chmod #{@resource[:path]}: #{detail.message}")
         error.set_backtrace detail.backtrace
         raise error
       end
       :file_changed
     end
   end
 end
 
diff --git a/spec/unit/transaction/resource_harness_spec.rb b/spec/unit/transaction/resource_harness_spec.rb
index 255481ae4..4611409d5 100755
--- a/spec/unit/transaction/resource_harness_spec.rb
+++ b/spec/unit/transaction/resource_harness_spec.rb
@@ -1,401 +1,401 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../../spec_helper'
 
 require 'puppet/transaction/resource_harness'
 
 describe Puppet::Transaction::ResourceHarness do
   before do
     @transaction = Puppet::Transaction.new(Puppet::Resource::Catalog.new)
     @resource = Puppet::Type.type(:file).new :path => "/my/file"
     @harness = Puppet::Transaction::ResourceHarness.new(@transaction)
     @current_state = Puppet::Resource.new(:file, "/my/file")
     @resource.stubs(:retrieve).returns @current_state
     @status = Puppet::Resource::Status.new(@resource)
     Puppet::Resource::Status.stubs(:new).returns @status
   end
 
   it "should accept a transaction at initialization" do
     harness = Puppet::Transaction::ResourceHarness.new(@transaction)
     harness.transaction.should equal(@transaction)
   end
 
   it "should delegate to the transaction for its relationship graph" do
     @transaction.expects(:relationship_graph).returns "relgraph"
     Puppet::Transaction::ResourceHarness.new(@transaction).relationship_graph.should == "relgraph"
   end
 
   describe "when copying audited parameters" do
     before do
       @resource = Puppet::Type.type(:file).new :path => "/foo/bar", :audit => :mode
     end
 
     it "should do nothing if no parameters are being audited" do
       @resource[:audit] = []
       @harness.expects(:cached).never
       @harness.copy_audited_parameters(@resource, {}).should == []
     end
 
     it "should do nothing if an audited parameter already has a desired value set" do
       @resource[:mode] = "755"
       @harness.expects(:cached).never
       @harness.copy_audited_parameters(@resource, {}).should == []
     end
 
     it "should copy any cached values to the 'should' values" do
       @harness.cache(@resource, :mode, "755")
       @harness.copy_audited_parameters(@resource, {}).should == [:mode]
 
-      @resource[:mode].should == 0755
+      @resource[:mode].should == "755"
     end
 
     it "should cache and log the current value if no cached values are present" do
       @resource.expects(:debug)
       @harness.copy_audited_parameters(@resource, {:mode => "755"}).should == []
 
       @harness.cached(@resource, :mode).should == "755"
     end
   end
 
   describe "when evaluating a resource" do
     it "should create and return a resource status instance for the resource" do
       @harness.evaluate(@resource).should be_instance_of(Puppet::Resource::Status)
     end
 
     it "should fail if no status can be created" do
       Puppet::Resource::Status.expects(:new).raises ArgumentError
 
       lambda { @harness.evaluate(@resource) }.should raise_error
     end
 
     it "should retrieve the current state of the resource" do
       @resource.expects(:retrieve).returns @current_state
       @harness.evaluate(@resource)
     end
 
     it "should mark the resource as failed and return if the current state cannot be retrieved" do
       @resource.expects(:retrieve).raises ArgumentError
       @harness.evaluate(@resource).should be_failed
     end
 
     it "should use the status and retrieved state to determine which changes need to be made" do
       @harness.expects(:changes_to_perform).with(@status, @resource).returns []
       @harness.evaluate(@resource)
     end
 
     it "should mark the status as out of sync and apply the created changes if there are any" do
       changes = %w{mychanges}
       @harness.expects(:changes_to_perform).returns changes
       @harness.expects(:apply_changes).with(@status, changes)
       @harness.evaluate(@resource).should be_out_of_sync
     end
 
     it "should cache the last-synced time" do
       changes = %w{mychanges}
       @harness.stubs(:changes_to_perform).returns changes
       @harness.stubs(:apply_changes)
       @harness.expects(:cache).with { |resource, name, time| name == :synced and time.is_a?(Time) }
       @harness.evaluate(@resource)
     end
 
     it "should flush the resource when applying changes if appropriate" do
       changes = %w{mychanges}
       @harness.stubs(:changes_to_perform).returns changes
       @harness.stubs(:apply_changes)
       @resource.expects(:flush)
       @harness.evaluate(@resource)
     end
 
     it "should use the status and retrieved state to determine which changes need to be made" do
       @harness.expects(:changes_to_perform).with(@status, @resource).returns []
       @harness.evaluate(@resource)
     end
 
     it "should not attempt to apply changes if none need to be made" do
       @harness.expects(:changes_to_perform).returns []
       @harness.expects(:apply_changes).never
       @harness.evaluate(@resource).should_not be_out_of_sync
     end
 
     it "should store the resource's evaluation time in the resource status" do
       @harness.evaluate(@resource).evaluation_time.should be_instance_of(Float)
     end
 
     it "should set the change count to the total number of changes" do
       changes = %w{a b c d}
       @harness.expects(:changes_to_perform).returns changes
       @harness.expects(:apply_changes).with(@status, changes)
       @harness.evaluate(@resource).change_count.should == 4
     end
   end
 
   describe "when creating changes" do
     before do
       @current_state = Puppet::Resource.new(:file, "/my/file")
       @resource.stubs(:retrieve).returns @current_state
       Puppet.features.stubs(:root?).returns true
     end
 
     it "should retrieve the current values from the resource" do
       @resource.expects(:retrieve).returns @current_state
       @harness.changes_to_perform(@status, @resource)
     end
 
     it "should cache that the resource was checked" do
       @harness.expects(:cache).with { |resource, name, time| name == :checked and time.is_a?(Time) }
       @harness.changes_to_perform(@status, @resource)
     end
 
     it "should create changes with the appropriate property and current value" do
       @resource[:ensure] = :present
       @current_state[:ensure] = :absent
 
       change = stub 'change'
       Puppet::Transaction::Change.expects(:new).with(@resource.parameter(:ensure), :absent).returns change
 
       @harness.changes_to_perform(@status, @resource)[0].should equal(change)
     end
 
     it "should not attempt to manage properties that do not have desired values set" do
       mode = @resource.newattr(:mode)
       @current_state[:mode] = :absent
 
       mode.expects(:insync?).never
 
       @harness.changes_to_perform(@status, @resource)
     end
 
     it "should copy audited parameters" do
       @resource[:audit] = :mode
       @harness.cache(@resource, :mode, "755")
       @harness.changes_to_perform(@status, @resource)
-      @resource[:mode].should == 0755
+      @resource[:mode].should == "755"
     end
 
     it "should mark changes created as a result of auditing as auditing changes" do
       @current_state[:mode] = 0644
       @resource[:audit] = :mode
       @harness.cache(@resource, :mode, "755")
       @harness.changes_to_perform(@status, @resource)[0].must be_auditing
     end
 
     describe "and the 'ensure' parameter is present but not in sync" do
       it "should return a single change for the 'ensure' parameter" do
         @resource[:ensure] = :present
         @resource[:mode] = "755"
         @current_state[:ensure] = :absent
         @current_state[:mode] = :absent
 
         @resource.stubs(:retrieve).returns @current_state
 
         changes = @harness.changes_to_perform(@status, @resource)
         changes.length.should == 1
         changes[0].property.name.should == :ensure
       end
     end
 
     describe "and the 'ensure' parameter should be set to 'absent', and is correctly set to 'absent'" do
       it "should return no changes" do
         @resource[:ensure] = :absent
         @resource[:mode] = "755"
         @current_state[:ensure] = :absent
         @current_state[:mode] = :absent
 
         @harness.changes_to_perform(@status, @resource).should == []
       end
     end
 
     describe "and the 'ensure' parameter is 'absent' and there is no 'desired value'" do
       it "should return no changes" do
         @resource.newattr(:ensure)
         @resource[:mode] = "755"
         @current_state[:ensure] = :absent
         @current_state[:mode] = :absent
 
         @harness.changes_to_perform(@status, @resource).should == []
       end
     end
 
     describe "and non-'ensure' parameters are not in sync" do
       it "should return a change for each parameter that is not in sync" do
         @resource[:ensure] = :present
         @resource[:mode] = "755"
         @resource[:owner] = 0
         @current_state[:ensure] = :present
         @current_state[:mode] = 0444
         @current_state[:owner] = 50
 
         mode = stub 'mode_change'
         owner = stub 'owner_change'
         Puppet::Transaction::Change.expects(:new).with(@resource.parameter(:mode), 0444).returns mode
         Puppet::Transaction::Change.expects(:new).with(@resource.parameter(:owner), 50).returns owner
 
         changes = @harness.changes_to_perform(@status, @resource)
         changes.length.should == 2
         changes.should be_include(mode)
         changes.should be_include(owner)
       end
     end
 
     describe "and all parameters are in sync" do
       it "should return an empty array" do
         @resource[:ensure] = :present
         @resource[:mode] = "755"
         @current_state[:ensure] = :present
-        @current_state[:mode] = 0755
+        @current_state[:mode] = "755"
         @harness.changes_to_perform(@status, @resource).should == []
       end
     end
   end
 
   describe "when applying changes" do
     before do
       @change1 = stub 'change1', :apply => stub("event", :status => "success"), :auditing? => false
       @change2 = stub 'change2', :apply => stub("event", :status => "success"), :auditing? => false
       @changes = [@change1, @change2]
     end
 
     it "should apply the change" do
       @change1.expects(:apply).returns( stub("event", :status => "success") )
       @change2.expects(:apply).returns( stub("event", :status => "success") )
 
       @harness.apply_changes(@status, @changes)
     end
 
     it "should mark the resource as changed" do
       @harness.apply_changes(@status, @changes)
 
       @status.should be_changed
     end
 
     it "should queue the resulting event" do
       @harness.apply_changes(@status, @changes)
 
       @status.events.should be_include(@change1.apply)
       @status.events.should be_include(@change2.apply)
     end
 
     it "should cache the new value if it is an auditing change" do
       @change1.expects(:auditing?).returns true
       property = stub 'property', :name => "foo", :resource => "myres"
       @change1.stubs(:property).returns property
       @change1.stubs(:is).returns "myval"
 
       @harness.apply_changes(@status, @changes)
 
       @harness.cached("myres", "foo").should == "myval"
     end
   end
 
   describe "when determining whether the resource can be changed" do
     before do
       @resource.stubs(:purging?).returns true
       @resource.stubs(:deleting?).returns true
     end
 
     it "should be true if the resource is not being purged" do
       @resource.expects(:purging?).returns false
       @harness.should be_allow_changes(@resource)
     end
 
     it "should be true if the resource is not being deleted" do
       @resource.expects(:deleting?).returns false
       @harness.should be_allow_changes(@resource)
     end
 
     it "should be true if the resource has no dependents" do
       @harness.relationship_graph.expects(:dependents).with(@resource).returns []
       @harness.should be_allow_changes(@resource)
     end
 
     it "should be true if all dependents are being deleted" do
       dep = stub 'dependent', :deleting? => true
       @harness.relationship_graph.expects(:dependents).with(@resource).returns [dep]
       @resource.expects(:purging?).returns true
       @harness.should be_allow_changes(@resource)
     end
 
     it "should be false if the resource's dependents are not being deleted" do
       dep = stub 'dependent', :deleting? => false, :ref => "myres"
       @resource.expects(:warning)
       @harness.relationship_graph.expects(:dependents).with(@resource).returns [dep]
       @harness.should_not be_allow_changes(@resource)
     end
   end
 
   describe "when finding the schedule" do
     before do
       @catalog = Puppet::Resource::Catalog.new
       @resource.catalog = @catalog
     end
 
     it "should warn and return nil if the resource has no catalog" do
       @resource.catalog = nil
       @resource.expects(:warning)
 
       @harness.schedule(@resource).should be_nil
     end
 
     it "should return nil if the resource specifies no schedule" do
       @harness.schedule(@resource).should be_nil
     end
 
     it "should fail if the named schedule cannot be found" do
       @resource[:schedule] = "whatever"
       @resource.expects(:fail)
       @harness.schedule(@resource)
     end
 
     it "should return the named schedule if it exists" do
       sched = Puppet::Type.type(:schedule).new(:name => "sched")
       @catalog.add_resource(sched)
       @resource[:schedule] = "sched"
       @harness.schedule(@resource).to_s.should == sched.to_s
     end
   end
 
   describe "when determining if a resource is scheduled" do
     before do
       @catalog = Puppet::Resource::Catalog.new
       @resource.catalog = @catalog
       @status = Puppet::Resource::Status.new(@resource)
     end
 
     it "should return true if 'ignoreschedules' is set" do
       Puppet[:ignoreschedules] = true
       @resource[:schedule] = "meh"
       @harness.should be_scheduled(@status, @resource)
     end
 
     it "should return true if the resource has no schedule set" do
       @harness.should be_scheduled(@status, @resource)
     end
 
     it "should return the result of matching the schedule with the cached 'checked' time if a schedule is set" do
       t = Time.now
       @harness.expects(:cached).with(@resource, :checked).returns(t)
 
       sched = Puppet::Type.type(:schedule).new(:name => "sched")
       @catalog.add_resource(sched)
       @resource[:schedule] = "sched"
 
       sched.expects(:match?).with(t.to_i).returns "feh"
 
       @harness.scheduled?(@status, @resource).should == "feh"
     end
   end
 
   it "should be able to cache data in the Storage module" do
     data = {}
     Puppet::Util::Storage.expects(:cache).with(@resource).returns data
     @harness.cache(@resource, :foo, "something")
 
     data[:foo].should == "something"
   end
 
   it "should be able to retrieve data from the cache" do
     data = {:foo => "other"}
     Puppet::Util::Storage.expects(:cache).with(@resource).returns data
     @harness.cached(@resource, :foo).should == "other"
   end
 end
diff --git a/spec/unit/type/file/source_spec.rb b/spec/unit/type/file/source_spec.rb
index a45a1f74e..522ae1f0e 100755
--- a/spec/unit/type/file/source_spec.rb
+++ b/spec/unit/type/file/source_spec.rb
@@ -1,272 +1,272 @@
 #!/usr/bin/env ruby
 
 Dir.chdir(File.dirname(__FILE__)) { (s = lambda { |f| File.exist?(f) ? require(f) : Dir.chdir("..") { s.call(f) } }).call("spec/spec_helper.rb") }
 
 source = Puppet::Type.type(:file).attrclass(:source)
 describe Puppet::Type.type(:file).attrclass(:source) do
   before do
     # Wow that's a messy interface to the resource.
     @resource = stub 'resource', :[]= => nil, :property => nil, :catalog => stub("catalog", :dependent_data_expired? => false)
   end
 
   it "should be a subclass of Parameter" do
     source.superclass.must == Puppet::Parameter
   end
 
   describe "when initializing" do
     it "should fail if the set values are not URLs" do
       s = source.new(:resource => @resource)
       URI.expects(:parse).with('foo').raises RuntimeError
 
       lambda { s.value = %w{foo} }.must raise_error(Puppet::Error)
     end
 
     it "should fail if the URI is not a local file, file URI, or puppet URI" do
       s = source.new(:resource => @resource)
 
       lambda { s.value = %w{http://foo/bar} }.must raise_error(Puppet::Error)
     end
   end
 
   it "should have a method for retrieving its metadata" do
     source.new(:resource => @resource).must respond_to(:metadata)
   end
 
   it "should have a method for setting its metadata" do
     source.new(:resource => @resource).must respond_to(:metadata=)
   end
 
   describe "when returning the metadata" do
     before do
       @metadata = stub 'metadata', :source= => nil
     end
 
     it "should return already-available metadata" do
       @source = source.new(:resource => @resource)
       @source.metadata = "foo"
       @source.metadata.should == "foo"
     end
 
     it "should return nil if no @should value is set and no metadata is available" do
       @source = source.new(:resource => @resource)
       @source.metadata.should be_nil
     end
 
     it "should collect its metadata using the Metadata class if it is not already set" do
       @source = source.new(:resource => @resource, :value => "/foo/bar")
       Puppet::FileServing::Metadata.expects(:find).with("/foo/bar").returns @metadata
       @source.metadata
     end
 
     it "should use the metadata from the first found source" do
       metadata = stub 'metadata', :source= => nil
       @source = source.new(:resource => @resource, :value => ["/foo/bar", "/fee/booz"])
       Puppet::FileServing::Metadata.expects(:find).with("/foo/bar").returns nil
       Puppet::FileServing::Metadata.expects(:find).with("/fee/booz").returns metadata
       @source.metadata.should equal(metadata)
     end
 
     it "should store the found source as the metadata's source" do
       metadata = mock 'metadata'
       @source = source.new(:resource => @resource, :value => "/foo/bar")
       Puppet::FileServing::Metadata.expects(:find).with("/foo/bar").returns metadata
 
       metadata.expects(:source=).with("/foo/bar")
       @source.metadata
     end
 
     it "should fail intelligently if an exception is encountered while querying for metadata" do
       @source = source.new(:resource => @resource, :value => "/foo/bar")
       Puppet::FileServing::Metadata.expects(:find).with("/foo/bar").raises RuntimeError
 
       @source.expects(:fail).raises ArgumentError
       lambda { @source.metadata }.should raise_error(ArgumentError)
     end
 
     it "should fail if no specified sources can be found" do
       @source = source.new(:resource => @resource, :value => "/foo/bar")
       Puppet::FileServing::Metadata.expects(:find).with("/foo/bar").returns nil
 
       @source.expects(:fail).raises RuntimeError
 
       lambda { @source.metadata }.should raise_error(RuntimeError)
     end
 
     it "should expire the metadata appropriately" do
       expirer = stub 'expired', :dependent_data_expired? => true
 
       metadata = stub 'metadata', :source= => nil
       Puppet::FileServing::Metadata.expects(:find).with("/fee/booz").returns metadata
 
       @source = source.new(:resource => @resource, :value => ["/fee/booz"])
       @source.metadata = "foo"
 
       @source.stubs(:expirer).returns expirer
 
       @source.metadata.should_not == "foo"
     end
   end
 
   it "should have a method for setting the desired values on the resource" do
     source.new(:resource => @resource).must respond_to(:copy_source_values)
   end
 
   describe "when copying the source values" do
     before do
 
       @resource = Puppet::Type.type(:file).new :path => "/foo/bar"
 
       @source = source.new(:resource => @resource)
       @metadata = stub 'metadata', :owner => 100, :group => 200, :mode => 123, :checksum => "{md5}asdfasdf", :ftype => "file"
       @source.stubs(:metadata).returns @metadata
     end
 
     it "should fail if there is no metadata" do
       @source.stubs(:metadata).returns nil
       @source.expects(:devfail).raises ArgumentError
       lambda { @source.copy_source_values }.should raise_error(ArgumentError)
     end
 
     it "should set :ensure to the file type" do
       @metadata.stubs(:ftype).returns "file"
 
       @source.copy_source_values
       @resource[:ensure].must == :file
     end
 
     it "should not set 'ensure' if it is already set to 'absent'" do
       @metadata.stubs(:ftype).returns "file"
 
       @resource[:ensure] = :absent
       @source.copy_source_values
       @resource[:ensure].must == :absent
     end
 
     describe "and the source is a file" do
       before do
         @metadata.stubs(:ftype).returns "file"
       end
 
       it "should copy the metadata's owner, group, checksum, and mode to the resource if they are not set on the resource" do
         Puppet.features.expects(:root?).returns true
 
         @source.copy_source_values
 
         @resource[:owner].must == 100
         @resource[:group].must == 200
-        @resource[:mode].must == 123
+        @resource[:mode].must == "173"
 
         # Metadata calls it checksum, we call it content.
         @resource[:content].must == @metadata.checksum
       end
 
       it "should not copy the metadata's owner to the resource if it is already set" do
         @resource[:owner] = 1
         @resource[:group] = 2
         @resource[:mode] = 3
         @resource[:content] = "foobar"
 
         @source.copy_source_values
 
         @resource[:owner].must == 1
         @resource[:group].must == 2
-        @resource[:mode].must == 3
+        @resource[:mode].must == "3"
         @resource[:content].should_not == @metadata.checksum
       end
 
       describe "and puppet is not running as root" do
         it "should not try to set the owner" do
           Puppet.features.expects(:root?).returns false
 
           @source.copy_source_values
           @resource[:owner].should be_nil
         end
       end
     end
 
     describe "and the source is a link" do
       it "should set the target to the link destination" do
         @metadata.stubs(:ftype).returns "link"
         @resource.stubs(:[])
         @resource.stubs(:[]=)
 
         @metadata.expects(:destination).returns "/path/to/symlink"
 
         @resource.expects(:[]=).with(:target, "/path/to/symlink")
         @source.copy_source_values
       end
     end
   end
 
   it "should have a local? method" do
     source.new(:resource => @resource).must be_respond_to(:local?)
   end
 
   context "when accessing source properties" do
     before(:each) do
       @source = source.new(:resource => @resource)
       @metadata = stub_everything
       @source.stubs(:metadata).returns(@metadata)
     end
 
     describe "for local sources" do
       before(:each) do
         @metadata.stubs(:ftype).returns "file"
         @metadata.stubs(:source).returns("file:///path/to/source")
       end
 
       it "should be local" do
         @source.must be_local
       end
 
       it "should be local if there is no scheme" do
         @metadata.stubs(:source).returns("/path/to/source")
         @source.must be_local
       end
 
       it "should be able to return the metadata source full path" do
         @source.full_path.should == "/path/to/source"
       end
     end
 
     describe "for remote sources" do
       before(:each) do
         @metadata.stubs(:ftype).returns "file"
         @metadata.stubs(:source).returns("puppet://server:8192/path/to/source")
       end
 
       it "should not be local" do
         @source.should_not be_local
       end
 
       it "should be able to return the metadata source full path" do
         @source.full_path.should == "/path/to/source"
       end
 
       it "should be able to return the source server" do
         @source.server.should == "server"
       end
 
       it "should be able to return the source port" do
         @source.port.should == 8192
       end
 
       describe "which don't specify server or port" do
         before(:each) do
           @metadata.stubs(:source).returns("puppet:///path/to/source")
         end
 
         it "should return the default source server" do
           Puppet.settings.expects(:[]).with(:server).returns("myserver")
           @source.server.should == "myserver"
         end
 
         it "should return the default source port" do
           Puppet.settings.expects(:[]).with(:masterport).returns(1234)
           @source.port.should == 1234
         end
       end
     end
   end
 
 end
diff --git a/test/language/snippets.rb b/test/language/snippets.rb
index 51c5e23fe..a10e8e870 100755
--- a/test/language/snippets.rb
+++ b/test/language/snippets.rb
@@ -1,519 +1,522 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../lib/puppettest'
 
 require 'puppet'
 require 'puppet/parser/parser'
 require 'puppet/network/client'
 require 'puppet/network/handler'
 require 'puppettest'
 
 class TestSnippets < Test::Unit::TestCase
   include PuppetTest
 
   def setup
     super
     @file = Puppet::Type.type(:file)
     Facter.stubs(:to_hash).returns({})
     Facter.stubs(:value).returns("whatever")
   end
 
   def self.snippetdir
     PuppetTest.datadir "snippets"
   end
 
   def assert_file(path, msg = nil)
     unless file = @catalog.resource(:file, path)
       msg ||= "Could not find file #{path}"
       raise msg
     end
   end
 
   def assert_not_file(path, msg = nil)
     if file = @catalog.resource(:file, path)
       msg ||= "File #{path} exists!"
       raise msg
     end
   end
 
   def assert_mode_equal(mode, path)
+    if mode.is_a? Integer
+      mode = mode.to_s(8)
+    end
     unless file = @catalog.resource(:file, path)
       raise "Could not find file #{path}"
     end
 
     unless mode == file.should(:mode)
       raise "Mode for %s is incorrect: %o vs %o" % [path, mode, file.should(:mode)]
     end
   end
 
   def snippet(name)
     File.join(self.class.snippetdir, name)
   end
 
   def file2ast(file)
     parser = Puppet::Parser::Parser.new
     parser.file = file
     ast = parser.parse
 
     ast
   end
 
   def snippet2ast(text)
     parser = Puppet::Parser::Parser.new
     parser.string = text
     ast = parser.parse
 
     ast
   end
 
   def client
     args = {
       :Listen => false
     }
     Puppet::Network::Client.new(args)
   end
 
   def ast2scope(ast)
     scope = Puppet::Parser::Scope.new
     ast.evaluate(scope)
 
     scope
   end
 
   def scope2objs(scope)
     objs = scope.to_trans
   end
 
   def snippet2scope(snippet)
     ast = snippet2ast(snippet)
     scope = ast2scope(ast)
   end
 
   def snippet2objs(snippet)
     ast = snippet2ast(snippet)
     scope = ast2scope(ast)
     objs = scope2objs(scope)
   end
 
   def properties(type)
     properties = type.validproperties
   end
 
   def metaparams(type)
     mparams = []
     Puppet::Type.eachmetaparam { |param|
       mparams.push param
     }
 
     mparams
   end
 
   def params(type)
     params = []
     type.parameters.each { |name,property|
       params.push name
     }
 
     params
   end
 
   def randthing(thing,type)
     list = self.send(thing,type)
     list[rand(list.length)]
   end
 
   def randeach(type)
     [:properties, :metaparams, :parameters].collect { |thing|
       randthing(thing,type)
     }
   end
 
   @@snippets = {
     true => [
       %{File { mode => 755 }}
     ],
   }
 
   def disabled_test_defaults
     Puppet::Type.eachtype { |type|
       next if type.name == :puppet or type.name == :component
 
       rands = randeach(type)
 
       name = type.name.to_s.capitalize
 
       [0..1, 0..2].each { |range|
         params = rands[range]
         paramstr = params.collect { |param|
           "#{param} => fake"
         }.join(", ")
 
         str = "#{name} { #{paramstr} }"
 
         scope = nil
         assert_nothing_raised {
           scope = snippet2scope(str)
         }
 
         defaults = nil
         assert_nothing_raised {
           defaults = scope.lookupdefaults(name)
         }
 
         p defaults
 
         params.each { |param|
           puts "#{name} => '#{param}'"
           assert(defaults.include?(param))
         }
       }
     }
   end
 
   # this is here in case no tests get defined; otherwise we get a warning
   def test_nothing
   end
 
   def snippet_filecreate
     %w{a b c d}.each { |letter|
       path = "/tmp/create#{letter}test"
       assert_file(path)
       assert_mode_equal(0755, path) if %w{a b}.include?(letter)
     }
   end
 
   def snippet_simpledefaults
     path = "/tmp/defaulttest"
     assert_file(path)
     assert_mode_equal(0755, path)
   end
 
   def snippet_simpleselector
     files = %w{a b c d}.collect { |letter|
       path = "/tmp/snippetselect#{letter}test"
       assert_file(path)
       assert_mode_equal(0755, path)
     }
   end
 
   def snippet_classpathtest
     path = "/tmp/classtest"
 
     file = @catalog.resource(:file, path)
     assert(file, "did not create file #{path}")
 
     assert_equal( "/Stage[main]/Testing/Mytype[componentname]/File[/tmp/classtest]", file.path)
   end
 
   def snippet_argumentdefaults
     path1 = "/tmp/argumenttest1"
     path2 = "/tmp/argumenttest2"
 
     file1 = @catalog.resource(:file, path1)
     file2 = @catalog.resource(:file, path2)
 
     assert_file(path1)
     assert_mode_equal(0755, path1)
 
     assert_file(path2)
     assert_mode_equal(0644, path2)
   end
 
   def snippet_casestatement
     paths = %w{
       /tmp/existsfile
       /tmp/existsfile2
       /tmp/existsfile3
       /tmp/existsfile4
       /tmp/existsfile5
       /tmp/existsfile6
     }
 
     paths.each { |path|
       file = @catalog.resource(:file, path)
       assert(file, "File #{path} is missing")
       assert_mode_equal(0755, path)
     }
   end
 
   def snippet_implicititeration
     paths = %w{a b c d e f g h}.collect { |l| "/tmp/iteration#{l}test" }
 
     paths.each { |path|
       file = @catalog.resource(:file, path)
       assert_file(path)
       assert_mode_equal(0755, path)
     }
   end
 
   def snippet_multipleinstances
     paths = %w{a b c}.collect { |l| "/tmp/multipleinstances#{l}" }
 
     paths.each { |path|
       assert_file(path)
       assert_mode_equal(0755, path)
 
     }
   end
 
   def snippet_namevartest
     file = "/tmp/testfiletest"
     dir = "/tmp/testdirtest"
     assert_file(file)
     assert_file(dir)
     assert_equal(:directory, @catalog.resource(:file, dir).should(:ensure), "Directory is not set to be a directory")
   end
 
   def snippet_scopetest
     file = "/tmp/scopetest"
     assert_file(file)
     assert_mode_equal(0755, file)
   end
 
   def snippet_selectorvalues
     nums = %w{1 2 3 4 5 6 7}
     files = nums.collect { |n|
       "/tmp/selectorvalues#{n}"
     }
 
     files.each { |f|
       assert_file(f)
       assert_mode_equal(0755, f)
     }
   end
 
   def snippet_singleselector
     nums = %w{1 2 3}
     files = nums.collect { |n|
       "/tmp/singleselector#{n}"
     }
 
     files.each { |f|
       assert_file(f)
       assert_mode_equal(0755, f)
     }
   end
 
   def snippet_falsevalues
     file = "/tmp/falsevaluesfalse"
     assert_file(file)
   end
 
   def disabled_snippet_classargtest
     [1,2].each { |num|
       file = "/tmp/classargtest#{num}"
       assert_file(file)
       assert_mode_equal(0755, file)
     }
   end
 
   def snippet_classheirarchy
     [1,2,3].each { |num|
       file = "/tmp/classheir#{num}"
       assert_file(file)
       assert_mode_equal(0755, file)
     }
   end
 
   def snippet_singleary
     [1,2,3,4].each { |num|
       file = "/tmp/singleary#{num}"
       assert_file(file)
     }
   end
 
   def snippet_classincludes
     [1,2,3].each { |num|
       file = "/tmp/classincludes#{num}"
       assert_file(file)
       assert_mode_equal(0755, file)
     }
   end
 
   def snippet_componentmetaparams
     ["/tmp/component1", "/tmp/component2"].each { |file|
       assert_file(file)
     }
   end
 
   def snippet_aliastest
     %w{/tmp/aliastest /tmp/aliastest2 /tmp/aliastest3}.each { |file|
       assert_file(file)
     }
   end
 
   def snippet_singlequote
     {   1 => 'a $quote',
       2 => 'some "\yayness\"'
     }.each { |count, str|
       path = "/tmp/singlequote#{count}"
       assert_file(path)
       assert_equal(str, @catalog.resource(:file, path).parameter(:content).actual_content)
     }
   end
 
   # There's no way to actually retrieve the list of classes from the
   # transaction.
   def snippet_tag
   end
 
   # Make sure that set tags are correctly in place, yo.
   def snippet_tagged
     tags = {"testing" => true, "yayness" => false,
       "both" => false, "bothtrue" => true, "define" => true}
 
     tags.each do |tag, retval|
       assert_file("/tmp/tagged#{tag}#{retval.to_s}")
     end
   end
 
   def snippet_defineoverrides
     file = "/tmp/defineoverrides1"
     assert_file(file)
     assert_mode_equal(0755, file)
   end
 
   def snippet_deepclassheirarchy
     5.times { |i|
       i += 1
       file = "/tmp/deepclassheir#{i}"
       assert_file(file)
     }
   end
 
   def snippet_emptyclass
     # There's nothing to check other than that it works
   end
 
   def snippet_emptyexec
     assert(@catalog.resource(:exec, "touch /tmp/emptyexectest"), "Did not create exec")
   end
 
   def snippet_multisubs
     path = "/tmp/multisubtest"
     assert_file(path)
     file = @catalog.resource(:file, path)
     assert_equal("{md5}5fbef65269a99bddc2106251dd89b1dc", file.should(:content), "sub2 did not override content")
     assert_mode_equal(0755, path)
   end
 
   def snippet_collection
     assert_file("/tmp/colltest1")
     assert_nil(@catalog.resource(:file, "/tmp/colltest2"), "Incorrectly collected file")
   end
 
   def snippet_virtualresources
     %w{1 2 3 4}.each do |num|
       assert_file("/tmp/virtualtest#{num}")
     end
   end
 
   def snippet_componentrequire
     %w{1 2}.each do |num|
 
             assert_file(
         "/tmp/testing_component_requires#{num}",
         
         "#{num} does not exist")
     end
   end
 
   def snippet_realize_defined_types
     assert_file("/tmp/realize_defined_test1")
     assert_file("/tmp/realize_defined_test2")
   end
 
   def snippet_collection_within_virtual_definitions
     assert_file("/tmp/collection_within_virtual_definitions1_foo.txt")
     assert_file("/tmp/collection_within_virtual_definitions2_foo2.txt")
   end
 
   def snippet_fqparents
     assert_file("/tmp/fqparent1", "Did not make file from parent class")
     assert_file("/tmp/fqparent2", "Did not make file from subclass")
   end
 
   def snippet_fqdefinition
     assert_file("/tmp/fqdefinition", "Did not make file from fully-qualified definition")
   end
 
   def snippet_subclass_name_duplication
     assert_file("/tmp/subclass_name_duplication1", "Did not make first file from duplicate subclass names")
     assert_file("/tmp/subclass_name_duplication2", "Did not make second file from duplicate subclass names")
   end
 
   def snippet_funccomma
     assert_file("/tmp/funccomma1", "Did not make first file from trailing function comma")
     assert_file("/tmp/funccomma2", "Did not make second file from trailing function comma")
   end
 
   def snippet_arraytrailingcomma
     assert_file("/tmp/arraytrailingcomma1", "Did not make first file from array")
     assert_file("/tmp/arraytrailingcomma2", "Did not make second file from array")
   end
 
   def snippet_multipleclass
     assert_file("/tmp/multipleclassone", "one")
     assert_file("/tmp/multipleclasstwo", "two")
   end
 
   def snippet_multilinecomments
     assert_not_file("/tmp/multilinecomments","Did create a commented resource");
   end
 
   def snippet_collection_override
     path = "/tmp/collection"
     assert_file(path)
     assert_mode_equal(0600, path)
   end
 
   def snippet_ifexpression
     assert_file("/tmp/testiftest","if test");
   end
 
   def snippet_hash
     assert_file("/tmp/myhashfile1","hash test 1");
     assert_file("/tmp/myhashfile2","hash test 2");
     assert_file("/tmp/myhashfile3","hash test 3");
     assert_file("/tmp/myhashfile4","hash test 4");
   end
 
   # Iterate across each of the snippets and create a test.
   Dir.entries(snippetdir).sort.each { |file|
     next if file =~ /^\./
 
 
     mname = "snippet_" + file.sub(/\.pp$/, '')
     if self.method_defined?(mname)
       #eval("alias #{testname} #{mname}")
       testname = ("test_#{mname}").intern
       self.send(:define_method, testname) {
         Puppet[:manifest] = snippet(file)
         facts = {
           "hostname" => "testhost",
           "domain" => "domain.com",
           "ipaddress" => "127.0.0.1",
           "fqdn" => "testhost.domain.com"
         }
 
         node = Puppet::Node.new("testhost")
         node.merge(facts)
 
         catalog = nil
         assert_nothing_raised("Could not compile catalog") {
           catalog = Puppet::Resource::Catalog.find(node)
         }
 
         assert_nothing_raised("Could not convert catalog") {
           catalog = catalog.to_ral
         }
 
         @catalog = catalog
         assert_nothing_raised {
           self.send(mname)
         }
       }
       mname = mname.intern
     end
   }
 end
diff --git a/test/ral/type/file.rb b/test/ral/type/file.rb
index 6322529cf..386c3ca1b 100755
--- a/test/ral/type/file.rb
+++ b/test/ral/type/file.rb
@@ -1,912 +1,912 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../../lib/puppettest'
 
 require 'puppettest'
 require 'puppettest/support/utils'
 require 'fileutils'
 require 'mocha'
 
 class TestFile < Test::Unit::TestCase
   include PuppetTest::Support::Utils
   include PuppetTest::FileTesting
 
   def mkfile(hash)
     file = nil
     assert_nothing_raised {
       file = Puppet::Type.type(:file).new(hash)
     }
     file
   end
 
   def mktestfile
     tmpfile = tempfile
     File.open(tmpfile, "w") { |f| f.puts rand(100) }
     @@tmpfiles.push tmpfile
     mkfile(:name => tmpfile)
   end
 
   def setup
     super
     @file = Puppet::Type.type(:file)
     $method = @method_name
     Puppet[:filetimeout] = -1
     Facter.stubs(:to_hash).returns({})
   end
 
   def teardown
     system("rm -rf #{Puppet[:statefile]}")
     super
   end
 
   def initstorage
     Puppet::Util::Storage.init
     Puppet::Util::Storage.load
   end
 
   def clearstorage
     Puppet::Util::Storage.store
     Puppet::Util::Storage.clear
   end
 
   def test_owner
     file = mktestfile
 
     users = {}
     count = 0
 
     # collect five users
     Etc.passwd { |passwd|
       if count > 5
         break
       else
         count += 1
       end
       users[passwd.uid] = passwd.name
     }
 
     fake = {}
     # find a fake user
     while true
       a = rand(1000)
       begin
         Etc.getpwuid(a)
       rescue
         fake[a] = "fakeuser"
         break
       end
     end
 
     uid, name = users.shift
     us = {}
     us[uid] = name
     users.each { |uid, name|
       assert_apply(file)
       assert_nothing_raised {
         file[:owner] = name
       }
       assert_nothing_raised {
         file.retrieve
       }
       assert_apply(file)
     }
   end
 
   def test_group
     file = mktestfile
     [%x{groups}.chomp.split(/ /), Process.groups].flatten.each { |group|
       assert_nothing_raised {
         file[:group] = group
       }
       assert(file.property(:group))
       assert(file.property(:group).should)
     }
   end
 
   def test_groups_fails_when_invalid
     assert_raise(Puppet::Error, "did not fail when the group was empty") do
       Puppet::Type.type(:file).new :path => "/some/file", :group => ""
     end
   end
 
   if Puppet.features.root?
     def test_createasuser
       dir = tmpdir
 
       user = nonrootuser
       path = File.join(tmpdir, "createusertesting")
       @@tmpfiles << path
 
       file = nil
       assert_nothing_raised {
 
               file = Puppet::Type.type(:file).new(
                 
           :path => path,
           :owner => user.name,
           :ensure => "file",
         
           :mode => "755"
         )
       }
 
       comp = mk_catalog("createusertest", file)
 
       assert_events([:file_created], comp)
     end
 
     def test_nofollowlinks
       basedir = tempfile
       Dir.mkdir(basedir)
       file = File.join(basedir, "file")
       link = File.join(basedir, "link")
 
       File.open(file, "w", 0644) { |f| f.puts "yayness"; f.flush }
       File.symlink(file, link)
 
       # First test 'user'
       user = nonrootuser
 
       inituser = File.lstat(link).uid
       File.lchown(inituser, nil, link)
 
       obj = nil
       assert_nothing_raised {
 
               obj = Puppet::Type.type(:file).new(
                 
           :title => link,
         
           :owner => user.name
         )
       }
       obj.retrieve
 
       # Make sure it defaults to managing the link
       assert_events([:file_changed], obj)
       assert_equal(user.uid, File.lstat(link).uid)
       assert_equal(inituser, File.stat(file).uid)
       File.chown(inituser, nil, file)
       File.lchown(inituser, nil, link)
 
       # Try following
       obj[:links] = :follow
       assert_events([:file_changed], obj)
       assert_equal(user.uid, File.stat(file).uid)
       assert_equal(inituser, File.lstat(link).uid)
 
       # And then explicitly managing
       File.chown(inituser, nil, file)
       File.lchown(inituser, nil, link)
       obj[:links] = :manage
       assert_events([:file_changed], obj)
       assert_equal(user.uid, File.lstat(link).uid)
       assert_equal(inituser, File.stat(file).uid)
 
       obj.delete(:owner)
       obj[:links] = :follow
 
       # And then test 'group'
       group = nonrootgroup
 
       initgroup = File.stat(file).gid
       obj[:group] = group.name
 
       obj[:links] = :follow
       assert_events([:file_changed], obj)
       assert_equal(group.gid, File.stat(file).gid)
       File.chown(nil, initgroup, file)
       File.lchown(nil, initgroup, link)
 
       obj[:links] = :manage
       assert_events([:file_changed], obj)
       assert_equal(group.gid, File.lstat(link).gid)
       assert_equal(initgroup, File.stat(file).gid)
     end
 
     def test_ownerasroot
       file = mktestfile
 
       users = {}
       count = 0
 
       # collect five users
       Etc.passwd { |passwd|
         if count > 5
           break
         else
           count += 1
         end
         next if passwd.uid < 0
         users[passwd.uid] = passwd.name
       }
 
       fake = {}
       # find a fake user
       while true
         a = rand(1000)
         begin
           Etc.getpwuid(a)
         rescue
           fake[a] = "fakeuser"
           break
         end
       end
 
       users.each { |uid, name|
         assert_nothing_raised {
           file[:owner] = name
         }
         assert_apply(file)
         currentvalue = file.retrieve
         assert(file.insync?(currentvalue))
         assert_nothing_raised {
           file[:owner] = uid
         }
         assert_apply(file)
         currentvalue = file.retrieve
         # make sure changing to number doesn't cause a sync
         assert(file.insync?(currentvalue))
       }
 
       # We no longer raise an error here, because we check at run time
       #fake.each { |uid, name|
       #    assert_raise(Puppet::Error) {
       #        file[:owner] = name
       #    }
       #    assert_raise(Puppet::Error) {
       #        file[:owner] = uid
       #    }
       #}
     end
 
     def test_groupasroot
       file = mktestfile
       [%x{groups}.chomp.split(/ /), Process.groups].flatten.each { |group|
         next unless Puppet::Util.gid(group) # grr.
         assert_nothing_raised {
           file[:group] = group
         }
         assert(file.property(:group))
         assert(file.property(:group).should)
         assert_apply(file)
         currentvalue = file.retrieve
         assert(file.insync?(currentvalue))
         assert_nothing_raised {
           file.delete(:group)
         }
       }
     end
 
     if Facter.value(:operatingsystem) == "Darwin"
       def test_sillyowner
         file = tempfile
         File.open(file, "w") { |f| f.puts "" }
         File.chown(-2, nil, file)
 
         assert(File.stat(file).uid > 120000, "eh?")
         user = nonrootuser
 
               obj = Puppet::Type.newfile(
                 
           :path => file,
         
           :owner => user.name
         )
 
         assert_apply(obj)
 
         assert_equal(user.uid, File.stat(file).uid)
       end
     end
   else
     $stderr.puts "Run as root for complete owner and group testing"
   end
 
   def test_create
     %w{a b c d}.collect { |name| tempfile + name.to_s }.each { |path|
       file =nil
       assert_nothing_raised {
 
               file = Puppet::Type.type(:file).new(
                 
           :name => path,
         
           :ensure => "file"
         )
       }
       assert_events([:file_created], file)
       assert_events([], file)
       assert(FileTest.file?(path), "File does not exist")
       @@tmpfiles.push path
     }
   end
 
   def test_create_dir
     basedir = tempfile
     Dir.mkdir(basedir)
     %w{a b c d}.collect { |name| "#{basedir}/#{name}" }.each { |path|
       file = nil
       assert_nothing_raised {
 
               file = Puppet::Type.type(:file).new(
                 
           :name => path,
         
           :ensure => "directory"
         )
       }
       assert(! FileTest.directory?(path), "Directory #{path} already exists")
       assert_events([:directory_created], file)
       assert_events([], file)
       assert(FileTest.directory?(path))
       @@tmpfiles.push path
     }
   end
 
   def test_modes
     file = mktestfile
     # Set it to something else initially
     File.chmod(0775, file.title)
     [0644,0755,0777,0641].each { |mode|
       assert_nothing_raised {
         file[:mode] = mode
       }
       assert_events([:mode_changed], file)
       assert_events([], file)
 
       assert_nothing_raised {
         file.delete(:mode)
       }
     }
   end
 
   def cyclefile(path)
     # i had problems with using :name instead of :path
     [:name,:path].each { |param|
       file = nil
       changes = nil
       comp = nil
       trans = nil
 
       initstorage
       assert_nothing_raised {
 
               file = Puppet::Type.type(:file).new(
                 
           param => path,
           :recurse => true,
         
           :checksum => "md5"
         )
       }
       comp = Puppet::Type.type(:component).new(
         :name => "component"
       )
       comp.push file
       assert_nothing_raised {
         trans = comp.evaluate
       }
       assert_nothing_raised {
         trans.evaluate
       }
       clearstorage
       Puppet::Type.allclear
     }
   end
 
   def test_filetype_retrieval
     file = nil
 
     # Verify it retrieves files of type directory
     assert_nothing_raised {
 
             file = Puppet::Type.type(:file).new(
                 
         :name => tmpdir,
         
         :check => :type
       )
     }
 
     assert_equal("directory", file.property(:type).retrieve)
 
     # And then check files
     assert_nothing_raised {
 
             file = Puppet::Type.type(:file).new(
                 
         :name => tempfile,
         
         :ensure => "file"
       )
     }
 
     assert_apply(file)
     file[:check] = "type"
     assert_apply(file)
 
     assert_equal("file", file.property(:type).retrieve)
   end
 
   def test_path
     dir = tempfile
 
     path = File.join(dir, "subdir")
 
     assert_nothing_raised("Could not make file") {
       FileUtils.mkdir_p(File.dirname(path))
       File.open(path, "w") { |f| f.puts "yayness" }
     }
 
     file = nil
     dirobj = nil
     assert_nothing_raised("Could not make file object") {
 
             dirobj = Puppet::Type.type(:file).new(
                 
         :path => dir,
         :recurse => true,
         
         :check => %w{mode owner group}
       )
     }
     catalog = mk_catalog dirobj
     transaction = Puppet::Transaction.new(catalog)
     transaction.eval_generate(dirobj)
 
     #assert_nothing_raised {
     #    dirobj.eval_generate
     #}
 
     file = catalog.resource(:file, path)
 
     assert(file, "Could not retrieve file object")
 
     assert_equal("/#{file.ref}", file.path)
   end
 
   def test_autorequire
     basedir = tempfile
     subfile = File.join(basedir, "subfile")
 
 
           baseobj = Puppet::Type.type(:file).new(
                 
       :name => basedir,
         
       :ensure => "directory"
     )
 
 
           subobj = Puppet::Type.type(:file).new(
                 
       :name => subfile,
         
       :ensure => "file"
     )
     catalog = mk_catalog(baseobj, subobj)
     edge = nil
     assert_nothing_raised do
       edge = subobj.autorequire.shift
     end
     assert_equal(baseobj, edge.source, "file did not require its parent dir")
     assert_equal(subobj, edge.target, "file did not require its parent dir")
   end
 
   # Unfortunately, I know this fails
   def disabled_test_recursivemkdir
     path = tempfile
     subpath = File.join(path, "this", "is", "a", "dir")
     file = nil
     assert_nothing_raised {
 
             file = Puppet::Type.type(:file).new(
                 
         :name => subpath,
         :ensure => "directory",
         
         :recurse => true
       )
     }
 
     comp = mk_catalog("yay", file)
     comp.finalize
     assert_apply(comp)
     #assert_events([:directory_created], comp)
 
     assert(FileTest.directory?(subpath), "Did not create directory")
   end
 
   # Make sure that content updates the checksum on the same run
   def test_checksumchange_for_content
     dest = tempfile
     File.open(dest, "w") { |f| f.puts "yayness" }
 
     file = nil
     assert_nothing_raised {
 
             file = Puppet::Type.type(:file).new(
                 
         :name => dest,
         :checksum => "md5",
         :content => "This is some content",
         
         :backup => false
       )
     }
 
     file.retrieve
 
     assert_events([:content_changed], file)
     file.retrieve
     assert_events([], file)
   end
 
   # Make sure that content updates the checksum on the same run
   def test_checksumchange_for_ensure
     dest = tempfile
 
     file = nil
     assert_nothing_raised {
 
             file = Puppet::Type.type(:file).new(
                 
         :name => dest,
         :checksum => "md5",
         
         :ensure => "file"
       )
     }
 
     file.retrieve
 
     assert_events([:file_created], file)
     file.retrieve
     assert_events([], file)
   end
 
   def test_nameandpath
     path = tempfile
 
     file = nil
     assert_nothing_raised {
 
             file = Puppet::Type.type(:file).new(
                 
         :title => "fileness",
         :path => path,
         
         :content => "this is some content"
       )
     }
 
     assert_apply(file)
 
     assert(FileTest.exists?(path))
   end
 
   # Make sure that a missing group isn't fatal at object instantiation time.
   def test_missinggroup
     file = nil
     assert_nothing_raised {
 
             file = Puppet::Type.type(:file).new(
                 
         :path => tempfile,
         
         :group => "fakegroup"
       )
     }
 
     assert(file.property(:group), "Group property failed")
   end
 
   def test_modecreation
     path = tempfile
 
           file = Puppet::Type.type(:file).new(
                 
       :path => path,
       :ensure => "file",
         
       :mode => "0777"
     )
-    assert_equal(0777, file.should(:mode), "Mode did not get set correctly")
+    assert_equal("777", file.should(:mode), "Mode did not get set correctly")
     assert_apply(file)
     assert_equal(0777, File.stat(path).mode & 007777, "file mode is incorrect")
     File.unlink(path)
     file[:ensure] = "directory"
     assert_apply(file)
     assert_equal(0777, File.stat(path).mode & 007777, "directory mode is incorrect")
   end
 
   # If both 'ensure' and 'content' are used, make sure that all of the other
   # properties are handled correctly.
   def test_contentwithmode
     path = tempfile
 
     file = nil
     assert_nothing_raised {
 
             file = Puppet::Type.type(:file).new(
                 
         :path => path,
         :ensure => "file",
         :content => "some text\n",
         
         :mode => 0755
       )
     }
 
     assert_apply(file)
     assert_equal("%o" % 0755, "%o" % (File.stat(path).mode & 007777))
   end
 
   def test_replacefilewithlink
     path = tempfile
     link = tempfile
 
     File.open(path, "w") { |f| f.puts "yay" }
     File.open(link, "w") { |f| f.puts "a file" }
 
     file = nil
     assert_nothing_raised {
 
             file = Puppet::Type.type(:file).new(
                 
         :ensure => path,
         :path => link,
         
         :backup => false
       )
     }
 
     assert_events([:link_created], file)
 
     assert(FileTest.symlink?(link), "Link was not created")
 
     assert_equal(path, File.readlink(link), "Link was created incorrectly")
   end
 
   def test_file_with_spaces
     dir = tempfile
     Dir.mkdir(dir)
     source = File.join(dir, "file spaces")
     dest = File.join(dir, "another space")
 
     File.open(source, "w") { |f| f.puts :yay }
 
           obj = Puppet::Type.type(:file).new(
                 
       :path => dest,
         
       :source => source
     )
     assert(obj, "Did not create file")
 
     assert_apply(obj)
 
     assert(FileTest.exists?(dest), "File did not get created")
   end
 
   # Testing #274.  Make sure target can be used without 'ensure'.
   def test_target_without_ensure
     source = tempfile
     dest = tempfile
     File.open(source, "w") { |f| f.puts "funtest" }
 
     obj = nil
     assert_nothing_raised {
       obj = Puppet::Type.newfile(:path => dest, :target => source)
     }
 
     assert_apply(obj)
   end
 
   def test_autorequire_owner_and_group
     file = tempfile
     comp = nil
     user = nil
     group =nil
     home = nil
     ogroup = nil
     assert_nothing_raised {
 
             user = Puppet::Type.type(:user).new(
                 
         :name => "pptestu",
         :home => file,
         
         :gid => "pptestg"
       )
 
             home = Puppet::Type.type(:file).new(
                 
         :path => file,
         :owner => "pptestu",
         :group => "pptestg",
         
         :ensure => "directory"
       )
       group = Puppet::Type.type(:group).new(
         :name => "pptestg"
       )
       comp = mk_catalog(user, group, home)
     }
 
     # Now make sure we get a relationship for each of these
     rels = nil
     assert_nothing_raised { rels = home.autorequire }
     assert(rels.detect { |e| e.source == user }, "owner was not autorequired")
     assert(rels.detect { |e| e.source == group }, "group was not autorequired")
   end
 
   # Testing #309 -- //my/file => /my/file
   def test_slash_deduplication
     ["/my/////file/for//testing", "/my/file/for/testing///",
       "/my/file/for/testing"].each do |path|
       file = nil
       assert_nothing_raised do
         file = Puppet::Type.newfile(:path => path)
       end
 
       assert_equal("/my/file/for/testing", file[:path])
     end
   end
 
   if Process.uid == 0
   # Testing #364.
   def test_writing_in_directories_with_no_write_access
     # Make a directory that our user does not have access to
     dir = tempfile
     Dir.mkdir(dir)
 
     # Get a fake user
     user = nonrootuser
     # and group
     group = nonrootgroup
 
     # First try putting a file in there
     path = File.join(dir, "file")
     file = Puppet::Type.newfile :path => path, :owner => user.name, :group => group.name, :content => "testing"
 
     # Make sure we can create it
     assert_apply(file)
     assert(FileTest.exists?(path), "File did not get created")
     # And that it's owned correctly
     assert_equal(user.uid, File.stat(path).uid, "File has the wrong owner")
     assert_equal(group.gid, File.stat(path).gid, "File has the wrong group")
 
     assert_equal("testing", File.read(path), "file has the wrong content")
 
     # Now make a dir
     subpath = File.join(dir, "subdir")
     subdir = Puppet::Type.newfile :path => subpath, :owner => user.name, :group => group.name, :ensure => :directory
     # Make sure we can create it
     assert_apply(subdir)
     assert(FileTest.directory?(subpath), "File did not get created")
     # And that it's owned correctly
     assert_equal(user.uid, File.stat(subpath).uid, "File has the wrong owner")
     assert_equal(group.gid, File.stat(subpath).gid, "File has the wrong group")
 
     assert_equal("testing", File.read(path), "file has the wrong content")
   end
   end
 
   # #366
   def test_replace_aliases
     file = Puppet::Type.newfile :path => tempfile
     file[:replace] = :yes
     assert_equal(:true, file[:replace], ":replace did not alias :true to :yes")
     file[:replace] = :no
     assert_equal(:false, file[:replace], ":replace did not alias :false to :no")
   end
 
   def test_pathbuilder
     dir = tempfile
     Dir.mkdir(dir)
     file = File.join(dir, "file")
     File.open(file, "w") { |f| f.puts "" }
     obj = Puppet::Type.newfile :path => dir, :recurse => true, :mode => 0755
     catalog = mk_catalog obj
     transaction = Puppet::Transaction.new(catalog)
 
     assert_equal("/#{obj.ref}", obj.path)
 
     list = transaction.eval_generate(obj)
     fileobj = catalog.resource(:file, file)
     assert(fileobj, "did not generate file object")
     assert_equal("/#{fileobj.ref}", fileobj.path, "did not generate correct subfile path")
   end
 
   # Testing #403
   def test_removal_with_content_set
     path = tempfile
     File.open(path, "w") { |f| f.puts "yay" }
     file = Puppet::Type.newfile(:name => path, :ensure => :absent, :content => "foo", :backup => false)
 
     assert_apply(file)
     assert(! FileTest.exists?(path), "File was not removed")
   end
 
   # Testing #438
   def test_creating_properties_conflict
     file = tempfile
     first = tempfile
     second = tempfile
     params = [:content, :source, :target]
     params.each do |param|
       assert_nothing_raised("#{param} conflicted with ensure") do
         Puppet::Type.newfile(:path => file, param => first, :ensure => :file)
       end
       params.each do |other|
         next if other == param
         assert_raise(Puppet::Error, "#{param} and #{other} did not conflict") do
           Puppet::Type.newfile(:path => file, other => first, param => second)
         end
       end
     end
   end
 
   # Testing #508
   if Process.uid == 0
   def test_files_replace_with_right_attrs
     source = tempfile
     File.open(source, "w") { |f|
       f.puts "some text"
     }
     File.chmod(0755, source)
     user = nonrootuser
     group = nonrootgroup
     path = tempfile
     good = {:uid => user.uid, :gid => group.gid, :mode => 0640}
 
     run = Proc.new do |obj, msg|
       assert_apply(obj)
       stat = File.stat(obj[:path])
       good.each do |should, sval|
         if should == :mode
           current = filemode(obj[:path])
         else
           current = stat.send(should)
         end
         assert_equal(sval, current, "Attr #{should} was not correct #{msg}")
       end
     end
 
 
           file = Puppet::Type.newfile(
         :path => path, :owner => user.name,
         
       :group => group.name, :mode => 0640, :backup => false)
     {:source => source, :content => "some content"}.each do |attr, value|
       file[attr] = value
       # First create the file
       run.call(file, "upon creation with #{attr}")
 
       # Now change something so that we replace the file
       case attr
       when :source
           File.open(source, "w") { |f| f.puts "some different text" }
       when :content; file[:content] = "something completely different"
       else
         raise "invalid attr #{attr}"
       end
 
       # Run it again
       run.call(file, "after modification with #{attr}")
 
       # Now remove the file and the attr
       file.delete(attr)
       File.unlink(path)
     end
   end
   end
 
   def test_root_dir_is_named_correctly
     obj = Puppet::Type.newfile(:path => '/', :mode => 0755)
     assert_equal("/", obj.title, "/ directory was changed to empty string")
   end
 
 end