puppet 6.0.9-x86-mingw32 → 6.0.10-x86-mingw32

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

@@ -7,6 +7,7 @@ describe Puppet::Type.type(:package).provider(:pip3) do
   it { is_expected.to be_upgradeable }
   it { is_expected.to be_versionable }
   it { is_expected.to be_install_options }
+  it { is_expected.to be_targetable }
 
   it "should inherit most things from pip provider" do
     expect(described_class < Puppet::Type.type(:package).provider(:pip))
@@ -16,4 +17,20 @@ describe Puppet::Type.type(:package).provider(:pip3) do
     expect(described_class.cmd).to eq(["pip3"])
   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/pip_spec.rb

@@ -3,8 +3,17 @@ require 'spec_helper'
 osfamilies = { 'windows' => ['pip.exe'], 'other' => ['pip', 'pip-python'] }
 
 describe Puppet::Type.type(:package).provider(:pip) do
+
+  it { is_expected.to be_installable }
+  it { is_expected.to be_uninstallable }
+  it { is_expected.to be_upgradeable }
+  it { is_expected.to be_versionable }
+  it { is_expected.to be_install_options }
+  it { is_expected.to be_targetable }
+
   before do
     @resource = Puppet::Resource.new(:package, "fake_package")
+    allow(@resource).to receive(:original_parameters).and_return({})
     @provider = described_class.new(@resource)
     @client = double('client')
     allow(@client).to receive(:call).with('package_releases', 'real_package').and_return(["1.3", "1.2.5", "1.2.4"])
@@ -52,11 +61,11 @@ describe Puppet::Type.type(:package).provider(:pip) do
               expect(described_class).to receive(:which).with(cmd).and_return(nil)
             end
           end
-          allow(described_class).to receive(:pip_version).and_return('8.0.1')
-          expect(described_class).to receive(:which).with(pip_cmd).and_return("/fake/bin/#{pip_cmd}")
+          allow(described_class).to receive(:pip_version).with(pip_cmd).and_return('8.0.1')
+          expect(described_class).to receive(:which).with(pip_cmd).and_return(pip_cmd)
           p = double("process")
           expect(p).to receive(:collect).and_yield("real_package==1.2.5")
-          expect(described_class).to receive(:execpipe).with(["/fake/bin/#{pip_cmd}", "freeze"]).and_yield(p)
+          expect(described_class).to receive(:execpipe).with([pip_cmd, ["freeze"]]).and_yield(p)
           described_class.instances
         end
       end
@@ -66,11 +75,11 @@ describe Puppet::Type.type(:package).provider(:pip) do
         versions.each do |version|
           it "should use the --all option when version is '#{version}'" do
             allow(Puppet::Util::Platform).to receive(:windows?).and_return(osfamily == 'windows')
-            allow(described_class).to receive(:pip_cmd).and_return('/fake/bin/pip')
-            allow(described_class).to receive(:pip_version).and_return(version)
+            allow(described_class).to receive(:provider_command).and_return('/fake/bin/pip')
+            allow(described_class).to receive(:pip_version).with('/fake/bin/pip').and_return(version)
             p = double("process")
             expect(p).to receive(:collect).and_yield("real_package==1.2.5")
-            expect(described_class).to receive(:execpipe).with(["/fake/bin/pip", "freeze", "--all"]).and_yield(p)
+            expect(described_class).to receive(:execpipe).with(["/fake/bin/pip", ["freeze", "--all"]]).and_yield(p)
             described_class.instances
           end
         end
@@ -89,6 +98,8 @@ describe Puppet::Type.type(:package).provider(:pip) do
   context "query" do
     before do
       @resource[:name] = "real_package"
+      allow(described_class).to receive(:provider_command).and_return('/fake/bin/pip')
+      allow(described_class).to receive(:validate_command).with('/fake/bin/pip')
     end
 
     it "should return a hash when pip and the package are present" do
@@ -96,12 +107,14 @@ describe Puppet::Type.type(:package).provider(:pip) do
         :ensure   => "1.2.5",
         :name     => "real_package",
         :provider => :pip,
+        :command  => '/fake/bin/pip',
       })])
 
       expect(@provider.query).to eq({
         :ensure   => "1.2.5",
         :name     => "real_package",
         :provider => :pip,
+        :command  => '/fake/bin/pip',
       })
     end
 
@@ -117,12 +130,14 @@ describe Puppet::Type.type(:package).provider(:pip) do
         :ensure   => "1.2.5",
         :name     => "real_package",
         :provider => :pip,
+        :command  => '/fake/bin/pip',
       })])
 
       expect(@provider.query).to eq({
         :ensure   => "1.2.5",
         :name     => "real_package",
         :provider => :pip,
+        :command  => '/fake/bin/pip',
       })
     end
   end
@@ -130,10 +145,12 @@ describe Puppet::Type.type(:package).provider(:pip) do
   context "latest" do
     context "with pip version < 1.5.4" do
       before :each do
-        allow(described_class).to receive(:pip_version).and_return('1.0.1')
+        allow(described_class).to receive(:pip_version).with("/fake/bin/pip").and_return('1.0.1')
         allow(described_class).to receive(:which).with('pip').and_return("/fake/bin/pip")
         allow(described_class).to receive(:which).with('pip-python').and_return("/fake/bin/pip")
         allow(described_class).to receive(:which).with('pip.exe').and_return("/fake/bin/pip")
+        allow(described_class).to receive(:provider_command).and_return('/fake/bin/pip')
+        allow(described_class).to receive(:validate_command).with('/fake/bin/pip')
       end
 
       it "should find a version number for new_pip_package" do
@@ -186,10 +203,12 @@ describe Puppet::Type.type(:package).provider(:pip) do
       # For Pip 1.5.4 and above, you can get a version list from CLI - which allows for native pip behavior
       # with regards to custom repositories, proxies and the like
       before :each do
-        allow(described_class).to receive(:pip_version).and_return('1.5.4')
+        allow(described_class).to receive(:pip_version).with("/fake/bin/pip").and_return('1.5.4')
         allow(described_class).to receive(:which).with('pip').and_return("/fake/bin/pip")
         allow(described_class).to receive(:which).with('pip-python').and_return("/fake/bin/pip")
         allow(described_class).to receive(:which).with('pip.exe').and_return("/fake/bin/pip")
+        allow(described_class).to receive(:provider_command).and_return('/fake/bin/pip')
+        allow(described_class).to receive(:validate_command).with('/fake/bin/pip')
       end
 
       it "should find a version number for real_package" do
@@ -239,12 +258,14 @@ describe Puppet::Type.type(:package).provider(:pip) do
     before do
       @resource[:name] = "fake_package"
       @url = "git+https://example.com/fake_package.git"
+      allow(described_class).to receive(:provider_command).and_return('/fake/bin/pip')
+      allow(described_class).to receive(:validate_command).with('/fake/bin/pip')
     end
 
     it "should install" do
       @resource[:ensure] = :installed
       @resource[:source] = nil
-      expect(@provider).to receive(:lazy_pip).with("install", '-q', "fake_package")
+      expect(@provider).to receive(:execute).with(["/fake/bin/pip", ["install", "-q", "fake_package"]])
       @provider.install
     end
 
@@ -252,7 +273,8 @@ describe Puppet::Type.type(:package).provider(:pip) do
       # The -e flag makes the provider non-idempotent
       @resource[:ensure] = :installed
       @resource[:source] = @url
-      expect(@provider).to receive(:lazy_pip) do |*args|
+      # TJK
+      expect(@provider).to receive(:execute) do |*args|
         expect(args).not_to include("-e")
       end
       @provider.install
@@ -261,28 +283,31 @@ describe Puppet::Type.type(:package).provider(:pip) do
     it "should install from SCM" do
       @resource[:ensure] = :installed
       @resource[:source] = @url
-      expect(@provider).to receive(:lazy_pip).with("install", '-q', "#{@url}#egg=fake_package")
+      expect(@provider).to receive(:execute).with(["/fake/bin/pip", ["install", "-q", "#{@url}#egg=fake_package"]])
       @provider.install
     end
 
     it "should install a particular SCM revision" do
       @resource[:ensure] = "0123456"
       @resource[:source] = @url
-      expect(@provider).to receive(:lazy_pip).with("install", "-q", "#{@url}@0123456#egg=fake_package")
+      # TJK
+      expect(@provider).to receive(:execute).with(["/fake/bin/pip", ["install", "-q", "#{@url}@0123456#egg=fake_package"]])
       @provider.install
     end
 
     it "should install a particular version" do
       @resource[:ensure] = "0.0.0"
       @resource[:source] = nil
-      expect(@provider).to receive(:lazy_pip).with("install", "-q", "fake_package==0.0.0")
+      # TJK
+      expect(@provider).to receive(:execute).with(["/fake/bin/pip", ["install", "-q", "fake_package==0.0.0"]])
       @provider.install
     end
 
     it "should upgrade" do
       @resource[:ensure] = :latest
       @resource[:source] = nil
-      expect(@provider).to receive(:lazy_pip).with("install", "-q", "--upgrade", "fake_package")
+      # TJK
+      expect(@provider).to receive(:execute).with(["/fake/bin/pip", ["install", "-q", "--upgrade", "fake_package"]])
       @provider.install
     end
 
@@ -290,15 +315,20 @@ describe Puppet::Type.type(:package).provider(:pip) do
       @resource[:ensure] = :installed
       @resource[:source] = nil
       @resource[:install_options] = [{"--timeout" => "10"}, "--no-index"]
-      expect(@provider).to receive(:lazy_pip).with("install", "-q", "--timeout=10", "--no-index", "fake_package")
+      expect(@provider).to receive(:execute).with(["/fake/bin/pip", ["install", "-q", "--timeout=10", "--no-index", "fake_package"]])
       @provider.install
     end
   end
 
   context "uninstall" do
+    before do
+      allow(described_class).to receive(:provider_command).and_return('/fake/bin/pip')
+      allow(described_class).to receive(:validate_command).with('/fake/bin/pip')
+    end
+
     it "should uninstall" do
       @resource[:name] = "fake_package"
-      expect(@provider).to receive(:lazy_pip).with('uninstall', '-y', '-q', 'fake_package')
+      expect(@provider).to receive(:execute).with(["/fake/bin/pip", ["uninstall", "-y", "-q", "fake_package"]])
       @provider.uninstall
     end
   end
@@ -311,68 +341,28 @@ describe Puppet::Type.type(:package).provider(:pip) do
   end
 
   context "pip_version" do
-    it "should return nil on missing pip" do
-      allow(described_class).to receive(:pip_cmd).and_return(nil)
-      expect(described_class.pip_version).to eq(nil)
-    end
-
     it "should look up version if pip is present" do
       allow(described_class).to receive(:pip_cmd).and_return('/fake/bin/pip')
       p = double("process")
       expect(p).to receive(:collect).and_yield('pip 8.0.2 from /usr/local/lib/python2.7/dist-packages (python 2.7)')
       expect(described_class).to receive(:execpipe).with(['/fake/bin/pip', '--version']).and_yield(p)
-      expect(described_class.pip_version).to eq('8.0.2')
+      expect(described_class.pip_version('/fake/bin/pip')).to eq('8.0.2')
     end
   end
 
-  context "lazy_pip" do
-    after(:each) do
-      Puppet::Type::Package::ProviderPip.instance_variable_set(:@confine_collection, nil)
+  context 'calculated specificity' do
+    context 'when is not defaultfor' do
+      subject { described_class.specificity }
+      it { is_expected.to eql 1 }
     end
 
-    it "should succeed if pip is present" do
-      allow(@provider).to receive(:pip).and_return(nil)
-      @provider.method(:lazy_pip).call "freeze"
-    end
-
-    osfamilies.each do |osfamily, pip_cmds|
-      pip_cmds.each do |pip_cmd|
-        it "should retry on #{osfamily} systems if #{pip_cmd} has not yet been found" do
-          allow(Puppet::Util::Platform).to receive(:windows?).and_return(osfamily == 'windows')
-          times_called = 0
-          expect(@provider).to receive(:pip).twice.with('freeze') do
-            times_called += 1
-            raise NoMethodError if times_called == 1
-            nil
-          end
-          pip_cmds.each do |cmd|
-            unless cmd == pip_cmd
-              expect(@provider).to receive(:which).with(cmd).and_return(nil)
-            end
-          end
-          expect(@provider).to receive(:which).with(pip_cmd).and_return("/fake/bin/#{pip_cmd}")
-          @provider.method(:lazy_pip).call "freeze"
-        end
-      end
-
-      it "should fail on #{osfamily} systems if #{pip_cmds.join(' and ')} are missing" do
-        allow(Puppet::Util::Platform).to receive(:windows?).and_return(osfamily == 'windows')
-        expect(@provider).to receive(:pip).with('freeze').and_raise(NoMethodError)
-        pip_cmds.each do |pip_cmd|
-          expect(@provider).to receive(:which).with(pip_cmd).and_return(nil)
-        end
-        expect { @provider.method(:lazy_pip).call("freeze") }.to raise_error(NoMethodError)
-      end
-
-      it "should output a useful error message on #{osfamily} systems if #{pip_cmds.join(' and ')} are missing" do
-        allow(Puppet::Util::Platform).to receive(:windows?).and_return(osfamily == 'windows')
-        expect(@provider).to receive(:pip).with('freeze').and_raise(NoMethodError)
-        pip_cmds.each do |pip_cmd|
-          expect(@provider).to receive(:which).with(pip_cmd).and_return(nil)
-        end
-        expect { @provider.method(:lazy_pip).call("freeze") }.
-          to raise_error(NoMethodError, "Could not locate command #{pip_cmds.join(' and ')}.")
+    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/puppet_gem_spec.rb

@@ -33,40 +33,56 @@ describe Puppet::Type.type(:package).provider(:puppet_gem) do
     end
 
     it "should use the path to the gem command" do
-      allow(described_class).to receive(:which).with(provider_gem_cmd).and_return(provider_gem_cmd)
+      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.install
     end
 
     it "should not append install_options by default" do
-      expect(described_class).to receive(:execute_gem_command).with(%w{install --no-rdoc --no-ri myresource}).and_return('')
+      expect(described_class).to receive(:execute_gem_command).with(provider_gem_cmd, %w{install --no-rdoc --no-ri myresource}).and_return('')
       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(%w{install --force --bindir=/usr/bin --no-rdoc --no-ri myresource}).and_return('')
+      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.install
     end
   end
 
   context "when uninstalling" do
     it "should use the path to the gem command" do
-      allow(described_class).to receive(:which).with(provider_gem_cmd).and_return(provider_gem_cmd)
+      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
     end
 
     it "should not append uninstall_options by default" do
-      expect(described_class).to receive(:execute_gem_command).with(%w{uninstall --executables --all myresource}).and_return('')
+      expect(described_class).to receive(:execute_gem_command).with(provider_gem_cmd, %w{uninstall --executables --all myresource}).and_return('')
       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(%w{uninstall --executables --all myresource --force --bindir=/usr/bin}).and_return('')
+      expect(described_class).to receive(:execute_gem_command).with(provider_gem_cmd, %w{uninstall --executables --all myresource --force --bindir=/usr/bin}).and_return('')
       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

@@ -56,7 +56,9 @@ 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)
+        expect(Puppet::Util::Execution).to receive(:execpipe)
+          .with("/bin/rpm -qa --nosignature --nodigest --qf '#{nevra_format}'")
+          .and_yield(packages)
 
         described_class.instances
       end
@@ -66,7 +68,9 @@ describe Puppet::Type.type(:package).provider(:rpm) 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)
+        expect(Puppet::Util::Execution).to receive(:execpipe)
+          .with("/bin/rpm -qa  --nodigest --qf '#{nevra_format}'")
+          .and_yield(packages)
 
         described_class.instances
       end
@@ -76,14 +80,18 @@ describe Puppet::Type.type(:package).provider(:rpm) 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)
+        expect(Puppet::Util::Execution).to receive(:execpipe)
+        .with("/bin/rpm -qa   --qf '#{nevra_format}'")
+        .and_yield(packages)
 
         described_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)
+      expect(Puppet::Util::Execution).to receive(:execpipe)
+        .with("/bin/rpm -qa --nosignature --nodigest --qf '#{nevra_format}'")
+        .and_yield(packages)
 
       installed_packages = described_class.instances
 
@@ -167,7 +175,8 @@ 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)
+        expect(Puppet::Util::Execution).to receive(:execute)
+          .with(["/bin/rpm", ["-i"], '/path/to/package'], execute_options)
         provider.install
       end
     end
@@ -184,7 +193,8 @@ 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)
+        expect(Puppet::Util::Execution).to receive(:execute)
+          .with(["/bin/rpm", ["-i", "-D", "--test=value", "-Q"], '/path/to/package'], execute_options)
         provider.install
       end
     end
@@ -197,7 +207,8 @@ 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)
+         expect(Puppet::Util::Execution).to receive(:execute)
+           .with(["/bin/rpm", ["-U", "--oldpackage"], '/path/to/package'], execute_options)
          provider.install
       end
     end
@@ -214,7 +225,9 @@ describe Puppet::Type.type(:package).provider(:rpm) do
 
     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')
+      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
@@ -225,52 +238,115 @@ describe Puppet::Type.type(:package).provider(:rpm) do
   describe "#uninstall" do
     let(:resource) do
       Puppet::Type.type(:package).new(
-        :name     => 'myresource',
-        :ensure   => :installed
+        :name   => resource_name,
+        :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", "myresource", '--nosignature', '--nodigest', "--qf", "'#{nevra_format}'"], execute_options)
-          .and_return(Puppet::Util::Execution::ProcessOutput.new("myresource 0 1.2.3.4 5.el4 noarch\n", 0))
+          .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
+      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"], 'myresource-1.2.3.4-5.el4.noarch'], execute_options)
+          .with(["/bin/rpm", ["-e"], "#{resource_name}.noarch"], execute_options)
           .and_return(Puppet::Util::Execution::ProcessOutput.new('', 0)).at_most(:once)
         provider.uninstall
       end
     end
 
-    describe "on an ancient RPM" do
+    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
+
       before(:each) do
         expect(Puppet::Util::Execution).to receive(:execute)
-          .with(["/bin/rpm", "-q", "myresource", '', '', '--qf', "'#{nevra_format}'"], execute_options)
-          .and_return(Puppet::Util::Execution::ProcessOutput.new("myresource 0 1.2.3.4 5.el4 noarch\n", 0))
+          .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))
       end
 
-      let(:rpm_version) { "RPM version 3.0.6\n" }
-
-      it "excludes the architecture from the package name" do
+      it "includes the version and release in the package name" do
         expect(Puppet::Util::Execution).to receive(:execute)
-          .with(["/bin/rpm", ["-e"], 'myresource-1.2.3.4-5.el4'], execute_options)
+          .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)
         provider.uninstall
       end
     end
 
-    describe "when uninstalled with options" do
+    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
+
       before(:each) do
         expect(Puppet::Util::Execution).to receive(:execute)
-          .with(["/bin/rpm", "-q", "myresource", '--nosignature', '--nodigest', "--qf", "'#{nevra_format}'"], execute_options)
-          .and_return(Puppet::Util::Execution::ProcessOutput.new("myresource 0 1.2.3.4 5.el4 noarch\n", 0))
+          .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
+      end
+    end
+
+    describe "when uninstalled with options" do
       let(:resource) do
         Puppet::Type.type(:package).new(
           :name              => resource_name,
@@ -280,8 +356,15 @@ 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"], 'myresource-1.2.3.4-5.el4.noarch'], execute_options)
+        expect(Puppet::Util::Execution).to receive(:execute)
+          .with(["/bin/rpm", ["-e", "--nodeps"], resource_name], execute_options)
         provider.uninstall
       end
     end
@@ -331,7 +414,9 @@ describe Puppet::Type.type(:package).provider(:rpm) 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"))
+        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
@@ -342,7 +427,9 @@ 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"))
+        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
@@ -350,7 +437,9 @@ 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)
+        .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)
         .and_return(Puppet::Util::Execution::ProcessOutput.new("myresource 0 1.2.3.4 5.el4 noarch\n", 0))