puppet 6.0.7-x64-mingw32 → 6.0.8-x64-mingw32

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

@@ -17,7 +17,7 @@ describe Puppet::Type.type(:package).provider(:apt) do
   end
 
   it "should be the default provider on :osfamily => Debian" do
-    Facter.expects(:value).with(:osfamily).returns("Debian")
+    expect(Facter).to receive(:value).with(:osfamily).and_return("Debian")
     expect(described_class.default?).to be_truthy
   end
 
@@ -26,38 +26,40 @@ describe Puppet::Type.type(:package).provider(:apt) do
   end
 
   it "should use :install to update" do
-    provider.expects(:install)
+    expect(provider).to receive(:install)
     provider.update
   end
 
   it "should use 'apt-get remove' to uninstall" do
-    provider.expects(:aptget).with("-y", "-q", :remove, name)
+    expect(provider).to receive(:aptget).with("-y", "-q", :remove, name)
     provider.uninstall
   end
 
   it "should use 'apt-get purge' and 'dpkg purge' to purge" do
-    provider.expects(:aptget).with("-y", "-q", :remove, "--purge", name)
-    provider.expects(:dpkg).with("--purge", name)
+    expect(provider).to receive(:aptget).with("-y", "-q", :remove, "--purge", name)
+    expect(provider).to receive(:dpkg).with("--purge", name)
     provider.purge
   end
 
   it "should use 'apt-cache policy' to determine the latest version of a package" do
-    provider.expects(:aptcache).with(:policy, name).returns "#{name}:
+    expect(provider).to receive(:aptcache).with(:policy, name).and_return(<<-HERE)
+#{name}:
 Installed: 1:1.0
 Candidate: 1:1.1
 Version table:
 1:1.0
   650 http://ftp.osuosl.org testing/main Packages
 *** 1:1.1
-  100 /var/lib/dpkg/status"
+  100 /var/lib/dpkg/status
+    HERE
 
     expect(provider.latest).to eq("1:1.1")
   end
 
   it "should print and error and return nil if no policy is found" do
-    provider.expects(:aptcache).with(:policy, name).returns "#{name}:"
+    expect(provider).to receive(:aptcache).with(:policy, name).and_return("#{name}:")
 
-    provider.expects(:err)
+    expect(provider).to receive(:err)
     expect(provider.latest).to be_nil
   end
 
@@ -67,17 +69,17 @@ Version table:
 
   it "should preseed with the provided responsefile when preseeding is called for" do
     resource[:responsefile] = '/my/file'
-    Puppet::FileSystem.expects(:exist?).with('/my/file').returns true
+    expect(Puppet::FileSystem).to receive(:exist?).with('/my/file').and_return(true)
 
-    provider.expects(:info)
-    provider.expects(:preseed).with('/my/file')
+    expect(provider).to receive(:info)
+    expect(provider).to receive(:preseed).with('/my/file')
 
     provider.run_preseed
   end
 
   it "should not preseed if no responsefile is provided" do
-    provider.expects(:info)
-    provider.expects(:preseed).never
+    expect(provider).to receive(:info)
+    expect(provider).not_to receive(:preseed)
 
     provider.run_preseed
   end
@@ -85,76 +87,91 @@ Version table:
   describe "when installing" do
     it "should preseed if a responsefile is provided" do
       resource[:responsefile] = "/my/file"
-      provider.expects(:run_preseed)
+      expect(provider).to receive(:run_preseed)
 
-      provider.stubs(:aptget)
+      allow(provider).to receive(:aptget)
       provider.install
     end
 
     it "should check for a cdrom" do
-      provider.expects(:checkforcdrom)
+      expect(provider).to receive(:checkforcdrom)
 
-      provider.stubs(:aptget)
+      allow(provider).to receive(:aptget)
       provider.install
     end
 
     it "should use 'apt-get install' with the package name if no version is asked for" do
       resource[:ensure] = :installed
-      provider.expects(:aptget).with { |*command| command[-1] == name and command[-2] == :install }
+      expect(provider).to receive(:aptget) do |*command|
+        expect(command[-1]).to eq(name)
+        expect(command[-2]).to eq(:install)
+      end
 
       provider.install
     end
 
     it "should specify the package version if one is asked for" do
       resource[:ensure] = '1.0'
-      provider.expects(:aptget).with { |*command| command[-1] == "#{name}=1.0" }
+      expect(provider).to receive(:aptget) do |*command|
+        expect(command[-1]).to eq("#{name}=1.0")
+      end
 
       provider.install
     end
 
     it "should use --force-yes if a package version is specified" do
       resource[:ensure] = '1.0'
-      provider.expects(:aptget).with { |*command| command.include?("--force-yes") }
+      expect(provider).to receive(:aptget) do |*command|
+        expect(command).to include("--force-yes")
+      end
 
       provider.install
     end
 
     it "should do a quiet install" do
-      provider.expects(:aptget).with { |*command| command.include?("-q") }
+      expect(provider).to receive(:aptget) do |*command|
+        expect(command).to include("-q")
+      end
 
       provider.install
     end
 
     it "should default to 'yes' for all questions" do
-      provider.expects(:aptget).with { |*command| command.include?("-y") }
+      expect(provider).to receive(:aptget) do |*command|
+        expect(command).to include("-y")
+      end
 
       provider.install
     end
 
     it "should keep config files if asked" do
       resource[:configfiles] = :keep
-      provider.expects(:aptget).with { |*command| command.include?("DPkg::Options::=--force-confold") }
+      expect(provider).to receive(:aptget) do |*command|
+        expect(command).to include("DPkg::Options::=--force-confold")
+      end
 
       provider.install
     end
 
     it "should replace config files if asked" do
       resource[:configfiles] = :replace
-      provider.expects(:aptget).with { |*command| command.include?("DPkg::Options::=--force-confnew") }
+      expect(provider).to receive(:aptget) do |*command|
+        expect(command).to include("DPkg::Options::=--force-confnew")
+      end
 
       provider.install
     end
 
     it 'should support string install options' do
       resource[:install_options] = ['--foo', '--bar']
-      provider.expects(:aptget).with('-q', '-y', '-o', 'DPkg::Options::=--force-confold', '--foo', '--bar', :install, name)
+      expect(provider).to receive(:aptget).with('-q', '-y', '-o', 'DPkg::Options::=--force-confold', '--foo', '--bar', :install, name)
 
       provider.install
     end
 
     it 'should support hash install options' do
       resource[:install_options] = ['--foo', { '--bar' => 'baz', '--baz' => 'foo' }]
-      provider.expects(:aptget).with('-q', '-y', '-o', 'DPkg::Options::=--force-confold', '--foo', '--bar=baz', '--baz=foo', :install, name)
+      expect(provider).to receive(:aptget).with('-q', '-y', '-o', 'DPkg::Options::=--force-confold', '--foo', '--bar=baz', '--baz=foo', :install, name)
 
       provider.install
     end

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

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 describe Puppet::Type.type(:package).provider(:aptitude) do
@@ -13,17 +12,17 @@ describe Puppet::Type.type(:package).provider(:aptitude) do
     let(:dpkgquery_path) { '/bin/dpkg-query' }
 
     before do
-      Puppet::Util.stubs(:which).with('/usr/bin/dpkg-query').returns(dpkgquery_path)
+      allow(Puppet::Util).to receive(:which).with('/usr/bin/dpkg-query').and_return(dpkgquery_path)
     end
 
     { :absent   => "deinstall ok config-files faff 1.2.3-1\n",
       "1.2.3-1" => "install ok installed faff 1.2.3-1\n",
     }.each do |expect, output|
       it "detects #{expect} packages" do
-        Puppet::Util::Execution.expects(:execute).with(
+        expect(Puppet::Util::Execution).to receive(:execute).with(
           [dpkgquery_path, '-W', '--showformat', "'${Status} ${Package} ${Version}\\n'", 'faff'],
           {:failonfail => true, :combine => true, :custom_environment => {}}
-        ).returns(Puppet::Util::Execution::ProcessOutput.new(output, 0))
+        ).and_return(Puppet::Util::Execution::ProcessOutput.new(output, 0))
 
         expect(pkg.property(:ensure).retrieve).to eq(expect)
       end
@@ -31,15 +30,15 @@ describe Puppet::Type.type(:package).provider(:aptitude) do
   end
 
   it "installs when asked" do
-    pkg.provider.expects(:aptitude).
+    expect(pkg.provider).to receive(:aptitude).
       with('-y', '-o', 'DPkg::Options::=--force-confold', :install, 'faff').
-      returns(0)
+      and_return(0)
 
     pkg.provider.install
   end
 
   it "purges when asked" do
-    pkg.provider.expects(:aptitude).with('-y', 'purge', 'faff').returns(0)
+    expect(pkg.provider).to receive(:aptitude).with('-y', 'purge', 'faff').and_return(0)
     pkg.provider.purge
   end
 end

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

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 describe Puppet::Type.type(:package).provider(:aptrpm) do
@@ -11,37 +10,33 @@ describe Puppet::Type.type(:package).provider(:aptrpm) do
 
   context "when retrieving ensure" do
     before(:each) do
-      Puppet::Util.stubs(:which).with("rpm").returns("/bin/rpm")
-      pkg.provider.stubs(:which).with("rpm").returns("/bin/rpm")
-      Puppet::Util::Execution.expects(:execute).with(["/bin/rpm", "--version"], {:combine => true, :custom_environment => {}, :failonfail => true}).returns(Puppet::Util::Execution::ProcessOutput.new("4.10.1\n", 0)).at_most_once
+      allow(Puppet::Util).to receive(:which).with("rpm").and_return("/bin/rpm")
+      allow(pkg.provider).to receive(:which).with("rpm").and_return("/bin/rpm")
+      expect(Puppet::Util::Execution).to receive(:execute).with(["/bin/rpm", "--version"], {:combine => true, :custom_environment => {}, :failonfail => true}).and_return(Puppet::Util::Execution::ProcessOutput.new("4.10.1\n", 0)).at_most(:once)
     end
 
     def rpm_args
       ['-q', 'faff', '--nosignature', '--nodigest', '--qf', "'%{NAME} %|EPOCH?{%{EPOCH}}:{0}| %{VERSION} %{RELEASE} %{ARCH}\\n'"]
     end
 
-    def rpm(args = rpm_args)
-      pkg.provider.expects(:rpm).with(*args)
-    end
-
     it "should report purged packages" do
-      rpm.raises(Puppet::ExecutionFailure, "couldn't find rpm")
+      expect(pkg.provider).to receive(:rpm).and_raise(Puppet::ExecutionFailure, "couldn't find rpm")
       expect(pkg.property(:ensure).retrieve).to eq(:purged)
     end
 
     it "should report present packages correctly" do
-      rpm.returns("faff-1.2.3-1 0 1.2.3-1 5 i686\n")
+      expect(pkg.provider).to receive(:rpm).and_return("faff-1.2.3-1 0 1.2.3-1 5 i686\n")
       expect(pkg.property(:ensure).retrieve).to eq("1.2.3-1-5")
     end
   end
 
   it "should try and install when asked" do
-    pkg.provider.expects(:aptget). with('-q', '-y', 'install', 'faff'). returns(0)
+    expect(pkg.provider).to receive(:aptget).with('-q', '-y', 'install', 'faff').and_return(0)
     pkg.provider.install
   end
 
   it "should try and purge when asked" do
-    pkg.provider.expects(:aptget).with('-y', '-q', 'remove', '--purge', 'faff').returns(0)
+    expect(pkg.provider).to receive(:aptget).with('-y', '-q', 'remove', '--purge', 'faff').and_return(0)
     pkg.provider.purge
   end
 end

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

@@ -4,15 +4,15 @@ require 'puppet/provider/package'
 describe Puppet::Provider::Package do
   it 'returns absent for uninstalled packages when not purgeable' do
     provider = Puppet::Provider::Package.new
-    provider.expects(:query).returns nil
-    provider.class.expects(:feature?).with(:purgeable).returns false
+    expect(provider).to receive(:query).and_return(nil)
+    expect(provider.class).to receive(:feature?).with(:purgeable).and_return(false)
     expect(provider.properties[:ensure]).to eq(:absent)
   end
 
   it 'returns purged for uninstalled packages when purgeable' do
     provider = Puppet::Provider::Package.new
-    provider.expects(:query).returns nil
-    provider.class.expects(:feature?).with(:purgeable).returns true
+    expect(provider).to receive(:query).and_return(nil)
+    expect(provider.class).to receive(:feature?).with(:purgeable).and_return(true)
     expect(provider.properties[:ensure]).to eq(:purged)
   end
 end

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

@@ -2,48 +2,46 @@ require 'spec_helper'
 
 # Note that much of the functionality of the dnf provider is already tested with yum provider tests,
 # as yum is the parent provider.
-
 describe Puppet::Type.type(:package).provider(:dnf) do
   context 'default' do
     (19..21).each do |ver|
       it "should not be the default provider on fedora#{ver}" do
-        Facter.stubs(:value).with(:osfamily).returns(:redhat)
-        Facter.stubs(:value).with(:operatingsystem).returns(:fedora)
-        Facter.stubs(:value).with(:operatingsystemmajrelease).returns("#{ver}")
+        allow(Facter).to receive(:value).with(:osfamily).and_return(:redhat)
+        allow(Facter).to receive(:value).with(:operatingsystem).and_return(:fedora)
+        allow(Facter).to receive(:value).with(:operatingsystemmajrelease).and_return("#{ver}")
         expect(described_class).to_not be_default
       end
     end
 
     (22..26).each do |ver|
       it "should be the default provider on fedora#{ver}" do
-        Facter.stubs(:value).with(:osfamily).returns(:redhat)
-        Facter.stubs(:value).with(:operatingsystem).returns(:fedora)
-        Facter.stubs(:value).with(:operatingsystemmajrelease).returns("#{ver}")
+        allow(Facter).to receive(:value).with(:osfamily).and_return(:redhat)
+        allow(Facter).to receive(:value).with(:operatingsystem).and_return(:fedora)
+        allow(Facter).to receive(:value).with(:operatingsystemmajrelease).and_return("#{ver}")
         expect(described_class).to be_default
       end
     end
 
     it "should not be the default provider on rhel7" do
-        Facter.stubs(:value).with(:osfamily).returns(:redhat)
-        Facter.stubs(:value).with(:operatingsystem).returns(:redhat)
-        Facter.stubs(:value).with(:operatingsystemmajrelease).returns("7")
-        expect(described_class).to_not be_default
+      allow(Facter).to receive(:value).with(:osfamily).and_return(:redhat)
+      allow(Facter).to receive(:value).with(:operatingsystem).and_return(:redhat)
+      allow(Facter).to receive(:value).with(:operatingsystemmajrelease).and_return("7")
+      expect(described_class).to_not be_default
     end
 
     it "should be the default provider on some random future fedora" do
-        Facter.stubs(:value).with(:osfamily).returns(:redhat)
-        Facter.stubs(:value).with(:operatingsystem).returns(:fedora)
-        Facter.stubs(:value).with(:operatingsystemmajrelease).returns("8675")
-        expect(described_class).to be_default
+      allow(Facter).to receive(:value).with(:osfamily).and_return(:redhat)
+      allow(Facter).to receive(:value).with(:operatingsystem).and_return(:fedora)
+      allow(Facter).to receive(:value).with(:operatingsystemmajrelease).and_return("8675")
+      expect(described_class).to be_default
     end
 
     it "should be the default provider on rhel8" do
-        Facter.stubs(:value).with(:osfamily).returns(:redhat)
-        Facter.stubs(:value).with(:operatingsystem).returns(:redhat)
-        Facter.stubs(:value).with(:operatingsystemmajrelease).returns("8")
-        expect(described_class).to be_default
+      allow(Facter).to receive(:value).with(:osfamily).and_return(:redhat)
+      allow(Facter).to receive(:value).with(:operatingsystem).and_return(:redhat)
+      allow(Facter).to receive(:value).with(:operatingsystemmajrelease).and_return("8")
+      expect(described_class).to be_default
     end
-
   end
 
   it_behaves_like 'RHEL package provider', described_class, 'dnf'

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

@@ -12,7 +12,7 @@ describe Puppet::Type.type(:package).provider(:dpkg) do
     {:failonfail => true, :combine => true, :custom_environment => {}}
   end
   let(:resource_name) { 'package' }
-  let(:resource) { stub 'resource', :[] => resource_name }
+  let(:resource) { double('resource', :[] => resource_name) }
   let(:provider) { described_class.new(resource) }
 
   it "has documentation" do
@@ -23,35 +23,35 @@ describe Puppet::Type.type(:package).provider(:dpkg) do
     let(:execpipe_args) { args.unshift('myquery') }
 
     before do
-      described_class.stubs(:command).with(:dpkgquery).returns 'myquery'
+      allow(described_class).to receive(:command).with(:dpkgquery).and_return('myquery')
     end
 
     it "creates and return an instance for a single dpkg-query entry" do
-      Puppet::Util::Execution.expects(:execpipe).with(execpipe_args).yields bash_installed_io
+      expect(Puppet::Util::Execution).to receive(:execpipe).with(execpipe_args).and_yield(bash_installed_io)
 
-      installed = mock 'bash'
-      described_class.expects(:new).with(:ensure => "4.2-5ubuntu3", :error => "ok", :desired => "install", :name => "bash", :status => "installed", :provider => :dpkg).returns installed
+      installed = double('bash')
+      expect(described_class).to receive(:new).with(:ensure => "4.2-5ubuntu3", :error => "ok", :desired => "install", :name => "bash", :status => "installed", :provider => :dpkg).and_return(installed)
 
       expect(described_class.instances).to eq([installed])
     end
 
     it "parses multiple dpkg-query multi-line entries in the output" do
-      Puppet::Util::Execution.expects(:execpipe).with(execpipe_args).yields all_installed_io
+      expect(Puppet::Util::Execution).to receive(:execpipe).with(execpipe_args).and_yield(all_installed_io)
 
-      bash = mock 'bash'
-      described_class.expects(:new).with(:ensure => "4.2-5ubuntu3", :error => "ok", :desired => "install", :name => "bash", :status => "installed", :provider => :dpkg).returns bash
-      vim = mock 'vim'
-      described_class.expects(:new).with(:ensure => "2:7.3.547-6ubuntu5", :error => "ok", :desired => "install", :name => "vim", :status => "installed", :provider => :dpkg).returns vim
+      bash = double('bash')
+      expect(described_class).to receive(:new).with(:ensure => "4.2-5ubuntu3", :error => "ok", :desired => "install", :name => "bash", :status => "installed", :provider => :dpkg).and_return(bash)
+      vim = double('vim')
+      expect(described_class).to receive(:new).with(:ensure => "2:7.3.547-6ubuntu5", :error => "ok", :desired => "install", :name => "vim", :status => "installed", :provider => :dpkg).and_return(vim)
 
       expect(described_class.instances).to eq([bash, vim])
     end
 
     it "continues without failing if it encounters bad lines between good entries" do
-      Puppet::Util::Execution.expects(:execpipe).with(execpipe_args).yields StringIO.new([bash_installed_output, "foobar\n", vim_installed_output].join)
+      expect(Puppet::Util::Execution).to receive(:execpipe).with(execpipe_args).and_yield(StringIO.new([bash_installed_output, "foobar\n", vim_installed_output].join))
 
-      bash = mock 'bash'
-      vim = mock 'vim'
-      described_class.expects(:new).twice.returns(bash, vim)
+      bash = double('bash')
+      vim = double('vim')
+      expect(described_class).to receive(:new).twice.and_return(bash, vim)
 
       expect(described_class.instances).to eq([bash, vim])
     end
@@ -65,15 +65,15 @@ describe Puppet::Type.type(:package).provider(:dpkg) do
     end
 
     def dpkg_query_execution_returns(output)
-      Puppet::Util::Execution.expects(:execute).with(query_args, execute_options).returns(Puppet::Util::Execution::ProcessOutput.new(output, 0))
+      expect(Puppet::Util::Execution).to receive(:execute).with(query_args, execute_options).and_return(Puppet::Util::Execution::ProcessOutput.new(output, 0))
     end
 
     before do
-      Puppet::Util.stubs(:which).with('/usr/bin/dpkg-query').returns(dpkgquery_path)
+      allow(Puppet::Util).to receive(:which).with('/usr/bin/dpkg-query').and_return(dpkgquery_path)
     end
 
     it "considers the package purged if dpkg-query fails" do
-      Puppet::Util::Execution.expects(:execute).with(query_args, execute_options).raises Puppet::ExecutionFailure.new("eh")
+      allow(Puppet::Util::Execution).to receive(:execute).with(query_args, execute_options).and_raise(Puppet::ExecutionFailure.new("eh"))
 
       expect(provider.query[:ensure]).to eq(:purged)
     end
@@ -147,8 +147,8 @@ describe Puppet::Type.type(:package).provider(:dpkg) do
 
       def parser_test(dpkg_output_string, gold_hash, number_of_debug_logs = 0)
         dpkg_query_execution_returns(dpkg_output_string)
-        Puppet.expects(:warning).never
-        Puppet.expects(:debug).times(number_of_debug_logs)
+        expect(Puppet).not_to receive(:warning)
+        expect(Puppet).to receive(:debug).exactly(number_of_debug_logs).times
 
         expect(provider.query).to eq(gold_hash)
       end
@@ -163,8 +163,8 @@ describe Puppet::Type.type(:package).provider(:dpkg) do
       end
 
       it "does not log if execution returns with non-zero exit code" do
-        Puppet::Util::Execution.expects(:execute).with(query_args, execute_options).raises Puppet::ExecutionFailure.new("failed")
-        Puppet::expects(:debug).never
+        expect(Puppet::Util::Execution).to receive(:execute).with(query_args, execute_options).and_raise(Puppet::ExecutionFailure.new("failed"))
+        expect(Puppet).not_to receive(:debug)
 
         expect(provider.query).to eq(package_not_found_hash)
       end
@@ -173,106 +173,106 @@ describe Puppet::Type.type(:package).provider(:dpkg) do
 
   context "when installing" do
     before do
-      resource.stubs(:[]).with(:source).returns "mypkg"
+      allow(resource).to receive(:[]).with(:source).and_return("mypkg")
     end
 
     it "fails to install if no source is specified in the resource" do
-      resource.expects(:[]).with(:source).returns nil
+      expect(resource).to receive(:[]).with(:source).and_return(nil)
 
       expect { provider.install }.to raise_error(ArgumentError)
     end
 
     it "uses 'dpkg -i' to install the package" do
-      resource.expects(:[]).with(:source).returns "mypackagefile"
-      provider.expects(:unhold)
-      provider.expects(:dpkg).with { |*command| command[-1] == "mypackagefile"  and command[-2] == "-i" }
+      expect(resource).to receive(:[]).with(:source).and_return("mypackagefile")
+      expect(provider).to receive(:unhold)
+      expect(provider).to receive(:dpkg).with(any_args, "-i", "mypackagefile")
 
       provider.install
     end
 
     it "keeps old config files if told to do so" do
-      resource.expects(:[]).with(:configfiles).returns :keep
-      provider.expects(:unhold)
-      provider.expects(:dpkg).with { |*command| command[0] == "--force-confold" }
+      expect(resource).to receive(:[]).with(:configfiles).and_return(:keep)
+      expect(provider).to receive(:unhold)
+      expect(provider).to receive(:dpkg).with("--force-confold", any_args)
 
       provider.install
     end
 
     it "replaces old config files if told to do so" do
-      resource.expects(:[]).with(:configfiles).returns :replace
-      provider.expects(:unhold)
-      provider.expects(:dpkg).with { |*command| command[0] == "--force-confnew" }
+      expect(resource).to receive(:[]).with(:configfiles).and_return(:replace)
+      expect(provider).to receive(:unhold)
+      expect(provider).to receive(:dpkg).with("--force-confnew", any_args)
 
       provider.install
     end
 
     it "ensures any hold is removed" do
-      provider.expects(:unhold).once
-      provider.expects(:dpkg)
+      expect(provider).to receive(:unhold).once
+      expect(provider).to receive(:dpkg)
       provider.install
     end
   end
 
   context "when holding or unholding" do
-    let(:tempfile) { stub 'tempfile', :print => nil, :close => nil, :flush => nil, :path => "/other/file" }
+    let(:tempfile) { double('tempfile', :print => nil, :close => nil, :flush => nil, :path => "/other/file") }
 
     before do
-      tempfile.stubs(:write)
-      Tempfile.stubs(:open).yields tempfile
+      allow(tempfile).to receive(:write)
+      allow(Tempfile).to receive(:open).and_yield(tempfile)
     end
 
     it "installs first if holding" do
-      provider.stubs(:execute)
-      provider.expects(:install).once
+      allow(provider).to receive(:execute)
+      expect(provider).to receive(:install).once
       provider.hold
     end
 
     it "executes dpkg --set-selections when holding" do
-      provider.stubs(:install)
-      provider.expects(:execute).with([:dpkg, '--set-selections'], {:failonfail => false, :combine => false, :stdinfile => tempfile.path}).once
+      allow(provider).to receive(:install)
+      expect(provider).to receive(:execute).with([:dpkg, '--set-selections'], {:failonfail => false, :combine => false, :stdinfile => tempfile.path}).once
       provider.hold
     end
 
     it "executes dpkg --set-selections when unholding" do
-      provider.stubs(:install)
-      provider.expects(:execute).with([:dpkg, '--set-selections'], {:failonfail => false, :combine => false, :stdinfile => tempfile.path}).once
+      allow(provider).to receive(:install)
+      expect(provider).to receive(:execute).with([:dpkg, '--set-selections'], {:failonfail => false, :combine => false, :stdinfile => tempfile.path}).once
       provider.hold
     end
   end
 
   it "uses :install to update" do
-    provider.expects(:install)
+    expect(provider).to receive(:install)
     provider.update
   end
 
   context "when determining latest available version" do
     it "returns the version found by dpkg-deb" do
-      resource.expects(:[]).with(:source).returns "myfile"
-      provider.expects(:dpkg_deb).with { |*command| command[-1] == "myfile" }.returns "package\t1.0"
+      expect(resource).to receive(:[]).with(:source).and_return("myfile")
+      expect(provider).to receive(:dpkg_deb).with(any_args, "myfile").and_return("package\t1.0")
       expect(provider.latest).to eq("1.0")
     end
 
     it "warns if the package file contains a different package" do
-      provider.expects(:dpkg_deb).returns("foo\tversion")
-      provider.expects(:warning)
+      expect(provider).to receive(:dpkg_deb).and_return("foo\tversion")
+      expect(provider).to receive(:warning)
       provider.latest
     end
 
     it "copes with names containing ++" do
-      resource = stub 'resource', :[] => "package++"
+      resource = double('resource', :[] => "package++")
       provider = described_class.new(resource)
-      provider.expects(:dpkg_deb).returns "package++\t1.0"
+      expect(provider).to receive(:dpkg_deb).and_return("package++\t1.0")
       expect(provider.latest).to eq("1.0")
     end
   end
 
   it "uses 'dpkg -r' to uninstall" do
-    provider.expects(:dpkg).with("-r", resource_name)
+    expect(provider).to receive(:dpkg).with("-r", resource_name)
     provider.uninstall
   end
 
   it "uses 'dpkg --purge' to purge" do
-    provider.expects(:dpkg).with("--purge", resource_name)
+    expect(provider).to receive(:dpkg).with("--purge", resource_name)
     provider.purge
   end
 end