diff --git a/lib/puppet/indirector/indirection.rb b/lib/puppet/indirector/indirection.rb
index 1bceea4e6..ed3e6f742 100644
--- a/lib/puppet/indirector/indirection.rb
+++ b/lib/puppet/indirector/indirection.rb
@@ -1,318 +1,325 @@
 require 'puppet/util/docs'
 require 'puppet/util/methodhelper'
 require 'puppet/indirector/envelope'
 require 'puppet/indirector/request'
 require 'puppet/util/instrumentation/instrumentable'
 
 # 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::MethodHelper
   include Puppet::Util::Docs
   extend Puppet::Util::Instrumentation::Instrumentable
 
   attr_accessor :name, :model
   attr_reader :termini
 
   probe :find, :label => Proc.new { |parent, key, *args| "find_#{parent.name}_#{parent.terminus_class}" }, :data => Proc.new { |parent, key, *args| { :key => key }}
   probe :save, :label => Proc.new { |parent, key, *args| "save_#{parent.name}_#{parent.terminus_class}" }, :data => Proc.new { |parent, key, *args| { :key => key }}
   probe :search, :label => Proc.new { |parent, key, *args| "search_#{parent.name}_#{parent.terminus_class}" }, :data => Proc.new { |parent, key, *args| { :key => key }}
   probe :destroy, :label => Proc.new { |parent, key, *args| "destroy_#{parent.name}_#{parent.terminus_class}" }, :data => Proc.new { |parent, key, *args| { :key => key }}
 
   @@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
 
   # 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
     @ttl ||= Puppet[:runinterval]
   end
 
   # Calculate the expiration date for a returned instance.
   def expiration
     Time.now + ttl
   end
 
   # Generate the full doc string.
   def doc
     text = ""
 
     text += scrub(@doc) + "\n\n" if @doc
 
     if s = terminus_setting
       text += "* **Terminus Setting**: #{terminus_setting}"
     end
 
     text
   end
 
   def initialize(model, name, options = {})
     @model = model
     @name = name
     @termini = {}
 
     @cache_class = nil
     @terminus_class = nil
 
     raise(ArgumentError, "Indirection #{@name} is already defined") 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.
     set_options(options)
   end
 
   # Set up our request object.
   def request(*args)
     Puppet::Indirector::Request.new(self.name, *args)
   end
 
   # Return the singleton terminus for this indirection.
   def terminus(terminus_name = nil)
     # Get the name of the terminus.
     raise Puppet::DevError, "No terminus specified for #{self.name}; cannot redirect" unless terminus_name ||= terminus_class
 
     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]
       else
         raise Puppet::DevError, "No terminus class nor terminus setting was provided for indirection #{self.name}"
       end
     end
     @terminus_class
   end
 
   def reset_terminus_class
     @terminus_class = nil
   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)
     raise ArgumentError, "Invalid terminus name #{terminus_class.inspect}" unless terminus_class and terminus_class.to_s != ""
     unless Puppet::Indirector::Terminus.terminus_class(self.name, terminus_class)
       raise ArgumentError, "Could not find terminus #{terminus_class} for indirection #{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, options={})
     request = request(:expire, key, nil, options)
 
     return nil unless cache?
 
     return nil unless instance = cache.find(request(:find, key, nil, options))
 
     Puppet.info "Expiring the #{self.name} cache of #{instance.name}"
 
     # Set an expiration date in the past
     instance.expiration = Time.now - 60
 
     cache.save(request(:save, nil, instance, options))
   end
 
   # Search for an instance in the appropriate terminus, caching the
   # results if caching is configured..
   def find(key, options={})
     request = request(:find, key, nil, options)
     terminus = prepare(request)
 
-    if result = find_in_cache(request)
-      return result
-    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 result.respond_to?(:expiration)
-      if cache? and request.use_cache?
-        Puppet.info "Caching #{self.name} for #{request.key}"
-        cache.save request(:save, nil, result, options)
+    result = find_in_cache(request)
+    if not result.nil?
+      result
+    elsif request.ignore_terminus?
+      nil
+    else
+      # Otherwise, return the result from the terminus, caching if
+      # appropriate.
+      result = terminus.find(request)
+      if not result.nil?
+        result.expiration ||= self.expiration if result.respond_to?(:expiration)
+        if cache? and request.use_cache?
+          Puppet.info "Caching #{self.name} for #{request.key}"
+          cache.save request(:save, nil, result, options)
+        end
+
+        if terminus.respond_to?(:filter)
+          terminus.filter(result)
+        else
+          result
+        end
       end
-
-      return terminus.respond_to?(:filter) ? terminus.filter(result) : result
     end
-
-    nil
   end
 
   # Search for an instance in the appropriate terminus, and return a
   # boolean indicating whether the instance was found.
   def head(key, options={})
     request = request(:head, key, nil, options)
     terminus = prepare(request)
 
     # Look in the cache first, then in the terminus.  Force the result
     # to be a boolean.
     !!(find_in_cache(request) || terminus.head(request))
   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 #{self.name} for #{request.key} from cache; expired at #{cached.expiration}"
       return nil
     end
 
     Puppet.debug "Using cached #{self.name} for #{request.key}"
     cached
   rescue => detail
     Puppet.log_exception(detail, "Cached #{self.name} for #{request.key} failed: #{detail}")
     nil
   end
 
   # Remove something via the terminus.
   def destroy(key, options={})
     request = request(:destroy, key, nil, options)
     terminus = prepare(request)
 
     result = terminus.destroy(request)
 
     if cache? and cached = cache.find(request(:find, key, nil, options))
       # 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, options={})
     request = request(:search, key, nil, options)
     terminus = prepare(request)
 
     if result = terminus.search(request)
       raise Puppet::DevError, "Search results from terminus #{terminus.name} are not an array" unless result.is_a?(Array)
       result.each do |instance|
         next unless instance.respond_to? :expiration
         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, key = nil, options={})
     request = request(:save, key, instance, options)
     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 #{request.method} on #{request}"
       msg += " with #{request.options.inspect}" unless request.options.empty?
       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 #{request}"
       end
     else
       terminus_name = terminus_class
     end
 
     dest_terminus = terminus(terminus_name)
     check_authorization(request, dest_terminus)
 
     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 #{terminus_class} for indirection #{self.name}"
     end
     klass.new
   end
 end
diff --git a/spec/unit/indirector/indirection_spec.rb b/spec/unit/indirector/indirection_spec.rb
index 96493bf41..03b228ffd 100755
--- a/spec/unit/indirector/indirection_spec.rb
+++ b/spec/unit/indirector/indirection_spec.rb
@@ -1,854 +1,859 @@
 #! /usr/bin/env ruby
 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", nil)
 
     @indirection.expects(:request).with(@method, "mystuff", nil, :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", nil)
 
     @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
   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[:runinterval] = 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 return false if the instance is false" do
+        @terminus.expects(:find).returns(false)
+        @indirection.find("me").should equal(false)
+      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", nil, optionally(instance_of(Hash))).returns destroy
           @indirection.expects(:request).with(:find, "/my/key", nil, optionally(instance_of(Hash))).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
     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[:node_terminus] = :my_terminus
       @indirection.terminus_setting = :node_terminus
       @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
       @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)
         @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