puppet 5.5.12-x64-mingw32 → 5.5.13-x64-mingw32

data/spec/unit/util/lockfile_spec.rb

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

data/spec/unit/util/log/destinations_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/util/json'
 
@@ -14,16 +13,15 @@ describe Puppet::Util::Log.desttypes[:report] do
   end
 
   it "should send new messages to the report" do
-    report = mock 'report'
+    report = double('report')
     dest = @dest.new(report)
 
-    report.expects(:<<).with("my log")
+    expect(report).to receive(:<<).with("my log")
 
     dest.handle "my log"
   end
 end
 
-
 describe Puppet::Util::Log.desttypes[:file] do
   include PuppetSpec::Files
 
@@ -54,26 +52,26 @@ describe Puppet::Util::Log.desttypes[:file] do
         it_behaves_like "file destination"
 
         it "logs an error if it can't chown the file owner & group" do
-          File.expects(:exists?).with(abspath).returns(false)
-          FileUtils.expects(:chown).with(Puppet[:user], Puppet[:group], abspath).raises(Errno::EPERM)
-          Puppet.features.expects(:root?).returns(true)
-          Puppet.expects(:err).with("Unable to set ownership to #{Puppet[:user]}:#{Puppet[:group]} for log file: #{abspath}")
+          expect(File).to receive(:exists?).with(abspath).and_return(false)
+          expect(FileUtils).to receive(:chown).with(Puppet[:user], Puppet[:group], abspath).and_raise(Errno::EPERM)
+          expect(Puppet.features).to receive(:root?).and_return(true)
+          expect(Puppet).to receive(:err).with("Unable to set ownership to #{Puppet[:user]}:#{Puppet[:group]} for log file: #{abspath}")
 
           @class.new(abspath)
         end
 
         it "doesn't attempt to chown when running as non-root" do
-          File.expects(:exists?).with(abspath).returns(false)
-          FileUtils.expects(:chown).with(Puppet[:user], Puppet[:group], abspath).never
-          Puppet.features.expects(:root?).returns(false)
+          expect(File).to receive(:exists?).with(abspath).and_return(false)
+          expect(FileUtils).not_to receive(:chown).with(Puppet[:user], Puppet[:group], abspath)
+          expect(Puppet.features).to receive(:root?).and_return(false)
 
           @class.new(abspath)
         end
 
         it "doesn't attempt to chown when file already exists" do
-          File.expects(:exists?).with(abspath).returns(true)
-          FileUtils.expects(:chown).with(Puppet[:user], Puppet[:group], abspath).never
-          Puppet.features.expects(:root?).returns(true)
+          expect(File).to receive(:exists?).with(abspath).and_return(true)
+          expect(FileUtils).not_to receive(:chown).with(Puppet[:user], Puppet[:group], abspath)
+          expect(Puppet.features).to receive(:root?).and_return(true)
 
           @class.new(abspath)
         end
@@ -110,28 +108,28 @@ describe Puppet::Util::Log.desttypes[:syslog] do
   # we can't stub the top-level Syslog module
   describe "when syslog is available", :if => Puppet.features.syslog? do
     before :each do
-      Syslog.stubs(:opened?).returns(false)
-      Syslog.stubs(:const_get).returns("LOG_KERN").returns(0)
-      Syslog.stubs(:open)
+      allow(Syslog).to receive(:opened?).and_return(false)
+      allow(Syslog).to receive(:const_get).and_return("LOG_KERN", 0)
+      allow(Syslog).to receive(:open)
     end
 
     it "should open syslog" do
-      Syslog.expects(:open)
+      expect(Syslog).to receive(:open)
 
       klass.new
     end
 
     it "should close syslog" do
-      Syslog.expects(:close)
+      expect(Syslog).to receive(:close)
 
       dest = klass.new
       dest.close
     end
 
     it "should send messages to syslog" do
-      syslog = mock 'syslog'
-      syslog.expects(:info).with("don't panic")
-      Syslog.stubs(:open).returns(syslog)
+      syslog = double('syslog')
+      expect(syslog).to receive(:info).with("don't panic")
+      allow(Syslog).to receive(:open).and_return(syslog)
 
       msg = Puppet::Util::Log.new(:level => :info, :message => "don't panic")
       dest = klass.new
@@ -141,7 +139,7 @@ describe Puppet::Util::Log.desttypes[:syslog] do
 
   describe "when syslog is unavailable" do
     it "should not be a suitable log destination" do
-      Puppet.features.stubs(:syslog?).returns(false)
+      allow(Puppet.features).to receive(:syslog?).and_return(false)
 
       expect(klass.suitable?(:syslog)).to be_falsey
     end
@@ -149,7 +147,6 @@ describe Puppet::Util::Log.desttypes[:syslog] do
 end
 
 describe Puppet::Util::Log.desttypes[:logstash_event] do
-
   describe "when using structured log format with logstash_event schema" do
     before :each do
       @msg = Puppet::Util::Log.new(:level => :info, :message => "So long, and thanks for all the fish.", :source => "a dolphin")
@@ -173,7 +170,7 @@ describe Puppet::Util::Log.desttypes[:logstash_event] do
     end
 
     it "handle should send the output to stdout" do
-      $stdout.expects(:puts).once
+      expect($stdout).to receive(:puts).once
       dest = described_class.new
       dest.handle(@msg)
     end
@@ -207,7 +204,7 @@ describe Puppet::Util::Log.desttypes[:console] do
 
   it "should include the log message's source/context in the output when available" do
     Puppet[:color] = false
-    $stdout.expects(:puts).with("Info: a hitchhiker: don't panic")
+    expect($stdout).to receive(:puts).with("Info: a hitchhiker: don't panic")
 
     msg = Puppet::Util::Log.new(:level => :info, :message => "don't panic", :source => "a hitchhiker")
     dest = klass.new
@@ -220,9 +217,9 @@ describe ":eventlog", :if => Puppet::Util::Platform.windows? do
   let(:klass) { Puppet::Util::Log.desttypes[:eventlog] }
 
   def expects_message_with_type(klass, level, eventlog_type, eventlog_id)
-    eventlog = stub('eventlog')
-    eventlog.expects(:report_event).with(has_entries(:event_type => eventlog_type, :event_id => eventlog_id, :data => "a hitchhiker: don't panic"))
-    Puppet::Util::Windows::EventLog.stubs(:open).returns(eventlog)
+    eventlog = double('eventlog')
+    expect(eventlog).to receive(:report_event).with(hash_including(:event_type => eventlog_type, :event_id => eventlog_id, :data => "a hitchhiker: don't panic"))
+    allow(Puppet::Util::Windows::EventLog).to receive(:open).and_return(eventlog)
 
     msg = Puppet::Util::Log.new(:level => level, :message => "don't panic", :source => "a hitchhiker")
     dest = klass.new
@@ -238,17 +235,17 @@ describe ":eventlog", :if => Puppet::Util::Platform.windows? do
     expected_truncated_msg = "#{'x' * 31785}...Message exceeds character length limit, truncating."
     expected_data = "a vogon ship: " + expected_truncated_msg
 
-    eventlog = stub('eventlog')
-    eventlog.expects(:report_event).with(has_entries(:event_type => 2, :event_id => 2, :data => expected_data))
+    eventlog = double('eventlog')
+    expect(eventlog).to receive(:report_event).with(hash_including(:event_type => 2, :event_id => 2, :data => expected_data))
     msg = Puppet::Util::Log.new(:level => :warning, :message => long_msg, :source => "a vogon ship")
-    Puppet::Util::Windows::EventLog.stubs(:open).returns(eventlog)
+    allow(Puppet::Util::Windows::EventLog).to receive(:open).and_return(eventlog)
 
     dest = klass.new
     dest.handle(msg)
   end
   
   it "logs to the Puppet Application event log" do
-    Puppet::Util::Windows::EventLog.expects(:open).with('Puppet').returns(stub('eventlog'))
+    expect(Puppet::Util::Windows::EventLog).to receive(:open).with('Puppet').and_return(double('eventlog'))
 
     klass.new
   end

data/spec/unit/util/log_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 # coding: utf-8
 require 'spec_helper'
 
@@ -64,7 +63,7 @@ describe Puppet::Util::Log do
     win_31j_msg = [130, 187].pack('C*').force_encoding(Encoding::Windows_31J)
     utf_8_msg = "\u305d"
 
-    $stdout.expects(:puts).with("\e[mNotice: #{mixed_utf8}: #{utf_8_msg}\e[0m")
+    expect($stdout).to receive(:puts).with("\e[mNotice: #{mixed_utf8}: #{utf_8_msg}\e[0m")
 
     # most handlers do special things with a :source => 'Puppet', so use something else
     Puppet::Util::Log.new(:level => :notice, :message => win_31j_msg, :source => mixed_utf8)
@@ -82,7 +81,7 @@ describe Puppet::Util::Log do
     win_31j_msg = [130, 187].pack('C*').force_encoding(Encoding::Windows_31J)
     utf_8_msg = "\u305d"
 
-    $stdout.expects(:puts).with("\e[mNotice: #{utf_8_msg}: #{mixed_utf8}\e[0m")
+    expect($stdout).to receive(:puts).with("\e[mNotice: #{utf_8_msg}: #{mixed_utf8}\e[0m")
 
     Puppet::Util::Log.new(:level => :notice, :message => mixed_utf8, :source => win_31j_msg)
     expect(logs.last.source).to eq(utf_8_msg)
@@ -94,10 +93,10 @@ describe Puppet::Util::Log do
     # spec_helper.rb redirects log output away from the console,
     # so we have to stop that here, or else the logic we are testing
     # will not be reached.
-    Puppet::Util::Log.stubs(:destinations).returns({})
+    allow(Puppet::Util::Log).to receive(:destinations).and_return({})
 
     our_exception = Puppet::DevError.new("test exception")
-    Puppet::FileSystem.expects(:dir).raises(our_exception)
+    expect(Puppet::FileSystem).to receive(:dir).and_raise(our_exception)
     bad_file = tmpfile("bad_file")
 
     expect { Puppet::Util::Log.newdestination(bad_file) }.to raise_error(Puppet::DevError)
@@ -105,24 +104,24 @@ describe Puppet::Util::Log do
 
   describe ".setup_default" do
     it "should default to :syslog" do
-      Puppet.features.stubs(:syslog?).returns(true)
-      Puppet::Util::Log.expects(:newdestination).with(:syslog)
+      allow(Puppet.features).to receive(:syslog?).and_return(true)
+      expect(Puppet::Util::Log).to receive(:newdestination).with(:syslog)
 
       Puppet::Util::Log.setup_default
     end
 
     it "should fall back to :eventlog" do
-      Puppet.features.stubs(:syslog?).returns(false)
-      Puppet.features.stubs(:eventlog?).returns(true)
-      Puppet::Util::Log.expects(:newdestination).with(:eventlog)
+      allow(Puppet.features).to receive(:syslog?).and_return(false)
+      allow(Puppet.features).to receive(:eventlog?).and_return(true)
+      expect(Puppet::Util::Log).to receive(:newdestination).with(:eventlog)
 
       Puppet::Util::Log.setup_default
     end
 
     it "should fall back to :file" do
-      Puppet.features.stubs(:syslog?).returns(false)
-      Puppet.features.stubs(:eventlog?).returns(false)
-      Puppet::Util::Log.expects(:newdestination).with(Puppet[:puppetdlog])
+      allow(Puppet.features).to receive(:syslog?).and_return(false)
+      allow(Puppet.features).to receive(:eventlog?).and_return(false)
+      expect(Puppet::Util::Log).to receive(:newdestination).with(Puppet[:puppetdlog])
 
       Puppet::Util::Log.setup_default
     end
@@ -336,28 +335,28 @@ describe Puppet::Util::Log do
 
   describe Puppet::Util::Log::DestEventlog, :if => Puppet.features.eventlog? do
     before :each do
-      Puppet::Util::Windows::EventLog.stubs(:open).returns(stub 'mylog')
-      Puppet::Util::Windows::EventLog.stubs(:report_event)
-      Puppet::Util::Windows::EventLog.stubs(:close)
-      Puppet.features.stubs(:eventlog?).returns(true)
+      allow(Puppet::Util::Windows::EventLog).to receive(:open).and_return(double('mylog', :close => nil))
+      allow(Puppet::Util::Windows::EventLog).to receive(:report_event)
+      allow(Puppet::Util::Windows::EventLog).to receive(:close)
+      allow(Puppet.features).to receive(:eventlog?).and_return(true)
     end
 
     it "should restrict its suitability to Windows" do
-      Puppet.features.expects(:microsoft_windows?).returns(false)
+      expect(Puppet.features).to receive(:microsoft_windows?).and_return(false)
 
       expect(Puppet::Util::Log::DestEventlog.suitable?('whatever')).to eq(false)
     end
 
     it "should open the 'Puppet' event log" do
-      Puppet::Util::Windows::EventLog.expects(:open).with('Puppet')
+      expect(Puppet::Util::Windows::EventLog).to receive(:open).with('Puppet')
 
       Puppet::Util::Log.newdestination(:eventlog)
     end
 
     it "should close the event log" do
-      log = stub('myeventlog')
-      log.expects(:close)
-      Puppet::Util::Windows::EventLog.expects(:open).returns(log)
+      log = double('myeventlog')
+      expect(log).to receive(:close)
+      expect(Puppet::Util::Windows::EventLog).to receive(:open).and_return(log)
 
       Puppet::Util::Log.newdestination(:eventlog)
       Puppet::Util::Log.close(:eventlog)
@@ -374,7 +373,7 @@ describe Puppet::Util::Log do
 
   describe "instances" do
     before do
-      Puppet::Util::Log.stubs(:newmessage)
+      allow(Puppet::Util::Log).to receive(:newmessage)
     end
 
     [:level, :message, :time, :remote].each do |attr|
@@ -409,7 +408,7 @@ describe Puppet::Util::Log do
 
     it "should flush the log queue when the first destination is specified" do
       Puppet::Util::Log.close_all
-      Puppet::Util::Log.expects(:flushqueue)
+      expect(Puppet::Util::Log).to receive(:flushqueue)
       Puppet::Util::Log.newdestination(:console)
     end
 
@@ -422,13 +421,13 @@ describe Puppet::Util::Log do
     end
 
     it "should fail if the provided level is not valid" do
-      Puppet::Util::Log.expects(:validlevel?).with(:notice).returns false
+      expect(Puppet::Util::Log).to receive(:validlevel?).with(:notice).and_return(false)
       expect { Puppet::Util::Log.new(:level => :notice, :message => :foo) }.to raise_error(ArgumentError)
     end
 
     it "should set its time to the initialization time" do
-      time = mock 'time'
-      Time.expects(:now).returns time
+      time = double('time')
+      expect(Time).to receive(:now).and_return(time)
       expect(Puppet::Util::Log.new(:level => "notice", :message => :foo).time).to equal(time)
     end
 
@@ -439,13 +438,13 @@ describe Puppet::Util::Log do
     end
 
     it "should use a passed-in source" do
-      Puppet::Util::Log.any_instance.expects(:source=).with "foo"
+      expect_any_instance_of(Puppet::Util::Log).to receive(:source=).with("foo")
       Puppet::Util::Log.new(:level => "notice", :message => :foo, :source => "foo")
     end
 
     [:file, :line].each do |attr|
       it "should use #{attr} if provided" do
-        Puppet::Util::Log.any_instance.expects(attr.to_s + "=").with "foo"
+        expect_any_instance_of(Puppet::Util::Log).to receive(attr.to_s + "=").with("foo")
         Puppet::Util::Log.new(:level => "notice", :message => :foo, attr => "foo")
       end
     end
@@ -455,12 +454,12 @@ describe Puppet::Util::Log do
     end
 
     it "should register itself with Log" do
-      Puppet::Util::Log.expects(:newmessage)
+      expect(Puppet::Util::Log).to receive(:newmessage)
       Puppet::Util::Log.new(:level => "notice", :message => :foo)
     end
 
     it "should update Log autoflush when Puppet[:autoflush] is set" do
-      Puppet::Util::Log.expects(:autoflush=).once.with(true)
+      expect(Puppet::Util::Log).to receive(:autoflush=).once.with(true)
       Puppet[:autoflush] = true
     end
 
@@ -490,10 +489,10 @@ describe Puppet::Util::Log do
     end
 
     it "should not create unsuitable log destinations" do
-      Puppet.features.stubs(:syslog?).returns(false)
+      allow(Puppet.features).to receive(:syslog?).and_return(false)
 
-      Puppet::Util::Log::DestSyslog.expects(:suitable?)
-      Puppet::Util::Log::DestSyslog.expects(:new).never
+      expect(Puppet::Util::Log::DestSyslog).to receive(:suitable?)
+      expect(Puppet::Util::Log::DestSyslog).not_to receive(:new)
 
       Puppet::Util::Log.newdestination(:syslog)
     end
@@ -546,8 +545,8 @@ describe Puppet::Util::Log do
 
     describe "when setting the source as a non-RAL object" do
       it "should not try to copy over file, version, line, or tag information" do
-        source = mock
-        source.expects(:file).never
+        source = double('source')
+        expect(source).not_to receive(:file)
         Puppet::Util::Log.new(:level => "notice", :message => :foo, :source => source)
       end
     end

data/spec/unit/util/logging_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/util/logging'
@@ -19,29 +18,29 @@ describe Puppet::Util::Logging do
   end
 
   it "should have a method for sending a log with a specified log level" do
-    @logger.expects(:to_s).returns "I'm a string!"
-    Puppet::Util::Log.expects(:create).with { |args| args[:source] == "I'm a string!" and args[:level] == "loglevel" and args[:message] == "mymessage" }
+    expect(@logger).to receive(:to_s).and_return("I'm a string!")
+    expect(Puppet::Util::Log).to receive(:create).with(hash_including(source: "I'm a string!", level: "loglevel", message: "mymessage"))
 
     @logger.send_log "loglevel", "mymessage"
   end
 
   describe "when sending a log" do
     it "should use the Log's 'create' entrance method" do
-      Puppet::Util::Log.expects(:create)
+      expect(Puppet::Util::Log).to receive(:create)
 
       @logger.notice "foo"
     end
 
     it "should send itself converted to a string as the log source" do
-      @logger.expects(:to_s).returns "I'm a string!"
-      Puppet::Util::Log.expects(:create).with { |args| args[:source] == "I'm a string!" }
+      expect(@logger).to receive(:to_s).and_return("I'm a string!")
+      expect(Puppet::Util::Log).to receive(:create).with(hash_including(source: "I'm a string!"))
 
       @logger.notice "foo"
     end
 
     it "should queue logs sent without a specified destination" do
       Puppet::Util::Log.close_all
-      Puppet::Util::Log.expects(:queuemessage)
+      expect(Puppet::Util::Log).to receive(:queuemessage)
 
       @logger.notice "foo"
     end
@@ -49,9 +48,9 @@ describe Puppet::Util::Logging do
     it "should use the path of any provided resource type" do
       resource = Puppet::Type.type(:host).new :name => "foo"
 
-      resource.expects(:path).returns "/path/to/host".to_sym
+      expect(resource).to receive(:path).and_return("/path/to/host".to_sym)
 
-      Puppet::Util::Log.expects(:create).with { |args| args[:source] == "/path/to/host" }
+      expect(Puppet::Util::Log).to receive(:create).with(hash_including(source: "/path/to/host"))
 
       resource.notice "foo"
     end
@@ -61,21 +60,21 @@ describe Puppet::Util::Logging do
 
       param = resource.parameter(:name)
 
-      param.expects(:path).returns "/path/to/param".to_sym
+      expect(param).to receive(:path).and_return("/path/to/param".to_sym)
 
-      Puppet::Util::Log.expects(:create).with { |args| args[:source] == "/path/to/param" }
+      expect(Puppet::Util::Log).to receive(:create).with(hash_including(source: "/path/to/param"))
 
       param.notice "foo"
     end
 
     it "should send the provided argument as the log message" do
-      Puppet::Util::Log.expects(:create).with { |args| args[:message] == "foo" }
+      expect(Puppet::Util::Log).to receive(:create).with(hash_including(message: "foo"))
 
       @logger.notice "foo"
     end
 
     it "should join any provided arguments into a single string for the message" do
-      Puppet::Util::Log.expects(:create).with { |args| args[:message] == "foo bar baz" }
+      expect(Puppet::Util::Log).to receive(:create).with(hash_including(message: "foo bar baz"))
 
       @logger.notice ["foo", "bar", "baz"]
     end
@@ -86,7 +85,7 @@ describe Puppet::Util::Logging do
 
         @logger.send(attr.to_s + "=", "myval")
 
-        Puppet::Util::Log.expects(:create).with { |args| args[attr] == "myval" }
+        expect(Puppet::Util::Log).to receive(:create).with(hash_including(attr => "myval"))
         @logger.notice "foo"
       end
     end
@@ -94,47 +93,41 @@ describe Puppet::Util::Logging do
 
   describe "when sending a deprecation warning" do
     it "does not log a message when deprecation warnings are disabled" do
-      Puppet.expects(:[]).with(:disable_warnings).returns %w[deprecations]
-      @logger.expects(:warning).never
+      expect(Puppet).to receive(:[]).with(:disable_warnings).and_return(%w[deprecations])
+      expect(@logger).not_to receive(:warning)
       @logger.deprecation_warning 'foo'
     end
 
     it "logs the message with warn" do
-      @logger.expects(:warning).with do |msg|
-        msg =~ /^foo\n/
-      end
+      expect(@logger).to receive(:warning).with(/^foo\n/)
       @logger.deprecation_warning 'foo'
     end
 
     it "only logs each offending line once" do
-      @logger.expects(:warning).with do |msg|
-        msg =~ /^foo\n/
-      end .once
+      expect(@logger).to receive(:warning).with(/^foo\n/).once
       5.times { @logger.deprecation_warning 'foo' }
     end
 
     it "ensures that deprecations from same origin are logged if their keys differ" do
-      @logger.expects(:warning).with(regexp_matches(/deprecated foo/)).times(5)
+      expect(@logger).to receive(:warning).with(/deprecated foo/).exactly(5).times()
       5.times { |i| @logger.deprecation_warning('deprecated foo', :key => "foo#{i}") }
     end
 
     it "does not duplicate deprecations for a given key" do
-      @logger.expects(:warning).with(regexp_matches(/deprecated foo/)).once
+      expect(@logger).to receive(:warning).with(/deprecated foo/).once
       5.times { @logger.deprecation_warning('deprecated foo', :key => 'foo-msg') }
     end
 
     it "only logs the first 100 messages" do
       (1..100).each { |i|
-        @logger.expects(:warning).with do |msg|
-          msg =~ /^#{i}\n/
-        end .once
+        expect(@logger).to receive(:warning).with(/^#{i}\n/).once
         # since the deprecation warning will only log each offending line once, we have to do some tomfoolery
         # here in order to make it think each of these calls is coming from a unique call stack; we're basically
         # mocking the method that it would normally use to find the call stack.
-        @logger.expects(:get_deprecation_offender).returns(["deprecation log count test ##{i}"])
+        expect(@logger).to receive(:get_deprecation_offender).and_return(["deprecation log count test ##{i}"])
         @logger.deprecation_warning i
       }
-      @logger.expects(:warning).with(101).never
+      expect(@logger).not_to receive(:warning).with(101)
       @logger.deprecation_warning 101
     end
   end
@@ -154,25 +147,25 @@ describe Puppet::Util::Logging do
     end
 
     it "warns with file and line" do
-      @logger.expects(:warning).with(regexp_matches(/deprecated foo.*\(file: afile, line: 5\)/m))
+      expect(@logger).to receive(:warning).with(/deprecated foo.*\(file: afile, line: 5\)/m)
       @logger.puppet_deprecation_warning("deprecated foo", :file => 'afile', :line => 5)
     end
 
     it "warns keyed from file and line" do
-      @logger.expects(:warning).with(regexp_matches(/deprecated foo.*\(file: afile, line: 5\)/m)).once
+      expect(@logger).to receive(:warning).with(/deprecated foo.*\(file: afile, line: 5\)/m).once
       5.times do
         @logger.puppet_deprecation_warning("deprecated foo", :file => 'afile', :line => 5)
       end
     end
 
     it "warns with separate key only once regardless of file and line" do
-      @logger.expects(:warning).with(regexp_matches(/deprecated foo.*\(file: afile, line: 5\)/m)).once
+      expect(@logger).to receive(:warning).with(/deprecated foo.*\(file: afile, line: 5\)/m).once
       @logger.puppet_deprecation_warning("deprecated foo", :key => 'some_key', :file => 'afile', :line => 5)
       @logger.puppet_deprecation_warning("deprecated foo", :key => 'some_key', :file => 'bfile', :line => 3)
     end
 
     it "warns with key but no file and line" do
-      @logger.expects(:warning).with(regexp_matches(/deprecated foo.*\(file: unknown, line: unknown\)/m))
+      expect(@logger).to receive(:warning).with(/deprecated foo.*\(file: unknown, line: unknown\)/m)
       @logger.puppet_deprecation_warning("deprecated foo", :key => 'some_key')
     end
   end
@@ -181,29 +174,24 @@ describe Puppet::Util::Logging do
     before(:each) {
       @logger.clear_deprecation_warnings
     }
-    after(:each) {
-      # this is required because of bugs in Mocha whe tearing down expectations for each test
-      # why it works elsewhere is a mystery.
-      @logger.unstub(:send_log)
-    }
 
     it "warns with file when only file is given" do
-      @logger.expects(:send_log).with(:warning, regexp_matches(/wet paint.*\(file: aFile\)/m))
+      expect(@logger).to receive(:send_log).with(:warning, /wet paint.*\(file: aFile\)/m)
       @logger.warn_once('kind', 'wp', "wet paint", 'aFile')
     end
 
     it "warns with unknown file and line when only line is given" do
-      @logger.expects(:send_log).with(:warning, regexp_matches(/wet paint.*\(line: 5\)/m))
+      expect(@logger).to receive(:send_log).with(:warning, /wet paint.*\(line: 5\)/m)
       @logger.warn_once('kind', 'wp', "wet paint", nil, 5)
     end
 
     it "warns with file and line when both are given" do
-      @logger.expects(:send_log).with(:warning, regexp_matches(/wet paint.*\(file: aFile, line: 5\)/m))
+      expect(@logger).to receive(:send_log).with(:warning, /wet paint.*\(file: aFile, line: 5\)/m)
       @logger.warn_once('kind', 'wp', "wet paint",'aFile', 5)
     end
 
     it "warns once per key" do
-      @logger.expects(:send_log).with(:warning, regexp_matches(/wet paint.*/m)).once
+      expect(@logger).to receive(:send_log).with(:warning, /wet paint.*/m).once
       5.times do
         @logger.warn_once('kind', 'wp', "wet paint")
       end
@@ -211,7 +199,7 @@ describe Puppet::Util::Logging do
 
     Puppet::Util::Log.eachlevel do |level|
       it "can use log level #{level}" do
-        @logger.expects(:send_log).with(level, regexp_matches(/wet paint.*/m)).once
+        expect(@logger).to receive(:send_log).with(level, /wet paint.*/m).once
         5.times do
           @logger.warn_once('kind', 'wp', "wet paint", nil, nil, level)
         end
@@ -222,17 +210,21 @@ describe Puppet::Util::Logging do
   describe "does not warn about undefined variables when disabled_warnings says so" do
     let(:logger) { LoggingTester.new }
 
-    around(:each) do |example|
+    before(:each) do
       Puppet.settings.initialize_global_settings
       logger.clear_deprecation_warnings
       Puppet[:disable_warnings] = ['undefined_variables']
-      example.run
+    end
+
+    after(:each) do
       Puppet[:disable_warnings] = []
-      logger.unstub(:send_log)
+      allow(Facter).to receive(:respond_to?).and_call_original()
+      allow(Facter).to receive(:debugging).and_call_original()
+      allow(logger).to receive(:send_log).and_call_original()
     end
 
     it "does not produce warning if kind is disabled" do
-      logger.expects(:send_log).never
+      expect(logger).not_to receive(:send_log)
       logger.warn_once('undefined_variables', 'wp', "wet paint")
     end
   end
@@ -240,17 +232,21 @@ describe Puppet::Util::Logging do
   describe "warns about undefined variables when deprecations are in disabled_warnings" do
     let(:logger) { LoggingTester.new }
 
-    around(:each) do |example|
+    before(:each) do
       Puppet.settings.initialize_global_settings
       logger.clear_deprecation_warnings
       Puppet[:disable_warnings] = ['deprecations']
-      example.run
+    end
+
+    after(:each) do
       Puppet[:disable_warnings] = []
-      logger.unstub(:send_log)
+      allow(Facter).to receive(:respond_to?).and_call_original()
+      allow(Facter).to receive(:debugging).and_call_original()
+      allow(logger).to receive(:send_log).and_call_original()
     end
 
     it "produces warning even if deprecation warnings are disabled " do
-      logger.expects(:send_log).with(:warning, regexp_matches(/wet paint/)).once
+      expect(logger).to receive(:send_log).with(:warning, /wet paint/).once
       logger.warn_once('undefined_variables', 'wp', "wet paint")
     end
   end
@@ -285,49 +281,49 @@ original
     after :each do
       # Unstub these calls as there is global code run after
       # each spec that may reset the log level to debug
-      Facter.unstub(:respond_to?)
-      Facter.unstub(:debugging)
+      allow(Facter).to receive(:respond_to?).and_call_original()
+      allow(Facter).to receive(:debugging).and_call_original()
     end
 
     describe 'does support debugging' do
       before :each do
-        Facter.stubs(:respond_to?).with(:debugging).returns true
+        allow(Facter).to receive(:respond_to?).with(:debugging).and_return(true)
       end
 
       it 'enables Facter debugging when debug level' do
-        Facter.stubs(:debugging).with(true)
+        allow(Facter).to receive(:debugging).with(true)
         Puppet::Util::Log.level = :debug
       end
 
       it 'disables Facter debugging when not debug level' do
-        Facter.stubs(:debugging).with(false)
+        allow(Facter).to receive(:debugging).with(false)
         Puppet::Util::Log.level = :info
       end
     end
 
     describe 'does support trace' do
       before :each do
-        Facter.stubs(:respond_to?).with(:trace).returns true
+        allow(Facter).to receive(:respond_to?).with(:trace).and_return(true)
       end
 
       it 'enables Facter trace when enabled' do
-        Facter.stubs(:trace).with(true)
+        allow(Facter).to receive(:trace).with(true)
         Puppet[:trace] = true
       end
 
       it 'disables Facter trace when disabled' do
-        Facter.stubs(:trace).with(false)
+        allow(Facter).to receive(:trace).with(false)
         Puppet[:trace] = false
       end
     end
 
     describe 'does support on_message' do
       before :each do
-        Facter.stubs(:respond_to?).with(:on_message).returns true
+        allow(Facter).to receive(:respond_to?).with(:on_message).and_return(true)
       end
 
       def setup(level, message)
-        Facter.stubs(:on_message).yields level, message
+        allow(Facter).to receive(:on_message).and_yield(level, message)
 
         # Transform from Facter level to Puppet level
         case level
@@ -341,11 +337,7 @@ original
           level = :crit
         end
 
-        Puppet::Util::Log.stubs(:create).with do |options|
-          expect(options[:level]).to eq(level)
-          expect(options[:message]).to eq(message)
-          expect(options[:source]).to eq('Facter')
-        end.once
+        allow(Puppet::Util::Log).to receive(:create).with(hash_including(level: level, message: message, source: 'Facter')).once
       end
 
       [:trace, :debug, :info, :warn, :error, :fatal].each do |level|