puppet 6.15.0-x64-mingw32 → 6.19.1-x64-mingw32

data/spec/unit/util/command_line_spec.rb

@@ -62,7 +62,7 @@ describe Puppet::Util::CommandLine do
       it "should print the version and exit if #{arg} is given" do
         expect do
           described_class.new("puppet", [arg]).execute
-        end.to have_printed(/^#{Regexp.escape(Puppet.version)}$/)
+        end.to output(/^#{Regexp.escape(Puppet.version)}$/).to_stdout
       end
     end
 
@@ -73,7 +73,8 @@ describe Puppet::Util::CommandLine do
 
         expect {
           commandline.execute
-        }.to have_printed(/Usage: puppet <subcommand> \[options\] <action> \[options\]/).and_exit_with(0)
+        }.to exit_with(0)
+         .and output(/Usage: puppet <subcommand> \[options\] <action> \[options\]/).to_stdout
       end
     end
 
@@ -95,7 +96,8 @@ describe Puppet::Util::CommandLine do
 
       expect {
         commandline.execute
-      }.to have_printed(/Usage: puppet <subcommand> \[options\] <action> \[options\]/).and_exit_with(0)
+      }.to exit_with(0)
+       .and output(/Usage: puppet <subcommand> \[options\] <action> \[options\]/).to_stdout
     end
   end
 
@@ -124,7 +126,8 @@ describe Puppet::Util::CommandLine do
 
           expect {
             commandline.execute
-          }.to have_printed(/Unknown Puppet subcommand 'whatever'/).and_exit_with(1)
+          }.to exit_with(1)
+           .and output(/Unknown Puppet subcommand 'whatever'/).to_stdout
         end
 
         it "should abort and show the help message" do
@@ -134,7 +137,8 @@ describe Puppet::Util::CommandLine do
 
           expect {
             commandline.execute
-          }.to have_printed(/See 'puppet help' for help on available puppet subcommands/).and_exit_with(1)
+          }.to exit_with(1)
+           .and output(/See 'puppet help' for help on available puppet subcommands/).to_stdout
         end
 
         %w{--version -V}.each do |arg|
@@ -145,7 +149,8 @@ describe Puppet::Util::CommandLine do
 
             expect {
               commandline.execute
-            }.to have_printed(%r[^#{Regexp.escape(Puppet.version)}$]).and_exit_with(1)
+            }.to exit_with(1)
+             .and output(%r[^#{Regexp.escape(Puppet.version)}$]).to_stdout
           end
         end
       end

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/package/version/range_spec.rb

@@ -34,12 +34,33 @@ describe Puppet::Util::Package::Version::Range do
       expect { Puppet::Util::Package::Version::Range.parse('=a', IntegerVersion) }.to raise_error(Puppet::Util::Package::Version::Range::ValidationFailure)
     end
     it 'should raise if operator cannot be parsed' do
-      expect { Puppet::Util::Package::Version::Range.parse('~=a', IntegerVersion) }.to raise_error(Puppet::Util::Package::Version::Range::ValidationFailure)
+      expect { Puppet::Util::Package::Version::Range.parse('~=a', IntegerVersion) }.to raise_error(IntegerVersion::ValidationFailure)
     end
     it 'should raise if version cannot be parsed' do
       expect { Puppet::Util::Package::Version::Range.parse('>=a', IntegerVersion) }.to raise_error(IntegerVersion::ValidationFailure)
     end
   end
+
+  context 'when creating new version range with regular version' do
+    it 'it does not include greater version' do
+      vr = Puppet::Util::Package::Version::Range.parse('3', IntegerVersion)
+      v = IntegerVersion.parse('4')
+      expect(vr.include?(v)).to eql(false)
+    end
+
+    it 'it includes specified version' do
+      vr = Puppet::Util::Package::Version::Range.parse('3', IntegerVersion)
+      v = IntegerVersion.parse('3')
+      expect(vr.include?(v)).to eql(true)
+    end
+
+    it 'it does not include lower version' do
+      vr = Puppet::Util::Package::Version::Range.parse('3', IntegerVersion)
+      v = IntegerVersion.parse('2')
+      expect(vr.include?(v)).to eql(false)
+    end
+  end
+
   context 'when creating new version range with greater or equal operator' do
     it 'it includes greater version' do
       vr = Puppet::Util::Package::Version::Range.parse('>=3', IntegerVersion)

data/spec/unit/util/run_mode_spec.rb

@@ -25,12 +25,12 @@ describe Puppet::Util::RunMode do
         as_non_root { expect(@run_mode.conf_dir).to eq(File.expand_path('~/.puppetlabs/etc/puppet')) }
       end
 
-      context "master run mode" do
+      context "server run mode" do
         before do
-          @run_mode = Puppet::Util::UnixRunMode.new('master')
+          @run_mode = Puppet::Util::UnixRunMode.new('server')
         end
 
-        it "has confdir ~/.puppetlabs/etc/puppet when run as non-root and master run mode" do
+        it "has confdir ~/.puppetlabs/etc/puppet when run as non-root and server run mode" do
           as_non_root { expect(@run_mode.conf_dir).to eq(File.expand_path('~/.puppetlabs/etc/puppet')) }
         end
       end
@@ -53,12 +53,12 @@ describe Puppet::Util::RunMode do
         as_non_root { expect(@run_mode.code_dir).to eq(File.expand_path('~/.puppetlabs/etc/code')) }
       end
 
-      context "master run mode" do
+      context "server run mode" do
         before do
-          @run_mode = Puppet::Util::UnixRunMode.new('master')
+          @run_mode = Puppet::Util::UnixRunMode.new('server')
         end
 
-        it "has codedir ~/.puppetlabs/etc/code when run as non-root and master run mode" do
+        it "has codedir ~/.puppetlabs/etc/code when run as non-root and server run mode" do
           as_non_root { expect(@run_mode.code_dir).to eq(File.expand_path('~/.puppetlabs/etc/code')) }
         end
       end

data/spec/unit/util/windows/api_types_spec.rb

@@ -4,62 +4,86 @@ require 'spec_helper'
 
 describe "FFI::MemoryPointer", :if => Puppet::Util::Platform.windows? do
   # use 2 bad bytes at end so we have even number of bytes / characters
-  let (:bad_string) { "hello invalid world".encode(Encoding::UTF_16LE) + "\xDD\xDD".force_encoding(Encoding::UTF_16LE) }
-  let (:bad_string_bytes) { bad_string.bytes.to_a }
+  let(:bad_string) { "hello invalid world".encode(Encoding::UTF_16LE) + "\xDD\xDD".force_encoding(Encoding::UTF_16LE) }
+  let(:bad_string_bytes) { bad_string.bytes.to_a }
+  let(:a_wide_bytes) { "A".encode(Encoding::UTF_16LE).bytes.to_a }
+  let(:b_wide_bytes) { "B".encode(Encoding::UTF_16LE).bytes.to_a }
 
   context "read_wide_string" do
     let (:string) { "foo_bar" }
 
     it "should properly roundtrip a given string" do
-      read_string = nil
       FFI::MemoryPointer.from_string_to_wide_string(string) do |ptr|
-        read_string = ptr.read_wide_string(string.length)
+        expect(ptr.read_wide_string(string.length)).to eq(string)
       end
-
-      expect(read_string).to eq(string)
     end
 
     it "should return a given string in UTF-8" do
-      read_string = nil
       FFI::MemoryPointer.from_string_to_wide_string(string) do |ptr|
         read_string = ptr.read_wide_string(string.length)
+        expect(read_string.encoding).to eq(Encoding::UTF_8)
       end
-
-      expect(read_string.encoding).to eq(Encoding::UTF_8)
     end
 
     it "should raise an error and emit a debug message when receiving a string containing invalid bytes in the destination encoding" do
-      # enable a debug output sink to local string array
-      Puppet.debug = true
-      arraydest = []
-      Puppet::Util::Log.newdestination(Puppet::Test::LogCollector.new(arraydest))
-
-      read_string = nil
+      Puppet[:log_level] = 'debug'
 
       expect {
         FFI::MemoryPointer.new(:byte, bad_string_bytes.count) do |ptr|
           # uchar here is synonymous with byte
           ptr.put_array_of_uchar(0, bad_string_bytes)
 
-          read_string = ptr.read_wide_string(bad_string.length)
+          ptr.read_wide_string(bad_string.length)
         end
       }.to raise_error(Encoding::InvalidByteSequenceError)
 
-      expect(read_string).to be_nil
-      expect(arraydest.last.message).to eq("Unable to convert value #{bad_string.dump} to encoding UTF-8 due to #<Encoding::InvalidByteSequenceError: \"\\xDD\\xDD\" on UTF-16LE>")
+      expect(@logs.last.message).to eq("Unable to convert value #{bad_string.dump} to encoding UTF-8 due to #<Encoding::InvalidByteSequenceError: \"\\xDD\\xDD\" on UTF-16LE>")
     end
 
     it "should not raise an error when receiving a string containing invalid bytes in the destination encoding, when specifying :invalid => :replace" do
-      read_string = nil
-
       FFI::MemoryPointer.new(:byte, bad_string_bytes.count) do |ptr|
         # uchar here is synonymous with byte
         ptr.put_array_of_uchar(0, bad_string_bytes)
 
-        read_string = ptr.read_wide_string(bad_string.length, Encoding::UTF_8, :invalid => :replace)
+        read_string = ptr.read_wide_string(bad_string.length, Encoding::UTF_8, false, :invalid => :replace)
+        expect(read_string).to eq("hello invalid world\uFFFD")
       end
+    end
 
-      expect(read_string).to eq("hello invalid world\uFFFD")
+    it "raises an IndexError if asked to read more characters than there are bytes allocated" do
+      expect {
+        FFI::MemoryPointer.new(:byte, 1) do |ptr|
+          ptr.read_wide_string(1) # 1 wchar = 2 bytes
+        end
+      }.to raise_error(IndexError, /out of bounds/)
+    end
+
+    it "raises an IndexError if asked to read a negative number of characters" do
+      expect {
+        FFI::MemoryPointer.new(:byte, 1) do |ptr|
+          ptr.read_wide_string(-1)
+        end
+      }.to raise_error(IndexError, /out of bounds/)
+    end
+
+    it "returns an empty string if asked to read 0 characters" do
+      FFI::MemoryPointer.new(:byte, 1) do |ptr|
+        expect(ptr.read_wide_string(0)).to eq("")
+      end
+    end
+
+    it "returns a substring if asked to read fewer characters than are in the byte array" do
+      FFI::MemoryPointer.new(:byte, 4) do |ptr|
+        ptr.write_array_of_uint8("AB".encode('UTF-16LE').bytes.to_a)
+        expect(ptr.read_wide_string(1)).to eq("A")
+      end
+    end
+
+    it "preserves wide null characters in the string" do
+      FFI::MemoryPointer.new(:byte, 6) do |ptr|
+        ptr.write_array_of_uint8(a_wide_bytes + [0, 0] + b_wide_bytes)
+        expect(ptr.read_wide_string(3)).to eq("A\x00B")
+      end
     end
   end
 
@@ -69,52 +93,92 @@ describe "FFI::MemoryPointer", :if => Puppet::Util::Platform.windows? do
     let (:double_null_string) { string + "\x00\x00" }
 
     it "should read a short single null terminated string" do
-      read_string = nil
       FFI::MemoryPointer.from_string_to_wide_string(single_null_string) do |ptr|
-        read_string = ptr.read_arbitrary_wide_string_up_to()
+        expect(ptr.read_arbitrary_wide_string_up_to).to eq(string)
       end
-
-      expect(read_string).to eq(string)
     end
 
     it "should read a short double null terminated string" do
-      read_string = nil
       FFI::MemoryPointer.from_string_to_wide_string(double_null_string) do |ptr|
-        read_string = ptr.read_arbitrary_wide_string_up_to(512, :double_null)
+        expect(ptr.read_arbitrary_wide_string_up_to(512, :double_null)).to eq(string)
       end
+    end
+
+    it "detects trailing single null wchar" do
+      FFI::MemoryPointer.from_string_to_wide_string(single_null_string) do |ptr|
+        expect(ptr).to receive(:read_wide_string).with(string.length, anything, anything, anything).and_call_original
 
-      expect(read_string).to eq(string)
+        expect(ptr.read_arbitrary_wide_string_up_to).to eq(string)
+      end
     end
 
-    it "should return a string of max_length characters when specified" do
-      read_string = nil
+    it "detects trailing double null wchar" do
+      FFI::MemoryPointer.from_string_to_wide_string(double_null_string) do |ptr|
+        expect(ptr).to receive(:read_wide_string).with(string.length, anything, anything, anything).and_call_original
+
+        expect(ptr.read_arbitrary_wide_string_up_to(512, :double_null)).to eq(string)
+      end
+    end
+
+    it "should raises an IndexError if max_length is negative" do
+      FFI::MemoryPointer.from_string_to_wide_string(single_null_string) do |ptr|
+        expect {
+          ptr.read_arbitrary_wide_string_up_to(-1)
+        }.to raise_error(IndexError, /out of bounds/)
+      end
+    end
+
+    it "should return an empty string when the max_length is 0" do
       FFI::MemoryPointer.from_string_to_wide_string(single_null_string) do |ptr|
-        read_string = ptr.read_arbitrary_wide_string_up_to(3)
+        expect(ptr.read_arbitrary_wide_string_up_to(0)).to eq("")
       end
+    end
 
-      expect(read_string).to eq(string[0..2])
+    it "should return a string of max_length characters when specified" do
+      FFI::MemoryPointer.from_string_to_wide_string(single_null_string) do |ptr|
+        expect(ptr.read_arbitrary_wide_string_up_to(3)).to eq(string[0..2])
+      end
     end
 
     it "should return wide strings in UTF-8" do
-      read_string = nil
       FFI::MemoryPointer.from_string_to_wide_string(string) do |ptr|
-        read_string = ptr.read_arbitrary_wide_string_up_to()
+        read_string = ptr.read_arbitrary_wide_string_up_to
+        expect(read_string.encoding).to eq(Encoding::UTF_8)
       end
-
-      expect(read_string.encoding).to eq(Encoding::UTF_8)
     end
 
     it "should not raise an error when receiving a string containing invalid bytes in the destination encoding, when specifying :invalid => :replace" do
-      read_string = nil
-
       FFI::MemoryPointer.new(:byte, bad_string_bytes.count) do |ptr|
         # uchar here is synonymous with byte
         ptr.put_array_of_uchar(0, bad_string_bytes)
 
         read_string = ptr.read_arbitrary_wide_string_up_to(ptr.size / 2, :single_null, :invalid => :replace)
+        expect(read_string).to eq("hello invalid world\uFFFD")
+      end
+    end
+
+    it "should raise an IndexError if there isn't a null terminator" do
+      # This only works when using a memory pointer with a known number of cells
+      # and size per cell, but not arbitrary Pointers
+      FFI::MemoryPointer.new(:wchar, 1) do |ptr|
+        ptr.write_array_of_uint8(a_wide_bytes)
+
+        expect {
+          ptr.read_arbitrary_wide_string_up_to(42)
+        }.to raise_error(IndexError, /out of bounds/)
       end
+    end
+
+    it "should raise an IndexError if there isn't a double null terminator" do
+      # This only works when using a memory pointer with a known number of cells
+      # and size per cell, but not arbitrary Pointers
+      FFI::MemoryPointer.new(:wchar, 1) do |ptr|
+        ptr.write_array_of_uint8(a_wide_bytes)
 
-      expect(read_string).to eq("hello invalid world\uFFFD")
+        expect {
+          ptr.read_arbitrary_wide_string_up_to(42, :double_null)
+        }.to raise_error(IndexError, /out of bounds/)
+      end
     end
   end
 end

data/spec/unit/util/windows/service_spec.rb

@@ -599,27 +599,27 @@ describe "Puppet::Util::Windows::Service", :if => Puppet.features.microsoft_wind
     end
   end
 
-  describe "#set_startup_mode" do
+  describe "#set_startup_configuration" do
     let(:status_checks) { sequence('status_checks') }
 
     context "when the service control manager cannot be opened" do
       let(:scm) { FFI::Pointer::NULL_HANDLE }
       it "raises a puppet error" do
-        expect{ subject.set_startup_mode(mock_service_name, :SERVICE_DEMAND_START) }.to raise_error(Puppet::Error)
+        expect{ subject.set_startup_configuration(mock_service_name, options: {startup_type: :SERVICE_DEMAND_START}) }.to raise_error(Puppet::Error)
       end
     end
 
     context "when the service cannot be opened" do
       let(:service) { FFI::Pointer::NULL_HANDLE }
       it "raises a puppet error" do
-        expect{ subject.set_startup_mode(mock_service_name, :SERVICE_DEMAND_START) }.to raise_error(Puppet::Error)
+        expect{ subject.set_startup_configuration(mock_service_name, options: {startup_type: :SERVICE_DEMAND_START}) }.to raise_error(Puppet::Error)
       end
     end
 
     context "when the service can be opened" do
       it "Raises an error on an unsuccessful change" do
         expect(subject).to receive(:ChangeServiceConfigW).and_return(FFI::WIN32_FALSE)
-        expect{ subject.set_startup_mode(mock_service_name, :SERVICE_DEMAND_START) }.to raise_error(Puppet::Error)
+        expect{ subject.set_startup_configuration(mock_service_name, options: {startup_type: :SERVICE_DEMAND_START}) }.to raise_error(Puppet::Error)
       end
     end
   end

data/spec/unit/util_spec.rb

@@ -299,11 +299,11 @@ describe Puppet::Util do
       expect(uri.to_s.encoding).to eq(expected_encoding)
       expect(uri.path).to eq("/foo+foo%20bar")
       # either + or %20 is correct for an encoded space in query
-      # + is usually used for backward compatibility, but %20 is preferred for compat with Uri.unescape
+      # + is usually used for backward compatibility, but %20 is preferred for compat with Puppet::Util.uri_unescape
       expect(uri.query).to eq("foo%2Bfoo%20bar")
       # complete roundtrip
-      expect(URI.unescape(uri.to_s).sub(%r{^file:(//)?}, '')).to eq(path)
-      expect(URI.unescape(uri.to_s).encoding).to eq(expected_encoding)
+      expect(Puppet::Util.uri_unescape(uri.to_s).sub(%r{^file:(//)?}, '')).to eq(path)
+      expect(Puppet::Util.uri_unescape(uri.to_s).encoding).to eq(expected_encoding)
     end
 
     it "should perform UTF-8 URI escaping" do

data/spec/unit/x509/cert_provider_spec.rb

@@ -5,7 +5,7 @@ describe Puppet::X509::CertProvider do
   include PuppetSpec::Files
 
   def create_provider(options)
-    described_class.new(options)
+    described_class.new(**options)
   end
 
   def expects_public_file(path)

data/tasks/manpages.rake

@@ -1,27 +1,17 @@
-# require 'fileutils'
-
 desc "Build Puppet manpages"
 task :gen_manpages do
   require 'puppet/face'
   require 'fileutils'
 
-  # TODO: this line is unfortunate.  In an ideal world, faces would serve
-  #  as a clear, well-defined entry-point into the code and could be
-  #  responsible for state management all on their own; this really should
-  #  not be necessary.  When we can, we should get rid of it.
-  #  --cprice 2012-05-16
-  Puppet.initialize_settings()
-
+  Puppet.initialize_settings
   helpface = Puppet::Face[:help, '0.0.1']
-  manface  = Puppet::Face[:man, '0.0.1']
 
-  sbins = Dir.glob(%w{sbin/*})
   bins  = Dir.glob(%w{bin/*})
   non_face_applications = helpface.legacy_applications
   faces = Puppet::Face.faces.map(&:to_s)
   apps = non_face_applications + faces
 
-  ronn_args = '--manual="Puppet manual" --organization="Puppet, Inc." -r'
+  ronn_args = '--manual="Puppet manual" --organization="Puppet, Inc." --roff'
 
   # Locate ronn
   begin
@@ -35,14 +25,6 @@ task :gen_manpages do
     abort("Ronn does not appear to be installed")
   end
 
-#   def write_manpage(text, filename)
-#     IO.popen("#{ronn} #{ronn_args} -r > #{filename}") do |fh| fh.write text end
-#   end
-
-  # Create puppet.conf.5 man page
-#   IO.popen("#{ronn} #{ronn_args} > ./man/man5/puppet.conf.5", 'w') do |fh|
-#     fh.write %x{RUBYLIB=./lib:$RUBYLIB bin/puppetdoc --reference configuration}
-#   end
   %x{mkdir -p ./man/man5 ./man/man8}
   %x{RUBYLIB=./lib:$RUBYLIB bin/puppet doc --reference configuration > ./man/man5/puppetconf.5.ronn}
   %x{#{ronn} #{ronn_args} ./man/man5/puppetconf.5.ronn}
@@ -50,31 +32,19 @@ task :gen_manpages do
   FileUtils.rm("./man/man5/puppetconf.5.ronn")
 
   # Create LEGACY binary man pages (i.e. delete me for 2.8.0)
-  binary = bins + sbins
-  binary.each do |bin|
+  bins.each do |bin|
     b = bin.gsub( /^s?bin\//, "")
     %x{RUBYLIB=./lib:$RUBYLIB #{bin} --help > ./man/man8/#{b}.8.ronn}
     %x{#{ronn} #{ronn_args} ./man/man8/#{b}.8.ronn}
     FileUtils.rm("./man/man8/#{b}.8.ronn")
   end
 
-  # Create regular non-face man pages
-  non_face_applications.each do |app|
-    %x{RUBYLIB=./lib:$RUBYLIB bin/puppet #{app} --help > ./man/man8/puppet-#{app}.8.ronn}
+  apps.each do |app|
+    %x{RUBYLIB=./lib:$RUBYLIB bin/puppet help #{app} --ronn > ./man/man8/puppet-#{app}.8.ronn}
     %x{#{ronn} #{ronn_args} ./man/man8/puppet-#{app}.8.ronn}
     FileUtils.rm("./man/man8/puppet-#{app}.8.ronn")
   end
 
-  # Create face man pages
-  faces.each do |face|
-    File.open("./man/man8/puppet-#{face}.8.ronn", 'w') do |fh|
-      fh.write manface.man("#{face}")
-    end
-
-    %x{#{ronn} #{ronn_args} ./man/man8/puppet-#{face}.8.ronn}
-    FileUtils.rm("./man/man8/puppet-#{face}.8.ronn")
-  end
-
   # Delete orphaned manpages if binary was deleted
   Dir.glob(%w{./man/man8/puppet-*.8}) do |app|
     appname = app.match(/puppet-(.*)\.8/)[1]