puppet 5.5.22-universal-darwin → 6.0.0-universal-darwin

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

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

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

@@ -1,38 +1,40 @@
 require "spec_helper"
 
-describe Puppet::Type.type(:package).provider(:pkgin) do
+provider_class = Puppet::Type.type(:package).provider(:pkgin)
+
+describe provider_class 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(described_class).to respond_to(:instances)
+      expect(provider_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
-      expect(subject).to receive(:pkgin).with("-y", :install, "vim").once()
+      subject.expects(: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
-      expect(subject).to receive(:pkgin).with("-y", :install, "vim-7.2.446").once()
+      subject.expects(:pkgin).with("-y", :install, "vim-7.2.446").once()
       subject.install
     end
    end
+
   end
 
   describe "#uninstall" do
     it "uses pkgin remove to uninstall" do
-      expect(subject).to receive(:pkgin).with("-y", :remove, "vim").once()
+      subject.expects(:pkgin).with("-y", :remove, "vim").once()
       subject.uninstall
     end
   end
@@ -43,19 +45,19 @@ describe Puppet::Type.type(:package).provider(:pkgin) do
     end
 
     before do
-      allow(described_class).to receive(:pkgin).with(:list).and_return(pkgin_ls_output)
+      provider_class.stubs(:pkgin).with(:list).returns(pkgin_ls_output)
     end
 
     it "returns an array of providers for each package" do
-      instances = described_class.instances
+      instances = provider_class.instances
       expect(instances).to have(2).items
       instances.each do |instance|
-        expect(instance).to be_a(described_class)
+        expect(instance).to be_a(provider_class)
       end
     end
 
     it "populates each provider with an installed package" do
-      zlib_provider, zziplib_provider = described_class.instances
+      zlib_provider, zziplib_provider = provider_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")
@@ -65,7 +67,7 @@ describe Puppet::Type.type(:package).provider(:pkgin) do
 
   describe "#latest" do
     before do
-      allow(described_class).to receive(:pkgin).with(:search, "vim").and_return(pkgin_search_output)
+      provider_class.stubs(:pkgin).with(:search, "vim").returns(pkgin_search_output)
     end
 
     context "when the package is installed" do
@@ -74,7 +76,7 @@ describe Puppet::Type.type(:package).provider(:pkgin) do
       end
 
       it "returns installed version" do
-        expect(subject).to receive(:properties).and_return({ :ensure => "7.2.446" })
+        subject.expects(:properties).returns( { :ensure => "7.2.446" } )
         expect(subject.latest).to eq("7.2.446")
       end
     end
@@ -95,7 +97,7 @@ describe Puppet::Type.type(:package).provider(:pkgin) do
       end
 
       it "returns current version" do
-        expect(subject).to receive(:properties).and_return({ :ensure => "7.2.446" })
+        subject.expects(:properties).returns( { :ensure => "7.2.446" } )
         expect(subject.latest).to eq("7.2.446")
       end
     end
@@ -117,7 +119,7 @@ SEARCH
       end
 
       it "returns the newest available version" do
-        allow(described_class).to receive(:pkgin).with(:search, "vim").and_return(pkgin_search_output)
+        provider_class.stubs(:pkgin).with(:search, "vim").returns(pkgin_search_output)
         expect(subject.latest).to eq("7.3")
       end
     end
@@ -138,7 +140,7 @@ SEARCH
       let(:package) { "vim-7.2.446;=;Vim editor (vi clone) without GUI" }
 
       it "extracts the name and status" do
-        expect(described_class.parse_pkgin_line(package)).to eq({ :name => "vim" ,
+        expect(provider_class.parse_pkgin_line(package)).to eq({ :name => "vim" ,
                                                              :status => "=" ,
                                                              :ensure => "7.2.446" })
       end
@@ -148,7 +150,7 @@ SEARCH
       let(:package) { "ruby18-puppet-0.25.5nb1;>;Configuration management framework written in Ruby" }
 
       it "extracts the name and status" do
-        expect(described_class.parse_pkgin_line(package)).to eq({ :name =>  "ruby18-puppet",
+        expect(provider_class.parse_pkgin_line(package)).to eq({ :name =>  "ruby18-puppet",
                                                              :status => ">" ,
                                                              :ensure => "0.25.5nb1" })
       end
@@ -158,7 +160,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(described_class.parse_pkgin_line(package)).to eq({ :name =>  "ruby200-facter",
+        expect(provider_class.parse_pkgin_line(package)).to eq({ :name =>  "ruby200-facter",
                                                              :status => "=" ,
                                                              :ensure => "2.4.3nb1" })
       end
@@ -168,17 +170,18 @@ SEARCH
       let(:package) { "vim-7.2.446;Vim editor (vi clone) without GUI" }
 
       it "extracts the name and status" do
-        expect(described_class.parse_pkgin_line(package)).to eq({ :name => "vim" ,
+        expect(provider_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(described_class.parse_pkgin_line(package)).to be_nil
+        expect(provider_class.parse_pkgin_line(package)).to be_nil
       end
     end
   end

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

@@ -1,7 +1,10 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/provider/package/pkgng'
 
-describe Puppet::Type.type(:package).provider(:pkgng) do
+provider_class = Puppet::Type.type(:package).provider(:pkgng)
+
+describe provider_class do
   let(:name) { 'bash' }
   let(:installed_name) { 'zsh' }
   let(:pkgng) { 'pkgng' }
@@ -28,48 +31,49 @@ 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
-    allow(described_class).to receive(:command).with(:pkg).and_return('/usr/local/sbin/pkg')
+    provider_class.stubs(:command).with(:pkg) { '/usr/local/sbin/pkg' }
 
     info = File.read(my_fixture('pkg.info'))
-    allow(described_class).to receive(:get_query).and_return(info)
+    provider_class.stubs(:get_query).returns(info)
 
     version_list = File.read(my_fixture('pkg.version'))
-    allow(described_class).to receive(:get_version_list).and_return(version_list)
+    provider_class.stubs(:get_version_list).returns(version_list)
   end
 
   context "#instances" do
     it "should return the empty set if no packages are listed" do
-      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
+      provider_class.stubs(:get_query).returns('')
+      provider_class.stubs(:get_version_list).returns('')
+      expect(provider_class.instances).to be_empty
     end
 
     it "should return all packages when invoked" do
-      expect(described_class.instances.map(&:name).sort).to eq(
-        %w{ca_root_nss curl nmap pkg gnupg mcollective zsh tac_plus}.sort)
+      expect(provider_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 = described_class.instances.find {|i| i.properties[:origin] == 'security/nmap' }
+      nmap = provider_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
-      allow(described_class).to receive(:get_query).and_raise(Puppet::ExecutionFailure, 'An error occurred.')
-      expect(described_class.instances).to eq([])
+      provider_class.stubs(:get_query).raises(Puppet::ExecutionFailure, 'An error occurred.')
+      expect(provider_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')
+        zsh = provider_class.instances.find {|i| i.properties[:origin] == 'shells/zsh' }
+        expect( zsh.properties[:version]).to eq('5.0.2_1')
       end
     end
   end
@@ -81,8 +85,8 @@ describe Puppet::Type.type(:package).provider(:pkgng) do
         :provider => :pkgng,
         :ensure   => '7.33.1'
       )
-      expect(resource.provider).to receive(:pkg) do |arg|
-        expect(arg).to include('curl-7.33.1')
+      resource.provider.expects(:pkg) do |arg|
+        arg.should include('curl-7.33.1')
       end
       resource.provider.install
     end
@@ -93,8 +97,8 @@ describe Puppet::Type.type(:package).provider(:pkgng) do
         :provider => :pkgng,
         :ensure   => '7.33.1'
       )
-      expect(resource.provider).to receive(:pkg) do |arg|
-        expect(arg).to include('curl-7.33.1')
+      resource.provider.expects(:pkg) do |arg|
+        arg.should include('curl-7.33.1')
       end
       resource.provider.install
     end
@@ -105,32 +109,8 @@ describe Puppet::Type.type(:package).provider(:pkgng) do
         :provider => :pkgng,
         :source   => 'urn:freebsd:repo: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')
+      resource.provider.expects(:pkg) do |arg|
+        arg.should include('FreeBSD')
       end
       resource.provider.install
     end
@@ -138,32 +118,32 @@ describe Puppet::Type.type(:package).provider(:pkgng) do
 
   context "#prefetch" do
     it "should fail gracefully when " do
-      allow(described_class).to receive(:instances).and_return([])
-      expect{ described_class.prefetch({}) }.to_not raise_error
+      provider_class.stubs(:instances).returns([])
+      expect{ provider_class.prefetch({}) }.to_not raise_error
     end
   end
 
   context "#query" do
     it "should return the installed version if present" do
-      described_class.prefetch({installed_name => installed_resource})
+      provider_class.prefetch({installed_name => installed_resource})
       expect(installed_provider.query).to eq({:version=>'5.0.2_1'})
     end
 
     it "should return nil if not present" do
       fixture = File.read(my_fixture('pkg.query_absent'))
-      allow(described_class).to receive(:get_resource_info).with('bash').and_return(fixture)
+      provider_class.stubs(:get_resource_info).with('bash').returns(fixture)
       expect(provider.query).to equal(nil)
     end
   end
 
   describe "latest" do
     it "should retrieve the correct version of the latest package" do
-      described_class.prefetch( { installed_name => installed_resource })
+      provider_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 = described_class.instances
+      instances = provider_class.instances
       curl = instances.find {|i| i.properties[:origin] == 'ftp/curl' }
       expect(curl.properties[:latest]).to eq('7.33.0_2')
     end
@@ -175,7 +155,7 @@ describe Puppet::Type.type(:package).provider(:pkgng) do
         :ensure   => :latest
       )
 
-      expect(resource.provider).to receive(:update)
+      resource.provider.expects(:update)
 
       resource.property(:ensure).sync
     end
@@ -184,34 +164,22 @@ 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'))
-      nmap_latest_version = described_class.get_latest_version('security/nmap', version_list)
+      nmap_latest_version = provider_class.get_latest_version('security/nmap', version_list)
       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 = described_class.get_latest_version('shells/bash-completion', version_list)
+      bash_comp_latest_version = provider_class.get_latest_version('shells/bash-completion', version_list)
       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'))
-      orphan_latest_version = described_class.get_latest_version('sysutils/orphan', version_list)
-      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'))
-      broken_latest_version = described_class.get_latest_version('sysutils/broken', version_list)
-      expect(broken_latest_version).to be_nil
-    end
   end
 
   describe "confine" do
     context "on FreeBSD" do
       it "should be the default provider" do
-        expect(Facter).to receive(:value).with(:operatingsystem).at_least(:once).and_return(:freebsd)
-        expect(described_class).to be_default
+        Facter.expects(:value).with(:operatingsystem).at_least_once.returns :freebsd
+        expect(provider_class).to be_default
       end
     end
   end