puppet 6.11.1-x64-mingw32 → 6.16.0-x64-mingw32

data/spec/unit/type/package_spec.rb

@@ -30,6 +30,10 @@ describe Puppet::Type.type(:package) do
     expect(Puppet::Type.type(:package).provider_feature(:versionable)).not_to be_nil
   end
 
+  it "should have a :supports_flavors feature" do
+    expect(Puppet::Type.type(:package).provider_feature(:supports_flavors)).not_to be_nil
+  end
+
   it "should have a :package_settings feature that requires :package_settings_insync?, :package_settings and :package_settings=" do
     expect(Puppet::Type.type(:package).provider_feature(:package_settings).methods).to eq([:package_settings_insync?, :package_settings, :package_settings=])
   end
@@ -53,6 +57,10 @@ describe Puppet::Type.type(:package) do
     it "should have a package_settings property" do
       expect(Puppet::Type.type(:package).attrtype(:package_settings)).to eq(:property)
     end
+
+    it "should have a flavor property" do
+      expect(Puppet::Type.type(:package).attrtype(:flavor)).to eq(:property)
+    end
   end
 
   describe "when validating attribute values" do

data/spec/unit/type/service_spec.rb

@@ -284,20 +284,21 @@ describe test_title, "when changing the host" do
     @service.property(:enable).sync
   end
 
-  it "should always consider the enable state of a static service to be in sync" do
+  it "should let superclass implementation resolve insyncness when provider does not respond to the 'enabled_insync?' method" do
     allow(@service.provider.class).to receive(:supports_parameter?).and_return(true)
-    expect(@service.provider).to receive(:cached_enabled?).and_return('static')
-    @service[:enable] = false
-    expect(Puppet).to receive(:debug).with("Unable to enable or disable static service yay")
+    @service[:enable] = true
+    allow(@service.provider).to receive(:respond_to?).with(:enabled_insync?).and_return(false)
+
     expect(@service.property(:enable).insync?(:true)).to eq(true)
   end
 
-  it "should determine insyncness normally when the service is not static" do
+  it "insyncness should be resolved by provider instead of superclass implementation when provider responds to the 'enabled_insync?' method" do
     allow(@service.provider.class).to receive(:supports_parameter?).and_return(true)
-    expect(@service.provider).to receive(:cached_enabled?).and_return('true')
     @service[:enable] = true
-    expect(Puppet).not_to receive(:debug)
-    expect(@service.property(:enable).insync?(:true)).to eq(true)
+    allow(@service.provider).to receive(:respond_to?).with(:enabled_insync?).and_return(true)
+    allow(@service.provider).to receive(:enabled_insync?).and_return(false)
+
+    expect(@service.property(:enable).insync?(:true)).to eq(false)
   end
 
   it "should sync the service's enable state when changing the state of :ensure if :enable is being managed" do

data/spec/unit/type/user_spec.rb

@@ -1,4 +1,4 @@
-# encoding: UTF-8
+# encoding: utf-8
 require 'spec_helper'
 
 describe Puppet::Type.type(:user) do
@@ -408,7 +408,6 @@ describe Puppet::Type.type(:user) do
       Puppet::Resource::Catalog.new :testing do |conf|
         [testuser, testrole].each { |resource| conf.add_resource resource }
       end
-      allow(Puppet::Type::User::ProviderDirectoryservice).to receive(:get_macosx_version_major).and_return("10.5")
 
       rel = testuser.autorequire[0]
       expect(rel.source.ref).to eq(testrole.ref)

data/spec/unit/util/at_fork_spec.rb

@@ -5,6 +5,7 @@ describe 'Puppet::Util::AtFork' do
 
   before :each do
     Puppet::Util.class_exec do
+      remove_const(:AtFork) if defined?(Puppet::Util::AtFork)
       const_set(:AtFork, Module.new)
     end
   end
@@ -18,7 +19,7 @@ describe 'Puppet::Util::AtFork' do
   describe '.get_handler' do
     context 'when on Solaris' do
       before :each do
-        expect(Facter).to receive(:value).with(:operatingsystem).and_return('Solaris')
+        expect(Puppet::Util::Platform).to receive(:solaris?).and_return(true)
       end
 
       after :each do
@@ -113,7 +114,7 @@ describe 'Puppet::Util::AtFork' do
 
     context 'when NOT on Solaris' do
       before :each do
-        expect(Facter).to receive(:value).with(:operatingsystem).and_return(nil)
+        expect(Puppet::Util::Platform).to receive(:solaris?).and_return(false)
       end
 
       def stub_noop_handler(namespace_only = false)

data/spec/unit/util/autoload_spec.rb

@@ -23,10 +23,10 @@ describe Puppet::Util::Autoload do
 
     def with_libdir(libdir)
       begin
-        Puppet::Util::Autoload.instance_variable_set(:@initialized, false)
         old_loadpath = $LOAD_PATH.dup
         old_libdir = Puppet[:libdir]
         Puppet[:libdir] = libdir
+        $LOAD_PATH.unshift(libdir)
         yield
       ensure
         Puppet[:libdir] = old_libdir
@@ -83,6 +83,7 @@ describe Puppet::Util::Autoload do
 
       libdir = File.expand_path('/libdir1')
       Puppet[:vendormoduledir] = vendor_dir
+      Puppet.initialize_settings
 
       with_libdir(libdir) do
         expect(@autoload.class).to receive(:gem_directories).and_return(%w{/one /two})

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

@@ -44,41 +44,13 @@ describe Puppet::Util::Log.desttypes[:file] do
       end
     end
 
-    describe "on POSIX systems", :if => Puppet.features.posix? do
+    describe "on POSIX systems", :unless => Puppet::Util::Platform.windows? 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(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}")
-
-          @class.new(abspath)
-        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(FileUtils).not_to receive(:chown).with(Puppet[:user], Puppet[:group], abspath)
-          expect(Puppet.features).to receive(:root?).and_return(false)
-
-          @class.new(abspath)
-        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(FileUtils).not_to receive(:chown).with(Puppet[:user], Puppet[:group], abspath)
-          expect(Puppet.features).to receive(:root?).and_return(true)
-
-          @class.new(abspath)
-        end
       end
 
       describe "with a JSON file" do

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