puppet 5.5.20-x64-mingw32 → 5.5.21-x64-mingw32

data/spec/unit/test/test_helper_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe "TestHelper" do
+  context "#after_each_test" do
+    it "restores the original environment" do
+      varname = 'test_helper_spec-test_variable'
+      Puppet::Util.set_env(varname, "\u16A0")
+
+      expect(Puppet::Util.get_env(varname)).to eq("\u16A0")
+
+      # Prematurely trigger the after_each_test method
+      Puppet::Test::TestHelper.after_each_test
+
+      expect(Puppet::Util::get_env(varname)).to be_nil
+    end
+  end
+end

data/spec/unit/type/service_spec.rb

@@ -234,20 +234,21 @@ describe Puppet::Type.type(:service), "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
@@ -484,22 +484,20 @@ describe Puppet::Type.type(:user) do
     end
 
     context "with no home directory specified" do
-      it "should not accept true" do
-        expect {
-          described_class.new(:name => "a", :purge_ssh_keys => true)
-        }.to raise_error(Puppet::Error, /purge_ssh_keys can only be true for users with a defined home directory/)
+      before(:each) do
+        allow(Dir).to receive(:home).with('a').and_return('/home/a')
       end
 
-      it "should not accept the ~ wildcard" do
-        expect {
-          described_class.new(:name => "a", :purge_ssh_keys => "~/keys")
-        }.to raise_error(Puppet::Error, /meta character ~ or %h only allowed for users with a defined home directory/)
+      it "should accept true" do
+        described_class.new(:name => "a", :purge_ssh_keys => true)
       end
 
-      it "should not accept the %h wildcard" do
-        expect {
-          described_class.new(:name => "a", :purge_ssh_keys => "%h/keys")
-        }.to raise_error(Puppet::Error, /meta character ~ or %h only allowed for users with a defined home directory/)
+      it "should accept the ~ wildcard" do
+        described_class.new(:name => "a", :purge_ssh_keys => "~/keys")
+      end
+
+      it "should accept the %h wildcard" do
+        described_class.new(:name => "a", :purge_ssh_keys => "%h/keys")
       end
     end
 
@@ -508,6 +506,10 @@ describe Puppet::Type.type(:user) do
         [ "/dev/null", "/tmp/keyfile" ].map { |path| File.expand_path(path) }
       end
 
+      before(:each) do
+        allow(Dir).to receive(:home).with('test').and_return('/home/test')
+      end
+
       subject do
         res = described_class.new(:name => "test", :purge_ssh_keys => paths)
         res.catalog = Puppet::Resource::Catalog.new
@@ -534,6 +536,10 @@ describe Puppet::Type.type(:user) do
         res
       end
 
+      before(:each) do
+        allow(Dir).to receive(:home).with('test_user_name').and_return('/home/test_user_name')
+      end
+
       context "when purging is disabled" do
         let(:purge_param) { false }
 

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/windows/api_types_spec.rb

@@ -4,62 +4,86 @@ require 'spec_helper'
 
 describe "FFI::MemoryPointer", :if => Puppet.features.microsoft_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.features.microsoft_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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: puppet
 version: !ruby/object:Gem::Version
-  version: 5.5.20
+  version: 5.5.21
 platform: x64-mingw32
 authors:
 - Puppet Labs
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-04-29 00:00:00.000000000 Z
+date: 2020-07-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: facter
@@ -1800,7 +1800,7 @@ files:
 - spec/fixtures/unit/provider/mount/parsed/solaris.fstab
 - spec/fixtures/unit/provider/mount/parsed/solaris.mount
 - spec/fixtures/unit/provider/naginator/define_empty_param
-- spec/fixtures/unit/provider/package/dnfmodule/dnf-module-list-enabled.txt
+- spec/fixtures/unit/provider/package/dnfmodule/dnf-module-list.txt
 - spec/fixtures/unit/provider/package/gem/gem-list-single-package
 - spec/fixtures/unit/provider/package/gem/line-with-1.8.5-warning
 - spec/fixtures/unit/provider/package/openbsd/pkginfo.detail
@@ -1942,7 +1942,6 @@ files:
 - spec/integration/ssl/certificate_revocation_list_spec.rb
 - spec/integration/ssl/host_spec.rb
 - spec/integration/ssl/key_spec.rb
-- spec/integration/test/test_helper_spec.rb
 - spec/integration/transaction/report_spec.rb
 - spec/integration/transaction_spec.rb
 - spec/integration/type/exec_spec.rb
@@ -2615,6 +2614,7 @@ files:
 - spec/unit/ssl/validator_spec.rb
 - spec/unit/status_spec.rb
 - spec/unit/task_spec.rb
+- spec/unit/test/test_helper_spec.rb
 - spec/unit/transaction/additional_resource_generator_spec.rb
 - spec/unit/transaction/event_manager_spec.rb
 - spec/unit/transaction/event_spec.rb
@@ -2789,7 +2789,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: 1.3.1
 requirements: []
-rubygems_version: 3.0.6
+rubygems_version: 3.0.8
 signing_key: 
 specification_version: 4
 summary: Puppet, an automated configuration management tool
@@ -3119,7 +3119,7 @@ test_files:
 - spec/fixtures/unit/provider/mount/parsed/solaris.fstab
 - spec/fixtures/unit/provider/mount/parsed/solaris.mount
 - spec/fixtures/unit/provider/naginator/define_empty_param
-- spec/fixtures/unit/provider/package/dnfmodule/dnf-module-list-enabled.txt
+- spec/fixtures/unit/provider/package/dnfmodule/dnf-module-list.txt
 - spec/fixtures/unit/provider/package/gem/gem-list-single-package
 - spec/fixtures/unit/provider/package/gem/line-with-1.8.5-warning
 - spec/fixtures/unit/provider/package/openbsd/pkginfo.detail
@@ -3261,7 +3261,6 @@ test_files:
 - spec/integration/ssl/certificate_revocation_list_spec.rb
 - spec/integration/ssl/host_spec.rb
 - spec/integration/ssl/key_spec.rb
-- spec/integration/test/test_helper_spec.rb
 - spec/integration/transaction/report_spec.rb
 - spec/integration/transaction_spec.rb
 - spec/integration/type/exec_spec.rb
@@ -3934,6 +3933,7 @@ test_files:
 - spec/unit/ssl/validator_spec.rb
 - spec/unit/status_spec.rb
 - spec/unit/task_spec.rb
+- spec/unit/test/test_helper_spec.rb
 - spec/unit/transaction/additional_resource_generator_spec.rb
 - spec/unit/transaction/event_manager_spec.rb
 - spec/unit/transaction/event_spec.rb

data/spec/integration/test/test_helper_spec.rb

@@ -1,31 +0,0 @@
-require 'spec_helper'
-
-describe "Windows UTF8 environment variables", :if => Puppet.features.microsoft_windows? do
-  # The Puppet::Util::Windows::Process class is used to manipulate environment variables as it is known to handle UTF8 characters. Where as the implementation of ENV in ruby does not.
-  # before and end all are used to inject environment variables before the test helper 'before_each_test' function is called
-  # Do not use before and after hooks in these tests as it may have unintended consequences
-
-  before(:all) {
-    @varname = 'test_helper_spec-test_variable'
-    @rune_utf8 = "\u16A0\u16C7\u16BB\u16EB\u16D2\u16E6\u16A6\u16EB\u16A0\u16B1\u16A9\u16A0\u16A2\u16B1\u16EB\u16A0\u16C1\u16B1\u16AA\u16EB\u16B7\u16D6\u16BB\u16B9\u16E6\u16DA\u16B3\u16A2\u16D7"
-
-    Puppet::Util::Windows::Process.set_environment_variable(@varname, @rune_utf8)
-  }
-  after(:all) {
-    # Need to cleanup this environment variable otherwise it contaminates any subsequent tests
-    Puppet::Util::Windows::Process.set_environment_variable(@varname, nil)
-  }
-
-  it "#after_each_test should preserve UTF8 environment variables" do
-    envhash = Puppet::Util::Windows::Process.get_environment_strings
-    expect(envhash[@varname]).to eq(@rune_utf8)
-    # Change the value in the test to force test_helper to restore the environment
-    ENV[@varname] = 'bad foo'
-
-    # Prematurely trigger the after_each_test method
-    Puppet::Test::TestHelper.after_each_test
-
-    envhash = Puppet::Util::Windows::Process.get_environment_strings
-    expect(envhash[@varname]).to eq(@rune_utf8)
-  end
-end