puppet 6.0.10-x86-mingw32 → 6.1.0-x86-mingw32

data/spec/unit/util/lockfile_spec.rb

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

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

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/util/json'
 
@@ -13,15 +14,16 @@ describe Puppet::Util::Log.desttypes[:report] do
   end
 
   it "should send new messages to the report" do
-    report = double('report')
+    report = mock 'report'
     dest = @dest.new(report)
 
-    expect(report).to receive(:<<).with("my log")
+    report.expects(:<<).with("my log")
 
     dest.handle "my log"
   end
 end
 
+
 describe Puppet::Util::Log.desttypes[:file] do
   include PuppetSpec::Files
 
@@ -52,26 +54,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
-          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}")
+          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}")
 
           @class.new(abspath)
         end
 
         it "doesn't attempt to chown when running as non-root" do
-          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)
+          File.expects(:exists?).with(abspath).returns(false)
+          FileUtils.expects(:chown).with(Puppet[:user], Puppet[:group], abspath).never
+          Puppet.features.expects(:root?).returns(false)
 
           @class.new(abspath)
         end
 
         it "doesn't attempt to chown when file already exists" do
-          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)
+          File.expects(:exists?).with(abspath).returns(true)
+          FileUtils.expects(:chown).with(Puppet[:user], Puppet[:group], abspath).never
+          Puppet.features.expects(:root?).returns(true)
 
           @class.new(abspath)
         end
@@ -108,28 +110,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
-      allow(Syslog).to receive(:opened?).and_return(false)
-      allow(Syslog).to receive(:const_get).and_return("LOG_KERN", 0)
-      allow(Syslog).to receive(:open)
+      Syslog.stubs(:opened?).returns(false)
+      Syslog.stubs(:const_get).returns("LOG_KERN").returns(0)
+      Syslog.stubs(:open)
     end
 
     it "should open syslog" do
-      expect(Syslog).to receive(:open)
+      Syslog.expects(:open)
 
       klass.new
     end
 
     it "should close syslog" do
-      expect(Syslog).to receive(:close)
+      Syslog.expects(:close)
 
       dest = klass.new
       dest.close
     end
 
     it "should send messages to syslog" do
-      syslog = double('syslog')
-      expect(syslog).to receive(:info).with("don't panic")
-      allow(Syslog).to receive(:open).and_return(syslog)
+      syslog = mock 'syslog'
+      syslog.expects(:info).with("don't panic")
+      Syslog.stubs(:open).returns(syslog)
 
       msg = Puppet::Util::Log.new(:level => :info, :message => "don't panic")
       dest = klass.new
@@ -139,7 +141,7 @@ describe Puppet::Util::Log.desttypes[:syslog] do
 
   describe "when syslog is unavailable" do
     it "should not be a suitable log destination" do
-      allow(Puppet.features).to receive(:syslog?).and_return(false)
+      Puppet.features.stubs(:syslog?).returns(false)
 
       expect(klass.suitable?(:syslog)).to be_falsey
     end
@@ -147,6 +149,7 @@ 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")
@@ -170,7 +173,7 @@ describe Puppet::Util::Log.desttypes[:logstash_event] do
     end
 
     it "handle should send the output to stdout" do
-      expect($stdout).to receive(:puts).once
+      $stdout.expects(:puts).once
       dest = described_class.new
       dest.handle(@msg)
     end
@@ -204,7 +207,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
-    expect($stdout).to receive(:puts).with("Info: a hitchhiker: don't panic")
+    $stdout.expects(: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
@@ -217,9 +220,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 = 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)
+    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)
 
     msg = Puppet::Util::Log.new(:level => level, :message => "don't panic", :source => "a hitchhiker")
     dest = klass.new
@@ -235,17 +238,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 = double('eventlog')
-    expect(eventlog).to receive(:report_event).with(hash_including(:event_type => 2, :event_id => 2, :data => expected_data))
+    eventlog = stub('eventlog')
+    eventlog.expects(:report_event).with(has_entries(:event_type => 2, :event_id => 2, :data => expected_data))
     msg = Puppet::Util::Log.new(:level => :warning, :message => long_msg, :source => "a vogon ship")
-    allow(Puppet::Util::Windows::EventLog).to receive(:open).and_return(eventlog)
+    Puppet::Util::Windows::EventLog.stubs(:open).returns(eventlog)
 
     dest = klass.new
     dest.handle(msg)
   end
   
   it "logs to the Puppet Application event log" do
-    expect(Puppet::Util::Windows::EventLog).to receive(:open).with('Puppet').and_return(double('eventlog'))
+    Puppet::Util::Windows::EventLog.expects(:open).with('Puppet').returns(stub('eventlog'))
 
     klass.new
   end

data/spec/unit/util/log_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 # coding: utf-8
 require 'spec_helper'
 
@@ -63,7 +64,7 @@ describe Puppet::Util::Log do
     win_31j_msg = [130, 187].pack('C*').force_encoding(Encoding::Windows_31J)
     utf_8_msg = "\u305d"
 
-    expect($stdout).to receive(:puts).with("\e[mNotice: #{mixed_utf8}: #{utf_8_msg}\e[0m")
+    $stdout.expects(: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)
@@ -81,47 +82,32 @@ describe Puppet::Util::Log do
     win_31j_msg = [130, 187].pack('C*').force_encoding(Encoding::Windows_31J)
     utf_8_msg = "\u305d"
 
-    expect($stdout).to receive(:puts).with("\e[mNotice: #{utf_8_msg}: #{mixed_utf8}\e[0m")
+    $stdout.expects(: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)
   end
 
-  require 'puppet/util/log/destinations'
-
-  it "raises an error when it has no successful logging destinations" 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.
-    allow(Puppet::Util::Log).to receive(:destinations).and_return({})
-
-    our_exception = Puppet::DevError.new("test 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)
-  end
-
   describe ".setup_default" do
     it "should default to :syslog" do
-      allow(Puppet.features).to receive(:syslog?).and_return(true)
-      expect(Puppet::Util::Log).to receive(:newdestination).with(:syslog)
+      Puppet.features.stubs(:syslog?).returns(true)
+      Puppet::Util::Log.expects(:newdestination).with(:syslog)
 
       Puppet::Util::Log.setup_default
     end
 
     it "should fall back to :eventlog" do
-      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.features.stubs(:syslog?).returns(false)
+      Puppet.features.stubs(:eventlog?).returns(true)
+      Puppet::Util::Log.expects(:newdestination).with(:eventlog)
 
       Puppet::Util::Log.setup_default
     end
 
     it "should fall back to :file" do
-      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.features.stubs(:syslog?).returns(false)
+      Puppet.features.stubs(:eventlog?).returns(false)
+      Puppet::Util::Log.expects(:newdestination).with(Puppet[:puppetdlog])
 
       Puppet::Util::Log.setup_default
     end
@@ -335,28 +321,28 @@ describe Puppet::Util::Log do
 
   describe Puppet::Util::Log::DestEventlog, :if => Puppet.features.eventlog? do
     before :each do
-      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)
+      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)
     end
 
     it "should restrict its suitability to Windows" do
-      allow(Puppet::Util::Platform).to receive(:windows?).and_return(false)
+      Puppet::Util::Platform.stubs(:windows?).returns false
 
       expect(Puppet::Util::Log::DestEventlog.suitable?('whatever')).to eq(false)
     end
 
     it "should open the 'Puppet' event log" do
-      expect(Puppet::Util::Windows::EventLog).to receive(:open).with('Puppet')
+      Puppet::Util::Windows::EventLog.expects(:open).with('Puppet')
 
       Puppet::Util::Log.newdestination(:eventlog)
     end
 
     it "should close the event log" do
-      log = double('myeventlog')
-      expect(log).to receive(:close)
-      expect(Puppet::Util::Windows::EventLog).to receive(:open).and_return(log)
+      log = stub('myeventlog')
+      log.expects(:close)
+      Puppet::Util::Windows::EventLog.expects(:open).returns(log)
 
       Puppet::Util::Log.newdestination(:eventlog)
       Puppet::Util::Log.close(:eventlog)
@@ -373,7 +359,7 @@ describe Puppet::Util::Log do
 
   describe "instances" do
     before do
-      allow(Puppet::Util::Log).to receive(:newmessage)
+      Puppet::Util::Log.stubs(:newmessage)
     end
 
     [:level, :message, :time, :remote].each do |attr|
@@ -408,7 +394,7 @@ describe Puppet::Util::Log do
 
     it "should flush the log queue when the first destination is specified" do
       Puppet::Util::Log.close_all
-      expect(Puppet::Util::Log).to receive(:flushqueue)
+      Puppet::Util::Log.expects(:flushqueue)
       Puppet::Util::Log.newdestination(:console)
     end
 
@@ -421,13 +407,13 @@ describe Puppet::Util::Log do
     end
 
     it "should fail if the provided level is not valid" do
-      expect(Puppet::Util::Log).to receive(:validlevel?).with(:notice).and_return(false)
+      Puppet::Util::Log.expects(:validlevel?).with(:notice).returns 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 = double('time')
-      expect(Time).to receive(:now).and_return(time)
+      time = mock 'time'
+      Time.expects(:now).returns time
       expect(Puppet::Util::Log.new(:level => "notice", :message => :foo).time).to equal(time)
     end
 
@@ -438,13 +424,13 @@ describe Puppet::Util::Log do
     end
 
     it "should use a passed-in source" do
-      expect_any_instance_of(Puppet::Util::Log).to receive(:source=).with("foo")
+      Puppet::Util::Log.any_instance.expects(: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
-        expect_any_instance_of(Puppet::Util::Log).to receive(attr.to_s + "=").with("foo")
+        Puppet::Util::Log.any_instance.expects(attr.to_s + "=").with "foo"
         Puppet::Util::Log.new(:level => "notice", :message => :foo, attr => "foo")
       end
     end
@@ -454,12 +440,12 @@ describe Puppet::Util::Log do
     end
 
     it "should register itself with Log" do
-      expect(Puppet::Util::Log).to receive(:newmessage)
+      Puppet::Util::Log.expects(:newmessage)
       Puppet::Util::Log.new(:level => "notice", :message => :foo)
     end
 
     it "should update Log autoflush when Puppet[:autoflush] is set" do
-      expect(Puppet::Util::Log).to receive(:autoflush=).once.with(true)
+      Puppet::Util::Log.expects(:autoflush=).once.with(true)
       Puppet[:autoflush] = true
     end
 
@@ -489,10 +475,10 @@ describe Puppet::Util::Log do
     end
 
     it "should not create unsuitable log destinations" do
-      allow(Puppet.features).to receive(:syslog?).and_return(false)
+      Puppet.features.stubs(:syslog?).returns(false)
 
-      expect(Puppet::Util::Log::DestSyslog).to receive(:suitable?)
-      expect(Puppet::Util::Log::DestSyslog).not_to receive(:new)
+      Puppet::Util::Log::DestSyslog.expects(:suitable?)
+      Puppet::Util::Log::DestSyslog.expects(:new).never
 
       Puppet::Util::Log.newdestination(:syslog)
     end
@@ -545,8 +531,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 = double('source')
-        expect(source).not_to receive(:file)
+        source = mock
+        source.expects(:file).never
         Puppet::Util::Log.new(:level => "notice", :message => :foo, :source => source)
       end
     end

data/spec/unit/util/logging_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/util/logging'
@@ -25,29 +26,29 @@ describe Puppet::Util::Logging do
   end
 
   it "should have a method for sending a log with a specified log level" do
-    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.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" }
 
     @logger.send_log "loglevel", "mymessage"
   end
 
   describe "when sending a log" do
     it "should use the Log's 'create' entrance method" do
-      expect(Puppet::Util::Log).to receive(:create)
+      Puppet::Util::Log.expects(:create)
 
       @logger.notice "foo"
     end
 
     it "should send itself converted to a string as the log source" do
-      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.expects(:to_s).returns "I'm a string!"
+      Puppet::Util::Log.expects(:create).with { |args| args[:source] == "I'm a string!" }
 
       @logger.notice "foo"
     end
 
     it "should queue logs sent without a specified destination" do
       Puppet::Util::Log.close_all
-      expect(Puppet::Util::Log).to receive(:queuemessage)
+      Puppet::Util::Log.expects(:queuemessage)
 
       @logger.notice "foo"
     end
@@ -55,9 +56,9 @@ describe Puppet::Util::Logging do
     it "should use the path of any provided resource type" do
       resource = Puppet::Type.type(:logging_test).new :name => "foo"
 
-      expect(resource).to receive(:path).and_return("/path/to/host".to_sym)
+      resource.expects(:path).returns "/path/to/host".to_sym
 
-      expect(Puppet::Util::Log).to receive(:create).with(hash_including(source: "/path/to/host"))
+      Puppet::Util::Log.expects(:create).with { |args| args[:source] == "/path/to/host" }
 
       resource.notice "foo"
     end
@@ -67,21 +68,21 @@ describe Puppet::Util::Logging do
 
       param = resource.parameter(:name)
 
-      expect(param).to receive(:path).and_return("/path/to/param".to_sym)
+      param.expects(:path).returns "/path/to/param".to_sym
 
-      expect(Puppet::Util::Log).to receive(:create).with(hash_including(source: "/path/to/param"))
+      Puppet::Util::Log.expects(:create).with { |args| args[:source] == "/path/to/param" }
 
       param.notice "foo"
     end
 
     it "should send the provided argument as the log message" do
-      expect(Puppet::Util::Log).to receive(:create).with(hash_including(message: "foo"))
+      Puppet::Util::Log.expects(:create).with { |args| args[:message] == "foo" }
 
       @logger.notice "foo"
     end
 
     it "should join any provided arguments into a single string for the message" do
-      expect(Puppet::Util::Log).to receive(:create).with(hash_including(message: "foo bar baz"))
+      Puppet::Util::Log.expects(:create).with { |args| args[:message] == "foo bar baz" }
 
       @logger.notice ["foo", "bar", "baz"]
     end
@@ -92,7 +93,7 @@ describe Puppet::Util::Logging do
 
         @logger.send(attr.to_s + "=", "myval")
 
-        expect(Puppet::Util::Log).to receive(:create).with(hash_including(attr => "myval"))
+        Puppet::Util::Log.expects(:create).with { |args| args[attr] == "myval" }
         @logger.notice "foo"
       end
     end
@@ -101,7 +102,7 @@ describe Puppet::Util::Logging do
   describe "log_exception" do
     context "when requesting a debug level it is logged at debug" do
       it "the exception is a ParseErrorWithIssue and message is :default" do
-        expect(Puppet::Util::Log).to receive(:create) do |args|
+        Puppet::Util::Log.expects(:create).with do |args|
           expect(args[:message]).to eq("Test")
           expect(args[:level]).to eq(:debug)
         end
@@ -114,7 +115,7 @@ describe Puppet::Util::Logging do
       end
 
       it "the exception is something else" do
-        expect(Puppet::Util::Log).to receive(:create) do |args|
+        Puppet::Util::Log.expects(:create).with do |args|
           expect(args[:message]).to eq("Test")
           expect(args[:level]).to eq(:debug)
         end
@@ -129,7 +130,7 @@ describe Puppet::Util::Logging do
 
     context "no log level is requested it defaults to err" do
       it "the exception is a ParseErrorWithIssue and message is :default" do
-        expect(Puppet::Util::Log).to receive(:create) do |args|
+        Puppet::Util::Log.expects(:create).with do |args|
           expect(args[:message]).to eq("Test")
           expect(args[:level]).to eq(:err)
         end
@@ -142,7 +143,7 @@ describe Puppet::Util::Logging do
       end
 
       it "the exception is something else" do
-        expect(Puppet::Util::Log).to receive(:create) do |args|
+        Puppet::Util::Log.expects(:create).with do |args|
           expect(args[:message]).to eq("Test")
           expect(args[:level]).to eq(:err)
         end
@@ -158,41 +159,47 @@ describe Puppet::Util::Logging do
 
   describe "when sending a deprecation warning" do
     it "does not log a message when deprecation warnings are disabled" do
-      expect(Puppet).to receive(:[]).with(:disable_warnings).and_return(%w[deprecations])
-      expect(@logger).not_to receive(:warning)
+      Puppet.expects(:[]).with(:disable_warnings).returns %w[deprecations]
+      @logger.expects(:warning).never
       @logger.deprecation_warning 'foo'
     end
 
     it "logs the message with warn" do
-      expect(@logger).to receive(:warning).with(/^foo\n/)
+      @logger.expects(:warning).with do |msg|
+        msg =~ /^foo\n/
+      end
       @logger.deprecation_warning 'foo'
     end
 
     it "only logs each offending line once" do
-      expect(@logger).to receive(:warning).with(/^foo\n/).once
+      @logger.expects(:warning).with do |msg|
+        msg =~ /^foo\n/
+      end .once
       5.times { @logger.deprecation_warning 'foo' }
     end
 
     it "ensures that deprecations from same origin are logged if their keys differ" do
-      expect(@logger).to receive(:warning).with(/deprecated foo/).exactly(5).times()
+      @logger.expects(:warning).with(regexp_matches(/deprecated foo/)).times(5)
       5.times { |i| @logger.deprecation_warning('deprecated foo', :key => "foo#{i}") }
     end
 
     it "does not duplicate deprecations for a given key" do
-      expect(@logger).to receive(:warning).with(/deprecated foo/).once
+      @logger.expects(:warning).with(regexp_matches(/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|
-        expect(@logger).to receive(:warning).with(/^#{i}\n/).once
+        @logger.expects(:warning).with do |msg|
+          msg =~ /^#{i}\n/
+        end .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.
-        expect(@logger).to receive(:get_deprecation_offender).and_return(["deprecation log count test ##{i}"])
+        @logger.expects(:get_deprecation_offender).returns(["deprecation log count test ##{i}"])
         @logger.deprecation_warning i
       }
-      expect(@logger).not_to receive(:warning).with(101)
+      @logger.expects(:warning).with(101).never
       @logger.deprecation_warning 101
     end
   end
@@ -212,25 +219,25 @@ describe Puppet::Util::Logging do
     end
 
     it "warns with file and line" do
-      expect(@logger).to receive(:warning).with(/deprecated foo.*\(file: afile, line: 5\)/m)
+      @logger.expects(:warning).with(regexp_matches(/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
-      expect(@logger).to receive(:warning).with(/deprecated foo.*\(file: afile, line: 5\)/m).once
+      @logger.expects(:warning).with(regexp_matches(/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
-      expect(@logger).to receive(:warning).with(/deprecated foo.*\(file: afile, line: 5\)/m).once
+      @logger.expects(:warning).with(regexp_matches(/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
-      expect(@logger).to receive(:warning).with(/deprecated foo.*\(file: unknown, line: unknown\)/m)
+      @logger.expects(:warning).with(regexp_matches(/deprecated foo.*\(file: unknown, line: unknown\)/m))
       @logger.puppet_deprecation_warning("deprecated foo", :key => 'some_key')
     end
   end
@@ -239,24 +246,29 @@ 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
-      expect(@logger).to receive(:send_log).with(:warning, /wet paint.*\(file: aFile\)/m)
+      @logger.expects(:send_log).with(:warning, regexp_matches(/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
-      expect(@logger).to receive(:send_log).with(:warning, /wet paint.*\(line: 5\)/m)
+      @logger.expects(:send_log).with(:warning, regexp_matches(/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
-      expect(@logger).to receive(:send_log).with(:warning, /wet paint.*\(file: aFile, line: 5\)/m)
+      @logger.expects(:send_log).with(:warning, regexp_matches(/wet paint.*\(file: aFile, line: 5\)/m))
       @logger.warn_once('kind', 'wp', "wet paint",'aFile', 5)
     end
 
     it "warns once per key" do
-      expect(@logger).to receive(:send_log).with(:warning, /wet paint.*/m).once
+      @logger.expects(:send_log).with(:warning, regexp_matches(/wet paint.*/m)).once
       5.times do
         @logger.warn_once('kind', 'wp', "wet paint")
       end
@@ -264,7 +276,7 @@ describe Puppet::Util::Logging do
 
     Puppet::Util::Log.eachlevel do |level|
       it "can use log level #{level}" do
-        expect(@logger).to receive(:send_log).with(level, /wet paint.*/m).once
+        @logger.expects(:send_log).with(level, regexp_matches(/wet paint.*/m)).once
         5.times do
           @logger.warn_once('kind', 'wp', "wet paint", nil, nil, level)
         end
@@ -275,21 +287,20 @@ describe Puppet::Util::Logging do
   describe "does not warn about undefined variables when disabled_warnings says so" do
     let(:logger) { LoggingTester.new }
 
-    before(:each) do
+    around(:each) do |example|
       Puppet.settings.initialize_global_settings
       logger.clear_deprecation_warnings
       Puppet[:disable_warnings] = ['undefined_variables']
+      example.run
+      Puppet[:disable_warnings] = []
     end
 
     after(:each) do
-      Puppet[:disable_warnings] = []
-      allow(logger).to receive(:send_log).and_call_original()
-      allow(Facter).to receive(:respond_to?).and_call_original()
-      allow(Facter).to receive(:debugging).and_call_original()
+      logger.unstub(:send_log)
     end
 
     it "does not produce warning if kind is disabled" do
-      expect(logger).not_to receive(:send_log)
+      logger.expects(:send_log).never
       logger.warn_once('undefined_variables', 'wp', "wet paint")
     end
   end
@@ -297,21 +308,20 @@ describe Puppet::Util::Logging do
   describe "warns about undefined variables when deprecations are in disabled_warnings" do
     let(:logger) { LoggingTester.new }
 
-    before(:each) do
+    around(:each) do |example|
       Puppet.settings.initialize_global_settings
       logger.clear_deprecation_warnings
       Puppet[:disable_warnings] = ['deprecations']
+      example.run
+      Puppet[:disable_warnings] = []
     end
 
     after(:each) do
-      Puppet[:disable_warnings] = []
-      allow(logger).to receive(:send_log).and_call_original()
-      allow(Facter).to receive(:respond_to?).and_call_original()
-      allow(Facter).to receive(:debugging).and_call_original()
+      logger.unstub(:send_log)
     end
 
     it "produces warning even if deprecation warnings are disabled " do
-      expect(logger).to receive(:send_log).with(:warning, /wet paint/).once
+      logger.expects(:send_log).with(:warning, regexp_matches(/wet paint/)).once
       logger.warn_once('undefined_variables', 'wp', "wet paint")
     end
   end
@@ -346,49 +356,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
-      allow(Facter).to receive(:respond_to?).and_call_original()
-      allow(Facter).to receive(:debugging).and_call_original()
+      Facter.unstub(:respond_to?)
+      Facter.unstub(:debugging)
     end
 
     describe 'does support debugging' do
       before :each do
-        allow(Facter).to receive(:respond_to?).with(:debugging).and_return(true)
+        Facter.stubs(:respond_to?).with(:debugging).returns true
       end
 
       it 'enables Facter debugging when debug level' do
-        allow(Facter).to receive(:debugging).with(true)
+        Facter.stubs(:debugging).with(true)
         Puppet::Util::Log.level = :debug
       end
 
       it 'disables Facter debugging when not debug level' do
-        allow(Facter).to receive(:debugging).with(false)
+        Facter.stubs(:debugging).with(false)
         Puppet::Util::Log.level = :info
       end
     end
 
     describe 'does support trace' do
       before :each do
-        allow(Facter).to receive(:respond_to?).with(:trace).and_return(true)
+        Facter.stubs(:respond_to?).with(:trace).returns true
       end
 
       it 'enables Facter trace when enabled' do
-        allow(Facter).to receive(:trace).with(true)
+        Facter.stubs(:trace).with(true)
         Puppet[:trace] = true
       end
 
       it 'disables Facter trace when disabled' do
-        allow(Facter).to receive(:trace).with(false)
+        Facter.stubs(:trace).with(false)
         Puppet[:trace] = false
       end
     end
 
     describe 'does support on_message' do
       before :each do
-        allow(Facter).to receive(:respond_to?).with(:on_message).and_return(true)
+        Facter.stubs(:respond_to?).with(:on_message).returns true
       end
 
       def setup(level, message)
-        allow(Facter).to receive(:on_message).and_yield(level, message)
+        Facter.stubs(:on_message).yields level, message
 
         # Transform from Facter level to Puppet level
         case level
@@ -402,7 +412,11 @@ original
           level = :crit
         end
 
-        allow(Puppet::Util::Log).to receive(:create).with(hash_including(level: level, message: message, source: 'Facter')).once
+        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
       end
 
       [:trace, :debug, :info, :warn, :error, :fatal].each do |level|