puppet 0.25.5 → 2.6.0

data/spec/integration/indirector/direct_file_server_spec.rb

@@ -0,0 +1,73 @@
+#!/usr/bin/env ruby
+#
+#  Created by Luke Kanies on 2007-10-19.
+#  Copyright (c) 2007. All rights reserved.
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+require 'puppet/indirector/file_content/file'
+
+describe Puppet::Indirector::DirectFileServer, " when interacting with the filesystem and the model" do
+  before do
+    # We just test a subclass, since it's close enough.
+    @terminus = Puppet::Indirector::FileContent::File.new
+
+    @filepath = "/path/to/my/file"
+  end
+
+  it "should return an instance of the model" do
+    FileTest.expects(:exists?).with(@filepath).returns(true)
+
+    @terminus.find(@terminus.indirection.request(:find, "file://host#{@filepath}")).should be_instance_of(Puppet::FileServing::Content)
+  end
+
+  it "should return an instance capable of returning its content" do
+    FileTest.expects(:exists?).with(@filepath).returns(true)
+    File.stubs(:lstat).with(@filepath).returns(stub("stat", :ftype => "file"))
+    File.expects(:read).with(@filepath).returns("my content")
+
+    instance = @terminus.find(@terminus.indirection.request(:find, "file://host#{@filepath}"))
+
+    instance.content.should == "my content"
+  end
+end
+
+describe Puppet::Indirector::DirectFileServer, " when interacting with FileServing::Fileset and the model" do
+  before do
+    @terminus = Puppet::Indirector::FileContent::File.new
+
+    @path = Tempfile.new("direct_file_server_testing")
+    path = @path.path
+    @path.close!
+    @path = path
+
+    Dir.mkdir(@path)
+    File.open(File.join(@path, "one"), "w") { |f| f.print "one content" }
+    File.open(File.join(@path, "two"), "w") { |f| f.print "two content" }
+
+    @request = @terminus.indirection.request(:search, "file:///#{@path}", :recurse => true)
+  end
+
+  after do
+    system("rm -rf #{@path}")
+  end
+
+  it "should return an instance for every file in the fileset" do
+    result = @terminus.search(@request)
+    result.should be_instance_of(Array)
+    result.length.should == 3
+    result.each { |r| r.should be_instance_of(Puppet::FileServing::Content) }
+  end
+
+  it "should return instances capable of returning their content" do
+    @terminus.search(@request).each do |instance|
+      case instance.full_path
+      when /one/; instance.content.should == "one content"
+      when /two/; instance.content.should == "two content"
+      when @path
+      else
+        raise "No valid key for #{instance.path.inspect}"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,94 @@
+#!/usr/bin/env ruby
+#
+#  Created by Luke Kanies on 2007-10-18.
+#  Copyright (c) 2007. All rights reserved.
+
+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" }
+
+    Puppet.settings[:modulepath] = "/no/such/file"
+
+    env = Puppet::Node::Environment.new("foo")
+    env.stubs(:modulepath).returns [path]
+
+    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/file_metadata/file_server_spec.rb

@@ -0,0 +1,18 @@
+#!/usr/bin/env ruby
+#
+#  Created by Luke Kanies on 2007-10-18.
+#  Copyright (c) 2007. All rights reserved.
+
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+require 'puppet/indirector/file_metadata/file_server'
+require 'shared_behaviours/file_server_terminus'
+
+describe Puppet::Indirector::FileMetadata::FileServer, " when finding files" do
+  it_should_behave_like "Puppet::Indirector::FileServerTerminus"
+
+  before do
+    @terminus = Puppet::Indirector::FileMetadata::FileServer.new
+    @test_class = Puppet::FileServing::Metadata
+  end
+end

data/spec/integration/indirector/node/ldap_spec.rb

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+require 'puppet/indirector/node/ldap'
+
+describe Puppet::Node::Ldap do
+  it "should use a restrictive filter when searching for nodes in a class" do
+    ldap = Puppet::Node.indirection.terminus(:ldap)
+    Puppet::Node.indirection.stubs(:terminus).returns ldap
+    ldap.expects(:ldapsearch).with("(&(objectclass=puppetClient)(puppetclass=foo))")
+
+    Puppet::Node.search "eh", :class => "foo"
+  end
+end

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

@@ -0,0 +1,96 @@
+#!/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::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.add_metric(:resources, resourcemetrics)
+
+    timemetrics = {
+      :resource1 => 10,
+      :resource2 => 50,
+      :resource3 => 40,
+      :resource4 => 20,
+    }
+    report.add_metric(:times, timemetrics)
+
+
+          report.add_metric(
+        :changes,
+        
+      :total => 20
+    )
+
+    report.save
+  end
+end

data/spec/integration/indirector/rest_spec.rb

@@ -0,0 +1,524 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+require 'puppet/network/server'
+require 'puppet/indirector'
+require 'puppet/indirector/rest'
+
+# a fake class that will be indirected via REST
+class Puppet::TestIndirectedFoo
+  extend Puppet::Indirector
+  indirects :test_indirected_foo, :terminus_setting => :test_indirected_foo_terminus
+
+  attr_reader :value
+  attr_accessor :name
+
+  def initialize(value = 0)
+    @value = value
+  end
+
+  def self.from_yaml(yaml)
+    YAML.load(yaml)
+  end
+
+  def name
+    "bob"
+  end
+end
+
+# empty Terminus class -- this would normally have to be in a directory findable by the autoloader, but we short-circuit that below
+class Puppet::TestIndirectedFoo::Rest < Puppet::Indirector::REST
+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::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'
+      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
+
+      # 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::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.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', :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', :name => "foo")
+          @mock_model.stubs(:find).raises(RuntimeError)
+          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(Net::HTTPError)
+        end
+      end
+    end
+
+    describe "when searching for model instances over 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.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|
+            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
+      end
+
+      describe "when no matching model instance can be found" do
+        before :each do
+          @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::Indirector::Request.any_instance.stubs(:model).returns(@mock_model)
+        end
+
+        it "should raise an exception" do
+          lambda { Puppet::TestIndirectedFoo.find('bar') }.should raise_error(Net::HTTPError)
+        end
+      end
+    end
+
+    describe "when destroying a model instance over REST" do
+      describe "when a matching model instance can be found" do
+        before :each do
+          @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.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.stubs(:destroy).raises(RuntimeError)
+        end
+
+        it "should raise an exception" do
+          lambda { Puppet::TestIndirectedFoo.destroy('bar') }.should raise_error(Net::HTTPError)
+        end
+      end
+    end
+
+    describe "when saving a model instance over REST" do
+      before :each do
+        @instance = Puppet::TestIndirectedFoo.new(42)
+        @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)
+        end
+
+        it "should raise an exception" do
+          lambda { @instance.save }.should raise_error(Net::HTTPError)
+        end
+      end
+    end
+
+    after :each do
+      @server.unlisten
+    end
+  end
+
+  describe "when using mongrel" do
+    confine "Mongrel is not available" => Puppet.features.mongrel?
+
+    before :each do
+      Puppet[:servertype] = 'mongrel'
+      @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
+
+      # 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
+
+    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.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.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.stubs(:find).raises(RuntimeError)
+        end
+
+        it "should raise an exception" do
+          lambda { Puppet::TestIndirectedFoo.find('bar') }.should raise_error(Net::HTTPError)
+        end
+      end
+    end
+
+    describe "when searching for model instances over REST" do
+      describe "when matching model instances can be found" do
+        before :each do
+          @model_instances = [ Puppet::TestIndirectedFoo.new(23), Puppet::TestIndirectedFoo.new(24) ]
+
+          # 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|
+            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.stubs(:search).returns nil
+          @mock_model.stubs(:render_multiple).returns nil.to_yaml
+        end
+
+        it "should return nil" do
+          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.stubs(:find).raises(RuntimeError)
+        end
+
+        it "should raise an exception" do
+          lambda { Puppet::TestIndirectedFoo.find('bar') }.should raise_error(Net::HTTPError)
+        end
+      end
+    end
+
+    describe "when destroying a model instance over REST" do
+      describe "when a matching model instance can be found" do
+        before :each do
+          @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.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.stubs(:destroy).raises(RuntimeError)
+        end
+
+        it "should raise an exception" do
+          lambda { Puppet::TestIndirectedFoo.destroy('bar') }.should raise_error(Net::HTTPError)
+        end
+      end
+    end
+
+    describe "when saving a model instance over REST" do
+      before :each do
+        @instance = Puppet::TestIndirectedFoo.new(42)
+        @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)
+      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)
+        end
+
+        it "should raise an exception" do
+          lambda { @instance.save }.should raise_error(Net::HTTPError)
+        end
+      end
+    end
+  end
+end