puppet 4.3.2-x64-mingw32 → 4.4.0-x64-mingw32

data/spec/unit/util/network_device/transport/telnet_spec.rb

@@ -1,84 +1,86 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
 
-require 'puppet/util/network_device/transport/telnet'
+if Puppet.features.telnet?
+  require 'puppet/util/network_device/transport/telnet'
 
-describe Puppet::Util::NetworkDevice::Transport::Telnet do
+  describe Puppet::Util::NetworkDevice::Transport::Telnet do
 
-  before(:each) do
-    TCPSocket.stubs(:open).returns stub_everything('tcp')
-    @transport = Puppet::Util::NetworkDevice::Transport::Telnet.new()
-  end
-
-  it "should not handle login through the transport" do
-    expect(@transport).not_to be_handles_login
-  end
-
-  it "should not open any files" do
-    File.expects(:open).never
-    @transport.host = "localhost"
-    @transport.port = 23
-
-    @transport.connect
-  end
+    before(:each) do
+      TCPSocket.stubs(:open).returns stub_everything('tcp')
+      @transport = Puppet::Util::NetworkDevice::Transport::Telnet.new()
+    end
 
-  it "should connect to the given host and port" do
-    Net::Telnet.expects(:new).with { |args| args["Host"] == "localhost" && args["Port"] == 23 }.returns stub_everything
-    @transport.host = "localhost"
-    @transport.port = 23
+    it "should not handle login through the transport" do
+      expect(@transport).not_to be_handles_login
+    end
 
-    @transport.connect
-  end
+    it "should not open any files" do
+      File.expects(:open).never
+      @transport.host = "localhost"
+      @transport.port = 23
 
-  it "should connect and specify the default prompt" do
-    @transport.default_prompt = "prompt"
-    Net::Telnet.expects(:new).with { |args| args["Prompt"] == "prompt" }.returns stub_everything
-    @transport.host = "localhost"
-    @transport.port = 23
+      @transport.connect
+    end
 
-    @transport.connect
-  end
+    it "should connect to the given host and port" do
+      Net::Telnet.expects(:new).with { |args| args["Host"] == "localhost" && args["Port"] == 23 }.returns stub_everything
+      @transport.host = "localhost"
+      @transport.port = 23
 
-  describe "when connected" do
-    before(:each) do
-      @telnet = stub_everything 'telnet'
-      Net::Telnet.stubs(:new).returns(@telnet)
       @transport.connect
     end
 
-    it "should send line to the telnet session" do
-      @telnet.expects(:puts).with("line")
-      @transport.send("line")
+    it "should connect and specify the default prompt" do
+      @transport.default_prompt = "prompt"
+      Net::Telnet.expects(:new).with { |args| args["Prompt"] == "prompt" }.returns stub_everything
+      @transport.host = "localhost"
+      @transport.port = 23
+
+      @transport.connect
     end
 
-    describe "when expecting output" do
-      it "should waitfor output on the telnet session" do
-        @telnet.expects(:waitfor).with(/regex/)
-        @transport.expect(/regex/)
+    describe "when connected" do
+      before(:each) do
+        @telnet = stub_everything 'telnet'
+        Net::Telnet.stubs(:new).returns(@telnet)
+        @transport.connect
       end
 
-      it "should return telnet session output" do
-        @telnet.expects(:waitfor).returns("output")
-        expect(@transport.expect(/regex/)).to eq("output")
+      it "should send line to the telnet session" do
+        @telnet.expects(:puts).with("line")
+        @transport.send("line")
       end
 
-      it "should yield telnet session output to the given block" do
-        @telnet.expects(:waitfor).yields("output")
-        @transport.expect(/regex/) { |out| expect(out).to eq("output") }
+      describe "when expecting output" do
+        it "should waitfor output on the telnet session" do
+          @telnet.expects(:waitfor).with(/regex/)
+          @transport.expect(/regex/)
+        end
+
+        it "should return telnet session output" do
+          @telnet.expects(:waitfor).returns("output")
+          expect(@transport.expect(/regex/)).to eq("output")
+        end
+
+        it "should yield telnet session output to the given block" do
+          @telnet.expects(:waitfor).yields("output")
+          @transport.expect(/regex/) { |out| expect(out).to eq("output") }
+        end
       end
     end
-  end
 
-  describe "when closing" do
-    before(:each) do
-      @telnet = stub_everything 'telnet'
-      Net::Telnet.stubs(:new).returns(@telnet)
-      @transport.connect
-    end
+    describe "when closing" do
+      before(:each) do
+        @telnet = stub_everything 'telnet'
+        Net::Telnet.stubs(:new).returns(@telnet)
+        @transport.connect
+      end
 
-    it "should close the telnet session" do
-      @telnet.expects(:close)
-      @transport.close
+      it "should close the telnet session" do
+        @telnet.expects(:close)
+        @transport.close
+      end
     end
   end
 end

data/spec/unit/util/plist_spec.rb

@@ -0,0 +1,110 @@
+require 'spec_helper'
+require 'puppet/util/plist' if Puppet.features.cfpropertylist?
+require 'puppet_spec/files'
+
+module Puppet::Util::Plist; end
+
+describe Puppet::Util::Plist, :if => Puppet.features.cfpropertylist? do
+  include PuppetSpec::Files
+
+  let(:valid_xml_plist) do
+    '<?xml version="1.0" encoding="UTF-8"?>
+     <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+     <plist version="1.0">
+     <dict>
+       <key>LastUsedPrinters</key>
+       <array>
+         <dict>
+                 <key>Network</key>
+                 <string>10.85.132.1</string>
+                 <key>PrinterID</key>
+                 <string>baskerville_corp_puppetlabs_net</string>
+         </dict>
+         <dict>
+                 <key>Network</key>
+                 <string>10.14.96.1</string>
+                 <key>PrinterID</key>
+                 <string>Statler</string>
+         </dict>
+       </array>
+    </dict>
+    </plist>'
+  end
+  let(:invalid_xml_plist) do
+    '<?xml version="1.0" encoding="UTF-8"?>
+     <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+     <plist version="1.0">
+     <dict>
+       <key>LastUsedPrinters</key>
+       <array>
+         <dict>
+                 <!-- this comment is --terrible -->
+                 <key>Network</key>
+                 <string>10.85.132.1</string>
+                 <key>PrinterID</key>
+                 <string>baskerville_corp_puppetlabs_net</string>
+         </dict>
+         <dict>
+                 <key>Network</key>
+                 <string>10.14.96.1</string>
+                 <key>PrinterID</key>
+                 <string>Statler</string>
+         </dict>
+       </array>
+    </dict>
+    </plist>'
+  end
+  let(:valid_xml_plist_hash) { {"LastUsedPrinters"=>[{"Network"=>"10.85.132.1", "PrinterID"=>"baskerville_corp_puppetlabs_net"}, {"Network"=>"10.14.96.1", "PrinterID"=>"Statler"}]} }
+  let(:plist_path) { file_containing('sample.plist', valid_xml_plist) }
+  let(:binary_plist_magic_number) { 'bplist00' }
+  let(:bad_xml_doctype) { '<!DOCTYPE plist PUBLIC -//Apple Computer' }
+  let(:good_xml_doctype) { '<!DOCTYPE plist PUBLIC "-//Apple Computer//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">' }
+
+  describe "#read_plist_file" do
+    it "calls #convert_cfpropertylist_to_native_types on a plist object when a valid binary plist is read" do
+      subject.stubs(:read_file_with_offset).with(plist_path, 8).returns(binary_plist_magic_number)
+      subject.stubs(:new_cfpropertylist).with({:file => plist_path}).returns('plist_object')
+      subject.expects(:convert_cfpropertylist_to_native_types).with('plist_object').returns('plist_hash')
+      expect(subject.read_plist_file(plist_path)).to eq('plist_hash')
+    end
+    it "returns a valid hash when a valid XML plist is read" do
+      subject.stubs(:read_file_with_offset).with(plist_path, 8).returns('notbinary')
+      subject.stubs(:open_file_with_args).with(plist_path, 'r:UTF-8').returns(valid_xml_plist)
+      expect(subject.read_plist_file(plist_path)).to eq(valid_xml_plist_hash)
+    end
+    it "raises a debug message and replaces a bad XML plist doctype should one be encountered" do
+      subject.stubs(:read_file_with_offset).with(plist_path, 8).returns('notbinary')
+      subject.stubs(:open_file_with_args).with(plist_path, 'r:UTF-8').returns(bad_xml_doctype)
+      subject.expects(:new_cfpropertylist).with({:data => good_xml_doctype}).returns('plist_object')
+      subject.stubs(:convert_cfpropertylist_to_native_types).with('plist_object').returns('plist_hash')
+      Puppet.expects(:debug).with("Had to fix plist with incorrect DOCTYPE declaration: #{plist_path}")
+      expect(subject.read_plist_file(plist_path)).to eq('plist_hash')
+    end
+    it "attempts to read pure xml using plutil when reading an improperly formatted service plist" do
+      subject.stubs(:read_file_with_offset).with(plist_path, 8).returns('notbinary')
+      subject.stubs(:open_file_with_args).with(plist_path, 'r:UTF-8').returns(invalid_xml_plist)
+      Puppet.expects(:debug).with(regexp_matches(/^Failed with CFFormatError/))
+      Puppet.expects(:debug).with("Plist #{plist_path} ill-formatted, converting with plutil")
+      Puppet::Util::Execution.expects(:execute).with(['/usr/bin/plutil', '-convert', 'xml1', '-o', '/dev/stdout', plist_path],
+                                                     {:failonfail => true, :combine => true}).returns(valid_xml_plist)
+      expect(subject.read_plist_file(plist_path)).to eq(valid_xml_plist_hash)
+    end
+  end
+
+  describe "#parse_plist" do
+    it "returns a valid hash when a valid XML plist is provided" do
+      expect(subject.parse_plist(valid_xml_plist)).to eq(valid_xml_plist_hash)
+    end
+    it "raises a debug message and replaces a bad XML plist doctype should one be encountered" do
+      subject.expects(:new_cfpropertylist).with({:data => good_xml_doctype}).returns('plist_object')
+      subject.stubs(:convert_cfpropertylist_to_native_types).with('plist_object')
+      Puppet.expects(:debug).with("Had to fix plist with incorrect DOCTYPE declaration: #{plist_path}")
+      subject.parse_plist(bad_xml_doctype, plist_path)
+    end
+    it "raises a debug message with malformed plist" do
+      subject.stubs(:convert_cfpropertylist_to_native_types).with('plist_object')
+      Puppet.expects(:debug).with(regexp_matches(/^Failed with CFFormatError/))
+      subject.parse_plist("<plist><dict><key>Foo</key>")
+    end
+  end
+end

data/spec/unit/util/resource_template_spec.rb

@@ -20,7 +20,7 @@ describe Puppet::Util::ResourceTemplate do
   describe "when evaluating" do
     before do
       Puppet::FileSystem.stubs(:exist?).returns true
-      File.stubs(:read).returns "eh"
+      Puppet::FileSystem.stubs(:read).returns "eh"
 
       @template = stub 'template', :result => nil
       ERB.stubs(:new).returns @template
@@ -38,7 +38,7 @@ describe Puppet::Util::ResourceTemplate do
     end
 
     it "should create a template instance with the contents of the file" do
-      File.expects(:read).with("/my/template").returns "yay"
+      Puppet::FileSystem.expects(:read).with("/my/template", :encoding => 'utf-8').returns "yay"
       ERB.expects(:new).with("yay", 0, "-").returns(@template)
 
       @wrapper.stubs :set_resource_variables

data/spec/unit/util/run_mode_spec.rb

@@ -261,6 +261,30 @@ describe Puppet::Util::RunMode do
         end
       end
     end
+
+    describe "#without_env internal helper with UTF8 characters" do
+      let(:varname) { "\u16A0\u16C7\u16BB\u16EB\u16D2\u16E6\u16A6\u16EB\u16A0\u16B1\u16A9\u16A0\u16A2\u16B1\u16EB\u16A0\u16C1\u16B1\u16AA\u16EB\u16B7\u16D6\u16BB\u16B9\u16E6\u16DA\u16B3\u16A2\u16D7" }
+      let(:rune_utf8) { "\u16A0\u16C7\u16BB\u16EB\u16D2\u16E6\u16A6\u16EB\u16A0\u16B1\u16A9\u16A0\u16A2\u16B1\u16EB\u16A0\u16C1\u16B1\u16AA\u16EB\u16B7\u16D6\u16BB\u16B9\u16E6\u16DA\u16B3\u16A2\u16D7" }
+
+      before do
+        Puppet::Util::Windows::Process.set_environment_variable(varname, rune_utf8)
+      end
+
+      it "removes environment variables within the block with UTF8 name" do
+        without_env(varname) do
+          expect(ENV[varname]).to be(nil)
+        end
+      end
+
+      it "restores UTF8 characters in environment variable values" do
+        without_env(varname) do
+          Puppet::Util::Windows::Process.set_environment_variable(varname, 'bad value')
+        end
+
+        envhash = Puppet::Util::Windows::Process.get_environment_strings
+        expect(envhash[varname]).to eq(rune_utf8)
+      end
+    end
   end
 
   def as_root
@@ -274,11 +298,11 @@ describe Puppet::Util::RunMode do
   end
 
   def without_env(name, &block)
-    saved = ENV[name]
-    ENV.delete name
+    saved = Puppet::Util.get_env(name)
+    Puppet::Util.set_env(name, nil)
     yield
   ensure
-    ENV[name] = saved
+    Puppet::Util.set_env(name, saved)
   end
 
   def without_home(&block)

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

@@ -108,14 +108,14 @@ describe Puppet::Util::Windows::ADSI, :if => Puppet.features.microsoft_windows?
     end
 
     it "should be able to confirm the existence of a user with a well-known SID" do
-      system_user = Win32::Security::SID::LocalSystem
+      system_user = Puppet::Util::Windows::SID::LocalSystem
       # ensure that the underlying OS is queried here
       Puppet::Util::Windows::ADSI.unstub(:connect)
       expect(Puppet::Util::Windows::ADSI::User.exists?(system_user)).to be_truthy
     end
 
     it "should return false with a well-known Group SID" do
-      group = Win32::Security::SID::BuiltinAdministrators
+      group = Puppet::Util::Windows::SID::BuiltinAdministrators
       # ensure that the underlying OS is queried here
       Puppet::Util::Windows::ADSI.unstub(:connect)
       expect(Puppet::Util::Windows::ADSI::User.exists?(group)).to be_falsey
@@ -446,14 +446,14 @@ describe Puppet::Util::Windows::ADSI, :if => Puppet.features.microsoft_windows?
 
     it "should be able to confirm the existence of a group with a well-known SID" do
 
-      service_group = Win32::Security::SID::Service
+      service_group = Puppet::Util::Windows::SID::Service
       # ensure that the underlying OS is queried here
       Puppet::Util::Windows::ADSI.unstub(:connect)
       expect(Puppet::Util::Windows::ADSI::Group.exists?(service_group)).to be_truthy
     end
 
     it "will return true with a well-known User SID, as there is no way to resolve it with a WinNT:// style moniker" do
-      user = Win32::Security::SID::NtLocal
+      user = Puppet::Util::Windows::SID::NtLocal
       # ensure that the underlying OS is queried here
       Puppet::Util::Windows::ADSI.unstub(:connect)
       expect(Puppet::Util::Windows::ADSI::Group.exists?(user)).to be_truthy

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

@@ -25,4 +25,46 @@ describe "FFI::MemoryPointer", :if => Puppet.features.microsoft_windows? do
       expect(read_string.encoding).to eq(Encoding::UTF_8)
     end
   end
+
+  context "read_arbitrary_wide_string_up_to" do
+    let (:string) { "foo_bar" }
+    let (:single_null_string) { string + "\x00" }
+    let (:double_null_string) { string + "\x00\x00" }
+
+    it "should read a short single null terminated string" do
+      read_string = nil
+      FFI::MemoryPointer.from_string_to_wide_string(single_null_string) do |ptr|
+        read_string = ptr.read_arbitrary_wide_string_up_to()
+      end
+
+      expect(read_string).to eq(string)
+    end
+
+    it "should read a short double null terminated string" do
+      read_string = nil
+      FFI::MemoryPointer.from_string_to_wide_string(double_null_string) do |ptr|
+        read_string = ptr.read_arbitrary_wide_string_up_to(512, :double_null)
+      end
+
+      expect(read_string).to eq(string)
+    end
+
+    it "should return a string of max_length characters when specified" do
+      read_string = nil
+      FFI::MemoryPointer.from_string_to_wide_string(single_null_string) do |ptr|
+        read_string = ptr.read_arbitrary_wide_string_up_to(3)
+      end
+
+      expect(read_string).to eq(string[0..2])
+    end
+
+    it "should return wide strings in UTF-8" do
+      read_string = nil
+      FFI::MemoryPointer.from_string_to_wide_string(string) do |ptr|
+        read_string = ptr.read_arbitrary_wide_string_up_to()
+      end
+
+      expect(read_string.encoding).to eq(Encoding::UTF_8)
+    end
+  end
 end

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

@@ -4,9 +4,9 @@ require 'spec_helper'
 require 'puppet/util/windows'
 
 describe "Puppet::Util::Windows::SecurityDescriptor", :if => Puppet.features.microsoft_windows? do
-  let(:system_sid) { Win32::Security::SID::LocalSystem }
-  let(:admins_sid) { Win32::Security::SID::BuiltinAdministrators }
-  let(:group_sid) { Win32::Security::SID::Nobody }
+  let(:system_sid) { Puppet::Util::Windows::SID::LocalSystem }
+  let(:admins_sid) { Puppet::Util::Windows::SID::BuiltinAdministrators }
+  let(:group_sid) { Puppet::Util::Windows::SID::Nobody }
   let(:new_sid)   { 'S-1-5-32-500-1-2-3' }
 
   def empty_dacl

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

@@ -7,7 +7,7 @@ describe "Puppet::Util::Windows::SID", :if => Puppet.features.microsoft_windows?
   end
 
   let(:subject)      { Puppet::Util::Windows::SID }
-  let(:sid)          { Win32::Security::SID::LocalSystem }
+  let(:sid)          { Puppet::Util::Windows::SID::LocalSystem }
   let(:invalid_sid)  { 'bogus' }
   let(:unknown_sid)  { 'S-0-0-0' }
   let(:unknown_name) { 'chewbacca' }

data/spec/unit/util_spec.rb

@@ -24,13 +24,15 @@ describe Puppet::Util do
   end
 
   describe "#withenv" do
+    let(:mode) { Puppet.features.microsoft_windows? ? :windows : :posix }
+
     before :each do
       @original_path = ENV["PATH"]
       @new_env = {:PATH => "/some/bogus/path"}
     end
 
     it "should change environment variables within the block then reset environment variables to their original values" do
-      Puppet::Util.withenv @new_env do
+      Puppet::Util.withenv @new_env, mode do
         expect(ENV["PATH"]).to eq("/some/bogus/path")
       end
       expect(ENV["PATH"]).to eq(@original_path)
@@ -38,7 +40,7 @@ describe Puppet::Util do
 
     it "should reset environment variables to their original values even if the block fails" do
       begin
-        Puppet::Util.withenv @new_env do
+        Puppet::Util.withenv @new_env, mode do
           expect(ENV["PATH"]).to eq("/some/bogus/path")
           raise "This is a failure"
         end
@@ -50,7 +52,7 @@ describe Puppet::Util do
     it "should reset environment variables even when they are set twice" do
       # Setting Path & Environment parameters in Exec type can cause weirdness
       @new_env["PATH"] = "/someother/bogus/path"
-      Puppet::Util.withenv @new_env do
+      Puppet::Util.withenv @new_env, mode do
         # When assigning duplicate keys, can't guarantee order of evaluation
         expect(ENV["PATH"]).to match(/\/some.*\/bogus\/path/)
       end
@@ -60,12 +62,119 @@ describe Puppet::Util do
     it "should remove any new environment variables after the block ends" do
       @new_env[:FOO] = "bar"
       ENV["FOO"] = nil
-      Puppet::Util.withenv @new_env do
+      Puppet::Util.withenv @new_env, mode do
         expect(ENV["FOO"]).to eq("bar")
       end
       expect(ENV["FOO"]).to eq(nil)
     end
+  end
+
+  describe "#withenv on POSIX", :unless => Puppet.features.microsoft_windows? do
+    it "should preserve case" do
+      # start with lower case key,
+      env_key = SecureRandom.uuid.downcase
+
+      begin
+        original_value = 'hello'
+        ENV[env_key] = original_value
+        new_value = 'goodbye'
+
+        Puppet::Util.withenv({env_key.upcase => new_value}, :posix) do
+          expect(ENV[env_key]).to eq(original_value)
+          expect(ENV[env_key.upcase]).to eq(new_value)
+        end
+
+        expect(ENV[env_key]).to eq(original_value)
+        expect(ENV[env_key.upcase]).to be_nil
+      ensure
+        ENV.delete(env_key)
+      end
+    end
+  end
+
+  describe "#withenv on Windows", :if => Puppet.features.microsoft_windows? do
+
+    let(:process) { Puppet::Util::Windows::Process }
+
+    it "should ignore case" do
+      # start with lower case key, ensuring string is not entirely numeric
+      env_key = SecureRandom.uuid.downcase + 'a'
+
+      begin
+        original_value = 'hello'
+        ENV[env_key] = original_value
+        new_value = 'goodbye'
+
+        Puppet::Util.withenv({env_key.upcase => new_value}, :windows) do
+          expect(ENV[env_key]).to eq(new_value)
+          expect(ENV[env_key.upcase]).to eq(new_value)
+        end
+
+        expect(ENV[env_key]).to eq(original_value)
+        expect(ENV[env_key.upcase]).to eq(original_value)
+      ensure
+        ENV.delete(env_key)
+      end
+    end
+
+    it "works around Ruby bug 8822 (which fails to preserve UTF-8 properly when accessing ENV)" do
+      env_var_name = SecureRandom.uuid
+      utf_8_bytes = [225, 154, 160] # rune ᚠ
+      utf_8_str = env_var_name + utf_8_bytes.pack('c*').force_encoding(Encoding::UTF_8)
 
+      Puppet::Util.withenv({utf_8_str => utf_8_str}, :windows) do
+        # the true Windows environemnt APIs see the variables correctly
+        expect(process.get_environment_strings[utf_8_str]).to eq(utf_8_str)
+
+        # document buggy Ruby behavior here for https://bugs.ruby-lang.org/issues/8822
+        # Ruby retrieves / stores ENV names in the current codepage
+        # when these tests no longer pass, Ruby has fixed its bugs and workarounds can be removed
+        # interestingly we would expect some of these tests to fail when codepage is 65001
+        # but instead the env values are in Encoding::ASCII_8BIT!
+
+        # both a string in UTF-8 and current codepage are deemed valid keys to the hash
+        # which in a sane world shouldn't be true
+        codepage_key = utf_8_str.dup.force_encoding(Encoding.default_external)
+        expect(ENV.key?(codepage_key)).to eq(true)
+        expect(ENV.key?(utf_8_str)).to eq(true)
+        # similarly the value stored at the key is in current codepage and won't match UTF-8 value
+        env_value = ENV[utf_8_str]
+        expect(env_value).to_not eq(utf_8_str)
+        expect(env_value.encoding).to_not eq(Encoding::UTF_8)
+        # but it can be forced back to UTF-8 to make it match.. ugh
+        converted_value = ENV[utf_8_str].dup.force_encoding(Encoding::UTF_8)
+        expect(converted_value).to eq(utf_8_str)
+      end
+
+      # real environment shouldn't have env var anymore
+      expect(process.get_environment_strings[utf_8_str]).to eq(nil)
+    end
+
+    it "should preseve existing environment and should not corrupt UTF-8 environment variables" do
+      env_var_name = SecureRandom.uuid
+      utf_8_bytes = [225, 154, 160] # rune ᚠ
+      utf_8_str = env_var_name + utf_8_bytes.pack('c*').force_encoding(Encoding::UTF_8)
+      env_var_name_utf_8 = utf_8_str
+
+      begin
+        # UTF-8 name and value
+        process.set_environment_variable(env_var_name_utf_8, utf_8_str)
+        # ASCII name / UTF-8 value
+        process.set_environment_variable(env_var_name, utf_8_str)
+
+        original_keys = process.get_environment_strings.keys.to_a
+        Puppet::Util.withenv({}, :windows) { }
+
+        env = process.get_environment_strings
+
+        expect(env[env_var_name]).to eq(utf_8_str)
+        expect(env[env_var_name_utf_8]).to eq(utf_8_str)
+        expect(env.keys.to_a).to eq(original_keys)
+      ensure
+        process.set_environment_variable(env_var_name_utf_8, nil)
+        process.set_environment_variable(env_var_name, nil)
+      end
+    end
   end
 
   describe "#absolute_path?" do
@@ -324,7 +433,8 @@ describe Puppet::Util do
       end
 
       it "should walk the search PATH returning the first executable" do
-        ENV.stubs(:[]).with('PATH').returns(File.expand_path('/bin'))
+        Puppet::Util.stubs(:get_env).with('PATH').returns(File.expand_path('/bin'))
+        Puppet::Util.stubs(:get_env).with('PATHEXT').returns(nil)
 
         expect(Puppet::Util.which('foo')).to eq(path)
       end
@@ -340,11 +450,11 @@ describe Puppet::Util do
 
       describe "when a file extension is specified" do
         it "should walk each directory in PATH ignoring PATHEXT" do
-          ENV.stubs(:[]).with('PATH').returns(%w[/bar /bin].map{|dir| File.expand_path(dir)}.join(File::PATH_SEPARATOR))
+          Puppet::Util.stubs(:get_env).with('PATH').returns(%w[/bar /bin].map{|dir| File.expand_path(dir)}.join(File::PATH_SEPARATOR))
+          Puppet::Util.stubs(:get_env).with('PATHEXT').returns('.FOOBAR')
 
           FileTest.expects(:file?).with(File.join(File.expand_path('/bar'), 'foo.CMD')).returns false
 
-          ENV.expects(:[]).with('PATHEXT').never
           expect(Puppet::Util.which('foo.CMD')).to eq(path)
         end
       end
@@ -352,8 +462,8 @@ describe Puppet::Util do
       describe "when a file extension is not specified" do
         it "should walk each extension in PATHEXT until an executable is found" do
           bar = File.expand_path('/bar')
-          ENV.stubs(:[]).with('PATH').returns("#{bar}#{File::PATH_SEPARATOR}#{base}")
-          ENV.stubs(:[]).with('PATHEXT').returns(".EXE#{File::PATH_SEPARATOR}.CMD")
+          Puppet::Util.stubs(:get_env).with('PATH').returns("#{bar}#{File::PATH_SEPARATOR}#{base}")
+          Puppet::Util.stubs(:get_env).with('PATHEXT').returns(".EXE#{File::PATH_SEPARATOR}.CMD")
 
           exts = sequence('extensions')
           FileTest.expects(:file?).in_sequence(exts).with(File.join(bar, 'foo.EXE')).returns false
@@ -365,8 +475,8 @@ describe Puppet::Util do
         end
 
         it "should walk the default extension path if the environment variable is not defined" do
-          ENV.stubs(:[]).with('PATH').returns(base)
-          ENV.stubs(:[]).with('PATHEXT').returns(nil)
+          Puppet::Util.stubs(:get_env).with('PATH').returns(base)
+          Puppet::Util.stubs(:get_env).with('PATHEXT').returns(nil)
 
           exts = sequence('extensions')
           %w[.COM .EXE .BAT].each do |ext|
@@ -378,8 +488,8 @@ describe Puppet::Util do
         end
 
         it "should fall back if no extension matches" do
-          ENV.stubs(:[]).with('PATH').returns(base)
-          ENV.stubs(:[]).with('PATHEXT').returns(".EXE")
+          Puppet::Util.stubs(:get_env).with('PATH').returns(base)
+          Puppet::Util.stubs(:get_env).with('PATHEXT').returns(".EXE")
 
           FileTest.stubs(:file?).with(File.join(base, 'foo.EXE')).returns false
           FileTest.stubs(:file?).with(File.join(base, 'foo')).returns true