puppet 5.5.12-x86-mingw32 → 5.5.13-x86-mingw32

data/spec/unit/face/epp_face_spec.rb

@@ -102,7 +102,6 @@ describe Puppet::Face[:epp, :current] do
     end
   end
 
-
   context "dump" do
     it "prints the AST of a template given with the -e option" do
       expect(eppface.dump({ :e => 'hello world' })).to eq("(lambda (epp (block\n  (render-s 'hello world')\n)))\n")
@@ -376,11 +375,11 @@ goodbye world
   end
 
   def from_an_interactive_terminal
-    STDIN.stubs(:tty?).returns(true)
+    allow(STDIN).to receive(:tty?).and_return(true)
   end
 
   def from_a_piped_input_of(contents)
-    STDIN.stubs(:tty?).returns(false)
-    STDIN.stubs(:read).returns(contents)
+    allow(STDIN).to receive(:tty?).and_return(false)
+    allow(STDIN).to receive(:read).and_return(contents)
   end
 end

data/spec/unit/face/facts_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/face'
 require 'puppet/indirector/facts/facter'
@@ -28,26 +27,26 @@ CONF
       # Faces start in :user run mode
       Puppet.settings.preferred_run_mode = :user
 
-      facter_terminus.stubs(:find).with(instance_of(Puppet::Indirector::Request)).returns(test_data)
-      rest_terminus.stubs(:save).with(instance_of(Puppet::Indirector::Request)).returns(nil)
+      allow(facter_terminus).to receive(:find).with(instance_of(Puppet::Indirector::Request)).and_return(test_data)
+      allow(rest_terminus).to receive(:save).with(instance_of(Puppet::Indirector::Request)).and_return(nil)
     end
 
     it { is_expected.to be_action :upload }
 
     it "finds facts from terminus_class :facter" do
-      facter_terminus.expects(:find).with(instance_of(Puppet::Indirector::Request)).returns(test_data)
+      expect(facter_terminus).to receive(:find).with(instance_of(Puppet::Indirector::Request)).and_return(test_data)
 
       subject.upload
     end
 
     it "saves facts to terminus_class :rest" do
-      rest_terminus.expects(:save).with(instance_of(Puppet::Indirector::Request)).returns(nil)
+      expect(rest_terminus).to receive(:save).with(instance_of(Puppet::Indirector::Request)).and_return(nil)
 
       subject.upload
     end
 
     it "uses settings from the agent section of puppet.conf" do
-      facter_terminus.expects(:find).with(responds_with(:key, 'puppet.node.test')).returns(test_data)
+      expect(facter_terminus).to receive(:find).with(have_attributes(key: 'puppet.node.test')).and_return(test_data)
 
       subject.upload
     end

data/spec/unit/face/generate_spec.rb

@@ -126,7 +126,7 @@ describe Puppet::Face[:generate, :current] do
       end
 
       it 'sets pcore as the default format' do
-        Puppet::Generate::Type.expects(:find_inputs).with(:pcore).returns([])
+        expect(Puppet::Generate::Type).to receive(:find_inputs).with(:pcore).and_return([])
         genface.types()
       end
 
@@ -135,8 +135,8 @@ describe Puppet::Face[:generate, :current] do
         # (There is no way to call the original when mocking expected parameters).
         input1 = Puppet::Generate::Type::Input.new(m1, File.join(m1, 'lib', 'puppet', 'type', 'test1.rb'), :pcore)
         input2 = Puppet::Generate::Type::Input.new(m1, File.join(m2, 'lib', 'puppet', 'type', 'test2.rb'), :pcore)
-        Puppet::Generate::Type::Input.expects(:new).with(m1, File.join(m1, 'lib', 'puppet', 'type', 'test1.rb'), :pcore).returns(input1)
-        Puppet::Generate::Type::Input.expects(:new).with(m2, File.join(m2, 'lib', 'puppet', 'type', 'test2.rb'), :pcore).returns(input2)
+        expect(Puppet::Generate::Type::Input).to receive(:new).with(m1, File.join(m1, 'lib', 'puppet', 'type', 'test1.rb'), :pcore).and_return(input1)
+        expect(Puppet::Generate::Type::Input).to receive(:new).with(m2, File.join(m2, 'lib', 'puppet', 'type', 'test2.rb'), :pcore).and_return(input2)
         genface.types
       end
 
@@ -224,7 +224,6 @@ describe Puppet::Face[:generate, :current] do
   end
 
   def from_an_interactive_terminal
-    STDIN.stubs(:tty?).returns(true)
+    allow(STDIN).to receive(:tty?).and_return(true)
   end
-
 end

data/spec/unit/face/help_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/face'
 
@@ -50,7 +49,7 @@ describe Puppet::Face[:help, '0.0.1'] do
   context 'rendering has an error' do
     it 'raises an ArgumentError if the face raises a StandardError' do
       face = Puppet::Face[:module, :current]
-      face.stubs(:short_description).raises(StandardError, 'whoops')
+      allow(face).to receive(:short_description).and_raise(StandardError, 'whoops')
 
       expect {
         subject.help(:module)
@@ -59,7 +58,7 @@ describe Puppet::Face[:help, '0.0.1'] do
 
     it 'raises an ArgumentError if the face raises a LoadError' do
       face = Puppet::Face[:module, :current]
-      face.stubs(:short_description).raises(LoadError, 'cannot load such file -- yard')
+      allow(face).to receive(:short_description).and_raise(LoadError, 'cannot load such file -- yard')
 
       expect {
         subject.help(:module)
@@ -69,7 +68,7 @@ describe Puppet::Face[:help, '0.0.1'] do
     context 'with face actions' do
       it 'returns an error if we can not get an action for the module' do
         face = Puppet::Face[:module, :current]
-        face.stubs(:get_action).returns(nil)
+        allow(face).to receive(:get_action).and_return(nil)
 
         expect {subject.help('module', 'list')}.to raise_error(ArgumentError, /Unable to load action list from Puppet::Face/)
       end
@@ -135,7 +134,7 @@ describe Puppet::Face[:help, '0.0.1'] do
 
   context 'deprecated faces' do
     it 'prints a deprecation warning for deprecated faces' do
-      Puppet::Face[:module, :current].stubs(:deprecated?).returns(true)
+      allow(Puppet::Face[:module, :current]).to receive(:deprecated?).and_return(true)
       expect(Puppet::Face[:help, :current].help(:module)).to match(/Warning: 'puppet module' is deprecated/)
     end
   end
@@ -143,7 +142,7 @@ describe Puppet::Face[:help, '0.0.1'] do
   context '#all_application_summaries' do
     it 'appends a deprecation warning for deprecated faces' do
       # Stub the module face as deprecated
-      Puppet::Face[:module, :current].expects(:deprecated?).returns(true)
+      expect(Puppet::Face[:module, :current]).to receive(:deprecated?).and_return(true)
       Puppet::Face[:help, :current].all_application_summaries.each do |appname,summary|
         expect(summary).to match(/Deprecated/) if appname == 'module'
       end
@@ -190,7 +189,7 @@ describe Puppet::Face[:help, '0.0.1'] do
 
     context 'rendering has an error' do
       it 'raises an ArgumentError if a legacy application raises a StandardError' do
-        Puppet::Application[appname].class.any_instance.stubs(:help).raises(StandardError, 'whoops')
+        allow_any_instance_of(Puppet::Application[appname].class).to receive(:help).and_raise(StandardError, 'whoops')
 
         expect {
           subject.help(appname)
@@ -198,7 +197,7 @@ describe Puppet::Face[:help, '0.0.1'] do
       end
 
       it 'raises an ArgumentError if a legacy application raises a LoadError' do
-        Puppet::Application[appname].class.any_instance.stubs(:help).raises(LoadError, 'cannot load such file -- yard')
+        allow_any_instance_of(Puppet::Application[appname].class).to receive(:help).and_raise(LoadError, 'cannot load such file -- yard')
 
         expect {
           subject.help(appname)

data/spec/unit/face/key_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/face'
 

data/spec/unit/face/man_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/face'
 
@@ -20,7 +19,7 @@ describe Puppet::Face[:man, '0.0.1'] do
   end
 
   it 'raises an ArgumentError when given to many arguments' do
-    subject.stubs(:print_man_help)
+    allow(subject).to receive(:print_man_help)
     expect { subject.man(:man, 'cert', 'extra') }.to raise_error(ArgumentError)
   end
 end

data/spec/unit/face/module/build_spec.rb

@@ -7,47 +7,47 @@ describe "puppet module build" do
 
   describe "when called without any options" do
     it "if current directory is a module root should call builder with it" do
-      Dir.expects(:pwd).returns('/a/b/c')
-      Puppet::ModuleTool.expects(:find_module_root).with('/a/b/c').returns('/a/b/c')
-      Puppet::ModuleTool.expects(:set_option_defaults).returns({})
-      Puppet::ModuleTool::Applications::Builder.expects(:run).with('/a/b/c', {})
+      expect(Dir).to receive(:pwd).and_return('/a/b/c')
+      expect(Puppet::ModuleTool).to receive(:find_module_root).with('/a/b/c').and_return('/a/b/c')
+      expect(Puppet::ModuleTool).to receive(:set_option_defaults).and_return({})
+      expect(Puppet::ModuleTool::Applications::Builder).to receive(:run).with('/a/b/c', {})
       subject.build
     end
 
     it "if parent directory of current dir is a module root should call builder with it" do
-      Dir.expects(:pwd).returns('/a/b/c')
-      Puppet::ModuleTool.expects(:find_module_root).with('/a/b/c').returns('/a/b')
-      Puppet::ModuleTool.expects(:set_option_defaults).returns({})
-      Puppet::ModuleTool::Applications::Builder.expects(:run).with('/a/b', {})
+      expect(Dir).to receive(:pwd).and_return('/a/b/c')
+      expect(Puppet::ModuleTool).to receive(:find_module_root).with('/a/b/c').and_return('/a/b')
+      expect(Puppet::ModuleTool).to receive(:set_option_defaults).and_return({})
+      expect(Puppet::ModuleTool::Applications::Builder).to receive(:run).with('/a/b', {})
       subject.build
     end
 
     it "if current directory or parents contain no module root, should return exception" do
-      Dir.expects(:pwd).returns('/a/b/c')
-      Puppet::ModuleTool.expects(:find_module_root).returns(nil)
+      expect(Dir).to receive(:pwd).and_return('/a/b/c')
+      expect(Puppet::ModuleTool).to receive(:find_module_root).and_return(nil)
       expect { subject.build }.to raise_error RuntimeError, "Unable to find metadata.json in module root /a/b/c or parent directories. See <https://puppet.com/docs/puppet/latest/modules_publishing.html> for required file format."
     end
   end
 
   describe "when called with a path" do
     it "if path is a module root should call builder with it" do
-      Puppet::ModuleTool.expects(:is_module_root?).with('/a/b/c').returns(true)
-      Puppet::ModuleTool.expects(:set_option_defaults).returns({})
-      Puppet::ModuleTool::Applications::Builder.expects(:run).with('/a/b/c', {})
+      expect(Puppet::ModuleTool).to receive(:is_module_root?).with('/a/b/c').and_return(true)
+      expect(Puppet::ModuleTool).to receive(:set_option_defaults).and_return({})
+      expect(Puppet::ModuleTool::Applications::Builder).to receive(:run).with('/a/b/c', {})
       subject.build('/a/b/c')
     end
 
     it "if path is not a module root should raise exception" do
-      Puppet::ModuleTool.expects(:is_module_root?).with('/a/b/c').returns(false)
+      expect(Puppet::ModuleTool).to receive(:is_module_root?).with('/a/b/c').and_return(false)
       expect { subject.build('/a/b/c') }.to raise_error RuntimeError, "Unable to find metadata.json in module root /a/b/c or parent directories. See <https://puppet.com/docs/puppet/latest/modules_publishing.html> for required file format."
     end
   end
 
   describe "with options" do
     it "should pass through options to builder when provided" do
-      Puppet::ModuleTool.stubs(:is_module_root?).returns(true)
-      Puppet::ModuleTool.expects(:set_option_defaults).returns({})
-      Puppet::ModuleTool::Applications::Builder.expects(:run).with('/a/b/c', {:modulepath => '/x/y/z'})
+      allow(Puppet::ModuleTool).to receive(:is_module_root?).and_return(true)
+      expect(Puppet::ModuleTool).to receive(:set_option_defaults).and_return({})
+      expect(Puppet::ModuleTool::Applications::Builder).to receive(:run).with('/a/b/c', {:modulepath => '/x/y/z'})
       subject.build('/a/b/c', :modulepath => '/x/y/z')
     end
   end

data/spec/unit/face/module/install_spec.rb

@@ -6,15 +6,13 @@ describe "puppet module install" do
   include PuppetSpec::Files
 
   describe "action" do
-    let(:name)        { stub(:name) }
+    let(:name)        { double(:name) }
     let(:target_dir)  { tmpdir('module install face action') }
     let(:options)     { { :target_dir => target_dir } }
 
     it 'should invoke the Installer app' do
-      Puppet::ModuleTool.expects(:set_option_defaults).with(options)
-      Puppet::ModuleTool::Applications::Installer.expects(:run).with do |*args|
-        mod, target, opts = args
-
+      expect(Puppet::ModuleTool).to receive(:set_option_defaults).with(options)
+      expect(Puppet::ModuleTool::Applications::Installer).to receive(:run) do |mod, target, opts|
         expect(mod).to eql(name)
         expect(opts).to eql(options)
         expect(target).to be_a(Puppet::ModuleTool::InstallDirectory)

data/spec/unit/face/module/list_spec.rb

@@ -207,12 +207,7 @@ describe "puppet module list" do
         }]
       })
 
-      warning_expectations = [
-        regexp_matches(/Missing dependency 'puppetlabs-dependable'/),
-        regexp_matches(/'puppetlabs-depender' \(v1\.0\.0\) requires 'puppetlabs-dependable' \(>= 0\.0\.5\)/)
-      ]
-
-      Puppet.expects(:warning).with(all_of(*warning_expectations))
+      expect(Puppet).to receive(:warning).with(match(/Missing dependency 'puppetlabs-dependable'/).and match(/'puppetlabs-depender' \(v1\.0\.0\) requires 'puppetlabs-dependable' \(>= 0\.0\.5\)/))
 
       console_output(:tree => true)
     end
@@ -287,12 +282,7 @@ describe "puppet module list" do
         }]
       })
 
-      warning_expectations = [
-        regexp_matches(/Module 'puppetlabs-dependable' \(v0\.0\.1\) fails to meet some dependencies/),
-        regexp_matches(/'puppetlabs-depender' \(v1\.0\.0\) requires 'puppetlabs-dependable' \(>= 0\.0\.5\)/)
-      ]
-
-      Puppet.expects(:warning).with(all_of(*warning_expectations))
+      expect(Puppet).to receive(:warning).with(match(/Module 'puppetlabs-dependable' \(v0\.0\.1\) fails to meet some dependencies/).and match(/'puppetlabs-depender' \(v1\.0\.0\) requires 'puppetlabs-dependable' \(>= 0\.0\.5\)/))
 
       console_output(:tree => true)
     end

data/spec/unit/face/module/search_spec.rb

@@ -13,12 +13,14 @@ describe "puppet module search" do
   describe Puppet::Application::Module do
     subject do
       app = Puppet::Application::Module.new
-      app.stubs(:action).returns(Puppet::Face.find_action(:module, :search))
+      allow(app).to receive(:action).and_return(Puppet::Face.find_action(:module, :search))
       app
     end
 
-    before { subject.render_as = :console }
-    before { Puppet::Util::Terminal.stubs(:width).returns(100) }
+    before do
+      subject.render_as = :console
+      allow(Puppet::Util::Terminal).to receive(:width).and_return(100)
+    end
 
     it 'should output nothing when receiving an empty dataset' do
       expect(subject.render({:answers => [], :result => :success}, ['apache', {}])).to eq("No results found for 'apache'.")
@@ -166,7 +168,7 @@ describe "puppet module search" do
           ]
         }
 
-        Puppet::Util::Terminal.expects(:width).returns(width)
+        expect(Puppet::Util::Terminal).to receive(:width).and_return(width)
         result = subject.render(results, ['apache', {}])
         expect(result.lines.sort_by(&:length).last.chomp.length).to be <= width
         expect(result).to eq(expectation)
@@ -183,13 +185,13 @@ describe "puppet module search" do
     end
 
     it "should accept the --module_repository option" do
-      forge = mock("Puppet::Forge")
-      searcher = mock("Searcher")
+      forge = double("Puppet::Forge")
+      searcher = double("Searcher")
       options[:module_repository] = "http://forge.example.com"
 
-      Puppet::Forge.expects(:new).with("http://forge.example.com", false).returns(forge)
-      Puppet::ModuleTool::Applications::Searcher.expects(:new).with("puppetlabs-apache", forge, has_entries(options)).returns(searcher)
-      searcher.expects(:run)
+      expect(Puppet::Forge).to receive(:new).with("http://forge.example.com", false).and_return(forge)
+      expect(Puppet::ModuleTool::Applications::Searcher).to receive(:new).with("puppetlabs-apache", forge, hash_including(options)).and_return(searcher)
+      expect(searcher).to receive(:run)
 
       subject.search("puppetlabs-apache", options)
     end

data/spec/unit/face/module/uninstall_spec.rb

@@ -10,10 +10,8 @@ describe "puppet module uninstall" do
     let(:options) { Hash.new }
 
     it 'should invoke the Uninstaller app' do
-      args = [ name, options ]
-
-      Puppet::ModuleTool.expects(:set_option_defaults).with(options)
-      Puppet::ModuleTool::Applications::Uninstaller.expects(:run).with(*args)
+      expect(Puppet::ModuleTool).to receive(:set_option_defaults).with(options)
+      expect(Puppet::ModuleTool::Applications::Uninstaller).to receive(:run).with(name, options)
 
       Puppet::Face[:module, :current].uninstall(name, options)
     end
@@ -22,10 +20,8 @@ describe "puppet module uninstall" do
       let(:name) { 'module/name' }
 
       it 'should invoke the Uninstaller app' do
-        args = [ 'module-name', options ]
-
-        Puppet::ModuleTool.expects(:set_option_defaults).with(options)
-        Puppet::ModuleTool::Applications::Uninstaller.expects(:run).with(*args)
+        expect(Puppet::ModuleTool).to receive(:set_option_defaults).with(options)
+        expect(Puppet::ModuleTool::Applications::Uninstaller).to receive(:run).with('module-name', options)
 
         Puppet::Face[:module, :current].uninstall(name, options)
       end

data/spec/unit/face/node_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/face'
 
@@ -14,32 +13,32 @@ describe Puppet::Face[:node, '0.0.1'] do
         "cached_facts" => ['hostname'],
         "cached_node"  => ['hostname'],
         "reports"      => ['hostname'],
-      }.each { |k, v| subject.expects("clean_#{k}".to_sym).with(*v) }
+      }.each { |k, v| expect(subject).to receive("clean_#{k}".to_sym).with(*v) }
       subject.cleanup('hostname')
     end
   end
 
   describe 'when running #clean' do
     before :each do
-      Puppet::Node::Facts.indirection.stubs(:terminus_class=)
-      Puppet::Node::Facts.indirection.stubs(:cache_class=)
-      Puppet::Node.stubs(:terminus_class=)
-      Puppet::Node.stubs(:cache_class=)
+      allow(Puppet::Node::Facts.indirection).to receive(:terminus_class=)
+      allow(Puppet::Node::Facts.indirection).to receive(:cache_class=)
+      allow(Puppet::Node).to receive(:terminus_class=)
+      allow(Puppet::Node).to receive(:cache_class=)
     end
 
     it 'should invoke #cleanup' do
-      subject.expects(:cleanup).with('hostname', nil)
+      expect(subject).to receive(:cleanup).with('hostname')
       subject.clean('hostname')
     end
   end
 
   describe "clean action" do
     before :each do
-      Puppet::Node::Facts.indirection.stubs(:terminus_class=)
-      Puppet::Node::Facts.indirection.stubs(:cache_class=)
-      Puppet::Node.stubs(:terminus_class=)
-      Puppet::Node.stubs(:cache_class=)
-      subject.stubs(:cleanup)
+      allow(Puppet::Node::Facts.indirection).to receive(:terminus_class=)
+      allow(Puppet::Node::Facts.indirection).to receive(:cache_class=)
+      allow(Puppet::Node).to receive(:terminus_class=)
+      allow(Puppet::Node).to receive(:cache_class=)
+      allow(subject).to receive(:cleanup)
     end
 
     it "should have a clean action" do
@@ -67,14 +66,14 @@ describe Puppet::Face[:node, '0.0.1'] do
     context "clean action" do
       subject { Puppet::Face[:node, :current] }
       before :each do
-        Puppet::Util::Log.stubs(:newdestination)
-        Puppet::Util::Log.stubs(:level=)
+        allow(Puppet::Util::Log).to receive(:newdestination)
+        allow(Puppet::Util::Log).to receive(:level=)
       end
 
       describe "during setup" do
         it "should set facts terminus and cache class to yaml" do
-          Puppet::Node::Facts.indirection.expects(:terminus_class=).with(:yaml)
-          Puppet::Node::Facts.indirection.expects(:cache_class=).with(:yaml)
+          expect(Puppet::Node::Facts.indirection).to receive(:terminus_class=).with(:yaml)
+          expect(Puppet::Node::Facts.indirection).to receive(:cache_class=).with(:yaml)
 
           subject.clean('hostname')
         end
@@ -85,43 +84,43 @@ describe Puppet::Face[:node, '0.0.1'] do
         end
 
         it "should set node cache as yaml" do
-          Puppet::Node.indirection.expects(:terminus_class=).with(:yaml)
-          Puppet::Node.indirection.expects(:cache_class=).with(:yaml)
+          expect(Puppet::Node.indirection).to receive(:terminus_class=).with(:yaml)
+          expect(Puppet::Node.indirection).to receive(:cache_class=).with(:yaml)
 
           subject.clean('hostname')
         end
 
         it "should manage the certs if the host is a CA" do
-          Puppet::SSL::CertificateAuthority.stubs(:ca?).returns(true)
-          Puppet::SSL::Host.expects(:ca_location=).with(:local)
+          allow(Puppet::SSL::CertificateAuthority).to receive(:ca?).and_return(true)
+          expect(Puppet::SSL::Host).to receive(:ca_location=).with(:local)
           subject.clean('hostname')
         end
 
         it "should not manage the certs if the host is not a CA" do
-          Puppet::SSL::CertificateAuthority.stubs(:ca?).returns(false)
-          Puppet::SSL::Host.expects(:ca_location=).with(:none)
+          allow(Puppet::SSL::CertificateAuthority).to receive(:ca?).and_return(false)
+          expect(Puppet::SSL::Host).to receive(:ca_location=).with(:none)
           subject.clean('hostname')
         end
       end
 
       describe "when cleaning certificate" do
         before :each do
-          Puppet::SSL::Host.stubs(:destroy)
-          @ca = mock()
-          Puppet::SSL::CertificateAuthority.stubs(:instance).returns(@ca)
+          allow(Puppet::SSL::Host).to receive(:destroy)
+          @ca = double()
+          allow(Puppet::SSL::CertificateAuthority).to receive(:instance).and_return(@ca)
         end
 
         it "should send the :destroy order to the ca if we are a CA" do
-          Puppet::SSL::CertificateAuthority.stubs(:ca?).returns(true)
-          @ca.expects(:revoke).with(@host)
-          @ca.expects(:destroy).with(@host)
+          allow(Puppet::SSL::CertificateAuthority).to receive(:ca?).and_return(true)
+          expect(@ca).to receive(:revoke).with(@host)
+          expect(@ca).to receive(:destroy).with(@host)
           subject.clean_cert(@host)
         end
 
         it "should not destroy the certs if we are not a CA" do
-          Puppet::SSL::CertificateAuthority.stubs(:ca?).returns(false)
-          @ca.expects(:revoke).never
-          @ca.expects(:destroy).never
+          allow(Puppet::SSL::CertificateAuthority).to receive(:ca?).and_return(false)
+          expect(@ca).not_to receive(:revoke)
+          expect(@ca).not_to receive(:destroy)
           subject.clean_cert(@host)
         end
       end
@@ -129,7 +128,7 @@ describe Puppet::Face[:node, '0.0.1'] do
       describe "when cleaning cached facts" do
         it "should destroy facts" do
           @host = 'node'
-          Puppet::Node::Facts.indirection.expects(:destroy).with(@host)
+          expect(Puppet::Node::Facts.indirection).to receive(:destroy).with(@host)
 
           subject.clean_cached_facts(@host)
         end
@@ -137,14 +136,14 @@ describe Puppet::Face[:node, '0.0.1'] do
 
       describe "when cleaning cached node" do
         it "should destroy the cached node" do
-          Puppet::Node.indirection.expects(:destroy).with(@host)
+          expect(Puppet::Node.indirection).to receive(:destroy).with(@host)
           subject.clean_cached_node(@host)
         end
       end
 
       describe "when cleaning archived reports" do
         it "should tell the reports to remove themselves" do
-          Puppet::Transaction::Report.indirection.stubs(:destroy).with(@host)
+          allow(Puppet::Transaction::Report.indirection).to receive(:destroy).with(@host)
 
           subject.clean_reports(@host)
         end