puppet 5.5.14 → 5.5.16

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

@@ -221,19 +221,30 @@ describe Puppet::Type.type(:package).provider(:dpkg) do
       allow(Tempfile).to receive(:new).and_return(tempfile)
     end
 
-    it "installs first if holding" do
+    it "installs first if package is not present and ensure holding" do
+
       allow(provider).to receive(:execute)
+      allow(provider).to receive(:package_not_installed?).and_return(true)
       expect(provider).to receive(:install).once
       provider.hold
     end
 
+    it "skips install new package if package is allready installed" do
+      allow(provider).to receive(:execute)
+      allow(provider).to receive(:package_not_installed?).and_return(false)
+      expect(provider).not_to receive(:install)
+      provider.hold
+    end
+
     it "executes dpkg --set-selections when holding" do
+      allow(provider).to receive(:package_not_installed?).and_return(false)
       allow(provider).to receive(:install)
       expect(provider).to receive(:execute).with([:dpkg, '--set-selections'], {:failonfail => false, :combine => false, :stdinfile => tempfile.path}).once
       provider.hold
     end
 
     it "executes dpkg --set-selections when unholding" do
+      allow(provider).to receive(:package_not_installed?).and_return(false)
       allow(provider).to receive(:install)
       expect(provider).to receive(:execute).with([:dpkg, '--set-selections'], {:failonfail => false, :combine => false, :stdinfile => tempfile.path}).once
       provider.hold
@@ -275,4 +286,10 @@ describe Puppet::Type.type(:package).provider(:dpkg) do
     expect(provider).to receive(:dpkg).with("--purge", resource_name)
     provider.purge
   end
+
+  it "raises error if package name is nil" do
+    expect {provider.package_not_installed?(nil)}.to raise_error(ArgumentError,"Package name is nil or empty")
+    expect {provider.package_not_installed?("")}.to raise_error(ArgumentError,"Package name is nil or empty")
+  end
 end
+

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

@@ -2,7 +2,15 @@ require 'spec_helper'
 
 context Puppet::Type.type(:package).provider(:gem) 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 }
+
   let(:provider_gem_cmd) { '/provider/gem' }
+  let(:execute_options) { {:failonfail => true, :combine => true, :custom_environment => {"HOME"=>ENV["HOME"]}} }
 
   context 'installing myresource' do
     let(:resource) do
@@ -18,8 +26,6 @@ context Puppet::Type.type(:package).provider(:gem) do
       provider
     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)
@@ -31,45 +37,45 @@ context Puppet::Type.type(:package).provider(: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 specify that the gem is being installed" do
-        expect(described_class).to receive(:execute_gem_command).with(be_a(Array)) { |args| expect(args[0]).to eq("install") }.and_return("")
+        expect(described_class).to receive(:execute_gem_command).with(provider_gem_cmd, be_a(Array)) { |cmd, args| expect(args[0]).to eq("install") }.and_return("")
         provider.install
       end
 
       it "should specify that --rdoc should not be included when gem version is < 2.0.0" do
-        expect(described_class).to receive(:execute_gem_command).with(be_a(Array)) { |args| expect(args[1]).to eq("--no-rdoc") }.and_return("")
+        expect(described_class).to receive(:execute_gem_command).with(provider_gem_cmd, be_a(Array)) { |cmd, args| expect(args[1]).to eq("--no-rdoc") }.and_return("")
         provider.install
       end
 
       it "should specify that --ri should not be included when gem version is < 2.0.0" do
-        expect(described_class).to receive(:execute_gem_command).with(be_a(Array)) { |args| expect(args[2]).to eq("--no-ri") }.and_return("")
+        expect(described_class).to receive(:execute_gem_command).with(provider_gem_cmd, be_a(Array)) { |cmd, args| expect(args[2]).to eq("--no-ri") }.and_return("")
         provider.install
       end
 
       it "should specify that --document should not be included when gem version is >= 2.0.0" do
         allow(provider).to receive(:rubygem_version).and_return('2.0.0')
-        expect(described_class).to receive(:execute_gem_command).with(be_a(Array)) { |args| expect(args[1]).to eq("--no-document") }.and_return("")
+        expect(described_class).to receive(:execute_gem_command).with(provider_gem_cmd, be_a(Array)) { |cmd, args| expect(args[1]).to eq("--no-document") }.and_return("")
         provider.install
       end
 
       it "should specify the package name" do
-        expect(described_class).to receive(:execute_gem_command).with(be_a(Array)) { |args| expect(args[3]).to eq("myresource") }.and_return("")
+        expect(described_class).to receive(:execute_gem_command).with(provider_gem_cmd, be_a(Array)) { |cmd, args| expect(args[3]).to eq("myresource") }.and_return("")
         provider.install
       end
 
       it "should not append install_options by default" do
-        expect(described_class).to receive(:execute_gem_command).with(be_a(Array)) { |args| expect(args.length).to eq(4) }.and_return("")
+        expect(described_class).to receive(:execute_gem_command).with(provider_gem_cmd, be_a(Array)) { |cmd, args| expect(args.length).to eq(4) }.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(be_a(Array)) do |args|
+        expect(described_class).to receive(:execute_gem_command).with(provider_gem_cmd, be_a(Array)) do |cmd, args|
           expect(args[1]).to eq('--force')
           expect(args[2]).to eq('--bindir=/usr/bin')
         end.and_return("")
@@ -80,7 +86,7 @@ context Puppet::Type.type(:package).provider(:gem) do
         context "as a normal file" do
           it "should use the file name instead of the gem name" do
             resource[:source] = "/my/file"
-            expect(described_class).to receive(:execute_gem_command).with(be_a(Array)) { |args| expect(args[3]).to eq("/my/file") }.and_return("")
+            expect(described_class).to receive(:execute_gem_command).with(provider_gem_cmd, array_including("/my/file")).and_return("")
             provider.install
           end
         end
@@ -88,7 +94,7 @@ context Puppet::Type.type(:package).provider(:gem) do
         context "as a file url" do
           it "should use the file name instead of the gem name" do
             resource[:source] = "file:///my/file"
-            expect(described_class).to receive(:execute_gem_command).with(be_a(Array)) { |args| expect(args[3]).to eq("/my/file") }.and_return("")
+            expect(described_class).to receive(:execute_gem_command).with(provider_gem_cmd, array_including("/my/file")).and_return("")
             provider.install
           end
         end
@@ -103,7 +109,7 @@ context Puppet::Type.type(:package).provider(:gem) do
         context "as a non-file and non-puppet url" do
           it "should treat the source as a gem repository" do
             resource[:source] = "http://host/my/file"
-            expect(described_class).to receive(:execute_gem_command).with(be_a(Array)) { |args| expect(args[3..5]).to eq(["--source", "http://host/my/file", "myresource"]) }.and_return("")
+            expect(described_class).to receive(:execute_gem_command).with(provider_gem_cmd, be_a(Array)) { |cmd, args| expect(args[3..5]).to eq(["--source", "http://host/my/file", "myresource"]) }.and_return("")
             provider.install
           end
         end
@@ -111,7 +117,7 @@ context Puppet::Type.type(:package).provider(:gem) do
         context "as a windows path on windows", :if => Puppet.features.microsoft_windows? do
           it "should treat the source as a local path" do
             resource[:source] = "c:/this/is/a/path/to/a/gem.gem"
-            expect(described_class).to receive(:execute_gem_command).with(be_a(Array)) { |args| expect(args[3]).to eq("c:/this/is/a/path/to/a/gem.gem") }.and_return("")
+            expect(described_class).to receive(:execute_gem_command).with(provider_gem_cmd, array_including("c:/this/is/a/path/to/a/gem.gem")).and_return("")
             provider.install
           end
         end
@@ -131,7 +137,7 @@ context Puppet::Type.type(:package).provider(:gem) do
         #gemlist is used for retrieving both local and remote version numbers, and there are cases
         # (particularly local) where it makes sense for it to return an array.  That doesn't make
         # sense for '#latest', though.
-        expect(provider.class).to receive(:gemlist).with({:justme => 'myresource'}).and_return({
+        expect(provider.class).to receive(:gemlist).with({:command => provider_gem_cmd, :justme => 'myresource'}).and_return({
           :name     => 'myresource',
           :ensure   => ["3.0"],
           :provider => :gem,
@@ -142,7 +148,7 @@ context Puppet::Type.type(:package).provider(:gem) do
       it "should list from the specified source repository" do
         resource[:source] = "http://foo.bar.baz/gems"
         expect(provider.class).to receive(:gemlist).
-          with({:justme => 'myresource', :source => "http://foo.bar.baz/gems"}).
+          with({:command => provider_gem_cmd, :justme => 'myresource', :source => "http://foo.bar.baz/gems"}).
           and_return({
             :name     => 'myresource',
             :ensure   => ["3.0"],
@@ -158,67 +164,67 @@ context Puppet::Type.type(:package).provider(:gem) do
       end
 
       it "should return an empty array when no gems installed" do
-        expect(described_class).to receive(:execute_gem_command).with(%w{list --local}).and_return("\n")
+        expect(described_class).to receive(:execute_gem_command).with(provider_gem_cmd, %w{list --local}).and_return("\n")
         expect(described_class.instances).to eq([])
       end
 
       it "should return ensure values as an array of installed versions" do
-        expect(described_class).to receive(:execute_gem_command).with(%w{list --local}).and_return(<<-HEREDOC.gsub(/        /, ''))
+        expect(described_class).to receive(:execute_gem_command).with(provider_gem_cmd, %w{list --local}).and_return(<<-HEREDOC.gsub(/        /, ''))
         systemu (1.2.0)
         vagrant (0.8.7, 0.6.9)
         HEREDOC
 
         expect(described_class.instances.map {|p| p.properties}).to eq([
-          {:ensure => ["1.2.0"],          :provider => :gem, :name => 'systemu'},
-          {:ensure => ["0.8.7", "0.6.9"], :provider => :gem, :name => 'vagrant'}
+          {:name => "systemu", :provider => :gem, :command => provider_gem_cmd, :ensure => ["1.2.0"]},
+          {:name => "vagrant", :provider => :gem, :command => provider_gem_cmd, :ensure => ["0.8.7", "0.6.9"]}
         ])
       end
 
       it "should ignore platform specifications" do
-        expect(described_class).to receive(:execute_gem_command).with(%w{list --local}).and_return(<<-HEREDOC.gsub(/        /, ''))
+        expect(described_class).to receive(:execute_gem_command).with(provider_gem_cmd, %w{list --local}).and_return(<<-HEREDOC.gsub(/        /, ''))
         systemu (1.2.0)
         nokogiri (1.6.1 ruby java x86-mingw32 x86-mswin32-60, 1.4.4.1 x86-mswin32)
         HEREDOC
 
         expect(described_class.instances.map {|p| p.properties}).to eq([
-          {:ensure => ["1.2.0"],          :provider => :gem, :name => 'systemu'},
-          {:ensure => ["1.6.1", "1.4.4.1"], :provider => :gem, :name => 'nokogiri'}
+          {:name => "systemu",  :provider => :gem, :command => provider_gem_cmd, :ensure => ["1.2.0"]},
+          {:name => "nokogiri", :provider => :gem, :command => provider_gem_cmd, :ensure => ["1.6.1", "1.4.4.1"]}
         ])
       end
 
       it "should not list 'default: ' text from rubygems''" do
-        expect(described_class).to receive(:execute_gem_command).with(%w{list --local}).and_return(<<-HEREDOC.gsub(/        /, ''))
+        expect(described_class).to receive(:execute_gem_command).with(provider_gem_cmd, %w{list --local}).and_return(<<-HEREDOC.gsub(/        /, ''))
         bundler (1.16.1, default: 1.16.0, 1.15.1)
         HEREDOC
 
         expect(described_class.instances.map {|p| p.properties}).to eq([
-          {:name => 'bundler', :ensure => ["1.16.1", "1.16.0", "1.15.1"], :provider => :gem}
+          {:name => "bundler", :provider => :gem, :command => provider_gem_cmd, :ensure => ["1.16.1", "1.16.0", "1.15.1"]}
         ])
       end
 
       it "should not fail when an unmatched line is returned" do
-        expect(described_class).to receive(:execute_gem_command).with(%w{list --local}).and_return(File.read(my_fixture('line-with-1.8.5-warning')))
+        expect(described_class).to receive(:execute_gem_command).with(provider_gem_cmd, %w{list --local}).and_return(File.read(my_fixture('line-with-1.8.5-warning')))
 
         expect(described_class.instances.map {|p| p.properties}).
-          to eq([{provider: :gem, ensure: ["0.3.2"],    name: "columnize"},
-                 {provider: :gem, ensure: ["1.1.3"],    name: "diff-lcs"},
-                 {provider: :gem, ensure: ["0.0.1"],    name: "metaclass"},
-                 {provider: :gem, ensure: ["0.10.5"],   name: "mocha"},
-                 {provider: :gem, ensure: ["0.8.7"],    name: "rake"},
-                 {provider: :gem, ensure: ["2.9.0"],    name: "rspec-core"},
-                 {provider: :gem, ensure: ["2.9.1"],    name: "rspec-expectations"},
-                 {provider: :gem, ensure: ["2.9.0"],    name: "rspec-mocks"},
-                 {provider: :gem, ensure: ["0.9.0"],    name: "rubygems-bundler"},
-                 {provider: :gem, ensure: ["1.11.3.3"], name: "rvm"}])
+          to eq([{:name=>"columnize",          :provider=>:gem, :command => provider_gem_cmd, :ensure=>["0.3.2"]},
+                 {:name=>"diff-lcs",           :provider=>:gem, :command => provider_gem_cmd, :ensure=>["1.1.3"]},
+                 {:name=>"metaclass",          :provider=>:gem, :command => provider_gem_cmd, :ensure=>["0.0.1"]},
+                 {:name=>"mocha",              :provider=>:gem, :command => provider_gem_cmd, :ensure=>["0.10.5"]},
+                 {:name=>"rake",               :provider=>:gem, :command => provider_gem_cmd, :ensure=>["0.8.7"]},
+                 {:name=>"rspec-core",         :provider=>:gem, :command => provider_gem_cmd, :ensure=>["2.9.0"]},
+                 {:name=>"rspec-expectations", :provider=>:gem, :command => provider_gem_cmd, :ensure=>["2.9.1"]},
+                 {:name=>"rspec-mocks",        :provider=>:gem, :command => provider_gem_cmd, :ensure=>["2.9.0"]},
+                 {:name=>"rubygems-bundler",   :provider=>:gem, :command => provider_gem_cmd, :ensure=>["0.9.0"]},
+                 {:name=>"rvm",                :provider=>:gem, :command => provider_gem_cmd, :ensure=>["1.11.3.3"]}])
       end
     end
 
     context "listing gems" do
       context "searching for a single package" do
         it "searches for an exact match" do
-          expect(described_class).to receive(:execute_gem_command).with(include('\Abundler\z')).and_return(File.read(my_fixture('gem-list-single-package')))
-          expected = {:name => 'bundler', :ensure => %w[1.6.2], :provider => :gem}
-          expect(described_class.gemlist({:justme => 'bundler'})).to eq(expected)
+          expect(described_class).to receive(:execute_gem_command).with(provider_gem_cmd, array_including('\Abundler\z')).and_return(File.read(my_fixture('gem-list-single-package')))
+          expected = {:name=>"bundler", :provider=>:gem, :ensure=>["1.6.2"]}
+          expect(described_class.gemlist({:command => provider_gem_cmd, :justme => 'bundler'})).to eq(expected)
         end
       end
     end
@@ -294,6 +300,39 @@ context Puppet::Type.type(:package).provider(:gem) do
     end
   end
 
+  context 'installing myresource with a target command' do
+    let(:resource_gem_cmd) { '/resource/gem' }
+
+    let(:resource) do
+      Puppet::Type.type(:package).new(
+        :name     => "myresource",
+        :ensure   => :installed,
+      )
+    end
+
+    let(:provider) do
+      provider = described_class.new
+      provider.resource = resource
+      provider
+    end
+
+    before :each do
+      resource.provider = provider
+    end
+
+    context "when installing with a target command" do
+      before :each do
+        allow(described_class).to receive(:which).with(resource_gem_cmd).and_return(resource_gem_cmd)
+      end
+
+      it "should use the path to the other gem" do
+        resource::original_parameters[:command] = resource_gem_cmd
+        expect(described_class).to receive(:execute_gem_command).with(resource_gem_cmd, be_a(Array)).twice.and_return("")
+        provider.install
+      end
+    end
+  end
+
   context 'uninstalling myresource' do
     let(:resource) do
       Puppet::Type.type(:package).new(
@@ -308,8 +347,6 @@ context Puppet::Type.type(:package).provider(:gem) do
       provider
     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)
@@ -317,39 +354,39 @@ context Puppet::Type.type(:package).provider(:gem) do
 
     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 specify that the gem is being uninstalled" do
-        expect(described_class).to receive(:execute_gem_command).with(be_a(Array)) { |args| expect(args[0]).to eq("uninstall") }.and_return("")
+        expect(described_class).to receive(:execute_gem_command).with(provider_gem_cmd, be_a(Array)) { |cmd, args| expect(args[0]).to eq("uninstall") }.and_return("")
         provider.uninstall
       end
 
       it "should specify that the relevant executables should be removed without confirmation" do
-        expect(described_class).to receive(:execute_gem_command).with(be_a(Array)) { |args| expect(args[1]).to eq("--executables") }.and_return("")
+        expect(described_class).to receive(:execute_gem_command).with(provider_gem_cmd, be_a(Array)) { |cmd, args| expect(args[1]).to eq("--executables") }.and_return("")
         provider.uninstall
       end
 
       it "should specify that all the matching versions should be removed" do
-        expect(described_class).to receive(:execute_gem_command).with(be_a(Array)) { |args| expect(args[2]).to eq("--all") }.and_return("")
+        expect(described_class).to receive(:execute_gem_command).with(provider_gem_cmd, be_a(Array)) { |cmd, args| expect(args[2]).to eq("--all") }.and_return("")
         provider.uninstall
       end
 
       it "should specify the package name" do
-        expect(described_class).to receive(:execute_gem_command).with(be_a(Array)) { |args| expect(args[3]).to eq("myresource") }.and_return("")
+        expect(described_class).to receive(:execute_gem_command).with(provider_gem_cmd, be_a(Array)) { |cmd, args| expect(args[3]).to eq("myresource") }.and_return("")
         provider.uninstall
       end
 
       it "should not append uninstall_options by default" do
-        expect(described_class).to receive(:execute_gem_command).with(be_a(Array)) { |args| expect(args.length).to eq(4) }.and_return("")
+        expect(described_class).to receive(:execute_gem_command).with(provider_gem_cmd, be_a(Array)) { |cmd, args| expect(args.length).to eq(4) }.and_return("")
         provider.uninstall
       end
 
       it "should allow setting an uninstall_options parameter" do
         resource[:uninstall_options] = [ '--ignore-dependencies', {'--version' => '0.1.1' } ]
-        expect(described_class).to receive(:execute_gem_command).with(be_a(Array)) do |args|
+        expect(described_class).to receive(:execute_gem_command).with(provider_gem_cmd, be_a(Array)) do |cmd, args|
           expect(args[4]).to eq('--ignore-dependencies')
           expect(args[5]).to eq('--version=0.1.1')
         end.and_return('')
@@ -357,4 +394,20 @@ context Puppet::Type.type(:package).provider(:gem) do
       end
     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/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
-  before 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"])
@@ -46,17 +55,17 @@ describe Puppet::Type.type(:package).provider(:pip) do
     osfamilies.each do |osfamily, pip_cmds|
       it "should return an array on #{osfamily} systems when #{pip_cmds.join(' or ')} is present" do
         allow(Puppet.features).to receive(:microsoft_windows?).and_return(osfamily == 'windows')
-        pip_cmds.each do |pip_cmd|  
+        pip_cmds.each do |pip_cmd|
           pip_cmds.each do |cmd|
             unless cmd == pip_cmd
               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.features).to receive(:microsoft_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,67 +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)
-    end
-
-    it "should succeed if pip is present" do
-      allow(@provider).to receive(:pip).and_return(nil)
-      @provider.method(:lazy_pip).call "freeze"
+  context 'calculated specificity' do
+    context 'when is not defaultfor' do
+      subject { described_class.specificity }
+      it { is_expected.to eql 1 }
     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.features).to receive(:microsoft_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
-          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.features).to receive(:microsoft_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.features).to receive(:microsoft_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