diff --git a/lib/puppet/indirector/indirection.rb b/lib/puppet/indirector/indirection.rb
index 7ac214cd0..2a54ecc24 100644
--- a/lib/puppet/indirector/indirection.rb
+++ b/lib/puppet/indirector/indirection.rb
@@ -1,304 +1,314 @@
 require 'puppet/util/docs'
 require 'puppet/indirector/envelope'
 require 'puppet/indirector/request'
 require 'puppet/util/cacher'
 
 # The class that connects functional classes with their different collection
 # back-ends.  Each indirection has a set of associated terminus classes,
 # each of which is a subclass of Puppet::Indirector::Terminus.
 class Puppet::Indirector::Indirection
     include Puppet::Util::Cacher
     include Puppet::Util::Docs
 
     @@indirections = []
 
     # Find an indirection by name.  This is provided so that Terminus classes
     # can specifically hook up with the indirections they are associated with.
     def self.instance(name)
         @@indirections.find { |i| i.name == name }
     end
 
     # Return a list of all known indirections.  Used to generate the
     # reference.
     def self.instances
         @@indirections.collect { |i| i.name }
     end
     
     # Find an indirected model by name.  This is provided so that Terminus classes
     # can specifically hook up with the indirections they are associated with.
     def self.model(name)
         return nil unless match = @@indirections.find { |i| i.name == name }
         match.model
     end
     
     attr_accessor :name, :model
 
     # Create and return our cache terminus.
     def cache
         raise(Puppet::DevError, "Tried to cache when no cache class was set") unless cache_class
         terminus(cache_class)
     end
 
     # Should we use a cache?
     def cache?
         cache_class ? true : false
     end
 
     attr_reader :cache_class
     # Define a terminus class to be used for caching.
     def cache_class=(class_name)
         validate_terminus_class(class_name) if class_name
         @cache_class = class_name
     end
 
     # This is only used for testing.
     def delete
         @@indirections.delete(self) if @@indirections.include?(self)
     end
 
     # Set the time-to-live for instances created through this indirection.
     def ttl=(value)
         raise ArgumentError, "Indirection TTL must be an integer" unless value.is_a?(Fixnum)
         @ttl = value
     end
 
     # Default to the runinterval for the ttl.
     def ttl
         unless defined?(@ttl)
             @ttl = Puppet[:runinterval].to_i
         end
         @ttl
     end
 
     # Calculate the expiration date for a returned instance.
     def expiration
         Time.now + ttl
     end
 
     # Generate the full doc string.
     def doc
         text = ""
 
         if defined? @doc and @doc
             text += scrub(@doc) + "\n\n"
         end
 
         if s = terminus_setting()
             text += "* **Terminus Setting**: %s" % terminus_setting
         end
 
         text
     end
 
     def initialize(model, name, options = {})
         @model = model
         @name = name
 
         @cache_class = nil
         @terminus_class = nil
 
         raise(ArgumentError, "Indirection %s is already defined" % @name) if @@indirections.find { |i| i.name == @name }
         @@indirections << self
 
         if mod = options[:extend]
             extend(mod)
             options.delete(:extend)
         end
 
         # This is currently only used for cache_class and terminus_class.
         options.each do |name, value|
             begin
                 send(name.to_s + "=", value)
             rescue NoMethodError
                 raise ArgumentError, "%s is not a valid Indirection parameter" % name
             end
         end
     end
 
     # Set up our request object.
     def request(method, key, arguments = nil)
         Puppet::Indirector::Request.new(self.name, method, key, arguments)
     end
 
     # Return the singleton terminus for this indirection.
     def terminus(terminus_name = nil)
         # Get the name of the terminus.
         unless terminus_name ||= terminus_class
             raise Puppet::DevError, "No terminus specified for %s; cannot redirect" % self.name
         end
         
         return termini[terminus_name] ||= make_terminus(terminus_name)
     end
 
     # This can be used to select the terminus class.
     attr_accessor :terminus_setting
 
     # Determine the terminus class.
     def terminus_class
         unless @terminus_class
             if setting = self.terminus_setting
                 self.terminus_class = Puppet.settings[setting].to_sym
             else
                 raise Puppet::DevError, "No terminus class nor terminus setting was provided for indirection %s" % self.name
             end
         end
         @terminus_class
     end
 
     # Specify the terminus class to use.
     def terminus_class=(klass)
         validate_terminus_class(klass)
         @terminus_class = klass
     end
 
     # This is used by terminus_class= and cache=.
     def validate_terminus_class(terminus_class)
         unless terminus_class and terminus_class.to_s != ""
             raise ArgumentError, "Invalid terminus name %s" % terminus_class.inspect
         end
         unless Puppet::Indirector::Terminus.terminus_class(self.name, terminus_class)
             raise ArgumentError, "Could not find terminus %s for indirection %s" % [terminus_class, self.name]
         end
     end
 
     # Expire a cached object, if one is cached.  Note that we don't actually
     # remove it, we expire it and write it back out to disk.  This way people
     # can still use the expired object if they want.
     def expire(key, *args)
         request = request(:expire, key, *args)
 
         return nil unless cache?
 
         return nil unless instance = cache.find(request(:find, key, *args))
 
         Puppet.info "Expiring the %s cache of %s" % [self.name, instance.name]
 
         # Set an expiration date in the past
         instance.expiration = Time.now - 60
 
         cache.save(request(:save, instance, *args))
     end
 
     # Search for an instance in the appropriate terminus, caching the
     # results if caching is configured..
     def find(key, *args)
         request = request(:find, key, *args)
         terminus = prepare(request)
 
-        # See if our instance is in the cache and up to date.
-        if cache? and ! request.ignore_cache? and cached = cache.find(request)
-            if cached.expired?
-                Puppet.info "Not using expired %s for %s from cache; expired at %s" % [self.name, request.key, cached.expiration]
-            else
-                Puppet.debug "Using cached %s for %s" % [self.name, request.key]
-                return cached
+        begin
+            if result = find_in_cache(request)
+                return result
             end
+        rescue => detail
+            Puppet.err "Cached %s for %s failed: %s" % [self.name, request.key, detail]
         end
 
         # Otherwise, return the result from the terminus, caching if appropriate.
         if ! request.ignore_terminus? and result = terminus.find(request)
             result.expiration ||= self.expiration
             if cache? and request.use_cache?
                 Puppet.info "Caching %s for %s" % [self.name, request.key]
                 cache.save request(:save, result, *args)
             end
 
             return result
         end
 
         return nil
     end
 
+    def find_in_cache(request)
+        # See if our instance is in the cache and up to date.
+        return nil unless cache? and ! request.ignore_cache? and cached = cache.find(request)
+        if cached.expired?
+            Puppet.info "Not using expired %s for %s from cache; expired at %s" % [self.name, request.key, cached.expiration]
+            return nil
+        end
+
+        Puppet.debug "Using cached %s for %s" % [self.name, request.key]
+        return cached
+    end
+
     # Remove something via the terminus.
     def destroy(key, *args)
         request = request(:destroy, key, *args)
         terminus = prepare(request)
 
         result = terminus.destroy(request)
 
         if cache? and cached = cache.find(request(:find, key, *args))
             # Reuse the existing request, since it's equivalent.
             cache.destroy(request)
         end
 
         result
     end
 
     # Search for more than one instance.  Should always return an array.
     def search(key, *args)
         request = request(:search, key, *args)
         terminus = prepare(request)
 
         if result = terminus.search(request)
             raise Puppet::DevError, "Search results from terminus %s are not an array" % terminus.name unless result.is_a?(Array)
             result.each do |instance|
                 instance.expiration ||= self.expiration
             end
             return result
         end
     end
 
     # Save the instance in the appropriate terminus.  This method is
     # normally an instance method on the indirected class.
     def save(instance, *args)
         request = request(:save, instance, *args)
         terminus = prepare(request)
 
         result = terminus.save(request)
 
         # If caching is enabled, save our document there
         cache.save(request) if cache?
 
         result
     end
 
     private
 
     # Check authorization if there's a hook available; fail if there is one
     # and it returns false.
     def check_authorization(request, terminus)
         # At this point, we're assuming authorization makes no sense without
         # client information.
         return unless request.node
 
         # This is only to authorize via a terminus-specific authorization hook.
         return unless terminus.respond_to?(:authorized?)
 
         unless terminus.authorized?(request)
             msg = "Not authorized to call %s on %s" % [request.method, request.to_s]
             unless request.options.empty?
                 msg += " with %s" % request.options.inspect
             end
             raise ArgumentError, msg
         end
     end
 
     # Setup a request, pick the appropriate terminus, check the request's authorization, and return it.
     def prepare(request)
         # Pick our terminus.
         if respond_to?(:select_terminus)
             unless terminus_name = select_terminus(request)
                 raise ArgumentError, "Could not determine appropriate terminus for %s" % request
             end
         else
             terminus_name = terminus_class
         end
 
         dest_terminus = terminus(terminus_name)
         check_authorization(request, dest_terminus)
 
         return dest_terminus
     end
 
     # Create a new terminus instance.
     def make_terminus(terminus_class)
         # Load our terminus class.
         unless klass = Puppet::Indirector::Terminus.terminus_class(self.name, terminus_class)
             raise ArgumentError, "Could not find terminus %s for indirection %s" % [terminus_class, self.name]
         end
         return klass.new
     end
 
     # Cache our terminus instances indefinitely, but make it easy to clean them up.
     cached_attr(:termini) { Hash.new }
 end
diff --git a/spec/unit/indirector/indirection.rb b/spec/unit/indirector/indirection.rb
index dc4157fd2..a8bc8ba99 100755
--- a/spec/unit/indirector/indirection.rb
+++ b/spec/unit/indirector/indirection.rb
@@ -1,772 +1,787 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../../spec_helper'
 
 require 'puppet/indirector/indirection'
 
 describe "Indirection Delegator", :shared => true 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
 
 describe "Delegation Authorizer", :shared => true 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.metaclass.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 = 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
 
             @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 default to the arguments being nil" do
                 Puppet::Indirector::Request.expects(:new).with { |name, method, key, args| args.nil? }
                 @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
 
             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 storing a model instance" do
             before { @method = :save }
 
             it_should_behave_like "Indirection Delegator"
             it_should_behave_like "Delegation Authorizer"
 
             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 that it is expiring any 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