puppet 0.24.9 → 0.25.0

data/test/ral/type/file.rb

@@ -5,6 +5,7 @@ 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
@@ -13,7 +14,7 @@ class TestFile < Test::Unit::TestCase
     def mkfile(hash)
         file = nil
         assert_nothing_raised {
-            file = Puppet.type(:file).create(hash)
+            file = Puppet::Type.type(:file).new(hash)
         }
         return file
     end
@@ -30,10 +31,10 @@ class TestFile < Test::Unit::TestCase
         @file = Puppet::Type.type(:file)
         $method = @method_name
         Puppet[:filetimeout] = -1
+        Facter.stubs(:to_hash).returns({})
     end
 
     def teardown
-        Puppet::Util::Storage.clear
         system("rm -rf %s" % Puppet[:statefile])
         super
     end
@@ -104,7 +105,7 @@ class TestFile < Test::Unit::TestCase
 
     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 => ""
+            Puppet::Type.type(:file).new :path => "/some/file", :group => ""
         end
     end
 
@@ -118,7 +119,7 @@ class TestFile < Test::Unit::TestCase
 
             file = nil
             assert_nothing_raised {
-                file = Puppet.type(:file).create(
+                file = Puppet::Type.type(:file).new(
                     :path => path,
                     :owner => user.name,
                     :ensure => "file",
@@ -148,7 +149,7 @@ class TestFile < Test::Unit::TestCase
 
             obj = nil
             assert_nothing_raised {
-                obj = Puppet.type(:file).create(
+                obj = Puppet::Type.type(:file).new(
                     :title => link,
                     :owner => user.name
                 )
@@ -302,7 +303,7 @@ class TestFile < Test::Unit::TestCase
         %w{a b c d}.collect { |name| tempfile() + name.to_s }.each { |path|
             file =nil
             assert_nothing_raised() {
-                file = Puppet.type(:file).create(
+                file = Puppet::Type.type(:file).new(
                     :name => path,
                     :ensure => "file"
                 )
@@ -321,7 +322,7 @@ class TestFile < Test::Unit::TestCase
         %w{a b c d}.collect { |name| "#{basedir}/%s" % name }.each { |path|
             file = nil
             assert_nothing_raised() {
-                file = Puppet.type(:file).create(
+                file = Puppet::Type.type(:file).new(
                     :name => path,
                     :ensure => "directory"
                 )
@@ -355,108 +356,6 @@ class TestFile < Test::Unit::TestCase
         }
     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|
@@ -467,13 +366,13 @@ class TestFile < Test::Unit::TestCase
 
             initstorage
             assert_nothing_raised {
-                file = Puppet.type(:file).create(
+                file = Puppet::Type.type(:file).new(
                     param => path,
                     :recurse => true,
                     :checksum => "md5"
                 )
             }
-            comp = Puppet.type(:component).create(
+            comp = Puppet::Type.type(:component).new(
                 :name => "component"
             )
             comp.push file
@@ -487,177 +386,24 @@ class TestFile < Test::Unit::TestCase
             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
-        
+        file = Puppet::Type.type(:file).new :path => tempfile
+
         # Make sure we default to false
         assert(! file.recurse?, "Recurse defaulted to true")
-        
-        [true, "true", 10, "inf"].each do |value|
+
+        [true, "true", 10, "inf", "remote"].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")
@@ -667,40 +413,40 @@ class TestFile < Test::Unit::TestCase
         dir = nil
         [true, "true", "inf", 50].each do |value|
             assert_nothing_raised {
-                dir = Puppet.type(:file).create(
+                dir = Puppet::Type.type(:file).new(
                     :path => basedir,
                     :recurse => value,
                     :check => %w{owner mode group}
                 )
             }
             config = mk_catalog dir
-            
+            transaction = Puppet::Transaction.new(config)
+
             children = nil
 
             assert_nothing_raised {
-                children = dir.eval_generate
+                children = transaction.eval_generate(dir)
             }
-            
+
             assert_equal([subdir], children.collect {|c| c.title },
                 "Incorrect generated children")
-            
-            # Remove our subdir resource, 
+
+            # 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
+                children = transaction.eval_generate(dir)
             }
 
             # 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
 
@@ -709,7 +455,7 @@ class TestFile < Test::Unit::TestCase
 
         # Verify it retrieves files of type directory
         assert_nothing_raised {
-            file = Puppet.type(:file).create(
+            file = Puppet::Type.type(:file).new(
                 :name => tmpdir(),
                 :check => :type
             )
@@ -723,7 +469,7 @@ class TestFile < Test::Unit::TestCase
 
         # And then check files
         assert_nothing_raised {
-            file = Puppet.type(:file).create(
+            file = Puppet::Type.type(:file).new(
                 :name => tempfile(),
                 :ensure => "file"
             )
@@ -745,43 +491,6 @@ class TestFile < Test::Unit::TestCase
         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()
 
@@ -795,21 +504,21 @@ class TestFile < Test::Unit::TestCase
         file = nil
         dirobj = nil
         assert_nothing_raised("Could not make file object") {
-            dirobj = Puppet.type(:file).create(
+            dirobj = Puppet::Type.type(:file).new(
                 :path => dir,
                 :recurse => true,
                 :check => %w{mode owner group}
             )
         }
-        mk_catalog dirobj
+        catalog = mk_catalog dirobj
+        transaction = Puppet::Transaction.new(catalog)
+        transaction.eval_generate(dirobj)
 
-        assert_nothing_raised {
-            dirobj.eval_generate
-        }
+        #assert_nothing_raised {
+        #    dirobj.eval_generate
+        #}
 
-        assert_nothing_raised {
-            file = dirobj.class[path]
-        }
+        file = catalog.resource(:file, path)
 
         assert(file, "Could not retrieve file object")
 
@@ -820,15 +529,16 @@ class TestFile < Test::Unit::TestCase
         basedir = tempfile()
         subfile = File.join(basedir, "subfile")
 
-        baseobj = Puppet.type(:file).create(
+        baseobj = Puppet::Type.type(:file).new(
             :name => basedir,
             :ensure => "directory"
         )
 
-        subobj = Puppet.type(:file).create(
+        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
@@ -837,53 +547,13 @@ class TestFile < Test::Unit::TestCase
         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(
+            file = Puppet::Type.type(:file).new(
                 :name => subpath,
                 :ensure => "directory",
                 :recurse => true
@@ -905,10 +575,11 @@ class TestFile < Test::Unit::TestCase
 
         file = nil
         assert_nothing_raised {
-            file = Puppet.type(:file).create(
+            file = Puppet::Type.type(:file).new(
                 :name => dest,
                 :checksum => "md5",
-                :content => "This is some content"
+                :content => "This is some content",
+                :backup => false
             )
         }
 
@@ -925,7 +596,7 @@ class TestFile < Test::Unit::TestCase
 
         file = nil
         assert_nothing_raised {
-            file = Puppet.type(:file).create(
+            file = Puppet::Type.type(:file).new(
                 :name => dest,
                 :checksum => "md5",
                 :ensure => "file"
@@ -939,59 +610,12 @@ class TestFile < Test::Unit::TestCase
         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(
+            file = Puppet::Type.type(:file).new(
                 :title => "fileness",
                 :path => path,
                 :content => "this is some content"
@@ -1007,7 +631,7 @@ class TestFile < Test::Unit::TestCase
     def test_missinggroup
         file = nil
         assert_nothing_raised {
-            file = Puppet.type(:file).create(
+            file = Puppet::Type.type(:file).new(
                 :path => tempfile(),
                 :group => "fakegroup"
             )
@@ -1018,7 +642,7 @@ class TestFile < Test::Unit::TestCase
 
     def test_modecreation
         path = tempfile()
-        file = Puppet.type(:file).create(
+        file = Puppet::Type.type(:file).new(
             :path => path,
             :ensure => "file",
             :mode => "0777"
@@ -1042,7 +666,7 @@ class TestFile < Test::Unit::TestCase
 
         file = nil
         assert_nothing_raised {
-            file = Puppet.type(:file).create(
+            file = Puppet::Type.type(:file).new(
                 :path => path,
                 :ensure => "file",
                 :content => "some text\n",
@@ -1056,20 +680,17 @@ class TestFile < Test::Unit::TestCase
 
     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)
+        obj = Puppet::Type.type(:file).new(
+            :path => file, :content => "rahness\n", :backup => ".puppet-bak"
+        )
+        catalog = mk_catalog(obj)
+        catalog.apply
 
         backupfile = file + obj[:backup]
         @@tmpfiles << backupfile
@@ -1079,16 +700,16 @@ class TestFile < Test::Unit::TestCase
         assert_equal(0411, filemode(backupfile),
             "File mode is wrong for backupfile")
 
-        bucket = "bucket"
+        name = "bucket"
         bpath = tempfile()
         Dir.mkdir(bpath)
-        Puppet::Type.type(:filebucket).create(
-            :title => bucket, :path => bpath
-        )
+        bucket = Puppet::Type.type(:filebucket).new(:title => name, :path => bpath)
+        catalog.add_resource(bucket)
 
-        obj[:backup] = bucket
+        obj[:backup] = name
         obj[:content] = "New content"
-        assert_apply(obj)
+        catalog.finalize
+        catalog.apply
 
         md5 = "18cc17fa3047fcc691fdf49c0a7f539a"
         dir, file, pathfile = Puppet::Network::Handler.filebucket.paths(bpath, md5)
@@ -1096,32 +717,6 @@ class TestFile < Test::Unit::TestCase
         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()
@@ -1131,9 +726,10 @@ class TestFile < Test::Unit::TestCase
 
         file = nil
         assert_nothing_raised {
-            file = Puppet.type(:file).create(
+            file = Puppet::Type.type(:file).new(
                 :ensure => path,
-                :path => link
+                :path => link,
+                :backup => false
             )
         }
 
@@ -1151,7 +747,7 @@ class TestFile < Test::Unit::TestCase
         dest = File.join(dir, "another space")
 
         File.open(source, "w") { |f| f.puts :yay }
-        obj = Puppet::Type.type(:file).create(
+        obj = Puppet::Type.type(:file).new(
             :path => dest,
             :source => source
         )
@@ -1162,89 +758,6 @@ class TestFile < Test::Unit::TestCase
         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()
@@ -1267,23 +780,23 @@ class TestFile < Test::Unit::TestCase
         home = nil
         ogroup = nil
         assert_nothing_raised {
-            user = Puppet.type(:user).create(
+            user = Puppet::Type.type(:user).new(
                 :name => "pptestu",
                 :home => file,
                 :gid => "pptestg"
             )
-            home = Puppet.type(:file).create(
+            home = Puppet::Type.type(:file).new(
                 :path => file,
                 :owner => "pptestu",
                 :group => "pptestg",
                 :ensure => "directory"
             )
-            group = Puppet.type(:group).create(
+            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 }
@@ -1301,142 +814,25 @@ class TestFile < Test::Unit::TestCase
             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")
@@ -1445,7 +841,7 @@ class TestFile < Test::Unit::TestCase
         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
@@ -1459,7 +855,7 @@ class TestFile < Test::Unit::TestCase
         assert_equal("testing", File.read(path), "file has the wrong content")
     end
     end
-    
+
     # #366
     def test_replace_aliases
         file = Puppet::Type.newfile :path => tempfile()
@@ -1468,142 +864,34 @@ class TestFile < Test::Unit::TestCase
         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
-        
+        catalog = mk_catalog obj
+        transaction = Puppet::Transaction.new(catalog)
+
         assert_equal("/%s" % obj.ref, obj.path)
-        
-        list = obj.eval_generate
-        fileobj = obj.class[file]
+
+        list = transaction.eval_generate(obj)
+        fileobj = catalog.resource(:file, 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")
-        
+        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 #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()
@@ -1614,7 +902,6 @@ class TestFile < Test::Unit::TestCase
             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
@@ -1660,13 +947,13 @@ class TestFile < Test::Unit::TestCase
 
             # Now change something so that we replace the file
             case attr
-            when :source:
+            when :source
                     File.open(source, "w") { |f| f.puts "some different text" }
-            when :content: file[:content] = "something completely different"
+            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)
 
@@ -1677,67 +964,6 @@ class TestFile < Test::Unit::TestCase
     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
@@ -1762,7 +988,7 @@ class TestFile < Test::Unit::TestCase
 
         wh = mock 'writehandle', :print => nil
         rh = mock 'readhandle'
-        rh.expects(:read).with(512).times(2).returns("other").then.returns(nil)
+        rh.expects(:read).with(4096).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)