puppet 6.0.10 → 6.1.0

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

@@ -1,3 +1,4 @@
+#!/usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/util/windows'
 

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

@@ -1,3 +1,5 @@
+#! /usr/bin/env ruby
+
 require 'spec_helper'
 require 'facter'
 
@@ -36,8 +38,8 @@ describe "Puppet::Util::Windows::Process", :if => Puppet::Util::Platform.windows
     after :each do
       # spec\integration\test\test_helper_spec.rb calls set_environment_strings
       # after :all and thus needs access to the real APIs once again
-      allow(Puppet::Util::Windows::Process).to receive(:GetEnvironmentStringsW).and_call_original
-      allow(Puppet::Util::Windows::Process).to receive(:FreeEnvironmentStringsW).and_call_original
+      Puppet::Util::Windows::Process.unstub(:GetEnvironmentStringsW)
+      Puppet::Util::Windows::Process.unstub(:FreeEnvironmentStringsW)
     end
 
     it "will ignore only keys or values with corrupt byte sequences" do
@@ -61,9 +63,9 @@ describe "Puppet::Util::Windows::Process", :if => Puppet::Util::Platform.windows
         ptr.put_array_of_uchar(0, env_var_block_bytes)
 
         # stub the block of memory that the Win32 API would typically return via pointer
-        expect(Puppet::Util::Windows::Process).to receive(:GetEnvironmentStringsW).and_return(ptr)
+        Puppet::Util::Windows::Process.expects(:GetEnvironmentStringsW).returns(ptr)
         # stub out the real API call to free memory, else process crashes
-        expect(Puppet::Util::Windows::Process).to receive(:FreeEnvironmentStringsW)
+        Puppet::Util::Windows::Process.expects(:FreeEnvironmentStringsW)
 
         env_vars = Puppet::Util::Windows::Process.get_environment_strings
       end

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
@@ -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,72 +252,20 @@ 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 string",
-          expected_value: "reg sz  string"
-        },
-        {
-          name: 'REG_SZ_2',
-          type: Win32::Registry::REG_SZ,
-          value: "reg sz\x00 string",
-          expected_value: "reg sz  string"
-        },
-        {
-          name: 'REG_EXPAND_SZ',
-          type: Win32::Registry::REG_EXPAND_SZ,
-          value: "\0reg expand string",
-          expected_value: " reg expand string"
-        }
-      ].each do |pair|
-        it 'replaces null bytes with spaces' 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') }
+    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
 
     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 (: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|

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

@@ -1,3 +1,4 @@
+#!/usr/bin/env ruby
 require 'spec_helper'
 
 if Puppet::Util::Platform.windows?
@@ -11,6 +12,7 @@ describe "Puppet::Util::Windows::Security", :if => Puppet::Util::Platform.window
   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::Util::Platform.window
     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::Util::Platform.window
     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

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

@@ -1,26 +1,28 @@
+#! /usr/bin/env ruby
+
 require 'spec_helper'
 
 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)
+      Puppet::Util::Windows::Process.stubs(:supports_elevated_security?).returns(false)
     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)
 
       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)
 
       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.")
 
       expect { Puppet::Util::Windows::User.admin? }.to raise_error(Puppet::Util::Windows::Error, /Access denied./)
     end
@@ -28,29 +30,29 @@ describe "Puppet::Util::Windows::User", :if => Puppet::Util::Platform.windows? d
 
   context "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)
+      Puppet::Util::Windows::Process.stubs(:supports_elevated_security?).returns(true)
     end
 
     describe "in local administrators group" do
       before :each do
-        allow(Puppet::Util::Windows::User).to receive(:check_token_membership).and_return(true)
+        Puppet::Util::Windows::User.stubs(:check_token_membership).returns(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)
+        Puppet::Util::Windows::Process.stubs(:elevated_security?).returns(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)
+        Puppet::Util::Windows::Process.stubs(:elevated_security?).returns(false)
 
         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.")
+        Puppet::Util::Windows::Process.stubs(:elevated_security?).raises(Puppet::Util::Windows::Error, "Access denied.")
 
         expect { Puppet::Util::Windows::User.admin? }.to raise_error(Puppet::Util::Windows::Error, /Access denied./)
       end
@@ -58,17 +60,17 @@ describe "Puppet::Util::Windows::User", :if => Puppet::Util::Platform.windows? d
 
     describe "not in local administrators group" do
       before :each do
-        allow(Puppet::Util::Windows::User).to receive(:check_token_membership).and_return(false)
+        Puppet::Util::Windows::User.stubs(:check_token_membership).returns(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)
+        Puppet::Util::Windows::Process.stubs(:elevated_security?).returns(true)
 
         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)
+        Puppet::Util::Windows::Process.stubs(:elevated_security?).returns(false)
 
         expect(Puppet::Util::Windows::User).not_to be_admin
       end
@@ -106,12 +108,6 @@ describe "Puppet::Util::Windows::User", :if => Puppet::Util::Platform.windows? d
     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 +119,8 @@ describe "Puppet::Util::Windows::User", :if => Puppet::Util::Platform.windows? d
           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 +133,25 @@ describe "Puppet::Util::Windows::User", :if => Puppet::Util::Platform.windows? d
       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