puppet 5.5.12 → 5.5.13

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

@@ -6,9 +6,9 @@ describe Puppet::Type.type(:package).provider(:pip) do
   before do  
     @resource = Puppet::Resource.new(:package, "fake_package")
     @provider = described_class.new(@resource)
-    @client = stub_everything('client')
-    @client.stubs(:call).with('package_releases', 'real_package').returns(["1.3", "1.2.5", "1.2.4"])
-    @client.stubs(:call).with('package_releases', 'fake_package').returns([])
+    @client = double('client')
+    allow(@client).to receive(:call).with('package_releases', 'real_package').and_return(["1.3", "1.2.5", "1.2.4"])
+    allow(@client).to receive(:call).with('package_releases', 'fake_package').and_return([])
   end
 
   context "parse" do
@@ -27,17 +27,17 @@ describe Puppet::Type.type(:package).provider(:pip) do
 
   context "cmd" do
     it "should return 'pip.exe' by default on Windows systems" do
-      Puppet.features.stubs(:microsoft_windows?).returns true
+      allow(Puppet.features).to receive(:microsoft_windows?).and_return(true)
       expect(described_class.cmd[0]).to eq('pip.exe')
     end
 
     it "could return pip-python on legacy redhat systems which rename pip" do
-      Puppet.features.stubs(:microsoft_windows?).returns false
+      allow(Puppet.features).to receive(:microsoft_windows?).and_return(false)
       expect(described_class.cmd[1]).to eq('pip-python')
     end
 
     it "should return pip by default on other systems" do
-      Puppet.features.stubs(:microsoft_windows?).returns false
+      allow(Puppet.features).to receive(:microsoft_windows?).and_return(false)
       expect(described_class.cmd[0]).to eq('pip')
     end
   end
@@ -45,18 +45,18 @@ describe Puppet::Type.type(:package).provider(:pip) do
   context "instances" do
     osfamilies.each do |osfamily, pip_cmds|
       it "should return an array on #{osfamily} systems when #{pip_cmds.join(' or ')} is present" do
-        Puppet.features.stubs(:microsoft_windows?).returns (osfamily == 'windows')
+        allow(Puppet.features).to receive(:microsoft_windows?).and_return(osfamily == 'windows')
         pip_cmds.each do |pip_cmd|  
           pip_cmds.each do |cmd|
             unless cmd == pip_cmd
-              described_class.expects(:which).with(cmd).returns(nil)
+              expect(described_class).to receive(:which).with(cmd).and_return(nil)
             end
           end
-          described_class.stubs(:pip_version).returns('8.0.1')
-          described_class.expects(:which).with(pip_cmd).returns("/fake/bin/#{pip_cmd}")
-          p = stub("process")
-          p.expects(:collect).yields("real_package==1.2.5")
-          described_class.expects(:execpipe).with(["/fake/bin/#{pip_cmd}", "freeze"]).yields(p)
+          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}")
+          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)
           described_class.instances
         end
       end
@@ -65,21 +65,21 @@ describe Puppet::Type.type(:package).provider(:pip) do
         versions = ['8.1.0', '9.0.1']
         versions.each do |version|
           it "should use the --all option when version is '#{version}'" do
-            Puppet.features.stubs(:microsoft_windows?).returns (osfamily == 'windows')
-            described_class.stubs(:pip_cmd).returns('/fake/bin/pip')
-            described_class.stubs(:pip_version).returns(version)
-            p = stub("process")
-            p.expects(:collect).yields("real_package==1.2.5")
-            described_class.expects(:execpipe).with(["/fake/bin/pip", "freeze", "--all"]).yields(p)
+            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)
+            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)
             described_class.instances
           end
         end
       end
 
       it "should return an empty array on #{osfamily} systems when #{pip_cmds.join(' and ')} are missing" do
-        Puppet.features.stubs(:microsoft_windows?).returns (osfamily == 'windows')
+        allow(Puppet.features).to receive(:microsoft_windows?).and_return(osfamily == 'windows')
         pip_cmds.each do |cmd|
-          described_class.expects(:which).with(cmd).returns nil
+          expect(described_class).to receive(:which).with(cmd).and_return(nil)
         end
         expect(described_class.instances).to eq([])
       end
@@ -92,11 +92,11 @@ describe Puppet::Type.type(:package).provider(:pip) do
     end
 
     it "should return a hash when pip and the package are present" do
-      described_class.expects(:instances).returns [described_class.new({
+      expect(described_class).to receive(:instances).and_return([described_class.new({
         :ensure   => "1.2.5",
         :name     => "real_package",
         :provider => :pip,
-      })]
+      })])
 
       expect(@provider.query).to eq({
         :ensure   => "1.2.5",
@@ -106,18 +106,18 @@ describe Puppet::Type.type(:package).provider(:pip) do
     end
 
     it "should return nil when the package is missing" do
-      described_class.expects(:instances).returns []
+      expect(described_class).to receive(:instances).and_return([])
       expect(@provider.query).to eq(nil)
     end
 
     it "should be case insensitive" do
       @resource[:name] = "Real_Package"
 
-      described_class.expects(:instances).returns [described_class.new({
+      expect(described_class).to receive(:instances).and_return([described_class.new({
         :ensure   => "1.2.5",
         :name     => "real_package",
         :provider => :pip,
-      })]
+      })])
 
       expect(@provider.query).to eq({
         :ensure   => "1.2.5",
@@ -130,10 +130,10 @@ describe Puppet::Type.type(:package).provider(:pip) do
   context "latest" do
     context "with pip version < 1.5.4" do
       before :each do
-        described_class.stubs(:pip_version).returns('1.0.1')
-        described_class.stubs(:which).with('pip').returns("/fake/bin/pip")
-        described_class.stubs(:which).with('pip-python').returns("/fake/bin/pip")
-        described_class.stubs(:which).with('pip.exe').returns("/fake/bin/pip")
+        allow(described_class).to receive(:pip_version).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")
       end
 
       it "should find a version number for new_pip_package" do
@@ -146,7 +146,7 @@ describe Puppet::Type.type(:package).provider(:pip) do
           Successfully downloaded real-package
           EOS
         )
-        Puppet::Util::Execution.expects(:execpipe).yields(p).once
+        expect(Puppet::Util::Execution).to receive(:execpipe).and_yield(p).once
         @resource[:name] = "real_package"
         expect(@provider.latest).to eq('0.10.1')
       end
@@ -176,7 +176,7 @@ describe Puppet::Type.type(:package).provider(:pip) do
           Storing complete log in /root/.pip/pip.log
           EOS
         )
-        Puppet::Util::Execution.expects(:execpipe).yields(p).once
+        expect(Puppet::Util::Execution).to receive(:execpipe).and_yield(p).once
         @resource[:name] = "fake_package"
         expect(@provider.latest).to eq(nil)
       end
@@ -186,10 +186,10 @@ 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
-        described_class.stubs(:pip_version).returns('1.5.4')
-        described_class.stubs(:which).with('pip').returns("/fake/bin/pip")
-        described_class.stubs(:which).with('pip-python').returns("/fake/bin/pip")
-        described_class.stubs(:which).with('pip.exe').returns("/fake/bin/pip")
+        allow(described_class).to receive(:pip_version).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")
       end
 
       it "should find a version number for real_package" do
@@ -200,7 +200,7 @@ describe Puppet::Type.type(:package).provider(:pip) do
           No matching distribution found for real-package==versionplease
           EOS
         )
-        Puppet::Util::Execution.expects(:execpipe).with(["/fake/bin/pip", "install", "real_package==versionplease"]).yields(p).once
+        expect(Puppet::Util::Execution).to receive(:execpipe).with(["/fake/bin/pip", "install", "real_package==versionplease"]).and_yield(p).once
         @resource[:name] = "real_package"
         latest = @provider.latest
         expect(latest).to eq('1.9b1')
@@ -214,7 +214,7 @@ describe Puppet::Type.type(:package).provider(:pip) do
           No matching distribution found for fake-package==versionplease
           EOS
         )
-        Puppet::Util::Execution.expects(:execpipe).with(["/fake/bin/pip", "install", "fake_package==versionplease"]).yields(p).once
+        expect(Puppet::Util::Execution).to receive(:execpipe).with(["/fake/bin/pip", "install", "fake_package==versionplease"]).and_yield(p).once
         @resource[:name] = "fake_package"
         expect(@provider.latest).to eq(nil)
       end
@@ -227,7 +227,7 @@ describe Puppet::Type.type(:package).provider(:pip) do
           No distributions matching the version for real-package==versionplease
           EOS
         )
-        Puppet::Util::Execution.expects(:execpipe).with(["/fake/bin/pip", "install", "real_package==versionplease"]).yields(p).once
+        expect(Puppet::Util::Execution).to receive(:execpipe).with(["/fake/bin/pip", "install", "real_package==versionplease"]).and_yield(p).once
         @resource[:name] = "real_package"
         latest = @provider.latest
         expect(latest).to eq('15.0.2')
@@ -244,8 +244,7 @@ describe Puppet::Type.type(:package).provider(:pip) do
     it "should install" do
       @resource[:ensure] = :installed
       @resource[:source] = nil
-      @provider.expects(:lazy_pip).
-        with("install", '-q', "fake_package")
+      expect(@provider).to receive(:lazy_pip).with("install", '-q', "fake_package")
       @provider.install
     end
 
@@ -253,8 +252,8 @@ describe Puppet::Type.type(:package).provider(:pip) do
       # The -e flag makes the provider non-idempotent
       @resource[:ensure] = :installed
       @resource[:source] = @url
-      @provider.expects(:lazy_pip).with() do |*args|
-        not args.include?("-e")
+      expect(@provider).to receive(:lazy_pip) do |*args|
+        expect(args).not_to include("-e")
       end
       @provider.install
     end
@@ -262,31 +261,28 @@ describe Puppet::Type.type(:package).provider(:pip) do
     it "should install from SCM" do
       @resource[:ensure] = :installed
       @resource[:source] = @url
-      @provider.expects(:lazy_pip).
-        with("install", '-q', "#{@url}#egg=fake_package")
+      expect(@provider).to receive(:lazy_pip).with("install", '-q', "#{@url}#egg=fake_package")
       @provider.install
     end
 
     it "should install a particular SCM revision" do
       @resource[:ensure] = "0123456"
       @resource[:source] = @url
-      @provider.expects(:lazy_pip).
-        with("install", "-q", "#{@url}@0123456#egg=fake_package")
+      expect(@provider).to receive(:lazy_pip).with("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
-      @provider.expects(:lazy_pip).with("install", "-q", "fake_package==0.0.0")
+      expect(@provider).to receive(:lazy_pip).with("install", "-q", "fake_package==0.0.0")
       @provider.install
     end
 
     it "should upgrade" do
       @resource[:ensure] = :latest
       @resource[:source] = nil
-      @provider.expects(:lazy_pip).
-        with("install", "-q", "--upgrade", "fake_package")
+      expect(@provider).to receive(:lazy_pip).with("install", "-q", "--upgrade", "fake_package")
       @provider.install
     end
 
@@ -294,8 +290,7 @@ describe Puppet::Type.type(:package).provider(:pip) do
       @resource[:ensure] = :installed
       @resource[:source] = nil
       @resource[:install_options] = [{"--timeout" => "10"}, "--no-index"]
-      @provider.expects(:lazy_pip).
-        with("install", "-q", "--timeout=10", "--no-index", "fake_package")
+      expect(@provider).to receive(:lazy_pip).with("install", "-q", "--timeout=10", "--no-index", "fake_package")
       @provider.install
     end
   end
@@ -303,30 +298,29 @@ describe Puppet::Type.type(:package).provider(:pip) do
   context "uninstall" do
     it "should uninstall" do
       @resource[:name] = "fake_package"
-      @provider.expects(:lazy_pip).
-        with('uninstall', '-y', '-q', 'fake_package')
+      expect(@provider).to receive(:lazy_pip).with('uninstall', '-y', '-q', 'fake_package')
       @provider.uninstall
     end
   end
 
   context "update" do
     it "should just call install" do
-      @provider.expects(:install).returns(nil)
+      expect(@provider).to receive(:install).and_return(nil)
       @provider.update
     end
   end
 
   context "pip_version" do
     it "should return nil on missing pip" do
-      described_class.stubs(:pip_cmd).returns(nil)
+      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
-      described_class.stubs(:pip_cmd).returns('/fake/bin/pip')
-      p = stub("process")
-      p.expects(:collect).yields('pip 8.0.2 from /usr/local/lib/python2.7/dist-packages (python 2.7)')
-      described_class.expects(:execpipe).with(['/fake/bin/pip', '--version']).yields(p)
+      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')
     end
   end
@@ -337,39 +331,43 @@ describe Puppet::Type.type(:package).provider(:pip) do
     end
 
     it "should succeed if pip is present" do
-      @provider.stubs(:pip).returns(nil)
+      allow(@provider).to receive(:pip).and_return(nil)
       @provider.method(:lazy_pip).call "freeze"
     end
 
     osfamilies.each do |osfamily, pip_cmds|
       pip_cmds.each do |pip_cmd|
         it "should retry on #{osfamily} systems if #{pip_cmd} has not yet been found" do
-          Puppet.features.stubs(:microsoft_windows?).returns (osfamily == 'windows')
-          @provider.expects(:pip).twice.with('freeze').raises(NoMethodError).then.returns(nil)
+          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
-              @provider.expects(:which).with(cmd).returns(nil)
+              expect(@provider).to receive(:which).with(cmd).and_return(nil)
             end
           end
-          @provider.expects(:which).with(pip_cmd).returns("/fake/bin/#{pip_cmd}")
+          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
-        Puppet.features.stubs(:microsoft_windows?).returns (osfamily == 'windows')
-        @provider.expects(:pip).with('freeze').raises(NoMethodError)
+        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|
-          @provider.expects(:which).with(pip_cmd).returns(nil)
+          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
-        Puppet.features.stubs(:microsoft_windows?).returns (osfamily == 'windows')
-        @provider.expects(:pip).with('freeze').raises(NoMethodError)
+        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|
-          @provider.expects(:which).with(pip_cmd).returns(nil)
+          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 ')}.")

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

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 describe Puppet::Type.type(:package).provider(:pkg) do
@@ -14,7 +13,7 @@ describe Puppet::Type.type(:package).provider(:pkg) do
   end
 
   before :each do
-    described_class.stubs(:command).with(:pkg).returns('/bin/pkg')
+    allow(described_class).to receive(:command).with(:pkg).and_return('/bin/pkg')
   end
 
   def self.it_should_respond_to(*actions)
@@ -30,20 +29,20 @@ describe Puppet::Type.type(:package).provider(:pkg) do
   context 'default' do
     [ 10 ].each do |ver|
       it "should not be the default provider on Solaris #{ver}" do
-        Facter.stubs(:value).with(:osfamily).returns(:Solaris)
-        Facter.stubs(:value).with(:kernelrelease).returns("5.#{ver}")
-        Facter.stubs(:value).with(:operatingsystem).returns(:Solaris)
-        Facter.stubs(:value).with(:operatingsystemmajrelease).returns("#{ver}")
+        allow(Facter).to receive(:value).with(:osfamily).and_return(:Solaris)
+        allow(Facter).to receive(:value).with(:kernelrelease).and_return("5.#{ver}")
+        allow(Facter).to receive(:value).with(:operatingsystem).and_return(:Solaris)
+        allow(Facter).to receive(:value).with(:operatingsystemmajrelease).and_return("#{ver}")
         expect(described_class).to_not be_default
       end
     end
 
     [ 11, 12 ].each do |ver|
       it "should be the default provider on Solaris #{ver}" do
-        Facter.stubs(:value).with(:osfamily).returns(:Solaris)
-        Facter.stubs(:value).with(:kernelrelease).returns("5.#{ver}")
-        Facter.stubs(:value).with(:operatingsystem).returns(:Solaris)
-        Facter.stubs(:value).with(:operatingsystemmajrelease).returns("#{ver}")
+        allow(Facter).to receive(:value).with(:osfamily).and_return(:Solaris)
+        allow(Facter).to receive(:value).with(:kernelrelease).and_return("5.#{ver}")
+        allow(Facter).to receive(:value).with(:operatingsystem).and_return(:Solaris)
+        allow(Facter).to receive(:value).with(:operatingsystemmajrelease).and_return("#{ver}")
         expect(described_class).to be_default
       end
     end
@@ -102,61 +101,62 @@ describe Puppet::Type.type(:package).provider(:pkg) do
 
     context ":latest" do
       before do
-        described_class.expects(:pkg).with(:refresh)
+        expect(described_class).to receive(:pkg).with(:refresh)
       end
+
       it "should work correctly for ensure latest on solaris 11 (UFOXI) when there are no further packages to install" do
-        described_class.expects(:pkg).with(:list,'-Hvn','dummy').returns File.read(my_fixture('dummy_solaris11.installed'))
+        expect(described_class).to receive(:pkg).with(:list,'-Hvn','dummy').and_return(File.read(my_fixture('dummy_solaris11.installed')))
         expect(provider.latest).to eq('1.0.6,5.11-0.175.0.0.0.2.537:20131230T130000Z')
       end
 
       it "should work correctly for ensure latest on solaris 11 in the presence of a certificate expiration warning" do
-        described_class.expects(:pkg).with(:list,'-Hvn','dummy').returns File.read(my_fixture('dummy_solaris11.certificate_warning'))
+        expect(described_class).to receive(:pkg).with(:list,'-Hvn','dummy').and_return(File.read(my_fixture('dummy_solaris11.certificate_warning')))
         expect(provider.latest).to eq("1.0.6-0.175.0.0.0.2.537")
       end
 
       it "should work correctly for ensure latest on solaris 11(known UFOXI)" do
-        Puppet::Util::Execution.expects(:execute)
+        expect(Puppet::Util::Execution).to receive(:execute)
           .with(['/bin/pkg', 'update', '-n', 'dummy'], {:failonfail => false, :combine => true})
-          .returns(Puppet::Util::Execution::ProcessOutput.new('', 0))
-        $CHILD_STATUS.stubs(:exitstatus).returns 0
+          .and_return(Puppet::Util::Execution::ProcessOutput.new('', 0))
+        allow($CHILD_STATUS).to receive(:exitstatus).and_return(0)
 
-        described_class.expects(:pkg).with(:list,'-Hvn','dummy').returns File.read(my_fixture('dummy_solaris11.known'))
+        expect(described_class).to receive(:pkg).with(:list,'-Hvn','dummy').and_return(File.read(my_fixture('dummy_solaris11.known')))
         expect(provider.latest).to eq('1.0.6,5.11-0.175.0.0.0.2.537:20131230T130000Z')
       end
 
       it "should work correctly for ensure latest on solaris 11 (IFO)" do
-        described_class.expects(:pkg).with(:list,'-Hvn','dummy').returns File.read(my_fixture('dummy_solaris11.ifo.installed'))
+        expect(described_class).to receive(:pkg).with(:list,'-Hvn','dummy').and_return(File.read(my_fixture('dummy_solaris11.ifo.installed')))
         expect(provider.latest).to eq('1.0.6,5.11-0.175.0.0.0.2.537:20131230T130000Z')
       end
 
       it "should work correctly for ensure latest on solaris 11(known IFO)" do
-        Puppet::Util::Execution.expects(:execute).with(['/bin/pkg', 'update', '-n', 'dummy'], {:failonfail => false, :combine => true}).returns ''
-        $CHILD_STATUS.stubs(:exitstatus).returns 0
+        expect(Puppet::Util::Execution).to receive(:execute).with(['/bin/pkg', 'update', '-n', 'dummy'], {:failonfail => false, :combine => true}).and_return('')
+        allow($CHILD_STATUS).to receive(:exitstatus).and_return(0)
 
-        described_class.expects(:pkg).with(:list,'-Hvn','dummy').returns File.read(my_fixture('dummy_solaris11.ifo.known'))
+        expect(described_class).to receive(:pkg).with(:list,'-Hvn','dummy').and_return(File.read(my_fixture('dummy_solaris11.ifo.known')))
         expect(provider.latest).to eq('1.0.6,5.11-0.175.0.0.0.2.537:20131230T130000Z')
       end
 
       it "issues a warning when the certificate has expired" do
         warning = "Certificate '/var/pkg/ssl/871b4ed0ade09926e6adf95f86bf17535f987684' for publisher 'solarisstudio', needed to access 'https://pkg.oracle.com/solarisstudio/release/', will expire in '29' days."
-        Puppet.expects(:warning).with("pkg warning: #{warning}")
+        expect(Puppet).to receive(:warning).with("pkg warning: #{warning}")
 
-        described_class.expects(:pkg).with(:list,'-Hvn','dummy').returns File.read(my_fixture('dummy_solaris11.certificate_warning'))
+        expect(described_class).to receive(:pkg).with(:list,'-Hvn','dummy').and_return(File.read(my_fixture('dummy_solaris11.certificate_warning')))
         provider.latest
       end
 
       it "doesn't issue a warning when the certificate hasn't expired" do
-        Puppet.expects(:warning).with(/pkg warning/).never
+        expect(Puppet).not_to receive(:warning).with(/pkg warning/)
 
-        described_class.expects(:pkg).with(:list,'-Hvn','dummy').returns File.read(my_fixture('dummy_solaris11.installed'))
+        expect(described_class).to receive(:pkg).with(:list,'-Hvn','dummy').and_return(File.read(my_fixture('dummy_solaris11.installed')))
         provider.latest
       end
     end
 
     context ":instances" do
       it "should correctly parse lines on solaris 11" do
-        described_class.expects(:pkg).with(:list, '-Hv').returns File.read(my_fixture('solaris11'))
-        described_class.expects(:warning).never
+        expect(described_class).to receive(:pkg).with(:list, '-Hv').and_return(File.read(my_fixture('solaris11')))
+        expect(described_class).not_to receive(:warning)
         instances = described_class.instances.map { |p| {:name => p.get(:name), :ensure => p.get(:ensure) }}
         expect(instances.size).to eq(2)
         expect(instances[0]).to eq({:name => 'dummy/dummy', :ensure => '3.0,5.11-0.175.0.0.0.2.537:20131230T130000Z'})
@@ -165,14 +165,14 @@ describe Puppet::Type.type(:package).provider(:pkg) do
 
       it "should fail on incorrect lines" do
         fake_output = File.read(my_fixture('incomplete'))
-        described_class.expects(:pkg).with(:list,'-Hv').returns fake_output
+        expect(described_class).to receive(:pkg).with(:list,'-Hv').and_return(fake_output)
         expect {
           described_class.instances
         }.to raise_error(ArgumentError, /Unknown line format pkg/)
       end
 
       it "should fail on unknown package status" do
-        described_class.expects(:pkg).with(:list,'-Hv').returns File.read(my_fixture('unknown_status'))
+        expect(described_class).to receive(:pkg).with(:list,'-Hv').and_return(File.read(my_fixture('unknown_status')))
         expect {
           described_class.instances
         }.to raise_error(ArgumentError, /Unknown format pkg/)
@@ -182,10 +182,10 @@ describe Puppet::Type.type(:package).provider(:pkg) do
     context ":query" do
       context "on solaris 10" do
         it "should find the package" do
-          Puppet::Util::Execution.expects(:execute)
+          expect(Puppet::Util::Execution).to receive(:execute)
             .with(['/bin/pkg', 'list', '-Hv', 'dummy'], {:failonfail => false, :combine => true})
-            .returns(Puppet::Util::Execution::ProcessOutput.new(File.read(my_fixture('dummy_solaris10')), 0))
-          $CHILD_STATUS.stubs(:exitstatus).returns 0
+            .and_return(Puppet::Util::Execution::ProcessOutput.new(File.read(my_fixture('dummy_solaris10')), 0))
+          allow($CHILD_STATUS).to receive(:exitstatus).and_return(0)
           expect(provider.query).to eq({
             :name      => 'dummy',
             :ensure    => '2.5.5,5.10-0.111:20131230T130000Z',
@@ -196,20 +196,20 @@ describe Puppet::Type.type(:package).provider(:pkg) do
         end
 
         it "should return :absent when the package is not found" do
-          Puppet::Util::Execution.expects(:execute)
+          expect(Puppet::Util::Execution).to receive(:execute)
             .with(['/bin/pkg', 'list', '-Hv', 'dummy'], {:failonfail => false, :combine => true})
-            .returns(Puppet::Util::Execution::ProcessOutput.new('', 0))
-          $CHILD_STATUS.stubs(:exitstatus).returns 1
+            .and_return(Puppet::Util::Execution::ProcessOutput.new('', 0))
+          allow($CHILD_STATUS).to receive(:exitstatus).and_return(1)
           expect(provider.query).to eq({:ensure => :absent, :name => "dummy"})
         end
       end
 
       context "on solaris 11" do
         it "should find the package" do
-          $CHILD_STATUS.stubs(:exitstatus).returns 0
-          Puppet::Util::Execution.expects(:execute)
+          allow($CHILD_STATUS).to receive(:exitstatus).and_return(0)
+          expect(Puppet::Util::Execution).to receive(:execute)
             .with(['/bin/pkg', 'list', '-Hv', 'dummy'], {:failonfail => false, :combine => true})
-            .returns(Puppet::Util::Execution::ProcessOutput.new(File.read(my_fixture('dummy_solaris11.installed')), 0))
+            .and_return(Puppet::Util::Execution::ProcessOutput.new(File.read(my_fixture('dummy_solaris11.installed')), 0))
           expect(provider.query).to eq({
             :name      => 'dummy',
             :status    => 'installed',
@@ -220,20 +220,19 @@ describe Puppet::Type.type(:package).provider(:pkg) do
         end
 
         it "should return :absent when the package is not found" do
-          Puppet::Util::Execution
-            .expects(:execute)
+          expect(Puppet::Util::Execution).to receive(:execute)
             .with(['/bin/pkg', 'list', '-Hv', 'dummy'], {:failonfail => false, :combine => true})
-            .returns(Puppet::Util::Execution::ProcessOutput.new('', 0))
-          $CHILD_STATUS.stubs(:exitstatus).returns 1
+            .and_return(Puppet::Util::Execution::ProcessOutput.new('', 0))
+          allow($CHILD_STATUS).to receive(:exitstatus).and_return(1)
           expect(provider.query).to eq({:ensure => :absent, :name => "dummy"})
         end
       end
 
       it "should return fail when the packageline cannot be parsed" do
-        Puppet::Util::Execution.expects(:execute)
+        expect(Puppet::Util::Execution).to receive(:execute)
           .with(['/bin/pkg', 'list', '-Hv', 'dummy'], {:failonfail => false, :combine => true})
-          .returns(Puppet::Util::Execution::ProcessOutput.new(File.read(my_fixture('incomplete')), 0))
-        $CHILD_STATUS.stubs(:exitstatus).returns 0
+          .and_return(Puppet::Util::Execution::ProcessOutput.new(File.read(my_fixture('incomplete')), 0))
+        allow($CHILD_STATUS).to receive(:exitstatus).and_return(0)
         expect {
           provider.query
         }.to raise_error(ArgumentError, /Unknown line format/)
@@ -247,91 +246,92 @@ describe Puppet::Type.type(:package).provider(:pkg) do
       ].each do |hash|
         context "with :operatingsystemrelease #{hash[:osrel]}" do
           before :each do
-            Facter.stubs(:value).with(:operatingsystemrelease).returns hash[:osrel]
+            allow(Facter).to receive(:value).with(:operatingsystemrelease).and_return(hash[:osrel])
           end
+
           it "should accept all licenses" do
-            provider.expects(:query).with().returns({:ensure => :absent})
-            Puppet::Util::Execution.expects(:execute)
+            expect(provider).to receive(:query).with(no_args).and_return({:ensure => :absent})
+            expect(Puppet::Util::Execution).to receive(:execute)
               .with(['/bin/pkg', 'install', *hash[:flags], 'dummy'], {:failonfail => false, :combine => true})
-              .returns(Puppet::Util::Execution::ProcessOutput.new('', 0))
-            Puppet::Util::Execution.expects(:execute)
+              .and_return(Puppet::Util::Execution::ProcessOutput.new('', 0))
+            expect(Puppet::Util::Execution).to receive(:execute)
               .with(['/bin/pkg', 'unfreeze', 'dummy'], {:failonfail => false, :combine => true})
-              .returns(Puppet::Util::Execution::ProcessOutput.new('', 0))
-            $CHILD_STATUS.stubs(:exitstatus).returns 0
+              .and_return(Puppet::Util::Execution::ProcessOutput.new('', 0))
+            allow($CHILD_STATUS).to receive(:exitstatus).and_return(0)
             provider.install
           end
 
           it "should install specific version(1)" do
             # Should install also check if the version installed is the same version we are asked to install? or should we rely on puppet for that?
             resource[:ensure] = '0.0.7,5.11-0.151006:20131230T130000Z'
-            $CHILD_STATUS.stubs(:exitstatus).returns 0
-            Puppet::Util::Execution.expects(:execute).with(['/bin/pkg', 'unfreeze', 'dummy'], {:failonfail => false, :combine => true})
-            Puppet::Util::Execution.expects(:execute)
+            allow($CHILD_STATUS).to receive(:exitstatus).and_return(0)
+            expect(Puppet::Util::Execution).to receive(:execute).with(['/bin/pkg', 'unfreeze', 'dummy'], {:failonfail => false, :combine => true})
+            expect(Puppet::Util::Execution).to receive(:execute)
               .with(['/bin/pkg', 'list', '-Hv', 'dummy'], {:failonfail => false, :combine => true})
-              .returns(Puppet::Util::Execution::ProcessOutput.new('pkg://foo/dummy@0.0.6,5.11-0.151006:20131230T130000Z  installed -----', 0))
-            Puppet::Util::Execution.expects(:execute)
+              .and_return(Puppet::Util::Execution::ProcessOutput.new('pkg://foo/dummy@0.0.6,5.11-0.151006:20131230T130000Z  installed -----', 0))
+            expect(Puppet::Util::Execution).to receive(:execute)
               .with(['/bin/pkg', 'update', *hash[:flags], 'dummy@0.0.7,5.11-0.151006:20131230T130000Z'], {:failonfail => false, :combine => true})
-              .returns(Puppet::Util::Execution::ProcessOutput.new('', 0))
+              .and_return(Puppet::Util::Execution::ProcessOutput.new('', 0))
             provider.install
           end
 
           it "should install specific version(2)" do
             resource[:ensure] = '0.0.8'
-            Puppet::Util::Execution.expects(:execute).with(['/bin/pkg', 'unfreeze', 'dummy'], {:failonfail => false, :combine => true})
-            Puppet::Util::Execution.expects(:execute)
+            expect(Puppet::Util::Execution).to receive(:execute).with(['/bin/pkg', 'unfreeze', 'dummy'], {:failonfail => false, :combine => true})
+            expect(Puppet::Util::Execution).to receive(:execute)
               .with(['/bin/pkg', 'list', '-Hv', 'dummy'], {:failonfail => false, :combine => true})
-              .returns(Puppet::Util::Execution::ProcessOutput.new('pkg://foo/dummy@0.0.7,5.11-0.151006:20131230T130000Z  installed -----', 0))
-            Puppet::Util::Execution.expects(:execute)
+              .and_return(Puppet::Util::Execution::ProcessOutput.new('pkg://foo/dummy@0.0.7,5.11-0.151006:20131230T130000Z  installed -----', 0))
+            expect(Puppet::Util::Execution).to receive(:execute)
               .with(['/bin/pkg', 'update', *hash[:flags], 'dummy@0.0.8'], {:failonfail => false, :combine => true})
-              .returns(Puppet::Util::Execution::ProcessOutput.new('', 0))
-            $CHILD_STATUS.stubs(:exitstatus).returns 0
+              .and_return(Puppet::Util::Execution::ProcessOutput.new('', 0))
+            allow($CHILD_STATUS).to receive(:exitstatus).and_return(0)
             provider.install
           end
 
           it "should downgrade to specific version" do
             resource[:ensure] = '0.0.7'
-            provider.expects(:query).with().returns({:ensure => '0.0.8,5.11-0.151106:20131230T130000Z'})
-            $CHILD_STATUS.stubs(:exitstatus).returns 0
-            Puppet::Util::Execution.expects(:execute).with(['/bin/pkg', 'unfreeze', 'dummy'], {:failonfail => false, :combine => true})
-            Puppet::Util::Execution.expects(:execute)
+            expect(provider).to receive(:query).with(no_args).and_return({:ensure => '0.0.8,5.11-0.151106:20131230T130000Z'})
+            allow($CHILD_STATUS).to receive(:exitstatus).and_return(0)
+            expect(Puppet::Util::Execution).to receive(:execute).with(['/bin/pkg', 'unfreeze', 'dummy'], {:failonfail => false, :combine => true})
+            expect(Puppet::Util::Execution).to receive(:execute)
               .with(['/bin/pkg', 'update', *hash[:flags], 'dummy@0.0.7'], {:failonfail => false, :combine => true})
-              .returns(Puppet::Util::Execution::ProcessOutput.new('', 0))
+              .and_return(Puppet::Util::Execution::ProcessOutput.new('', 0))
             provider.install
           end
 
           it "should install any if version is not specified" do
             resource[:ensure] = :present
-            provider.expects(:query).with().returns({:ensure => :absent})
-            Puppet::Util::Execution.expects(:execute)
+            expect(provider).to receive(:query).with(no_args).and_return({:ensure => :absent})
+            expect(Puppet::Util::Execution).to receive(:execute)
               .with(['/bin/pkg', 'install', *hash[:flags], 'dummy'], {:failonfail => false, :combine => true})
-              .returns(Puppet::Util::Execution::ProcessOutput.new('', 0))
-            Puppet::Util::Execution.expects(:execute).with(['/bin/pkg', 'unfreeze', 'dummy'], {:failonfail => false, :combine => true})
-            $CHILD_STATUS.stubs(:exitstatus).returns 0
+              .and_return(Puppet::Util::Execution::ProcessOutput.new('', 0))
+            expect(Puppet::Util::Execution).to receive(:execute).with(['/bin/pkg', 'unfreeze', 'dummy'], {:failonfail => false, :combine => true})
+            allow($CHILD_STATUS).to receive(:exitstatus).and_return(0)
             provider.install
           end
 
           it "should install if no version was previously installed, and a specific version was requested" do
             resource[:ensure] = '0.0.7'
-            provider.expects(:query).with().returns({:ensure => :absent})
-            Puppet::Util::Execution.expects(:execute).with(['/bin/pkg', 'unfreeze', 'dummy'], {:failonfail => false, :combine => true})
-            Puppet::Util::Execution.expects(:execute)
+            expect(provider).to receive(:query).with(no_args).and_return({:ensure => :absent})
+            expect(Puppet::Util::Execution).to receive(:execute).with(['/bin/pkg', 'unfreeze', 'dummy'], {:failonfail => false, :combine => true})
+            expect(Puppet::Util::Execution).to receive(:execute)
               .with(['/bin/pkg', 'install', *hash[:flags], 'dummy@0.0.7'], {:failonfail => false, :combine => true})
-              .returns(Puppet::Util::Execution::ProcessOutput.new('', 0))
-            $CHILD_STATUS.stubs(:exitstatus).returns 0
+              .and_return(Puppet::Util::Execution::ProcessOutput.new('', 0))
+            allow($CHILD_STATUS).to receive(:exitstatus).and_return(0)
             provider.install
           end
 
           it "installs the latest matching version when given implicit version, and none are installed" do
             resource[:ensure] = '1.0-0.151006'
             is = :absent
-            provider.expects(:query).with().returns({:ensure => is})
-            described_class.expects(:pkg)
+            expect(provider).to receive(:query).with(no_args).and_return({:ensure => is})
+            expect(described_class).to receive(:pkg)
               .with(:list, '-Hvfa', 'dummy@1.0-0.151006')
-              .returns(Puppet::Util::Execution::ProcessOutput.new(File.read(my_fixture('dummy_implicit_version')), 0))
-            Puppet::Util::Execution.expects(:execute).with(['/bin/pkg', 'install', '-n', 'dummy@1.0,5.11-0.151006:20140220T084443Z'], {:failonfail => false, :combine => true})
-            provider.expects(:unhold).with()
-            Puppet::Util::Execution.expects(:execute).with(['/bin/pkg', 'install', *hash[:flags], 'dummy@1.0,5.11-0.151006:20140220T084443Z'], {:failonfail => false, :combine => true})
-            $CHILD_STATUS.stubs(:exitstatus).returns 0
+              .and_return(Puppet::Util::Execution::ProcessOutput.new(File.read(my_fixture('dummy_implicit_version')), 0))
+            expect(Puppet::Util::Execution).to receive(:execute).with(['/bin/pkg', 'install', '-n', 'dummy@1.0,5.11-0.151006:20140220T084443Z'], {:failonfail => false, :combine => true})
+            expect(provider).to receive(:unhold).with(no_args)
+            expect(Puppet::Util::Execution).to receive(:execute).with(['/bin/pkg', 'install', *hash[:flags], 'dummy@1.0,5.11-0.151006:20140220T084443Z'], {:failonfail => false, :combine => true})
+            allow($CHILD_STATUS).to receive(:exitstatus).and_return(0)
             provider.insync?(is)
             provider.install
           end
@@ -339,12 +339,12 @@ describe Puppet::Type.type(:package).provider(:pkg) do
           it "updates to the latest matching version when given implicit version" do
             resource[:ensure] = '1.0-0.151006'
             is = '1.0,5.11-0.151006:20140219T191204Z'
-            provider.expects(:query).with().returns({:ensure => is})
-            described_class.expects(:pkg).with(:list, '-Hvfa', 'dummy@1.0-0.151006').returns File.read(my_fixture('dummy_implicit_version'))
-            Puppet::Util::Execution.expects(:execute).with(['/bin/pkg', 'update', '-n', 'dummy@1.0,5.11-0.151006:20140220T084443Z'], {:failonfail => false, :combine => true})
-            provider.expects(:unhold).with()
-            Puppet::Util::Execution.expects(:execute).with(['/bin/pkg', 'update', *hash[:flags], 'dummy@1.0,5.11-0.151006:20140220T084443Z'], {:failonfail => false, :combine => true})
-            $CHILD_STATUS.stubs(:exitstatus).returns 0
+            expect(provider).to receive(:query).with(no_args).and_return({:ensure => is})
+            expect(described_class).to receive(:pkg).with(:list, '-Hvfa', 'dummy@1.0-0.151006').and_return(File.read(my_fixture('dummy_implicit_version')))
+            expect(Puppet::Util::Execution).to receive(:execute).with(['/bin/pkg', 'update', '-n', 'dummy@1.0,5.11-0.151006:20140220T084443Z'], {:failonfail => false, :combine => true})
+            expect(provider).to receive(:unhold).with(no_args)
+            expect(Puppet::Util::Execution).to receive(:execute).with(['/bin/pkg', 'update', *hash[:flags], 'dummy@1.0,5.11-0.151006:20140220T084443Z'], {:failonfail => false, :combine => true})
+            allow($CHILD_STATUS).to receive(:exitstatus).and_return(0)
             provider.insync?(is)
             provider.install
           end
@@ -352,23 +352,23 @@ describe Puppet::Type.type(:package).provider(:pkg) do
           it "issues a warning when an implicit version number is used, and in sync" do
             resource[:ensure] = '1.0-0.151006'
             is = '1.0,5.11-0.151006:20140220T084443Z'
-            provider.expects(:warning).with("Implicit version 1.0-0.151006 has 3 possible matches")
-            described_class.expects(:pkg)
+            expect(provider).to receive(:warning).with("Implicit version 1.0-0.151006 has 3 possible matches")
+            expect(described_class).to receive(:pkg)
               .with(:list, '-Hvfa', 'dummy@1.0-0.151006')
-              .returns(Puppet::Util::Execution::ProcessOutput.new(File.read(my_fixture('dummy_implicit_version')), 0))
-            Puppet::Util::Execution.expects(:execute).with(['/bin/pkg', 'update', '-n', 'dummy@1.0,5.11-0.151006:20140220T084443Z'], {:failonfail => false, :combine => true})
-            $CHILD_STATUS.stubs(:exitstatus).returns 4
+              .and_return(Puppet::Util::Execution::ProcessOutput.new(File.read(my_fixture('dummy_implicit_version')), 0))
+            expect(Puppet::Util::Execution).to receive(:execute).with(['/bin/pkg', 'update', '-n', 'dummy@1.0,5.11-0.151006:20140220T084443Z'], {:failonfail => false, :combine => true})
+            allow($CHILD_STATUS).to receive(:exitstatus).and_return(4)
             provider.insync?(is)
           end
 
           it "issues a warning when choosing a version number for an implicit match" do
             resource[:ensure] = '1.0-0.151006'
             is = :absent
-            provider.expects(:warning).with("Implicit version 1.0-0.151006 has 3 possible matches")
-            provider.expects(:warning).with("Selecting version '1.0,5.11-0.151006:20140220T084443Z' for implicit '1.0-0.151006'")
-            described_class.expects(:pkg).with(:list, '-Hvfa', 'dummy@1.0-0.151006').returns File.read(my_fixture('dummy_implicit_version'))
-            Puppet::Util::Execution.expects(:execute).with(['/bin/pkg', 'install', '-n', 'dummy@1.0,5.11-0.151006:20140220T084443Z'], {:failonfail => false, :combine => true})
-            $CHILD_STATUS.stubs(:exitstatus).returns 0
+            expect(provider).to receive(:warning).with("Implicit version 1.0-0.151006 has 3 possible matches")
+            expect(provider).to receive(:warning).with("Selecting version '1.0,5.11-0.151006:20140220T084443Z' for implicit '1.0-0.151006'")
+            expect(described_class).to receive(:pkg).with(:list, '-Hvfa', 'dummy@1.0-0.151006').and_return(File.read(my_fixture('dummy_implicit_version')))
+            expect(Puppet::Util::Execution).to receive(:execute).with(['/bin/pkg', 'install', '-n', 'dummy@1.0,5.11-0.151006:20140220T084443Z'], {:failonfail => false, :combine => true})
+            allow($CHILD_STATUS).to receive(:exitstatus).and_return(0)
             provider.insync?(is)
           end
         end
@@ -377,17 +377,17 @@ describe Puppet::Type.type(:package).provider(:pkg) do
 
     context ":update" do
       it "should not raise error if not necessary" do
-        provider.expects(:install).with(true).returns({:exit => 0})
+        expect(provider).to receive(:install).with(true).and_return({:exit => 0})
         provider.update
       end
 
       it "should not raise error if not necessary (2)" do
-        provider.expects(:install).with(true).returns({:exit => 4})
+        expect(provider).to receive(:install).with(true).and_return({:exit => 4})
         provider.update
       end
 
       it "should raise error if necessary" do
-        provider.expects(:install).with(true).returns({:exit => 1})
+        expect(provider).to receive(:install).with(true).and_return({:exit => 1})
         expect {
           provider.update
         }.to raise_error(Puppet::Error, /Unable to update/)
@@ -396,14 +396,14 @@ describe Puppet::Type.type(:package).provider(:pkg) do
 
     context ":uninstall" do
       it "should support current pkg version" do
-        described_class.expects(:pkg).with(:version).returns('630e1ffc7a19')
-        described_class.expects(:pkg).with([:uninstall, resource[:name]])
+        expect(described_class).to receive(:pkg).with(:version).and_return('630e1ffc7a19')
+        expect(described_class).to receive(:pkg).with([:uninstall, resource[:name]])
         provider.uninstall
       end
 
       it "should support original pkg commands" do
-        described_class.expects(:pkg).with(:version).returns('052adf36c3f4')
-        described_class.expects(:pkg).with([:uninstall, '-r', resource[:name]])
+        expect(described_class).to receive(:pkg).with(:version).and_return('052adf36c3f4')
+        expect(described_class).to receive(:pkg).with([:uninstall, '-r', resource[:name]])
         provider.uninstall
       end
     end