puppet 6.4.5-x64-mingw32 → 6.5.0-x64-mingw32

data/spec/unit/util/ldap/manager_spec.rb

@@ -532,21 +532,6 @@ describe Puppet::Util::Ldap::Manager, :if => Puppet.features.ldap? do
         @manager.update(@name, @is, @should)
       end
 
-      it "should convert the property names to strings" do
-        expect(@manager).to receive(:create).with(anything, hash_including("uno" => ["yay"]))
-        @manager.update(@name, @is, @should)
-      end
-
-      it "should convert the property values to arrays if necessary" do
-        expect(@manager).to receive(:create).with(anything, hash_including("uno" => ["yay"]))
-        @manager.update(@name, @is, @should)
-      end
-
-      it "should convert the property values to strings if necessary" do
-        expect(@manager).to receive(:create).with(anything, hash_including("uno" => ["yay"]))
-        @manager.update(@name, @is, @should)
-      end
-
       it "should not include :ensure in the properties sent" do
         expect(@manager).to receive(:create).with(anything, hash_excluding(:ensure))
         @manager.update(@name, @is, @should)

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

@@ -46,15 +46,13 @@ describe Puppet::Util::Log.desttypes[:file] do
 
     describe "on POSIX systems", :if => Puppet.features.posix? do
       describe "with a normal file" do
-        let (:parent) { Pathname.new('/tmp') }
         let (:abspath) { '/tmp/log' }
         let (:relpath) { 'log' }
 
         it_behaves_like "file destination"
 
         it "logs an error if it can't chown the file owner & group" do
-          allow(File).to receive(:exist?).with(parent).and_return(true)
-          expect(File).to receive(:exist?).with(Pathname.new(abspath)).and_return(false)
+          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}")
@@ -63,8 +61,7 @@ describe Puppet::Util::Log.desttypes[:file] do
         end
 
         it "doesn't attempt to chown when running as non-root" do
-          allow(File).to receive(:exist?).with(parent).and_return(true)
-          expect(File).to receive(:exist?).with(Pathname.new(abspath)).and_return(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)
 
@@ -72,8 +69,7 @@ describe Puppet::Util::Log.desttypes[:file] do
         end
 
         it "doesn't attempt to chown when file already exists" do
-          allow(File).to receive(:exist?).with(parent).and_return(true)
-          expect(File).to receive(:exist?).with(Pathname.new(abspath)).and_return(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)
 

data/spec/unit/util/log_spec.rb

@@ -177,6 +177,144 @@ 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 option is passed' 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
+
+    context "global options" do
+      around :each do |example|
+        Puppet[:trace] = true
+        example.run
+        Puppet[:trace] = false
+      end
+
+      it 'includes backtrace for RuntimeError in log message when trace is enabled globally' 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)
+          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
+    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(/ \(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
+      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(/ \(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 Puppet::Util::Log::DestConsole do

data/spec/unit/util/logging_spec.rb

@@ -13,39 +13,6 @@ class LoggingTester
   include Puppet::Util::Logging
 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
-end
-
 describe Puppet::Util::Logging do
   before do
     @logger = LoggingTester.new
@@ -373,173 +340,6 @@ original
 .*2\.rb:2:in `b'
 .*3\.rb:1/)
     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
-    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')
-      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
-      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
-      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
-      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)
-      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)
-      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

data/spec/unit/util/pidlock_spec.rb

@@ -26,18 +26,6 @@ describe Puppet::Util::Pidlock, if: !Puppet::Util::Platform.jruby? do
         allow(Puppet::Util::Windows::Process).to receive(:get_process_image_name_by_pid).with(@lock.lock_pid).and_return('C:\Program Files\Puppet Labs\Puppet\puppet\bin\ruby.exe')
       else
         allow(Puppet::Util::Execution).to receive(:execute).with(['ps', '-p', @lock.lock_pid, '-o', 'comm=']).and_return('puppet')
-        allow(Puppet::Util::Execution).to receive(:execute).with(['ps', '-p', @lock.lock_pid, '-o', 'args=']).and_return('puppet')
-      end
-      expect(@lock).to be_locked
-    end
-
-    it "should become locked if puppet is a gem" do
-      @lock.lock
-      unless Puppet::Util::Platform.windows?
-        expect(Puppet::Util::Execution).to receive(:execute).with(['ps', '-p', @lock.lock_pid, '-o', 'comm=']).and_return('ruby')
-        expect(Puppet::Util::Execution).to receive(:execute).with(['ps', '-p', @lock.lock_pid, '-o', 'args=']).and_return('ruby /root/puppet/.bundle/ruby/2.3.0/bin/puppet agent --no-daemonize -v')
-      else
-        allow(Puppet::Util::Windows::Process).to receive(:get_process_image_name_by_pid).with(@lock.lock_pid).and_return('C:\tools\ruby25\bin\ruby.exe')
       end
       expect(@lock).to be_locked
     end
@@ -121,18 +109,6 @@ describe Puppet::Util::Pidlock, if: !Puppet::Util::Platform.jruby? do
         allow(Puppet::Util::Windows::Process).to receive(:get_process_image_name_by_pid).with(@lock.lock_pid).and_return('C:\Program Files\Puppet Labs\Puppet\puppet\bin\ruby.exe')
       else
         allow(Puppet::Util::Execution).to receive(:execute).with(['ps', '-p', @lock.lock_pid, '-o', 'comm=']).and_return('puppet')
-        allow(Puppet::Util::Execution).to receive(:execute).with(['ps', '-p', @lock.lock_pid, '-o', 'args=']).and_return('puppet')
-      end
-      expect(@lock).to be_locked
-    end
-
-    it "should return true if locked when puppet as gem" do
-      @lock.lock
-      unless Puppet::Util::Platform.windows?
-        expect(Puppet::Util::Execution).to receive(:execute).with(['ps', '-p', @lock.lock_pid, '-o', 'comm=']).and_return('ruby')
-        expect(Puppet::Util::Execution).to receive(:execute).with(['ps', '-p', @lock.lock_pid, '-o', 'args=']).and_return('ruby /root/puppet/.bundle/ruby/2.3.0/bin/puppet agent --no-daemonize -v')
-      else
-        allow(Puppet::Util::Windows::Process).to receive(:get_process_image_name_by_pid).with(@lock.lock_pid).and_return('C:\tools\ruby25\bin\ruby.exe')
       end
       expect(@lock).to be_locked
     end
@@ -183,7 +159,6 @@ describe Puppet::Util::Pidlock, if: !Puppet::Util::Platform.jruby? do
           allow(Puppet::Util::Windows::Process).to receive(:get_process_image_name_by_pid).with(6789).and_return('C:\Program Files\Puppet Labs\Puppet\puppet\bin\ruby.exe')
         else
           allow(Puppet::Util::Execution).to receive(:execute).with(['ps', '-p', 6789, '-o', 'comm=']).and_return('puppet')
-          allow(Puppet::Util::Execution).to receive(:execute).with(['ps', '-p', 6789, '-o', 'args=']).and_return('puppet')
         end
         @lock.lock
         expect(Puppet::FileSystem.exist?(@lockfile)).to be_truthy
@@ -213,7 +188,6 @@ describe Puppet::Util::Pidlock, if: !Puppet::Util::Platform.jruby? do
         allow(Puppet::Util::Windows::Process).to receive(:get_process_image_name_by_pid).with(1234).and_return('C:\Program Files\Puppet Labs\Puppet\puppet\bin\ruby.exe')
       else
         allow(Puppet::Util::Execution).to receive(:execute).with(['ps', '-p', 1234, '-o', 'comm=']).and_return('puppet')
-        allow(Puppet::Util::Execution).to receive(:execute).with(['ps', '-p', 1234, '-o', 'args=']).and_return('puppet')
       end
       # lock the file
       @lock.lock