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

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

@@ -12,7 +12,7 @@ describe Puppet::Type.type(:package).provider(:dpkg) do
     {:failonfail => true, :combine => true, :custom_environment => {}}
   end
   let(:resource_name) { 'package' }
-  let(:resource) { double('resource', :[] => resource_name) }
+  let(:resource) { stub 'resource', :[] => resource_name }
   let(:provider) { described_class.new(resource) }
 
   it "has documentation" do
@@ -23,35 +23,35 @@ describe Puppet::Type.type(:package).provider(:dpkg) do
     let(:execpipe_args) { args.unshift('myquery') }
 
     before do
-      allow(described_class).to receive(:command).with(:dpkgquery).and_return('myquery')
+      described_class.stubs(:command).with(:dpkgquery).returns 'myquery'
     end
 
     it "creates and return an instance for a single dpkg-query entry" do
-      expect(Puppet::Util::Execution).to receive(:execpipe).with(execpipe_args).and_yield(bash_installed_io)
+      Puppet::Util::Execution.expects(:execpipe).with(execpipe_args).yields bash_installed_io
 
-      installed = double('bash')
-      expect(described_class).to receive(:new).with(:ensure => "4.2-5ubuntu3", :error => "ok", :desired => "install", :name => "bash", :status => "installed", :provider => :dpkg).and_return(installed)
+      installed = mock 'bash'
+      described_class.expects(:new).with(:ensure => "4.2-5ubuntu3", :error => "ok", :desired => "install", :name => "bash", :status => "installed", :provider => :dpkg).returns installed
 
       expect(described_class.instances).to eq([installed])
     end
 
     it "parses multiple dpkg-query multi-line entries in the output" do
-      expect(Puppet::Util::Execution).to receive(:execpipe).with(execpipe_args).and_yield(all_installed_io)
+      Puppet::Util::Execution.expects(:execpipe).with(execpipe_args).yields all_installed_io
 
-      bash = double('bash')
-      expect(described_class).to receive(:new).with(:ensure => "4.2-5ubuntu3", :error => "ok", :desired => "install", :name => "bash", :status => "installed", :provider => :dpkg).and_return(bash)
-      vim = double('vim')
-      expect(described_class).to receive(:new).with(:ensure => "2:7.3.547-6ubuntu5", :error => "ok", :desired => "install", :name => "vim", :status => "installed", :provider => :dpkg).and_return(vim)
+      bash = mock 'bash'
+      described_class.expects(:new).with(:ensure => "4.2-5ubuntu3", :error => "ok", :desired => "install", :name => "bash", :status => "installed", :provider => :dpkg).returns bash
+      vim = mock 'vim'
+      described_class.expects(:new).with(:ensure => "2:7.3.547-6ubuntu5", :error => "ok", :desired => "install", :name => "vim", :status => "installed", :provider => :dpkg).returns vim
 
       expect(described_class.instances).to eq([bash, vim])
     end
 
     it "continues without failing if it encounters bad lines between good entries" do
-      expect(Puppet::Util::Execution).to receive(:execpipe).with(execpipe_args).and_yield(StringIO.new([bash_installed_output, "foobar\n", vim_installed_output].join))
+      Puppet::Util::Execution.expects(:execpipe).with(execpipe_args).yields StringIO.new([bash_installed_output, "foobar\n", vim_installed_output].join)
 
-      bash = double('bash')
-      vim = double('vim')
-      expect(described_class).to receive(:new).twice.and_return(bash, vim)
+      bash = mock 'bash'
+      vim = mock 'vim'
+      described_class.expects(:new).twice.returns(bash, vim)
 
       expect(described_class.instances).to eq([bash, vim])
     end
@@ -65,15 +65,15 @@ describe Puppet::Type.type(:package).provider(:dpkg) do
     end
 
     def dpkg_query_execution_returns(output)
-      expect(Puppet::Util::Execution).to receive(:execute).with(query_args, execute_options).and_return(Puppet::Util::Execution::ProcessOutput.new(output, 0))
+      Puppet::Util::Execution.expects(:execute).with(query_args, execute_options).returns(Puppet::Util::Execution::ProcessOutput.new(output, 0))
     end
 
     before do
-      allow(Puppet::Util).to receive(:which).with('/usr/bin/dpkg-query').and_return(dpkgquery_path)
+      Puppet::Util.stubs(:which).with('/usr/bin/dpkg-query').returns(dpkgquery_path)
     end
 
     it "considers the package purged if dpkg-query fails" do
-      allow(Puppet::Util::Execution).to receive(:execute).with(query_args, execute_options).and_raise(Puppet::ExecutionFailure.new("eh"))
+      Puppet::Util::Execution.expects(:execute).with(query_args, execute_options).raises Puppet::ExecutionFailure.new("eh")
 
       expect(provider.query[:ensure]).to eq(:purged)
     end
@@ -147,8 +147,8 @@ describe Puppet::Type.type(:package).provider(:dpkg) do
 
       def parser_test(dpkg_output_string, gold_hash, number_of_debug_logs = 0)
         dpkg_query_execution_returns(dpkg_output_string)
-        expect(Puppet).not_to receive(:warning)
-        expect(Puppet).to receive(:debug).exactly(number_of_debug_logs).times
+        Puppet.expects(:warning).never
+        Puppet.expects(:debug).times(number_of_debug_logs)
 
         expect(provider.query).to eq(gold_hash)
       end
@@ -163,8 +163,8 @@ describe Puppet::Type.type(:package).provider(:dpkg) do
       end
 
       it "does not log if execution returns with non-zero exit code" do
-        expect(Puppet::Util::Execution).to receive(:execute).with(query_args, execute_options).and_raise(Puppet::ExecutionFailure.new("failed"))
-        expect(Puppet).not_to receive(:debug)
+        Puppet::Util::Execution.expects(:execute).with(query_args, execute_options).raises Puppet::ExecutionFailure.new("failed")
+        Puppet::expects(:debug).never
 
         expect(provider.query).to eq(package_not_found_hash)
       end
@@ -173,123 +173,106 @@ describe Puppet::Type.type(:package).provider(:dpkg) do
 
   context "when installing" do
     before do
-      allow(resource).to receive(:[]).with(:source).and_return("mypkg")
+      resource.stubs(:[]).with(:source).returns "mypkg"
     end
 
     it "fails to install if no source is specified in the resource" do
-      expect(resource).to receive(:[]).with(:source).and_return(nil)
+      resource.expects(:[]).with(:source).returns nil
 
       expect { provider.install }.to raise_error(ArgumentError)
     end
 
     it "uses 'dpkg -i' to install the package" do
-      expect(resource).to receive(:[]).with(:source).and_return("mypackagefile")
-      expect(provider).to receive(:unhold)
-      expect(provider).to receive(:dpkg).with(any_args, "-i", "mypackagefile")
+      resource.expects(:[]).with(:source).returns "mypackagefile"
+      provider.expects(:unhold)
+      provider.expects(:dpkg).with { |*command| command[-1] == "mypackagefile"  and command[-2] == "-i" }
 
       provider.install
     end
 
     it "keeps old config files if told to do so" do
-      expect(resource).to receive(:[]).with(:configfiles).and_return(:keep)
-      expect(provider).to receive(:unhold)
-      expect(provider).to receive(:dpkg).with("--force-confold", any_args)
+      resource.expects(:[]).with(:configfiles).returns :keep
+      provider.expects(:unhold)
+      provider.expects(:dpkg).with { |*command| command[0] == "--force-confold" }
 
       provider.install
     end
 
     it "replaces old config files if told to do so" do
-      expect(resource).to receive(:[]).with(:configfiles).and_return(:replace)
-      expect(provider).to receive(:unhold)
-      expect(provider).to receive(:dpkg).with("--force-confnew", any_args)
+      resource.expects(:[]).with(:configfiles).returns :replace
+      provider.expects(:unhold)
+      provider.expects(:dpkg).with { |*command| command[0] == "--force-confnew" }
 
       provider.install
     end
 
     it "ensures any hold is removed" do
-      expect(provider).to receive(:unhold).once
-      expect(provider).to receive(:dpkg)
+      provider.expects(:unhold).once
+      provider.expects(:dpkg)
       provider.install
     end
   end
 
   context "when holding or unholding" do
-    let(:tempfile) { double('tempfile', :print => nil, :close => nil, :flush => nil, :path => "/other/file") }
+    let(:tempfile) { stub 'tempfile', :print => nil, :close => nil, :flush => nil, :path => "/other/file" }
 
     before do
-      allow(tempfile).to receive(:write)
-      allow(Tempfile).to receive(:open).and_yield(tempfile)
+      tempfile.stubs(:write)
+      Tempfile.stubs(:open).yields tempfile
     end
 
-    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)
+    it "installs first if holding" do
+      provider.stubs(:execute)
+      provider.expects(:install).once
       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.stubs(:install)
+      provider.expects(: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.stubs(:install)
+      provider.expects(:execute).with([:dpkg, '--set-selections'], {:failonfail => false, :combine => false, :stdinfile => tempfile.path}).once
       provider.hold
     end
   end
 
   it "uses :install to update" do
-    expect(provider).to receive(:install)
+    provider.expects(:install)
     provider.update
   end
 
   context "when determining latest available version" do
     it "returns the version found by dpkg-deb" do
-      expect(resource).to receive(:[]).with(:source).and_return("myfile")
-      expect(provider).to receive(:dpkg_deb).with(any_args, "myfile").and_return("package\t1.0")
+      resource.expects(:[]).with(:source).returns "myfile"
+      provider.expects(:dpkg_deb).with { |*command| command[-1] == "myfile" }.returns "package\t1.0"
       expect(provider.latest).to eq("1.0")
     end
 
     it "warns if the package file contains a different package" do
-      expect(provider).to receive(:dpkg_deb).and_return("foo\tversion")
-      expect(provider).to receive(:warning)
+      provider.expects(:dpkg_deb).returns("foo\tversion")
+      provider.expects(:warning)
       provider.latest
     end
 
     it "copes with names containing ++" do
-      resource = double('resource', :[] => "package++")
+      resource = stub 'resource', :[] => "package++"
       provider = described_class.new(resource)
-      expect(provider).to receive(:dpkg_deb).and_return("package++\t1.0")
+      provider.expects(:dpkg_deb).returns "package++\t1.0"
       expect(provider.latest).to eq("1.0")
     end
   end
 
   it "uses 'dpkg -r' to uninstall" do
-    expect(provider).to receive(:dpkg).with("-r", resource_name)
+    provider.expects(:dpkg).with("-r", resource_name)
     provider.uninstall
   end
 
   it "uses 'dpkg --purge' to purge" do
-    expect(provider).to receive(:dpkg).with("--purge", resource_name)
+    provider.expects(: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/freebsd_spec.rb

@@ -3,14 +3,14 @@ require 'spec_helper'
 describe Puppet::Type.type(:package).provider(:freebsd) do
   before :each do
     # Create a mock resource
-    @resource = double('resource')
+    @resource = stub 'resource'
 
     # A catch all; no parameters set
-    allow(@resource).to receive(:[]).and_return(nil)
+    @resource.stubs(:[]).returns(nil)
 
     # But set name and source
-    allow(@resource).to receive(:[]).with(:name).and_return("mypackage")
-    allow(@resource).to receive(:[]).with(:ensure).and_return(:installed)
+    @resource.stubs(:[]).with(:name).returns   "mypackage"
+    @resource.stubs(:[]).with(:ensure).returns :installed
 
     @provider = subject()
     @provider.resource = @resource
@@ -23,15 +23,15 @@ describe Puppet::Type.type(:package).provider(:freebsd) do
 
   context "when installing" do
     before :each do
-      allow(@resource).to receive(:should).with(:ensure).and_return(:installed)
+      @resource.stubs(:should).with(:ensure).returns(:installed)
     end
 
     it "should install a package from a path to a directory" do
       # For better or worse, trailing '/' is needed. --daniel 2011-01-26
       path = '/path/to/directory/'
-      allow(@resource).to receive(:[]).with(:source).and_return(path)
-      expect(Puppet::Util).to receive(:withenv).once.with({:PKG_PATH => path}).and_yield
-      expect(@provider).to receive(:pkgadd).once.with("mypackage")
+      @resource.stubs(:[]).with(:source).returns(path)
+      Puppet::Util.expects(:withenv).once.with({:PKG_PATH => path}).yields
+      @provider.expects(:pkgadd).once.with("mypackage")
 
       expect { @provider.install }.to_not raise_error
     end
@@ -40,9 +40,9 @@ describe Puppet::Type.type(:package).provider(:freebsd) do
       it "should install a package via #{protocol}" do
         # For better or worse, trailing '/' is needed. --daniel 2011-01-26
         path = "#{protocol}://localhost/"
-        allow(@resource).to receive(:[]).with(:source).and_return(path)
-        expect(Puppet::Util).to receive(:withenv).once.with({:PACKAGESITE => path}).and_yield
-        expect(@provider).to receive(:pkgadd).once.with('-r', "mypackage")
+        @resource.stubs(:[]).with(:source).returns(path)
+        Puppet::Util.expects(:withenv).once.with({:PACKAGESITE => path}).yields
+        @provider.expects(:pkgadd).once.with('-r', "mypackage")
 
         expect { @provider.install }.to_not raise_error
       end

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

@@ -1,17 +1,6 @@
 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
       Puppet::Type.type(:package).new(
@@ -28,57 +17,43 @@ context Puppet::Type.type(:package).provider(:gem) do
 
     before :each do
       resource.provider = provider
-      allow(described_class).to receive(:command).with(:gemcmd).and_return(provider_gem_cmd)
     end
 
     context "when installing" do
-      before :each do
-        allow(provider).to receive(:rubygem_version).and_return('1.9.9')
-      end
-
-      it "should use the path to the gem command" do
-        allow(described_class).to receive(:validate_command).with(provider_gem_cmd)
-        expect(described_class).to receive(:execute).with(be_a(Array), execute_options) { |args| expect(args[0]).to eq(provider_gem_cmd) }.and_return("")
+      it "should use the path to the gem" do
+        described_class.stubs(:command).with(:gemcmd).returns "/my/gem"
+        provider.expects(:execute).with { |args| args[0] == "/my/gem" }.returns ""
         provider.install
       end
 
       it "should specify that the gem is being installed" do
-        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.expects(:execute).with { |args| args[1] == "install" }.returns ""
         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(provider_gem_cmd, be_a(Array)) { |cmd, args| expect(args[1]).to eq("--no-rdoc") }.and_return("")
+      it "should specify that documentation should not be included" do
+        provider.expects(:execute).with { |args| args[2] == "--no-rdoc" }.returns ""
         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(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(provider_gem_cmd, be_a(Array)) { |cmd, args| expect(args[1]).to eq("--no-document") }.and_return("")
+      it "should specify that RI should not be included" do
+        provider.expects(:execute).with { |args| args[3] == "--no-ri" }.returns ""
         provider.install
       end
 
       it "should specify the package name" do
-        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.expects(:execute).with { |args| args[4] == "myresource" }.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, be_a(Array)) { |cmd, args| expect(args.length).to eq(4) }.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, be_a(Array)) do |cmd, args|
-          expect(args[1]).to eq('--force')
-          expect(args[2]).to eq('--bindir=/usr/bin')
-        end.and_return("")
+        provider.expects(:execute).with { |args| args[2] == '--force' && args[3] == '--bindir=/usr/bin' }.returns ''
         provider.install
       end
 
@@ -86,7 +61,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(provider_gem_cmd, array_including("/my/file")).and_return("")
+            provider.expects(:execute).with { |args| args[2] == "/my/file" }.returns ""
             provider.install
           end
         end
@@ -94,7 +69,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(provider_gem_cmd, array_including("/my/file")).and_return("")
+            provider.expects(:execute).with { |args| args[2] == "/my/file" }.returns ""
             provider.install
           end
         end
@@ -109,7 +84,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(provider_gem_cmd, be_a(Array)) { |cmd, args| expect(args[3..5]).to eq(["--source", "http://host/my/file", "myresource"]) }.and_return("")
+            provider.expects(:execute).with { |args| args[2..4] == ["--source", "http://host/my/file", "myresource"] }.returns ""
             provider.install
           end
         end
@@ -117,14 +92,14 @@ context Puppet::Type.type(:package).provider(:gem) do
         context "as a windows path on windows", :if => Puppet::Util::Platform.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(provider_gem_cmd, array_including("c:/this/is/a/path/to/a/gem.gem")).and_return("")
+            provider.expects(:execute).with { |args| args[2] == "c:/this/is/a/path/to/a/gem.gem" }.returns ""
             provider.install
           end
         end
 
         context "with an invalid uri" do
           it "should fail" do
-            expect(URI).to receive(:parse).and_raise(ArgumentError)
+            URI.expects(:parse).raises(ArgumentError)
             resource[:source] = "http:::::uppet:/:/my/file"
             expect { provider.install }.to raise_error(Puppet::Error)
           end
@@ -137,7 +112,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({:command => provider_gem_cmd, :justme => 'myresource'}).and_return({
+        provider.class.expects(:gemlist).with({ :justme => 'myresource'}).returns({
           :name     => 'myresource',
           :ensure   => ["3.0"],
           :provider => :gem,
@@ -147,84 +122,85 @@ 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({:command => provider_gem_cmd, :justme => 'myresource', :source => "http://foo.bar.baz/gems"}).
-          and_return({
+        provider.class.expects(:gemlist).
+          with({:justme => 'myresource', :source => "http://foo.bar.baz/gems"}).
+          returns({
             :name     => 'myresource',
             :ensure   => ["3.0"],
             :provider => :gem,
           })
-        expect(provider.latest).to eq("3.0")
+          expect(provider.latest).to eq("3.0")
       end
     end
 
     context "#instances" do
       before do
-        allow(described_class).to receive(:command).with(:gemcmd).and_return(provider_gem_cmd)
+        described_class.stubs(:command).with(:gemcmd).returns "/my/gem"
       end
 
       it "should return an empty array when no gems installed" do
-        expect(described_class).to receive(:execute_gem_command).with(provider_gem_cmd, %w{list --local}).and_return("\n")
+        described_class.expects(:execute).with(%w{/my/gem list --local}, {:failonfail => true, :combine => true, :custom_environment => {"HOME"=>ENV["HOME"]}}).returns("\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(provider_gem_cmd, %w{list --local}).and_return(<<-HEREDOC.gsub(/        /, ''))
+        described_class.expects(:execute).with(%w{/my/gem list --local}, {:failonfail => true, :combine => true, :custom_environment => {"HOME"=>ENV["HOME"]}}).returns <<-HEREDOC.gsub(/        /, '')
         systemu (1.2.0)
         vagrant (0.8.7, 0.6.9)
         HEREDOC
 
         expect(described_class.instances.map {|p| p.properties}).to eq([
-          {: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"]}
+          {:ensure => ["1.2.0"],          :provider => :gem, :name => 'systemu'},
+          {:ensure => ["0.8.7", "0.6.9"], :provider => :gem, :name => 'vagrant'}
         ])
       end
 
       it "should ignore platform specifications" do
-        expect(described_class).to receive(:execute_gem_command).with(provider_gem_cmd, %w{list --local}).and_return(<<-HEREDOC.gsub(/        /, ''))
+        described_class.expects(:execute).with(%w{/my/gem list --local}, {:failonfail => true, :combine => true, :custom_environment => {"HOME"=>ENV["HOME"]}}).returns <<-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([
-          {: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"]}
+          {:ensure => ["1.2.0"],          :provider => :gem, :name => 'systemu'},
+          {:ensure => ["1.6.1", "1.4.4.1"], :provider => :gem, :name => 'nokogiri'}
         ])
       end
 
       it "should not list 'default: ' text from rubygems''" do
-        expect(described_class).to receive(:execute_gem_command).with(provider_gem_cmd, %w{list --local}).and_return(<<-HEREDOC.gsub(/        /, ''))
+        described_class.expects(:execute).with(%w{/my/gem list --local}, anything).returns <<-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", :provider => :gem, :command => provider_gem_cmd, :ensure => ["1.16.1", "1.16.0", "1.15.1"]}
+          {:name => 'bundler', :ensure => ["1.16.1", "1.16.0", "1.15.1"], :provider => :gem}
         ])
       end
 
       it "should not fail when an unmatched line is returned" do
-        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')))
+        described_class.expects(:execute).with(%w{/my/gem list --local}, {:failonfail => true, :combine => true, :custom_environment => {"HOME"=>ENV["HOME"]}}).
+          returns(File.read(my_fixture('line-with-1.8.5-warning')))
 
         expect(described_class.instances.map {|p| p.properties}).
-          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"]}])
+          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"}])
       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(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)
+          described_class.expects(:execute).with(includes('\Abundler\z'), {:failonfail => true, :combine => true, :custom_environment => {"HOME"=>ENV["HOME"]}}).returns(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)
         end
       end
     end
@@ -300,39 +276,6 @@ 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(
@@ -349,65 +292,45 @@ context Puppet::Type.type(:package).provider(:gem) do
 
     before :each do
       resource.provider = provider
-      allow(described_class).to receive(:command).with(:gemcmd).and_return(provider_gem_cmd)
     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("")
+      it "should use the path to the gem" do
+        described_class.stubs(:command).with(:gemcmd).returns "/my/gem"
+        provider.expects(:execute).with { |args| args[0] == "/my/gem" }.returns ""
         provider.uninstall
       end
 
       it "should specify that the gem is being uninstalled" do
-        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.expects(:execute).with { |args| args[1] == "uninstall" }.returns ""
         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(provider_gem_cmd, be_a(Array)) { |cmd, args| expect(args[1]).to eq("--executables") }.and_return("")
+        provider.expects(:execute).with { |args| args[2] == "--executables" }.returns ""
         provider.uninstall
       end
 
       it "should specify that all the matching versions should be removed" do
-        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.expects(:execute).with { |args| args[3] == "--all" }.returns ""
         provider.uninstall
       end
 
       it "should specify the package name" do
-        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.expects(:execute).with { |args| args[4] == "myresource" }.returns ""
         provider.uninstall
       end
 
       it "should not append uninstall_options by default" do
-        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.expects(:execute).with { |args| args.length == 5 }.returns ""
         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(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('')
+        provider.expects(:execute).with { |args| args[5] == '--ignore-dependencies' && args[6] == '--version=0.1.1' }.returns ''
         provider.uninstall
       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