puppet 4.8.2-x64-mingw32 → 4.9.0-x64-mingw32

data/spec/unit/data_providers/{sample_data_provider_spec.rb → custom_data_provider_spec.rb}

@@ -2,11 +2,12 @@
 require 'spec_helper'
 require 'puppet_spec/compiler'
 
-describe "when using a sample data provider from an external module" do
+describe 'when using a custom data provider' do
   include PuppetSpec::Compiler
 
   # There is a fully configured 'sample' environment in fixtures at this location
   let(:environmentpath) { parent_fixture('environments') }
+  let(:node) { Puppet::Node.new('testnode', :facts => Puppet::Node::Facts.new("facts", {}), :environment => 'sample') }
 
   around(:each) do |example|
     # Initialize settings to get a full compile as close as possible to a real
@@ -26,27 +27,24 @@ describe "when using a sample data provider from an external module" do
   end
 
   it 'the environment data loader is used to set parameters' do
-    node = Puppet::Node.new("testnode", :facts => Puppet::Node::Facts.new("facts", {}), :environment => 'sample')
-    compiler = Puppet::Parser::Compiler.new(node)
-    catalog = compiler.compile()
-    resources_created_in_fixture = ["Notify[env data param_a is 10, env data param_b is 20, 3]"]
-    expect(resources_in(catalog)).to include(*resources_created_in_fixture)
+    code = <<-PUPPET.unindent
+      class test($param_a = 1, $param_b = 2, $param_c = 3) {
+        notice("$param_a, $param_b, $param_c")
+      }
+      include test
+    PUPPET
+    expect(eval_and_collect_notices(code, node)).to eql(['env data param_a is 10, env data param_b is 20, 3'])
   end
 
   it 'the module and environment data loader is used to set parameters' do
-    node = Puppet::Node.new("testnode", :facts => Puppet::Node::Facts.new("facts", {}), :environment => 'sample')
-    compiler = Puppet::Parser::Compiler.new(node)
-    catalog = compiler.compile()
-    resources_created_in_fixture = ["Notify[module data param_a is 100, module data param_b is 200, env data param_c is 300]"]
-    expect(resources_in(catalog)).to include(*resources_created_in_fixture)
+    expect(eval_and_collect_notices('include dataprovider::test', node)).to eql(['module data param_a is 100, module data param_b is 200, env data param_c is 300'])
   end
 
-  def parent_fixture(dir_name)
-    File.absolute_path(File.join(my_fixture_dir(), "../#{dir_name}"))
+  it 'the custom hiera backend in a module and the environment data loader is used to set parameters' do
+    expect(eval_and_collect_notices('include backend::test', node)).to eql(['module data param_a is 1000, module data param_b is 2000, env data param_c is 3000'])
   end
 
-  def resources_in(catalog)
-    catalog.resources.map(&:ref)
+  def parent_fixture(dir_name)
+    File.absolute_path(File.join(my_fixture_dir(), "../#{dir_name}"))
   end
-
 end

data/spec/unit/data_providers/function_data_provider_spec.rb

@@ -90,7 +90,7 @@ describe "when using function data provider" do
     env_loader.add_entry(:function, 'environment::data', f.new(compiler.topscope, env_loader), nil)
     expect do
       compiler.compile()
-    end.to raise_error(/Expected 'environment::data' function to return a Hash/)
+    end.to raise_error(/Value returned from deprecated API function "environment::data" has wrong type/)
   end
 
   it 'raises an error if the module data function does not return a hash' do
@@ -109,7 +109,7 @@ describe "when using function data provider" do
     module_loader.add_entry(:function, 'abc::data', f.new(compiler.topscope, module_loader), nil)
     expect do
       compiler.compile()
-    end.to raise_error(/Expected 'abc::data' function to return a Hash/)
+    end.to raise_error(/Value returned from deprecated API function "abc::data" has wrong type/)
   end
 
   def parent_fixture(dir_name)

data/spec/unit/data_providers/hiera_data_provider_spec.rb

@@ -35,6 +35,7 @@ describe "when using a hiera data provider" do
     Puppet[:code] = code if code
     node = Puppet::Node.new("testnode", :facts => facts, :environment => environment)
     compiler = Puppet::Parser::Compiler.new(node)
+    compiler.topscope['domain'] = 'example.com'
     block_given? ? compiler.compile { |catalog| yield(compiler); catalog } : compiler.compile
   end
 
@@ -170,7 +171,12 @@ describe "when using a hiera data provider" do
   it 'traps endless interpolate recursion' do
     expect do
       compile_and_get_notifications('hiera_misc', '$r1 = "%{r2}" $r2 = "%{r1}" notify{lookup(recursive):}')
-    end.to raise_error(Puppet::DataBinding::RecursiveLookupError, /detected in \[recursive, r1, r2\]/)
+    end.to raise_error(Puppet::DataBinding::RecursiveLookupError, /detected in \[recursive, scope:r1, scope:r2\]/)
+  end
+
+  it 'does not consider use of same key in the lookup and scope namespaces as recursion' do
+    resources = compile_and_get_notifications('hiera_misc', 'notify{lookup(domain):}')
+    expect(resources).to include('-- example.com --')
   end
 
   it 'traps bad alias declarations' do
@@ -196,21 +202,14 @@ describe "when using a hiera data provider" do
       compile('hiera_misc', '$target_scope = "with scope"') do |compiler|
         lookup_invocation = Puppet::Pops::Lookup::Invocation.new(compiler.topscope, {}, {}, true)
         value = Puppet::Pops::Lookup.lookup('km_scope', nil, nil, nil, nil, lookup_invocation)
-        expect(lookup_invocation.explainer.to_s).to eq(<<EOS)
-Merge strategy first
-  Data Binding "hiera"
-    No such key: "km_scope"
-  Data Provider "Hiera Data Provider, version 4"
-    ConfigurationPath "#{environmentpath}/hiera_misc/hiera.yaml"
-    Data Provider "common"
+        expect(lookup_invocation.explainer.explain).to include(<<-EOS)
       Path "#{environmentpath}/hiera_misc/data/common.yaml"
-        Original path: "common"
+        Original path: "common.yaml"
         Interpolation on "Value from interpolation %{scope("target_scope")}"
           Global Scope
             Found key: "target_scope" value: "with scope"
         Found key: "km_scope" value: "Value from interpolation with scope"
-  Merged result: "Value from interpolation with scope"
-EOS
+          EOS
       end
     end
 
@@ -218,49 +217,7 @@ EOS
       compile('hiera_misc', '$target_scope = "with scope"') do |compiler|
         lookup_invocation = Puppet::Pops::Lookup::Invocation.new(compiler.topscope, {}, {}, true)
         value = Puppet::Pops::Lookup.lookup('one::loptsm_test::hash', nil, nil, nil, nil, lookup_invocation)
-        expect(lookup_invocation.explainer.to_s).to eq(<<EOS)
-Using merge options from "lookup_options" hash
-Merge strategy deep
-  Data Binding "hiera"
-    No such key: "one::loptsm_test::hash"
-  Data Provider "Hiera Data Provider, version 4"
-    ConfigurationPath "#{environmentpath}/hiera_misc/hiera.yaml"
-    Data Provider "common"
-      Path "#{environmentpath}/hiera_misc/data/common.yaml"
-        Original path: "common"
-        Found key: "one::loptsm_test::hash" value: {
-          "a" => "A",
-          "b" => "B",
-          "m" => {
-            "ma" => "MA",
-            "mb" => "MB"
-          }
-        }
-  Module "one" using Data Provider "Hiera Data Provider, version 4"
-    ConfigurationPath "#{environmentpath}/hiera_misc/modules/one/hiera.yaml"
-    Data Provider "common"
-      Path "#{environmentpath}/hiera_misc/modules/one/data/common.yaml"
-        Original path: "common"
-        Found key: "one::loptsm_test::hash" value: {
-          "a" => "A",
-          "c" => "C",
-          "m" => {
-            "ma" => "MA",
-            "mc" => "MC",
-            "mb" => "MB"
-          }
-        }
-  Merged result: {
-    "a" => "A",
-    "c" => "C",
-    "m" => {
-      "ma" => "MA",
-      "mc" => "MC",
-      "mb" => "MB"
-    },
-    "b" => "B"
-  }
-EOS
+        expect(lookup_invocation.explainer.explain).to include("Using merge options from \"lookup_options\" hash")
       end
     end
 
@@ -268,31 +225,41 @@ EOS
       compile('hiera_misc', '$target_scope = "with scope"') do |compiler|
         lookup_invocation = Puppet::Pops::Lookup::Invocation.new(compiler.topscope, {}, {}, Puppet::Pops::Lookup::Explainer.new(true))
         value = Puppet::Pops::Lookup.lookup('one::loptsm_test::hash', nil, nil, nil, nil, lookup_invocation)
-        expect(lookup_invocation.explainer.to_s).to eq(<<EOS)
+        expect(lookup_invocation.explainer.explain).to eq(<<EOS)
 Searching for "lookup_options"
-  Merge strategy hash
-    Data Binding "hiera"
-      No such key: "lookup_options"
-    Data Provider "Hiera Data Provider, version 4"
-      ConfigurationPath "#{environmentpath}/hiera_misc/hiera.yaml"
-      Data Provider "common"
-        Path "#{environmentpath}/hiera_misc/data/common.yaml"
-          Original path: "common"
-          Found key: "lookup_options" value: {
-            "one::lopts_test::hash" => {
-              "merge" => "deep"
-            }
+  Global Data Provider (hiera configuration version 5)
+    No such key: "lookup_options"
+  Environment Data Provider (hiera configuration version 5)
+    Hierarchy entry "Common"
+      Path "#{environmentpath}/hiera_misc/data/common.yaml"
+        Original path: "common.yaml"
+        Found key: "lookup_options" value: {
+          "one::lopts_test::hash" => {
+            "merge" => "deep"
           }
-    Module "one" using Data Provider "Hiera Data Provider, version 4"
-      ConfigurationPath "#{environmentpath}/hiera_misc/modules/one/hiera.yaml"
-      Data Provider "common"
-        Path "#{environmentpath}/hiera_misc/modules/one/data/common.yaml"
-          Original path: "common"
-          Found key: "lookup_options" value: {
-            "one::loptsm_test::hash" => {
-              "merge" => "deep"
-            }
+        }
+  Module "one" Data Provider (hiera configuration version 5)
+    Hierarchy entry "Common"
+      Path "#{environmentpath}/hiera_misc/modules/one/data/common.yaml"
+        Original path: "common.yaml"
+        Found key: "lookup_options" value: {
+          "one::loptsm_test::hash" => {
+            "merge" => "deep"
           }
+        }
+  Merge strategy hash
+    Global and Environment
+      Found key: "lookup_options" value: {
+        "one::lopts_test::hash" => {
+          "merge" => "deep"
+        }
+      }
+    Module one
+      Found key: "lookup_options" value: {
+        "one::loptsm_test::hash" => {
+          "merge" => "deep"
+        }
+      }
     Merged result: {
       "one::loptsm_test::hash" => {
         "merge" => "deep"
@@ -301,15 +268,15 @@ Searching for "lookup_options"
         "merge" => "deep"
       }
     }
+Using merge options from "lookup_options" hash
 Searching for "one::loptsm_test::hash"
   Merge strategy deep
-    Data Binding "hiera"
+    Global Data Provider (hiera configuration version 5)
       No such key: "one::loptsm_test::hash"
-    Data Provider "Hiera Data Provider, version 4"
-      ConfigurationPath "#{environmentpath}/hiera_misc/hiera.yaml"
-      Data Provider "common"
+    Environment Data Provider (hiera configuration version 5)
+      Hierarchy entry "Common"
         Path "#{environmentpath}/hiera_misc/data/common.yaml"
-          Original path: "common"
+          Original path: "common.yaml"
           Found key: "one::loptsm_test::hash" value: {
             "a" => "A",
             "b" => "B",
@@ -318,18 +285,16 @@ Searching for "one::loptsm_test::hash"
               "mb" => "MB"
             }
           }
-    Module "one" using Data Provider "Hiera Data Provider, version 4"
-      ConfigurationPath "#{environmentpath}/hiera_misc/modules/one/hiera.yaml"
-      Data Provider "common"
+    Module "one" Data Provider (hiera configuration version 5)
+      Hierarchy entry "Common"
         Path "#{environmentpath}/hiera_misc/modules/one/data/common.yaml"
-          Original path: "common"
+          Original path: "common.yaml"
           Found key: "one::loptsm_test::hash" value: {
             "a" => "A",
             "c" => "C",
             "m" => {
               "ma" => "MA",
-              "mc" => "MC",
-              "mb" => "MB"
+              "mc" => "MC"
             }
           }
     Merged result: {
@@ -350,25 +315,23 @@ EOS
       compile('hiera_misc', '$target_scope = "with scope"') do |compiler|
         lookup_invocation = Puppet::Pops::Lookup::Invocation.new(compiler.topscope, {}, {}, Puppet::Pops::Lookup::Explainer.new(true, true))
         value = Puppet::Pops::Lookup.lookup('one::loptsm_test::hash', nil, nil, nil, nil, lookup_invocation)
-        expect(lookup_invocation.explainer.to_s).to eq(<<EOS)
+        expect(lookup_invocation.explainer.explain).to eq(<<EOS)
 Merge strategy hash
-  Data Binding "hiera"
+  Global Data Provider (hiera configuration version 5)
     No such key: "lookup_options"
-  Data Provider "Hiera Data Provider, version 4"
-    ConfigurationPath "#{environmentpath}/hiera_misc/hiera.yaml"
-    Data Provider "common"
+  Environment Data Provider (hiera configuration version 5)
+    Hierarchy entry "Common"
       Path "#{environmentpath}/hiera_misc/data/common.yaml"
-        Original path: "common"
+        Original path: "common.yaml"
         Found key: "lookup_options" value: {
           "one::lopts_test::hash" => {
             "merge" => "deep"
           }
         }
-  Module "one" using Data Provider "Hiera Data Provider, version 4"
-    ConfigurationPath "#{environmentpath}/hiera_misc/modules/one/hiera.yaml"
-    Data Provider "common"
+  Module "one" Data Provider (hiera configuration version 5)
+    Hierarchy entry "Common"
       Path "#{environmentpath}/hiera_misc/modules/one/data/common.yaml"
-        Original path: "common"
+        Original path: "common.yaml"
         Found key: "lookup_options" value: {
           "one::loptsm_test::hash" => {
             "merge" => "deep"

data/spec/unit/defaults_spec.rb

@@ -104,7 +104,7 @@ describe "Defaults" do
       expect(Puppet.settings[:supported_checksum_types]).to eq(['sha256', 'md5lite', 'mtime'])
     end
   end
-  
+
   describe 'server vs server_list' do
     it 'should warn when both settings are set in code' do
       Puppet.expects(:deprecation_warning).with('Attempted to set both server and server_list. Server setting will not be used.', :SERVER_DUPLICATION)

data/spec/unit/face/ca_spec.rb

@@ -0,0 +1,10 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+require 'puppet/face'
+
+describe Puppet::Face[:ca, '0.1.0'] do
+  it "should be deprecated" do
+    expect(subject.deprecated?).to be_truthy
+  end
+end
+

data/spec/unit/face/certificate_request_spec.rb

@@ -0,0 +1,10 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+require 'puppet/face'
+
+describe Puppet::Face[:certificate_request, '0.0.1'] do
+  it "should be deprecated" do
+    expect(subject.deprecated?).to be_truthy
+  end
+end
+

data/spec/unit/face/certificate_revocation_list_spec.rb

@@ -0,0 +1,10 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+require 'puppet/face'
+
+describe Puppet::Face[:certificate_revocation_list, '0.0.1'] do
+  it "should be deprecated" do
+    expect(subject.deprecated?).to be_truthy
+  end
+end
+

data/spec/unit/face/file_spec.rb

@@ -7,4 +7,8 @@ describe Puppet::Face[:file, '0.0.1'] do
     it { is_expected.to be_action action }
     it { is_expected.to respond_to action }
   end
+
+  it "should be deprecated" do
+    expect(subject.deprecated?).to be_truthy
+  end
 end

data/spec/unit/face/help_spec.rb

@@ -141,6 +141,23 @@ describe Puppet::Face[:help, '0.0.1'] do
     end
   end
 
+  context "deprecated faces" do
+    it "prints a deprecation warning for deprecated faces" do
+      Puppet::Face[:module, :current].stubs(:deprecated?).returns(true)
+      expect(Puppet::Face[:help, :current].help(:module)).to match(/Warning: 'puppet module' is deprecated/)
+    end
+  end
+
+  context "#all_application_summaries" do
+    it "appends a deprecation warning for deprecated faces" do
+      # Stub the module face as deprecated
+      Puppet::Face[:module, :current].expects(:deprecated?).returns(true)
+      result = Puppet::Face[:help, :current].all_application_summaries.each do |appname,summary|
+        expect(summary).to match(/Deprecated/) if appname == 'module'
+      end
+    end
+  end
+
   context "#legacy_applications" do
     subject { Puppet::Face[:help, :current].legacy_applications }
 

data/spec/unit/face/key_spec.rb

@@ -0,0 +1,10 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+require 'puppet/face'
+
+describe Puppet::Face[:key, '0.0.1'] do
+  it "should be deprecated" do
+    expect(subject.deprecated?).to be_truthy
+  end
+end
+

data/spec/unit/face/status_spec.rb

@@ -0,0 +1,10 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+require 'puppet/face'
+
+describe Puppet::Face[:status, '0.0.1'] do
+  it "should be deprecated" do
+    expect(subject.deprecated?).to be_truthy
+  end
+end
+

data/spec/unit/file_system_spec.rb

@@ -5,6 +5,13 @@ require 'puppet/util/platform'
 describe "Puppet::FileSystem" do
   include PuppetSpec::Files
 
+  # 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
+  let (:mixed_utf8) { "A\u06FF\u16A0\u{2070E}" } # Aۿᚠ𠜎
+
   def with_file_content(content)
     path = tmpfile('file-system')
     file = File.new(path, 'wb')
@@ -17,6 +24,106 @@ describe "Puppet::FileSystem" do
     file.close
   end
 
+  SYSTEM_SID_BYTES = [1, 1, 0, 0, 0, 0, 0, 5, 18, 0, 0, 0]
+
+  def is_current_user_system?
+    SYSTEM_SID_BYTES == Puppet::Util::Windows::ADSI::User.current_user_sid.sid_bytes
+  end
+
+  context "#open" do
+    it "uses the same default mode as File.open, when specifying a nil mode (umask used on non-Windows)" do
+      file = tmpfile('file_to_update')
+      expect(Puppet::FileSystem.exist?(file)).to be_falsey
+
+      Puppet::FileSystem.open(file, nil, 'a') { |fh| fh.write('') }
+
+      expected_perms = Puppet::Util::Platform.windows? ?
+        # default Windows mode based on temp file storage for SYSTEM user or regular user
+        # for Jenkins or other services running as SYSTEM writing to c:\windows\temp
+        # the permissions will typically be SYSTEM(F) / Administrators(F) which is 770
+        # but sometimes there are extra users like IIS_IUSRS granted rights which adds the "extra ace" 2
+        # for local Administrators writing to their own temp folders under c:\users\USER
+        # they will have (F) for themselves, and Users will not have a permission, hence 700
+        (is_current_user_system? ? ['770', '2000770'] : '2000700') :
+        # or for *nix determine expected mode via bitwise AND complement of umask
+        (0100000 | 0666 & ~File.umask).to_s(8)
+      expect([expected_perms].flatten).to include(Puppet::FileSystem.stat(file).mode.to_s(8))
+
+      default_file = tmpfile('file_to_update2')
+      expect(Puppet::FileSystem.exist?(default_file)).to be_falsey
+
+      File.open(default_file, 'a') { |fh| fh.write('') }
+
+      # which matches the behavior of File.open
+      expect(Puppet::FileSystem.stat(file).mode).to eq(Puppet::FileSystem.stat(default_file).mode)
+    end
+
+    it "can accept an octal mode integer" do
+      file = tmpfile('file_to_update')
+      # NOTE: 777 here returns 755, but due to Ruby?
+      Puppet::FileSystem.open(file, 0444, 'a') { |fh| fh.write('') }
+
+      # Behavior may change in the future on Windows, to *actually* change perms
+      # but for now, setting a mode doesn't touch them
+      expected_perms = Puppet::Util::Platform.windows? ?
+        (is_current_user_system? ? ['770', '2000770'] : '2000700') :
+        '100444'
+      expect([expected_perms].flatten).to include(Puppet::FileSystem.stat(file).mode.to_s(8))
+
+      expected_ruby_mode = Puppet::Util::Platform.windows? ?
+        # The Windows behavior has been changed to ignore the mode specified by open
+        # given it's unlikely a caller expects Windows file attributes to be set
+        # therefore mode is explicitly not managed (until PUP-6959 is fixed)
+        #
+        # In default Ruby on Windows a mode controls file attribute setting
+        # (like archive, read-only, etc)
+        # The GetFileInformationByHandle API returns an attributes value that is
+        # a bitmask of Windows File Attribute Constants at
+        # https://msdn.microsoft.com/en-us/library/windows/desktop/gg258117(v=vs.85).aspx
+        '100644' :
+        # On other platforms, the mode should be what was set by octal 0444
+        '100444'
+
+      expect(File.stat(file).mode.to_s(8)).to eq(expected_ruby_mode)
+    end
+
+    it "cannot accept a mode string" do
+      file = tmpfile('file_to_update')
+      expect {
+        Puppet::FileSystem.open(file, "444", 'a') { |fh| fh.write('') }
+      }.to raise_error(TypeError)
+    end
+
+    it "opens, creates ands allows updating of a new file, using by default, the external system encoding" do
+      begin
+        original_encoding = Encoding.default_external
+
+        # this must be set through Ruby API and cannot be mocked - it sets internal state used by File.open
+        # pick a bizarre encoding unlikely to be used in any real tests
+        Encoding.default_external = Encoding::CP737
+
+        file = tmpfile('file_to_update')
+
+        # test writing a UTF-8 string when Default external encoding is something different
+        Puppet::FileSystem.open(file, 0660, 'w') do |fh|
+          # note Ruby behavior which has no external_encoding, but implicitly uses Encoding.default_external
+          expect(fh.external_encoding).to be_nil
+          # write a UTF-8 string to this file
+          fh.write(mixed_utf8)
+        end
+
+        # prove that Ruby implicitly converts read strings back to Encoding.default_external
+        # and that it did that in the previous write
+        written = Puppet::FileSystem.read(file)
+        expect(written.encoding).to eq(Encoding.default_external)
+        expect(written).to eq(mixed_utf8.force_encoding(Encoding.default_external))
+      ensure
+        # carefully roll back to the previous
+        Encoding.default_external = original_encoding
+      end
+    end
+  end
+
   context "#exclusive_open" do
     it "opens ands allows updating of an existing file" do
       file = file_containing("file_to_update", "the contents")
@@ -31,14 +138,33 @@ describe "Puppet::FileSystem" do
       expect(Puppet::FileSystem.read(file)).to eq("updated the contents")
     end
 
-    it "opens, creates ands allows updating of a new file" do
-      file = tmpfile("file_to_update")
+    it "opens, creates ands allows updating of a new file, using by default, the external system encoding" do
+      begin
+        original_encoding = Encoding.default_external
 
-      Puppet::FileSystem.exclusive_open(file, 0660, 'w') do |fh|
-        fh.write("updated new file")
-      end
+        # this must be set through Ruby API and cannot be mocked - it sets internal state used by File.open
+        # pick a bizarre encoding unlikely to be used in any real tests
+        Encoding.default_external = Encoding::CP737
+
+        file = tmpfile('file_to_update')
 
-      expect(Puppet::FileSystem.read(file)).to eq("updated new file")
+        # test writing a UTF-8 string when Default external encoding is something different
+        Puppet::FileSystem.exclusive_open(file, 0660, 'w') do |fh|
+          # note Ruby behavior which has no external_encoding, but implicitly uses Encoding.default_external
+          expect(fh.external_encoding).to be_nil
+          # write a UTF-8 string to this file
+          fh.write(mixed_utf8)
+        end
+
+        # prove that Ruby implicitly converts read strings back to Encoding.default_external
+        # and that it did that in the previous write
+        written = Puppet::FileSystem.read(file)
+        expect(written.encoding).to eq(Encoding.default_external)
+        expect(written).to eq(mixed_utf8.force_encoding(Encoding.default_external))
+      ensure
+        # carefully roll back to the previous
+        Encoding.default_external = original_encoding
+      end
     end
 
     it "excludes other processes from updating at the same time", :unless => Puppet::Util::Platform.windows? do
@@ -134,6 +260,17 @@ describe "Puppet::FileSystem" do
     end
   end
 
+  context "read without an encoding specified" do
+    it "returns strings as Encoding.default_external" do
+      temp_file = file_containing('test.txt', 'hello world')
+
+      contents = Puppet::FileSystem.read(temp_file)
+
+      expect(contents.encoding).to eq(Encoding.default_external)
+      expect(contents).to eq('hello world')
+    end
+  end
+
   context "read should allow an encoding to be specified" do
     # First line of Rune version of Rune poem at http://www.columbia.edu/~fdc/utf8/
     # characters chosen since they will not parse on Windows with codepage 437 or 1252