puppet 6.21.1 → 7.4.1

data/spec/unit/indirector/file_bucket_file/file_spec.rb

@@ -18,7 +18,7 @@ describe Puppet::FileBucketFile::File, :uses_checksums => true do
     describe "when servicing a save request" do
       it "should return a result whose content is empty" do
         bucket_file = Puppet::FileBucket::File.new('stuff')
-        result = Puppet::FileBucket::File.indirection.save(bucket_file, "md5/c13d88cb4cb02003daedb8a84e5d272a")
+        result = Puppet::FileBucket::File.indirection.save(bucket_file, "sha256/35bafb1ce99aef3ab068afbaabae8f21fd9b9f02d3a9442e364fa92c0b3eeef0")
         expect(result.contents).to be_empty
       end
 
@@ -34,12 +34,14 @@ describe Puppet::FileBucketFile::File, :uses_checksums => true do
         end
         children.each { |child| Process.wait(child) }
 
-        paths = File.read("#{Puppet[:bucketdir]}/9/8/b/f/7/d/8/c/98bf7d8c15784f0a3d63204441e1e2aa/paths").lines.to_a
+        paths = File.read("#{Puppet[:bucketdir]}/d/1/b/2/a/5/9/f/d1b2a59fbea7e20077af9f91b27e95e865061b270be03ff539ab3b73587882e8/paths").lines.to_a
         expect(paths.length).to eq(1)
         expect(Puppet::FileBucket::File.indirection.head("#{bucket_file.checksum_type}/#{bucket_file.checksum_data}/testing")).to be_truthy
       end
 
       it "fails if the contents collide with existing contents" do
+        Puppet[:digest_algorithm] = 'md5'
+
         # This is the shortest known MD5 collision (little endian). See https://eprint.iacr.org/2010/643.pdf
         first_contents = [0x6165300e,0x87a79a55,0xf7c60bd0,0x34febd0b,
                           0x6503cf04,0x854f709e,0xfb0fc034,0x874c9c65,
@@ -66,7 +68,7 @@ describe Puppet::FileBucketFile::File, :uses_checksums => true do
       context "when the contents file exists but is corrupted and does not match the expected checksum" do
         let(:original_contents) { "a file that will get corrupted" }
         let(:bucket_file) { Puppet::FileBucket::File.new(original_contents) }
-        let(:contents_file) { "#{Puppet[:bucketdir]}/8/e/6/4/f/8/5/d/8e64f85dd54a412f65edabcafe44d491/contents" }
+        let(:contents_file) { "#{Puppet[:bucketdir]}/7/7/4/1/0/2/7/9/77410279bb789b799c2f38bf654b46a509dd27ddad6e47a6684805e9ba390bce/contents" }
 
         before(:each) do
           # Ensure we're starting with a clean slate - no pre-existing backup

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

@@ -57,8 +57,4 @@ describe Puppet::Indirector::FileContent::Rest do
 
     described_class.indirection.find("puppet://example.com:8140/:mount/path/to/file")
   end
-
-  it "should use the :fileserver SRV service" do
-    expect(Puppet::Indirector::FileContent::Rest.srv_service).to eq(:fileserver)
-  end
 end

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

@@ -113,8 +113,4 @@ describe Puppet::Indirector::FileMetadata::Rest do
       model.indirection.search("puppet://example.com:8140/:mount/path/to/dir")
     end
   end
-
-  it "should use the :fileserver SRV service" do
-    expect(Puppet::Indirector::FileMetadata::Rest.srv_service).to eq(:fileserver)
-  end
 end

data/spec/unit/indirector/file_server_spec.rb

@@ -246,7 +246,7 @@ describe Puppet::Indirector::FileServer do
   end
 
   describe "when checking authorization" do
-    let(:mount) { double('mount', :empty? => nil, :globalallow? => nil) }
+    let(:mount) { double('mount') }
     let(:request) { Puppet::Indirector::Request.new(:myind, :mymethod, uri, :environment => "myenv") }
 
     before(:each) do
@@ -282,21 +282,7 @@ describe Puppet::Indirector::FileServer do
     end
 
     it "should return true when no auth directives are defined for the mount point" do
-      allow(mount).to receive(:empty?).and_return(true)
-      allow(mount).to receive(:globalallow?).and_return(nil)
       expect(terminus).to be_authorized(request)
     end
-
-    it "should return true when a global allow directive is defined for the mount point" do
-      allow(mount).to receive(:empty?).and_return(false)
-      allow(mount).to receive(:globalallow?).and_return(true)
-      expect(terminus).to be_authorized(request)
-    end
-
-    it "should return false when a non-global allow directive is defined for the mount point" do
-      allow(mount).to receive(:empty?).and_return(false)
-      allow(mount).to receive(:globalallow?).and_return(false)
-      expect(terminus).not_to be_authorized(request)
-    end
   end
 end

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

@@ -20,21 +20,6 @@ describe Puppet::Transaction::Report::Rest do
     { body: formatter.render(["store", "http"]), headers: {'Content-Type' => formatter.mime } }
   end
 
-  it "should use the :report_server setting in preference to :server" do
-    Puppet.settings[:server] = "server"
-    Puppet.settings[:report_server] = "report_server"
-    expect(Puppet::Transaction::Report::Rest.server).to eq("report_server")
-  end
-
-  it "should have a value for report_server and report_port" do
-    expect(Puppet::Transaction::Report::Rest.server).not_to be_nil
-    expect(Puppet::Transaction::Report::Rest.port).not_to be_nil
-  end
-
-  it "should use the :report SRV service" do
-    expect(Puppet::Transaction::Report::Rest.srv_service).to eq(:report)
-  end
-
   it "saves a report " do
     stub_request(:put, uri)
       .to_return(status: 200, **report_response)
@@ -77,7 +62,7 @@ describe Puppet::Transaction::Report::Rest do
 
       stub_request(:put, uri)
         .to_return(status: 500,
-                   headers: { 'Content-Type' => 'text/pson', Puppet::Network::HTTP::HEADER_PUPPET_VERSION => '4.10.1' })
+                   headers: { 'Content-Type' => 'text/pson', Puppet::HTTP::HEADER_PUPPET_VERSION => '4.10.1' })
 
       expect {
         described_class.indirection.save(report)
@@ -89,7 +74,7 @@ describe Puppet::Transaction::Report::Rest do
 
       stub_request(:put, uri)
         .to_return(status: 500,
-                   headers: { 'Content-Type' => 'text/pson', Puppet::Network::HTTP::HEADER_PUPPET_VERSION => '4.10.1' })
+                   headers: { 'Content-Type' => 'text/pson', Puppet::HTTP::HEADER_PUPPET_VERSION => '4.10.1' })
 
       expect {
         described_class.indirection.save(report)

data/spec/unit/indirector/request_spec.rb

@@ -271,229 +271,6 @@ describe Puppet::Indirector::Request do
     expect(Puppet::Indirector::Request.new(:myind, :find, "my key", nil, :node => 'foo').to_hash[:node]).to eq('foo')
   end
 
-  describe "when building a query string from its options" do
-    def a_request_with_options(options)
-      Puppet::Indirector::Request.new(:myind, :find, "my key", nil, options)
-    end
-
-    def the_parsed_query_string_from(request)
-      CGI.parse(request.query_string.sub(/^\?/, ''))
-    end
-
-    it "should return an empty query string if there are no options" do
-      request = a_request_with_options(nil)
-
-      expect(request.query_string).to eq("")
-    end
-
-    it "should return an empty query string if the options are empty" do
-      request = a_request_with_options({})
-
-      expect(request.query_string).to eq("")
-    end
-
-    it "should include all options in the query string, separated by '&'" do
-      request = a_request_with_options(:one => "two", :three => "four")
-
-      expect(the_parsed_query_string_from(request)).to eq({
-        "one" => ["two"],
-        "three" => ["four"]
-      })
-    end
-
-    it "should ignore nil options" do
-      request = a_request_with_options(:one => "two", :three => nil)
-
-      expect(the_parsed_query_string_from(request)).to eq({
-        "one" => ["two"]
-      })
-    end
-
-    it "should convert 'true' option values into strings" do
-      request = a_request_with_options(:one => true)
-
-      expect(the_parsed_query_string_from(request)).to eq({
-        "one" => ["true"]
-      })
-    end
-
-    it "should convert 'false' option values into strings" do
-      request = a_request_with_options(:one => false)
-
-      expect(the_parsed_query_string_from(request)).to eq({
-        "one" => ["false"]
-      })
-    end
-
-    it "should convert to a string all option values that are integers" do
-      request = a_request_with_options(:one => 50)
-
-      expect(the_parsed_query_string_from(request)).to eq({
-        "one" => ["50"]
-      })
-    end
-
-    it "should convert to a string all option values that are floating point numbers" do
-      request = a_request_with_options(:one => 1.2)
-
-      expect(the_parsed_query_string_from(request)).to eq({
-        "one" => ["1.2"]
-      })
-    end
-
-    it "should CGI-escape all option values that are strings" do
-      request = a_request_with_options(:one => "one two")
-
-      expect(the_parsed_query_string_from(request)).to eq({
-        "one" => ["one two"]
-      })
-    end
-
-    it "should convert an array of values into multiple entries for the same key" do
-      request = a_request_with_options(:one => %w{one two})
-
-      expect(the_parsed_query_string_from(request)).to eq({
-        "one" => ["one", "two"]
-      })
-    end
-
-    it "should stringify simple data types inside an array" do
-      request = a_request_with_options(:one => ['one', nil])
-
-      expect(the_parsed_query_string_from(request)).to eq({
-        "one" => ["one"]
-      })
-    end
-
-    it "should error if an array contains another array" do
-      request = a_request_with_options(:one => ['one', ["not allowed"]])
-
-      expect { request.query_string }.to raise_error(ArgumentError)
-    end
-
-    it "should error if an array contains illegal data" do
-      request = a_request_with_options(:one => ['one', { :not => "allowed" }])
-
-      expect { request.query_string }.to raise_error(ArgumentError)
-    end
-
-    it "should convert to a string and CGI-escape all option values that are symbols" do
-      request = a_request_with_options(:one => :"sym bol")
-
-      expect(the_parsed_query_string_from(request)).to eq({
-        "one" => ["sym bol"]
-      })
-    end
-
-    it "should fail if options other than booleans or strings are provided" do
-      request = a_request_with_options(:one => { :one => :two })
-
-      expect { request.query_string }.to raise_error(ArgumentError)
-    end
-  end
-
-  context '#do_request' do
-    before :each do
-      @request = Puppet::Indirector::Request.new(:myind, :find, "my key", nil)
-    end
-
-    context 'when not using SRV records' do
-      before :each do
-        Puppet.settings[:use_srv_records] = false
-      end
-
-      it "yields the request with the default server and port when no server or port were specified on the original request" do
-        count = 0
-        rval = @request.do_request(:puppet, 'puppet.example.com', '90210') do |got|
-          count += 1
-          expect(got.server).to eq('puppet.example.com')
-          expect(got.port).to   eq('90210')
-          'Block return value'
-        end
-        expect(count).to eq(1)
-
-        expect(rval).to eq('Block return value')
-      end
-    end
-
-    context 'when using SRV records' do
-      before :each do
-        Puppet.settings[:use_srv_records] = true
-        Puppet.settings[:srv_domain]      = 'example.com'
-      end
-
-      it "yields the request with the original server and port unmodified" do
-        @request.server = 'puppet.example.com'
-        @request.port   = '90210'
-
-        count = 0
-        rval = @request.do_request do |got|
-          count += 1
-          expect(got.server).to eq('puppet.example.com')
-          expect(got.port).to   eq('90210')
-          'Block return value'
-        end
-        expect(count).to eq(1)
-
-        expect(rval).to eq('Block return value')
-      end
-
-      context "when SRV returns servers" do
-        before :each do
-          @dns_mock = double('dns')
-          expect(Resolv::DNS).to receive(:new).and_return(@dns_mock)
-
-          @port = 7205
-          @target = 'example.com'
-          record = Resolv::DNS::Resource::IN::SRV.new(0, 0, @port, @target)
-          record.instance_variable_set(:@ttl, 10)
-          @srv_records = [record]
-
-          expect(@dns_mock).to receive(:getresources).
-            with("_x-puppet._tcp.#{Puppet.settings[:srv_domain]}", Resolv::DNS::Resource::IN::SRV).
-            and_return(@srv_records)
-        end
-
-        it "yields a request using the server and port from the SRV record" do
-          count = 0
-          rval = @request.do_request do |got|
-            count += 1
-            expect(got.server).to eq('example.com')
-            expect(got.port).to eq(7205)
-
-            @block_return
-          end
-          expect(count).to eq(1)
-
-          expect(rval).to eq(@block_return)
-        end
-
-        it "should fall back to the default server when the block raises a SystemCallError" do
-          count = 0
-          second_pass = nil
-
-          rval = @request.do_request(:puppet, 'puppet', 8140) do |got|
-            count += 1
-
-            if got.server == 'example.com' then
-              raise SystemCallError, "example failure"
-            else
-              second_pass = got
-            end
-
-            @block_return
-          end
-
-          expect(second_pass.server).to eq('puppet')
-          expect(second_pass.port).to   eq(8140)
-          expect(count).to eq(2)
-
-          expect(rval).to eq(@block_return)
-        end
-      end
-    end
-  end
-
   describe "#remote?" do
     def request(options = {})
       Puppet::Indirector::Request.new('node', 'find', 'localhost', nil, options)
@@ -515,45 +292,4 @@ describe Puppet::Indirector::Request do
       expect(request(:node => 'example.com', :ip => '127.0.0.1')).to be_remote
     end
   end
-
-  describe "failover" do
-    it "should use the provided failover host and port" do
-      Puppet.override(:server => 'myhost', :serverport => 666) do
-        req = Puppet::Indirector::Request.new('node', 'find', 'localhost', nil)
-        req.do_request() do |request|
-          expect(request.server).to eq('myhost')
-          expect(request.port).to eq(666)
-        end
-      end
-    end
-
-    it "should not use raw settings when failover fails" do
-      Puppet.override(:server => nil, :serverport => nil) do
-        req = Puppet::Indirector::Request.new('node', 'find', 'localhost', nil)
-        req.do_request() do |request|
-          expect(request.server).to be_nil
-          expect(request.port).to be_nil
-          expect(Puppet.settings[:server]).not_to be_nil
-          expect(Puppet.settings[:serverport]).not_to be_nil
-        end
-      end
-    end
-
-    it "should use server_list when set and failover has not occured" do
-      Puppet.settings[:server_list] = [['myhost',666]]
-      req = Puppet::Indirector::Request.new('node', 'find', 'localhost', nil)
-      req.do_request() do |request|
-        expect(request.server).to eq('myhost')
-        expect(request.port).to eq(666)
-      end
-    end
-
-    it "should use server when server_list is not set" do
-      req = Puppet::Indirector::Request.new('node', 'find', 'localhost', nil)
-      req.do_request() do |request|
-        expect(request.server).to eq(Puppet.settings[:server])
-        expect(request.port).to eq(Puppet.settings[:serverport])
-      end
-    end
-  end
 end

data/spec/unit/indirector/rest_spec.rb

@@ -1,803 +1,149 @@
 require 'spec_helper'
-require 'puppet/util/json'
-require 'puppet/indirector'
-require 'puppet/indirector/errors'
 require 'puppet/indirector/rest'
-require 'puppet/util/psych_support'
 
-HTTP_ERROR_CODES = [300, 400, 500]
-
-# Just one from each category since the code makes no real distinctions
-shared_examples_for "a REST terminus method" do |terminus_method|
-
-  describe "when handling the response" do
-    let(:response) do
-      mock_response(200, 'OK')
-    end
-
-    it "falls back to pson for future requests" do
-      allow(response).to receive(:[]).with(Puppet::Network::HTTP::HEADER_PUPPET_VERSION).and_return("4.10.1")
-      terminus.send(terminus_method, request)
-
-      expect(Puppet[:preferred_serialization_format]).to eq("pson")
-    end
-
-    it "doesn't change the serialization format if the X-Puppet-Version header is missing" do
-      allow(response).to receive(:[]).with(Puppet::Network::HTTP::HEADER_PUPPET_VERSION).and_return(nil)
-
-      terminus.send(terminus_method, request)
-
-      expect(Puppet[:preferred_serialization_format]).to eq("json")
-    end
-
-    it "doesn't change the serialization format if the server major version is 5" do
-      allow(response).to receive(:[]).with(Puppet::Network::HTTP::HEADER_PUPPET_VERSION).and_return("5.0.3")
-
-      terminus.send(terminus_method, request)
-
-      expect(Puppet[:preferred_serialization_format]).to eq("json")
-    end
-
-    it "doesn't change the serialization format if the current format is already pson" do
-      allow(response).to receive(:[]).with(Puppet::Network::HTTP::HEADER_PUPPET_VERSION).and_return("4.10.1")
-      Puppet[:preferred_serialization_format] = "pson"
-      terminus.send(terminus_method, request)
-
-      expect(Puppet[:preferred_serialization_format]).to eq("pson")
-    end
-
-    it "logs a deprecation warning" do
-      terminus.send(terminus_method, request)
-
-      expect(@logs).to include(an_object_having_attributes(level: :warning, message: /Puppet::Indirector::Rest##{terminus_method} is deprecated. Use Puppet::HTTP::Client instead./))
-    end
-
-    it "omits the warning when deprecations are disabled" do
-      Puppet[:disable_warnings] = 'deprecations'
-      terminus.send(terminus_method, request)
-
-      expect(@logs).to eq([])
-    end
-  end
-
-  HTTP_ERROR_CODES.each do |code|
-    describe "when the response code is #{code}" do
-      let(:message) { 'error messaged!!!' }
-      let(:body) do
-        Puppet::Util::Json.dump({
-          :issue_kind => 'server-error',
-          :message    => message
-        })
-      end
-      let(:response) { mock_response(code, body, 'application/json') }
-
-      describe "when the response is plain text" do
-        let(:response) { mock_response(code, message) }
-
-        it "raises an http error with the body of the response when plain text" do
-
-          expect {
-            terminus.send(terminus_method, request)
-          }.to raise_error(Net::HTTPError, "Error #{code} on SERVER: #{message}")
-        end
-      end
-
-      it "raises an http error with the body's message field when json" do
-        expect {
-          terminus.send(terminus_method, request)
-        }.to raise_error(Net::HTTPError, "Error #{code} on SERVER: #{message}")
-      end
-
-      it "does not attempt to deserialize the response into a model" do
-        expect(model).not_to receive(:convert_from)
-
-        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
-        allow(response).to receive(:body).and_return("")
-        allow(response).to receive(:message).and_return("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
-          compressed_body = Zlib::Deflate.deflate(body)
+class Puppet::TestModel
+  extend Puppet::Indirector
+  indirects :test_model
+end
 
-          compressed_response = mock_response(code, compressed_body, 'application/json', 'deflate')
-          expect(connection).to receive(http_method).and_return(compressed_response)
+# The subclass must not be all caps even though the superclass is
+class Puppet::TestModel::Rest < Puppet::Indirector::REST
+end
 
-          expect {
-            terminus.send(terminus_method, request)
-          }.to raise_error(Net::HTTPError, "Error #{code} on SERVER: #{message}")
-        end
-      end
-    end
-  end
+class Puppet::FailingTestModel
+  extend Puppet::Indirector
+  indirects :failing_test_model
 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
-  end
+# The subclass must not be all caps even though the superclass is
+class Puppet::FailingTestModel::Rest < Puppet::Indirector::REST
+  def find(request)
+    http = Puppet.runtime[:http]
+    response = http.get(URI('http://puppet.example.com:8140/puppet/v3/failing_test_model'))
 
-  it "doesn't catch errors in deserialization" do
-    expect(model).to receive(:convert_from).and_raise(Puppet::Error, "Whoa there")
+    if response.code == 404
+      return nil unless request.options[:fail_on_404]
 
-    expect { terminus.send(terminus_method, request) }.to raise_error(Puppet::Error, "Whoa there")
+      _, body = parse_response(response)
+      msg = _("Find %{uri} resulted in 404 with the message: %{body}") % { uri: elide(response.url.path, 100), body: body }
+      raise Puppet::Error, msg
+    else
+      raise convert_to_http_error(response)
+    end
   end
 end
 
 describe Puppet::Indirector::REST do
-  before :all do
-    class Puppet::TestModel
-      include Puppet::Util::PsychSupport
-      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 to_data_hash
-        { 'name' => @name, 'data' => @data }
-      end
-
-      def ==(other)
-        other.is_a? Puppet::TestModel and other.name == name and other.data == data
-      end
-    end
-
-    # The subclass must not be all caps even though the superclass is
-    class Puppet::TestModel::Rest < Puppet::Indirector::REST
-    end
-
+  before :each do
     Puppet::TestModel.indirection.terminus_class = :rest
   end
 
-  after :all do
-    Puppet::TestModel.indirection.delete
-    # 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 }
-  let(:url_prefix) { "#{Puppet::Network::HTTP::MASTER_URL_PREFIX}/v3"}
-
-  around(:each) do |example|
-    Puppet.override(:current_environment => Puppet::Node::Environment.create(:production, [])) do
-      example.run
-    end
-  end
-
-  def mock_response(code, body, content_type='text/plain', encoding=nil)
-    obj = double('http 200 ok', :code => code.to_s, :body => body)
-    allow(obj).to receive(:[]).with('content-type').and_return(content_type)
-    allow(obj).to receive(:[]).with('content-encoding').and_return(encoding)
-    allow(obj).to receive(:[]).with(Puppet::Network::HTTP::HEADER_PUPPET_VERSION).and_return(Puppet.version)
-    obj
-  end
-
-  def find_request(key, options={})
-    Puppet::Indirector::Request.new(:test_model, :find, key, nil, options)
-  end
-
-  def head_request(key, options={})
-    Puppet::Indirector::Request.new(:test_model, :head, key, nil, options)
-  end
-
-  def search_request(key, options={})
-    Puppet::Indirector::Request.new(:test_model, :search, key, nil, options)
-  end
-
-  def delete_request(key, options={})
-    Puppet::Indirector::Request.new(:test_model, :destroy, key, nil, options)
-  end
-
-  def save_request(key, instance, options={})
-    Puppet::Indirector::Request.new(:test_model, :save, key, instance, options)
-  end
-
-  it "should have a method for specifying what setting a subclass should use to retrieve its server" do
-    expect(terminus_class).to respond_to(:use_server_setting)
+  it "raises when find is called" do
+    expect {
+      Puppet::TestModel.indirection.find('foo')
+    }.to raise_error(NotImplementedError)
   end
 
-  it "should use any specified setting to pick the server" do
-    expect(terminus_class).to receive(:server_setting).and_return(:ca_server)
-    Puppet[:ca_server] = "myserver"
-    expect(terminus_class.server).to eq("myserver")
-  end
-
-  it "should default to :server for the server setting" do
-    expect(terminus_class).to receive(:server_setting).and_return(nil)
-    Puppet[:server] = "myserver"
-    expect(terminus_class.server).to eq("myserver")
-  end
-
-  it "should have a method for specifying what setting a subclass should use to retrieve its port" do
-    expect(terminus_class).to respond_to(:use_port_setting)
-  end
-
-  it "should use any specified setting to pick the port" do
-    expect(terminus_class).to receive(:port_setting).and_return(:ca_port)
-    Puppet[:ca_port] = "321"
-    expect(terminus_class.port).to eq(321)
-  end
-
-  it "should default to :port for the port setting" do
-    expect(terminus_class).to receive(:port_setting).and_return(nil)
-    Puppet[:serverport] = "543"
-    expect(terminus_class.port).to eq(543)
-  end
-
-  it "should use a failover-selected server if set" do
-    expect(terminus_class).to receive(:server_setting).and_return(nil)
-    Puppet.override(:server => "myserver") do
-      expect(terminus_class.server).to eq("myserver")
-    end
-  end
-
-  it "should use a failover-selected port if set" do
-    expect(terminus_class).to receive(:port_setting).and_return(nil)
-    Puppet.override(:serverport => 321) do
-      expect(terminus_class.port).to eq(321)
-    end
-  end
-
-  it "should use server_list for server when available" do
-    expect(terminus_class).to receive(:server_setting).and_return(nil)
-    Puppet[:server_list] = [["foo", "123"]]
-    expect(terminus_class.server).to eq("foo")
-  end
-
-  it "should prefer failover-selected server from server list" do
-    expect(terminus_class).to receive(:server_setting).and_return(nil)
-    Puppet[:server_list] = [["foo", "123"],["bar", "321"]]
-    Puppet.override(:server => "bar") do
-      expect(terminus_class.server).to eq("bar")
-    end
-  end
-
-  it "should use server_list for port when available" do
-    expect(terminus_class).to receive(:port_setting).and_return(nil)
-    Puppet[:server_list] = [["foo", "123"]]
-    expect(terminus_class.port).to eq(123)
-  end
-
-  it "should prefer failover-selected port from server list" do
-    expect(terminus_class).to receive(:port_setting).and_return(nil)
-    Puppet[:server_list] = [["foo", "123"],["bar", "321"]]
-    Puppet.override(:serverport => "321") do
-      expect(terminus_class.port).to eq(321)
-    end
-  end
-
-  it "should use an explicitly specified more-speciic server when failover is active" do
-    expect(terminus_class).to receive(:server_setting).and_return(:ca_server)
-    Puppet[:ca_server] = "myserver"
-    Puppet.override(:server => "anotherserver") do
-      expect(terminus_class.server).to eq("myserver")
-    end
-  end
-
-  it "should use an explicitly specified more-specific port when failover is active" do
-    expect(terminus_class).to receive(:port_setting).and_return(:ca_port)
-    Puppet[:ca_port] = 321
-    Puppet.override(:serverport => 543) do
-      expect(terminus_class.port).to eq(321)
-    end
-  end
-
-  it "should use a default port when a more-specific server is set" do
-    expect(terminus_class).to receive(:server_setting).and_return(:ca_server)
-    expect(terminus_class).to receive(:port_setting).and_return(:ca_port)
-    Puppet[:ca_server] = "myserver"
-    Puppet.override(:server => "anotherserver", :port => 666) do
-      expect(terminus_class.port).to eq(8140)
-    end
-  end
-
-  it 'should default to :puppet for the srv_service' do
-    expect(Puppet::Indirector::REST.srv_service).to eq(:puppet)
-  end
-
-  it 'excludes yaml from the Accept header' do
-    expect(model).to receive(:supported_formats).and_return([:json, :pson, :yaml, :binary])
-
-    expect(terminus.headers['Accept']).to eq('application/json, text/pson, application/octet-stream')
-  end
-
-  it 'excludes b64_zlib_yaml from the Accept header' do
-    expect(model).to receive(:supported_formats).and_return([:json, :pson, :b64_zlib_yaml])
-
-    expect(terminus.headers['Accept']).to eq('application/json, text/pson')
-  end
-
-  it 'excludes dot from the Accept header' do
-    expect(model).to receive(:supported_formats).and_return([:json, :dot])
-
-    expect(terminus.headers['Accept']).to eq('application/json')
-  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 = double('request', :key => "foo", :server => nil, :port => nil)
-      expect(terminus.class).to receive(:port).and_return(321)
-      expect(terminus.class).to receive(:server).and_return("myserver")
-      expect(Puppet::Network::HttpPool).to receive(:connection).with('myserver', 321, anything).and_return("myconn")
-      expect(terminus.network(@request)).to eq("myconn")
-    end
-
-    it "should use the server from the indirection request if one is present" do
-      @request = double('request', :key => "foo", :server => "myserver", :port => nil)
-      allow(terminus.class).to receive(:port).and_return(321)
-      expect(Puppet::Network::HttpPool).to receive(:connection).with('myserver', 321, anything).and_return("myconn")
-      expect(terminus.network(@request)).to eq("myconn")
-    end
-
-    it "should use the port from the indirection request if one is present" do
-      @request = double('request', :key => "foo", :server => nil, :port => 321)
-      allow(terminus.class).to receive(:server).and_return("myserver")
-      expect(Puppet::Network::HttpPool).to receive(:connection).with('myserver', 321, anything).and_return("myconn")
-      expect(terminus.network(@request)).to eq("myconn")
-    end
-  end
-
-  describe "#find" do
-    let(:http_method) { :get }
-    let(:response) { mock_response(200, 'body') }
-    let(:connection) { double('mock http connection', :get => response, :verify_callback= => nil) }
-    let(:request) { find_request('foo') }
-
-    before :each do
-      allow(terminus).to receive(:network).and_return(connection)
-    end
-
-    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'
-        end
-
-        # The request special-cases this parameter, and it
-        # won't be passed on to the server, so we remove it here
-        # to avoid a failure.
-        params.delete('ip')
-
-        params["environment"] = "production"
-
-        request = find_request('whoa', params)
-
-        expect(connection).to receive(:post) do |_,req,_|
-          expect(req.split("&").flatten).to match_array(params.map {|key,value| "#{key}=#{value}"})
-
-          mock_response(200, 'body')
-        end
-
-        terminus.find(request)
-      end
-    end
-
-    describe "with no parameters" do
-      it "calls get on the connection" do
-        request = find_request('foo bar')
-
-        expect(connection).to receive(:get).with("#{url_prefix}/test_model/foo%20bar?environment=production&", anything).and_return(mock_response('200', 'response body'))
-
-        expect(terminus.find(request)).to eq(model.new('foo bar', 'response body'))
-      end
-    end
-
-    it "returns nil on 404" do
-      response = mock_response('404', nil)
-
-      expect(connection).to receive(:get).and_return(response)
-
-      expect(terminus.find(request)).to eq(nil)
-    end
-
-    it 'raises no warning for a 404 (when not asked to do so)' do
-      response = mock_response('404', 'this is the notfound you are looking for')
-      expect(connection).to receive(:get).and_return(response)
-      expect{terminus.find(request)}.to_not raise_error()
-    end
-
-    context 'when fail_on_404 is used in request' do
-      it 'raises an error for a 404 when asked to do so' do
-        request = find_request('foo', :fail_on_404 => true)
-        response = mock_response('404', 'this is the notfound you are looking for')
-        expect(connection).to receive(:get).and_return(response)
-
-        expect do
-          terminus.find(request)
-        end.to raise_error(
-          Puppet::Error,
-          "Find #{url_prefix}/test_model/foo?environment=production&fail_on_404=true resulted in 404 with the message: this is the notfound you are looking for")
-      end
-
-      it 'truncates the URI when it is very long' do
-        request = find_request('foo', :fail_on_404 => true, :long_param => ('A' * 100) + 'B')
-        response = mock_response('404', 'this is the notfound you are looking for')
-        expect(connection).to receive(:get).and_return(response)
-
-        expect do
-          terminus.find(request)
-        end.to raise_error(
-          Puppet::Error,
-          /\/test_model\/foo.*\?environment=production&.*long_param=A+\.\.\..*resulted in 404 with the message/)
-      end
-
-      it 'does not truncate the URI when logging debug information' do
-        Puppet.debug = true
-        request = find_request('foo', :fail_on_404 => true, :long_param => ('A' * 100) + 'B')
-        response = mock_response('404', 'this is the notfound you are looking for')
-        expect(connection).to receive(:get).and_return(response)
-
-        expect do
-          terminus.find(request)
-        end.to raise_error(
-          Puppet::Error,
-          /\/test_model\/foo.*\?environment=production&.*long_param=A+B.*resulted in 404 with the message/)
-      end
-    end
-
-    it "asks the model to deserialize the response body and sets the name on the resulting object to the find key" do
-      expect(connection).to receive(:get).and_return(response)
-
-      expect(model).to receive(:convert_from).with(response['content-type'], response.body).and_return(
-        model.new('overwritten', 'decoded body')
-      )
-
-      expect(terminus.find(request)).to eq(model.new('foo', 'decoded body'))
-    end
-
-    it "doesn't require the model to support name=" do
-      class Puppet::TestModel2 < Puppet::TestModel
-        undef_method :name=
-      end
-
-      expect(connection).to receive(:get).and_return(response)
-      instance = Puppet::TestModel2.new('name', 'decoded body')
-
-      expect(model).to receive(:convert_from).with(response['content-type'], response.body).and_return(instance)
-
-      expect(terminus.find(request)).to eq(model.new('name', 'decoded body'))
-    end
-
-    it "provides an Accept header containing the list of supported mime types joined with commas" do
-      expect(connection).to receive(:get).with(anything, hash_including("Accept" => "application/json, text/pson")).and_return(response)
-
-      expect(terminus.model).to receive(:supported_formats).and_return([:json, :pson])
-      terminus.find(request)
-    end
-
-    it "provides a version header with the current puppet version" do
-      expect(connection).to receive(:get).with(anything, hash_including(Puppet::Network::HTTP::HEADER_PUPPET_VERSION => Puppet.version)).and_return(response)
-
-      terminus.find(request)
-    end
-
-    it "adds an Accept-Encoding header" do
-      expect(terminus).to receive(:add_accept_encoding).and_return({"accept-encoding" => "gzip"})
-
-      expect(connection).to receive(:get).with(anything, hash_including("accept-encoding" => "gzip")).and_return(response)
-
-      terminus.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")
-      expect(connection).to receive(:get).and_return(response)
-
-      expect(model).to receive(:convert_from).with("text/plain", "mydata").and_return("myobject")
-
-      expect(terminus.find(request)).to eq("myobject")
-    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')
-      expect(connection).to receive(:get).and_return(response)
-
-      expect(model).to receive(:convert_from).with("text/plain", uncompressed_body).and_return("myobject")
-
-      expect(terminus.find(request)).to eq("myobject")
-    end
+  it "raises when head is called" do
+    expect {
+      Puppet::TestModel.indirection.head('foo')
+    }.to raise_error(NotImplementedError)
   end
 
-  describe "#head" do
-    let(:http_method) { :head }
-    let(:response) { mock_response(200, nil) }
-    let(:connection) { double('mock http connection', :head => response, :verify_callback= => nil) }
-    let(:request) { head_request('foo') }
-
-    before :each do
-      allow(terminus).to receive(:network).and_return(connection)
-    end
-
-    it_behaves_like 'a REST terminus method', :head
-
-    it "returns true if there was a successful http response" do
-      expect(connection).to receive(:head).and_return(mock_response('200', nil))
-
-      expect(terminus.head(request)).to eq(true)
-    end
-
-    it "returns false on a 404 response" do
-      expect(connection).to receive(:head).and_return(mock_response('404', nil))
-
-      expect(terminus.head(request)).to eq(false)
-    end
-
-    it "provides a version header with the current puppet version" do
-      expect(connection).to receive(:head).with(anything, hash_including(Puppet::Network::HTTP::HEADER_PUPPET_VERSION => Puppet.version)).and_return(response)
-
-      terminus.head(request)
-    end
+  it "raises when search is called" do
+    expect {
+      Puppet::TestModel.indirection.search('foo')
+    }.to raise_error(NotImplementedError)
   end
 
-  describe "#search" do
-    let(:http_method) { :get }
-    let(:response) { mock_response(200, 'data1,data2,data3') }
-    let(:connection) { double('mock http connection', :get => response, :verify_callback= => nil) }
-    let(:request) { search_request('foo') }
-
-    before :each do
-      allow(terminus).to receive(:network).and_return(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
-      expect(connection).to receive(:get).with("#{url_prefix}/test_models/foo?environment=production&", hash_including('Accept' => anything)).and_return(mock_response(200, 'data3, data4'))
-
-      terminus.search(request)
-    end
-
-    it "returns an empty list on 404" do
-      response = mock_response('404', nil)
-
-      expect(connection).to receive(:get).and_return(response)
-
-      expect(terminus.search(request)).to eq([])
-    end
-
-    it "asks the model to deserialize the response body into multiple instances" do
-      expect(terminus.search(request)).to eq([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
-      expect(connection).to receive(:get).with(anything, hash_including("Accept" => "application/json, text/pson")).and_return(mock_response(200, ''))
-
-      expect(terminus.model).to receive(:supported_formats).and_return([:json, :pson])
-      terminus.search(request)
-    end
-
-    it "provides a version header with the current puppet version" do
-      expect(connection).to receive(:get).with(anything, hash_including(Puppet::Network::HTTP::HEADER_PUPPET_VERSION => Puppet.version)).and_return(mock_response(200, ''))
-
-      terminus.search(request)
-    end
-
-    it "should return an empty array if serialization returns nil" do
-      allow(model).to receive(:convert_from_multiple).and_return(nil)
-
-      expect(terminus.search(request)).to eq([])
-    end
+  it "raises when save is called" do
+    expect {
+      Puppet::TestModel.indirection.save(Puppet::TestModel.new, 'foo')
+    }.to raise_error(NotImplementedError)
   end
 
-  describe "#destroy" do
-    let(:http_method) { :delete }
-    let(:response) { mock_response(200, 'body') }
-    let(:connection) { double('mock http connection', :delete => response, :verify_callback= => nil) }
-    let(:request) { delete_request('foo') }
-
-    before :each do
-      allow(terminus).to receive(:network).and_return(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
-      expect(connection).to receive(:delete).with("#{url_prefix}/test_model/foo?environment=production&", hash_including('Accept' => anything)).and_return(response)
-
-      terminus.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")
-
-      expect { terminus.destroy(request) }.to raise_error(ArgumentError)
-    end
-
-    it "should deserialize and return the http response" do
-      expect(connection).to receive(:delete).and_return(response)
-
-      expect(terminus.destroy(request)).to eq(model.new('', 'body'))
-    end
-
-    it "returns nil on 404" do
-      response = mock_response('404', nil)
-
-      expect(connection).to receive(:delete).and_return(response)
-
-      expect(terminus.destroy(request)).to eq(nil)
-    end
-
-    it "should provide an Accept header containing the list of supported formats joined with commas" do
-      expect(connection).to receive(:delete).with(anything, hash_including("Accept" => "application/json, text/pson")).and_return(response)
-
-      expect(terminus.model).to receive(:supported_formats).and_return([:json, :pson])
-      terminus.destroy(request)
-    end
-
-    it "provides a version header with the current puppet version" do
-      expect(connection).to receive(:delete).with(anything, hash_including(Puppet::Network::HTTP::HEADER_PUPPET_VERSION => Puppet.version)).and_return(response)
-
-      terminus.destroy(request)
-    end
+  it "raises when destroy is called" do
+    expect {
+      Puppet::TestModel.indirection.destroy('foo')
+    }.to raise_error(NotImplementedError)
   end
 
-  describe "#save" do
-    let(:http_method) { :put }
-    let(:response) { mock_response(200, 'body') }
-    let(:connection) { double('mock http connection', :put => response, :verify_callback= => nil) }
-    let(:instance) { model.new('the thing', 'some contents') }
-    let(:request) { save_request(instance.name, instance) }
-
+  context 'when parsing the response error' do
     before :each do
-      allow(terminus).to receive(:network).and_return(connection)
-    end
-
-    it_behaves_like 'a REST terminus method', :save
-
-    it "should call the PUT http method on a network connection" do
-      expect(connection).to receive(:put).with("#{url_prefix}/test_model/the%20thing?environment=production&", anything, hash_including("Content-Type")).and_return(response)
-
-      terminus.save(request)
-    end
-
-    it "should fail if any options are provided, since PUT apparently does not support query options" do
-      request = save_request(instance.name, 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
-      expect(instance).to receive(:render).and_return("serial_instance")
-      expect(connection).to receive(:put).with(anything, "serial_instance", anything).and_return(response)
-
-      terminus.save(request)
-    end
-
-    it "returns nil on 404" do
-      response = mock_response('404', nil)
-
-      expect(connection).to receive(:put).and_return(response)
-
-      expect(terminus.save(request)).to eq(nil)
-    end
-
-    it "returns nil" do
-      expect(connection).to receive(:put).and_return(response)
-
-      expect(terminus.save(request)).to be_nil
-    end
-
-    it "should provide an Accept header containing the list of supported formats joined with commas" do
-      expect(connection).to receive(:put).with(anything, anything, hash_including("Accept" => "application/json, text/pson")).and_return(response)
-
-      expect(instance).to receive(:render).and_return('')
-      expect(model).to receive(:supported_formats).and_return([:json, :pson])
-      expect(instance).to receive(:mime).and_return("supported")
-
-      terminus.save(request)
+      Puppet::FailingTestModel.indirection.terminus_class = :rest
     end
 
-    it "provides a version header with the current puppet version" do
-      expect(connection).to receive(:put).with(anything, anything, hash_including(Puppet::Network::HTTP::HEADER_PUPPET_VERSION => Puppet.version)).and_return(response)
+    it 'returns nil if 404 is returned and fail_on_404 is omitted' do
+      stub_request(:get, 'http://puppet.example.com:8140/puppet/v3/failing_test_model').to_return(status: 404)
 
-      terminus.save(request)
+      expect(Puppet::FailingTestModel.indirection.find('foo')).to be_nil
     end
 
-    it "should provide a Content-Type header containing the mime-type of the sent object" do
-      expect(instance).to receive(:mime).and_return("mime")
-      expect(connection).to receive(:put).with(anything, anything, hash_including('Content-Type' => "mime")).and_return(response)
+    it 'raises if 404 is returned and fail_on_404 is true' do
+      stub_request(
+        :get, 'http://puppet.example.com:8140/puppet/v3/failing_test_model',
+      ).to_return(status: 404,
+                  headers: { 'Content-Type' => 'text/plain' },
+                  body: 'plaintext')
 
-      terminus.save(request)
+      expect {
+        Puppet::FailingTestModel.indirection.find('foo', fail_on_404: true)
+      }.to raise_error(Puppet::Error, 'Find /puppet/v3/failing_test_model resulted in 404 with the message: plaintext')
     end
-  end
 
-  describe '#handle_response' do
-    # There are multiple request types to choose from, this may not be the one I want for this situation
-    let(:response) { mock_response(200, 'body') }
-    let(:connection) { double('mock http connection', :put => response, :verify_callback= => nil) }
-    let(:instance) { model.new('the thing', 'some contents') }
-    let(:request) { save_request(instance.name, instance) }
+    it 'returns the HTTP reason if the response body is empty' do
+      stub_request(:get, 'http://puppet.example.com:8140/puppet/v3/failing_test_model').to_return(status: [500, 'Internal Server Error'])
 
-    before :each do
-      allow(terminus).to receive(:network).and_return(connection)
+      expect {
+        Puppet::FailingTestModel.indirection.find('foo')
+      }.to raise_error(Net::HTTPError, 'Error 500 on SERVER: Internal Server Error')
     end
 
-    it 'adds server_agent_version to the context if not already set' do
-      expect(Puppet).to receive(:push_context).with(:server_agent_version => Puppet.version)
-      terminus.handle_response(request, response)
-    end
+    it 'parses the response body as text' do
+      stub_request(
+        :get, 'http://puppet.example.com:8140/puppet/v3/failing_test_model'
+      ).to_return(status: [500, 'Internal Server Error'],
+                  headers: { 'Content-Type' => 'text/plain' },
+                  body: 'plaintext')
 
-    it 'does not add server_agent_version to the context if it is already set' do
-      Puppet.override(:server_agent_version => "5.3.4") do
-        expect(Puppet).not_to receive(:push_context)
-        terminus.handle_response(request, response)
-      end
+      expect {
+        Puppet::FailingTestModel.indirection.find('foo')
+      }.to raise_error(Net::HTTPError, 'Error 500 on SERVER: plaintext')
     end
 
-    it 'downgrades to pson and emits a warning' do
-      allow(response).to receive(:[]).with(Puppet::Network::HTTP::HEADER_PUPPET_VERSION).and_return('4.2.8')
-      Puppet[:preferred_serialization_format] = 'other'
+    it 'parses the response body as json and returns the "message"' do
+      stub_request(
+        :get, 'http://puppet.example.com:8140/puppet/v3/failing_test_model'
+      ).to_return(status: [500, 'Internal Server Error'],
+                  headers: { 'Content-Type' => 'application/json' },
+                  body: JSON.dump({'status' => false, 'message' => 'json error'}))
 
-      expect(Puppet).to receive(:warning).with('Downgrading to PSON for future requests')
-
-      terminus.handle_response(request, response)
-
-      expect(Puppet[:preferred_serialization_format]).to eq('pson')
+      expect {
+        Puppet::FailingTestModel.indirection.find('foo')
+      }.to raise_error(Net::HTTPError, 'Error 500 on SERVER: json error')
     end
 
-    it 'preserves the set serialization format' do
-      Puppet[:preferred_serialization_format] = 'other'
-
-      expect(Puppet[:preferred_serialization_format]).to eq('other')
+    it 'parses the response body as pson and returns the "message"' do
+      stub_request(
+        :get, 'http://puppet.example.com:8140/puppet/v3/failing_test_model'
+      ).to_return(status: [500, 'Internal Server Error'],
+                  headers: { 'Content-Type' => 'application/pson' },
+                  body: PSON.dump({'status' => false, 'message' => 'pson error'}))
 
-      terminus.handle_response(request, response)
+      expect {
+        Puppet::FailingTestModel.indirection.find('foo')
+      }.to raise_error(Net::HTTPError, 'Error 500 on SERVER: pson error')
     end
-  end
 
-  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 = mock_response('200', 'body')
+    it 'returns the response body if no content-type given' do
+      stub_request(
+        :get, 'http://puppet.example.com:8140/puppet/v3/failing_test_model'
+      ).to_return(status: [500, 'Internal Server Error'],
+                  body: 'unknown text')
 
-        expect(request).to receive(:do_request).with(terminus.class.srv_service, terminus.class.server, terminus.class.port).and_return(stub_response)
-
-        terminus.send(method, request)
-      end
+      expect {
+        Puppet::FailingTestModel.indirection.find('foo')
+      }.to raise_error(Net::HTTPError, 'Error 500 on SERVER: unknown text')
     end
   end
 end