puppet 6.20.0-x64-mingw32 → 7.0.0-x64-mingw32

data/spec/unit/{network/http → http}/site_spec.rb

@@ -1,14 +1,14 @@
 require 'spec_helper'
 
-require 'puppet/network/http'
+require 'puppet/http'
 
-describe Puppet::Network::HTTP::Site do
+describe Puppet::HTTP::Site do
   let(:scheme)      { 'https' }
   let(:host)        { 'rubygems.org' }
   let(:port)        { 443 }
 
   def create_site(scheme, host, port)
-    Puppet::Network::HTTP::Site.new(scheme, host, port)
+    described_class.new(scheme, host, port)
   end
 
   it 'accepts scheme, host, and port' do

data/spec/unit/indirector/face_spec.rb

@@ -33,6 +33,7 @@ describe Puppet::Indirector::Face do
   describe "as an instance" do
     it "should be able to determine its indirection" do
       # Loading actions here can get, um, complicated
+      allow(Puppet::Face).to receive(:load_actions)
       expect(Puppet::Indirector::Face.new(:catalog, '0.0.1').indirection).to equal(Puppet::Resource::Catalog.indirection)
     end
   end

data/spec/unit/indirector/facts/facter_spec.rb

@@ -22,12 +22,14 @@ describe Puppet::Node::Facts::Facter do
   end
 
   before :each do
+    allow(Puppet::Node::Facts::Facter).to receive(:reload_facter)
     @facter = Puppet::Node::Facts::Facter.new
     allow(Facter).to receive(:to_hash).and_return({})
     @name = "me"
     @request = double('request', :key => @name)
     @environment = double('environment')
     allow(@request).to receive(:environment).and_return(@environment)
+    allow(@request).to receive(:options).and_return({})
     allow(@request.environment).to receive(:modules).and_return([])
     allow(@request.environment).to receive(:modulepath).and_return([])
   end
@@ -104,6 +106,7 @@ describe Puppet::Node::Facts::Facter do
       expect(FileTest).to receive(:directory?).with(factpath1).and_return(true)
       expect(FileTest).to receive(:directory?).with(factpath2).and_return(true)
       allow(@request.environment).to receive(:modulepath).and_return([modulepath])
+      allow(@request).to receive(:options).and_return({})
       expect(Dir).to receive(:glob).with("#{modulepath}/*/lib/facter").and_return([modulelibfacter])
       expect(Dir).to receive(:glob).with("#{modulepath}/*/plugins/facter").and_return([modulepluginsfacter])
 
@@ -149,4 +152,99 @@ describe Puppet::Node::Facts::Facter do
       Puppet::Node::Facts::Facter.setup_external_search_paths @request
     end
   end
+
+  describe 'when :resolve_options is true' do
+    let(:options) { { resolve_options: true, user_query: ["os", "timezone"], show_legacy: true } }
+    let(:facts) { Puppet::Node::Facts.new("foo") }
+
+    before :each do
+      allow(@request).to receive(:options).and_return(options)
+      allow(Puppet::Node::Facts).to receive(:new).and_return(facts)
+      allow(Facter).to receive(:respond_to?).and_return(false)
+      allow(Facter).to receive(:respond_to?).with(:resolve).and_return(true)
+      allow(facts).to receive(:add_local_facts)
+    end
+
+    it 'should call Facter.resolve method' do
+      expect(Facter).to receive(:resolve).with("os timezone --show-legacy")
+      @facter.find(@request)
+    end
+
+    it 'should NOT add local facts' do
+      expect(facts).not_to receive(:add_local_facts)
+
+      @facter.find(@request)
+    end
+
+    describe 'when Facter version is lower than 4.0.40' do
+      before :each do
+        allow(Facter).to receive(:respond_to?).and_return(false)
+        allow(Facter).to receive(:respond_to?).with(:resolve).and_return(false)
+      end
+
+      it 'raises an error' do
+        expect { @facter.find(@request) }.to raise_error(Puppet::Error, "puppet facts show requires version 4.0.40 or greater of Facter.")
+      end
+    end
+
+    describe 'when setting up external search paths' do
+      let(:options) { { resolve_options: true, user_query: ["os", "timezone"], external_dir: 'some/dir' } }
+      let(:pluginfactdest) { File.expand_path 'plugin/dest' }
+      let(:modulepath) { File.expand_path 'module/foo' }
+      let(:modulefactsd) { File.expand_path 'module/foo/facts.d'  }
+
+      before :each do
+        expect(FileTest).to receive(:directory?).with(pluginfactdest).and_return(true)
+        mod = Puppet::Module.new('foo', modulepath, @request.environment)
+        allow(@request.environment).to receive(:modules).and_return([mod])
+        Puppet[:pluginfactdest] = pluginfactdest
+      end
+
+      it 'should skip files' do
+        expect(File).to receive(:directory?).with(modulefactsd).and_return(false)
+        expect(Facter).to receive(:search_external).with([pluginfactdest, options[:external_dir]])
+        Puppet::Node::Facts::Facter.setup_external_search_paths @request
+      end
+
+      it 'should add directories' do
+        expect(File).to receive(:directory?).with(modulefactsd).and_return(true)
+        expect(Facter).to receive(:search_external).with([modulefactsd, pluginfactdest, options[:external_dir]])
+        Puppet::Node::Facts::Facter.setup_external_search_paths @request
+      end
+    end
+
+    describe 'when setting up search paths' do
+      let(:factpath1) { File.expand_path 'one' }
+      let(:factpath2) { File.expand_path 'two' }
+      let(:factpath) { [factpath1, factpath2].join(File::PATH_SEPARATOR) }
+      let(:modulepath) { File.expand_path 'module/foo' }
+      let(:modulelibfacter) { File.expand_path 'module/foo/lib/facter' }
+      let(:modulepluginsfacter) { File.expand_path 'module/foo/plugins/facter' }
+      let(:options) { { resolve_options: true, custom_dir: 'some/dir' } }
+
+      before :each do
+        expect(FileTest).to receive(:directory?).with(factpath1).and_return(true)
+        expect(FileTest).to receive(:directory?).with(factpath2).and_return(true)
+        allow(@request.environment).to receive(:modulepath).and_return([modulepath])
+        expect(Dir).to receive(:glob).with("#{modulepath}/*/lib/facter").and_return([modulelibfacter])
+        expect(Dir).to receive(:glob).with("#{modulepath}/*/plugins/facter").and_return([modulepluginsfacter])
+
+        Puppet[:factpath] = factpath
+      end
+
+      it 'should skip files' do
+        expect(FileTest).to receive(:directory?).with(modulelibfacter).and_return(false)
+        expect(FileTest).to receive(:directory?).with(modulepluginsfacter).and_return(false)
+        expect(Facter).to receive(:search).with(factpath1, factpath2, options[:custom_dir])
+        Puppet::Node::Facts::Facter.setup_search_paths @request
+      end
+
+      it 'should add directories' do
+        expect(FileTest).to receive(:directory?).with(modulelibfacter).and_return(true)
+        expect(FileTest).to receive(:directory?).with(modulepluginsfacter).and_return(false)
+        expect(Facter).to receive(:search).with(modulelibfacter, factpath1, factpath2, options[:custom_dir])
+        Puppet::Node::Facts::Facter.setup_search_paths @request
+      end
+    end
+  end
 end

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_bucket_file/selector_spec.rb

@@ -5,40 +5,22 @@ require 'puppet/indirector/file_bucket_file/file'
 require 'puppet/indirector/file_bucket_file/rest'
 
 describe Puppet::FileBucketFile::Selector do
-  let(:model) { Puppet::FileBucket::File.new('') }
-  let(:indirection) { Puppet::FileBucket::File.indirection }
-  let(:terminus) { indirection.terminus(:selector) }
-
   %w[head find save search destroy].each do |method|
     describe "##{method}" do
       it "should proxy to rest terminus for https requests" do
-        key = "https://example.com/path/to/file"
+        request = double('request', :protocol => 'https')
 
-        expect(indirection.terminus(:rest)).to receive(method)
+        expect_any_instance_of(Puppet::FileBucketFile::Rest).to receive(method).with(request)
 
-        if method == 'save'
-          terminus.send(method, indirection.request(method, key, model))
-        else
-          terminus.send(method, indirection.request(method, key, nil))
-        end
+        subject.send(method, request)
       end
 
       it "should proxy to file terminus for other requests" do
-        key = "file:///path/to/file"
-
-        case method
-        when 'save'
-          expect(indirection.terminus(:file)).to receive(method)
-          terminus.send(method, indirection.request(method, key, model))
-        when 'find', 'head'
-          expect(indirection.terminus(:file)).to receive(method)
-          terminus.send(method, indirection.request(method, key, nil))
-        else
-          # file terminus doesn't implement search or destroy
-          expect {
-            terminus.send(method, indirection.request(method, key, nil))
-          }.to raise_error(NoMethodError)
-        end
+        request = double('request', :protocol => 'file')
+
+        expect_any_instance_of(Puppet::FileBucketFile::File).to receive(method).with(request)
+
+        subject.send(method, request)
       end
     end
   end

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/indirection_spec.rb

@@ -178,25 +178,29 @@ describe Puppet::Indirector::Indirection do
 
     describe "creates a request" do
       it "should create it with its name as the request's indirection name" do
-        expect(@indirection.request(:funtest, "yayness", nil).indirection_name).to eq(@indirection.name)
+        expect(Puppet::Indirector::Request).to receive(:new).with(@indirection.name, anything, anything)
+        @indirection.request(:funtest, "yayness")
       end
 
       it "should require a method and key" do
-        request = @indirection.request(:funtest, "yayness", nil)
-        expect(request.method).to eq(:funtest)
-        expect(request.key).to eq("yayness")
+        expect(Puppet::Indirector::Request).to receive(:new).with(anything, :funtest, "yayness")
+        @indirection.request(:funtest, "yayness")
       end
 
       it "should support optional arguments" do
-        expect(@indirection.request(:funtest, "yayness", nil, :one => :two).options).to eq(:one => :two)
+        expect(Puppet::Indirector::Request).to receive(:new).with(anything, anything, anything, {:one => :two})
+        @indirection.request(:funtest, "yayness", :one => :two)
       end
 
       it "should not pass options if none are supplied" do
-        expect(@indirection.request(:funtest, "yayness", nil).options).to eq({})
+        expect(Puppet::Indirector::Request).to receive(:new).with(anything, anything, anything)
+        @indirection.request(:funtest, "yayness")
       end
 
       it "should return the request" do
-        expect(@indirection.request(:funtest, "yayness", nil)).to be_a(Puppet::Indirector::Request)
+        request = double('request')
+        expect(Puppet::Indirector::Request).to receive(:new).and_return(request)
+        expect(@indirection.request(:funtest, "yayness")).to equal(request)
       end
     end
 
@@ -829,7 +833,7 @@ describe Puppet::Indirector::Indirection do
     end
 
     it "should not create a terminus instance until one is actually needed" do
-      expect(@indirection).not_to receive(:terminus)
+      expect(Puppet::Indirector).not_to receive(:terminus)
       Puppet::Indirector::Indirection.new(double('model'), :lazytest)
     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