puppet 0.24.9 → 0.25.0

data/test/ral/type/file/target.rb

@@ -24,7 +24,7 @@ class TestFileTarget < Test::Unit::TestCase
 
         file = nil
         assert_nothing_raised {
-            file = Puppet.type(:file).create(
+            file = Puppet::Type.type(:file).new(
                 :title => "somethingelse",
                 :ensure => path,
                 :path => link
@@ -42,54 +42,6 @@ class TestFileTarget < Test::Unit::TestCase
         assert_events([], file)
         assert_events([], file)
     end
-    
-    def test_linkrecurse
-        dest = tempfile()
-        link = @file.create :path => tempfile(), :recurse => true, :ensure => dest
-        mk_catalog link
-        
-        ret = nil
-        
-        # Start with nothing, just to make sure we get nothing back
-        assert_nothing_raised { ret = link.linkrecurse(true) }
-        assert_nil(ret, "got a return when the dest doesn't exist")
-        
-        # then with a directory with only one file
-        Dir.mkdir(dest)
-        one = File.join(dest, "one")
-        File.open(one, "w") { |f| f.puts "" }
-        link[:ensure] = dest
-        assert_nothing_raised { ret = link.linkrecurse(true) }
-        
-        assert_equal(:directory, link.should(:ensure), "ensure was not set to directory")
-        assert_equal([File.join(link.title, "one")], ret.collect { |f| f.title },
-            "Did not get linked file")
-        oneobj = @file[File.join(link.title, "one")]
-        assert_equal(one, oneobj.should(:target), "target was not set correctly")
-        
-        oneobj.remove
-        File.unlink(one)
-        
-        # Then make sure we get multiple files
-        returns = []
-        5.times do |i|
-            path = File.join(dest, i.to_s)
-            returns << File.join(link.title, i.to_s)
-            File.open(path, "w") { |f| f.puts "" }
-        end
-        assert_nothing_raised { ret = link.linkrecurse(true) }
-
-        assert_equal(returns.sort, ret.collect { |f| f.title }.sort,
-            "Did not get links back")
-        
-        returns.each do |path|
-            obj = @file[path]
-            assert(path, "did not get obj for %s" % path)
-            sdest = File.join(dest, File.basename(path))
-            assert_equal(sdest, obj.should(:target),
-                "target was not set correctly for %s" % path)
-        end
-    end
 
     def test_simplerecursivelinking
         source = tempfile()
@@ -100,16 +52,14 @@ class TestFileTarget < Test::Unit::TestCase
         system("mkdir -p %s" % subdir)
         system("touch %s" % file)
 
-        link = nil
-        assert_nothing_raised {
-            link = Puppet.type(:file).create(
-                :ensure => source,
-                :path => path,
-                :recurse => true
-            )
-        }
+        link = Puppet::Type.type(:file).new(
+            :ensure => source,
+            :path => path,
+            :recurse => true
+        )
 
-        assert_apply(link)
+        catalog = mk_catalog(link)
+        catalog.apply
 
         sublink = File.join(path, "subdir")
         linkpath = File.join(sublink, "file")
@@ -118,7 +68,8 @@ class TestFileTarget < Test::Unit::TestCase
         assert(File.symlink?(linkpath), "path is not a link")
         assert_equal(file, File.readlink(linkpath))
 
-        assert_nil(@file[sublink], "objects were not removed")
+        # Use classes for comparison, because the resource inspection is so large
+        assert_equal(NilClass, catalog.resource(:file, sublink).class, "dynamically generated resources were not removed")
         assert_equal([], link.evaluate, "Link is not in sync")
     end
 
@@ -146,7 +97,7 @@ class TestFileTarget < Test::Unit::TestCase
 
         link = nil
         assert_nothing_raised {
-            link = Puppet.type(:file).create(
+            link = Puppet::Type.type(:file).new(
                 :ensure => source,
                 :path => dest,
                 :recurse => true
@@ -181,7 +132,7 @@ class TestFileTarget < Test::Unit::TestCase
 
         link = nil
         assert_nothing_raised {
-            link = Puppet.type(:file).create(
+            link = Puppet::Type.type(:file).new(
                 :path => dest,
                 :ensure => "source"
             )
@@ -197,20 +148,20 @@ class TestFileTarget < Test::Unit::TestCase
         source = tempfile()
         dest = tempfile()
 
-        objects = []
-        objects << Puppet.type(:exec).create(
+        resources = []
+        resources << Puppet::Type.type(:exec).new(
             :command => "mkdir %s; touch %s/file" % [source, source],
             :title => "yay",
             :path => ENV["PATH"]
         )
-        objects << Puppet.type(:file).create(
+        resources << Puppet::Type.type(:file).new(
             :ensure => source,
             :path => dest,
             :recurse => true,
-            :require => objects[0]
+            :require => resources[0]
         )
 
-        assert_apply(*objects)
+        assert_apply(*resources)
 
         link = File.join(dest, "file")
         assert(FileTest.symlink?(link), "Did not make link")
@@ -252,7 +203,7 @@ class TestFileTarget < Test::Unit::TestCase
 
         file = nil
         assert_nothing_raised {
-            file = Puppet.type(:file).create(
+            file = Puppet::Type.type(:file).new(
                 :ensure => path,
                 :path => link,
                 :backup => false
@@ -283,7 +234,7 @@ class TestFileTarget < Test::Unit::TestCase
         File.open(file, "w") { |f| f.puts "yayness" }
         File.symlink(file, link)
 
-        obj = Puppet::Type.type(:file).create(
+        obj = Puppet::Type.type(:file).new(
             :path => link,
             :ensure => "file"
         )
@@ -314,7 +265,7 @@ class TestFileTarget < Test::Unit::TestCase
         File.open(sourcefile, "w") { |f| f.puts "source" }
         File.symlink(file, link)
 
-        obj = Puppet::Type.type(:file).create(
+        obj = Puppet::Type.type(:file).new(
             :path => dirs["target"],
             :ensure => :file,
             :source => dirs["source"],
@@ -344,7 +295,7 @@ class TestFileTarget < Test::Unit::TestCase
         File.open(dest, "w") { |f| f.puts "boo" }
         File.open(otherdest, "w") { |f| f.puts "yay" }
 
-        obj = Puppet::Type.type(:file).create(
+        obj = Puppet::Type.type(:file).new(
             :path => link,
             :ensure => otherdest
         )

data/test/ral/type/fileignoresource.rb

@@ -10,7 +10,7 @@ require 'fileutils'
 class TestFileIgnoreSources < Test::Unit::TestCase
     include PuppetTest::Support::Utils
     include PuppetTest::FileTesting
-   
+
     def setup
         super
         begin
@@ -18,6 +18,8 @@ class TestFileIgnoreSources < Test::Unit::TestCase
         rescue
             system("rm -rf %s" % Puppet[:statefile])
         end
+
+        Facter.stubs(:to_hash).returns({})
     end
 
 #This is not needed unless using md5 (correct me if I'm wrong)
@@ -54,40 +56,38 @@ class TestFileIgnoreSources < Test::Unit::TestCase
 
         #create source files
 
-        File.open(File.join(frompath,sourcefile1), 
+        File.open(File.join(frompath,sourcefile1),
           File::WRONLY|File::CREAT|File::APPEND) { |of|
             of.puts "yayness"
         }
-      
-        File.open(File.join(frompath,sourcefile2), 
+
+        File.open(File.join(frompath,sourcefile2),
           File::WRONLY|File::CREAT|File::APPEND) { |of|
             of.puts "even yayer"
         }
-      
+
 
         #makes Puppet file Object
         assert_nothing_raised {
-            tofile = Puppet.type(:file).create(
+            tofile = Puppet::Type.type(:file).new(
                 :name => topath,
                 :source => frompath,
-                :recurse => true,                             
-                :ignore => "sourcefile2"                            
+                :recurse => true,
+                :ignore => "sourcefile2"
             )
         }
 
         config = mk_catalog(tofile)
         config.apply
-  
-      
+
+
         #topath should exist as a directory with sourcedir as a directory
-       
+
         #This file should exist
         assert(FileTest.exists?(File.join(topath,sourcefile1)))
 
         #This file should not
         assert(!(FileTest.exists?(File.join(topath,sourcefile2))))
-     
-        Puppet::Type.allclear
     end
 
     def test_ignore_with_wildcard
@@ -104,7 +104,7 @@ class TestFileIgnoreSources < Test::Unit::TestCase
 
         frompath = File.join(path,sourcedir)
         FileUtils.mkdir_p frompath
-        
+
         FileUtils.mkdir_p(File.join(frompath, subdir))
         FileUtils.mkdir_p(File.join(frompath, subdir2))
         dir =  Dir.glob(File.join(path,"**/*"))
@@ -117,35 +117,35 @@ class TestFileIgnoreSources < Test::Unit::TestCase
         trans = nil
 
         #create source files
-               
-        dir.each { |dir|       
-            File.open(File.join(dir,sourcefile1), 
+
+        dir.each { |dir|
+            File.open(File.join(dir,sourcefile1),
              File::WRONLY|File::CREAT|File::APPEND) { |of|
                 of.puts "yayness"
             }
-      
-            File.open(File.join(dir,sourcefile2), 
+
+            File.open(File.join(dir,sourcefile2),
              File::WRONLY|File::CREAT|File::APPEND) { |of|
               of.puts "even yayer"
             }
-      
+
         }
 
         #makes Puppet file Object
         assert_nothing_raised {
-            tofile = Puppet.type(:file).create(
+            tofile = Puppet::Type.type(:file).new(
                 :name => topath,
                 :source => frompath,
-                :recurse => true,                             
-                :ignore => "*2"                            
+                :recurse => true,
+                :ignore => "*2"
             )
         }
 
         config = mk_catalog(tofile)
         config.apply
-              
+
         #topath should exist as a directory with sourcedir as a directory
-       
+
         #This file should exist
         assert(FileTest.exists?(File.join(topath,sourcefile1)))
         assert(FileTest.exists?(File.join(topath,subdir)))
@@ -155,8 +155,6 @@ class TestFileIgnoreSources < Test::Unit::TestCase
         assert(!(FileTest.exists?(File.join(topath,sourcefile2))))
         assert(!(FileTest.exists?(File.join(topath,subdir2))))
         assert(!(FileTest.exists?(File.join(File.join(topath,subdir),sourcefile2))))
-        Puppet::Type.allclear
-
     end
 
     def test_ignore_array
@@ -174,7 +172,7 @@ class TestFileIgnoreSources < Test::Unit::TestCase
 
         frompath = File.join(path,sourcedir)
         FileUtils.mkdir_p frompath
-        
+
         FileUtils.mkdir_p(File.join(frompath, subdir))
         FileUtils.mkdir_p(File.join(frompath, subdir2))
         FileUtils.mkdir_p(File.join(frompath, subdir3))
@@ -188,31 +186,31 @@ class TestFileIgnoreSources < Test::Unit::TestCase
         trans = nil
 
         #create source files
-       
 
-    
-        sourcedir.each { |dir|       
-            File.open(File.join(dir,sourcefile1), 
+
+
+        sourcedir.each { |dir|
+            File.open(File.join(dir,sourcefile1),
              File::WRONLY|File::CREAT|File::APPEND) { |of|
                 of.puts "yayness"
             }
-      
-            File.open(File.join(dir,sourcefile2), 
+
+            File.open(File.join(dir,sourcefile2),
              File::WRONLY|File::CREAT|File::APPEND) { |of|
               of.puts "even yayer"
             }
-      
+
         }
 
 
         #makes Puppet file Object
         assert_nothing_raised {
-            tofile = Puppet.type(:file).create(
+            tofile = Puppet::Type.type(:file).new(
                 :name => topath,
                 :source => frompath,
                 :recurse => true,
-                :ignore => ["*2", "an*"]                            
-               # :ignore => ["*2", "an*", "nomatch"]                            
+                :ignore => ["*2", "an*"]
+               # :ignore => ["*2", "an*", "nomatch"]
             )
         }
 
@@ -226,7 +224,7 @@ class TestFileIgnoreSources < Test::Unit::TestCase
         assert(FileTest.exists?(File.join(topath,sourcefile1)), "file1 not in destdir")
         assert(FileTest.exists?(File.join(topath,subdir)), "subdir1 not in destdir")
         assert(FileTest.exists?(File.join(File.join(topath,subdir),sourcefile1)), "file1 not in subdir")
-        # proper files in source 
+        # proper files in source
         assert(FileTest.exists?(File.join(frompath,subdir)), "subdir not in source")
         assert(FileTest.exists?(File.join(frompath,subdir2)), "subdir2 not in source")
         assert(FileTest.exists?(File.join(frompath,subdir3)), "subdir3 not in source")
@@ -236,10 +234,5 @@ class TestFileIgnoreSources < Test::Unit::TestCase
         assert(!(FileTest.exists?(File.join(topath,subdir2))), "subdir2 in dest")
         assert(!(FileTest.exists?(File.join(topath,subdir3))), "anotherdir in dest")
         assert(!(FileTest.exists?(File.join(File.join(topath,subdir),sourcefile2))), "file2 in dest/sub")
-        
-
-        Puppet::Type.allclear
-
     end
-
 end

data/test/ral/type/filesources.rb

@@ -20,14 +20,15 @@ class TestFileSources < Test::Unit::TestCase
         end
         @file = Puppet::Type.type(:file)
         Puppet[:filetimeout] = -1
-        Puppet::Util::SUIDManager.stubs(:asuser).yields 
+        Puppet::Util::SUIDManager.stubs(:asuser).yields
+        Facter.stubs(:to_hash).returns({})
     end
 
     def teardown
         super
         Puppet::Network::HttpPool.clear_http_instances
     end
-    
+
     def use_storage
         begin
             initstorage
@@ -40,321 +41,34 @@ class TestFileSources < Test::Unit::TestCase
         Puppet::Util::Storage.init
         Puppet::Util::Storage.load
     end
-    
+
     # Make a simple recursive tree.
     def mk_sourcetree
         source = tempfile()
         sourcefile = File.join(source, "file")
         Dir.mkdir source
         File.open(sourcefile, "w") { |f| f.puts "yay" }
-        
+
         dest = tempfile()
         destfile = File.join(dest, "file")
         return source, dest, sourcefile, destfile
     end
 
-    def test_newchild
-        path = tempfile()
-        @@tmpfiles.push path
-
-        FileUtils.mkdir_p path
-        File.open(File.join(path,"childtest"), "w") { |of|
-            of.puts "yayness"
-        }
-        file = nil
-        comp = nil
-        trans = nil
-        assert_nothing_raised {
-            file = Puppet.type(:file).create(
-                :name => path
-            )
-        }
-        config = mk_catalog(file)
-        child = nil
-        assert_nothing_raised {
-            child = file.newchild("childtest", true)
-        }
-        assert(child)
-        assert_raise(Puppet::DevError) {
-            file.newchild(File.join(path,"childtest"), true)
-        }
-    end
-    
-    def test_describe
-        source = tempfile()
-        dest = tempfile()
-        
-        file = Puppet::Type.newfile :path => dest, :source => source, :title => "copier"
-        
-        property = file.property(:source)
-        
-        # First try describing with a normal source
-        result = nil
-        assert_nothing_raised do
-            result = property.describe(source)
-        end
-        assert_nil(result, "Got a result back when source is missing")
-        
-        # Now make a remote directory
-        Dir.mkdir(source)
-        assert_nothing_raised do
-            result = property.describe(source)
-        end
-        assert_equal("directory", result[:type])
-        
-        # And as a file
-        Dir.rmdir(source)
-        File.open(source, "w") { |f| f.puts "yay" }
-        assert_nothing_raised do
-            result = property.describe(source)
-        end
-        assert_equal("file", result[:type])
-        assert(result[:checksum], "did not get value for checksum")
-        if Puppet::Util::SUIDManager.uid == 0
-            assert(result.has_key?(:owner), "Lost owner in describe")
-        else
-            assert(! result.has_key?(:owner),
-                "Kept owner in describe even tho not root")
-        end
-        
-        # Now let's do the various link things
-        File.unlink(source)
-        target = tempfile()
-        File.open(target, "w") { |f| f.puts "yay" }
-        File.symlink(target, source)
-        
-        file[:links] = :manage
-        assert_equal("link", property.describe(source)[:type])
-        
-        # And then make sure links get followed
-        file[:links] = :follow
-        assert_equal("file", property.describe(source)[:type])
-    end
-    
-    def test_source_retrieve
-        source = tempfile()
-        dest = tempfile()
-        
-        file = Puppet::Type.newfile :path => dest, :source => source,
-            :title => "copier"
-        
-        assert(file.property(:checksum), "source property did not create checksum property")
-        property = file.property(:source)
-        assert(property, "did not get source property")
-        
-        # Make sure the munge didn't actually change the source
-        assert_equal([source], property.should, "munging changed the source")
-        
-        currentvalue = nil
-        # Now make the dest a directory, and make sure the object sets :ensure
-        # up to create a directory
-        Dir.mkdir(source)
-        assert_nothing_raised do
-            currentvalue = property.retrieve
-        end
-        assert_equal(:directory, file.should(:ensure),
-            "Did not set to create directory")
-        
-        # And make sure the source property won't try to do anything with a
-        # remote dir
-        assert(property.insync?(currentvalue), "Source was out of sync even tho remote is dir")
-        
-        # Now remove the source, and make sure :ensure was not modified
-        Dir.rmdir(source)
-        assert_equal(:directory, file.should(:ensure),
-            "Did not keep :ensure setting")
-        
-        # Now have a remote file and make sure things work correctly
-        File.open(source, "w") { |f| f.puts "yay" }
-        File.chmod(0755, source)
-        
-        assert_nothing_raised do
-            property.retrieve
-        end
-        assert_equal(:file, file.should(:ensure),
-            "Did not make correct :ensure setting")
-        assert_equal(0755, file.should(:mode),
-            "Mode was not copied over")
-        
-        # Now let's make sure that we get the first found source
-        fake = tempfile()
-        property.should = [fake, source]
-        assert_nothing_raised do
-            property.retrieve
-        end
-        assert_equal(Digest::MD5.hexdigest(File.read(source)), property.checksum.sub(/^\{\w+\}/, ''), 
-            "Did not catch later source")
-    end
-    
-    def test_insync
-        source = tempfile()
-        dest = tempfile()
-        
-        file = Puppet::Type.newfile :path => dest, :source => source,
-            :title => "copier"
-        
-        property = file.property(:source)
-        assert(property, "did not get source property")
-        
-        # with a directory
-        Dir.mkdir(source)
-        currentvalues = file.retrieve
-        assert(property.insync?(currentvalues[property]), "source property not in sync with directory as source")
-        Dir.rmdir(source)
-        
-        # with a file
-        File.open(source, "w") { |f| f.puts "yay" }
-        currentvalues = file.retrieve
-        assert(!property.insync?(currentvalues[property]), "source property was in sync when file was missing")
-        
-        # With a different file
-        File.open(dest, "w") { |f| f.puts "foo" }
-        currentvalues = file.retrieve
-        assert(!property.insync?(currentvalues[property]), "source property was in sync with different file")
-        
-        # with matching files
-        File.open(dest, "w") { |f| f.puts "yay" }
-        currentvalues = file.retrieve
-        assert(property.insync?(currentvalues[property]), "source property was not in sync with matching file")
-    end
-    
-    def test_source_sync
-        source = tempfile()
-        dest = tempfile()
-
-        file = Puppet::Type.newfile :path => dest, :source => source,
-            :title => "copier"
-        property = file.property(:source)
-        
-        File.open(source, "w") { |f| f.puts "yay" }
-        
-        currentvalues = file.retrieve
-        assert(! property.insync?(currentvalues[property]), "source thinks it's in sync")
-        
-        event = nil
-        assert_nothing_raised do
-            event = property.sync
-        end
-        assert_equal(:file_created, event)
-        assert_equal(File.read(source), File.read(dest),
-            "File was not copied correctly")
-        
-        # Now write something different
-        File.open(source, "w") { |f| f.puts "rah" }
-        currentvalues = file.retrieve
-        assert(! property.insync?(currentvalues[property]), "source should be out of sync")
-        assert_nothing_raised do
-            event = property.sync
-        end
-        assert_equal(:file_changed, event)
-        assert_equal(File.read(source), File.read(dest),
-            "File was not copied correctly")
-    end
-    
-    # XXX This test doesn't cover everything.  Specifically,
-    # it doesn't handle 'ignore' and 'links'.
-    def test_sourcerecurse
-        source, dest, sourcefile, destfile = mk_sourcetree
-        
-        # The sourcerecurse method will only ever get called when we're
-        # recursing, so we go ahead and set it.
-        obj = Puppet::Type.newfile :source => source, :path => dest, :recurse => true
-        config = mk_catalog(obj)
-
-        result = nil
-        sourced = nil
-        assert_nothing_raised do
-            result, sourced = obj.sourcerecurse(true)
-        end
-
-        assert_equal([destfile], sourced, "Did not get correct list of sourced objects")
-        dfileobj = @file[destfile]
-        assert(dfileobj, "Did not create destfile object")
-        assert_equal([dfileobj], result)
-        
-        # Clean this up so it can be recreated
-        config.remove_resource(dfileobj)
-        
-        # Make sure we correctly iterate over the sources
-        nosource = tempfile()
-        obj[:source] = [nosource, source]
-
-        result = nil
-        assert_nothing_raised do
-            result, sourced = obj.sourcerecurse(true)
-        end
-        assert_equal([destfile], sourced, "Did not get correct list of sourced objects")
-        dfileobj = @file[destfile]
-        assert(dfileobj, "Did not create destfile object with a missing source")
-        assert_equal([dfileobj], result)
-        dfileobj.remove
-        
-        # Lastly, make sure we return an empty array when no sources are there
-        obj[:source] = [nosource, tempfile()]
-        
-        assert_raise(Puppet::Error) do
-            result, sourced = obj.sourcerecurse(true)
-        end
-    end
-
-    def test_simplelocalsource
-        path = tempfile()
-        FileUtils.mkdir_p path
-        frompath = File.join(path,"source")
-        topath = File.join(path,"dest")
-        fromfile = nil
-        tofile = nil
-        trans = nil
-
-        File.open(frompath, File::WRONLY|File::CREAT|File::APPEND) { |of|
-            of.puts "yayness"
-        }
-        assert_nothing_raised {
-            tofile = Puppet.type(:file).create(
-                :name => topath,
-                :source => frompath
-            )
-        }
-
-        assert_apply(tofile)
-
-        assert(FileTest.exists?(topath), "File #{topath} is missing")
-        from = File.open(frompath) { |o| o.read }
-        to = File.open(topath) { |o| o.read }
-        assert_equal(from,to)
-    end
-    
-    # Make sure a simple recursive copy works
-    def test_simple_recursive_source
-        source, dest, sourcefile, destfile = mk_sourcetree
-        
-        file = Puppet::Type.newfile :path => dest, :source => source, :recurse => true
-        
-        assert_events([:directory_created, :file_created], file)
-        
-        assert(FileTest.directory?(dest), "Dest dir was not created")
-        assert(FileTest.file?(destfile), "dest file was not created")
-        assert_equal("yay\n", File.read(destfile), "dest file was not copied correctly")
-    end
-
     def recursive_source_test(fromdir, todir)
-        Puppet::Type.allclear
         initstorage
         tofile = nil
         trans = nil
 
-        assert_nothing_raised {
-            tofile = Puppet.type(:file).create(
-                :path => todir,
-                :recurse => true,
-                :backup => false,
-                :source => fromdir
-            )
-        }
-        assert_apply(tofile)
+        tofile = Puppet::Type.type(:file).new(
+            :path => todir,
+            :recurse => true,
+            :backup => false,
+            :source => fromdir
+        )
+        catalog = mk_catalog(tofile)
+        catalog.apply
 
         assert(FileTest.exists?(todir), "Created dir %s does not exist" % todir)
-        Puppet::Type.allclear
     end
 
     def run_complex_sources(networked = false)
@@ -396,9 +110,6 @@ class TestFileSources < Test::Unit::TestCase
     def test_sources_with_deleted_destfiles
         fromdir, todir, one, two = run_complex_sources
         assert(FileTest.exists?(todir))
-        
-        # We shouldn't have a 'two' file object in memory
-        assert_nil(@file[two], "object for 'two' is still in memory")
 
         # then delete a file
         File.unlink(two)
@@ -420,7 +131,7 @@ class TestFileSources < Test::Unit::TestCase
 
         # and make sure they're still equal
         assert_trees_equal(fromdir,todir)
-        
+
         # Now try it with the directory being read-only
         File.chmod(0111, todir)
         recursive_source_test(fromdir, todir)
@@ -433,7 +144,7 @@ class TestFileSources < Test::Unit::TestCase
         fromdir, todir, one, two = run_complex_sources
 
         assert(FileTest.exists?(todir))
-        
+
         # Modify a dest file
         File.open(two, "w") { |f| f.puts "something else" }
 
@@ -460,7 +171,7 @@ class TestFileSources < Test::Unit::TestCase
         FileUtils.cd(todir) {
             %x{find . 2>/dev/null}.chomp.split(/\n/).each { |file|
                 if file =~ /file[0-9]+/
-                    File.unlink(file)
+                    FileUtils.rm_rf(file)
                 end
             }
         }
@@ -481,14 +192,14 @@ class TestFileSources < Test::Unit::TestCase
         File.open(file1, "w") { |f| f.puts "yay" }
         rootobj = nil
         assert_nothing_raised {
-            rootobj = Puppet.type(:file).create(
+            rootobj = Puppet::Type.type(:file).new(
                 :name => basedir,
                 :recurse => true,
                 :check => %w{type owner},
                 :mode => 0755
             )
         }
-        
+
         assert_apply(rootobj)
         assert_equal(0755, filemode(file1))
 
@@ -514,53 +225,6 @@ class TestFileSources < Test::Unit::TestCase
         return file
     end
 
-    def test_NetworkSources
-        server = nil
-        mounts = {
-            "/" => "root"
-        }
-
-        fileserverconf = mkfileserverconf(mounts)
-
-        Puppet[:autosign] = true
-
-        Puppet[:masterport] = 8762
-        Puppet[:name] = "puppetmasterd"
-        Puppet[:certdnsnames] = "localhost"
-
-        serverpid = nil
-        assert_nothing_raised() {
-            server = Puppet::Network::HTTPServer::WEBrick.new(
-                :Handlers => {
-                    :CA => {}, # so that certs autogenerate
-                    :FileServer => {
-                        :Config => fileserverconf
-                    }
-                }
-            )
-
-        }
-        serverpid = fork {
-            assert_nothing_raised() {
-                #trap(:INT) { server.shutdown; Kernel.exit! }
-                trap(:INT) { server.shutdown }
-                server.start
-            }
-        }
-        @@tmppids << serverpid
-
-        sleep(1)
-
-        fromdir, todir = run_complex_sources("root")
-        assert_trees_equal(fromdir,todir)
-        recursive_source_test(fromdir, todir)
-        assert_trees_equal(fromdir,todir)
-
-        assert_nothing_raised {
-            system("kill -INT %s" % serverpid)
-        }
-    end
-
     def test_unmountedNetworkSources
         server = nil
         mounts = {
@@ -600,14 +264,14 @@ class TestFileSources < Test::Unit::TestCase
         sleep(1)
 
         name = File.join(tmpdir(), "nosourcefile")
-        file = Puppet.type(:file).create(
+        file = Puppet::Type.type(:file).new(
             :source => "puppet://localhost/noexist/file",
             :name => name
         )
 
-        assert_raise Puppet::Error do 
+        assert_raise Puppet::Error do
             file.retrieve
-        end 
+        end
 
         comp = mk_catalog(file)
         comp.apply
@@ -627,7 +291,7 @@ class TestFileSources < Test::Unit::TestCase
         # Now the files should be exactly the same, so we should not see attempts
         # at copying
         assert_nothing_raised {
-            file = Puppet.type(:file).create(
+            file = Puppet::Type.type(:file).new(
                 :path => to,
                 :source => from
             )
@@ -635,7 +299,7 @@ class TestFileSources < Test::Unit::TestCase
 
         currentvalue = file.retrieve
 
-        assert(currentvalue[file.property(:checksum)], 
+        assert(currentvalue[file.property(:checksum)],
                "File does not have a checksum property")
 
         assert_equal(0, file.evaluate.length, "File produced changes")
@@ -643,7 +307,7 @@ class TestFileSources < Test::Unit::TestCase
 
     def test_sourcepaths
         files = []
-        3.times { 
+        3.times {
             files << tempfile()
         }
 
@@ -653,7 +317,7 @@ class TestFileSources < Test::Unit::TestCase
 
         file = nil
         assert_nothing_raised {
-            file = Puppet.type(:file).create(
+            file = Puppet::Type.type(:file).new(
                 :name => to,
                 :source => files
             )
@@ -679,7 +343,7 @@ class TestFileSources < Test::Unit::TestCase
 
         file = nil
         assert_nothing_raised {
-            file = Puppet.type(:file).create(
+            file = Puppet::Type.type(:file).new(
                 :name => dest,
                 :source => source
             )
@@ -700,7 +364,7 @@ class TestFileSources < Test::Unit::TestCase
 
         file = nil
         assert_nothing_raised {
-            file = Puppet.type(:file).create(
+            file = Puppet::Type.type(:file).new(
                 :name => dest,
                 :ensure => "file",
                 :source => source
@@ -723,77 +387,18 @@ class TestFileSources < Test::Unit::TestCase
         File.open(source, "w") { |f| f.puts "yay" }
         File.symlink(source, link)
 
-        file = nil
-        assert_nothing_raised {
-            file = Puppet.type(:file).create(
-                :name => dest,
-                :source => link,
-                :links => :follow
-            )
-        }
-
-        assert_events([:file_created], file)
-        assert(FileTest.file?(dest), "Destination is not a file")
-
-        # Now copy the links
-        file[:links] = :manage
-        assert_events([:link_created], file)
-        assert(FileTest.symlink?(dest), "Destination is not a link")
-    end
-
-    def test_changes
-        source = tempfile()
-        dest = tempfile()
-
-        File.open(source, "w") { |f| f.puts "yay" }
-
-        obj = nil
-        assert_nothing_raised {
-            obj = Puppet.type(:file).create(
-                :name => dest,
-                :source => source
-            )
-        }
-
-        assert_events([:file_created], obj)
-        assert_equal(File.read(source), File.read(dest), "Files are not equal")
-        assert_events([], obj)
-
-        File.open(source, "w") { |f| f.puts "boo" }
-
-        assert_events([:file_changed], obj)
-        assert_equal(File.read(source), File.read(dest), "Files are not equal")
-        assert_events([], obj)
-
-        File.open(dest, "w") { |f| f.puts "kaboom" }
-
-        # There are two changes, because first the checksum is noticed, and
-        # then the source causes a change
-        assert_events([:file_changed, :file_changed], obj)
-        assert_equal(File.read(source), File.read(dest), "Files are not equal")
-        assert_events([], obj)
-    end
-
-    def test_file_source_with_space
-        dir = tempfile()
-        source = File.join(dir, "file with spaces")
-        Dir.mkdir(dir)
-        File.open(source, "w") { |f| f.puts "yayness" }
-
-        newdir = tempfile()
-        newpath = File.join(newdir, "file with spaces")
-
-        file = Puppet::Type.newfile(
-            :path => newdir,
-            :source => dir,
-            :recurse => true
-        )
+        file = Puppet::Type.type(:file).new(:name => dest, :source => link)
 
+        catalog = mk_catalog(file)
 
-        assert_apply(file)
+        # Default to managing links
+        catalog.apply
+        assert(FileTest.symlink?(dest), "Did not create link")
 
-        assert(FileTest.exists?(newpath), "Did not create file")
-        assert_equal("yayness\n", File.read(newpath))
+        # Now follow the links
+        file[:links] = :follow
+        catalog.apply
+        assert(FileTest.file?(dest), "Destination is not a file")
     end
 
     # Make sure files aren't replaced when replace is false, but otherwise
@@ -828,49 +433,14 @@ class TestFileSources < Test::Unit::TestCase
             "File got replaced when :replace was false")
 
         # Now set it to true and make sure it does change.
-        assert_nothing_raised {
-            file[:replace] = true
-        }
+        file[:replace] = true
         assert_apply(file)
 
-        # Make sure it doesn't change.
+        # Make sure it changes.
         assert_equal("funtest\n", File.read(dest),
             "File was not replaced when :replace was true")
     end
 
-    # Testing #285.  This just makes sure that URI parsing works correctly.
-    def test_fileswithpoundsigns
-        dir = tstdir()
-        subdir = File.join(dir, "#dir")
-        Dir.mkdir(subdir)
-        file = File.join(subdir, "file")
-        File.open(file, "w") { |f| f.puts "yayness" }
-
-        dest = tempfile()
-        source = "file://localhost#{dir}"
-        obj = Puppet::Type.newfile(
-            :path => dest,
-            :source => source,
-            :recurse => true
-        )
-
-        newfile = File.join(dest, "#dir", "file")
-
-        poundsource = "file://localhost#{subdir}"
-
-        sourceobj = path = nil
-        assert_nothing_raised {
-            sourceobj, path = obj.uri2obj(poundsource)
-        }
-
-        assert_equal("/localhost" + URI.escape(subdir), path)
-
-        assert_apply(obj)
-
-        assert(FileTest.exists?(newfile), "File did not get created")
-        assert_equal("yayness\n", File.read(newfile))
-    end
-
     def test_sourceselect
         dest = tempfile()
         sources = []
@@ -919,7 +489,7 @@ class TestFileSources < Test::Unit::TestCase
         assert(FileTest.exists?(file3), "File from source 1 was not copied")
         assert_equal("0", File.read(file3), "file3 got wrong contents")
     end
-    
+
     def test_recursive_sourceselect
         dest = tempfile()
         source1 = tempfile()
@@ -936,15 +506,15 @@ class TestFileSources < Test::Unit::TestCase
             File.open(file, "w") { |f| f.puts "yaysecond-%s" % i}
             files << file
         end
-        
+
         obj = Puppet::Type.newfile(:path => dest, :source => [source1, source2], :sourceselect => :all, :recurse => true)
-        
+
         assert_apply(obj)
-        
+
         ["file0", "file1", "second-file0", "second-file1", "subdir/file2", "subdir/second-file2", "subdir/file3", "subdir/second-file3"].each do |file|
             path = File.join(dest, file)
             assert(FileTest.exists?(path), "did not create %s" % file)
-            
+
             assert_equal("yay%s\n" % File.basename(file).sub("file", ''), File.read(path), "file was not copied correctly")
         end
     end