puppet 6.4.0-universal-darwin → 6.4.1-universal-darwin

data/spec/unit/provider/package/portage_spec.rb

@@ -1,67 +1,63 @@
-#! /usr/bin/env ruby
-
 require 'spec_helper'
 
-provider = Puppet::Type.type(:package).provider(:portage)
-
-describe provider do
+describe Puppet::Type.type(:package).provider(:portage) do
   before do
-    packagename="sl"
-    @resource = stub('resource', :should => true)
-    @resource.stubs(:[]).with(:name).returns(packagename)
-    @resource.stubs(:[]).with(:install_options).returns(['--foo', '--bar'])
-    @resource.stubs(:[]).with(:uninstall_options).returns(['--foo', { '--bar' => 'baz', '--baz' => 'foo' }])
+    packagename = "sl"
+    @resource = double('resource', :should => true)
+    allow(@resource).to receive(:[]).with(:name).and_return(packagename)
+    allow(@resource).to receive(:[]).with(:install_options).and_return(['--foo', '--bar'])
+    allow(@resource).to receive(:[]).with(:uninstall_options).and_return(['--foo', { '--bar' => 'baz', '--baz' => 'foo' }])
 
     unslotted_packagename = "dev-lang/ruby"
-    @unslotted_resource = stub('resource', :should => true)
-    @unslotted_resource.stubs(:should).with(:ensure).returns :latest
-    @unslotted_resource.stubs(:[]).with(:name).returns(unslotted_packagename)
-    @unslotted_resource.stubs(:[]).with(:install_options).returns([])
+    @unslotted_resource = double('resource', :should => true)
+    allow(@unslotted_resource).to receive(:should).with(:ensure).and_return(:latest)
+    allow(@unslotted_resource).to receive(:[]).with(:name).and_return(unslotted_packagename)
+    allow(@unslotted_resource).to receive(:[]).with(:install_options).and_return([])
 
     slotted_packagename = "dev-lang/ruby:2.1"
-    @slotted_resource = stub('resource', :should => true)
-    @slotted_resource.stubs(:[]).with(:name).returns(slotted_packagename)
-    @slotted_resource.stubs(:[]).with(:install_options).returns(['--foo', { '--bar' => 'baz', '--baz' => 'foo' }])
+    @slotted_resource = double('resource', :should => true)
+    allow(@slotted_resource).to receive(:[]).with(:name).and_return(slotted_packagename)
+    allow(@slotted_resource).to receive(:[]).with(:install_options).and_return(['--foo', { '--bar' => 'baz', '--baz' => 'foo' }])
 
     versioned_packagename = "=dev-lang/ruby-1.9.3"
-    @versioned_resource = stub('resource', :should => true)
-    @versioned_resource.stubs(:[]).with(:name).returns(versioned_packagename)
-    @versioned_resource.stubs(:[]).with(:install_options).returns([])
-    @versioned_resource.stubs(:[]).with(:uninstall_options).returns([])
+    @versioned_resource = double('resource', :should => true)
+    allow(@versioned_resource).to receive(:[]).with(:name).and_return(versioned_packagename)
+    allow(@versioned_resource).to receive(:[]).with(:install_options).and_return([])
+    allow(@versioned_resource).to receive(:[]).with(:uninstall_options).and_return([])
 
     versioned_slotted_packagename = "=dev-lang/ruby-1.9.3:1.9"
-    @versioned_slotted_resource = stub('resource', :should => true)
-    @versioned_slotted_resource.stubs(:[]).with(:name).returns(versioned_slotted_packagename)
-    @versioned_slotted_resource.stubs(:[]).with(:install_options).returns([])
-    @versioned_slotted_resource.stubs(:[]).with(:uninstall_options).returns([])
+    @versioned_slotted_resource = double('resource', :should => true)
+    allow(@versioned_slotted_resource).to receive(:[]).with(:name).and_return(versioned_slotted_packagename)
+    allow(@versioned_slotted_resource).to receive(:[]).with(:install_options).and_return([])
+    allow(@versioned_slotted_resource).to receive(:[]).with(:uninstall_options).and_return([])
 
     set_packagename = "@system"
-    @set_resource = stub('resource', :should => true)
-    @set_resource.stubs(:[]).with(:name).returns(set_packagename)
-    @set_resource.stubs(:[]).with(:install_options).returns([])
+    @set_resource = double('resource', :should => true)
+    allow(@set_resource).to receive(:[]).with(:name).and_return(set_packagename)
+    allow(@set_resource).to receive(:[]).with(:install_options).and_return([])
 
     package_sets = "system\nworld\n"
-    @provider = provider.new(@resource)
-    @provider.stubs(:qatom).returns({:category=>nil, :pn=>"sl", :pv=>nil, :pr=>nil, :slot=>nil, :pfx=>nil, :sfx=>nil})
-    @provider.class.stubs(:emerge).with('--list-sets').returns(package_sets)
-    @unslotted_provider = provider.new(@unslotted_resource)
-    @unslotted_provider.stubs(:qatom).returns({:category=>"dev-lang", :pn=>"ruby", :pv=>nil, :pr=>nil, :slot=>nil, :pfx=>nil, :sfx=>nil})
-    @unslotted_provider.class.stubs(:emerge).with('--list-sets').returns(package_sets)
-    @slotted_provider = provider.new(@slotted_resource)
-    @slotted_provider.stubs(:qatom).returns({:category=>"dev-lang", :pn=>"ruby", :pv=>nil, :pr=>nil, :slot=>":2.1", :pfx=>nil, :sfx=>nil})
-    @slotted_provider.class.stubs(:emerge).with('--list-sets').returns(package_sets)
-    @versioned_provider = provider.new(@versioned_resource)
-    @versioned_provider.stubs(:qatom).returns({:category=>"dev-lang", :pn=>"ruby", :pv=>"1.9.3", :pr=>nil, :slot=>nil, :pfx=>"=", :sfx=>nil})
-    @versioned_provider.class.stubs(:emerge).with('--list-sets').returns(package_sets)
-    @versioned_slotted_provider = provider.new(@versioned_slotted_resource)
-    @versioned_slotted_provider.stubs(:qatom).returns({:category=>"dev-lang", :pn=>"ruby", :pv=>"1.9.3", :pr=>nil, :slot=>":1.9", :pfx=>"=", :sfx=>nil})
-    @versioned_slotted_provider.class.stubs(:emerge).with('--list-sets').returns(package_sets)
-    @set_provider = provider.new(@set_resource)
-    @set_provider.stubs(:qatom).returns({:category=>nil, :pn=>"@system", :pv=>nil, :pr=>nil, :slot=>nil, :pfx=>nil, :sfx=>nil})
-    @set_provider.class.stubs(:emerge).with('--list-sets').returns(package_sets)
-
-    portage   = stub(:executable => "foo",:execute => true)
-    Puppet::Provider::CommandDefiner.stubs(:define).returns(portage)
+    @provider = described_class.new(@resource)
+    allow(@provider).to receive(:qatom).and_return({:category=>nil, :pn=>"sl", :pv=>nil, :pr=>nil, :slot=>nil, :pfx=>nil, :sfx=>nil})
+    allow(@provider.class).to receive(:emerge).with('--list-sets').and_return(package_sets)
+    @unslotted_provider = described_class.new(@unslotted_resource)
+    allow(@unslotted_provider).to receive(:qatom).and_return({:category=>"dev-lang", :pn=>"ruby", :pv=>nil, :pr=>nil, :slot=>nil, :pfx=>nil, :sfx=>nil})
+    allow(@unslotted_provider.class).to receive(:emerge).with('--list-sets').and_return(package_sets)
+    @slotted_provider = described_class.new(@slotted_resource)
+    allow(@slotted_provider).to receive(:qatom).and_return({:category=>"dev-lang", :pn=>"ruby", :pv=>nil, :pr=>nil, :slot=>":2.1", :pfx=>nil, :sfx=>nil})
+    allow(@slotted_provider.class).to receive(:emerge).with('--list-sets').and_return(package_sets)
+    @versioned_provider = described_class.new(@versioned_resource)
+    allow(@versioned_provider).to receive(:qatom).and_return({:category=>"dev-lang", :pn=>"ruby", :pv=>"1.9.3", :pr=>nil, :slot=>nil, :pfx=>"=", :sfx=>nil})
+    allow(@versioned_provider.class).to receive(:emerge).with('--list-sets').and_return(package_sets)
+    @versioned_slotted_provider = described_class.new(@versioned_slotted_resource)
+    allow(@versioned_slotted_provider).to receive(:qatom).and_return({:category=>"dev-lang", :pn=>"ruby", :pv=>"1.9.3", :pr=>nil, :slot=>":1.9", :pfx=>"=", :sfx=>nil})
+    allow(@versioned_slotted_provider.class).to receive(:emerge).with('--list-sets').and_return(package_sets)
+    @set_provider = described_class.new(@set_resource)
+    allow(@set_provider).to receive(:qatom).and_return({:category=>nil, :pn=>"@system", :pv=>nil, :pr=>nil, :slot=>nil, :pfx=>nil, :sfx=>nil})
+    allow(@set_provider.class).to receive(:emerge).with('--list-sets').and_return(package_sets)
+
+    portage   = double(:executable => "foo",:execute => true)
+    allow(Puppet::Provider::CommandDefiner).to receive(:define).and_return(portage)
 
     @nomatch_result = ""
     @match_result    = "app-misc sl [] [5.02] [] [] [5.02] [5.02:0] http://www.tkl.iis.u-tokyo.ac.jp/~toyoda/index_e.html https://github.com/mtoyoda/sl/ sophisticated graphical program which corrects your miss typing\n"
@@ -69,89 +65,89 @@ describe provider do
   end
 
   it "is versionable" do
-    expect(provider).to be_versionable
+    expect(described_class).to be_versionable
   end
 
   it "is reinstallable" do
-    expect(provider).to be_reinstallable
+    expect(described_class).to be_reinstallable
   end
 
   it 'should support string install options' do
-    @provider.expects(:emerge).with('--foo', '--bar', @resource[:name])
+    expect(@provider).to receive(:emerge).with('--foo', '--bar', @resource[:name])
 
     @provider.install
   end
 
   it 'should support updating' do
-    @unslotted_provider.expects(:emerge).with('--update', @unslotted_resource[:name])
+    expect(@unslotted_provider).to receive(:emerge).with('--update', @unslotted_resource[:name])
 
     @unslotted_provider.install
   end
 
   it 'should support hash install options' do
-    @slotted_provider.expects(:emerge).with('--foo', '--bar=baz', '--baz=foo', @slotted_resource[:name])
+    expect(@slotted_provider).to receive(:emerge).with('--foo', '--bar=baz', '--baz=foo', @slotted_resource[:name])
 
     @slotted_provider.install
   end
 
   it 'should support hash uninstall options' do
-    @provider.expects(:emerge).with('--rage-clean', '--foo', '--bar=baz', '--baz=foo', @resource[:name])
+    expect(@provider).to receive(:emerge).with('--rage-clean', '--foo', '--bar=baz', '--baz=foo', @resource[:name])
 
     @provider.uninstall
   end
 
   it 'should support install of specific version' do
-    @versioned_provider.expects(:emerge).with(@versioned_resource[:name])
+    expect(@versioned_provider).to receive(:emerge).with(@versioned_resource[:name])
 
     @versioned_provider.install
   end
 
   it 'should support install of specific version and slot' do
-    @versioned_slotted_provider.expects(:emerge).with(@versioned_slotted_resource[:name])
+    expect(@versioned_slotted_provider).to receive(:emerge).with(@versioned_slotted_resource[:name])
 
     @versioned_slotted_provider.install
   end
 
   it 'should support uninstall of specific version' do
-    @versioned_provider.expects(:emerge).with('--rage-clean', @versioned_resource[:name])
+    expect(@versioned_provider).to receive(:emerge).with('--rage-clean', @versioned_resource[:name])
 
     @versioned_provider.uninstall
   end
 
   it 'should support uninstall of specific version and slot' do
-    @versioned_slotted_provider.expects(:emerge).with('--rage-clean', @versioned_slotted_resource[:name])
+    expect(@versioned_slotted_provider).to receive(:emerge).with('--rage-clean', @versioned_slotted_resource[:name])
 
     @versioned_slotted_provider.uninstall
   end
 
   it "uses :emerge to install packages" do
-    @provider.expects(:emerge)
+    expect(@provider).to receive(:emerge)
 
     @provider.install
   end
 
   it "uses query to find the latest package" do
-    @provider.expects(:query).returns({:versions_available => "myversion"})
+    expect(@provider).to receive(:query).and_return({:versions_available => "myversion"})
 
     @provider.latest
   end
 
   it "uses eix to search the lastest version of a package" do
-    @provider.stubs(:update_eix)
-    @provider.expects(:eix).returns(StringIO.new(@match_result))
+    allow(@provider).to receive(:update_eix)
+    expect(@provider).to receive(:eix).and_return(StringIO.new(@match_result))
 
     @provider.query
   end
 
   it "allows to emerge package sets" do
-    @set_provider.expects(:emerge).with(@set_resource[:name])
+    expect(@set_provider).to receive(:emerge).with(@set_resource[:name])
 
     @set_provider.install
   end
 
   it "allows to emerge and update package sets" do
-    @set_resource.stubs(:should).with(:ensure).returns :latest
-    @set_provider.expects(:emerge).with('--update', @set_resource[:name])
+    allow(@set_resource).to receive(:should).with(:ensure).and_return(:latest)
+    expect(@set_provider).to receive(:emerge).with('--update', @set_resource[:name])
 
     @set_provider.install
   end
@@ -165,16 +161,16 @@ describe provider do
   end
 
   it "query uses default arguments" do
-    @provider.stubs(:update_eix)
-    @provider.expects(:eix).returns(StringIO.new(@match_result))
-    @provider.class.expects(:eix_search_arguments).returns([])
+    allow(@provider).to receive(:update_eix)
+    expect(@provider).to receive(:eix).and_return(StringIO.new(@match_result))
+    expect(@provider.class).to receive(:eix_search_arguments).and_return([])
 
     @provider.query
   end
 
   it "can handle search output with empty square brackets" do
-    @provider.stubs(:update_eix)
-    @provider.expects(:eix).returns(StringIO.new(@match_result))
+    allow(@provider).to receive(:update_eix)
+    expect(@provider).to receive(:eix).and_return(StringIO.new(@match_result))
 
     expect(@provider.query[:name]).to eq("sl")
   end
@@ -204,8 +200,8 @@ describe provider do
   end
 
   it "can handle search output with slots for unslotted packages" do
-    @unslotted_provider.stubs(:update_eix)
-    @unslotted_provider.expects(:eix).returns(StringIO.new(@slot_match_result))
+    allow(@unslotted_provider).to receive(:update_eix)
+    expect(@unslotted_provider).to receive(:eix).and_return(StringIO.new(@slot_match_result))
 
     result = @unslotted_provider.query
     expect(result[:name]).to eq('ruby')
@@ -214,8 +210,8 @@ describe provider do
   end
 
   it "can handle search output with slots" do
-    @slotted_provider.stubs(:update_eix)
-    @slotted_provider.expects(:eix).returns(StringIO.new(@slot_match_result))
+    allow(@slotted_provider).to receive(:update_eix)
+    expect(@slotted_provider).to receive(:eix).and_return(StringIO.new(@slot_match_result))
 
     result = @slotted_provider.query
     expect(result[:name]).to eq('ruby')

data/spec/unit/provider/package/puppet_gem_spec.rb

@@ -26,38 +26,58 @@ describe Puppet::Type.type(:package).provider(:puppet_gem) do
 
   context "when installing" do
     it "should use the path to the gem" do
-      described_class.expects(:which).with(puppet_gem).returns(puppet_gem)
-      provider.expects(:execute).with { |args| args[0] == puppet_gem }.returns ''
+      expect(described_class).to receive(:which).with(puppet_gem).and_return(puppet_gem)
+      expect(provider).to receive(:execute) do |args|
+        expect(args[0]).to eq(puppet_gem)
+        ''
+      end
       provider.install
     end
 
     it "should not append install_options by default" do
-      provider.expects(:execute).with { |args| args.length == 5 }.returns ''
+      expect(provider).to receive(:execute) do |args|
+        expect(args.length).to eq(5)
+        ''
+      end
       provider.install
     end
 
     it "should allow setting an install_options parameter" do
       resource[:install_options] = [ '--force', {'--bindir' => '/usr/bin' } ]
-      provider.expects(:execute).with { |args| args[2] == '--force' && args[3] == '--bindir=/usr/bin' }.returns ''
+      expect(provider).to receive(:execute) do |args|
+        expect(args[2]).to eq('--force')
+        expect(args[3]).to eq('--bindir=/usr/bin')
+        ''
+      end
       provider.install
     end
   end
 
   context "when uninstalling" do
     it "should use the path to the gem" do
-      described_class.expects(:which).with(puppet_gem).returns(puppet_gem)
-      provider.expects(:execute).with { |args| args[0] == puppet_gem }.returns ''
+      expect(described_class).to receive(:which).with(puppet_gem).and_return(puppet_gem)
+      expect(provider).to receive(:execute) do |args|
+        expect(args[0]).to eq(puppet_gem)
+        ''
+      end
       provider.install
     end
 
     it "should not append uninstall_options by default" do
-      provider.expects(:execute).with { |args| args.length == 5 }.returns ''
+      expect(provider).to receive(:execute) do |args|
+        expect(args.length).to eq(5)
+        ''
+      end
       provider.uninstall
     end
 
     it "should allow setting an uninstall_options parameter" do
       resource[:uninstall_options] = [ '--force', {'--bindir' => '/usr/bin' } ]
-      provider.expects(:execute).with { |args| args[5] == '--force' && args[6] == '--bindir=/usr/bin' }.returns ''
+      expect(provider).to receive(:execute) do |args|
+        expect(args[5]).to eq('--force')
+        expect(args[6]).to eq('--bindir=/usr/bin')
+        ''
+      end
       provider.uninstall
     end
   end

data/spec/unit/provider/package/rpm_spec.rb

@@ -1,9 +1,6 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
-provider_class = Puppet::Type.type(:package).provider(:rpm)
-
-describe provider_class do
+describe Puppet::Type.type(:package).provider(:rpm) do
   let (:packages) do
     <<-RPM_OUTPUT
     'cracklib-dicts 0 2.8.9 3.3 x86_64
@@ -26,7 +23,7 @@ describe provider_class do
   end
 
   let(:provider) do
-    provider = provider_class.new
+    provider = subject()
     provider.resource = resource
     provider
   end
@@ -38,15 +35,15 @@ describe provider_class do
   let(:rpm_version) { "RPM version 5.0.0\n" }
 
   before(:each) do
-    Puppet::Util.stubs(:which).with("rpm").returns("/bin/rpm")
-    provider_class.stubs(:which).with("rpm").returns("/bin/rpm")
-    provider_class.instance_variable_set("@current_version", nil)
-    Puppet::Type::Package::ProviderRpm.expects(:execute)
+    allow(Puppet::Util).to receive(:which).with("rpm").and_return("/bin/rpm")
+    allow(described_class).to receive(:which).with("rpm").and_return("/bin/rpm")
+    described_class.instance_variable_set("@current_version", nil)
+    expect(Puppet::Type::Package::ProviderRpm).to receive(:execute)
       .with(["/bin/rpm", "--version"])
-      .returns(rpm_version).at_most_once
-    Puppet::Util::Execution.expects(:execute)
+      .and_return(rpm_version).at_most(:once)
+    expect(Puppet::Util::Execution).to receive(:execute)
       .with(["/bin/rpm", "--version"], execute_options)
-      .returns(Puppet::Util::Execution::ProcessOutput.new(rpm_version, 0)).at_most_once
+      .and_return(Puppet::Util::Execution::ProcessOutput.new(rpm_version, 0)).at_most(:once)
   end
 
   describe 'provider features' do
@@ -59,34 +56,36 @@ describe provider_class do
   describe "self.instances" do
     describe "with a modern version of RPM" do
       it "includes all the modern flags" do
-        Puppet::Util::Execution.expects(:execpipe).with("/bin/rpm -qa --nosignature --nodigest --qf '#{nevra_format}'").yields(packages)
+        expect(Puppet::Util::Execution).to receive(:execpipe).with("/bin/rpm -qa --nosignature --nodigest --qf '#{nevra_format}'").and_yield(packages)
 
-        provider_class.instances
+        described_class.instances
       end
     end
 
     describe "with a version of RPM < 4.1" do
       let(:rpm_version) { "RPM version 4.0.2\n" }
+
       it "excludes the --nosignature flag" do
-        Puppet::Util::Execution.expects(:execpipe).with("/bin/rpm -qa  --nodigest --qf '#{nevra_format}'").yields(packages)
+        expect(Puppet::Util::Execution).to receive(:execpipe).with("/bin/rpm -qa  --nodigest --qf '#{nevra_format}'").and_yield(packages)
 
-        provider_class.instances
+        described_class.instances
       end
     end
 
     describe "with a version of RPM < 4.0.2" do
       let(:rpm_version) { "RPM version 3.0.5\n" }
+
       it "excludes the --nodigest flag" do
-        Puppet::Util::Execution.expects(:execpipe).with("/bin/rpm -qa   --qf '#{nevra_format}'").yields(packages)
+        expect(Puppet::Util::Execution).to receive(:execpipe).with("/bin/rpm -qa   --qf '#{nevra_format}'").and_yield(packages)
 
-        provider_class.instances
+        described_class.instances
       end
     end
 
     it "returns an array of packages" do
-      Puppet::Util::Execution.expects(:execpipe).with("/bin/rpm -qa --nosignature --nodigest --qf '#{nevra_format}'").yields(packages)
+      expect(Puppet::Util::Execution).to receive(:execpipe).with("/bin/rpm -qa --nosignature --nodigest --qf '#{nevra_format}'").and_yield(packages)
 
-      installed_packages = provider_class.instances
+      installed_packages = described_class.instances
 
       expect(installed_packages[0].properties).to eq(
         {
@@ -168,7 +167,7 @@ describe provider_class do
 
     describe "when not already installed" do
       it "only includes the '-i' flag" do
-        Puppet::Util::Execution.expects(:execute).with(["/bin/rpm", ["-i"], '/path/to/package'], execute_options)
+        expect(Puppet::Util::Execution).to receive(:execute).with(["/bin/rpm", ["-i"], '/path/to/package'], execute_options)
         provider.install
       end
     end
@@ -185,7 +184,7 @@ describe provider_class do
       end
 
       it "includes the options" do
-        Puppet::Util::Execution.expects(:execute).with(["/bin/rpm", ["-i", "-D", "--test=value", "-Q"], '/path/to/package'], execute_options)
+        expect(Puppet::Util::Execution).to receive(:execute).with(["/bin/rpm", ["-i", "-D", "--test=value", "-Q"], '/path/to/package'], execute_options)
         provider.install
       end
     end
@@ -198,7 +197,7 @@ describe provider_class do
       end
 
       it "includes the '-U --oldpackage' flags" do
-         Puppet::Util::Execution.expects(:execute).with(["/bin/rpm", ["-U", "--oldpackage"], '/path/to/package'], execute_options)
+         expect(Puppet::Util::Execution).to receive(:execute).with(["/bin/rpm", ["-U", "--oldpackage"], '/path/to/package'], execute_options)
          provider.install
       end
     end
@@ -206,16 +205,16 @@ describe provider_class do
 
   describe "#latest" do
     it "retrieves version string after querying rpm for version from source file" do
-      resource.expects(:[]).with(:source).returns('source-string')
-      Puppet::Util::Execution.expects(:execute)
+      expect(resource).to receive(:[]).with(:source).and_return('source-string')
+      expect(Puppet::Util::Execution).to receive(:execute)
         .with(["/bin/rpm", "-q", "--qf", "'#{nevra_format}'", "-p", "source-string"])
-        .returns(Puppet::Util::Execution::ProcessOutput.new("myresource 0 1.2.3.4 5.el4 noarch\n", 0))
+        .and_return(Puppet::Util::Execution::ProcessOutput.new("myresource 0 1.2.3.4 5.el4 noarch\n", 0))
       expect(provider.latest).to eq("1.2.3.4-5.el4")
     end
 
     it "raises an error if the rpm command fails" do
-      resource.expects(:[]).with(:source).returns('source-string')
-      Puppet::Util::Execution.expects(:execute).with(["/bin/rpm", "-q", "--qf", "'#{nevra_format}'", "-p", "source-string"]).raises(Puppet::ExecutionFailure, 'rpm command failed')
+      expect(resource).to receive(:[]).with(:source).and_return('source-string')
+      expect(Puppet::Util::Execution).to receive(:execute).with(["/bin/rpm", "-q", "--qf", "'#{nevra_format}'", "-p", "source-string"]).and_raise(Puppet::ExecutionFailure, 'rpm command failed')
 
       expect {
         provider.latest
@@ -233,43 +232,43 @@ describe provider_class do
 
     describe "on a modern RPM" do
       before(:each) do
-        Puppet::Util::Execution.expects(:execute)
+        expect(Puppet::Util::Execution).to receive(:execute)
           .with(["/bin/rpm", "-q", "myresource", '--nosignature', '--nodigest', "--qf", "'#{nevra_format}'"], execute_options)
-          .returns(Puppet::Util::Execution::ProcessOutput.new("myresource 0 1.2.3.4 5.el4 noarch\n", 0))
+          .and_return(Puppet::Util::Execution::ProcessOutput.new("myresource 0 1.2.3.4 5.el4 noarch\n", 0))
       end
 
       let(:rpm_version) { "RPM version 4.10.0\n" }
 
       it "includes the architecture in the package name" do
-        Puppet::Util::Execution.expects(:execute)
+        expect(Puppet::Util::Execution).to receive(:execute)
           .with(["/bin/rpm", ["-e"], 'myresource-1.2.3.4-5.el4.noarch'], execute_options)
-          .returns(Puppet::Util::Execution::ProcessOutput.new('', 0)).at_most_once
+          .and_return(Puppet::Util::Execution::ProcessOutput.new('', 0)).at_most(:once)
         provider.uninstall
       end
     end
 
     describe "on an ancient RPM" do
       before(:each) do
-        Puppet::Util::Execution.expects(:execute)
+        expect(Puppet::Util::Execution).to receive(:execute)
           .with(["/bin/rpm", "-q", "myresource", '', '', '--qf', "'#{nevra_format}'"], execute_options)
-          .returns(Puppet::Util::Execution::ProcessOutput.new("myresource 0 1.2.3.4 5.el4 noarch\n", 0))
+          .and_return(Puppet::Util::Execution::ProcessOutput.new("myresource 0 1.2.3.4 5.el4 noarch\n", 0))
       end
 
       let(:rpm_version) { "RPM version 3.0.6\n" }
 
       it "excludes the architecture from the package name" do
-        Puppet::Util::Execution.expects(:execute)
+        expect(Puppet::Util::Execution).to receive(:execute)
           .with(["/bin/rpm", ["-e"], 'myresource-1.2.3.4-5.el4'], execute_options)
-          .returns(Puppet::Util::Execution::ProcessOutput.new('', 0)).at_most_once
+          .and_return(Puppet::Util::Execution::ProcessOutput.new('', 0)).at_most(:once)
         provider.uninstall
       end
     end
 
     describe "when uninstalled with options" do
       before(:each) do
-        Puppet::Util::Execution.expects(:execute)
+        expect(Puppet::Util::Execution).to receive(:execute)
           .with(["/bin/rpm", "-q", "myresource", '--nosignature', '--nodigest', "--qf", "'#{nevra_format}'"], execute_options)
-          .returns(Puppet::Util::Execution::ProcessOutput.new("myresource 0 1.2.3.4 5.el4 noarch\n", 0))
+          .and_return(Puppet::Util::Execution::ProcessOutput.new("myresource 0 1.2.3.4 5.el4 noarch\n", 0))
       end
 
       let(:resource) do
@@ -282,7 +281,7 @@ describe provider_class do
       end
 
       it "includes the options" do
-        Puppet::Util::Execution.expects(:execute).with(["/bin/rpm", ["-e", "--nodeps"], 'myresource-1.2.3.4-5.el4.noarch'], execute_options)
+        expect(Puppet::Util::Execution).to receive(:execute).with(["/bin/rpm", ["-e", "--nodeps"], 'myresource-1.2.3.4-5.el4.noarch'], execute_options)
         provider.uninstall
       end
     end
@@ -290,10 +289,10 @@ describe provider_class do
 
   describe "parsing" do
     def parser_test(rpm_output_string, gold_hash, number_of_debug_logs = 0)
-      Puppet.expects(:debug).times(number_of_debug_logs)
-      Puppet::Util::Execution.expects(:execute)
+      expect(Puppet).to receive(:debug).exactly(number_of_debug_logs).times()
+      expect(Puppet::Util::Execution).to receive(:execute)
         .with(["/bin/rpm", "-q", resource_name, "--nosignature", "--nodigest", "--qf", "'#{nevra_format}'"], execute_options)
-        .returns(Puppet::Util::Execution::ProcessOutput.new(rpm_output_string, 0))
+        .and_return(Puppet::Util::Execution::ProcessOutput.new(rpm_output_string, 0))
       expect(provider.query).to eq(gold_hash)
     end
 
@@ -313,7 +312,6 @@ describe provider_class do
     let(:line) { 'name epoch version release arch' }
 
     ['name', 'epoch', 'version', 'release', 'arch'].each do |field|
-
       it "still parses if #{field} is replaced by delimiter" do
         parser_test(
           line.gsub(field, delimiter),
@@ -323,7 +321,6 @@ describe provider_class do
           )
         )
       end
-
     end
 
     it "does not fail if line is unparseable, but issues a debug log" do
@@ -332,9 +329,9 @@ describe provider_class do
 
     describe "when the package is not found" do
       before do
-        Puppet.expects(:debug).never
+        expect(Puppet).not_to receive(:debug)
         expected_args = ["/bin/rpm", "-q", resource_name, "--nosignature", "--nodigest", "--qf", "'#{nevra_format}'"]
-        Puppet::Util::Execution.expects(:execute).with(expected_args, execute_options).raises Puppet::ExecutionFailure.new("package #{resource_name} is not installed")
+        expect(Puppet::Util::Execution).to receive(:execute).with(expected_args, execute_options).and_raise(Puppet::ExecutionFailure.new("package #{resource_name} is not installed"))
       end
 
       it "does not log or fail if allow_virtual is false" do
@@ -345,7 +342,7 @@ describe provider_class do
       it "does not log or fail if allow_virtual is true" do
         resource[:allow_virtual] = true
         expected_args = ['/bin/rpm', '-q', resource_name, '--nosignature', '--nodigest', '--qf', "'#{nevra_format}'", '--whatprovides']
-        Puppet::Util::Execution.expects(:execute).with(expected_args, execute_options).raises Puppet::ExecutionFailure.new("package #{resource_name} is not provided")
+        expect(Puppet::Util::Execution).to receive(:execute).with(expected_args, execute_options).and_raise(Puppet::ExecutionFailure.new("package #{resource_name} is not provided"))
         expect(provider.query).to be_nil
       end
     end
@@ -353,10 +350,10 @@ describe provider_class do
     it "parses virtual package" do
       provider.resource[:allow_virtual] = true
       expected_args = ["/bin/rpm", "-q", resource_name, "--nosignature", "--nodigest", "--qf", "'#{nevra_format}'"]
-      Puppet::Util::Execution.expects(:execute).with(expected_args, execute_options).raises Puppet::ExecutionFailure.new("package #{resource_name} is not installed")
-      Puppet::Util::Execution.expects(:execute)
+      expect(Puppet::Util::Execution).to receive(:execute).with(expected_args, execute_options).and_raise(Puppet::ExecutionFailure.new("package #{resource_name} is not installed"))
+      expect(Puppet::Util::Execution).to receive(:execute)
         .with(expected_args + ["--whatprovides"], execute_options)
-        .returns(Puppet::Util::Execution::ProcessOutput.new("myresource 0 1.2.3.4 5.el4 noarch\n", 0))
+        .and_return(Puppet::Util::Execution::ProcessOutput.new("myresource 0 1.2.3.4 5.el4 noarch\n", 0))
       expect(provider.query).to eq({
         :name     => "myresource",
         :epoch    => "0",
@@ -430,8 +427,8 @@ describe provider_class do
     }.each do |version, expected|
       describe "when current version is #{version}" do
         it "returns #{expected.inspect}" do
-          provider_class.stubs(:current_version).returns(version)
-          expect(provider_class.nodigest).to eq(expected)
+          allow(described_class).to receive(:current_version).and_return(version)
+          expect(described_class.nodigest).to eq(expected)
         end
       end
     end
@@ -446,15 +443,14 @@ describe provider_class do
     }.each do |version, expected|
       describe "when current version is #{version}" do
         it "returns #{expected.inspect}" do
-          provider_class.stubs(:current_version).returns(version)
-          expect(provider_class.nosignature).to eq(expected)
+          allow(described_class).to receive(:current_version).and_return(version)
+          expect(described_class.nosignature).to eq(expected)
         end
       end
     end
   end
 
   describe 'version comparison' do
-
     # test cases munged directly from rpm's own
     # tests/rpmvercmp.at
     it { expect(provider.rpmvercmp("1.0", "1.0")).to eq(0) }
@@ -538,7 +534,6 @@ describe provider_class do
   end
 
   describe 'package evr parsing' do
-
     it 'should parse full simple evr' do
       v = provider.rpm_parse_evr('0:1.2.3-4.el5')
       expect(v[:epoch]).to eq('0')
@@ -595,11 +590,9 @@ describe provider_class do
       expect(v[:version]).to eq('2.2')
       expect(v[:release]).to eq('SNAPSHOT20121119105647')
     end
-
   end
 
   describe 'rpm evr comparison' do
-
     # currently passing tests
     it 'should evaluate identical version-release as equal' do
       v = provider.rpm_compareEVR({:epoch => '0', :version => '1.2.3', :release => '1.el5'},
@@ -643,11 +636,9 @@ describe provider_class do
       expect(provider.rpm_compareEVR({:epoch => '0', :version => '2.2', :release => '405'},
                                {:epoch => '0', :version => '2.2', :release => '406'})).to eq(-1)
     end
-
   end
 
   describe 'version segment comparison' do
-
     it 'should treat two nil values as equal' do
       v = provider.compare_values(nil, nil)
       expect(v).to eq(0)
@@ -664,11 +655,9 @@ describe provider_class do
     end
 
     it 'should pass two non-nil values on to rpmvercmp' do
-      provider.stubs(:rpmvercmp) { 0 }
-      provider.expects(:rpmvercmp).with('s1', 's2')
+      allow(provider).to receive(:rpmvercmp).and_return(0)
+      expect(provider).to receive(:rpmvercmp).with('s1', 's2')
       provider.compare_values('s1', 's2')
     end
-
   end
-
 end