puppet 4.10.0 → 5.0.0

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

@@ -612,6 +612,19 @@ describe Puppet::Type.type(:file).attrclass(:source), :uses_checksums => true do
         resource.write(source)
       end
 
+      it 'should request binary content' do
+        response.stubs(:code).returns('200')
+        Puppet::Network::HttpPool.stubs(:http_instance).returns(conn)
+        source.stubs(:metadata).returns stub_everything('metadata', :source => 'puppet:///test/foo bar', :ftype => 'file')
+
+        conn.unstub(:request_get)
+        conn.expects(:request_get).with do |_, options|
+          expect(options).to include('Accept' => 'application/octet-stream')
+        end.yields(response)
+
+        resource.write(source)
+      end
+
       describe 'when handling file_content responses' do
         before do
           File.open(filename, 'w') {|f| f.write "initial file content"}

data/spec/unit/type/file_spec.rb

@@ -1415,6 +1415,52 @@ describe Puppet::Type.type(:file) do
     end
   end
 
+  describe 'when using source' do
+    # different UTF-8 widths
+    # 1-byte A
+    # 2-byte ۿ - http://www.fileformat.info/info/unicode/char/06ff/index.htm - 0xDB 0xBF / 219 191
+    # 3-byte ᚠ - http://www.fileformat.info/info/unicode/char/16A0/index.htm - 0xE1 0x9A 0xA0 / 225 154 160
+    # 4-byte <U+070E> - http://www.fileformat.info/info/unicode/char/2070E/index.htm - 0xF0 0xA0 0x9C 0x8E / 240 160 156 142
+    let (:mixed_utf8) { "A\u06FF\u16A0\u{2070E}" } # Aۿᚠ<U+070E>
+
+    it 'should allow UTF-8 characters and return a UTF-8 uri' do
+      filename = "/bar #{mixed_utf8}"
+      source = "puppet://foo#{filename}"
+      file[:source] = source
+
+      # intercept the indirector call to provide back mocked metadata for the given URI
+      metadata = stub 'metadata', :source => source
+      metadata.expects(:source=)
+      Puppet::FileServing::Metadata.indirection.expects(:find).with do |path, opts|
+        path == source
+      end.returns metadata
+
+      uri = file.parameters[:source].uri
+      expect(URI.unescape(uri.path)).to eq(filename)
+      expect(uri.path.encoding).to eq(Encoding::UTF_8)
+    end
+
+    it 'should allow UTF-8 characters inside the indirector / terminus code' do
+      filename = "/bar #{mixed_utf8}"
+      source = "puppet://foo#{filename}"
+      file[:source] = source
+
+      # for this test to properly trigger previously errant behavior, the code for
+      # Puppet::FileServing::Metadata.indirection.find must run and produce an
+      # instance of Puppet::Indirector::FileMetadata::Rest that can be amended
+      metadata = stub 'metadata', :source => source
+      metadata.expects(:source=)
+      require 'puppet/indirector/file_metadata/rest'
+      Puppet::Indirector::FileMetadata::Rest.any_instance.expects(:find).with do |req|
+        req.key == filename[1..-1]
+      end.returns(metadata)
+
+      uri = file.parameters[:source].uri
+      expect(URI.unescape(uri.path)).to eq(filename)
+      expect(uri.path.encoding).to eq(Encoding::UTF_8)
+    end
+  end
+
   describe "when using source" do
     before do
       file[:source] = File.expand_path('/one')

data/spec/unit/type/ssh_authorized_key_spec.rb

@@ -149,12 +149,12 @@ describe Puppet::Type.type(:ssh_authorized_key), :unless => Puppet.features.micr
 
       it "property should return well formed string of arrays from is_to_s" do
         resource = described_class.new(:name => "whev", :type => :rsa, :user => "nobody", :options => ["a","b","c"])
-        expect(resource.property(:options).is_to_s(["a","b","c"])).to eq "a,b,c"
+        expect(resource.property(:options).is_to_s(["a","b","c"])).to eq "['a', 'b', 'c']"
       end
 
       it "property should return well formed string of arrays from should_to_s" do
         resource = described_class.new(:name => "whev", :type => :rsa, :user => "nobody", :options => ["a","b","c"])
-        expect(resource.property(:options).should_to_s(["a","b","c"])).to eq "a,b,c"
+        expect(resource.property(:options).should_to_s(["a","b","c"])).to eq "['a', 'b', 'c']"
       end
 
     end

data/spec/unit/type/user_spec.rb

@@ -369,8 +369,7 @@ describe Puppet::Type.type(:user) do
             is.force_encoding(Encoding::ASCII_8BIT)
             should.force_encoding(Encoding::UTF_8)
             expect(Encoding.compatible?(is, should)).to be_falsey
-            # append Regexp with 'n' to set encoding to ASCII_8BIT
-            expect(comment_property.change_to_s(is,should)).to match(/changed '\xE2\x98\x83' to '\xDB\xBF'/n)
+            expect(comment_property.change_to_s(is,should)).to match(/changed '\u{E2}\u{98}\u{83}' to '\u{DB}\u{BF}'/)
           end
         end
 
@@ -379,8 +378,7 @@ describe Puppet::Type.type(:user) do
             is.force_encoding(Encoding::UTF_8)
             should.force_encoding(Encoding::UTF_8)
             expect(Encoding.compatible?(is, should)).to be_truthy
-            # append Regexp with 'u' to set encoding to UTF_8
-            expect(comment_property.change_to_s(is,should)).to match(/changed '\u2603' to '\u06FF'/u)
+            expect(comment_property.change_to_s(is,should)).to match(/changed '\u{2603}' to '\u{6FF}'/u)
           end
         end
       end

data/spec/unit/util/at_fork_spec.rb

@@ -0,0 +1,150 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+
+describe 'Puppet::Util::AtFork' do
+  EXPECTED_HANDLER_METHODS = [:prepare, :parent, :child]
+
+  before :each do
+    Puppet::Util.class_exec do
+      const_set(:AtFork, Module.new)
+    end
+  end
+
+  after :each do
+    Puppet::Util.class_exec do
+      remove_const(:AtFork)
+    end
+  end
+
+  describe '.get_handler' do
+    context 'when on Solaris' do
+      before :each do
+        Facter.expects(:value).with(:operatingsystem).returns('Solaris')
+      end
+
+      after :each do
+        Object.class_exec do
+          remove_const(:Fiddle) if const_defined?(:Fiddle)
+        end
+      end
+
+      def stub_solaris_handler(stub_noop_too = false)
+        Puppet::Util::AtFork.stubs(:require).with() do |lib|
+          if lib == 'puppet/util/at_fork/solaris'
+            load lib + '.rb'
+            true
+          elsif stub_noop_too && lib == 'puppet/util/at_fork/noop'
+            Puppet::Util::AtFork.class_exec do
+              const_set(:Noop, Class.new)
+            end
+            true
+          else
+            false
+          end
+        end.returns(true)
+
+        unless stub_noop_too
+          Object.class_exec do
+            const_set(:Fiddle, Module.new do
+              const_set(:TYPE_VOIDP, nil)
+              const_set(:TYPE_VOID,  nil)
+              const_set(:TYPE_INT,   nil)
+              const_set(:DLError,    Class.new(StandardError))
+              const_set(:Handle,     Class.new)
+              const_set(:Function,   Class.new)
+            end)
+          end
+        end
+
+        TOPLEVEL_BINDING.eval('self').stubs(:require).with() do |lib|
+          if lib == 'fiddle'
+            raise LoadError, 'no fiddle' if stub_noop_too
+          else
+            Kernel.require lib
+          end
+          true
+        end.returns(true)
+      end
+
+      it %q(should return the Solaris specific AtFork handler) do
+        Puppet::Util::AtFork.stubs(:require).with() do |lib|
+          if lib == 'puppet/util/at_fork/solaris'
+            Puppet::Util::AtFork.class_exec do
+              const_set(:Solaris, Class.new)
+            end
+            true
+          else
+            false
+          end
+        end.returns(true)
+        load 'puppet/util/at_fork.rb'
+        expect(Puppet::Util::AtFork.get_handler.class).to eq(Puppet::Util::AtFork::Solaris)
+      end
+
+      it %q(should return the Noop handler when Fiddle could not be loaded) do
+        stub_solaris_handler(true)
+        load 'puppet/util/at_fork.rb'
+        expect(Puppet::Util::AtFork.get_handler.class).to eq(Puppet::Util::AtFork::Noop)
+      end
+
+      it %q(should fail when libcontract cannot be loaded) do
+        stub_solaris_handler
+        Fiddle::Handle.expects(:new).with(regexp_matches(/^libcontract.so.*/)).raises(Fiddle::DLError, 'no such library')
+        expect { load 'puppet/util/at_fork.rb' }.to raise_error(Fiddle::DLError, 'no such library')
+      end
+
+      it %q(should fail when libcontract doesn't define all the necessary functions) do
+        stub_solaris_handler
+        handle = stub('Fiddle::Handle')
+        Fiddle::Handle.expects(:new).with(regexp_matches(/^libcontract.so.*/)).returns(handle)
+        handle.expects(:[]).raises(Fiddle::DLError, 'no such method')
+        expect { load 'puppet/util/at_fork.rb' }.to raise_error(Fiddle::DLError, 'no such method')
+      end
+
+      it %q(the returned Solaris specific handler should respond to the expected methods) do
+        stub_solaris_handler
+        handle = stub('Fiddle::Handle')
+        Fiddle::Handle.expects(:new).with(regexp_matches(/^libcontract.so.*/)).returns(handle)
+        handle.stubs(:[]).returns(nil)
+        Fiddle::Function.stubs(:new).returns(Proc.new {})
+        load 'puppet/util/at_fork.rb'
+        expect(Puppet::Util::AtFork.get_handler.public_methods).to include(*EXPECTED_HANDLER_METHODS)
+      end
+    end
+
+    context 'when NOT on Solaris' do
+      before :each do
+        Facter.expects(:value).with(:operatingsystem).returns(nil)
+      end
+
+      def stub_noop_handler(namespace_only = false)
+        Puppet::Util::AtFork.stubs(:require).with() do |lib|
+          if lib == 'puppet/util/at_fork/noop'
+            if namespace_only
+              Puppet::Util::AtFork.class_exec do
+                const_set(:Noop, Class.new)
+              end
+            else
+              load lib + '.rb'
+            end
+            true
+          else
+            false
+          end
+        end.returns(true)
+      end
+
+      it %q(should return the Noop AtFork handler) do
+        stub_noop_handler(true)
+        load 'puppet/util/at_fork.rb'
+        expect(Puppet::Util::AtFork.get_handler.class).to eq(Puppet::Util::AtFork::Noop)
+      end
+
+      it %q(the returned Noop handler should respond to the expected methods) do
+        stub_noop_handler
+        load 'puppet/util/at_fork.rb'
+        expect(Puppet::Util::AtFork.get_handler.public_methods).to include(*EXPECTED_HANDLER_METHODS)
+      end
+    end
+  end
+end

data/spec/unit/util/character_encoding_spec.rb

@@ -1,14 +1,20 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/util/character_encoding'
+require 'puppet_spec/character_encoding'
 
 describe Puppet::Util::CharacterEncoding do
-  describe "::convert_to_utf_8!" do
+  describe "::convert_to_utf_8" do
     context "when passed a string that is already UTF-8" do
       context "with valid encoding" do
-        it "should return the string unaltered" do
-          utf8_string = "\u06FF\u2603"
-          expect(Puppet::Util::CharacterEncoding.convert_to_utf_8!(utf8_string)).to eq(utf8_string)
+        let(:utf8_string) { "\u06FF\u2603".force_encoding(Encoding::UTF_8) }
+
+        it "should return the string unmodified" do
+          expect(Puppet::Util::CharacterEncoding.convert_to_utf_8(utf8_string)).to eq("\u06FF\u2603".force_encoding(Encoding::UTF_8))
+        end
+
+        it "should not mutate the original string" do
+          expect(utf8_string).to eq("\u06FF\u2603".force_encoding(Encoding::UTF_8))
         end
       end
 
@@ -16,73 +22,208 @@ describe Puppet::Util::CharacterEncoding do
         let(:invalid_utf8_string) { "\xfd\xf1".force_encoding(Encoding::UTF_8) }
 
         it "should issue a debug message" do
-          Puppet.expects(:debug).with(regexp_matches(/not valid UTF-8/))
-          Puppet::Util::CharacterEncoding.convert_to_utf_8!(invalid_utf8_string)
+          Puppet.expects(:debug).with(regexp_matches(/encoding is invalid/))
+          Puppet::Util::CharacterEncoding.convert_to_utf_8(invalid_utf8_string)
         end
 
-        it "should return nil" do
-          expect(Puppet::Util::CharacterEncoding.convert_to_utf_8!(invalid_utf8_string)).to be_nil
+        it "should return the string unmodified" do
+          expect(Puppet::Util::CharacterEncoding.convert_to_utf_8(invalid_utf8_string)).to eq("\xfd\xf1".force_encoding(Encoding::UTF_8))
+        end
+
+        it "should not mutate the original string" do
+          Puppet::Util::CharacterEncoding.convert_to_utf_8(invalid_utf8_string)
+          expect(invalid_utf8_string).to eq("\xfd\xf1".force_encoding(Encoding::UTF_8))
         end
       end
     end
 
-    context "when passed a string not in UTF-8 encoding" do
-      context "the bytes of which represent valid UTF-8" do
-        # I think this effectively what the ruby Etc module is doing when it
-        # returns strings read in from /etc/passwd and /etc/group
-        let(:iso_8859_1_string) { [225, 154, 160].pack('C*').force_encoding(Encoding::ISO_8859_1) }
-        let(:result) { Puppet::Util::CharacterEncoding.convert_to_utf_8!(iso_8859_1_string) }
+    context "when passed a string in BINARY encoding" do
+      context "that is valid in Encoding.default_external" do
+        # When received as BINARY are not transcodable, but by "guessing"
+        # Encoding.default_external can transcode to UTF-8
+        let(:win_31j) { [130, 187].pack('C*') } # pack('C*') returns string in BINARY
+
+        it "should be able to convert to UTF-8 by labeling as Encoding.default_external" do
+          # そ - HIRAGANA LETTER SO
+          # In Windows_31J: \x82 \xbb - 130 187
+          # In Unicode: \u305d - \xe3 \x81 \x9d - 227 129 157
+          result = PuppetSpec::CharacterEncoding.with_external_encoding(Encoding::Windows_31J) do
+            Puppet::Util::CharacterEncoding.convert_to_utf_8(win_31j)
+          end
+          expect(result).to eq("\u305d")
+          expect(result.bytes.to_a).to eq([227, 129, 157])
+        end
+
+        it "should not mutate the original string" do
+          PuppetSpec::CharacterEncoding.with_external_encoding(Encoding::Windows_31J) do
+            Puppet::Util::CharacterEncoding.convert_to_utf_8(win_31j)
+          end
+          expect(win_31j).to eq([130, 187].pack('C*'))
+        end
+      end
+
+      context "that is invalid in Encoding.default_external" do
+        let(:invalid_win_31j) { [255, 254, 253].pack('C*') } # these bytes are not valid windows_31j
 
-        it "should set external encoding to UTF-8" do
-          expect(result.encoding).to eq(Encoding::UTF_8)
+        it "should return the string umodified" do
+          result = PuppetSpec::CharacterEncoding.with_external_encoding(Encoding::Windows_31J) do
+            Puppet::Util::CharacterEncoding.convert_to_utf_8(invalid_win_31j)
+          end
+          expect(result.bytes.to_a).to eq([255, 254, 253])
+          expect(result.encoding).to eq(Encoding::BINARY)
         end
 
-        it "should not modify the bytes (transcode) the string" do
-          expect(result.bytes.to_a).to eq([225, 154, 160])
+        it "should not mutate the original string" do
+          PuppetSpec::CharacterEncoding.with_external_encoding(Encoding::Windows_31J) do
+            Puppet::Util::CharacterEncoding.convert_to_utf_8(invalid_win_31j)
+          end
+          expect(invalid_win_31j).to eq([255, 254, 253].pack('C*'))
+        end
+
+        it "should issue a debug message that the string was not transcodable" do
+          Puppet.expects(:debug).with(regexp_matches(/cannot be transcoded/))
+          PuppetSpec::CharacterEncoding.with_external_encoding(Encoding::Windows_31J) do
+            Puppet::Util::CharacterEncoding.convert_to_utf_8(invalid_win_31j)
+          end
         end
       end
 
-      context "the bytes of which do not represent valid UTF-8" do
-        it "should transcode the string to UTF-8 if it is transcodable" do
-          # http://www.fileformat.info/info/unicode/char/3050/index.htm
-          # ぐ - HIRAGANA LETTER GU
-          # In Shift_JIS: \x82 \xae - 130 174
-          # In Unicode: \u3050 - \xe3 \x81 \x90 - 227 129 144
-          # if we were only ruby > 2.3.0, we could do String.new("\x82\xae", :encoding => Encoding::Shift_JIS)
-          as_shift_jis = [130, 174].pack('C*').force_encoding(Encoding::Shift_JIS)
-          as_utf8 = "\u3050"
-
-          # this is not valid UTF-8
-          expect(as_shift_jis.dup.force_encoding(Encoding::UTF_8).valid_encoding?).to be_falsey
-
-          result = Puppet::Util::CharacterEncoding.convert_to_utf_8!(as_shift_jis)
-          expect(result).to eq(as_utf8)
-          # largely redundant but reinforces the point - this was transcoded:
-          expect(result.bytes.to_a).to eq([227, 129, 144])
+      context "Given a string labeled as neither UTF-8 nor BINARY" do
+        context "that is transcodable" do
+          let (:shift_jis) { [130, 174].pack('C*').force_encoding(Encoding::Shift_JIS) }
+
+          it "should return a copy of the string transcoded to UTF-8 if it is transcodable" do
+            # http://www.fileformat.info/info/unicode/char/3050/index.htm
+            # ぐ - HIRAGANA LETTER GU
+            # In Shift_JIS: \x82 \xae - 130 174
+            # In Unicode: \u3050 - \xe3 \x81 \x90 - 227 129 144
+            # if we were only ruby > 2.3.0, we could do String.new("\x82\xae", :encoding => Encoding::Shift_JIS)
+
+            result = Puppet::Util::CharacterEncoding.convert_to_utf_8(shift_jis)
+            expect(result).to eq("\u3050".force_encoding(Encoding::UTF_8))
+            # largely redundant but reinforces the point - this was transcoded:
+            expect(result.bytes.to_a).to eq([227, 129, 144])
+          end
+
+          it "should not mutate the original string" do
+            Puppet::Util::CharacterEncoding.convert_to_utf_8(shift_jis)
+            expect(shift_jis).to eq([130, 174].pack('C*').force_encoding(Encoding::Shift_JIS))
+          end
         end
 
-        context "if it is not transcodable" do
-          let(:as_ascii) { [254, 241].pack('C*').force_encoding(Encoding::ASCII) }
-          it "should issue a debug message and return nil if not transcodable" do
-            # An admittedly contrived case, but perhaps not so improbable
-            # http://www.fileformat.info/info/unicode/char/5e0c/index.htm
-            # 希 Han Character 'rare; hope, expect, strive for'
-            # In EUC_KR: \xfd \xf1 - 253 241
-            # In Unicode: \u5e0c - \xe5 \xb8 \x8c - 229 184 140
-
-            # If the original system value is in EUC_KR, and puppet (ruby) is run
-            # in ISO_8859_1, this value will be read in as ASCII, with invalid
-            # escape sequences in that encoding. It is also not valid unicode
-            # as-is. This scenario is one we can't recover from, so fail.
-            Puppet.expects(:debug).with(regexp_matches(/not valid UTF-8/))
-            Puppet::Util::CharacterEncoding.convert_to_utf_8!(as_ascii)
+        context "when not transcodable" do
+          # An admittedly contrived case, but perhaps not so improbable
+          # http://www.fileformat.info/info/unicode/char/5e0c/index.htm
+          # 希 Han Character 'rare; hope, expect, strive for'
+          # In EUC_KR: \xfd \xf1 - 253 241
+          # In Unicode: \u5e0c - \xe5 \xb8 \x8c - 229 184 140
+
+          # In this case, this EUC_KR character has been read in as ASCII and is
+          # invalid in that encoding. This would raise an EncodingError
+          # exception on transcode but we catch this issue a debug message -
+          # leaving the original string unaltered.
+          let(:euc_kr) { [253, 241].pack('C*').force_encoding(Encoding::ASCII) }
+
+          it "should issue a debug message" do
+            Puppet.expects(:debug).with(regexp_matches(/cannot be transcoded/))
+            Puppet::Util::CharacterEncoding.convert_to_utf_8(euc_kr)
+          end
+
+          it "should return the original string unmodified" do
+            result = Puppet::Util::CharacterEncoding.convert_to_utf_8(euc_kr)
+            expect(result).to eq([253, 241].pack('C*').force_encoding(Encoding::ASCII))
           end
 
-          it "should return nil" do
-            expect(Puppet::Util::CharacterEncoding.convert_to_utf_8!(as_ascii)).to be_nil
+          it "should not mutate the original string" do
+            Puppet::Util::CharacterEncoding.convert_to_utf_8(euc_kr)
+            expect(euc_kr).to eq([253, 241].pack('C*').force_encoding(Encoding::ASCII))
           end
         end
       end
     end
   end
+
+  describe "::override_encoding_to_utf_8" do
+    context "given a string with bytes that represent valid UTF-8" do
+      # ☃ - unicode snowman
+      # \u2603 - \xe2 \x98 \x83 - 226 152 131
+      let(:snowman) { [226, 152, 131].pack('C*') }
+
+      it "should return a copy of the string with external encoding of the string to UTF-8" do
+        result = Puppet::Util::CharacterEncoding.override_encoding_to_utf_8(snowman)
+        expect(result).to eq("\u2603")
+        expect(result.encoding).to eq(Encoding::UTF_8)
+      end
+
+      it "should not modify the original string" do
+        Puppet::Util::CharacterEncoding.override_encoding_to_utf_8(snowman)
+        expect(snowman).to eq([226, 152, 131].pack('C*'))
+      end
+    end
+
+    context "given a string with bytes that do not represent valid UTF-8" do
+      # Ø - Latin capital letter O with stroke
+      # In ISO-8859-1: \xd8 - 216
+      # Invalid in UTF-8 without transcoding
+      let(:oslash) { [216].pack('C*').force_encoding(Encoding::ISO_8859_1) }
+      let(:foo) { 'foo' }
+      it "should issue a debug message" do
+        Puppet.expects(:debug).with(regexp_matches(/not valid UTF-8/))
+        Puppet::Util::CharacterEncoding.override_encoding_to_utf_8(oslash)
+      end
+
+      it "should return the original string unmodified" do
+        result = Puppet::Util::CharacterEncoding.override_encoding_to_utf_8(oslash)
+        expect(result).to eq([216].pack('C*').force_encoding(Encoding::ISO_8859_1))
+      end
+
+      it "should not modify the string" do
+        Puppet::Util::CharacterEncoding.override_encoding_to_utf_8(oslash)
+        expect(oslash).to eq([216].pack('C*').force_encoding(Encoding::ISO_8859_1))
+      end
+    end
+  end
+
+  describe "::scrub" do
+    let(:utf_8_string_to_scrub) { "\xfdfoo".force_encoding(Encoding::UTF_8) } # invalid in UTF-8
+    # The invalid-ness of this string comes from unpaired surrogates, ie:
+    #  "any value in the range D80016 to DBFF16 not followed by a value in the
+    #  range DC0016 to DFFF16, or any value in the range DC0016 to DFFF16 not
+    #  preceded by a value in the range D80016 to DBFF16"
+    # http://unicode.org/faq/utf_bom.html#utf16-7
+    # "a\ud800b"
+    # We expect the "b" to be replaced as that is what makes the string invalid
+    let(:utf_16LE_string_to_scrub) { [97, 237, 160, 128, 98].pack('C*').force_encoding(Encoding::UTF_16LE) } # invalid in UTF-16
+    let(:invalid_non_utf) { "foo\u2603".force_encoding(Encoding::EUC_KR) } # EUC_KR foosnowman!
+
+    it "should defer to String#scrub if defined", :if => String.method_defined?(:scrub) do
+      result = Puppet::Util::CharacterEncoding.scrub(utf_8_string_to_scrub)
+      # The result should have the UTF-8 replacement character if we're using Ruby scrub
+      expect(result).to eq("\uFFFDfoo".force_encoding(Encoding::UTF_8))
+      expect(result.bytes.to_a).to eq([239, 191, 189, 102, 111, 111])
+    end
+
+    context "when String#scrub is not defined" do
+      it "should still issue unicode replacement characters if the string is UTF-8" do
+        utf_8_string_to_scrub.stubs(:respond_to?).with(:scrub).returns(false)
+        result = Puppet::Util::CharacterEncoding.scrub(utf_8_string_to_scrub)
+        expect(result).to eq("\uFFFDfoo".force_encoding(Encoding::UTF_8))
+      end
+
+      it "should still issue unicode replacement characters if the string is UTF-16LE" do
+        utf_16LE_string_to_scrub.stubs(:respond_to?).with(:scrub).returns(false)
+        result = Puppet::Util::CharacterEncoding.scrub(utf_16LE_string_to_scrub)
+        # Bytes of replacement character on UTF_16LE are [253, 255]
+        # We just check for bytes because something (ruby?) interprets this array of bytes as:
+        # (97) (237 160) (128 253 255) rather than (97) (237 160 128) (253 255)
+        expect(result).to eq([97, 237, 160, 128, 253, 255].pack('C*').force_encoding(Encoding::UTF_16LE))
+      end
+
+      it "should issue '?' characters if the string is not one of UTF_8 or UTF_16LE" do
+        invalid_non_utf.stubs(:respond_to?).with(:scrub).returns(false)
+        result = Puppet::Util::CharacterEncoding.scrub(invalid_non_utf)
+        expect(result).to eq("foo???".force_encoding(Encoding::EUC_KR))
+      end
+    end
+  end
 end

data/spec/unit/util/execution_spec.rb

@@ -675,8 +675,9 @@ describe Puppet::Util::Execution do
     it "should fail if asked to fail, and the child does" do
       Puppet::Util::Execution.stubs(:open).with('| echo hello 2>&1').returns('error message')
       Puppet::Util::Execution.expects(:exitstatus).returns(1)
-      expect { Puppet::Util::Execution.execpipe('echo hello') }.
-        to raise_error Puppet::ExecutionFailure, /error message/
+      expect {
+        Puppet::Util::Execution.execpipe('echo hello')
+      }.to raise_error Puppet::ExecutionFailure, /error message/
     end
 
     it "should not fail if asked not to fail, and the child does" do
@@ -684,4 +685,32 @@ describe Puppet::Util::Execution do
       expect(Puppet::Util::Execution.execpipe('echo hello', false)).to eq('error message')
     end
   end
+
+  describe "execfail" do
+    it "returns the executed command output" do
+      Puppet::Util::Execution.stubs(:execute).returns("process output")
+      expect(Puppet::Util::Execution.execfail('echo hello', Puppet::Error)).to eq('process output')
+    end
+
+    it "raises a caller-specified exception on failure with the backtrace" do
+      Puppet::Util::Execution.stubs(:execute).raises(Puppet::ExecutionFailure, "failed to execute")
+      expect {
+        Puppet::Util::Execution.execfail("this will fail", Puppet::Error)
+      }.to raise_error(Puppet::Error, /failed to execute/)
+    end
+
+    it "raises exceptions that don't extend ExecutionFailure" do
+      Puppet::Util::Execution.stubs(:execute).raises(ArgumentError, "failed to execute")
+      expect {
+        Puppet::Util::Execution.execfail("this will fail", Puppet::Error)
+      }.to raise_error(ArgumentError, /failed to execute/)
+    end
+
+    it "raises a TypeError if the exception class is nil" do
+      Puppet::Util::Execution.stubs(:execute).raises(Puppet::ExecutionFailure, "failed to execute")
+      expect {
+        Puppet::Util::Execution.execfail('echo hello', nil)
+      }.to raise_error(TypeError), /exception class\/object expected/
+    end
+  end
 end

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

@@ -133,7 +133,7 @@ describe Puppet::Util::Log.desttypes[:logstash_event] do
       dest = described_class.new
       result = dest.format(@msg)
       expect(result["version"]).to eq(1)
-      expect(result["level"]).to   eq(:info)
+      expect(result["level"]).to   eq('info')
       expect(result["message"]).to eq("So long, and thanks for all the fish.")
       expect(result["source"]).to  eq("a dolphin")
       # timestamp should be within 10 seconds
@@ -195,8 +195,8 @@ describe ":eventlog", :if => Puppet::Util::Platform.windows? do
 
   def expects_message_with_type(klass, level, eventlog_type, eventlog_id)
     eventlog = stub('eventlog')
-    eventlog.expects(:report_event).with(has_entries(:source => "Puppet", :event_type => eventlog_type, :event_id => eventlog_id, :data => "a hitchhiker: don't panic"))
-    Win32::EventLog.stubs(:open).returns(eventlog)
+    eventlog.expects(:report_event).with(has_entries(:event_type => eventlog_type, :event_id => eventlog_id, :data => "a hitchhiker: don't panic"))
+    Puppet::Util::Windows::EventLog.stubs(:open).returns(eventlog)
 
     msg = Puppet::Util::Log.new(:level => level, :message => "don't panic", :source => "a hitchhiker")
     dest = klass.new
@@ -207,9 +207,8 @@ describe ":eventlog", :if => Puppet::Util::Platform.windows? do
     expect(Puppet.features.eventlog?).to be_truthy
   end
 
-  it "logs to the Application event log" do
-    eventlog = stub('eventlog')
-    Win32::EventLog.expects(:open).with('Application').returns(stub('eventlog'))
+  it "logs to the Puppet Application event log" do
+    Puppet::Util::Windows::EventLog.expects(:open).with('Puppet').returns(stub('eventlog'))
 
     klass.new
   end