puppet 0.24.9 → 0.25.0

data/spec/integration/indirector/file_content/file_server.rb

@@ -8,11 +8,86 @@ require File.dirname(__FILE__) + '/../../../spec_helper'
 require 'puppet/indirector/file_content/file_server'
 require 'shared_behaviours/file_server_terminus'
 
+require 'puppet_spec/files'
+
 describe Puppet::Indirector::FileContent::FileServer, " when finding files" do
     it_should_behave_like "Puppet::Indirector::FileServerTerminus"
+    include PuppetSpec::Files
 
     before do
         @terminus = Puppet::Indirector::FileContent::FileServer.new
         @test_class = Puppet::FileServing::Content
     end
+
+    it "should find plugin file content in the environment specified in the request" do
+        path = tmpfile("file_content_with_env")
+
+        Dir.mkdir(path)
+
+        modpath = File.join(path, "mod")
+        FileUtils.mkdir_p(File.join(modpath, "lib"))
+        file = File.join(modpath, "lib", "file.rb")
+        File.open(file, "w") { |f| f.puts "1" }
+
+        env = Puppet::Node::Environment.new("foo")
+        env.stubs(:modulepath).returns [path]
+        Puppet.settings[:modulepath] = "/no/such/file"
+
+        result = Puppet::FileServing::Content.search("plugins", :environment => "foo", :recurse => true)
+
+        result.should_not be_nil
+        result.length.should == 2
+        result[1].should be_instance_of(Puppet::FileServing::Content)
+        result[1].content.should == "1\n"
+    end
+
+    it "should find file content in modules" do
+        path = tmpfile("file_content")
+
+        Dir.mkdir(path)
+
+        modpath = File.join(path, "mymod")
+        FileUtils.mkdir_p(File.join(modpath, "files"))
+        file = File.join(modpath, "files", "myfile")
+        File.open(file, "w") { |f| f.puts "1" }
+
+        Puppet.settings[:modulepath] = path
+
+        result = Puppet::FileServing::Content.find("modules/mymod/myfile")
+
+        result.should_not be_nil
+        result.should be_instance_of(Puppet::FileServing::Content)
+        result.content.should == "1\n"
+    end
+
+    it "should find file content in files when node name expansions are used" do
+        Puppet::Util::Cacher.expire
+        FileTest.stubs(:exists?).returns true
+        FileTest.stubs(:exists?).with(Puppet[:fileserverconfig]).returns(true)
+
+        @path = tmpfile("file_server_testing")
+
+        Dir.mkdir(@path)
+        subdir = File.join(@path, "mynode")
+        Dir.mkdir(subdir)
+        File.open(File.join(subdir, "myfile"), "w") { |f| f.puts "1" }
+
+        # Use a real mount, so the integration is a bit deeper.
+        @mount1 = Puppet::FileServing::Configuration::Mount::File.new("one")
+        @mount1.stubs(:allowed?).returns true
+        @mount1.path = File.join(@path, "%h")
+
+        @parser = stub 'parser', :changed? => false
+        @parser.stubs(:parse).returns("one" => @mount1)
+
+        Puppet::FileServing::Configuration::Parser.stubs(:new).returns(@parser)
+
+        path = File.join(@path, "myfile")
+
+        result = Puppet::FileServing::Content.find("one/myfile", :environment => "foo", :node => "mynode")
+
+        result.should_not be_nil
+        result.should be_instance_of(Puppet::FileServing::Content)
+        result.content.should == "1\n"
+    end
 end

data/spec/integration/indirector/report/rest.rb

@@ -0,0 +1,95 @@
+#!/usr/bin/env ruby
+
+Dir.chdir(File.dirname(__FILE__)) { (s = lambda { |f| File.exist?(f) ? require(f) : Dir.chdir("..") { s.call(f) } }).call("spec/spec_helper.rb") }
+
+require 'puppet/transaction/report'
+require 'puppet/network/server'
+require 'puppet/network/http/webrick/rest'
+
+describe "Report REST Terminus" do
+    before do
+        Puppet[:masterport] = 34343
+        Puppet[:server] = "localhost"
+
+        # Get a safe temporary file
+        @tmpfile = Tempfile.new("webrick_integration_testing")
+        @dir = @tmpfile.path + "_dir"
+
+        Puppet.settings[:confdir] = @dir
+        Puppet.settings[:vardir] = @dir
+        Puppet.settings[:server] = "127.0.0.1"
+        Puppet.settings[:masterport] = "34343"
+        Puppet.settings[:http_enable_post_connection_check] = false
+
+        Puppet::Util::Cacher.expire
+
+        Puppet[:servertype] = 'webrick'
+        Puppet[:server] = '127.0.0.1'
+        Puppet[:certname] = '127.0.0.1'
+
+        # Generate the certificate with a local CA
+        Puppet::SSL::Host.ca_location = :local
+        ca = Puppet::SSL::CertificateAuthority.new
+        ca.generate(Puppet[:certname]) unless Puppet::SSL::Certificate.find(Puppet[:certname])
+        ca.generate("foo.madstop.com") unless Puppet::SSL::Certificate.find(Puppet[:certname])
+
+        @host = Puppet::SSL::Host.new(Puppet[:certname])
+
+        @params = { :port => 34343, :handlers => [ :report ] }
+        @server = Puppet::Network::Server.new(@params)
+        @server.listen
+
+        # Let's use REST for our reports :-)
+        @old_terminus = Puppet::Transaction::Report.indirection.terminus_class
+        Puppet::Transaction::Report.terminus_class = :rest
+
+        # LAK:NOTE We need to have a fake model here so that our indirected methods get
+        # passed through REST; otherwise we'd be stubbing 'save', which would cause an immediate
+        # return.
+        @report = stub_everything 'report'
+        @mock_model = stub_everything 'faked model', :name => "report", :convert_from => @report
+        Puppet::Indirector::Request.any_instance.stubs(:model).returns(@mock_model)
+
+        Puppet::Network::HTTP::WEBrickREST.any_instance.stubs(:check_authorization)
+    end
+
+    after do
+        Puppet::Network::HttpPool.expire
+        Puppet::SSL::Host.ca_location = :none
+        Puppet.settings.clear
+        @server.unlisten
+        Puppet::Transaction::Report.terminus_class = @old_terminus
+    end
+
+    it "should be able to send a report to the server" do
+        @report.expects(:save)
+
+        report = Puppet::Transaction::Report.new
+
+        resourcemetrics = {
+            :total => 12,
+            :out_of_sync => 20,
+            :applied => 45,
+            :skipped => 1,
+            :restarted => 23,
+            :failed_restarts => 1,
+            :scheduled => 10
+        }
+        report.newmetric(:resources, resourcemetrics)
+
+        timemetrics = {
+            :resource1 => 10,
+            :resource2 => 50,
+            :resource3 => 40,
+            :resource4 => 20,
+        }
+        report.newmetric(:times, timemetrics)
+
+        report.newmetric(:changes,
+            :total => 20
+        )
+
+        report.time = Time.now
+        report.save
+    end
+end

data/spec/integration/indirector/rest.rb

@@ -7,19 +7,19 @@ require 'puppet/indirector/rest'
 
 # a fake class that will be indirected via REST
 class Puppet::TestIndirectedFoo
-    extend Puppet::Indirector    
+    extend Puppet::Indirector
     indirects :test_indirected_foo, :terminus_setting => :test_indirected_foo_terminus
-    
+
     attr_reader :value
-    
+
     def initialize(value = 0)
         @value = value
     end
-    
+
     def self.from_yaml(yaml)
         YAML.load(yaml)
     end
-    
+
     def name
         "bob"
     end
@@ -31,66 +31,109 @@ end
 
 
 describe Puppet::Indirector::REST do
+    before do
+        # Get a safe temporary file
+        @tmpfile = Tempfile.new("webrick_integration_testing")
+        @dir = @tmpfile.path + "_dir"
+
+        Puppet.settings[:confdir] = @dir
+        Puppet.settings[:vardir] = @dir
+        Puppet.settings[:server] = "127.0.0.1"
+        Puppet.settings[:masterport] = "34343"
+        Puppet.settings[:http_enable_post_connection_check] = false
+
+        Puppet::SSL::Host.ca_location = :local
+
+        Puppet::TestIndirectedFoo.terminus_class = :rest
+    end
+
+    after do
+        Puppet::Network::HttpPool.expire
+        Puppet::SSL::Host.ca_location = :none
+        Puppet.settings.clear
+    end
+
     describe "when using webrick" do
         before :each do
+            Puppet::Util::Cacher.expire
+
             Puppet[:servertype] = 'webrick'
-            @params = { :address => "127.0.0.1", :port => 34343, :handlers => [ :test_indirected_foo ] }
+            Puppet[:server] = '127.0.0.1'
+            Puppet[:certname] = '127.0.0.1'
+
+            ca = Puppet::SSL::CertificateAuthority.new
+            ca.generate(Puppet[:certname]) unless Puppet::SSL::Certificate.find(Puppet[:certname])
+
+            @params = { :port => 34343, :handlers => [ :test_indirected_foo ], :xmlrpc_handlers => [ :status ] }
             @server = Puppet::Network::Server.new(@params)
             @server.listen
 
-            # the autoloader was clearly not written test-first.    We subvert the integration test to get around its bullshit.
-            Puppet::Indirector::Terminus.stubs(:terminus_class).returns(Puppet::TestIndirectedFoo::Rest)
-            Puppet::TestIndirectedFoo.indirection.stubs(:terminus_class).returns :rest
+            # LAK:NOTE We need to have a fake model here so that our indirected methods get
+            # passed through REST; otherwise we'd be stubbing 'find', which would cause an immediate
+            # return.
+            @mock_model = stub('faked model', :name => "foo")
+            Puppet::Indirector::Request.any_instance.stubs(:model).returns(@mock_model)
 
-            # Stub the connection information.
-            Puppet::TestIndirectedFoo.indirection.terminus(:rest).stubs(:rest_connection_details).returns(:host => "localhost", :port => 34343)
+            # do not trigger the authorization layer
+            Puppet::Network::HTTP::WEBrickREST.any_instance.stubs(:check_authorization).returns(true)
         end
-    
+
         describe "when finding a model instance over REST" do
             describe "when a matching model instance can be found" do
                 before :each do
                     @model_instance = Puppet::TestIndirectedFoo.new(23)
-                    @mock_model = stub('faked model', :find => @model_instance)
-                    Puppet::Network::HTTP::WEBrickREST.any_instance.stubs(:model).returns(@mock_model)                
+                    @mock_model.stubs(:find).returns @model_instance
                 end
-            
+
                 it "should not fail" do
                     lambda { Puppet::TestIndirectedFoo.find('bar') }.should_not raise_error
                 end
-    
+
                 it 'should return an instance of the model class' do
                     Puppet::TestIndirectedFoo.find('bar').class.should == Puppet::TestIndirectedFoo
                 end
-    
+
+                it "should pass options all the way through" do
+                    @mock_model.expects(:find).with { |key, args| args[:one] == "two" and args[:three] == "four" }.returns @model_instance
+                    Puppet::TestIndirectedFoo.find('bar', :one => "two", :three => "four")
+                end
+
                 it 'should return the instance of the model class associated with the provided lookup key' do
                     Puppet::TestIndirectedFoo.find('bar').value.should == @model_instance.value
                 end
-    
+
                 it 'should set an expiration on model instance' do
                     Puppet::TestIndirectedFoo.find('bar').expiration.should_not be_nil
                 end
+
+                it "should use a supported format" do
+                    Puppet::TestIndirectedFoo.expects(:supported_formats).returns ["marshal"]
+                    text = Marshal.dump(@model_instance)
+                    @model_instance.expects(:render).with(Puppet::Network::FormatHandler.format("marshal")).returns text
+                    Puppet::TestIndirectedFoo.find('bar')
+                end
             end
-        
+
             describe "when no matching model instance can be found" do
                 before :each do
-                    @mock_model = stub('faked model', :find => nil)
-                    Puppet::Network::HTTP::WEBrickREST.any_instance.stubs(:model).returns(@mock_model)
+                    @mock_model = stub('faked model', :name => "foo", :find => nil)
+                    Puppet::Indirector::Request.any_instance.stubs(:model).returns(@mock_model)
                 end
-            
+
                 it "should return nil" do
                     Puppet::TestIndirectedFoo.find('bar').should be_nil
                 end
             end
-        
+
             describe "when an exception is encountered in looking up a model instance" do
                 before :each do
-                    @mock_model = stub('faked model')
+                    @mock_model = stub('faked model', :name => "foo")
                     @mock_model.stubs(:find).raises(RuntimeError)
-                    Puppet::Network::HTTP::WEBrickREST.any_instance.stubs(:model).returns(@mock_model)                
+                    Puppet::Indirector::Request.any_instance.stubs(:model).returns(@mock_model)
                 end
-            
+
                 it "should raise an exception" do
-                    lambda { Puppet::TestIndirectedFoo.find('bar') }.should raise_error(RuntimeError) 
+                    lambda { Puppet::TestIndirectedFoo.find('bar') }.should raise_error(Net::HTTPError)
                 end
             end
         end
@@ -99,57 +142,58 @@ describe Puppet::Indirector::REST do
             describe "when matching model instances can be found" do
                 before :each do
                     @model_instances = [ Puppet::TestIndirectedFoo.new(23), Puppet::TestIndirectedFoo.new(24) ]
-                    @mock_model = stub('faked model', :search => @model_instances)
-                    Puppet::Network::HTTP::WEBrickREST.any_instance.stubs(:model).returns(@mock_model)                
+                    @mock_model.stubs(:search).returns @model_instances
+
+                    # Force yaml, because otherwise our mocks can't work correctly
+                    Puppet::TestIndirectedFoo.stubs(:supported_formats).returns %w{yaml}
+
+                    @mock_model.stubs(:render_multiple).returns @model_instances.to_yaml
                 end
-            
+
                 it "should not fail" do
                     lambda { Puppet::TestIndirectedFoo.search('bar') }.should_not raise_error
                 end
-    
+
                 it 'should return all matching results' do
                     Puppet::TestIndirectedFoo.search('bar').length.should == @model_instances.length
                 end
-    
+
+                it "should pass options all the way through" do
+                    @mock_model.expects(:search).with { |key, args| args[:one] == "two" and args[:three] == "four" }.returns @model_instances
+                    Puppet::TestIndirectedFoo.search("foo", :one => "two", :three => "four")
+                end
+
                 it 'should return model instances' do
-                    Puppet::TestIndirectedFoo.search('bar').each do |result| 
+                    Puppet::TestIndirectedFoo.search('bar').each do |result|
                         result.class.should == Puppet::TestIndirectedFoo
                     end
                 end
-    
+
                 it 'should return the instance of the model class associated with the provided lookup key' do
                     Puppet::TestIndirectedFoo.search('bar').collect { |i| i.value }.should == @model_instances.collect { |i| i.value }
                 end
-    
-                it 'should set a version timestamp on model instances' do
-                    pending("Luke looking at why this version magic might not be working") do
-                        Puppet::TestIndirectedFoo.search('bar').each do |result|
-                            result.version.should_not be_nil
-                        end
-                    end
-                end
             end
-        
+
             describe "when no matching model instance can be found" do
                 before :each do
-                    @mock_model = stub('faked model', :find => nil)
-                    Puppet::Network::HTTP::WEBrickREST.any_instance.stubs(:model).returns(@mock_model)
+                    @mock_model = stub('faked model', :name => "foo", :find => nil)
+                    Puppet::Indirector::Request.any_instance.stubs(:model).returns(@mock_model)
                 end
-            
+
                 it "should return nil" do
                     Puppet::TestIndirectedFoo.find('bar').should be_nil
                 end
             end
-        
+
             describe "when an exception is encountered in looking up a model instance" do
                 before :each do
                     @mock_model = stub('faked model')
                     @mock_model.stubs(:find).raises(RuntimeError)
-                    Puppet::Network::HTTP::WEBrickREST.any_instance.stubs(:model).returns(@mock_model)                
+                    Puppet::Indirector::Request.any_instance.stubs(:model).returns(@mock_model)
                 end
-            
+
                 it "should raise an exception" do
-                    lambda { Puppet::TestIndirectedFoo.find('bar') }.should raise_error(RuntimeError) 
+                    lambda { Puppet::TestIndirectedFoo.find('bar') }.should raise_error(Net::HTTPError)
                 end
             end
         end
@@ -157,39 +201,35 @@ describe Puppet::Indirector::REST do
         describe "when destroying a model instance over REST" do
             describe "when a matching model instance can be found" do
                 before :each do
-                    @mock_model = stub('faked model', :destroy => true)
-                    Puppet::Network::HTTP::WEBrickREST.any_instance.stubs(:model).returns(@mock_model)                
+                    @mock_model.stubs(:destroy).returns true
                 end
-            
+
                 it "should not fail" do
                     lambda { Puppet::TestIndirectedFoo.destroy('bar') }.should_not raise_error
                 end
-    
+
                 it 'should return success' do
                     Puppet::TestIndirectedFoo.destroy('bar').should == true
                 end
             end
-        
+
             describe "when no matching model instance can be found" do
                 before :each do
-                    @mock_model = stub('faked model', :destroy => false)
-                    Puppet::Network::HTTP::WEBrickREST.any_instance.stubs(:model).returns(@mock_model)
+                    @mock_model.stubs(:destroy).returns false
                 end
-            
+
                 it "should return failure" do
                     Puppet::TestIndirectedFoo.destroy('bar').should == false
                 end
             end
-        
+
             describe "when an exception is encountered in destroying a model instance" do
                 before :each do
-                    @mock_model = stub('faked model')
                     @mock_model.stubs(:destroy).raises(RuntimeError)
-                    Puppet::Network::HTTP::WEBrickREST.any_instance.stubs(:model).returns(@mock_model)                
                 end
-            
+
                 it "should raise an exception" do
-                    lambda { Puppet::TestIndirectedFoo.destroy('bar') }.should raise_error(RuntimeError) 
+                    lambda { Puppet::TestIndirectedFoo.destroy('bar') }.should raise_error(Net::HTTPError)
                 end
             end
         end
@@ -197,45 +237,45 @@ describe Puppet::Indirector::REST do
         describe "when saving a model instance over REST" do
             before :each do
                 @instance = Puppet::TestIndirectedFoo.new(42)
-                @mock_model = stub('faked model', :from_yaml => @instance)
-                Puppet::Network::HTTP::WEBrickREST.any_instance.stubs(:model).returns(@mock_model)                
-                Puppet::Network::HTTP::WEBrickREST.any_instance.stubs(:save_object).returns(@instance)                
+                @mock_model.stubs(:save_object).returns @instance
+                @mock_model.stubs(:convert_from).returns @instance
+                Puppet::Network::HTTP::WEBrickREST.any_instance.stubs(:save_object).returns(@instance)
             end
-            
+
             describe "when a successful save can be performed" do
                 before :each do
                 end
-            
+
                 it "should not fail" do
                     lambda { @instance.save }.should_not raise_error
                 end
-    
+
                 it 'should return an instance of the model class' do
                     @instance.save.class.should == Puppet::TestIndirectedFoo
                 end
-                 
+
                 it 'should return a matching instance of the model class' do
                     @instance.save.value.should == @instance.value
                 end
             end
-                    
+
             describe "when a save cannot be completed" do
                 before :each do
                     Puppet::Network::HTTP::WEBrickREST.any_instance.stubs(:save_object).returns(false)
                 end
-                            
+
                 it "should return failure" do
                     @instance.save.should == false
                 end
             end
-                    
+
             describe "when an exception is encountered in performing a save" do
                 before :each do
-                    Puppet::Network::HTTP::WEBrickREST.any_instance.stubs(:save_object).raises(RuntimeError)             
+                    Puppet::Network::HTTP::WEBrickREST.any_instance.stubs(:save_object).raises(RuntimeError)
                 end
-            
+
                 it "should raise an exception" do
-                    lambda { @instance.save }.should raise_error(RuntimeError) 
+                    lambda { @instance.save }.should raise_error(Net::HTTPError)
                 end
             end
         end
@@ -247,66 +287,88 @@ describe Puppet::Indirector::REST do
 
     describe "when using mongrel" do
         confine "Mongrel is not available" => Puppet.features.mongrel?
-        
+
         before :each do
             Puppet[:servertype] = 'mongrel'
-            @params = { :address => "127.0.0.1", :port => 34343, :handlers => [ :test_indirected_foo ] }
+            @params = { :port => 34343, :handlers => [ :test_indirected_foo ] }
+
+            # Make sure we never get a cert, since mongrel can't speak ssl
+            Puppet::SSL::Certificate.stubs(:find).returns nil
+
+            # We stub ssl to be off, since mongrel can't speak ssl
+            Net::HTTP.any_instance.stubs(:use_ssl?).returns false
+
             @server = Puppet::Network::Server.new(@params)
             @server.listen
 
-            # the autoloader was clearly not written test-first.    We subvert the integration test to get around its bullshit.
-            Puppet::Indirector::Terminus.stubs(:terminus_class).returns(Puppet::TestIndirectedFoo::Rest)
-            Puppet::TestIndirectedFoo.indirection.stubs(:terminus_class).returns :rest
+            # LAK:NOTE We need to have a fake model here so that our indirected methods get
+            # passed through REST; otherwise we'd be stubbing 'find', which would cause an immediate
+            # return.
+            @mock_model = stub('faked model', :name => "foo")
+            Puppet::Indirector::Request.any_instance.stubs(:model).returns(@mock_model)
+
+            # do not trigger the authorization layer
+            Puppet::Network::HTTP::MongrelREST.any_instance.stubs(:check_authorization).returns(true)
+        end
 
-            # Stub the connection information.
-            Puppet::TestIndirectedFoo.indirection.terminus(:rest).stubs(:rest_connection_details).returns(:host => "localhost", :port => 34343)
+        after do
+            @server.unlisten
         end
-    
+
         describe "when finding a model instance over REST" do
             describe "when a matching model instance can be found" do
                 before :each do
                     @model_instance = Puppet::TestIndirectedFoo.new(23)
-                    @mock_model = stub('faked model', :find => @model_instance)
-                    Puppet::Network::HTTP::MongrelREST.any_instance.stubs(:model).returns(@mock_model)                
+                    @mock_model.stubs(:find).returns @model_instance
                 end
-            
+
                 it "should not fail" do
                     lambda { Puppet::TestIndirectedFoo.find('bar') }.should_not raise_error
                 end
-    
+
                 it 'should return an instance of the model class' do
                     Puppet::TestIndirectedFoo.find('bar').class.should == Puppet::TestIndirectedFoo
                 end
-    
+
+                it "should pass options all the way through" do
+                    @mock_model.expects(:find).with { |key, args| args[:one] == "two" and args[:three] == "four" }.returns @model_instance
+                    Puppet::TestIndirectedFoo.find('bar', :one => "two", :three => "four")
+                end
+
                 it 'should return the instance of the model class associated with the provided lookup key' do
                     Puppet::TestIndirectedFoo.find('bar').value.should == @model_instance.value
                 end
-    
+
                 it 'should set an expiration on model instance' do
                     Puppet::TestIndirectedFoo.find('bar').expiration.should_not be_nil
                 end
+
+                it "should use a supported format" do
+                    Puppet::TestIndirectedFoo.expects(:supported_formats).returns ["marshal"]
+                    format = stub 'format'
+                    text = Marshal.dump(@model_instance)
+                    @model_instance.expects(:render).with(Puppet::Network::FormatHandler.format("marshal")).returns text
+                    Puppet::TestIndirectedFoo.find('bar')
+                end
             end
-        
+
             describe "when no matching model instance can be found" do
                 before :each do
-                    @mock_model = stub('faked model', :find => nil)
-                    Puppet::Network::HTTP::MongrelREST.any_instance.stubs(:model).returns(@mock_model)
+                    @mock_model.stubs(:find).returns nil
                 end
-            
+
                 it "should return nil" do
                     Puppet::TestIndirectedFoo.find('bar').should be_nil
                 end
             end
-        
+
             describe "when an exception is encountered in looking up a model instance" do
                 before :each do
-                    @mock_model = stub('faked model')
                     @mock_model.stubs(:find).raises(RuntimeError)
-                    Puppet::Network::HTTP::MongrelREST.any_instance.stubs(:model).returns(@mock_model)                
                 end
-            
+
                 it "should raise an exception" do
-                    lambda { Puppet::TestIndirectedFoo.find('bar') }.should raise_error(RuntimeError) 
+                    lambda { Puppet::TestIndirectedFoo.find('bar') }.should raise_error(Net::HTTPError)
                 end
             end
         end
@@ -315,55 +377,62 @@ describe Puppet::Indirector::REST do
             describe "when matching model instances can be found" do
                 before :each do
                     @model_instances = [ Puppet::TestIndirectedFoo.new(23), Puppet::TestIndirectedFoo.new(24) ]
-                    @mock_model = stub('faked model', :search => @model_instances)
-                    Puppet::Network::HTTP::MongrelREST.any_instance.stubs(:model).returns(@mock_model)                
+
+                    # Force yaml, because otherwise our mocks can't work correctly
+                    Puppet::TestIndirectedFoo.stubs(:supported_formats).returns %w{yaml}
+
+                    @mock_model.stubs(:search).returns @model_instances
+                    @mock_model.stubs(:render_multiple).returns @model_instances.to_yaml
                 end
-            
+
                 it "should not fail" do
                     lambda { Puppet::TestIndirectedFoo.search('bar') }.should_not raise_error
                 end
-    
+
                 it 'should return all matching results' do
                     Puppet::TestIndirectedFoo.search('bar').length.should == @model_instances.length
                 end
-    
+
+                it "should pass options all the way through" do
+                    @mock_model.expects(:search).with { |key, args| args[:one] == "two" and args[:three] == "four" }.returns @model_instances
+                    Puppet::TestIndirectedFoo.search('bar', :one => "two", :three => "four")
+                end
+
                 it 'should return model instances' do
-                    Puppet::TestIndirectedFoo.search('bar').each do |result| 
+                    Puppet::TestIndirectedFoo.search('bar').each do |result|
                         result.class.should == Puppet::TestIndirectedFoo
                     end
                 end
-    
+
                 it 'should return the instance of the model class associated with the provided lookup key' do
                     Puppet::TestIndirectedFoo.search('bar').collect { |i| i.value }.should == @model_instances.collect { |i| i.value }
                 end
-    
+
                 it 'should set an expiration on model instances' do
                     Puppet::TestIndirectedFoo.search('bar').each do |result|
                         result.expiration.should_not be_nil
                     end
                 end
             end
-        
+
             describe "when no matching model instance can be found" do
                 before :each do
-                    @mock_model = stub('faked model', :find => nil)
-                    Puppet::Network::HTTP::MongrelREST.any_instance.stubs(:model).returns(@mock_model)
+                    @mock_model.stubs(:search).returns nil
+                    @mock_model.stubs(:render_multiple).returns nil.to_yaml
                 end
-            
+
                 it "should return nil" do
-                    Puppet::TestIndirectedFoo.find('bar').should be_nil
+                    Puppet::TestIndirectedFoo.search('bar').should == []
                 end
             end
-        
+
             describe "when an exception is encountered in looking up a model instance" do
                 before :each do
-                    @mock_model = stub('faked model')
                     @mock_model.stubs(:find).raises(RuntimeError)
-                    Puppet::Network::HTTP::MongrelREST.any_instance.stubs(:model).returns(@mock_model)                
                 end
-            
+
                 it "should raise an exception" do
-                    lambda { Puppet::TestIndirectedFoo.find('bar') }.should raise_error(RuntimeError) 
+                    lambda { Puppet::TestIndirectedFoo.find('bar') }.should raise_error(Net::HTTPError)
                 end
             end
         end
@@ -371,39 +440,35 @@ describe Puppet::Indirector::REST do
         describe "when destroying a model instance over REST" do
             describe "when a matching model instance can be found" do
                 before :each do
-                    @mock_model = stub('faked model', :destroy => true)
-                    Puppet::Network::HTTP::MongrelREST.any_instance.stubs(:model).returns(@mock_model)                
+                    @mock_model.stubs(:destroy).returns true
                 end
-            
+
                 it "should not fail" do
                     lambda { Puppet::TestIndirectedFoo.destroy('bar') }.should_not raise_error
                 end
-    
+
                 it 'should return success' do
                     Puppet::TestIndirectedFoo.destroy('bar').should == true
                 end
             end
-        
+
             describe "when no matching model instance can be found" do
                 before :each do
-                    @mock_model = stub('faked model', :destroy => false)
-                    Puppet::Network::HTTP::MongrelREST.any_instance.stubs(:model).returns(@mock_model)
+                    @mock_model.stubs(:destroy).returns false
                 end
-            
+
                 it "should return failure" do
                     Puppet::TestIndirectedFoo.destroy('bar').should == false
                 end
             end
-        
+
             describe "when an exception is encountered in destroying a model instance" do
                 before :each do
-                    @mock_model = stub('faked model')
                     @mock_model.stubs(:destroy).raises(RuntimeError)
-                    Puppet::Network::HTTP::MongrelREST.any_instance.stubs(:model).returns(@mock_model)                
                 end
-            
+
                 it "should raise an exception" do
-                    lambda { Puppet::TestIndirectedFoo.destroy('bar') }.should raise_error(RuntimeError) 
+                    lambda { Puppet::TestIndirectedFoo.destroy('bar') }.should raise_error(Net::HTTPError)
                 end
             end
         end
@@ -411,54 +476,49 @@ describe Puppet::Indirector::REST do
         describe "when saving a model instance over REST" do
             before :each do
                 @instance = Puppet::TestIndirectedFoo.new(42)
-                @mock_model = stub('faked model', :from_yaml => @instance)
-                Puppet::Network::HTTP::MongrelREST.any_instance.stubs(:model).returns(@mock_model)                
+                @mock_model.stubs(:convert_from).returns @instance
 
                 # LAK:NOTE This stub is necessary to prevent the REST call from calling
                 # REST.save again, thus producing painful infinite recursion.
-                Puppet::Network::HTTP::MongrelREST.any_instance.stubs(:save_object).returns(@instance)                
+                Puppet::Network::HTTP::MongrelREST.any_instance.stubs(:save_object).returns(@instance)
             end
-            
+
             describe "when a successful save can be performed" do
                 before :each do
                 end
-            
+
                 it "should not fail" do
                     lambda { @instance.save }.should_not raise_error
                 end
-    
+
                 it 'should return an instance of the model class' do
                     @instance.save.class.should == Puppet::TestIndirectedFoo
                 end
-                 
+
                 it 'should return a matching instance of the model class' do
                     @instance.save.value.should == @instance.value
                 end
             end
-                    
+
             describe "when a save cannot be completed" do
                 before :each do
                     Puppet::Network::HTTP::MongrelREST.any_instance.stubs(:save_object).returns(false)
                 end
-                            
+
                 it "should return failure" do
                     @instance.save.should == false
                 end
             end
-                    
+
             describe "when an exception is encountered in performing a save" do
                 before :each do
-                    Puppet::Network::HTTP::MongrelREST.any_instance.stubs(:save_object).raises(RuntimeError)             
+                    Puppet::Network::HTTP::MongrelREST.any_instance.stubs(:save_object).raises(RuntimeError)
                 end
-            
+
                 it "should raise an exception" do
-                    lambda { @instance.save }.should raise_error(RuntimeError) 
+                    lambda { @instance.save }.should raise_error(Net::HTTPError)
                 end
             end
         end
-
-        after :each do
-            @server.unlisten
-        end
     end
 end