puppet 0.24.9 → 0.25.0

data/spec/unit/type/component.rb

@@ -0,0 +1,63 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+component = Puppet::Type.type(:component)
+
+describe component do
+    it "should have a :name attribute" do
+        component.attrclass(:name).should_not be_nil
+    end
+
+    it "should use Class as its type when a normal string is provided as the title" do
+        component.new(:name => "bar").ref.should == "Class[bar]"
+    end
+
+    it "should always produce a resource reference string as its title" do
+        component.new(:name => "bar").title.should == "Class[bar]"
+    end
+
+    it "should have a reference string equivalent to its title" do
+        comp = component.new(:name => "Foo[bar]")
+        comp.title.should == comp.ref
+    end
+
+    it "should alias itself to its reference if it has a catalog and the catalog does not already have a resource with the same reference" do
+        catalog = mock 'catalog'
+        catalog.expects(:resource).with("Foo[bar]").returns nil
+
+        catalog.expects(:alias).with { |resource, name| resource.is_a?(component) and name == "Foo[bar]" }
+
+        component.new(:name => "Foo[bar]", :catalog => catalog)
+    end
+
+    it "should not fail when provided an invalid value" do
+        comp = component.new(:name => "Foo[bar]")
+        lambda { comp[:yayness] = "ey" }.should_not raise_error
+    end
+
+    it "should return previously provided invalid values" do
+        comp = component.new(:name => "Foo[bar]")
+        comp[:yayness] = "eh"
+        comp[:yayness].should == "eh"
+    end
+
+    it "should correctly support metaparameters" do
+        comp = component.new(:name => "Foo[bar]", :require => "Foo[bar]")
+        comp.parameter(:require).should be_instance_of(component.attrclass(:require))
+    end
+
+    describe "when building up the path" do
+        it "should produce the class name if the component models a class" do
+            component.new(:name => "Class[foo]").pathbuilder.must == ["foo"]
+        end
+
+        it "should produce an empty string if the component models the 'main' class" do
+            component.new(:name => "Class[main]").pathbuilder.must == [""]
+        end
+
+        it "should produce a resource reference if the component does not model a class" do
+            component.new(:name => "Foo[bar]").pathbuilder.must == ["Foo[bar]"]
+        end
+    end
+end

data/spec/unit/type/computer.rb

@@ -1,34 +1,30 @@
 #!/usr/bin/env ruby
- 
+
 require File.dirname(__FILE__) + '/../../spec_helper'
 
 computer = Puppet::Type.type(:computer)
 
-describe Puppet.type(:computer), " when checking computer objects" do
+describe Puppet::Type.type(:computer), " when checking computer objects" do
     before do
         provider_class = Puppet::Type::Computer.provider(Puppet::Type::Computer.providers[0])
         Puppet::Type::Computer.expects(:defaultprovider).returns provider_class
-        @resource = Puppet::Type::Computer.create(
+        @resource = Puppet::Type::Computer.new(
                         :name => "puppetcomputertest",
                         :en_address => "aa:bb:cc:dd:ee:ff",
                         :ip_address => "1.2.3.4")
         @properties = {}
         @ensure = Puppet::Type::Computer.attrclass(:ensure).new(:resource => @resource)
     end
-  
-    after do
-        computer.clear
-    end
-    
+
     it "should be able to create a instance" do
         provider_class = Puppet::Type::Computer.provider(Puppet::Type::Computer.providers[0])
         Puppet::Type::Computer.expects(:defaultprovider).returns provider_class
-        computer.create(:name => "bar").should_not be_nil
+        computer.new(:name => "bar").should_not be_nil
     end
-  
+
     properties = [:en_address, :ip_address]
     params = [:name]
-  
+
     properties.each do |property|
         it "should have a %s property" % property do
             computer.attrclass(property).ancestors.should be_include(Puppet::Property)
@@ -37,14 +33,14 @@ describe Puppet.type(:computer), " when checking computer objects" do
         it "should have documentation for its %s property" % property do
             computer.attrclass(property).doc.should be_instance_of(String)
         end
-        
+
         it "should accept :absent as a value" do
             prop = computer.attrclass(property).new(:resource => @resource)
             prop.should = :absent
             prop.should.must == :absent
         end
     end
-    
+
     params.each do |param|
         it "should have a %s parameter" % param do
             computer.attrclass(param).ancestors.should be_include(Puppet::Parameter)
@@ -54,7 +50,7 @@ describe Puppet.type(:computer), " when checking computer objects" do
             computer.attrclass(param).doc.should be_instance_of(String)
         end
     end
-    
+
     describe "default values" do
         before do
             provider_class = computer.provider(computer.providers[0])
@@ -62,21 +58,21 @@ describe Puppet.type(:computer), " when checking computer objects" do
         end
 
         it "should be nil for en_address" do
-            computer.create(:name => :en_address)[:en_address].should == nil
+            computer.new(:name => :en_address)[:en_address].should == nil
         end
-        
+
         it "should be nil for ip_address" do
-            computer.create(:name => :ip_address)[:ip_address].should == nil
+            computer.new(:name => :ip_address)[:ip_address].should == nil
         end
     end
-        
-    describe "when managing the ensure property" do    
+
+    describe "when managing the ensure property" do
         it "should support a :present value" do
             lambda { @ensure.should = :present }.should_not raise_error
         end
-    
+
         it "should support an :absent value" do
             lambda { @ensure.should = :absent }.should_not raise_error
         end
     end
-end
+end

data/spec/unit/type/exec.rb

@@ -3,11 +3,11 @@
 require File.dirname(__FILE__) + '/../../spec_helper'
 
 module ExecModuleTesting
-    def create_resource(command, output, exitstatus)
+    def create_resource(command, output, exitstatus, returns = [0])
         @user_name = 'some_user_name'
         @group_name = 'some_group_name'
         Puppet.features.stubs(:root?).returns(true)
-        @execer = Puppet::Type.type(:exec).create(:name => command, :path => %w{/usr/bin /bin}, :user => @user_name, :group => @group_name)
+        @execer = Puppet::Type.type(:exec).new(:name => command, :path => %w{/usr/bin /bin}, :user => @user_name, :group => @group_name, :returns => returns)
 
         status = stub "process"
         status.stubs(:exitstatus).returns(exitstatus)
@@ -44,6 +44,18 @@ describe Puppet::Type.type(:exec), " when execing" do
 
         proc { @execer.refresh }.should raise_error(Puppet::Error)
     end
+    
+    it "should not report a failure if the exit status is specified in a returns array" do
+        command = "false"
+        create_resource(command, "", 1, [0,1])
+        proc { @execer.refresh }.should_not raise_error(Puppet::Error)
+    end
+    
+    it "should report a failure if the exit status is not specified in a returns array" do
+        command = "false"
+        create_resource(command, "", 1, [0,100])
+        proc { @execer.refresh }.should raise_error(Puppet::Error)
+    end
 
     it "should log the output on success" do
         #Puppet::Util::Log.newdestination :console
@@ -89,3 +101,16 @@ describe Puppet::Type.type(:exec), " when logoutput=>on_failure is set," do
         @execer.refresh
     end
 end
+
+describe Puppet::Type.type(:exec) do
+    it "should be able to autorequire files mentioned in the command" do
+        catalog = Puppet::Resource::Catalog.new
+        catalog.add_resource Puppet::Type.type(:file).new(:name => "/bin/true")
+        @execer = Puppet::Type.type(:exec).new(:name => "/bin/true")
+        catalog.add_resource @execer
+
+        rels = @execer.autorequire
+        rels[0].should be_instance_of(Puppet::Relationship)
+        rels[0].target.should equal(@execer)
+    end
+end

data/spec/unit/type/file.rb

@@ -7,107 +7,103 @@ describe Puppet::Type.type(:file) do
         Puppet.settings.stubs(:use)
 
         @path = Tempfile.new("puppetspec")
+        pathname = @path.path
         @path.close!()
-        @path = @path.path
-        @file = Puppet::Type::File.create(:name => @path)
-    end
-
-    describe "when used with content and replace=>false" do
-        before do
-            @file[:content] = "foo"
-            @file[:replace] = false
-        end
+        @path = pathname
+        @file = Puppet::Type::File.new(:name => @path)
 
-        it "should be insync if the file exists and the content is different" do
-            File.open(@path, "w") do |f| f.puts "bar" end
-            @file.property(:content).insync?("bar").should be_true
-        end
-
-        it "should be insync if the file exists and the content is right" do
-            File.open(@path, "w") do |f| f.puts "foo" end
-            @file.property(:content).insync?("foo").should be_true
-        end
+        @catalog = Puppet::Resource::Catalog.new
+        @file.catalog = @catalog
+    end
 
-        it "should not be insync if the file does not exist" do
-            @file.property(:content).insync?(:nil).should be_false
-        end
+    it "should have a method for determining if the file is present" do
+        @file.must respond_to(:exist?)
     end
 
-    describe "when specifying a source" do
-        before do
-            @file[:source] = "/bar"
-        end
+    it "should be considered existent if it can be stat'ed" do
+        @file.expects(:stat).returns mock('stat')
+        @file.must be_exist
+    end
 
-        it "should raise if source doesn't exist" do
-            @file.property(:source).expects(:found?).returns(false)
-            lambda { @file.retrieve }.should raise_error(Puppet::Error)
-        end
+    it "should be considered nonexistent if it can not be stat'ed" do
+        @file.expects(:stat).returns nil
+        @file.must_not be_exist
+    end
 
-        it "should have a checksum type of md5 and warn if retrieving with mtime" do
-            File.open(@path, "w") do |f| f.puts "foo" end
-            @file.property(:checksum).expects(:warning).with("Files with source set must use md5 as checksum. Forcing to md5 from %s for %s" % [:mtime, @path]) 
-            @file[:checksum] = :mtime
-            @file.property(:checksum).checktype.should == :md5
-            @file.property(:checksum).retrieve.should == "{md5}d3b07384d113edec49eaa6238ad5ff00"
-        end
+    it "should have a method for determining if the file should be a normal file" do
+        @file.must respond_to(:should_be_file?)
+    end
 
-        it "should have a checksum type of md5 and warn if retrieving with md5lite" do
-            File.open(@path, "w") do |f| f.puts "foo" end
-            @file.property(:checksum).expects(:warning).with("Files with source set must use md5 as checksum. Forcing to md5 from %s for %s" % [:md5lite, @path]) 
-            @file[:checksum] = :md5lite
-            @file.property(:checksum).checktype.should == :md5
-            @file.property(:checksum).retrieve.should == "{md5}d3b07384d113edec49eaa6238ad5ff00"
-        end
+    it "should be a file if :ensure is set to :file" do
+        @file[:ensure] = :file
+        @file.must be_should_be_file
+    end
 
+    it "should be a file if :ensure is set to :present and the file exists as a normal file" do
+        @file.stubs(:stat).returns(mock('stat', :ftype => "file"))
+        @file[:ensure] = :present
+        @file.must be_should_be_file
+    end
 
-        it "should have a checksum type of md5 if getsum called with mtime" do
-            File.open(@path, "w") do |f| f.puts "foo" end
-            @file[:checksum] = :md5
-            @file.property(:checksum).checktype.should == :md5
-            @file.property(:checksum).getsum(:mtime).should == "{md5}d3b07384d113edec49eaa6238ad5ff00"
-        end
+    it "should not be a file if :ensure is set to something other than :file" do
+        @file[:ensure] = :directory
+        @file.must_not be_should_be_file
+    end
 
-        it "should not warn if sumtype set to md5" do
-            File.open(@path, "w") do |f| f.puts "foo" end
-            @file.property(:checksum).expects(:warning).never
-            @file[:checksum] = :md5
-            @file.property(:checksum).checktype.should == :md5
-            @file.property(:checksum).retrieve.should == "{md5}d3b07384d113edec49eaa6238ad5ff00"
-        end
+    it "should not be a file if :ensure is set to :present and the file exists but is not a normal file" do
+        @file.stubs(:stat).returns(mock('stat', :ftype => "directory"))
+        @file[:ensure] = :present
+        @file.must_not be_should_be_file
+    end
 
+    it "should be a file if :ensure is not set and :content is" do
+        @file[:content] = "foo"
+        @file.must be_should_be_file
     end
 
-    describe "when retrieving remote files" do
-        before do
-            @filesource = Puppet::Type::File::FileSource.new
-            @filesource.server = mock 'fileserver'
+    it "should be a file if neither :ensure nor :content is set but the file exists as a normal file" do
+        @file.stubs(:stat).returns(mock("stat", :ftype => "file"))
+        @file.must be_should_be_file
+    end
 
-            @file.stubs(:uri2obj).returns(@filesource)
+    it "should not be a file if neither :ensure nor :content is set but the file exists but not as a normal file" do
+        @file.stubs(:stat).returns(mock("stat", :ftype => "directory"))
+        @file.must_not be_should_be_file
+    end
 
-            @file[:source] = "puppet:///test"
-        end
+    it "should autorequire its parent directory" do
+        catalog = Puppet::Resource::Catalog.new
+        file = Puppet::Type::File.new(:name => "/foo/bar")
+        dir = Puppet::Type::File.new(:name => "/foo")
+        catalog.add_resource file
+        catalog.add_resource dir
+        reqs = file.autorequire
+        reqs[0].source.must == dir
+        reqs[0].target.must == file
+    end
 
-        it "should fail without writing if it cannot retrieve remote contents" do
-            # create the file, because we only get the problem when it starts
-            # out absent.
-            File.open(@file[:path], "w") { |f| f.puts "a" }
-            @file.expects(:write).never
+    it "should not autorequire its parent dir if its parent dir is itself" do
+        catalog = Puppet::Resource::Catalog.new
+        file = Puppet::Type::File.new(:name => "/")
+        catalog.add_resource file
+        file.autorequire.should be_empty
+    end
 
-            @filesource.server.stubs(:describe).returns("493\tfile\t100\t0\t{md5}3f5fef3bddbc4398c46a7bd7ba7b3af7")
-            @filesource.server.stubs(:retrieve).raises(RuntimeError)
-            @file.property(:source).retrieve
-            lambda { @file.property(:source).sync }.should raise_error(Puppet::Error)
+    describe "when validating attributes" do
+        %w{path backup recurse recurselimit source replace force ignore links purge sourceselect}.each do |attr|
+            it "should have a '#{attr}' parameter" do
+                Puppet::Type.type(:file).attrtype(attr.intern).should == :param
+            end
         end
 
-        it "should fail if it cannot describe remote contents" do
-            @filesource.server.stubs(:describe).raises(Puppet::Network::XMLRPCClientError.new("Testing"))
-            lambda { @file.retrieve }.should raise_error(Puppet::Error)
+        %w{checksum content target ensure owner group mode type}.each do |attr|
+            it "should have a '#{attr}' property" do
+                Puppet::Type.type(:file).attrtype(attr.intern).should == :property
+            end
         end
 
-        it "should fail during eval_generate if no remote sources exist" do
-            file = Puppet::Type.type(:file).create :path => "/foobar", :source => "/this/file/does/not/exist", :recurse => true
-
-            lambda { file.eval_generate }.should raise_error(Puppet::Error)
+        it "should have its 'path' attribute set as its namevar" do
+            Puppet::Type.type(:file).namevar.should == :path
         end
     end
 
@@ -125,11 +121,10 @@ describe Puppet::Type.type(:file) do
             File.open(@file, "w", 0644) { |f| f.puts "yayness"; f.flush }
             File.symlink(@file, @link)
 
-            @resource = Puppet.type(:file).create(
+            @resource = Puppet::Type.type(:file).new(
                 :path => @link,
                 :mode => "755"
             )
-            @catalog = Puppet::Node::Catalog.new
             @catalog.add_resource @resource
         end
 
@@ -151,7 +146,633 @@ describe Puppet::Type.type(:file) do
         end
     end
 
-    after do
-        Puppet::Type::File.clear
+    it "should be able to retrieve a stat instance for the file it is managing" do
+        Puppet::Type.type(:file).new(:path => "/foo/bar", :source => "/bar/foo").should respond_to(:stat)
+    end
+
+    describe "when stat'ing its file" do
+        before do
+            @resource = Puppet::Type.type(:file).new(:path => "/foo/bar")
+            @resource[:links] = :manage # so we always use :lstat
+        end
+
+        it "should use :stat if it is following links" do
+            @resource[:links] = :follow
+            File.expects(:stat)
+
+            @resource.stat
+        end
+
+        it "should use :lstat if is it not following links" do
+            @resource[:links] = :manage
+            File.expects(:lstat)
+
+            @resource.stat
+        end
+
+        it "should stat the path of the file" do
+            File.expects(:lstat).with("/foo/bar")
+
+            @resource.stat
+        end
+
+        # This only happens in testing.
+        it "should return nil if the stat does not exist" do
+            File.expects(:lstat).returns nil
+
+            @resource.stat.should be_nil
+        end
+
+        it "should return nil if the file does not exist" do
+            File.expects(:lstat).raises(Errno::ENOENT)
+
+            @resource.stat.should be_nil
+        end
+
+        it "should return nil if the file cannot be stat'ed" do
+            File.expects(:lstat).raises(Errno::EACCES)
+
+            @resource.stat.should be_nil
+        end
+
+        it "should return the stat instance" do
+            File.expects(:lstat).returns "mystat"
+
+            @resource.stat.should == "mystat"
+        end
+
+        it "should cache the stat instance if it has a catalog and is applying" do
+            stat = mock 'stat'
+            File.expects(:lstat).returns stat
+
+            catalog = Puppet::Resource::Catalog.new
+            @resource.catalog = catalog
+
+            catalog.stubs(:applying?).returns true
+
+            @resource.stat.should equal(@resource.stat)
+        end
+    end
+
+    describe "when flushing" do
+        it "should flush all properties that respond to :flush" do
+            @resource = Puppet::Type.type(:file).new(:path => "/foo/bar", :source => "/bar/foo")
+            @resource.parameter(:source).expects(:flush)
+            @resource.flush
+        end
+
+        it "should reset its stat reference" do
+            @resource = Puppet::Type.type(:file).new(:path => "/foo/bar")
+            File.expects(:lstat).times(2).returns("stat1").then.returns("stat2")
+            @resource.stat.should == "stat1"
+            @resource.flush
+            @resource.stat.should == "stat2"
+        end
+    end
+
+    it "should have a method for performing recursion" do
+        @file.must respond_to(:perform_recursion)
+    end
+
+    describe "when executing a recursive search" do
+        it "should use Metadata to do its recursion" do
+            Puppet::FileServing::Metadata.expects(:search)
+            @file.perform_recursion(@file[:path])
+        end
+
+        it "should use the provided path as the key to the search" do
+            Puppet::FileServing::Metadata.expects(:search).with { |key, options| key == "/foo" }
+            @file.perform_recursion("/foo")
+        end
+
+        it "should return the results of the metadata search" do
+            Puppet::FileServing::Metadata.expects(:search).returns "foobar"
+            @file.perform_recursion(@file[:path]).should == "foobar"
+        end
+
+        it "should pass its recursion value to the search" do
+            @file[:recurse] = true
+            Puppet::FileServing::Metadata.expects(:search).with { |key, options| options[:recurse] == true }
+            @file.perform_recursion(@file[:path])
+        end
+
+        it "should pass true if recursion is remote" do
+            @file[:recurse] = :remote
+            Puppet::FileServing::Metadata.expects(:search).with { |key, options| options[:recurse] == true }
+            @file.perform_recursion(@file[:path])
+        end
+
+        it "should pass its recursion limit value to the search" do
+            @file[:recurselimit] = 10
+            Puppet::FileServing::Metadata.expects(:search).with { |key, options| options[:recurselimit] == 10 }
+            @file.perform_recursion(@file[:path])
+        end
+
+        it "should configure the search to ignore or manage links" do
+            @file[:links] = :manage
+            Puppet::FileServing::Metadata.expects(:search).with { |key, options| options[:links] == :manage }
+            @file.perform_recursion(@file[:path])
+        end
+
+        it "should pass its 'ignore' setting to the search if it has one" do
+            @file[:ignore] = %w{.svn CVS}
+            Puppet::FileServing::Metadata.expects(:search).with { |key, options| options[:ignore] == %w{.svn CVS} }
+            @file.perform_recursion(@file[:path])
+        end
+    end
+
+    it "should have a method for performing local recursion" do
+        @file.must respond_to(:recurse_local)
+    end
+
+    describe "when doing local recursion" do
+        before do
+            @metadata = stub 'metadata', :relative_path => "my/file"
+        end
+
+        it "should pass its path to the :perform_recursion method" do
+            @file.expects(:perform_recursion).with(@file[:path]).returns [@metadata]
+            @file.stubs(:newchild)
+            @file.recurse_local
+        end
+
+        it "should return an empty hash if the recursion returns nothing" do
+            @file.expects(:perform_recursion).returns nil
+            @file.recurse_local.should == {}
+        end
+
+        it "should create a new child resource with each generated metadata instance's relative path" do
+            @file.expects(:perform_recursion).returns [@metadata]
+            @file.expects(:newchild).with(@metadata.relative_path).returns "fiebar"
+            @file.recurse_local
+        end
+
+        it "should not create a new child resource for the '.' directory" do
+            @metadata.stubs(:relative_path).returns "."
+
+            @file.expects(:perform_recursion).returns [@metadata]
+            @file.expects(:newchild).never
+            @file.recurse_local
+        end
+
+        it "should return a hash of the created resources with the relative paths as the hash keys" do
+            @file.expects(:perform_recursion).returns [@metadata]
+            @file.expects(:newchild).with("my/file").returns "fiebar"
+            @file.recurse_local.should == {"my/file" => "fiebar"}
+        end
+    end
+
+    it "should have a method for performing link recursion" do
+        @file.must respond_to(:recurse_link)
+    end
+
+    describe "when doing link recursion" do
+        before do
+            @first = stub 'first', :relative_path => "first", :full_path => "/my/first", :ftype => "directory"
+            @second = stub 'second', :relative_path => "second", :full_path => "/my/second", :ftype => "file"
+
+            @resource = stub 'file', :[]= => nil
+        end
+
+        it "should pass its target to the :perform_recursion method" do
+            @file[:target] = "mylinks"
+            @file.expects(:perform_recursion).with("mylinks").returns [@first]
+            @file.stubs(:newchild).returns @resource
+            @file.recurse_link({})
+        end
+
+        it "should ignore the recursively-found '.' file and configure the top-level file to create a directory" do
+            @first.stubs(:relative_path).returns "."
+            @file[:target] = "mylinks"
+            @file.expects(:perform_recursion).with("mylinks").returns [@first]
+            @file.stubs(:newchild).never
+            @file.expects(:[]=).with(:ensure, :directory)
+            @file.recurse_link({})
+        end
+
+        it "should create a new child resource for each generated metadata instance's relative path that doesn't already exist in the children hash" do
+            @file.expects(:perform_recursion).returns [@first, @second]
+            @file.expects(:newchild).with(@first.relative_path).returns @resource
+            @file.recurse_link("second" => @resource)
+        end
+
+        it "should not create a new child resource for paths that already exist in the children hash" do
+            @file.expects(:perform_recursion).returns [@first]
+            @file.expects(:newchild).never
+            @file.recurse_link("first" => @resource)
+        end
+
+        it "should set the target to the full path of discovered file and set :ensure to :link if the file is not a directory" do
+            file = stub 'file'
+            file.expects(:[]=).with(:target, "/my/second")
+            file.expects(:[]=).with(:ensure, :link)
+
+            @file.stubs(:perform_recursion).returns [@first, @second]
+            @file.recurse_link("first" => @resource, "second" => file)
+        end
+
+        it "should :ensure to :directory if the file is a directory" do
+            file = stub 'file'
+            file.expects(:[]=).with(:ensure, :directory)
+
+            @file.stubs(:perform_recursion).returns [@first, @second]
+            @file.recurse_link("first" => file, "second" => @resource)
+        end
+
+        it "should return a hash with both created and existing resources with the relative paths as the hash keys" do
+            file = stub 'file', :[]= => nil
+
+            @file.expects(:perform_recursion).returns [@first, @second]
+            @file.stubs(:newchild).returns file
+            @file.recurse_link("second" => @resource).should == {"second" => @resource, "first" => file}
+        end
+    end
+
+    it "should have a method for performing remote recursion" do
+        @file.must respond_to(:recurse_remote)
+    end
+
+    describe "when doing remote recursion" do
+        before do
+            @file[:source] = "puppet://foo/bar"
+
+            @first = Puppet::FileServing::Metadata.new("/my", :relative_path => "first")
+            @second = Puppet::FileServing::Metadata.new("/my", :relative_path => "second")
+            @first.stubs(:ftype).returns "directory"
+            @second.stubs(:ftype).returns "directory"
+
+            @parameter = stub 'property', :metadata= => nil
+            @resource = stub 'file', :[]= => nil, :parameter => @parameter
+        end
+
+        it "should pass its source to the :perform_recursion method" do
+            data = Puppet::FileServing::Metadata.new("/whatever", :relative_path => "foobar")
+            @file.expects(:perform_recursion).with("puppet://foo/bar").returns [data]
+            @file.stubs(:newchild).returns @resource
+            @file.recurse_remote({})
+        end
+
+        it "should not recurse when the remote file is not a directory" do
+            data = Puppet::FileServing::Metadata.new("/whatever", :relative_path => ".")
+            data.stubs(:ftype).returns "file"
+            @file.expects(:perform_recursion).with("puppet://foo/bar").returns [data]
+            @file.expects(:newchild).never
+            @file.recurse_remote({})
+        end
+
+        it "should set the source of each returned file to the searched-for URI plus the found relative path" do
+            @first.expects(:source=).with File.join("puppet://foo/bar", @first.relative_path)
+            @file.expects(:perform_recursion).returns [@first]
+            @file.stubs(:newchild).returns @resource
+            @file.recurse_remote({})
+        end
+
+        it "should create a new resource for any relative file paths that do not already have a resource" do
+            @file.stubs(:perform_recursion).returns [@first]
+            @file.expects(:newchild).with("first").returns @resource
+            @file.recurse_remote({}).should == {"first" => @resource}
+        end
+
+        it "should not create a new resource for any relative file paths that do already have a resource" do
+            @file.stubs(:perform_recursion).returns [@first]
+            @file.expects(:newchild).never
+            @file.recurse_remote("first" => @resource)
+        end
+
+        it "should set the source of each resource to the source of the metadata" do
+            @file.stubs(:perform_recursion).returns [@first]
+            @resource.stubs(:[]=)
+            @resource.expects(:[]=).with(:source, File.join("puppet://foo/bar", @first.relative_path))
+            @file.recurse_remote("first" => @resource)
+        end
+
+        # LAK:FIXME This is a bug, but I can't think of a fix for it.  Fortunately it's already
+        # filed, and when it's fixed, we'll just fix the whole flow.
+        it "should set the checksum type to :md5 if the remote file is a file" do
+            @first.stubs(:ftype).returns "file"
+            @file.stubs(:perform_recursion).returns [@first]
+            @resource.stubs(:[]=)
+            @resource.expects(:[]=).with(:checksum, :md5)
+            @file.recurse_remote("first" => @resource)
+        end
+
+        it "should store the metadata in the source property for each resource so the source does not have to requery the metadata" do
+            @file.stubs(:perform_recursion).returns [@first]
+            @resource.expects(:parameter).with(:source).returns @parameter
+
+            @parameter.expects(:metadata=).with(@first)
+
+            @file.recurse_remote("first" => @resource)
+        end
+
+        it "should not create a new resource for the '.' file" do
+            @first.stubs(:relative_path).returns "."
+            @file.stubs(:perform_recursion).returns [@first]
+
+            @file.expects(:newchild).never
+
+            @file.recurse_remote({})
+        end
+
+        it "should store the metadata in the main file's source property if the relative path is '.'" do
+            @first.stubs(:relative_path).returns "."
+            @file.stubs(:perform_recursion).returns [@first]
+
+            @file.parameter(:source).expects(:metadata=).with @first
+
+            @file.recurse_remote("first" => @resource)
+        end
+
+        describe "and multiple sources are provided" do
+            describe "and :sourceselect is set to :first" do
+                it "should create file instances for the results for the first source to return any values" do
+                    data = Puppet::FileServing::Metadata.new("/whatever", :relative_path => "foobar")
+                    @file[:source] = %w{/one /two /three /four}
+                    @file.expects(:perform_recursion).with("/one").returns nil
+                    @file.expects(:perform_recursion).with("/two").returns []
+                    @file.expects(:perform_recursion).with("/three").returns [data]
+                    @file.expects(:perform_recursion).with("/four").never
+                    @file.expects(:newchild).with("foobar").returns @resource
+                    @file.recurse_remote({})
+                end
+            end
+
+            describe "and :sourceselect is set to :all" do
+                before do
+                    @file[:sourceselect] = :all
+                end
+
+                it "should return every found file that is not in a previous source" do
+                    klass = Puppet::FileServing::Metadata
+                    @file[:source] = %w{/one /two /three /four}
+                    @file.stubs(:newchild).returns @resource
+
+                    one = [klass.new("/one", :relative_path => "a")]
+                    @file.expects(:perform_recursion).with("/one").returns one
+                    @file.expects(:newchild).with("a").returns @resource
+
+                    two = [klass.new("/two", :relative_path => "a"), klass.new("/two", :relative_path => "b")]
+                    @file.expects(:perform_recursion).with("/two").returns two
+                    @file.expects(:newchild).with("b").returns @resource
+
+                    three = [klass.new("/three", :relative_path => "a"), klass.new("/three", :relative_path => "c")]
+                    @file.expects(:perform_recursion).with("/three").returns three
+                    @file.expects(:newchild).with("c").returns @resource
+
+                    @file.expects(:perform_recursion).with("/four").returns []
+
+                    @file.recurse_remote({})
+                end
+            end
+        end
+    end
+
+    describe "when returning resources with :eval_generate" do
+        before do
+            @graph = stub 'graph', :add_edge => nil
+            @catalog.stubs(:relationship_graph).returns @graph
+
+            @file.catalog = @catalog
+            @file[:recurse] = true
+        end
+
+        it "should recurse if recursion is enabled" do
+            resource = stub('resource', :[] => "resource")
+            @file.expects(:recurse?).returns true
+            @file.expects(:recurse).returns [resource]
+            @file.eval_generate.should == [resource]
+        end
+
+        it "should not recurse if recursion is disabled" do
+            @file.expects(:recurse?).returns false
+            @file.expects(:recurse).never
+            @file.eval_generate.should == []
+        end
+
+        it "should return each resource found through recursion" do
+            foo = stub 'foo', :[] => "/foo"
+            bar = stub 'bar', :[] => "/bar"
+            bar2 = stub 'bar2', :[] => "/bar"
+
+            @file.expects(:recurse).returns [foo, bar]
+
+            @file.eval_generate.should == [foo, bar]
+        end
+    end
+
+    describe "when recursing" do
+        before do
+            @file[:recurse] = true
+            @metadata = Puppet::FileServing::Metadata
+        end
+
+        describe "and a source is set" do
+            before { @file[:source] = "/my/source" }
+
+            it "should pass the already-discovered resources to recurse_remote" do
+                @file.stubs(:recurse_local).returns(:foo => "bar")
+                @file.expects(:recurse_remote).with(:foo => "bar").returns []
+                @file.recurse
+            end
+        end
+
+        describe "and a target is set" do
+            before { @file[:target] = "/link/target" }
+
+            it "should use recurse_link" do
+                @file.stubs(:recurse_local).returns(:foo => "bar")
+                @file.expects(:recurse_link).with(:foo => "bar").returns []
+                @file.recurse
+            end
+        end
+
+        it "should use recurse_local if recurse is not remote" do
+            @file.expects(:recurse_local).returns({})
+            @file.recurse
+        end
+
+        it "should not use recurse_local if recurse remote" do
+            @file[:recurse] = :remote
+            @file.expects(:recurse_local).never
+            @file.recurse
+        end
+
+        it "should return the generated resources as an array sorted by file path" do
+            one = stub 'one', :[] => "/one"
+            two = stub 'two', :[] => "/one/two"
+            three = stub 'three', :[] => "/three"
+            @file.expects(:recurse_local).returns(:one => one, :two => two, :three => three)
+            @file.recurse.should == [one, two, three]
+        end
+
+        describe "and purging is enabled" do
+            before do
+                @file[:purge] = true
+            end
+
+            it "should configure each file to be removed" do
+                local = stub 'local'
+                local.stubs(:[]).with(:source).returns nil # Thus, a local file
+                local.stubs(:[]).with(:path).returns "foo"
+                @file.expects(:recurse_local).returns("local" => local)
+                local.expects(:[]=).with(:ensure, :absent)
+
+                @file.recurse
+            end
+
+            it "should not remove files that exist in the remote repository" do
+                @file["source"] = "/my/file"
+                @file.expects(:recurse_local).returns({})
+
+                remote = stub 'remote'
+                remote.stubs(:[]).with(:source).returns "/whatever" # Thus, a remote file
+                remote.stubs(:[]).with(:path).returns "foo"
+
+                @file.expects(:recurse_remote).with { |hash| hash["remote"] = remote }
+                remote.expects(:[]=).with(:ensure, :absent).never
+
+                @file.recurse
+            end
+        end
+
+        describe "and making a new child resource" do
+            it "should not copy the parent resource's parent" do
+                Puppet::Type.type(:file).expects(:new).with { |options| ! options.include?(:parent) }
+                @file.newchild("my/path")
+            end
+
+            {:recurse => true, :target => "/foo/bar", :ensure => :present, :alias => "yay", :source => "/foo/bar"}.each do |param, value|
+                it "should not pass on #{param} to the sub resource" do
+                    @file = Puppet::Type::File.new(:name => @path, param => value, :catalog => @catalog)
+
+                    @file.class.expects(:new).with { |params| params[param].nil? }
+
+                    @file.newchild("sub/file")
+                end
+            end
+
+            it "should copy all of the parent resource's 'should' values that were set at initialization" do
+                file = @file.class.new(:path => "/foo/bar", :owner => "root", :group => "wheel")
+                @catalog.add_resource(file)
+                file.class.expects(:new).with { |options| options[:owner] == "root" and options[:group] == "wheel" }
+                file.newchild("my/path")
+            end
+
+            it "should not copy default values to the new child" do
+                @file.class.expects(:new).with { |params| params[:backup].nil? }
+                @file.newchild("my/path")
+            end
+
+            it "should not copy values to the child which were set by the source" do
+                @file[:source] = "/foo/bar"
+                metadata = stub 'metadata', :owner => "root", :group => "root", :mode => 0755, :ftype => "file", :checksum => "{md5}whatever"
+                @file.parameter(:source).stubs(:metadata).returns metadata
+
+                @file.parameter(:source).copy_source_values
+
+                @file.class.expects(:new).with { |params| params[:group].nil? }
+                @file.newchild("my/path")
+            end
+        end
+    end
+
+    describe "when setting the backup" do
+        it "should default to 'puppet'" do
+            Puppet::Type::File.new(:name => "/my/file")[:backup].should == "puppet"
+        end
+
+        it "should allow setting backup to 'false'" do
+            Puppet::Type::File.new(:name => "/my/file", :backup => false)[:backup].should be_false
+        end
+
+        it "should set the backup to '.puppet-bak' if it is set to true" do
+            Puppet::Type::File.new(:name => "/my/file", :backup => true)[:backup].should == ".puppet-bak"
+        end
+
+        it "should support any other backup extension" do
+            Puppet::Type::File.new(:name => "/my/file", :backup => ".bak")[:backup].should == ".bak"
+        end
+
+        it "should set the filebucket when backup is set to a string matching the name of a filebucket in the catalog" do
+            catalog = Puppet::Resource::Catalog.new
+            bucket_resource = Puppet::Type.type(:filebucket).new :name => "foo", :path => "/my/file/bucket"
+            catalog.add_resource bucket_resource
+
+            file = Puppet::Type::File.new(:name => "/my/file")
+            catalog.add_resource file
+
+            file[:backup] = "foo"
+            file.bucket.should == bucket_resource.bucket
+        end
+
+        it "should find filebuckets added to the catalog after the file resource was created" do
+            catalog = Puppet::Resource::Catalog.new
+
+            file = Puppet::Type::File.new(:name => "/my/file", :backup => "foo")
+            catalog.add_resource file
+
+            bucket_resource = Puppet::Type.type(:filebucket).new :name => "foo", :path => "/my/file/bucket"
+            catalog.add_resource bucket_resource
+
+            file.bucket.should == bucket_resource.bucket
+        end
+
+        it "should have a nil filebucket if backup is false" do
+            catalog = Puppet::Resource::Catalog.new
+            bucket_resource = Puppet::Type.type(:filebucket).new :name => "foo", :path => "/my/file/bucket"
+            catalog.add_resource bucket_resource
+
+            file = Puppet::Type::File.new(:name => "/my/file", :backup => false)
+            catalog.add_resource file
+
+            file.bucket.should be_nil
+        end
+
+        it "should have a nil filebucket if backup is set to a string starting with '.'" do
+            catalog = Puppet::Resource::Catalog.new
+            bucket_resource = Puppet::Type.type(:filebucket).new :name => "foo", :path => "/my/file/bucket"
+            catalog.add_resource bucket_resource
+
+            file = Puppet::Type::File.new(:name => "/my/file", :backup => ".foo")
+            catalog.add_resource file
+
+            file.bucket.should be_nil
+        end
+
+        it "should fail if there's no catalog and backup is not false" do
+            file = Puppet::Type::File.new(:name => "/my/file", :backup => "foo")
+
+            lambda { file.bucket }.should raise_error(Puppet::Error)
+        end
+
+        it "should fail if a non-existent catalog is specified" do
+            file = Puppet::Type::File.new(:name => "/my/file", :backup => "foo")
+            catalog = Puppet::Resource::Catalog.new
+            catalog.add_resource file
+
+            lambda { file.bucket }.should raise_error(Puppet::Error)
+        end
+
+        it "should be able to use the default filebucket without a catalog" do
+            file = Puppet::Type::File.new(:name => "/my/file", :backup => "puppet")
+            file.bucket.should be_instance_of(Puppet::Network::Client::Dipper)
+        end
+
+        it "should look up the filebucket during finish()" do
+            file = Puppet::Type::File.new(:name => "/my/file", :backup => ".foo")
+            file.expects(:bucket)
+            file.finish
+        end
+    end
+
+    describe "when writing the file" do
+        it "should propagate failures encountered when renaming the temporary file" do
+            File.stubs(:open)
+
+            File.expects(:rename).raises ArgumentError
+            file = Puppet::Type::File.new(:name => "/my/file", :backup => "puppet")
+
+            lambda { file.write("something", :content) }.should raise_error(Puppet::Error)
+        end
     end
 end