puppet 3.8.7 → 4.0.0.rc1

data/spec/unit/util/log_spec.rb

@@ -15,7 +15,7 @@ describe Puppet::Util::Log do
     Puppet::Util::Log.newdestination(Puppet::Test::LogCollector.new(arraydest))
     Puppet::Util::Log.new(:level => :notice, :message => "foo")
     message = arraydest.last.message
-    message.should == "foo"
+    expect(message).to eq("foo")
   end
 
   describe ".setup_default" do
@@ -93,154 +93,40 @@ describe Puppet::Util::Log do
 
       expect(logs.collect(&:message)).to include("Inner block", "Outer block")
     end
-
-    it 'includes backtrace for RuntimeError in log message when trace is enabled' do
-      logs = []
-      destination = Puppet::Test::LogCollector.new(logs)
-
-      Puppet::Util::Log.newdestination(destination)
-      Puppet::Util::Log.with_destination(destination) do
-        begin
-          raise RuntimeError, 'Oops'
-        rescue RuntimeError => e
-          Puppet.log_exception(e, :default, :trace => true)
-        end
-      end
-      expect(logs.size).to eq(1)
-      log = logs[0]
-      expect(log.message).to match('/log_spec.rb')
-      expect(log.backtrace).to be_nil
-    end
-
-    it 'excludes backtrace for RuntimeError in log message when trace is disabled' do
-      logs = []
-      destination = Puppet::Test::LogCollector.new(logs)
-
-      Puppet::Util::Log.newdestination(destination)
-      Puppet::Util::Log.with_destination(destination) do
-        begin
-          raise RuntimeError, 'Oops'
-        rescue RuntimeError => e
-          Puppet.log_exception(e)
-        end
-      end
-      expect(logs.size).to eq(1)
-      log = logs[0]
-      expect(log.message).to_not match('/log_spec.rb')
-      expect(log.backtrace).to be_nil
-    end
-
-    it "backtrace is Array in 'backtrace' and excluded from 'message' when logging ParseErrorWithIssue with trace enabled" do
-      logs = []
-      destination = Puppet::Test::LogCollector.new(logs)
-
-      Puppet::Util::Log.newdestination(destination)
-      Puppet::Util::Log.with_destination(destination) 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
-      end
-      expect(logs.size).to eq(1)
-      log = logs[0]
-      expect(log.message).to_not match('/log_spec.rb')
-      expect(log.backtrace).to be_a(Array)
-    end
-
-    it "backtrace is excluded when logging ParseErrorWithIssue with trace disabled" do
-      logs = []
-      destination = Puppet::Test::LogCollector.new(logs)
-
-      Puppet::Util::Log.newdestination(destination)
-      Puppet::Util::Log.with_destination(destination) do
-        begin
-          raise Puppet::ParseErrorWithIssue.new('Oops', '/tmp/test.pp', 30, 15, nil, :SYNTAX_ERROR)
-        rescue RuntimeError => e
-          Puppet.log_exception(e)
-        end
-      end
-      expect(logs.size).to eq(1)
-      log = logs[0]
-      expect(log.message).to_not match('/log_spec.rb')
-      expect(log.backtrace).to be_nil
-    end
-
-    it 'includes position details for ParseError in log message' do
-      logs = []
-      destination = Puppet::Test::LogCollector.new(logs)
-
-      Puppet::Util::Log.newdestination(destination)
-      Puppet::Util::Log.with_destination(destination) do
-        begin
-          raise Puppet::ParseError.new('Oops', '/tmp/test.pp', 30, 15)
-        rescue RuntimeError => e
-          Puppet.log_exception(e)
-        end
-      end
-      expect(logs.size).to eq(1)
-      log = logs[0]
-      expect(log.message).to match(/ at \/tmp\/test\.pp:30:15/)
-      expect(log.message).to be(log.to_s)
-    end
-
-    it 'excludes position details for ParseErrorWithIssue from log message' do
-      logs = []
-      destination = Puppet::Test::LogCollector.new(logs)
-
-      Puppet::Util::Log.newdestination(destination)
-      Puppet::Util::Log.with_destination(destination) do
-        begin
-          raise Puppet::ParseErrorWithIssue.new('Oops', '/tmp/test.pp', 30, 15, nil, :SYNTAX_ERROR)
-        rescue RuntimeError => e
-          Puppet.log_exception(e)
-        end
-      end
-      expect(logs.size).to eq(1)
-      log = logs[0]
-      expect(log.message).to_not match(/ at \/tmp\/test\.pp:30:15/)
-      expect(log.to_s).to match(/ at \/tmp\/test\.pp:30: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 Puppet::Util::Log::DestConsole do
     before do
       @console = Puppet::Util::Log::DestConsole.new
-      @console.stubs(:console_has_color?).returns(true)
     end
 
     it "should colorize if Puppet[:color] is :ansi" do
       Puppet[:color] = :ansi
 
-      @console.colorize(:alert, "abc").should == "\e[0;31mabc\e[0m"
+      expect(@console.colorize(:alert, "abc")).to eq("\e[0;31mabc\e[0m")
     end
 
     it "should colorize if Puppet[:color] is 'yes'" do
       Puppet[:color] = "yes"
 
-      @console.colorize(:alert, "abc").should == "\e[0;31mabc\e[0m"
+      expect(@console.colorize(:alert, "abc")).to eq("\e[0;31mabc\e[0m")
     end
 
     it "should htmlize if Puppet[:color] is :html" do
       Puppet[:color] = :html
 
-      @console.colorize(:alert, "abc").should == "<span style=\"color: #FFA0A0\">abc</span>"
+      expect(@console.colorize(:alert, "abc")).to eq("<span style=\"color: #FFA0A0\">abc</span>")
     end
 
     it "should do nothing if Puppet[:color] is false" do
       Puppet[:color] = false
 
-      @console.colorize(:alert, "abc").should == "abc"
+      expect(@console.colorize(:alert, "abc")).to eq("abc")
     end
 
     it "should do nothing if Puppet[:color] is invalid" do
       Puppet[:color] = "invalid option"
 
-      @console.colorize(:alert, "abc").should == "abc"
+      expect(@console.colorize(:alert, "abc")).to eq("abc")
     end
   end
 
@@ -252,7 +138,7 @@ describe Puppet::Util::Log do
 
   describe Puppet::Util::Log::DestEventlog, :if => Puppet.features.eventlog? do
     before :each do
-      Win32::EventLog.stubs(:open).returns(mock 'mylog')
+      Win32::EventLog.stubs(:open).returns(stub 'mylog')
       Win32::EventLog.stubs(:report_event)
       Win32::EventLog.stubs(:close)
       Puppet.features.stubs(:eventlog?).returns(true)
@@ -261,7 +147,7 @@ describe Puppet::Util::Log do
     it "should restrict its suitability" do
       Puppet.features.expects(:eventlog?).returns(false)
 
-      Puppet::Util::Log::DestEventlog.suitable?('whatever').should == false
+      expect(Puppet::Util::Log::DestEventlog.suitable?('whatever')).to eq(false)
     end
 
     it "should open the 'Application' event log" do
@@ -271,7 +157,7 @@ describe Puppet::Util::Log do
     end
 
     it "should close the event log" do
-      log = mock('myeventlog')
+      log = stub('myeventlog')
       log.expects(:close)
       Win32::EventLog.expects(:open).returns(log)
 
@@ -283,7 +169,7 @@ describe Puppet::Util::Log do
       log = Puppet::Util::Log::DestEventlog.new
 
       Puppet::Util::Log.eachlevel do |level|
-        log.to_native(level).should be_is_a(Array)
+        expect(log.to_native(level)).to be_is_a(Array)
       end
     end
   end
@@ -296,31 +182,31 @@ describe Puppet::Util::Log do
     [:level, :message, :time, :remote].each do |attr|
       it "should have a #{attr} attribute" do
         log = Puppet::Util::Log.new :level => :notice, :message => "A test message"
-        log.should respond_to(attr)
-        log.should respond_to(attr.to_s + "=")
+        expect(log).to respond_to(attr)
+        expect(log).to respond_to(attr.to_s + "=")
       end
     end
 
     it "should fail if created without a level" do
-      lambda { Puppet::Util::Log.new(:message => "A test message") }.should raise_error(ArgumentError)
+      expect { Puppet::Util::Log.new(:message => "A test message") }.to raise_error(ArgumentError)
     end
 
     it "should fail if created without a message" do
-      lambda { Puppet::Util::Log.new(:level => :notice) }.should raise_error(ArgumentError)
+      expect { Puppet::Util::Log.new(:level => :notice) }.to raise_error(ArgumentError)
     end
 
     it "should make available the level passed in at initialization" do
-      Puppet::Util::Log.new(:level => :notice, :message => "A test message").level.should == :notice
+      expect(Puppet::Util::Log.new(:level => :notice, :message => "A test message").level).to eq(:notice)
     end
 
     it "should make available the message passed in at initialization" do
-      Puppet::Util::Log.new(:level => :notice, :message => "A test message").message.should == "A test message"
+      expect(Puppet::Util::Log.new(:level => :notice, :message => "A test message").message).to eq("A test message")
     end
 
     # LAK:NOTE I don't know why this behavior is here, I'm just testing what's in the code,
     # at least at first.
     it "should always convert messages to strings" do
-      Puppet::Util::Log.new(:level => :notice, :message => :foo).message.should == "foo"
+      expect(Puppet::Util::Log.new(:level => :notice, :message => :foo).message).to eq("foo")
     end
 
     it "should flush the log queue when the first destination is specified" do
@@ -330,28 +216,28 @@ describe Puppet::Util::Log do
     end
 
     it "should convert the level to a symbol if it's passed in as a string" do
-      Puppet::Util::Log.new(:level => "notice", :message => :foo).level.should == :notice
+      expect(Puppet::Util::Log.new(:level => "notice", :message => :foo).level).to eq(:notice)
     end
 
     it "should fail if the level is not a symbol or string" do
-      lambda { Puppet::Util::Log.new(:level => 50, :message => :foo) }.should raise_error(ArgumentError)
+      expect { Puppet::Util::Log.new(:level => 50, :message => :foo) }.to raise_error(ArgumentError)
     end
 
     it "should fail if the provided level is not valid" do
       Puppet::Util::Log.expects(:validlevel?).with(:notice).returns false
-      lambda { Puppet::Util::Log.new(:level => :notice, :message => :foo) }.should raise_error(ArgumentError)
+      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
-      Puppet::Util::Log.new(:level => "notice", :message => :foo).time.should equal(time)
+      expect(Puppet::Util::Log.new(:level => "notice", :message => :foo).time).to equal(time)
     end
 
     it "should make available any passed-in tags" do
       log = Puppet::Util::Log.new(:level => "notice", :message => :foo, :tags => %w{foo bar})
-      log.tags.should be_include("foo")
-      log.tags.should be_include("bar")
+      expect(log.tags).to be_include("foo")
+      expect(log.tags).to be_include("bar")
     end
 
     it "should use a passed-in source" do
@@ -367,7 +253,7 @@ describe Puppet::Util::Log do
     end
 
     it "should default to 'Puppet' as its source" do
-      Puppet::Util::Log.new(:level => "notice", :message => :foo).source.should == "Puppet"
+      expect(Puppet::Util::Log.new(:level => "notice", :message => :foo).source).to eq("Puppet")
     end
 
     it "should register itself with Log" do
@@ -381,28 +267,28 @@ describe Puppet::Util::Log do
     end
 
     it "should have a method for determining if a tag is present" do
-      Puppet::Util::Log.new(:level => "notice", :message => :foo).should respond_to(:tagged?)
+      expect(Puppet::Util::Log.new(:level => "notice", :message => :foo)).to respond_to(:tagged?)
     end
 
     it "should match a tag if any of the tags are equivalent to the passed tag as a string" do
-      Puppet::Util::Log.new(:level => "notice", :message => :foo, :tags => %w{one two}).should be_tagged(:one)
+      expect(Puppet::Util::Log.new(:level => "notice", :message => :foo, :tags => %w{one two})).to be_tagged(:one)
     end
 
     it "should tag itself with its log level" do
-      Puppet::Util::Log.new(:level => "notice", :message => :foo).should be_tagged(:notice)
+      expect(Puppet::Util::Log.new(:level => "notice", :message => :foo)).to be_tagged(:notice)
     end
 
     it "should return its message when converted to a string" do
-      Puppet::Util::Log.new(:level => "notice", :message => :foo).to_s.should == "foo"
+      expect(Puppet::Util::Log.new(:level => "notice", :message => :foo).to_s).to eq("foo")
     end
 
     it "should include its time, source, level, and message when prepared for reporting" do
       log = Puppet::Util::Log.new(:level => "notice", :message => :foo)
       report = log.to_report
-      report.should be_include("notice")
-      report.should be_include("foo")
-      report.should be_include(log.source)
-      report.should be_include(log.time.to_s)
+      expect(report).to be_include("notice")
+      expect(report).to be_include("foo")
+      expect(report).to be_include(log.source)
+      expect(report).to be_include(log.time.to_s)
     end
 
     it "should not create unsuitable log destinations" do
@@ -421,11 +307,11 @@ describe Puppet::Util::Log do
         source = Puppet::Type.type(:file).new :path => path
         log = Puppet::Util::Log.new(:level => "notice", :message => :foo, :source => source)
         source.tags.each do |tag|
-          log.tags.should be_include(tag)
+          expect(log.tags).to be_include(tag)
         end
       end
 
-      it "should set the source to a type's 'path', when available" do
+      it "should set the source to 'path', when available" do
         source = Puppet::Type.type(:file).new :path => path
         source.tags = ["tag", "tag2"]
 
@@ -436,18 +322,7 @@ describe Puppet::Util::Log do
 
         log.source = source
 
-        log.source.should == "/File[#{path}]"
-      end
-
-      it "should set the source to a provider's type's 'path', when available" do
-        source = Puppet::Type.type(:file).new :path => path
-        source.tags = ["tag", "tag2"]
-
-        log = Puppet::Util::Log.new(:level => "notice", :message => :foo)
-
-        log.source = source.provider
-
-        log.source.should match Regexp.quote("File\[#{path}\]\(provider=")
+        expect(log.source).to eq("/File[#{path}]")
       end
 
       it "should copy over any file and line information" do
@@ -455,8 +330,8 @@ describe Puppet::Util::Log do
         source.file = "/my/file"
         source.line = 50
         log = Puppet::Util::Log.new(:level => "notice", :message => :foo, :source => source)
-        log.line.should == 50
-        log.file.should == "/my/file"
+        expect(log.line).to eq(50)
+        expect(log.file).to eq("/my/file")
       end
     end
 
@@ -472,18 +347,18 @@ describe Puppet::Util::Log do
   describe "to_yaml" do
     it "should not include the @version attribute" do
       log = Puppet::Util::Log.new(:level => "notice", :message => :foo, :version => 100)
-      log.to_yaml_properties.should_not include('@version')
+      expect(log.to_yaml_properties).not_to include('@version')
     end
 
     it "should include attributes @level, @message, @source, @tags, and @time" do
       log = Puppet::Util::Log.new(:level => "notice", :message => :foo, :version => 100)
-      log.to_yaml_properties.should =~ [:@level, :@message, :@source, :@tags, :@time]
+      expect(log.to_yaml_properties).to match_array([:@level, :@message, :@source, :@tags, :@time])
     end
 
     it "should include attributes @file and @line if specified" do
       log = Puppet::Util::Log.new(:level => "notice", :message => :foo, :file => "foo", :line => 35)
-      log.to_yaml_properties.should include(:@file)
-      log.to_yaml_properties.should include(:@line)
+      expect(log.to_yaml_properties).to include(:@file)
+      expect(log.to_yaml_properties).to include(:@line)
     end
   end
 
@@ -491,12 +366,12 @@ describe Puppet::Util::Log do
     log = Puppet::Util::Log.new(:level => 'notice', :message => 'hooray', :file => 'thefile', :line => 1729, :source => 'specs', :tags => ['a', 'b', 'c'])
     tripped = Puppet::Util::Log.from_data_hash(PSON.parse(log.to_pson))
 
-    tripped.file.should == log.file
-    tripped.line.should == log.line
-    tripped.level.should == log.level
-    tripped.message.should == log.message
-    tripped.source.should == log.source
-    tripped.tags.should == log.tags
-    tripped.time.should == log.time
+    expect(tripped.file).to eq(log.file)
+    expect(tripped.line).to eq(log.line)
+    expect(tripped.level).to eq(log.level)
+    expect(tripped.message).to eq(log.message)
+    expect(tripped.source).to eq(log.source)
+    expect(tripped.tags).to eq(log.tags)
+    expect(tripped.time).to eq(log.time)
   end
 end

data/spec/unit/util/logging_spec.rb

@@ -14,7 +14,7 @@ describe Puppet::Util::Logging do
 
   Puppet::Util::Log.eachlevel do |level|
     it "should have a method for sending '#{level}' logs" do
-      @logger.should respond_to(level)
+      expect(@logger).to respond_to(level)
     end
   end
 
@@ -186,7 +186,7 @@ describe Puppet::Util::Logging do
       exc1 = Puppet::Error.new("third", exc2)
       exc1.set_backtrace(["7.rb:31:in `e'","8.rb:22:in `f'","9.rb:9"])
       # whoa ugly
-      @logger.format_exception(exc1).should =~ /third
+      expect(@logger.format_exception(exc1)).to match(/third
 .*7\.rb:31:in `e'
 .*8\.rb:22:in `f'
 .*9\.rb:9
@@ -199,7 +199,124 @@ Wrapped exception:
 original
 .*1\.rb:4:in `a'
 .*2\.rb:2:in `b'
-.*3\.rb:1/
+.*3\.rb:1/)
+    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
+      Facter.unstub(:respond_to?)
+      Facter.unstub(:debugging)
+    end
+
+    describe 'does not support debugging' do
+      before :each do
+        Facter.stubs(:respond_to?).with(:debugging).returns false
+        Facter.stubs(:debugging).never
+      end
+
+      it 'does not enable Facter debugging for debug level' do
+        Puppet::Util::Log.level = :debug
+      end
+
+      it 'does not enable Facter debugging non-debug level' do
+        Puppet::Util::Log.level = :info
+      end
+    end
+
+    describe 'does support debugging' do
+      before :each do
+        Facter.stubs(:respond_to?).with(:debugging).returns true
+      end
+
+      it 'enables Facter debugging when debug level' do
+        Facter.stubs(:debugging).with(true)
+        Puppet::Util::Log.level = :debug
+      end
+
+      it 'disables Facter debugging when not debug level' do
+        Facter.stubs(:debugging).with(false)
+        Puppet::Util::Log.level = :info
+      end
+    end
+
+    describe 'does not support trace' do
+      before :each do
+        Facter.stubs(:respond_to?).with(:trace).returns false
+        Facter.stubs(:trace).never
+      end
+
+      it 'does not enable Facter trace when enabled' do
+        Puppet[:trace] = true
+      end
+
+      it 'does not enable Facter trace when disabled' do
+        Puppet[:trace] = false
+      end
+    end
+
+    describe 'does support trace' do
+      before :each do
+        Facter.stubs(:respond_to?).with(:trace).returns true
+      end
+
+      it 'enables Facter trace when enabled' do
+        Facter.stubs(:trace).with(true)
+        Puppet[:trace] = true
+      end
+
+      it 'disables Facter trace when disabled' do
+        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
+        Facter.stubs(:respond_to?).with(:on_message).returns true
+      end
+
+      def setup(level, message)
+        Facter.stubs(:on_message).yields level, message
+
+        # Transform from Facter level to Puppet level
+        case level
+        when :trace
+          level = :debug
+        when :warn
+          level = :warning
+        when :error
+          level = :err
+        when :fatal
+          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
+      end
+
+      [:trace, :debug, :info, :warn, :error, :fatal].each do |level|
+        it "calls Facter.on_message and handles #{level} messages" do
+          setup(level, "#{level} message")
+          expect(Puppet::Util::Logging::setup_facter_logging!).to be_truthy
+        end
+      end
     end
   end
 end