puppet 5.5.22 → 6.0.0

data/spec/unit/util/logging_spec.rb

@@ -1,42 +1,17 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/util/logging'
 
-class LoggingTester
-  include Puppet::Util::Logging
+Puppet::Type.newtype(:logging_test) do
+  newparam(:name, isnamevar: true)
+  newproperty(:path)
+end
+Puppet::Type.type(:logging_test).provide(:logging_test) do
 end
 
-class PuppetStackCreator
-  def raise_error(exception_class)
-    case exception_class
-    when Puppet::ParseErrorWithIssue
-      raise exception_class.new('Oops', '/tmp/test.pp', 30, 15, nil, :SYNTAX_ERROR)
-    when Puppet::ParseError
-      raise exception_class.new('Oops', '/tmp/test.pp', 30, 15)
-    else
-      raise exception_class.new('Oops')
-    end
-  end
-
-  def call_raiser(exception_class)
-    Puppet::Pops::PuppetStack.stack('/tmp/test2.pp', 20, self, :raise_error, [exception_class])
-  end
-
-  def two_frames_and_a_raise(exception_class)
-    Puppet::Pops::PuppetStack.stack('/tmp/test3.pp', 15, self, :call_raiser, [exception_class])
-  end
-
-  def outer_rescue(exception_class)
-    begin
-      two_frames_and_a_raise(exception_class)
-    rescue Puppet::Error => e
-      Puppet.log_exception(e)
-    end
-  end
-
-  def run(exception_class)
-    Puppet::Pops::PuppetStack.stack('/tmp/test4.pp', 10, self, :outer_rescue, [exception_class])
-  end
+class LoggingTester
+  include Puppet::Util::Logging
 end
 
 describe Puppet::Util::Logging do
@@ -51,63 +26,63 @@ 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
 
     it "should use the path of any provided resource type" do
-      resource = Puppet::Type.type(:host).new :name => "foo"
+      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
 
     it "should use the path of any provided resource parameter" do
-      resource = Puppet::Type.type(:host).new :name => "foo"
+      resource = Puppet::Type.type(:logging_test).new :name => "foo"
 
       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
@@ -118,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
@@ -126,41 +101,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
@@ -180,25 +161,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
@@ -207,24 +188,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
@@ -232,7 +218,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
@@ -243,21 +229,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(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()
+      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
@@ -265,21 +250,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(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()
+      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
@@ -308,222 +292,96 @@ original
 .*2\.rb:2:in `b'
 .*3\.rb:1/)
     end
+  end
 
-    describe "when trace is disabled" do
-      it 'excludes backtrace for RuntimeError in log message' do
-        begin
-          raise RuntimeError, 'Oops'
-        rescue RuntimeError => e
-          Puppet.log_exception(e)
-        end
-
-        expect(@logs.size).to eq(1)
-        log = @logs[0]
-        expect(log.message).to_not match('/logging_spec.rb')
-        expect(log.backtrace).to be_nil
-      end
-
-      it "backtrace member is unset when logging ParseErrorWithIssue" do
-        begin
-          raise Puppet::ParseErrorWithIssue.new('Oops', '/tmp/test.pp', 30, 15, nil, :SYNTAX_ERROR)
-        rescue RuntimeError => e
-          Puppet.log_exception(e)
-        end
-
-        expect(@logs.size).to eq(1)
-        log = @logs[0]
-        expect(log.message).to_not match('/logging_spec.rb')
-        expect(log.backtrace).to be_nil
-      end
+  describe 'when Facter' do
+    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)
     end
 
-    describe "when trace is enabled" do
-      it 'includes backtrace for RuntimeError in log message when enabled globally' do
-        Puppet[:trace] = true
-        begin
-          raise RuntimeError, 'Oops'
-        rescue RuntimeError => e
-          Puppet.log_exception(e, :default)
-        end
-        Puppet[:trace] = false
-
-        expect(@logs.size).to eq(1)
-        log = @logs[0]
-        expect(log.message).to match('/logging_spec.rb')
-        expect(log.backtrace).to be_nil
-      end
-
-      it 'includes backtrace for RuntimeError in log message when enabled via option' do
-        begin
-          raise RuntimeError, 'Oops'
-        rescue RuntimeError => e
-          Puppet.log_exception(e, :default, :trace => true)
-        end
-
-        expect(@logs.size).to eq(1)
-        log = @logs[0]
-        expect(log.message).to match('/logging_spec.rb')
-        expect(log.backtrace).to be_nil
-      end
-
-
-      it "backtrace member is set when logging ParseErrorWithIssue" do
-        begin
-          raise Puppet::ParseErrorWithIssue.new('Oops', '/tmp/test.pp', 30, 15, nil, :SYNTAX_ERROR)
-        rescue RuntimeError => e
-          Puppet.log_exception(e, :default, :trace => true)
-        end
-
-        expect(@logs.size).to eq(1)
-        log = @logs[0]
-        expect(log.message).to_not match('/logging_spec.rb')
-        expect(log.backtrace).to be_a(Array)
-        expect(log.backtrace[0]).to match('/logging_spec.rb')
+    describe 'does not support debugging' do
+      before :each do
+        Facter.stubs(:respond_to?).with(:debugging).returns false
+        Facter.stubs(:debugging).never
       end
-      it "backtrace has interleaved PuppetStack when logging ParseErrorWithIssue" do
-        Puppet[:trace] = true
-        PuppetStackCreator.new.run(Puppet::ParseErrorWithIssue)
-        Puppet[:trace] = false
 
-        expect(@logs.size).to eq(1)
-        log = @logs[0]
-        expect(log.message).to_not match('/logging_spec.rb')
-        expect(log.backtrace[0]).to match('/logging_spec.rb')
-
-        expect(log.backtrace[1]).to match('/tmp/test2.pp:20')
-        puppetstack = log.backtrace.select { |l| l =~ /tmp\/test\d\.pp/ }
-
-        expect(puppetstack.length).to equal 3
+      it 'does not enable Facter debugging for debug level' do
+        Puppet::Util::Log.level = :debug
       end
 
-      it "message has interleaved PuppetStack when logging ParseError" do
-        Puppet[:trace] = true
-        PuppetStackCreator.new.run(Puppet::ParseError)
-        Puppet[:trace] = false
-
-        expect(@logs.size).to eq(1)
-        log = @logs[0]
-
-        log_lines = log.message.split("\n")
-        expect(log_lines[1]).to match('/logging_spec.rb')
-        expect(log_lines[2]).to match('/tmp/test2.pp:20')
-        puppetstack = log_lines.select { |l| l =~ /tmp\/test\d\.pp/ }
-
-        expect(puppetstack.length).to equal 3
+      it 'does not enable Facter debugging non-debug level' do
+        Puppet::Util::Log.level = :info
       end
     end
 
-    describe "when trace is disabled but puppet_trace is enabled" do
-      it "includes only PuppetStack as backtrace member with ParseErrorWithIssue" do
-        Puppet[:trace] = false
-        Puppet[:puppet_trace] = true
-        PuppetStackCreator.new.run(Puppet::ParseErrorWithIssue)
-        Puppet[:trace] = false
-        Puppet[:puppet_trace] = false
-
-        expect(@logs.size).to eq(1)
-        log = @logs[0]
-
-        expect(log.backtrace[0]).to match('/tmp/test2.pp:20')
-        expect(log.backtrace.length).to equal 3
-      end
-
-      it "includes only PuppetStack in message with ParseError" do
-        Puppet[:trace] = false
-        Puppet[:puppet_trace] = true
-        PuppetStackCreator.new.run(Puppet::ParseError)
-        Puppet[:trace] = false
-        Puppet[:puppet_trace] = false
-
-        expect(@logs.size).to eq(1)
-        log = @logs[0]
-
-        log_lines = log.message.split("\n")
-        expect(log_lines[1]).to match('/tmp/test2.pp:20')
-        puppetstack = log_lines.select { |l| l =~ /tmp\/test\d\.pp/ }
-
-        expect(puppetstack.length).to equal 3
+    describe 'does support debugging' do
+      before :each do
+        Facter.stubs(:respond_to?).with(:debugging).returns true
       end
-    end
 
-    it 'includes position details for ParseError in log message' do
-      begin
-        raise Puppet::ParseError.new('Oops', '/tmp/test.pp', 30, 15)
-      rescue RuntimeError => e
-        Puppet.log_exception(e)
+      it 'enables Facter debugging when debug level' do
+        Facter.stubs(:debugging).with(true)
+        Puppet::Util::Log.level = :debug
       end
 
-      expect(@logs.size).to eq(1)
-      log = @logs[0]
-      expect(log.message).to match(/ \(file: \/tmp\/test\.pp, line: 30, column: 15\)/)
-      expect(log.message).to be(log.to_s)
-    end
-
-    it 'excludes position details for ParseErrorWithIssue from log message' do
-      begin
-        raise Puppet::ParseErrorWithIssue.new('Oops', '/tmp/test.pp', 30, 15, nil, :SYNTAX_ERROR)
-      rescue RuntimeError => e
-        Puppet.log_exception(e)
+      it 'disables Facter debugging when not debug level' do
+        Facter.stubs(:debugging).with(false)
+        Puppet::Util::Log.level = :info
       end
-
-      expect(@logs.size).to eq(1)
-      log = @logs[0]
-      expect(log.message).to_not match(/ \(file: \/tmp\/test\.pp, line: 30, column: 15\)/)
-      expect(log.to_s).to match(/ \(file: \/tmp\/test\.pp, line: 30, column: 15\)/)
-      expect(log.issue_code).to eq(:SYNTAX_ERROR)
-      expect(log.file).to eq('/tmp/test.pp')
-      expect(log.line).to eq(30)
-      expect(log.pos).to eq(15)
     end
-  end
 
-  describe 'when Facter' do
-    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()
-    end
-
-    describe 'does support debugging' do
+    describe 'does not support trace' do
       before :each do
-        allow(Facter).to receive(:respond_to?).with(:debugging).and_return(true)
+        Facter.stubs(:respond_to?).with(:trace).returns false
+        Facter.stubs(:trace).never
       end
 
-      it 'enables Facter debugging when debug level' do
-        allow(Facter).to receive(:debugging).with(true)
-        Puppet::Util::Log.level = :debug
+      it 'does not enable Facter trace when enabled' do
+        Puppet[:trace] = true
       end
 
-      it 'disables Facter debugging when not debug level' do
-        allow(Facter).to receive(:debugging).with(false)
-        Puppet::Util::Log.level = :info
+      it 'does not enable Facter trace when disabled' do
+        Puppet[:trace] = false
       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 not support on_message' do
+      before :each do
+        Facter.stubs(:respond_to?).with(:on_message).returns false
+        Facter.stubs(:on_message).never
+      end
+
+      it 'does not call Facter.on_message' do
+        expect(Puppet::Util::Logging::setup_facter_logging!).to be_falsey
+      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
@@ -537,7 +395,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|