puppet 0.25.5 → 2.6.0

data/spec/unit/type/selboolean.rb

@@ -1,45 +0,0 @@
-#!/usr/bin/env ruby
-
-Dir.chdir(File.dirname(__FILE__)) { (s = lambda { |f| File.exist?(f) ? require(f) : Dir.chdir("..") { s.call(f) } }).call("spec/spec_helper.rb") }
-
-describe Puppet::Type.type(:selboolean), "when validating attributes" do
-    [:name, :persistent].each do |param|
-        it "should have a #{param} parameter" do
-            Puppet::Type.type(:selboolean).attrtype(param).should == :param
-        end
-    end
-
-    it "should have a value property" do
-        Puppet::Type.type(:selboolean).attrtype(:value).should == :property
-    end
-end
-
-describe Puppet::Type.type(:selboolean), "when validating values" do
-    before do
-        @class = Puppet::Type.type(:selboolean)
-
-        @provider_class = stub 'provider_class', :name => "fake", :suitable? => true, :supports_parameter? => true
-        @class.stubs(:defaultprovider).returns(@provider_class)
-        @class.stubs(:provider).returns(@provider_class)
-
-        @provider = stub 'provider', :class => @provider_class, :clear => nil
-        @provider_class.stubs(:new).returns(@provider)
-    end
-
-    it "should support :on as a value to :value" do
-        Puppet::Type.type(:selboolean).new(:name => "yay", :value => :on)
-    end
-
-    it "should support :off as a value to :value" do
-        Puppet::Type.type(:selboolean).new(:name => "yay", :value => :off)
-    end
-
-    it "should support :true as a value to :persistent" do
-        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).new(:name => "yay", :value => :on, :persistent => :false)
-    end
-end
-

data/spec/unit/type/selmodule.rb

@@ -1,18 +0,0 @@
-#!/usr/bin/env ruby
-
-Dir.chdir(File.dirname(__FILE__)) { (s = lambda { |f| File.exist?(f) ? require(f) : Dir.chdir("..") { s.call(f) } }).call("spec/spec_helper.rb") }
-
-describe Puppet::Type.type(:selmodule), "when validating attributes" do
-    [:name, :selmoduledir, :selmodulepath].each do |param|
-        it "should have a #{param} parameter" do
-            Puppet::Type.type(:selmodule).attrtype(param).should == :param
-        end
-    end
-
-    [:ensure, :syncversion].each do |param|
-        it "should have a #{param} property" do
-            Puppet::Type.type(:selmodule).attrtype(param).should == :property
-        end
-    end
-end
-

data/spec/unit/type/service.rb

@@ -1,230 +0,0 @@
-#!/usr/bin/env ruby
-
-require File.dirname(__FILE__) + '/../../spec_helper'
-
-describe Puppet::Type.type(:service) do
-    it "should have an :enableable feature that requires the :enable, :disable, and :enabled? methods" do
-        Puppet::Type.type(:service).provider_feature(:enableable).methods.should == [:disable, :enable, :enabled?]
-    end
-
-    it "should have a :refreshable feature that requires the :restart method" do
-        Puppet::Type.type(:service).provider_feature(:refreshable).methods.should == [:restart]
-    end
-end
-
-describe Puppet::Type.type(:service), "when validating attributes" do
-    [:name, :binary, :hasstatus, :path, :pattern, :start, :restart, :stop, :status, :hasrestart, :control].each do |param|
-        it "should have a #{param} parameter" do
-            Puppet::Type.type(:service).attrtype(param).should == :param
-        end
-    end
-
-    [:ensure, :enable].each do |param|
-        it "should have an #{param} property" do
-            Puppet::Type.type(:service).attrtype(param).should == :property
-        end
-    end
-end
-
-describe Puppet::Type.type(:service), "when validating attribute values" do
-    before do
-        @provider = stub 'provider', :class => Puppet::Type.type(:service).defaultprovider, :clear => nil, :controllable? => false
-        Puppet::Type.type(:service).defaultprovider.stubs(:new).returns(@provider)
-    end
-
-    it "should support :running as a value to :ensure" do
-        Puppet::Type.type(:service).new(:name => "yay", :ensure => :running)
-    end
-
-    it "should support :stopped as a value to :ensure" do
-        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).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).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).new(:name => "yay", :enable => :true)
-    end
-
-    it "should support :false as a value to :enable" do
-        Puppet::Type.type(:service).new(:name => "yay", :enable => :false)
-    end
-
-    it "should support :true as a value to :hasstatus" do
-        Puppet::Type.type(:service).new(:name => "yay", :hasstatus => :true)
-    end
-
-    it "should support :false as a value to :hasstatus" do
-        Puppet::Type.type(:service).new(:name => "yay", :hasstatus => :false)
-    end
-
-    it "should support :true as a value to :hasrestart" do
-        Puppet::Type.type(:service).new(:name => "yay", :hasrestart => :true)
-    end
-
-    it "should support :false as a value to :hasrestart" do
-        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).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).new(:name => "yay", :enable => true)
-        svc.should(:enable).should be_nil
-    end
-
-    it "should split paths on ':'" do
-        FileTest.stubs(:exist?).returns(true)
-        FileTest.stubs(:directory?).returns(true)
-        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).new(:name => "yay", :path => ["/one:/two", "/three:/four"])
-        svc[:path].should == %w{/one /two /three /four}
-    end
-end
-
-describe Puppet::Type.type(:service), "when setting default attribute values" do
-    it "should default to the provider's default path if one is available" do
-        FileTest.stubs(:directory?).returns(true)
-        FileTest.stubs(:exist?).returns(true)
-
-        Puppet::Type.type(:service).defaultprovider.stubs(:respond_to?).returns(true)
-        Puppet::Type.type(:service).defaultprovider.stubs(:defpath).returns("testing")
-        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).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).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).new(:name => "nfs.client")
-        svc[:control].should == "NFS_CLIENT_START"
-    end
-end
-
-describe Puppet::Type.type(:service), "when retrieving the host's current state" do
-    before do
-        @service = Puppet::Type.type(:service).new(:name => "yay")
-    end
-
-    it "should use the provider's status to determine whether the service is running" do
-        @service.provider.expects(:status).returns(:yepper)
-        @service[:ensure] = :running
-        @service.property(:ensure).retrieve.should == :yepper
-    end
-
-    it "should ask the provider whether it is enabled" do
-        @service.provider.class.stubs(:supports_parameter?).returns(true)
-        @service.provider.expects(:enabled?).returns(:yepper)
-        @service[:enable] = true
-        @service.property(:enable).retrieve.should == :yepper
-    end
-end
-
-describe Puppet::Type.type(:service), "when changing the host" do
-    before do
-        @service = Puppet::Type.type(:service).new(:name => "yay")
-    end
-
-    it "should start the service if it is supposed to be running" do
-        @service[:ensure] = :running
-        @service.provider.expects(:start)
-        @service.property(:ensure).sync
-    end
-
-    it "should stop the service if it is supposed to be stopped" do
-        @service[:ensure] = :stopped
-        @service.provider.expects(:stop)
-        @service.property(:ensure).sync
-    end
-
-    it "should enable the service if it is supposed to be enabled" do
-        @service.provider.class.stubs(:supports_parameter?).returns(true)
-        @service[:enable] = true
-        @service.provider.expects(:enable)
-        @service.property(:enable).sync
-    end
-
-    it "should disable the service if it is supposed to be disabled" do
-        @service.provider.class.stubs(:supports_parameter?).returns(true)
-        @service[:enable] = false
-        @service.provider.expects(:disable)
-        @service.property(:enable).sync
-    end
-
-    it "should sync the service's enable state when changing the state of :ensure if :enable is being managed" do
-        @service.provider.class.stubs(:supports_parameter?).returns(true)
-        @service[:enable] = false
-        @service[:ensure] = :stopped
-
-        @service.property(:enable).expects(:retrieve).returns("whatever")
-        @service.property(:enable).expects(:insync?).returns(false)
-        @service.property(:enable).expects(:sync)
-
-        @service.provider.stubs(:stop)
-
-        @service.property(:ensure).sync
-    end
-end
-
-describe Puppet::Type.type(:service), "when refreshing the service" do
-    before do
-        @service = Puppet::Type.type(:service).new(:name => "yay")
-    end
-
-    it "should restart the service if it is running" do
-        @service[:ensure] = :running
-        @service.provider.expects(:status).returns(:running)
-        @service.provider.expects(:restart)
-        @service.refresh
-    end
-
-    it "should restart the service if it is running, even if it is supposed to stopped" do
-        @service[:ensure] = :stopped
-        @service.provider.expects(:status).returns(:running)
-        @service.provider.expects(:restart)
-        @service.refresh
-    end
-
-    it "should not restart the service if it is not running" do
-        @service[:ensure] = :running
-        @service.provider.expects(:status).returns(:stopped)
-        @service.refresh
-    end
-
-    it "should add :ensure as a property if it is not being managed" do
-        @service.provider.expects(:status).returns(:running)
-        @service.provider.expects(:restart)
-        @service.refresh
-    end
-end

data/spec/unit/type/ssh_authorized_key.rb

@@ -1,140 +0,0 @@
-#!/usr/bin/env ruby
-
-require File.dirname(__FILE__) + '/../../spec_helper'
-
-ssh_authorized_key = Puppet::Type.type(:ssh_authorized_key)
-
-describe ssh_authorized_key do
-    before do
-        @class = Puppet::Type.type(:ssh_authorized_key)
-
-        @provider_class = stub 'provider_class', :name => "fake", :suitable? => true, :supports_parameter? => true
-        @class.stubs(:defaultprovider).returns(@provider_class)
-        @class.stubs(:provider).returns(@provider_class)
-
-        @provider = stub 'provider', :class => @provider_class, :file_path => "/tmp/whatever", :clear => nil
-        @provider_class.stubs(:new).returns(@provider)
-        @catalog = Puppet::Resource::Catalog.new
-    end
-
-    it "should have a name parameter" do
-        @class.attrtype(:name).should == :param
-    end
-
-    it "should have :name be its namevar" do
-        @class.namevar.should == :name
-    end
-
-    it "should have a :provider parameter" do
-        @class.attrtype(:provider).should == :param
-    end
-
-    it "should have an ensure property" do
-        @class.attrtype(:ensure).should == :property
-    end
-
-    it "should support :present as a value for :ensure" do
-        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.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.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.new(:name => "whev", :type => "ssh-rsa", :user => "nobody") }.should_not raise_error
-    end
-    it "should support :dsa as an type value" do
-        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.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.new(:name => "whev", :type => :something) }.should raise_error(Puppet::Error)
-    end
-
-    it "should have an key property" do
-        @class.attrtype(:key).should == :property
-    end
-
-    it "should have an user property" do
-        @class.attrtype(:user).should == :property
-    end
-
-    it "should have an options property" do
-        @class.attrtype(:options).should == :property
-    end
-
-    it "'s options property should return well formed string of arrays from is_to_s" do
-        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.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
-
-    it "should have a target property" do
-        @class.attrtype(:target).should == :property
-    end
-
-    describe "when neither user nor target is specified" do
-        it "should raise an error" do
-            proc do
-                @class.create(
-                  :name   => "Test",
-                  :key    => "AAA",
-                  :type   => "ssh-rsa",
-                  :ensure => :present)
-            end.should raise_error(Puppet::Error)
-        end
-    end
-
-    describe "when both target and user are specified" do
-        it "should use target" do
-            resource = @class.create(
-                :name => "Test",
-                :user => "root",
-                :target => "/tmp/blah")
-            resource.should(:target).should == "/tmp/blah"
-        end
-    end
-
-
-    describe "when user is specified" do
-        it "should determine target" do
-            resource = @class.create(
-                :name   => "Test",
-                :user   => "root")
-            target = File.expand_path("~root/.ssh/authorized_keys")
-            resource.should(:target).should == target
-        end
-
-        # 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

@@ -1,422 +0,0 @@
-#!/usr/bin/env ruby
-
-require File.dirname(__FILE__) + '/../../spec_helper'
-
-tidy = Puppet::Type.type(:tidy)
-
-describe tidy do
-    before do
-        Puppet.settings.stubs(:use)
-
-        # for an unknown reason some of these specs fails when run individually
-        # with a failed expectation on File.lstat in the autoloader.
-        File.stubs(:lstat)
-    end
-
-    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
-
-    [:age, :size, :path, :matches, :type, :recurse, :rmdirs].each do |param|
-        it "should have a %s parameter" % param do
-            Puppet::Type.type(:tidy).attrclass(param).ancestors.should be_include(Puppet::Parameter)
-        end
-
-        it "should have documentation for its %s param" % param do
-            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 = Puppet::Type.type(:tidy).new :path => "/tmp", :age => "100d"
-            end
-
-            it "should allow 'true'" do
-                lambda { @tidy[:recurse] = true }.should_not raise_error
-            end
-
-            it "should allow 'false'" do
-                lambda { @tidy[:recurse] = false }.should_not raise_error
-            end
-
-            it "should allow integers" do
-                lambda { @tidy[:recurse] = 10 }.should_not raise_error
-            end
-
-            it "should allow string representations of integers" do
-                lambda { @tidy[:recurse] = "10" }.should_not raise_error
-            end
-
-            it "should allow 'inf'" do
-                lambda { @tidy[:recurse] = "inf" }.should_not raise_error
-            end
-
-            it "should not allow arbitrary values" do
-                lambda { @tidy[:recurse] = "whatever" }.should raise_error
-            end
-        end
-
-        describe "for 'matches'" do
-            before do
-                @tidy = Puppet::Type.type(:tidy).new :path => "/tmp", :age => "100d"
-            end
-
-            it "should object if matches is given with recurse is not specified" do
-                lambda { @tidy[:matches] = '*.doh' }.should raise_error
-            end
-            it "should object if matches is given and recurse is 0" do
-                lambda { @tidy[:recurse] = 0; @tidy[:matches] = '*.doh' }.should raise_error
-            end
-            it "should object if matches is given and recurse is false" do
-                lambda { @tidy[:recurse] = false; @tidy[:matches] = '*.doh' }.should raise_error
-            end
-            it "should not object if matches is given and recurse is > 0" do
-                lambda { @tidy[:recurse] = 1; @tidy[:matches] = '*.doh' }.should_not raise_error
-            end
-            it "should not object if matches is given and recurse is true" do
-                lambda { @tidy[:recurse] = true; @tidy[:matches] = '*.doh' }.should_not raise_error
-            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 infinite 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 use a Fileset for limited recursion" do
-                @tidy[:recurse] = 42
-                Puppet::FileServing::Fileset.expects(:new).with("/what/ever", :recurse => true, :recurselimit => 42).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", :recurse => 1
-                @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
-
-            it "should return true if the file is equal to the specified size" do
-                @stat.expects(:size).returns(1024)
-
-                @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[:recurse] = 1
-                @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