puppet 6.0.7-universal-darwin → 6.0.8-universal-darwin

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

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/util/windows'
 
@@ -31,8 +30,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
@@ -45,17 +44,15 @@ describe Puppet::Util::Windows::Registry do
   end
 
   context "#open" do
-    let(:hkey)   { stub 'hklm' }
-    let(:subkey) { stub 'subkey' }
+    let(:hkey)   { double('hklm') }
+    let(:subkey) { double('subkey') }
 
     before :each do
-      subject.stubs(:root).returns(hkey)
+      allow(subject).to receive(:root).and_return(hkey)
     end
 
     it "should yield the opened the subkey" do
-      hkey.expects(:open).with do |p, _|
-        expect(p).to eq(path)
-      end.yields(subkey)
+      expect(hkey).to receive(:open).with(path, anything).and_yield(subkey)
 
       yielded = nil
       subject.open(name, path) {|reg| yielded = reg}
@@ -66,7 +63,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
-          hkey.expects(:open).with(path, mode)
+          expect(hkey).to receive(:open).with(path, mode)
 
           subject.open(name, path, mode) {|reg| }
         end
@@ -74,14 +71,14 @@ describe Puppet::Util::Windows::Registry do
     end
 
     it "should default to KEY64" do
-      hkey.expects(:open).with(path, described_class::KEY_READ | described_class::KEY64)
+      expect(hkey).to receive(: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
-      hkey.expects(:keyname).returns('HKEY_LOCAL_MACHINE')
-      hkey.expects(:open).raises(Win32::Registry::Error.new(2)) # file not found
+      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
       expect do
         subject.open(hkey, 'doesnotexist') {|hkey| }
       end.to raise_error(Puppet::Error, /Failed to open registry key 'HKEY_LOCAL_MACHINE\\doesnotexist'/)
@@ -89,34 +86,27 @@ describe Puppet::Util::Windows::Registry do
   end
 
   context "#values" do
-    let(:key) { stub('uninstall') }
-
-    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
+    let(:key) { double('uninstall') }
 
     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(key).not_to receive(:each_value)
+      expect(subject).to receive(:each_value).with(key).and_yield('string', 1, 'foo').and_yield('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
-      key.expects(:each_value).never
-      subject.expects(:each_value).with(key)
+      expect(key).not_to receive(:each_value)
+      expect(subject).to receive(:each_value).with(key)
 
       expect(subject.values(key)).to eq({})
     end
 
     it "passes REG_DWORD through" do
-      reg_value = ['dword', Win32::Registry::REG_DWORD, '1']
+      expect(key).not_to receive(:each_value)
+      expect(subject).to receive(:each_value).with(key).and_yield('dword', Win32::Registry::REG_DWORD, '1')
 
-      value = expects_registry_value(reg_value)
+      value = subject.values(key).first[1]
 
       expect(Integer(value)).to eq(1)
     end
@@ -127,11 +117,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
@@ -160,11 +150,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
-        Win32::Registry.expects(:export_string).never
+        expect(Win32::Registry).not_to receive(:export_string)
 
         # also, expect that we're using our variants of keys / values, not Rubys
-        Win32::Registry.expects(:each_key).never
-        Win32::Registry.expects(:each_value).never
+        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)
@@ -185,10 +175,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|
@@ -226,10 +216,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|
@@ -255,17 +245,17 @@ describe Puppet::Util::Windows::Registry do
   end
 
   context "#values_by_name" do
-    let(:hkey)   { stub 'hklm' }
-    let(:subkey) { stub 'subkey' }
+    let(:hkey)   { double('hklm') }
+    let(:subkey) { double('subkey') }
 
     before :each do
-      subject.stubs(:root).returns(hkey)
+      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}" }
+      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,4 +1,3 @@
-#!/usr/bin/env ruby
 require 'spec_helper'
 
 if Puppet::Util::Platform.windows?
@@ -12,7 +11,6 @@ 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)
@@ -99,7 +97,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
-          winsec.stubs(:supports_acl?).returns false
+          allow(winsec).to receive(:supports_acl?).and_return(false)
 
           expect(winsec.send("get_#{p}", path)).to be_nil
         end
@@ -109,7 +107,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
-          Puppet.features.stubs(:root?).returns(false)
+          allow(Puppet.features).to receive(:root?).and_return(false)
         end
 
         after :each do

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

@@ -1,28 +1,26 @@
-#! /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
-      Puppet::Util::Windows::Process.stubs(:windows_major_version).returns(5)
-      Puppet::Util::Windows::Process.stubs(:supports_elevated_security?).returns(false)
+      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)
     end
 
     it "should be an admin if user's token contains the Administrators SID" do
-      Puppet::Util::Windows::User.expects(:check_token_membership).returns(true)
+      expect(Puppet::Util::Windows::User).to receive(:check_token_membership).and_return(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
-      Puppet::Util::Windows::User.expects(:check_token_membership).returns(false)
+      expect(Puppet::Util::Windows::User).to receive(:check_token_membership).and_return(false)
 
       expect(Puppet::Util::Windows::User).not_to be_admin
     end
 
     it "should raise an exception if we can't check token membership" do
-      Puppet::Util::Windows::User.expects(:check_token_membership).raises(Puppet::Util::Windows::Error, "Access denied.")
+      expect(Puppet::Util::Windows::User).to receive(:check_token_membership).and_raise(Puppet::Util::Windows::Error, "Access denied.")
 
       expect { Puppet::Util::Windows::User.admin? }.to raise_error(Puppet::Util::Windows::Error, /Access denied./)
     end
@@ -30,29 +28,29 @@ describe "Puppet::Util::Windows::User", :if => Puppet::Util::Platform.windows? d
 
   context "2008 with UAC" do
     before :each do
-      Puppet::Util::Windows::Process.stubs(:windows_major_version).returns(6)
-      Puppet::Util::Windows::Process.stubs(:supports_elevated_security?).returns(true)
+      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)
     end
 
     describe "in local administrators group" do
       before :each do
-        Puppet::Util::Windows::User.stubs(:check_token_membership).returns(true)
+        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
-        Puppet::Util::Windows::Process.stubs(:elevated_security?).returns(true)
+        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
-        Puppet::Util::Windows::Process.stubs(:elevated_security?).returns(false)
+        allow(Puppet::Util::Windows::Process).to receive(:elevated_security?).and_return(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
-        Puppet::Util::Windows::Process.stubs(:elevated_security?).raises(Puppet::Util::Windows::Error, "Access denied.")
+        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
@@ -60,17 +58,17 @@ describe "Puppet::Util::Windows::User", :if => Puppet::Util::Platform.windows? d
 
     describe "not in local administrators group" do
       before :each do
-        Puppet::Util::Windows::User.stubs(:check_token_membership).returns(false)
+        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
-        Puppet::Util::Windows::Process.stubs(:elevated_security?).returns(true)
+        allow(Puppet::Util::Windows::Process).to receive(:elevated_security?).and_return(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
-        Puppet::Util::Windows::Process.stubs(:elevated_security?).returns(false)
+        allow(Puppet::Util::Windows::Process).to receive(:elevated_security?).and_return(false)
 
         expect(Puppet::Util::Windows::User).not_to be_admin
       end
@@ -133,25 +131,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)
-          Puppet::Util::Windows::User.stubs(:logon_user).raises(error)
+          allow(Puppet::Util::Windows::User).to receive(:logon_user).and_raise(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)
-          Puppet::Util::Windows::User.stubs(:logon_user).raises(error)
+          allow(Puppet::Util::Windows::User).to receive(:logon_user).and_raise(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)
-          Puppet::Util::Windows::User.stubs(:logon_user).raises(error)
+          allow(Puppet::Util::Windows::User).to receive(:logon_user).and_raise(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)
-          Puppet::Util::Windows::User.stubs(:logon_user).raises(error)
+          allow(Puppet::Util::Windows::User).to receive(:logon_user).and_raise(error)
           expect(Puppet::Util::Windows::User.password_is?(username, 'p@ssword')).to be(true)
         end
       end

data/spec/integration/util_spec.rb

@@ -1,5 +1,3 @@
-#!/usr/bin/env ruby
-
 require 'spec_helper'
 
 describe Puppet::Util do
@@ -115,11 +113,11 @@ describe Puppet::Util do
     let (:filepath) { File.expand_path('C:\\' + rune_utf8 + '\\' + filename) }
 
     before :each do
-      FileTest.stubs(:file?).returns false
-      FileTest.stubs(:file?).with(filepath).returns true
+      allow(FileTest).to receive(:file?).and_return(false)
+      allow(FileTest).to receive(:file?).with(filepath).and_return(true)
 
-      FileTest.stubs(:executable?).returns false
-      FileTest.stubs(:executable?).with(filepath).returns true
+      allow(FileTest).to receive(:executable?).and_return(false)
+      allow(FileTest).to receive(:executable?).with(filepath).and_return(true)
     end
 
     it "should be able to use UTF8 characters in the path" do
@@ -129,5 +127,4 @@ describe Puppet::Util do
       end
     end
   end
-
 end

data/spec/lib/puppet_spec/compiler.rb

@@ -44,7 +44,7 @@ module PuppetSpec::Compiler
 
   def apply_with_error_check(manifest)
     apply_compiled_manifest(manifest) do |res|
-      res.expects(:err).never
+      expect(res).not_to receive(:err)
     end
   end
 

data/spec/lib/puppet_spec/files.rb

@@ -9,7 +9,6 @@ module PuppetSpec::Files
     $global_tempfiles ||= []
     while path = $global_tempfiles.pop do
       begin
-        Dir.unstub(:entries)
         FileUtils.rm_rf path, :secure => true
       rescue Errno::ENOENT
         # nothing to do

data/spec/lib/puppet_spec/module_tool/shared_functions.rb

@@ -21,7 +21,7 @@ module PuppetSpec
 
       def mark_changed(path)
         app = Puppet::ModuleTool::Applications::Checksummer
-        app.stubs(:run).with(path).returns(['README'])
+        allow(app).to receive(:run).with(path).and_return(['README'])
       end
 
       def graph_should_include(name, options)

data/spec/lib/puppet_spec/scope.rb

@@ -1,4 +1,3 @@
-
 module PuppetSpec::Scope
   # Initialize a new scope suitable for testing.
   #
@@ -11,4 +10,4 @@ module PuppetSpec::Scope
     scope
   end
 
-end
+end

data/spec/shared_behaviours/all_parsedfile_providers.rb

@@ -5,7 +5,7 @@ shared_examples_for "all parsedfile providers" do |provider, *files|
 
   files.flatten.each do |file|
     it "should rewrite #{file} reasonably unchanged" do
-      provider.stubs(:default_target).returns(file)
+      allow(provider).to receive(:default_target).and_return(file)
       provider.prefetch
 
       text = provider.to_file(provider.target_records(file))

data/spec/shared_behaviours/file_server_terminus.rb

@@ -1,11 +1,10 @@
-#! /usr/bin/env ruby
 shared_examples_for "Puppet::Indirector::FileServerTerminus" do
   # This only works if the shared behaviour is included before
   # the 'before' block in the including context.
   before do
     Puppet::FileServing::Configuration.instance_variable_set(:@configuration, nil)
-    Puppet::FileSystem.stubs(:exist?).returns true
-    Puppet::FileSystem.stubs(:exist?).with(Puppet[:fileserverconfig]).returns(true)
+    allow(Puppet::FileSystem).to receive(:exist?).and_return(true)
+    allow(Puppet::FileSystem).to receive(:exist?).with(Puppet[:fileserverconfig]).and_return(true)
 
     @path = Tempfile.new("file_server_testing")
     path = @path.path
@@ -19,20 +18,20 @@ shared_examples_for "Puppet::Indirector::FileServerTerminus" do
     @mount1 = Puppet::FileServing::Configuration::Mount::File.new("one")
     @mount1.path = @path
 
-    @parser = stub 'parser', :changed? => false
-    @parser.stubs(:parse).returns("one" => @mount1)
+    @parser = double('parser', :changed? => false)
+    allow(@parser).to receive(:parse).and_return("one" => @mount1)
 
-    Puppet::FileServing::Configuration::Parser.stubs(:new).returns(@parser)
+    allow(Puppet::FileServing::Configuration::Parser).to receive(:new).and_return(@parser)
 
     # Stub out the modules terminus
-    @modules = mock 'modules terminus'
+    @modules = double('modules terminus')
 
     @request = Puppet::Indirector::Request.new(:indirection, :method, "puppet://myhost/one/myfile", nil)
   end
 
   it "should use the file server configuration to find files" do
-    @modules.stubs(:find).returns(nil)
-    @terminus.indirection.stubs(:terminus).with(:modules).returns(@modules)
+    allow(@modules).to receive(:find).and_return(nil)
+    allow(@terminus.indirection).to receive(:terminus).with(:modules).and_return(@modules)
 
     expect(@terminus.find(@request)).to be_instance_of(@test_class)
   end