diff --git a/test/ral/type/file.rb b/test/ral/type/file.rb
index cbbe818ae..5cf989aa3 100755
--- a/test/ral/type/file.rb
+++ b/test/ral/type/file.rb
@@ -1,1782 +1,1776 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../../lib/puppettest'
 
 require 'puppettest'
 require 'puppettest/support/utils'
 require 'fileutils'
 
 class TestFile < Test::Unit::TestCase
     include PuppetTest::Support::Utils
     include PuppetTest::FileTesting
 
     def mkfile(hash)
         file = nil
         assert_nothing_raised {
             file = Puppet.type(:file).create(hash)
         }
         return 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
     end
 
     def teardown
         Puppet::Util::Storage.clear
         system("rm -rf %s" % 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).create :path => "/some/file", :group => ""
         end
     end
 
     if Puppet::Util::SUIDManager.uid == 0
         def test_createasuser
             dir = tmpdir()
 
             user = nonrootuser()
             path = File.join(tmpdir, "createusertesting")
             @@tmpfiles << path
 
             file = nil
             assert_nothing_raised {
                 file = Puppet.type(:file).create(
                     :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(:file).create(
                     :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
 
-            assert_events([:file_changed], obj)
-            assert_equal(initgroup, File.stat(file).gid)
-            assert_equal(group.gid, File.lstat(link).gid)
-            File.chown(nil, initgroup, file)
-            File.lchown(nil, initgroup, link)
-
             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
                 }
                 changes = []
                 assert_nothing_raised() {
                     changes << file.evaluate
                 }
                 assert(changes.length > 0)
                 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(:file).create(
                     :name => path,
                     :ensure => "file"
                 )
             }
             assert_events([:file_created], file)
             assert_events([], file)
             assert(FileTest.file?(path), "File does not exist")
             assert(file.insync?(file.retrieve))
             @@tmpfiles.push path
         }
     end
 
     def test_create_dir
         basedir = tempfile()
         Dir.mkdir(basedir)
         %w{a b c d}.collect { |name| "#{basedir}/%s" % name }.each { |path|
             file = nil
             assert_nothing_raised() {
                 file = Puppet.type(:file).create(
                     :name => path,
                     :ensure => "directory"
                 )
             }
             assert(! FileTest.directory?(path), "Directory %s already exists" %
                 [path])
             assert_events([:directory_created], file)
             assert_events([], file)
             assert(file.insync?(file.retrieve))
             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([:file_changed], file)
             assert_events([], file)
 
             assert(file.insync?(file.retrieve))
 
             assert_nothing_raised() {
                 file.delete(:mode)
             }
         }
     end
 
     def test_checksums
         types = %w{md5 md5lite timestamp time}
         exists = "/tmp/sumtest-exists"
         nonexists = "/tmp/sumtest-nonexists"
 
         @@tmpfiles << exists
         @@tmpfiles << nonexists
 
         # try it both with files that exist and ones that don't
         files = [exists, nonexists]
         initstorage
         File.open(exists,File::CREAT|File::TRUNC|File::WRONLY) { |of|
             of.puts "initial text"
         }
         types.each { |type|
             files.each { |path|
                 if Puppet[:debug]
                     Puppet.warning "Testing %s on %s" % [type,path]
                 end
                 file = nil
                 events = nil
                 # okay, we now know that we have a file...
                 assert_nothing_raised() {
                     file = Puppet.type(:file).create(
                         :name => path,
                         :ensure => "file",
                         :checksum => type
                     )
                 }
                 trans = nil
 
                 currentvalues = file.retrieve
 
                 if file.title !~ /nonexists/
                     sum = file.property(:checksum)
                     assert(sum.insync?(currentvalues[sum]), "file is not in sync")
                 end
 
                 events = assert_apply(file)
 
                 assert(events)
 
                 assert(! events.include?(:file_changed), "File incorrectly changed")
                 assert_events([], file)
 
                 # We have to sleep because the time resolution of the time-based
                 # mechanisms is greater than one second
                 sleep 1 if type =~ /time/
 
                 assert_nothing_raised() {
                     File.open(path,File::CREAT|File::TRUNC|File::WRONLY) { |of|
                         of.puts "some more text, yo"
                     }
                 }
                 Puppet.type(:file).clear
 
                 # now recreate the file
                 assert_nothing_raised() {
                     file = Puppet.type(:file).create(
                         :name => path,
                         :checksum => type
                     )
                 }
                 trans = nil
 
                 assert_events([:file_changed], file)
 
                 # Run it a few times to make sure we aren't getting
                 # spurious changes.
                 sum = nil
                 assert_nothing_raised do
                     sum = file.property(:checksum).retrieve
                 end
                 assert(file.property(:checksum).insync?(sum),
                     "checksum is not in sync")
 
                 sleep 1.1 if type =~ /time/
                 assert_nothing_raised() {
                     File.unlink(path)
                     File.open(path,File::CREAT|File::TRUNC|File::WRONLY) { |of|
                         # We have to put a certain amount of text in here or
                         # the md5-lite test fails
                         2.times {
                             of.puts rand(100)
                         }
                         of.flush
                     }
                 }
                 assert_events([:file_changed], file)
 
                 # verify that we're actually getting notified when a file changes
                 assert_nothing_raised() {
                     Puppet.type(:file).clear
                 }
 
                 if path =~ /nonexists/
                     File.unlink(path)
                 end
             }
         }
     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(:file).create(
                     param => path,
                     :recurse => true,
                     :checksum => "md5"
                 )
             }
             comp = Puppet.type(:component).create(
                 :name => "component"
             )
             comp.push file
             assert_nothing_raised {
                 trans = comp.evaluate
             }
             assert_nothing_raised {
                 trans.evaluate
             }
             clearstorage
             Puppet::Type.allclear
         }
     end
     
     def test_localrecurse
         # Create a test directory
         path = tempfile()
         dir = @file.create :path => path, :mode => 0755, :recurse => true
         config = mk_catalog(dir)
         
         Dir.mkdir(path)
         
         # Make sure we return nothing when there are no children
         ret = nil
         assert_nothing_raised() { ret = dir.localrecurse(true) }
         assert_equal([], ret, "empty dir returned children")
         
         # Now make a file and make sure we get it
         test = File.join(path, "file")
         File.open(test, "w") { |f| f.puts "yay" }
         assert_nothing_raised() { ret = dir.localrecurse(true) }
         fileobj = @file[test]
         assert(fileobj, "child object was not created")
         assert_equal([fileobj], ret, "child object was not returned")
         
         # And that it inherited our recurse setting
         assert_equal(true, fileobj[:recurse], "file did not inherit recurse")
         
         # Make sure it's not returned again
         assert_nothing_raised() { ret = dir.localrecurse(true) }
         assert_equal([], ret, "child object was returned twice")
         
         # Now just for completion, make sure we will return many files
         files = []
         10.times do |i|
             f = File.join(path, i.to_s)
             files << f
             File.open(f, "w") do |o| o.puts "" end
         end
         assert_nothing_raised() { ret = dir.localrecurse(true) }
         assert_equal(files.sort, ret.collect { |f| f.title }.sort,
             "child object was returned twice")
         
         # Clean everything up and start over
         files << test
         files.each do |f| File.unlink(f) end
         
         # Now make sure we correctly ignore things
         dir[:ignore] = "*.out"
         bad = File.join(path, "test.out")
         good = File.join(path, "yayness")
         [good, bad].each do |f|
             File.open(f, "w") { |o| o.puts "" }
         end
         
         assert_nothing_raised() { ret = dir.localrecurse(true) }
         assert_equal([good], ret.collect { |f| f.title }, "ignore failed")
         
         # Now make sure purging works
         dir[:purge] = true
         dir[:ignore] = "svn"
         
         assert_nothing_raised() { ret = dir.localrecurse(true) }
         assert_equal([bad], ret.collect { |f| f.title }, "purge failed")
         
         badobj = @file[bad]
         assert(badobj, "did not create bad object")
     end
     
     def test_recurse
         basedir = tempfile()
         FileUtils.mkdir_p(basedir)
         
         # Create our file
         dir = nil
         assert_nothing_raised {
             dir = Puppet.type(:file).create(
                 :path => basedir,
                 :check => %w{owner mode group}
             )
         }
         
         return_nil = false
         
         # and monkey-patch it
         [:localrecurse, :linkrecurse].each do |m|
             dir.meta_def(m) do |recurse|
                 if return_nil # for testing nil return, of course
                     return nil
                 else
                     return [recurse]
                 end
             end
         end
 
         # We have to special-case this, because it returns a list of
         # found files.
         dir.meta_def(:sourcerecurse) do |recurse|
             if return_nil # for testing nil return, of course
                 return nil
             else
                 return [recurse], []
             end
         end
         
         # First try it with recurse set to false
         dir[:recurse] = false
         assert_nothing_raised do
             assert_nil(dir.recurse)
         end
         
         # Now try it with the different valid positive values
         [true, "true", "inf", 50].each do |value|
             assert_nothing_raised { dir[:recurse] = value}
             
             # Now make sure the methods are called appropriately
             ret = nil
             assert_nothing_raised do
                 ret = dir.recurse
             end
             
             # We should only call the localrecurse method, so make sure
             # that's the case
             if value == 50
                 # Make sure our counter got decremented
                 assert_equal([49], ret, "did not call localrecurse")
             else
                 assert_equal([true], ret, "did not call localrecurse")
             end
         end
         
         # Make sure it doesn't recurse when we've set recurse to false
         [false, "false"].each do |value|
             assert_nothing_raised { dir[:recurse] = value }
             
             ret = nil
             assert_nothing_raised() { ret = dir.recurse }
             assert_nil(ret)
         end
         dir[:recurse] = true
         
         # Now add a target, so we do the linking thing
         dir[:target] = tempfile()
         ret = nil
         assert_nothing_raised { ret = dir.recurse }
         assert_equal([true, true], ret, "did not call linkrecurse")
         
         # And add a source, and make sure we call that
         dir[:source] = tempfile()
         assert_nothing_raised { ret = dir.recurse }
         assert_equal([true, true, true], ret, "did not call linkrecurse")
         
         # Lastly, make sure we correctly handle returning nil
         return_nil = true
         assert_nothing_raised { ret = dir.recurse }
     end
     
     def test_recurse?
         file = Puppet::Type.type(:file).create :path => tempfile
         
         # Make sure we default to false
         assert(! file.recurse?, "Recurse defaulted to true")
         
         [true, "true", 10, "inf"].each do |value|
             file[:recurse] = value
             assert(file.recurse?, "%s did not cause recursion" % value)
         end
         
         [false, "false", 0].each do |value|
             file[:recurse] = value
             assert(! file.recurse?, "%s caused recursion" % value)
         end
     end
     
     def test_recursion
         basedir = tempfile()
         subdir = File.join(basedir, "subdir")
         tmpfile = File.join(basedir,"testing")
         FileUtils.mkdir_p(subdir)
 
         dir = nil
         [true, "true", "inf", 50].each do |value|
             assert_nothing_raised {
                 dir = Puppet.type(:file).create(
                     :path => basedir,
                     :recurse => value,
                     :check => %w{owner mode group}
                 )
             }
             config = mk_catalog dir
             
             children = nil
 
             assert_nothing_raised {
                 children = dir.eval_generate
             }
             
             assert_equal([subdir], children.collect {|c| c.title },
                 "Incorrect generated children")
             
             # Remove our subdir resource, 
             subdir_resource = config.resource(:file, subdir)
             config.remove_resource(subdir_resource)
 
             # Create the test file
             File.open(tmpfile, "w") { |f| f.puts "yayness" }
             
             assert_nothing_raised {
                 children = dir.eval_generate
             }
 
             # And make sure we get both resources back.
             assert_equal([subdir, tmpfile].sort, children.collect {|c| c.title }.sort,
                 "Incorrect generated children when recurse == %s" % value.inspect)
             
             File.unlink(tmpfile)
             Puppet.type(:file).clear
         end
     end
 
     def test_filetype_retrieval
         file = nil
 
         # Verify it retrieves files of type directory
         assert_nothing_raised {
             file = Puppet.type(:file).create(
                 :name => tmpdir(),
                 :check => :type
             )
         }
 
         assert_nothing_raised {
             file.evaluate
         }
 
         assert_equal("directory", file.property(:type).retrieve)
 
         # And then check files
         assert_nothing_raised {
             file = Puppet.type(:file).create(
                 :name => tempfile(),
                 :ensure => "file"
             )
         }
 
         assert_apply(file)
         file[:check] = "type"
         assert_apply(file)
 
         assert_equal("file", file.property(:type).retrieve)
 
         file[:type] = "directory"
 
         currentvalues = {}
         assert_nothing_raised { currentvalues = file.retrieve }
 
         # The 'retrieve' method sets @should to @is, so they're never
         # out of sync.  It's a read-only class.
         assert(file.insync?(currentvalues))
     end
 
     def test_remove
         basedir = tempfile()
         subdir = File.join(basedir, "this")
         FileUtils.mkdir_p(subdir)
 
         dir = nil
         assert_nothing_raised {
             dir = Puppet.type(:file).create(
                 :path => basedir,
                 :recurse => true,
                 :check => %w{owner mode group}
             )
         }
         mk_catalog dir
 
         assert_nothing_raised {
             dir.eval_generate
         }
 
         obj = nil
         assert_nothing_raised {
             obj = Puppet.type(:file)[subdir]
         }
 
         assert(obj, "Could not retrieve subdir object")
 
         assert_nothing_raised {
             obj.remove(true)
         }
 
         assert_nothing_raised {
             obj = Puppet.type(:file)[subdir]
         }
 
         assert_nil(obj, "Retrieved removed object")
     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(:file).create(
                 :path => dir,
                 :recurse => true,
                 :check => %w{mode owner group}
             )
         }
         mk_catalog dirobj
 
         assert_nothing_raised {
             dirobj.eval_generate
         }
 
         assert_nothing_raised {
             file = dirobj.class[path]
         }
 
         assert(file, "Could not retrieve file object")
 
         assert_equal("/%s" % file.ref, file.path)
     end
 
     def test_autorequire
         basedir = tempfile()
         subfile = File.join(basedir, "subfile")
 
         baseobj = Puppet.type(:file).create(
             :name => basedir,
             :ensure => "directory"
         )
 
         subobj = Puppet.type(:file).create(
             :name => subfile,
             :ensure => "file"
         )
         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
 
     def test_content
         file = tempfile()
         str = "This is some content"
 
         obj = nil
         assert_nothing_raised {
             obj = Puppet.type(:file).create(
                 :name => file,
                 :content => str
             )
         }
 
         assert(!obj.insync?(obj.retrieve), "Object is incorrectly in sync")
 
         assert_events([:file_created], obj)
 
         currentvalues = obj.retrieve
 
         assert(obj.insync?(currentvalues), "Object is not in sync")
 
         text = File.read(file)
 
         assert_equal(str, text, "Content did not copy correctly")
 
         newstr = "Another string, yo"
 
         obj[:content] = newstr
 
         assert(!obj.insync?(obj.retrieve), "Object is incorrectly in sync")
 
         assert_events([:file_changed], obj)
 
         text = File.read(file)
 
         assert_equal(newstr, text, "Content did not copy correctly")
 
         currentvalues = obj.retrieve
         assert(obj.insync?(currentvalues), "Object is not in sync")
     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(:file).create(
                 :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(:file).create(
                 :name => dest,
                 :checksum => "md5",
                 :content => "This is some content"
             )
         }
 
         file.retrieve
 
         assert_events([:file_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(:file).create(
                 :name => dest,
                 :checksum => "md5",
                 :ensure => "file"
             )
         }
 
         file.retrieve
 
         assert_events([:file_created], file)
         file.retrieve
         assert_events([], file)
     end
 
     # Make sure that content gets used before ensure
     def test_contentbeatsensure
         dest = tempfile()
 
         file = nil
         assert_nothing_raised {
             file = Puppet.type(:file).create(
                 :name => dest,
                 :ensure => "file",
                 :content => "this is some content, yo"
             )
         }
 
         currentvalues = file.retrieve
 
         assert_events([:file_created], file)
         file.retrieve
         assert_events([], file)
         assert_events([], file)
     end
 
     # Make sure that content gets used before ensure
     def test_deletion_beats_source
         dest = tempfile()
         source = tempfile()
         File.open(source, "w") { |f| f.puts "yay" }
 
         file = nil
         assert_nothing_raised {
             file = Puppet.type(:file).create(
                 :name => dest,
                 :ensure => :absent,
                 :source => source
             )
         }
 
         file.retrieve
 
         assert_events([], file)
         assert(! FileTest.exists?(dest), "file was copied during deletion")
 
         # Now create the dest, and make sure it gets deleted
         File.open(dest, "w") { |f| f.puts "boo" }
         assert_events([:file_removed], file)
         assert(! FileTest.exists?(dest), "file was not deleted during deletion")
     end
 
     def test_nameandpath
         path = tempfile()
 
         file = nil
         assert_nothing_raised {
             file = Puppet.type(:file).create(
                 :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(:file).create(
                 :path => tempfile(),
                 :group => "fakegroup"
             )
         }
 
         assert(file.property(:group), "Group property failed")
     end
 
     def test_modecreation
         path = tempfile()
         file = Puppet.type(:file).create(
             :path => path,
             :ensure => "file",
             :mode => "0777"
         )
         assert_equal(0777, 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(:file).create(
                 :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_backupmodes
         File.umask(0022)
         
         file = tempfile()
         newfile = tempfile()
 
         File.open(file, "w", 0411) { |f| f.puts "yayness" }
 
         obj = nil
         assert_nothing_raised {
             obj = Puppet::Type.type(:file).create(
                 :path => file, :content => "rahness\n", :backup => ".puppet-bak"
             )
         }
 
         assert_apply(obj)
 
         backupfile = file + obj[:backup]
         @@tmpfiles << backupfile
         assert(FileTest.exists?(backupfile),
             "Backup file %s does not exist" % backupfile)
 
         assert_equal(0411, filemode(backupfile),
             "File mode is wrong for backupfile")
 
         bucket = "bucket"
         bpath = tempfile()
         Dir.mkdir(bpath)
         Puppet::Type.type(:filebucket).create(
             :title => bucket, :path => bpath
         )
 
         obj[:backup] = bucket
         obj[:content] = "New content"
         assert_apply(obj)
 
         md5 = "18cc17fa3047fcc691fdf49c0a7f539a"
         dir, file, pathfile = Puppet::Network::Handler.filebucket.paths(bpath, md5)
 
         assert_equal(0440, filemode(file))
     end
 
     def test_largefilechanges
         source = tempfile()
         dest = tempfile()
 
         # Now make a large file
         File.open(source, "w") { |f|
             500.times { |i| f.puts "line %s" % i }
         }
 
         obj = Puppet::Type.type(:file).create(
             :title => dest, :source => source
         )
 
         assert_events([:file_created], obj)
 
         File.open(source, File::APPEND|File::WRONLY) { |f| f.puts "another line" }
 
         assert_events([:file_changed], obj)
 
         # Now modify the dest file
         File.open(dest, File::APPEND|File::WRONLY) { |f| f.puts "one more line" }
 
         assert_events([:file_changed, :file_changed], obj)
 
     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(:file).create(
                 :ensure => path,
                 :path => link
             )
         }
 
         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).create(
             :path => dest,
             :source => source
         )
         assert(obj, "Did not create file")
 
         assert_apply(obj)
 
         assert(FileTest.exists?(dest), "File did not get created")
     end
 
     def test_present_matches_anything
         path = tempfile()
 
         file = Puppet::Type.newfile(:path => path, :ensure => :present)
 
         currentvalues = file.retrieve
         assert(! file.insync?(currentvalues), "File incorrectly in sync")
 
         # Now make a file
         File.open(path, "w") { |f| f.puts "yay" }
 
         currentvalues = file.retrieve
         assert(file.insync?(currentvalues), "File not in sync")
 
         # Now make a directory
         File.unlink(path)
         Dir.mkdir(path)
 
         currentvalues = file.retrieve
         assert(file.insync?(currentvalues), "Directory not considered 'present'")
 
         Dir.rmdir(path)
 
         # Now make a link
         file[:links] = :manage
 
         otherfile = tempfile()
         File.symlink(otherfile, path)
 
         currentvalues = file.retrieve
         assert(file.insync?(currentvalues), "Symlink not considered 'present'")
         File.unlink(path)
 
         # Now set some content, and make sure it works
         file[:content] = "yayness"
 
         assert_apply(file)
 
         assert_equal("yayness", File.read(path), "Content did not get set correctly")
     end
 
     # Make sure unmanaged files are purged.
     def test_purge
         sourcedir = tempfile()
         destdir = tempfile()
         Dir.mkdir(sourcedir)
         Dir.mkdir(destdir)
         sourcefile = File.join(sourcedir, "sourcefile")
         dsourcefile = File.join(destdir, "sourcefile")
         localfile = File.join(destdir, "localfile")
         purgee = File.join(destdir, "to_be_purged")
         File.open(sourcefile, "w") { |f| f.puts "funtest" }
         # this file should get removed
         File.open(purgee, "w") { |f| f.puts "footest" }
 
         lfobj = Puppet::Type.newfile(
             :title => "localfile",
             :path => localfile,
             :content => "rahtest",
             :ensure => :file,
             :backup => false
         )
 
         destobj = Puppet::Type.newfile(:title => "destdir", :path => destdir,
                                     :source => sourcedir,
                                     :backup => false,
                                     :recurse => true)
 
         config = mk_catalog(lfobj, destobj)
         config.apply
 
         assert(FileTest.exists?(dsourcefile), "File did not get copied")
         assert(FileTest.exists?(localfile), "Local file did not get created")
         assert(FileTest.exists?(purgee), "Purge target got prematurely purged")
 
         assert_nothing_raised { destobj[:purge] = true }
         config.apply
 
         assert(FileTest.exists?(localfile), "Local file got purged")
         assert(FileTest.exists?(dsourcefile), "Source file got purged")
         assert(! FileTest.exists?(purgee), "File did not get purged")
     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(:user).create(
                 :name => "pptestu",
                 :home => file,
                 :gid => "pptestg"
             )
             home = Puppet.type(:file).create(
                 :path => file,
                 :owner => "pptestu",
                 :group => "pptestg",
                 :ensure => "directory"
             )
             group = Puppet.type(:group).create(
                 :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.title)
             assert_equal(file, Puppet::Type.type(:file)["/my/file/for/testing"])
             Puppet::Type.type(:file).clear
         end
     end
 
     # Testing #304
     def test_links_to_directories
         link = tempfile()
         file = tempfile()
         dir = tempfile()
         Dir.mkdir(dir)
 
         bucket = Puppet::Type.newfilebucket :name => "main"
         File.symlink(dir, link)
         File.open(file, "w") { |f| f.puts "" }
         assert_equal(dir, File.readlink(link))
         obj = Puppet::Type.newfile :path => link, :ensure => :link, :target => file, :recurse => false, :backup => "main"
 
         assert_apply(obj)
 
         assert_equal(file, File.readlink(link))
     end
 
     # Testing #303
     def test_nobackups_with_links
         link = tempfile()
         new = tempfile()
 
         File.open(link, "w") { |f| f.puts "old" }
         File.open(new, "w") { |f| f.puts "new" }
         obj = Puppet::Type.newfile :path => link, :ensure => :link,
             :target => new, :recurse => true, :backup => false
 
         assert_nothing_raised do
             obj.handlebackup
         end
 
         bfile = [link, "puppet-bak"].join(".")
 
         assert(! FileTest.exists?(bfile), "Backed up when told not to")
 
         assert_apply(obj)
 
         assert(! FileTest.exists?(bfile), "Backed up when told not to")
     end
 
     # Make sure we consistently handle backups for all cases.
     def test_ensure_with_backups
         # We've got three file types, so make sure we can replace any type
         # with the other type and that backups are done correctly.
         types = [:file, :directory, :link]
 
         dir = tempfile()
         path = File.join(dir, "test")
         linkdest = tempfile()
         creators = {
             :file => proc { File.open(path, "w") { |f| f.puts "initial" } },
             :directory => proc { Dir.mkdir(path) },
             :link => proc { File.symlink(linkdest, path) }
         }
 
         bucket = Puppet::Type.newfilebucket :name => "main", :path => tempfile()
 
         obj = Puppet::Type.newfile :path => path, :force => true,
             :links => :manage
 
         Puppet[:trace] = true
         ["main", false].each do |backup|
             obj[:backup] = backup
             obj.finish
             types.each do |should|
                 types.each do |is|
                     # It makes no sense to replace a directory with a directory
                     # next if should == :directory and is == :directory
 
                     Dir.mkdir(dir)
 
                     # Make the thing
                     creators[is].call
 
                     obj[:ensure] = should
 
                     if should == :link
                         obj[:target] = linkdest
                     else
                         if obj.property(:target)
                             obj.delete(:target)
                         end
                     end
 
                     # First try just removing the initial data
                     assert_nothing_raised do
                         obj.remove_existing(should)
                     end
 
                     unless is == should
                         # Make sure the original is gone
                         assert(! FileTest.exists?(obj[:path]),
                             "remove_existing did not work: " +
                             "did not remove %s with %s" % [is, should])
                     end
                     FileUtils.rmtree(obj[:path])
 
                     # Now make it again
                     creators[is].call
 
                     property = obj.property(:ensure)
 
                     currentvalue = property.retrieve
                     unless property.insync?(currentvalue)
                         assert_nothing_raised do
                             property.sync
                         end
                     end
                     FileUtils.rmtree(dir)
                 end
             end
         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
     
     # #365 -- make sure generated files also use filebuckets.
     def test_recursive_filebuckets
         source = tempfile()
         dest = tempfile()
         s1 = File.join(source, "1")
         sdir = File.join(source, "dir")
         s2 = File.join(sdir, "2")
         Dir.mkdir(source)
         Dir.mkdir(sdir)
         [s1, s2].each { |file| File.open(file, "w") { |f| f.puts "yay: %s" % File.basename(file) } }
         
         sums = {}
         [s1, s2].each do |f|
             sums[File.basename(f)] = Digest::MD5.hexdigest(File.read(f))
         end
         
         dfiles = [File.join(dest, "1"), File.join(dest, "dir", "2")]
         
         bpath = tempfile
         bucket = Puppet::Type.type(:filebucket).create :name => "rtest", :path => bpath
         dipper = bucket.bucket
         dipper = Puppet::Network::Handler.filebucket.new(
             :Path => bpath
         )
         assert(dipper, "did not receive bucket client")
         file = Puppet::Type.newfile :path => dest, :source => source, :recurse => true, :backup => "rtest"
         
         assert_apply(file)
         dfiles.each do |f|
             assert(FileTest.exists?(f), "destfile %s was not created" % f)
         end
         
         # Now modify the source files to make sure things get backed up correctly
         [s1, s2].each { |sf| File.open(sf, "w") { |f|
             f.puts "boo: %s" % File.basename(sf)
         } }
         
         assert_apply(file)
         dfiles.each do |f|
             assert_equal("boo: %s\n" % File.basename(f), File.read(f),
                 "file was not copied correctly")
         end
         
         # Make sure we didn't just copy the files over to backup locations
         dfiles.each do |f|
             assert(! FileTest.exists?(f + "rtest"),
             "file %s was copied for backup instead of bucketed" % File.basename(f))
         end
         
         # Now make sure we can get the source sums from the bucket
         sums.each do |f, sum|
             result = nil
             assert_nothing_raised do
                 result = dipper.getfile(sum)
             end
             assert(result, "file %s was not backed to filebucket" % f)
             assert_equal("yay: %s\n" % f, result, "file backup was not correct")
         end
     end
     
     def test_backup
         path = tempfile()
         file = Puppet::Type.newfile :path => path, :content => "yay"
         
         [false, :false, "false"].each do |val|
             assert_nothing_raised do
                 file[:backup] = val
             end
             assert_equal(false, file[:backup], "%s did not translate" % val.inspect)
         end
         [true, :true, "true", ".puppet-bak"].each do |val|
             assert_nothing_raised do
                 file[:backup] = val
             end
             assert_equal(".puppet-bak", file[:backup], "%s did not translate" % val.inspect)
         end
         
         # Now try a non-bucket string
         assert_nothing_raised do
             file[:backup] = ".bak"
         end
         assert_equal(".bak", file[:backup], ".bak did not translate")
         
         # Now try a non-existent bucket
         assert_nothing_raised do
             file[:backup] = "main"
         end
         assert_equal("main", file[:backup], "bucket name was not retained")
         assert_equal("main", file.bucket, "file's bucket was not set")
         
         # And then an existing bucket
         obj = Puppet::Type.type(:filebucket).create :name => "testing"
         bucket = obj.bucket
         
         assert_nothing_raised do
             file[:backup] = "testing"
         end
         assert_equal("testing", file[:backup], "backup value was reset")
         assert_equal(obj.bucket, file.bucket, "file's bucket was not set")
     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
         mk_catalog obj
         
         assert_equal("/%s" % obj.ref, obj.path)
         
         list = obj.eval_generate
         fileobj = obj.class[file]
         assert(fileobj, "did not generate file object")
         assert_equal("/%s" % 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")
         
         assert_apply(file)
         assert(! FileTest.exists?(path), "File was not removed")
     end
     
     # Testing #434
     def test_stripping_extra_slashes_during_lookup
         file = Puppet::Type.newfile(:path => "/one/two")
         %w{/one/two/ /one/two /one//two //one//two//}.each do |path|
             assert(Puppet::Type.type(:file)[path], "could not look up file via path %s" % path)
         end
     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("%s conflicted with ensure" % [param]) do
                 Puppet::Type.newfile(:path => file, param => first, :ensure => :file)
             end
             Puppet::Type.type(:file).clear
             params.each do |other|
                 next if other == param
                 assert_raise(Puppet::Error, "%s and %s did not conflict" % [param, other]) 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 %s was not correct %s" % [should, 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 %s" % 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 %s" % attr
             end
             
             # Run it again
             run.call(file, "after modification with %s" % attr)
 
             # Now remove the file and the attr
             file.delete(attr)
             File.unlink(path)
         end
     end
     end
 
     # #505
     def test_numeric_recurse
         dir = tempfile()
         subdir = File.join(dir, "subdir")
         other = File.join(subdir, "deeper")
         file = File.join(other, "file")
         [dir, subdir, other].each { |d| Dir.mkdir(d) }
         File.open(file, "w") { |f| f.puts "yay" }
         File.chmod(0644, file)
         obj = Puppet::Type.newfile(:path => dir, :mode => 0750, :recurse => "2")
         config = mk_catalog(obj)
 
         children = nil
         assert_nothing_raised("Failure when recursing") do
             children = obj.eval_generate
         end
         assert(obj.class[subdir], "did not create subdir object")
         children.each do |c|
             assert_nothing_raised("Failure when recursing on %s" % c) do
                 c.catalog = config
                 others = c.eval_generate
             end
         end
         oobj = obj.class[other]
         assert(oobj, "did not create other object")
 
         assert_nothing_raised do
             assert_nil(oobj.eval_generate, "recursed too far")
         end
     end
 
     # Make sure we default to the "puppet" filebucket, rather than a string
     def test_backup_defaults_to_bucket
         path = tempfile
         file = Puppet::Type.newfile(:path => path, :content => 'some content')
         file.finish
 
         assert_instance_of(Puppet::Network::Client::Dipper, file.bucket,
             "did not default to a filebucket for backups")
     end
 
     # #515 - make sure 'ensure' other than "link" is deleted during recursion
     def test_ensure_deleted_during_recursion
         dir = tempfile()
         Dir.mkdir(dir)
         file = File.join(dir, "file")
         File.open(file, "w") { |f| f.puts "asdfasdf" }
 
         obj = Puppet::Type.newfile(:path => dir, :ensure => :directory,
             :recurse => true)
 
         config = mk_catalog(obj)
         children = nil
         assert_nothing_raised do
             children = obj.eval_generate
         end
         fobj = obj.class[file]
         assert(fobj, "did not create file object")
         assert(fobj.should(:ensure) != :directory, "ensure was passed to child")
     end
 
     # #567
     def test_missing_files_are_in_sync
         file = tempfile
         obj = Puppet::Type.newfile(:path => file, :mode => 0755)
 
         changes = obj.evaluate
         assert(changes.empty?, "Missing file with no ensure resulted in changes")
     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
 
     # #1010 and #1037 -- write should fail if the written checksum does not
     # match the file we thought we were writing.
     def test_write_validates_checksum
         file = tempfile
         inst = Puppet::Type.newfile(:path => file, :content => "something")
 
         tmpfile = file + ".puppettmp"
 
         wh = mock 'writehandle', :print => nil
         rh = mock 'readhandle'
         rh.expects(:read).with(512).times(2).returns("other").then.returns(nil)
         File.expects(:open).with { |*args| args[0] == tmpfile and args[1] != "r" }.yields(wh)
         File.expects(:open).with { |*args| args[0] == tmpfile and args[1] == "r" }.yields(rh)
 
         File.stubs(:rename)
         FileTest.stubs(:exist?).returns(true)
         FileTest.stubs(:file?).returns(true)
 
         inst.expects(:fail)
         inst.write("something", :whatever)
     end
 end
diff --git a/test/ral/type/tidy.rb b/test/ral/type/tidy.rb
index 60fad6516..17f98df22 100755
--- a/test/ral/type/tidy.rb
+++ b/test/ral/type/tidy.rb
@@ -1,291 +1,292 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../../lib/puppettest'
 
 require 'puppettest'
 require 'puppettest/support/utils'
+require 'puppet/type/tidy'
 
 class TestTidy < Test::Unit::TestCase
     include PuppetTest::Support::Utils
     include PuppetTest::FileTesting
     def mktmpfile
         # because luke's home directory is on nfs, it can't be used for testing
         # as root
         tmpfile = tempfile()
         File.open(tmpfile, "w") { |f| f.puts rand(100) }
         @@tmpfiles.push tmpfile
         return tmpfile
     end
 
     def mktmpdir
         dir = File.join(tmpdir(), "puppetlinkdir")
         unless FileTest.exists?(dir)
             Dir.mkdir(dir)
         end
         @@tmpfiles.push dir
         return dir
     end
 
     def test_tidydirs
         dir = mktmpdir
         file = File.join(dir, "file")
         File.open(file, "w") { |f|
             f.puts "some stuff"
         }
 
         tidy = Puppet.type(:tidy).create(
             :name => dir,
             :size => "1b",
             :rmdirs => true,
             :recurse => true
         )
 
         assert_events([:file_tidied, :file_tidied], tidy)
 
         assert(!FileTest.exists?(file), "Tidied %s still exists" % file)
         assert(!FileTest.exists?(dir), "Tidied %s still exists" % dir)
 
     end
 
     def disabled_test_recursion
         source = mktmpdir()
         FileUtils.cd(source) {
             mkranddirsandfiles()
         }
 
         link = nil
         assert_nothing_raised {
             link = newlink(:target => source, :recurse => true)
         }
         comp = mk_catalog("linktest",link)
         cycle(comp)
 
         path = link.name
         list = file_list(path)
         FileUtils.cd(path) {
             list.each { |file|
                 unless FileTest.directory?(file)
                     assert(FileTest.symlink?(file))
                     target = File.readlink(file)
                     assert_equal(target,File.join(source,file.sub(/^\.\//,'')))
                 end
             }
         }
     end
 
     # Test the different age iterations.
     def test_age_conversions
         tidy = Puppet::Type.newtidy :path => tempfile(), :age => "1m"
 
         convertors = {
             :second => 1,
             :minute => 60
         }
 
         convertors[:hour] = convertors[:minute] * 60
         convertors[:day] = convertors[:hour] * 24
         convertors[:week] = convertors[:day] * 7
 
         # First make sure we default to days
         assert_nothing_raised do
             tidy[:age] = "2"
         end
 
         assert_equal(2 * convertors[:day], tidy.should(:age),
             "Converted 2 wrong")
 
         convertors.each do |name, number|
             init = name.to_s[0..0] # The first letter
             [0, 1, 5].each do |multi|
                 [init, init.upcase].each do |letter|
                     age = multi.to_s + letter.to_s
                     assert_nothing_raised do
                         tidy[:age] = age
                     end
 
                     assert_equal(multi * convertors[name], tidy.should(:age),
                         "Converted %s wrong" % age)
                 end
             end
         end
     end
 
     def test_size_conversions
         convertors = {
             :b => 0,
             :kb => 1,
             :mb => 2,
             :gb => 3
         }
 
         tidy = Puppet::Type.newtidy :path => tempfile(), :age => "1m"
 
         # First make sure we default to kb
         assert_nothing_raised do
             tidy[:size] = "2"
         end
 
         assert_equal(2048, tidy.should(:size),
             "Converted 2 wrong")
 
         convertors.each do |name, number|
             init = name.to_s[0..0] # The first letter
             [0, 1, 5].each do |multi|
                 [init, init.upcase].each do |letter|
                     size = multi.to_s + letter.to_s
                     assert_nothing_raised do
                         tidy[:size] = size
                     end
 
                     total = multi
                     number.times do total *= 1024 end
 
                     assert_equal(total, tidy.should(:size),
                         "Converted %s wrong" % size)
                 end
             end
         end
     end
 
     def test_agetest
         tidy = Puppet::Type.newtidy :path => tempfile(), :age => "1m"
 
         age = tidy.property(:age)
 
         # Set it to something that should be fine
         assert(age.insync?(Time.now.to_i - 5), "Tried to tidy a low age")
 
         # Now to something that should fail
         assert(! age.insync?(Time.now.to_i - 120), "Incorrectly skipped tidy")
     end
 
     def test_sizetest
         tidy = Puppet::Type.newtidy :path => tempfile(), :size => "1k"
 
         size = tidy.property(:size)
 
         # Set it to something that should be fine
         assert(size.insync?(50), "Tried to tidy a low size")
 
         # Now to something that should fail
         assert(! size.insync?(2048), "Incorrectly skipped tidy")
     end
 
     # Make sure we can remove different types of files
     def test_tidytypes
         path = tempfile()
         tidy = Puppet::Type.newtidy :path => path, :size => "1b", :age => "1s"
 
         # Start with a file
         File.open(path, "w") { |f| f.puts "this is a test" }
         assert_events([:file_tidied], tidy)
         assert(! FileTest.exists?(path), "File was not removed")
 
         # Then a link
         dest = tempfile
         File.open(dest, "w") { |f| f.puts "this is a test" }
         File.symlink(dest, path)
         assert_events([:file_tidied], tidy)
         assert(! FileTest.exists?(path), "Link was not removed")
         assert(FileTest.exists?(dest), "Destination was removed")
 
         # And a directory
         Dir.mkdir(path)
         tidy[:rmdirs] = true
         assert_events([:file_tidied], tidy)
         assert(! FileTest.exists?(path), "File was not removed")
     end
     
     # Make sure we can specify either attribute and get appropriate behaviour.
     # I found that the original implementation of this did not work unless both
     # size and age were specified.
     def test_one_attribute
         path = tempfile()
         File.open(path, "w") { |f| 10.times { f.puts "yayness " } }
         tidy = Puppet::Type.type(:tidy).create :path => path, :size => "1b"
         
         assert_apply(tidy)
         assert(! FileTest.exists?(path), "file did not get tidied")
         
         tidy.class.clear
 
         # Now try one with just an age attribute.
         time = Time.now - 10
         stat = stub 'stat', :mtime => time, :atime => time, :ftype => "file"
         File.stubs(:lstat)
         File.stubs(:lstat).with(path).returns(stat)
 
         File.open(path, "w") { |f| 10.times { f.puts "yayness " } }
         tidy = Puppet::Type.type(:tidy).create :path => path, :age => "5s"
         
 
         assert_apply(tidy)
         assert(! FileTest.exists?(path), "file did not get tidied")
     end
     
     # Testing #355.
     def test_remove_dead_links
         dir = tempfile()
         link = File.join(dir, "link")
         target = tempfile()
         Dir.mkdir(dir)
         File.symlink(target, link)
         
         tidy = Puppet::Type.newtidy :path => dir, :size => "1b", :recurse => true
         assert_apply(tidy)
         assert(! FileTest.symlink?(link), "link was not tidied")
     end
 
     def test_glob_matches_single
         dir = mktmpdir
         files = {
           :remove => File.join(dir, "01-foo"),
           :keep   => File.join(dir, "default")
         }
         files.each do |tag, file|
           File.open(file, "w") { |f|
               f.puts "some stuff"
           }
         end
 
         tidy = Puppet.type(:tidy).create(
             :name => dir,
             :size => "1b",
             :rmdirs => true,
             :recurse => true,
             :matches => "01-*"
         )
         assert_apply(tidy)
 
         assert(FileTest.exists?(files[:keep]), "%s was tidied" % files[:keep])
         assert(!FileTest.exists?(files[:remove]), "Tidied %s still exists" % files[:remove])
     end
 
     def test_glob_matches_multiple
         dir = mktmpdir
         files = {
           :remove1 => File.join(dir, "01-foo"),
           :remove2 => File.join(dir, "02-bar"),
           :keep1   => File.join(dir, "default")
         }
         files.each do |tag, file|
           File.open(file, "w") { |f|
               f.puts "some stuff"
           }
         end
 
         tidy = Puppet.type(:tidy).create(
             :name => dir,
             :size => "1b",
             :rmdirs => true,
             :recurse => true,
             :matches => ["01-*", "02-*"]
         )
         assert_apply(tidy)
 
         assert(FileTest.exists?(files[:keep1]), "%s was tidied" % files[:keep1])
         assert(!FileTest.exists?(files[:remove1]), "Tidied %s still exists" % files[:remove1])
         assert(!FileTest.exists?(files[:remove2]), "Tidied %s still exists" % files[:remove2])
     end
 end