puppet 2.7.21 → 2.7.22

data/lib/puppet/vendor/safe_yaml/spec/spec_helper.rb

@@ -0,0 +1,18 @@
+HERE = File.dirname(__FILE__) unless defined?(HERE)
+ROOT = File.join(HERE, "..") unless defined?(ROOT)
+
+$LOAD_PATH << File.join(ROOT, "lib")
+$LOAD_PATH << File.join(HERE, "support")
+
+require "yaml"
+if ENV["YAMLER"] && defined?(YAML::ENGINE)
+  YAML::ENGINE.yamler = ENV["YAMLER"]
+  puts "Running specs in Ruby #{RUBY_VERSION} with '#{YAML::ENGINE.yamler}' YAML engine."
+end
+
+require "safe_yaml"
+require "ostruct"
+require "hashie"
+require "heredoc_unindent"
+
+require File.join(HERE, "resolver_specs")

data/lib/puppet/vendor/safe_yaml/spec/support/exploitable_back_door.rb

@@ -0,0 +1,29 @@
+class ExploitableBackDoor
+  def exploited?
+    @exploited_through_setter || @exploited_through_init_with || @exploited_through_ivars
+  end
+
+  def exploited_through_setter?
+    @exploited_through_setter
+  end
+
+  def exploited_through_init_with?
+    @exploited_through_init_with
+  end
+
+  def exploited_through_ivars?
+    self.instance_variables.any?
+  end
+
+  def init_with(command)
+    # Note: this is how bad this COULD be.
+    # system("#{command}")
+    @exploited_through_init_with = true
+  end
+
+  def []=(command, arguments)
+    # Note: this is how bad this COULD be.
+    # system("#{command} #{arguments}")
+    @exploited_through_setter = true
+  end
+end

data/lib/puppet/vendor/safe_yaml/spec/syck_resolver_spec.rb

@@ -0,0 +1,10 @@
+require File.join(File.dirname(__FILE__), "spec_helper")
+
+if SafeYAML::YAML_ENGINE == "syck"
+  require "safe_yaml/syck_resolver"
+
+  describe SafeYAML::SyckResolver do
+    include ResolverSpecs
+    let(:resolver) { SafeYAML::SyckResolver.new }
+  end
+end

data/lib/puppet/vendor/safe_yaml/spec/transform/base64_spec.rb

@@ -0,0 +1,11 @@
+require File.join(File.dirname(__FILE__), "..", "spec_helper")
+
+describe SafeYAML::Transform do
+  it "should return the same encoding when decoding Base64" do
+    value = "c3VyZS4="
+    decoded = SafeYAML::Transform.to_proper_type(value, false, "!binary")
+
+    decoded.should == "sure."
+    decoded.encoding.should == value.encoding if decoded.respond_to?(:encoding)
+  end
+end

data/lib/puppet/vendor/safe_yaml/spec/transform/to_date_spec.rb

@@ -0,0 +1,34 @@
+require File.join(File.dirname(__FILE__), "..", "spec_helper")
+
+describe SafeYAML::Transform::ToDate do
+  it "returns true when the value matches a valid Date" do
+    subject.transform?("2013-01-01").should == [true, Date.parse("2013-01-01")]
+  end
+
+  it "returns false when the value does not match a valid Date" do
+    subject.transform?("foobar").should be_false
+  end
+
+  it "returns false when the value does not end with a Date" do
+    subject.transform?("2013-01-01\nNOT A DATE").should be_false
+  end
+
+  it "returns false when the value does not begin with a Date" do
+    subject.transform?("NOT A DATE\n2013-01-01").should be_false
+  end
+
+  it "correctly parses the remaining formats of the YAML spec" do
+    equivalent_values = [
+      "2001-12-15T02:59:43.1Z", # canonical
+      "2001-12-14t21:59:43.10-05:00", # iso8601
+      "2001-12-14 21:59:43.10 -5", # space separated
+      "2001-12-15 2:59:43.10" # no time zone (Z)
+    ]
+
+    equivalent_values.each do |value|
+      success, result = subject.transform?(value)
+      success.should be_true
+      result.should == Time.utc(2001, 12, 15, 2, 59, 43, 100000)
+    end
+  end
+end

data/lib/puppet/vendor/safe_yaml/spec/transform/to_float_spec.rb

@@ -0,0 +1,42 @@
+require File.join(File.dirname(__FILE__), "..", "spec_helper")
+
+describe SafeYAML::Transform::ToFloat do
+  it "returns true when the value matches a valid Float" do
+    subject.transform?("20.00").should == [true, 20.0]
+  end
+
+  it "returns false when the value does not match a valid Float" do
+    subject.transform?("foobar").should be_false
+  end
+
+  it "returns false when the value spans multiple lines" do
+    subject.transform?("20.00\nNOT A FLOAT").should be_false
+  end
+
+  it "correctly parses all formats in the YAML spec" do
+    # canonical
+    subject.transform?("6.8523015e+5").should == [true, 685230.15]
+
+    # exponentioal
+    subject.transform?("685.230_15e+03").should == [true, 685230.15]
+
+    # fixed
+    subject.transform?("685_230.15").should == [true, 685230.15]
+
+    # sexagesimal
+    subject.transform?("190:20:30.15").should == [true, 685230.15]
+
+    # infinity
+    subject.transform?("-.inf").should == [true, (-1.0 / 0.0)]
+
+    # not a number
+    # NOTE: can't use == here since NaN != NaN
+    success, result = subject.transform?(".NaN")
+    success.should be_true; result.should be_nan
+  end
+
+  # issue 29
+  it "returns false for the string '.'" do
+    subject.transform?(".").should be_false
+  end
+end

data/lib/puppet/vendor/safe_yaml/spec/transform/to_integer_spec.rb

@@ -0,0 +1,59 @@
+require File.join(File.dirname(__FILE__), "..", "spec_helper")
+
+describe SafeYAML::Transform::ToInteger do
+  it "returns true when the value matches a valid Integer" do
+    subject.transform?("10").should == [true, 10]
+  end
+
+  it "returns false when the value does not match a valid Integer" do
+    subject.transform?("foobar").should be_false
+  end
+
+  it "returns false when the value spans multiple lines" do
+    subject.transform?("10\nNOT AN INTEGER").should be_false
+  end
+
+  it "allows commas in the number" do
+    subject.transform?("1,000").should == [true, 1000]
+  end
+
+  it "correctly parses numbers in octal format" do
+    subject.transform?("010").should == [true, 8]
+  end
+
+  it "correctly parses numbers in hexadecimal format" do
+    subject.transform?("0x1FF").should == [true, 511]
+  end
+
+  it "defaults to a string for a number that resembles octal format but is not" do
+    subject.transform?("09").should be_false
+  end
+
+  it "correctly parses 0 in decimal" do
+    subject.transform?("0").should == [true, 0]
+  end
+
+  it "defaults to a string for a number that resembles hexadecimal format but is not" do
+    subject.transform?("0x1G").should be_false
+  end
+
+  it "correctly parses all formats in the YAML spec" do
+    # canonical
+    subject.transform?("685230").should == [true, 685230]
+
+    # decimal
+    subject.transform?("+685_230").should == [true, 685230]
+
+    # octal
+    subject.transform?("02472256").should == [true, 685230]
+
+    # hexadecimal:
+    subject.transform?("0x_0A_74_AE").should == [true, 685230]
+
+    # binary
+    subject.transform?("0b1010_0111_0100_1010_1110").should == [true, 685230]
+
+    # sexagesimal
+    subject.transform?("190:20:30").should == [true, 685230]
+  end
+end

data/lib/puppet/vendor/safe_yaml/spec/transform/to_symbol_spec.rb

@@ -0,0 +1,49 @@
+require File.join(File.dirname(__FILE__), "..", "spec_helper")
+
+describe SafeYAML::Transform::ToSymbol do
+  def with_symbol_deserialization_value(value)
+    symbol_deserialization_flag = SafeYAML::OPTIONS[:deserialize_symbols]
+    SafeYAML::OPTIONS[:deserialize_symbols] = value
+
+    yield
+
+  ensure
+    SafeYAML::OPTIONS[:deserialize_symbols] = symbol_deserialization_flag
+  end
+
+  def with_symbol_deserialization(&block)
+    with_symbol_deserialization_value(true, &block)
+  end
+
+  def without_symbol_deserialization(&block)
+    with_symbol_deserialization_value(false, &block)
+  end
+
+  it "returns true when the value matches a valid Symbol" do
+    with_symbol_deserialization { subject.transform?(":foo")[0].should be_true }
+  end
+
+  it "returns true when the value matches a valid String+Symbol" do
+    with_symbol_deserialization { subject.transform?(':"foo"')[0].should be_true }
+  end
+
+  it "returns false when symbol deserialization is disabled" do
+    without_symbol_deserialization { subject.transform?(":foo").should be_false }
+  end
+
+  it "returns false when the value does not match a valid Symbol" do
+    with_symbol_deserialization { subject.transform?("foo").should be_false }
+  end
+
+  it "returns false when the symbol does not begin the line" do
+    with_symbol_deserialization do
+      subject.transform?("NOT A SYMBOL\n:foo").should be_false
+    end
+  end
+
+  it "returns false when the symbol does not end the line" do
+    with_symbol_deserialization do
+      subject.transform?(":foo\nNOT A SYMBOL").should be_false
+    end
+  end
+end

data/lib/puppet/version.rb

@@ -6,7 +6,7 @@
 # Raketasks and such to set the version based on the output of `git describe`
 #
 module Puppet
-  PUPPETVERSION = '2.7.21'
+  PUPPETVERSION = '2.7.22'
 
   def self.version
     @puppet_version || PUPPETVERSION

data/spec/lib/puppet_spec/matchers.rb

@@ -85,3 +85,11 @@ RSpec::Matchers.define :have_printed do |expected|
 
   diffable
 end
+
+RSpec::Matchers.define :equal_attributes_of do |expected|
+  match do |actual|
+    actual.instance_variables.all? do |attr|
+      actual.instance_variable_get(attr) == expected.instance_variable_get(attr)
+    end
+  end
+end

data/spec/unit/file_serving/metadata_spec.rb

@@ -33,14 +33,6 @@ describe Puppet::FileServing::Metadata do
   describe "when serializing" do
     let(:metadata) { Puppet::FileServing::Metadata.new(foobar) }
 
-    it "should perform pson serialization by calling to_pson on it's pson_data_hash" do
-      pdh = mock "data hash"
-      pdh_as_pson = mock "data as pson"
-      metadata.expects(:to_pson_data_hash).returns pdh
-      pdh.expects(:to_pson).returns pdh_as_pson
-      metadata.to_pson.should == pdh_as_pson
-    end
-
     it "should serialize as FileMetadata" do
       metadata.to_pson_data_hash['document_type'].should == "FileMetadata"
     end
@@ -49,48 +41,48 @@ describe Puppet::FileServing::Metadata do
       metadata.to_pson_data_hash['data'].keys.sort.should == %w{ path relative_path links owner group mode checksum type destination }.sort
     end
 
-    it "should pass the path in the hash verbatum" do
-      metadata.to_pson_data_hash['data']['path'] == metadata.path
+    it "should pass the path in the hash verbatim" do
+      metadata.to_pson_data_hash['data']['path'].should == metadata.path
     end
 
-    it "should pass the relative_path in the hash verbatum" do
-      metadata.to_pson_data_hash['data']['relative_path'] == metadata.relative_path
+    it "should pass the relative_path in the hash verbatim" do
+      metadata.to_pson_data_hash['data']['relative_path'].should == metadata.relative_path
     end
 
-    it "should pass the links in the hash verbatum" do
-      metadata.to_pson_data_hash['data']['links'] == metadata.links
+    it "should pass the links in the hash verbatim" do
+      metadata.to_pson_data_hash['data']['links'].should == metadata.links
     end
 
-    it "should pass the path owner in the hash verbatum" do
-      metadata.to_pson_data_hash['data']['owner'] == metadata.owner
+    it "should pass the path owner in the hash verbatim" do
+      metadata.to_pson_data_hash['data']['owner'].should == metadata.owner
     end
 
-    it "should pass the group in the hash verbatum" do
-      metadata.to_pson_data_hash['data']['group'] == metadata.group
+    it "should pass the group in the hash verbatim" do
+      metadata.to_pson_data_hash['data']['group'].should == metadata.group
     end
 
-    it "should pass the mode in the hash verbatum" do
-      metadata.to_pson_data_hash['data']['mode'] == metadata.mode
+    it "should pass the mode in the hash verbatim" do
+      metadata.to_pson_data_hash['data']['mode'].should == metadata.mode
     end
 
-    it "should pass the ftype in the hash verbatum as the 'type'" do
-      metadata.to_pson_data_hash['data']['type'] == metadata.ftype
+    it "should pass the ftype in the hash verbatim as the 'type'" do
+      metadata.to_pson_data_hash['data']['type'].should == metadata.ftype
     end
 
-    it "should pass the destination verbatum" do
-      metadata.to_pson_data_hash['data']['destination'] == metadata.destination
+    it "should pass the destination verbatim" do
+      metadata.to_pson_data_hash['data']['destination'].should == metadata.destination
     end
 
     it "should pass the checksum in the hash as a nested hash" do
       metadata.to_pson_data_hash['data']['checksum'].should be_is_a(Hash)
     end
 
-    it "should pass the checksum_type in the hash verbatum as the checksum's type" do
-      metadata.to_pson_data_hash['data']['checksum']['type'] == metadata.checksum_type
+    it "should pass the checksum_type in the hash verbatim as the checksum's type" do
+      metadata.to_pson_data_hash['data']['checksum']['type'].should == metadata.checksum_type
     end
 
-    it "should pass the checksum in the hash verbatum as the checksum's value" do
-      metadata.to_pson_data_hash['data']['checksum']['value'] == metadata.checksum
+    it "should pass the checksum in the hash verbatim as the checksum's value" do
+      metadata.to_pson_data_hash['data']['checksum']['value'].should == metadata.checksum
     end
 
   end

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

@@ -24,4 +24,45 @@ describe Puppet::Transaction::Report::Rest do
     Puppet::Transaction::Report::Rest.server.should_not be_nil
     Puppet::Transaction::Report::Rest.port.should_not be_nil
   end
+
+  let(:model) { Puppet::Transaction::Report }
+  let(:terminus_class) { Puppet::Transaction::Report::Rest }
+  let(:terminus) { model.indirection.terminus(:rest) }
+  let(:indirection) { model.indirection }
+
+  before(:each) do
+    Puppet::Transaction::Report.indirection.terminus_class = :rest
+  end
+
+  def mock_response(code, body, content_type='text/plain', encoding=nil)
+    obj = stub('http 200 ok', :code => code.to_s, :body => body)
+    obj.stubs(:[]).with('content-type').returns(content_type)
+    obj.stubs(:[]).with('content-encoding').returns(encoding)
+    obj
+  end
+
+  def save_request(key, instance)
+    Puppet::Indirector::Request.new(:report, :find, key, instance)
+  end
+
+  describe "#save" do
+    let(:http_method) { :put }
+    let(:response) { mock_response(200, 'body') }
+    let(:connection) { stub('mock http connection', :put => response, :verify_callback= => nil) }
+    let(:instance) { model.new('the thing', 'some contents') }
+    let(:request) { save_request(instance.name, instance) }
+
+    before :each do
+      terminus.stubs(:network).returns(connection)
+    end
+
+    it "deserializes the response as an array of report processor names" do
+      processors = ["store", "http"]
+      body = YAML.dump(processors)
+      response = mock_response('200', body, 'text/yaml')
+      connection.expects(:put).returns response
+
+      terminus.save(request).should == ["store", "http"]
+    end
+  end
 end

data/spec/unit/indirector/rest_spec.rb

@@ -1,57 +1,140 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
+require 'puppet/indirector'
+require 'puppet/indirector/errors'
 require 'puppet/indirector/rest'
 
-shared_examples_for "a REST http call" do
-  it "should accept a path" do
-    lambda { @search.send(@method, *@arguments) }.should_not raise_error(ArgumentError)
-  end
+# Just one from each category since the code makes no real distinctions
+HTTP_ERROR_CODES = [300, 400, 500]
+shared_examples_for "a REST terminus method" do |terminus_method|
+  HTTP_ERROR_CODES.each do |code|
+    describe "when the response code is #{code}" do
+      let(:response) { mock_response(code, 'error messaged!!!') }
+
+      it "raises an http error with the body of the response" do
+        expect {
+          terminus.send(terminus_method, request)
+        }.to raise_error(Net::HTTPError, "Error #{code} on SERVER: #{response.body}")
+      end
+
+      it "does not attempt to deserialize the response" do
+        model.expects(:convert_from).never
+
+        expect {
+          terminus.send(terminus_method, request)
+        }.to raise_error(Net::HTTPError)
+      end
+
+      # I'm not sure what this means or if it's used
+      it "if the body is empty raises an http error with the response header" do
+        response.stubs(:body).returns ""
+        response.stubs(:message).returns "fhqwhgads"
+
+        expect {
+          terminus.send(terminus_method, request)
+        }.to raise_error(Net::HTTPError, "Error #{code} on SERVER: #{response.message}")
+      end
 
-  it "should require a path" do
-    lambda { @searcher.send(@method) }.should raise_error(ArgumentError)
+      describe "and the body is compressed" do
+        it "raises an http error with the decompressed body of the response" do
+          uncompressed_body = "why"
+          compressed_body = Zlib::Deflate.deflate(uncompressed_body)
+
+          response = mock_response(code, compressed_body, 'text/plain', 'deflate')
+          connection.expects(http_method).returns(response)
+
+          expect {
+            terminus.send(terminus_method, request)
+          }.to raise_error(Net::HTTPError, "Error #{code} on SERVER: #{uncompressed_body}")
+        end
+      end
+    end
   end
+end
 
-  it "should return the results of deserializing the response to the request" do
-    conn = mock 'connection'
-    conn.stubs(:put).returns @response
-    conn.stubs(:delete).returns @response
-    conn.stubs(:get).returns @response
-    Puppet::Network::HttpPool.stubs(:http_instance).returns conn
+shared_examples_for "a deserializing terminus method" do |terminus_method|
+  describe "when the response has no content-type" do
+    let(:response) { mock_response(200, "body", nil, nil) }
+    it "raises an error" do
+      expect {
+        terminus.send(terminus_method, request)
+      }.to raise_error(RuntimeError, "No content type in http response; cannot parse")
+    end
+  end
 
-    @searcher.expects(:deserialize).with(@response).returns "myobject"
+  it "doesn't catch errors in deserialization" do
+    model.expects(:convert_from).raises(Puppet::Error, "Whoa there")
 
-    @searcher.send(@method, *@arguments).should == 'myobject'
+    expect { terminus.send(terminus_method, request) }.to raise_error(Puppet::Error, "Whoa there")
   end
 end
 
 describe Puppet::Indirector::REST do
   before :all do
-    Puppet::Indirector::Terminus.stubs(:register_terminus_class)
-    @model = stub('model', :supported_formats => %w{}, :convert_from => nil)
-    @instance = stub('model instance', :name= => nil)
-    @indirection = stub('indirection', :name => :mystuff, :register_terminus_type => nil, :model => @model)
-    Puppet::Indirector::Indirection.expects(:instance).returns(@indirection)
-
-    module This
-      module Is
-        module A
-          module Test
-          end
-        end
+    class Puppet::TestModel
+      extend Puppet::Indirector
+      indirects :test_model
+      attr_accessor :name, :data
+      def initialize(name = "name", data = '')
+        @name = name
+        @data = data
+      end
+
+      def self.convert_from(format, string)
+        new('', string)
+      end
+
+      def self.convert_from_multiple(format, string)
+        string.split(',').collect { |s| convert_from(format, s) }
+      end
+
+      def ==(other)
+        other.is_a? Puppet::TestModel and other.name == name and other.data == data
       end
     end
-    @rest_class = class This::Is::A::Test::Class < Puppet::Indirector::REST
-      self
+
+    # The subclass must not be all caps even though the superclass is
+    class Puppet::TestModel::Rest < Puppet::Indirector::REST
     end
+
+    Puppet::TestModel.indirection.terminus_class = :rest
+  end
+
+  after :all do
+    # Remove the class, unlinking it from the rest of the system.
+    Puppet.send(:remove_const, :TestModel)
+  end
+
+  let(:terminus_class) { Puppet::TestModel::Rest }
+  let(:terminus) { Puppet::TestModel.indirection.terminus(:rest) }
+  let(:indirection) { Puppet::TestModel.indirection }
+  let(:model) { Puppet::TestModel }
+
+  def mock_response(code, body, content_type='text/plain', encoding=nil)
+    obj = stub('http 200 ok', :code => code.to_s, :body => body)
+    obj.stubs(:[]).with('content-type').returns(content_type)
+    obj.stubs(:[]).with('content-encoding').returns(encoding)
+    obj
+  end
+
+  def find_request(key, options={})
+    Puppet::Indirector::Request.new(:test_model, :find, key, options)
+  end
+
+  def head_request(key, options={})
+    Puppet::Indirector::Request.new(:test_model, :head, key, options)
+  end
+
+  def search_request(key, options={})
+    Puppet::Indirector::Request.new(:test_model, :search, key, options)
   end
 
-  before :each do
-    @response = stub('mock response', :body => 'result', :code => "200")
-    @response.stubs(:[]).with('content-type').returns "text/plain"
-    @response.stubs(:[]).with('content-encoding').returns nil
+  def delete_request(key, options={})
+    Puppet::Indirector::Request.new(:test_model, :destroy, key, options)
+  end
 
-    @searcher = @rest_class.new
-    @searcher.stubs(:model).returns @model
+  def save_request(key, instance)
+    Puppet::Indirector::Request.new(:test_model, :save, key, instance)
   end
 
   it "should include the v1 REST API module" do
@@ -59,35 +142,35 @@ describe Puppet::Indirector::REST do
   end
 
   it "should have a method for specifying what setting a subclass should use to retrieve its server" do
-    @rest_class.should respond_to(:use_server_setting)
+    terminus_class.should respond_to(:use_server_setting)
   end
 
   it "should use any specified setting to pick the server" do
-    @rest_class.expects(:server_setting).returns :servset
-    Puppet.settings.expects(:value).with(:servset).returns "myserver"
-    @rest_class.server.should == "myserver"
+    terminus_class.expects(:server_setting).returns :inventory_server
+    Puppet[:inventory_server] = "myserver"
+    terminus_class.server.should == "myserver"
   end
 
   it "should default to :server for the server setting" do
-    @rest_class.expects(:server_setting).returns nil
-    Puppet.settings.expects(:value).with(:server).returns "myserver"
-    @rest_class.server.should == "myserver"
+    terminus_class.expects(:server_setting).returns nil
+    Puppet[:server] = "myserver"
+    terminus_class.server.should == "myserver"
   end
 
   it "should have a method for specifying what setting a subclass should use to retrieve its port" do
-    @rest_class.should respond_to(:use_port_setting)
+    terminus_class.should respond_to(:use_port_setting)
   end
 
   it "should use any specified setting to pick the port" do
-    @rest_class.expects(:port_setting).returns :servset
-    Puppet.settings.expects(:value).with(:servset).returns "321"
-    @rest_class.port.should == 321
+    terminus_class.expects(:port_setting).returns :ca_port
+    Puppet[:ca_port] = "321"
+    terminus_class.port.should == 321
   end
 
   it "should default to :port for the port setting" do
-    @rest_class.expects(:port_setting).returns nil
-    Puppet.settings.expects(:value).with(:masterport).returns "543"
-    @rest_class.port.should == 543
+    terminus_class.expects(:port_setting).returns nil
+    Puppet[:masterport] = "543"
+    terminus_class.port.should == 543
   end
 
   describe "when making http requests" do
@@ -112,24 +195,24 @@ describe Puppet::Indirector::REST do
     end
 
     it "should provide a useful error message when one is available and certificate validation fails", :unless => Puppet.features.microsoft_windows? do
-      @searcher.stubs(:network).
+      terminus.stubs(:network).
         returns(a_connection_that_verifies(:has_passed_pre_checks => false,
                                            :in_context => a_store_context(:for_server => 'not_my_server',
                                                                           :with_error_string => 'shady looking signature'),
                                            :fails_with => 'certificate verify failed'))
       expect do
-        @searcher.http_request(:get, stub('request'))
+        terminus.http_request(:get, stub('request'))
       end.to raise_error(Puppet::Error, "certificate verify failed: [shady looking signature for /CN=not_my_server]")
     end
 
     it "should provide a helpful error message when hostname was not match with server certificate", :unless => Puppet.features.microsoft_windows? do
-      @searcher.stubs(:network).
+      terminus.stubs(:network).
         returns(a_connection_that_verifies(:has_passed_pre_checks => true,
                                            :in_context => a_store_context(:for_server => 'not_my_server',
                                                                           :for_aliases => 'foo,bar,baz'),
                                            :fails_with => 'hostname was not match with server certificate'))
 
-      expect { @searcher.http_request(:get, stub('request')) }.
+      expect { terminus.http_request(:get, stub('request')) }.
         to raise_error(Puppet::Error) do |error|
           error.message =~ /Server hostname 'my_server' did not match server certificate; expected one of (.+)/
           $1.split(', ').should =~ %w[DNS:foo DNS:bar DNS:baz DNS:not_my_server not_my_server]
@@ -138,115 +221,16 @@ describe Puppet::Indirector::REST do
 
     it "should pass along the error message otherwise" do
       connection = Net::HTTP.new('my_server', 8140)
-      @searcher.stubs(:network).returns(connection)
+      terminus.stubs(:network).returns(connection)
 
       connection.stubs(:get).raises(OpenSSL::SSL::SSLError.new('some other message'))
 
       expect do
-        @searcher.http_request(:get, stub('request'))
+        terminus.http_request(:get, stub('request'))
       end.to raise_error(/some other message/)
     end
   end
 
-  describe "when deserializing responses" do
-    it "should return nil if the response code is 404" do
-      response = mock 'response'
-      response.expects(:code).returns "404"
-
-      @searcher.deserialize(response).should be_nil
-    end
-
-    [300,400,403,405,500,501,502,503,504].each { |rc|
-      describe "when the response code is #{rc}" do
-        before :each do
-          @model.expects(:convert_from).never
-
-          @response = mock 'response'
-          @response.stubs(:code).returns rc.to_s
-          @response.stubs(:[]).with('content-encoding').returns nil
-          @response.stubs(:message).returns "There was a problem (header)"
-        end
-
-        it "should fail" do
-          @response.stubs(:body).returns nil
-          lambda { @searcher.deserialize(@response) }.should raise_error(Net::HTTPError)
-        end
-
-        it "should take the error message from the body, if present" do
-          @response.stubs(:body).returns "There was a problem (body)"
-          lambda { @searcher.deserialize(@response) }.should raise_error(Net::HTTPError,"Error #{rc} on SERVER: There was a problem (body)")
-        end
-
-        it "should take the error message from the response header if the body is empty" do
-          @response.stubs(:body).returns ""
-          lambda { @searcher.deserialize(@response) }.should raise_error(Net::HTTPError,"Error #{rc} on SERVER: There was a problem (header)")
-        end
-
-        it "should take the error message from the response header if the body is absent" do
-          @response.stubs(:body).returns nil
-          lambda { @searcher.deserialize(@response) }.should raise_error(Net::HTTPError,"Error #{rc} on SERVER: There was a problem (header)")
-        end
-
-        describe "and with http compression" do
-          it "should uncompress the body" do
-            @response.stubs(:body).returns("compressed body")
-            @searcher.expects(:uncompress_body).with(@response).returns("uncompressed")
-            lambda { @searcher.deserialize(@response) }.should raise_error { |e| e.message =~ /uncompressed/ }
-          end
-        end
-      end
-    }
-
-    it "should return the results of converting from the format specified by the content-type header if the response code is in the 200s" do
-      @model.expects(:convert_from).with("myformat", "mydata").returns "myobject"
-
-      response = mock 'response'
-      response.stubs(:[]).with("content-type").returns "myformat"
-      response.stubs(:[]).with("content-encoding").returns nil
-      response.stubs(:body).returns "mydata"
-      response.stubs(:code).returns "200"
-
-      @searcher.deserialize(response).should == "myobject"
-    end
-
-    it "should convert and return multiple instances if the return code is in the 200s and 'multiple' is specified" do
-      @model.expects(:convert_from_multiple).with("myformat", "mydata").returns "myobjects"
-
-      response = mock 'response'
-      response.stubs(:[]).with("content-type").returns "myformat"
-      response.stubs(:[]).with("content-encoding").returns nil
-      response.stubs(:body).returns "mydata"
-      response.stubs(:code).returns "200"
-
-      @searcher.deserialize(response, true).should == "myobjects"
-    end
-
-    it "should strip the content-type header to keep only the mime-type" do
-      @model.expects(:convert_from).with("text/plain", "mydata").returns "myobject"
-
-      response = mock 'response'
-      response.stubs(:[]).with("content-type").returns "text/plain; charset=utf-8"
-      response.stubs(:[]).with("content-encoding").returns nil
-      response.stubs(:body).returns "mydata"
-      response.stubs(:code).returns "200"
-
-      @searcher.deserialize(response)
-    end
-
-    it "should uncompress the body" do
-      @model.expects(:convert_from).with("myformat", "uncompressed mydata").returns "myobject"
-
-      response = mock 'response'
-      response.stubs(:[]).with("content-type").returns "myformat"
-      response.stubs(:body).returns "compressed mydata"
-      response.stubs(:code).returns "200"
-
-      @searcher.expects(:uncompress_body).with(response).returns("uncompressed mydata")
-
-      @searcher.deserialize(response).should == "myobject"
-    end
-  end
-
   describe "when creating an HTTP client" do
     before do
       Puppet.settings.stubs(:value).returns("rest_testing")
@@ -254,38 +238,42 @@ describe Puppet::Indirector::REST do
 
     it "should use the class's server and port if the indirection request provides neither" do
       @request = stub 'request', :key => "foo", :server => nil, :port => nil
-      @searcher.class.expects(:port).returns 321
-      @searcher.class.expects(:server).returns "myserver"
+      terminus.class.expects(:port).returns 321
+      terminus.class.expects(:server).returns "myserver"
       Puppet::Network::HttpPool.expects(:http_instance).with("myserver", 321).returns "myconn"
-      @searcher.network(@request).should == "myconn"
+      terminus.network(@request).should == "myconn"
     end
 
     it "should use the server from the indirection request if one is present" do
       @request = stub 'request', :key => "foo", :server => "myserver", :port => nil
-      @searcher.class.stubs(:port).returns 321
+      terminus.class.stubs(:port).returns 321
       Puppet::Network::HttpPool.expects(:http_instance).with("myserver", 321).returns "myconn"
-      @searcher.network(@request).should == "myconn"
+      terminus.network(@request).should == "myconn"
     end
 
     it "should use the port from the indirection request if one is present" do
       @request = stub 'request', :key => "foo", :server => nil, :port => 321
-      @searcher.class.stubs(:server).returns "myserver"
+      terminus.class.stubs(:server).returns "myserver"
       Puppet::Network::HttpPool.expects(:http_instance).with("myserver", 321).returns "myconn"
-      @searcher.network(@request).should == "myconn"
+      terminus.network(@request).should == "myconn"
     end
   end
 
-  describe "when doing a find" do
-    before :each do
-      @connection = stub('mock http connection', :get => @response, :verify_callback= => nil)
-      @searcher.stubs(:network).returns(@connection)    # neuter the network connection
+  describe "#find" do
+    let(:http_method) { :get }
+    let(:response) { mock_response(200, 'body') }
+    let(:connection) { stub('mock http connection', :get => response, :verify_callback= => nil) }
+    let(:request) { find_request('foo') }
 
-      # Use a key with spaces, so we can test escaping
-      @request = Puppet::Indirector::Request.new(:foo, :find, "foo bar", :environment => "myenv")
+    before :each do
+      terminus.stubs(:network).returns(connection)
     end
 
-    describe "with a large body" do
-      it "should use the POST http method" do
+    it_behaves_like 'a REST terminus method', :find
+    it_behaves_like 'a deserializing terminus method', :find
+
+    describe "with a long set of parameters" do
+      it "calls post on the connection with the query params in the body" do
         params = {}
         'aa'.upto('zz') do |s|
           params[s] = 'foo'
@@ -296,283 +284,270 @@ describe Puppet::Indirector::REST do
         # to avoid a failure.
         params.delete('ip')
 
-        @request = Puppet::Indirector::Request.new(:foo, :find, "foo bar", params.merge(:environment => "myenv"))
+        request = find_request('whoa', params)
 
-        @connection.expects(:post).with do |uri, body|
-          uri == "/myenv/foo/foo%20bar" and body.split("&").sort == params.map {|key,value| "#{key}=#{value}"}.sort
-        end.returns(@response)
+        connection.expects(:post).with do |uri, body|
+          body.split("&").sort == params.map {|key,value| "#{key}=#{value}"}.sort
+        end.returns(mock_response(200, 'body'))
 
-        @searcher.find(@request)
+        terminus.find(request)
       end
     end
 
-    describe "with a small body" do
-      it "should use the GET http method" do
-        @searcher.expects(:network).returns @connection
-        @connection.expects(:get).returns @response
-        @searcher.find(@request)
+    describe "with no parameters" do
+      it "calls get on the connection" do
+        request = find_request('foo bar')
+
+        connection.expects(:get).with('/production/test_model/foo%20bar?', anything).returns(mock_response('200', 'response body'))
+
+        terminus.find(request).should == model.new('foo bar', 'response body')
       end
     end
 
-    it "should deserialize and return the http response, setting name" do
-      @connection.expects(:get).returns @response
+    it "returns nil on 404" do
+      response = mock_response('404', nil)
 
-      instance = stub 'object'
-      instance.expects(:name=)
-      @searcher.expects(:deserialize).with(@response).returns instance
+      connection.expects(:get).returns(response)
 
-      @searcher.find(@request).should == instance
+      terminus.find(request).should == nil
     end
 
-    it "should deserialize and return the http response, and not require name=" do
-      @connection.expects(:get).returns @response
+    it "asks the model to deserialize the response body and sets the name on the resulting object to the find key" do
+      connection.expects(:get).returns response
 
-      instance = stub 'object'
-      @searcher.expects(:deserialize).with(@response).returns instance
+      model.expects(:convert_from).with(response['content-type'], response.body).returns(
+        model.new('overwritten', 'decoded body')
+      )
 
-      @searcher.find(@request).should == instance
+      terminus.find(request).should == model.new('foo', 'decoded body')
     end
 
-    it "should use the URI generated by the Handler module" do
-      @connection.expects(:get).with { |path, args| path == "/myenv/foo/foo%20bar?" }.returns(@response)
-      @searcher.find(@request)
-    end
+    it "doesn't require the model to support name=" do
+      connection.expects(:get).returns response
+      instance = model.new('name', 'decoded body')
 
-    it "should provide an Accept header containing the list of supported formats joined with commas" do
-      @connection.expects(:get).with { |path, args| args["Accept"] == "supported, formats" }.returns(@response)
+      model.expects(:convert_from).with(response['content-type'], response.body).returns(instance)
+      instance.expects(:respond_to?).with(:name=).returns(false)
+      instance.expects(:name=).never
 
-      @searcher.model.expects(:supported_formats).returns %w{supported formats}
-      @searcher.find(@request)
+      terminus.find(request).should == model.new('name', 'decoded body')
     end
 
-    it "should add Accept-Encoding header" do
-      @searcher.expects(:add_accept_encoding).returns({"accept-encoding" => "gzip"})
+    it "provides an Accept header containing the list of supported formats joined with commas" do
+      connection.expects(:get).with(anything, has_entry("Accept" => "supported, formats")).returns(response)
 
-      @connection.expects(:get).with { |path, args| args["accept-encoding"] == "gzip" }.returns(@response)
-      @searcher.find(@request)
+      terminus.model.expects(:supported_formats).returns %w{supported formats}
+      terminus.find(request)
     end
 
-    it "should deserialize and return the network response" do
-      @searcher.expects(:deserialize).with(@response).returns @instance
-      @searcher.find(@request).should equal(@instance)
-    end
+    it "adds an Accept-Encoding header" do
+      terminus.expects(:add_accept_encoding).returns({"accept-encoding" => "gzip"})
 
-    it "should set the name of the resulting instance to the asked-for name" do
-      @searcher.expects(:deserialize).with(@response).returns @instance
-      @instance.expects(:name=).with "foo bar"
-      @searcher.find(@request)
-    end
+      connection.expects(:get).with(anything, has_entry("accept-encoding" => "gzip")).returns(response)
 
-    it "should generate an error when result data deserializes fails" do
-      @searcher.expects(:deserialize).raises(ArgumentError)
-      lambda { @searcher.find(@request) }.should raise_error(ArgumentError)
+      terminus.find(request)
     end
-  end
 
-  describe "when doing a head" do
-    before :each do
-      @connection = stub('mock http connection', :head => @response, :verify_callback= => nil)
-      @searcher.stubs(:network).returns(@connection)
+    it "uses only the mime-type from the content-type header when asking the model to deserialize" do
+      response = mock_response('200', 'mydata', "text/plain; charset=utf-8")
+      connection.expects(:get).returns(response)
+
+      model.expects(:convert_from).with("text/plain", "mydata").returns "myobject"
 
-      # Use a key with spaces, so we can test escaping
-      @request = Puppet::Indirector::Request.new(:foo, :head, "foo bar")
+      terminus.find(request).should == "myobject"
     end
 
-    it "should call the HEAD http method on a network connection" do
-      @searcher.expects(:network).returns @connection
-      @connection.expects(:head).returns @response
-      @searcher.head(@request)
+    it "decompresses the body before passing it to the model for deserialization" do
+      uncompressed_body = "Why hello there"
+      compressed_body = Zlib::Deflate.deflate(uncompressed_body)
+
+      response = mock_response('200', compressed_body, 'text/plain', 'deflate')
+      connection.expects(:get).returns(response)
+
+      model.expects(:convert_from).with("text/plain", uncompressed_body).returns "myobject"
+
+      terminus.find(request).should == "myobject"
     end
+  end
 
-    it "should return true if there was a successful http response" do
-      @connection.expects(:head).returns @response
-      @response.stubs(:code).returns "200"
+  describe "#head" do
+    let(:http_method) { :head }
+    let(:response) { mock_response(200, nil) }
+    let(:connection) { stub('mock http connection', :head => response, :verify_callback= => nil) }
+    let(:request) { head_request('foo') }
 
-      @searcher.head(@request).should == true
+    before :each do
+      terminus.stubs(:network).returns(connection)
     end
 
-    it "should return false if there was a successful http response" do
-      @connection.expects(:head).returns @response
-      @response.stubs(:code).returns "404"
+    it_behaves_like 'a REST terminus method', :head
+
+    it "returns true if there was a successful http response" do
+      connection.expects(:head).returns mock_response('200', nil)
 
-      @searcher.head(@request).should == false
+      terminus.head(request).should == true
     end
 
-    it "should use the URI generated by the Handler module" do
-      @searcher.expects(:indirection2uri).with(@request).returns "/my/uri"
-      @connection.expects(:head).with { |path, args| path == "/my/uri" }.returns(@response)
-      @searcher.head(@request)
+    it "returns false on a 404 response" do
+      connection.expects(:head).returns mock_response('404', nil)
+
+      terminus.head(request).should == false
     end
   end
 
-  describe "when doing a search" do
-    before :each do
-      @connection = stub('mock http connection', :get => @response, :verify_callback= => nil)
-      @searcher.stubs(:network).returns(@connection)    # neuter the network connection
-
-      @model.stubs(:convert_from_multiple)
+  describe "#search" do
+    let(:http_method) { :get }
+    let(:response) { mock_response(200, 'data1,data2,data3') }
+    let(:connection) { stub('mock http connection', :get => response, :verify_callback= => nil) }
+    let(:request) { search_request('foo') }
 
-      @request = Puppet::Indirector::Request.new(:foo, :search, "foo bar")
+    before :each do
+      terminus.stubs(:network).returns(connection)
     end
 
+    it_behaves_like 'a REST terminus method', :search
+    it_behaves_like 'a deserializing terminus method', :search
+
     it "should call the GET http method on a network connection" do
-      @searcher.expects(:network).returns @connection
-      @connection.expects(:get).returns @response
-      @searcher.search(@request)
+      connection.expects(:get).with('/production/test_models/foo', has_key('Accept')).returns mock_response(200, 'data3, data4')
+
+      terminus.search(request)
     end
 
-    it "should deserialize as multiple instances and return the http response" do
-      @connection.expects(:get).returns @response
-      @searcher.expects(:deserialize).with(@response, true).returns "myobject"
+    it "returns an empty list on 404" do
+      response = mock_response('404', nil)
+
+      connection.expects(:get).returns(response)
 
-      @searcher.search(@request).should == 'myobject'
+      terminus.search(request).should == []
     end
 
-    it "should use the URI generated by the Handler module" do
-      @searcher.expects(:indirection2uri).with(@request).returns "/mys/uri"
-      @connection.expects(:get).with { |path, args| path == "/mys/uri" }.returns(@response)
-      @searcher.search(@request)
+    it "asks the model to deserialize the response body into multiple instances" do
+      terminus.search(request).should == [model.new('', 'data1'), model.new('', 'data2'), model.new('', 'data3')]
     end
 
     it "should provide an Accept header containing the list of supported formats joined with commas" do
-      @connection.expects(:get).with { |path, args| args["Accept"] == "supported, formats" }.returns(@response)
+      connection.expects(:get).with(anything, has_entry("Accept" => "supported, formats")).returns(mock_response(200, ''))
 
-      @searcher.model.expects(:supported_formats).returns %w{supported formats}
-      @searcher.search(@request)
+      terminus.model.expects(:supported_formats).returns %w{supported formats}
+      terminus.search(request)
     end
 
     it "should return an empty array if serialization returns nil" do
-      @model.stubs(:convert_from_multiple).returns nil
+      model.stubs(:convert_from_multiple).returns nil
 
-      @searcher.search(@request).should == []
-    end
-
-    it "should generate an error when result data deserializes fails" do
-      @searcher.expects(:deserialize).raises(ArgumentError)
-      lambda { @searcher.search(@request) }.should raise_error(ArgumentError)
+      terminus.search(request).should == []
     end
   end
 
-  describe "when doing a destroy" do
-    before :each do
-      @connection = stub('mock http connection', :delete => @response, :verify_callback= => nil)
-      @searcher.stubs(:network).returns(@connection)    # neuter the network connection
+  describe "#destroy" do
+    let(:http_method) { :delete }
+    let(:response) { mock_response(200, 'body') }
+    let(:connection) { stub('mock http connection', :delete => response, :verify_callback= => nil) }
+    let(:request) { delete_request('foo') }
 
-      @request = Puppet::Indirector::Request.new(:foo, :destroy, "foo bar")
+    before :each do
+      terminus.stubs(:network).returns(connection)
     end
 
+    it_behaves_like 'a REST terminus method', :destroy
+    it_behaves_like 'a deserializing terminus method', :destroy
+
     it "should call the DELETE http method on a network connection" do
-      @searcher.expects(:network).returns @connection
-      @connection.expects(:delete).returns @response
-      @searcher.destroy(@request)
+      connection.expects(:delete).with('/production/test_model/foo', has_key('Accept')).returns(response)
+
+      terminus.destroy(request)
     end
 
     it "should fail if any options are provided, since DELETE apparently does not support query options" do
-      @request.stubs(:options).returns(:one => "two", :three => "four")
+      request = delete_request('foo', :one => "two", :three => "four")
 
-      lambda { @searcher.destroy(@request) }.should raise_error(ArgumentError)
+      expect { terminus.destroy(request) }.to raise_error(ArgumentError)
     end
 
     it "should deserialize and return the http response" do
-      @connection.expects(:delete).returns @response
-      @searcher.expects(:deserialize).with(@response).returns "myobject"
-
-      @searcher.destroy(@request).should == 'myobject'
-    end
+      connection.expects(:delete).returns response
 
-    it "should use the URI generated by the Handler module" do
-      @searcher.expects(:indirection2uri).with(@request).returns "/my/uri"
-      @connection.expects(:delete).with { |path, args| path == "/my/uri" }.returns(@response)
-      @searcher.destroy(@request)
+      terminus.destroy(request).should == model.new('', 'body')
     end
 
-    it "should not include the query string" do
-      @connection.stubs(:delete).returns @response
-      @searcher.destroy(@request)
-    end
+    it "returns nil on 404" do
+      response = mock_response('404', nil)
 
-    it "should provide an Accept header containing the list of supported formats joined with commas" do
-      @connection.expects(:delete).with { |path, args| args["Accept"] == "supported, formats" }.returns(@response)
+      connection.expects(:delete).returns(response)
 
-      @searcher.model.expects(:supported_formats).returns %w{supported formats}
-      @searcher.destroy(@request)
+      terminus.destroy(request).should == nil
     end
 
-    it "should deserialize and return the network response" do
-      @searcher.expects(:deserialize).with(@response).returns @instance
-      @searcher.destroy(@request).should equal(@instance)
-    end
+    it "should provide an Accept header containing the list of supported formats joined with commas" do
+      connection.expects(:delete).with(anything, has_entry("Accept" => "supported, formats")).returns(response)
 
-    it "should generate an error when result data deserializes fails" do
-      @searcher.expects(:deserialize).raises(ArgumentError)
-      lambda { @searcher.destroy(@request) }.should raise_error(ArgumentError)
+      terminus.model.expects(:supported_formats).returns %w{supported formats}
+      terminus.destroy(request)
     end
   end
 
-  describe "when doing a save" do
-    before :each do
-      @connection = stub('mock http connection', :put => @response, :verify_callback= => nil)
-      @searcher.stubs(:network).returns(@connection)    # neuter the network connection
+  describe "#save" do
+    let(:http_method) { :put }
+    let(:response) { mock_response(200, 'body') }
+    let(:connection) { stub('mock http connection', :put => response, :verify_callback= => nil) }
+    let(:instance) { model.new('the thing', 'some contents') }
+    let(:request) { save_request(instance.name, instance) }
 
-      @instance = stub 'instance', :render => "mydata", :mime => "mime"
-      @request = Puppet::Indirector::Request.new(:foo, :save, "foo bar")
-      @request.instance = @instance
+    before :each do
+      terminus.stubs(:network).returns(connection)
     end
 
-    it "should call the PUT http method on a network connection" do
-      @searcher.expects(:network).returns @connection
-      @connection.expects(:put).returns @response
-      @searcher.save(@request)
-    end
+    it_behaves_like 'a REST terminus method', :save
 
-    it "should fail if any options are provided, since DELETE apparently does not support query options" do
-      @request.stubs(:options).returns(:one => "two", :three => "four")
+    it "should call the PUT http method on a network connection" do
+      connection.expects(:put).with('/production/test_model/the%20thing', anything, has_key("Content-Type")).returns response
 
-      lambda { @searcher.save(@request) }.should raise_error(ArgumentError)
+      terminus.save(request)
     end
 
-    it "should use the URI generated by the Handler module" do
-      @searcher.expects(:indirection2uri).with(@request).returns "/my/uri"
-      @connection.expects(:put).with { |path, args| path == "/my/uri" }.returns(@response)
-      @searcher.save(@request)
+    it "should fail if any options are provided, since PUT apparently does not support query options" do
+      request = save_request(instance, :one => "two", :three => "four")
+
+      expect { terminus.save(request) }.to raise_error(ArgumentError)
     end
 
     it "should serialize the instance using the default format and pass the result as the body of the request" do
-      @instance.expects(:render).returns "serial_instance"
-      @connection.expects(:put).with { |path, data, args| data == "serial_instance" }.returns @response
+      instance.expects(:render).returns "serial_instance"
+      connection.expects(:put).with(anything, "serial_instance", anything).returns response
 
-      @searcher.save(@request)
+      terminus.save(request)
     end
 
-    it "should deserialize and return the http response" do
-      @connection.expects(:put).returns @response
-      @searcher.expects(:deserialize).with(@response).returns "myobject"
+    it "returns nil on 404" do
+      response = mock_response('404', nil)
 
-      @searcher.save(@request).should == 'myobject'
+      connection.expects(:put).returns(response)
+
+      terminus.save(request).should == nil
     end
 
-    it "should provide an Accept header containing the list of supported formats joined with commas" do
-      @connection.expects(:put).with { |path, data, args| args["Accept"] == "supported, formats" }.returns(@response)
+    it "returns nil" do
+      connection.expects(:put).returns response
 
-      @searcher.model.expects(:supported_formats).returns %w{supported formats}
-      @searcher.save(@request)
+      terminus.save(request).should be_nil
     end
 
-    it "should provide a Content-Type header containing the mime-type of the sent object" do
-      @connection.expects(:put).with { |path, data, args| args['Content-Type'] == "mime" }.returns(@response)
+    it "should provide an Accept header containing the list of supported formats joined with commas" do
+      connection.expects(:put).with(anything, anything, has_entry("Accept" => "supported, formats")).returns(response)
 
-      @instance.expects(:mime).returns "mime"
-      @searcher.save(@request)
-    end
+      instance.expects(:render).returns('')
+      model.expects(:supported_formats).returns %w{supported formats}
+      instance.expects(:mime).returns "supported"
 
-    it "should deserialize and return the network response" do
-      @searcher.expects(:deserialize).with(@response).returns @instance
-      @searcher.save(@request).should equal(@instance)
+      terminus.save(request)
     end
 
-    it "should generate an error when result data deserializes fails" do
-      @searcher.expects(:deserialize).raises(ArgumentError)
-      lambda { @searcher.save(@request) }.should raise_error(ArgumentError)
+    it "should provide a Content-Type header containing the mime-type of the sent object" do
+      instance.expects(:mime).returns "mime"
+      connection.expects(:put).with(anything, anything, has_entry('Content-Type' => "mime")).returns(response)
+
+      terminus.save(request)
     end
   end
 end