puppet 6.0.10-universal-darwin → 6.1.0-universal-darwin

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

@@ -7,7 +7,6 @@ describe Puppet::Type.type(:package).provider(:pip3) do
   it { is_expected.to be_upgradeable }
   it { is_expected.to be_versionable }
   it { is_expected.to be_install_options }
-  it { is_expected.to be_targetable }
 
   it "should inherit most things from pip provider" do
     expect(described_class < Puppet::Type.type(:package).provider(:pip))
@@ -17,20 +16,4 @@ describe Puppet::Type.type(:package).provider(:pip3) do
     expect(described_class.cmd).to eq(["pip3"])
   end
 
-  context 'calculated specificity' do
-    context 'when is not defaultfor' do
-      subject { described_class.specificity }
-      it { is_expected.to eql 1 }
-    end
-
-    context 'when is defaultfor' do
-      let(:os) {  Facter.value(:operatingsystem) }
-      subject do
-        described_class.defaultfor(operatingsystem: os)
-        described_class.specificity
-      end
-      it { is_expected.to be > 100 }
-    end
-  end
-
 end

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

@@ -3,21 +3,12 @@ require 'spec_helper'
 osfamilies = { 'windows' => ['pip.exe'], 'other' => ['pip', 'pip-python'] }
 
 describe Puppet::Type.type(:package).provider(:pip) do
-
-  it { is_expected.to be_installable }
-  it { is_expected.to be_uninstallable }
-  it { is_expected.to be_upgradeable }
-  it { is_expected.to be_versionable }
-  it { is_expected.to be_install_options }
-  it { is_expected.to be_targetable }
-
-  before do
+  before do  
     @resource = Puppet::Resource.new(:package, "fake_package")
-    allow(@resource).to receive(:original_parameters).and_return({})
     @provider = described_class.new(@resource)
-    @client = double('client')
-    allow(@client).to receive(:call).with('package_releases', 'real_package').and_return(["1.3", "1.2.5", "1.2.4"])
-    allow(@client).to receive(:call).with('package_releases', 'fake_package').and_return([])
+    @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([])
   end
 
   context "parse" do
@@ -36,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
-      allow(Puppet::Util::Platform).to receive(:windows?).and_return(true)
+      Puppet::Util::Platform.stubs(:windows?).returns true
       expect(described_class.cmd[0]).to eq('pip.exe')
     end
 
     it "could return pip-python on legacy redhat systems which rename pip" do
-      allow(Puppet::Util::Platform).to receive(:windows?).and_return(false)
+      Puppet::Util::Platform.stubs(:windows?).returns false
       expect(described_class.cmd[1]).to eq('pip-python')
     end
 
     it "should return pip by default on other systems" do
-      allow(Puppet::Util::Platform).to receive(:windows?).and_return(false)
+      Puppet::Util::Platform.stubs(:windows?).returns false
       expect(described_class.cmd[0]).to eq('pip')
     end
   end
@@ -54,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
-        allow(Puppet::Util::Platform).to receive(:windows?).and_return(osfamily == 'windows')
+        Puppet::Util::Platform.stubs(:windows?).returns (osfamily == 'windows')
         pip_cmds.each do |pip_cmd|
           pip_cmds.each do |cmd|
             unless cmd == pip_cmd
-              expect(described_class).to receive(:which).with(cmd).and_return(nil)
+              described_class.expects(:which).with(cmd).returns(nil)
             end
           end
-          allow(described_class).to receive(:pip_version).with(pip_cmd).and_return('8.0.1')
-          expect(described_class).to receive(:which).with(pip_cmd).and_return(pip_cmd)
-          p = double("process")
-          expect(p).to receive(:collect).and_yield("real_package==1.2.5")
-          expect(described_class).to receive(:execpipe).with([pip_cmd, ["freeze"]]).and_yield(p)
+          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)
           described_class.instances
         end
       end
@@ -74,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
-            allow(Puppet::Util::Platform).to receive(:windows?).and_return(osfamily == 'windows')
-            allow(described_class).to receive(:provider_command).and_return('/fake/bin/pip')
-            allow(described_class).to receive(:pip_version).with('/fake/bin/pip').and_return(version)
-            p = double("process")
-            expect(p).to receive(:collect).and_yield("real_package==1.2.5")
-            expect(described_class).to receive(:execpipe).with(["/fake/bin/pip", ["freeze", "--all"]]).and_yield(p)
+            Puppet::Util::Platform.stubs(: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)
             described_class.instances
           end
         end
       end
 
       it "should return an empty array on #{osfamily} systems when #{pip_cmds.join(' and ')} are missing" do
-        allow(Puppet::Util::Platform).to receive(:windows?).and_return(osfamily == 'windows')
+        Puppet::Util::Platform.stubs(:windows?).returns (osfamily == 'windows')
         pip_cmds.each do |cmd|
-          expect(described_class).to receive(:which).with(cmd).and_return(nil)
+          described_class.expects(:which).with(cmd).returns nil
         end
         expect(described_class.instances).to eq([])
       end
@@ -98,46 +89,40 @@ describe Puppet::Type.type(:package).provider(:pip) do
   context "query" do
     before do
       @resource[:name] = "real_package"
-      allow(described_class).to receive(:provider_command).and_return('/fake/bin/pip')
-      allow(described_class).to receive(:validate_command).with('/fake/bin/pip')
     end
 
     it "should return a hash when pip and the package are present" do
-      expect(described_class).to receive(:instances).and_return([described_class.new({
+      described_class.expects(:instances).returns [described_class.new({
         :ensure   => "1.2.5",
         :name     => "real_package",
         :provider => :pip,
-        :command  => '/fake/bin/pip',
-      })])
+      })]
 
       expect(@provider.query).to eq({
         :ensure   => "1.2.5",
         :name     => "real_package",
         :provider => :pip,
-        :command  => '/fake/bin/pip',
       })
     end
 
     it "should return nil when the package is missing" do
-      expect(described_class).to receive(:instances).and_return([])
+      described_class.expects(:instances).returns []
       expect(@provider.query).to eq(nil)
     end
 
     it "should be case insensitive" do
       @resource[:name] = "Real_Package"
 
-      expect(described_class).to receive(:instances).and_return([described_class.new({
+      described_class.expects(:instances).returns [described_class.new({
         :ensure   => "1.2.5",
         :name     => "real_package",
         :provider => :pip,
-        :command  => '/fake/bin/pip',
-      })])
+      })]
 
       expect(@provider.query).to eq({
         :ensure   => "1.2.5",
         :name     => "real_package",
         :provider => :pip,
-        :command  => '/fake/bin/pip',
       })
     end
   end
@@ -145,12 +130,10 @@ describe Puppet::Type.type(:package).provider(:pip) do
   context "latest" do
     context "with pip version < 1.5.4" do
       before :each do
-        allow(described_class).to receive(:pip_version).with("/fake/bin/pip").and_return('1.0.1')
-        allow(described_class).to receive(:which).with('pip').and_return("/fake/bin/pip")
-        allow(described_class).to receive(:which).with('pip-python').and_return("/fake/bin/pip")
-        allow(described_class).to receive(:which).with('pip.exe').and_return("/fake/bin/pip")
-        allow(described_class).to receive(:provider_command).and_return('/fake/bin/pip')
-        allow(described_class).to receive(:validate_command).with('/fake/bin/pip')
+        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")
       end
 
       it "should find a version number for new_pip_package" do
@@ -163,7 +146,7 @@ describe Puppet::Type.type(:package).provider(:pip) do
           Successfully downloaded real-package
           EOS
         )
-        expect(Puppet::Util::Execution).to receive(:execpipe).and_yield(p).once
+        Puppet::Util::Execution.expects(:execpipe).yields(p).once
         @resource[:name] = "real_package"
         expect(@provider.latest).to eq('0.10.1')
       end
@@ -193,7 +176,7 @@ describe Puppet::Type.type(:package).provider(:pip) do
           Storing complete log in /root/.pip/pip.log
           EOS
         )
-        expect(Puppet::Util::Execution).to receive(:execpipe).and_yield(p).once
+        Puppet::Util::Execution.expects(:execpipe).yields(p).once
         @resource[:name] = "fake_package"
         expect(@provider.latest).to eq(nil)
       end
@@ -203,12 +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
-        allow(described_class).to receive(:pip_version).with("/fake/bin/pip").and_return('1.5.4')
-        allow(described_class).to receive(:which).with('pip').and_return("/fake/bin/pip")
-        allow(described_class).to receive(:which).with('pip-python').and_return("/fake/bin/pip")
-        allow(described_class).to receive(:which).with('pip.exe').and_return("/fake/bin/pip")
-        allow(described_class).to receive(:provider_command).and_return('/fake/bin/pip')
-        allow(described_class).to receive(:validate_command).with('/fake/bin/pip')
+        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")
       end
 
       it "should find a version number for real_package" do
@@ -219,7 +200,7 @@ describe Puppet::Type.type(:package).provider(:pip) do
           No matching distribution found for real-package==versionplease
           EOS
         )
-        expect(Puppet::Util::Execution).to receive(:execpipe).with(["/fake/bin/pip", "install", "real_package==versionplease"]).and_yield(p).once
+        Puppet::Util::Execution.expects(:execpipe).with(["/fake/bin/pip", "install", "real_package==versionplease"]).yields(p).once
         @resource[:name] = "real_package"
         latest = @provider.latest
         expect(latest).to eq('1.9b1')
@@ -233,7 +214,7 @@ describe Puppet::Type.type(:package).provider(:pip) do
           No matching distribution found for fake-package==versionplease
           EOS
         )
-        expect(Puppet::Util::Execution).to receive(:execpipe).with(["/fake/bin/pip", "install", "fake_package==versionplease"]).and_yield(p).once
+        Puppet::Util::Execution.expects(:execpipe).with(["/fake/bin/pip", "install", "fake_package==versionplease"]).yields(p).once
         @resource[:name] = "fake_package"
         expect(@provider.latest).to eq(nil)
       end
@@ -246,7 +227,7 @@ describe Puppet::Type.type(:package).provider(:pip) do
           No distributions matching the version for real-package==versionplease
           EOS
         )
-        expect(Puppet::Util::Execution).to receive(:execpipe).with(["/fake/bin/pip", "install", "real_package==versionplease"]).and_yield(p).once
+        Puppet::Util::Execution.expects(:execpipe).with(["/fake/bin/pip", "install", "real_package==versionplease"]).yields(p).once
         @resource[:name] = "real_package"
         latest = @provider.latest
         expect(latest).to eq('15.0.2')
@@ -258,14 +239,13 @@ describe Puppet::Type.type(:package).provider(:pip) do
     before do
       @resource[:name] = "fake_package"
       @url = "git+https://example.com/fake_package.git"
-      allow(described_class).to receive(:provider_command).and_return('/fake/bin/pip')
-      allow(described_class).to receive(:validate_command).with('/fake/bin/pip')
     end
 
     it "should install" do
       @resource[:ensure] = :installed
       @resource[:source] = nil
-      expect(@provider).to receive(:execute).with(["/fake/bin/pip", ["install", "-q", "fake_package"]])
+      @provider.expects(:lazy_pip).
+        with("install", '-q', "fake_package")
       @provider.install
     end
 
@@ -273,9 +253,8 @@ describe Puppet::Type.type(:package).provider(:pip) do
       # The -e flag makes the provider non-idempotent
       @resource[:ensure] = :installed
       @resource[:source] = @url
-      # TJK
-      expect(@provider).to receive(:execute) do |*args|
-        expect(args).not_to include("-e")
+      @provider.expects(:lazy_pip).with() do |*args|
+        not args.include?("-e")
       end
       @provider.install
     end
@@ -283,31 +262,31 @@ describe Puppet::Type.type(:package).provider(:pip) do
     it "should install from SCM" do
       @resource[:ensure] = :installed
       @resource[:source] = @url
-      expect(@provider).to receive(:execute).with(["/fake/bin/pip", ["install", "-q", "#{@url}#egg=fake_package"]])
+      @provider.expects(: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
-      # TJK
-      expect(@provider).to receive(:execute).with(["/fake/bin/pip", ["install", "-q", "#{@url}@0123456#egg=fake_package"]])
+      @provider.expects(: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
-      # TJK
-      expect(@provider).to receive(:execute).with(["/fake/bin/pip", ["install", "-q", "fake_package==0.0.0"]])
+      @provider.expects(:lazy_pip).with("install", "-q", "fake_package==0.0.0")
       @provider.install
     end
 
     it "should upgrade" do
       @resource[:ensure] = :latest
       @resource[:source] = nil
-      # TJK
-      expect(@provider).to receive(:execute).with(["/fake/bin/pip", ["install", "-q", "--upgrade", "fake_package"]])
+      @provider.expects(:lazy_pip).
+        with("install", "-q", "--upgrade", "fake_package")
       @provider.install
     end
 
@@ -315,54 +294,86 @@ describe Puppet::Type.type(:package).provider(:pip) do
       @resource[:ensure] = :installed
       @resource[:source] = nil
       @resource[:install_options] = [{"--timeout" => "10"}, "--no-index"]
-      expect(@provider).to receive(:execute).with(["/fake/bin/pip", ["install", "-q", "--timeout=10", "--no-index", "fake_package"]])
+      @provider.expects(:lazy_pip).
+        with("install", "-q", "--timeout=10", "--no-index", "fake_package")
       @provider.install
     end
   end
 
   context "uninstall" do
-    before do
-      allow(described_class).to receive(:provider_command).and_return('/fake/bin/pip')
-      allow(described_class).to receive(:validate_command).with('/fake/bin/pip')
-    end
-
     it "should uninstall" do
       @resource[:name] = "fake_package"
-      expect(@provider).to receive(:execute).with(["/fake/bin/pip", ["uninstall", "-y", "-q", "fake_package"]])
+      @provider.expects(:lazy_pip).
+        with('uninstall', '-y', '-q', 'fake_package')
       @provider.uninstall
     end
   end
 
   context "update" do
     it "should just call install" do
-      expect(@provider).to receive(:install).and_return(nil)
+      @provider.expects(:install).returns(nil)
       @provider.update
     end
   end
 
   context "pip_version" do
+    it "should return nil on missing pip" do
+      described_class.stubs(:pip_cmd).returns(nil)
+      expect(described_class.pip_version).to eq(nil)
+    end
+
     it "should look up version if pip is present" do
-      allow(described_class).to receive(:pip_cmd).and_return('/fake/bin/pip')
-      p = double("process")
-      expect(p).to receive(:collect).and_yield('pip 8.0.2 from /usr/local/lib/python2.7/dist-packages (python 2.7)')
-      expect(described_class).to receive(:execpipe).with(['/fake/bin/pip', '--version']).and_yield(p)
-      expect(described_class.pip_version('/fake/bin/pip')).to eq('8.0.2')
+      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)
+      expect(described_class.pip_version).to eq('8.0.2')
     end
   end
 
-  context 'calculated specificity' do
-    context 'when is not defaultfor' do
-      subject { described_class.specificity }
-      it { is_expected.to eql 1 }
+  context "lazy_pip" do
+    after(:each) do
+      Puppet::Type::Package::ProviderPip.instance_variable_set(:@confine_collection, nil)
+    end
+
+    it "should succeed if pip is present" do
+      @provider.stubs(:pip).returns(nil)
+      @provider.method(:lazy_pip).call "freeze"
     end
 
-    context 'when is defaultfor' do
-      let(:os) {  Facter.value(:operatingsystem) }
-      subject do
-        described_class.defaultfor(operatingsystem: os)
-        described_class.specificity
+    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::Util::Platform.stubs(:windows?).returns (osfamily == 'windows')
+          @provider.expects(:pip).twice.with('freeze').raises(NoMethodError).then.returns(nil)
+          pip_cmds.each do |cmd|
+            unless cmd == pip_cmd
+              @provider.expects(:which).with(cmd).returns(nil)
+            end
+          end
+          @provider.expects(:which).with(pip_cmd).returns("/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::Util::Platform.stubs(:windows?).returns (osfamily == 'windows')
+        @provider.expects(:pip).with('freeze').raises(NoMethodError)
+        pip_cmds.each do |pip_cmd|
+          @provider.expects(:which).with(pip_cmd).returns(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::Util::Platform.stubs(:windows?).returns (osfamily == 'windows')
+        @provider.expects(:pip).with('freeze').raises(NoMethodError)
+        pip_cmds.each do |pip_cmd|
+          @provider.expects(:which).with(pip_cmd).returns(nil)
+        end
+        expect { @provider.method(:lazy_pip).call("freeze") }.
+          to raise_error(NoMethodError, "Could not locate command #{pip_cmds.join(' and ')}.")
       end
-      it { is_expected.to be > 100 }
     end
   end
 end

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

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 describe Puppet::Type.type(:package).provider(:pkg), unless: Puppet::Util::Platform.jruby? do
@@ -15,7 +16,7 @@ describe Puppet::Type.type(:package).provider(:pkg), unless: Puppet::Util::Platf
   end
 
   before :each do
-    allow(described_class).to receive(:command).with(:pkg).and_return('/bin/pkg')
+    described_class.stubs(:command).with(:pkg).returns('/bin/pkg')
   end
 
   def self.it_should_respond_to(*actions)
@@ -31,20 +32,20 @@ describe Puppet::Type.type(:package).provider(:pkg), unless: Puppet::Util::Platf
   context 'default' do
     [ 10 ].each do |ver|
       it "should not be the default provider on Solaris #{ver}" do
-        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}")
+        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}")
         expect(described_class).to_not be_default
       end
     end
 
     [ 11, 12 ].each do |ver|
       it "should be the default provider on Solaris #{ver}" do
-        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}")
+        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}")
         expect(described_class).to be_default
       end
     end
@@ -103,62 +104,61 @@ describe Puppet::Type.type(:package).provider(:pkg), unless: Puppet::Util::Platf
 
     context ":latest" do
       before do
-        expect(described_class).to receive(:pkg).with(:refresh)
+        described_class.expects(:pkg).with(:refresh)
       end
-
       it "should work correctly for ensure latest on solaris 11 (UFOXI) when there are no further packages to install" do
-        expect(described_class).to receive(:pkg).with(:list,'-Hvn','dummy').and_return(File.read(my_fixture('dummy_solaris11.installed')))
+        described_class.expects(:pkg).with(:list,'-Hvn','dummy').returns 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
-        expect(described_class).to receive(:pkg).with(:list,'-Hvn','dummy').and_return(File.read(my_fixture('dummy_solaris11.certificate_warning')))
+        described_class.expects(:pkg).with(:list,'-Hvn','dummy').returns 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
-        expect(Puppet::Util::Execution).to receive(:execute)
+        Puppet::Util::Execution.expects(:execute)
           .with(['/bin/pkg', 'update', '-n', 'dummy'], {:failonfail => false, :combine => true})
-          .and_return(Puppet::Util::Execution::ProcessOutput.new('', 0))
-        allow($CHILD_STATUS).to receive(:exitstatus).and_return(0)
+          .returns(Puppet::Util::Execution::ProcessOutput.new('', 0))
+        $CHILD_STATUS.stubs(:exitstatus).returns 0
 
-        expect(described_class).to receive(:pkg).with(:list,'-Hvn','dummy').and_return(File.read(my_fixture('dummy_solaris11.known')))
+        described_class.expects(:pkg).with(:list,'-Hvn','dummy').returns 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
-        expect(described_class).to receive(:pkg).with(:list,'-Hvn','dummy').and_return(File.read(my_fixture('dummy_solaris11.ifo.installed')))
+        described_class.expects(:pkg).with(:list,'-Hvn','dummy').returns 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
-        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)
+        Puppet::Util::Execution.expects(:execute).with(['/bin/pkg', 'update', '-n', 'dummy'], {:failonfail => false, :combine => true}).returns ''
+        $CHILD_STATUS.stubs(:exitstatus).returns 0
 
-        expect(described_class).to receive(:pkg).with(:list,'-Hvn','dummy').and_return(File.read(my_fixture('dummy_solaris11.ifo.known')))
+        described_class.expects(:pkg).with(:list,'-Hvn','dummy').returns 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."
-        expect(Puppet).to receive(:warning).with("pkg warning: #{warning}")
+        Puppet.expects(:warning).with("pkg warning: #{warning}")
 
-        expect(described_class).to receive(:pkg).with(:list,'-Hvn','dummy').and_return(File.read(my_fixture('dummy_solaris11.certificate_warning')))
+        described_class.expects(:pkg).with(:list,'-Hvn','dummy').returns File.read(my_fixture('dummy_solaris11.certificate_warning'))
         provider.latest
       end
 
       it "doesn't issue a warning when the certificate hasn't expired" do
-        expect(Puppet).not_to receive(:warning).with(/pkg warning/)
+        Puppet.expects(:warning).with(/pkg warning/).never
 
-        expect(described_class).to receive(:pkg).with(:list,'-Hvn','dummy').and_return(File.read(my_fixture('dummy_solaris11.installed')))
+        described_class.expects(:pkg).with(:list,'-Hvn','dummy').returns File.read(my_fixture('dummy_solaris11.installed'))
         provider.latest
       end
     end
 
     context ":instances" do
       it "should correctly parse lines on solaris 11" do
-        expect(described_class).to receive(:pkg).with(:list, '-Hv').and_return(File.read(my_fixture('solaris11')))
-        expect(described_class).not_to receive(:warning)
+        described_class.expects(:pkg).with(:list, '-Hv').returns File.read(my_fixture('solaris11'))
+        described_class.expects(:warning).never
         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'})
@@ -167,14 +167,14 @@ describe Puppet::Type.type(:package).provider(:pkg), unless: Puppet::Util::Platf
 
       it "should fail on incorrect lines" do
         fake_output = File.read(my_fixture('incomplete'))
-        expect(described_class).to receive(:pkg).with(:list,'-Hv').and_return(fake_output)
+        described_class.expects(:pkg).with(:list,'-Hv').returns fake_output
         expect {
           described_class.instances
         }.to raise_error(ArgumentError, /Unknown line format pkg/)
       end
 
       it "should fail on unknown package status" do
-        expect(described_class).to receive(:pkg).with(:list,'-Hv').and_return(File.read(my_fixture('unknown_status')))
+        described_class.expects(:pkg).with(:list,'-Hv').returns File.read(my_fixture('unknown_status'))
         expect {
           described_class.instances
         }.to raise_error(ArgumentError, /Unknown format pkg/)
@@ -184,10 +184,10 @@ describe Puppet::Type.type(:package).provider(:pkg), unless: Puppet::Util::Platf
     context ":query" do
       context "on solaris 10" do
         it "should find the package" do
-          expect(Puppet::Util::Execution).to receive(:execute)
+          Puppet::Util::Execution.expects(:execute)
             .with(['/bin/pkg', 'list', '-Hv', 'dummy'], {:failonfail => false, :combine => true})
-            .and_return(Puppet::Util::Execution::ProcessOutput.new(File.read(my_fixture('dummy_solaris10')), 0))
-          allow($CHILD_STATUS).to receive(:exitstatus).and_return(0)
+            .returns(Puppet::Util::Execution::ProcessOutput.new(File.read(my_fixture('dummy_solaris10')), 0))
+          $CHILD_STATUS.stubs(:exitstatus).returns 0
           expect(provider.query).to eq({
             :name      => 'dummy',
             :ensure    => '2.5.5,5.10-0.111:20131230T130000Z',
@@ -198,20 +198,20 @@ describe Puppet::Type.type(:package).provider(:pkg), unless: Puppet::Util::Platf
         end
 
         it "should return :absent when the package is not found" do
-          expect(Puppet::Util::Execution).to receive(:execute)
+          Puppet::Util::Execution.expects(:execute)
             .with(['/bin/pkg', 'list', '-Hv', 'dummy'], {:failonfail => false, :combine => true})
-            .and_return(Puppet::Util::Execution::ProcessOutput.new('', 0))
-          allow($CHILD_STATUS).to receive(:exitstatus).and_return(1)
+            .returns(Puppet::Util::Execution::ProcessOutput.new('', 0))
+          $CHILD_STATUS.stubs(:exitstatus).returns 1
           expect(provider.query).to eq({:ensure => :absent, :name => "dummy"})
         end
       end
 
       context "on solaris 11" do
         it "should find the package" do
-          allow($CHILD_STATUS).to receive(:exitstatus).and_return(0)
-          expect(Puppet::Util::Execution).to receive(:execute)
+          $CHILD_STATUS.stubs(:exitstatus).returns 0
+          Puppet::Util::Execution.expects(:execute)
             .with(['/bin/pkg', 'list', '-Hv', 'dummy'], {:failonfail => false, :combine => true})
-            .and_return(Puppet::Util::Execution::ProcessOutput.new(File.read(my_fixture('dummy_solaris11.installed')), 0))
+            .returns(Puppet::Util::Execution::ProcessOutput.new(File.read(my_fixture('dummy_solaris11.installed')), 0))
           expect(provider.query).to eq({
             :name      => 'dummy',
             :status    => 'installed',
@@ -222,19 +222,20 @@ describe Puppet::Type.type(:package).provider(:pkg), unless: Puppet::Util::Platf
         end
 
         it "should return :absent when the package is not found" do
-          expect(Puppet::Util::Execution).to receive(:execute)
+          Puppet::Util::Execution
+            .expects(:execute)
             .with(['/bin/pkg', 'list', '-Hv', 'dummy'], {:failonfail => false, :combine => true})
-            .and_return(Puppet::Util::Execution::ProcessOutput.new('', 0))
-          allow($CHILD_STATUS).to receive(:exitstatus).and_return(1)
+            .returns(Puppet::Util::Execution::ProcessOutput.new('', 0))
+          $CHILD_STATUS.stubs(:exitstatus).returns 1
           expect(provider.query).to eq({:ensure => :absent, :name => "dummy"})
         end
       end
 
       it "should return fail when the packageline cannot be parsed" do
-        expect(Puppet::Util::Execution).to receive(:execute)
+        Puppet::Util::Execution.expects(:execute)
           .with(['/bin/pkg', 'list', '-Hv', 'dummy'], {:failonfail => false, :combine => true})
-          .and_return(Puppet::Util::Execution::ProcessOutput.new(File.read(my_fixture('incomplete')), 0))
-        allow($CHILD_STATUS).to receive(:exitstatus).and_return(0)
+          .returns(Puppet::Util::Execution::ProcessOutput.new(File.read(my_fixture('incomplete')), 0))
+        $CHILD_STATUS.stubs(:exitstatus).returns 0
         expect {
           provider.query
         }.to raise_error(ArgumentError, /Unknown line format/)
@@ -248,92 +249,91 @@ describe Puppet::Type.type(:package).provider(:pkg), unless: Puppet::Util::Platf
       ].each do |hash|
         context "with :operatingsystemrelease #{hash[:osrel]}" do
           before :each do
-            allow(Facter).to receive(:value).with(:operatingsystemrelease).and_return(hash[:osrel])
+            Facter.stubs(:value).with(:operatingsystemrelease).returns hash[:osrel]
           end
-
           it "should accept all licenses" do
-            expect(provider).to receive(:query).with(no_args).and_return({:ensure => :absent})
-            expect(Puppet::Util::Execution).to receive(:execute)
+            provider.expects(:query).with().returns({:ensure => :absent})
+            Puppet::Util::Execution.expects(:execute)
               .with(['/bin/pkg', 'install', *hash[:flags], 'dummy'], {:failonfail => false, :combine => true})
-              .and_return(Puppet::Util::Execution::ProcessOutput.new('', 0))
-            expect(Puppet::Util::Execution).to receive(:execute)
+              .returns(Puppet::Util::Execution::ProcessOutput.new('', 0))
+            Puppet::Util::Execution.expects(:execute)
               .with(['/bin/pkg', 'unfreeze', 'dummy'], {:failonfail => false, :combine => true})
-              .and_return(Puppet::Util::Execution::ProcessOutput.new('', 0))
-            allow($CHILD_STATUS).to receive(:exitstatus).and_return(0)
+              .returns(Puppet::Util::Execution::ProcessOutput.new('', 0))
+            $CHILD_STATUS.stubs(:exitstatus).returns 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'
-            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)
+            $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)
               .with(['/bin/pkg', 'list', '-Hv', 'dummy'], {:failonfail => false, :combine => true})
-              .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)
+              .returns(Puppet::Util::Execution::ProcessOutput.new('pkg://foo/dummy@0.0.6,5.11-0.151006:20131230T130000Z  installed -----', 0))
+            Puppet::Util::Execution.expects(:execute)
               .with(['/bin/pkg', 'update', *hash[:flags], 'dummy@0.0.7,5.11-0.151006:20131230T130000Z'], {:failonfail => false, :combine => true})
-              .and_return(Puppet::Util::Execution::ProcessOutput.new('', 0))
+              .returns(Puppet::Util::Execution::ProcessOutput.new('', 0))
             provider.install
           end
 
           it "should install specific version(2)" do
             resource[:ensure] = '0.0.8'
-            expect(Puppet::Util::Execution).to receive(:execute).with(['/bin/pkg', 'unfreeze', 'dummy'], {:failonfail => false, :combine => true})
-            expect(Puppet::Util::Execution).to receive(:execute)
+            Puppet::Util::Execution.expects(:execute).with(['/bin/pkg', 'unfreeze', 'dummy'], {:failonfail => false, :combine => true})
+            Puppet::Util::Execution.expects(:execute)
               .with(['/bin/pkg', 'list', '-Hv', 'dummy'], {:failonfail => false, :combine => true})
-              .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)
+              .returns(Puppet::Util::Execution::ProcessOutput.new('pkg://foo/dummy@0.0.7,5.11-0.151006:20131230T130000Z  installed -----', 0))
+            Puppet::Util::Execution.expects(:execute)
               .with(['/bin/pkg', 'update', *hash[:flags], 'dummy@0.0.8'], {:failonfail => false, :combine => true})
-              .and_return(Puppet::Util::Execution::ProcessOutput.new('', 0))
-            allow($CHILD_STATUS).to receive(:exitstatus).and_return(0)
+              .returns(Puppet::Util::Execution::ProcessOutput.new('', 0))
+            $CHILD_STATUS.stubs(:exitstatus).returns 0
             provider.install
           end
 
           it "should downgrade to specific version" do
             resource[:ensure] = '0.0.7'
-            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)
+            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)
               .with(['/bin/pkg', 'update', *hash[:flags], 'dummy@0.0.7'], {:failonfail => false, :combine => true})
-              .and_return(Puppet::Util::Execution::ProcessOutput.new('', 0))
+              .returns(Puppet::Util::Execution::ProcessOutput.new('', 0))
             provider.install
           end
 
           it "should install any if version is not specified" do
             resource[:ensure] = :present
-            expect(provider).to receive(:query).with(no_args).and_return({:ensure => :absent})
-            expect(Puppet::Util::Execution).to receive(:execute)
+            provider.expects(:query).with().returns({:ensure => :absent})
+            Puppet::Util::Execution.expects(:execute)
               .with(['/bin/pkg', 'install', *hash[:flags], 'dummy'], {:failonfail => false, :combine => true})
-              .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)
+              .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
             provider.install
           end
 
           it "should install if no version was previously installed, and a specific version was requested" do
             resource[:ensure] = '0.0.7'
-            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)
+            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)
               .with(['/bin/pkg', 'install', *hash[:flags], 'dummy@0.0.7'], {:failonfail => false, :combine => true})
-              .and_return(Puppet::Util::Execution::ProcessOutput.new('', 0))
-            allow($CHILD_STATUS).to receive(:exitstatus).and_return(0)
+              .returns(Puppet::Util::Execution::ProcessOutput.new('', 0))
+            $CHILD_STATUS.stubs(:exitstatus).returns 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
-            expect(provider).to receive(:query).with(no_args).and_return({:ensure => is})
-            expect(described_class).to receive(:pkg)
+            provider.expects(:query).with().returns({:ensure => is})
+            described_class.expects(:pkg)
               .with(:list, '-Hvfa', 'dummy@1.0-0.151006')
-              .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)
+              .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
             provider.insync?(is)
             provider.install
           end
@@ -341,12 +341,12 @@ describe Puppet::Type.type(:package).provider(:pkg), unless: Puppet::Util::Platf
           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'
-            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.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
             provider.insync?(is)
             provider.install
           end
@@ -354,23 +354,23 @@ describe Puppet::Type.type(:package).provider(:pkg), unless: Puppet::Util::Platf
           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'
-            expect(provider).to receive(:warning).with("Implicit version 1.0-0.151006 has 3 possible matches")
-            expect(described_class).to receive(:pkg)
+            provider.expects(:warning).with("Implicit version 1.0-0.151006 has 3 possible matches")
+            described_class.expects(:pkg)
               .with(:list, '-Hvfa', 'dummy@1.0-0.151006')
-              .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)
+              .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
             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
-            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.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
             provider.insync?(is)
           end
         end
@@ -379,17 +379,17 @@ describe Puppet::Type.type(:package).provider(:pkg), unless: Puppet::Util::Platf
 
     context ":update" do
       it "should not raise error if not necessary" do
-        expect(provider).to receive(:install).with(true).and_return({:exit => 0})
+        provider.expects(:install).with(true).returns({:exit => 0})
         provider.update
       end
 
       it "should not raise error if not necessary (2)" do
-        expect(provider).to receive(:install).with(true).and_return({:exit => 4})
+        provider.expects(:install).with(true).returns({:exit => 4})
         provider.update
       end
 
       it "should raise error if necessary" do
-        expect(provider).to receive(:install).with(true).and_return({:exit => 1})
+        provider.expects(:install).with(true).returns({:exit => 1})
         expect {
           provider.update
         }.to raise_error(Puppet::Error, /Unable to update/)
@@ -398,14 +398,14 @@ describe Puppet::Type.type(:package).provider(:pkg), unless: Puppet::Util::Platf
 
     context ":uninstall" do
       it "should support current pkg version" do
-        expect(described_class).to receive(:pkg).with(:version).and_return('630e1ffc7a19')
-        expect(described_class).to receive(:pkg).with([:uninstall, resource[:name]])
+        described_class.expects(:pkg).with(:version).returns('630e1ffc7a19')
+        described_class.expects(:pkg).with([:uninstall, resource[:name]])
         provider.uninstall
       end
 
       it "should support original pkg commands" do
-        expect(described_class).to receive(:pkg).with(:version).and_return('052adf36c3f4')
-        expect(described_class).to receive(:pkg).with([:uninstall, '-r', resource[:name]])
+        described_class.expects(:pkg).with(:version).returns('052adf36c3f4')
+        described_class.expects(:pkg).with([:uninstall, '-r', resource[:name]])
         provider.uninstall
       end
     end