puppet 0.24.9 → 0.25.0

data/spec/unit/indirector/facts/rest.rb

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+require 'puppet/indirector/facts/rest'
+
+describe Puppet::Node::Facts::Rest do
+    it "should be a sublcass of Puppet::Indirector::REST" do
+        Puppet::Node::Facts::Rest.superclass.should equal(Puppet::Indirector::REST)
+    end
+end

data/spec/unit/indirector/file.rb

@@ -24,7 +24,7 @@ describe Puppet::Indirector::File do
 
         @request = stub 'request', :key => @path
     end
-  
+
     describe Puppet::Indirector::File, " when finding files" do
 
         it "should provide a method to return file contents at a specified path" do
@@ -140,6 +140,13 @@ describe Puppet::Indirector::File do
             proc { @searcher.destroy(@request) }.should raise_error(Puppet::Error)
         end
 
+        it "should log that is removing the file" do
+            File.expects(:exist?).returns(true)
+            File.expects(:unlink)
+            Puppet.expects(:notice)
+            @searcher.destroy(@request)
+        end
+
         it "should use the path() method to calculate the path if it exists" do
             @searcher.meta_def(:path) do |thing|
                 thing.to_s.upcase

data/spec/unit/indirector/file_metadata/file.rb

@@ -21,14 +21,14 @@ describe Puppet::Indirector::FileMetadata::File do
             @metadata = Puppet::Indirector::FileMetadata::File.new
             @uri = "file:///my/local"
             @data = mock 'metadata'
-            @data.stubs(:collect_attributes)
+            @data.stubs(:collect)
             FileTest.expects(:exists?).with("/my/local").returns true
 
-            @request = stub 'request', :key => @uri, :options => {}
+            @request = Puppet::Indirector::Request.new(:file_metadata, :find, @uri)
         end
 
         it "should collect its attributes when a file is found" do
-            @data.expects(:collect_attributes)
+            @data.expects(:collect)
 
             Puppet::FileServing::Metadata.expects(:new).returns(@data)
             @metadata.find(@request).should == @data
@@ -40,12 +40,12 @@ describe Puppet::Indirector::FileMetadata::File do
             @metadata = Puppet::Indirector::FileMetadata::File.new
             @uri = "file:///my/local"
 
-            @request = stub 'request', :key => @uri, :options => {}
+            @request = Puppet::Indirector::Request.new(:file_metadata, :find, @uri)
         end
 
         it "should collect the attributes of the instances returned" do
             FileTest.expects(:exists?).with("/my/local").returns true
-            @metadata.expects(:path2instances).returns( [mock("one", :collect_attributes => nil), mock("two", :collect_attributes => nil)] )
+            @metadata.expects(:path2instances).returns( [mock("one", :collect => nil), mock("two", :collect => nil)] )
             @metadata.search(@request)
         end
     end

data/spec/unit/indirector/file_server.rb

@@ -24,161 +24,244 @@ describe Puppet::Indirector::FileServer do
 
         @file_server = @file_server_class.new
 
-        @uri = "puppetmounts://host/my/local/file"
+        @uri = "puppet://host/my/local/file"
         @configuration = mock 'configuration'
         Puppet::FileServing::Configuration.stubs(:create).returns(@configuration)
 
-        @request = Puppet::Indirector::Request.new(:myind, :mymethod, @uri)
+        @request = Puppet::Indirector::Request.new(:myind, :mymethod, @uri, :environment => "myenv")
     end
 
-    describe Puppet::Indirector::FileServer, " when finding files" do
+    describe "when finding files" do
+        before do
+            @mount = stub 'mount', :find => nil
+            @instance = stub('instance', :links= => nil, :collect => nil)
+        end
+
+        it "should use the configuration to find the mount and relative path" do
+            @configuration.expects(:split_path).with(@request)
 
-        it "should use the path portion of the URI as the file name" do
-            @configuration.expects(:file_path).with("/my/local/file", :node => nil)
             @file_server.find(@request)
         end
 
-        it "should use the FileServing configuration to convert the file name to a fully qualified path" do
-            @configuration.expects(:file_path).with("/my/local/file", :node => nil)
+        it "should return nil if it cannot find the mount" do
+            @configuration.expects(:split_path).with(@request).returns(nil, nil)
+
+            @file_server.find(@request).should be_nil
+        end
+
+        it "should use the mount to find the full path" do
+            @configuration.expects(:split_path).with(@request).returns([@mount, "rel/path"])
+
+            @mount.expects(:find).with { |key, request| key == "rel/path" }
+
             @file_server.find(@request)
         end
 
-        it "should pass the node name to the FileServing configuration if one is provided" do
-            @configuration.expects(:file_path).with("/my/local/file", :node => "testing")
-            @request.node = "testing"
+        it "should pass the request when finding a file" do
+            @configuration.expects(:split_path).with(@request).returns([@mount, "rel/path"])
+
+            @mount.expects(:find).with { |key, request| request == @request }
+
             @file_server.find(@request)
         end
 
-        it "should return nil if no fully qualified path is found" do
-            @configuration.expects(:file_path).with("/my/local/file", :node => nil).returns(nil)
+        it "should return nil if it cannot find a full path" do
+            @configuration.expects(:split_path).with(@request).returns([@mount, "rel/path"])
+
+            @mount.expects(:find).with { |key, request| key == "rel/path" }.returns nil
+
             @file_server.find(@request).should be_nil
         end
 
-        it "should return an instance of the model created with the full path if a file is found" do
-            @configuration.expects(:file_path).with("/my/local/file", :node => nil).returns("/some/file")
-            @model.expects(:new).returns(:myinstance)
-            @file_server.find(@request).should == :myinstance
+        it "should create an instance with the found path" do
+            @configuration.expects(:split_path).with(@request).returns([@mount, "rel/path"])
+
+            @mount.expects(:find).with { |key, request| key == "rel/path" }.returns "/my/file"
+
+            @model.expects(:new).with("/my/file").returns @instance
+
+            @file_server.find(@request).should equal(@instance)
         end
-    end
 
-    describe Puppet::Indirector::FileServer, " when returning instances" do
-        before :each do
-            @configuration.expects(:file_path).with("/my/local/file", :node => nil).returns("/some/file")
-            @instance = mock 'instance'
+        it "should set 'links' on the instance if it is set in the request options" do
+            @request.options[:links] = true
+            @configuration.expects(:split_path).with(@request).returns([@mount, "rel/path"])
+
+            @mount.expects(:find).with { |key, request| key == "rel/path" }.returns "/my/file"
+
+            @model.expects(:new).with("/my/file").returns @instance
+
+            @instance.expects(:links=).with(true)
+
+            @file_server.find(@request).should equal(@instance)
         end
 
-        it "should create the instance with the key used to find the instance" do
-            @model.expects(:new).with { |key, *options| key == @uri }
-            @file_server.find(@request)
+        it "should collect the instance" do
+            @request.options[:links] = true
+            @configuration.expects(:split_path).with(@request).returns([@mount, "rel/path"])
+
+            @mount.expects(:find).with { |key, request| key == "rel/path" }.returns "/my/file"
+
+            @model.expects(:new).with("/my/file").returns @instance
+
+            @instance.expects(:collect)
+
+            @file_server.find(@request).should equal(@instance)
         end
+    end
 
-        it "should create the instance with the path at which the instance was found" do
-            @model.expects(:new).with { |key, options| options[:path] == "/some/file" }
-            @file_server.find(@request)
+    describe "when searching for instances" do
+        before do
+            @mount = stub 'mount', :search => nil
+            @instance = stub('instance', :links= => nil, :collect => nil)
         end
 
-        it "should set the provided :links setting on to the instance if one is provided" do
-            @model.expects(:new).returns(@instance)
-            @instance.expects(:links=).with(:mytest)
-            @request.options[:links] = :mytest
-            @file_server.find(@request)
+        it "should use the configuration to search the mount and relative path" do
+            @configuration.expects(:split_path).with(@request)
+
+            @file_server.search(@request)
         end
 
-        it "should not set a :links value if no :links parameter is provided" do
-            @model.expects(:new).returns(@instance)
-            @file_server.find(@request)
+        it "should return nil if it cannot search the mount" do
+            @configuration.expects(:split_path).with(@request).returns(nil, nil)
+
+            @file_server.search(@request).should be_nil
         end
-    end
 
-    describe Puppet::Indirector::FileServer, " when checking authorization" do
+        it "should use the mount to search for the full paths" do
+            @configuration.expects(:split_path).with(@request).returns([@mount, "rel/path"])
+
+            @mount.expects(:search).with { |key, request| key == "rel/path" }
 
-        it "should have an authorization hook" do
-            @file_server.should respond_to(:authorized?)
+            @file_server.search(@request)
         end
 
-        it "should deny the :destroy method" do
-            @request.method = :destroy
-            @file_server.authorized?(@request).should be_false
+        it "should pass the request" do
+            @configuration.stubs(:split_path).returns([@mount, "rel/path"])
+
+            @mount.expects(:search).with { |key, request| request == @request }
+
+            @file_server.search(@request)
         end
 
-        it "should deny the :save method" do
-            @request.method = :save
-            @file_server.authorized?(@request).should be_false
+        it "should return nil if searching does not find any full paths" do
+            @configuration.expects(:split_path).with(@request).returns([@mount, "rel/path"])
+
+            @mount.expects(:search).with { |key, request| key == "rel/path" }.returns nil
+
+            @file_server.search(@request).should be_nil
         end
-        
-        describe "and finding file information" do
-            before do
-                @request.key =  "puppetmounts://host/my/file"
-                @request.method = :find 
-            end
 
-            it "should use the file server configuration to determine authorization" do
-                @configuration.expects(:authorized?)
-                @file_server.authorized?(@request)
-            end
+        it "should create a fileset with each returned path and merge them" do
+            @configuration.expects(:split_path).with(@request).returns([@mount, "rel/path"])
 
-            it "should pass the file path from the URI to the file server configuration" do
-                @configuration.expects(:authorized?).with { |uri, *args| uri == "/my/file" }
-                @file_server.authorized?(@request)
-            end
+            @mount.expects(:search).with { |key, request| key == "rel/path" }.returns %w{/one /two}
 
-            it "should pass the node name to the file server configuration" do
-                @configuration.expects(:authorized?).with { |key, options| options[:node] == "mynode" }
-                @request.node = "mynode"
-                @file_server.authorized?(@request)
-            end
+            FileTest.stubs(:exist?).returns true
 
-            it "should pass the IP address to the file server configuration" do
-                @configuration.expects(:authorized?).with { |key, options| options[:ipaddress] == "myip" }
-                @request.ip = "myip"
-                @file_server.authorized?(@request)
-            end
+            one = mock 'fileset_one'
+            Puppet::FileServing::Fileset.expects(:new).with("/one", @request).returns(one)
+            two = mock 'fileset_two'
+            Puppet::FileServing::Fileset.expects(:new).with("/two", @request).returns(two)
 
-            it "should return false if the file server configuration denies authorization" do
-                @configuration.expects(:authorized?).returns(false)
-                @file_server.authorized?(@request)
-            end
+            Puppet::FileServing::Fileset.expects(:merge).with(one, two).returns []
 
-            it "should return true if the file server configuration approves authorization" do
-                @configuration.expects(:authorized?).returns(true)
-                @file_server.authorized?(@request)
-            end
+            @file_server.search(@request)
         end
-    end
 
-    describe Puppet::Indirector::FileServer, " when searching for files" do
+        it "should create an instance with each path resulting from the merger of the filesets" do
+            @configuration.expects(:split_path).with(@request).returns([@mount, "rel/path"])
 
-        it "should use the path portion of the URI as the file name" do
-            @configuration.expects(:file_path).with("/my/local/file", :node => nil)
-            @file_server.search(@request)
+            @mount.expects(:search).with { |key, request| key == "rel/path" }.returns []
+
+            FileTest.stubs(:exist?).returns true
+
+            Puppet::FileServing::Fileset.expects(:merge).returns("one" => "/one", "two" => "/two")
+
+            one = stub 'one', :collect => nil
+            @model.expects(:new).with("/one", :relative_path => "one").returns one
+
+            two = stub 'two', :collect => nil
+            @model.expects(:new).with("/two", :relative_path => "two").returns two
+
+            # order can't be guaranteed
+            result = @file_server.search(@request)
+            result.should be_include(one)
+            result.should be_include(two)
+            result.length.should == 2
         end
 
-        it "should use the FileServing configuration to convert the file name to a fully qualified path" do
-            @configuration.expects(:file_path).with("/my/local/file", :node => nil)
+        it "should set 'links' on the instances if it is set in the request options" do
+            @configuration.expects(:split_path).with(@request).returns([@mount, "rel/path"])
+
+            @mount.expects(:search).with { |key, request| key == "rel/path" }.returns []
+
+            FileTest.stubs(:exist?).returns true
+
+            Puppet::FileServing::Fileset.expects(:merge).returns("one" => "/one")
+
+            one = stub 'one', :collect => nil
+            @model.expects(:new).with("/one", :relative_path => "one").returns one
+            one.expects(:links=).with true
+
+            @request.options[:links] = true
+
             @file_server.search(@request)
         end
 
-        it "should pass the node name to the FileServing configuration if one is provided" do
-            @configuration.expects(:file_path).with("/my/local/file", :node => "testing")
-            @request.node = "testing"
+        it "should collect the instances" do
+            @configuration.expects(:split_path).with(@request).returns([@mount, "rel/path"])
+
+            @mount.expects(:search).with { |key, options| key == "rel/path" }.returns []
+
+            FileTest.stubs(:exist?).returns true
+
+            Puppet::FileServing::Fileset.expects(:merge).returns("one" => "/one")
+
+            one = mock 'one'
+            @model.expects(:new).with("/one", :relative_path => "one").returns one
+            one.expects(:collect)
+
             @file_server.search(@request)
         end
+    end
 
-        it "should return nil if no fully qualified path is found" do
-            @configuration.expects(:file_path).with("/my/local/file", :node => nil).returns(nil)
-            @file_server.search(@request).should be_nil
+    describe "when checking authorization" do
+        before do
+            @request.method = :find
         end
 
-        it "should use :path2instances from the terminus_helper to return instances if a module is found and the file exists" do
-            @configuration.expects(:file_path).with("/my/local/file", :node => nil).returns("/my/file")
-            @file_server.expects(:path2instances)
-            @file_server.search(@request)
+        it "should return false when destroying" do
+            @request.method = :destroy
+            @file_server.should_not be_authorized(@request)
         end
 
-        it "should pass the request on to :path2instances" do
-            @configuration.expects(:file_path).with("/my/local/file", :node => nil).returns("/my/file")
-            @file_server.expects(:path2instances).with(@request, "/my/file")
-            @file_server.search(@request)
+        it "should return false when saving" do
+            @request.method = :save
+            @file_server.should_not be_authorized(@request)
+        end
+
+        it "should use the configuration to find the mount and relative path" do
+            @configuration.expects(:split_path).with(@request)
+
+            @file_server.authorized?(@request)
+        end
+
+        it "should return false if it cannot find the mount" do
+            @configuration.expects(:split_path).with(@request).returns(nil, nil)
+
+            @file_server.should_not be_authorized(@request)
+        end
+
+        it "should return the results of asking the mount whether the node and IP are authorized" do
+            @mount = stub 'mount'
+            @configuration.expects(:split_path).with(@request).returns([@mount, "rel/path"])
+
+            @request.stubs(:node).returns("mynode")
+            @request.stubs(:ip).returns("myip")
+            @mount.expects(:allowed?).with("mynode", "myip").returns "something"
+
+            @file_server.authorized?(@request).should == "something"
         end
     end
 end

data/spec/unit/indirector/indirection.rb

@@ -6,7 +6,7 @@ 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 = stub 'request', :node => nil
+        request = Puppet::Indirector::Request.new(:indirection, :find, "me")
 
         @indirection.expects(:request).with(@method, "mystuff", :one => :two).returns request
 
@@ -22,7 +22,7 @@ describe "Indirection Delegator", :shared => true do
             end
         end
 
-        request = stub 'request', :key => "me", :options => {}
+        request = Puppet::Indirector::Request.new(:indirection, :find, "me")
 
         @indirection.stubs(:request).returns request
 
@@ -34,6 +34,22 @@ describe "Indirection Delegator", :shared => true do
         @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
 
@@ -87,6 +103,9 @@ describe "Delegation Authorizer", :shared => true do
 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
@@ -127,7 +146,7 @@ describe Puppet::Indirector::Indirection do
             @terminus_class = mock 'terminus_class'
             @terminus = mock 'terminus'
             @terminus_class.stubs(:new).returns(@terminus)
-            @cache = mock 'cache'
+            @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)
@@ -190,7 +209,7 @@ describe Puppet::Indirector::Indirection do
                 @indirection.request(:funtest, "yayness").should equal(request)
             end
         end
-      
+
         describe "and looking for a model instance" do
             before { @method = :find }
 
@@ -224,10 +243,18 @@ describe Puppet::Indirector::Indirection do
                 @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.expects(:new).returns(@cache)
+                    @cache_class.stubs(:new).returns(@cache)
 
                     @instance.stubs(:expired?).returns false
                 end
@@ -239,6 +266,28 @@ describe Puppet::Indirector::Indirection do
                     @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
 
@@ -254,6 +303,21 @@ describe Puppet::Indirector::Indirection do
                     @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
@@ -325,19 +389,29 @@ describe Puppet::Indirector::Indirection do
             it_should_behave_like "Indirection Delegator"
             it_should_behave_like "Delegation Authorizer"
 
-            it "should return nil" do
-                @terminus.stubs(:save)
-                @indirection.save(@instance).should be_nil
+            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.expects(:new).returns(@cache)
+                    @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
 
@@ -347,9 +421,19 @@ describe Puppet::Indirector::Indirection do
                     @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 }
 
@@ -494,7 +578,7 @@ describe Puppet::Indirector::Indirection do
 
         after :each do
             @indirection.delete
-            Puppet::Indirector::Indirection.clear_cache
+            Puppet::Util::Cacher.expire
         end
     end
 
@@ -504,7 +588,7 @@ describe Puppet::Indirector::Indirection 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
@@ -514,7 +598,7 @@ describe Puppet::Indirector::Indirection do
             @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
@@ -615,15 +699,6 @@ describe Puppet::Indirector::Indirection do
             @indirection.terminus(:foo).should equal(@terminus)
         end
 
-        it "should allow the clearance of cached terminus instances" do
-            terminus1 = mock 'terminus1'
-            terminus2 = mock 'terminus2'
-            @terminus_class.stubs(:new).returns(terminus1, terminus2, ArgumentError)
-            @indirection.terminus(:foo).should equal(terminus1)
-            @indirection.class.clear_cache
-            @indirection.terminus(:foo).should equal(terminus2)
-        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)
@@ -638,7 +713,6 @@ describe Puppet::Indirector::Indirection do
 
         after do
             @indirection.delete
-            Puppet::Indirector::Indirection.clear_cache
         end
     end
 
@@ -664,8 +738,9 @@ describe Puppet::Indirector::Indirection do
             proc { @indirection.cache_class = "" }.should raise_error(ArgumentError)
         end
 
-        it "should fail to set the cache class when the cache class name is nil" do
-            proc { @indirection.cache_class = nil }.should raise_error(ArgumentError)
+        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
@@ -675,7 +750,6 @@ describe Puppet::Indirector::Indirection do
 
         after do
             @indirection.delete
-            Puppet::Indirector::Indirection.clear_cache
         end
     end
 
@@ -706,26 +780,16 @@ describe Puppet::Indirector::Indirection do
                 @indirection.cache.should equal(@cache)
                 @indirection.cache.should equal(@cache)
             end
-
-            it "should remove the cache terminus when all other terminus instances are cleared" do
-                cache2 = mock 'cache2'
-                @cache_class.stubs(:new).returns(@cache, cache2)
-                @indirection.cache_class = :cache_terminus
-                @indirection.cache.should equal(@cache)
-                @indirection.clear_cache
-                @indirection.cache.should equal(cache2)
-            end
         end
 
         describe "and saving" do
         end
-        
+
         describe "and finding" do
         end
-        
+
         after :each do
             @indirection.delete
-            Puppet::Indirector::Indirection.clear_cache
         end
     end
 end