puppet 5.5.12-x64-mingw32 → 5.5.13-x64-mingw32

data/spec/unit/provider/zfs/zfs_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 describe Puppet::Type.type(:zfs).provider(:zfs) do
@@ -12,7 +11,7 @@ describe Puppet::Type.type(:zfs).provider(:zfs) do
   let(:provider) { resource.provider }
 
   before do
-    provider.class.stubs(:which).with('zfs').returns(zfs)
+    allow(provider.class).to receive(:which).with('zfs').and_return(zfs)
   end
 
   context ".instances" do
@@ -21,7 +20,7 @@ describe Puppet::Type.type(:zfs).provider(:zfs) do
     end
 
     it "should list instances" do
-      provider.class.expects(:zfs).with(:list,'-H').returns File.read(my_fixture('zfs-list.out'))
+      expect(provider.class).to receive(:zfs).with(:list,'-H').and_return(File.read(my_fixture('zfs-list.out')))
       instances = provider.class.instances.map { |p| {:name => p.get(:name), :ensure => p.get(:ensure)} }
       expect(instances.size).to eq(2)
       expect(instances[0]).to eq({:name => 'rpool', :ensure => :present})
@@ -43,7 +42,7 @@ describe Puppet::Type.type(:zfs).provider(:zfs) do
 
   context "#create" do
     it "should execute zfs create" do
-      provider.expects(:zfs).with(:create, name)
+      expect(provider).to receive(:zfs).with(:create, name)
 
       provider.create
     end
@@ -53,7 +52,7 @@ describe Puppet::Type.type(:zfs).provider(:zfs) do
       it "should include property #{prop}" do
         resource[prop] = prop
 
-        provider.expects(:zfs).with(:create, '-o', "#{prop}=#{prop}", name)
+        expect(provider).to receive(:zfs).with(:create, '-o', "#{prop}=#{prop}", name)
 
         provider.create
       end
@@ -61,14 +60,14 @@ describe Puppet::Type.type(:zfs).provider(:zfs) do
 
     it "should use -V for the volsize property" do
       resource[:volsize] = "10"
-      provider.expects(:zfs).with(:create, '-V', "10", name)
+      expect(provider).to receive(:zfs).with(:create, '-V', "10", name)
       provider.create
     end
   end
 
   context "#destroy" do
     it "should execute zfs destroy" do
-      provider.expects(:zfs).with(:destroy, name)
+      expect(provider).to receive(:zfs).with(:destroy, name)
 
       provider.destroy
     end
@@ -77,13 +76,13 @@ describe Puppet::Type.type(:zfs).provider(:zfs) do
   context "#exists?" do
     it "should return true if the resource exists" do
       #return stuff because we have to slice and dice it
-      provider.expects(:zfs).with(:list, name)
+      expect(provider).to receive(:zfs).with(:list, name)
 
       expect(provider).to be_exists
     end
 
     it "should return false if returned values don't match the name" do
-      provider.expects(:zfs).with(:list, name).raises(Puppet::ExecutionFailure, "Failed")
+      expect(provider).to receive(:zfs).with(:list, name).and_raise(Puppet::ExecutionFailure, "Failed")
 
       expect(provider).not_to be_exists
     end
@@ -97,68 +96,74 @@ describe Puppet::Type.type(:zfs).provider(:zfs) do
      :secondarycache, :setuid, :shareiscsi, :sharenfs, :sharesmb,
      :snapdir, :version, :volsize, :vscan, :xattr].each do |prop|
       it "should get #{prop}" do
-        provider.expects(:zfs).with(:get, '-H', '-o', 'value', prop, name).returns("value\n")
+        expect(provider).to receive(:zfs).with(:get, '-H', '-o', 'value', prop, name).and_return("value\n")
 
         expect(provider.send(prop)).to eq('value')
       end
 
       it "should set #{prop}=value" do
-        provider.expects(:zfs).with(:set, "#{prop}=value", name)
+        expect(provider).to receive(:zfs).with(:set, "#{prop}=value", name)
 
         provider.send("#{prop}=", "value")
       end
     end
   end
+
   describe "zoned" do
     context "on FreeBSD" do
       before do
-        Facter.stubs(:value).with(:operatingsystem).returns("FreeBSD")
+        allow(Facter).to receive(:value).with(:operatingsystem).and_return("FreeBSD")
       end
+
       it "should get 'jailed' property" do
-        provider.expects(:zfs).with(:get, '-H', '-o', 'value', :jailed, name).returns("value\n")
+        expect(provider).to receive(:zfs).with(:get, '-H', '-o', 'value', :jailed, name).and_return("value\n")
         expect(provider.send("zoned")).to eq('value')
       end
 
       it "should set jalied=value" do
-        provider.expects(:zfs).with(:set, "jailed=value", name)
+        expect(provider).to receive(:zfs).with(:set, "jailed=value", name)
         provider.send("zoned=", "value")
       end
     end
 
     context "when not running FreeBSD" do
       before do
-        Facter.stubs(:value).with(:operatingsystem).returns("Solaris")
+        allow(Facter).to receive(:value).with(:operatingsystem).and_return("Solaris")
       end
+
       it "should get 'zoned' property" do
-        provider.expects(:zfs).with(:get, '-H', '-o', 'value', :zoned, name).returns("value\n")
+        expect(provider).to receive(:zfs).with(:get, '-H', '-o', 'value', :zoned, name).and_return("value\n")
         expect(provider.send("zoned")).to eq('value')
       end
 
       it "should set zoned=value" do
-        provider.expects(:zfs).with(:set, "zoned=value", name)
+        expect(provider).to receive(:zfs).with(:set, "zoned=value", name)
         provider.send("zoned=", "value")
       end
     end
   end
+
   describe "acltype" do
     context "when available" do
       it "should get 'acltype' property" do
-        provider.expects(:zfs).with(:get, '-H', '-o', 'value', :acltype, name).returns("value\n")
+        expect(provider).to receive(:zfs).with(:get, '-H', '-o', 'value', :acltype, name).and_return("value\n")
         expect(provider.send("acltype")).to eq('value')
       end
+
       it "should set acltype=value" do
-        provider.expects(:zfs).with(:set, "acltype=value", name)
+        expect(provider).to receive(:zfs).with(:set, "acltype=value", name)
         provider.send("acltype=", "value")
       end
     end
 
     context "when not available" do
       it "should get '-' for the acltype property" do
-        provider.expects(:zfs).with(:get, '-H', '-o', 'value', :acltype, name).raises(RuntimeError, 'not valid')
+        expect(provider).to receive(:zfs).with(:get, '-H', '-o', 'value', :acltype, name).and_raise(RuntimeError, 'not valid')
         expect(provider.send("acltype")).to eq('-')
       end
+
       it "should not error out when trying to set acltype" do
-        provider.expects(:zfs).with(:set, "acltype=value", name).raises(RuntimeError, 'not valid')
+        expect(provider).to receive(:zfs).with(:set, "acltype=value", name).and_raise(RuntimeError, 'not valid')
         expect{provider.send("acltype=", "value")}.to_not raise_error
       end
     end

data/spec/unit/provider/zone/solaris_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 describe Puppet::Type.type(:zone).provider(:solaris) do
@@ -7,19 +6,20 @@ describe Puppet::Type.type(:zone).provider(:solaris) do
 
   context "#configure" do
     it "should add the create args to the create str" do
-      resource.stubs(:properties).returns([])
+      allow(resource).to receive(:properties).and_return([])
       resource[:create_args] = "create_args"
-      provider.expects(:setconfig).with("create -b create_args")
+      expect(provider).to receive(:setconfig).with("create -b create_args")
       provider.configure
     end
+
     it "should add the create args to the create str" do
-      iptype = stub "property"
-      iptype.stubs(:name).with().returns(:iptype)
-      iptype.stubs(:safe_insync?).with(iptype).returns(false)
-      provider.stubs(:properties).returns({:iptype => iptype})
-      resource.stubs(:properties).with().returns([iptype])
+      iptype = double("property")
+      allow(iptype).to receive(:name).with(no_args).and_return(:iptype)
+      allow(iptype).to receive(:safe_insync?).with(iptype).and_return(false)
+      allow(provider).to receive(:properties).and_return({:iptype => iptype})
+      allow(resource).to receive(:properties).with(no_args).and_return([iptype])
       resource[:create_args] = "create_args"
-      provider.expects(:setconfig).with("create -b create_args\nset ip-type=shared")
+      expect(provider).to receive(:setconfig).with("create -b create_args\nset ip-type=shared")
       provider.configure
     end
   end
@@ -27,13 +27,13 @@ describe Puppet::Type.type(:zone).provider(:solaris) do
   context "#install" do
     context "clone" do
       it "should call zoneadm" do
-        provider.expects(:zoneadm).with(:install)
+        expect(provider).to receive(:zoneadm).with(:install)
         provider.install
       end
 
       it "with the resource's clone attribute" do
         resource[:clone] = :clone_argument
-        provider.expects(:zoneadm).with(:clone, :clone_argument)
+        expect(provider).to receive(:zoneadm).with(:clone, :clone_argument)
         provider.install
       end
     end
@@ -41,24 +41,25 @@ describe Puppet::Type.type(:zone).provider(:solaris) do
     context "not clone" do
       it "should just install if there are no install args" do
         # there is a nil check in type.rb:[]= so we cannot directly set nil.
-        resource.stubs(:[]).with(:clone).returns(nil)
-        resource.stubs(:[]).with(:install_args).returns(nil)
-        provider.expects(:zoneadm).with(:install)
+        allow(resource).to receive(:[]).with(:clone).and_return(nil)
+        allow(resource).to receive(:[]).with(:install_args).and_return(nil)
+        expect(provider).to receive(:zoneadm).with(:install)
         provider.install
       end
 
       it "should add the install args to the command if they exist" do
         # there is a nil check in type.rb:[]= so we cannot directly set nil.
-        resource.stubs(:[]).with(:clone).returns(nil)
-        resource.stubs(:[]).with(:install_args).returns('install args')
-        provider.expects(:zoneadm).with(:install, ["install", "args"])
+        allow(resource).to receive(:[]).with(:clone).and_return(nil)
+        allow(resource).to receive(:[]).with(:install_args).and_return('install args')
+        expect(provider).to receive(:zoneadm).with(:install, ["install", "args"])
         provider.install
       end
     end
   end
+
   context "#instances" do
     it "should list the instances correctly" do
-      described_class.expects(:adm).with(:list, "-cp").returns("0:dummy:running:/::native:shared")
+      expect(described_class).to receive(:adm).with(:list, "-cp").and_return("0:dummy:running:/::native:shared")
       instances = described_class.instances.map { |p| {:name => p.get(:name), :ensure => p.get(:ensure)} }
       expect(instances.size).to eq(1)
       expect(instances[0]).to eq({
@@ -67,23 +68,25 @@ describe Puppet::Type.type(:zone).provider(:solaris) do
       })
     end
   end
+
   context "#setconfig" do
     it "should correctly set configuration" do
-      provider.expects(:command).with(:cfg).returns('/usr/sbin/zonecfg')
-      provider.expects(:exec_cmd).with(:input => "set zonepath=/\ncommit\nexit", :cmd => '/usr/sbin/zonecfg -z dummy -f -').returns({:out=>'', :exit => 0})
+      expect(provider).to receive(:command).with(:cfg).and_return('/usr/sbin/zonecfg')
+      expect(provider).to receive(:exec_cmd).with(:input => "set zonepath=/\ncommit\nexit", :cmd => '/usr/sbin/zonecfg -z dummy -f -').and_return({:out=>'', :exit => 0})
       provider.setconfig("set zonepath=\/")
       provider.flush
     end
 
     it "should correctly warn on 'not allowed'" do
-      provider.expects(:command).with(:cfg).returns('/usr/sbin/zonecfg')
-      provider.expects(:exec_cmd).with(:input => "set zonepath=/\ncommit\nexit", :cmd => '/usr/sbin/zonecfg -z dummy -f -').returns({:out=>"Zone z2 already installed; set zonepath not allowed.\n", :exit => 0})
+      expect(provider).to receive(:command).with(:cfg).and_return('/usr/sbin/zonecfg')
+      expect(provider).to receive(:exec_cmd).with(:input => "set zonepath=/\ncommit\nexit", :cmd => '/usr/sbin/zonecfg -z dummy -f -').and_return({:out=>"Zone z2 already installed; set zonepath not allowed.\n", :exit => 0})
       provider.setconfig("set zonepath=\/")
       expect {
         provider.flush
       }.to raise_error(ArgumentError, /Failed to apply configuration/)
     end
   end
+
   context "#getconfig" do
     describe "with a shared iptype zone" do
       zone_info =<<-EOF
@@ -106,8 +109,9 @@ net:
         physical: ex0002
         defrouter not specified
       EOF
+
       it "should correctly parse zone info" do
-        provider.expects(:zonecfg).with(:info).returns(zone_info)
+        expect(provider).to receive(:zonecfg).with(:info).and_return(zone_info)
         expect(provider.getconfig).to eq({
           :brand=>"native",
           :autoboot=>"true",
@@ -118,6 +122,7 @@ net:
         })
       end
     end
+
     describe "with an exclusive iptype zone" do
       zone_info =<<-EOF
 zonename: dummy
@@ -137,8 +142,9 @@ net:
         physical: net1
         defrouter not specified
       EOF
+
       it "should correctly parse zone info" do
-        provider.expects(:zonecfg).with(:info).returns(zone_info)
+        expect(provider).to receive(:zonecfg).with(:info).and_return(zone_info)
         expect(provider.getconfig).to eq({
           :brand=>"native",
           :autoboot=>"true",
@@ -149,78 +155,85 @@ net:
         })
       end
     end
+
     describe "with an invalid or unrecognized config" do
       it "should produce an error message with provider context when given an invalid config" do
         erroneous_zone_info =<<-EOF
           physical: net1'
         EOF
 
-        provider.expects(:zonecfg).with(:info).returns(erroneous_zone_info)
-        provider.expects('err').with("Ignoring '          physical: net1''")
+        expect(provider).to receive(:zonecfg).with(:info).and_return(erroneous_zone_info)
+        expect(provider).to receive('err').with("Ignoring '          physical: net1''")
         provider.getconfig
       end
 
-
       it "should produce a debugging message with provider context when given an unrecognized config" do
         unrecognized_zone_info = "dummy"
-        provider.expects(:zonecfg).with(:info).returns(unrecognized_zone_info)
-        provider.expects('debug').with("Ignoring zone output 'dummy'")
+        expect(provider).to receive(:zonecfg).with(:info).and_return(unrecognized_zone_info)
+        expect(provider).to receive('debug').with("Ignoring zone output 'dummy'")
         provider.getconfig
       end
     end
   end
+
   context "#flush" do
     it "should correctly execute pending commands" do
-      provider.expects(:command).with(:cfg).returns('/usr/sbin/zonecfg')
-      provider.expects(:exec_cmd).with(:input => "set iptype=shared\ncommit\nexit", :cmd => '/usr/sbin/zonecfg -z dummy -f -').returns({:out=>'', :exit => 0})
+      expect(provider).to receive(:command).with(:cfg).and_return('/usr/sbin/zonecfg')
+      expect(provider).to receive(:exec_cmd).with(:input => "set iptype=shared\ncommit\nexit", :cmd => '/usr/sbin/zonecfg -z dummy -f -').and_return({:out=>'', :exit => 0})
       provider.setconfig("set iptype=shared")
       provider.flush
     end
 
     it "should correctly raise error on failure" do
-      provider.expects(:command).with(:cfg).returns('/usr/sbin/zonecfg')
-      provider.expects(:exec_cmd).with(:input => "set iptype=shared\ncommit\nexit", :cmd => '/usr/sbin/zonecfg -z dummy -f -').returns({:out=>'', :exit => 1})
+      expect(provider).to receive(:command).with(:cfg).and_return('/usr/sbin/zonecfg')
+      expect(provider).to receive(:exec_cmd).with(:input => "set iptype=shared\ncommit\nexit", :cmd => '/usr/sbin/zonecfg -z dummy -f -').and_return({:out=>'', :exit => 1})
       provider.setconfig("set iptype=shared")
       expect {
         provider.flush
       }.to raise_error(ArgumentError, /Failed to apply/)
     end
   end
+
   context "#start" do
     it "should not require path if sysidcfg is specified" do
       resource[:path] = '/mypath'
       resource[:sysidcfg] = 'dummy'
-      Puppet::FileSystem.stubs(:exist?).with('/mypath/root/etc/sysidcfg').returns true
-      File.stubs(:directory?).with('/mypath/root/etc').returns true
-      provider.expects(:zoneadm).with(:boot)
+      allow(Puppet::FileSystem).to receive(:exist?).with('/mypath/root/etc/sysidcfg').and_return(true)
+      allow(File).to receive(:directory?).with('/mypath/root/etc').and_return(true)
+      expect(provider).to receive(:zoneadm).with(:boot)
       provider.start
     end
 
     it "should require path if sysidcfg is specified" do
-      resource.stubs(:[]).with(:path).returns nil
-      resource.stubs(:[]).with(:sysidcfg).returns 'dummy'
+      allow(resource).to receive(:[]).with(:path).and_return(nil)
+      allow(resource).to receive(:[]).with(:sysidcfg).and_return('dummy')
       expect {
         provider.start
       }.to raise_error(Puppet::Error, /Path is required/)
     end
   end
+
   context "#line2hash" do
     it "should parse lines correctly" do
       expect(described_class.line2hash('0:dummy:running:/z::native:shared')).to eq({:ensure=>:running, :iptype=>"shared", :path=>"/z", :name=>"dummy", :id=>"0"})
     end
+
     it "should parse lines correctly(2)" do
       expect(described_class.line2hash('0:dummy:running:/z:ipkg:native:shared')).to eq({:ensure=>:running, :iptype=>"shared", :path=>"/z", :name=>"dummy", :id=>"0"})
     end
+
     it "should parse lines correctly(3)" do
       expect(described_class.line2hash('-:dummy:running:/z:ipkg:native:shared')).to eq({:ensure=>:running, :iptype=>"shared", :path=>"/z", :name=>"dummy"})
     end
+
     it "should parse lines correctly(3)" do
       expect(described_class.line2hash('-:dummy:running:/z:ipkg:native:exclusive')).to eq({:ensure=>:running, :iptype=>"exclusive", :path=>"/z", :name=>"dummy"})
     end
   end
+
   context "#multi_conf" do
     it "should correctly add and remove properties" do
-      provider.stubs(:properties).with().returns({:ip => ['1.1.1.1', '2.2.2.2']})
+      allow(provider).to receive(:properties).with(no_args).and_return({:ip => ['1.1.1.1', '2.2.2.2']})
       should = ['1.1.1.1', '3.3.3.3']
       p = Proc.new do |a, str|
         case a
@@ -231,17 +244,18 @@ net:
       expect(provider.multi_conf(:ip, should, &p)).to eq("rm:2.2.2.2\nadd:3.3.3.3")
     end
   end
+
   context "single props" do
     {:iptype => /set ip-type/, :autoboot => /set autoboot/, :path => /set zonepath/, :pool => /set pool/, :shares => /add rctl/}.each do |p, v|
       it "#{p.to_s}: should correctly return conf string" do
         expect(provider.send(p.to_s + '_conf', 'dummy')).to match(v)
       end
+
       it "#{p.to_s}: should correctly set property string" do
-        provider.expects((p.to_s + '_conf').intern).returns('dummy')
-        provider.expects(:setconfig).with('dummy').returns('dummy2')
+        expect(provider).to receive((p.to_s + '_conf').intern).and_return('dummy')
+        expect(provider).to receive(:setconfig).with('dummy').and_return('dummy2')
         expect(provider.send(p.to_s + '=', 'dummy')).to eq('dummy2')
       end
-
     end
   end
 end

data/spec/unit/provider/zpool/zpool_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 describe Puppet::Type.type(:zpool).provider(:zpool) do
@@ -12,13 +11,13 @@ describe Puppet::Type.type(:zpool).provider(:zpool) do
   let(:provider) { resource.provider }
 
   before do
-    provider.class.stubs(:which).with('zpool').returns(zpool)
+    allow(provider.class).to receive(:which).with('zpool').and_return(zpool)
   end
 
   context '#current_pool' do
     it "should call process_zpool_data with the result of get_pool_data only once" do
-      provider.stubs(:get_pool_data).returns(["foo", "disk"])
-      provider.expects(:process_zpool_data).with(["foo", "disk"]).returns("stuff").once
+      allow(provider).to receive(:get_pool_data).and_return(["foo", "disk"])
+      expect(provider).to receive(:process_zpool_data).with(["foo", "disk"]).and_return("stuff").once
 
       provider.current_pool
       provider.current_pool
@@ -31,7 +30,7 @@ describe Puppet::Type.type(:zpool).provider(:zpool) do
     end
 
     it "should list instances" do
-      provider.class.expects(:zpool).with(:list,'-H').returns File.read(my_fixture('zpool-list.out'))
+      expect(provider.class).to receive(:zpool).with(:list,'-H').and_return(File.read(my_fixture('zpool-list.out')))
       instances = provider.class.instances.map { |p| {:name => p.get(:name), :ensure => p.get(:ensure)} }
       expect(instances.size).to eq(2)
       expect(instances[0]).to eq({:name => 'rpool', :ensure => :present})
@@ -41,8 +40,8 @@ describe Puppet::Type.type(:zpool).provider(:zpool) do
 
   context '#flush' do
     it "should reload the pool" do
-      provider.stubs(:get_pool_data)
-      provider.expects(:process_zpool_data).returns("stuff").times(2)
+      allow(provider).to receive(:get_pool_data)
+      expect(provider).to receive(:process_zpool_data).and_return("stuff").twice
       provider.current_pool
       provider.flush
       provider.current_pool
@@ -153,7 +152,7 @@ describe Puppet::Type.type(:zpool).provider(:zpool) do
         it "should get the #{field} value from the current_pool hash" do
           pool_hash = {}
           pool_hash[field] = 'value'
-          provider.stubs(:current_pool).returns(pool_hash)
+          allow(provider).to receive(:current_pool).and_return(pool_hash)
 
           expect(provider.send(field)).to eq('value')
         end
@@ -161,7 +160,7 @@ describe Puppet::Type.type(:zpool).provider(:zpool) do
 
       describe "when setting the #{field}" do
         it "should fail if readonly #{field} values change" do
-          provider.stubs(:current_pool).returns(Hash.new("currentvalue"))
+          allow(provider).to receive(:current_pool).and_return(Hash.new("currentvalue"))
           expect {
             provider.send((field.to_s + "=").intern, "shouldvalue")
           }.to raise_error(Puppet::Error, /can\'t be changed/)
@@ -177,14 +176,14 @@ describe Puppet::Type.type(:zpool).provider(:zpool) do
       end
 
       it "should call create with the build_vdevs value" do
-        provider.expects(:zpool).with(:create, name, 'disk1')
+        expect(provider).to receive(:zpool).with(:create, name, 'disk1')
         provider.create
       end
 
       it "should call create with the 'spares' and 'log' values" do
         resource[:spare] = ['value1']
         resource[:log] = ['value2']
-        provider.expects(:zpool).with(:create, name, 'disk1', 'spare', 'value1', 'log', 'value2')
+        expect(provider).to receive(:zpool).with(:create, name, 'disk1', 'spare', 'value1', 'log', 'value2')
         provider.create
       end
     end
@@ -192,13 +191,13 @@ describe Puppet::Type.type(:zpool).provider(:zpool) do
     context "when creating mirrors for a zpool" do
       it "executes 'create' for a single group of mirrored devices" do
         resource[:mirror] = ["disk1 disk2"]
-        provider.expects(:zpool).with(:create, name, 'mirror', 'disk1', 'disk2')
+        expect(provider).to receive(:zpool).with(:create, name, 'mirror', 'disk1', 'disk2')
         provider.create
       end
 
       it "repeats the 'mirror' keyword between groups of mirrored devices" do
         resource[:mirror] = ["disk1 disk2", "disk3 disk4"]
-        provider.expects(:zpool).with(:create, name, 'mirror', 'disk1', 'disk2', 'mirror', 'disk3', 'disk4')
+        expect(provider).to receive(:zpool).with(:create, name, 'mirror', 'disk1', 'disk2', 'mirror', 'disk3', 'disk4')
         provider.create
       end
     end
@@ -206,20 +205,20 @@ describe Puppet::Type.type(:zpool).provider(:zpool) do
     describe "when creating raidz for a zpool" do
       it "executes 'create' for a single raidz group" do
         resource[:raidz] = ["disk1 disk2"]
-        provider.expects(:zpool).with(:create, name, 'raidz1', 'disk1', 'disk2')
+        expect(provider).to receive(:zpool).with(:create, name, 'raidz1', 'disk1', 'disk2')
         provider.create
       end
 
       it "execute 'create' for a single raidz2 group" do
         resource[:raidz] = ["disk1 disk2"]
         resource[:raid_parity] = 'raidz2'
-        provider.expects(:zpool).with(:create, name, 'raidz2', 'disk1', 'disk2')
+        expect(provider).to receive(:zpool).with(:create, name, 'raidz2', 'disk1', 'disk2')
         provider.create
       end
 
       it "repeats the 'raidz1' keyword between each group of raidz devices" do
         resource[:raidz] = ["disk1 disk2", "disk3 disk4"]
-        provider.expects(:zpool).with(:create, name, 'raidz1', 'disk1', 'disk2', 'raidz1', 'disk3', 'disk4')
+        expect(provider).to receive(:zpool).with(:create, name, 'raidz1', 'disk1', 'disk2', 'raidz1', 'disk3', 'disk4')
         provider.create
       end
     end
@@ -227,24 +226,24 @@ describe Puppet::Type.type(:zpool).provider(:zpool) do
 
   context '#delete' do
     it "should call zpool with destroy and the pool name" do
-      provider.expects(:zpool).with(:destroy, name)
+      expect(provider).to receive(:zpool).with(:destroy, name)
       provider.destroy
     end
   end
 
   context '#exists?' do
     it "should get the current pool" do
-      provider.expects(:current_pool).returns({:pool => 'somepool'})
+      expect(provider).to receive(:current_pool).and_return({:pool => 'somepool'})
       provider.exists?
     end
 
     it "should return false if the current_pool is absent" do
-      provider.expects(:current_pool).returns({:pool => :absent})
+      expect(provider).to receive(:current_pool).and_return({:pool => :absent})
       expect(provider).not_to be_exists
     end
 
     it "should return true if the current_pool has values" do
-      provider.expects(:current_pool).returns({:pool => name})
+      expect(provider).to receive(:current_pool).and_return({:pool => name})
       expect(provider).to be_exists
     end
   end