puppet 4.10.1-universal-darwin → 4.10.4-universal-darwin

data/lib/puppet/util/monkey_patches.rb

@@ -101,7 +101,9 @@ class OpenSSL::SSL::SSLContext
   else
     DEFAULT_PARAMS[:options] = OpenSSL::SSL::OP_NO_SSLv2 | OpenSSL::SSL::OP_NO_SSLv3
   end
-  DEFAULT_PARAMS[:ciphers] << ':!SSLv2'
+  if DEFAULT_PARAMS[:ciphers]
+    DEFAULT_PARAMS[:ciphers] << ':!SSLv2'
+  end
 
   alias __original_initialize initialize
   private :__original_initialize

data/lib/puppet/util/windows/api_types.rb

@@ -165,6 +165,9 @@ module Puppet::Util::Windows::APITypes
   # https://blogs.msdn.com/b/oldnewthing/archive/2011/03/28/10146459.aspx
   FFI.typedef :int32, :win32_bool
 
+  # BOOLEAN (unlike BOOL) is a BYTE - typedef unsigned char BYTE;
+  FFI.typedef :uchar, :boolean
+
   # Same as a LONG, a 32-bit signed integer
   FFI.typedef :int32, :hresult
 

data/lib/puppet/util/windows/file.rb

@@ -397,7 +397,7 @@ module Puppet::Util::Windows::File
   begin
     ffi_lib :kernel32
     attach_function_private :CreateSymbolicLinkW,
-      [:lpwstr, :lpwstr, :dword], :win32_bool
+      [:lpwstr, :lpwstr, :dword], :boolean
   rescue LoadError
   end
 

data/lib/puppet/version.rb

@@ -6,7 +6,7 @@
 # Raketasks and such to set the version based on the output of `git describe`
 
 module Puppet
-  PUPPETVERSION = '4.10.1'
+  PUPPETVERSION = '4.10.4'
 
   ##
   # version is a public API method intended to always provide a fast and

data/locales/puppet.pot

@@ -6,11 +6,11 @@
 #, fuzzy
 msgid ""
 msgstr ""
-"Project-Id-Version: Puppet automation framework 4.10.0-45-gb0ff2a9\n"
+"Project-Id-Version: Puppet automation framework 4.10.1-82-gd7074ee\n"
 "\n"
 "Report-Msgid-Bugs-To: https://tickets.puppetlabs.com\n"
-"POT-Creation-Date: 2017-04-18 09:07-0700\n"
-"PO-Revision-Date: 2017-04-18 09:07-0700\n"
+"POT-Creation-Date: 2017-05-25 21:24+0000\n"
+"PO-Revision-Date: 2017-05-25 21:24+0000\n"
 "Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
 "Language-Team: LANGUAGE <LL@li.org>\n"
 "Language: \n"
@@ -23,11 +23,11 @@ msgstr ""
 msgid "`puppet %{name}` is deprecated and will be removed in a future release."
 msgstr ""
 
-#: ../lib/puppet/defaults.rb:1698
+#: ../lib/puppet/defaults.rb:1720
 msgid "Setting 'archive_files' is deprecated. It will be removed in a future release along with the `inspect` command."
 msgstr ""
 
-#: ../lib/puppet/defaults.rb:1707
+#: ../lib/puppet/defaults.rb:1729
 msgid "Setting 'archive_file_server' is deprecated. It will be removed in a future release along with the `inspect` command."
 msgstr ""
 
@@ -106,6 +106,10 @@ msgstr ""
 msgid "! Subcommand unavailable due to error. Check error logs."
 msgstr ""
 
+#: ../lib/puppet/generate/models/type/type.rb:46
+msgid "title patterns that use procs are not supported."
+msgstr ""
+
 #: ../lib/puppet/indirector/file_bucket_file/file.rb:169
 msgid "Unable to verify existing FileBucket backup at '%{path}'."
 msgstr ""
@@ -118,6 +122,18 @@ msgstr ""
 msgid "Existing backup does not match its expected sum, %{sum}. Overwriting corrupted backup."
 msgstr ""
 
+#: ../lib/puppet/pops/lookup/environment_data_provider.rb:20
+msgid "hiera.yaml version 3 found at the environment root was ignored"
+msgstr ""
+
+#: ../lib/puppet/pops/lookup/module_data_provider.rb:69
+msgid "hiera.yaml version 3 found at module root was ignored"
+msgstr ""
+
+#: ../lib/puppet/provider/nameservice.rb:56
+msgid "listbyname is deprecated and will be removed in a future release of Puppet. Please use `self.instances` to obtain a list of users."
+msgstr ""
+
 #: ../lib/puppet/resource.rb:81
 msgid "Unable to deserialize non-Data value for parameter %{param} unless rich data is enabled"
 msgstr ""
@@ -130,8 +146,16 @@ msgstr ""
 msgid "The `audit` metaparameter is deprecated and will be ignored in a future release."
 msgstr ""
 
-#: ../lib/puppet/util/character_encoding.rb:75
-msgid "%{error}: %{value} is not valid UTF-8 and cannot be transcoded by Puppet."
+#: ../lib/puppet/util/character_encoding.rb:22
+msgid "%{value} is already labeled as UTF-8 but this encoding is invalid. It cannot be transcoded by Puppet."
+msgstr ""
+
+#: ../lib/puppet/util/character_encoding.rb:43
+msgid "%{error}: %{value} cannot be transcoded by Puppet."
+msgstr ""
+
+#: ../lib/puppet/util/character_encoding.rb:70
+msgid "%{value} is not valid UTF-8 and result of overriding encoding would be invalid."
 msgstr ""
 
 #. TRANSLATORS message accompanied by date of generation

data/spec/integration/faces/documentation_spec.rb

@@ -43,10 +43,10 @@ describe "documentation of faces" do
       ########################################################################
       # Ensure that we have authorship and copyright information in *our* faces;
       # if you apply this to third party faces you might well be disappointed.
-      context "licensing of Puppet Labs face '#{face_name}'" do
+      context "licensing of Puppet Inc. face '#{face_name}'" do
         subject { Puppet::Face[face_name, :current] }
         its :license   do should =~ /Apache\s*2/ end
-        its :copyright do should =~ /Puppet Labs|Puppet Inc\./ end
+        its :copyright do should =~ /Puppet Inc\./ end
 
         # REVISIT: This is less that ideal, I think, but right now I am more
         # comfortable watching us ship with some copyright than without any; we

data/spec/integration/parser/pcore_resource_spec.rb

@@ -57,6 +57,17 @@ describe 'when pcore described resources types are in use' do
               end
             end;end
             EOF
+            'test3.rb' => <<-RUBY,
+              Puppet::Type.newtype(:test3) do
+                newproperty(:message)
+                newparam(:a) { isnamevar }
+                newparam(:b) { isnamevar }
+                newparam(:c) { isnamevar }
+                def self.title_patterns
+                  [ [ /^((.+)\\/(.*))$/,  [[:a], [:b], [:c]]] ]
+                end
+              end
+            RUBY
             'cap.rb' => <<-EOF
             module Puppet
             Type.newtype(:cap, :is_capability => true) do
@@ -112,12 +123,16 @@ describe 'when pcore described resources types are in use' do
         test2 { 'b':
           message => 'b works'
         }
+        test3 { 'x/y':
+          message => 'x/y works'
+        }
         cap { 'c':
           message => 'c works'
         }
       MANIFEST
       expect(catalog.resource(:test1, "a")['message']).to eq('a works')
       expect(catalog.resource(:test2, "b")['message']).to eq('b works')
+      expect(catalog.resource(:test3, "x/y")['message']).to eq('x/y works')
       expect(catalog.resource(:cap, "c")['message']).to eq('c works')
     end
 

data/spec/integration/resource/type_collection_spec.rb

@@ -83,5 +83,11 @@ describe Puppet::Resource::TypeCollection do
       mk_module(name, :define => true, :mydefine => ["mymod::mydefine"])
       expect(@code.find_definition("mymod::mydefine").name).to eq("mymod::mydefine")
     end
+
+    it 'should be able to load definitions from their own file using uppercased name' do
+      name = 'mymod'
+      mk_module(name, :define => true, :mydefine => ['mymod::mydefine'])
+      expect(@code.find_definition('Mymod::Mydefine')).not_to be_nil
+    end
   end
 end

data/spec/lib/puppet/face/1.0.0/huzzah.rb

@@ -1,6 +1,6 @@
 require 'puppet/face'
 Puppet::Face.define(:huzzah, '1.0.0') do
-  copyright "Puppet Labs", 2011
+  copyright "Puppet Inc.", 2011
   license   "Apache 2 license; see COPYING"
   summary "life is a thing for celebration"
   action(:obsolete_in_core) { when_invoked { |_| "you are in obsolete core now!" } }

data/spec/lib/puppet/face/basetest.rb

@@ -1,7 +1,7 @@
 require 'puppet/face'
 
 Puppet::Face.define(:basetest, '0.0.1') do
-  copyright "Puppet Labs", 2011
+  copyright "Puppet Inc.", 2011
   license   "Apache 2 license; see COPYING"
   summary "This is just so tests don't fail"
 

data/spec/lib/puppet/face/huzzah.rb

@@ -1,6 +1,6 @@
 require 'puppet/face'
 Puppet::Face.define(:huzzah, '2.0.1') do
-  copyright "Puppet Labs", 2011
+  copyright "Puppet Inc.", 2011
   license   "Apache 2 license; see COPYING"
   summary "life is a thing for celebration"
   action(:bar) { when_invoked { |options| "is where beer comes from" } }

data/spec/lib/puppet/face/version_matching.rb

@@ -4,7 +4,7 @@ require 'puppet/face'
 # change this you need to ensure that is still correct. --daniel 2011-04-21
 ['1.0.0', '1.0.1', '1.1.0', '1.1.1', '2.0.0'].each do |version|
   Puppet::Face.define(:version_matching, version) do
-    copyright "Puppet Labs", 2011
+    copyright "Puppet Inc.", 2011
     license   "Apache 2 license; see COPYING"
     summary "version matching face #{version}"
     action(:version) { when_invoked { |options| version } }

data/spec/lib/puppet_spec/character_encoding.rb

@@ -0,0 +1,12 @@
+# A support module for testing character encoding
+module PuppetSpec::CharacterEncoding
+  def self.with_external_encoding(encoding, &blk)
+    original_encoding = Encoding.default_external
+    begin
+      Encoding.default_external = encoding
+      yield
+    ensure
+      Encoding.default_external = original_encoding
+    end
+  end
+end

data/spec/lib/puppet_spec/compiler.rb

@@ -7,6 +7,13 @@ module PuppetSpec::Compiler
     Puppet::Parser::Compiler.compile(node).filter { |r| r.virtual? }
   end
 
+  # Does not removed virtual resources in compiled catalog (i.e. keeps unrealized)
+  def compile_to_catalog_unfiltered(string, node = Puppet::Node.new('test'))
+    Puppet[:code] = string
+    # see lib/puppet/indirector/catalog/compiler.rb#filter
+    Puppet::Parser::Compiler.compile(node)
+  end
+
   def compile_to_ral(manifest, node = Puppet::Node.new('test'))
     catalog = compile_to_catalog(manifest, node)
     ral = catalog.to_ral

data/spec/shared_examples/rhel_package_provider.rb

@@ -178,7 +178,7 @@ shared_examples "RHEL package provider" do |provider_class, provider_name|
           {'--enablerepo' => 'centosplus'},
         ]
         provider.stubs(:properties).returns({:ensure => '3.4.5'})
-        described_class.expects(:latest_package_version).with(name, ['contrib', 'centosplus'], [], [])
+        described_class.expects(:latest_package_version).with(name, [], ['contrib', 'centosplus'], [])
         provider.latest
       end
       it "passes the value of disablerepo install_options when querying" do
@@ -187,7 +187,7 @@ shared_examples "RHEL package provider" do |provider_class, provider_name|
           {'--disablerepo' => 'centosplus'},
         ]
         provider.stubs(:properties).returns({:ensure => '3.4.5'})
-        described_class.expects(:latest_package_version).with(name, [], ['updates', 'centosplus'], [])
+        described_class.expects(:latest_package_version).with(name, ['updates', 'centosplus'], [], [])
         provider.latest
       end
       it "passes the value of disableexcludes install_options when querying" do
@@ -270,15 +270,15 @@ shared_examples "RHEL package provider" do |provider_class, provider_name|
           expect(version).to eq mypackage_version
         }
       end
-      it "caches separate lists for each combination of 'enablerepo' and 'disablerepo' and 'disableexcludes'" do
+      it "caches separate lists for each combination of 'disablerepo' and 'enablerepo' and 'disableexcludes'" do
         described_class.expects(:check_updates).with([], [], []).once.returns(latest_versions)
-        described_class.expects(:check_updates).with(['enabled'], ['disabled'], ['disableexcludes']).once.returns(enabled_versions)
+        described_class.expects(:check_updates).with(['disabled'], ['enabled'], ['disableexcludes']).once.returns(enabled_versions)
         2.times {
           version = described_class.latest_package_version(name, [], [], [])
           expect(version).to eq mypackage_version
         }
         2.times {
-          version = described_class.latest_package_version(name, ['enabled'], ['disabled'], ['disableexcludes'])
+          version = described_class.latest_package_version(name, ['disabled'], ['enabled'], ['disableexcludes'])
           expect(version).to eq(mypackage_newerversion)
         }
       end
@@ -288,19 +288,19 @@ shared_examples "RHEL package provider" do |provider_class, provider_name|
         Puppet::Util::Execution.expects(:execute).with do |args, *rest|
           expect(args).to eq %W[/usr/bin/#{provider_name} check-update --enablerepo=updates --enablerepo=centosplus]
         end.returns(stub(:exitstatus => 0))
-        described_class.check_updates(%W[updates centosplus], [], [])
+        described_class.check_updates([], %W[updates centosplus], [])
       end
       it "passes repos to disable to '#{provider_name} check-update'" do
         Puppet::Util::Execution.expects(:execute).with do |args, *rest|
           expect(args).to eq %W[/usr/bin/#{provider_name} check-update --disablerepo=updates --disablerepo=centosplus]
         end.returns(stub(:exitstatus => 0))
-        described_class.check_updates([],%W[updates centosplus], [])
+        described_class.check_updates(%W[updates centosplus], [], [])
       end
       it "passes a combination of repos to enable and disable to '#{provider_name} check-update'" do
         Puppet::Util::Execution.expects(:execute).with do |args, *rest|
-          expect(args).to eq %W[/usr/bin/#{provider_name} check-update --enablerepo=os --enablerepo=contrib --disablerepo=updates --disablerepo=centosplus]
+          expect(args).to eq %W[/usr/bin/#{provider_name} check-update --disablerepo=updates --disablerepo=centosplus --enablerepo=os --enablerepo=contrib ]
         end.returns(stub(:exitstatus => 0))
-        described_class.check_updates(%W[os contrib], %W[updates centosplus], [])
+        described_class.check_updates(%W[updates centosplus], %W[os contrib], [])
       end
       it "passes disableexcludes to '#{provider_name} check-update'" do
         Puppet::Util::Execution.expects(:execute).with do |args, *rest|
@@ -310,8 +310,7 @@ shared_examples "RHEL package provider" do |provider_class, provider_name|
       end
       it "passes all options to '#{provider_name} check-update'" do
         Puppet::Util::Execution.expects(:execute).with do |args, *rest|
-          expect(args).to eq %W[/usr/bin/#{provider_name} check-update --enablerepo=a --enablerepo=b --disablerepo=c
-                                --disablerepo=d --disableexcludes=e --disableexcludes=f]
+          expect(args).to eq %W[/usr/bin/#{provider_name} check-update --disablerepo=a --disablerepo=b --enablerepo=c --enablerepo=d --disableexcludes=e --disableexcludes=f]
         end.returns(stub(:exitstatus => 0))
         described_class.check_updates(%W[a b], %W[c d], %W[e f])
       end

data/spec/unit/application/resource_spec.rb

@@ -2,6 +2,7 @@
 require 'spec_helper'
 
 require 'puppet/application/resource'
+require 'puppet_spec/character_encoding'
 
 describe Puppet::Application::Resource do
   include PuppetSpec::Files
@@ -50,7 +51,7 @@ describe Puppet::Application::Resource do
       # provider is a parameter that should always be available
       @resource_app.extra_params = [ :provider ]
 
-      expect { @resource_app.main }.to have_printed /provider\s+=>/
+      expect { @resource_app.main }.to have_printed(/provider\s+=>/)
     end
   end
 
@@ -88,6 +89,7 @@ describe Puppet::Application::Resource do
 
       @res = stub_everything "resource"
       @res.stubs(:prune_parameters).returns(@res)
+      @res.stubs(:to_manifest).returns("resource")
       @report = stub_everything "report"
 
       @resource_app.stubs(:puts)
@@ -129,6 +131,25 @@ describe Puppet::Application::Resource do
     end
   end
 
+  describe "when printing output" do
+    it "should ensure all values to be printed are in the external encoding" do
+      resources = [
+        Puppet::Type.type(:user).new(:name => "\u2603".force_encoding(Encoding::UTF_8)).to_resource,
+        Puppet::Type.type(:user).new(:name => "Jos\xE9".force_encoding(Encoding::ISO_8859_1)).to_resource
+      ]
+      Puppet::Resource.indirection.expects(:search).with('user/', {}).returns(resources)
+      @resource_app.command_line.stubs(:args).returns(['user'])
+
+      # All of our output should be in external encoding
+      @resource_app.expects(:puts).with { |args| expect(args.encoding).to eq(Encoding::ISO_8859_1) }
+
+      # This would raise an error if we weren't handling it
+      PuppetSpec::CharacterEncoding.with_external_encoding(Encoding::ISO_8859_1) do
+        expect { @resource_app.main }.not_to raise_error
+      end
+    end
+  end
+
   describe "when handling file type" do
     before :each do
       Facter.stubs(:loadfacts)

data/spec/unit/configurer/fact_handler_spec.rb

@@ -78,7 +78,8 @@ describe Puppet::Configurer::FactHandler do
   end
 
   it "should properly accept facts containing a '+'" do
-    facts = Puppet::Node::Facts.new('foo', 'afact' => 'a+b')
+    fact_hash = { 'afact' => 'a+b' }
+    facts = Puppet::Node::Facts.new(Puppet[:node_name_value], fact_hash)
     Puppet::Node::Facts.indirection.save(facts)
     text = CGI.escape(facthandler.find_facts.render(:pson))
 

data/spec/unit/etc_spec.rb

@@ -1,234 +1,442 @@
 require 'puppet'
 require 'spec_helper'
+require 'puppet_spec/character_encoding'
 
 # The Ruby::Etc module is largely non-functional on Windows - many methods
 # simply return nil regardless of input, the Etc::Group struct is not defined,
 # and Etc::Passwd is missing fields
-describe Puppet::Etc, :if => !Puppet.features.microsoft_windows? do
-  let(:bin) { 'bin'.force_encoding(Encoding::ISO_8859_1) }
-  let(:root) { 'root'.force_encoding(Encoding::ISO_8859_1) }
-  let(:x) { 'x'.force_encoding(Encoding::ISO_8859_1) }
-  let(:daemon) { 'daemon'.force_encoding(Encoding::ISO_8859_1) }
-  let(:root_comment) { 'i am the root user'.force_encoding(Encoding::ISO_8859_1) }
-  let(:user_struct_iso_8859_1) { Etc::Passwd.new(root, x, 0, 0, root_comment) }
-  let(:group_struct_iso_8859_1) { Etc::Group.new(bin, x, 1, [root, bin, daemon]) }
+# We want to test that:
+# - We correctly set external encoding values IF they're valid UTF-8 bytes
+# - We do not modify non-UTF-8 values if they're NOT valid UTF-8 bytes
 
+describe Puppet::Etc, :if => !Puppet.features.microsoft_windows? do
   # http://www.fileformat.info/info/unicode/char/5e0c/index.htm
   # 希 Han Character 'rare; hope, expect, strive for'
   # In EUC_KR: \xfd \xf1 - 253 241
-  # Not convertible to UTF-8, likely to be read in as BINARY by Ruby unless system is in EUC_KR
-  let(:not_convertible) { [254, 241].pack('C*') }
+  # In UTF-8: \u5e0c - \xe5 \xb8 \x8c - 229 184 140
+  let(:euc_kr) { [253, 241].pack('C*').force_encoding(Encoding::EUC_KR) } # valid_encoding? == true
+  let(:euc_kr_as_binary) { [253, 241].pack('C*') } # valid_encoding? == true
+  let(:euc_kr_as_utf_8) { [253, 241].pack('C*').force_encoding(Encoding::UTF_8) } # valid_encoding? == false
 
   # characters representing 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 𠜎 - http://www.fileformat.info/info/unicode/char/2070E/index.htm - 0xF0 0xA0 0x9C 0x8E / 240 160 156 142
-  #
-  # Should all convert cleanly to UTF-8
-  # Unless the system is in UTF-8, these will likely be read in as BINARY by Ruby
-  let(:convertible_utf8) { "A\u06FF\u16A0\u{2070E}" } # Aۿᚠ𠜎
-  let(:convertible_binary) { "A\u06FF\u16A0\u{2070E}".force_encoding(Encoding::BINARY) }
-
-  # For the methods described which actually expect an encoding conversion, we
-  # only superficially test via #force_encoding - the deeper level testing is in
-  # character_encoding_spec.rb which handles testing transcoding etc.
-
-  describe "getgrent" do
-    context "given an original system Etc Group struct with ISO-8850-1 string values" do
-      before { Etc.expects(:getgrent).returns(group_struct_iso_8859_1) }
-      let(:converted) { Puppet::Etc.getgrent }
-
-      it "should return a struct with :name and :passwd field values converted to UTF-8" do
-        [converted.name, converted.passwd].each do |value|
-          expect(value.encoding).to eq(Encoding::UTF_8)
-        end
-      end
+  let(:mixed_utf_8) { "A\u06FF\u16A0\u{2070E}".force_encoding(Encoding::UTF_8) } # Aۿᚠ𠜎
+  let(:mixed_utf_8_as_binary) { "A\u06FF\u16A0\u{2070E}".force_encoding(Encoding::BINARY) }
+  let(:mixed_utf_8_as_euc_kr) { "A\u06FF\u16A0\u{2070E}".force_encoding(Encoding::EUC_KR) }
+
+  # An uninteresting value that ruby might return in an Etc struct.
+  let(:root) { 'root' }
+
+  # Set up example Etc Group structs with values representative of what we would
+  # get back in these encodings
+
+  let(:utf_8_group_struct) do
+    group = Etc::Group.new
+    # In a UTF-8 environment, these values will come back as UTF-8, even if
+    # they're not valid UTF-8. We do not modify anything about either the
+    # valid or invalid UTF-8 strings.
+
+    # Group member contains a mix of valid and invalid UTF-8-labeled strings
+    group.mem = [mixed_utf_8, root.dup.force_encoding(Encoding::UTF_8), euc_kr_as_utf_8]
+    # group name contains same EUC_KR bytes labeled as UTF-8
+    group.name = euc_kr_as_utf_8
+    # group passwd field is valid UTF-8
+    group.passwd = mixed_utf_8
+    group.gid = 12345
+    group
+  end
 
-      it "should return a struct with a :mem array with all field values converted to UTF-8" do
-        converted.mem.each { |elem| expect(elem.encoding).to eq(Encoding::UTF_8) }
-      end
+  let(:euc_kr_group_struct) do
+    # In an EUC_KR environment, values will come back as EUC_KR, even if they're
+    # not valid in that encoding. For values that are valid in UTF-8 we expect
+    # their external encoding to be set to UTF-8 by Puppet::Etc. For values that
+    # are invalid in UTF-8, we expect the string to be kept intact, unmodified,
+    # as we can't transcode it.
+    group = Etc::Group.new
+    group.mem = [euc_kr, root.dup.force_encoding(Encoding::EUC_KR), mixed_utf_8_as_euc_kr]
+    group.name = euc_kr
+    group.passwd = mixed_utf_8_as_euc_kr
+    group.gid = 12345
+    group
+  end
+
+  let(:ascii_group_struct) do
+    # In a POSIX environment, any strings containing only values under
+    # code-point 128 will be returned as ASCII, whereas anything above that
+    # point will be returned as BINARY. In either case we override the encoding
+    # to UTF-8 if that would be valid.
+    group = Etc::Group.new
+    group.mem = [euc_kr_as_binary, root.dup.force_encoding(Encoding::ASCII), mixed_utf_8_as_binary]
+    group.name = euc_kr_as_binary
+    group.passwd = mixed_utf_8_as_binary
+    group.gid = 12345
+    group
+  end
+
+  let(:utf_8_user_struct) do
+    user = Etc::Passwd.new
+    # user name contains same EUC_KR bytes labeled as UTF-8
+    user.name = euc_kr_as_utf_8
+    # group passwd field is valid UTF-8
+    user.passwd = mixed_utf_8
+    user.uid = 12345
+    user
+  end
+
+  let(:euc_kr_user_struct) do
+    user = Etc::Passwd.new
+    user.name = euc_kr
+    user.passwd = mixed_utf_8_as_euc_kr
+    user.uid = 12345
+    user
+  end
+
+  let(:ascii_user_struct) do
+    user = Etc::Passwd.new
+    user.name = euc_kr_as_binary
+    user.passwd = mixed_utf_8_as_binary
+    user.uid = 12345
+    user
+  end
+
+  shared_examples "methods that return an overridden group struct from Etc" do |params|
+
+    it "should return a new Struct object with corresponding canonical_ members" do
+      group = Etc::Group.new
+      Etc.expects(subject).with(*params).returns(group)
+      puppet_group = Puppet::Etc.send(subject, *params)
+
+      expect(puppet_group.members).to include(*group.members)
+      expect(puppet_group.members).to include(*group.members.map { |mem| "canonical_#{mem}".to_sym })
+
+      # Confirm we haven't just added the new members to the original struct object, ie this is really a new struct
+      expect(group.members.any? { |elem| elem.match(/^canonical_/) }).to be_falsey
     end
 
-    context "given an original Etc::Group struct with field values that cannot be converted to UTF-8" do
-      let(:group) { Etc::Group.new }
+    context "when Encoding.default_external is UTF-8" do
       before do
-        # group membership contains valid and invalid UTF-8
-        group.mem = [convertible_binary, not_convertible]
-        # group name contains a value that is invalid UTF-8
-        group.name = not_convertible
-        # group passwd field is valid UTF-8
-        group.passwd = convertible_binary
+        Etc.expects(subject).with(*params).returns(utf_8_group_struct)
+      end
 
-        Etc.expects(:getgrent).returns(group)
+      let(:overridden) {
+        PuppetSpec::CharacterEncoding.with_external_encoding(Encoding::UTF_8) do
+          Puppet::Etc.send(subject, *params)
+        end
+      }
+
+      it "should leave the valid UTF-8 values in arrays unmodified" do
+        expect(overridden.mem[0]).to eq(mixed_utf_8)
+        expect(overridden.mem[1]).to eq(root)
       end
 
-      let(:converted) { Puppet::Etc.getgrent }
+      it "should replace invalid characters with replacement characters in invalid UTF-8 values in arrays" do
+        expect(overridden.mem[2]).to eq("\uFFFD\uFFFD")
+      end
 
-      it "should convert convertible values in arrays to UTF-8" do
-        expect(converted.mem[0]).to eq("A\u06FF\u16A0\u{2070E}")
-        expect(converted.mem[0].encoding).to eq(Encoding::UTF_8) # just being explicit
+      it "should keep an unmodified version of the invalid UTF-8 values in arrays in the corresponding canonical_ member" do
+        expect(overridden.canonical_mem[2]).to eq(euc_kr_as_utf_8)
       end
 
-      it "should leave the unconvertible values unmodified" do
-        expect(converted.name).to eq([254, 241].pack('C*'))
-        expect(converted.name.encoding).to eq(Encoding::BINARY) # just being explicit
+      it "should leave the valid UTF-8 values unmodified" do
+        expect(overridden.passwd).to eq(mixed_utf_8)
       end
 
-      it "should leave unconvertible values in arrays unmodifed" do
-        expect(converted.mem[1]).to eq([254, 241].pack('C*'))
-        expect(converted.mem[1].encoding).to eq(Encoding::BINARY) # just being explicit
+      it "should replace invalid characters with '?' characters in invalid UTF-8 values" do
+        expect(overridden.name).to eq("\uFFFD\uFFFD")
       end
 
-      it "should convert values that can be converted to UTf-8" do
-        expect(converted.passwd).to eq("A\u06FF\u16A0\u{2070E}")
-        expect(converted.passwd.encoding).to eq(Encoding::UTF_8) # just being explicit
+      it "should keep an unmodified version of the invalid UTF-8 values in the corresponding canonical_ member" do
+        expect(overridden.canonical_name).to eq(euc_kr_as_utf_8)
       end
-    end
-  end
 
-  describe "endgrent" do
-    it "should call Etc.getgrent" do
-      Etc.expects(:getgrent)
-      Puppet::Etc.getgrent
-    end
-  end
+      it "should copy all values to the new struct object" do
+        # Confirm we've actually copied all the values to the canonical_members
+        utf_8_group_struct.each_pair do |member, value|
+          expect(overridden["canonical_#{member}"]).to eq(value)
 
-  describe "setgrent" do
-    it "should call Etc.setgrent" do
-      Etc.expects(:setgrent)
-      Puppet::Etc.setgrent
+          # Confirm we've reassigned all non-string and array values
+          if !value.is_a?(String) && !value.is_a?(Array)
+            expect(overridden[member]).to eq(value)
+            expect(overridden[member].object_id).to eq(value.object_id)
+          end
+        end
+      end
     end
-  end
 
-  describe "getpwent" do
-    context "given an original system Etc Passwd struct with ISO-8859-1 string values" do
-      before { Etc.expects(:getpwent).returns(user_struct_iso_8859_1) }
-      let(:converted) { Puppet::Etc.getpwent }
+    context "when Encoding.default_external is EUC_KR (i.e., neither UTF-8 nor POSIX)" do
+      before do
+        Etc.expects(subject).with(*params).returns(euc_kr_group_struct)
+      end
+
+      let(:overridden) {
+        PuppetSpec::CharacterEncoding.with_external_encoding(Encoding::EUC_KR) do
+          Puppet::Etc.send(subject, *params)
+        end
+      }
+
+      it "should override EUC_KR-labeled values in arrays to UTF-8 if that would result in valid UTF-8" do
+        expect(overridden.mem[2]).to eq(mixed_utf_8)
+        expect(overridden.mem[1]).to eq(root)
+      end
+
+      it "should leave valid EUC_KR-labeled values that would not be valid UTF-8 in arrays unmodified" do
+        expect(overridden.mem[0]).to eq(euc_kr)
+      end
+
+      it "should override EUC_KR-labeled values to UTF-8 if that would result in valid UTF-8" do
+        expect(overridden.passwd).to eq(mixed_utf_8)
+      end
+
+      it "should leave valid EUC_KR-labeled values that would not be valid UTF-8 unmodified" do
+        expect(overridden.name).to eq(euc_kr)
+      end
 
-      it "should return an Etc Passwd struct with field values converted to UTF-8" do
-        [converted.name, converted.passwd, converted.gecos].each do |value|
-          expect(value.encoding).to eq(Encoding::UTF_8)
+      it "should copy all values to the new struct object" do
+        # Confirm we've actually copied all the values to the canonical_members
+        euc_kr_group_struct.each_pair do |member, value|
+          expect(overridden["canonical_#{member}"]).to eq(value)
+
+          # Confirm we've reassigned all non-string and array values
+          if !value.is_a?(String) && !value.is_a?(Array)
+            expect(overridden[member]).to eq(value)
+            expect(overridden[member].object_id).to eq(value.object_id)
+          end
         end
       end
     end
 
-    context "given an original Etc::Passwd struct with field values that cannot be converted to UTF-8" do
-      let(:user) { Etc::Passwd.new }
+    context "when Encoding.default_external is POSIX (ASCII-7bit)" do
       before do
-        # user comment field cannot be converted to UTF-8
-        user.gecos =  not_convertible
-        # user passwd field is valid UTF-8
-        user.passwd = convertible_binary
+        Etc.expects(subject).with(*params).returns(ascii_group_struct)
+      end
+
+      let(:overridden) {
+        PuppetSpec::CharacterEncoding.with_external_encoding(Encoding::ASCII) do
+          Puppet::Etc.send(subject, *params)
+        end
+      }
 
-        Etc.expects(:getpwent).returns(user)
+      it "should not modify binary values in arrays that would be invalid UTF-8" do
+        expect(overridden.mem[0]).to eq(euc_kr_as_binary)
       end
 
-      let(:converted) { Puppet::Etc.getpwent }
+      it "should set the encoding to UTF-8 on binary values in arrays that would be valid UTF-8" do
+        expect(overridden.mem[1]).to eq(root.dup.force_encoding(Encoding::UTF_8))
+        expect(overridden.mem[2]).to eq(mixed_utf_8)
+      end
 
-      it "should leave the unconvertible values unmodified" do
-        expect(converted.gecos).to eq([254, 241].pack('C*'))
-        expect(converted.gecos.encoding).to eq(Encoding::BINARY) # just being explicit
+      it "should not modify binary values that would be invalid UTF-8" do
+        expect(overridden.name).to eq(euc_kr_as_binary)
       end
 
-      it "should convert values that can be converted to UTf-8" do
-        expect(converted.passwd).to eq("A\u06FF\u16A0\u{2070E}")
-        expect(converted.passwd.encoding).to eq(Encoding::UTF_8) # just being explicit
+      it "should set the encoding to UTF-8 on binary values that would be valid UTF-8" do
+        expect(overridden.passwd).to eq(mixed_utf_8)
       end
-    end
-  end
 
-  describe "endpwent" do
-    it "should call Etc.endpwent" do
-      Etc.expects(:endpwent)
-      Puppet::Etc.endpwent
+      it "should copy all values to the new struct object" do
+        # Confirm we've actually copied all the values to the canonical_members
+        ascii_group_struct.each_pair do |member, value|
+          expect(overridden["canonical_#{member}"]).to eq(value)
+
+          # Confirm we've reassigned all non-string and array values
+          if !value.is_a?(String) && !value.is_a?(Array)
+            expect(overridden[member]).to eq(value)
+            expect(overridden[member].object_id).to eq(value.object_id)
+          end
+        end
+      end
     end
   end
 
-  describe "setpwent" do
-    it "should call Etc.setpwent" do
-      Etc.expects(:setpwent)
-      Puppet::Etc.setpwent
+  shared_examples "methods that return an overridden user struct from Etc" do |params|
+
+    it "should return a new Struct object with corresponding canonical_ members" do
+      user = Etc::Passwd.new
+      Etc.expects(subject).with(*params).returns(user)
+      puppet_user = Puppet::Etc.send(subject, *params)
+
+      expect(puppet_user.members).to include(*user.members)
+      expect(puppet_user.members).to include(*user.members.map { |mem| "canonical_#{mem}".to_sym })
+      # Confirm we haven't just added the new members to the original struct object, ie this is really a new struct
+      expect(user.members.any? { |elem| elem.match(/^canonical_/)}).to be_falsey
     end
-  end
 
-  describe "getpwnam" do
-    context "given a username to query" do
-      it "should call Etc.getpwnam with that username" do
-        Etc.expects(:getpwnam).with('foo')
-        Puppet::Etc.getpwnam('foo')
+    context "when Encoding.default_external is UTF-8" do
+      before do
+        Etc.expects(subject).with(*params).returns(utf_8_user_struct)
+      end
+
+      let(:overridden) {
+        PuppetSpec::CharacterEncoding.with_external_encoding(Encoding::UTF_8) do
+          Puppet::Etc.send(subject, *params)
+        end
+      }
+
+      it "should leave the valid UTF-8 values unmodified" do
+        expect(overridden.passwd).to eq(mixed_utf_8)
+      end
+
+      it "should replace invalid characters with unicode replacement characters in invalid UTF-8 values" do
+        expect(overridden.name).to eq("\uFFFD\uFFFD")
+      end
+
+      it "should keep an unmodified version of the invalid UTF-8 values in the corresponding canonical_ member" do
+        expect(overridden.canonical_name).to eq(euc_kr_as_utf_8)
       end
-    end
 
-    context "given an original system Etc Passwd struct with ISO-8859-1 string values" do
-      it "should return an Etc Passwd struct with field values converted to UTF-8" do
-        Etc.expects(:getpwnam).with('root').returns(user_struct_iso_8859_1)
-        converted = Puppet::Etc.getpwnam('root')
-        [converted.name, converted.passwd, converted.gecos].each do |value|
-          expect(value.encoding).to eq(Encoding::UTF_8)
+      it "should copy all values to the new struct object" do
+        # Confirm we've actually copied all the values to the canonical_members
+        utf_8_user_struct.each_pair do |member, value|
+          expect(overridden["canonical_#{member}"]).to eq(value)
+
+          # Confirm we've reassigned all non-string and array values
+          if !value.is_a?(String) && !value.is_a?(Array)
+            expect(overridden[member]).to eq(value)
+            expect(overridden[member].object_id).to eq(value.object_id)
+          end
         end
       end
     end
-  end
 
-  describe "getgrnam" do
-    context "given a group name to query" do
-      it "should call Etc.getgrnam with that group name" do
-        Etc.expects(:getgrnam).with('foo')
-        Puppet::Etc.getgrnam('foo')
+    context "when Encoding.default_external is EUC_KR (i.e., neither UTF-8 nor POSIX)" do
+      before do
+        Etc.expects(subject).with(*params).returns(euc_kr_user_struct)
       end
-    end
 
-    context "given an original system Etc Group struct with ISO-8859-1 string values" do
-      it "should return an Etc Group struct with field values converted to UTF-8" do
-        Etc.expects(:getgrnam).with('bin').returns(group_struct_iso_8859_1)
-        converted = Puppet::Etc.getgrnam('bin')
-        [converted.name, converted.passwd].each do |value|
-          expect(value.encoding).to eq(Encoding::UTF_8)
+      let(:overridden) {
+        PuppetSpec::CharacterEncoding.with_external_encoding(Encoding::EUC_KR) do
+          Puppet::Etc.send(subject, *params)
         end
-        converted.mem.each { |elem| expect(elem.encoding).to eq(Encoding::UTF_8) }
+      }
+
+      it "should override valid UTF-8 EUC_KR-labeled values to UTF-8" do
+        expect(overridden.passwd).to eq(mixed_utf_8)
+      end
+
+      it "should leave invalid EUC_KR-labeled values unmodified" do
+        expect(overridden.name).to eq(euc_kr)
       end
-    end
-  end
 
-  describe "getgrgid" do
-    context "given a group ID to query" do
-      it "should call Etc.getgrgid with the id" do
-        Etc.expects(:getgrgid).with(0)
-        Puppet::Etc.getgrgid(0)
+      it "should copy all values to the new struct object" do
+        # Confirm we've actually copied all the values to the canonical_members
+        euc_kr_user_struct.each_pair do |member, value|
+          expect(overridden["canonical_#{member}"]).to eq(value)
+
+          # Confirm we've reassigned all non-string and array values
+          if !value.is_a?(String) && !value.is_a?(Array)
+            expect(overridden[member]).to eq(value)
+            expect(overridden[member].object_id).to eq(value.object_id)
+          end
+        end
       end
     end
 
-    context "given an original Etc Group struct with field values in ISO-8859-1" do
-      it "should return an Etc Group struct with field values converted to UTF-8" do
-        Etc.expects(:getgrgid).with(1).returns(group_struct_iso_8859_1)
-        converted = Puppet::Etc.getgrgid(1)
-        [converted.name, converted.passwd].each do |value|
-          expect(value.encoding).to eq(Encoding::UTF_8)
+    context "when Encoding.default_external is POSIX (ASCII-7bit)" do
+      before do
+        Etc.expects(subject).with(*params).returns(ascii_user_struct)
+      end
+
+      let(:overridden) {
+        PuppetSpec::CharacterEncoding.with_external_encoding(Encoding::ASCII) do
+          Puppet::Etc.send(subject, *params)
+        end
+      }
+
+      it "should not modify binary values that would be invalid UTF-8" do
+        expect(overridden.name).to eq(euc_kr_as_binary)
+      end
+
+      it "should set the encoding to UTF-8 on binary values that would be valid UTF-8" do
+        expect(overridden.passwd).to eq(mixed_utf_8)
+      end
+
+      it "should copy all values to the new struct object" do
+        # Confirm we've actually copied all the values to the canonical_members
+        ascii_user_struct.each_pair do |member, value|
+          expect(overridden["canonical_#{member}"]).to eq(value)
+
+          # Confirm we've reassigned all non-string and array values
+          if !value.is_a?(String) && !value.is_a?(Array)
+            expect(overridden[member]).to eq(value)
+            expect(overridden[member].object_id).to eq(value.object_id)
+          end
         end
-        converted.mem.each { |elem| expect(elem.encoding).to eq(Encoding::UTF_8) }
       end
     end
   end
 
-  describe "getpwid" do
-    context "given a UID to query" do
-      it "should call Etc.getpwuid with the id" do
-        Etc.expects(:getpwuid).with(2)
-        Puppet::Etc.getpwuid(2)
-      end
+  describe :getgrent do
+    it_should_behave_like "methods that return an overridden group struct from Etc"
+  end
+
+  describe :getgrnam do
+    it_should_behave_like "methods that return an overridden group struct from Etc", 'foo'
+
+    it "should call Etc.getgrnam with the supplied group name" do
+      Etc.expects(:getgrnam).with('foo')
+      Puppet::Etc.getgrnam('foo')
     end
   end
 
-  context "given an orginal Etc Passwd struct with field values in ISO-8859-1" do
-    it "should return an Etc Passwd struct with field values converted to UTF-8" do
-      Etc.expects(:getpwuid).with(0).returns(user_struct_iso_8859_1)
-      converted = Puppet::Etc.getpwuid(0)
-      [converted.name, converted.passwd, converted.gecos].each do |value|
-        expect(value.encoding).to eq(Encoding::UTF_8)
-      end
+  describe :getgrgid do
+    it_should_behave_like "methods that return an overridden group struct from Etc", 0
+
+    it "should call Etc.getgrgid with supplied group id" do
+      Etc.expects(:getgrgid).with(0)
+      Puppet::Etc.getgrgid(0)
     end
   end
 
+  describe :getpwent do
+    it_should_behave_like "methods that return an overridden user struct from Etc"
+  end
+
+  describe :getpwnam do
+    it_should_behave_like "methods that return an overridden user struct from Etc", 'foo'
+
+    it "should call Etc.getpwnam with that username" do
+      Etc.expects(:getpwnam).with('foo')
+      Puppet::Etc.getpwnam('foo')
+    end
+  end
+
+  describe :getpwuid do
+    it_should_behave_like "methods that return an overridden user struct from Etc", 2
+
+    it "should call Etc.getpwuid with the id" do
+      Etc.expects(:getpwuid).with(2)
+      Puppet::Etc.getpwuid(2)
+    end
+  end
+
+  describe "endgrent" do
+    it "should call Etc.getgrent" do
+      Etc.expects(:getgrent)
+      Puppet::Etc.getgrent
+    end
+  end
+
+  describe "setgrent" do
+    it "should call Etc.setgrent" do
+      Etc.expects(:setgrent)
+      Puppet::Etc.setgrent
+    end
+  end
+
+  describe "endpwent" do
+    it "should call Etc.endpwent" do
+      Etc.expects(:endpwent)
+      Puppet::Etc.endpwent
+    end
+  end
 
+  describe "setpwent" do
+    it "should call Etc.setpwent" do
+      Etc.expects(:setpwent)
+      Puppet::Etc.setpwent
+    end
+  end
 end