puppet 0.24.9 → 0.25.0

data/spec/unit/type/resources.rb

@@ -7,21 +7,18 @@ resources = Puppet::Type.type(:resources)
 # There are still plenty of tests to port over from test/.
 describe resources do
     describe "when initializing" do
-        before do
-            resources.clear
-        end
-
         it "should fail if the specified resource type does not exist" do
+            Puppet::Type.stubs(:type).with("Resources").returns resources
             Puppet::Type.expects(:type).with("nosuchtype").returns nil
-            lambda { resources.create :name => "nosuchtype" }.should raise_error(Puppet::Error)
+            lambda { resources.new :name => "nosuchtype" }.should raise_error(Puppet::Error)
         end
 
         it "should not fail when the specified resource type exists" do
-            lambda { resources.create :name => "file" }.should_not raise_error
+            lambda { resources.new :name => "file" }.should_not raise_error
         end
 
         it "should set its :resource_type attribute" do
-            resources.create(:name => "file").resource_type.should == Puppet::Type.type(:file)
+            resources.new(:name => "file").resource_type.should == Puppet::Type.type(:file)
         end
     end
 end

data/spec/unit/type/schedule.rb

@@ -40,18 +40,12 @@ module ScheduleTesting
 end
 
 describe Puppet::Type.type(:schedule) do
-
     before :each do
       Puppet.settings.stubs(:value).with(:ignoreschedules).returns(false)
 
-      @schedule = Puppet::Type.type(:schedule).create(:name => "testing")
-    end
-
-    after :each do
-        Puppet::Type.type(:schedule).clear
+      @schedule = Puppet::Type.type(:schedule).new(:name => "testing")
     end
 
-
     describe Puppet::Type.type(:schedule) do
         include ScheduleTesting
 

data/spec/unit/type/selboolean.rb

@@ -27,21 +27,19 @@ describe Puppet::Type.type(:selboolean), "when validating values" do
     end
 
     it "should support :on as a value to :value" do
-        Puppet::Type.type(:selboolean).create(:name => "yay", :value => :on)
+        Puppet::Type.type(:selboolean).new(:name => "yay", :value => :on)
     end
 
     it "should support :off as a value to :value" do
-        Puppet::Type.type(:selboolean).create(:name => "yay", :value => :off)
+        Puppet::Type.type(:selboolean).new(:name => "yay", :value => :off)
     end
 
     it "should support :true as a value to :persistent" do
-        Puppet::Type.type(:selboolean).create(:name => "yay", :value => :on, :persistent => :true)
+        Puppet::Type.type(:selboolean).new(:name => "yay", :value => :on, :persistent => :true)
     end
 
     it "should support :false as a value to :persistent" do
-        Puppet::Type.type(:selboolean).create(:name => "yay", :value => :on, :persistent => :false)
+        Puppet::Type.type(:selboolean).new(:name => "yay", :value => :on, :persistent => :false)
     end
-
-    after { Puppet::Type.type(:selboolean).clear }
 end
 

data/spec/unit/type/service.rb

@@ -33,90 +33,88 @@ describe Puppet::Type.type(:service), "when validating attribute values" do
     end
 
     it "should support :running as a value to :ensure" do
-        Puppet::Type.type(:service).create(:name => "yay", :ensure => :running)
+        Puppet::Type.type(:service).new(:name => "yay", :ensure => :running)
     end
 
     it "should support :stopped as a value to :ensure" do
-        Puppet::Type.type(:service).create(:name => "yay", :ensure => :stopped)
+        Puppet::Type.type(:service).new(:name => "yay", :ensure => :stopped)
     end
 
     it "should alias the value :true to :running in :ensure" do
-        svc = Puppet::Type.type(:service).create(:name => "yay", :ensure => true)
+        svc = Puppet::Type.type(:service).new(:name => "yay", :ensure => true)
         svc.should(:ensure).should == :running
     end
 
     it "should alias the value :false to :stopped in :ensure" do
-        svc = Puppet::Type.type(:service).create(:name => "yay", :ensure => false)
+        svc = Puppet::Type.type(:service).new(:name => "yay", :ensure => false)
         svc.should(:ensure).should == :stopped
     end
 
     it "should support :true as a value to :enable" do
-        Puppet::Type.type(:service).create(:name => "yay", :enable => :true)
+        Puppet::Type.type(:service).new(:name => "yay", :enable => :true)
     end
 
     it "should support :false as a value to :enable" do
-        Puppet::Type.type(:service).create(:name => "yay", :enable => :false)
+        Puppet::Type.type(:service).new(:name => "yay", :enable => :false)
     end
 
     it "should support :true as a value to :hasstatus" do
-        Puppet::Type.type(:service).create(:name => "yay", :hasstatus => :true)
+        Puppet::Type.type(:service).new(:name => "yay", :hasstatus => :true)
     end
 
     it "should support :false as a value to :hasstatus" do
-        Puppet::Type.type(:service).create(:name => "yay", :hasstatus => :false)
+        Puppet::Type.type(:service).new(:name => "yay", :hasstatus => :false)
     end
 
     it "should support :true as a value to :hasrestart" do
-        Puppet::Type.type(:service).create(:name => "yay", :hasrestart => :true)
+        Puppet::Type.type(:service).new(:name => "yay", :hasrestart => :true)
     end
 
     it "should support :false as a value to :hasrestart" do
-        Puppet::Type.type(:service).create(:name => "yay", :hasrestart => :false)
+        Puppet::Type.type(:service).new(:name => "yay", :hasrestart => :false)
     end
 
     it "should allow setting the :enable parameter if the provider has the :enableable feature" do
         Puppet::Type.type(:service).defaultprovider.stubs(:supports_parameter?).returns(true)
         Puppet::Type.type(:service).defaultprovider.expects(:supports_parameter?).with(Puppet::Type.type(:service).attrclass(:enable)).returns(true)
-        svc = Puppet::Type.type(:service).create(:name => "yay", :enable => true)
+        svc = Puppet::Type.type(:service).new(:name => "yay", :enable => true)
         svc.should(:enable).should == :true
     end
 
     it "should not allow setting the :enable parameter if the provider is missing the :enableable feature" do
         Puppet::Type.type(:service).defaultprovider.stubs(:supports_parameter?).returns(true)
         Puppet::Type.type(:service).defaultprovider.expects(:supports_parameter?).with(Puppet::Type.type(:service).attrclass(:enable)).returns(false)
-        svc = Puppet::Type.type(:service).create(:name => "yay", :enable => true)
+        svc = Puppet::Type.type(:service).new(:name => "yay", :enable => true)
         svc.should(:enable).should be_nil
     end
 
     it "should discard paths that do not exist" do
         FileTest.stubs(:exist?).returns(false)
         FileTest.stubs(:directory?).returns(false)
-        svc = Puppet::Type.type(:service).create(:name => "yay", :path => "/one/two")
+        svc = Puppet::Type.type(:service).new(:name => "yay", :path => "/one/two")
         svc[:path].should be_empty
     end
 
     it "should discard paths that are not directories" do
         FileTest.stubs(:exist?).returns(true)
         FileTest.stubs(:directory?).returns(false)
-        svc = Puppet::Type.type(:service).create(:name => "yay", :path => "/one/two")
+        svc = Puppet::Type.type(:service).new(:name => "yay", :path => "/one/two")
         svc[:path].should be_empty
     end
 
     it "should split paths on ':'" do
         FileTest.stubs(:exist?).returns(true)
         FileTest.stubs(:directory?).returns(true)
-        svc = Puppet::Type.type(:service).create(:name => "yay", :path => "/one/two:/three/four")
+        svc = Puppet::Type.type(:service).new(:name => "yay", :path => "/one/two:/three/four")
         svc[:path].should == %w{/one/two /three/four}
     end
 
     it "should accept arrays of paths joined by ':'" do
         FileTest.stubs(:exist?).returns(true)
         FileTest.stubs(:directory?).returns(true)
-        svc = Puppet::Type.type(:service).create(:name => "yay", :path => ["/one:/two", "/three:/four"])
+        svc = Puppet::Type.type(:service).new(:name => "yay", :path => ["/one:/two", "/three:/four"])
         svc[:path].should == %w{/one /two /three /four}
     end
-
-    after { Puppet::Type.type(:service).clear }
 end
 
 describe Puppet::Type.type(:service), "when setting default attribute values" do
@@ -126,33 +124,31 @@ describe Puppet::Type.type(:service), "when setting default attribute values" do
 
         Puppet::Type.type(:service).defaultprovider.stubs(:respond_to?).returns(true)
         Puppet::Type.type(:service).defaultprovider.stubs(:defpath).returns("testing")
-        svc = Puppet::Type.type(:service).create(:name => "other")
+        svc = Puppet::Type.type(:service).new(:name => "other")
         svc[:path].should == ["testing"]
     end
 
     it "should default 'pattern' to the binary if one is provided" do
-        svc = Puppet::Type.type(:service).create(:name => "other", :binary => "/some/binary")
+        svc = Puppet::Type.type(:service).new(:name => "other", :binary => "/some/binary")
         svc[:pattern].should == "/some/binary"
     end
 
     it "should default 'pattern' to the name if no pattern is provided" do
-        svc = Puppet::Type.type(:service).create(:name => "other")
+        svc = Puppet::Type.type(:service).new(:name => "other")
         svc[:pattern].should == "other"
     end
 
     it "should default 'control' to the upcased service name with periods replaced by underscores if the provider supports the 'controllable' feature" do
         provider = stub 'provider', :controllable? => true, :class => Puppet::Type.type(:service).defaultprovider, :clear => nil
         Puppet::Type.type(:service).defaultprovider.stubs(:new).returns(provider)
-        svc = Puppet::Type.type(:service).create(:name => "nfs.client")
+        svc = Puppet::Type.type(:service).new(:name => "nfs.client")
         svc[:control].should == "NFS_CLIENT_START"
     end
-
-    after { Puppet::Type.type(:service).clear }
 end
 
 describe Puppet::Type.type(:service), "when retrieving the host's current state" do
     before do
-        @service = Puppet::Type.type(:service).create(:name => "yay")
+        @service = Puppet::Type.type(:service).new(:name => "yay")
     end
 
     it "should use the provider's status to determine whether the service is running" do
@@ -167,13 +163,11 @@ describe Puppet::Type.type(:service), "when retrieving the host's current state"
         @service[:enable] = true
         @service.property(:enable).retrieve.should == :yepper
     end
-
-    after { Puppet::Type.type(:service).clear }
 end
 
 describe Puppet::Type.type(:service), "when changing the host" do
     before do
-        @service = Puppet::Type.type(:service).create(:name => "yay")
+        @service = Puppet::Type.type(:service).new(:name => "yay")
     end
 
     it "should start the service if it is supposed to be running" do
@@ -215,13 +209,11 @@ describe Puppet::Type.type(:service), "when changing the host" do
 
         @service.property(:ensure).sync
     end
-
-    after { Puppet::Type.type(:service).clear }
 end
 
 describe Puppet::Type.type(:service), "when refreshing the service" do
     before do
-        @service = Puppet::Type.type(:service).create(:name => "yay")
+        @service = Puppet::Type.type(:service).new(:name => "yay")
     end
 
     it "should restart the service if it is running" do
@@ -249,6 +241,4 @@ describe Puppet::Type.type(:service), "when refreshing the service" do
         @service.provider.expects(:restart)
         @service.refresh
     end
-
-    after { Puppet::Type.type(:service).clear }
 end

data/spec/unit/type/ssh_authorized_key.rb

@@ -14,7 +14,7 @@ describe ssh_authorized_key do
 
         @provider = stub 'provider', :class => @provider_class, :file_path => "/tmp/whatever", :clear => nil
         @provider_class.stubs(:new).returns(@provider)
-        @catalog = Puppet::Node::Catalog.new
+        @catalog = Puppet::Resource::Catalog.new
     end
 
     it "should have a name parameter" do
@@ -34,31 +34,31 @@ describe ssh_authorized_key do
     end
 
     it "should support :present as a value for :ensure" do
-        proc { @class.create(:name => "whev", :ensure => :present, :user => "nobody") }.should_not raise_error
+        proc { @class.new(:name => "whev", :ensure => :present, :user => "nobody") }.should_not raise_error
     end
 
     it "should support :absent as a value for :ensure" do
-        proc { @class.create(:name => "whev", :ensure => :absent, :user => "nobody") }.should_not raise_error
+        proc { @class.new(:name => "whev", :ensure => :absent, :user => "nobody") }.should_not raise_error
     end
 
     it "should have an type property" do
         @class.attrtype(:type).should == :property
     end
     it "should support ssh-dss as an type value" do
-        proc { @class.create(:name => "whev", :type => "ssh-dss", :user => "nobody") }.should_not raise_error
+        proc { @class.new(:name => "whev", :type => "ssh-dss", :user => "nobody") }.should_not raise_error
     end
     it "should support ssh-rsa as an type value" do
-        proc { @class.create(:name => "whev", :type => "ssh-rsa", :user => "nobody") }.should_not raise_error
+        proc { @class.new(:name => "whev", :type => "ssh-rsa", :user => "nobody") }.should_not raise_error
     end
     it "should support :dsa as an type value" do
-        proc { @class.create(:name => "whev", :type => :dsa, :user => "nobody") }.should_not raise_error
+        proc { @class.new(:name => "whev", :type => :dsa, :user => "nobody") }.should_not raise_error
     end
     it "should support :rsa as an type value" do
-        proc { @class.create(:name => "whev", :type => :rsa, :user => "nobody") }.should_not raise_error
+        proc { @class.new(:name => "whev", :type => :rsa, :user => "nobody") }.should_not raise_error
     end
 
     it "should not support values other than ssh-dss, ssh-rsa, dsa, rsa in the ssh_authorized_key_type" do
-        proc { @class.create(:name => "whev", :type => :something) }.should raise_error(Puppet::Error)
+        proc { @class.new(:name => "whev", :type => :something) }.should raise_error(Puppet::Error)
     end
 
     it "should have an key property" do
@@ -74,13 +74,13 @@ describe ssh_authorized_key do
     end
 
     it "'s options property should return well formed string of arrays from is_to_s" do
-        resource = @class.create(:name => "whev", :type => :rsa, :user => "nobody", :options => ["a","b","c"])
+        resource = @class.new(:name => "whev", :type => :rsa, :user => "nobody", :options => ["a","b","c"])
 
         resource.property(:options).is_to_s(["a","b","c"]).should == "a,b,c"
     end
 
     it "'s options property should return well formed string of arrays from is_to_s" do
-        resource = @class.create(:name => "whev", :type => :rsa, :user => "nobody", :options => ["a","b","c"])
+        resource = @class.new(:name => "whev", :type => :rsa, :user => "nobody", :options => ["a","b","c"])
 
         resource.property(:options).should_to_s(["a","b","c"]).should == "a,b,c"
     end
@@ -120,10 +120,21 @@ describe ssh_authorized_key do
             target = File.expand_path("~root/.ssh/authorized_keys")
             resource.should(:target).should == target
         end
-    end
 
-    after do
-      @class.clear
-      @catalog.clear
+        # Bug #2124 - ssh_authorized_key always changes target if target is not defined
+        it "should not raise spurious change events" do
+            resource = @class.new(:name => "Test", :user => "root")
+            target = File.expand_path("~root/.ssh/authorized_keys")
+            resource.property(:target).insync?(target).should == true
+        end
+   end
+
+    describe "when calling validate" do
+        it "should not crash on a non-existant user" do
+            resource = @class.create(
+                :name   => "Test",
+                :user   => "ihopesuchuserdoesnotexist")
+            proc { resource.validate }.should_not raise_error
+        end
     end
 end

data/spec/unit/type/tidy.rb

@@ -9,39 +9,27 @@ describe tidy do
         Puppet.settings.stubs(:use)
     end
 
-    after { tidy.clear }
-    
-    it "should be in sync if the targeted file does not exist" do
-        File.expects(:lstat).with("/tmp/foonesslaters").raises Errno::ENOENT
-        @tidy = tidy.create :path => "/tmp/foonesslaters", :age => "100d"
-
-        @tidy.property(:ensure).must be_insync({})
+    it "should use :lstat when stating a file" do
+        resource = tidy.new :path => "/foo/bar", :age => "1d"
+        stat = mock 'stat'
+        File.expects(:lstat).with("/foo/bar").returns stat
+        resource.stat("/foo/bar").should == stat
     end
 
-    [:ensure, :age, :size].each do |property|
-        it "should have a %s property" % property do
-            tidy.attrclass(property).ancestors.should be_include(Puppet::Property)
-        end
-
-        it "should have documentation for its %s property" % property do
-            tidy.attrclass(property).doc.should be_instance_of(String)
-        end
-    end
-
-    [:path, :matches, :type, :recurse, :rmdirs].each do |param|
+    [:age, :size, :path, :matches, :type, :recurse, :rmdirs].each do |param|
         it "should have a %s parameter" % param do
-            tidy.attrclass(param).ancestors.should be_include(Puppet::Parameter)
+            Puppet::Type.type(:tidy).attrclass(param).ancestors.should be_include(Puppet::Parameter)
         end
 
         it "should have documentation for its %s param" % param do
-            tidy.attrclass(param).doc.should be_instance_of(String)
+            Puppet::Type.type(:tidy).attrclass(param).doc.should be_instance_of(String)
         end
     end
 
     describe "when validating parameter values" do
         describe "for 'recurse'" do
             before do
-                @tidy = tidy.create :path => "/tmp", :age => "100d"
+                @tidy = Puppet::Type.type(:tidy).new :path => "/tmp", :age => "100d"
             end
 
             it "should allow 'true'" do
@@ -69,4 +57,324 @@ describe tidy do
             end
         end
     end
+
+    describe "when matching files by age" do
+        convertors = {
+            :second => 1,
+            :minute => 60
+        }
+
+        convertors[:hour] = convertors[:minute] * 60
+        convertors[:day] = convertors[:hour] * 24
+        convertors[:week] = convertors[:day] * 7
+
+        convertors.each do |unit, multiple|
+            it "should consider a %s to be %s seconds" % [unit, multiple] do
+                tidy = Puppet::Type.type(:tidy).new :path => "/what/ever", :age => "5%s" % unit.to_s[0..0]
+
+                tidy[:age].should == 5 * multiple
+            end
+        end
+    end
+
+    describe "when matching files by size" do
+        convertors = {
+            :b => 0,
+            :kb => 1,
+            :mb => 2,
+            :gb => 3
+        }
+
+        convertors.each do |unit, multiple|
+            it "should consider a %s to be 1024^%s bytes" % [unit, multiple] do
+                tidy = Puppet::Type.type(:tidy).new :path => "/what/ever", :size => "5%s" % unit
+
+                total = 5
+                multiple.times { total *= 1024 }
+                tidy[:size].should == total
+            end
+        end
+    end
+
+    describe "when tidying" do
+        before do
+            @tidy = Puppet::Type.type(:tidy).new :path => "/what/ever"
+            @stat = stub 'stat', :ftype => "directory"
+            File.stubs(:lstat).with("/what/ever").returns @stat
+        end
+
+        describe "and generating files" do
+            it "should set the backup on the file if backup is set on the tidy instance" do
+                @tidy[:backup] = "whatever"
+                Puppet::Type.type(:file).expects(:new).with { |args| args[:backup] == "whatever" }
+
+                @tidy.mkfile("/what/ever")
+            end
+
+            it "should set the file's path to the tidy's path" do
+                Puppet::Type.type(:file).expects(:new).with { |args| args[:path] == "/what/ever" }
+
+                @tidy.mkfile("/what/ever")
+            end
+
+            it "should configure the file for deletion" do
+                Puppet::Type.type(:file).expects(:new).with { |args| args[:ensure] == :absent }
+
+                @tidy.mkfile("/what/ever")
+            end
+
+            it "should force deletion on the file" do
+                Puppet::Type.type(:file).expects(:new).with { |args| args[:force] == true }
+
+                @tidy.mkfile("/what/ever")
+            end
+
+            it "should do nothing if the targeted file does not exist" do
+                File.expects(:lstat).with("/what/ever").raises Errno::ENOENT
+
+                @tidy.generate.should == []
+            end
+        end
+
+        describe "and recursion is not used" do
+            it "should generate a file resource if the file should be tidied" do
+                @tidy.expects(:tidy?).with("/what/ever").returns true
+                file = Puppet::Type.type(:file).new(:path => "/eh")
+                @tidy.expects(:mkfile).with("/what/ever").returns file
+
+                @tidy.generate.should == [file]
+            end
+
+            it "should do nothing if the file should not be tidied" do
+                @tidy.expects(:tidy?).with("/what/ever").returns false
+                @tidy.expects(:mkfile).never
+
+                @tidy.generate.should == []
+            end
+        end
+
+        describe "and recursion is used" do
+            before do
+                @tidy[:recurse] = true
+                Puppet::FileServing::Fileset.any_instance.stubs(:stat).returns mock("stat")
+                @fileset = Puppet::FileServing::Fileset.new("/what/ever")
+                Puppet::FileServing::Fileset.stubs(:new).returns @fileset
+            end
+
+            it "should use a Fileset for recursion" do
+                Puppet::FileServing::Fileset.expects(:new).with("/what/ever", :recurse => true).returns @fileset
+                @fileset.expects(:files).returns %w{. one two}
+                @tidy.stubs(:tidy?).returns false
+
+                @tidy.generate
+            end
+
+            it "should generate a file resource for every file that should be tidied but not for files that should not be tidied" do
+                @fileset.expects(:files).returns %w{. one two}
+
+                @tidy.expects(:tidy?).with("/what/ever").returns true
+                @tidy.expects(:tidy?).with("/what/ever/one").returns true
+                @tidy.expects(:tidy?).with("/what/ever/two").returns false
+
+                file = Puppet::Type.type(:file).new(:path => "/eh")
+                @tidy.expects(:mkfile).with("/what/ever").returns file
+                @tidy.expects(:mkfile).with("/what/ever/one").returns file
+
+                @tidy.generate
+            end
+        end
+
+        describe "and determining whether a file matches provided glob patterns" do
+            before do
+                @tidy = Puppet::Type.type(:tidy).new :path => "/what/ever"
+                @tidy[:matches] = %w{*foo* *bar*}
+
+                @stat = mock 'stat'
+
+                @matcher = @tidy.parameter(:matches)
+            end
+
+            it "should always convert the globs to an array" do
+                @matcher.value = "*foo*"
+                @matcher.value.should == %w{*foo*}
+            end
+
+            it "should return true if any pattern matches the last part of the file" do
+                @matcher.value = %w{*foo* *bar*}
+                @matcher.must be_tidy("/file/yaybarness", @stat)
+            end
+
+            it "should return false if no pattern matches the last part of the file" do
+                @matcher.value = %w{*foo* *bar*}
+                @matcher.should_not be_tidy("/file/yayness", @stat)
+            end
+        end
+
+        describe "and determining whether a file is too old" do
+            before do
+                @tidy = Puppet::Type.type(:tidy).new :path => "/what/ever"
+                @stat = stub 'stat'
+
+                @tidy[:age] = "1s"
+                @tidy[:type] = "mtime"
+                @ager = @tidy.parameter(:age)
+            end
+
+            it "should use the age type specified" do
+                @tidy[:type] = :ctime
+                @stat.expects(:ctime).returns(Time.now)
+
+                @ager.tidy?("/what/ever", @stat)
+            end
+
+            it "should return false if the file is more recent than the specified age" do
+                @stat.expects(:mtime).returns(Time.now)
+
+                @ager.should_not be_tidy("/what/ever", @stat)
+            end
+
+            it "should return true if the file is older than the specified age" do
+                @stat.expects(:mtime).returns(Time.now - 10)
+
+                @ager.must be_tidy("/what/ever", @stat)
+            end
+        end
+
+        describe "and determining whether a file is too large" do
+            before do
+                @tidy = Puppet::Type.type(:tidy).new :path => "/what/ever"
+                @stat = stub 'stat', :ftype => "file"
+
+                @tidy[:size] = "1kb"
+                @sizer = @tidy.parameter(:size)
+            end
+
+            it "should return false if the file is smaller than the specified size" do
+                @stat.expects(:size).returns(4) # smaller than a kilobyte
+
+                @sizer.should_not be_tidy("/what/ever", @stat)
+            end
+
+            it "should return true if the file is larger than the specified size" do
+                @stat.expects(:size).returns(1500) # larger than a kilobyte
+
+                @sizer.must be_tidy("/what/ever", @stat)
+            end
+        end
+
+        describe "and determining whether a file should be tidied" do
+            before do
+                @tidy = Puppet::Type.type(:tidy).new :path => "/what/ever"
+                @stat = stub 'stat', :ftype => "file"
+                File.stubs(:lstat).with("/what/ever").returns @stat
+            end
+
+            it "should not try to recurse if the file does not exist" do
+                @tidy[:recurse] = true
+
+                File.stubs(:lstat).with("/what/ever").returns nil
+
+                @tidy.generate.should == []
+            end
+
+            it "should not be tidied if the file does not exist" do
+                File.expects(:lstat).with("/what/ever").raises Errno::ENOENT
+
+                @tidy.should_not be_tidy("/what/ever")
+            end
+
+            it "should not be tidied if the user has no access to the file" do
+                File.expects(:lstat).with("/what/ever").raises Errno::EACCES
+
+                @tidy.should_not be_tidy("/what/ever")
+            end
+
+            it "should not be tidied if it is a directory and rmdirs is set to false" do
+                stat = mock 'stat', :ftype => "directory"
+                File.expects(:lstat).with("/what/ever").returns stat
+
+                @tidy.should_not be_tidy("/what/ever")
+            end
+
+            it "should return false if it does not match any provided globs" do
+                @tidy[:matches] = "globs"
+
+                matches = @tidy.parameter(:matches)
+                matches.expects(:tidy?).with("/what/ever", @stat).returns false
+                @tidy.should_not be_tidy("/what/ever")
+            end
+
+            it "should return false if it does not match aging requirements" do
+                @tidy[:age] = "1d"
+
+                ager = @tidy.parameter(:age)
+                ager.expects(:tidy?).with("/what/ever", @stat).returns false
+                @tidy.should_not be_tidy("/what/ever")
+            end
+
+            it "should return false if it does not match size requirements" do
+                @tidy[:size] = "1b"
+
+                sizer = @tidy.parameter(:size)
+                sizer.expects(:tidy?).with("/what/ever", @stat).returns false
+                @tidy.should_not be_tidy("/what/ever")
+            end
+
+            it "should tidy a file if age and size are set but only size matches" do
+                @tidy[:size] = "1b"
+                @tidy[:age] = "1d"
+
+                @tidy.parameter(:size).stubs(:tidy?).returns true
+                @tidy.parameter(:age).stubs(:tidy?).returns false
+                @tidy.should be_tidy("/what/ever")
+            end
+
+            it "should tidy a file if age and size are set but only age matches" do
+                @tidy[:size] = "1b"
+                @tidy[:age] = "1d"
+
+                @tidy.parameter(:size).stubs(:tidy?).returns false
+                @tidy.parameter(:age).stubs(:tidy?).returns true
+                @tidy.should be_tidy("/what/ever")
+            end
+
+            it "should tidy all files if neither age nor size is set" do
+                @tidy.must be_tidy("/what/ever")
+            end
+
+            it "should sort the results inversely by path length, so files are added to the catalog before their directories" do
+                @tidy[:recurse] = true
+                @tidy[:rmdirs] = true
+                fileset = Puppet::FileServing::Fileset.new("/what/ever")
+                Puppet::FileServing::Fileset.expects(:new).returns fileset
+                fileset.expects(:files).returns %w{. one one/two}
+
+                @tidy.stubs(:tidy?).returns true
+
+                @tidy.generate.collect { |r| r[:path] }.should == %w{/what/ever/one/two /what/ever/one /what/ever}
+            end
+        end
+
+        it "should configure directories to require their contained files if rmdirs is enabled, so the files will be deleted first" do
+            @tidy[:recurse] = true
+            @tidy[:rmdirs] = true
+            fileset = mock 'fileset'
+            Puppet::FileServing::Fileset.expects(:new).with("/what/ever", :recurse => true).returns fileset
+            fileset.expects(:files).returns %w{. one two one/subone two/subtwo one/subone/ssone}
+            @tidy.stubs(:tidy?).returns true
+
+            result = @tidy.generate.inject({}) { |hash, res| hash[res[:path]] = res; hash }
+            {
+                "/what/ever" => %w{/what/ever/one /what/ever/two},
+                "/what/ever/one" => ["/what/ever/one/subone"],
+                "/what/ever/two" => ["/what/ever/two/subtwo"],
+                "/what/ever/one/subone" => ["/what/ever/one/subone/ssone"]
+            }.each do |parent, children|
+                children.each do |child|
+                    ref = Puppet::Resource::Reference.new(:file, child)
+                    result[parent][:require].find { |req| req.to_s == ref.to_s }.should_not be_nil
+                end
+            end
+        end
+    end
 end