puppet 6.26.0-x86-mingw32 → 7.0.0-x86-mingw32

data/spec/integration/transaction/report_spec.rb

@@ -48,7 +48,7 @@ describe Puppet::Transaction::Report do
       expect(Puppet::Transaction::Report.indirection).to receive(:save) do |report, x|
         last_run_report = report
         true
-      end.exactly(4)
+      end.twice
 
       Puppet[:report] = true
       Puppet[:noop] = noop1

data/spec/integration/transaction_spec.rb

@@ -61,7 +61,7 @@ describe Puppet::Transaction do
 
     transaction = Puppet::Transaction.new(catalog, nil, Puppet::Graph::SequentialPrioritizer.new)
 
-    expect(resource).not_to receive(:retrieve)
+    expect(resource).not_to receive(:evaluate)
 
     transaction.evaluate
   end
@@ -86,7 +86,7 @@ describe Puppet::Transaction do
 
     transaction = Puppet::Transaction.new(catalog, nil, Puppet::Graph::SequentialPrioritizer.new)
 
-    expect(resource).not_to receive(:retrieve)
+    expect(resource).not_to receive(:evaluate)
 
     transaction.evaluate
   end
@@ -315,14 +315,16 @@ describe Puppet::Transaction do
         file1 = tmpfile("file1")
         file2 = tmpfile("file2")
 
-        expect(Puppet::FileSystem).to_not be_exist(file2)
-
         exec1 = Puppet::Type.type(:exec).new(
           :name        => "exec1",
           :path        => ENV["PATH"],
           :command     => touch(file1),
         )
 
+        allow(exec1).to receive(:eval_generate).and_return(
+          [ Puppet::Type.type(:notify).new(:name => "eval1_notify") ]
+        )
+
         exec2 = Puppet::Type.type(:exec).new(
           :name        => "exec2",
           :path        => ENV["PATH"],
@@ -330,6 +332,9 @@ describe Puppet::Transaction do
           :refreshonly => true,
           :subscribe   => exec1,
         )
+        allow(exec2).to receive(:eval_generate).and_return(
+          [ Puppet::Type.type(:notify).new(:name => "eval2_notify") ]
+        )
 
         Puppet[:tags] = "exec"
         catalog = mk_catalog(exec1, exec2)

data/spec/integration/type/exec_spec.rb

@@ -7,95 +7,70 @@ describe Puppet::Type.type(:exec), unless: Puppet::Util::Platform.jruby? do
 
   let(:catalog) { Puppet::Resource::Catalog.new }
   let(:path) { tmpfile('exec_provider') }
+  let(:command) { "ruby -e 'File.open(\"#{path}\", \"w\") { |f| f.print \"foo\" }'" }
 
   before :each do
     catalog.host_config = false
   end
 
-  shared_examples_for 'a valid exec resource' do
-    it "should execute the command" do
-      exec = described_class.new :command => command, :path => ENV['PATH']
+  it "should execute the command" do
+    exec = described_class.new :command => command, :path => ENV['PATH']
 
-      catalog.add_resource exec
-      catalog.apply
+    catalog.add_resource exec
+    catalog.apply
 
-      expect(File.read(path)).to eq('foo')
-    end
-
-    it "should not execute the command if onlyif returns non-zero" do
-      exec = described_class.new(
-        :command => command,
-        :onlyif => "ruby -e 'exit 44'",
-        :path => ENV['PATH']
-      )
-
-      catalog.add_resource exec
-      catalog.apply
-
-      expect(Puppet::FileSystem.exist?(path)).to be_falsey
-    end
-
-    it "should execute the command if onlyif returns zero" do
-      exec = described_class.new(
-        :command => command,
-        :onlyif => "ruby -e 'exit 0'",
-        :path => ENV['PATH']
-      )
-
-      catalog.add_resource exec
-      catalog.apply
-
-      expect(File.read(path)).to eq('foo')
-    end
+    expect(File.read(path)).to eq('foo')
+  end
 
-    it "should execute the command if unless returns non-zero" do
-      exec = described_class.new(
-        :command => command,
-        :unless => "ruby -e 'exit 45'",
-        :path => ENV['PATH']
-      )
+  it "should not execute the command if onlyif returns non-zero" do
+    exec = described_class.new(
+      :command => command,
+      :onlyif => "ruby -e 'exit 44'",
+      :path => ENV['PATH']
+    )
 
-      catalog.add_resource exec
-      catalog.apply
+    catalog.add_resource exec
+    catalog.apply
 
-      expect(File.read(path)).to eq('foo')
-    end
+    expect(Puppet::FileSystem.exist?(path)).to be_falsey
+  end
 
-    it "should not execute the command if unless returns zero" do
-      exec = described_class.new(
-        :command => command,
-        :unless => "ruby -e 'exit 0'",
-        :path => ENV['PATH']
-      )
+  it "should execute the command if onlyif returns zero" do
+    exec = described_class.new(
+      :command => command,
+      :onlyif => "ruby -e 'exit 0'",
+      :path => ENV['PATH']
+    )
 
-      catalog.add_resource exec
-      catalog.apply
+    catalog.add_resource exec
+    catalog.apply
 
-      expect(Puppet::FileSystem.exist?(path)).to be_falsey
-    end
+    expect(File.read(path)).to eq('foo')
   end
 
-  context 'when command is a string' do
-    let(:command) { "ruby -e 'File.open(\"#{path}\", \"w\") { |f| f.print \"foo\" }'" }
+  it "should execute the command if unless returns non-zero" do
+    exec = described_class.new(
+      :command => command,
+      :unless => "ruby -e 'exit 45'",
+      :path => ENV['PATH']
+    )
 
-    it_behaves_like 'a valid exec resource'
-  end
+    catalog.add_resource exec
+    catalog.apply
 
-  context 'when command is an array' do
-    let(:command) { ['ruby', '-e', "File.open(\"#{path}\", \"w\") { |f| f.print \"foo\" }"] }
-
-    it_behaves_like 'a valid exec resource'
+    expect(File.read(path)).to eq('foo')
+  end
 
-    context 'when is invalid' do
-      let(:command) { [ "ruby -e 'puts 1'" ] }
+  it "should not execute the command if unless returns zero" do
+    exec = described_class.new(
+      :command => command,
+      :unless => "ruby -e 'exit 0'",
+      :path => ENV['PATH']
+    )
 
-      it 'logs error' do
-        exec = described_class.new :command => command, :path => ENV['PATH']
-        catalog.add_resource exec
-        logs = catalog.apply.report.logs
+    catalog.add_resource exec
+    catalog.apply
 
-        expect(logs[0].message).to eql("Could not find command 'ruby -e 'puts 1''")
-      end
-    end
+    expect(Puppet::FileSystem.exist?(path)).to be_falsey
   end
 end

data/spec/integration/type/file_spec.rb

@@ -1,3 +1,4 @@
+# coding: utf-8
 require 'spec_helper'
 
 require 'puppet_spec/files'
@@ -657,9 +658,9 @@ describe Puppet::Type.type(:file), :uses_checksums => true do
 
     CHECKSUM_TYPES_TO_TRY.each do |checksum_type, checksum|
       describe "when checksum_type is #{checksum_type}" do
-        # FileBucket uses the globally configured default for lookup by digest, which right now is MD5.
+        # FileBucket uses the globally configured default for lookup by digest, which right now is SHA256.
         it_should_behave_like "files are backed up", {:checksum => checksum_type} do
-          let(:filebucket_digest) { Proc.new {|x| Puppet::Util::Checksums.md5(x)} }
+          let(:filebucket_digest) { Proc.new {|x| Puppet::Util::Checksums.sha256(x)} }
         end
       end
     end
@@ -1709,11 +1710,11 @@ describe Puppet::Type.type(:file), :uses_checksums => true do
 
   describe "when using validate_cmd" do
     test_cmd = '/bin/test'
-    if Puppet.runtime[:facter].value(:osfamily) == 'Debian'
+    if Facter.value(:osfamily) == 'Debian'
       test_cmd = '/usr/bin/test'
     end
 
-    if Puppet.runtime[:facter].value(:operatingsystem) == 'Darwin'
+    if Facter.value(:operatingsystem) == 'Darwin'
       stat_cmd = "stat -f '%Lp'"
     else
       stat_cmd = "stat --format=%a"
@@ -1727,7 +1728,7 @@ describe Puppet::Type.type(:file), :uses_checksums => true do
                                                #{test_cmd} "644" == "$(#{stat_cmd} ^)"
                                                }))
       report = catalog.apply.report
-      expect(report.resource_statuses["File[#{path}]"].events.first.message).to match(/defined content as '{md5}/)
+      expect(report.resource_statuses["File[#{path}]"].events.first.message).to match(/defined content as '{sha256}/)
       expect(report.resource_statuses["File[#{path}]"]).not_to be_failed
       expect(Puppet::FileSystem.exist?(path)).to be_truthy
     end
@@ -1741,7 +1742,7 @@ describe Puppet::Type.type(:file), :uses_checksums => true do
                                                #{test_cmd} "555" == "$(#{stat_cmd} ^)"
                                                }))
       report = catalog.apply.report
-      expect(report.resource_statuses["File[#{path}]"].events.first.message).to match(/defined content as '{md5}/)
+      expect(report.resource_statuses["File[#{path}]"].events.first.message).to match(/defined content as '{sha256}/)
       expect(report.resource_statuses["File[#{path}]"]).not_to be_failed
       expect(Puppet::FileSystem.exist?(path)).to be_truthy
     end

data/spec/integration/type/package_spec.rb

@@ -9,7 +9,7 @@ describe Puppet::Type.type(:package), "when choosing a default package provider"
   def provider_name(os)
     case os
     when 'Solaris'
-      if Puppet::Util::Package.versioncmp(Puppet.runtime[:facter].value(:kernelrelease), '5.11') >= 0
+      if Puppet::Util::Package.versioncmp(Facter.value(:kernelrelease), '5.11') >= 0
         :pkg
       else
         :sun
@@ -21,19 +21,19 @@ describe Puppet::Type.type(:package), "when choosing a default package provider"
     when 'Darwin'
       :pkgdmg
     when 'RedHat'
-      if ['2.1', '3', '4'].include?(Puppet.runtime[:facter].value(:lsbdistrelease))
+      if ['2.1', '3', '4'].include?(Facter.value(:lsbdistrelease))
         :up2date
       else
         :yum
       end
     when 'Fedora'
-      if Puppet::Util::Package.versioncmp(Puppet.runtime[:facter].value(:operatingsystemmajrelease), '22') >= 0
+      if Puppet::Util::Package.versioncmp(Facter.value(:operatingsystemmajrelease), '22') >= 0
         :dnf
       else
         :yum
       end
     when 'Suse'
-      if Puppet::Util::Package.versioncmp(Puppet.runtime[:facter].value(:operatingsystemmajrelease), '10') >= 0
+      if Puppet::Util::Package.versioncmp(Facter.value(:operatingsystemmajrelease), '10') >= 0
         :zypper
       else
         :rug
@@ -54,8 +54,8 @@ describe Puppet::Type.type(:package), "when choosing a default package provider"
   end
 
   it "should choose the correct provider each platform" do
-    unless default_provider = provider_name(Puppet.runtime[:facter].value(:operatingsystem))
-      pending("No default provider specified in this test for #{Puppet.runtime[:facter].value(:operatingsystem)}")
+    unless default_provider = provider_name(Facter.value(:operatingsystem))
+      pending("No default provider specified in this test for #{Facter.value(:operatingsystem)}")
     end
     expect(Puppet::Type.type(:package).defaultprovider.name).to eq(default_provider)
   end

data/spec/integration/util/rdoc/parser_spec.rb

@@ -91,7 +91,7 @@ end
         File.join(modules_dir, 'a_module', 'lib', 'facter', 'a_fact.rb'),
         <<-EOF
 # The a_fact fact comment
-Puppet.runtime[:facter].add("a_fact") do
+Facter.add("a_fact") do
 end
         EOF
       ],

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

@@ -55,24 +55,6 @@ describe Puppet::Util::Windows::ADSI::User,
       end
     end
   end
-
-  describe '.current_user_name_with_format' do
-    context 'when desired format is NameSamCompatible' do
-      it 'should get the same user name as the current_user_name method but fully qualified' do
-        user_name = Puppet::Util::Windows::ADSI::User.current_user_name
-        fully_qualified_user_name = Puppet::Util::Windows::ADSI::User.current_sam_compatible_user_name
-
-        expect(fully_qualified_user_name).to match(/^.+\\#{user_name}$/)
-      end
-
-      it 'should have the same SID as with the current_user_name method' do
-        user_name = Puppet::Util::Windows::ADSI::User.current_user_name
-        fully_qualified_user_name = Puppet::Util::Windows::ADSI::User.current_sam_compatible_user_name
-
-        expect(Puppet::Util::Windows::SID.name_to_sid(user_name)).to eq(Puppet::Util::Windows::SID.name_to_sid(fully_qualified_user_name))
-      end
-    end
-  end
 end
 
 describe Puppet::Util::Windows::ADSI::Group,
@@ -175,9 +157,7 @@ describe Puppet::Util::Windows::ADSI::Group,
 
       # touch the native_object member to have it lazily loaded, so COM objects can be stubbed
       admins.native_object
-      without_partial_double_verification do
-        allow(admins.native_object).to receive(:Members).and_return(members)
-      end
+      allow(admins.native_object).to receive(:Members).and_return(members)
 
       # well-known NULL SID
       expect(admins.members[0].sid).to eq('S-1-0-0')

data/spec/integration/util/windows/monkey_patches/process_spec.rb

@@ -0,0 +1,231 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe 'Process', if: Puppet::Util::Platform.windows? do
+  describe '.create' do
+    context 'with common flags' do
+      it do
+        Process.create(
+          app_name: 'cmd.exe /c echo 123',
+          creation_flags: 0x00000008,
+          process_inherit: false,
+          thread_inherit: false,
+          cwd: 'C:\\'
+        )
+      end
+
+      context 'when FFI call fails' do
+        before do
+          allow(Process).to receive(:CreateProcessW).and_return(false)
+        end
+
+        it 'raises SystemCallError' do
+          expect do
+            Process.create(
+              app_name: 'cmd.exe /c echo 123',
+              creation_flags: 0x00000008
+            )
+          end.to raise_error(SystemCallError)
+        end
+      end
+    end
+
+    context 'with logon' do
+      context 'without password' do
+        it 'raises error' do
+          expect do
+            Process.create(
+              app_name: 'cmd.exe /c echo 123',
+              creation_flags: 0x00000008,
+              with_logon: 'test'
+            )
+          end.to raise_error(ArgumentError, 'password must be specified if with_logon is used')
+        end
+      end
+
+      context 'with common flags' do
+        before do
+          allow(Process).to receive(:CreateProcessWithLogonW).and_return(true)
+        end
+
+        it do
+          Process.create(
+            app_name: 'cmd.exe /c echo 123',
+            creation_flags: 0x00000008,
+            process_inherit: false,
+            thread_inherit: false,
+            with_logon: 'test',
+            password: 'password',
+            cwd: 'C:\\'
+          )
+        end
+
+        context 'when FFI call fails' do
+          before do
+            allow(Process).to receive(:CreateProcessWithLogonW).and_return(false)
+          end
+
+          it 'raises SystemCallError' do
+            expect do
+              Process.create(
+                app_name: 'cmd.exe /c echo 123',
+                creation_flags: 0x00000008,
+                with_logon: 'test',
+                password: 'password'
+              )
+            end.to raise_error(SystemCallError)
+          end
+        end
+      end
+    end
+
+    describe 'validations' do
+      context 'when args is not a hash' do
+        it 'raises TypeError' do
+          expect do
+            Process.create('test')
+          end.to raise_error(TypeError, 'hash keyword arguments expected')
+        end
+      end
+
+      context 'when args key is invalid' do
+        it 'raises ArgumentError' do
+          expect do
+            Process.create(invalid_key: 'test')
+          end.to raise_error(ArgumentError, "invalid key 'invalid_key'")
+        end
+      end
+
+      context 'when startup_info is invalid' do
+        it 'raises ArgumentError' do
+          expect do
+            Process.create(startup_info: { invalid_key: 'test' })
+          end.to raise_error(ArgumentError, "invalid startup_info key 'invalid_key'")
+        end
+      end
+
+      context 'when app_name and command_line are missing' do
+        it 'raises ArgumentError' do
+          expect do
+            Process.create(creation_flags: 0)
+          end.to raise_error(ArgumentError, 'command_line or app_name must be specified')
+        end
+      end
+
+      context 'when executable is not found' do
+        it 'raises Errno::ENOENT' do
+          expect do
+            Process.create(app_name: 'non_existent')
+          end.to raise_error(Errno::ENOENT)
+        end
+      end
+    end
+
+    context 'when environment is not specified' do
+      it 'passes local environment' do
+        stdout_read, stdout_write = IO.pipe
+        ENV['TEST_ENV'] = 'B'
+
+        Process.create(
+          app_name: 'cmd.exe /c echo %TEST_ENV%',
+          creation_flags: 0x00000008,
+          startup_info: { stdout: stdout_write }
+        )
+
+        stdout_write.close
+        expect(stdout_read.read.chomp).to eql('B')
+      end
+    end
+
+    context 'when environment is specified' do
+      it 'does not pass local environment' do
+        stdout_read, stdout_write = IO.pipe
+        ENV['TEST_ENV'] = 'B'
+
+        Process.create(
+          app_name: 'cmd.exe /c echo %TEST_ENV%',
+          creation_flags: 0x00000008,
+          environment: '',
+          startup_info: { stdout: stdout_write }
+        )
+
+        stdout_write.close
+        expect(stdout_read.read.chomp).to eql('%TEST_ENV%')
+      end
+
+      it 'supports :environment as a string' do
+        stdout_read, stdout_write = IO.pipe
+
+        Process.create(
+          app_name: 'cmd.exe /c echo %A% %B%',
+          creation_flags: 0x00000008,
+          environment: 'A=C;B=D',
+          startup_info: { stdout: stdout_write }
+        )
+
+        stdout_write.close
+        expect(stdout_read.read.chomp).to eql('C D')
+      end
+
+      it 'supports :environment as a string' do
+        stdout_read, stdout_write = IO.pipe
+
+        Process.create(
+          app_name: 'cmd.exe /c echo %A% %C%',
+          creation_flags: 0x00000008,
+          environment: ['A=B;X;', 'C=;D;Y'],
+          startup_info: { stdout: stdout_write }
+        )
+
+        stdout_write.close
+        expect(stdout_read.read.chomp).to eql('B;X; ;D;Y')
+      end
+    end
+  end
+
+  describe '.setpriority' do
+    let(:priority) { Process::BELOW_NORMAL_PRIORITY_CLASS }
+
+    context 'when success' do
+      it 'returns 0' do
+        expect(Process.setpriority(0, Process.pid, priority)).to eql(0)
+      end
+
+      it 'treats an int argument of zero as the current process' do
+        expect(Process.setpriority(0, 0, priority)).to eql(0)
+      end
+    end
+
+    context 'when invalid arguments are sent' do
+      it 'raises TypeError' do
+        expect {
+          Process.setpriority('test', 0, priority)
+        }.to raise_error(TypeError)
+      end
+    end
+
+    context 'when process is not found' do
+      before do
+        allow(Process).to receive(:OpenProcess).and_return(0)
+      end
+      it 'raises SystemCallError' do
+        expect {
+          Process.setpriority(0, 0, priority)
+        }.to raise_error(SystemCallError)
+      end
+    end
+
+    context 'when priority is not set' do
+      before do
+        allow(Process).to receive(:SetPriorityClass).and_return(false)
+      end
+
+      it 'raises SystemCallError' do
+        expect {
+          Process.setpriority(0, 0, priority)
+        }.to raise_error(SystemCallError)
+      end
+    end
+  end
+end

data/spec/integration/util/windows/principal_spec.rb

@@ -7,7 +7,6 @@ describe Puppet::Util::Windows::SID::Principal, :if => Puppet::Util::Platform.wi
   let (:system_bytes) { [1, 1, 0, 0, 0, 0, 0, 5, 18, 0, 0, 0] }
   let (:null_sid_bytes) { [1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] }
   let (:administrator_bytes) { [1, 2, 0, 0, 0, 0, 0, 5, 32, 0, 0, 0, 32, 2, 0, 0] }
-  let (:all_application_packages_bytes) { [1, 2, 0, 0, 0, 0, 0, 15, 2, 0, 0, 0, 1, 0, 0, 0] }
   let (:computer_sid) { Puppet::Util::Windows::SID.name_to_principal(Puppet::Util::Windows::ADSI.computer_name) }
   # BUILTIN is localized on German Windows, but not French
   # looking this up like this dilutes the values of the tests as we're comparing two mechanisms
@@ -122,26 +121,6 @@ describe Puppet::Util::Windows::SID::Principal, :if => Puppet::Util::Platform.wi
       expect(principal.to_s).to eq(builtin_localized)
     end
 
-    it "should always sanitize the account name first" do
-      expect(Puppet::Util::Windows::SID::Principal).to receive(:sanitize_account_name).with('NT AUTHORITY\\SYSTEM').and_call_original
-      Puppet::Util::Windows::SID::Principal.lookup_account_name('NT AUTHORITY\\SYSTEM')
-    end
-
-    it "should be able to create an instance from an account name prefixed by APPLICATION PACKAGE AUTHORITY" do
-      principal = Puppet::Util::Windows::SID::Principal.lookup_account_name('APPLICATION PACKAGE AUTHORITY\\ALL APPLICATION PACKAGES')
-      expect(principal.account).to eq('ALL APPLICATION PACKAGES')
-      expect(principal.sid_bytes).to eq(all_application_packages_bytes)
-      expect(principal.sid).to eq('S-1-15-2-1')
-      expect(principal.domain).to eq('APPLICATION PACKAGE AUTHORITY')
-      expect(principal.domain_account).to eq('APPLICATION PACKAGE AUTHORITY\\ALL APPLICATION PACKAGES')
-      expect(principal.account_type).to eq(:SidTypeWellKnownGroup)
-      expect(principal.to_s).to eq('APPLICATION PACKAGE AUTHORITY\\ALL APPLICATION PACKAGES')
-    end
-
-    it "should fail without proper account name sanitization when it is prefixed by APPLICATION PACKAGE AUTHORITY" do
-      given_account_name = 'APPLICATION PACKAGE AUTHORITY\\ALL APPLICATION PACKAGES'
-      expect { Puppet::Util::Windows::SID::Principal.lookup_account_name(nil, false, given_account_name) }.to raise_error(Puppet::Util::Windows::Error, /No mapping between account names and security IDs was done./)
-    end
   end
 
   describe ".lookup_account_sid" do

data/spec/integration/util/windows/process_spec.rb

@@ -1,14 +1,22 @@
 require 'spec_helper'
+require 'facter'
 
 describe "Puppet::Util::Windows::Process", :if => Puppet::Util::Platform.windows?  do
   describe "as an admin" do
-    it "should have the SeCreateSymbolicLinkPrivilege necessary to create symlinks" do
+    it "should have the SeCreateSymbolicLinkPrivilege necessary to create symlinks on Vista / 2008+",
+      :if => Facter.value(:kernelmajversion).to_f >= 6.0 && Puppet::Util::Platform.windows? do
       # this is a bit of a lame duck test since it requires running user to be admin
       # a better integration test would create a new user with the privilege and verify
       expect(Puppet::Util::Windows::User).to be_admin
       expect(Puppet::Util::Windows::Process.process_privilege_symlink?).to be_truthy
     end
 
+    it "should not have the SeCreateSymbolicLinkPrivilege necessary to create symlinks on 2003 and earlier",
+      :if => Facter.value(:kernelmajversion).to_f < 6.0 && Puppet::Util::Platform.windows? do
+      expect(Puppet::Util::Windows::User).to be_admin
+      expect(Puppet::Util::Windows::Process.process_privilege_symlink?).to be_falsey
+    end
+
     it "should be able to lookup a standard Windows process privilege" do
       Puppet::Util::Windows::Process.lookup_privilege_value('SeShutdownPrivilege') do |luid|
         expect(luid).not_to be_nil

data/spec/integration/util/windows/registry_spec.rb

@@ -146,6 +146,16 @@ describe Puppet::Util::Windows::Registry do
         utf_8_bytes = ENDASH_UTF_8 + TM_UTF_8
         utf_8_str = utf_8_bytes.pack('c*').force_encoding(Encoding::UTF_8)
 
+        # this problematic Ruby codepath triggers a conversion of UTF-16LE to
+        # a local codepage which can totally break when that codepage has no
+        # conversion from the given UTF-16LE characters to local codepage
+        # a prime example is that IBM437 has no conversion from a Unicode en-dash
+        expect(Win32::Registry).not_to receive(:export_string)
+
+        # also, expect that we're using our variants of keys / values, not Rubys
+        expect(Win32::Registry).not_to receive(:each_key)
+        expect(Win32::Registry).not_to receive(:each_value)
+
         hklm.create("#{puppet_key}\\#{subkey_name}", Win32::Registry::KEY_ALL_ACCESS | regsam) do |reg|
           reg.write("#{guid}", Win32::Registry::REG_SZ, utf_16_str)
 
@@ -263,12 +273,6 @@ describe Puppet::Util::Windows::Registry do
           type: Win32::Registry::REG_EXPAND_SZ,
           value: "\0\0\0reg expand string",
           expected_value: ""
-        },
-        {
-          name: 'REG_EXPAND_SZ_2',
-          type: Win32::Registry::REG_EXPAND_SZ,
-          value: "1\x002\x003\x004\x00\x00\x00\x90\xD8UoY".force_encoding("UTF-16LE"),
-          expected_value: "1234"
         }
       ].each do |pair|
         it 'reads up to the first wide null' do

data/spec/integration/util/windows/security_spec.rb

@@ -822,7 +822,7 @@ describe "Puppet::Util::Windows::Security", :if => Puppet::Util::Platform.window
     end
 
     describe "locked files" do
-      let (:explorer) { File.join(Dir::WINDOWS, "explorer.exe") }
+      let (:explorer) { File.join(ENV['SystemRoot'], "explorer.exe") }
 
       it "should get the owner" do
         expect(winsec.get_owner(explorer)).to match(/^S-1-5-/)