puppet 5.5.12-x86-mingw32 → 5.5.13-x86-mingw32

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

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 describe Puppet::Type.type(:package).provider(:aptrpm) do
@@ -11,37 +10,33 @@ describe Puppet::Type.type(:package).provider(:aptrpm) do
 
   context "when retrieving ensure" do
     before(:each) do
-      Puppet::Util.stubs(:which).with("rpm").returns("/bin/rpm")
-      pkg.provider.stubs(:which).with("rpm").returns("/bin/rpm")
-      Puppet::Util::Execution.expects(:execute).with(["/bin/rpm", "--version"], {:combine => true, :custom_environment => {}, :failonfail => true}).returns(Puppet::Util::Execution::ProcessOutput.new("4.10.1\n", 0)).at_most_once
+      allow(Puppet::Util).to receive(:which).with("rpm").and_return("/bin/rpm")
+      allow(pkg.provider).to receive(:which).with("rpm").and_return("/bin/rpm")
+      expect(Puppet::Util::Execution).to receive(:execute).with(["/bin/rpm", "--version"], {:combine => true, :custom_environment => {}, :failonfail => true}).and_return(Puppet::Util::Execution::ProcessOutput.new("4.10.1\n", 0)).at_most(:once)
     end
 
     def rpm_args
       ['-q', 'faff', '--nosignature', '--nodigest', '--qf', "'%{NAME} %|EPOCH?{%{EPOCH}}:{0}| %{VERSION} %{RELEASE} %{ARCH}\\n'"]
     end
 
-    def rpm(args = rpm_args)
-      pkg.provider.expects(:rpm).with(*args)
-    end
-
     it "should report purged packages" do
-      rpm.raises(Puppet::ExecutionFailure, "couldn't find rpm")
+      expect(pkg.provider).to receive(:rpm).and_raise(Puppet::ExecutionFailure, "couldn't find rpm")
       expect(pkg.property(:ensure).retrieve).to eq(:purged)
     end
 
     it "should report present packages correctly" do
-      rpm.returns("faff-1.2.3-1 0 1.2.3-1 5 i686\n")
+      expect(pkg.provider).to receive(:rpm).and_return("faff-1.2.3-1 0 1.2.3-1 5 i686\n")
       expect(pkg.property(:ensure).retrieve).to eq("1.2.3-1-5")
     end
   end
 
   it "should try and install when asked" do
-    pkg.provider.expects(:aptget). with('-q', '-y', 'install', 'faff'). returns(0)
+    expect(pkg.provider).to receive(:aptget).with('-q', '-y', 'install', 'faff').and_return(0)
     pkg.provider.install
   end
 
   it "should try and purge when asked" do
-    pkg.provider.expects(:aptget).with('-y', '-q', 'remove', '--purge', 'faff').returns(0)
+    expect(pkg.provider).to receive(:aptget).with('-y', '-q', 'remove', '--purge', 'faff').and_return(0)
     pkg.provider.purge
   end
 end

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

@@ -4,15 +4,15 @@ require 'puppet/provider/package'
 describe Puppet::Provider::Package do
   it 'returns absent for uninstalled packages when not purgeable' do
     provider = Puppet::Provider::Package.new
-    provider.expects(:query).returns nil
-    provider.class.expects(:feature?).with(:purgeable).returns false
+    expect(provider).to receive(:query).and_return(nil)
+    expect(provider.class).to receive(:feature?).with(:purgeable).and_return(false)
     expect(provider.properties[:ensure]).to eq(:absent)
   end
 
   it 'returns purged for uninstalled packages when purgeable' do
     provider = Puppet::Provider::Package.new
-    provider.expects(:query).returns nil
-    provider.class.expects(:feature?).with(:purgeable).returns true
+    expect(provider).to receive(:query).and_return(nil)
+    expect(provider.class).to receive(:feature?).with(:purgeable).and_return(true)
     expect(provider.properties[:ensure]).to eq(:purged)
   end
 end

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

@@ -2,41 +2,39 @@ require 'spec_helper'
 
 # Note that much of the functionality of the dnf provider is already tested with yum provider tests,
 # as yum is the parent provider.
-
 describe Puppet::Type.type(:package).provider(:dnf) do
   context 'default' do
     (19..21).each do |ver|
       it "should not be the default provider on fedora#{ver}" do
-        Facter.stubs(:value).with(:osfamily).returns(:redhat)
-        Facter.stubs(:value).with(:operatingsystem).returns(:fedora)
-        Facter.stubs(:value).with(:operatingsystemmajrelease).returns("#{ver}")
+        allow(Facter).to receive(:value).with(:osfamily).and_return(:redhat)
+        allow(Facter).to receive(:value).with(:operatingsystem).and_return(:fedora)
+        allow(Facter).to receive(:value).with(:operatingsystemmajrelease).and_return("#{ver}")
         expect(described_class).to_not be_default
       end
     end
 
     (22..26).each do |ver|
       it "should be the default provider on fedora#{ver}" do
-        Facter.stubs(:value).with(:osfamily).returns(:redhat)
-        Facter.stubs(:value).with(:operatingsystem).returns(:fedora)
-        Facter.stubs(:value).with(:operatingsystemmajrelease).returns("#{ver}")
+        allow(Facter).to receive(:value).with(:osfamily).and_return(:redhat)
+        allow(Facter).to receive(:value).with(:operatingsystem).and_return(:fedora)
+        allow(Facter).to receive(:value).with(:operatingsystemmajrelease).and_return("#{ver}")
         expect(described_class).to be_default
       end
     end
 
     it "should not be the default provider on rhel7" do
-        Facter.stubs(:value).with(:osfamily).returns(:redhat)
-        Facter.stubs(:value).with(:operatingsystem).returns(:redhat)
-        Facter.stubs(:value).with(:operatingsystemmajrelease).returns("7")
-        expect(described_class).to_not be_default
+      allow(Facter).to receive(:value).with(:osfamily).and_return(:redhat)
+      allow(Facter).to receive(:value).with(:operatingsystem).and_return(:redhat)
+      allow(Facter).to receive(:value).with(:operatingsystemmajrelease).and_return("7")
+      expect(described_class).to_not be_default
     end
 
     it "should be the default provider on rhel8" do
-        Facter.stubs(:value).with(:osfamily).returns(:redhat)
-        Facter.stubs(:value).with(:operatingsystem).returns(:redhat)
-        Facter.stubs(:value).with(:operatingsystemmajrelease).returns("8")
-        expect(described_class).to be_default
+      allow(Facter).to receive(:value).with(:osfamily).and_return(:redhat)
+      allow(Facter).to receive(:value).with(:operatingsystem).and_return(:redhat)
+      allow(Facter).to receive(:value).with(:operatingsystemmajrelease).and_return("8")
+      expect(described_class).to be_default
     end
-
   end
 
   it_behaves_like 'RHEL package provider', described_class, 'dnf'

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

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

@@ -21,39 +21,43 @@ context Puppet::Type.type(:package).provider(:gem) do
 
     context "when installing" do
       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 ""
+        allow(described_class).to receive(:command).with(:gemcmd).and_return("/my/gem")
+        expect(provider).to receive(:execute).with(be_a(Array), be_a(Hash)) { |args| expect(args[0]).to eq("/my/gem") }.and_return("")
         provider.install
       end
 
       it "should specify that the gem is being installed" do
-        provider.expects(:execute).with { |args| args[1] == "install" }.returns ""
+        expect(provider).to receive(:execute).with(be_a(Array), be_a(Hash)) { |args| expect(args[1]).to eq("install") }.and_return("")
         provider.install
       end
 
       it "should specify that documentation should not be included" do
-        provider.expects(:execute).with { |args| args[2] == "--no-rdoc" }.returns ""
+        expect(provider).to receive(:execute).with(be_a(Array), be_a(Hash)) { |args| expect(args[2]).to eq("--no-rdoc") }.and_return("")
         provider.install
       end
 
       it "should specify that RI should not be included" do
-        provider.expects(:execute).with { |args| args[3] == "--no-ri" }.returns ""
+        expect(provider).to receive(:execute).with(be_a(Array), be_a(Hash)) { |args| expect(args[3]).to eq("--no-ri") }.and_return("")
         provider.install
       end
 
       it "should specify the package name" do
-        provider.expects(:execute).with { |args| args[4] == "myresource" }.returns ""
+        expect(provider).to receive(:execute).with(be_a(Array), be_a(Hash)) { |args| expect(args[4]).to eq("myresource") }.and_return("")
         provider.install
       end
 
       it "should not append install_options by default" do
-        provider.expects(:execute).with { |args| args.length == 5 }.returns ""
+        expect(provider).to receive(:execute).with(be_a(Array), be_a(Hash)) { |args| expect(args.length).to eq(5) }.and_return("")
         provider.install
       end
 
       it "should allow setting an install_options parameter" do
         resource[:install_options] = [ '--force', {'--bindir' => '/usr/bin' } ]
-        provider.expects(:execute).with { |args| args[2] == '--force' && args[3] == '--bindir=/usr/bin' }.returns ''
+        expect(provider).to receive(:execute).with(be_a(Array), be_a(Hash)) do |args|
+          expect(args[2]).to eq('--force')
+          expect(args[3]).to eq('--bindir=/usr/bin')
+        end.and_return('')
+
         provider.install
       end
 
@@ -61,7 +65,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"
-            provider.expects(:execute).with { |args| args[2] == "/my/file" }.returns ""
+            expect(provider).to receive(:execute).with(be_a(Array), be_a(Hash)) { |args| expect(args[2]).to eq("/my/file") }.and_return("")
             provider.install
           end
         end
@@ -69,7 +73,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"
-            provider.expects(:execute).with { |args| args[2] == "/my/file" }.returns ""
+            expect(provider).to receive(:execute).with(be_a(Array), be_a(Hash)) { |args| expect(args[2]).to eq("/my/file") }.and_return("")
             provider.install
           end
         end
@@ -84,7 +88,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"
-            provider.expects(:execute).with { |args| args[2..4] == ["--source", "http://host/my/file", "myresource"] }.returns ""
+            expect(provider).to receive(:execute).with(be_a(Array), be_a(Hash)) { |args| expect(args[2..4]).to eq(["--source", "http://host/my/file", "myresource"]) }.and_return("")
             provider.install
           end
         end
@@ -92,14 +96,14 @@ 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"
-            provider.expects(:execute).with { |args| args[2] == "c:/this/is/a/path/to/a/gem.gem" }.returns ""
+            expect(provider).to receive(:execute).with(be_a(Array), be_a(Hash)) { |args| expect(args[2]).to eq("c:/this/is/a/path/to/a/gem.gem") }.and_return("")
             provider.install
           end
         end
 
         context "with an invalid uri" do
           it "should fail" do
-            URI.expects(:parse).raises(ArgumentError)
+            expect(URI).to receive(:parse).and_raise(ArgumentError)
             resource[:source] = "http:::::uppet:/:/my/file"
             expect { provider.install }.to raise_error(Puppet::Error)
           end
@@ -112,7 +116,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.
-        provider.class.expects(:gemlist).with({ :justme => 'myresource'}).returns({
+        expect(provider.class).to receive(:gemlist).with({:justme => 'myresource'}).and_return({
           :name     => 'myresource',
           :ensure   => ["3.0"],
           :provider => :gem,
@@ -122,29 +126,29 @@ context Puppet::Type.type(:package).provider(:gem) do
 
       it "should list from the specified source repository" do
         resource[:source] = "http://foo.bar.baz/gems"
-        provider.class.expects(:gemlist).
+        expect(provider.class).to receive(:gemlist).
           with({:justme => 'myresource', :source => "http://foo.bar.baz/gems"}).
-          returns({
+          and_return({
             :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
-        described_class.stubs(:command).with(:gemcmd).returns "/my/gem"
+        allow(described_class).to receive(:command).with(:gemcmd).and_return("/my/gem")
       end
 
       it "should return an empty array when no gems installed" do
-        described_class.expects(:execute).with(%w{/my/gem list --local}, {:failonfail => true, :combine => true, :custom_environment => {"HOME"=>ENV["HOME"]}}).returns("\n")
+        expect(described_class).to receive(:execute).with(%w{/my/gem list --local}, {:failonfail => true, :combine => true, :custom_environment => {"HOME"=>ENV["HOME"]}}).and_return("\n")
         expect(described_class.instances).to eq([])
       end
 
       it "should return ensure values as an array of installed versions" do
-        described_class.expects(:execute).with(%w{/my/gem list --local}, {:failonfail => true, :combine => true, :custom_environment => {"HOME"=>ENV["HOME"]}}).returns <<-HEREDOC.gsub(/        /, '')
+        expect(described_class).to receive(:execute).with(%w{/my/gem list --local}, {:failonfail => true, :combine => true, :custom_environment => {"HOME"=>ENV["HOME"]}}).and_return(<<-HEREDOC.gsub(/        /, ''))
         systemu (1.2.0)
         vagrant (0.8.7, 0.6.9)
         HEREDOC
@@ -156,7 +160,7 @@ context Puppet::Type.type(:package).provider(:gem) do
       end
 
       it "should ignore platform specifications" do
-        described_class.expects(:execute).with(%w{/my/gem list --local}, {:failonfail => true, :combine => true, :custom_environment => {"HOME"=>ENV["HOME"]}}).returns <<-HEREDOC.gsub(/        /, '')
+        expect(described_class).to receive(:execute).with(%w{/my/gem list --local}, {:failonfail => true, :combine => true, :custom_environment => {"HOME"=>ENV["HOME"]}}).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
@@ -168,7 +172,7 @@ context Puppet::Type.type(:package).provider(:gem) do
       end
 
       it "should not list 'default: ' text from rubygems''" do
-        described_class.expects(:execute).with(%w{/my/gem list --local}, anything).returns <<-HEREDOC.gsub(/        /, '')
+        expect(described_class).to receive(:execute).with(%w{/my/gem list --local}, anything).and_return(<<-HEREDOC.gsub(/        /, ''))
         bundler (1.16.1, default: 1.16.0, 1.15.1)
         HEREDOC
 
@@ -178,27 +182,27 @@ context Puppet::Type.type(:package).provider(:gem) do
       end
 
       it "should not fail when an unmatched line is returned" do
-        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).to receive(:execute).with(%w{/my/gem list --local}, {:failonfail => true, :combine => true, :custom_environment => {"HOME"=>ENV["HOME"]}}).
+          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([{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
-          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')))
+          expect(described_class).to receive(:execute).with(include('\Abundler\z'), {:failonfail => true, :combine => true, :custom_environment => {"HOME"=>ENV["HOME"]}}).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)
         end
@@ -296,39 +300,43 @@ context Puppet::Type.type(:package).provider(:gem) do
 
     context "when uninstalling" do
       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 ""
+        allow(described_class).to receive(:command).with(:gemcmd).and_return("/my/gem")
+        expect(provider).to receive(:execute).with(be_a(Array), be_a(Hash)) { |args| expect(args[0]).to eq("/my/gem") }.and_return("")
         provider.uninstall
       end
 
       it "should specify that the gem is being uninstalled" do
-        provider.expects(:execute).with { |args| args[1] == "uninstall" }.returns ""
+        expect(provider).to receive(:execute).with(be_a(Array), be_a(Hash)) { |args| expect(args[1]).to eq("uninstall") }.and_return("")
         provider.uninstall
       end
 
       it "should specify that the relevant executables should be removed without confirmation" do
-        provider.expects(:execute).with { |args| args[2] == "--executables" }.returns ""
+        expect(provider).to receive(:execute).with(be_a(Array), be_a(Hash)) { |args| expect(args[2]).to eq("--executables") }.and_return("")
         provider.uninstall
       end
 
       it "should specify that all the matching versions should be removed" do
-        provider.expects(:execute).with { |args| args[3] == "--all" }.returns ""
+        expect(provider).to receive(:execute).with(be_a(Array), be_a(Hash)) { |args| expect(args[3]).to eq("--all") }.and_return("")
         provider.uninstall
       end
 
       it "should specify the package name" do
-        provider.expects(:execute).with { |args| args[4] == "myresource" }.returns ""
+        expect(provider).to receive(:execute).with(be_a(Array), be_a(Hash)) { |args| expect(args[4]).to eq("myresource") }.and_return("")
         provider.uninstall
       end
 
       it "should not append uninstall_options by default" do
-        provider.expects(:execute).with { |args| args.length == 5 }.returns ""
+        expect(provider).to receive(:execute).with(be_a(Array), be_a(Hash)) { |args| expect(args.length).to eq(5) }.and_return("")
         provider.uninstall
       end
 
       it "should allow setting an uninstall_options parameter" do
         resource[:uninstall_options] = [ '--ignore-dependencies', {'--version' => '0.1.1' } ]
-        provider.expects(:execute).with { |args| args[5] == '--ignore-dependencies' && args[6] == '--version=0.1.1' }.returns ''
+        expect(provider).to receive(:execute).with(be_a(Array), be_a(Hash)) do |args|
+          expect(args[5]).to eq('--ignore-dependencies')
+          expect(args[6]).to eq('--version=0.1.1')
+        end.and_return('')
+
         provider.uninstall
       end
     end