puppet 5.3.4 → 6.29.0

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
@@ -9,10 +8,6 @@ describe Puppet::Type.type(:package).provider(:pkgdmg) do
   it { is_expected.not_to be_uninstallable }
 
   describe "when installing it should fail when" do
-    before :each do
-      Puppet::Util.expects(:execute).never
-    end
-
     it "no source is specified" do
       expect { provider.install }.to raise_error(Puppet::Error, /must specify a package source/)
     end
@@ -29,33 +24,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", "-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 +62,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 +136,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 +150,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

@@ -1,40 +1,38 @@
 require "spec_helper"
 
-provider_class = Puppet::Type.type(:package).provider(:pkgin)
-
-describe provider_class do
+describe Puppet::Type.type(:package).provider(:pkgin) do
   let(:resource) { Puppet::Type.type(:package).new(:name => "vim", :provider => :pkgin) }
   subject        { resource.provider }
 
   describe "Puppet provider interface" do
     it "can return the list of all packages" do
-      expect(provider_class).to respond_to(:instances)
+      expect(described_class).to respond_to(:instances)
     end
   end
 
   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
-
   end
 
   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
@@ -45,19 +43,19 @@ describe provider_class do
     end
 
     before do
-      provider_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
-      instances = provider_class.instances
-      expect(instances).to have(2).items
+      instances = described_class.instances
+      expect(instances.count).to eq 2
       instances.each do |instance|
-        expect(instance).to be_a(provider_class)
+        expect(instance).to be_a(described_class)
       end
     end
 
     it "populates each provider with an installed package" do
-      zlib_provider, zziplib_provider = provider_class.instances
+      zlib_provider, zziplib_provider = described_class.instances
       expect(zlib_provider.get(:name)).to eq("zlib")
       expect(zlib_provider.get(:ensure)).to eq("1.2.3")
       expect(zziplib_provider.get(:name)).to eq("zziplib")
@@ -67,7 +65,7 @@ describe provider_class do
 
   describe "#latest" do
     before do
-      provider_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
@@ -76,7 +74,7 @@ describe provider_class 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
@@ -97,7 +95,7 @@ describe provider_class 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
@@ -119,7 +117,7 @@ SEARCH
       end
 
       it "returns the newest available version" do
-        provider_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
@@ -140,7 +138,7 @@ SEARCH
       let(:package) { "vim-7.2.446;=;Vim editor (vi clone) without GUI" }
 
       it "extracts the name and status" do
-        expect(provider_class.parse_pkgin_line(package)).to eq({ :name => "vim" ,
+        expect(described_class.parse_pkgin_line(package)).to eq({ :name => "vim" ,
                                                              :status => "=" ,
                                                              :ensure => "7.2.446" })
       end
@@ -150,7 +148,7 @@ SEARCH
       let(:package) { "ruby18-puppet-0.25.5nb1;>;Configuration management framework written in Ruby" }
 
       it "extracts the name and status" do
-        expect(provider_class.parse_pkgin_line(package)).to eq({ :name =>  "ruby18-puppet",
+        expect(described_class.parse_pkgin_line(package)).to eq({ :name =>  "ruby18-puppet",
                                                              :status => ">" ,
                                                              :ensure => "0.25.5nb1" })
       end
@@ -160,7 +158,7 @@ SEARCH
       let(:package) { "ruby200-facter-2.4.3nb1;=;Cross-platform Ruby library for retrieving facts from OS" }
 
       it "extracts the name and status" do
-        expect(provider_class.parse_pkgin_line(package)).to eq({ :name =>  "ruby200-facter",
+        expect(described_class.parse_pkgin_line(package)).to eq({ :name =>  "ruby200-facter",
                                                              :status => "=" ,
                                                              :ensure => "2.4.3nb1" })
       end
@@ -170,18 +168,17 @@ SEARCH
       let(:package) { "vim-7.2.446;Vim editor (vi clone) without GUI" }
 
       it "extracts the name and status" do
-        expect(provider_class.parse_pkgin_line(package)).to eq({ :name => "vim" ,
+        expect(described_class.parse_pkgin_line(package)).to eq({ :name => "vim" ,
                                                              :status => nil ,
                                                              :ensure => "7.2.446" })
       end
-
     end
 
     context "with an invalid package" do
       let(:package) { "" }
 
       it "returns nil" do
-        expect(provider_class.parse_pkgin_line(package)).to be_nil
+        expect(described_class.parse_pkgin_line(package)).to be_nil
       end
     end
   end

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

@@ -1,10 +1,7 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/provider/package/pkgng'
 
-provider_class = Puppet::Type.type(:package).provider(:pkgng)
-
-describe provider_class do
+describe Puppet::Type.type(:package).provider(:pkgng) do
   let(:name) { 'bash' }
   let(:installed_name) { 'zsh' }
   let(:pkgng) { 'pkgng' }
@@ -31,49 +28,48 @@ describe provider_class 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
-    provider_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.info'))
-    provider_class.stubs(:get_query).returns(info)
+    info = File.read(my_fixture('pkg.query'))
+    allow(described_class).to receive(:get_query).and_return(info)
 
     version_list = File.read(my_fixture('pkg.version'))
-    provider_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
-      provider_class.stubs(:get_query).returns('')
-      provider_class.stubs(:get_version_list).returns('')
-      expect(provider_class.instances).to be_empty
+      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
 
     it "should return all packages when invoked" do
-      expect(provider_class.instances.map(&:name).sort).to eq(
-        %w{ca_root_nss curl nmap pkg gnupg mcollective zsh tac_plus}.sort)
+      expect(described_class.instances.map(&:name).sort).to eq(
+        %w{ca_root_nss curl nmap pkg gnupg zsh tac_plus}.sort)
     end
 
     it "should set latest to current version when no upgrade available" do
-      nmap = provider_class.instances.find {|i| i.properties[:origin] == 'security/nmap' }
+      nmap = described_class.instances.find {|i| i.properties[:origin] == 'security/nmap' }
 
       expect(nmap.properties[:version]).to eq(nmap.properties[:latest])
     end
 
     it "should return an empty array when pkg calls raise an exception" do
-      provider_class.stubs(:get_query).raises(Puppet::ExecutionFailure, 'An error occurred.')
-      expect(provider_class.instances).to eq([])
+      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 = provider_class.instances.find {|i| i.properties[:origin] == 'shells/zsh' }
-        expect( zsh.properties[:version]).to eq('5.0.2_1')
+        zsh = described_class.instances.find {|i| i.properties[:origin] == 'shells/zsh' }
+        expect(zsh.properties[:version]).to eq('5.0.2_1')
       end
     end
   end
@@ -85,8 +81,8 @@ describe provider_class 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
@@ -97,8 +93,8 @@ describe provider_class 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
@@ -109,8 +105,32 @@ describe provider_class 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
+
+    it "should call pkg with the specified install options string" do
+      resource = Puppet::Type.type(:package).new(
+        :name            => 'curl',
+        :provider        => :pkgng,
+        :install_options => ['--foo', '--bar']
+      )
+      expect(resource.provider).to receive(:pkg) do |arg|
+        expect(arg).to include('--foo', '--bar')
+      end
+      resource.provider.install
+    end
+
+    it "should call pkg with the specified install options hash" do
+      resource = Puppet::Type.type(:package).new(
+        :name            => 'curl',
+        :provider        => :pkgng,
+        :install_options => ['--foo', { '--bar' => 'baz', '--baz' => 'foo' }]
+      )
+      expect(resource.provider).to receive(:pkg) do |arg|
+        expect(arg).to include('--foo', '--bar=baz', '--baz=foo')
       end
       resource.provider.install
     end
@@ -118,44 +138,48 @@ describe provider_class do
 
   context "#prefetch" do
     it "should fail gracefully when " do
-      provider_class.stubs(:instances).returns([])
-      expect{ provider_class.prefetch({}) }.to_not raise_error
+      allow(described_class).to receive(:instances).and_return([])
+      expect{ described_class.prefetch({}) }.to_not raise_error
     end
   end
 
   context "#query" do
     it "should return the installed version if present" do
-      provider_class.prefetch({installed_name => installed_resource})
-      expect(installed_provider.query).to eq({:version=>'5.0.2_1'})
+      pkg_query_zsh = File.read(my_fixture('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
-      fixture = File.read(my_fixture('pkg.query_absent'))
-      provider_class.stubs(:get_resource_info).with('bash').returns(fixture)
+      allow(described_class).to receive(:get_resource_info).with('bash').and_raise(Puppet::ExecutionFailure, 'An error occurred')
+
       expect(provider.query).to equal(nil)
     end
   end
 
   describe "latest" do
     it "should retrieve the correct version of the latest package" do
-      provider_class.prefetch( { installed_name => installed_resource })
+      described_class.prefetch( { installed_name => installed_resource })
       expect(installed_provider.latest).not_to be_nil
     end
 
     it "should set latest to newer package version when available" do
-      instances = provider_class.instances
+      instances = described_class.instances
       curl = instances.find {|i| i.properties[:origin] == 'ftp/curl' }
       expect(curl.properties[:latest]).to eq('7.33.0_2')
     end
 
     it "should call update to upgrade the version" do
+      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',
         :provider => pkgng,
         :ensure   => :latest
       )
 
-      resource.provider.expects(:update)
+      expect(resource.provider).to receive(:update)
 
       resource.property(:ensure).sync
     end
@@ -164,22 +188,40 @@ describe provider_class 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'))
-      nmap_latest_version = provider_class.get_latest_version('security/nmap', 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
     end
 
     it "should match the package name exactly" do
       version_list = File.read(my_fixture('pkg.version'))
-      bash_comp_latest_version = provider_class.get_latest_version('shells/bash-completion', 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')
     end
+
+    it "should return nil when the package is orphaned" do
+      version_list = File.read(my_fixture('pkg.version'))
+      allow(described_class).to receive(:get_version_list).and_return(version_list)
+      orphan_latest_version = described_class.get_latest_version('sysutils/orphan')
+      expect(orphan_latest_version).to be_nil
+    end
+
+    it "should return nil when the package is broken" do
+      version_list = File.read(my_fixture('pkg.version'))
+      allow(described_class).to receive(:get_version_list).and_return(version_list)
+      broken_latest_version = described_class.get_latest_version('sysutils/broken')
+      expect(broken_latest_version).to be_nil
+    end
   end
 
   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(provider_class).to be_default
+        expect(Facter).to receive(:value).with(:operatingsystem).at_least(:once).and_return(:freebsd)
+        expect(described_class).to be_default
       end
     end
   end