puppet 6.4.0-x64-mingw32 → 6.4.1-x64-mingw32

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

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 describe Puppet::Type.type(:package).provider(:pkgdmg) do
@@ -10,7 +9,7 @@ describe Puppet::Type.type(:package).provider(:pkgdmg) do
 
   describe "when installing it should fail when" do
     before :each do
-      Puppet::Util.expects(:execute).never
+      expect(Puppet::Util).not_to receive(:execute)
     end
 
     it "no source is specified" do
@@ -29,33 +28,33 @@ describe Puppet::Type.type(:package).provider(:pkgdmg) do
     let(:fake_hdiutil_plist) { {"system-entities" => [{"mount-point" => fake_mountpoint}]} }
 
     before do
-      fh = mock 'filehandle'
-      fh.stubs(:path).yields "/tmp/foo"
+      fh = double('filehandle')
+      allow(fh).to receive(:path).and_return("/tmp/foo")
       resource[:source] = "foo.dmg"
-      File.stubs(:open).yields fh
-      Dir.stubs(:mktmpdir).returns "/tmp/testtmp123"
-      FileUtils.stubs(:remove_entry_secure)
+      allow(File).to receive(:open).and_yield(fh)
+      allow(Dir).to receive(:mktmpdir).and_return("/tmp/testtmp123")
+      allow(FileUtils).to receive(:remove_entry_secure)
     end
 
     it "should fail when a disk image with no system entities is mounted" do
-      described_class.stubs(:hdiutil).returns 'empty plist'
-      Puppet::Util::Plist.expects(:parse_plist).with('empty plist').returns({})
+      allow(described_class).to receive(:hdiutil).and_return('empty plist')
+      expect(Puppet::Util::Plist).to receive(:parse_plist).with('empty plist').and_return({})
       expect { provider.install }.to raise_error(Puppet::Error, /No disk entities/)
     end
 
     it "should call hdiutil to mount and eject the disk image" do
-      Dir.stubs(:entries).returns []
-      provider.class.expects(:hdiutil).with("eject", fake_mountpoint).returns 0
-      provider.class.expects(:hdiutil).with("mount", "-plist", "-nobrowse", "-readonly", "-noidme", "-mountrandom", "/tmp", nil).returns 'a plist'
-      Puppet::Util::Plist.expects(:parse_plist).with('a plist').returns fake_hdiutil_plist
+      allow(Dir).to receive(:entries).and_return([])
+      expect(provider.class).to receive(:hdiutil).with("eject", fake_mountpoint).and_return(0)
+      expect(provider.class).to receive(:hdiutil).with("mount", "-plist", "-nobrowse", "-readonly", "-noidme", "-mountrandom", "/tmp", '/tmp/foo').and_return('a plist')
+      expect(Puppet::Util::Plist).to receive(:parse_plist).with('a plist').and_return(fake_hdiutil_plist)
       provider.install
     end
 
     it "should call installpkg if a pkg/mpkg is found on the dmg" do
-      Dir.stubs(:entries).returns ["foo.pkg"]
-      provider.class.stubs(:hdiutil).returns 'a plist'
-      Puppet::Util::Plist.expects(:parse_plist).with('a plist').returns fake_hdiutil_plist
-      provider.class.expects(:installpkg).with("#{fake_mountpoint}/foo.pkg", resource[:name], "foo.dmg").returns ""
+      allow(Dir).to receive(:entries).and_return(["foo.pkg"])
+      allow(provider.class).to receive(:hdiutil).and_return('a plist')
+      expect(Puppet::Util::Plist).to receive(:parse_plist).with('a plist').and_return(fake_hdiutil_plist)
+      expect(provider.class).to receive(:installpkg).with("#{fake_mountpoint}/foo.pkg", resource[:name], "foo.dmg").and_return("")
       provider.install
     end
 
@@ -67,66 +66,69 @@ describe Puppet::Type.type(:package).provider(:pkgdmg) do
       end
 
       it "should call tmpdir and then call curl with that directory" do
-        Dir.expects(:mktmpdir).returns tmpdir
-        Dir.stubs(:entries).returns ["foo.pkg"]
-        described_class.expects(:curl).with do |*args|
-          args[0] == "-o" && args[1].include?(tmpdir) && args.include?("--fail") && ! args.include?("-k")
+        expect(Dir).to receive(:mktmpdir).and_return(tmpdir)
+        allow(Dir).to receive(:entries).and_return(["foo.pkg"])
+        expect(described_class).to receive(:curl) do |*args|
+          expect(args[0]).to eq("-o")
+          expect(args[1]).to include(tmpdir)
+          expect(args).to include("--fail")
+          expect(args).not_to include("-k")
         end
-        described_class.stubs(:hdiutil).returns 'a plist'
-        Puppet::Util::Plist.expects(:parse_plist).with('a plist').returns fake_hdiutil_plist
-        described_class.expects(:installpkg)
+        allow(described_class).to receive(:hdiutil).and_return('a plist')
+        expect(Puppet::Util::Plist).to receive(:parse_plist).with('a plist').and_return(fake_hdiutil_plist)
+        expect(described_class).to receive(:installpkg)
 
         provider.install
       end
 
       it "should use an http proxy host and port if specified" do
-        Puppet::Util::HttpProxy.expects(:no_proxy?).returns false
-        Puppet::Util::HttpProxy.expects(:http_proxy_host).returns 'some_host'
-        Puppet::Util::HttpProxy.expects(:http_proxy_port).returns 'some_port'
-        Dir.expects(:mktmpdir).returns tmpdir
-        Dir.stubs(:entries).returns ["foo.pkg"]
-        described_class.expects(:curl).with do |*args|
-          expect(args).to be_include 'some_host:some_port'
-          expect(args).to be_include '--proxy'
+        expect(Puppet::Util::HttpProxy).to receive(:no_proxy?).and_return(false)
+        expect(Puppet::Util::HttpProxy).to receive(:http_proxy_host).and_return('some_host')
+        expect(Puppet::Util::HttpProxy).to receive(:http_proxy_port).and_return('some_port')
+        expect(Dir).to receive(:mktmpdir).and_return(tmpdir)
+        allow(Dir).to receive(:entries).and_return(["foo.pkg"])
+        expect(described_class).to receive(:curl) do |*args|
+          expect(args).to include('some_host:some_port')
+          expect(args).to include('--proxy')
         end
-        described_class.stubs(:hdiutil).returns 'a plist'
-        Puppet::Util::Plist.expects(:parse_plist).with('a plist').returns fake_hdiutil_plist
-        described_class.expects(:installpkg)
+        allow(described_class).to receive(:hdiutil).and_return('a plist')
+        expect(Puppet::Util::Plist).to receive(:parse_plist).with('a plist').and_return(fake_hdiutil_plist)
+        expect(described_class).to receive(:installpkg)
 
         provider.install
       end
 
       it "should use an http proxy host only if specified" do
-        Puppet::Util::HttpProxy.expects(:no_proxy?).returns false
-        Puppet::Util::HttpProxy.expects(:http_proxy_host).returns 'some_host'
-        Puppet::Util::HttpProxy.expects(:http_proxy_port).returns nil
-        Dir.expects(:mktmpdir).returns tmpdir
-        Dir.stubs(:entries).returns ["foo.pkg"]
-        described_class.expects(:curl).with do |*args|
-          expect(args).to be_include 'some_host'
-          expect(args).to be_include '--proxy'
+        expect(Puppet::Util::HttpProxy).to receive(:no_proxy?).and_return(false)
+        expect(Puppet::Util::HttpProxy).to receive(:http_proxy_host).and_return('some_host')
+        expect(Puppet::Util::HttpProxy).to receive(:http_proxy_port).and_return(nil)
+        expect(Dir).to receive(:mktmpdir).and_return(tmpdir)
+        allow(Dir).to receive(:entries).and_return(["foo.pkg"])
+        expect(described_class).to receive(:curl) do |*args|
+          expect(args).to include('some_host')
+          expect(args).to include('--proxy')
         end
-        described_class.stubs(:hdiutil).returns 'a plist'
-        Puppet::Util::Plist.expects(:parse_plist).with('a plist').returns fake_hdiutil_plist
-        described_class.expects(:installpkg)
+        allow(described_class).to receive(:hdiutil).and_return('a plist')
+        expect(Puppet::Util::Plist).to receive(:parse_plist).with('a plist').and_return(fake_hdiutil_plist)
+        expect(described_class).to receive(:installpkg)
 
         provider.install
       end
 
       it "should not use the configured proxy if no_proxy contains a match for the destination" do
-        Puppet::Util::HttpProxy.expects(:no_proxy?).returns true
-        Puppet::Util::HttpProxy.expects(:http_proxy_host).never
-        Puppet::Util::HttpProxy.expects(:http_proxy_port).never
-        Dir.expects(:mktmpdir).returns tmpdir
-        Dir.stubs(:entries).returns ["foo.pkg"]
-        described_class.expects(:curl).with do |*args|
-          expect(args).not_to be_include 'some_host:some_port'
-          expect(args).not_to be_include '--proxy'
+        expect(Puppet::Util::HttpProxy).to receive(:no_proxy?).and_return(true)
+        expect(Puppet::Util::HttpProxy).not_to receive(:http_proxy_host)
+        expect(Puppet::Util::HttpProxy).not_to receive(:http_proxy_port)
+        expect(Dir).to receive(:mktmpdir).and_return(tmpdir)
+        allow(Dir).to receive(:entries).and_return(["foo.pkg"])
+        expect(described_class).to receive(:curl) do |*args|
+          expect(args).not_to include('some_host:some_port')
+          expect(args).not_to include('--proxy')
           true
         end
-        described_class.stubs(:hdiutil).returns 'a plist'
-        Puppet::Util::Plist.expects(:parse_plist).with('a plist').returns fake_hdiutil_plist
-        described_class.expects(:installpkg)
+        allow(described_class).to receive(:hdiutil).and_return('a plist')
+        expect(Puppet::Util::Plist).to receive(:parse_plist).with('a plist').and_return(fake_hdiutil_plist)
+        expect(described_class).to receive(:installpkg)
 
         provider.install
       end
@@ -138,7 +140,7 @@ describe Puppet::Type.type(:package).provider(:pkgdmg) do
       it "should call installpkg if a flat pkg file is found instead of a .dmg image" do
         resource[:source] = "/tmp/test.pkg"
         resource[:name] = "testpkg"
-        provider.class.expects(:installpkgdmg).with("/tmp/test.pkg", "testpkg").returns ""
+        expect(provider.class).to receive(:installpkgdmg).with("/tmp/test.pkg", "testpkg").and_return("")
         provider.install
       end
     end
@@ -152,15 +154,15 @@ describe Puppet::Type.type(:package).provider(:pkgdmg) do
         resource[:name]   = 'testpkg'
         resource[:source] = remote_source
 
-        Dir.stubs(:mktmpdir).returns tmpdir
+        allow(Dir).to receive(:mktmpdir).and_return(tmpdir)
       end
 
       it "should call installpkg if a flat pkg file is found instead of a .dmg image" do
-        described_class.expects(:curl).with do |*args|
-          expect(args).to be_include tmpfile
-          expect(args).to be_include remote_source
+        expect(described_class).to receive(:curl) do |*args|
+          expect(args).to include(tmpfile)
+          expect(args).to include(remote_source)
         end
-        provider.class.expects(:installpkg).with(tmpfile, 'testpkg', remote_source)
+        expect(provider.class).to receive(:installpkg).with(tmpfile, 'testpkg', remote_source)
         provider.install
       end
     end

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

@@ -13,16 +13,18 @@ describe Puppet::Type.type(:package).provider(:pkgin) do
   describe "#install" do
    describe "a package not installed" do
     before { resource[:ensure] = :absent }
+
     it "uses pkgin install to install" do
-      subject.expects(:pkgin).with("-y", :install, "vim").once()
+      expect(subject).to receive(:pkgin).with("-y", :install, "vim").once()
       subject.install
     end
    end
 
    describe "a package with a fixed version" do
     before { resource[:ensure] = '7.2.446' }
+
     it "uses pkgin install to install a fixed version" do
-      subject.expects(:pkgin).with("-y", :install, "vim-7.2.446").once()
+      expect(subject).to receive(:pkgin).with("-y", :install, "vim-7.2.446").once()
       subject.install
     end
    end
@@ -30,7 +32,7 @@ describe Puppet::Type.type(:package).provider(:pkgin) do
 
   describe "#uninstall" do
     it "uses pkgin remove to uninstall" do
-      subject.expects(:pkgin).with("-y", :remove, "vim").once()
+      expect(subject).to receive(:pkgin).with("-y", :remove, "vim").once()
       subject.uninstall
     end
   end
@@ -41,7 +43,7 @@ describe Puppet::Type.type(:package).provider(:pkgin) do
     end
 
     before do
-      described_class.stubs(:pkgin).with(:list).returns(pkgin_ls_output)
+      allow(described_class).to receive(:pkgin).with(:list).and_return(pkgin_ls_output)
     end
 
     it "returns an array of providers for each package" do
@@ -63,7 +65,7 @@ describe Puppet::Type.type(:package).provider(:pkgin) do
 
   describe "#latest" do
     before do
-      described_class.stubs(:pkgin).with(:search, "vim").returns(pkgin_search_output)
+      allow(described_class).to receive(:pkgin).with(:search, "vim").and_return(pkgin_search_output)
     end
 
     context "when the package is installed" do
@@ -72,7 +74,7 @@ describe Puppet::Type.type(:package).provider(:pkgin) do
       end
 
       it "returns installed version" do
-        subject.expects(:properties).returns( { :ensure => "7.2.446" } )
+        expect(subject).to receive(:properties).and_return({ :ensure => "7.2.446" })
         expect(subject.latest).to eq("7.2.446")
       end
     end
@@ -93,7 +95,7 @@ describe Puppet::Type.type(:package).provider(:pkgin) do
       end
 
       it "returns current version" do
-        subject.expects(:properties).returns( { :ensure => "7.2.446" } )
+        expect(subject).to receive(:properties).and_return({ :ensure => "7.2.446" })
         expect(subject.latest).to eq("7.2.446")
       end
     end
@@ -115,7 +117,7 @@ SEARCH
       end
 
       it "returns the newest available version" do
-        described_class.stubs(:pkgin).with(:search, "vim").returns(pkgin_search_output)
+        allow(described_class).to receive(:pkgin).with(:search, "vim").and_return(pkgin_search_output)
         expect(subject.latest).to eq("7.3")
       end
     end

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

@@ -28,26 +28,25 @@ describe Puppet::Type.type(:package).provider(:pkgng) do
     catalog = Puppet::Resource::Catalog.new
     catalog.host_config = false
     resources.each do |resource|
-      #resource.expects(:err).never
       catalog.add_resource(resource)
     end
     catalog.apply
   end
 
   before do
-    described_class.stubs(:command).with(:pkg) { '/usr/local/sbin/pkg' }
+    allow(described_class).to receive(:command).with(:pkg).and_return('/usr/local/sbin/pkg')
 
     info = File.read(my_fixture('pkg.query'))
-    described_class.stubs(:get_query).returns(info)
+    allow(described_class).to receive(:get_query).and_return(info)
 
     version_list = File.read(my_fixture('pkg.version'))
-    described_class.stubs(:get_version_list).returns(version_list)
+    allow(described_class).to receive(:get_version_list).and_return(version_list)
   end
 
   context "#instances" do
     it "should return the empty set if no packages are listed" do
-      described_class.stubs(:get_query).returns('')
-      described_class.stubs(:get_version_list).returns('')
+      allow(described_class).to receive(:get_query).and_return('')
+      allow(described_class).to receive(:get_version_list).and_return('')
       expect(described_class.instances).to be_empty
     end
 
@@ -63,14 +62,14 @@ describe Puppet::Type.type(:package).provider(:pkgng) do
     end
 
     it "should return an empty array when pkg calls raise an exception" do
-      described_class.stubs(:get_query).raises(Puppet::ExecutionFailure, 'An error occurred.')
+      allow(described_class).to receive(:get_query).and_raise(Puppet::ExecutionFailure, 'An error occurred.')
       expect(described_class.instances).to eq([])
     end
 
     describe "version" do
       it "should retrieve the correct version of the current package" do
         zsh = described_class.instances.find {|i| i.properties[:origin] == 'shells/zsh' }
-        expect( zsh.properties[:version]).to eq('5.0.2_1')
+        expect(zsh.properties[:version]).to eq('5.0.2_1')
       end
     end
   end
@@ -82,8 +81,8 @@ describe Puppet::Type.type(:package).provider(:pkgng) do
         :provider => :pkgng,
         :ensure   => '7.33.1'
       )
-      resource.provider.expects(:pkg) do |arg|
-        arg.should include('curl-7.33.1')
+      expect(resource.provider).to receive(:pkg) do |arg|
+        expect(arg).to include('curl-7.33.1')
       end
       resource.provider.install
     end
@@ -94,8 +93,8 @@ describe Puppet::Type.type(:package).provider(:pkgng) do
         :provider => :pkgng,
         :ensure   => '7.33.1'
       )
-      resource.provider.expects(:pkg) do |arg|
-        arg.should include('curl-7.33.1')
+      expect(resource.provider).to receive(:pkg) do |arg|
+        expect(arg).to include('curl-7.33.1')
       end
       resource.provider.install
     end
@@ -106,8 +105,8 @@ describe Puppet::Type.type(:package).provider(:pkgng) do
         :provider => :pkgng,
         :source   => 'urn:freebsd:repo:FreeBSD'
       )
-      resource.provider.expects(:pkg) do |arg|
-        arg.should include('FreeBSD')
+      expect(resource.provider).to receive(:pkg) do |arg|
+        expect(arg).to include('FreeBSD')
       end
       resource.provider.install
     end
@@ -115,7 +114,7 @@ describe Puppet::Type.type(:package).provider(:pkgng) do
 
   context "#prefetch" do
     it "should fail gracefully when " do
-      described_class.stubs(:instances).returns([])
+      allow(described_class).to receive(:instances).and_return([])
       expect{ described_class.prefetch({}) }.to_not raise_error
     end
   end
@@ -123,13 +122,13 @@ describe Puppet::Type.type(:package).provider(:pkgng) do
   context "#query" do
     it "should return the installed version if present" do
       pkg_query_zsh = File.read(my_fixture('pkg.query.zsh'))
-      described_class.stubs(:get_resource_info).with('zsh').returns(pkg_query_zsh)
+      allow(described_class).to receive(:get_resource_info).with('zsh').and_return(pkg_query_zsh)
       described_class.prefetch({installed_name => installed_resource})
       expect(installed_provider.query).to be >= {:version=>'5.0.2_1'}
     end
 
     it "should return nil if not present" do
-      described_class.stubs(:get_resource_info).with('bash').raises(Puppet::ExecutionFailure, 'An error occurred')
+      allow(described_class).to receive(:get_resource_info).with('bash').and_raise(Puppet::ExecutionFailure, 'An error occurred')
 
       expect(provider.query).to equal(nil)
     end
@@ -148,7 +147,7 @@ describe Puppet::Type.type(:package).provider(:pkgng) do
     end
 
     it "should call update to upgrade the version" do
-      described_class.stubs(:get_resource_info).with('ftp/curl').returns('curl 7.61.1 ftp/curl')
+      allow(described_class).to receive(:get_resource_info).with('ftp/curl').and_return('curl 7.61.1 ftp/curl')
 
       resource = Puppet::Type.type(:package).new(
         :name     => 'ftp/curl',
@@ -156,7 +155,7 @@ describe Puppet::Type.type(:package).provider(:pkgng) do
         :ensure   => :latest
       )
 
-      resource.provider.expects(:update)
+      expect(resource.provider).to receive(:update)
 
       resource.property(:ensure).sync
     end
@@ -165,7 +164,7 @@ describe Puppet::Type.type(:package).provider(:pkgng) do
   describe "get_latest_version" do
     it "should rereturn nil when the current package is the latest" do
       version_list = File.read(my_fixture('pkg.version'))
-      described_class.stubs(:get_version_list).returns(version_list)
+      allow(described_class).to receive(:get_version_list).and_return(version_list)
       nmap_latest_version = described_class.get_latest_version('security/nmap')
 
       expect(nmap_latest_version).to be_nil
@@ -173,7 +172,7 @@ describe Puppet::Type.type(:package).provider(:pkgng) do
 
     it "should match the package name exactly" do
       version_list = File.read(my_fixture('pkg.version'))
-      described_class.stubs(:get_version_list).returns(version_list)
+      allow(described_class).to receive(:get_version_list).and_return(version_list)
       bash_comp_latest_version = described_class.get_latest_version('shells/bash-completion')
 
       expect(bash_comp_latest_version).to eq('2.1_3')
@@ -183,7 +182,7 @@ describe Puppet::Type.type(:package).provider(:pkgng) do
   describe "confine" do
     context "on FreeBSD" do
       it "should be the default provider" do
-        Facter.expects(:value).with(:operatingsystem).at_least_once.returns :freebsd
+        expect(Facter).to receive(:value).with(:operatingsystem).at_least(:once).and_return(:freebsd)
         expect(described_class).to be_default
       end
     end

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

@@ -1,19 +1,16 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
-provider = Puppet::Type.type(:package).provider(:pkgutil)
-
-describe provider do
+describe Puppet::Type.type(:package).provider(:pkgutil) do
   before(:each) do
     @resource = Puppet::Type.type(:package).new(
       :name     => "TESTpkg",
       :ensure   => :present,
       :provider => :pkgutil
     )
-    @provider = provider.new(@resource)
+    @provider = described_class.new(@resource)
 
     # Stub all file and config tests
-    provider.stubs(:healthcheck)
+    allow(described_class).to receive(:healthcheck)
   end
 
   it "should have an install method" do
@@ -35,59 +32,59 @@ describe provider do
   describe "when installing" do
     it "should use a command without versioned package" do
       @resource[:ensure] = :latest
-      @provider.expects(:pkguti).with('-y', '-i', 'TESTpkg')
+      expect(@provider).to receive(:pkguti).with('-y', '-i', 'TESTpkg')
       @provider.install
     end
 
     it "should support a single temp repo URL" do
       @resource[:ensure] = :latest
       @resource[:source] = "http://example.net/repo"
-      @provider.expects(:pkguti).with('-t', 'http://example.net/repo', '-y', '-i', 'TESTpkg')
+      expect(@provider).to receive(:pkguti).with('-t', 'http://example.net/repo', '-y', '-i', 'TESTpkg')
       @provider.install
     end
 
     it "should support multiple temp repo URLs as array" do
       @resource[:ensure] = :latest
       @resource[:source] = [ 'http://example.net/repo', 'http://example.net/foo' ]
-      @provider.expects(:pkguti).with('-t', 'http://example.net/repo', '-t', 'http://example.net/foo', '-y', '-i', 'TESTpkg')
+      expect(@provider).to receive(:pkguti).with('-t', 'http://example.net/repo', '-t', 'http://example.net/foo', '-y', '-i', 'TESTpkg')
       @provider.install
     end
   end
 
   describe "when updating" do
     it "should use a command without versioned package" do
-      @provider.expects(:pkguti).with('-y', '-u', 'TESTpkg')
+      expect(@provider).to receive(:pkguti).with('-y', '-u', 'TESTpkg')
       @provider.update
     end
 
     it "should support a single temp repo URL" do
       @resource[:source] = "http://example.net/repo"
-      @provider.expects(:pkguti).with('-t', 'http://example.net/repo', '-y', '-u', 'TESTpkg')
+      expect(@provider).to receive(:pkguti).with('-t', 'http://example.net/repo', '-y', '-u', 'TESTpkg')
       @provider.update
     end
 
     it "should support multiple temp repo URLs as array" do
       @resource[:source] = [ 'http://example.net/repo', 'http://example.net/foo' ]
-      @provider.expects(:pkguti).with('-t', 'http://example.net/repo', '-t', 'http://example.net/foo', '-y', '-u', 'TESTpkg')
+      expect(@provider).to receive(:pkguti).with('-t', 'http://example.net/repo', '-t', 'http://example.net/foo', '-y', '-u', 'TESTpkg')
       @provider.update
     end
   end
 
   describe "when uninstalling" do
     it "should call the remove operation" do
-      @provider.expects(:pkguti).with('-y', '-r', 'TESTpkg')
+      expect(@provider).to receive(:pkguti).with('-y', '-r', 'TESTpkg')
       @provider.uninstall
     end
 
     it "should support a single temp repo URL" do
       @resource[:source] = "http://example.net/repo"
-      @provider.expects(:pkguti).with('-t', 'http://example.net/repo', '-y', '-r', 'TESTpkg')
+      expect(@provider).to receive(:pkguti).with('-t', 'http://example.net/repo', '-y', '-r', 'TESTpkg')
       @provider.uninstall
     end
 
     it "should support multiple temp repo URLs as array" do
       @resource[:source] = [ 'http://example.net/repo', 'http://example.net/foo' ]
-      @provider.expects(:pkguti).with('-t', 'http://example.net/repo', '-t', 'http://example.net/foo', '-y', '-r', 'TESTpkg')
+      expect(@provider).to receive(:pkguti).with('-t', 'http://example.net/repo', '-t', 'http://example.net/foo', '-y', '-r', 'TESTpkg')
       @provider.uninstall
     end
   end
@@ -97,7 +94,7 @@ describe provider do
       fake_data = "
 noisy output here
 TESTpkg                   1.4.5,REV=2007.11.18      1.4.5,REV=2007.11.20"
-      provider.expects(:pkguti).with('-c', '--single', 'TESTpkg').returns fake_data
+      expect(described_class).to receive(:pkguti).with('-c', '--single', 'TESTpkg').and_return(fake_data)
       expect(@provider.latest).to eq("1.4.5,REV=2007.11.20")
     end
 
@@ -106,7 +103,7 @@ TESTpkg                   1.4.5,REV=2007.11.18      1.4.5,REV=2007.11.20"
       fake_data = "
 noisy output here
 TESTpkg                   1.4.5,REV=2007.11.18      1.4.5,REV=2007.11.20"
-      provider.expects(:pkguti).with('-t', 'http://example.net/repo', '-c', '--single', 'TESTpkg').returns fake_data
+      expect(described_class).to receive(:pkguti).with('-t', 'http://example.net/repo', '-c', '--single', 'TESTpkg').and_return(fake_data)
       expect(@provider.latest).to eq("1.4.5,REV=2007.11.20")
     end
 
@@ -114,19 +111,19 @@ TESTpkg                   1.4.5,REV=2007.11.18      1.4.5,REV=2007.11.20"
       fake_data = "
 noisy output here
 TESTpkg                   1.4.5,REV=2007.11.18      SAME"
-      provider.expects(:pkguti).with('-c', '--single', 'TESTpkg').returns fake_data
+      expect(described_class).to receive(:pkguti).with('-c', '--single', 'TESTpkg').and_return(fake_data)
       expect(@provider.latest).to eq("1.4.5,REV=2007.11.18")
     end
 
     it "should handle a non-existent package" do
       fake_data = "noisy output here
 Not in catalog"
-      provider.expects(:pkguti).with('-c', '--single', 'TESTpkg').returns fake_data
+      expect(described_class).to receive(:pkguti).with('-c', '--single', 'TESTpkg').and_return(fake_data)
       expect(@provider.latest).to eq(nil)
     end
 
     it "should warn on unknown pkgutil noise" do
-      provider.expects(:pkguti).with('-c', '--single', 'TESTpkg').returns("testingnoise")
+      expect(described_class).to receive(:pkguti).with('-c', '--single', 'TESTpkg').and_return("testingnoise")
       expect(@provider.latest).to eq(nil)
     end
 
@@ -140,7 +137,7 @@ gpg: Good signature from \"Distribution Manager <dm@blastwave.org>\"
 ==> 2770 packages loaded from /var/opt/csw/pkgutil/catalog.mirror.opencsw.org_opencsw_unstable_i386_5.11
 package                   installed                 catalog
 TESTpkg                   1.4.5,REV=2007.11.18      1.4.5,REV=2007.11.20"
-      provider.expects(:pkguti).with('-c', '--single', 'TESTpkg').returns fake_data
+      expect(described_class).to receive(:pkguti).with('-c', '--single', 'TESTpkg').and_return(fake_data)
       expect(@provider.latest).to eq("1.4.5,REV=2007.11.20")
     end
 
@@ -148,7 +145,7 @@ TESTpkg                   1.4.5,REV=2007.11.18      1.4.5,REV=2007.11.20"
       fake_data = "
 noisy output here
 REALpkg                   1.4.5,REV=2007.11.18      1.4.5,REV=2007.11.20"
-      provider.expects(:pkguti).with('-c', '--single', 'TESTpkg').returns fake_data
+      expect(described_class).to receive(:pkguti).with('-c', '--single', 'TESTpkg').and_return(fake_data)
       expect(@provider.query[:name]).to eq("TESTpkg")
     end
   end
@@ -156,80 +153,79 @@ REALpkg                   1.4.5,REV=2007.11.18      1.4.5,REV=2007.11.20"
   describe "when querying current version" do
     it "should return TESTpkg's version string" do
       fake_data = "TESTpkg  1.4.5,REV=2007.11.18  1.4.5,REV=2007.11.20"
-      provider.expects(:pkguti).with('-c', '--single', 'TESTpkg').returns fake_data
+      expect(described_class).to receive(:pkguti).with('-c', '--single', 'TESTpkg').and_return(fake_data)
       expect(@provider.query[:ensure]).to eq("1.4.5,REV=2007.11.18")
     end
 
     it "should handle a package that isn't installed" do
       fake_data = "TESTpkg  notinst  1.4.5,REV=2007.11.20"
-      provider.expects(:pkguti).with('-c', '--single', 'TESTpkg').returns fake_data
+      expect(described_class).to receive(:pkguti).with('-c', '--single', 'TESTpkg').and_return(fake_data)
       expect(@provider.query[:ensure]).to eq(:absent)
     end
 
     it "should handle a non-existent package" do
       fake_data = "noisy output here
 Not in catalog"
-      provider.expects(:pkguti).with('-c', '--single', 'TESTpkg').returns fake_data
+      expect(described_class).to receive(:pkguti).with('-c', '--single', 'TESTpkg').and_return(fake_data)
       expect(@provider.query[:ensure]).to eq(:absent)
     end
 
     it "should support a temp repo URL" do
       @resource[:source] = "http://example.net/repo"
       fake_data = "TESTpkg  1.4.5,REV=2007.11.18  1.4.5,REV=2007.11.20"
-      provider.expects(:pkguti).with('-t', 'http://example.net/repo', '-c', '--single', 'TESTpkg').returns fake_data
+      expect(described_class).to receive(:pkguti).with('-t', 'http://example.net/repo', '-c', '--single', 'TESTpkg').and_return(fake_data)
       expect(@provider.query[:ensure]).to eq("1.4.5,REV=2007.11.18")
     end
   end
 
   describe "when querying current instances" do
     it "should warn on unknown pkgutil noise" do
-      provider.expects(:pkguti).with(['-a']).returns("testingnoise")
-      provider.expects(:pkguti).with(['-c']).returns("testingnoise")
-      Puppet.expects(:warning).times(2)
-      provider.expects(:new).never
-      expect(provider.instances).to eq([])
+      expect(described_class).to receive(:pkguti).with(['-a']).and_return("testingnoise")
+      expect(described_class).to receive(:pkguti).with(['-c']).and_return("testingnoise")
+      expect(Puppet).to receive(:warning).twice
+      expect(described_class).not_to receive(:new)
+      expect(described_class.instances).to eq([])
     end
 
     it "should return TESTpkg's version string" do
       fake_data = "TESTpkg  TESTpkg  1.4.5,REV=2007.11.20"
-      provider.expects(:pkguti).with(['-a']).returns fake_data
+      expect(described_class).to receive(:pkguti).with(['-a']).and_return(fake_data)
 
       fake_data = "TESTpkg  1.4.5,REV=2007.11.18  1.4.5,REV=2007.11.20"
-      provider.expects(:pkguti).with(['-c']).returns fake_data
+      expect(described_class).to receive(:pkguti).with(['-c']).and_return(fake_data)
 
-      testpkg = mock 'pkg1'
-      provider.expects(:new).with(:ensure => "1.4.5,REV=2007.11.18", :name => "TESTpkg", :provider => :pkgutil).returns testpkg
-      expect(provider.instances).to eq([testpkg])
+      testpkg = double('pkg1')
+      expect(described_class).to receive(:new).with(:ensure => "1.4.5,REV=2007.11.18", :name => "TESTpkg", :provider => :pkgutil).and_return(testpkg)
+      expect(described_class.instances).to eq([testpkg])
     end
 
     it "should also return both TESTpkg and mypkg alias instances" do
       fake_data = "mypkg  TESTpkg  1.4.5,REV=2007.11.20"
-      provider.expects(:pkguti).with(['-a']).returns fake_data
+      expect(described_class).to receive(:pkguti).with(['-a']).and_return(fake_data)
 
       fake_data = "TESTpkg  1.4.5,REV=2007.11.18  1.4.5,REV=2007.11.20"
-      provider.expects(:pkguti).with(['-c']).returns fake_data
+      expect(described_class).to receive(:pkguti).with(['-c']).and_return(fake_data)
 
-      testpkg = mock 'pkg1'
-      provider.expects(:new).with(:ensure => "1.4.5,REV=2007.11.18", :name => "TESTpkg", :provider => :pkgutil).returns testpkg
+      testpkg = double('pkg1')
+      expect(described_class).to receive(:new).with(:ensure => "1.4.5,REV=2007.11.18", :name => "TESTpkg", :provider => :pkgutil).and_return(testpkg)
 
-      aliaspkg = mock 'pkg2'
-      provider.expects(:new).with(:ensure => "1.4.5,REV=2007.11.18", :name => "mypkg", :provider => :pkgutil).returns aliaspkg
+      aliaspkg = double('pkg2')
+      expect(described_class).to receive(:new).with(:ensure => "1.4.5,REV=2007.11.18", :name => "mypkg", :provider => :pkgutil).and_return(aliaspkg)
 
-      expect(provider.instances).to eq([testpkg,aliaspkg])
+      expect(described_class.instances).to eq([testpkg,aliaspkg])
     end
 
     it "shouldn't mind noise in the -a output" do
       fake_data = "noisy output here"
-      provider.expects(:pkguti).with(['-a']).returns fake_data
+      expect(described_class).to receive(:pkguti).with(['-a']).and_return(fake_data)
 
       fake_data = "TESTpkg  1.4.5,REV=2007.11.18  1.4.5,REV=2007.11.20"
-      provider.expects(:pkguti).with(['-c']).returns fake_data
+      expect(described_class).to receive(:pkguti).with(['-c']).and_return(fake_data)
 
-      testpkg = mock 'pkg1'
-      provider.expects(:new).with(:ensure => "1.4.5,REV=2007.11.18", :name => "TESTpkg", :provider => :pkgutil).returns testpkg
+      testpkg = double('pkg1')
+      expect(described_class).to receive(:new).with(:ensure => "1.4.5,REV=2007.11.18", :name => "TESTpkg", :provider => :pkgutil).and_return(testpkg)
 
-      expect(provider.instances).to eq([testpkg])
+      expect(described_class.instances).to eq([testpkg])
     end
   end
-
 end