puppet 5.5.22-universal-darwin → 6.0.0-universal-darwin

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

@@ -1,6 +1,9 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
-describe Puppet::Type.type(:package).provider(:puppet_gem) do
+provider_class = Puppet::Type.type(:package).provider(:puppet_gem)
+
+describe provider_class do
   let(:resource) do
     Puppet::Type.type(:package).new(
       :name     => 'myresource',
@@ -9,83 +12,56 @@ describe Puppet::Type.type(:package).provider(:puppet_gem) do
   end
 
   let(:provider) do
-    provider = described_class.new
+    provider = provider_class.new
     provider.resource = resource
     provider
   end
 
-  if Puppet.features.microsoft_windows?
-    let(:provider_gem_cmd) { 'gem' }
+  if Puppet::Util::Platform.windows?
+    let(:puppet_gem) { 'gem' }
   else
-    let(:provider_gem_cmd) { '/opt/puppetlabs/puppet/bin/gem' }
+    let(:puppet_gem) { '/opt/puppetlabs/puppet/bin/gem' }
   end
 
-  custom_environment = {"HOME"=>ENV["HOME"]}
-  custom_environment['PKG_CONFIG_PATH'] = '/opt/puppetlabs/puppet/lib/pkgconfig' unless Puppet::Util::Platform.windows?
-
-  let(:execute_options) { {:failonfail => true, :combine => true, :custom_environment => custom_environment} }
-
   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('')
+  describe "when installing" do
+    it "should use the path to the gem" do
+      provider_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
+  describe "when uninstalling" do
+    it "should use the path to the gem" do
+      provider_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
@@ -9,8 +12,6 @@ describe Puppet::Type.type(:package).provider(:rpm) do
     myresource 0 1.2.3.4 5.el4 noarch
     mysummaryless 0 1.2.3.4 5.el4 noarch
     tomcat 1 1.2.3.4 5.el4 x86_64
-    kernel 1 1.2.3.4 5.el4 x86_64
-    kernel 1 1.2.3.6 5.el4 x86_64
     '
     RPM_OUTPUT
   end
@@ -25,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
@@ -37,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
@@ -58,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}' | sort")
-          .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}' | sort")
-          .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}' | sort")
-        .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}' | sort")
-        .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(
         {
@@ -163,17 +154,6 @@ describe Puppet::Type.type(:package).provider(:rpm) do
           :ensure      => "1:1.2.3.4-5.el4",
         }
       )
-      expect(installed_packages[6].properties).to eq(
-        {
-          :provider    => :rpm,
-          :name        => "kernel",
-          :epoch       => "1",
-          :version     => "1.2.3.4",
-          :release     => "5.el4",
-          :arch        => "x86_64",
-          :ensure      => "1:1.2.3.4-5.el4; 1:1.2.3.6-5.el4",
-        }
-      )
     end
   end
 
@@ -188,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
@@ -206,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
@@ -220,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
@@ -229,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)
-        .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))
+      resource.expects(:[]).with(:source).returns('source-string')
+      Puppet::Util::Execution.expects(: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))
       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
@@ -251,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))
+        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
 
-      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 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))
+        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
 
-      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
-      end
-    end
-
-    describe "when uninstalled with options" do
       let(:resource) do
         Puppet::Type.type(:package).new(
           :name              => resource_name,
@@ -369,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
@@ -385,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)
-        .with(["/bin/rpm", "-q", resource_name, "--nosignature", "--nodigest", "--qf", "#{nevra_format}"], execute_options)
-        .and_return(Puppet::Util::Execution::ProcessOutput.new(rpm_output_string, 0))
+      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)
+        .returns(Puppet::Util::Execution::ProcessOutput.new(rpm_output_string, 0))
       expect(provider.query).to eq(gold_hash)
     end
 
@@ -408,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),
@@ -417,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
@@ -425,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)
-        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.expects(:debug).never
+        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")
       end
 
       it "does not log or fail if allow_virtual is false" do
@@ -439,23 +344,19 @@ 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"))
+        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(provider.query).to be_nil
       end
     end
 
     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)
+      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)
         .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",
@@ -529,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
@@ -545,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) }
@@ -636,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')
@@ -692,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'},
@@ -738,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)
@@ -757,130 +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
-
 
-  describe 'insync?' do
-    context 'for multiple versions' do
-      let(:is) { '1:1.2.3.4-5.el4; 1:5.6.7.8-5.el4' }
-      it 'returns true if there is match and feature is enabled' do
-        resource[:install_only] = true
-        resource[:ensure] = '1:1.2.3.4-5.el4'
-        expect(provider).to be_insync(is)
-      end
-      it 'returns false if there is match and feature is not enabled' do
-        resource[:ensure] = '1:1.2.3.4-5.el4'
-        expect(provider).to_not be_insync(is)
-      end
-      it 'returns false if no match and feature is enabled' do
-        resource[:install_only] = true
-        resource[:ensure] = '1:1.2.3.6-5.el4'
-        expect(provider).to_not be_insync(is)
-      end
-      it 'returns false if no match and feature is not enabled' do
-        resource[:ensure] = '1:1.2.3.6-5.el4'
-        expect(provider).to_not be_insync(is)
-      end
-    end
-    context 'for simple versions' do
-      let(:is) { '1:1.2.3.4-5.el4' }
-      it 'returns true if there is match and feature is enabled' do
-        resource[:install_only] = true
-        resource[:ensure] = '1:1.2.3.4-5.el4'
-        expect(provider).to be_insync(is)
-      end
-      it 'returns true if there is match and feature is not enabled' do
-        resource[:ensure] = '1:1.2.3.4-5.el4'
-        expect(provider).to be_insync(is)
-      end
-      it 'returns false if no match and feature is enabled' do
-        resource[:install_only] = true
-        resource[:ensure] = '1:1.2.3.6-5.el4'
-        expect(provider).to_not be_insync(is)
-      end
-      it 'returns false if no match and feature is not enabled' do
-        resource[:ensure] = '1:1.2.3.6-5.el4'
-        expect(provider).to_not be_insync(is)
-      end
-    end
   end
 
-  describe 'rpm multiversion to hash' do
-    it 'should return empty hash for empty imput' do
-      package_hash = described_class.nevra_to_multiversion_hash('')
-      expect(package_hash).to eq({})
-    end
-
-    it 'should return package hash for one package input' do
-      package_list = <<-RPM_OUTPUT
-kernel-devel 1 1.2.3.4 5.el4 x86_64
-RPM_OUTPUT
-      package_hash = described_class.nevra_to_multiversion_hash(package_list)
-      expect(package_hash).to eq(
-        {
-          :arch => "x86_64",
-          :ensure => "1:1.2.3.4-5.el4",
-          :epoch => "1",
-          :name => "kernel-devel",
-          :provider => :rpm,
-          :release => "5.el4",
-          :version => "1.2.3.4",
-        }
-      )
-    end
-
-    it 'should return package hash with versions concatenated in ensure for two package input' do
-      package_list = <<-RPM_OUTPUT
-kernel-devel 1 1.2.3.4 5.el4 x86_64
-kernel-devel 1 5.6.7.8 5.el4 x86_64
-RPM_OUTPUT
-      package_hash = described_class.nevra_to_multiversion_hash(package_list)
-      expect(package_hash).to eq(
-        {
-          :arch => "x86_64",
-          :ensure => "1:1.2.3.4-5.el4; 1:5.6.7.8-5.el4",
-          :epoch => "1",
-          :name => "kernel-devel",
-          :provider => :rpm,
-          :release => "5.el4",
-          :version => "1.2.3.4",
-        }
-      )
-    end
-
-    it 'should return list of packages for one multiversion and one package input' do
-      package_list = <<-RPM_OUTPUT
-kernel-devel 1 1.2.3.4 5.el4 x86_64
-kernel-devel 1 5.6.7.8 5.el4 x86_64
-basesystem 0 8.0 5.1.1.el5.centos noarch
-RPM_OUTPUT
-      package_hash = described_class.nevra_to_multiversion_hash(package_list)
-      expect(package_hash).to eq(
-        [
-          {
-            :arch => "x86_64",
-            :ensure => "1:1.2.3.4-5.el4; 1:5.6.7.8-5.el4",
-            :epoch => "1",
-            :name => "kernel-devel",
-            :provider => :rpm,
-            :release => "5.el4",
-            :version => "1.2.3.4",
-          },
-          {
-            :provider => :rpm,
-            :name => "basesystem",
-            :epoch => "0",
-            :version => "8.0",
-            :release => "5.1.1.el5.centos",
-            :arch => "noarch",
-            :ensure => "8.0-5.1.1.el5.centos",
-          }
-        ]
-      )
-    end
-  end
 end