puppet 6.4.0-universal-darwin → 6.4.1-universal-darwin

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

@@ -3,18 +3,18 @@ require 'spec_helper'
 describe Puppet::Type.type(:package).provider(:hpux) do
   before(:each) do
     # Create a mock resource
-    @resource = stub 'resource'
+    @resource = double('resource')
 
     # A catch all; no parameters set
-    @resource.stubs(:[]).returns(nil)
+    allow(@resource).to receive(:[]).and_return(nil)
 
     # But set name and source
-    @resource.stubs(:[]).with(:name).returns "mypackage"
-    @resource.stubs(:[]).with(:source).returns "mysource"
-    @resource.stubs(:[]).with(:ensure).returns :installed
+    allow(@resource).to receive(:[]).with(:name).and_return("mypackage")
+    allow(@resource).to receive(:[]).with(:source).and_return("mysource")
+    allow(@resource).to receive(:[]).with(:ensure).and_return(:installed)
 
     @provider = subject()
-    @provider.stubs(:resource).returns @resource
+    allow(@provider).to receive(:resource).and_return(@resource)
   end
 
   it "should have an install method" do
@@ -34,14 +34,14 @@ describe Puppet::Type.type(:package).provider(:hpux) do
 
   context "when installing" do
     it "should use a command-line like 'swinstall -x mount_all_filesystems=false -s SOURCE PACKAGE-NAME'" do
-      @provider.expects(:swinstall).with('-x', 'mount_all_filesystems=false', '-s', 'mysource', 'mypackage')
+      expect(@provider).to receive(:swinstall).with('-x', 'mount_all_filesystems=false', '-s', 'mysource', 'mypackage')
       @provider.install
     end
   end
 
   context "when uninstalling" do
     it "should use a command-line like 'swremove -x mount_all_filesystems=false PACKAGE-NAME'" do
-      @provider.expects(:swremove).with('-x', 'mount_all_filesystems=false', 'mypackage')
+      expect(@provider).to receive(:swremove).with('-x', 'mount_all_filesystems=false', 'mypackage')
       @provider.uninstall
     end
   end

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

@@ -11,7 +11,7 @@ describe Puppet::Type.type(:package).provider(:macports) do
 
   let :provider do
     prov = resource.provider
-    prov.expects(:execute).never
+    expect(prov).not_to receive(:execute)
     prov
   end
 
@@ -30,17 +30,17 @@ describe Puppet::Type.type(:package).provider(:macports) do
 
   context "when listing all instances" do
     it "should call port -q installed" do
-      described_class.expects(:port).with("-q", :installed).returns("")
+      expect(described_class).to receive(:port).with("-q", :installed).and_return("")
       described_class.instances
     end
 
     it "should create instances from active ports" do
-      described_class.expects(:port).returns("foo @1.234.5_2 (active)")
+      expect(described_class).to receive(:port).and_return("foo @1.234.5_2 (active)")
       expect(described_class.instances.size).to eq(1)
     end
 
     it "should ignore ports that aren't activated" do
-      described_class.expects(:port).returns("foo @1.234.5_2")
+      expect(described_class).to receive(:port).and_return("foo @1.234.5_2")
       expect(described_class.instances.size).to eq(0)
     end
 
@@ -52,68 +52,72 @@ describe Puppet::Type.type(:package).provider(:macports) do
   end
 
   context "when installing" do
-   it "should not specify a version when ensure is set to latest" do
-     resource[:ensure] = :latest
-     provider.expects(:port).with { |flag, method, name, version|
-       expect(version).to be_nil
-     }
-     provider.install
-   end
-
-   it "should not specify a version when ensure is set to present" do
-     resource[:ensure] = :present
-     provider.expects(:port).with { |flag, method, name, version|
-       expect(version).to be_nil
-     }
-     provider.install
-   end
-
-   it "should specify a version when ensure is set to a version" do
-     resource[:ensure] = "1.2.3"
-     provider.expects(:port).with { |flag, method, name, version|
-       expect(version).to be
-     }
-     provider.install
-   end
+    it "should not specify a version when ensure is set to latest" do
+      resource[:ensure] = :latest
+      # version would be the 4th argument, if provided.
+      expect(provider).to receive(:port).with(anything, anything, anything)
+
+      provider.install
+    end
+
+    it "should not specify a version when ensure is set to present" do
+      resource[:ensure] = :present
+      # version would be the 4th argument, if provided.
+      expect(provider).to receive(:port).with(anything, anything, anything)
+
+      provider.install
+    end
+
+    it "should specify a version when ensure is set to a version" do
+      resource[:ensure] = "1.2.3"
+      expect(provider).to receive(:port).with(anything, anything, anything, '@1.2.3')
+
+      provider.install
+    end
   end
 
   context "when querying for the latest version" do
-    let :new_info_line do
+    # Redefine provider to avoid the "expect(prov).not_to receive(:execute)"
+    # that was set in the original definition.
+    let(:provider) { resource.provider }
+    let(:new_info_line) do
       "1.2.3 2"
     end
-    let :infoargs do
+    let(:infoargs) do
       ["/opt/local/bin/port", "-q", :info, "--line", "--version", "--revision",  resource_name]
     end
-    let(:arguments) do {:failonfail => false, :combine => false} end
+    let(:arguments) do
+      {:failonfail => false, :combine => false}
+    end
 
     before :each do
-      provider.stubs(:command).with(:port).returns("/opt/local/bin/port")
+      allow(provider).to receive(:command).with(:port).and_return("/opt/local/bin/port")
     end
 
     it "should return nil when the package cannot be found" do
       resource[:name] = resource_name
-      provider.expects(:execute).with(infoargs, arguments).returns("")
+      expect(provider).to receive(:execute).with(infoargs, arguments).and_return("")
       expect(provider.latest).to eq(nil)
     end
 
     it "should return the current version if the installed port has the same revision" do
       current_hash[:revision] = "2"
-      provider.expects(:execute).with(infoargs, arguments).returns(new_info_line)
-      provider.expects(:query).returns(current_hash)
+      expect(provider).to receive(:execute).with(infoargs, arguments).and_return(new_info_line)
+      expect(provider).to receive(:query).and_return(current_hash)
       expect(provider.latest).to eq(current_hash[:ensure])
     end
 
     it "should return the new version_revision if the installed port has a lower revision" do
       current_hash[:revision] = "1"
-      provider.expects(:execute).with(infoargs, arguments).returns(new_info_line)
-      provider.expects(:query).returns(current_hash)
+      expect(provider).to receive(:execute).with(infoargs, arguments).and_return(new_info_line)
+      expect(provider).to receive(:query).and_return(current_hash)
       expect(provider.latest).to eq("1.2.3_2")
     end
 
     it "should return the newest version if the port is not installed" do
       resource[:name] = resource_name
-      provider.expects(:execute).with(infoargs, arguments).returns(new_info_line)
-      provider.expects(:execute).with(["/opt/local/bin/port", "-q", :installed, resource[:name]], arguments).returns("")
+      expect(provider).to receive(:execute).with(infoargs, arguments).and_return(new_info_line)
+      expect(provider).to receive(:execute).with(["/opt/local/bin/port", "-q", :installed, resource[:name]], arguments).and_return("")
       expect(provider.latest).to eq("1.2.3_2")
     end
   end
@@ -122,16 +126,16 @@ describe Puppet::Type.type(:package).provider(:macports) do
     it "should execute port install if the port is installed" do
       resource[:name] = resource_name
       resource[:ensure] = :present
-      provider.stubs(:query).returns(current_hash)
-      provider.expects(:port).with("-q", :install, resource_name)
+      allow(provider).to receive(:query).and_return(current_hash)
+      expect(provider).to receive(:port).with("-q", :install, resource_name)
       provider.update
     end
 
     it "should execute port install if the port is not installed" do
       resource[:name] = resource_name
       resource[:ensure] = :present
-      provider.stubs(:query).returns("")
-      provider.expects(:port).with("-q", :install, resource_name)
+      allow(provider).to receive(:query).and_return("")
+      expect(provider).to receive(:port).with("-q", :install, resource_name)
       provider.update
     end
   end

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

@@ -2,16 +2,15 @@ require 'spec_helper'
 
 describe Puppet::Type.type(:package).provider(:nim) do
   before(:each) do
-    # Create a mock resource
-    @resource = stub 'resource'
+    @resource = double('resource')
 
     # A catch all; no parameters set
-    @resource.stubs(:[]).returns(nil)
+    allow(@resource).to receive(:[]).and_return(nil)
 
     # But set name and source
-    @resource.stubs(:[]).with(:name).returns "mypackage.foo"
-    @resource.stubs(:[]).with(:source).returns "mysource"
-    @resource.stubs(:[]).with(:ensure).returns :installed
+    allow(@resource).to receive(:[]).with(:name).and_return("mypackage.foo")
+    allow(@resource).to receive(:[]).with(:source).and_return("mysource")
+    allow(@resource).to receive(:[]).with(:ensure).and_return(:installed)
 
     @provider = subject()
     @provider.resource = @resource
@@ -44,9 +43,9 @@ END
 
   context "when installing" do
     it "should install a package" do
-      @resource.stubs(:should).with(:ensure).returns(:installed)
-      Puppet::Util::Execution.expects(:execute).with("/usr/sbin/nimclient -o showres -a resource=mysource |/usr/bin/grep -p -E 'mypackage\\.foo'").returns(bff_showres_output)
-      @provider.expects(:nimclient).with("-o", "cust", "-a", "installp_flags=acgwXY", "-a", "lpp_source=mysource", "-a", "filesets=mypackage.foo 1.2.3.8")
+      allow(@resource).to receive(:should).with(:ensure).and_return(:installed)
+      expect(Puppet::Util::Execution).to receive(:execute).with("/usr/sbin/nimclient -o showres -a resource=mysource |/usr/bin/grep -p -E 'mypackage\\.foo'").and_return(bff_showres_output)
+      expect(@provider).to receive(:nimclient).with("-o", "cust", "-a", "installp_flags=acgwXY", "-a", "lpp_source=mysource", "-a", "filesets=mypackage.foo 1.2.3.8")
       @provider.install
     end
 
@@ -54,25 +53,21 @@ END
       it "should fail if the package is not available on the lpp source" do
         nimclient_showres_output = ""
 
-        @resource.stubs(:should).with(:ensure).returns("1.2.3.4")
-        Puppet::Util::Execution.expects(:execute).with("/usr/sbin/nimclient -o showres -a resource=mysource |/usr/bin/grep -p -E 'mypackage\\.foo( |-)1\\.2\\.3\\.4'").returns(nimclient_showres_output)
+        allow(@resource).to receive(:should).with(:ensure).and_return("1.2.3.4")
+        expect(Puppet::Util::Execution).to receive(:execute).with("/usr/sbin/nimclient -o showres -a resource=mysource |/usr/bin/grep -p -E 'mypackage\\.foo( |-)1\\.2\\.3\\.4'").and_return(nimclient_showres_output)
         expect {
           @provider.install
         }.to raise_error(Puppet::Error, "Unable to find package 'mypackage.foo' with version '1.2.3.4' on lpp_source 'mysource'")
       end
 
       it "should succeed if a BFF/installp package is available on the lpp source" do
-        nimclient_sequence = sequence('nimclient')
-
-        @resource.stubs(:should).with(:ensure).returns("1.2.3.4")
-        Puppet::Util::Execution.expects(:execute).with("/usr/sbin/nimclient -o showres -a resource=mysource |/usr/bin/grep -p -E 'mypackage\\.foo( |-)1\\.2\\.3\\.4'").returns(bff_showres_output).in_sequence(nimclient_sequence)
-        @provider.expects(:nimclient).with("-o", "cust", "-a", "installp_flags=acgwXY", "-a", "lpp_source=mysource", "-a", "filesets=mypackage.foo 1.2.3.4").in_sequence(nimclient_sequence)
+        allow(@resource).to receive(:should).with(:ensure).and_return("1.2.3.4")
+        expect(Puppet::Util::Execution).to receive(:execute).with("/usr/sbin/nimclient -o showres -a resource=mysource |/usr/bin/grep -p -E 'mypackage\\.foo( |-)1\\.2\\.3\\.4'").and_return(bff_showres_output).ordered
+        expect(@provider).to receive(:nimclient).with("-o", "cust", "-a", "installp_flags=acgwXY", "-a", "lpp_source=mysource", "-a", "filesets=mypackage.foo 1.2.3.4").ordered
         @provider.install
       end
 
       it "should fail if the specified version of a BFF package is superseded" do
-        nimclient_sequence = sequence('nimclient')
-
         install_output = <<OUTPUT
 +-----------------------------------------------------------------------------+
                     Pre-installation Verification...
@@ -118,26 +113,22 @@ Name                      Level           Pre-installation Failure/Warning
 mypackage.foo              1.2.3.1         Already superseded by 1.2.3.4
 OUTPUT
 
-        @resource.stubs(:should).with(:ensure).returns("1.2.3.1")
-        Puppet::Util::Execution.expects(:execute).with("/usr/sbin/nimclient -o showres -a resource=mysource |/usr/bin/grep -p -E 'mypackage\\.foo( |-)1\\.2\\.3\\.1'").returns(bff_showres_output).in_sequence(nimclient_sequence)
-        @provider.expects(:nimclient).with("-o", "cust", "-a", "installp_flags=acgwXY", "-a", "lpp_source=mysource", "-a", "filesets=mypackage.foo 1.2.3.1").in_sequence(nimclient_sequence).returns(install_output)
+        allow(@resource).to receive(:should).with(:ensure).and_return("1.2.3.1")
+        expect(Puppet::Util::Execution).to receive(:execute).with("/usr/sbin/nimclient -o showres -a resource=mysource |/usr/bin/grep -p -E 'mypackage\\.foo( |-)1\\.2\\.3\\.1'").and_return(bff_showres_output).ordered
+        expect(@provider).to receive(:nimclient).with("-o", "cust", "-a", "installp_flags=acgwXY", "-a", "lpp_source=mysource", "-a", "filesets=mypackage.foo 1.2.3.1").and_return(install_output).ordered
 
         expect { @provider.install }.to raise_error(Puppet::Error, "NIM package provider is unable to downgrade packages")
     end
 
     it "should succeed if an RPM package is available on the lpp source" do
-        nimclient_sequence = sequence('nimclient')
-
-        @resource.stubs(:should).with(:ensure).returns("1.2.3-4")
-        Puppet::Util::Execution.expects(:execute).with("/usr/sbin/nimclient -o showres -a resource=mysource |/usr/bin/grep -p -E 'mypackage\\.foo( |-)1\\.2\\.3\\-4'").returns(rpm_showres_output).in_sequence(nimclient_sequence)
-        @provider.expects(:nimclient).with("-o", "cust", "-a", "installp_flags=acgwXY", "-a", "lpp_source=mysource", "-a", "filesets=mypackage.foo-1.2.3-4").in_sequence(nimclient_sequence)
+        allow(@resource).to receive(:should).with(:ensure).and_return("1.2.3-4")
+        expect(Puppet::Util::Execution).to receive(:execute).with("/usr/sbin/nimclient -o showres -a resource=mysource |/usr/bin/grep -p -E 'mypackage\\.foo( |-)1\\.2\\.3\\-4'").and_return(rpm_showres_output).ordered
+        expect(@provider).to receive(:nimclient).with("-o", "cust", "-a", "installp_flags=acgwXY", "-a", "lpp_source=mysource", "-a", "filesets=mypackage.foo-1.2.3-4").ordered
         @provider.install
       end
     end
 
     it "should fail if the specified version of a RPM package is superseded" do
-      nimclient_sequence = sequence('nimclient')
-
       install_output = <<OUTPUT
 
 
@@ -155,9 +146,9 @@ mypackage.foo-1.2.3-1 is superseded by mypackage.foo-1.2.3-4
 
 OUTPUT
 
-      @resource.stubs(:should).with(:ensure).returns("1.2.3-1")
-      Puppet::Util::Execution.expects(:execute).with("/usr/sbin/nimclient -o showres -a resource=mysource |/usr/bin/grep -p -E 'mypackage\\.foo( |-)1\\.2\\.3\\-1'").returns(rpm_showres_output).in_sequence(nimclient_sequence)
-      @provider.expects(:nimclient).with("-o", "cust", "-a", "installp_flags=acgwXY", "-a", "lpp_source=mysource", "-a", "filesets=mypackage.foo-1.2.3-1").in_sequence(nimclient_sequence).returns(install_output)
+      allow(@resource).to receive(:should).with(:ensure).and_return("1.2.3-1")
+      expect(Puppet::Util::Execution).to receive(:execute).with("/usr/sbin/nimclient -o showres -a resource=mysource |/usr/bin/grep -p -E 'mypackage\\.foo( |-)1\\.2\\.3\\-1'").and_return(rpm_showres_output)
+      expect(@provider).to receive(:nimclient).with("-o", "cust", "-a", "installp_flags=acgwXY", "-a", "lpp_source=mysource", "-a", "filesets=mypackage.foo-1.2.3-1").and_return(install_output)
 
       expect { @provider.install }.to raise_error(Puppet::Error, "NIM package provider is unable to downgrade packages")
     end
@@ -165,16 +156,16 @@ OUTPUT
 
   context "when uninstalling" do
     it "should call installp to uninstall a bff package" do
-      @provider.expects(:lslpp).with("-qLc", "mypackage.foo").returns("#bos.atm:bos.atm.atmle:7.1.2.0: : :C: :ATM LAN Emulation Client Support : : : : : : :0:0:/:1241")
-      @provider.expects(:installp).with("-gu", "mypackage.foo")
-      @provider.class.expects(:pkglist).with(:pkgname => 'mypackage.foo').returns(nil)
+      expect(@provider).to receive(:lslpp).with("-qLc", "mypackage.foo").and_return("#bos.atm:bos.atm.atmle:7.1.2.0: : :C: :ATM LAN Emulation Client Support : : : : : : :0:0:/:1241")
+      expect(@provider).to receive(:installp).with("-gu", "mypackage.foo")
+      expect(@provider.class).to receive(:pkglist).with(:pkgname => 'mypackage.foo').and_return(nil)
       @provider.uninstall
     end
 
     it "should call rpm to uninstall an rpm package" do
-      @provider.expects(:lslpp).with("-qLc", "mypackage.foo").returns("cdrecord:cdrecord-1.9-6:1.9-6: : :C:R:A command line CD/DVD recording program.: :/bin/rpm -e cdrecord: : : : :0: :/opt/freeware:Wed Jun 29 09:41:32 PDT 2005")
-      @provider.expects(:rpm).with("-e", "mypackage.foo")
-      @provider.class.expects(:pkglist).with(:pkgname => 'mypackage.foo').returns(nil)
+      expect(@provider).to receive(:lslpp).with("-qLc", "mypackage.foo").and_return("cdrecord:cdrecord-1.9-6:1.9-6: : :C:R:A command line CD/DVD recording program.: :/bin/rpm -e cdrecord: : : : :0: :/opt/freeware:Wed Jun 29 09:41:32 PDT 2005")
+      expect(@provider).to receive(:rpm).with("-e", "mypackage.foo")
+      expect(@provider.class).to receive(:pkglist).with(:pkgname => 'mypackage.foo').and_return(nil)
       @provider.uninstall
     end
   end
@@ -202,7 +193,7 @@ OUTPUT
       end
     end
 
-    describe "#determine_latest_version" do
+    context "#determine_latest_version" do
       context "when there are multiple versions" do
         it "should return the latest version" do
           expect(subject.send(:determine_latest_version, rpm_showres_output, 'mypackage.foo')).to eq([:rpm, '1.2.3-8'])
@@ -221,7 +212,7 @@ END
       end
     end
 
-    describe "#determine_package_type" do
+    context "#determine_package_type" do
       it "should return :rpm for rpm packages" do
         expect(subject.send(:determine_package_type, rpm_showres_output, 'mypackage.foo', '1.2.3-4')).to eq(:rpm)
       end

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

@@ -6,28 +6,25 @@ describe Puppet::Type.type(:package).provider(:openbsd) do
   let(:provider) { described_class.new(package) }
 
   def expect_read_from_pkgconf(lines)
-    pkgconf = stub(:readlines => lines)
-    Puppet::FileSystem.expects(:exist?).with('/etc/pkg.conf').returns(true)
-    File.expects(:open).with('/etc/pkg.conf', 'rb').returns(pkgconf)
+    pkgconf = double(:readlines => lines)
+    expect(Puppet::FileSystem).to receive(:exist?).with('/etc/pkg.conf').and_return(true)
+    expect(File).to receive(:open).with('/etc/pkg.conf', 'rb').and_return(pkgconf)
   end
 
   def expect_pkgadd_with_source(source)
-    provider.expects(:pkgadd).with do |fullname|
-      expect(ENV).not_to be_key('PKG_PATH')
-      expect(fullname).to eq([source])
+    expect(provider).to receive(:pkgadd).with([source]) do
+      expect(ENV).not_to have_key('PKG_PATH')
     end
   end
 
   def expect_pkgadd_with_env_and_name(source, &block)
-    expect(ENV).not_to be_key('PKG_PATH')
+    expect(ENV).not_to have_key('PKG_PATH')
 
-    provider.expects(:pkgadd).with do |fullname|
-      expect(ENV).to be_key('PKG_PATH')
+    expect(provider).to receive(:pkgadd).with([provider.resource[:name]]) do
+      expect(ENV).to have_key('PKG_PATH')
       expect(ENV['PKG_PATH']).to eq(source)
-
-      expect(fullname).to eq([provider.resource[:name]])
     end
-    provider.expects(:execpipe).with(['/bin/pkg_info', '-I', provider.resource[:name]]).yields('')
+    expect(provider).to receive(:execpipe).with(['/bin/pkg_info', '-I', provider.resource[:name]]).and_yield('')
 
     yield
 
@@ -46,25 +43,25 @@ describe Puppet::Type.type(:package).provider(:openbsd) do
   before :each do
     # Stub some provider methods to avoid needing the actual software
     # installed, so we can test on whatever platform we want.
-    described_class.stubs(:command).with(:pkginfo).returns('/bin/pkg_info')
-    described_class.stubs(:command).with(:pkgadd).returns('/bin/pkg_add')
-    described_class.stubs(:command).with(:pkgdelete).returns('/bin/pkg_delete')
+    allow(described_class).to receive(:command).with(:pkginfo).and_return('/bin/pkg_info')
+    allow(described_class).to receive(:command).with(:pkgadd).and_return('/bin/pkg_add')
+    allow(described_class).to receive(:command).with(:pkgdelete).and_return('/bin/pkg_delete')
   end
 
   context "#instances" do
     it "should return nil if execution failed" do
-      described_class.expects(:execpipe).raises(Puppet::ExecutionFailure, 'wawawa')
+      expect(described_class).to receive(:execpipe).and_raise(Puppet::ExecutionFailure, 'wawawa')
       expect(described_class.instances).to be_nil
     end
 
     it "should return the empty set if no packages are listed" do
-      described_class.expects(:execpipe).with(%w{/bin/pkg_info -a}).yields(StringIO.new(''))
+      expect(described_class).to receive(:execpipe).with(%w{/bin/pkg_info -a}).and_yield(StringIO.new(''))
       expect(described_class.instances).to be_empty
     end
 
     it "should return all packages when invoked" do
       fixture = File.read(my_fixture('pkginfo.list'))
-      described_class.expects(:execpipe).with(%w{/bin/pkg_info -a}).yields(fixture)
+      expect(described_class).to receive(:execpipe).with(%w{/bin/pkg_info -a}).and_yield(fixture)
       expect(described_class.instances.map(&:name).sort).to eq(
         %w{bash bzip2 expat gettext libiconv lzo openvpn python vim wget}.sort
       )
@@ -72,7 +69,7 @@ describe Puppet::Type.type(:package).provider(:openbsd) do
 
     it "should return all flavors if set" do
       fixture = File.read(my_fixture('pkginfo_flavors.list'))
-      described_class.expects(:execpipe).with(%w{/bin/pkg_info -a}).yields(fixture)
+      expect(described_class).to receive(:execpipe).with(%w{/bin/pkg_info -a}).and_yield(fixture)
       instances = described_class.instances.map {|p| {:name => p.get(:name),
         :ensure => p.get(:ensure), :flavor => p.get(:flavor)}}
       expect(instances.size).to eq(2)
@@ -83,7 +80,7 @@ describe Puppet::Type.type(:package).provider(:openbsd) do
 
   context "#install" do
     it "should fail if the resource doesn't have a source" do
-      Puppet::FileSystem.expects(:exist?).with('/etc/pkg.conf').returns(false)
+      expect(Puppet::FileSystem).to receive(:exist?).with('/etc/pkg.conf').and_return(false)
 
       expect {
         provider.install
@@ -91,8 +88,8 @@ describe Puppet::Type.type(:package).provider(:openbsd) do
     end
 
     it "should fail if /etc/pkg.conf exists, but is not readable" do
-      Puppet::FileSystem.expects(:exist?).with('/etc/pkg.conf').returns(true)
-      File.expects(:open).with('/etc/pkg.conf', 'rb').raises(Errno::EACCES)
+      expect(Puppet::FileSystem).to receive(:exist?).with('/etc/pkg.conf').and_return(true)
+      expect(File).to receive(:open).with('/etc/pkg.conf', 'rb').and_raise(Errno::EACCES)
 
       expect {
         provider.install
@@ -235,7 +232,7 @@ describe Puppet::Type.type(:package).provider(:openbsd) do
     it 'should use install_options as Array' do
       provider.resource[:source] = '/tma1/'
       provider.resource[:install_options] = ['-r', '-z']
-      provider.expects(:pkgadd).with(['-r', '-z', 'bash'])
+      expect(provider).to receive(:pkgadd).with(['-r', '-z', 'bash'])
       provider.install
     end
   end
@@ -244,31 +241,31 @@ describe Puppet::Type.type(:package).provider(:openbsd) do
     before do
       provider.resource[:source] = '/tmp/tcsh.tgz'
       provider.resource[:name] = 'tcsh'
-      provider.stubs(:pkginfo).with('tcsh')
+      allow(provider).to receive(:pkginfo).with('tcsh')
     end
 
     it "should return the ensure value if the package is already installed" do
-      provider.stubs(:properties).returns({:ensure => '4.2.45'})
-      provider.stubs(:pkginfo).with('-Q', 'tcsh')
+      allow(provider).to receive(:properties).and_return({:ensure => '4.2.45'})
+      allow(provider).to receive(:pkginfo).with('-Q', 'tcsh')
       expect(provider.latest).to eq('4.2.45')
     end
 
     it "should recognize a new version" do
       pkginfo_query = 'tcsh-6.18.01p1'
-      provider.stubs(:pkginfo).with('-Q', 'tcsh').returns(pkginfo_query)
+      allow(provider).to receive(:pkginfo).with('-Q', 'tcsh').and_return(pkginfo_query)
       expect(provider.latest).to eq('6.18.01p1')
     end
 
     it "should recognize a newer version" do
-      provider.stubs(:properties).returns({:ensure => '1.6.8'})
+      allow(provider).to receive(:properties).and_return({:ensure => '1.6.8'})
       pkginfo_query = 'tcsh-1.6.10'
-      provider.stubs(:pkginfo).with('-Q', 'tcsh').returns(pkginfo_query)
+      allow(provider).to receive(:pkginfo).with('-Q', 'tcsh').and_return(pkginfo_query)
       expect(provider.latest).to eq('1.6.10')
     end
 
     it "should recognize a package that is already the newest" do
       pkginfo_query = 'tcsh-6.18.01p0 (installed)'
-      provider.stubs(:pkginfo).with('-Q', 'tcsh').returns(pkginfo_query)
+      allow(provider).to receive(:pkginfo).with('-Q', 'tcsh').and_return(pkginfo_query)
       expect(provider.latest).to eq('6.18.01p0')
     end
   end
@@ -294,7 +291,7 @@ describe Puppet::Type.type(:package).provider(:openbsd) do
 
     it "should lookup the correct version" do
       output = 'bash-3.1.17         GNU Bourne Again Shell'
-      provider.expects(:execpipe).with(%w{/bin/pkg_info -I bash}).yields(output)
+      expect(provider).to receive(:execpipe).with(%w{/bin/pkg_info -I bash}).and_yield(output)
       expect(provider.get_full_name).to eq('bash-3.1.17')
     end
 
@@ -302,26 +299,26 @@ describe Puppet::Type.type(:package).provider(:openbsd) do
       provider.resource[:name] = 'fossil'
       provider.resource[:flavor] = 'static'
       output = 'fossil-1.29v0-static simple distributed software configuration management'
-      provider.expects(:execpipe).with(%w{/bin/pkg_info -I fossil}).yields(output)
+      expect(provider).to receive(:execpipe).with(%w{/bin/pkg_info -I fossil}).and_yield(output)
       expect(provider.get_full_name).to eq('fossil-1.29v0-static')
     end
   end
 
   context "#get_version" do
     it "should return nil if execution fails" do
-      provider.expects(:execpipe).raises(Puppet::ExecutionFailure, 'wawawa')
+      expect(provider).to receive(:execpipe).and_raise(Puppet::ExecutionFailure, 'wawawa')
       expect(provider.get_version).to be_nil
     end
 
     it "should return the package version if in the output" do
       output = 'bash-3.1.17         GNU Bourne Again Shell'
-      provider.expects(:execpipe).with(%w{/bin/pkg_info -I bash}).yields(output)
+      expect(provider).to receive(:execpipe).with(%w{/bin/pkg_info -I bash}).and_yield(output)
       expect(provider.get_version).to eq('3.1.17')
     end
 
     it "should return the empty string if the package is not present" do
       provider.resource[:name] = 'zsh'
-      provider.expects(:execpipe).with(%w{/bin/pkg_info -I zsh}).yields(StringIO.new(''))
+      expect(provider).to receive(:execpipe).with(%w{/bin/pkg_info -I zsh}).and_yield(StringIO.new(''))
       expect(provider.get_version).to eq('')
     end
   end
@@ -329,13 +326,13 @@ describe Puppet::Type.type(:package).provider(:openbsd) do
   context "#query" do
     it "should return the installed version if present" do
       fixture = File.read(my_fixture('pkginfo.detail'))
-      provider.expects(:pkginfo).with('bash').returns(fixture)
+      expect(provider).to receive(:pkginfo).with('bash').and_return(fixture)
       expect(provider.query).to eq({ :ensure => '3.1.17' })
     end
 
     it "should return nothing if not present" do
       provider.resource[:name] = 'zsh'
-      provider.expects(:pkginfo).with('zsh').returns('')
+      expect(provider).to receive(:pkginfo).with('zsh').and_return('')
       expect(provider.query).to be_nil
     end
   end
@@ -385,7 +382,7 @@ describe Puppet::Type.type(:package).provider(:openbsd) do
   context "#uninstall" do
     describe 'when uninstalling' do
       it 'should use erase to purge' do
-        provider.expects(:pkgdelete).with('-c', '-q', 'bash')
+        expect(provider).to receive(:pkgdelete).with('-c', '-q', 'bash')
         provider.purge
       end
     end
@@ -393,7 +390,7 @@ describe Puppet::Type.type(:package).provider(:openbsd) do
     describe 'with uninstall_options' do
       it 'should use uninstall_options as Array' do
         provider.resource[:uninstall_options] = ['-q', '-c']
-        provider.expects(:pkgdelete).with(['-q', '-c'], 'bash')
+        expect(provider).to receive(:pkgdelete).with(['-q', '-c'], 'bash')
         provider.uninstall
       end
     end