diff --git a/lib/puppet/node/environment.rb b/lib/puppet/node/environment.rb
index 96fdc3c1e..f25bb65a9 100644
--- a/lib/puppet/node/environment.rb
+++ b/lib/puppet/node/environment.rb
@@ -1,179 +1,173 @@
 require 'puppet/util/cacher'
 require 'monitor'
 
 # Just define it, so this class has fewer load dependencies.
 class Puppet::Node
 end
 
 # Model the environment that a node can operate in.  This class just
 # provides a simple wrapper for the functionality around environments.
 class Puppet::Node::Environment
   module Helper
     def environment
       Puppet::Node::Environment.new(@environment)
     end
 
     def environment=(env)
       if env.is_a?(String) or env.is_a?(Symbol)
         @environment = env
       else
         @environment = env.name
       end
     end
   end
 
   include Puppet::Util::Cacher
 
   @seen = {}
 
   # Return an existing environment instance, or create a new one.
   def self.new(name = nil)
     return name if name.is_a?(self)
     name ||= Puppet.settings.value(:environment)
 
     raise ArgumentError, "Environment name must be specified" unless name
 
     symbol = name.to_sym
 
     return @seen[symbol] if @seen[symbol]
 
     obj = self.allocate
     obj.send :initialize, symbol
     @seen[symbol] = obj
   end
 
   def self.current
     Thread.current[:environment] || root
   end
 
   def self.current=(env)
     Thread.current[:environment] = new(env)
   end
 
   def self.root
     @root
   end
 
   # This is only used for testing.
   def self.clear
     @seen.clear
   end
 
   attr_reader :name
 
   # Return an environment-specific setting.
   def [](param)
     Puppet.settings.value(param, self.name)
   end
 
   def initialize(name)
     @name = name
     extend MonitorMixin
   end
 
   def known_resource_types
     # This makes use of short circuit evaluation to get the right thread-safe
     # per environment semantics with an efficient most common cases; we almost
     # always just return our thread's known-resource types.  Only at the start
     # of a compilation (after our thread var has been set to nil) or when the
     # environment has changed do we delve deeper.
     Thread.current[:known_resource_types] = nil if (krt = Thread.current[:known_resource_types]) && krt.environment != self
     Thread.current[:known_resource_types] ||= synchronize {
       if @known_resource_types.nil? or @known_resource_types.require_reparse?
         @known_resource_types = Puppet::Resource::TypeCollection.new(self)
         @known_resource_types.import_ast(perform_initial_import, '')
       end
       @known_resource_types
     }
   end
 
   def module(name)
     mod = Puppet::Module.new(name, self)
     return nil unless mod.exist?
     mod
   end
 
   # Cache the modulepath, so that we aren't searching through
   # all known directories all the time.
-  cached_attr(:modulepath, :ttl => Puppet[:filetimeout]) do
+  cached_attr(:modulepath, Puppet[:filetimeout]) do
     dirs = self[:modulepath].split(File::PATH_SEPARATOR)
     dirs = ENV["PUPPETLIB"].split(File::PATH_SEPARATOR) + dirs if ENV["PUPPETLIB"]
     validate_dirs(dirs)
   end
 
   # Return all modules from this environment.
   # Cache the list, because it can be expensive to create.
-  cached_attr(:modules, :ttl => Puppet[:filetimeout]) do
+  cached_attr(:modules, Puppet[:filetimeout]) do
     module_names = modulepath.collect { |path| Dir.entries(path) }.flatten.uniq
     module_names.collect do |path|
       begin
         Puppet::Module.new(path, self)
       rescue Puppet::Module::Error => e
         nil
       end
     end.compact
   end
 
-  # Cache the manifestdir, so that we aren't searching through
-  # all known directories all the time.
-  cached_attr(:manifestdir, :ttl => Puppet[:filetimeout]) do
-    validate_dirs(self[:manifestdir].split(File::PATH_SEPARATOR))
-  end
-
   def to_s
     name.to_s
   end
 
   def to_sym
     to_s.to_sym
   end
 
   # The only thing we care about when serializing an environment is its
   # identity; everything else is ephemeral and should not be stored or
   # transmitted.
   def to_zaml(z)
     self.to_s.to_zaml(z)
   end
 
   def validate_dirs(dirs)
     dir_regex = Puppet.features.microsoft_windows? ? /^[A-Za-z]:#{File::SEPARATOR}/ : /^#{File::SEPARATOR}/
     dirs.collect do |dir|
       if dir !~ dir_regex
         File.join(Dir.getwd, dir)
       else
         dir
       end
     end.find_all do |p|
       p =~ dir_regex && FileTest.directory?(p)
     end
   end
 
   private
 
   def perform_initial_import
     return empty_parse_result if Puppet.settings[:ignoreimport]
     parser = Puppet::Parser::Parser.new(self)
     if code = Puppet.settings.uninterpolated_value(:code, name.to_s) and code != ""
       parser.string = code
     else
       file = Puppet.settings.value(:manifest, name.to_s)
       parser.file = file
     end
     parser.parse
   rescue => detail
     known_resource_types.parse_failed = true
 
     msg = "Could not parse for environment #{self}: #{detail}"
     error = Puppet::Error.new(msg)
     error.set_backtrace(detail.backtrace)
     raise error
   end
 
   def empty_parse_result
     # Return an empty toplevel hostclass to use as the result of
     # perform_initial_import when no file was actually loaded.
     return Puppet::Parser::AST::Hostclass.new('')
   end
 
   @root = new(:'*root*')
 end
diff --git a/lib/puppet/util/cacher.rb b/lib/puppet/util/cacher.rb
index 3dddec0d4..136c9973e 100644
--- a/lib/puppet/util/cacher.rb
+++ b/lib/puppet/util/cacher.rb
@@ -1,132 +1,80 @@
 require 'monitor'
 
 module Puppet::Util::Cacher
-  module Expirer
-    attr_reader :timestamp
-
-    # Cause all cached values to be considered expired.
-    def expire
-      @timestamp = Time.now
-    end
-
-    # Is the provided timestamp earlier than our expiration timestamp?
-    # If it is, then the associated value is expired.
-    def dependent_data_expired?(ts)
-      return false unless timestamp
-
-      timestamp > ts
-    end
-  end
-
-  extend Expirer
-
   # Our module has been extended in a class; we can only add the Instance methods,
   # which become *class* methods in the class.
   def self.extended(other)
     class << other
       extend ClassMethods
       include InstanceMethods
     end
   end
 
   # Our module has been included in a class, which means the class gets the class methods
   # and all of its instances get the instance methods.
   def self.included(other)
     other.extend(ClassMethods)
     other.send(:include, InstanceMethods)
   end
 
   # Methods that can get added to a class.
   module ClassMethods
     # Provide a means of defining an attribute whose value will be cached.
     # Must provide a block capable of defining the value if it's flushed..
-    def cached_attr(name, options = {}, &block)
+    def cached_attr(name, ttl, &block)
       init_method = "init_#{name}"
       define_method(init_method, &block)
 
+      set_attr_ttl(name, ttl)
+
       define_method(name) do
         cached_value(name)
       end
 
       define_method(name.to_s + "=") do |value|
         # Make sure the cache timestamp is set
-        cache_timestamp
-        value_cache.synchronize { value_cache[name] = value }
-      end
-
-      if ttl = options[:ttl]
-        set_attr_ttl(name, ttl)
+        value_cache.synchronize do
+          value_cache[name] = value
+          set_expiration(name)
+        end
       end
     end
 
     def attr_ttl(name)
-      return nil unless @attr_ttls
       @attr_ttls[name]
     end
 
     def set_attr_ttl(name, value)
       @attr_ttls ||= {}
       @attr_ttls[name] = Integer(value)
     end
   end
 
   # Methods that get added to instances.
   module InstanceMethods
-
-    def expire
-      # Only expire if we have an expirer.  This is
-      # mostly so that we can comfortably handle cases
-      # like Puppet::Type instances, which use their
-      # catalog as their expirer, and they often don't
-      # have a catalog.
-      if e = expirer
-        e.expire
-      end
-    end
-
-    def expirer
-      Puppet::Util::Cacher
-    end
-
     private
 
-    def cache_timestamp
-      @cache_timestamp ||= Time.now
-    end
-
     def cached_value(name)
       value_cache.synchronize do
-        # Allow a nil expirer, in which case we regenerate the value every time.
-        if expired_by_expirer?(name)
-          value_cache.clear
-          @cache_timestamp = Time.now
-        elsif expired_by_ttl?(name)
-          value_cache.delete(name)
+        if value_cache[name].nil? or expired_by_ttl?(name)
+          value_cache[name] = send("init_#{name}")
+          set_expiration(name)
         end
-        value_cache[name] = send("init_#{name}") unless value_cache.include?(name)
         value_cache[name]
       end
     end
 
-    def expired_by_expirer?(name)
-      if expirer.nil?
-        return true unless self.class.attr_ttl(name)
-      end
-      expirer.dependent_data_expired?(cache_timestamp)
-    end
-
     def expired_by_ttl?(name)
-      return false unless self.class.respond_to?(:attr_ttl)
-      return false unless ttl = self.class.attr_ttl(name)
-
-      @ttl_timestamps ||= {}
-      @ttl_timestamps[name] ||= Time.now
+      @attr_expirations[name] < Time.now
+    end
 
-      (Time.now - @ttl_timestamps[name]) > ttl
+    def set_expiration(name)
+      @attr_expirations ||= {}
+      @attr_expirations[name] = Time.now + self.class.attr_ttl(name)
     end
 
     def value_cache
       @value_cache ||= {}.extend(MonitorMixin)
     end
   end
 end
diff --git a/spec/integration/file_serving/content_spec.rb b/spec/integration/file_serving/content_spec.rb
index 5b08a6137..e2efecfa4 100755
--- a/spec/integration/file_serving/content_spec.rb
+++ b/spec/integration/file_serving/content_spec.rb
@@ -1,16 +1,14 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 require 'puppet/file_serving/content'
 require 'shared_behaviours/file_serving'
 
 describe Puppet::FileServing::Content, " when finding files" do
   it_should_behave_like "Puppet::FileServing::Files"
 
   before do
     @test_class = Puppet::FileServing::Content
     @indirection = Puppet::FileServing::Content.indirection
   end
-
-  after { Puppet::Util::Cacher.expire }
 end
diff --git a/spec/integration/file_serving/metadata_spec.rb b/spec/integration/file_serving/metadata_spec.rb
index 821b6baca..d9aaa37f5 100755
--- a/spec/integration/file_serving/metadata_spec.rb
+++ b/spec/integration/file_serving/metadata_spec.rb
@@ -1,17 +1,15 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 require 'puppet/file_serving/metadata'
 require 'shared_behaviours/file_serving'
 require 'puppet/indirector/file_metadata/file_server'
 
 describe Puppet::FileServing::Metadata, " when finding files" do
   it_should_behave_like "Puppet::FileServing::Files"
 
   before do
     @test_class = Puppet::FileServing::Metadata
     @indirection = Puppet::FileServing::Metadata.indirection
   end
-
-  after { Puppet::Util::Cacher.expire }
 end
diff --git a/spec/integration/network/server/webrick_spec.rb b/spec/integration/network/server/webrick_spec.rb
index 81c35af4f..2390fcab1 100755
--- a/spec/integration/network/server/webrick_spec.rb
+++ b/spec/integration/network/server/webrick_spec.rb
@@ -1,86 +1,85 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 require 'puppet/network/server'
 require 'puppet/ssl/certificate_authority'
 require 'socket'
 
 describe Puppet::Network::Server do
   describe "when using webrick" do
     before :each do
       Puppet[:servertype] = 'webrick'
       Puppet[:server] = '127.0.0.1'
       @params = { :port => 34343, :handlers => [ :node ], :xmlrpc_handlers => [ :status ] }
 
       # Get a safe temporary file
       @tmpfile = Tempfile.new("webrick_integration_testing")
       @dir = @tmpfile.path + "_dir"
 
       Puppet.settings[:confdir] = @dir
       Puppet.settings[:vardir] = @dir
       Puppet.settings[:group] = Process.gid
 
       Puppet::SSL::Host.ca_location = :local
 
       ca = Puppet::SSL::CertificateAuthority.new
       ca.generate(Puppet[:certname]) unless Puppet::SSL::Certificate.indirection.find(Puppet[:certname])
     end
 
     after do
       @tmpfile.delete
       Puppet.settings.clear
 
       system("rm -rf #{@dir}")
 
       Puppet::SSL::Host.ca_location = :none
-      Puppet::Util::Cacher.expire
     end
 
     describe "before listening" do
       it "should not be reachable at the specified address and port" do
         lambda { TCPSocket.new('127.0.0.1', 34343) }.should raise_error
       end
     end
 
     describe "when listening" do
       it "should be reachable on the specified address and port" do
         @server = Puppet::Network::Server.new(@params.merge(:port => 34343))
         @server.listen
         lambda { TCPSocket.new('127.0.0.1', 34343) }.should_not raise_error
       end
 
       it "should default to '0.0.0.0' as its bind address" do
         Puppet.settings.clear
         Puppet[:servertype] = 'webrick'
         Puppet[:bindaddress].should == '0.0.0.0'
       end
 
       it "should use any specified bind address" do
         Puppet[:bindaddress] = "127.0.0.1"
         @server = Puppet::Network::Server.new(@params.merge(:port => 34343))
         @server.stubs(:unlisten) # we're breaking listening internally, so we have to keep it from unlistening
         @server.send(:http_server).expects(:listen).with { |args| args[:address] == "127.0.0.1" }
         @server.listen
       end
 
       it "should not allow multiple servers to listen on the same address and port" do
         @server = Puppet::Network::Server.new(@params.merge(:port => 34343))
         @server.listen
         @server2 = Puppet::Network::Server.new(@params.merge(:port => 34343))
         lambda { @server2.listen }.should raise_error
       end
 
       after :each do
         @server.unlisten if @server && @server.listening?
       end
     end
 
     describe "after unlistening" do
       it "should not be reachable on the port and address assigned" do
         @server = Puppet::Network::Server.new(@params.merge(:port => 34343))
         @server.listen
         @server.unlisten
         lambda { TCPSocket.new('127.0.0.1', 34343) }.should raise_error(Errno::ECONNREFUSED)
       end
     end
   end
 end
diff --git a/spec/integration/node/facts_spec.rb b/spec/integration/node/facts_spec.rb
index b2c71e42a..78bdabce1 100755
--- a/spec/integration/node/facts_spec.rb
+++ b/spec/integration/node/facts_spec.rb
@@ -1,43 +1,41 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 describe Puppet::Node::Facts do
   describe "when using the indirector" do
-    after(:each) { Puppet::Util::Cacher.expire }
-
     it "should expire any cached node instances when it is saved" do
       Puppet::Node::Facts.indirection.stubs(:terminus_class).returns :yaml
 
       Puppet::Node::Facts.indirection.terminus(:yaml).should equal(Puppet::Node::Facts.indirection.terminus(:yaml))
       terminus = Puppet::Node::Facts.indirection.terminus(:yaml)
       terminus.stubs :save
 
       Puppet::Node.indirection.expects(:expire).with("me")
 
       facts = Puppet::Node::Facts.new("me")
       Puppet::Node::Facts.indirection.save(facts)
     end
 
     it "should be able to delegate to the :yaml terminus" do
       Puppet::Node::Facts.indirection.stubs(:terminus_class).returns :yaml
 
       # Load now, before we stub the exists? method.
       terminus = Puppet::Node::Facts.indirection.terminus(:yaml)
 
       terminus.expects(:path).with("me").returns "/my/yaml/file"
       FileTest.expects(:exist?).with("/my/yaml/file").returns false
 
       Puppet::Node::Facts.indirection.find("me").should be_nil
     end
 
     it "should be able to delegate to the :facter terminus" do
       Puppet::Node::Facts.indirection.stubs(:terminus_class).returns :facter
 
       Facter.expects(:to_hash).returns "facter_hash"
       facts = Puppet::Node::Facts.new("me")
       Puppet::Node::Facts.expects(:new).with("me", "facter_hash").returns facts
 
       Puppet::Node::Facts.indirection.find("me").should equal(facts)
     end
   end
 end
diff --git a/spec/integration/resource/catalog_spec.rb b/spec/integration/resource/catalog_spec.rb
index 528e29545..df310b184 100755
--- a/spec/integration/resource/catalog_spec.rb
+++ b/spec/integration/resource/catalog_spec.rb
@@ -1,56 +1,55 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 describe Puppet::Resource::Catalog do
   describe "when pson is available", :if => Puppet.features.pson? do
     it "should support pson" do
       Puppet::Resource::Catalog.supported_formats.should be_include(:pson)
     end
   end
 
   describe "when using the indirector" do
-    after { Puppet::Util::Cacher.expire }
     before do
       # This is so the tests work w/out networking.
       Facter.stubs(:to_hash).returns({"hostname" => "foo.domain.com"})
       Facter.stubs(:value).returns("eh")
     end
 
 
     it "should be able to delegate to the :yaml terminus" do
       Puppet::Resource::Catalog.indirection.stubs(:terminus_class).returns :yaml
 
       # Load now, before we stub the exists? method.
       terminus = Puppet::Resource::Catalog.indirection.terminus(:yaml)
       terminus.expects(:path).with("me").returns "/my/yaml/file"
 
       FileTest.expects(:exist?).with("/my/yaml/file").returns false
       Puppet::Resource::Catalog.indirection.find("me").should be_nil
     end
 
     it "should be able to delegate to the :compiler terminus" do
       Puppet::Resource::Catalog.indirection.stubs(:terminus_class).returns :compiler
 
       # Load now, before we stub the exists? method.
       compiler = Puppet::Resource::Catalog.indirection.terminus(:compiler)
 
       node = mock 'node'
       node.stub_everything
 
       Puppet::Node.indirection.expects(:find).returns(node)
       compiler.expects(:compile).with(node).returns nil
 
       Puppet::Resource::Catalog.indirection.find("me").should be_nil
     end
 
     it "should pass provided node information directly to the terminus" do
       terminus = mock 'terminus'
 
       Puppet::Resource::Catalog.indirection.stubs(:terminus).returns terminus
 
       node = mock 'node'
       terminus.expects(:find).with { |request| request.options[:use_node] == node }
       Puppet::Resource::Catalog.indirection.find("me", :use_node => node)
     end
   end
 end
diff --git a/spec/integration/ssl/host_spec.rb b/spec/integration/ssl/host_spec.rb
index 4ee32bcc7..f452afa2e 100755
--- a/spec/integration/ssl/host_spec.rb
+++ b/spec/integration/ssl/host_spec.rb
@@ -1,87 +1,86 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 require 'puppet/ssl/host'
 require 'tempfile'
 
 describe Puppet::SSL::Host, :fails_on_windows => true do
   before do
     # Get a safe temporary file
     file = Tempfile.new("host_integration_testing")
     @dir = file.path
     file.delete
 
     Puppet.settings[:confdir] = @dir
     Puppet.settings[:vardir] = @dir
     Puppet.settings[:group] = Process.gid
 
     Puppet::SSL::Host.ca_location = :local
 
     @host = Puppet::SSL::Host.new("luke.madstop.com")
     @ca = Puppet::SSL::CertificateAuthority.new
   end
 
   after {
     Puppet::SSL::Host.ca_location = :none
 
     system("rm -rf #{@dir}")
     Puppet.settings.clear
-    Puppet::Util::Cacher.expire
   }
 
   it "should be considered a CA host if its name is equal to 'ca'" do
     Puppet::SSL::Host.new(Puppet::SSL::CA_NAME).should be_ca
   end
 
   describe "when managing its key" do
     it "should be able to generate and save a key" do
       @host.generate_key
     end
 
     it "should save the key such that the Indirector can find it" do
       @host.generate_key
 
       Puppet::SSL::Key.indirection.find(@host.name).content.to_s.should == @host.key.to_s
     end
 
     it "should save the private key into the :privatekeydir" do
       @host.generate_key
       File.read(File.join(Puppet.settings[:privatekeydir], "luke.madstop.com.pem")).should == @host.key.to_s
     end
   end
 
   describe "when managing its certificate request" do
     it "should be able to generate and save a certificate request" do
       @host.generate_certificate_request
     end
 
     it "should save the certificate request such that the Indirector can find it" do
       @host.generate_certificate_request
 
       Puppet::SSL::CertificateRequest.indirection.find(@host.name).content.to_s.should == @host.certificate_request.to_s
     end
 
     it "should save the private certificate request into the :privatekeydir" do
       @host.generate_certificate_request
       File.read(File.join(Puppet.settings[:requestdir], "luke.madstop.com.pem")).should == @host.certificate_request.to_s
     end
   end
 
   describe "when the CA host" do
     it "should never store its key in the :privatekeydir" do
       Puppet.settings.use(:main, :ssl, :ca)
       @ca = Puppet::SSL::Host.new(Puppet::SSL::Host.ca_name)
       @ca.generate_key
 
       FileTest.should_not be_exist(File.join(Puppet[:privatekeydir], "ca.pem"))
     end
   end
 
   it "should pass the verification of its own SSL store" do
     @host.generate
     @ca = Puppet::SSL::CertificateAuthority.new
     @ca.sign(@host.name)
 
     @host.ssl_store.verify(@host.certificate.content).should be_true
   end
 end
diff --git a/spec/integration/transaction/report_spec.rb b/spec/integration/transaction/report_spec.rb
index 031562ea1..8c581cc04 100755
--- a/spec/integration/transaction/report_spec.rb
+++ b/spec/integration/transaction/report_spec.rb
@@ -1,25 +1,24 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 describe Puppet::Transaction::Report do
   describe "when using the indirector" do
     after do
-      Puppet::Util::Cacher.expire
       Puppet.settings.stubs(:use)
     end
 
     it "should be able to delegate to the :processor terminus" do
       Puppet::Transaction::Report.indirection.stubs(:terminus_class).returns :processor
 
       terminus = Puppet::Transaction::Report.indirection.terminus(:processor)
 
       Facter.stubs(:value).returns "host.domain.com"
 
       report = Puppet::Transaction::Report.new("apply")
 
       terminus.expects(:process).with(report)
 
       Puppet::Transaction::Report.indirection.save(report)
     end
   end
 end
diff --git a/spec/unit/indirector/indirection_spec.rb b/spec/unit/indirector/indirection_spec.rb
index 4bbc855b1..c33fdf165 100755
--- a/spec/unit/indirector/indirection_spec.rb
+++ b/spec/unit/indirector/indirection_spec.rb
@@ -1,860 +1,856 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 require 'puppet/indirector/indirection'
 
 shared_examples_for "Indirection Delegator" do
   it "should create a request object with the appropriate method name and all of the passed arguments" do
     request = Puppet::Indirector::Request.new(:indirection, :find, "me")
 
     @indirection.expects(:request).with(@method, "mystuff", :one => :two).returns request
 
     @terminus.stubs(@method)
 
     @indirection.send(@method, "mystuff", :one => :two)
   end
 
   it "should let the :select_terminus method choose the terminus using the created request if the :select_terminus method is available" do
     # Define the method, so our respond_to? hook matches.
     class << @indirection
       def select_terminus(request)
       end
     end
 
     request = Puppet::Indirector::Request.new(:indirection, :find, "me")
 
     @indirection.stubs(:request).returns request
 
     @indirection.expects(:select_terminus).with(request).returns :test_terminus
 
     @indirection.stubs(:check_authorization)
     @terminus.expects(@method)
 
     @indirection.send(@method, "me")
   end
 
   it "should fail if the :select_terminus hook does not return a terminus name" do
     # Define the method, so our respond_to? hook matches.
     class << @indirection
       def select_terminus(request)
       end
     end
 
     request = stub 'request', :key => "me", :options => {}
 
     @indirection.stubs(:request).returns request
 
     @indirection.expects(:select_terminus).with(request).returns nil
 
     lambda { @indirection.send(@method, "me") }.should raise_error(ArgumentError)
   end
 
   it "should choose the terminus returned by the :terminus_class method if no :select_terminus method is available" do
     @indirection.expects(:terminus_class).returns :test_terminus
 
     @terminus.expects(@method)
 
     @indirection.send(@method, "me")
   end
 
   it "should let the appropriate terminus perform the lookup" do
     @terminus.expects(@method).with { |r| r.is_a?(Puppet::Indirector::Request) }
     @indirection.send(@method, "me")
   end
 end
 
 shared_examples_for "Delegation Authorizer" do
   before do
     # So the :respond_to? turns out correctly.
     class << @terminus
       def authorized?
       end
     end
   end
 
   it "should not check authorization if a node name is not provided" do
     @terminus.expects(:authorized?).never
     @terminus.stubs(@method)
 
     # The quotes are necessary here, else it looks like a block.
     @request.stubs(:options).returns({})
     @indirection.send(@method, "/my/key")
   end
 
   it "should pass the request to the terminus's authorization method" do
     @terminus.expects(:authorized?).with { |r| r.is_a?(Puppet::Indirector::Request) }.returns(true)
     @terminus.stubs(@method)
 
     @indirection.send(@method, "/my/key", :node => "mynode")
   end
 
   it "should fail if authorization returns false" do
     @terminus.expects(:authorized?).returns(false)
     @terminus.stubs(@method)
     proc { @indirection.send(@method, "/my/key", :node => "mynode") }.should raise_error(ArgumentError)
   end
 
   it "should continue if authorization returns true" do
     @terminus.expects(:authorized?).returns(true)
     @terminus.stubs(@method)
     @indirection.send(@method, "/my/key", :node => "mynode")
   end
 end
 
 describe Puppet::Indirector::Indirection do
-  after do
-    Puppet::Util::Cacher.expire
-  end
   describe "when initializing" do
     # (LAK) I've no idea how to test this, really.
     it "should store a reference to itself before it consumes its options" do
       proc { @indirection = Puppet::Indirector::Indirection.new(Object.new, :testingness, :not_valid_option) }.should raise_error
       Puppet::Indirector::Indirection.instance(:testingness).should be_instance_of(Puppet::Indirector::Indirection)
       Puppet::Indirector::Indirection.instance(:testingness).delete
     end
 
     it "should keep a reference to the indirecting model" do
       model = mock 'model'
       @indirection = Puppet::Indirector::Indirection.new(model, :myind)
       @indirection.model.should equal(model)
     end
 
     it "should set the name" do
       @indirection = Puppet::Indirector::Indirection.new(mock('model'), :myind)
       @indirection.name.should == :myind
     end
 
     it "should require indirections to have unique names" do
       @indirection = Puppet::Indirector::Indirection.new(mock('model'), :test)
       proc { Puppet::Indirector::Indirection.new(:test) }.should raise_error(ArgumentError)
     end
 
     it "should extend itself with any specified module" do
       mod = Module.new
       @indirection = Puppet::Indirector::Indirection.new(mock('model'), :test, :extend => mod)
       @indirection.singleton_class.included_modules.should include(mod)
     end
 
     after do
       @indirection.delete if defined?(@indirection)
     end
   end
 
   describe "when an instance" do
     before :each do
       @terminus_class = mock 'terminus_class'
       @terminus = mock 'terminus'
       @terminus_class.stubs(:new).returns(@terminus)
       @cache = stub 'cache', :name => "mycache"
       @cache_class = mock 'cache_class'
       Puppet::Indirector::Terminus.stubs(:terminus_class).with(:test, :cache_terminus).returns(@cache_class)
       Puppet::Indirector::Terminus.stubs(:terminus_class).with(:test, :test_terminus).returns(@terminus_class)
 
       @indirection = Puppet::Indirector::Indirection.new(mock('model'), :test)
       @indirection.terminus_class = :test_terminus
 
       @instance = stub 'instance', :expiration => nil, :expiration= => nil, :name => "whatever"
       @name = :mything
 
       #@request = stub 'instance', :key => "/my/key", :instance => @instance, :options => {}
       @request = mock 'instance'
     end
 
     it "should allow setting the ttl" do
       @indirection.ttl = 300
       @indirection.ttl.should == 300
     end
 
     it "should default to the :runinterval setting, converted to an integer, for its ttl" do
       Puppet.settings.expects(:value).returns "1800"
       @indirection.ttl.should == 1800
     end
 
     it "should calculate the current expiration by adding the TTL to the current time" do
       @indirection.stubs(:ttl).returns(100)
       now = Time.now
       Time.stubs(:now).returns now
       @indirection.expiration.should == (Time.now + 100)
     end
 
     it "should have a method for creating an indirection request instance" do
       @indirection.should respond_to(:request)
     end
 
     describe "creates a request" do
       it "should create it with its name as the request's indirection name" do
         Puppet::Indirector::Request.expects(:new).with { |name, *other| @indirection.name == name }
         @indirection.request(:funtest, "yayness")
       end
 
       it "should require a method and key" do
         Puppet::Indirector::Request.expects(:new).with { |name, method, key, *other| method == :funtest and key == "yayness" }
         @indirection.request(:funtest, "yayness")
       end
 
       it "should support optional arguments" do
         Puppet::Indirector::Request.expects(:new).with { |name, method, key, other| other == {:one => :two} }
         @indirection.request(:funtest, "yayness", :one => :two)
       end
 
       it "should not pass options if none are supplied" do
         Puppet::Indirector::Request.expects(:new).with { |*args| args.length < 4 }
         @indirection.request(:funtest, "yayness")
       end
 
       it "should return the request" do
         request = mock 'request'
         Puppet::Indirector::Request.expects(:new).returns request
         @indirection.request(:funtest, "yayness").should equal(request)
       end
     end
 
     describe "and looking for a model instance" do
       before { @method = :find }
 
       it_should_behave_like "Indirection Delegator"
       it_should_behave_like "Delegation Authorizer"
 
       it "should return the results of the delegation" do
         @terminus.expects(:find).returns(@instance)
         @indirection.find("me").should equal(@instance)
       end
 
       it "should set the expiration date on any instances without one set" do
         @terminus.stubs(:find).returns(@instance)
 
         @indirection.expects(:expiration).returns :yay
 
         @instance.expects(:expiration).returns(nil)
         @instance.expects(:expiration=).with(:yay)
 
         @indirection.find("/my/key")
       end
 
       it "should not override an already-set expiration date on returned instances" do
         @terminus.stubs(:find).returns(@instance)
 
         @indirection.expects(:expiration).never
 
         @instance.expects(:expiration).returns(:yay)
         @instance.expects(:expiration=).never
 
         @indirection.find("/my/key")
       end
 
       it "should filter the result instance if the terminus supports it" do
         @terminus.stubs(:find).returns(@instance)
         @terminus.stubs(:respond_to?).with(:filter).returns(true)
 
         @terminus.expects(:filter).with(@instance)
 
         @indirection.find("/my/key")
       end
       describe "when caching is enabled" do
         before do
           @indirection.cache_class = :cache_terminus
           @cache_class.stubs(:new).returns(@cache)
 
           @instance.stubs(:expired?).returns false
         end
 
         it "should first look in the cache for an instance" do
           @terminus.stubs(:find).never
           @cache.expects(:find).returns @instance
 
           @indirection.find("/my/key")
         end
 
         it "should not look in the cache if the request specifies not to use the cache" do
           @terminus.expects(:find).returns @instance
           @cache.expects(:find).never
           @cache.stubs(:save)
 
           @indirection.find("/my/key", :ignore_cache => true)
         end
 
         it "should still save to the cache even if the cache is being ignored during readin" do
           @terminus.expects(:find).returns @instance
           @cache.expects(:save)
 
           @indirection.find("/my/key", :ignore_cache => true)
         end
 
         it "should only look in the cache if the request specifies not to use the terminus" do
           @terminus.expects(:find).never
           @cache.expects(:find)
 
           @indirection.find("/my/key", :ignore_terminus => true)
         end
 
         it "should use a request to look in the cache for cached objects" do
           @cache.expects(:find).with { |r| r.method == :find and r.key == "/my/key" }.returns @instance
 
           @cache.stubs(:save)
 
           @indirection.find("/my/key")
         end
 
         it "should return the cached object if it is not expired" do
           @instance.stubs(:expired?).returns false
 
           @cache.stubs(:find).returns @instance
           @indirection.find("/my/key").should equal(@instance)
         end
 
         it "should not fail if the cache fails" do
           @terminus.stubs(:find).returns @instance
 
           @cache.expects(:find).raises ArgumentError
           @cache.stubs(:save)
           lambda { @indirection.find("/my/key") }.should_not raise_error
         end
 
         it "should look in the main terminus if the cache fails" do
           @terminus.expects(:find).returns @instance
           @cache.expects(:find).raises ArgumentError
           @cache.stubs(:save)
           @indirection.find("/my/key").should equal(@instance)
         end
 
         it "should send a debug log if it is using the cached object" do
           Puppet.expects(:debug)
           @cache.stubs(:find).returns @instance
 
           @indirection.find("/my/key")
         end
 
         it "should not return the cached object if it is expired" do
           @instance.stubs(:expired?).returns true
 
           @cache.stubs(:find).returns @instance
           @terminus.stubs(:find).returns nil
           @indirection.find("/my/key").should be_nil
         end
 
         it "should send an info log if it is using the cached object" do
           Puppet.expects(:info)
           @instance.stubs(:expired?).returns true
 
           @cache.stubs(:find).returns @instance
           @terminus.stubs(:find).returns nil
           @indirection.find("/my/key")
         end
 
         it "should cache any objects not retrieved from the cache" do
           @cache.expects(:find).returns nil
 
           @terminus.expects(:find).returns(@instance)
           @cache.expects(:save)
 
           @indirection.find("/my/key")
         end
 
         it "should use a request to look in the cache for cached objects" do
           @cache.expects(:find).with { |r| r.method == :find and r.key == "/my/key" }.returns nil
 
           @terminus.stubs(:find).returns(@instance)
           @cache.stubs(:save)
 
           @indirection.find("/my/key")
         end
 
         it "should cache the instance using a request with the instance set to the cached object" do
           @cache.stubs(:find).returns nil
 
           @terminus.stubs(:find).returns(@instance)
 
           @cache.expects(:save).with { |r| r.method == :save and r.instance == @instance }
 
           @indirection.find("/my/key")
         end
 
         it "should send an info log that the object is being cached" do
           @cache.stubs(:find).returns nil
 
           @terminus.stubs(:find).returns(@instance)
           @cache.stubs(:save)
 
           Puppet.expects(:info)
 
           @indirection.find("/my/key")
         end
       end
     end
 
     describe "and doing a head operation" do
       before { @method = :head }
 
       it_should_behave_like "Indirection Delegator"
       it_should_behave_like "Delegation Authorizer"
 
       it "should return true if the head method returned true" do
         @terminus.expects(:head).returns(true)
         @indirection.head("me").should == true
       end
 
       it "should return false if the head method returned false" do
         @terminus.expects(:head).returns(false)
         @indirection.head("me").should == false
       end
 
       describe "when caching is enabled" do
         before do
           @indirection.cache_class = :cache_terminus
           @cache_class.stubs(:new).returns(@cache)
 
           @instance.stubs(:expired?).returns false
         end
 
         it "should first look in the cache for an instance" do
           @terminus.stubs(:find).never
           @terminus.stubs(:head).never
           @cache.expects(:find).returns @instance
 
           @indirection.head("/my/key").should == true
         end
 
         it "should not save to the cache" do
           @cache.expects(:find).returns nil
           @cache.expects(:save).never
           @terminus.expects(:head).returns true
           @indirection.head("/my/key").should == true
         end
 
         it "should not fail if the cache fails" do
           @terminus.stubs(:head).returns true
 
           @cache.expects(:find).raises ArgumentError
           lambda { @indirection.head("/my/key") }.should_not raise_error
         end
 
         it "should look in the main terminus if the cache fails" do
           @terminus.expects(:head).returns true
           @cache.expects(:find).raises ArgumentError
           @indirection.head("/my/key").should == true
         end
 
         it "should send a debug log if it is using the cached object" do
           Puppet.expects(:debug)
           @cache.stubs(:find).returns @instance
 
           @indirection.head("/my/key")
         end
 
         it "should not accept the cached object if it is expired" do
           @instance.stubs(:expired?).returns true
 
           @cache.stubs(:find).returns @instance
           @terminus.stubs(:head).returns false
           @indirection.head("/my/key").should == false
         end
       end
     end
 
     describe "and storing a model instance" do
       before { @method = :save }
 
       it "should return the result of the save" do
         @terminus.stubs(:save).returns "foo"
         @indirection.save(@instance).should == "foo"
       end
 
       describe "when caching is enabled" do
         before do
           @indirection.cache_class = :cache_terminus
           @cache_class.stubs(:new).returns(@cache)
 
           @instance.stubs(:expired?).returns false
         end
 
         it "should return the result of saving to the terminus" do
           request = stub 'request', :instance => @instance, :node => nil
 
           @indirection.expects(:request).returns request
 
           @cache.stubs(:save)
           @terminus.stubs(:save).returns @instance
           @indirection.save(@instance).should equal(@instance)
         end
 
         it "should use a request to save the object to the cache" do
           request = stub 'request', :instance => @instance, :node => nil
 
           @indirection.expects(:request).returns request
 
           @cache.expects(:save).with(request)
           @terminus.stubs(:save)
           @indirection.save(@instance)
         end
 
         it "should not save to the cache if the normal save fails" do
           request = stub 'request', :instance => @instance, :node => nil
 
           @indirection.expects(:request).returns request
 
           @cache.expects(:save).never
           @terminus.expects(:save).raises "eh"
           lambda { @indirection.save(@instance) }.should raise_error
         end
       end
     end
 
     describe "and removing a model instance" do
       before { @method = :destroy }
 
       it_should_behave_like "Indirection Delegator"
       it_should_behave_like "Delegation Authorizer"
 
       it "should return the result of removing the instance" do
         @terminus.stubs(:destroy).returns "yayness"
         @indirection.destroy("/my/key").should == "yayness"
       end
 
       describe "when caching is enabled" do
         before do
           @indirection.cache_class = :cache_terminus
           @cache_class.expects(:new).returns(@cache)
 
           @instance.stubs(:expired?).returns false
         end
 
         it "should use a request instance to search in and remove objects from the cache" do
           destroy = stub 'destroy_request', :key => "/my/key", :node => nil
           find = stub 'destroy_request', :key => "/my/key", :node => nil
 
           @indirection.expects(:request).with(:destroy, "/my/key").returns destroy
           @indirection.expects(:request).with(:find, "/my/key").returns find
 
           cached = mock 'cache'
 
           @cache.expects(:find).with(find).returns cached
           @cache.expects(:destroy).with(destroy)
 
           @terminus.stubs(:destroy)
 
           @indirection.destroy("/my/key")
         end
       end
     end
 
     describe "and searching for multiple model instances" do
       before { @method = :search }
 
       it_should_behave_like "Indirection Delegator"
       it_should_behave_like "Delegation Authorizer"
 
       it "should set the expiration date on any instances without one set" do
         @terminus.stubs(:search).returns([@instance])
 
         @indirection.expects(:expiration).returns :yay
 
         @instance.expects(:expiration).returns(nil)
         @instance.expects(:expiration=).with(:yay)
 
         @indirection.search("/my/key")
       end
 
       it "should not override an already-set expiration date on returned instances" do
         @terminus.stubs(:search).returns([@instance])
 
         @indirection.expects(:expiration).never
 
         @instance.expects(:expiration).returns(:yay)
         @instance.expects(:expiration=).never
 
         @indirection.search("/my/key")
       end
 
       it "should return the results of searching in the terminus" do
         @terminus.expects(:search).returns([@instance])
         @indirection.search("/my/key").should == [@instance]
       end
     end
 
     describe "and expiring a model instance" do
       describe "when caching is not enabled" do
         it "should do nothing" do
           @cache_class.expects(:new).never
 
           @indirection.expire("/my/key")
         end
       end
 
       describe "when caching is enabled" do
         before do
           @indirection.cache_class = :cache_terminus
           @cache_class.expects(:new).returns(@cache)
 
           @instance.stubs(:expired?).returns false
 
           @cached = stub 'cached', :expiration= => nil, :name => "/my/key"
         end
 
         it "should use a request to find within the cache" do
           @cache.expects(:find).with { |r| r.is_a?(Puppet::Indirector::Request) and r.method == :find }
           @indirection.expire("/my/key")
         end
 
         it "should do nothing if no such instance is cached" do
           @cache.expects(:find).returns nil
 
           @indirection.expire("/my/key")
         end
 
         it "should log when expiring a found instance" do
           @cache.expects(:find).returns @cached
           @cache.stubs(:save)
 
           Puppet.expects(:info)
 
           @indirection.expire("/my/key")
         end
 
         it "should set the cached instance's expiration to a time in the past" do
           @cache.expects(:find).returns @cached
           @cache.stubs(:save)
 
           @cached.expects(:expiration=).with { |t| t < Time.now }
 
           @indirection.expire("/my/key")
         end
 
         it "should save the now expired instance back into the cache" do
           @cache.expects(:find).returns @cached
 
           @cached.expects(:expiration=).with { |t| t < Time.now }
 
           @cache.expects(:save)
 
           @indirection.expire("/my/key")
         end
 
         it "should use a request to save the expired resource to the cache" do
           @cache.expects(:find).returns @cached
 
           @cached.expects(:expiration=).with { |t| t < Time.now }
 
           @cache.expects(:save).with { |r| r.is_a?(Puppet::Indirector::Request) and r.instance == @cached and r.method == :save }.returns(@cached)
 
           @indirection.expire("/my/key")
         end
       end
     end
 
     after :each do
       @indirection.delete
-      Puppet::Util::Cacher.expire
     end
   end
 
 
   describe "when managing indirection instances" do
     it "should allow an indirection to be retrieved by name" do
       @indirection = Puppet::Indirector::Indirection.new(mock('model'), :test)
       Puppet::Indirector::Indirection.instance(:test).should equal(@indirection)
     end
 
     it "should return nil when the named indirection has not been created" do
       Puppet::Indirector::Indirection.instance(:test).should be_nil
     end
 
     it "should allow an indirection's model to be retrieved by name" do
       mock_model = mock('model')
       @indirection = Puppet::Indirector::Indirection.new(mock_model, :test)
       Puppet::Indirector::Indirection.model(:test).should equal(mock_model)
     end
 
     it "should return nil when no model matches the requested name" do
       Puppet::Indirector::Indirection.model(:test).should be_nil
     end
 
     after do
       @indirection.delete if defined?(@indirection)
     end
   end
 
   describe "when routing to the correct the terminus class" do
     before do
       @indirection = Puppet::Indirector::Indirection.new(mock('model'), :test)
       @terminus = mock 'terminus'
       @terminus_class = stub 'terminus class', :new => @terminus
       Puppet::Indirector::Terminus.stubs(:terminus_class).with(:test, :default).returns(@terminus_class)
     end
 
     it "should fail if no terminus class can be picked" do
       proc { @indirection.terminus_class }.should raise_error(Puppet::DevError)
     end
 
     it "should choose the default terminus class if one is specified" do
       @indirection.terminus_class = :default
       @indirection.terminus_class.should equal(:default)
     end
 
     it "should use the provided Puppet setting if told to do so" do
       Puppet::Indirector::Terminus.stubs(:terminus_class).with(:test, :my_terminus).returns(mock("terminus_class2"))
       Puppet.settings.expects(:value).with(:my_setting).returns("my_terminus")
       @indirection.terminus_setting = :my_setting
       @indirection.terminus_class.should equal(:my_terminus)
     end
 
     it "should fail if the provided terminus class is not valid" do
       Puppet::Indirector::Terminus.stubs(:terminus_class).with(:test, :nosuchclass).returns(nil)
       proc { @indirection.terminus_class = :nosuchclass }.should raise_error(ArgumentError)
     end
 
     after do
       @indirection.delete if defined?(@indirection)
     end
   end
 
   describe "when specifying the terminus class to use" do
     before do
       @indirection = Puppet::Indirector::Indirection.new(mock('model'), :test)
       @terminus = mock 'terminus'
       @terminus_class = stub 'terminus class', :new => @terminus
     end
 
     it "should allow specification of a terminus type" do
       @indirection.should respond_to(:terminus_class=)
     end
 
     it "should fail to redirect if no terminus type has been specified" do
       proc { @indirection.find("blah") }.should raise_error(Puppet::DevError)
     end
 
     it "should fail when the terminus class name is an empty string" do
       proc { @indirection.terminus_class = "" }.should raise_error(ArgumentError)
     end
 
     it "should fail when the terminus class name is nil" do
       proc { @indirection.terminus_class = nil }.should raise_error(ArgumentError)
     end
 
     it "should fail when the specified terminus class cannot be found" do
       Puppet::Indirector::Terminus.expects(:terminus_class).with(:test, :foo).returns(nil)
       proc { @indirection.terminus_class = :foo }.should raise_error(ArgumentError)
     end
 
     it "should select the specified terminus class if a terminus class name is provided" do
       Puppet::Indirector::Terminus.expects(:terminus_class).with(:test, :foo).returns(@terminus_class)
       @indirection.terminus(:foo).should equal(@terminus)
     end
 
     it "should use the configured terminus class if no terminus name is specified" do
       Puppet::Indirector::Terminus.stubs(:terminus_class).with(:test, :foo).returns(@terminus_class)
       @indirection.terminus_class = :foo
       @indirection.terminus.should equal(@terminus)
     end
 
     after do
       @indirection.delete if defined?(@indirection)
     end
   end
 
   describe "when managing terminus instances" do
     before do
       @indirection = Puppet::Indirector::Indirection.new(mock('model'), :test)
       @terminus = mock 'terminus'
       @terminus_class = mock 'terminus class'
       Puppet::Indirector::Terminus.stubs(:terminus_class).with(:test, :foo).returns(@terminus_class)
     end
 
     it "should create an instance of the chosen terminus class" do
       @terminus_class.stubs(:new).returns(@terminus)
       @indirection.terminus(:foo).should equal(@terminus)
     end
 
     # Make sure it caches the terminus.
     it "should return the same terminus instance each time for a given name" do
       @terminus_class.stubs(:new).returns(@terminus)
       @indirection.terminus(:foo).should equal(@terminus)
       @indirection.terminus(:foo).should equal(@terminus)
     end
 
     it "should not create a terminus instance until one is actually needed" do
       Puppet::Indirector.expects(:terminus).never
       indirection = Puppet::Indirector::Indirection.new(mock('model'), :lazytest)
     end
 
     after do
       @indirection.delete
     end
   end
 
   describe "when deciding whether to cache" do
     before do
       @indirection = Puppet::Indirector::Indirection.new(mock('model'), :test)
       @terminus = mock 'terminus'
       @terminus_class = mock 'terminus class'
       @terminus_class.stubs(:new).returns(@terminus)
       Puppet::Indirector::Terminus.stubs(:terminus_class).with(:test, :foo).returns(@terminus_class)
       @indirection.terminus_class = :foo
     end
 
     it "should provide a method for setting the cache terminus class" do
       @indirection.should respond_to(:cache_class=)
     end
 
     it "should fail to cache if no cache type has been specified" do
       proc { @indirection.cache }.should raise_error(Puppet::DevError)
     end
 
     it "should fail to set the cache class when the cache class name is an empty string" do
       proc { @indirection.cache_class = "" }.should raise_error(ArgumentError)
     end
 
     it "should allow resetting the cache_class to nil" do
       @indirection.cache_class = nil
       @indirection.cache_class.should be_nil
     end
 
     it "should fail to set the cache class when the specified cache class cannot be found" do
       Puppet::Indirector::Terminus.expects(:terminus_class).with(:test, :foo).returns(nil)
       proc { @indirection.cache_class = :foo }.should raise_error(ArgumentError)
     end
 
     after do
       @indirection.delete
     end
   end
 
   describe "when using a cache" do
     before :each do
       Puppet.settings.stubs(:value).with("test_terminus").returns("test_terminus")
       @terminus_class = mock 'terminus_class'
       @terminus = mock 'terminus'
       @terminus_class.stubs(:new).returns(@terminus)
       @cache = mock 'cache'
       @cache_class = mock 'cache_class'
       Puppet::Indirector::Terminus.stubs(:terminus_class).with(:test, :cache_terminus).returns(@cache_class)
       Puppet::Indirector::Terminus.stubs(:terminus_class).with(:test, :test_terminus).returns(@terminus_class)
       @indirection = Puppet::Indirector::Indirection.new(mock('model'), :test)
       @indirection.terminus_class = :test_terminus
     end
 
     describe "and managing the cache terminus" do
       it "should not create a cache terminus at initialization" do
         # This is weird, because all of the code is in the setup.  If we got
         # new called on the cache class, we'd get an exception here.
       end
 
       it "should reuse the cache terminus" do
         @cache_class.expects(:new).returns(@cache)
         Puppet.settings.stubs(:value).with("test_cache").returns("cache_terminus")
         @indirection.cache_class = :cache_terminus
         @indirection.cache.should equal(@cache)
         @indirection.cache.should equal(@cache)
       end
     end
 
     describe "and saving" do
     end
 
     describe "and finding" do
     end
 
     after :each do
       @indirection.delete
     end
   end
 end
diff --git a/spec/unit/node/environment_spec.rb b/spec/unit/node/environment_spec.rb
index 144e82e0c..f3772749a 100755
--- a/spec/unit/node/environment_spec.rb
+++ b/spec/unit/node/environment_spec.rb
@@ -1,339 +1,321 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
+require 'tmpdir'
+
 require 'puppet/node/environment'
 require 'puppet/util/execution'
 
 describe Puppet::Node::Environment do
   include PuppetSpec::Files
   after do
     Puppet::Node::Environment.clear
   end
 
-  it "should include the Cacher module" do
-    Puppet::Node::Environment.ancestors.should be_include(Puppet::Util::Cacher)
-  end
-
   it "should use the filetimeout for the ttl for the modulepath" do
     Puppet::Node::Environment.attr_ttl(:modulepath).should == Integer(Puppet[:filetimeout])
   end
 
   it "should use the filetimeout for the ttl for the module list" do
     Puppet::Node::Environment.attr_ttl(:modules).should == Integer(Puppet[:filetimeout])
   end
 
-  it "should use the filetimeout for the ttl for the manifestdir" do
-    Puppet::Node::Environment.attr_ttl(:manifestdir).should == Integer(Puppet[:filetimeout])
-  end
-
   it "should use the default environment if no name is provided while initializing an environment" do
     Puppet.settings.expects(:value).with(:environment).returns("one")
     Puppet::Node::Environment.new.name.should == :one
   end
 
   it "should treat environment instances as singletons" do
     Puppet::Node::Environment.new("one").should equal(Puppet::Node::Environment.new("one"))
   end
 
   it "should treat an environment specified as names or strings as equivalent" do
     Puppet::Node::Environment.new(:one).should equal(Puppet::Node::Environment.new("one"))
   end
 
   it "should return its name when converted to a string" do
     Puppet::Node::Environment.new(:one).to_s.should == "one"
   end
 
   it "should just return any provided environment if an environment is provided as the name" do
     one = Puppet::Node::Environment.new(:one)
     Puppet::Node::Environment.new(one).should equal(one)
   end
 
   describe "when managing known resource types" do
     before do
       @env = Puppet::Node::Environment.new("dev")
       @collection = Puppet::Resource::TypeCollection.new(@env)
       @env.stubs(:perform_initial_import).returns(Puppet::Parser::AST::Hostclass.new(''))
       Thread.current[:known_resource_types] = nil
     end
 
     it "should create a resource type collection if none exists" do
       Puppet::Resource::TypeCollection.expects(:new).with(@env).returns @collection
       @env.known_resource_types.should equal(@collection)
     end
 
     it "should reuse any existing resource type collection" do
       @env.known_resource_types.should equal(@env.known_resource_types)
     end
 
     it "should perform the initial import when creating a new collection" do
       @env = Puppet::Node::Environment.new("dev")
       @env.expects(:perform_initial_import).returns(Puppet::Parser::AST::Hostclass.new(''))
       @env.known_resource_types
     end
 
     it "should return the same collection even if stale if it's the same thread" do
       Puppet::Resource::TypeCollection.stubs(:new).returns @collection
       @env.known_resource_types.stubs(:stale?).returns true
 
       @env.known_resource_types.should equal(@collection)
     end
 
     it "should return the current thread associated collection if there is one" do
       Thread.current[:known_resource_types] = @collection
 
       @env.known_resource_types.should equal(@collection)
     end
 
     it "should give to all threads using the same environment the same collection if the collection isn't stale" do
       original_thread_type_collection = Puppet::Resource::TypeCollection.new(@env)
       Puppet::Resource::TypeCollection.expects(:new).with(@env).returns original_thread_type_collection
       @env.known_resource_types.should equal(original_thread_type_collection)
 
       original_thread_type_collection.expects(:require_reparse?).returns(false)
       Puppet::Resource::TypeCollection.stubs(:new).with(@env).returns @collection
 
       t = Thread.new {
         @env.known_resource_types.should equal(original_thread_type_collection)
       }
       t.join
     end
 
     it "should generate a new TypeCollection if the current one requires reparsing" do
       old_type_collection = @env.known_resource_types
       old_type_collection.stubs(:require_reparse?).returns true
       Thread.current[:known_resource_types] = nil
       new_type_collection = @env.known_resource_types
 
       new_type_collection.should be_a Puppet::Resource::TypeCollection
       new_type_collection.should_not equal(old_type_collection)
     end
   end
 
-  [:modulepath, :manifestdir].each do |setting|
-    it "should validate the #{setting} directories" do
-      path = %w{/one /two}.join(File::PATH_SEPARATOR)
-
-      env = Puppet::Node::Environment.new("testing")
-      env.stubs(:[]).with(setting).returns path
-
-      env.expects(:validate_dirs).with(%w{/one /two})
-
-      env.send(setting)
-    end
+  it "should validate the modulepath directories" do
+    real_file = Dir.mktmpdir
+    path = %W[/one /two #{real_file}].join(File::PATH_SEPARATOR)
 
-    it "should return the validated dirs for #{setting}" do
-      path = %w{/one /two}.join(File::PATH_SEPARATOR)
+    Puppet[:modulepath] = path
 
-      env = Puppet::Node::Environment.new("testing")
-      env.stubs(:[]).with(setting).returns path
-      env.stubs(:validate_dirs).returns %w{/one /two}
+    env = Puppet::Node::Environment.new("testing")
 
-      env.send(setting).should == %w{/one /two}
-    end
+    env.modulepath.should == [real_file]
   end
 
   it "should prefix the value of the 'PUPPETLIB' environment variable to the module path if present" do
     Puppet::Util::Execution.withenv("PUPPETLIB" => %w{/l1 /l2}.join(File::PATH_SEPARATOR)) do
       env = Puppet::Node::Environment.new("testing")
       module_path = %w{/one /two}.join(File::PATH_SEPARATOR)
       env.expects(:validate_dirs).with(%w{/l1 /l2 /one /two}).returns %w{/l1 /l2 /one /two}
       env.expects(:[]).with(:modulepath).returns module_path
 
       env.modulepath.should == %w{/l1 /l2 /one /two}
     end
   end
 
   describe "when validating modulepath or manifestdir directories" do
     before :each do
       @path_one = make_absolute('/one')
       @path_two = make_absolute('/two')
     end
 
     it "should not return non-directories" do
       env = Puppet::Node::Environment.new("testing")
 
       FileTest.expects(:directory?).with(@path_one).returns true
       FileTest.expects(:directory?).with(@path_two).returns false
 
       env.validate_dirs([@path_one, @path_two]).should == [@path_one]
     end
 
     it "should use the current working directory to fully-qualify unqualified paths" do
       FileTest.stubs(:directory?).returns true
       env = Puppet::Node::Environment.new("testing")
 
       two = File.join(Dir.getwd, "two")
       env.validate_dirs([@path_one, 'two']).should == [@path_one, two]
     end
   end
 
   describe "when modeling a specific environment" do
     it "should have a method for returning the environment name" do
       Puppet::Node::Environment.new("testing").name.should == :testing
     end
 
     it "should provide an array-like accessor method for returning any environment-specific setting" do
       env = Puppet::Node::Environment.new("testing")
       env.should respond_to(:[])
     end
 
     it "should ask the Puppet settings instance for the setting qualified with the environment name" do
       Puppet.settings.expects(:value).with("myvar", :testing).returns("myval")
       env = Puppet::Node::Environment.new("testing")
       env["myvar"].should == "myval"
     end
 
     it "should be able to return an individual module that exists in its module path" do
       env = Puppet::Node::Environment.new("testing")
 
       mod = mock 'module'
       Puppet::Module.expects(:new).with("one", env).returns mod
       mod.expects(:exist?).returns true
 
       env.module("one").should equal(mod)
     end
 
     it "should return nil if asked for a module that does not exist in its path" do
       env = Puppet::Node::Environment.new("testing")
 
       mod = mock 'module'
       Puppet::Module.expects(:new).with("one", env).returns mod
       mod.expects(:exist?).returns false
 
       env.module("one").should be_nil
     end
 
     it "should be able to return its modules" do
       Puppet::Node::Environment.new("testing").should respond_to(:modules)
     end
 
     describe ".modules" do
       it "should return a module named for every directory in each module path" do
         env = Puppet::Node::Environment.new("testing")
         env.expects(:modulepath).at_least_once.returns %w{/a /b}
         Dir.expects(:entries).with("/a").returns %w{foo bar}
         Dir.expects(:entries).with("/b").returns %w{bee baz}
 
         env.modules.collect{|mod| mod.name}.sort.should == %w{foo bar bee baz}.sort
       end
 
       it "should remove duplicates" do
         env = Puppet::Node::Environment.new("testing")
         env.expects(:modulepath).returns( %w{/a /b} ).at_least_once
         Dir.expects(:entries).with("/a").returns %w{foo}
         Dir.expects(:entries).with("/b").returns %w{foo}
 
         env.modules.collect{|mod| mod.name}.sort.should == %w{foo}
       end
 
       it "should ignore invalid modules" do
         env = Puppet::Node::Environment.new("testing")
         env.stubs(:modulepath).returns %w{/a}
         Dir.expects(:entries).with("/a").returns %w{foo bar}
 
         Puppet::Module.expects(:new).with { |name, env| name == "foo" }.returns mock("foomod", :name => "foo")
         Puppet::Module.expects(:new).with { |name, env| name == "bar" }.raises( Puppet::Module::InvalidName, "name is invalid" )
 
         env.modules.collect{|mod| mod.name}.sort.should == %w{foo}
       end
 
       it "should create modules with the correct environment" do
         env = Puppet::Node::Environment.new("testing")
         env.expects(:modulepath).at_least_once.returns %w{/a}
         Dir.expects(:entries).with("/a").returns %w{foo}
 
         env.modules.each {|mod| mod.environment.should == env }
       end
 
       it "should cache the module list" do
         env = Puppet::Node::Environment.new("testing")
         env.expects(:modulepath).at_least_once.returns %w{/a}
         Dir.expects(:entries).once.with("/a").returns %w{foo}
 
         env.modules
         env.modules
       end
     end
   end
 
   describe Puppet::Node::Environment::Helper do
     before do
       @helper = Object.new
       @helper.extend(Puppet::Node::Environment::Helper)
     end
 
     it "should be able to set and retrieve the environment" do
       @helper.environment = :foo
       @helper.environment.name.should == :foo
     end
 
     it "should accept an environment directly" do
       env = Puppet::Node::Environment.new :foo
       @helper.environment = env
       @helper.environment.name.should == :foo
     end
 
     it "should accept an environment as a string" do
       env = Puppet::Node::Environment.new "foo"
       @helper.environment = env
       @helper.environment.name.should == :foo
     end
   end
 
   describe "when performing initial import" do
     before do
       @parser = Puppet::Parser::Parser.new("test")
       Puppet::Parser::Parser.stubs(:new).returns @parser
       @env = Puppet::Node::Environment.new("env")
     end
 
     it "should set the parser's string to the 'code' setting and parse if code is available" do
       Puppet.settings[:code] = "my code"
       @parser.expects(:string=).with "my code"
       @parser.expects(:parse)
       @env.instance_eval { perform_initial_import }
     end
 
     it "should set the parser's file to the 'manifest' setting and parse if no code is available and the manifest is available" do
       filename = tmpfile('myfile')
       File.open(filename, 'w'){|f| }
       Puppet.settings[:manifest] = filename
       @parser.expects(:file=).with filename
       @parser.expects(:parse)
       @env.instance_eval { perform_initial_import }
     end
 
     it "should pass the manifest file to the parser even if it does not exist on disk" do
       filename = tmpfile('myfile')
       Puppet.settings[:code] = ""
       Puppet.settings[:manifest] = filename
       @parser.expects(:file=).with(filename).once
       @parser.expects(:parse).once
       @env.instance_eval { perform_initial_import }
     end
 
     it "should fail helpfully if there is an error importing" do
       File.stubs(:exist?).returns true
       @env.stubs(:known_resource_types).returns Puppet::Resource::TypeCollection.new(@env)
       @parser.expects(:file=).once
       @parser.expects(:parse).raises ArgumentError
       lambda { @env.instance_eval { perform_initial_import } }.should raise_error(Puppet::Error)
     end
 
     it "should not do anything if the ignore_import settings is set" do
       Puppet.settings[:ignoreimport] = true
       @parser.expects(:string=).never
       @parser.expects(:file=).never
       @parser.expects(:parse).never
       @env.instance_eval { perform_initial_import }
     end
 
     it "should mark the type collection as needing a reparse when there is an error parsing" do
       @parser.expects(:parse).raises Puppet::ParseError.new("Syntax error at ...")
       @env.stubs(:known_resource_types).returns Puppet::Resource::TypeCollection.new(@env)
 
       lambda { @env.instance_eval { perform_initial_import } }.should raise_error(Puppet::Error, /Syntax error at .../)
       @env.known_resource_types.require_reparse?.should be_true
     end
   end
 end
diff --git a/spec/unit/node/facts_spec.rb b/spec/unit/node/facts_spec.rb
index efaa76e12..4514607be 100755
--- a/spec/unit/node/facts_spec.rb
+++ b/spec/unit/node/facts_spec.rb
@@ -1,133 +1,129 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 require 'matchers/json'
 require 'puppet/node/facts'
 
 describe Puppet::Node::Facts, "when indirecting" do
   before do
     @facts = Puppet::Node::Facts.new("me")
   end
 
   it "should be able to convert all fact values to strings" do
     @facts.values["one"] = 1
     @facts.stringify
     @facts.values["one"].should == "1"
   end
 
   it "should add the node's certificate name as the 'clientcert' fact when adding local facts" do
     @facts.add_local_facts
     @facts.values["clientcert"].should == Puppet.settings[:certname]
   end
 
   it "should add the Puppet version as a 'clientversion' fact when adding local facts" do
     @facts.add_local_facts
     @facts.values["clientversion"].should == Puppet.version.to_s
   end
 
   it "should add the current environment as a fact if one is not set when adding local facts" do
     @facts.add_local_facts
     @facts.values["environment"].should == Puppet[:environment]
   end
 
   it "should not replace any existing environment fact when adding local facts" do
     @facts.values["environment"] = "foo"
     @facts.add_local_facts
     @facts.values["environment"].should == "foo"
   end
 
   it "should be able to downcase fact values" do
     Puppet.settings.stubs(:value).returns "eh"
     Puppet.settings.expects(:value).with(:downcasefacts).returns true
 
     @facts.values["one"] = "Two"
 
     @facts.downcase_if_necessary
     @facts.values["one"].should == "two"
   end
 
   it "should only try to downcase strings" do
     Puppet.settings.stubs(:value).returns "eh"
     Puppet.settings.expects(:value).with(:downcasefacts).returns true
 
     @facts.values["now"] = Time.now
 
     @facts.downcase_if_necessary
     @facts.values["now"].should be_instance_of(Time)
   end
 
   it "should not downcase facts if not configured to do so" do
     Puppet.settings.stubs(:value).returns "eh"
     Puppet.settings.expects(:value).with(:downcasefacts).returns false
 
     @facts.values["one"] = "Two"
     @facts.downcase_if_necessary
     @facts.values["one"].should == "Two"
   end
 
   describe "when indirecting" do
     before do
       @indirection = stub 'indirection', :request => mock('request'), :name => :facts
 
-      # We have to clear the cache so that the facts ask for our indirection stub,
-      # instead of anything that might be cached.
-      Puppet::Util::Cacher.expire
-
       @facts = Puppet::Node::Facts.new("me", "one" => "two")
     end
 
     it "should redirect to the specified fact store for storage" do
       Puppet::Node::Facts.stubs(:indirection).returns(@indirection)
       @indirection.expects(:save)
       Puppet::Node::Facts.indirection.save(@facts)
     end
 
     describe "when the Puppet application is 'master'" do
       it "should default to the 'yaml' terminus" do
         pending "Cannot test the behavior of defaults in defaults.rb"
         # Puppet::Node::Facts.indirection.terminus_class.should == :yaml
       end
     end
 
     describe "when the Puppet application is not 'master'" do
       it "should default to the 'facter' terminus" do
         pending "Cannot test the behavior of defaults in defaults.rb"
         # Puppet::Node::Facts.indirection.terminus_class.should == :facter
       end
     end
 
   end
 
   describe "when storing and retrieving" do
     it "should add metadata to the facts" do
       facts = Puppet::Node::Facts.new("me", "one" => "two", "three" => "four")
       facts.values[:_timestamp].should be_instance_of(Time)
     end
 
     describe "using pson" do
       before :each do
         @timestamp = Time.parse("Thu Oct 28 11:16:31 -0700 2010")
         @expiration = Time.parse("Thu Oct 28 11:21:31 -0700 2010")
       end
 
       it "should accept properly formatted pson" do
         pson = %Q({"name": "foo", "expiration": "#{@expiration}", "timestamp": "#{@timestamp}", "values": {"a": "1", "b": "2", "c": "3"}})
         format = Puppet::Network::FormatHandler.format('pson')
         facts = format.intern(Puppet::Node::Facts,pson)
         facts.name.should == 'foo'
         facts.expiration.should == @expiration
         facts.values.should == {'a' => '1', 'b' => '2', 'c' => '3', :_timestamp => @timestamp}
       end
 
       it "should generate properly formatted pson" do
         Time.stubs(:now).returns(@timestamp)
         facts = Puppet::Node::Facts.new("foo", {'a' => 1, 'b' => 2, 'c' => 3})
         facts.expiration = @expiration
         result = PSON.parse(facts.to_pson)
         result['name'].should == facts.name
         result['values'].should == facts.values.reject { |key, value| key.to_s =~ /_/ }
         result['timestamp'].should == facts.timestamp.to_s
         result['expiration'].should == facts.expiration.to_s
       end
     end
   end
 end
diff --git a/spec/unit/node_spec.rb b/spec/unit/node_spec.rb
index 339054d55..33bb4d1b2 100755
--- a/spec/unit/node_spec.rb
+++ b/spec/unit/node_spec.rb
@@ -1,199 +1,197 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 require 'matchers/json'
 
 describe Puppet::Node do
   describe "when managing its environment" do
     it "should use any set environment" do
       Puppet::Node.new("foo", :environment => "bar").environment.name.should == :bar
     end
 
     it "should support providing an actual environment instance" do
       Puppet::Node.new("foo", :environment => Puppet::Node::Environment.new(:bar)).environment.name.should == :bar
     end
 
     it "should determine its environment from its parameters if no environment is set" do
       Puppet::Node.new("foo", :parameters => {"environment" => :bar}).environment.name.should == :bar
     end
 
     it "should use the default environment if no environment is provided" do
       Puppet::Node.new("foo").environment.name.should == Puppet::Node::Environment.new.name
     end
 
     it "should always return an environment instance rather than a string" do
       Puppet::Node.new("foo").environment.should be_instance_of(Puppet::Node::Environment)
     end
 
     it "should allow the environment to be set after initialization" do
       node = Puppet::Node.new("foo")
       node.environment = :bar
       node.environment.name.should == :bar
     end
 
     it "should allow its environment to be set by parameters after initialization" do
       node = Puppet::Node.new("foo")
       node.parameters["environment"] = :bar
       node.environment.name.should == :bar
     end
   end
 end
 
 describe Puppet::Node, "when initializing" do
   before do
     @node = Puppet::Node.new("testnode")
   end
 
   it "should set the node name" do
     @node.name.should == "testnode"
   end
 
   it "should not allow nil node names" do
     proc { Puppet::Node.new(nil) }.should raise_error(ArgumentError)
   end
 
   it "should default to an empty parameter hash" do
     @node.parameters.should == {}
   end
 
   it "should default to an empty class array" do
     @node.classes.should == []
   end
 
   it "should note its creation time" do
     @node.time.should be_instance_of(Time)
   end
 
   it "should accept parameters passed in during initialization" do
     params = {"a" => "b"}
     @node = Puppet::Node.new("testing", :parameters => params)
     @node.parameters.should == params
   end
 
   it "should accept classes passed in during initialization" do
     classes = %w{one two}
     @node = Puppet::Node.new("testing", :classes => classes)
     @node.classes.should == classes
   end
 
   it "should always return classes as an array" do
     @node = Puppet::Node.new("testing", :classes => "myclass")
     @node.classes.should == ["myclass"]
   end
 end
 
 describe Puppet::Node, "when merging facts" do
   before do
     @node = Puppet::Node.new("testnode")
     Puppet::Node::Facts.indirection.stubs(:find).with(@node.name).returns(Puppet::Node::Facts.new(@node.name, "one" => "c", "two" => "b"))
   end
 
   it "should fail intelligently if it cannot find facts" do
     Puppet::Node::Facts.indirection.expects(:find).with(@node.name).raises "foo"
     lambda { @node.fact_merge }.should raise_error(Puppet::Error)
   end
 
   it "should prefer parameters already set on the node over facts from the node" do
     @node = Puppet::Node.new("testnode", :parameters => {"one" => "a"})
     @node.fact_merge
     @node.parameters["one"].should == "a"
   end
 
   it "should add passed parameters to the parameter list" do
     @node = Puppet::Node.new("testnode", :parameters => {"one" => "a"})
     @node.fact_merge
     @node.parameters["two"].should == "b"
   end
 
   it "should accept arbitrary parameters to merge into its parameters" do
     @node = Puppet::Node.new("testnode", :parameters => {"one" => "a"})
     @node.merge "two" => "three"
     @node.parameters["two"].should == "three"
   end
 
   it "should add the environment to the list of parameters" do
     Puppet.settings.stubs(:value).with(:environments).returns("one,two")
     Puppet.settings.stubs(:value).with(:environment).returns("one")
     @node = Puppet::Node.new("testnode", :environment => "one")
     @node.merge "two" => "three"
     @node.parameters["environment"].should == "one"
   end
 
   it "should not set the environment if it is already set in the parameters" do
     Puppet.settings.stubs(:value).with(:environments).returns("one,two")
     Puppet.settings.stubs(:value).with(:environment).returns("one")
     @node = Puppet::Node.new("testnode", :environment => "one")
     @node.merge "environment" => "two"
     @node.parameters["environment"].should == "two"
   end
 end
 
 describe Puppet::Node, "when indirecting" do
   it "should default to the 'plain' node terminus" do
     Puppet::Node.indirection.reset_terminus_class
 
     Puppet::Node.indirection.terminus_class.should == :plain
-
-    Puppet::Util::Cacher.expire
   end
 end
 
 describe Puppet::Node, "when generating the list of names to search through" do
   before do
     @node = Puppet::Node.new("foo.domain.com", :parameters => {"hostname" => "yay", "domain" => "domain.com"})
   end
 
   it "should return an array of names" do
     @node.names.should be_instance_of(Array)
   end
 
   describe "and the node name is fully qualified" do
     it "should contain an entry for each part of the node name" do
       @node.names.should be_include("foo.domain.com")
       @node.names.should be_include("foo.domain")
       @node.names.should be_include("foo")
     end
   end
 
   it "should include the node's fqdn" do
     @node.names.should be_include("yay.domain.com")
   end
 
   it "should combine and include the node's hostname and domain if no fqdn is available" do
     @node.names.should be_include("yay.domain.com")
   end
 
   it "should contain an entry for each name available by stripping a segment of the fqdn" do
     @node.parameters["fqdn"] = "foo.deep.sub.domain.com"
     @node.names.should be_include("foo.deep.sub.domain")
     @node.names.should be_include("foo.deep.sub")
   end
 
   describe "and :node_name is set to 'cert'" do
     before do
       Puppet.settings.stubs(:value).with(:strict_hostname_checking).returns false
       Puppet.settings.stubs(:value).with(:node_name).returns "cert"
     end
 
     it "should use the passed-in key as the first value" do
       @node.names[0].should == "foo.domain.com"
     end
 
     describe "and strict hostname checking is enabled" do
       it "should only use the passed-in key" do
         Puppet.settings.expects(:value).with(:strict_hostname_checking).returns true
         @node.names.should == ["foo.domain.com"]
       end
     end
   end
 
   describe "and :node_name is set to 'facter'" do
     before do
       Puppet.settings.stubs(:value).with(:strict_hostname_checking).returns false
       Puppet.settings.stubs(:value).with(:node_name).returns "facter"
     end
 
     it "should use the node's 'hostname' fact as the first value" do
       @node.names[0].should == "yay"
     end
   end
 end
diff --git a/spec/unit/transaction/report_spec.rb b/spec/unit/transaction/report_spec.rb
index 033c4c740..0a6ab8b5f 100755
--- a/spec/unit/transaction/report_spec.rb
+++ b/spec/unit/transaction/report_spec.rb
@@ -1,312 +1,308 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 require 'puppet/transaction/report'
 
 describe Puppet::Transaction::Report do
   include PuppetSpec::Files
   before do
     Puppet::Util::Storage.stubs(:store)
   end
 
   it "should set its host name to the node_name_value" do
     Puppet[:node_name_value] = 'mynode'
     Puppet::Transaction::Report.new("apply").host.should == "mynode"
   end
 
   it "should return its host name as its name" do
     r = Puppet::Transaction::Report.new("apply")
     r.name.should == r.host
   end
 
   it "should create an initialization timestamp" do
     Time.expects(:now).returns "mytime"
     Puppet::Transaction::Report.new("apply").time.should == "mytime"
   end
 
   it "should take a 'kind' as an argument" do
     Puppet::Transaction::Report.new("inspect").kind.should == "inspect"
   end
 
   it "should take a 'configuration_version' as an argument" do
     Puppet::Transaction::Report.new("inspect", "some configuration version").configuration_version.should == "some configuration version"
   end
 
   it "should be able to set configuration_version" do
     report = Puppet::Transaction::Report.new("inspect")
     report.configuration_version = "some version"
     report.configuration_version.should == "some version"
   end
 
   it "should not include whits" do
     Puppet::FileBucket::File.indirection.stubs(:save)
 
     filename = tmpfile('whit_test')
     file = Puppet::Type.type(:file).new(:path => filename)
 
     catalog = Puppet::Resource::Catalog.new
     catalog.add_resource(file)
 
     report = Puppet::Transaction::Report.new("apply")
 
     catalog.apply(:report => report)
     report.finalize_report
 
     report.resource_statuses.values.any? {|res| res.resource_type =~ /whit/i}.should be_false
     report.metrics['time'].values.any? {|metric| metric.first =~ /whit/i}.should be_false
   end
 
   describe "when accepting logs" do
     before do
       @report = Puppet::Transaction::Report.new("apply")
     end
 
     it "should add new logs to the log list" do
       @report << "log"
       @report.logs[-1].should == "log"
     end
 
     it "should return self" do
       r = @report << "log"
       r.should equal(@report)
     end
   end
 
   describe "when accepting resource statuses" do
     before do
       @report = Puppet::Transaction::Report.new("apply")
     end
 
     it "should add each status to its status list" do
       status = stub 'status', :resource => "foo"
       @report.add_resource_status status
       @report.resource_statuses["foo"].should equal(status)
     end
   end
 
   describe "when using the indirector" do
     it "should redirect :save to the indirection" do
       Facter.stubs(:value).returns("eh")
       @indirection = stub 'indirection', :name => :report
       Puppet::Transaction::Report.stubs(:indirection).returns(@indirection)
       report = Puppet::Transaction::Report.new("apply")
       @indirection.expects(:save)
       Puppet::Transaction::Report.indirection.save(report)
     end
 
     it "should default to the 'processor' terminus" do
       Puppet::Transaction::Report.indirection.terminus_class.should == :processor
     end
 
     it "should delegate its name attribute to its host method" do
       report = Puppet::Transaction::Report.new("apply")
       report.expects(:host).returns "me"
       report.name.should == "me"
     end
-
-    after do
-      Puppet::Util::Cacher.expire
-    end
   end
 
   describe "when computing exit status" do
     it "should produce 2 if changes are present" do
       report = Puppet::Transaction::Report.new("apply")
       report.add_metric("changes", {"total" => 1})
       report.add_metric("resources", {"failed" => 0})
       report.exit_status.should == 2
     end
 
     it "should produce 4 if failures are present" do
       report = Puppet::Transaction::Report.new("apply")
       report.add_metric("changes", {"total" => 0})
       report.add_metric("resources", {"failed" => 1})
       report.exit_status.should == 4
     end
 
     it "should produce 6 if both changes and failures are present" do
       report = Puppet::Transaction::Report.new("apply")
       report.add_metric("changes", {"total" => 1})
       report.add_metric("resources", {"failed" => 1})
       report.exit_status.should == 6
     end
   end
 
   describe "before finalizing the report" do
     it "should have a status of 'failed'" do
       report = Puppet::Transaction::Report.new("apply")
       report.status.should == 'failed'
     end
   end
 
   describe "when finalizing the report" do
     before do
       @report = Puppet::Transaction::Report.new("apply")
     end
 
     def metric(name, value)
       if metric = @report.metrics[name.to_s]
         metric[value]
       else
         nil
       end
     end
 
     def add_statuses(count, type = :file)
       count.times do |i|
         status = Puppet::Resource::Status.new(Puppet::Type.type(type).new(:title => make_absolute("/my/path#{i}")))
         yield status if block_given?
         @report.add_resource_status status
       end
     end
 
 
     [:time, :resources, :changes, :events].each do |type|
       it "should add #{type} metrics" do
         @report.finalize_report
         @report.metrics[type.to_s].should be_instance_of(Puppet::Transaction::Metric)
       end
     end
 
     describe "for resources" do
       it "should provide the total number of resources" do
         add_statuses(3)
 
         @report.finalize_report
         metric(:resources, "total").should == 3
       end
 
       Puppet::Resource::Status::STATES.each do |state|
         it "should provide the number of #{state} resources as determined by the status objects" do
           add_statuses(3) { |status| status.send(state.to_s + "=", true) }
 
           @report.finalize_report
           metric(:resources, state.to_s).should == 3
         end
       end
 
       it "should mark the report as 'failed' if there are failing resources" do
         add_statuses(1) { |status| status.failed = true }
         @report.finalize_report
         @report.status.should == 'failed'
       end
     end
 
     describe "for changes" do
       it "should provide the number of changes from the resource statuses and mark the report as 'changed'" do
         add_statuses(3) { |status| 3.times { status << Puppet::Transaction::Event.new(:status => 'success') } }
         @report.finalize_report
         metric(:changes, "total").should == 9
         @report.status.should == 'changed'
       end
 
       it "should provide a total even if there are no changes, and mark the report as 'unchanged'" do
         @report.finalize_report
         metric(:changes, "total").should == 0
         @report.status.should == 'unchanged'
       end
     end
 
     describe "for times" do
       it "should provide the total amount of time for each resource type", :fails_on_windows => true do
         add_statuses(3, :file) do |status|
           status.evaluation_time = 1
         end
         add_statuses(3, :exec) do |status|
           status.evaluation_time = 2
         end
         add_statuses(3, :mount) do |status|
           status.evaluation_time = 3
         end
 
         @report.finalize_report
 
         metric(:time, "file").should == 3
         metric(:time, "exec").should == 6
         metric(:time, "mount").should == 9
       end
 
       it "should add any provided times from external sources" do
         @report.add_times :foobar, 50
         @report.finalize_report
         metric(:time, "foobar").should == 50
       end
 
       it "should have a total time" do
         add_statuses(3, :file) do |status|
           status.evaluation_time = 1.25
         end
         @report.add_times :config_retrieval, 0.5
         @report.finalize_report
         metric(:time, "total").should == 4.25
       end
     end
 
     describe "for events" do
       it "should provide the total number of events" do
         add_statuses(3) do |status|
           3.times { |i| status.add_event(Puppet::Transaction::Event.new :status => 'success') }
         end
         @report.finalize_report
         metric(:events, "total").should == 9
       end
 
       it "should provide the total even if there are no events" do
         @report.finalize_report
         metric(:events, "total").should == 0
       end
 
       Puppet::Transaction::Event::EVENT_STATUSES.each do |status_name|
         it "should provide the number of #{status_name} events" do
           add_statuses(3) do |status|
             3.times do |i|
               event = Puppet::Transaction::Event.new
               event.status = status_name
               status.add_event(event)
             end
           end
 
           @report.finalize_report
           metric(:events, status_name).should == 9
         end
       end
     end
   end
 
   describe "when producing a summary" do
     before do
       resource = Puppet::Type.type(:notify).new(:name => "testing")
       catalog = Puppet::Resource::Catalog.new
       catalog.add_resource resource
       trans = catalog.apply
 
       @report = trans.report
       @report.finalize_report
     end
 
     %w{changes time resources events}.each do |main|
       it "should include the key #{main} in the raw summary hash" do
         @report.raw_summary.should be_key main
       end
     end
 
     it "should include the last run time in the raw summary hash" do
       Time.stubs(:now).returns(Time.utc(2010,11,10,12,0,24))
       @report.raw_summary["time"]["last_run"].should == 1289390424
     end
 
     %w{Changes Total Resources Time Events}.each do |main|
       it "should include information on #{main} in the textual summary" do
         @report.summary.should be_include(main)
       end
     end
   end
 
   describe "when outputting yaml" do
     it "should not include @external_times" do
       report = Puppet::Transaction::Report.new('apply')
       report.add_times('config_retrieval', 1.0)
       report.to_yaml_properties.should_not include('@external_times')
     end
   end
 end
diff --git a/spec/unit/util/cacher_spec.rb b/spec/unit/util/cacher_spec.rb
index fe93afd2b..16414c858 100755
--- a/spec/unit/util/cacher_spec.rb
+++ b/spec/unit/util/cacher_spec.rb
@@ -1,184 +1,107 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 require 'puppet/util/cacher'
 
-class ExpirerTest
-  include Puppet::Util::Cacher::Expirer
-end
-
 class CacheTest
-  @@init_count = 0
-
-  include Puppet::Util::Cacher
-  cached_attr(:instance_cache) { Time.now }
-end
+  @@count = 0
 
-describe Puppet::Util::Cacher::Expirer do
-  before do
-    @expirer = ExpirerTest.new
+  def self.count
+    @@count
   end
 
-  it "should be able to test whether a timestamp is expired" do
-    @expirer.should respond_to(:dependent_data_expired?)
-  end
-
-  it "should be able to expire all values" do
-    @expirer.should respond_to(:expire)
-  end
-
-  it "should consider any value to be valid if it has never been expired" do
-    @expirer.should_not be_dependent_data_expired(Time.now)
-  end
+  include Puppet::Util::Cacher
 
-  it "should consider any value created after expiration to be expired" do
-    @expirer.expire
-    @expirer.should be_dependent_data_expired(Time.now - 1)
+  cached_attr(:instance_cache, 10) do
+    @@count += 1
+    {:number => @@count}
   end
 end
 
 describe Puppet::Util::Cacher do
-  it "should be extended with the Expirer module" do
-    Puppet::Util::Cacher.singleton_class.ancestors.should be_include(Puppet::Util::Cacher::Expirer)
+  before :each do
+    CacheTest.set_attr_ttl(:instance_cache, 10)
+    @object = CacheTest.new
   end
 
-  it "should support defining cached attributes", :'fails_on_ruby_1.9.2' => true do
-    CacheTest.methods.should be_include("cached_attr")
+  it "should return a value calculated from the provided block" do
+    @object.instance_cache.should == {:number => CacheTest.count}
   end
 
-  it "should default to the Cacher module as its expirer" do
-    CacheTest.new.expirer.should equal(Puppet::Util::Cacher)
+  it "should return the cached value from the getter every time if the value is not expired" do
+    @object.instance_cache.should equal(@object.instance_cache)
   end
 
-  describe "when using cached attributes" do
-    before do
-      @expirer = ExpirerTest.new
-      @object = CacheTest.new
+  it "should regenerate and return a new value using the provided block if the value has expired" do
+    initial = @object.instance_cache
 
-      @object.stubs(:expirer).returns @expirer
-    end
-
-    it "should create a getter for the cached attribute" do
-      @object.should respond_to(:instance_cache)
-    end
-
-    it "should return a value calculated from the provided block" do
-      time = Time.now
-      Time.stubs(:now).returns time
-      @object.instance_cache.should equal(time)
-    end
+    # Ensure the value is expired immediately
+    CacheTest.set_attr_ttl(:instance_cache, -10)
+    @object.send(:set_expiration, :instance_cache)
 
-    it "should return the cached value from the getter every time if the value is not expired" do
-      @object.instance_cache.should equal(@object.instance_cache)
-    end
-
-    it "should regenerate and return a new value using the provided block if the value has been expired" do
-      value = @object.instance_cache
-      @expirer.expire
-      @object.instance_cache.should_not equal(value)
-    end
+    @object.instance_cache.should_not equal(initial)
+  end
 
-    it "should be able to trigger expiration on its expirer" do
-      @expirer.expects(:expire)
-      @object.expire
-    end
+  it "should be able to cache false values" do
+    @object.expects(:init_instance_cache).once.returns false
+    @object.instance_cache.should be_false
+    @object.instance_cache.should be_false
+  end
 
-    it "should do nothing when asked to expire when no expirer is available" do
-      cacher = CacheTest.new
-      class << cacher
-        def expirer
-          nil
-        end
-      end
-      lambda { cacher.expire }.should_not raise_error
-    end
+  it "should cache values again after expiration" do
+    initial = @object.instance_cache
 
-    it "should be able to cache false values" do
-      @object.expects(:init_instance_cache).returns false
-      @object.instance_cache.should be_false
-      @object.instance_cache.should be_false
-    end
+    # Ensure the value is expired immediately
+    CacheTest.set_attr_ttl(:instance_cache, -10)
+    @object.send(:set_expiration, :instance_cache)
 
-    it "should cache values again after expiration" do
-      @object.instance_cache
-      @expirer.expire
-      @object.instance_cache.should equal(@object.instance_cache)
-    end
+    # Reset ttl so this new value doesn't get expired
+    CacheTest.set_attr_ttl(:instance_cache, 10)
+    after_expiration = @object.instance_cache
 
-    it "should always consider a value expired if it has no expirer" do
-      @object.stubs(:expirer).returns nil
-      @object.instance_cache.should_not equal(@object.instance_cache)
-    end
+    after_expiration.should_not == initial
+    @object.instance_cache.should == after_expiration
+  end
 
-    it "should allow writing of the attribute" do
-      @object.should respond_to(:instance_cache=)
-    end
+  it "should allow writing of the attribute" do
+    initial = @object.instance_cache
 
-    it "should correctly configure timestamps for expiration when the cached attribute is written to" do
-      @object.instance_cache = "foo"
-      @expirer.expire
-      @object.instance_cache.should_not == "foo"
-    end
+    @object.instance_cache = "another value"
+    @object.instance_cache.should == "another value"
+  end
 
-    it "should allow specification of a ttl for cached attributes" do
-      klass = Class.new do
-        include Puppet::Util::Cacher
-      end
+  it "should update the expiration when the cached attribute is set manually" do
+    # Freeze time
+    now = Time.now
+    Time.stubs(:now).returns now
 
-      klass.cached_attr(:myattr, :ttl => 5)  { Time.now }
+    @object.instance_cache
 
-      klass.attr_ttl(:myattr).should == 5
-    end
+    # Set expiration to something far in the future
+    CacheTest.set_attr_ttl(:instance_cache, 60)
+    @object.send(:set_expiration, :instance_cache)
 
-    it "should allow specification of a ttl as a string" do
-      klass = Class.new do
-        include Puppet::Util::Cacher
-      end
+    CacheTest.set_attr_ttl(:instance_cache, 10)
 
-      klass.cached_attr(:myattr, :ttl => "5")  { Time.now }
+    @object.instance_cache = "foo"
+    @object.instance_variable_get(:@attr_expirations)[:instance_cache].should == now + 10
+  end
 
-      klass.attr_ttl(:myattr).should == 5
+  it "should allow specification of a ttl as a string" do
+    klass = Class.new do
+      include Puppet::Util::Cacher
     end
 
-    it "should fail helpfully if the ttl cannot be converted to an integer" do
-      klass = Class.new do
-        include Puppet::Util::Cacher
-      end
-
-      lambda { klass.cached_attr(:myattr, :ttl => "yep")  { Time.now } }.should raise_error(ArgumentError)
-    end
+    klass.cached_attr(:myattr, "5")  { 10 }
 
-    it "should not check for a ttl expiration if the class does not support that method" do
-      klass = Class.new do
-        extend Puppet::Util::Cacher
-      end
+    klass.attr_ttl(:myattr).should == 5
+  end
 
-      klass.singleton_class.cached_attr(:myattr) { "eh" }
-      klass.myattr
+  it "should fail helpfully if the ttl cannot be converted to an integer" do
+    klass = Class.new do
+      include Puppet::Util::Cacher
     end
 
-    it "should automatically expire cached attributes whose ttl has expired, even if no expirer is present" do
-      klass = Class.new do
-        def self.to_s
-          "CacheTestClass"
-        end
-        include Puppet::Util::Cacher
-        attr_accessor :value
-      end
-
-      klass.cached_attr(:myattr, :ttl => 5)  { self.value += 1; self.value }
-
-      now = Time.now
-      later = Time.now + 15
-
-      instance = klass.new
-      instance.value = 0
-      instance.myattr.should == 1
-
-      Time.expects(:now).returns later
-
-      # This call should get the new Time value, which should expire the old value
-      instance.myattr.should == 2
-    end
+    lambda { klass.cached_attr(:myattr, "yep") { 10 } }.should raise_error(ArgumentError)
   end
 end
diff --git a/test/lib/puppettest.rb b/test/lib/puppettest.rb
index a60092cf7..6bae80a01 100755
--- a/test/lib/puppettest.rb
+++ b/test/lib/puppettest.rb
@@ -1,319 +1,318 @@
 # Add .../test/lib
 testlib = File.expand_path(File.dirname(__FILE__))
 $LOAD_PATH.unshift(testlib) unless $LOAD_PATH.include?(testlib)
 # Add .../lib
 mainlib = File.expand_path(File.join(File.dirname(__FILE__), '../../lib'))
 $LOAD_PATH.unshift(mainlib) unless $LOAD_PATH.include?(mainlib)
 
 require 'puppet'
 require 'mocha'
 
 # Only load the test/unit class if we're not in the spec directory.
 # Else we get the bogus 'no tests, no failures' message.
 unless Dir.getwd =~ /spec/
   require 'test/unit'
 end
 
 # Yay; hackish but it works
 if ARGV.include?("-d")
   ARGV.delete("-d")
   $console = true
 end
 
 require File.expand_path(File.join(File.dirname(__FILE__), '../../spec/monkey_patches/publicize_methods'))
 
 module PuppetTest
   # These need to be here for when rspec tests use these
   # support methods.
   @@tmpfiles = []
 
   # Munge cli arguments, so we can enable debugging if we want
   # and so we can run just specific methods.
   def self.munge_argv
     require 'getoptlong'
 
 
       result = GetoptLong.new(
 
         [ "--debug",    "-d", GetoptLong::NO_ARGUMENT       ],
         [ "--resolve",  "-r", GetoptLong::REQUIRED_ARGUMENT ],
         [ "-n",               GetoptLong::REQUIRED_ARGUMENT ],
 
         [ "--help",     "-h", GetoptLong::NO_ARGUMENT       ]
     )
 
     usage = "USAGE: TESTOPTS='[-n <method> -n <method> ...] [-d]' rake [target] [target] ..."
 
     opts = []
 
     dir = method = nil
     result.each { |opt,arg|
       case opt
       when "--resolve"
         dir, method = arg.split(",")
       when "--debug"
         $puppet_debug = true
         Puppet::Util::Log.level = :debug
         Puppet::Util::Log.newdestination(:console)
       when "--help"
         puts usage
         exit
       else
         opts << opt << arg
       end
     }
     suites = nil
 
     args = ARGV.dup
 
     # Reset the options, so the test suite can deal with them (this is
     # what makes things like '-n' work).
     opts.each { |o| ARGV << o }
 
     args
   end
 
   # Find the root of the Puppet tree; this is not the test directory, but
   # the parent of that dir.
   def basedir(*list)
     unless defined?(@@basedir)
       Dir.chdir(File.dirname(__FILE__)) do
         @@basedir = File.dirname(File.dirname(Dir.getwd))
       end
     end
     if list.empty?
       @@basedir
     else
       File.join(@@basedir, *list)
     end
   end
 
   def datadir(*list)
     File.join(basedir, "test", "data", *list)
   end
 
   def exampledir(*args)
     @@exampledir = File.join(basedir, "examples") unless defined?(@@exampledir)
 
     if args.empty?
       return @@exampledir
     else
       return File.join(@@exampledir, *args)
     end
   end
 
   module_function :basedir, :datadir, :exampledir
 
   def cleanup(&block)
     @@cleaners << block
   end
 
   # Rails clobbers RUBYLIB, thanks
   def libsetup
     curlibs = ENV["RUBYLIB"].split(":")
     $LOAD_PATH.reject do |dir| dir =~ /^\/usr/ end.each do |dir|
       curlibs << dir unless curlibs.include?(dir)
     end
 
     ENV["RUBYLIB"] = curlibs.join(":")
   end
 
   def logcollector
     collector = []
     Puppet::Util::Log.newdestination(collector)
     cleanup do
       Puppet::Util::Log.close(collector)
     end
     collector
   end
 
   def rake?
     $0 =~ /test_loader/
   end
 
   # Redirect stdout and stderr
   def redirect
     @stderr = tempfile
     @stdout = tempfile
     $stderr = File.open(@stderr, "w")
     $stdout = File.open(@stdout, "w")
 
     cleanup do
       $stderr = STDERR
       $stdout = STDOUT
     end
   end
 
   def setup
     ENV["PATH"] += File::PATH_SEPARATOR + "/usr/sbin" unless ENV["PATH"].split(File::PATH_SEPARATOR).include?("/usr/sbin")
     @memoryatstart = Puppet::Util.memory
     if defined?(@@testcount)
       @@testcount += 1
     else
       @@testcount = 0
     end
 
 
       @configpath = File.join(
         tmpdir,
 
       "configdir" + @@testcount.to_s + "/"
     )
 
     unless defined? $user and $group
       $user = nonrootuser.uid.to_s
       $group = nonrootgroup.gid.to_s
     end
 
     Puppet.settings.clear
     Puppet[:user] = $user
     Puppet[:group] = $group
 
     Puppet[:confdir] = @configpath
     Puppet[:vardir] = @configpath
 
     Dir.mkdir(@configpath) unless File.exists?(@configpath)
 
     @@tmpfiles << @configpath << tmpdir
     @@tmppids = []
 
     @@cleaners = []
 
     @logs = []
 
     # If we're running under rake, then disable debugging and such.
     #if rake? or ! Puppet[:debug]
     #if defined?($puppet_debug) or ! rake?
       Puppet[:color] = false if textmate?
       Puppet::Util::Log.newdestination(Puppet::Test::LogCollector.new(@logs))
       if defined? $console
         Puppet.info @method_name
         Puppet::Util::Log.newdestination(:console)
         Puppet[:trace] = true
       end
       Puppet::Util::Log.level = :debug
       #$VERBOSE = 1
     #else
     #    Puppet::Util::Log.close
     #    Puppet::Util::Log.newdestination(@logs)
     #    Puppet[:httplog] = tempfile
     #end
 
     Puppet[:ignoreschedules] = true
 
     #@start = Time.now
 
     #Facter.stubs(:value).returns "stubbed_value"
     #Facter.stubs(:to_hash).returns({})
   end
 
   def tempfile(suffix = '')
     if defined?(@@tmpfilenum)
       @@tmpfilenum += 1
     else
       @@tmpfilenum = 1
     end
 
     f = File.join(self.tmpdir, "tempfile_" + @@tmpfilenum.to_s + suffix)
     @@tmpfiles ||= []
     @@tmpfiles << f
     f
   end
 
   def textmate?
     !!ENV["TM_FILENAME"]
   end
 
   def tstdir
     dir = tempfile
     Dir.mkdir(dir)
     dir
   end
 
   def tmpdir
     unless @tmpdir
       @tmpdir = case Facter["operatingsystem"].value
         when "Darwin"; "/private/tmp"
         when "SunOS"; "/var/tmp"
         else
           "/tmp"
             end
 
 
       @tmpdir = File.join(@tmpdir, "puppettesting#{Process.pid}")
 
       unless File.exists?(@tmpdir)
         FileUtils.mkdir_p(@tmpdir)
         File.chmod(01777, @tmpdir)
       end
     end
     @tmpdir
   end
 
   def remove_tmp_files
     @@tmpfiles.each { |file|
       unless file =~ /tmp/
         puts "Not deleting tmpfile #{file}"
         next
       end
       if FileTest.exists?(file)
         system("chmod -R 755 #{file}")
         system("rm -rf #{file}")
       end
     }
     @@tmpfiles.clear
   end
 
   def teardown
     #@stop = Time.now
     #File.open("/tmp/test_times.log", ::File::WRONLY|::File::CREAT|::File::APPEND) { |f| f.puts "%0.4f %s %s" % [@stop - @start, @method_name, self.class] }
     @@cleaners.each { |cleaner| cleaner.call }
 
     remove_tmp_files
 
     @@tmppids.each { |pid|
       %x{kill -INT #{pid} 2>/dev/null}
     }
 
     @@tmppids.clear
 
     Puppet::Util::Storage.clear
     Puppet.clear
     Puppet.settings.clear
-    Puppet::Util::Cacher.expire
 
     @memoryatend = Puppet::Util.memory
     diff = @memoryatend - @memoryatstart
 
     Puppet.info "#{self.class}##{@method_name} memory growth (#{@memoryatstart} to #{@memoryatend}): #{diff}" if diff > 1000
 
     # reset all of the logs
     Puppet::Util::Log.close_all
     @logs.clear
 
     # Just in case there are processes waiting to die...
     require 'timeout'
 
     begin
       Timeout::timeout(5) do
         Process.waitall
       end
     rescue Timeout::Error
       # just move on
     end
   end
 
   def logstore
     @logs = []
     Puppet::Util::Log.newdestination(Puppet::Test::LogCollector.new(@logs))
   end
 end
 
 require 'puppettest/support'
 require 'puppettest/filetesting'
 require 'puppettest/fakes'
 require 'puppettest/exetest'
 require 'puppettest/parsertesting'
 require 'puppettest/servertest'
 require 'puppettest/testcase'