puppet 6.0.10-x64-mingw32 → 6.1.0-x64-mingw32

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", "-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)
+      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

@@ -13,18 +13,16 @@ 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
-      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
@@ -32,7 +30,7 @@ describe Puppet::Type.type(:package).provider(:pkgin) do
 
   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,7 +41,7 @@ describe Puppet::Type.type(:package).provider(:pkgin) do
     end
 
     before do
-      allow(described_class).to receive(:pkgin).with(:list).and_return(pkgin_ls_output)
+      described_class.stubs(:pkgin).with(:list).returns(pkgin_ls_output)
     end
 
     it "returns an array of providers for each package" do
@@ -65,7 +63,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)
+      described_class.stubs(:pkgin).with(:search, "vim").returns(pkgin_search_output)
     end
 
     context "when the package is installed" do
@@ -74,7 +72,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 +93,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 +115,7 @@ SEARCH
       end
 
       it "returns the newest available version" do
-        allow(described_class).to receive(:pkgin).with(:search, "vim").and_return(pkgin_search_output)
+        described_class.stubs(:pkgin).with(:search, "vim").returns(pkgin_search_output)
         expect(subject.latest).to eq("7.3")
       end
     end

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

@@ -28,25 +28,26 @@ 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')
+    described_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)
+    info = File.read(my_fixture('pkg.query'))
+    described_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)
+    described_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('')
+      described_class.stubs(:get_query).returns('')
+      described_class.stubs(:get_version_list).returns('')
       expect(described_class.instances).to be_empty
     end
 
@@ -62,14 +63,14 @@ describe Puppet::Type.type(:package).provider(:pkgng) do
     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.')
+      described_class.stubs(:get_query).raises(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
@@ -81,8 +82,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 +94,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,8 +106,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')
+      resource.provider.expects(:pkg) do |arg|
+        arg.should include('FreeBSD')
       end
       resource.provider.install
     end
@@ -114,20 +115,22 @@ 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([])
+      described_class.stubs(:instances).returns([])
       expect{ described_class.prefetch({}) }.to_not raise_error
     end
   end
 
   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)
       described_class.prefetch({installed_name => installed_resource})
-      expect(installed_provider.query).to eq({:version=>'5.0.2_1'})
+      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'))
-      allow(described_class).to receive(:get_resource_info).with('bash').and_return(fixture)
+      described_class.stubs(:get_resource_info).with('bash').raises(Puppet::ExecutionFailure, 'An error occurred')
+
       expect(provider.query).to equal(nil)
     end
   end
@@ -145,13 +148,15 @@ 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')
+
       resource = Puppet::Type.type(:package).new(
         :name     => 'ftp/curl',
         :provider => pkgng,
         :ensure   => :latest
       )
 
-      expect(resource.provider).to receive(:update)
+      resource.provider.expects(:update)
 
       resource.property(:ensure).sync
     end
@@ -160,13 +165,17 @@ 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)
+      described_class.stubs(:get_version_list).returns(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 = described_class.get_latest_version('shells/bash-completion', version_list)
+      described_class.stubs(:get_version_list).returns(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
   end
@@ -174,7 +183,7 @@ describe Puppet::Type.type(:package).provider(:pkgng) do
   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)
+        Facter.expects(:value).with(:operatingsystem).at_least_once.returns :freebsd
         expect(described_class).to be_default
       end
     end

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

@@ -1,16 +1,19 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
-describe Puppet::Type.type(:package).provider(:pkgutil) do
+provider = Puppet::Type.type(:package).provider(:pkgutil)
+
+describe provider do
   before(:each) do
     @resource = Puppet::Type.type(:package).new(
       :name     => "TESTpkg",
       :ensure   => :present,
       :provider => :pkgutil
     )
-    @provider = described_class.new(@resource)
+    @provider = provider.new(@resource)
 
     # Stub all file and config tests
-    allow(described_class).to receive(:healthcheck)
+    provider.stubs(:healthcheck)
   end
 
   it "should have an install method" do
@@ -32,59 +35,59 @@ describe Puppet::Type.type(:package).provider(:pkgutil) do
   describe "when installing" do
     it "should use a command without versioned package" do
       @resource[:ensure] = :latest
-      expect(@provider).to receive(:pkguti).with('-y', '-i', 'TESTpkg')
+      @provider.expects(: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"
-      expect(@provider).to receive(:pkguti).with('-t', 'http://example.net/repo', '-y', '-i', 'TESTpkg')
+      @provider.expects(: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' ]
-      expect(@provider).to receive(:pkguti).with('-t', 'http://example.net/repo', '-t', 'http://example.net/foo', '-y', '-i', 'TESTpkg')
+      @provider.expects(: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
-      expect(@provider).to receive(:pkguti).with('-y', '-u', 'TESTpkg')
+      @provider.expects(:pkguti).with('-y', '-u', 'TESTpkg')
       @provider.update
     end
 
     it "should support a single temp repo URL" do
       @resource[:source] = "http://example.net/repo"
-      expect(@provider).to receive(:pkguti).with('-t', 'http://example.net/repo', '-y', '-u', 'TESTpkg')
+      @provider.expects(: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' ]
-      expect(@provider).to receive(:pkguti).with('-t', 'http://example.net/repo', '-t', 'http://example.net/foo', '-y', '-u', 'TESTpkg')
+      @provider.expects(: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
-      expect(@provider).to receive(:pkguti).with('-y', '-r', 'TESTpkg')
+      @provider.expects(:pkguti).with('-y', '-r', 'TESTpkg')
       @provider.uninstall
     end
 
     it "should support a single temp repo URL" do
       @resource[:source] = "http://example.net/repo"
-      expect(@provider).to receive(:pkguti).with('-t', 'http://example.net/repo', '-y', '-r', 'TESTpkg')
+      @provider.expects(: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' ]
-      expect(@provider).to receive(:pkguti).with('-t', 'http://example.net/repo', '-t', 'http://example.net/foo', '-y', '-r', 'TESTpkg')
+      @provider.expects(:pkguti).with('-t', 'http://example.net/repo', '-t', 'http://example.net/foo', '-y', '-r', 'TESTpkg')
       @provider.uninstall
     end
   end
@@ -94,7 +97,7 @@ describe Puppet::Type.type(:package).provider(:pkgutil) do
       fake_data = "
 noisy output here
 TESTpkg                   1.4.5,REV=2007.11.18      1.4.5,REV=2007.11.20"
-      expect(described_class).to receive(:pkguti).with('-c', '--single', 'TESTpkg').and_return(fake_data)
+      provider.expects(:pkguti).with('-c', '--single', 'TESTpkg').returns fake_data
       expect(@provider.latest).to eq("1.4.5,REV=2007.11.20")
     end
 
@@ -103,7 +106,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"
-      expect(described_class).to receive(:pkguti).with('-t', 'http://example.net/repo', '-c', '--single', 'TESTpkg').and_return(fake_data)
+      provider.expects(:pkguti).with('-t', 'http://example.net/repo', '-c', '--single', 'TESTpkg').returns fake_data
       expect(@provider.latest).to eq("1.4.5,REV=2007.11.20")
     end
 
@@ -111,19 +114,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"
-      expect(described_class).to receive(:pkguti).with('-c', '--single', 'TESTpkg').and_return(fake_data)
+      provider.expects(:pkguti).with('-c', '--single', 'TESTpkg').returns 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"
-      expect(described_class).to receive(:pkguti).with('-c', '--single', 'TESTpkg').and_return(fake_data)
+      provider.expects(:pkguti).with('-c', '--single', 'TESTpkg').returns fake_data
       expect(@provider.latest).to eq(nil)
     end
 
     it "should warn on unknown pkgutil noise" do
-      expect(described_class).to receive(:pkguti).with('-c', '--single', 'TESTpkg').and_return("testingnoise")
+      provider.expects(:pkguti).with('-c', '--single', 'TESTpkg').returns("testingnoise")
       expect(@provider.latest).to eq(nil)
     end
 
@@ -137,7 +140,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"
-      expect(described_class).to receive(:pkguti).with('-c', '--single', 'TESTpkg').and_return(fake_data)
+      provider.expects(:pkguti).with('-c', '--single', 'TESTpkg').returns fake_data
       expect(@provider.latest).to eq("1.4.5,REV=2007.11.20")
     end
 
@@ -145,7 +148,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"
-      expect(described_class).to receive(:pkguti).with('-c', '--single', 'TESTpkg').and_return(fake_data)
+      provider.expects(:pkguti).with('-c', '--single', 'TESTpkg').returns fake_data
       expect(@provider.query[:name]).to eq("TESTpkg")
     end
   end
@@ -153,79 +156,80 @@ 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"
-      expect(described_class).to receive(:pkguti).with('-c', '--single', 'TESTpkg').and_return(fake_data)
+      provider.expects(:pkguti).with('-c', '--single', 'TESTpkg').returns 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"
-      expect(described_class).to receive(:pkguti).with('-c', '--single', 'TESTpkg').and_return(fake_data)
+      provider.expects(:pkguti).with('-c', '--single', 'TESTpkg').returns 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"
-      expect(described_class).to receive(:pkguti).with('-c', '--single', 'TESTpkg').and_return(fake_data)
+      provider.expects(:pkguti).with('-c', '--single', 'TESTpkg').returns 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"
-      expect(described_class).to receive(:pkguti).with('-t', 'http://example.net/repo', '-c', '--single', 'TESTpkg').and_return(fake_data)
+      provider.expects(:pkguti).with('-t', 'http://example.net/repo', '-c', '--single', 'TESTpkg').returns 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
-      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([])
+      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([])
     end
 
     it "should return TESTpkg's version string" do
       fake_data = "TESTpkg  TESTpkg  1.4.5,REV=2007.11.20"
-      expect(described_class).to receive(:pkguti).with(['-a']).and_return(fake_data)
+      provider.expects(:pkguti).with(['-a']).returns fake_data
 
       fake_data = "TESTpkg  1.4.5,REV=2007.11.18  1.4.5,REV=2007.11.20"
-      expect(described_class).to receive(:pkguti).with(['-c']).and_return(fake_data)
+      provider.expects(:pkguti).with(['-c']).returns fake_data
 
-      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])
+      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])
     end
 
     it "should also return both TESTpkg and mypkg alias instances" do
       fake_data = "mypkg  TESTpkg  1.4.5,REV=2007.11.20"
-      expect(described_class).to receive(:pkguti).with(['-a']).and_return(fake_data)
+      provider.expects(:pkguti).with(['-a']).returns fake_data
 
       fake_data = "TESTpkg  1.4.5,REV=2007.11.18  1.4.5,REV=2007.11.20"
-      expect(described_class).to receive(:pkguti).with(['-c']).and_return(fake_data)
+      provider.expects(:pkguti).with(['-c']).returns fake_data
 
-      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)
+      testpkg = mock 'pkg1'
+      provider.expects(:new).with(:ensure => "1.4.5,REV=2007.11.18", :name => "TESTpkg", :provider => :pkgutil).returns testpkg
 
-      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)
+      aliaspkg = mock 'pkg2'
+      provider.expects(:new).with(:ensure => "1.4.5,REV=2007.11.18", :name => "mypkg", :provider => :pkgutil).returns aliaspkg
 
-      expect(described_class.instances).to eq([testpkg,aliaspkg])
+      expect(provider.instances).to eq([testpkg,aliaspkg])
     end
 
     it "shouldn't mind noise in the -a output" do
       fake_data = "noisy output here"
-      expect(described_class).to receive(:pkguti).with(['-a']).and_return(fake_data)
+      provider.expects(:pkguti).with(['-a']).returns fake_data
 
       fake_data = "TESTpkg  1.4.5,REV=2007.11.18  1.4.5,REV=2007.11.20"
-      expect(described_class).to receive(:pkguti).with(['-c']).and_return(fake_data)
+      provider.expects(:pkguti).with(['-c']).returns fake_data
 
-      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)
+      testpkg = mock 'pkg1'
+      provider.expects(:new).with(:ensure => "1.4.5,REV=2007.11.18", :name => "TESTpkg", :provider => :pkgutil).returns testpkg
 
-      expect(described_class.instances).to eq([testpkg])
+      expect(provider.instances).to eq([testpkg])
     end
   end
+
 end