puppet 2.7.26 → 3.0.0.rc4

data/spec/unit/indirector/resource/active_record_spec.rb

@@ -1,4 +1,4 @@
-#!/usr/bin/env rspec
+#! /usr/bin/env ruby -S rspec
 require 'spec_helper'
 require 'puppet/rails'
 require 'puppet/node/facts'
@@ -32,7 +32,7 @@ describe "Puppet::Resource::ActiveRecord", :if => can_use_scratch_database? do
 
     def search(type, host = 'default.local', filter = nil)
       args = { :host => host, :filter => filter }
-      subject.search(Puppet::Resource.indirection.request(:search, type, args))
+      subject.search(Puppet::Resource.indirection.request(:search, type, nil, args))
     end
 
     it "should return an empty array if no resources match" do

data/spec/unit/indirector/resource/ral_spec.rb

@@ -1,4 +1,4 @@
-#!/usr/bin/env rspec
+#! /usr/bin/env ruby -S rspec
 require 'spec_helper'
 
 describe "Puppet::Resource::Ral" do
@@ -18,7 +18,7 @@ describe "Puppet::Resource::Ral" do
       Puppet::Resource::Ral.new.find(@request).should == my_resource
     end
 
-    it "if there is no instance, it should create one", :'fails_on_ruby_1.9.2' => true do
+    it "if there is no instance, it should create one" do
       wrong_instance = stub "wrong user", :name => "bob"
       root = mock "Root User"
       root_resource = mock "Root Resource"

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

@@ -1,4 +1,4 @@
-#!/usr/bin/env rspec
+#! /usr/bin/env ruby -S rspec
 require 'spec_helper'
 
 require 'puppet/indirector/resource/rest'

data/spec/unit/indirector/resource/store_configs_spec.rb

@@ -1,4 +1,4 @@
-#!/usr/bin/env rspec
+#! /usr/bin/env ruby -S rspec
 require 'spec_helper'
 require 'puppet/resource'
 require 'puppet/indirector/memory'

data/spec/unit/indirector/resource_type/parser_spec.rb

@@ -1,4 +1,4 @@
-#!/usr/bin/env rspec
+#! /usr/bin/env ruby -S rspec
 require 'spec_helper'
 
 require 'puppet/indirector/resource_type/parser'
@@ -9,7 +9,7 @@ describe Puppet::Indirector::ResourceType::Parser do
 
   before do
     @terminus = Puppet::Indirector::ResourceType::Parser.new
-    @request = Puppet::Indirector::Request.new(:resource_type, :find, "foo")
+    @request = Puppet::Indirector::Request.new(:resource_type, :find, "foo", nil)
     @krt = @request.environment.known_resource_types
   end
 
@@ -31,7 +31,7 @@ describe Puppet::Indirector::ResourceType::Parser do
       Puppet[:modulepath] = dir
 
       # Make a new request, since we've reset the env
-      @request = Puppet::Indirector::Request.new(:resource_type, :find, "foo::bar")
+      @request = Puppet::Indirector::Request.new(:resource_type, :find, "foo::bar", nil)
 
       manifest_path = File.join(dir, "foo", "manifests")
       FileUtils.mkdir_p(manifest_path)
@@ -56,57 +56,157 @@ describe Puppet::Indirector::ResourceType::Parser do
   end
 
   describe "when searching" do
-    before do
-      @request.key = "*"
+    describe "when the search key is a wildcard" do
+      before do
+        @request.key = "*"
+      end
+
+      it "should use the request's environment's list of known resource types" do
+        @request.environment.known_resource_types.expects(:hostclasses).returns({})
+
+        @terminus.search(@request)
+      end
+
+      it "should return all results if '*' is provided as the search string" do
+        type = @krt.add(Puppet::Resource::Type.new(:hostclass, "foo"))
+        node = @krt.add(Puppet::Resource::Type.new(:node, "bar"))
+        define = @krt.add(Puppet::Resource::Type.new(:definition, "baz"))
+
+        result = @terminus.search(@request)
+        result.should be_include(type)
+        result.should be_include(node)
+        result.should be_include(define)
+      end
+
+      it "should return all known types" do
+        type = @krt.add(Puppet::Resource::Type.new(:hostclass, "foo"))
+        node = @krt.add(Puppet::Resource::Type.new(:node, "bar"))
+        define = @krt.add(Puppet::Resource::Type.new(:definition, "baz"))
+
+        result = @terminus.search(@request)
+        result.should be_include(type)
+        result.should be_include(node)
+        result.should be_include(define)
+      end
+
+      it "should not return the 'main' class" do
+        main = @krt.add(Puppet::Resource::Type.new(:hostclass, ""))
+
+        # So there is a return value
+        foo = @krt.add(Puppet::Resource::Type.new(:hostclass, "foo"))
+
+        @terminus.search(@request).should_not be_include(main)
+      end
+
+      it "should return nil if no types can be found" do
+        @terminus.search(@request).should be_nil
+      end
+
+      it "should load all resource types from all search paths" do
+        dir = tmpdir("searching_in_all")
+        first = File.join(dir, "first")
+        second = File.join(dir, "second")
+        FileUtils.mkdir_p(first)
+        FileUtils.mkdir_p(second)
+        Puppet[:modulepath] = "#{first}#{File::PATH_SEPARATOR}#{second}"
+
+        # Make a new request, since we've reset the env
+        @request = Puppet::Indirector::Request.new(:resource_type, :search, "*", nil)
+
+        onepath = File.join(first, "one", "manifests")
+        FileUtils.mkdir_p(onepath)
+        twopath = File.join(first, "two", "manifests")
+        FileUtils.mkdir_p(twopath)
+
+        File.open(File.join(onepath, "oneklass.pp"), "w") { |f| f.puts "class one::oneklass {}" }
+        File.open(File.join(twopath, "twoklass.pp"), "w") { |f| f.puts "class two::twoklass {}" }
+
+        result = @terminus.search(@request)
+        result.find { |t| t.name == "one::oneklass" }.should be_instance_of(Puppet::Resource::Type)
+        result.find { |t| t.name == "two::twoklass" }.should be_instance_of(Puppet::Resource::Type)
+      end
+
+      context "when specifying a 'kind' parameter" do
+        before :each do
+          @klass = @krt.add(Puppet::Resource::Type.new(:hostclass, "foo"))
+          @node = @krt.add(Puppet::Resource::Type.new(:node, "bar"))
+          @define = @krt.add(Puppet::Resource::Type.new(:definition, "baz"))
+        end
+
+        it "should raise an error if you pass an invalid kind filter" do
+          @request.options[:kind] = "i bet you don't have a kind called this"
+          expect {
+            @terminus.search(@request)
+          }.to raise_error(ArgumentError, /Unrecognized kind filter/)
+
+        end
+
+        it "should support filtering for only hostclass results" do
+          @request.options[:kind] = "class"
+
+          result = @terminus.search(@request)
+          result.should be_include(@klass)
+          result.should_not be_include(@node)
+          result.should_not be_include(@define)
+        end
+
+        it "should support filtering for only node results" do
+          @request.options[:kind] = "node"
+
+          result = @terminus.search(@request)
+          result.should_not be_include(@klass)
+          result.should be_include(@node)
+          result.should_not be_include(@define)
+        end
+
+        it "should support filtering for only definition results" do
+          @request.options[:kind] = "defined_type"
+
+          result = @terminus.search(@request)
+          result.should_not be_include(@klass)
+          result.should_not be_include(@node)
+          result.should be_include(@define)
+        end
+      end
     end
 
-    it "should use the request's environment's list of known resource types" do
-      @request.environment.known_resource_types.expects(:hostclasses).returns({})
-
-      @terminus.search(@request)
-    end
-
-    it "should return all results if '*' is provided as the search string" do
-      @request.key = "*"
-      type = @krt.add(Puppet::Resource::Type.new(:hostclass, "foo"))
-      node = @krt.add(Puppet::Resource::Type.new(:node, "bar"))
-      define = @krt.add(Puppet::Resource::Type.new(:definition, "baz"))
-
-      result = @terminus.search(@request)
-      result.should be_include(type)
-      result.should be_include(node)
-      result.should be_include(define)
-    end
-
-    it "should treat any search string not '*' as a regex" do
-      @request.key = "a"
-      foo = @krt.add(Puppet::Resource::Type.new(:hostclass, "foo"))
-      bar = @krt.add(Puppet::Resource::Type.new(:hostclass, "bar"))
-      baz = @krt.add(Puppet::Resource::Type.new(:hostclass, "baz"))
-
-      result = @terminus.search(@request)
-      result.should be_include(bar)
-      result.should be_include(baz)
-      result.should_not be_include(foo)
-    end
-
-    it "should fail if a provided search string is not '*' and is not a valid regex" do
-      @request.key = "*foo*"
-
-      # Add one instance so we don't just get an empty array"
-      @krt.add(Puppet::Resource::Type.new(:hostclass, "foo"))
-      lambda { @terminus.search(@request) }.should raise_error(ArgumentError)
-    end
-
-    it "should return all known types" do
-      type = @krt.add(Puppet::Resource::Type.new(:hostclass, "foo"))
-      node = @krt.add(Puppet::Resource::Type.new(:node, "bar"))
-      define = @krt.add(Puppet::Resource::Type.new(:definition, "baz"))
-
-      result = @terminus.search(@request)
-      result.should be_include(type)
-      result.should be_include(node)
-      result.should be_include(define)
+    context "when the search string is not a wildcard" do
+
+      it "should treat any search string as a regex" do
+        @request.key = "a"
+        foo = @krt.add(Puppet::Resource::Type.new(:hostclass, "foo"))
+        bar = @krt.add(Puppet::Resource::Type.new(:hostclass, "bar"))
+        baz = @krt.add(Puppet::Resource::Type.new(:hostclass, "baz"))
+
+        result = @terminus.search(@request)
+        result.should be_include(bar)
+        result.should be_include(baz)
+        result.should_not be_include(foo)
+      end
+
+      it "should support kind filtering with a regex" do
+        @request.key = "foo"
+        @request.options[:kind] = "class"
+
+        foobar = @krt.add(Puppet::Resource::Type.new(:hostclass, "foobar"))
+        foobaz = @krt.add(Puppet::Resource::Type.new(:hostclass, "foobaz"))
+        foobam = @krt.add(Puppet::Resource::Type.new(:definition, "foobam"))
+        fooball = @krt.add(Puppet::Resource::Type.new(:node, "fooball"))
+
+        result = @terminus.search(@request)
+        result.should be_include(foobar)
+        result.should be_include(foobaz)
+        result.should_not be_include(foobam)
+        result.should_not be_include(fooball)
+      end
+
+      it "should fail if a provided search string is not a valid regex" do
+        @request.key = "*foo*"
+
+        # Add one instance so we don't just get an empty array"
+        @krt.add(Puppet::Resource::Type.new(:hostclass, "foo"))
+        lambda { @terminus.search(@request) }.should raise_error(ArgumentError)
+      end
     end
 
     it "should not return the 'main' class" do
@@ -131,7 +231,7 @@ describe Puppet::Indirector::ResourceType::Parser do
       Puppet[:modulepath] = "#{first}#{File::PATH_SEPARATOR}#{second}"
 
       # Make a new request, since we've reset the env
-      @request = Puppet::Indirector::Request.new(:resource_type, :search, "*")
+      @request = Puppet::Indirector::Request.new(:resource_type, :search, "*", nil)
 
       onepath = File.join(first, "one", "manifests")
       FileUtils.mkdir_p(onepath)

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

@@ -1,4 +1,4 @@
-#!/usr/bin/env rspec
+#! /usr/bin/env ruby -S rspec
 require 'spec_helper'
 
 require 'puppet/indirector/resource_type/rest'

data/spec/unit/indirector/rest_spec.rb

@@ -1,140 +1,57 @@
-#!/usr/bin/env rspec
+#! /usr/bin/env ruby -S rspec
 require 'spec_helper'
-require 'puppet/indirector'
-require 'puppet/indirector/errors'
 require 'puppet/indirector/rest'
 
-# 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
-
-      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
+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
-end
 
-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
+  it "should require a path" do
+    lambda { @searcher.send(@method) }.should raise_error(ArgumentError)
   end
 
-  it "doesn't catch errors in deserialization" do
-    model.expects(:convert_from).raises(Puppet::Error, "Whoa there")
+  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
+
+    @searcher.expects(:deserialize).with(@response).returns "myobject"
 
-    expect { terminus.send(terminus_method, request) }.to raise_error(Puppet::Error, "Whoa there")
+    @searcher.send(@method, *@arguments).should == 'myobject'
   end
 end
 
 describe Puppet::Indirector::REST do
   before :all do
-    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
+    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
       end
     end
-
-    # The subclass must not be all caps even though the superclass is
-    class Puppet::TestModel::Rest < Puppet::Indirector::REST
+    @rest_class = class This::Is::A::Test::Class < Puppet::Indirector::REST
+      self
     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
 
-  def delete_request(key, options={})
-    Puppet::Indirector::Request.new(:test_model, :destroy, 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 save_request(key, instance)
-    Puppet::Indirector::Request.new(:test_model, :save, key, instance)
+    @searcher = @rest_class.new
+    @searcher.stubs(:model).returns @model
   end
 
   it "should include the v1 REST API module" do
@@ -142,138 +59,176 @@ describe Puppet::Indirector::REST do
   end
 
   it "should have a method for specifying what setting a subclass should use to retrieve its server" do
-    terminus_class.should respond_to(:use_server_setting)
+    @rest_class.should respond_to(:use_server_setting)
   end
 
   it "should use any specified setting to pick the server" do
-    terminus_class.expects(:server_setting).returns :inventory_server
+    @rest_class.expects(:server_setting).returns :inventory_server
     Puppet[:inventory_server] = "myserver"
-    terminus_class.server.should == "myserver"
+    @rest_class.server.should == "myserver"
   end
 
   it "should default to :server for the server setting" do
-    terminus_class.expects(:server_setting).returns nil
+    @rest_class.expects(:server_setting).returns nil
     Puppet[:server] = "myserver"
-    terminus_class.server.should == "myserver"
+    @rest_class.server.should == "myserver"
   end
 
   it "should have a method for specifying what setting a subclass should use to retrieve its port" do
-    terminus_class.should respond_to(:use_port_setting)
+    @rest_class.should respond_to(:use_port_setting)
   end
 
   it "should use any specified setting to pick the port" do
-    terminus_class.expects(:port_setting).returns :ca_port
+    @rest_class.expects(:port_setting).returns :ca_port
     Puppet[:ca_port] = "321"
-    terminus_class.port.should == 321
+    @rest_class.port.should == 321
   end
 
   it "should default to :port for the port setting" do
-    terminus_class.expects(:port_setting).returns nil
+    @rest_class.expects(:port_setting).returns nil
     Puppet[:masterport] = "543"
-    terminus_class.port.should == 543
+    @rest_class.port.should == 543
+  end
+
+
+  it 'should default to :puppet for the srv_service' do
+    Puppet::Indirector::REST.srv_service.should == :puppet
   end
 
-  describe "when making http requests" do
-    include PuppetSpec::Files
-
-    def a_connection_that_verifies(args)
-      connection = Net::HTTP.new('my_server', 8140)
-      connection.stubs(:get).with do
-        connection.verify_callback.call(args[:has_passed_pre_checks], args[:in_context])
-        true
-      end.raises(OpenSSL::SSL::SSLError.new(args[:fails_with]))
-      connection
-    end
-
-    def a_store_context(args)
-      Puppet[:confdir] = tmpdir('conf')
-      cert = Puppet::SSL::CertificateAuthority.new.generate(args[:for_server], :dns_alt_names => args[:for_aliases]).content
-      ssl_context = mock('OpenSSL::X509::StoreContext')
-      ssl_context.stubs(:current_cert).returns(cert)
-      ssl_context.stubs(:error_string).returns(args[:with_error_string])
-      ssl_context
-    end
-
-    it "should provide a useful error message when one is available and certificate validation fails", :unless => Puppet.features.microsoft_windows? do
-      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
-        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
-      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 { 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]
+  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 pass along the error message otherwise" do
-      connection = Net::HTTP.new('my_server', 8140)
-      terminus.stubs(:network).returns(connection)
+    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"
 
-      connection.stubs(:get).raises(OpenSSL::SSL::SSLError.new('some other message'))
+      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"
 
-      expect do
-        terminus.http_request(:get, stub('request'))
-      end.to raise_error(/some other message/)
+      @searcher.deserialize(response, true).should == "myobjects"
     end
-  end
 
-  describe "when creating an HTTP client" do
-    before do
-      Puppet.settings.stubs(:value).returns("rest_testing")
+    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
     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
-      terminus.class.expects(:port).returns 321
-      terminus.class.expects(:server).returns "myserver"
-      Puppet::Network::HttpPool.expects(:http_instance).with("myserver", 321).returns "myconn"
-      terminus.network(@request).should == "myconn"
+      @searcher.class.expects(:port).returns 321
+      @searcher.class.expects(:server).returns "myserver"
+      Puppet::Network::HTTP::Connection.expects(:new).with("myserver", 321).returns "myconn"
+      @searcher.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
-      terminus.class.stubs(:port).returns 321
-      Puppet::Network::HttpPool.expects(:http_instance).with("myserver", 321).returns "myconn"
-      terminus.network(@request).should == "myconn"
+      @searcher.class.stubs(:port).returns 321
+      Puppet::Network::HTTP::Connection.expects(:new).with("myserver", 321).returns "myconn"
+      @searcher.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
-      terminus.class.stubs(:server).returns "myserver"
-      Puppet::Network::HttpPool.expects(:http_instance).with("myserver", 321).returns "myconn"
-      terminus.network(@request).should == "myconn"
+      @searcher.class.stubs(:server).returns "myserver"
+      Puppet::Network::HTTP::Connection.expects(:new).with("myserver", 321).returns "myconn"
+      @searcher.network(@request).should == "myconn"
     end
   end
 
-  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') }
-
+  describe "when doing a find" do
     before :each do
-      terminus.stubs(:network).returns(connection)
-    end
+      @connection = stub('mock http connection', :get => @response, :verify_callback= => nil)
+      @searcher.stubs(:network).returns(@connection)    # neuter the network connection
 
-    it_behaves_like 'a REST terminus method', :find
-    it_behaves_like 'a deserializing terminus method', :find
+      # Use a key with spaces, so we can test escaping
+      @request = Puppet::Indirector::Request.new(:foo, :find, "foo bar", nil, :environment => "myenv")
+    end
 
-    describe "with a long set of parameters" do
-      it "calls post on the connection with the query params in the body" do
+    describe "with a large body" do
+      it "should use the POST http method" do
         params = {}
         'aa'.upto('zz') do |s|
           params[s] = 'foo'
@@ -284,270 +239,304 @@ describe Puppet::Indirector::REST do
         # to avoid a failure.
         params.delete('ip')
 
-        request = find_request('whoa', params)
+        @request = Puppet::Indirector::Request.new(:foo, :find, "foo bar", nil, params.merge(:environment => "myenv"))
 
-        connection.expects(:post).with do |uri, body|
-          body.split("&").sort == params.map {|key,value| "#{key}=#{value}"}.sort
-        end.returns(mock_response(200, 'body'))
+        @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)
 
-        terminus.find(request)
+        @searcher.find(@request)
       end
     end
 
-    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')
+    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)
       end
     end
 
-    it "returns nil on 404" do
-      response = mock_response('404', nil)
+    it "should deserialize and return the http response, setting name" do
+      @connection.expects(:get).returns @response
 
-      connection.expects(:get).returns(response)
+      instance = stub 'object'
+      instance.expects(:name=)
+      @searcher.expects(:deserialize).with(@response).returns instance
 
-      terminus.find(request).should == nil
+      @searcher.find(@request).should == instance
     end
 
-    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
+    it "should deserialize and return the http response, and not require name=" do
+      @connection.expects(:get).returns @response
 
-      model.expects(:convert_from).with(response['content-type'], response.body).returns(
-        model.new('overwritten', 'decoded body')
-      )
+      instance = stub 'object'
+      @searcher.expects(:deserialize).with(@response).returns instance
 
-      terminus.find(request).should == model.new('foo', 'decoded body')
+      @searcher.find(@request).should == instance
     end
 
-    it "doesn't require the model to support name=" do
-      connection.expects(:get).returns response
-      instance = model.new('name', 'decoded body')
-
-      model.expects(:convert_from).with(response['content-type'], response.body).returns(instance)
-      instance.expects(:respond_to?).with(:name=).returns(false)
-      instance.expects(:name=).never
-
-      terminus.find(request).should == model.new('name', 'decoded body')
+    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 "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)
+    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)
 
-      terminus.model.expects(:supported_formats).returns %w{supported formats}
-      terminus.find(request)
+      @searcher.model.expects(:supported_formats).returns %w{supported formats}
+      @searcher.find(@request)
     end
 
-    it "adds an Accept-Encoding header" do
-      terminus.expects(:add_accept_encoding).returns({"accept-encoding" => "gzip"})
-
-      connection.expects(:get).with(anything, has_entry("accept-encoding" => "gzip")).returns(response)
+    it "should add Accept-Encoding header" do
+      @searcher.expects(:add_accept_encoding).returns({"accept-encoding" => "gzip"})
 
-      terminus.find(request)
+      @connection.expects(:get).with { |path, args| args["accept-encoding"] == "gzip" }.returns(@response)
+      @searcher.find(@request)
     end
 
-    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"
-
-      terminus.find(request).should == "myobject"
+    it "should deserialize and return the network response" do
+      @searcher.expects(:deserialize).with(@response).returns @instance
+      @searcher.find(@request).should equal(@instance)
     end
 
-    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"
+    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
 
-      terminus.find(request).should == "myobject"
+    it "should generate an error when result data deserializes fails" do
+      @searcher.expects(:deserialize).raises(ArgumentError)
+      lambda { @searcher.find(@request) }.should raise_error(ArgumentError)
     end
   end
 
-  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') }
-
+  describe "when doing a head" do
     before :each do
-      terminus.stubs(:network).returns(connection)
+      @connection = stub('mock http connection', :head => @response, :verify_callback= => nil)
+      @searcher.stubs(:network).returns(@connection)
+
+      # Use a key with spaces, so we can test escaping
+      @request = Puppet::Indirector::Request.new(:foo, :head, "foo bar", nil)
     end
 
-    it_behaves_like 'a REST terminus method', :head
+    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)
+    end
 
-    it "returns true if there was a successful http response" do
-      connection.expects(:head).returns mock_response('200', nil)
+    it "should return true if there was a successful http response" do
+      @connection.expects(:head).returns @response
+      @response.stubs(:code).returns "200"
 
-      terminus.head(request).should == true
+      @searcher.head(@request).should == true
     end
 
-    it "returns false on a 404 response" do
-      connection.expects(:head).returns mock_response('404', nil)
+    it "should return false if there was a successful http response" do
+      @connection.expects(:head).returns @response
+      @response.stubs(:code).returns "404"
 
-      terminus.head(request).should == false
+      @searcher.head(@request).should == false
     end
-  end
-
-  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') }
 
-    before :each do
-      terminus.stubs(:network).returns(connection)
+    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)
     end
+  end
 
-    it_behaves_like 'a REST terminus method', :search
-    it_behaves_like 'a deserializing terminus method', :search
+  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
 
-    it "should call the GET http method on a network connection" do
-      connection.expects(:get).with('/production/test_models/foo', has_key('Accept')).returns mock_response(200, 'data3, data4')
+      @model.stubs(:convert_from_multiple)
 
-      terminus.search(request)
+      @request = Puppet::Indirector::Request.new(:foo, :search, "foo bar", nil)
     end
 
-    it "returns an empty list on 404" do
-      response = mock_response('404', nil)
+    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)
+    end
 
-      connection.expects(:get).returns(response)
+    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"
 
-      terminus.search(request).should == []
+      @searcher.search(@request).should == 'myobject'
     end
 
-    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')]
+    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)
     end
 
     it "should provide an Accept header containing the list of supported formats joined with commas" do
-      connection.expects(:get).with(anything, has_entry("Accept" => "supported, formats")).returns(mock_response(200, ''))
+      @connection.expects(:get).with { |path, args| args["Accept"] == "supported, formats" }.returns(@response)
 
-      terminus.model.expects(:supported_formats).returns %w{supported formats}
-      terminus.search(request)
+      @searcher.model.expects(:supported_formats).returns %w{supported formats}
+      @searcher.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
 
-      terminus.search(request).should == []
+      @searcher.search(@request).should == []
     end
-  end
 
-  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') }
+    it "should generate an error when result data deserializes fails" do
+      @searcher.expects(:deserialize).raises(ArgumentError)
+      lambda { @searcher.search(@request) }.should raise_error(ArgumentError)
+    end
+  end
 
+  describe "when doing a destroy" do
     before :each do
-      terminus.stubs(:network).returns(connection)
-    end
+      @connection = stub('mock http connection', :delete => @response, :verify_callback= => nil)
+      @searcher.stubs(:network).returns(@connection)    # neuter the network connection
 
-    it_behaves_like 'a REST terminus method', :destroy
-    it_behaves_like 'a deserializing terminus method', :destroy
+      @request = Puppet::Indirector::Request.new(:foo, :destroy, "foo bar", nil)
+    end
 
     it "should call the DELETE http method on a network connection" do
-      connection.expects(:delete).with('/production/test_model/foo', has_key('Accept')).returns(response)
-
-      terminus.destroy(request)
+      @searcher.expects(:network).returns @connection
+      @connection.expects(:delete).returns @response
+      @searcher.destroy(@request)
     end
 
     it "should fail if any options are provided, since DELETE apparently does not support query options" do
-      request = delete_request('foo', :one => "two", :three => "four")
+      @request.stubs(:options).returns(:one => "two", :three => "four")
 
-      expect { terminus.destroy(request) }.to raise_error(ArgumentError)
+      lambda { @searcher.destroy(@request) }.should raise_error(ArgumentError)
     end
 
     it "should deserialize and return the http response" do
-      connection.expects(:delete).returns response
+      @connection.expects(:delete).returns @response
+      @searcher.expects(:deserialize).with(@response).returns "myobject"
 
-      terminus.destroy(request).should == model.new('', 'body')
+      @searcher.destroy(@request).should == 'myobject'
     end
 
-    it "returns nil on 404" do
-      response = mock_response('404', nil)
-
-      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)
+    end
 
-      terminus.destroy(request).should == nil
+    it "should not include the query string" do
+      @connection.stubs(:delete).returns @response
+      @searcher.destroy(@request)
     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)
+      @connection.expects(:delete).with { |path, args| args["Accept"] == "supported, formats" }.returns(@response)
 
-      terminus.model.expects(:supported_formats).returns %w{supported formats}
-      terminus.destroy(request)
+      @searcher.model.expects(:supported_formats).returns %w{supported formats}
+      @searcher.destroy(@request)
     end
-  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) }
+    it "should deserialize and return the network response" do
+      @searcher.expects(:deserialize).with(@response).returns @instance
+      @searcher.destroy(@request).should equal(@instance)
+    end
 
-    before :each do
-      terminus.stubs(:network).returns(connection)
+    it "should generate an error when result data deserializes fails" do
+      @searcher.expects(:deserialize).raises(ArgumentError)
+      lambda { @searcher.destroy(@request) }.should raise_error(ArgumentError)
     end
+  end
 
-    it_behaves_like 'a REST terminus method', :save
+  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
 
-    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
+      @instance = stub 'instance', :render => "mydata", :mime => "mime"
+      @request = Puppet::Indirector::Request.new(:foo, :save, "foo bar", nil)
+      @request.instance = @instance
+    end
 
-      terminus.save(request)
+    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 "should fail if any options are provided, since PUT apparently does not support query options" do
-      request = save_request(instance, :one => "two", :three => "four")
+    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")
+
+      lambda { @searcher.save(@request) }.should raise_error(ArgumentError)
+    end
 
-      expect { terminus.save(request) }.to raise_error(ArgumentError)
+    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)
     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(anything, "serial_instance", anything).returns response
+      @instance.expects(:render).returns "serial_instance"
+      @connection.expects(:put).with { |path, data, args| data == "serial_instance" }.returns @response
 
-      terminus.save(request)
+      @searcher.save(@request)
     end
 
-    it "returns nil on 404" do
-      response = mock_response('404', nil)
-
-      connection.expects(:put).returns(response)
+    it "should deserialize and return the http response" do
+      @connection.expects(:put).returns @response
+      @searcher.expects(:deserialize).with(@response).returns "myobject"
 
-      terminus.save(request).should == nil
+      @searcher.save(@request).should == 'myobject'
     end
 
-    it "returns nil" do
-      connection.expects(:put).returns response
+    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)
 
-      terminus.save(request).should be_nil
+      @searcher.model.expects(:supported_formats).returns %w{supported formats}
+      @searcher.save(@request)
     end
 
-    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)
+    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)
 
-      instance.expects(:render).returns('')
-      model.expects(:supported_formats).returns %w{supported formats}
-      instance.expects(:mime).returns "supported"
+      @instance.expects(:mime).returns "mime"
+      @searcher.save(@request)
+    end
 
-      terminus.save(request)
+    it "should deserialize and return the network response" do
+      @searcher.expects(:deserialize).with(@response).returns @instance
+      @searcher.save(@request).should equal(@instance)
     end
 
-    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)
+    it "should generate an error when result data deserializes fails" do
+      @searcher.expects(:deserialize).raises(ArgumentError)
+      lambda { @searcher.save(@request) }.should raise_error(ArgumentError)
+    end
+  end
 
-      terminus.save(request)
+  context 'dealing with SRV settings' do
+    [
+      :destroy,
+      :find,
+      :head,
+      :save,
+      :search
+    ].each do |method|
+      it "##{method} passes the SRV service, and fall-back server & port to the request's do_request method" do
+        request = Puppet::Indirector::Request.new(:indirection, method, 'key', nil)
+        stub_response = stub 'response'
+        stub_response.stubs(:code).returns('200')
+        @searcher.stubs(:deserialize)
+
+        request.expects(:do_request).with(@searcher.class.srv_service, @searcher.class.server, @searcher.class.port).returns(stub_response)
+
+        @searcher.send(method, request)
+      end
     end
   end
 end