puppet 6.0.10-x64-mingw32 → 6.1.0-x64-mingw32

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

@@ -1,139 +1,143 @@
+#! /usr/bin/env ruby
+
 require 'spec_helper'
 
-describe Puppet::Type.type(:package).provider(:portage) do
+provider = Puppet::Type.type(:package).provider(:portage)
+
+describe provider do
   before do
-    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' }])
+    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' }])
 
     unslotted_packagename = "dev-lang/ruby"
-    @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([])
+    @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([])
 
     slotted_packagename = "dev-lang/ruby:2.1"
-    @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' }])
+    @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' }])
 
     versioned_packagename = "dev-lang/ruby-1.9.3"
-    @versioned_resource = double('resource', :should => true)
-    allow(@versioned_resource).to receive(:[]).with(:name).and_return(versioned_packagename)
-    allow(@versioned_resource).to receive(:[]).with(:uninstall_options).and_return([])
+    @versioned_resource = stub('resource', :should => true)
+    @versioned_resource.stubs(:[]).with(:name).returns(versioned_packagename)
+    @versioned_resource.stubs(:[]).with(:uninstall_options).returns([])
 
     versioned_slotted_packagename = "=dev-lang/ruby-1.9.3:1.9"
-    @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(:uninstall_options).and_return([])
+    @versioned_slotted_resource = stub('resource', :should => true)
+    @versioned_slotted_resource.stubs(:[]).with(:name).returns(versioned_slotted_packagename)
+    @versioned_slotted_resource.stubs(:[]).with(:uninstall_options).returns([])
 
     set_packagename = "@system"
-    @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([])
+    @set_resource = stub('resource', :should => true)
+    @set_resource.stubs(:[]).with(:name).returns(set_packagename)
+    @set_resource.stubs(:[]).with(:install_options).returns([])
 
     package_sets = "system\nworld\n"
-    @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=>nil, :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"
+    @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=>nil, :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)
+
+    @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"
     @slot_match_result = "dev-lang ruby [2.1.8] [2.1.9] [2.1.8:2.1] [2.1.8] [2.1.9,,,,,,,] [2.1.9:2.1] http://www.ruby-lang.org/ An object-oriented scripting language\n"
   end
 
   it "is versionable" do
-    expect(described_class).to be_versionable
+    expect(provider).to be_versionable
   end
 
   it "is reinstallable" do
-    expect(described_class).to be_reinstallable
+    expect(provider).to be_reinstallable
   end
 
   it 'should support string install options' do
-    expect(@provider).to receive(:emerge).with('--foo', '--bar', @resource[:name])
+    @provider.expects(:emerge).with('--foo', '--bar', @resource[:name])
 
     @provider.install
   end
 
   it 'should support updating' do
-    expect(@unslotted_provider).to receive(:emerge).with('--update', @unslotted_resource[:name])
+    @unslotted_provider.expects(:emerge).with('--update', @unslotted_resource[:name])
 
     @unslotted_provider.install
   end
 
   it 'should support hash install options' do
-    expect(@slotted_provider).to receive(:emerge).with('--foo', '--bar=baz', '--baz=foo', @slotted_resource[:name])
+    @slotted_provider.expects(:emerge).with('--foo', '--bar=baz', '--baz=foo', @slotted_resource[:name])
 
     @slotted_provider.install
   end
 
   it 'should support hash uninstall options' do
-    expect(@provider).to receive(:emerge).with('--rage-clean', '--foo', '--bar=baz', '--baz=foo', @resource[:name])
+    @provider.expects(:emerge).with('--rage-clean', '--foo', '--bar=baz', '--baz=foo', @resource[:name])
 
     @provider.uninstall
   end
 
   it 'should support uninstall of specific version' do
-    expect(@versioned_provider).to receive(:emerge).with('--rage-clean', @versioned_resource[:name])
+    @versioned_provider.expects(:emerge).with('--rage-clean', @versioned_resource[:name])
 
     @versioned_provider.uninstall
   end
 
   it 'should support uninstall of specific version and slot' do
-    expect(@versioned_slotted_provider).to receive(:emerge).with('--rage-clean', @versioned_slotted_resource[:name])
+    @versioned_slotted_provider.expects(:emerge).with('--rage-clean', @versioned_slotted_resource[:name])
 
     @versioned_slotted_provider.uninstall
   end
 
   it "uses :emerge to install packages" do
-    expect(@provider).to receive(:emerge)
+    @provider.expects(:emerge)
 
     @provider.install
   end
 
   it "uses query to find the latest package" do
-    expect(@provider).to receive(:query).and_return({:versions_available => "myversion"})
+    @provider.expects(:query).returns({:versions_available => "myversion"})
 
     @provider.latest
   end
 
   it "uses eix to search the lastest version of a package" do
-    allow(@provider).to receive(:update_eix)
-    expect(@provider).to receive(:eix).and_return(StringIO.new(@match_result))
+    @provider.stubs(:update_eix)
+    @provider.expects(:eix).returns(StringIO.new(@match_result))
 
     @provider.query
   end
 
   it "allows to emerge package sets" do
-    expect(@set_provider).to receive(:emerge).with(@set_resource[:name])
+    @set_provider.expects(:emerge).with(@set_resource[:name])
 
     @set_provider.install
   end
 
   it "allows to emerge and update package sets" do
-    allow(@set_resource).to receive(:should).with(:ensure).and_return(:latest)
-    expect(@set_provider).to receive(:emerge).with('--update', @set_resource[:name])
+    @set_resource.stubs(:should).with(:ensure).returns :latest
+    @set_provider.expects(:emerge).with('--update', @set_resource[:name])
 
     @set_provider.install
   end
@@ -147,16 +151,16 @@ describe Puppet::Type.type(:package).provider(:portage) do
   end
 
   it "query uses default arguments" do
-    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.stubs(:update_eix)
+    @provider.expects(:eix).returns(StringIO.new(@match_result))
+    @provider.class.expects(:eix_search_arguments).returns([])
 
     @provider.query
   end
 
   it "can handle search output with empty square brackets" do
-    allow(@provider).to receive(:update_eix)
-    expect(@provider).to receive(:eix).and_return(StringIO.new(@match_result))
+    @provider.stubs(:update_eix)
+    @provider.expects(:eix).returns(StringIO.new(@match_result))
 
     expect(@provider.query[:name]).to eq("sl")
   end
@@ -186,8 +190,8 @@ describe Puppet::Type.type(:package).provider(:portage) do
   end
 
   it "can handle search output with slots for unslotted packages" do
-    allow(@unslotted_provider).to receive(:update_eix)
-    expect(@unslotted_provider).to receive(:eix).and_return(StringIO.new(@slot_match_result))
+    @unslotted_provider.stubs(:update_eix)
+    @unslotted_provider.expects(:eix).returns(StringIO.new(@slot_match_result))
 
     result = @unslotted_provider.query
     expect(result[:name]).to eq('ruby')
@@ -196,8 +200,8 @@ describe Puppet::Type.type(:package).provider(:portage) do
   end
 
   it "can handle search output with slots" do
-    allow(@slotted_provider).to receive(:update_eix)
-    expect(@slotted_provider).to receive(:eix).and_return(StringIO.new(@slot_match_result))
+    @slotted_provider.stubs(:update_eix)
+    @slotted_provider.expects(:eix).returns(StringIO.new(@slot_match_result))
 
     result = @slotted_provider.query
     expect(result[:name]).to eq('ruby')

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

@@ -15,74 +15,50 @@ describe Puppet::Type.type(:package).provider(:puppet_gem) do
   end
 
   if Puppet::Util::Platform.windows?
-    let(:provider_gem_cmd) { 'gem' }
+    let(:puppet_gem) { 'gem' }
   else
-    let(:provider_gem_cmd) { '/opt/puppetlabs/puppet/bin/gem' }
+    let(:puppet_gem) { '/opt/puppetlabs/puppet/bin/gem' }
   end
 
-  let(:execute_options) { {:failonfail => true, :combine => true, :custom_environment => {"HOME"=>ENV["HOME"]}} }
-
   before :each do
     resource.provider = provider
-    allow(described_class).to receive(:command).with(:gemcmd).and_return(provider_gem_cmd)
   end
 
   context "when installing" do
-    before :each do
-      allow(provider).to receive(:rubygem_version).and_return('1.9.9')
-    end
-
-    it "should use the path to the gem command" do
-      allow(described_class).to receive(:validate_command).with(provider_gem_cmd)
-      expect(described_class).to receive(:execute).with(be_a(Array), execute_options) { |args| expect(args[0]).to eq(provider_gem_cmd) }.and_return('')
+    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 ''
       provider.install
     end
 
     it "should not append install_options by default" do
-      expect(described_class).to receive(:execute_gem_command).with(provider_gem_cmd, %w{install --no-rdoc --no-ri myresource}).and_return('')
+      provider.expects(:execute).with { |args| args.length == 5 }.returns ''
       provider.install
     end
 
     it "should allow setting an install_options parameter" do
       resource[:install_options] = [ '--force', {'--bindir' => '/usr/bin' } ]
-      expect(described_class).to receive(:execute_gem_command).with(provider_gem_cmd, %w{install --force --bindir=/usr/bin --no-rdoc --no-ri myresource}).and_return('')
+      provider.expects(:execute).with { |args| args[2] == '--force' && args[3] == '--bindir=/usr/bin' }.returns ''
       provider.install
     end
   end
 
   context "when uninstalling" do
-    it "should use the path to the gem command" do
-      allow(described_class).to receive(:validate_command).with(provider_gem_cmd)
-      expect(described_class).to receive(:execute).with(be_a(Array), execute_options) { |args| expect(args[0]).to eq(provider_gem_cmd) }.and_return('')
-      provider.uninstall
+    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 ''
+      provider.install
     end
 
     it "should not append uninstall_options by default" do
-      expect(described_class).to receive(:execute_gem_command).with(provider_gem_cmd, %w{uninstall --executables --all myresource}).and_return('')
+      provider.expects(:execute).with { |args| args.length == 5 }.returns ''
       provider.uninstall
     end
 
     it "should allow setting an uninstall_options parameter" do
       resource[:uninstall_options] = [ '--force', {'--bindir' => '/usr/bin' } ]
-      expect(described_class).to receive(:execute_gem_command).with(provider_gem_cmd, %w{uninstall --executables --all myresource --force --bindir=/usr/bin}).and_return('')
+      provider.expects(:execute).with { |args| args[5] == '--force' && args[6] == '--bindir=/usr/bin' }.returns ''
       provider.uninstall
     end
   end
-
-  context 'calculated specificity' do
-    context 'when is not defaultfor' do
-      subject { described_class.specificity }
-      it { is_expected.to eql 1 }
-    end
-
-    context 'when is defaultfor' do
-      let(:os) {  Facter.value(:operatingsystem) }
-      subject do
-        described_class.defaultfor(operatingsystem: os)
-        described_class.specificity
-      end
-      it { is_expected.to be > 100 }
-    end
-  end
-
 end

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

@@ -1,6 +1,9 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
-describe Puppet::Type.type(:package).provider(:rpm) do
+provider_class = Puppet::Type.type(:package).provider(:rpm)
+
+describe provider_class do
   let (:packages) do
     <<-RPM_OUTPUT
     'cracklib-dicts 0 2.8.9 3.3 x86_64
@@ -23,7 +26,7 @@ describe Puppet::Type.type(:package).provider(:rpm) do
   end
 
   let(:provider) do
-    provider = subject()
+    provider = provider_class.new
     provider.resource = resource
     provider
   end
@@ -35,15 +38,15 @@ describe Puppet::Type.type(:package).provider(:rpm) do
   let(:rpm_version) { "RPM version 5.0.0\n" }
 
   before(:each) do
-    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)
+    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)
       .with(["/bin/rpm", "--version"])
-      .and_return(rpm_version).at_most(:once)
-    expect(Puppet::Util::Execution).to receive(:execute)
+      .returns(rpm_version).at_most_once
+    Puppet::Util::Execution.expects(:execute)
       .with(["/bin/rpm", "--version"], execute_options)
-      .and_return(Puppet::Util::Execution::ProcessOutput.new(rpm_version, 0)).at_most(:once)
+      .returns(Puppet::Util::Execution::ProcessOutput.new(rpm_version, 0)).at_most_once
   end
 
   describe 'provider features' do
@@ -56,44 +59,34 @@ describe Puppet::Type.type(:package).provider(:rpm) do
   describe "self.instances" do
     describe "with a modern version of RPM" do
       it "includes all the modern flags" do
-        expect(Puppet::Util::Execution).to receive(:execpipe)
-          .with("/bin/rpm -qa --nosignature --nodigest --qf '#{nevra_format}'")
-          .and_yield(packages)
+        Puppet::Util::Execution.expects(:execpipe).with("/bin/rpm -qa --nosignature --nodigest --qf '#{nevra_format}'").yields(packages)
 
-        described_class.instances
+        provider_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
-        expect(Puppet::Util::Execution).to receive(:execpipe)
-          .with("/bin/rpm -qa  --nodigest --qf '#{nevra_format}'")
-          .and_yield(packages)
+        Puppet::Util::Execution.expects(:execpipe).with("/bin/rpm -qa  --nodigest --qf '#{nevra_format}'").yields(packages)
 
-        described_class.instances
+        provider_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
-        expect(Puppet::Util::Execution).to receive(:execpipe)
-        .with("/bin/rpm -qa   --qf '#{nevra_format}'")
-        .and_yield(packages)
+        Puppet::Util::Execution.expects(:execpipe).with("/bin/rpm -qa   --qf '#{nevra_format}'").yields(packages)
 
-        described_class.instances
+        provider_class.instances
       end
     end
 
     it "returns an array of packages" do
-      expect(Puppet::Util::Execution).to receive(:execpipe)
-        .with("/bin/rpm -qa --nosignature --nodigest --qf '#{nevra_format}'")
-        .and_yield(packages)
+      Puppet::Util::Execution.expects(:execpipe).with("/bin/rpm -qa --nosignature --nodigest --qf '#{nevra_format}'").yields(packages)
 
-      installed_packages = described_class.instances
+      installed_packages = provider_class.instances
 
       expect(installed_packages[0].properties).to eq(
         {
@@ -175,8 +168,7 @@ describe Puppet::Type.type(:package).provider(:rpm) do
 
     describe "when not already installed" do
       it "only includes the '-i' flag" do
-        expect(Puppet::Util::Execution).to receive(:execute)
-          .with(["/bin/rpm", ["-i"], '/path/to/package'], execute_options)
+        Puppet::Util::Execution.expects(:execute).with(["/bin/rpm", ["-i"], '/path/to/package'], execute_options)
         provider.install
       end
     end
@@ -193,8 +185,7 @@ describe Puppet::Type.type(:package).provider(:rpm) do
       end
 
       it "includes the options" do
-        expect(Puppet::Util::Execution).to receive(:execute)
-          .with(["/bin/rpm", ["-i", "-D", "--test=value", "-Q"], '/path/to/package'], execute_options)
+        Puppet::Util::Execution.expects(:execute).with(["/bin/rpm", ["-i", "-D", "--test=value", "-Q"], '/path/to/package'], execute_options)
         provider.install
       end
     end
@@ -207,8 +198,7 @@ describe Puppet::Type.type(:package).provider(:rpm) do
       end
 
       it "includes the '-U --oldpackage' flags" do
-         expect(Puppet::Util::Execution).to receive(:execute)
-           .with(["/bin/rpm", ["-U", "--oldpackage"], '/path/to/package'], execute_options)
+         Puppet::Util::Execution.expects(:execute).with(["/bin/rpm", ["-U", "--oldpackage"], '/path/to/package'], execute_options)
          provider.install
       end
     end
@@ -216,18 +206,16 @@ describe Puppet::Type.type(:package).provider(:rpm) do
 
   describe "#latest" do
     it "retrieves version string after querying rpm for version from source file" do
-      expect(resource).to receive(:[]).with(:source).and_return('source-string')
-      expect(Puppet::Util::Execution).to receive(:execute)
+      resource.expects(:[]).with(:source).returns('source-string')
+      Puppet::Util::Execution.expects(:execute)
         .with(["/bin/rpm", "-q", "--qf", "'#{nevra_format}'", "-p", "source-string"])
-        .and_return(Puppet::Util::Execution::ProcessOutput.new("myresource 0 1.2.3.4 5.el4 noarch\n", 0))
+        .returns(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
-      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')
+      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 {
         provider.latest
@@ -238,115 +226,52 @@ describe Puppet::Type.type(:package).provider(:rpm) do
   describe "#uninstall" do
     let(:resource) do
       Puppet::Type.type(:package).new(
-        :name   => resource_name,
-        :ensure => :installed
+        :name     => 'myresource',
+        :ensure   => :installed
       )
     end
 
-    describe "on an ancient RPM" do
-      let(:rpm_version) { "RPM version 3.0.6\n" }
-
-      before(:each) do
-        expect(Puppet::Util::Execution).to receive(:execute)
-          .with(["/bin/rpm", "-q", resource_name, '', '', '--qf', "'#{nevra_format}'"], execute_options)
-          .and_return(Puppet::Util::Execution::ProcessOutput.new("#{resource_name} 0 1.2.3.4 5.el4 noarch\n", 0))
-      end
-
-      it "excludes the architecture from the package name" do
-        expect(Puppet::Util::Execution).to receive(:execute)
-          .with(["/bin/rpm", ["-e"], resource_name], execute_options)
-          .and_return(Puppet::Util::Execution::ProcessOutput.new('', 0)).at_most(:once)
-        provider.uninstall
-      end
-    end
-
     describe "on a modern RPM" do
-      let(:rpm_version) { "RPM version 4.10.0\n" }
-
-
       before(:each) do
-        expect(Puppet::Util::Execution).to receive(:execute)
-          .with(["/bin/rpm", "-q", resource_name, '--nosignature', '--nodigest', "--qf", "'#{nevra_format}'"], execute_options)
-          .and_return(Puppet::Util::Execution::ProcessOutput.new("#{resource_name} 0 1.2.3.4 5.el4 noarch\n", 0))
-      end
-
-      it "excludes the architecture from the package name" do
-        expect(Puppet::Util::Execution).to receive(:execute)
-          .with(["/bin/rpm", ["-e"], resource_name], execute_options)
-          .and_return(Puppet::Util::Execution::ProcessOutput.new('', 0)).at_most(:once)
-        provider.uninstall
+        Puppet::Util::Execution.expects(: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))
       end
-    end
 
-    describe "on a modern RPM when architecture is specified" do
       let(:rpm_version) { "RPM version 4.10.0\n" }
 
-      let(:resource) do
-        Puppet::Type.type(:package).new(
-          :name   => "#{resource_name}.noarch",
-          :ensure => :absent,
-        )
-      end
-
-      before(:each) do
-        expect(Puppet::Util::Execution).to receive(:execute)
-          .with(["/bin/rpm", "-q", "#{resource_name}.noarch", '--nosignature', '--nodigest', "--qf", "'#{nevra_format}'"], execute_options)
-          .and_return(Puppet::Util::Execution::ProcessOutput.new("#{resource_name} 0 1.2.3.4 5.el4 noarch\n", 0))
-      end
-
       it "includes the architecture in the package name" do
-        expect(Puppet::Util::Execution).to receive(:execute)
-          .with(["/bin/rpm", ["-e"], "#{resource_name}.noarch"], execute_options)
-          .and_return(Puppet::Util::Execution::ProcessOutput.new('', 0)).at_most(:once)
+        Puppet::Util::Execution.expects(: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
         provider.uninstall
       end
     end
 
-    describe "when version and release are specified" do
-      let(:resource) do
-        Puppet::Type.type(:package).new(
-          :name   => "#{resource_name}-1.2.3.4-5.el4",
-          :ensure => :absent,
-        )
-      end
-
+    describe "on an ancient RPM" do
       before(:each) do
-        expect(Puppet::Util::Execution).to receive(:execute)
-          .with(["/bin/rpm", "-q", "#{resource_name}-1.2.3.4-5.el4", '--nosignature', '--nodigest', "--qf", "'#{nevra_format}'"], execute_options)
-          .and_return(Puppet::Util::Execution::ProcessOutput.new("#{resource_name} 0 1.2.3.4 5.el4 noarch\n", 0))
+        Puppet::Util::Execution.expects(: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))
       end
 
-      it "includes the version and release in the package name" do
-        expect(Puppet::Util::Execution).to receive(:execute)
-          .with(["/bin/rpm", ["-e"], "#{resource_name}-1.2.3.4-5.el4"], execute_options)
-          .and_return(Puppet::Util::Execution::ProcessOutput.new('', 0)).at_most(:once)
+      let(:rpm_version) { "RPM version 3.0.6\n" }
+
+      it "excludes the architecture from the package name" do
+        Puppet::Util::Execution.expects(:execute)
+          .with(["/bin/rpm", ["-e"], 'myresource-1.2.3.4-5.el4'], execute_options)
+          .returns(Puppet::Util::Execution::ProcessOutput.new('', 0)).at_most_once
         provider.uninstall
       end
     end
 
-    describe "when only version is specified" do
-      let(:resource) do
-        Puppet::Type.type(:package).new(
-          :name   => "#{resource_name}-1.2.3.4",
-          :ensure => :absent,
-        )
-      end
-
+    describe "when uninstalled with options" do
       before(:each) do
-        expect(Puppet::Util::Execution).to receive(:execute)
-          .with(["/bin/rpm", "-q", "#{resource_name}-1.2.3.4", '--nosignature', '--nodigest', "--qf", "'#{nevra_format}'"], execute_options)
-          .and_return(Puppet::Util::Execution::ProcessOutput.new("#{resource_name} 0 1.2.3.4 5.el4 noarch\n", 0))
-      end
-
-      it "includes the version in the package name" do
-        expect(Puppet::Util::Execution).to receive(:execute)
-          .with(["/bin/rpm", ["-e"], "#{resource_name}-1.2.3.4"], execute_options)
-          .and_return(Puppet::Util::Execution::ProcessOutput.new('', 0)).at_most(:once)
-        provider.uninstall
+        Puppet::Util::Execution.expects(: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))
       end
-    end
 
-    describe "when uninstalled with options" do
       let(:resource) do
         Puppet::Type.type(:package).new(
           :name              => resource_name,
@@ -356,15 +281,8 @@ describe Puppet::Type.type(:package).provider(:rpm) do
         )
       end
 
-      before(:each) do
-        expect(Puppet::Util::Execution).to receive(:execute)
-          .with(["/bin/rpm", "-q", resource_name, '--nosignature', '--nodigest', "--qf", "'#{nevra_format}'"], execute_options)
-          .and_return(Puppet::Util::Execution::ProcessOutput.new("#{resource_name} 0 1.2.3.4 5.el4 noarch\n", 0))
-      end
-
       it "includes the options" do
-        expect(Puppet::Util::Execution).to receive(:execute)
-          .with(["/bin/rpm", ["-e", "--nodeps"], resource_name], execute_options)
+        Puppet::Util::Execution.expects(:execute).with(["/bin/rpm", ["-e", "--nodeps"], 'myresource-1.2.3.4-5.el4.noarch'], execute_options)
         provider.uninstall
       end
     end
@@ -372,10 +290,10 @@ describe Puppet::Type.type(:package).provider(:rpm) do
 
   describe "parsing" do
     def parser_test(rpm_output_string, gold_hash, number_of_debug_logs = 0)
-      expect(Puppet).to receive(:debug).exactly(number_of_debug_logs).times()
-      expect(Puppet::Util::Execution).to receive(:execute)
+      Puppet.expects(:debug).times(number_of_debug_logs)
+      Puppet::Util::Execution.expects(:execute)
         .with(["/bin/rpm", "-q", resource_name, "--nosignature", "--nodigest", "--qf", "'#{nevra_format}'"], execute_options)
-        .and_return(Puppet::Util::Execution::ProcessOutput.new(rpm_output_string, 0))
+        .returns(Puppet::Util::Execution::ProcessOutput.new(rpm_output_string, 0))
       expect(provider.query).to eq(gold_hash)
     end
 
@@ -395,6 +313,7 @@ describe Puppet::Type.type(:package).provider(:rpm) 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),
@@ -404,6 +323,7 @@ describe Puppet::Type.type(:package).provider(:rpm) do
           )
         )
       end
+
     end
 
     it "does not fail if line is unparseable, but issues a debug log" do
@@ -412,11 +332,9 @@ describe Puppet::Type.type(:package).provider(:rpm) do
 
     describe "when the package is not found" do
       before do
-        expect(Puppet).not_to receive(:debug)
+        Puppet.expects(:debug).never
         expected_args = ["/bin/rpm", "-q", resource_name, "--nosignature", "--nodigest", "--qf", "'#{nevra_format}'"]
-        expect(Puppet::Util::Execution).to receive(:execute)
-          .with(expected_args, execute_options)
-          .and_raise(Puppet::ExecutionFailure.new("package #{resource_name} is not installed"))
+        Puppet::Util::Execution.expects(:execute).with(expected_args, execute_options).raises Puppet::ExecutionFailure.new("package #{resource_name} is not installed")
       end
 
       it "does not log or fail if allow_virtual is false" do
@@ -427,9 +345,7 @@ describe Puppet::Type.type(:package).provider(:rpm) 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']
-        expect(Puppet::Util::Execution).to receive(:execute)
-          .with(expected_args, execute_options)
-          .and_raise(Puppet::ExecutionFailure.new("package #{resource_name} is not provided"))
+        Puppet::Util::Execution.expects(:execute).with(expected_args, execute_options).raises Puppet::ExecutionFailure.new("package #{resource_name} is not provided")
         expect(provider.query).to be_nil
       end
     end
@@ -437,12 +353,10 @@ describe Puppet::Type.type(:package).provider(:rpm) do
     it "parses virtual package" do
       provider.resource[:allow_virtual] = true
       expected_args = ["/bin/rpm", "-q", resource_name, "--nosignature", "--nodigest", "--qf", "'#{nevra_format}'"]
-      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)
+      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)
         .with(expected_args + ["--whatprovides"], execute_options)
-        .and_return(Puppet::Util::Execution::ProcessOutput.new("myresource 0 1.2.3.4 5.el4 noarch\n", 0))
+        .returns(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",
@@ -516,8 +430,8 @@ describe Puppet::Type.type(:package).provider(:rpm) do
     }.each do |version, expected|
       describe "when current version is #{version}" do
         it "returns #{expected.inspect}" do
-          allow(described_class).to receive(:current_version).and_return(version)
-          expect(described_class.nodigest).to eq(expected)
+          provider_class.stubs(:current_version).returns(version)
+          expect(provider_class.nodigest).to eq(expected)
         end
       end
     end
@@ -532,14 +446,15 @@ describe Puppet::Type.type(:package).provider(:rpm) do
     }.each do |version, expected|
       describe "when current version is #{version}" do
         it "returns #{expected.inspect}" do
-          allow(described_class).to receive(:current_version).and_return(version)
-          expect(described_class.nosignature).to eq(expected)
+          provider_class.stubs(:current_version).returns(version)
+          expect(provider_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) }
@@ -623,6 +538,7 @@ describe Puppet::Type.type(:package).provider(:rpm) 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')
@@ -679,9 +595,11 @@ describe Puppet::Type.type(:package).provider(:rpm) 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'},
@@ -725,9 +643,11 @@ describe Puppet::Type.type(:package).provider(:rpm) 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)
@@ -744,9 +664,11 @@ describe Puppet::Type.type(:package).provider(:rpm) do
     end
 
     it 'should pass two non-nil values on to rpmvercmp' do
-      allow(provider).to receive(:rpmvercmp).and_return(0)
-      expect(provider).to receive(:rpmvercmp).with('s1', 's2')
+      provider.stubs(:rpmvercmp) { 0 }
+      provider.expects(:rpmvercmp).with('s1', 's2')
       provider.compare_values('s1', 's2')
     end
+
   end
+
 end