puppet 6.11.1 → 6.12.0

data/spec/unit/provider/package_targetable_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+require 'puppet'
+require 'puppet/provider/package_targetable'
+require 'puppet/provider/package/gem'
+
+describe Puppet::Provider::Package::Targetable do
+  let(:provider) { Puppet::Type.type(:package).provider(:gem) }
+  let(:command)  { '/opt/bin/gem' }
+
+  describe "when prefetching" do
+    context "with a package without a command attribute" do
+      let(:resource) { Puppet::Type.type(:package).new(:name => 'noo', :provider => 'gem', :ensure => :present) }
+      let(:catalog)  { Puppet::Resource::Catalog.new }
+      let(:instance) { provider.new(resource) }
+      let(:packages) { { 'noo' => resource } }
+
+      it "should pass a command to the instances method of the provider" do
+        catalog.add_resource(resource)
+        expect(provider).to receive(:instances).with(nil).and_return([instance])
+        expect(provider.prefetch(packages)).to eq([nil]) # prefetch arbitrarily returns the array of commands for a provider in the catalog
+      end
+    end
+
+    context "with a package with a command attribute" do
+      let(:resource) { Puppet::Type.type(:package).new(:name => 'noo', :provider => 'gem', :ensure => :present) }
+      let(:resource_targeted) { Puppet::Type.type(:package).new(:name => 'yes', :provider => 'gem', :command => command, :ensure => :present) }
+      let(:catalog)  { Puppet::Resource::Catalog.new }
+      let(:instance) { provider.new(resource) }
+      let(:instance_targeted) { provider.new(resource_targeted) }
+      let(:packages) { { 'noo' => resource, 'yes' => resource_targeted } }
+
+      it "should pass the command to the instances method of the provider" do
+        catalog.add_resource(resource)
+        catalog.add_resource(resource_targeted)
+        expect(provider).to receive(:instances).with(nil).and_return([instance])
+        expect(provider).to receive(:instances).with(command).and_return([instance_targeted]).once
+        expect(provider.prefetch(packages)).to eq([nil, command]) # prefetch arbitrarily returns the array of commands for a provider in the catalog
+      end
+    end
+  end
+
+  describe "when validating a command" do
+    context "with no command" do
+      it "report not functional" do
+        expect { provider.validate_command(nil) }.to raise_error(Puppet::Error, "Provider gem package command is not functional on this host")
+      end
+    end
+    context "with a missing command" do
+      it "report does not exist" do
+        expect { provider.validate_command(command) }.to raise_error(Puppet::Error, "Provider gem package command '#{command}' does not exist on this host")
+      end
+    end
+    context "with an existing command" do
+      it "validates" do
+        allow(File).to receive(:file?).with(command).and_return(true)
+        expect { provider.validate_command(command) }.not_to raise_error
+      end
+    end
+  end
+end

data/spec/unit/provider/user/hpux_spec.rb

@@ -58,14 +58,14 @@ describe Puppet::Type.type(:user).provider(:hpuxuseradd),
     it "should add modprpw to modifycmd if Trusted System" do
       allow(resource).to receive(:allowdupe?).and_return(true)
       expect(provider).to receive(:exec_getprpw).with('root','-m uid').and_return('uid=0')
-      expect(provider).to receive(:execute).with(['/usr/sam/lbin/usermod.sam', '-u', 1000, '-o', 'testuser', '-F', ';', '/usr/lbin/modprpw', '-v', '-l', 'testuser'], hash_including(custom_environment: {}))
+      expect(provider).to receive(:execute).with(['/usr/sam/lbin/usermod.sam', '-F', '-u', 1000, '-o', 'testuser', ';', '/usr/lbin/modprpw', '-v', '-l', 'testuser'], hash_including(custom_environment: {}))
       provider.uid = 1000
     end
 
     it "should not add modprpw if not Trusted System" do
       allow(resource).to receive(:allowdupe?).and_return(true)
       expect(provider).to receive(:exec_getprpw).with('root','-m uid').and_return('System is not trusted')
-      expect(provider).to receive(:execute).with(['/usr/sam/lbin/usermod.sam', '-u', 1000, '-o', 'testuser', '-F'], hash_including(custom_environment: {}))
+      expect(provider).to receive(:execute).with(['/usr/sam/lbin/usermod.sam', '-F', '-u', 1000, '-o', 'testuser'], hash_including(custom_environment: {}))
       provider.uid = 1000
     end
   end

data/spec/unit/ssl/ssl_provider_spec.rb

@@ -73,6 +73,67 @@ describe Puppet::SSL::SSLProvider do
         sslctx.verify_peer = false
       }.to raise_error(/can't modify frozen/)
     end
+
+    it 'verifies peer' do
+      sslctx = subject.create_root_context(config)
+      expect(sslctx.verify_peer).to eq(true)
+    end
+  end
+
+  context 'when creating a system ssl context' do
+    it 'accepts empty list of CA certs' do
+      sslctx = subject.create_system_context(cacerts: [])
+      expect(sslctx.cacerts).to eq([])
+    end
+
+    it 'accepts valid root certs' do
+      certs = [cert_fixture('ca.pem')]
+      sslctx = subject.create_system_context(cacerts: certs)
+      expect(sslctx.cacerts).to eq(certs)
+    end
+
+    it 'accepts valid intermediate certs' do
+      certs = [cert_fixture('ca.pem'), cert_fixture('intermediate.pem')]
+      sslctx = subject.create_system_context(cacerts: certs)
+      expect(sslctx.cacerts).to eq(certs)
+    end
+
+    it 'accepts expired CA certs' do
+      expired = [cert_fixture('ca.pem'), cert_fixture('intermediate.pem')]
+      expired.each { |x509| x509.not_after = Time.at(0) }
+
+      sslctx = subject.create_system_context(cacerts: expired)
+      expect(sslctx.cacerts).to eq(expired)
+    end
+
+    it 'raises if the frozen context is modified' do
+      sslctx = subject.create_system_context(cacerts: [])
+      expect {
+        sslctx.verify_peer = false
+      }.to raise_error(/can't modify frozen/)
+    end
+
+    it 'trusts system ca store' do
+      expect_any_instance_of(OpenSSL::X509::Store).to receive(:set_default_paths)
+
+      subject.create_system_context(cacerts: [])
+    end
+
+    it 'verifies peer' do
+      sslctx = subject.create_system_context(cacerts: [])
+      expect(sslctx.verify_peer).to eq(true)
+    end
+
+    it 'disable revocation' do
+      sslctx = subject.create_system_context(cacerts: [])
+      expect(sslctx.revocation).to eq(false)
+    end
+
+    it 'sets client cert and private key to nil' do
+      sslctx = subject.create_system_context(cacerts: [])
+      expect(sslctx.client_cert).to be_nil
+      expect(sslctx.private_key).to be_nil
+    end
   end
 
   context 'when creating an ssl context with crls' do
@@ -99,6 +160,11 @@ describe Puppet::SSL::SSLProvider do
       sslctx = subject.create_root_context(config.merge(crls: expired))
       expect(sslctx.crls).to eq(expired)
     end
+
+    it 'verifies peer' do
+      sslctx = subject.create_root_context(config)
+      expect(sslctx.verify_peer).to eq(true)
+    end
   end
 
   context 'when creating an ssl context with client certs' do
@@ -345,6 +411,11 @@ describe Puppet::SSL::SSLProvider do
         sslctx.verify_peer = false
       }.to raise_error(/can't modify frozen/)
     end
+
+    it 'verifies peer' do
+      sslctx = subject.create_context(config)
+      expect(sslctx.verify_peer).to eq(true)
+    end
   end
 
   context 'when loading an ssl context' do

data/spec/unit/transaction_spec.rb

@@ -3,6 +3,7 @@ require 'matchers/include_in_order'
 require 'puppet_spec/compiler'
 
 require 'puppet/transaction'
+require 'puppet/type/exec'
 require 'puppet/type/notify'
 require 'fileutils'
 
@@ -967,6 +968,51 @@ describe Puppet::Transaction do
       expect(times_send_log_with_skipping_called).to eq(3)
     end
   end
+
+  describe "failed dependency is depended on multiple times" do
+    it "notifies and warns the failed class dependency once" do
+      Puppet.settings[:merge_dependency_warnings] = true
+
+      command_string = File.expand_path('/my/command')
+      allow(Puppet::Util::Execution).to receive(:execute).with([command_string]).and_raise(Puppet::ExecutionFailure, "Failed")
+
+      # Exec['exec1'] is outside of a class, so it's warning is not subject to being coalesced.
+      times_send_log_with_skipping_called = 0
+      allow_any_instance_of(Puppet::Type::Exec).to receive(:send_log) {times_send_log_with_skipping_called += 1; nil}.with(:warning, "Skipping because of failed dependencies")
+
+      # Class['declared_class'] depends upon Class['required_class'] which contains a resource with a failure.
+      times_send_log_with_class_dependency_called = 0
+      allow_any_instance_of(Puppet::Type).to receive(:send_log) {times_send_log_with_class_dependency_called += 1; nil}.with(:notice, "Class dependency Exec[exec2] has failures: true")
+      times_send_log_with_class_skipping_called = 0
+      allow_any_instance_of(Puppet::Type).to receive(:send_log) {times_send_log_with_class_skipping_called += 1; nil}.with(:warning, "Skipping resources in class because of failed class dependencies")
+
+      apply_compiled_manifest(<<-MANIFEST)
+        class required_class {
+          exec { 'exec2':
+            command => '#{command_string}'
+          }
+        }
+        class declared_class {
+          require required_class
+          exec { 'exec3':
+            command => '#{command_string}'
+          }
+          exec { 'exec4':
+            command => '#{command_string}'
+          }
+        }
+        exec { 'exec1':
+          command => '#{command_string}',
+          require => Exec['exec2']
+        }
+        include declared_class
+      MANIFEST
+
+      expect(times_send_log_with_skipping_called).to eq(1)
+      expect(times_send_log_with_class_dependency_called).to eq(1)
+      expect(times_send_log_with_class_skipping_called).to eq(1)
+    end
+  end
 end
 
 describe Puppet::Transaction, " when determining tags" do

data/spec/unit/type/file/content_spec.rb

@@ -200,15 +200,21 @@ describe Puppet::Type.type(:file).attrclass(:content), :uses_checksums => true d
             end
 
             it "prints the diff" do
-              expect(content).to receive(:diff).and_return("my diff").once
-              expect(content).to receive(:debug).with("\nmy diff").once
+              expect(content).to receive(:diff).and_return("my diff")
+              expect(content).to receive(:debug).with("\nmy diff")
+              expect(content).not_to be_safe_insync("other content")
+            end
+
+            it "prints binary file notice if diff is not valid encoding" do
+              expect(content).to receive(:diff).and_return("\xc7\xd1\xfc\x84")
+              expect(content).to receive(:debug).with(/\nBinary files #{filename} and .* differ/)
               expect(content).not_to be_safe_insync("other content")
             end
 
             it "redacts the diff when the property is sensitive" do
               content.sensitive = true
               expect(content).not_to receive(:diff)
-              expect(content).to receive(:debug).with("[diff redacted]").once
+              expect(content).to receive(:debug).with("[diff redacted]")
               expect(content).not_to be_safe_insync("other content")
             end
           end

data/spec/unit/util/log_spec.rb

@@ -177,144 +177,6 @@ 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,6 +13,39 @@ 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
@@ -340,6 +373,173 @@ 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