puppet 5.5.22-universal-darwin → 6.0.0-universal-darwin

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

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/util/windows'
 
@@ -30,8 +31,8 @@ describe Puppet::Util::Windows::Registry do
     TestRegistry.new
   end
 
-  let(:name) { 'HKEY_LOCAL_MACHINE' }
-  let(:path) { 'Software\Microsoft' }
+  let(:name)   { 'HKEY_LOCAL_MACHINE' }
+  let(:path)   { 'Software\Microsoft' }
 
   context "#root" do
     it "should lookup the root hkey" do
@@ -44,15 +45,17 @@ describe Puppet::Util::Windows::Registry do
   end
 
   context "#open" do
-    let(:hkey)   { double('hklm') }
-    let(:subkey) { double('subkey') }
+    let(:hkey)   { stub 'hklm' }
+    let(:subkey) { stub 'subkey' }
 
     before :each do
-      allow(subject).to receive(:root).and_return(hkey)
+      subject.stubs(:root).returns(hkey)
     end
 
     it "should yield the opened the subkey" do
-      expect(hkey).to receive(:open).with(path, anything).and_yield(subkey)
+      hkey.expects(:open).with do |p, _|
+        expect(p).to eq(path)
+      end.yields(subkey)
 
       yielded = nil
       subject.open(name, path) {|reg| yielded = reg}
@@ -63,7 +66,7 @@ describe Puppet::Util::Windows::Registry do
       [described_class::KEY64, described_class::KEY32].each do |access|
         it "should open the key for read access 0x#{access.to_s(16)}" do
           mode = described_class::KEY_READ | access
-          expect(hkey).to receive(:open).with(path, mode)
+          hkey.expects(:open).with(path, mode)
 
           subject.open(name, path, mode) {|reg| }
         end
@@ -71,14 +74,14 @@ describe Puppet::Util::Windows::Registry do
     end
 
     it "should default to KEY64" do
-      expect(hkey).to receive(:open).with(path, described_class::KEY_READ | described_class::KEY64)
+      hkey.expects(:open).with(path, described_class::KEY_READ | described_class::KEY64)
 
       subject.open(hkey, path) {|hkey| }
     end
 
     it "should raise for a path that doesn't exist" do
-      expect(hkey).to receive(:keyname).and_return('HKEY_LOCAL_MACHINE')
-      expect(hkey).to receive(:open).and_raise(Win32::Registry::Error.new(2)) # file not found
+      hkey.expects(:keyname).returns('HKEY_LOCAL_MACHINE')
+      hkey.expects(:open).raises(Win32::Registry::Error.new(2)) # file not found
       expect do
         subject.open(hkey, 'doesnotexist') {|hkey| }
       end.to raise_error(Puppet::Error, /Failed to open registry key 'HKEY_LOCAL_MACHINE\\doesnotexist'/)
@@ -86,27 +89,34 @@ describe Puppet::Util::Windows::Registry do
   end
 
   context "#values" do
-    let(:key) { double('uninstall') }
+    let(:key) { stub('uninstall') }
 
-    it "should return each value's name and data" do
-      expect(key).not_to receive(:each_value)
-      expect(subject).to receive(:each_value).with(key).and_yield('string', 1, 'foo').and_yield('dword', 4, 0)
+    def expects_registry_value(array)
+      key.expects(:each_value).never
+      subject.expects(:each_value).with(key).multiple_yields(array)
+
+      subject.values(key).first[1]
+    end
 
+    it "should return each value's name and data" do
+      key.expects(:each_value).never
+      subject.expects(:each_value).with(key).multiple_yields(
+        ['string', 1, 'foo'], ['dword', 4, 0]
+      )
       expect(subject.values(key)).to eq({ 'string' => 'foo', 'dword' => 0 })
     end
 
     it "should return an empty hash if there are no values" do
-      expect(key).not_to receive(:each_value)
-      expect(subject).to receive(:each_value).with(key)
+      key.expects(:each_value).never
+      subject.expects(:each_value).with(key)
 
       expect(subject.values(key)).to eq({})
     end
 
     it "passes REG_DWORD through" do
-      expect(key).not_to receive(:each_value)
-      expect(subject).to receive(:each_value).with(key).and_yield('dword', Win32::Registry::REG_DWORD, '1')
+      reg_value = ['dword', Win32::Registry::REG_DWORD, '1']
 
-      value = subject.values(key).first[1]
+      value = expects_registry_value(reg_value)
 
       expect(Integer(value)).to eq(1)
     end
@@ -117,11 +127,11 @@ describe Puppet::Util::Windows::Registry do
       TM_UTF_8 = [0xE2, 0x84, 0xA2]
       TM_UTF_16 = [0x2122]
 
-      let(:hklm) { Win32::Registry::HKEY_LOCAL_MACHINE }
-      let(:puppet_key) { "SOFTWARE\\Puppet Labs"}
-      let(:subkey_name) { "PuppetRegistryTest#{SecureRandom.uuid}" }
-      let(:guid) { SecureRandom.uuid }
-      let(:regsam) { Puppet::Util::Windows::Registry::KEY32 }
+      let (:hklm) { Win32::Registry::HKEY_LOCAL_MACHINE }
+      let (:puppet_key) { "SOFTWARE\\Puppet Labs"}
+      let (:subkey_name) { "PuppetRegistryTest#{SecureRandom.uuid}" }
+      let (:guid) { SecureRandom.uuid }
+      let (:regsam) { Puppet::Util::Windows::Registry::KEY32 }
 
       after(:each) do
         # Ruby 2.1.5 has bugs with deleting registry keys due to using ANSI
@@ -136,7 +146,7 @@ describe Puppet::Util::Windows::Registry do
 
       # proof that local encodings (such as IBM437 are no longer relevant)
       it "will return a UTF-8 string from a REG_SZ registry value (written as UTF-16LE)",
-        :if => Puppet::Util::Platform.windows? && RUBY_VERSION >= '2.1' do
+        :if => Puppet::Util::Platform.windows? do
 
         # create a UTF-16LE byte array representing "–™"
         utf_16_bytes = ENDASH_UTF_16 + TM_UTF_16
@@ -150,11 +160,11 @@ describe Puppet::Util::Windows::Registry do
         # 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)
+        Win32::Registry.expects(:export_string).never
 
         # 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)
+        Win32::Registry.expects(:each_key).never
+        Win32::Registry.expects(:each_value).never
 
         hklm.create("#{puppet_key}\\#{subkey_name}", Win32::Registry::KEY_ALL_ACCESS | regsam) do |reg|
           reg.write("#{guid}", Win32::Registry::REG_SZ, utf_16_str)
@@ -175,10 +185,10 @@ describe Puppet::Util::Windows::Registry do
     end
 
     context "when reading values" do
-      let(:hklm) { Win32::Registry::HKEY_LOCAL_MACHINE }
-      let(:puppet_key) { "SOFTWARE\\Puppet Labs"}
-      let(:subkey_name) { "PuppetRegistryTest#{SecureRandom.uuid}" }
-      let(:value_name) { SecureRandom.uuid }
+      let (:hklm) { Win32::Registry::HKEY_LOCAL_MACHINE }
+      let (:puppet_key) { "SOFTWARE\\Puppet Labs"}
+      let (:subkey_name) { "PuppetRegistryTest#{SecureRandom.uuid}" }
+      let (:value_name) { SecureRandom.uuid }
 
       after(:each) do
         hklm.open(puppet_key, Win32::Registry::KEY_ALL_ACCESS) do |reg|
@@ -216,10 +226,10 @@ describe Puppet::Util::Windows::Registry do
     end
 
     context "when reading corrupt values" do
-      let(:hklm) { Win32::Registry::HKEY_LOCAL_MACHINE }
-      let(:puppet_key) { "SOFTWARE\\Puppet Labs"}
-      let(:subkey_name) { "PuppetRegistryTest#{SecureRandom.uuid}" }
-      let(:value_name) { SecureRandom.uuid }
+      let (:hklm) { Win32::Registry::HKEY_LOCAL_MACHINE }
+      let (:puppet_key) { "SOFTWARE\\Puppet Labs"}
+      let (:subkey_name) { "PuppetRegistryTest#{SecureRandom.uuid}" }
+      let (:value_name) { SecureRandom.uuid }
 
       before(:each) do
         hklm.create("#{puppet_key}\\#{subkey_name}", Win32::Registry::KEY_ALL_ACCESS) do |reg_key|
@@ -242,97 +252,6 @@ describe Puppet::Util::Windows::Registry do
         end
       end
     end
-
-    context 'whean reading null byte' do
-      let(:hklm) { Win32::Registry::HKEY_LOCAL_MACHINE }
-      let(:puppet_key) { 'SOFTWARE\\Puppet Labs' }
-      let(:subkey_name) { "PuppetRegistryTest#{SecureRandom.uuid}" }
-      let(:value_name) { SecureRandom.uuid }
-
-      after(:each) do
-        hklm.open(puppet_key, Win32::Registry::KEY_ALL_ACCESS) do |reg|
-          subject.delete_key(reg, subkey_name)
-        end
-      end
-
-      [
-        {
-          name: 'REG_SZ',
-          type: Win32::Registry::REG_SZ,
-          value: "reg sz\u0000\u0000 string",
-          expected_value: "reg sz"
-        },
-        {
-          name: 'REG_SZ_2',
-          type: Win32::Registry::REG_SZ,
-          value: "reg sz 2\x00\x00 string",
-          expected_value: "reg sz 2"
-        },
-        {
-          name: 'REG_EXPAND_SZ',
-          type: Win32::Registry::REG_EXPAND_SZ,
-          value: "\0\0\0reg expand string",
-          expected_value: ""
-        }
-      ].each do |pair|
-        it 'reads up to the first wide null' do
-          hklm.create("#{puppet_key}\\#{subkey_name}", Win32::Registry::KEY_ALL_ACCESS) do |reg|
-            reg.write(value_name, pair[:type], pair[:value])
-          end
-
-          hklm.open("#{puppet_key}\\#{subkey_name}", Win32::Registry::KEY_READ) do |reg|
-            vals = subject.values(reg)
-
-            expect(vals).to have_key(value_name)
-            subject.each_value(reg) do |_subkey, type, _data|
-              expect(type).to eq(pair[:type])
-            end
-
-            written = vals[value_name]
-            expect(written).to eq(pair[:expected_value])
-          end
-        end
-      end
-    end
-  end
-
-  context "#values_by_name" do
-    let(:hkey)   { double('hklm') }
-    let(:subkey) { double('subkey') }
-
-    before :each do
-      allow(subject).to receive(:root).and_return(hkey)
-    end
-
-    context "when reading values" do
-      let(:hklm) { Win32::Registry::HKEY_LOCAL_MACHINE }
-      let(:puppet_key) { "SOFTWARE\\Puppet Labs"}
-      let(:subkey_name) { "PuppetRegistryTest#{SecureRandom.uuid}" }
-
-      before(:each) do
-        hklm.create("#{puppet_key}\\#{subkey_name}", Win32::Registry::KEY_ALL_ACCESS) do |reg|
-          reg.write('valuename1', Win32::Registry::REG_SZ, 'value1')
-          reg.write('valuename2', Win32::Registry::REG_SZ, 'value2')
-        end
-      end
-
-      after(:each) do
-        hklm.open(puppet_key, Win32::Registry::KEY_ALL_ACCESS) do |reg|
-          subject.delete_key(reg, subkey_name)
-        end
-      end
-
-      it "should return only the values for the names specified" do
-        hklm.open("#{puppet_key}\\#{subkey_name}", Win32::Registry::KEY_ALL_ACCESS) do |reg_key|
-          vals = subject.values_by_name(reg_key, ['valuename1', 'missingname'])
-
-          expect(vals).to have_key('valuename1')
-          expect(vals).to_not have_key('valuename2')
-          expect(vals['valuename1']).to eq('value1')
-          expect(vals['missingname']).to be_nil
-        end
-      end
-    end
   end
 end
 end

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

@@ -1,16 +1,18 @@
+#!/usr/bin/env ruby
 require 'spec_helper'
 
-if Puppet.features.microsoft_windows?
+if Puppet::Util::Platform.windows?
   class WindowsSecurityTester
     require 'puppet/util/windows/security'
     include Puppet::Util::Windows::Security
   end
 end
 
-describe "Puppet::Util::Windows::Security", :if => Puppet.features.microsoft_windows? do
+describe "Puppet::Util::Windows::Security", :if => Puppet::Util::Platform.windows? do
   include PuppetSpec::Files
 
   before :all do
+
     # necessary for localized name of guests
     guests_name = Puppet::Util::Windows::SID.sid_to_name('S-1-5-32-546')
     guests = Puppet::Util::Windows::ADSI::Group.new(guests_name)
@@ -97,7 +99,7 @@ describe "Puppet::Util::Windows::Security", :if => Puppet.features.microsoft_win
     describe "on a volume that doesn't support ACLs" do
       [:owner, :group, :mode].each do |p|
         it "should return nil #{p}" do
-          allow(winsec).to receive(:supports_acl?).and_return(false)
+          winsec.stubs(:supports_acl?).returns false
 
           expect(winsec.send("get_#{p}", path)).to be_nil
         end
@@ -107,7 +109,7 @@ describe "Puppet::Util::Windows::Security", :if => Puppet.features.microsoft_win
     describe "on a volume that supports ACLs" do
       describe "for a normal user" do
         before :each do
-          allow(Puppet.features).to receive(:root?).and_return(false)
+          Puppet.features.stubs(:root?).returns(false)
         end
 
         after :each do
@@ -283,11 +285,10 @@ describe "Puppet::Util::Windows::Security", :if => Puppet.features.microsoft_win
                     # access mask, and back to mode without loss of information
                     # (provided the owner and group are not the same)
                     next if ((u & g) != g) or ((g & o) != o)
-                    applied_mode  = (s << 9 | u << 6 | g << 3 | o << 0)
-                    # SYSTEM must always be Full Control (7)
-                    expected_mode = (s << 9 | u << 6 | 7 << 3 | o << 0)
-                    winsec.set_mode(applied_mode, path)
-                    expect(winsec.get_mode(path).to_s(8)).to eq(expected_mode.to_s(8))
+
+                    mode = (s << 9 | u << 6 | g << 3 | o << 0)
+                    winsec.set_mode(mode, path)
+                    expect(winsec.get_mode(path).to_s(8)).to eq(mode.to_s(8))
                   end
                 end
               end
@@ -469,13 +470,13 @@ describe "Puppet::Util::Windows::Security", :if => Puppet.features.microsoft_win
         end
       end
 
-      describe "for an administrator", :if => (Puppet.features.root? && Puppet.features.microsoft_windows?) do
+      describe "for an administrator", :if => (Puppet.features.root? && Puppet::Util::Platform.windows?) do
         before :each do
           is_dir = Puppet::FileSystem.directory?(path)
           winsec.set_mode(WindowsSecurityTester::S_IRWXU | WindowsSecurityTester::S_IRWXG, path)
           set_group_depending_on_current_user(path)
           winsec.set_owner(sids[:guest], path)
-          expected_error = RUBY_VERSION =~ /^2\./ && is_dir ? Errno::EISDIR : Errno::EACCES
+          expected_error = is_dir ? Errno::EISDIR : Errno::EACCES
           expect { File.open(path, 'r') }.to raise_error(expected_error)
         end
 
@@ -633,11 +634,9 @@ describe "Puppet::Util::Windows::Security", :if => Puppet.features.microsoft_win
                   # access mask, and back to mode without loss of information
                   # (provided the owner and group are the same)
                   next if ((ug & o) != o)
-                  applied_mode  = (s << 9 | ug << 6 | ug << 3 | o << 0)
-                  # SYSTEM must always be Full Control (7)
-                  expected_mode = (s << 9 | 7 << 6 | 7 << 3 | o << 0)
-                  winsec.set_mode(applied_mode, path)
-                  expect(winsec.get_mode(path).to_s(8)).to eq(expected_mode.to_s(8))
+                  mode = (s << 9 | ug << 6 | ug << 3 | o << 0)
+                  winsec.set_mode(mode, path)
+                  expect(winsec.get_mode(path).to_s(8)).to eq(mode.to_s(8))
                 end
               end
             end

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

@@ -1,77 +1,59 @@
+#! /usr/bin/env ruby
+
 require 'spec_helper'
 
-describe "Puppet::Util::Windows::User", :if => Puppet.features.microsoft_windows? do
+describe "Puppet::Util::Windows::User", :if => Puppet::Util::Platform.windows? do
   describe "2003 without UAC" do
     before :each do
-      allow(Puppet::Util::Windows::Process).to receive(:windows_major_version).and_return(5)
-      allow(Puppet::Util::Windows::Process).to receive(:supports_elevated_security?).and_return(false)
+      Puppet::Util::Windows::Process.stubs(:windows_major_version).returns(5)
     end
 
     it "should be an admin if user's token contains the Administrators SID" do
-      expect(Puppet::Util::Windows::User).to receive(:check_token_membership).and_return(true)
+      Puppet::Util::Windows::User.expects(:check_token_membership).returns(true)
+      Puppet::Util::Windows::Process.expects(:elevated_security?).never
 
       expect(Puppet::Util::Windows::User).to be_admin
     end
 
     it "should not be an admin if user's token doesn't contain the Administrators SID" do
-      expect(Puppet::Util::Windows::User).to receive(:check_token_membership).and_return(false)
+      Puppet::Util::Windows::User.expects(:check_token_membership).returns(false)
+      Puppet::Util::Windows::Process.expects(:elevated_security?).never
 
       expect(Puppet::Util::Windows::User).not_to be_admin
     end
 
     it "should raise an exception if we can't check token membership" do
-      expect(Puppet::Util::Windows::User).to receive(:check_token_membership).and_raise(Puppet::Util::Windows::Error, "Access denied.")
+      Puppet::Util::Windows::User.expects(:check_token_membership).raises(Puppet::Util::Windows::Error, "Access denied.")
+      Puppet::Util::Windows::Process.expects(:elevated_security?).never
 
       expect { Puppet::Util::Windows::User.admin? }.to raise_error(Puppet::Util::Windows::Error, /Access denied./)
     end
   end
 
-  context "2008 with UAC" do
+  describe "2008 with UAC" do
     before :each do
-      allow(Puppet::Util::Windows::Process).to receive(:windows_major_version).and_return(6)
-      allow(Puppet::Util::Windows::Process).to receive(:supports_elevated_security?).and_return(true)
+      Puppet::Util::Windows::Process.stubs(:windows_major_version).returns(6)
     end
 
-    describe "in local administrators group" do
-      before :each do
-        allow(Puppet::Util::Windows::User).to receive(:check_token_membership).and_return(true)
-      end
-
-      it "should be an admin if user is running with elevated privileges" do
-        allow(Puppet::Util::Windows::Process).to receive(:elevated_security?).and_return(true)
-
-        expect(Puppet::Util::Windows::User).to be_admin
-      end
-
-      it "should not be an admin if user is not running with elevated privileges" do
-        allow(Puppet::Util::Windows::Process).to receive(:elevated_security?).and_return(false)
+    it "should be an admin if user is running with elevated privileges" do
+      Puppet::Util::Windows::Process.stubs(:elevated_security?).returns(true)
+      Puppet::Util::Windows::User.expects(:check_token_membership).never
 
-        expect(Puppet::Util::Windows::User).not_to be_admin
-      end
-
-      it "should raise an exception if the process fails to open the process token" do
-        allow(Puppet::Util::Windows::Process).to receive(:elevated_security?).and_raise(Puppet::Util::Windows::Error, "Access denied.")
-
-        expect { Puppet::Util::Windows::User.admin? }.to raise_error(Puppet::Util::Windows::Error, /Access denied./)
-      end
+      expect(Puppet::Util::Windows::User).to be_admin
     end
 
-    describe "not in local administrators group" do
-      before :each do
-        allow(Puppet::Util::Windows::User).to receive(:check_token_membership).and_return(false)
-      end
-
-      it "should not be an admin if user is running with elevated privileges" do
-        allow(Puppet::Util::Windows::Process).to receive(:elevated_security?).and_return(true)
+    it "should not be an admin if user is not running with elevated privileges" do
+      Puppet::Util::Windows::Process.stubs(:elevated_security?).returns(false)
+      Puppet::Util::Windows::User.expects(:check_token_membership).never
 
-        expect(Puppet::Util::Windows::User).not_to be_admin
-      end
+      expect(Puppet::Util::Windows::User).not_to be_admin
+    end
 
-      it "should not be an admin if user is not running with elevated privileges" do
-        allow(Puppet::Util::Windows::Process).to receive(:elevated_security?).and_return(false)
+    it "should raise an exception if the process fails to open the process token" do
+      Puppet::Util::Windows::Process.stubs(:elevated_security?).raises(Puppet::Util::Windows::Error, "Access denied.")
+      Puppet::Util::Windows::User.expects(:check_token_membership).never
 
-        expect(Puppet::Util::Windows::User).not_to be_admin
-      end
+      expect { Puppet::Util::Windows::User.admin? }.to raise_error(Puppet::Util::Windows::Error, /Access denied./)
     end
   end
 
@@ -106,12 +88,6 @@ describe "Puppet::Util::Windows::User", :if => Puppet.features.microsoft_windows
     end
 
     describe "logon_user" do
-      let(:fLOGON32_PROVIDER_DEFAULT) {0}
-      let(:fLOGON32_LOGON_INTERACTIVE) {2}
-      let(:fLOGON32_LOGON_NETWORK) {3}
-      let(:token) {'test'}
-      let(:user) {'test'}
-      let(:passwd) {'test'}
       it "should raise an error when provided with an incorrect username and password" do
         expect_logon_failure_error {
           Puppet::Util::Windows::User.logon_user(username, bad_password)
@@ -123,21 +99,8 @@ describe "Puppet::Util::Windows::User", :if => Puppet.features.microsoft_windows
           Puppet::Util::Windows::User.logon_user(username, nil)
         }
       end
-
-      it 'should raise error given that logon returns false' do
-
-        allow(Puppet::Util::Windows::User).to receive(:logon_user_by_logon_type).with(
-            user, passwd, fLOGON32_LOGON_NETWORK, fLOGON32_PROVIDER_DEFAULT, anything).and_return (0)
-        allow(Puppet::Util::Windows::User).to receive(:logon_user_by_logon_type).with(
-            user, passwd, fLOGON32_LOGON_INTERACTIVE, fLOGON32_PROVIDER_DEFAULT, anything).and_return(0)
-
-        expect {Puppet::Util::Windows::User.logon_user(user, passwd) {}}
-            .to raise_error(Puppet::Util::Windows::Error, /Failed to logon user/)
-
-      end
     end
 
-
     describe "password_is?" do
       it "should return false given an incorrect username and password" do
         expect(Puppet::Util::Windows::User.password_is?(username, bad_password)).to be_falsey
@@ -150,25 +113,25 @@ describe "Puppet::Util::Windows::User", :if => Puppet.features.microsoft_windows
       context "with a correct password" do
         it "should return true even if account restrictions are in place " do
           error = Puppet::Util::Windows::Error.new('', Puppet::Util::Windows::User::ERROR_ACCOUNT_RESTRICTION)
-          allow(Puppet::Util::Windows::User).to receive(:logon_user).and_raise(error)
+          Puppet::Util::Windows::User.stubs(:logon_user).raises(error)
           expect(Puppet::Util::Windows::User.password_is?(username, 'p@ssword')).to be(true)
         end
 
         it "should return true even for an account outside of logon hours" do
           error = Puppet::Util::Windows::Error.new('', Puppet::Util::Windows::User::ERROR_INVALID_LOGON_HOURS)
-          allow(Puppet::Util::Windows::User).to receive(:logon_user).and_raise(error)
+          Puppet::Util::Windows::User.stubs(:logon_user).raises(error)
           expect(Puppet::Util::Windows::User.password_is?(username, 'p@ssword')).to be(true)
         end
 
         it "should return true even for an account not allowed to log into this workstation" do
           error = Puppet::Util::Windows::Error.new('', Puppet::Util::Windows::User::ERROR_INVALID_WORKSTATION)
-          allow(Puppet::Util::Windows::User).to receive(:logon_user).and_raise(error)
+          Puppet::Util::Windows::User.stubs(:logon_user).raises(error)
           expect(Puppet::Util::Windows::User.password_is?(username, 'p@ssword')).to be(true)
         end
 
         it "should return true even for a disabled account" do
           error = Puppet::Util::Windows::Error.new('', Puppet::Util::Windows::User::ERROR_ACCOUNT_DISABLED)
-          allow(Puppet::Util::Windows::User).to receive(:logon_user).and_raise(error)
+          Puppet::Util::Windows::User.stubs(:logon_user).raises(error)
           expect(Puppet::Util::Windows::User.password_is?(username, 'p@ssword')).to be(true)
         end
       end