puppet 5.5.12-universal-darwin → 5.5.13-universal-darwin

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

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

data/spec/shared_behaviours/file_serving.rb

@@ -1,5 +1,3 @@
-#! /usr/bin/env ruby
-
 shared_examples_for "Puppet::FileServing::Files" do |indirection|
   %w[find search].each do |method|
     let(:request) { Puppet::Indirector::Request.new(indirection, method, 'foo', nil) }
@@ -8,7 +6,7 @@ shared_examples_for "Puppet::FileServing::Files" do |indirection|
       it "should proxy to file terminus if the path is absolute" do
         request.key = make_absolute('/tmp/foo')
 
-        described_class.indirection.terminus(:file).class.any_instance.expects(method).with(request)
+        expect_any_instance_of(described_class.indirection.terminus(:file).class).to receive(method).with(request)
 
         subject.send(method, request)
       end
@@ -16,7 +14,7 @@ shared_examples_for "Puppet::FileServing::Files" do |indirection|
       it "should proxy to file terminus if the protocol is file" do
         request.protocol = 'file'
 
-        described_class.indirection.terminus(:file).class.any_instance.expects(method).with(request)
+        expect_any_instance_of(described_class.indirection.terminus(:file).class).to receive(method).with(request)
 
         subject.send(method, request)
       end
@@ -34,7 +32,7 @@ shared_examples_for "Puppet::FileServing::Files" do |indirection|
           it "should proxy to rest terminus if default_file_terminus is rest" do
             Puppet[:default_file_terminus] = "rest"
 
-            described_class.indirection.terminus(:rest).class.any_instance.expects(method).with(request)
+            expect_any_instance_of(described_class.indirection.terminus(:rest).class).to receive(method).with(request)
 
             subject.send(method, request)
           end
@@ -42,7 +40,7 @@ shared_examples_for "Puppet::FileServing::Files" do |indirection|
           it "should proxy to rest terminus if default_file_terminus is not rest" do
             Puppet[:default_file_terminus] = 'file_server'
 
-            described_class.indirection.terminus(:rest).class.any_instance.expects(method).with(request)
+            expect_any_instance_of(described_class.indirection.terminus(:rest).class).to receive(method).with(request)
 
             subject.send(method, request)
           end
@@ -56,7 +54,7 @@ shared_examples_for "Puppet::FileServing::Files" do |indirection|
           it "should proxy to file_server if default_file_terminus is 'file_server'" do
             Puppet[:default_file_terminus] = 'file_server'
 
-            described_class.indirection.terminus(:file_server).class.any_instance.expects(method).with(request)
+            expect_any_instance_of(described_class.indirection.terminus(:file_server).class).to receive(method).with(request)
 
             subject.send(method, request)
           end
@@ -64,7 +62,7 @@ shared_examples_for "Puppet::FileServing::Files" do |indirection|
           it "should proxy to rest if default_file_terminus is 'rest'" do
             Puppet[:default_file_terminus] = "rest"
 
-            described_class.indirection.terminus(:rest).class.any_instance.expects(method).with(request)
+            expect_any_instance_of(described_class.indirection.terminus(:rest).class).to receive(method).with(request)
 
             subject.send(method, request)
           end

data/spec/shared_behaviours/file_serving_model.rb

@@ -1,5 +1,3 @@
-#! /usr/bin/env ruby
-
 shared_examples_for "a file_serving model" do
   include PuppetSpec::Files
 
@@ -9,7 +7,7 @@ shared_examples_for "a file_serving model" do
 
     before :each do
       # Never connect to the network, no matter what
-      described_class.indirection.terminus(:rest).class.any_instance.stubs(:find)
+      allow_any_instance_of(described_class.indirection.terminus(:rest).class).to receive(:find)
     end
 
     describe "when running the master application" do
@@ -24,7 +22,7 @@ shared_examples_for "a file_serving model" do
        "puppet://server/modules/foo/bar" => :file_server,
       }.each do |key, terminus|
         it "should use the #{terminus} terminus when requesting #{key.inspect}" do
-          described_class.indirection.terminus(terminus).class.any_instance.expects(:find)
+          expect_any_instance_of(described_class.indirection.terminus(terminus).class).to receive(:find)
 
           described_class.indirection.find(key)
         end
@@ -43,7 +41,7 @@ shared_examples_for "a file_serving model" do
        "puppet://server/modules/foo/bar" => :rest,
       }.each do |key, terminus|
         it "should use the #{terminus} terminus when requesting #{key.inspect}" do
-          described_class.indirection.terminus(terminus).class.any_instance.expects(:find)
+          expect_any_instance_of(described_class.indirection.terminus(terminus).class).to receive(:find)
 
           described_class.indirection.find(key)
         end
@@ -62,7 +60,7 @@ shared_examples_for "a file_serving model" do
        "puppet://server/modules/foo/bar" => :rest,
       }.each do |key, terminus|
         it "should use the #{terminus} terminus when requesting #{key.inspect}" do
-          described_class.indirection.terminus(terminus).class.any_instance.expects(:find)
+          expect_any_instance_of(described_class.indirection.terminus(terminus).class).to receive(:find)
 
           described_class.indirection.find(key)
         end

data/spec/shared_behaviours/hiera_indirections.rb

@@ -32,7 +32,7 @@ shared_examples_for "Hiera indirection" do |test_klass, fixture_dir|
   end
 
   it "should raise an error if we don't have the hiera feature" do
-    Puppet.features.expects(:hiera?).returns(false)
+    expect(Puppet.features).to receive(:hiera?).and_return(false)
     expect { test_klass.new }.to raise_error RuntimeError,
       "Hiera terminus not supported without hiera library"
   end
@@ -50,13 +50,13 @@ shared_examples_for "Hiera indirection" do |test_klass, fixture_dir|
       end
 
       it "should log a warning" do
-        Puppet.expects(:warning).with(
+        expect(Puppet).to receive(:warning).with(
          "Config file #{path} not found, using Hiera defaults")
         test_klass.hiera_config
       end
 
       it "should only configure the logger and set it to puppet" do
-        Puppet.expects(:warning).with(
+        expect(Puppet).to receive(:warning).with(
          "Config file #{path} not found, using Hiera defaults")
         expect(test_klass.hiera_config).to eq({ :logger => 'puppet' })
       end
@@ -64,7 +64,6 @@ shared_examples_for "Hiera indirection" do |test_klass, fixture_dir|
   end
 
   describe "the behavior of the find method", :if => Puppet.features.hiera? do
-
     let(:data_binder) { test_klass.new }
 
     it "should support looking up an integer" do

data/spec/shared_behaviours/iterative_functions.rb

@@ -1,4 +1,3 @@
-
 shared_examples_for 'all iterative functions hash handling' do |func|
   it 'passes a hash entry as an array of the key and value' do
     catalog = compile_to_catalog(<<-MANIFEST)

data/spec/shared_behaviours/memory_terminus.rb

@@ -10,8 +10,8 @@ shared_examples_for "A Memory Terminus" do
 
   it "should replace existing saved instances when a new instance with the same name is saved" do
     @searcher.save(@request)
-    two = stub 'second', :name => @name
-    trequest = stub 'request', :key => @name, :instance => two
+    two = double('second', :name => @name)
+    trequest = double('request', :key => @name, :instance => two)
     @searcher.save(trequest)
     expect(@searcher.find(@request)).to equal(two)
   end

data/spec/shared_examples/rhel_package_provider.rb

@@ -1,6 +1,5 @@
 shared_examples "RHEL package provider" do |provider_class, provider_name|
   describe provider_name do
-
     let(:name) { 'mypackage' }
     let(:resource) do
       Puppet::Type.type(:package).new(
@@ -47,12 +46,13 @@ shared_examples "RHEL package provider" do |provider_class, provider_name|
     end
 
     before do
-      provider_class.stubs(:command).with(:cmd).returns("/usr/bin/#{provider_name}")
-      provider.stubs(:rpm).returns 'rpm'
-      provider.stubs(:get).with(:version).returns '1'
-      provider.stubs(:get).with(:release).returns '1'
-      provider.stubs(:get).with(:arch).returns 'i386'
+      allow(provider_class).to receive(:command).with(:cmd).and_return("/usr/bin/#{provider_name}")
+      allow(provider).to receive(:rpm).and_return('rpm')
+      allow(provider).to receive(:get).with(:version).and_return('1')
+      allow(provider).to receive(:get).with(:release).and_return('1')
+      allow(provider).to receive(:get).with(:arch).and_return('i386')
     end
+
     describe 'provider features' do
       it { is_expected.to be_versionable }
       it { is_expected.to be_install_options }
@@ -66,154 +66,174 @@ shared_examples "RHEL package provider" do |provider_class, provider_name|
     end
     describe 'when installing' do
       before(:each) do
-        Puppet::Util.stubs(:which).with("rpm").returns("/bin/rpm")
-        provider.stubs(:which).with("rpm").returns("/bin/rpm")
-        Puppet::Util::Execution.expects(:execute).with(["/bin/rpm", "--version"], {:combine => true, :custom_environment => {}, :failonfail => true}).returns(Puppet::Util::Execution::ProcessOutput.new("4.10.1\n", 0)).at_most_once
-        Facter.stubs(:value).with(:operatingsystemmajrelease).returns('6')
+        allow(Puppet::Util).to receive(:which).with("rpm").and_return("/bin/rpm")
+        allow(provider).to receive(:which).with("rpm").and_return("/bin/rpm")
+        expect(Puppet::Util::Execution).to receive(:execute).with(["/bin/rpm", "--version"], {:combine => true, :custom_environment => {}, :failonfail => true}).and_return(Puppet::Util::Execution::ProcessOutput.new("4.10.1\n", 0)).at_most(:once)
+        allow(Facter).to receive(:value).with(:operatingsystemmajrelease).and_return('6')
       end
+
       it "should call #{provider_name} install for :installed" do
-        resource.stubs(:should).with(:ensure).returns :installed
-        Puppet::Util::Execution.expects(:execute).with(["/usr/bin/#{provider_name}", '-d', '0', '-e', error_level, '-y', :install, 'mypackage'])
+        allow(resource).to receive(:should).with(:ensure).and_return(:installed)
+        expect(Puppet::Util::Execution).to receive(:execute).with(["/usr/bin/#{provider_name}", '-d', '0', '-e', error_level, '-y', :install, 'mypackage'])
         provider.install
       end
 
       if provider_name == 'yum'
         context 'on el-5' do
           before(:each) do
-            Facter.stubs(:value).with(:operatingsystemmajrelease).returns('5')
+            allow(Facter).to receive(:value).with(:operatingsystemmajrelease).and_return('5')
           end
+
           it "should catch #{provider_name} install failures when status code is wrong" do
-            resource.stubs(:should).with(:ensure).returns :installed
-            Puppet::Util::Execution.expects(:execute).with(["/usr/bin/#{provider_name}", '-e', error_level, '-y', :install, name]).returns(Puppet::Util::Execution::ProcessOutput.new("No package #{name} available.", 0))
+            allow(resource).to receive(:should).with(:ensure).and_return(:installed)
+            expect(Puppet::Util::Execution).to receive(:execute).with(["/usr/bin/#{provider_name}", '-e', error_level, '-y', :install, name]).and_return(Puppet::Util::Execution::ProcessOutput.new("No package #{name} available.", 0))
             expect {
               provider.install
             }.to raise_error(Puppet::Error, "Could not find package #{name}")
           end
         end
       end
+
       it 'should use :install to update' do
-        provider.expects(:install)
+        expect(provider).to receive(:install)
         provider.update
       end
+
       it 'should be able to set version' do
         version = '1.2'
         resource[:ensure] = version
-        Puppet::Util::Execution.expects(:execute).with(["/usr/bin/#{provider_name}", '-d', '0', '-e', error_level, '-y', :install, "#{name}-#{version}"])
-        provider.stubs(:query).returns :ensure => version
+        expect(Puppet::Util::Execution).to receive(:execute).with(["/usr/bin/#{provider_name}", '-d', '0', '-e', error_level, '-y', :install, "#{name}-#{version}"])
+        allow(provider).to receive(:query).and_return(:ensure => version)
         provider.install
       end
       it 'should handle partial versions specified' do
         version = '1.3.4'
         resource[:ensure] = version
-        Puppet::Util::Execution.expects(:execute).with(["/usr/bin/#{provider_name}", '-d', '0', '-e', error_level, '-y', :install, 'mypackage-1.3.4'])
-        provider.stubs(:query).returns :ensure => '1.3.4-1.el6'
+        expect(Puppet::Util::Execution).to receive(:execute).with(["/usr/bin/#{provider_name}", '-d', '0', '-e', error_level, '-y', :install, 'mypackage-1.3.4'])
+        allow(provider).to receive(:query).and_return(:ensure => '1.3.4-1.el6')
         provider.install
       end
+
       it 'should be able to downgrade' do
         current_version = '1.2'
         version = '1.0'
         resource[:ensure] = '1.0'
-        Puppet::Util::Execution.expects(:execute).with(["/usr/bin/#{provider_name}", '-d', '0', '-e', error_level, '-y', :downgrade, "#{name}-#{version}"])
-        provider.stubs(:query).returns(:ensure => current_version).then.returns(:ensure => version)
+        expect(Puppet::Util::Execution).to receive(:execute).with(["/usr/bin/#{provider_name}", '-d', '0', '-e', error_level, '-y', :downgrade, "#{name}-#{version}"])
+        allow(provider).to receive(:query).and_return({:ensure => current_version}, {:ensure => version})
         provider.install
       end
+
       it 'should be able to upgrade' do
         current_version = '1.0'
         version = '1.2'
         resource[:ensure] = '1.2'
-        Puppet::Util::Execution.expects(:execute).with(["/usr/bin/#{provider_name}", '-d', '0', '-e', error_level, '-y', upgrade_command, "#{name}-#{version}"])
-        provider.stubs(:query).returns(:ensure => current_version).then.returns(:ensure => version)
+        expect(Puppet::Util::Execution).to receive(:execute).with(["/usr/bin/#{provider_name}", '-d', '0', '-e', error_level, '-y', upgrade_command, "#{name}-#{version}"])
+        allow(provider).to receive(:query).and_return({:ensure => current_version}, {:ensure => version})
         provider.install
       end
+
       it 'should not run upgrade command if absent and ensure latest' do
         current_version = ''
         version = '1.2'
         resource[:ensure] = :latest
-        Puppet::Util::Execution.expects(:execute).with(["/usr/bin/#{provider_name}", '-d', '0', '-e', error_level, '-y', :install, name])
-        provider.stubs(:query).returns(:ensure => current_version).then.returns(:ensure => version)
+        expect(Puppet::Util::Execution).to receive(:execute).with(["/usr/bin/#{provider_name}", '-d', '0', '-e', error_level, '-y', :install, name])
+        allow(provider).to receive(:query).and_return({:ensure => current_version}, {:ensure => version})
         provider.install
       end
+
       it 'should run upgrade command if present and ensure latest' do
         current_version = '1.0'
         version = '1.2'
         resource[:ensure] = :latest
-        Puppet::Util::Execution.expects(:execute).with(["/usr/bin/#{provider_name}", '-d', '0', '-e', error_level, '-y', upgrade_command, name])
-        provider.stubs(:query).returns(:ensure => current_version).then.returns(:ensure => version)
+        expect(Puppet::Util::Execution).to receive(:execute).with(["/usr/bin/#{provider_name}", '-d', '0', '-e', error_level, '-y', upgrade_command, name])
+        allow(provider).to receive(:query).and_return({:ensure => current_version}, {:ensure => version})
         provider.install
       end
+
       it 'should accept install options' do
         resource[:ensure] = :installed
         resource[:install_options] = ['-t', {'-x' => 'expackage'}]
-        Puppet::Util::Execution.expects(:execute).with(["/usr/bin/#{provider_name}", '-d', '0', '-e', error_level, '-y', ['-t', '-x=expackage'], :install, name])
+        expect(Puppet::Util::Execution).to receive(:execute).with(["/usr/bin/#{provider_name}", '-d', '0', '-e', error_level, '-y', ['-t', '-x=expackage'], :install, name])
         provider.install
       end
+
       it 'allow virtual packages' do
         resource[:ensure] = :installed
         resource[:allow_virtual] = true
-        Puppet::Util::Execution.expects(:execute).with(["/usr/bin/#{provider_name}", '-d', '0', '-e', error_level, '-y', :list, name]).never
-        Puppet::Util::Execution.expects(:execute).with(["/usr/bin/#{provider_name}", '-d', '0', '-e', error_level, '-y', :install, name])
+        expect(Puppet::Util::Execution).not_to receive(:execute).with(["/usr/bin/#{provider_name}", '-d', '0', '-e', error_level, '-y', :list, name])
+        expect(Puppet::Util::Execution).to receive(:execute).with(["/usr/bin/#{provider_name}", '-d', '0', '-e', error_level, '-y', :install, name])
         provider.install
       end
+
       it 'moves architecture to end of version' do
         version = '1.2.3'
         arch_resource[:ensure] = version
-        Puppet::Util::Execution.expects(:execute).with(["/usr/bin/#{provider_name}", '-d', '0', '-e', error_level, '-y', :install, "#{name}-#{version}.#{arch}"])
-        arch_provider.stubs(:query).returns :ensure => version
+        expect(Puppet::Util::Execution).to receive(:execute).with(["/usr/bin/#{provider_name}", '-d', '0', '-e', error_level, '-y', :install, "#{name}-#{version}.#{arch}"])
+        allow(arch_provider).to receive(:query).and_return(:ensure => version)
         arch_provider.install
       end
     end
+
     describe 'when uninstalling' do
       it 'should use erase to purge' do
-        Puppet::Util::Execution.expects(:execute).with(["/usr/bin/#{provider_name}", '-y', :erase, name])
+        expect(Puppet::Util::Execution).to receive(:execute).with(["/usr/bin/#{provider_name}", '-y', :erase, name])
         provider.purge
       end
     end
+
     it 'should be versionable' do
       expect(provider).to be_versionable
     end
+
     describe 'determining the latest version available for a package' do
       it "passes the value of enablerepo install_options when querying" do
         resource[:install_options] = [
           {'--enablerepo' => 'contrib'},
           {'--enablerepo' => 'centosplus'},
         ]
-        provider.stubs(:properties).returns({:ensure => '3.4.5'})
-        described_class.expects(:latest_package_version).with(name, [], ['contrib', 'centosplus'], [])
+        allow(provider).to receive(:properties).and_return({:ensure => '3.4.5'})
+        expect(described_class).to receive(:latest_package_version).with(name, [], ['contrib', 'centosplus'], [])
         provider.latest
       end
+
       it "passes the value of disablerepo install_options when querying" do
         resource[:install_options] = [
           {'--disablerepo' => 'updates'},
           {'--disablerepo' => 'centosplus'},
         ]
-        provider.stubs(:properties).returns({:ensure => '3.4.5'})
-        described_class.expects(:latest_package_version).with(name, ['updates', 'centosplus'], [], [])
+        allow(provider).to receive(:properties).and_return({:ensure => '3.4.5'})
+        expect(described_class).to receive(:latest_package_version).with(name, ['updates', 'centosplus'], [], [])
         provider.latest
       end
+
       it "passes the value of disableexcludes install_options when querying" do
         resource[:install_options] = [
           {'--disableexcludes' => 'main'},
           {'--disableexcludes' => 'centosplus'},
         ]
-        provider.stubs(:properties).returns({:ensure => '3.4.5'})
-        described_class.expects(:latest_package_version).with(name, [], [], ['main', 'centosplus'])
+        allow(provider).to receive(:properties).and_return({:ensure => '3.4.5'})
+        expect(described_class).to receive(:latest_package_version).with(name, [], [], ['main', 'centosplus'])
         provider.latest
       end
+
       describe 'and a newer version is not available' do
         before :each do
-          described_class.stubs(:latest_package_version).with(name, [], [], []).returns nil
+          allow(described_class).to receive(:latest_package_version).with(name, [], [], []).and_return(nil)
         end
+
         it 'raises an error the package is not installed' do
-          provider.stubs(:properties).returns({:ensure => :absent})
+          allow(provider).to receive(:properties).and_return({:ensure => :absent})
           expect {
             provider.latest
           }.to raise_error(Puppet::DevError, 'Tried to get latest on a missing package')
         end
+
         it 'returns version of the currently installed package' do
-          provider.stubs(:properties).returns({:ensure => '3.4.5'})
+          allow(provider).to receive(:properties).and_return({:ensure => '3.4.5'})
           expect(provider.latest).to eq('3.4.5')
         end
       end
+
       describe 'and a newer version is available' do
         let(:latest_version) do
           {
@@ -224,12 +244,14 @@ shared_examples "RHEL package provider" do |provider_class, provider_name|
             :arch     => 'i686',
           }
         end
+
         it 'includes the epoch in the version string' do
-          described_class.stubs(:latest_package_version).with(name, [], [], []).returns(latest_version)
+          allow(described_class).to receive(:latest_package_version).with(name, [], [], []).and_return(latest_version)
           expect(provider.latest).to eq('1:2.3.4-5')
         end
       end
     end
+
     describe "lazy loading of latest package versions" do
       before { described_class.clear }
       after { described_class.clear }
@@ -253,26 +275,30 @@ shared_examples "RHEL package provider" do |provider_class, provider_name|
       end
       let(:latest_versions) { {name => [mypackage_version]} }
       let(:enabled_versions) { {name => [mypackage_newerversion]} }
+
       it "returns the version hash if the package was found" do
-        described_class.expects(:check_updates).with([], [], []).once.returns(latest_versions)
+        expect(described_class).to receive(:check_updates).with([], [], []).once.and_return(latest_versions)
         version = described_class.latest_package_version(name, [], [], [])
         expect(version).to eq(mypackage_version)
       end
+
       it "is nil if the package was not found in the query" do
-        described_class.expects(:check_updates).with([], [], []).once.returns(latest_versions)
+        expect(described_class).to receive(:check_updates).with([], [], []).once.and_return(latest_versions)
         version = described_class.latest_package_version('nopackage', [], [], [])
         expect(version).to be_nil
       end
+
       it "caches the package list and reuses that for subsequent queries" do
-        described_class.expects(:check_updates).with([], [], []).once.returns(latest_versions)
+        expect(described_class).to receive(:check_updates).with([], [], []).once.and_return(latest_versions)
         2.times {
           version = described_class.latest_package_version(name, [], [], [])
           expect(version).to eq mypackage_version
         }
       end
+
       it "caches separate lists for each combination of 'disablerepo' and 'enablerepo' and 'disableexcludes'" do
-        described_class.expects(:check_updates).with([], [], []).once.returns(latest_versions)
-        described_class.expects(:check_updates).with(['disabled'], ['enabled'], ['disableexcludes']).once.returns(enabled_versions)
+        expect(described_class).to receive(:check_updates).with([], [], []).once.and_return(latest_versions)
+        expect(described_class).to receive(:check_updates).with(['disabled'], ['enabled'], ['disableexcludes']).once.and_return(enabled_versions)
         2.times {
           version = described_class.latest_package_version(name, [], [], [])
           expect(version).to eq mypackage_version
@@ -283,53 +309,67 @@ shared_examples "RHEL package provider" do |provider_class, provider_name|
         }
       end
     end
+
     describe "executing #{provider_name} check-update" do
       it "passes repos to enable to '#{provider_name} check-update'" do
-        Puppet::Util::Execution.expects(:execute).with do |args, *rest|
-          expect(args).to eq %W[/usr/bin/#{provider_name} check-update --enablerepo=updates --enablerepo=centosplus]
-        end.returns(stub(:exitstatus => 0))
+        expect(Puppet::Util::Execution).to receive(:execute).with(
+          %W[/usr/bin/#{provider_name} check-update --enablerepo=updates --enablerepo=centosplus],
+          any_args
+        ).and_return(double(:exitstatus => 0))
         described_class.check_updates([], %W[updates centosplus], [])
       end
+
       it "passes repos to disable to '#{provider_name} check-update'" do
-        Puppet::Util::Execution.expects(:execute).with do |args, *rest|
-          expect(args).to eq %W[/usr/bin/#{provider_name} check-update --disablerepo=updates --disablerepo=centosplus]
-        end.returns(stub(:exitstatus => 0))
+        expect(Puppet::Util::Execution).to receive(:execute).with(
+          %W[/usr/bin/#{provider_name} check-update --disablerepo=updates --disablerepo=centosplus],
+          any_args
+        ).and_return(double(:exitstatus => 0))
         described_class.check_updates(%W[updates centosplus], [], [])
       end
+
       it "passes a combination of repos to enable and disable to '#{provider_name} check-update'" do
-        Puppet::Util::Execution.expects(:execute).with do |args, *rest|
-          expect(args).to eq %W[/usr/bin/#{provider_name} check-update --disablerepo=updates --disablerepo=centosplus --enablerepo=os --enablerepo=contrib ]
-        end.returns(stub(:exitstatus => 0))
+        expect(Puppet::Util::Execution).to receive(:execute).with(
+          %W[/usr/bin/#{provider_name} check-update --disablerepo=updates --disablerepo=centosplus --enablerepo=os --enablerepo=contrib ],
+          any_args
+        ).and_return(double(:exitstatus => 0))
         described_class.check_updates(%W[updates centosplus], %W[os contrib], [])
       end
+
       it "passes disableexcludes to '#{provider_name} check-update'" do
-        Puppet::Util::Execution.expects(:execute).with do |args, *rest|
-          expect(args).to eq %W[/usr/bin/#{provider_name} check-update --disableexcludes=main --disableexcludes=centosplus]
-        end.returns(stub(:exitstatus => 0))
+        expect(Puppet::Util::Execution).to receive(:execute).with(
+          %W[/usr/bin/#{provider_name} check-update --disableexcludes=main --disableexcludes=centosplus],
+          any_args
+        ).and_return(double(:exitstatus => 0))
         described_class.check_updates([], [], %W[main centosplus])
       end
+
       it "passes all options to '#{provider_name} check-update'" do
-        Puppet::Util::Execution.expects(:execute).with do |args, *rest|
-          expect(args).to eq %W[/usr/bin/#{provider_name} check-update --disablerepo=a --disablerepo=b --enablerepo=c --enablerepo=d --disableexcludes=e --disableexcludes=f]
-        end.returns(stub(:exitstatus => 0))
+        expect(Puppet::Util::Execution).to receive(:execute).with(
+          %W[/usr/bin/#{provider_name} check-update --disablerepo=a --disablerepo=b --enablerepo=c --enablerepo=d --disableexcludes=e --disableexcludes=f],
+          any_args
+        ).and_return(double(:exitstatus => 0))
         described_class.check_updates(%W[a b], %W[c d], %W[e f])
       end
+
       it "returns an empty hash if '#{provider_name} check-update' returned 0" do
-        Puppet::Util::Execution.expects(:execute).returns(stub :exitstatus => 0)
+        expect(Puppet::Util::Execution).to receive(:execute).and_return(double(:exitstatus => 0))
         expect(described_class.check_updates([], [], [])).to be_empty
       end
+
       it "returns a populated hash if '#{provider_name} check-update returned 100'" do
-        output = stub(:exitstatus => 100)
-        Puppet::Util::Execution.expects(:execute).returns(output)
-        described_class.expects(:parse_updates).with(output).returns({:has => :updates})
+        output = double(:exitstatus => 100)
+        expect(Puppet::Util::Execution).to receive(:execute).and_return(output)
+        expect(described_class).to receive(:parse_updates).with(output).and_return({:has => :updates})
         expect(described_class.check_updates([], [], [])).to eq({:has => :updates})
       end
+
       it "returns an empty hash if '#{provider_name} check-update' returned an exit code that was not 0 or 100" do
-        Puppet::Util::Execution.expects(:execute).returns(stub(:exitstatus => 1))
-        described_class.expects(:warning).with("Could not check for updates, \'/usr/bin/#{provider_name} check-update\' exited with 1")
+        expect(Puppet::Util::Execution).to receive(:execute).and_return(double(:exitstatus => 1))
+        expect(described_class).to receive(:warning).with("Could not check for updates, \'/usr/bin/#{provider_name} check-update\' exited with 1")
         expect(described_class.check_updates([], [], [])).to eq({})
       end
     end
+
     describe "parsing a line from #{provider_name} check-update" do
       it "splits up the package name and architecture fields" do
         checkupdate = %W[curl.i686 7.32.0-10.fc20]
@@ -337,6 +377,7 @@ shared_examples "RHEL package provider" do |provider_class, provider_name|
         expect(parsed[:name]).to eq 'curl'
         expect(parsed[:arch]).to eq 'i686'
       end
+
       it "splits up the epoch, version, and release fields" do
         checkupdate = %W[dhclient.i686 12:4.1.1-38.P1.el6.centos]
         parsed = described_class.update_to_hash(*checkupdate)
@@ -344,6 +385,7 @@ shared_examples "RHEL package provider" do |provider_class, provider_name|
         expect(parsed[:version]).to eq '4.1.1'
         expect(parsed[:release]).to eq '38.P1.el6.centos'
       end
+
       it "sets the epoch to 0 when an epoch is not specified" do
         checkupdate = %W[curl.i686 7.32.0-10.fc20]
         parsed = described_class.update_to_hash(*checkupdate)