puppet 5.5.22-x64-mingw32 → 6.0.0-x64-mingw32

data/spec/lib/puppet_spec/validators.rb

@@ -0,0 +1,37 @@
+class ConstantErrorValidator
+  def initialize(args)
+    @fails_with = args[:fails_with]
+    @error_string = args[:error_string] || ""
+    @peer_certs = args[:peer_certs] || []
+  end
+
+  def setup_connection(connection)
+    connection.stubs(:start).raises(OpenSSL::SSL::SSLError.new(@fails_with))
+  end
+
+  def peer_certs
+    @peer_certs
+  end
+
+  def verify_errors
+    [@error_string]
+  end
+end
+
+class NoProblemsValidator
+  def initialize(cert)
+    @cert = cert
+  end
+
+  def setup_connection(connection)
+  end
+
+  def peer_certs
+    [@cert]
+  end
+
+  def verify_errors
+    []
+  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
-      allow(provider).to receive(:default_target).and_return(file)
+      provider.stubs(:default_target).returns(file)
       provider.prefetch
 
       text = provider.to_file(provider.target_records(file))

data/spec/shared_behaviours/file_server_terminus.rb

@@ -1,10 +1,11 @@
+#! /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)
-    allow(Puppet::FileSystem).to receive(:exist?).and_return(true)
-    allow(Puppet::FileSystem).to receive(:exist?).with(Puppet[:fileserverconfig]).and_return(true)
+    Puppet::FileSystem.stubs(:exist?).returns true
+    Puppet::FileSystem.stubs(:exist?).with(Puppet[:fileserverconfig]).returns(true)
 
     @path = Tempfile.new("file_server_testing")
     path = @path.path
@@ -18,20 +19,20 @@ shared_examples_for "Puppet::Indirector::FileServerTerminus" do
     @mount1 = Puppet::FileServing::Configuration::Mount::File.new("one")
     @mount1.path = @path
 
-    @parser = double('parser', :changed? => false)
-    allow(@parser).to receive(:parse).and_return("one" => @mount1)
+    @parser = stub 'parser', :changed? => false
+    @parser.stubs(:parse).returns("one" => @mount1)
 
-    allow(Puppet::FileServing::Configuration::Parser).to receive(:new).and_return(@parser)
+    Puppet::FileServing::Configuration::Parser.stubs(:new).returns(@parser)
 
     # Stub out the modules terminus
-    @modules = double('modules terminus')
+    @modules = mock '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
-    allow(@modules).to receive(:find).and_return(nil)
-    allow(@terminus.indirection).to receive(:terminus).with(:modules).and_return(@modules)
+    @modules.stubs(:find).returns(nil)
+    @terminus.indirection.stubs(:terminus).with(:modules).returns(@modules)
 
     expect(@terminus.find(@request)).to be_instance_of(@test_class)
   end

data/spec/shared_behaviours/file_serving.rb

@@ -1,3 +1,5 @@
+#! /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) }
@@ -6,7 +8,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')
 
-        expect_any_instance_of(described_class.indirection.terminus(:file).class).to receive(method).with(request)
+        described_class.indirection.terminus(:file).class.any_instance.expects(method).with(request)
 
         subject.send(method, request)
       end
@@ -14,7 +16,7 @@ shared_examples_for "Puppet::FileServing::Files" do |indirection|
       it "should proxy to file terminus if the protocol is file" do
         request.protocol = 'file'
 
-        expect_any_instance_of(described_class.indirection.terminus(:file).class).to receive(method).with(request)
+        described_class.indirection.terminus(:file).class.any_instance.expects(method).with(request)
 
         subject.send(method, request)
       end
@@ -32,7 +34,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"
 
-            expect_any_instance_of(described_class.indirection.terminus(:rest).class).to receive(method).with(request)
+            described_class.indirection.terminus(:rest).class.any_instance.expects(method).with(request)
 
             subject.send(method, request)
           end
@@ -40,7 +42,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'
 
-            expect_any_instance_of(described_class.indirection.terminus(:rest).class).to receive(method).with(request)
+            described_class.indirection.terminus(:rest).class.any_instance.expects(method).with(request)
 
             subject.send(method, request)
           end
@@ -54,7 +56,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'
 
-            expect_any_instance_of(described_class.indirection.terminus(:file_server).class).to receive(method).with(request)
+            described_class.indirection.terminus(:file_server).class.any_instance.expects(method).with(request)
 
             subject.send(method, request)
           end
@@ -62,7 +64,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"
 
-            expect_any_instance_of(described_class.indirection.terminus(:rest).class).to receive(method).with(request)
+            described_class.indirection.terminus(:rest).class.any_instance.expects(method).with(request)
 
             subject.send(method, request)
           end

data/spec/shared_behaviours/file_serving_model.rb

@@ -1,3 +1,5 @@
+#! /usr/bin/env ruby
+
 shared_examples_for "a file_serving model" do
   include PuppetSpec::Files
 
@@ -7,26 +9,7 @@ shared_examples_for "a file_serving model" do
 
     before :each do
       # Never connect to the network, no matter what
-      allow_any_instance_of(described_class.indirection.terminus(:rest).class).to receive(:find)
-    end
-
-    describe "when running the master application" do
-      before :each do
-        Puppet::Application[:master].setup_terminuses
-      end
-
-      {
-       localpath     => :file_server,
-       localurl => :file_server,
-       "puppet:///modules/foo/bar"       => :file_server,
-       "puppet://server/modules/foo/bar" => :file_server,
-      }.each do |key, terminus|
-        it "should use the #{terminus} terminus when requesting #{key.inspect}" do
-          expect_any_instance_of(described_class.indirection.terminus(terminus).class).to receive(:find)
-
-          described_class.indirection.find(key)
-        end
-      end
+      described_class.indirection.terminus(:rest).class.any_instance.stubs(:find)
     end
 
     describe "when running the apply application" do
@@ -41,7 +24,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
-          expect_any_instance_of(described_class.indirection.terminus(terminus).class).to receive(:find)
+          described_class.indirection.terminus(terminus).class.any_instance.expects(:find)
 
           described_class.indirection.find(key)
         end
@@ -60,7 +43,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
-          expect_any_instance_of(described_class.indirection.terminus(terminus).class).to receive(:find)
+          described_class.indirection.terminus(terminus).class.any_instance.expects(: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
-    expect(Puppet.features).to receive(:hiera?).and_return(false)
+    Puppet.features.expects(:hiera?).returns(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
-        expect(Puppet).to receive(:warning).with(
+        Puppet.expects(: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
-        expect(Puppet).to receive(:warning).with(
+        Puppet.expects(:warning).with(
          "Config file #{path} not found, using Hiera defaults")
         expect(test_klass.hiera_config).to eq({ :logger => 'puppet' })
       end
@@ -64,6 +64,7 @@ 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,3 +1,4 @@
+
 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 = double('second', :name => @name)
-    trequest = double('request', :key => @name, :instance => two)
+    two = stub 'second', :name => @name
+    trequest = stub 'request', :key => @name, :instance => two
     @searcher.save(trequest)
     expect(@searcher.find(@request)).to equal(two)
   end

data/spec/shared_behaviours/path_parameters.rb

@@ -115,7 +115,7 @@ shared_examples_for "all path parameters" do |param, options|
     end
   end
 
-  describe "on a Windows-like platform it", :if => Puppet.features.microsoft_windows? do
+  describe "on a Windows-like platform it", :if => Puppet::Util::Platform.windows? do
     if array then
       it_should_behave_like "all pathname parameters with arrays", true
     end

data/spec/shared_contexts/types_setup.rb

@@ -187,8 +187,6 @@ shared_context 'types_setup' do
     result << Puppet::Pops::Types::PURIType
     result << Puppet::Pops::Types::PTupleType.new([tf.rich_data])
     result << Puppet::Pops::Types::PObjectType
-    result << Puppet::Pops::Types::PTypeType
-    result << Puppet::Pops::Types::PTypeSetType
     result
   end
   def rich_data_compatible_types

data/spec/shared_examples/rhel_package_provider.rb

@@ -1,5 +1,6 @@
 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(
@@ -46,13 +47,12 @@ shared_examples "RHEL package provider" do |provider_class, provider_name|
     end
 
     before do
-      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')
+      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'
     end
-
     describe 'provider features' do
       it { is_expected.to be_versionable }
       it { is_expected.to be_install_options }
@@ -66,174 +66,154 @@ shared_examples "RHEL package provider" do |provider_class, provider_name|
     end
     describe 'when installing' do
       before(:each) do
-        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')
+        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')
       end
-
       it "should call #{provider_name} install for :installed" do
-        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'])
+        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'])
         provider.install
       end
 
       if provider_name == 'yum'
         context 'on el-5' do
           before(:each) do
-            allow(Facter).to receive(:value).with(:operatingsystemmajrelease).and_return('5')
+            Facter.stubs(:value).with(:operatingsystemmajrelease).returns('5')
           end
-
           it "should catch #{provider_name} install failures when status code is wrong" do
-            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))
+            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))
             expect {
               provider.install
             }.to raise_error(Puppet::Error, "Could not find package #{name}")
           end
         end
       end
-
       it 'should use :install to update' do
-        expect(provider).to receive(:install)
+        provider.expects(:install)
         provider.update
       end
-
       it 'should be able to set version' do
         version = '1.2'
         resource[: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)
+        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
         provider.install
       end
       it 'should handle partial versions specified' do
         version = '1.3.4'
         resource[:ensure] = version
-        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')
+        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'
         provider.install
       end
-
       it 'should be able to downgrade' do
         current_version = '1.2'
         version = '1.0'
         resource[:ensure] = '1.0'
-        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})
+        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)
         provider.install
       end
-
       it 'should be able to upgrade' do
         current_version = '1.0'
         version = '1.2'
         resource[:ensure] = '1.2'
-        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})
+        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)
         provider.install
       end
-
       it 'should not run upgrade command if absent and ensure latest' do
         current_version = ''
         version = '1.2'
         resource[:ensure] = :latest
-        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})
+        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)
         provider.install
       end
-
       it 'should run upgrade command if present and ensure latest' do
         current_version = '1.0'
         version = '1.2'
         resource[:ensure] = :latest
-        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})
+        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)
         provider.install
       end
-
       it 'should accept install options' do
         resource[:ensure] = :installed
         resource[:install_options] = ['-t', {'-x' => 'expackage'}]
-        expect(Puppet::Util::Execution).to receive(:execute).with(["/usr/bin/#{provider_name}", '-d', '0', '-e', error_level, '-y', ['-t', '-x=expackage'], :install, name])
+        Puppet::Util::Execution.expects(: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
-        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])
+        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])
         provider.install
       end
-
       it 'moves architecture to end of version' do
         version = '1.2.3'
         arch_resource[: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)
+        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
         arch_provider.install
       end
     end
-
     describe 'when uninstalling' do
       it 'should use erase to purge' do
-        expect(Puppet::Util::Execution).to receive(:execute).with(["/usr/bin/#{provider_name}", '-y', :erase, name])
+        Puppet::Util::Execution.expects(: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'},
         ]
-        allow(provider).to receive(:properties).and_return({:ensure => '3.4.5'})
-        expect(described_class).to receive(:latest_package_version).with(name, [], ['contrib', 'centosplus'], [])
+        provider.stubs(:properties).returns({:ensure => '3.4.5'})
+        described_class.expects(: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'},
         ]
-        allow(provider).to receive(:properties).and_return({:ensure => '3.4.5'})
-        expect(described_class).to receive(:latest_package_version).with(name, ['updates', 'centosplus'], [], [])
+        provider.stubs(:properties).returns({:ensure => '3.4.5'})
+        described_class.expects(: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'},
         ]
-        allow(provider).to receive(:properties).and_return({:ensure => '3.4.5'})
-        expect(described_class).to receive(:latest_package_version).with(name, [], [], ['main', 'centosplus'])
+        provider.stubs(:properties).returns({:ensure => '3.4.5'})
+        described_class.expects(:latest_package_version).with(name, [], [], ['main', 'centosplus'])
         provider.latest
       end
-
       describe 'and a newer version is not available' do
         before :each do
-          allow(described_class).to receive(:latest_package_version).with(name, [], [], []).and_return(nil)
+          described_class.stubs(:latest_package_version).with(name, [], [], []).returns nil
         end
-
         it 'raises an error the package is not installed' do
-          allow(provider).to receive(:properties).and_return({:ensure => :absent})
+          provider.stubs(:properties).returns({: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
-          allow(provider).to receive(:properties).and_return({:ensure => '3.4.5'})
+          provider.stubs(:properties).returns({: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
           {
@@ -244,14 +224,12 @@ shared_examples "RHEL package provider" do |provider_class, provider_name|
             :arch     => 'i686',
           }
         end
-
         it 'includes the epoch in the version string' do
-          allow(described_class).to receive(:latest_package_version).with(name, [], [], []).and_return(latest_version)
+          described_class.stubs(:latest_package_version).with(name, [], [], []).returns(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 }
@@ -275,30 +253,26 @@ 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
-        expect(described_class).to receive(:check_updates).with([], [], []).once.and_return(latest_versions)
+        described_class.expects(:check_updates).with([], [], []).once.returns(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
-        expect(described_class).to receive(:check_updates).with([], [], []).once.and_return(latest_versions)
+        described_class.expects(:check_updates).with([], [], []).once.returns(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
-        expect(described_class).to receive(:check_updates).with([], [], []).once.and_return(latest_versions)
+        described_class.expects(:check_updates).with([], [], []).once.returns(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
-        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)
+        described_class.expects(:check_updates).with([], [], []).once.returns(latest_versions)
+        described_class.expects(:check_updates).with(['disabled'], ['enabled'], ['disableexcludes']).once.returns(enabled_versions)
         2.times {
           version = described_class.latest_package_version(name, [], [], [])
           expect(version).to eq mypackage_version
@@ -309,67 +283,53 @@ 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
-        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))
+        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))
         described_class.check_updates([], %W[updates centosplus], [])
       end
-
       it "passes repos to disable to '#{provider_name} check-update'" do
-        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))
+        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))
         described_class.check_updates(%W[updates centosplus], [], [])
       end
-
       it "passes a combination of repos to enable and disable to '#{provider_name} check-update'" do
-        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))
+        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))
         described_class.check_updates(%W[updates centosplus], %W[os contrib], [])
       end
-
       it "passes disableexcludes to '#{provider_name} check-update'" do
-        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))
+        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))
         described_class.check_updates([], [], %W[main centosplus])
       end
-
       it "passes all options to '#{provider_name} check-update'" do
-        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))
+        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))
         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
-        expect(Puppet::Util::Execution).to receive(:execute).and_return(double(:exitstatus => 0))
+        Puppet::Util::Execution.expects(:execute).returns(stub :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 = 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})
+        output = stub(:exitstatus => 100)
+        Puppet::Util::Execution.expects(:execute).returns(output)
+        described_class.expects(:parse_updates).with(output).returns({: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
-        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")
+        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(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]
@@ -377,7 +337,6 @@ 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)
@@ -385,7 +344,6 @@ 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)