puppet 6.15.0-universal-darwin → 6.19.1-universal-darwin

data/spec/unit/application/agent_spec.rb

@@ -12,16 +12,16 @@ describe Puppet::Application::Agent do
   before :each do
     @puppetd = Puppet::Application[:agent]
 
-    @daemon = Puppet::Daemon.new(nil)
+    @agent = double('agent')
+    allow(Puppet::Agent).to receive(:new).and_return(@agent)
+
+    @daemon = Puppet::Daemon.new(@agent, nil)
     allow(@daemon).to receive(:daemonize)
     allow(@daemon).to receive(:start)
     allow(@daemon).to receive(:stop)
     allow(Puppet::Daemon).to receive(:new).and_return(@daemon)
     Puppet[:daemonize] = false
 
-    @agent = double('agent')
-    allow(Puppet::Agent).to receive(:new).and_return(@agent)
-
     @puppetd.preinit
     allow(Puppet::Util::Log).to receive(:newdestination)
 
@@ -571,10 +571,9 @@ describe Puppet::Application::Agent do
         allow_any_instance_of(Puppet::X509::CertProvider).to receive(:load_request).and_return(nil)
 
         expect {
-          expect {
-            @puppetd.fingerprint
-          }.to exit_with(1)
-        }.to output(/Fingerprint asked but neither the certificate, nor the certificate request have been issued/).to_stderr
+          @puppetd.fingerprint
+        }.to exit_with(1)
+         .and output(/Fingerprint asked but neither the certificate, nor the certificate request have been issued/).to_stderr
       end
 
       it "should log an error if an exception occurs" do

data/spec/unit/application/doc_spec.rb

@@ -234,8 +234,8 @@ describe Puppet::Application::Doc do
         end
       end
 
-      it "should operate in master run_mode" do
-        expect(@doc.class.run_mode.name).to eq(:master)
+      it "should operate in server run_mode" do
+        expect(@doc.class.run_mode.name).to eq(:server)
 
         @doc.setup_rdoc
       end

data/spec/unit/application/face_base_spec.rb

@@ -423,16 +423,18 @@ EOT
     it "should work if asked to render json" do
       allow(app.command_line).to receive(:args).and_return(%w{count_args a b c --render-as json})
       expect {
-        expect { app.run }.to exit_with(0)
-      }.to have_printed(/3/)
+        app.run
+      }.to exit_with(0)
+       .and output(/3/).to_stdout
     end
 
     it "should invoke when_rendering hook 's' when asked to render-as 's'" do
       allow(app.command_line).to receive(:args).and_return(%w{with_s_rendering_hook --render-as s})
       app.action = app.face.get_action(:with_s_rendering_hook)
       expect {
-        expect { app.run }.to exit_with(0)
-      }.to have_printed(/you invoked the 's' rendering hook/)
+        app.run
+      }.to exit_with(0)
+       .and output(/you invoked the 's' rendering hook/).to_stdout
     end
   end
 

data/spec/unit/application/facts_spec.rb

@@ -2,21 +2,52 @@ require 'spec_helper'
 require 'puppet/application/facts'
 
 describe Puppet::Application::Facts do
+  let(:app) { Puppet::Application[:facts] }
+  let(:values) { {"filesystems" => "apfs,autofs,devfs", "macaddress" => "64:52:11:22:03:25"} }
+
   before :each do
-    allow(subject.command_line).to receive(:subcommand_name).and_return('facts')
+    Puppet::Node::Facts.indirection.terminus_class = :memory
   end
 
-  it "should return facts if a key is given to find" do
-    Puppet::Node::Facts.indirection.reset_terminus_class
-    expect(Puppet::Node::Facts.indirection).to receive(:find).and_return(Puppet::Node::Facts.new('whatever', {}))
-    allow(subject.command_line).to receive(:args).and_return(%w{find whatever --render-as yaml})
+  it "returns facts for a given node" do
+    facts = Puppet::Node::Facts.new('whatever', values)
+    Puppet::Node::Facts.indirection.save(facts)
+
+    app.command_line.args = %w{find whatever --render-as yaml}
+
+    # due to PUP-10105 we emit the class tag when we shouldn't
+    expected = Regexp.new(<<~END)
+      --- !ruby/object:Puppet::Node::Facts
+      name: whatever
+      values:
+        filesystems: apfs,autofs,devfs
+        macaddress: "64:52:11:22:03:25"
+    END
 
     expect {
-      expect {
-        subject.run
-      }.to exit_with(0)
-    }.to have_printed(/object:Puppet::Node::Facts/)
+      app.run
+    }.to exit_with(0)
+     .and output(expected).to_stdout
+  end
 
-    expect(@logs).to be_empty
+  it "returns facts for the current node when the name is omitted" do
+    facts = Puppet::Node::Facts.new(Puppet[:certname], values)
+    Puppet::Node::Facts.indirection.save(facts)
+
+    app.command_line.args = %w{find --render-as yaml}
+
+    # due to PUP-10105 we emit the class tag when we shouldn't
+    expected = Regexp.new(<<~END)
+      --- !ruby/object:Puppet::Node::Facts
+      name: #{Puppet[:certname]}
+      values:
+        filesystems: apfs,autofs,devfs
+        macaddress: "64:52:11:22:03:25"
+    END
+
+    expect {
+      app.run
+    }.to exit_with(0)
+     .and output(expected).to_stdout
   end
 end

data/spec/unit/application/man_spec.rb

@@ -0,0 +1,52 @@
+require 'spec_helper'
+require 'puppet/face'
+
+describe Puppet::Face[:man, :current] do
+  let(:pager) { '/path/to/our/pager' }
+
+  around do |example|
+    Puppet::Util.withenv('MANPAGER' => pager) do
+      example.run
+    end
+  end
+
+  it 'is deprecated' do
+    expect(subject).to be_deprecated
+  end
+
+  it 'has a man action' do
+    expect(subject).to be_action(:man)
+  end
+
+  it 'accepts a call with no arguments' do
+    expect { subject.man }.to output(/USAGE: puppet man <action>/).to_stdout
+  end
+
+  it 'raises an ArgumentError when given too many arguments' do
+    expect {
+      subject.man(:man, 'agent', 'extra')
+    }.to raise_error(ArgumentError)
+     .and output(/USAGE: puppet man <action>/).to_stdout
+  end
+
+  it "exits with 0 when generating man documentation for each available application" do
+    # turn off deprecation warning
+    Puppet[:disable_warnings] = ['deprecations']
+
+    allow(Puppet::Util).to receive(:which).with('ronn').and_return(nil)
+    allow(Puppet::Util).to receive(:which).with(pager).and_return(pager)
+
+    Puppet::Application.available_application_names.each do |name|
+      next if %w{man face_base indirection_base}.include? name
+
+      app = Puppet::Application[:man]
+      app.command_line.args << 'man' << name
+
+      expect {
+        allow(IO).to receive(:popen).with(pager, 'w:UTF-8').and_yield($stdout)
+        app.run
+      }.to exit_with(0)
+       .and output(/puppet-#{name}/m).to_stdout
+    end
+  end
+end

data/spec/unit/application/resource_spec.rb

@@ -51,7 +51,9 @@ describe Puppet::Application::Resource do
       # provider is a parameter that should always be available
       @resource_app.extra_params = [ :provider ]
 
-      expect { @resource_app.main }.to have_printed(/provider\s+=>/)
+      expect {
+        @resource_app.main
+      }.to output(/provider\s+=>/).to_stdout
     end
   end
 

data/spec/unit/application/ssl_spec.rb

@@ -38,7 +38,7 @@ describe Puppet::Application::Ssl, unless: Puppet::Util::Platform.jruby? do
   def expects_command_to_pass(expected_output = nil)
     expect {
       ssl.run_command
-    }.to have_printed(expected_output)
+    }.to output(expected_output).to_stdout
   end
 
   def expects_command_to_fail(message)
@@ -46,7 +46,7 @@ describe Puppet::Application::Ssl, unless: Puppet::Util::Platform.jruby? do
       expect {
         ssl.run_command
       }.to raise_error(Puppet::Error, message)
-    }.to have_printed(/.*/) # ignore output
+    }.to output(/.*/).to_stdout
   end
 
   shared_examples_for 'an ssl action' do
@@ -266,6 +266,19 @@ describe Puppet::Application::Ssl, unless: Puppet::Util::Platform.jruby? do
       FileUtils.cp(File.join(PuppetSpec::FIXTURE_DIR, 'ssl', 'encrypted-key.pem'), Puppet[:hostprivkey])
       FileUtils.cp(File.join(PuppetSpec::FIXTURE_DIR, 'ssl', 'signed.pem'), Puppet[:hostcert])
 
+      # To verify the client cert we need the root and intermediate certs and crls.
+      # We don't need to do this with `ssl-client` cert above, because it is issued
+      # directly from the generated TestCa above.
+      File.open(Puppet[:localcacert], 'w') do |f|
+        f.write(File.read(File.join(PuppetSpec::FIXTURE_DIR, 'ssl', 'ca.pem')))
+        f.write(File.read(File.join(PuppetSpec::FIXTURE_DIR, 'ssl', 'intermediate.pem')))
+      end
+
+      File.open(Puppet[:hostcrl], 'w') do |f|
+        f.write(File.read(File.join(PuppetSpec::FIXTURE_DIR, 'ssl', 'crl.pem')))
+        f.write(File.read(File.join(PuppetSpec::FIXTURE_DIR, 'ssl', 'intermediate-crl.pem')))
+      end
+
       Puppet[:passfile] = file_containing('passfile', '74695716c8b6')
 
       expects_command_to_pass(%r{Verified client certificate 'CN=signed' fingerprint})

data/spec/unit/application_spec.rb

@@ -118,6 +118,11 @@ describe Puppet::Application do
       @appclass.run_mode :agent
       expect(@appclass.run_mode.name).to eq(:agent)
     end
+
+    it "considers :server to be master" do
+      @appclass.run_mode :server
+      expect(@appclass.run_mode).to be_master
+    end
   end
 
   describe ".environment_mode" do
@@ -147,7 +152,7 @@ describe Puppet::Application do
   describe "when dealing with run_mode" do
 
     class TestApp < Puppet::Application
-      run_mode :master
+      run_mode :server
       def run_command
         # no-op
       end
@@ -159,16 +164,16 @@ describe Puppet::Application do
       app = TestApp.new
       app.initialize_app_defaults
 
-      expect(Puppet.run_mode).to be_master
+      expect(Puppet.run_mode).to be_server
     end
 
     it "should sadly and frighteningly allow run_mode to change at runtime via #run" do
       app = TestApp.new
       app.run
 
-      expect(app.class.run_mode.name).to eq(:master)
+      expect(app.class.run_mode.name).to eq(:server)
 
-      expect(Puppet.run_mode).to be_master
+      expect(Puppet.run_mode).to be_server
     end
   end
 

data/spec/unit/configurer/downloader_spec.rb

@@ -228,5 +228,15 @@ describe Puppet::Configurer::Downloader do
 
       expect { @dler.evaluate }.not_to raise_error
     end
+
+    it "raises an exception if catalog application fails" do
+      Puppet[:ignore_plugin_errors] = false
+
+      expect(@dler.file).to receive(:retrieve).and_raise(Puppet::Error, "testing")
+
+      expect {
+        @dler.evaluate
+      }.to raise_error(Puppet::Error, /testing/)
+    end
   end
 end

data/spec/unit/configurer/fact_handler_spec.rb

@@ -104,7 +104,7 @@ describe Puppet::Configurer::FactHandler do
           expect(text).to include(test_fact[:encoded])
 
           # this is not sufficient to test whether these values are sent via HTTP GET or HTTP POST in actual catalog request
-          expect(JSON.parse(URI.unescape(to_upload[:facts]))['values']).to eq(test_fact[:hash])
+          expect(JSON.parse(Puppet::Util.uri_unescape(to_upload[:facts]))['values']).to eq(test_fact[:hash])
         end
       end
     end
@@ -129,7 +129,7 @@ describe Puppet::Configurer::FactHandler do
           expect(to_upload).to eq({:facts_format => 'application/json', :facts => text})
           expect(text).to include(test_fact[:encoded])
 
-          expect(JSON.parse(URI.unescape(to_upload[:facts]))['values']).to eq(test_fact[:hash])
+          expect(JSON.parse(Puppet::Util.uri_unescape(to_upload[:facts]))['values']).to eq(test_fact[:hash])
         end
       end
     end
@@ -138,9 +138,9 @@ describe Puppet::Configurer::FactHandler do
       facts = Puppet::Node::Facts.new(Puppet[:node_name_value], 'my_name_fact' => 'other_node_name')
       Puppet::Node::Facts.indirection.save(facts)
 
-      # prefer URI.unescape but validate CGI also works
+      # prefer Puppet::Util.uri_unescape but validate CGI also works
       encoded_facts = facthandler.facts_for_uploading[:facts]
-      expect(URI.unescape(encoded_facts)).to validate_against('api/schemas/facts.json')
+      expect(Puppet::Util.uri_unescape(encoded_facts)).to validate_against('api/schemas/facts.json')
       expect(CGI.unescape(encoded_facts)).to validate_against('api/schemas/facts.json')
     end
   end

data/spec/unit/configurer_spec.rb

@@ -1,6 +1,5 @@
 require 'spec_helper'
 require 'puppet/configurer'
-require 'webmock/rspec'
 
 describe Puppet::Configurer do
   before do
@@ -85,6 +84,44 @@ describe Puppet::Configurer do
       expect(configurer.run).to eq(0)
     end
 
+    it "fails the run if pluginsync fails when usecacheonfailure is false" do
+      Puppet[:ignore_plugin_errors] = false
+
+      # --test implies these, set them so we don't fall back to a cached catalog
+      Puppet[:use_cached_catalog] = false
+      Puppet[:usecacheonfailure] = false
+
+      body = "{\"message\":\"Not Found: Could not find environment 'fasdfad'\",\"issue_kind\":\"RUNTIME_ERROR\"}"
+      stub_request(:get, %r{/puppet/v3/file_metadatas/pluginfacts}).to_return(
+        status: 404, body: body, headers: {'Content-Type' => 'application/json'}
+      )
+      stub_request(:get, %r{/puppet/v3/file_metadata/pluginfacts}).to_return(
+        status: 404, body: body, headers: {'Content-Type' => 'application/json'}
+      )
+
+      configurer.run(pluginsync: true)
+
+      expect(@logs).to include(an_object_having_attributes(level: :err, message: %r{Failed to apply catalog: Failed to retrieve pluginfacts: Could not retrieve information from environment production source\(s\) puppet:///pluginfacts}))
+    end
+
+    it "applies a cached catalog if pluginsync fails when usecacheonfailure is true" do
+      Puppet[:ignore_plugin_errors] = false
+
+      Puppet[:use_cached_catalog] = false
+      Puppet[:usecacheonfailure] = true
+
+      body = "{\"message\":\"Not Found: Could not find environment 'fasdfad'\",\"issue_kind\":\"RUNTIME_ERROR\"}"
+      stub_request(:get, %r{/puppet/v3/file_metadatas/pluginfacts}).to_return(
+        status: 404, body: body, headers: {'Content-Type' => 'application/json'}
+      )
+      stub_request(:get, %r{/puppet/v3/file_metadata/pluginfacts}).to_return(
+        status: 404, body: body, headers: {'Content-Type' => 'application/json'}
+      )
+
+      expect(configurer.run(pluginsync: true, :report => report)).to eq(0)
+      expect(report.cached_catalog_status).to eq('on_failure')
+    end
+
     it "applies a cached catalog when it can't connect to the master" do
       error = Errno::ECONNREFUSED.new('Connection refused - connect(2)')
 
@@ -96,7 +133,8 @@ describe Puppet::Configurer do
     end
 
     it "should initialize a transaction report if one is not provided" do
-      expect(Puppet::Transaction::Report).to receive(:new).and_return(report)
+      # host and settings catalogs each create a report...
+      expect(Puppet::Transaction::Report).to receive(:new).and_return(report).twice
 
       configurer.run
     end
@@ -192,22 +230,21 @@ describe Puppet::Configurer do
     end
 
     it "should remove the report as a log destination when the run is finished" do
-      expect(Puppet::Transaction::Report).to receive(:new).and_return(report)
-
-      configurer.run
+      configurer.run(report: report)
 
       expect(Puppet::Util::Log.destinations).not_to include(report)
     end
 
-    it "should return the report exit_status as the result of the run" do
-      expect(Puppet::Transaction::Report).to receive(:new).and_return(report)
-      expect(report).to receive(:exit_status).and_return(1234)
+    it "should return an exit status of 2 due to the notify resource 'changing'" do
+      cat = Puppet::Resource::Catalog.new("tester", Puppet::Node::Environment.remote(Puppet[:environment].to_sym))
+      cat.add_resource(Puppet::Type.type(:notify).new(:name => 'something changed'))
 
-      expect(configurer.run).to eq(1234)
+      expect(configurer.run(catalog: cat, report: report)).to eq(2)
     end
 
     it "should return nil if catalog application fails" do
-      expect_any_instance_of(Puppet::Resource::Catalog).to receive(:apply).and_raise(Puppet::Error, 'One or more resource dependency cycles detected in graph')
+      expect(catalog).to receive(:apply).and_raise(Puppet::Error, 'One or more resource dependency cycles detected in graph')
+
       expect(configurer.run(catalog: catalog, report: report)).to be_nil
     end
 
@@ -222,34 +259,28 @@ describe Puppet::Configurer do
     end
 
     it "should include the pre-run command failure in the report" do
-      expect(Puppet::Transaction::Report).to receive(:new).and_return(report)
-
       Puppet.settings[:prerun_command] = "/my/command"
       expect(Puppet::Util::Execution).to receive(:execute).with(["/my/command"]).and_raise(Puppet::ExecutionFailure, "Failed")
 
-      expect(configurer.run).to be_nil
+      expect(configurer.run(report: report)).to be_nil
       expect(report.logs.find { |x| x.message =~ /Could not run command from prerun_command/ }).to be
     end
 
     it "should send the transaction report even if the post-run command fails" do
-      expect(Puppet::Transaction::Report).to receive(:new).and_return(report)
-
       Puppet.settings[:postrun_command] = "/my/command"
       expect(Puppet::Util::Execution).to receive(:execute).with(["/my/command"]).and_raise(Puppet::ExecutionFailure, "Failed")
       expect(configurer).to receive(:send_report).with(report)
 
-      expect(configurer.run).to be_nil
+      expect(configurer.run(report: report)).to be_nil
     end
 
     it "should include the post-run command failure in the report" do
-      expect(Puppet::Transaction::Report).to receive(:new).and_return(report)
-
       Puppet.settings[:postrun_command] = "/my/command"
       expect(Puppet::Util::Execution).to receive(:execute).with(["/my/command"]).and_raise(Puppet::ExecutionFailure, "Failed")
 
       expect(report).to receive(:<<) { |log, _| expect(log.message).to match(/Could not run command from postrun_command/) }.at_least(:once)
 
-      expect(configurer.run).to be_nil
+      expect(configurer.run(report: report)).to be_nil
     end
 
     it "should execute post-run command even if the pre-run command fails" do
@@ -262,34 +293,28 @@ describe Puppet::Configurer do
     end
 
     it "should finalize the report" do
-      expect(Puppet::Transaction::Report).to receive(:new).and_return(report)
-
       expect(report).to receive(:finalize_report)
-      configurer.run
+      configurer.run(report: report)
     end
 
     it "should not apply the catalog if the pre-run command fails" do
-      expect(Puppet::Transaction::Report).to receive(:new).and_return(report)
-
       Puppet.settings[:prerun_command] = "/my/command"
       expect(Puppet::Util::Execution).to receive(:execute).with(["/my/command"]).and_raise(Puppet::ExecutionFailure, "Failed")
 
       expect_any_instance_of(Puppet::Resource::Catalog).not_to receive(:apply)
       expect(configurer).to receive(:send_report)
 
-      expect(configurer.run).to be_nil
+      expect(configurer.run(report: report)).to be_nil
     end
 
     it "should apply the catalog, send the report, and return nil if the post-run command fails" do
-      expect(Puppet::Transaction::Report).to receive(:new).and_return(report)
-
       Puppet.settings[:postrun_command] = "/my/command"
       expect(Puppet::Util::Execution).to receive(:execute).with(["/my/command"]).and_raise(Puppet::ExecutionFailure, "Failed")
 
       expect_any_instance_of(Puppet::Resource::Catalog).to receive(:apply)
       expect(configurer).to receive(:send_report)
 
-      expect(configurer.run).to be_nil
+      expect(configurer.run(report: report)).to be_nil
     end
 
     it 'includes total time metrics in the report after successfully applying the catalog' do
@@ -546,6 +571,15 @@ describe Puppet::Configurer do
     end
   end
 
+  def expects_pluginsync
+    metadata = "[{\"path\":\"/etc/puppetlabs/code\",\"relative_path\":\".\",\"links\":\"follow\",\"owner\":0,\"group\":0,\"mode\":420,\"checksum\":{\"type\":\"ctime\",\"value\":\"{ctime}2020-07-10 14:00:00 -0700\"},\"type\":\"directory\",\"destination\":null}]"
+    stub_request(:get, %r{/puppet/v3/file_metadatas/(plugins|locales)}).to_return(status: 200, body: metadata, headers: {'Content-Type' => 'application/json'})
+
+    # response retains owner/group/mode due to source_permissions => use
+    facts_metadata = "[{\"path\":\"/etc/puppetlabs/code\",\"relative_path\":\".\",\"links\":\"follow\",\"owner\":500,\"group\":500,\"mode\":493,\"checksum\":{\"type\":\"ctime\",\"value\":\"{ctime}2020-07-10 14:00:00 -0700\"},\"type\":\"directory\",\"destination\":null}]"
+    stub_request(:get, %r{/puppet/v3/file_metadatas/pluginfacts}).to_return(status: 200, body: facts_metadata, headers: {'Content-Type' => 'application/json'})
+  end
+
   def expects_new_catalog_only(catalog)
     expect(Puppet::Resource::Catalog.indirection).to receive(:find).with(anything, hash_including(ignore_cache: true)).and_return(catalog)
     expect(Puppet::Resource::Catalog.indirection).not_to receive(:find).with(anything, hash_including(ignore_terminus: true))
@@ -562,6 +596,7 @@ describe Puppet::Configurer do
   end
 
   def expects_fallback_to_new_catalog(catalog)
+    expects_pluginsync
     expect(Puppet::Resource::Catalog.indirection).to receive(:find).with(anything, hash_including(ignore_terminus: true)).and_return(nil)
     expect(Puppet::Resource::Catalog.indirection).to receive(:find).with(anything, hash_including(ignore_cache: true)).and_return(catalog)
   end
@@ -598,7 +633,6 @@ describe Puppet::Configurer do
       it "should make a node request and pluginsync when a cached catalog cannot be retrieved" do
         expect(Puppet::Node.indirection).to receive(:find).and_return(nil)
         expects_fallback_to_new_catalog(catalog)
-        expect(configurer).to receive(:download_plugins)
 
         configurer.run
       end
@@ -636,6 +670,7 @@ describe Puppet::Configurer do
       it "should not attempt to retrieve a cached catalog again if the first attempt failed" do
         expect(Puppet::Node.indirection).to receive(:find).and_return(nil)
         expects_neither_new_or_cached_catalog
+        expects_pluginsync
 
         # after failing to use a cached catalog, we'll need to pluginsync before getting
         # a new catalog, which also fails.
@@ -656,8 +691,7 @@ describe Puppet::Configurer do
       end
 
       it "applies the catalog passed as options when the catalog cache terminus is not set" do
-        stub_request(:get, %r{/puppet/v3/file_metadatas?/plugins}).to_return(:status => 404)
-        stub_request(:get, %r{/puppet/v3/file_metadatas?/pluginfacts}).to_return(:status => 404)
+        expects_pluginsync
 
         catalog.add_resource(Puppet::Resource.new('notify', 'from apply'))
         configurer.run(catalog: catalog.to_ral)
@@ -1010,30 +1044,45 @@ describe Puppet::Configurer do
       options = {}
       configurer.run(options)
       expect(options[:report].master_used).to eq('myserver:123')
+      expect(options[:report].server_used).to eq('myserver:123')
     end
 
-    it "should report when a server is unavailable" do
+    it "should report when usecacheonfailure is false and server is unavailable" do
       Puppet.settings[:server_list] = ["myserver:123"]
+      Puppet[:usecacheonfailure] = false
 
       stub_request(:get, 'https://myserver:123/status/v1/simple/master').to_return(status: [500, "Internal Server Error"])
 
-      allow(Puppet).to receive(:debug)
-      expect(Puppet).to receive(:debug).with("Puppet server myserver:123 is unavailable: 500 Internal Server Error")
-
       expect {
         configurer.run
-      }.to raise_error(Puppet::Error, /Could not select a functional puppet master from server_list:/)
+      }.to raise_error(Puppet::Error, /Could not select a functional puppet server from server_list:/)
+
+      expect(@logs).to include(an_object_having_attributes(level: :err, message: /Puppet server myserver:123 is unavailable: 500 Internal Server Error/))
     end
 
     it "should error when no servers in 'server_list' are reachable" do
       Puppet.settings[:server_list] = "myserver:123,someotherservername"
+      Puppet[:usecacheonfailure] = false
 
       stub_request(:get, 'https://myserver:123/status/v1/simple/master').to_return(status: 400)
       stub_request(:get, 'https://someotherservername:8140/status/v1/simple/master').to_return(status: 400)
 
       expect{
         configurer.run
-      }.to raise_error(Puppet::Error, /Could not select a functional puppet master from server_list: 'myserver:123,someotherservername'/)
+      }.to raise_error(Puppet::Error, /Could not select a functional puppet server from server_list: 'myserver:123,someotherservername'/)
+    end
+
+    it "should not error when usecacheonfailure is true and no servers in 'server_list' are reachable" do
+      Puppet.settings[:server_list] = "myserver:123,someotherservername"
+      Puppet[:usecacheonfailure] = true
+
+      stub_request(:get, 'https://myserver:123/status/v1/simple/master').to_return(status: 400)
+      stub_request(:get, 'https://someotherservername:8140/status/v1/simple/master').to_return(status: 400)
+
+      options = {}
+
+      expect(configurer.run(options)).to eq(0)
+      expect(options[:report].server_used).to be_nil
     end
 
     it "should not make multiple node requests when the server is found" do