puppet 6.4.0-x64-mingw32 → 6.4.1-x64-mingw32

data/spec/unit/capability_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet_spec/compiler'
 
@@ -9,7 +8,7 @@ describe 'Capability types' do
   let(:loaders) { Puppet::Pops::Loaders.new(env) }
 
   before(:each) do
-    Puppet::Parser::Compiler.any_instance.stubs(:loaders).returns(loaders)
+    allow_any_instance_of(Puppet::Parser::Compiler).to receive(:loaders).and_return(loaders)
     Puppet.push_context({:loaders => loaders, :current_environment => env})
     Puppet::Type.newtype :cap, :is_capability => true do
       newparam :name
@@ -86,7 +85,7 @@ describe 'Capability types' do
       parse_results << parser.parse
 
       main = Puppet::Parser::AST::Hostclass.new('', :code => Puppet::Parser::ParserFactory.code_merger.concatenate(parse_results))
-      Puppet::Node::Environment.any_instance.stubs(:perform_initial_import).returns main
+      allow_any_instance_of(Puppet::Node::Environment).to receive(:perform_initial_import).and_return(main)
 
       type = compile_to_catalog(nil).environment_instance.known_resource_types.definition(:test)
       expect(type.produces).to be_instance_of(Array)
@@ -120,7 +119,7 @@ describe 'Capability types' do
       parse_results << parser.parse
 
       main = Puppet::Parser::AST::Hostclass.new('', :code => Puppet::Parser::ParserFactory.code_merger.concatenate(parse_results))
-      Puppet::Node::Environment.any_instance.stubs(:perform_initial_import).returns main
+     allow_any_instance_of(Puppet::Node::Environment).to receive(:perform_initial_import).and_return(main)
 
       type = compile_to_catalog(nil).environment_instance.known_resource_types.definition('Mod::Test')
       expect(type.produces).to be_instance_of(Array)
@@ -131,6 +130,7 @@ describe 'Capability types' do
       expect(cns[:mappings]).to be_instance_of(Hash)
       expect(cns[:mappings]['host']).to be_instance_of(Puppet::Parser::AST::PopsBridge::Expression)
     end
+
     it "does not allow operator '+>' in a mapping" do
       expect do
       compile_to_catalog(<<-MANIFEST, node)
@@ -256,12 +256,12 @@ test { one: hostname => "ahost", export => Cap[two] }
     def mock_cap_finding
       cap = Puppet::Resource.new("Cap", "two")
       cap["host"] = "ahost"
-      Puppet::Resource::CapabilityFinder.expects(:find).returns(cap)
+      expect(Puppet::Resource::CapabilityFinder).to receive(:find).and_return(cap)
       cap
     end
 
     it "does not fetch a consumed resource when consume metaparam not set" do
-      Puppet::Resource::CapabilityFinder.expects(:find).never
+      expect(Puppet::Resource::CapabilityFinder).not_to receive(:find)
       catalog = make_catalog("test { one: }")
       expect(catalog.resource_keys.find { |type, _| type == "Cap" }).to be_nil
       expect(catalog.resource("Test", "one")["hostname"]).to eq("nohost")

data/spec/unit/certificate_factory_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/test_ca'
 
@@ -20,7 +19,7 @@ describe Puppet::CertificateFactory, :unless => RUBY_PLATFORM == 'java' do
     it "should return a new X509 certificate" do
       a = subject.build(:server, csr, issuer, serial)
       b = subject.build(:server, csr, issuer, serial)
-      # The two instances are equal in every aspect except that they are 
+      # The two instances are equal in every aspect except that they are
       # different instances - they are `==`, but not hash `eql?`
       expect(a).not_to eql(b)
     end
@@ -63,7 +62,7 @@ describe Puppet::CertificateFactory, :unless => RUBY_PLATFORM == 'java' do
 
     it "should respect a custom TTL for the CA" do
       now = Time.now.utc
-      Time.expects(:now).at_least_once.returns(now)
+      expect(Time).to receive(:now).at_least(:once).and_return(now)
       cert = subject.build(:server, csr, issuer, serial, 12)
       expect(cert.not_after.to_i).to eq(now.to_i + 12)
     end
@@ -87,7 +86,6 @@ describe Puppet::CertificateFactory, :unless => RUBY_PLATFORM == 'java' do
       )
     end
 
-
     it "should add an extension for the authorityKeyIdentifer" do
       cert = subject.build(:server, csr, issuer, serial)
       ef = OpenSSL::X509::ExtensionFactory.new(issuer, cert)
@@ -131,7 +129,7 @@ describe Puppet::CertificateFactory, :unless => RUBY_PLATFORM == 'java' do
       csr = Puppet::SSL::CertificateRequest.new(name)
       csr.generate(key)
 
-      csr.stubs(:request_extensions).returns([
+      allow(csr).to receive(:request_extensions).and_return([
         {'oid' => '1.3.6.1.4.1.34380.1.2.1', 'value' => 'some-value'},
         {'oid' => 'pp_uuid', 'value' => 'some-uuid'},
       ])

data/spec/unit/configurer/downloader_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/configurer/downloader'
@@ -90,14 +89,14 @@ describe Puppet::Configurer::Downloader do
       end
 
       it "should always set the owner to the current UID" do
-        Process.expects(:uid).returns 51
+        expect(Process).to receive(:uid).and_return(51)
 
         file = generate_file_resource(:path => '/path')
         expect(file[:owner]).to eq(51)
       end
 
       it "should always set the group to the current GID" do
-        Process.expects(:gid).returns 61
+        expect(Process).to receive(:gid).and_return(61)
 
         file = generate_file_resource(:path => '/path')
         expect(file[:group]).to eq(61)
@@ -161,7 +160,7 @@ describe Puppet::Configurer::Downloader do
     end
 
     it "should not issue a deprecation warning for source_permissions" do
-      Puppet.expects(:puppet_deprecation_warning).never
+      expect(Puppet).not_to receive(:puppet_deprecation_warning)
       catalog = @dler.catalog
       expect(catalog.resources.size).to eq(1) # Must consume catalog to fix warnings
     end
@@ -184,37 +183,37 @@ describe Puppet::Configurer::Downloader do
     end
 
     it "should log that it is downloading" do
-      Puppet.expects(:info)
+      expect(Puppet).to receive(:info)
 
       @dler.evaluate
     end
 
     it "should return all changed file paths" do
-      trans = mock 'transaction'
+      trans = double('transaction')
 
-      catalog = mock 'catalog'
-      @dler.expects(:catalog).returns(catalog)
-      catalog.expects(:apply).yields(trans)
+      catalog = double('catalog')
+      expect(@dler).to receive(:catalog).and_return(catalog)
+      expect(catalog).to receive(:apply).and_yield(trans)
 
-      resource = mock 'resource'
-      resource.expects(:[]).with(:path).returns "/changed/file"
+      resource = double('resource')
+      expect(resource).to receive(:[]).with(:path).and_return("/changed/file")
 
-      trans.expects(:changed?).returns([resource])
+      expect(trans).to receive(:changed?).and_return([resource])
 
       expect(@dler.evaluate).to eq(%w{/changed/file})
     end
 
     it "should yield the resources if a block is given" do
-      trans = mock 'transaction'
+      trans = double('transaction')
 
-      catalog = mock 'catalog'
-      @dler.expects(:catalog).returns(catalog)
-      catalog.expects(:apply).yields(trans)
+      catalog = double('catalog')
+      expect(@dler).to receive(:catalog).and_return(catalog)
+      expect(catalog).to receive(:apply).and_yield(trans)
 
-      resource = mock 'resource'
-      resource.expects(:[]).with(:path).returns "/changed/file"
+      resource = double('resource')
+      expect(resource).to receive(:[]).with(:path).and_return("/changed/file")
 
-      trans.expects(:changed?).returns([resource])
+      expect(trans).to receive(:changed?).and_return([resource])
 
       yielded = nil
       @dler.evaluate { |r| yielded = r }
@@ -222,10 +221,10 @@ describe Puppet::Configurer::Downloader do
     end
 
     it "should catch and log exceptions" do
-      Puppet.expects(:log_exception)
+      expect(Puppet).to receive(:log_exception)
       # The downloader creates a new catalog for each apply, and really the only object
       # that it is possible to stub for the purpose of generating a puppet error
-      Puppet::Resource::Catalog.any_instance.stubs(:apply).raises(Puppet::Error, "testing")
+      allow_any_instance_of(Puppet::Resource::Catalog).to receive(:apply).and_raise(Puppet::Error, "testing")
 
       expect { @dler.evaluate }.not_to raise_error
     end

data/spec/unit/configurer/fact_handler_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/configurer'
 require 'puppet/configurer/fact_handler'
@@ -58,13 +57,13 @@ describe Puppet::Configurer::FactHandler do
     end
 
     it "should fail if finding facts fails" do
-      Puppet::Node::Facts.indirection.expects(:find).raises RuntimeError
+      expect(Puppet::Node::Facts.indirection).to receive(:find).and_raise(RuntimeError)
 
       expect { facthandler.find_facts }.to raise_error(Puppet::Error, /Could not retrieve local facts/)
     end
 
     it "should only load fact plugins once" do
-      Puppet::Node::Facts.indirection.expects(:find).once
+      expect(Puppet::Node::Facts.indirection).to receive(:find).once
       facthandler.find_facts
     end
   end

data/spec/unit/configurer/plugin_handler_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/configurer'
 require 'puppet/configurer/plugin_handler'
@@ -11,21 +10,35 @@ describe Puppet::Configurer::PluginHandler do
     before :each do
       # PluginHandler#load_plugin has an extra-strong rescue clause
       # this mock is to make sure that we don't silently ignore errors
-      Puppet.expects(:err).never
+      expect(Puppet).not_to receive(:err)
       # Server_agent version needs to be at 5.3.4 in order to mount locales
       Puppet.push_context({:server_agent_version => "5.3.4"})
     end
 
     it "downloads plugins, facts, and locales" do
-      Puppet::Configurer::Downloader.any_instance.expects(:evaluate).times(3).returns([])
+      times_called = 0
+      allow_any_instance_of(Puppet::Configurer::Downloader).to receive(:evaluate) { times_called += 1 }.and_return([])
 
       pluginhandler.download_plugins(environment)
+      expect(times_called).to eq(3)
     end
 
     it "returns downloaded plugin, fact, and locale filenames" do
-      Puppet::Configurer::Downloader.any_instance.expects(:evaluate).times(3).returns(%w[/a]).then.returns(%w[/b]).then.returns(%w[/c])
+      times_called = 0
+      allow_any_instance_of(Puppet::Configurer::Downloader).to receive(:evaluate) do
+        times_called += 1
+
+        if times_called == 1
+          %w[/a]
+        elsif times_called == 2
+          %w[/b]
+        else
+          %w[/c]
+        end
+      end
 
       expect(pluginhandler.download_plugins(environment)).to match_array(%w[/a /b /c])
+      expect(times_called).to eq(3)
     end
   end
 
@@ -33,15 +46,25 @@ describe Puppet::Configurer::PluginHandler do
     before :each do
       # PluginHandler#load_plugin has an extra-strong rescue clause
       # this mock is to make sure that we don't silently ignore errors
-      Puppet.expects(:err).never
+      expect(Puppet).not_to receive(:err)
       # Server_agent version needs to be at 5.3.4 in order to mount locales
       Puppet.push_context({:server_agent_version => "5.3.3"})
     end
 
     it "returns downloaded plugin, fact, but not locale filenames" do
-      Puppet::Configurer::Downloader.any_instance.expects(:evaluate).times(2).returns(%w[/a]).then.returns(%w[/b])
+      times_called = 0
+      allow_any_instance_of(Puppet::Configurer::Downloader).to receive(:evaluate) do
+        times_called += 1
+
+        if times_called == 1
+          %w[/a]
+        else
+          %w[/b]
+        end
+      end
 
       expect(pluginhandler.download_plugins(environment)).to match_array(%w[/a /b])
+      expect(times_called).to eq(2)
     end
   end
 
@@ -49,16 +72,26 @@ describe Puppet::Configurer::PluginHandler do
     before :each do
       # PluginHandler#load_plugin has an extra-strong rescue clause
       # this mock is to make sure that we don't silently ignore errors
-      Puppet.expects(:err).never
+      expect(Puppet).not_to receive(:err)
       # Server_agent version needs to be at 5.3.4 in order to mount locales
       # A blank version will default to 0.0
       Puppet.push_context({:server_agent_version => ""})
     end
 
     it "returns downloaded plugin, fact, but not locale filenames" do
-      Puppet::Configurer::Downloader.any_instance.expects(:evaluate).times(2).returns(%w[/a]).then.returns(%w[/b])
+      times_called = 0
+      allow_any_instance_of(Puppet::Configurer::Downloader).to receive(:evaluate) do
+        times_called += 1
+
+        if times_called == 1
+          %w[/a]
+        else
+          %w[/b]
+        end
+      end
 
       expect(pluginhandler.download_plugins(environment)).to match_array(%w[/a /b])
+      expect(times_called).to eq(2)
     end
   end
 end

data/spec/unit/configurer_spec.rb

@@ -1,13 +1,12 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/configurer'
 
 describe Puppet::Configurer do
   before do
-    Puppet.settings.stubs(:use).returns(true)
+    allow(Puppet.settings).to receive(:use).and_return(true)
     @agent = Puppet::Configurer.new
-    @agent.stubs(:init_storage)
-    Puppet::Util::Storage.stubs(:store)
+    allow(@agent).to receive(:init_storage)
+    allow(Puppet::Util::Storage).to receive(:store)
     Puppet[:server] = "puppetmaster"
     Puppet[:report] = true
   end
@@ -19,21 +18,21 @@ describe Puppet::Configurer do
   describe "when executing a pre-run hook" do
     it "should do nothing if the hook is set to an empty string" do
       Puppet.settings[:prerun_command] = ""
-      Puppet::Util.expects(:exec).never
+      expect(Puppet::Util).not_to receive(:exec)
 
       @agent.execute_prerun_command
     end
 
     it "should execute any pre-run command provided via the 'prerun_command' setting" do
       Puppet.settings[:prerun_command] = "/my/command"
-      Puppet::Util::Execution.expects(:execute).with(["/my/command"]).raises(Puppet::ExecutionFailure, "Failed")
+      expect(Puppet::Util::Execution).to receive(:execute).with(["/my/command"]).and_raise(Puppet::ExecutionFailure, "Failed")
 
       @agent.execute_prerun_command
     end
 
     it "should fail if the command fails" do
       Puppet.settings[:prerun_command] = "/my/command"
-      Puppet::Util::Execution.expects(:execute).with(["/my/command"]).raises(Puppet::ExecutionFailure, "Failed")
+      expect(Puppet::Util::Execution).to receive(:execute).with(["/my/command"]).and_raise(Puppet::ExecutionFailure, "Failed")
 
       expect(@agent.execute_prerun_command).to be_falsey
     end
@@ -42,21 +41,21 @@ describe Puppet::Configurer do
   describe "when executing a post-run hook" do
     it "should do nothing if the hook is set to an empty string" do
       Puppet.settings[:postrun_command] = ""
-      Puppet::Util.expects(:exec).never
+      expect(Puppet::Util).not_to receive(:exec)
 
       @agent.execute_postrun_command
     end
 
     it "should execute any post-run command provided via the 'postrun_command' setting" do
       Puppet.settings[:postrun_command] = "/my/command"
-      Puppet::Util::Execution.expects(:execute).with(["/my/command"]).raises(Puppet::ExecutionFailure, "Failed")
+      expect(Puppet::Util::Execution).to receive(:execute).with(["/my/command"]).and_raise(Puppet::ExecutionFailure, "Failed")
 
       @agent.execute_postrun_command
     end
 
     it "should fail if the command fails" do
       Puppet.settings[:postrun_command] = "/my/command"
-      Puppet::Util::Execution.expects(:execute).with(["/my/command"]).raises(Puppet::ExecutionFailure, "Failed")
+      expect(Puppet::Util::Execution).to receive(:execute).with(["/my/command"]).and_raise(Puppet::ExecutionFailure, "Failed")
 
       expect(@agent.execute_postrun_command).to be_falsey
     end
@@ -64,20 +63,20 @@ describe Puppet::Configurer do
 
   describe "when executing a catalog run" do
     before do
-      Puppet.settings.stubs(:use).returns(true)
-      @agent.stubs(:download_plugins)
+      allow(Puppet.settings).to receive(:use).and_return(true)
+      allow(@agent).to receive(:download_plugins)
       Puppet::Node::Facts.indirection.terminus_class = :memory
       @facts = Puppet::Node::Facts.new(Puppet[:node_name_value])
       Puppet::Node::Facts.indirection.save(@facts)
 
       @catalog = Puppet::Resource::Catalog.new("tester", Puppet::Node::Environment.remote(Puppet[:environment].to_sym))
-      @catalog.stubs(:to_ral).returns(@catalog)
+      allow(@catalog).to receive(:to_ral).and_return(@catalog)
       Puppet::Resource::Catalog.indirection.terminus_class = :rest
-      Puppet::Resource::Catalog.indirection.stubs(:find).returns(@catalog)
-      @agent.stubs(:send_report)
-      @agent.stubs(:save_last_run_summary)
+      allow(Puppet::Resource::Catalog.indirection).to receive(:find).and_return(@catalog)
+      allow(@agent).to receive(:send_report)
+      allow(@agent).to receive(:save_last_run_summary)
 
-      Puppet::Util::Log.stubs(:close_all)
+      allow(Puppet::Util::Log).to receive(:close_all)
     end
 
     after :all do
@@ -86,39 +85,39 @@ describe Puppet::Configurer do
     end
 
     it "should initialize storage" do
-      Puppet::Util::Storage.expects(:load)
+      expect(Puppet::Util::Storage).to receive(:load)
       @agent.run
     end
 
     it "downloads plugins when told" do
-      @agent.expects(:download_plugins)
+      expect(@agent).to receive(:download_plugins)
       @agent.run(:pluginsync => true)
     end
 
     it "does not download plugins when told" do
-      @agent.expects(:download_plugins).never
+      expect(@agent).not_to receive(:download_plugins)
       @agent.run(:pluginsync => false)
     end
 
     it "should carry on when it can't fetch its node definition" do
       error = Net::HTTPError.new(400, 'dummy server communication error')
-      Puppet::Node.indirection.expects(:find).raises(error)
+      expect(Puppet::Node.indirection).to receive(:find).and_raise(error)
       expect(@agent.run).to eq(0)
     end
 
     it "applies a cached catalog when it can't connect to the master" do
       error = Errno::ECONNREFUSED.new('Connection refused - connect(2)')
 
-      Puppet::Node.indirection.expects(:find).raises(error)
-      Puppet::Resource::Catalog.indirection.expects(:find).with(anything, has_entry(:ignore_cache => true)).raises(error)
-      Puppet::Resource::Catalog.indirection.expects(:find).with(anything, has_entry(:ignore_terminus => true)).returns(@catalog)
+      expect(Puppet::Node.indirection).to receive(:find).and_raise(error)
+      expect(Puppet::Resource::Catalog.indirection).to receive(:find).with(anything, hash_including(:ignore_cache => true)).and_raise(error)
+      expect(Puppet::Resource::Catalog.indirection).to receive(:find).with(anything, hash_including(:ignore_terminus => true)).and_return(@catalog)
 
       expect(@agent.run).to eq(0)
     end
 
     it "should initialize a transaction report if one is not provided" do
       report = Puppet::Transaction::Report.new
-      Puppet::Transaction::Report.expects(:new).returns report
+      expect(Puppet::Transaction::Report).to receive(:new).and_return(report)
 
       @agent.run
     end
@@ -135,15 +134,15 @@ describe Puppet::Configurer do
 
     it "should pass the new report to the catalog" do
       report = Puppet::Transaction::Report.new
-      Puppet::Transaction::Report.stubs(:new).returns report
-      @catalog.expects(:apply).with{|options| options[:report] == report}
+      allow(Puppet::Transaction::Report).to receive(:new).and_return(report)
+      expect(@catalog).to receive(:apply).with(hash_including(report: report))
 
       @agent.run
     end
 
     it "should use the provided report if it was passed one" do
       report = Puppet::Transaction::Report.new
-      @catalog.expects(:apply).with {|options| options[:report] == report}
+      expect(@catalog).to receive(:apply).with(hash_including(report: report))
 
       @agent.run(:report => report)
     end
@@ -151,69 +150,69 @@ describe Puppet::Configurer do
     it "should set the report as a log destination" do
       report = Puppet::Transaction::Report.new
 
-      report.expects(:<<).with(instance_of(Puppet::Util::Log)).at_least_once
+      expect(report).to receive(:<<).with(instance_of(Puppet::Util::Log)).at_least(:once)
 
       @agent.run(:report => report)
     end
 
     it "should retrieve the catalog" do
-      @agent.expects(:retrieve_catalog)
+      expect(@agent).to receive(:retrieve_catalog)
 
       @agent.run
     end
 
     it "should log a failure and do nothing if no catalog can be retrieved" do
-      @agent.expects(:retrieve_catalog).returns nil
+      expect(@agent).to receive(:retrieve_catalog).and_return(nil)
 
-      Puppet.expects(:err).with "Could not retrieve catalog; skipping run"
+      expect(Puppet).to receive(:err).with("Could not retrieve catalog; skipping run")
 
       @agent.run
     end
 
     it "should apply the catalog with all options to :run" do
-      @agent.expects(:retrieve_catalog).returns @catalog
+      expect(@agent).to receive(:retrieve_catalog).and_return(@catalog)
 
-      @catalog.expects(:apply).with { |args| args[:one] == true }
+      expect(@catalog).to receive(:apply).with(hash_including(one: true))
       @agent.run :one => true
     end
 
     it "should accept a catalog and use it instead of retrieving a different one" do
-      @agent.expects(:retrieve_catalog).never
+      expect(@agent).not_to receive(:retrieve_catalog)
 
-      @catalog.expects(:apply)
+      expect(@catalog).to receive(:apply)
       @agent.run :one => true, :catalog => @catalog
     end
 
     it "should benchmark how long it takes to apply the catalog" do
-      @agent.expects(:benchmark).with(:notice, instance_of(String))
+      expect(@agent).to receive(:benchmark).with(:notice, instance_of(String))
 
-      @agent.expects(:retrieve_catalog).returns @catalog
+      expect(@agent).to receive(:retrieve_catalog).and_return(@catalog)
 
-      @catalog.expects(:apply).never # because we're not yielding
+      expect(@catalog).not_to receive(:apply) # because we're not yielding
       @agent.run
     end
 
     it "should execute post-run hooks after the run" do
-      @agent.expects(:execute_postrun_command)
+      expect(@agent).to receive(:execute_postrun_command)
 
       @agent.run
     end
 
     it "should create report with passed transaction_uuid and job_id" do
       @agent = Puppet::Configurer.new("test_tuuid", "test_jid")
-      @agent.stubs(:init_storage)
+      allow(@agent).to receive(:init_storage)
 
       report = Puppet::Transaction::Report.new(nil, "test", "aaaa")
-      Puppet::Transaction::Report.expects(:new).with(anything, anything, 'test_tuuid', 'test_jid').returns(report)
-      @agent.expects(:send_report).with(report)
+      expect(Puppet::Transaction::Report).to receive(:new).with(anything, anything, 'test_tuuid', 'test_jid').and_return(report)
+      expect(@agent).to receive(:send_report).with(report)
 
       @agent.run
     end
 
     it "should send the report" do
       report = Puppet::Transaction::Report.new(nil, "test", "aaaa")
-      Puppet::Transaction::Report.expects(:new).returns(report)
-      @agent.expects(:send_report).with(report)
+      expect(Puppet::Transaction::Report).to receive(:new).and_return(report)
+      expect(@agent).to receive(:send_report).with(report)
 
       expect(report.environment).to eq("test")
       expect(report.transaction_uuid).to eq("aaaa")
@@ -222,11 +221,11 @@ describe Puppet::Configurer do
     end
 
     it "should send the transaction report even if the catalog could not be retrieved" do
-      @agent.expects(:retrieve_catalog).returns nil
+      expect(@agent).to receive(:retrieve_catalog).and_return(nil)
 
       report = Puppet::Transaction::Report.new(nil, "test", "aaaa")
-      Puppet::Transaction::Report.expects(:new).returns(report)
-      @agent.expects(:send_report).with(report)
+      expect(Puppet::Transaction::Report).to receive(:new).and_return(report)
+      expect(@agent).to receive(:send_report).with(report)
 
       expect(report.environment).to eq("test")
       expect(report.transaction_uuid).to eq("aaaa")
@@ -235,11 +234,11 @@ describe Puppet::Configurer do
     end
 
     it "should send the transaction report even if there is a failure" do
-      @agent.expects(:retrieve_catalog).raises "whatever"
+      expect(@agent).to receive(:retrieve_catalog).and_raise("whatever")
 
       report = Puppet::Transaction::Report.new(nil, "test", "aaaa")
-      Puppet::Transaction::Report.expects(:new).returns(report)
-      @agent.expects(:send_report).with(report)
+      expect(Puppet::Transaction::Report).to receive(:new).and_return(report)
+      expect(@agent).to receive(:send_report).with(report)
 
       expect(report.environment).to eq("test")
       expect(report.transaction_uuid).to eq("aaaa")
@@ -249,7 +248,7 @@ describe Puppet::Configurer do
 
     it "should remove the report as a log destination when the run is finished" do
       report = Puppet::Transaction::Report.new
-      Puppet::Transaction::Report.expects(:new).returns(report)
+      expect(Puppet::Transaction::Report).to receive(:new).and_return(report)
 
       @agent.run
 
@@ -258,35 +257,35 @@ describe Puppet::Configurer do
 
     it "should return the report exit_status as the result of the run" do
       report = Puppet::Transaction::Report.new
-      Puppet::Transaction::Report.expects(:new).returns(report)
-      report.expects(:exit_status).returns(1234)
+      expect(Puppet::Transaction::Report).to receive(:new).and_return(report)
+      expect(report).to receive(:exit_status).and_return(1234)
 
       expect(@agent.run).to eq(1234)
     end
 
     it "should return nil if catalog application fails" do
-      @catalog.expects(:apply).raises(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')
       report = Puppet::Transaction::Report.new
       expect(@agent.run(catalog: @catalog, report: report)).to be_nil
     end
 
     it "should send the transaction report even if the pre-run command fails" do
       report = Puppet::Transaction::Report.new
-      Puppet::Transaction::Report.expects(:new).returns(report)
+      expect(Puppet::Transaction::Report).to receive(:new).and_return(report)
 
       Puppet.settings[:prerun_command] = "/my/command"
-      Puppet::Util::Execution.expects(:execute).with(["/my/command"]).raises(Puppet::ExecutionFailure, "Failed")
-      @agent.expects(:send_report).with(report)
+      expect(Puppet::Util::Execution).to receive(:execute).with(["/my/command"]).and_raise(Puppet::ExecutionFailure, "Failed")
+      expect(@agent).to receive(:send_report).with(report)
 
       expect(@agent.run).to be_nil
     end
 
     it "should include the pre-run command failure in the report" do
       report = Puppet::Transaction::Report.new
-      Puppet::Transaction::Report.expects(:new).returns(report)
+      expect(Puppet::Transaction::Report).to receive(:new).and_return(report)
 
       Puppet.settings[:prerun_command] = "/my/command"
-      Puppet::Util::Execution.expects(:execute).with(["/my/command"]).raises(Puppet::ExecutionFailure, "Failed")
+      expect(Puppet::Util::Execution).to receive(:execute).with(["/my/command"]).and_raise(Puppet::ExecutionFailure, "Failed")
 
       expect(@agent.run).to be_nil
       expect(report.logs.find { |x| x.message =~ /Could not run command from prerun_command/ }).to be
@@ -294,23 +293,23 @@ describe Puppet::Configurer do
 
     it "should send the transaction report even if the post-run command fails" do
       report = Puppet::Transaction::Report.new
-      Puppet::Transaction::Report.expects(:new).returns(report)
+      expect(Puppet::Transaction::Report).to receive(:new).and_return(report)
 
       Puppet.settings[:postrun_command] = "/my/command"
-      Puppet::Util::Execution.expects(:execute).with(["/my/command"]).raises(Puppet::ExecutionFailure, "Failed")
-      @agent.expects(:send_report).with(report)
+      expect(Puppet::Util::Execution).to receive(:execute).with(["/my/command"]).and_raise(Puppet::ExecutionFailure, "Failed")
+      expect(@agent).to receive(:send_report).with(report)
 
       expect(@agent.run).to be_nil
     end
 
     it "should include the post-run command failure in the report" do
       report = Puppet::Transaction::Report.new
-      Puppet::Transaction::Report.expects(:new).returns(report)
+      expect(Puppet::Transaction::Report).to receive(:new).and_return(report)
 
       Puppet.settings[:postrun_command] = "/my/command"
-      Puppet::Util::Execution.expects(:execute).with(["/my/command"]).raises(Puppet::ExecutionFailure, "Failed")
+      expect(Puppet::Util::Execution).to receive(:execute).with(["/my/command"]).and_raise(Puppet::ExecutionFailure, "Failed")
 
-      report.expects(:<<).with { |log| log.message.include?("Could not run command from postrun_command") }
+      expect(report).to receive(:<<) { |log, _| expect(log.message).to match(/Could not run command from postrun_command/) }.at_least(:once)
 
       expect(@agent.run).to be_nil
     end
@@ -318,49 +317,49 @@ describe Puppet::Configurer do
     it "should execute post-run command even if the pre-run command fails" do
       Puppet.settings[:prerun_command] = "/my/precommand"
       Puppet.settings[:postrun_command] = "/my/postcommand"
-      Puppet::Util::Execution.expects(:execute).with(["/my/precommand"]).raises(Puppet::ExecutionFailure, "Failed")
-      Puppet::Util::Execution.expects(:execute).with(["/my/postcommand"])
+      expect(Puppet::Util::Execution).to receive(:execute).with(["/my/precommand"]).and_raise(Puppet::ExecutionFailure, "Failed")
+      expect(Puppet::Util::Execution).to receive(:execute).with(["/my/postcommand"])
 
       expect(@agent.run).to be_nil
     end
 
     it "should finalize the report" do
       report = Puppet::Transaction::Report.new
-      Puppet::Transaction::Report.expects(:new).returns(report)
+      expect(Puppet::Transaction::Report).to receive(:new).and_return(report)
 
-      report.expects(:finalize_report)
+      expect(report).to receive(:finalize_report)
       @agent.run
     end
 
     it "should not apply the catalog if the pre-run command fails" do
       report = Puppet::Transaction::Report.new
-      Puppet::Transaction::Report.expects(:new).returns(report)
+      expect(Puppet::Transaction::Report).to receive(:new).and_return(report)
 
       Puppet.settings[:prerun_command] = "/my/command"
-      Puppet::Util::Execution.expects(:execute).with(["/my/command"]).raises(Puppet::ExecutionFailure, "Failed")
+      expect(Puppet::Util::Execution).to receive(:execute).with(["/my/command"]).and_raise(Puppet::ExecutionFailure, "Failed")
 
-      @catalog.expects(:apply).never()
-      @agent.expects(:send_report)
+      expect(@catalog).not_to receive(:apply)
+      expect(@agent).to receive(:send_report)
 
       expect(@agent.run).to be_nil
     end
 
     it "should apply the catalog, send the report, and return nil if the post-run command fails" do
       report = Puppet::Transaction::Report.new
-      Puppet::Transaction::Report.expects(:new).returns(report)
+      expect(Puppet::Transaction::Report).to receive(:new).and_return(report)
 
       Puppet.settings[:postrun_command] = "/my/command"
-      Puppet::Util::Execution.expects(:execute).with(["/my/command"]).raises(Puppet::ExecutionFailure, "Failed")
+      expect(Puppet::Util::Execution).to receive(:execute).with(["/my/command"]).and_raise(Puppet::ExecutionFailure, "Failed")
 
-      @catalog.expects(:apply)
-      @agent.expects(:send_report)
+      expect(@catalog).to receive(:apply)
+      expect(@agent).to receive(:send_report)
 
       expect(@agent.run).to be_nil
     end
 
     it 'includes total time metrics in the report after successfully applying the catalog' do
       report = Puppet::Transaction::Report.new
-      @catalog.stubs(:apply).with() {|options| options[:report] == report }
+      allow(@catalog).to receive(:apply).with(hash_including(report: report))
       @agent.run(report: report)
 
       expect(report.metrics['time']).to be
@@ -369,7 +368,7 @@ describe Puppet::Configurer do
 
     it 'includes total time metrics in the report even if prerun fails' do
       Puppet.settings[:prerun_command] = "/my/command"
-      Puppet::Util::Execution.expects(:execute).with(["/my/command"]).raises(Puppet::ExecutionFailure, "Failed")
+      expect(Puppet::Util::Execution).to receive(:execute).with(["/my/command"]).and_raise(Puppet::ExecutionFailure, "Failed")
 
       report = Puppet::Transaction::Report.new
       @agent.run(report: report)
@@ -380,7 +379,7 @@ describe Puppet::Configurer do
 
     it 'includes total time metrics in the report even if catalog retrieval fails' do
       report = Puppet::Transaction::Report.new
-      @agent.stubs(:prepare_and_retrieve_catalog_from_cache).raises
+      allow(@agent).to receive(:prepare_and_retrieve_catalog_from_cache).and_raise
       @agent.run(:report => report)
 
       expect(report.metrics['time']).to be
@@ -389,13 +388,13 @@ describe Puppet::Configurer do
 
     it "should refetch the catalog if the server specifies a new environment in the catalog" do
       catalog = Puppet::Resource::Catalog.new("tester", Puppet::Node::Environment.remote('second_env'))
-      @agent.expects(:retrieve_catalog).returns(catalog).twice
+      expect(@agent).to receive(:retrieve_catalog).and_return(catalog).twice
 
       @agent.run
     end
 
     it "should change the environment setting if the server specifies a new environment in the catalog" do
-      @catalog.stubs(:environment).returns("second_env")
+      allow(@catalog).to receive(:environment).and_return("second_env")
 
       @agent.run
 
@@ -404,11 +403,11 @@ describe Puppet::Configurer do
 
     it "should fix the report if the server specifies a new environment in the catalog" do
       report = Puppet::Transaction::Report.new(nil, "test", "aaaa")
-      Puppet::Transaction::Report.expects(:new).returns(report)
-      @agent.expects(:send_report).with(report)
+      expect(Puppet::Transaction::Report).to receive(:new).and_return(report)
+      expect(@agent).to receive(:send_report).with(report)
 
-      @catalog.stubs(:environment).returns("second_env")
-      @agent.stubs(:retrieve_catalog).returns(@catalog)
+      allow(@catalog).to receive(:environment).and_return("second_env")
+      allow(@agent).to receive(:retrieve_catalog).and_return(@catalog)
 
       @agent.run
 
@@ -417,24 +416,24 @@ describe Puppet::Configurer do
 
     it "sends the transaction uuid in a catalog request" do
       @agent.instance_variable_set(:@transaction_uuid, 'aaa')
-      Puppet::Resource::Catalog.indirection.expects(:find).with(anything, has_entries(:transaction_uuid => 'aaa'))
+      expect(Puppet::Resource::Catalog.indirection).to receive(:find).with(anything, hash_including(transaction_uuid: 'aaa'))
       @agent.run
     end
 
     it "sends the transaction uuid in a catalog request" do
       @agent.instance_variable_set(:@job_id, 'aaa')
-      Puppet::Resource::Catalog.indirection.expects(:find).with(anything, has_entries(:job_id => 'aaa'))
+      expect(Puppet::Resource::Catalog.indirection).to receive(:find).with(anything, hash_including(job_id: 'aaa'))
       @agent.run
     end
 
     it "sets the static_catalog query param to true in a catalog request" do
-      Puppet::Resource::Catalog.indirection.expects(:find).with(anything, has_entries(:static_catalog => true))
+      expect(Puppet::Resource::Catalog.indirection).to receive(:find).with(anything, hash_including(static_catalog: true))
       @agent.run
     end
 
     it "sets the checksum_type query param to the default supported_checksum_types in a catalog request" do
-      Puppet::Resource::Catalog.indirection.expects(:find).with(anything,
-        has_entries(:checksum_type => 'md5.sha256.sha384.sha512.sha224'))
+      expect(Puppet::Resource::Catalog.indirection).to receive(:find).with(anything,
+        hash_including(checksum_type: 'md5.sha256.sha384.sha512.sha224'))
       @agent.run
     end
 
@@ -442,22 +441,22 @@ describe Puppet::Configurer do
       # Regenerate the agent to pick up the new setting
       Puppet[:supported_checksum_types] = ['sha256']
       @agent = Puppet::Configurer.new
-      @agent.stubs(:init_storage)
-      @agent.stubs(:download_plugins)
-      @agent.stubs(:send_report)
-      @agent.stubs(:save_last_run_summary)
+      allow(@agent).to receive(:init_storage)
+      allow(@agent).to receive(:download_plugins)
+      allow(@agent).to receive(:send_report)
+      allow(@agent).to receive(:save_last_run_summary)
 
-      Puppet::Resource::Catalog.indirection.expects(:find).with(anything, has_entries(:checksum_type => 'sha256'))
+      expect(Puppet::Resource::Catalog.indirection).to receive(:find).with(anything, hash_including(checksum_type: 'sha256'))
       @agent.run
     end
 
     describe "when not using a REST terminus for catalogs" do
       it "should not pass any facts when retrieving the catalog" do
         Puppet::Resource::Catalog.indirection.terminus_class = :compiler
-        @agent.expects(:facts_for_uploading).never
-        Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options|
+        expect(@agent).not_to receive(:facts_for_uploading)
+        expect(Puppet::Resource::Catalog.indirection).to receive(:find) do |name, options|
           options[:facts].nil?
-        }.returns @catalog
+        end.and_return(@catalog)
 
         @agent.run
       end
@@ -471,11 +470,9 @@ describe Puppet::Configurer do
         # call to "encode" - the encode in turn returns mocked data that is asserted as being
         # presented to the catalog terminus as options.
         #
-        @agent.expects(:find_facts).returns(12345)
-        @agent.expects(:encode_facts).with(12345).returns(:facts => "myfacts", :facts_format => :foo)
-        Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options|
-          options[:facts] == "myfacts" and options[:facts_format] == :foo
-        }.returns @catalog
+        expect(@agent).to receive(:find_facts).and_return(12345)
+        expect(@agent).to receive(:encode_facts).with(12345).and_return(:facts => "myfacts", :facts_format => :foo)
+        expect(Puppet::Resource::Catalog.indirection).to receive(:find).with(anything, hash_including(facts: "myfacts", facts_format: :foo)).and_return(@catalog)
 
         @agent.run
       end
@@ -484,7 +481,7 @@ describe Puppet::Configurer do
 
   describe "when initialized with a transaction_uuid" do
     it "stores it" do
-      SecureRandom.expects(:uuid).never
+      expect(SecureRandom).not_to receive(:uuid)
       configurer = Puppet::Configurer.new('foo')
       expect(configurer.instance_variable_get(:@transaction_uuid) == 'foo')
     end
@@ -494,7 +491,7 @@ describe Puppet::Configurer do
     include PuppetSpec::Files
 
     before do
-      Puppet.settings.stubs(:use).returns(true)
+      allow(Puppet.settings).to receive(:use).and_return(true)
       @configurer = Puppet::Configurer.new
       Puppet[:lastrunfile] = tmpfile('last_run_file')
 
@@ -505,53 +502,53 @@ describe Puppet::Configurer do
     it "should print a report summary if configured to do so" do
       Puppet.settings[:summarize] = true
 
-      @report.expects(:summary).returns "stuff"
+      expect(@report).to receive(:summary).and_return("stuff")
 
-      @configurer.expects(:puts).with("stuff")
+      expect(@configurer).to receive(:puts).with("stuff")
       @configurer.send_report(@report)
     end
 
     it "should not print a report summary if not configured to do so" do
       Puppet.settings[:summarize] = false
 
-      @configurer.expects(:puts).never
+      expect(@configurer).not_to receive(:puts)
       @configurer.send_report(@report)
     end
 
     it "should save the report if reporting is enabled" do
       Puppet.settings[:report] = true
 
-      Puppet::Transaction::Report.indirection.expects(:save).with(@report, nil, instance_of(Hash))
+      expect(Puppet::Transaction::Report.indirection).to receive(:save).with(@report, nil, instance_of(Hash))
       @configurer.send_report(@report)
     end
 
     it "should not save the report if reporting is disabled" do
       Puppet.settings[:report] = false
 
-      Puppet::Transaction::Report.indirection.expects(:save).with(@report, nil, instance_of(Hash)).never
+      expect(Puppet::Transaction::Report.indirection).not_to receive(:save).with(@report, nil, instance_of(Hash))
       @configurer.send_report(@report)
     end
 
     it "should save the last run summary if reporting is enabled" do
       Puppet.settings[:report] = true
 
-      @configurer.expects(:save_last_run_summary).with(@report)
+      expect(@configurer).to receive(:save_last_run_summary).with(@report)
       @configurer.send_report(@report)
     end
 
     it "should save the last run summary if reporting is disabled" do
       Puppet.settings[:report] = false
 
-      @configurer.expects(:save_last_run_summary).with(@report)
+      expect(@configurer).to receive(:save_last_run_summary).with(@report)
       @configurer.send_report(@report)
     end
 
     it "should log but not fail if saving the report fails" do
       Puppet.settings[:report] = true
 
-      Puppet::Transaction::Report.indirection.expects(:save).raises("whatever")
+      expect(Puppet::Transaction::Report.indirection).to receive(:save).and_raise("whatever")
 
-      Puppet.expects(:send_log).with(:err, 'Could not send report: whatever')
+      expect(Puppet).to receive(:send_log).with(:err, 'Could not send report: whatever')
       @configurer.send_report(@report)
     end
   end
@@ -560,10 +557,10 @@ describe Puppet::Configurer do
     include PuppetSpec::Files
 
     before do
-      Puppet.settings.stubs(:use).returns(true)
+      allow(Puppet.settings).to receive(:use).and_return(true)
       @configurer = Puppet::Configurer.new
 
-      @report = stub 'report', :raw_summary => {}
+      @report = double('report', :raw_summary => {})
 
       Puppet[:lastrunfile] = tmpfile('last_run_file')
     end
@@ -574,7 +571,7 @@ describe Puppet::Configurer do
     end
 
     it "should write the raw summary as yaml" do
-      @report.expects(:raw_summary).returns("summary")
+      expect(@report).to receive(:raw_summary).and_return("summary")
       @configurer.save_last_run_summary(@report)
       expect(File.read(Puppet[:lastrunfile])).to eq(YAML.dump("summary"))
     end
@@ -588,14 +585,14 @@ describe Puppet::Configurer do
         end
       end.new
 
-      Puppet::Util.expects(:replace_file).yields(fh)
+      expect(Puppet::Util).to receive(:replace_file).and_yield(fh)
 
-      Puppet.expects(:send_log).with(:err, 'Could not save last run local report: failed to do print')
+      expect(Puppet).to receive(:send_log).with(:err, 'Could not save last run local report: failed to do print')
       @configurer.save_last_run_summary(@report)
     end
 
     it "should create the last run file with the correct mode" do
-      Puppet.settings.setting(:lastrunfile).expects(:mode).returns('664')
+      expect(Puppet.settings.setting(:lastrunfile)).to receive(:mode).and_return('664')
       @configurer.save_last_run_summary(@report)
 
       if Puppet::Util::Platform.windows?
@@ -608,66 +605,66 @@ describe Puppet::Configurer do
     end
 
     it "should report invalid last run file permissions" do
-      Puppet.settings.setting(:lastrunfile).expects(:mode).returns('892')
-      Puppet.expects(:send_log).with(:err, regexp_matches(/Could not save last run local report.*892 is invalid/))
+      expect(Puppet.settings.setting(:lastrunfile)).to receive(:mode).and_return('892')
+      expect(Puppet).to receive(:send_log).with(:err, /Could not save last run local report.*892 is invalid/)
       @configurer.save_last_run_summary(@report)
     end
   end
 
   describe "when requesting a node" do
     it "uses the transaction uuid in the request" do
-      Puppet::Node.indirection.expects(:find).with(anything, has_entries(:transaction_uuid => anything)).twice
+      expect(Puppet::Node.indirection).to receive(:find).with(anything, hash_including(transaction_uuid: anything)).twice
       @agent.run
     end
 
     it "sends an explicitly configured environment request" do
-      Puppet.settings.expects(:set_by_config?).with(:environment).returns(true)
-      Puppet::Node.indirection.expects(:find).with(anything, has_entries(:configured_environment => Puppet[:environment])).twice
+      expect(Puppet.settings).to receive(:set_by_config?).with(:environment).and_return(true)
+      expect(Puppet::Node.indirection).to receive(:find).with(anything, hash_including(configured_environment: Puppet[:environment])).twice
       @agent.run
     end
 
     it "does not send a configured_environment when using the default" do
-      Puppet::Node.indirection.expects(:find).with(anything, has_entries(:configured_environment => nil)).twice
+      expect(Puppet::Node.indirection).to receive(:find).with(anything, hash_including(configured_environment: nil)).twice
       @agent.run
     end
   end
 
   def expects_new_catalog_only(catalog)
-    Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options| options[:ignore_cache] == true }.returns catalog
-    Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options| options[:ignore_terminus] == true }.never
+    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))
   end
 
   def expects_cached_catalog_only(catalog)
-    Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options| options[:ignore_terminus] == true }.returns catalog
-    Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options| options[:ignore_cache] == true }.never
+    expect(Puppet::Resource::Catalog.indirection).to receive(:find).with(anything, hash_including(ignore_terminus: true)).and_return(catalog)
+    expect(Puppet::Resource::Catalog.indirection).not_to receive(:find).with(anything, hash_including(ignore_cache: true))
   end
 
   def expects_fallback_to_cached_catalog(catalog)
-    Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options| options[:ignore_cache] == true }.returns nil
-    Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options| options[:ignore_terminus] == true }.returns catalog
+    expect(Puppet::Resource::Catalog.indirection).to receive(:find).with(anything, hash_including(ignore_cache: true)).and_return(nil)
+    expect(Puppet::Resource::Catalog.indirection).to receive(:find).with(anything, hash_including(ignore_terminus: true)).and_return(catalog)
   end
 
   def expects_fallback_to_new_catalog(catalog)
-    Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options| options[:ignore_terminus] == true }.returns nil
-    Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options| options[:ignore_cache] == true }.returns catalog
+    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
 
   def expects_neither_new_or_cached_catalog
-    Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options| options[:ignore_cache] == true }.returns nil
-    Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options| options[:ignore_terminus] == true }.returns nil
+    expect(Puppet::Resource::Catalog.indirection).to receive(:find).with(anything, hash_including(ignore_cache: true)).and_return(nil)
+    expect(Puppet::Resource::Catalog.indirection).to receive(:find).with(anything, hash_including(ignore_terminus: true)).and_return(nil)
   end
 
   describe "when retrieving a catalog" do
     before do
-      Puppet.settings.stubs(:use).returns(true)
-      @agent.stubs(:facts_for_uploading).returns({})
-      @agent.stubs(:download_plugins)
+      allow(Puppet.settings).to receive(:use).and_return(true)
+      allow(@agent).to receive(:facts_for_uploading).and_return({})
+      allow(@agent).to receive(:download_plugins)
 
       # retrieve a catalog in the current environment, so we don't try to converge unexpectedly
       @catalog = Puppet::Resource::Catalog.new("tester", Puppet::Node::Environment.remote(Puppet[:environment].to_sym))
 
       # this is the default when using a Configurer instance
-      Puppet::Resource::Catalog.indirection.stubs(:terminus_class).returns :rest
+      allow(Puppet::Resource::Catalog.indirection).to receive(:terminus_class).and_return(:rest)
     end
 
     describe "and configured to only retrieve a catalog from the cache" do
@@ -682,17 +679,17 @@ describe Puppet::Configurer do
       end
 
       it "should not make a node request or pluginsync when a cached catalog is successfully retrieved" do
-        Puppet::Node.indirection.expects(:find).never
+        expect(Puppet::Node.indirection).not_to receive(:find)
         expects_cached_catalog_only(@catalog)
-        @agent.expects(:download_plugins).never
+        expect(@agent).not_to receive(:download_plugins)
 
         @agent.run
       end
 
       it "should make a node request and pluginsync when a cached catalog cannot be retrieved" do
-        Puppet::Node.indirection.expects(:find).returns nil
+        expect(Puppet::Node.indirection).to receive(:find).and_return(nil)
         expects_fallback_to_new_catalog(@catalog)
-        @agent.expects(:download_plugins)
+        expect(@agent).to receive(:download_plugins)
 
         @agent.run
       end
@@ -726,7 +723,7 @@ describe Puppet::Configurer do
       end
 
       it "should not attempt to retrieve a cached catalog again if the first attempt failed" do
-        Puppet::Node.indirection.expects(:find).returns(nil)
+        expect(Puppet::Node.indirection).to receive(:find).and_return(nil)
         expects_neither_new_or_cached_catalog
 
         @agent.run
@@ -736,23 +733,23 @@ describe Puppet::Configurer do
         cached_catalog = Puppet::Resource::Catalog.new("tester", Puppet::Node::Environment.remote('second_env'))
         expects_cached_catalog_only(cached_catalog)
 
-        Puppet.expects(:info).with("Using cached catalog from environment 'second_env'")
+        expect(Puppet).to receive(:info).with("Using cached catalog from environment 'second_env'")
         expect(@agent.retrieve_catalog({})).to eq(cached_catalog)
       end
     end
 
     describe "and strict environment mode is set" do
       before do
-        @catalog.stubs(:to_ral).returns(@catalog)
-        @catalog.stubs(:write_class_file)
-        @catalog.stubs(:write_resource_file)
-        @agent.stubs(:send_report)
-        @agent.stubs(:save_last_run_summary)
+        allow(@catalog).to receive(:to_ral).and_return(@catalog)
+        allow(@catalog).to receive(:write_class_file)
+        allow(@catalog).to receive(:write_resource_file)
+        allow(@agent).to receive(:send_report)
+        allow(@agent).to receive(:save_last_run_summary)
         Puppet.settings[:strict_environment_mode] = true
       end
 
       it "should not make a node request" do
-        Puppet::Node.indirection.expects(:find).never
+        expect(Puppet::Node.indirection).not_to receive(:find)
 
         @agent.run
       end
@@ -761,7 +758,7 @@ describe Puppet::Configurer do
         @agent.instance_variable_set(:@environment, 'second_env')
         expects_new_catalog_only(@catalog)
 
-        Puppet.expects(:err).with("Not using catalog because its environment 'production' does not match agent specified environment 'second_env' and strict_environment_mode is set")
+        expect(Puppet).to receive(:err).with("Not using catalog because its environment 'production' does not match agent specified environment 'second_env' and strict_environment_mode is set")
         expect(@agent.run).to be_nil
       end
 
@@ -781,7 +778,7 @@ describe Puppet::Configurer do
           @agent.instance_variable_set(:@environment, 'second_env')
           expects_cached_catalog_only(@catalog)
 
-          Puppet.expects(:err).with("Not using catalog because its environment 'production' does not match agent specified environment 'second_env' and strict_environment_mode is set")
+          expect(Puppet).to receive(:err).with("Not using catalog because its environment 'production' does not match agent specified environment 'second_env' and strict_environment_mode is set")
           expect(@agent.run).to be_nil
         end
 
@@ -796,28 +793,28 @@ describe Puppet::Configurer do
     end
 
     it "should use the Catalog class to get its catalog" do
-      Puppet::Resource::Catalog.indirection.expects(:find).returns @catalog
+      expect(Puppet::Resource::Catalog.indirection).to receive(:find).and_return(@catalog)
 
       @agent.retrieve_catalog({})
     end
 
     it "should set its cached_catalog_status to 'not_used' when downloading a new catalog" do
-      Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options| options[:ignore_cache] == true }.returns @catalog
+      expect(Puppet::Resource::Catalog.indirection).to receive(:find).with(anything, hash_including(ignore_cache: true)).and_return(@catalog)
 
       @agent.retrieve_catalog({})
       expect(@agent.instance_variable_get(:@cached_catalog_status)).to eq('not_used')
     end
 
     it "should use its node_name_value to retrieve the catalog" do
-      Facter.stubs(:value).returns "eh"
+      allow(Facter).to receive(:value).and_return("eh")
       Puppet.settings[:node_name_value] = "myhost.domain.com"
-      Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options| name == "myhost.domain.com" }.returns @catalog
+      expect(Puppet::Resource::Catalog.indirection).to receive(:find).with("myhost.domain.com", anything).and_return(@catalog)
 
       @agent.retrieve_catalog({})
     end
 
     it "should default to returning a catalog retrieved directly from the server, skipping the cache" do
-      Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options| options[:ignore_cache] == true }.returns @catalog
+      expect(Puppet::Resource::Catalog.indirection).to receive(:find).with(anything, hash_including(ignore_cache: true)).and_return(@catalog)
 
       expect(@agent.retrieve_catalog({})).to eq(@catalog)
     end
@@ -825,7 +822,7 @@ describe Puppet::Configurer do
     it "should log and return the cached catalog when no catalog can be retrieved from the server" do
       expects_fallback_to_cached_catalog(@catalog)
 
-      Puppet.expects(:info).with("Using cached catalog from environment 'production'")
+      expect(Puppet).to receive(:info).with("Using cached catalog from environment 'production'")
       expect(@agent.retrieve_catalog({})).to eq(@catalog)
     end
 
@@ -843,15 +840,15 @@ describe Puppet::Configurer do
     end
 
     it "should return the cached catalog when retrieving the remote catalog throws an exception" do
-      Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options| options[:ignore_cache] == true }.raises "eh"
-      Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options| options[:ignore_terminus] == true }.returns @catalog
+      expect(Puppet::Resource::Catalog.indirection).to receive(:find).with(anything, hash_including(ignore_cache: true)).and_raise("eh")
+      expect(Puppet::Resource::Catalog.indirection).to receive(:find).with(anything, hash_including(ignore_terminus: true)).and_return(@catalog)
 
       expect(@agent.retrieve_catalog({})).to eq(@catalog)
     end
 
     it "should set its cached_catalog_status to 'on_failure' when retrieving the remote catalog throws an exception" do
-      Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options| options[:ignore_cache] == true }.raises "eh"
-      Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options| options[:ignore_terminus] == true }.returns @catalog
+      expect(Puppet::Resource::Catalog.indirection).to receive(:find).with(anything, hash_including(ignore_cache: true)).and_raise("eh")
+      expect(Puppet::Resource::Catalog.indirection).to receive(:find).with(anything, hash_including(ignore_terminus: true)).and_return(@catalog)
 
       @agent.retrieve_catalog({})
       expect(@agent.instance_variable_get(:@cached_catalog_status)).to eq('on_failure')
@@ -859,16 +856,16 @@ describe Puppet::Configurer do
 
     it "should log and return nil if no catalog can be retrieved from the server and :usecacheonfailure is disabled" do
       Puppet[:usecacheonfailure] = false
-      Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options| options[:ignore_cache] == true }.returns nil
+      expect(Puppet::Resource::Catalog.indirection).to receive(:find).with(anything, hash_including(ignore_cache: true)).and_return(nil)
 
-      Puppet.expects(:warning).with('Not using cache on failed catalog')
+      expect(Puppet).to receive(:warning).with('Not using cache on failed catalog')
 
       expect(@agent.retrieve_catalog({})).to be_nil
     end
 
     it "should set its cached_catalog_status to 'not_used' if no catalog can be retrieved from the server and :usecacheonfailure is disabled or fails to retrieve a catalog" do
       Puppet[:usecacheonfailure] = false
-      Puppet::Resource::Catalog.indirection.expects(:find).with { |name, options| options[:ignore_cache] == true }.returns nil
+      expect(Puppet::Resource::Catalog.indirection).to receive(:find).with(anything, hash_including(ignore_cache: true)).and_return(nil)
 
       @agent.retrieve_catalog({})
       expect(@agent.instance_variable_get(:@cached_catalog_status)).to eq('not_used')
@@ -886,7 +883,7 @@ describe Puppet::Configurer do
 
       expects_fallback_to_cached_catalog(cached_catalog)
 
-      Puppet.expects(:err).with("Not using cached catalog because its environment 'second_env' does not match 'production'")
+      expect(Puppet).to receive(:err).with("Not using cached catalog because its environment 'second_env' does not match 'production'")
       expect(@agent.retrieve_catalog({})).to be_nil
     end
 
@@ -921,14 +918,14 @@ describe Puppet::Configurer do
 
     it "should not update the cached catalog in noop mode" do
       Puppet[:noop] = true
-      Puppet::Resource::Catalog.indirection.expects(:find).with(anything, has_entries(:ignore_cache => true, :ignore_cache_save => true)).returns(@catalog)
+      expect(Puppet::Resource::Catalog.indirection).to receive(:find).with(anything, hash_including(ignore_cache: true, ignore_cache_save: true)).and_return(@catalog)
 
       @agent.retrieve_catalog({})
     end
 
     it "should update the cached catalog when not in noop mode" do
       Puppet[:noop] = false
-      Puppet::Resource::Catalog.indirection.expects(:find).with(anything, has_entries(:ignore_cache => true, :ignore_cache_save => false)).returns(@catalog)
+      expect(Puppet::Resource::Catalog.indirection).to receive(:find).with(anything, hash_including(ignore_cache: true, ignore_cache_save: false)).and_return(@catalog)
 
       @agent.retrieve_catalog({})
     end
@@ -936,9 +933,9 @@ describe Puppet::Configurer do
 
   describe "when converting the catalog" do
     before do
-      Puppet.settings.stubs(:use).returns(true)
+      allow(Puppet.settings).to receive(:use).and_return(true)
 
-      catalog.stubs(:to_ral).returns ral_catalog
+      allow(catalog).to receive(:to_ral).and_return(ral_catalog)
     end
 
     let (:catalog) { Puppet::Resource::Catalog.new('tester', Puppet::Node::Environment.remote(Puppet[:environment].to_sym)) }
@@ -949,25 +946,25 @@ describe Puppet::Configurer do
     end
 
     it "should finalize the catalog" do
-      ral_catalog.expects(:finalize)
+      expect(ral_catalog).to receive(:finalize)
 
       @agent.convert_catalog(catalog, 10)
     end
 
     it "should record the passed retrieval time with the RAL catalog" do
-      ral_catalog.expects(:retrieval_duration=).with 10
+      expect(ral_catalog).to receive(:retrieval_duration=).with(10)
 
       @agent.convert_catalog(catalog, 10)
     end
 
     it "should write the RAL catalog's class file" do
-      ral_catalog.expects(:write_class_file)
+      expect(ral_catalog).to receive(:write_class_file)
 
       @agent.convert_catalog(catalog, 10)
     end
 
     it "should write the RAL catalog's resource file" do
-      ral_catalog.expects(:write_resource_file)
+      expect(ral_catalog).to receive(:write_resource_file)
 
       @agent.convert_catalog(catalog, 10)
     end
@@ -975,7 +972,7 @@ describe Puppet::Configurer do
     it "should set catalog conversion time on the report" do
       report = Puppet::Transaction::Report.new
 
-      report.expects(:add_times).with(:convert_catalog, kind_of(Numeric))
+      expect(report).to receive(:add_times).with(:convert_catalog, kind_of(Numeric))
       @agent.convert_catalog(catalog, 10, {:report => report})
     end
   end
@@ -997,13 +994,13 @@ describe Puppet::Configurer do
   describe "when attempting failover" do
     it "should not failover if server_list is not set" do
       Puppet.settings[:server_list] = []
-      @agent.expects(:find_functional_server).never
+      expect(@agent).not_to receive(:find_functional_server)
       @agent.run
     end
 
     it "should not failover during an apply run" do
       Puppet.settings[:server_list] = ["myserver:123"]
-      @agent.expects(:find_functional_server).never
+      expect(@agent).not_to receive(:find_functional_server)
       catalog = Puppet::Resource::Catalog.new("tester", Puppet::Node::Environment.remote(Puppet[:environment].to_sym))
       @agent.run :catalog => catalog
     end
@@ -1011,8 +1008,8 @@ describe Puppet::Configurer do
     it "should select a server when provided" do
       Puppet.settings[:server_list] = ["myserver:123"]
       response = Net::HTTPOK.new(nil, 200, 'OK')
-      Puppet::Network::HttpPool.stubs(:connection).with('myserver', 123, anything).returns(mock('request', get: response))
-      @agent.stubs(:run_internal)
+      allow(Puppet::Network::HttpPool).to receive(:connection).with('myserver', 123, anything).and_return(double('request', get: response))
+      allow(@agent).to receive(:run_internal)
 
       options = {}
       @agent.run(options)
@@ -1022,10 +1019,10 @@ describe Puppet::Configurer do
     it "queries the simple status for the 'master' service" do
       Puppet.settings[:server_list] = ["myserver:123"]
       response = Net::HTTPOK.new(nil, 200, 'OK')
-      http = mock('request')
-      http.expects(:get).with('/status/v1/simple/master').returns(response)
-      Puppet::Network::HttpPool.stubs(:connection).with('myserver', 123, anything).returns(http)
-      @agent.stubs(:run_internal)
+      http = double('request')
+      expect(http).to receive(:get).with('/status/v1/simple/master').and_return(response)
+      allow(Puppet::Network::HttpPool).to receive(:connection).with('myserver', 123, anything).and_return(http)
+      allow(@agent).to receive(:run_internal)
 
       @agent.run
     end
@@ -1033,16 +1030,16 @@ describe Puppet::Configurer do
     it "should report when a server is unavailable" do
       Puppet.settings[:server_list] = ["myserver:123"]
       response = Net::HTTPInternalServerError.new(nil, 500, 'Internal Server Error')
-      Puppet::Network::HttpPool.stubs(:connection).with('myserver', 123, anything).returns(mock('request', get: response))
+      allow(Puppet::Network::HttpPool).to receive(:connection).with('myserver', 123, anything).and_return(double('request', get: response))
 
-      Puppet.expects(:debug).with("Puppet server myserver:123 is unavailable: 500 Internal Server Error")
+      expect(Puppet).to receive(:debug).with("Puppet server myserver:123 is unavailable: 500 Internal Server Error")
       expect{ @agent.run }.to raise_error(Puppet::Error, /Could not select a functional puppet master from server_list/)
     end
 
     it "should error when no servers in 'server_list' are reachable" do
       Puppet.settings[:server_list] = ["myserver:123"]
       error = Net::HTTPError.new(400, 'dummy server communication error')
-      Puppet::Network::HttpPool.stubs(:connection).with('myserver', 123, anything).returns(mock('request', get: error))
+      allow(Puppet::Network::HttpPool).to receive(:connection).with('myserver', 123, anything).and_return(double('request', get: error))
 
       options = {}
       expect{ @agent.run(options) }.to raise_error(Puppet::Error, /Could not select a functional puppet master from server_list/)
@@ -1053,8 +1050,8 @@ describe Puppet::Configurer do
       Puppet.settings[:server_list] = ["myserver:123"]
       response = Net::HTTPOK.new(nil, 200, 'OK')
 
-      Puppet::Network::HttpPool.expects(:connection).with('myserver', 123, anything).returns(mock('request', get: response))
-      @agent.stubs(:run_internal)
+      expect(Puppet::Network::HttpPool).to receive(:connection).with('myserver', 123, anything).and_return(double('request', get: response))
+      allow(@agent).to receive(:run_internal)
 
       @agent.run
     end