puppet 5.5.12-universal-darwin → 5.5.13-universal-darwin

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

@@ -12,14 +12,14 @@ describe Puppet::Type.type(:user).provider(:hpuxuseradd), :unless => Puppet.feat
   let(:provider) { resource.provider }
 
   it "should add -F when modifying a user" do
-    resource.stubs(:allowdupe?).returns true
-    provider.expects(:execute).with { |args| args.include?("-F") }
+    allow(resource).to receive(:allowdupe?).and_return(true)
+    expect(provider).to receive(:execute).with(include("-F"), anything)
     provider.uid = 1000
   end
 
   it "should add -F when deleting a user" do
-    provider.stubs(:exists?).returns(true)
-    provider.expects(:execute).with { |args| args.include?("-F") }
+    allow(provider).to receive(:exists?).and_return(true)
+    expect(provider).to receive(:execute).with(include("-F"), anything)
     provider.delete
   end
 
@@ -29,9 +29,9 @@ describe Puppet::Type.type(:user).provider(:hpuxuseradd), :unless => Puppet.feat
     end
 
     before :each do
-      Etc.stubs(:getpwent).returns(pwent)
-      Etc.stubs(:getpwnam).returns(pwent)
-      resource.stubs(:command).with(:modify).returns '/usr/sam/lbin/usermod.sam'
+      allow(Etc).to receive(:getpwent).and_return(pwent)
+      allow(Etc).to receive(:getpwnam).and_return(pwent)
+      allow(resource).to receive(:command).with(:modify).and_return('/usr/sam/lbin/usermod.sam')
     end
 
     it "should have feature manages_passwords" do
@@ -39,7 +39,7 @@ describe Puppet::Type.type(:user).provider(:hpuxuseradd), :unless => Puppet.feat
     end
 
     it "should return nil if user does not exist" do
-      Etc.stubs(:getpwent).returns(nil)
+      allow(Etc).to receive(:getpwent).and_return(nil)
       expect(provider.password).to be_nil
     end
 
@@ -50,20 +50,20 @@ describe Puppet::Type.type(:user).provider(:hpuxuseradd), :unless => Puppet.feat
 
   context "check for trusted computing" do
     before :each do
-      provider.stubs(:command).with(:modify).returns '/usr/sam/lbin/usermod.sam'
+      allow(provider).to receive(:command).with(:modify).and_return('/usr/sam/lbin/usermod.sam')
     end
 
     it "should add modprpw to modifycmd if Trusted System" do
-      resource.stubs(:allowdupe?).returns true
-      provider.expects(:exec_getprpw).with('root','-m uid').returns('uid=0')
-      provider.expects(:execute).with(['/usr/sam/lbin/usermod.sam', '-u', 1000, '-o', 'testuser', '-F', ';', '/usr/lbin/modprpw', '-v', '-l', 'testuser'], has_entry(:custom_environment, {}))
+      allow(resource).to receive(:allowdupe?).and_return(true)
+      expect(provider).to receive(:exec_getprpw).with('root','-m uid').and_return('uid=0')
+      expect(provider).to receive(:execute).with(['/usr/sam/lbin/usermod.sam', '-u', 1000, '-o', 'testuser', '-F', ';', '/usr/lbin/modprpw', '-v', '-l', 'testuser'], hash_including(custom_environment: {}))
       provider.uid = 1000
     end
 
     it "should not add modprpw if not Trusted System" do
-      resource.stubs(:allowdupe?).returns true
-      provider.expects(:exec_getprpw).with('root','-m uid').returns('System is not trusted')
-      provider.expects(:execute).with(['/usr/sam/lbin/usermod.sam', '-u', 1000, '-o', 'testuser', '-F'], has_entry(:custom_environment, {}))
+      allow(resource).to receive(:allowdupe?).and_return(true)
+      expect(provider).to receive(:exec_getprpw).with('root','-m uid').and_return('System is not trusted')
+      expect(provider).to receive(:execute).with(['/usr/sam/lbin/usermod.sam', '-u', 1000, '-o', 'testuser', '-F'], hash_including(custom_environment: {}))
       provider.uid = 1000
     end
   end

data/spec/unit/provider/user/ldap_spec.rb

@@ -37,36 +37,36 @@ describe Puppet::Type.type(:user).provider(:ldap) do
   context "when being created" do
     before do
       # So we don't try to actually talk to ldap
-      @connection = mock 'connection'
-      described_class.manager.stubs(:connect).yields @connection
+      @connection = double('connection')
+      allow(described_class.manager).to receive(:connect).and_yield(@connection)
     end
 
     it "should generate the sn as the last field of the cn" do
-      Puppet::Type.type(:group).provider(:ldap).expects(:name2id).with(["whatever"]).returns [123]
+      expect(Puppet::Type.type(:group).provider(:ldap)).to receive(:name2id).with(["whatever"]).and_return([123])
 
-      resource = stub 'resource', :should => %w{whatever}
-      resource.stubs(:should).with(:comment).returns ["Luke Kanies"]
-      resource.stubs(:should).with(:ensure).returns :present
+      resource = double('resource', :should => %w{whatever})
+      allow(resource).to receive(:should).with(:comment).and_return(["Luke Kanies"])
+      allow(resource).to receive(:should).with(:ensure).and_return(:present)
       instance = described_class.new(:name => "luke", :ensure => :absent)
 
-      instance.stubs(:resource).returns resource
+      allow(instance).to receive(:resource).and_return(resource)
 
-      @connection.expects(:add).with { |dn, attrs| attrs["sn"] == ["Kanies"] }
+      expect(@connection).to receive(:add).with(anything, hash_including("sn" => ["Kanies"]))
 
       instance.create
       instance.flush
     end
 
     it "should translate a group name to the numeric id" do
-      Puppet::Type.type(:group).provider(:ldap).expects(:name2id).with("bar").returns 101
+      expect(Puppet::Type.type(:group).provider(:ldap)).to receive(:name2id).with("bar").and_return(101)
 
-      resource = stub 'resource', :should => %w{whatever}
-      resource.stubs(:should).with(:gid).returns 'bar'
-      resource.stubs(:should).with(:ensure).returns :present
+      resource = double('resource', :should => %w{whatever})
+      allow(resource).to receive(:should).with(:gid).and_return('bar')
+      allow(resource).to receive(:should).with(:ensure).and_return(:present)
       instance = described_class.new(:name => "luke", :ensure => :absent)
-      instance.stubs(:resource).returns resource
+      allow(instance).to receive(:resource).and_return(resource)
 
-      @connection.expects(:add).with { |dn, attrs| attrs["gidNumber"] == ["101"] }
+      expect(@connection).to receive(:add).with(anything, hash_including("gidNumber" => ["101"]))
 
       instance.create
       instance.flush
@@ -74,36 +74,36 @@ describe Puppet::Type.type(:user).provider(:ldap) do
 
     context "with no uid specified" do
       it "should pick the first available UID after the largest existing UID" do
-        Puppet::Type.type(:group).provider(:ldap).expects(:name2id).with(["whatever"]).returns [123]
+        expect(Puppet::Type.type(:group).provider(:ldap)).to receive(:name2id).with(["whatever"]).and_return([123])
 
         low = {:name=>["luke"], :shell=>:absent, :uid=>["600"], :home=>["/h"], :gid=>["1000"], :password=>["blah"], :comment=>["l k"]}
         high = {:name=>["testing"], :shell=>:absent, :uid=>["640"], :home=>["/h"], :gid=>["1000"], :password=>["blah"], :comment=>["t u"]}
-        described_class.manager.expects(:search).returns([low, high])
+        expect(described_class.manager).to receive(:search).and_return([low, high])
 
-        resource = stub 'resource', :should => %w{whatever}
-        resource.stubs(:should).with(:uid).returns nil
-        resource.stubs(:should).with(:ensure).returns :present
+        resource = double('resource', :should => %w{whatever})
+        allow(resource).to receive(:should).with(:uid).and_return(nil)
+        allow(resource).to receive(:should).with(:ensure).and_return(:present)
         instance = described_class.new(:name => "luke", :ensure => :absent)
-        instance.stubs(:resource).returns resource
+        allow(instance).to receive(:resource).and_return(resource)
 
-        @connection.expects(:add).with { |dn, attrs| attrs["uidNumber"] == ["641"] }
+        expect(@connection).to receive(:add).with(anything, hash_including("uidNumber" => ["641"]))
 
         instance.create
         instance.flush
       end
 
       it "should pick 501 of no users exist" do
-        Puppet::Type.type(:group).provider(:ldap).expects(:name2id).with(["whatever"]).returns [123]
+        expect(Puppet::Type.type(:group).provider(:ldap)).to receive(:name2id).with(["whatever"]).and_return([123])
 
-        described_class.manager.expects(:search).returns nil
+        expect(described_class.manager).to receive(:search).and_return(nil)
 
-        resource = stub 'resource', :should => %w{whatever}
-        resource.stubs(:should).with(:uid).returns nil
-        resource.stubs(:should).with(:ensure).returns :present
+        resource = double('resource', :should => %w{whatever})
+        allow(resource).to receive(:should).with(:uid).and_return(nil)
+        allow(resource).to receive(:should).with(:ensure).and_return(:present)
         instance = described_class.new(:name => "luke", :ensure => :absent)
-        instance.stubs(:resource).returns resource
+        allow(instance).to receive(:resource).and_return(resource)
 
-        @connection.expects(:add).with { |dn, attrs| attrs["uidNumber"] == ["501"] }
+        expect(@connection).to receive(:add).with(anything, hash_including("uidNumber" => ["501"]))
 
         instance.create
         instance.flush
@@ -113,19 +113,19 @@ describe Puppet::Type.type(:user).provider(:ldap) do
 
   context "when flushing" do
     before do
-      described_class.stubs(:suitable?).returns true
+      allow(described_class).to receive(:suitable?).and_return(true)
 
       @instance = described_class.new(:name => "myname", :groups => %w{whatever}, :uid => "400")
     end
 
     it "should remove the :groups value before updating" do
-      @instance.class.manager.expects(:update).with { |name, ldap, puppet| puppet[:groups].nil? }
+      expect(@instance.class.manager).to receive(:update).with(anything, anything, hash_excluding(:groups))
 
       @instance.flush
     end
 
     it "should empty the property hash" do
-      @instance.class.manager.stubs(:update)
+      allow(@instance.class.manager).to receive(:update)
 
       @instance.flush
 
@@ -133,7 +133,7 @@ describe Puppet::Type.type(:user).provider(:ldap) do
     end
 
     it "should empty the ldap property hash" do
-      @instance.class.manager.stubs(:update)
+      allow(@instance.class.manager).to receive(:update)
 
       @instance.flush
 
@@ -145,7 +145,7 @@ describe Puppet::Type.type(:user).provider(:ldap) do
     before do
       @groups = Puppet::Type.type(:group).provider(:ldap)
       @group_manager = @groups.manager
-      described_class.stubs(:suitable?).returns true
+      allow(described_class).to receive(:suitable?).and_return(true)
 
       @instance = described_class.new(:name => "myname")
     end
@@ -153,19 +153,19 @@ describe Puppet::Type.type(:user).provider(:ldap) do
     it "should show its group membership as the sorted list of all groups returned by an ldap query of group memberships" do
       one = {:name => "one"}
       two = {:name => "two"}
-      @group_manager.expects(:search).with("memberUid=myname").returns([two, one])
+      expect(@group_manager).to receive(:search).with("memberUid=myname").and_return([two, one])
 
       expect(@instance.groups).to eq("one,two")
     end
 
     it "should show its group membership as :absent if no matching groups are found in ldap" do
-      @group_manager.expects(:search).with("memberUid=myname").returns(nil)
+      expect(@group_manager).to receive(:search).with("memberUid=myname").and_return(nil)
 
       expect(@instance.groups).to eq(:absent)
     end
 
     it "should cache the group value" do
-      @group_manager.expects(:search).with("memberUid=myname").once.returns nil
+      expect(@group_manager).to receive(:search).with("memberUid=myname").once.and_return(nil)
 
       @instance.groups
       expect(@instance.groups).to eq(:absent)
@@ -176,61 +176,61 @@ describe Puppet::Type.type(:user).provider(:ldap) do
     before do
       @groups = Puppet::Type.type(:group).provider(:ldap)
       @group_manager = @groups.manager
-      described_class.stubs(:suitable?).returns true
+      allow(described_class).to receive(:suitable?).and_return(true)
 
       @one = {:name => "one", :gid => "500"}
-      @group_manager.stubs(:find).with("one").returns(@one)
+      allow(@group_manager).to receive(:find).with("one").and_return(@one)
 
       @two = {:name => "one", :gid => "600"}
-      @group_manager.stubs(:find).with("two").returns(@two)
+      allow(@group_manager).to receive(:find).with("two").and_return(@two)
 
       @instance = described_class.new(:name => "myname")
 
-      @instance.stubs(:groups).returns :absent
+      allow(@instance).to receive(:groups).and_return(:absent)
     end
 
     it "should fail if the group does not exist" do
-      @group_manager.expects(:find).with("mygroup").returns nil
+      expect(@group_manager).to receive(:find).with("mygroup").and_return(nil)
 
       expect { @instance.groups = "mygroup" }.to raise_error(Puppet::Error)
     end
 
     it "should only pass the attributes it cares about to the group manager" do
-      @group_manager.expects(:update).with { |name, attrs| attrs[:gid].nil? }
+      expect(@group_manager).to receive(:update).with(anything, hash_excluding(:gid), anything)
 
       @instance.groups = "one"
     end
 
     it "should always include :ensure => :present in the current values" do
-      @group_manager.expects(:update).with { |name, is, should| is[:ensure] == :present }
+      expect(@group_manager).to receive(:update).with(anything, hash_including(ensure: :present), anything)
 
       @instance.groups = "one"
     end
 
     it "should always include :ensure => :present in the desired values" do
-      @group_manager.expects(:update).with { |name, is, should| should[:ensure] == :present }
+      expect(@group_manager).to receive(:update).with(anything, anything, hash_including(ensure: :present))
 
       @instance.groups = "one"
     end
 
     it "should always pass the group's original member list" do
       @one[:members] = %w{yay ness}
-      @group_manager.expects(:update).with { |name, is, should| is[:members] == %w{yay ness} }
+      expect(@group_manager).to receive(:update).with(anything, hash_including(members: %w{yay ness}), anything)
 
       @instance.groups = "one"
     end
 
     it "should find the group again when resetting its member list, so it has the full member list" do
-      @group_manager.expects(:find).with("one").returns(@one)
+      expect(@group_manager).to receive(:find).with("one").and_return(@one)
 
-      @group_manager.stubs(:update)
+      allow(@group_manager).to receive(:update)
 
       @instance.groups = "one"
     end
 
     context "for groups that have no members" do
       it "should create a new members attribute with its value being the user's name" do
-        @group_manager.expects(:update).with { |name, is, should| should[:members] == %w{myname} }
+        expect(@group_manager).to receive(:update).with(anything, anything, hash_including(members: %w{myname}))
 
         @instance.groups = "one"
       end
@@ -241,9 +241,9 @@ describe Puppet::Type.type(:user).provider(:ldap) do
         @one[:members] = %w{myname a}
         @two[:members] = %w{myname b}
 
-        @group_manager.expects(:update).with { |name, is, should| name == "two" and should[:members] == %w{b} }
+        expect(@group_manager).to receive(:update).with("two", anything, hash_including(members: %w{b}))
 
-        @instance.stubs(:groups).returns "one,two"
+        allow(@instance).to receive(:groups).and_return("one,two")
         @instance.groups = "one"
       end
 
@@ -251,9 +251,9 @@ describe Puppet::Type.type(:user).provider(:ldap) do
         @one[:members] = %w{myname}
         @two[:members] = %w{myname b}
 
-        @group_manager.expects(:update).with { |name, is, should| name == "one" and should[:members] == :absent }
+        expect(@group_manager).to receive(:update).with("one", anything, hash_including(members: :absent))
 
-        @instance.stubs(:groups).returns "one,two"
+        allow(@instance).to receive(:groups).and_return("one,two")
         @instance.groups = "two"
       end
     end
@@ -261,9 +261,9 @@ describe Puppet::Type.type(:user).provider(:ldap) do
     context "for groups that already have members" do
       it "should replace each group's member list with a new list including the user's name" do
         @one[:members] = %w{a b}
-        @group_manager.expects(:update).with { |name, is, should| should[:members] == %w{a b myname} }
+        expect(@group_manager).to receive(:update).with(anything, anything, hash_including(members: %w{a b myname}))
         @two[:members] = %w{b c}
-        @group_manager.expects(:update).with { |name, is, should| should[:members] == %w{b c myname} }
+        expect(@group_manager).to receive(:update).with(anything, anything, hash_including(members: %w{b c myname}))
 
         @instance.groups = "one,two"
       end
@@ -272,12 +272,12 @@ describe Puppet::Type.type(:user).provider(:ldap) do
     context "for groups of which it is a member" do
       it "should do nothing" do
         @one[:members] = %w{a b}
-        @group_manager.expects(:update).with { |name, is, should| should[:members] == %w{a b myname} }
+        expect(@group_manager).to receive(:update).with(anything, anything, hash_including(members: %w{a b myname}))
 
         @two[:members] = %w{c myname}
-        @group_manager.expects(:update).with { |name, *other| name == "two" }.never
+        expect(@group_manager).not_to receive(:update).with("two", any_args)
 
-        @instance.stubs(:groups).returns "two"
+        allow(@instance).to receive(:groups).and_return("two")
 
         @instance.groups = "one,two"
       end

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

@@ -1,13 +1,11 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 describe Puppet::Type.type(:user).provider(:openbsd) do
-
   before :each do
-    described_class.stubs(:command).with(:password).returns '/usr/sbin/passwd'
-    described_class.stubs(:command).with(:add).returns '/usr/sbin/useradd'
-    described_class.stubs(:command).with(:modify).returns '/usr/sbin/usermod'
-    described_class.stubs(:command).with(:delete).returns '/usr/sbin/userdel'
+    allow(described_class).to receive(:command).with(:password).and_return('/usr/sbin/passwd')
+    allow(described_class).to receive(:command).with(:add).and_return('/usr/sbin/useradd')
+    allow(described_class).to receive(:command).with(:modify).and_return('/usr/sbin/usermod')
+    allow(described_class).to receive(:command).with(:delete).and_return('/usr/sbin/userdel')
   end
 
   let(:resource) do
@@ -33,20 +31,20 @@ describe Puppet::Type.type(:user).provider(:openbsd) do
   describe "#expiry=" do
     it "should pass expiry to usermod as MM/DD/YY" do
       resource[:expiry] = '2014-11-05'
-      provider.expects(:execute).with(['/usr/sbin/usermod', '-e', 'November 05 2014', 'myuser'], has_entry(:custom_environment, {}))
+      expect(provider).to receive(:execute).with(['/usr/sbin/usermod', '-e', 'November 05 2014', 'myuser'], hash_including(custom_environment: {}))
       provider.expiry = '2014-11-05'
     end
 
     it "should use -e with an empty string when the expiry property is removed" do
       resource[:expiry] = :absent
-      provider.expects(:execute).with(['/usr/sbin/usermod', '-e', '', 'myuser'], has_entry(:custom_environment, {}))
+      expect(provider).to receive(:execute).with(['/usr/sbin/usermod', '-e', '', 'myuser'], hash_including(custom_environment: {}))
       provider.expiry = :absent
     end
   end
 
   describe "#addcmd" do
     it "should return an array with the full command and expiry as MM/DD/YY" do
-      Facter.stubs(:value).with(:osfamily).returns('OpenBSD')
+      allow(Facter).to receive(:value).with(:osfamily).and_return('OpenBSD')
       resource[:expiry] = "1997-06-01"
       expect(provider.addcmd).to eq(['/usr/sbin/useradd', '-e', 'June 01 1997', 'myuser'])
     end
@@ -58,19 +56,19 @@ describe Puppet::Type.type(:user).provider(:openbsd) do
     end
 
     it "should return the loginclass if set", :if => Puppet.features.libshadow? do
-      Shadow::Passwd.expects(:getspnam).with('myuser').returns shadow_entry
+      expect(Shadow::Passwd).to receive(:getspnam).with('myuser').and_return(shadow_entry)
       provider.send(:loginclass).should == 'staff'
     end
 
     it "should return the empty string when loginclass isn't set", :if => Puppet.features.libshadow? do
       shadow_entry[:sp_loginclass] = ''
-      Shadow::Passwd.expects(:getspnam).with('myuser').returns shadow_entry
+      expect(Shadow::Passwd).to receive(:getspnam).with('myuser').and_return(shadow_entry)
       provider.send(:loginclass).should == ''
     end
 
     it "should return nil when loginclass isn't available", :if => Puppet.features.libshadow? do
       shadow_entry[:sp_loginclass] = nil
-      Shadow::Passwd.expects(:getspnam).with('myuser').returns shadow_entry
+      expect(Shadow::Passwd).to receive(:getspnam).with('myuser').and_return(shadow_entry)
       provider.send(:loginclass).should be_nil
     end
   end

data/spec/unit/provider/user/pw_spec.rb

@@ -1,5 +1,7 @@
 require 'spec_helper'
 
+RSpec::Matchers.define_negated_matcher :excluding, :include
+
 describe Puppet::Type.type(:user).provider(:pw) do
   let :resource do
     Puppet::Type.type(:user).new(:name => "testuser", :provider => :pw)
@@ -8,86 +10,86 @@ describe Puppet::Type.type(:user).provider(:pw) do
   context "when creating users" do
     let :provider do
       prov = resource.provider
-      prov.expects(:exists?).returns nil
+      expect(prov).to receive(:exists?).and_return(nil)
       prov
     end
 
     it "should run pw with no additional flags when no properties are given" do
       expect(provider.addcmd).to eq([described_class.command(:pw), "useradd", "testuser"])
-      provider.expects(:execute).with([described_class.command(:pw), "useradd", "testuser"], kind_of(Hash))
+      expect(provider).to receive(:execute).with([described_class.command(:pw), "useradd", "testuser"], kind_of(Hash))
       provider.create
     end
 
     it "should use -o when allowdupe is enabled" do
       resource[:allowdupe] = true
-      provider.expects(:execute).with(includes("-o"), kind_of(Hash))
+      expect(provider).to receive(:execute).with(include("-o"), kind_of(Hash))
       provider.create
     end
 
     it "should use -c with the correct argument when the comment property is set" do
       resource[:comment] = "Testuser Name"
-      provider.expects(:execute).with(all_of(includes("-c"), includes("Testuser Name")), kind_of(Hash))
+      expect(provider).to receive(:execute).with(include("-c").and(include("Testuser Name")), kind_of(Hash))
       provider.create
     end
 
     it "should use -e with the correct argument when the expiry property is set" do
       resource[:expiry] = "2010-02-19"
-      provider.expects(:execute).with(all_of(includes("-e"), includes("19-02-2010")), kind_of(Hash))
+      expect(provider).to receive(:execute).with(include("-e").and(include("19-02-2010")), kind_of(Hash))
       provider.create
     end
 
     it "should use -e 00-00-0000 if the expiry property has to be removed" do
       resource[:expiry] = :absent
-      provider.expects(:execute).with(all_of(includes("-e"), includes("00-00-0000")), kind_of(Hash))
+      expect(provider).to receive(:execute).with(include("-e").and(include("00-00-0000")), kind_of(Hash))
       provider.create
     end
 
     it "should use -g with the correct argument when the gid property is set" do
       resource[:gid] = 12345
-      provider.expects(:execute).with(all_of(includes("-g"), includes(12345)), kind_of(Hash))
+      expect(provider).to receive(:execute).with(include("-g").and(include(12345)), kind_of(Hash))
       provider.create
     end
 
     it "should use -G with the correct argument when the groups property is set" do
       resource[:groups] = "group1"
-      provider.expects(:execute).with(all_of(includes("-G"), includes("group1")), kind_of(Hash))
+      expect(provider).to receive(:execute).with(include("-G").and(include("group1")), kind_of(Hash))
       provider.create
     end
 
     it "should use -G with all the given groups when the groups property is set to an array" do
       resource[:groups] = ["group1", "group2"]
-      provider.expects(:execute).with(all_of(includes("-G"), includes("group1,group2")), kind_of(Hash))
+      expect(provider).to receive(:execute).with(include("-G").and(include("group1,group2")), kind_of(Hash))
       provider.create
     end
 
     it "should use -d with the correct argument when the home property is set" do
       resource[:home] = "/home/testuser"
-      provider.expects(:execute).with(all_of(includes("-d"), includes("/home/testuser")), kind_of(Hash))
+      expect(provider).to receive(:execute).with(include("-d").and(include("/home/testuser")), kind_of(Hash))
       provider.create
     end
 
     it "should use -m when the managehome property is enabled" do
       resource[:managehome] = true
-      provider.expects(:execute).with(includes("-m"), kind_of(Hash))
+      expect(provider).to receive(:execute).with(include("-m"), kind_of(Hash))
       provider.create
     end
 
     it "should call the password set function with the correct argument when the password property is set" do
       resource[:password] = "*"
-      provider.expects(:execute)
-      provider.expects(:password=).with("*")
+      expect(provider).to receive(:execute)
+      expect(provider).to receive(:password=).with("*")
       provider.create
     end
 
     it "should use -s with the correct argument when the shell property is set" do
       resource[:shell] = "/bin/sh"
-      provider.expects(:execute).with(all_of(includes("-s"), includes("/bin/sh")), kind_of(Hash))
+      expect(provider).to receive(:execute).with(include("-s").and(include("/bin/sh")), kind_of(Hash))
       provider.create
     end
 
     it "should use -u with the correct argument when the uid property is set" do
       resource[:uid] = 12345
-      provider.expects(:execute).with(all_of(includes("-u"), includes(12345)), kind_of(Hash))
+      expect(provider).to receive(:execute).with(include("-u").and(include(12345)), kind_of(Hash))
       provider.create
     end
 
@@ -95,8 +97,8 @@ describe Puppet::Type.type(:user).provider(:pw) do
     it "should not use -p when a password is given" do
       resource[:password] = "*"
       expect(provider.addcmd).not_to include("-p")
-      provider.expects(:password=)
-      provider.expects(:execute).with(Not(includes("-p")), kind_of(Hash))
+      expect(provider).to receive(:password=)
+      expect(provider).to receive(:execute).with(excluding("-p"), kind_of(Hash))
       provider.create
     end
   end
@@ -104,9 +106,9 @@ describe Puppet::Type.type(:user).provider(:pw) do
   context "when deleting users" do
     it "should run pw with no additional flags" do
       provider = resource.provider
-      provider.expects(:exists?).returns true
+      expect(provider).to receive(:exists?).and_return(true)
       expect(provider.deletecmd).to eq([described_class.command(:pw), "userdel", "testuser"])
-      provider.expects(:execute).with([described_class.command(:pw), "userdel", "testuser"], has_entry(:custom_environment, {}))
+      expect(provider).to receive(:execute).with([described_class.command(:pw), "userdel", "testuser"], hash_including(custom_environment: {}))
       provider.delete
     end
 
@@ -115,17 +117,17 @@ describe Puppet::Type.type(:user).provider(:pw) do
     # have an explicit test.
     it "should not use -r when managehome is not set" do
       provider = resource.provider
-      provider.expects(:exists?).returns true
+      expect(provider).to receive(:exists?).and_return(true)
       resource[:managehome] = false
-      provider.expects(:execute).with(Not(includes("-r")), has_entry(:custom_environment, {}))
+      expect(provider).to receive(:execute).with(excluding("-r"), hash_including(custom_environment: {}))
       provider.delete
     end
 
     it "should use -r when managehome is set" do
       provider = resource.provider
-      provider.expects(:exists?).returns true
+      expect(provider).to receive(:exists?).and_return(true)
       resource[:managehome] = true
-      provider.expects(:execute).with(includes("-r"), has_entry(:custom_environment, {}))
+      expect(provider).to receive(:execute).with(include("-r"), hash_including(custom_environment: {}))
       provider.delete
     end
   end
@@ -137,74 +139,74 @@ describe Puppet::Type.type(:user).provider(:pw) do
 
     it "should run pw with the correct arguments" do
       expect(provider.modifycmd("uid", 12345)).to eq([described_class.command(:pw), "usermod", "testuser", "-u", 12345])
-      provider.expects(:execute).with([described_class.command(:pw), "usermod", "testuser", "-u", 12345], has_entry(:custom_environment, {}))
+      expect(provider).to receive(:execute).with([described_class.command(:pw), "usermod", "testuser", "-u", 12345], hash_including(custom_environment: {}))
       provider.uid = 12345
     end
 
     it "should use -c with the correct argument when the comment property is changed" do
       resource[:comment] = "Testuser Name"
-      provider.expects(:execute).with(all_of(includes("-c"), includes("Testuser New Name")), has_entry(:custom_environment, {}))
+      expect(provider).to receive(:execute).with(include("-c").and(include("Testuser New Name")), hash_including(custom_environment: {}))
       provider.comment = "Testuser New Name"
     end
 
     it "should use -e with the correct argument when the expiry property is changed" do
       resource[:expiry] = "2010-02-19"
-      provider.expects(:execute).with(all_of(includes("-e"), includes("19-02-2011")), has_entry(:custom_environment, {}))
+      expect(provider).to receive(:execute).with(include("-e").and(include("19-02-2011")), hash_including(custom_environment: {}))
       provider.expiry = "2011-02-19"
     end
 
     it "should use -e with the correct argument when the expiry property is removed" do
       resource[:expiry] = :absent
-      provider.expects(:execute).with(all_of(includes("-e"), includes("00-00-0000")), has_entry(:custom_environment, {}))
+      expect(provider).to receive(:execute).with(include("-e").and(include("00-00-0000")), hash_including(custom_environment: {}))
       provider.expiry = :absent
     end
 
     it "should use -g with the correct argument when the gid property is changed" do
       resource[:gid] = 12345
-      provider.expects(:execute).with(all_of(includes("-g"), includes(54321)), has_entry(:custom_environment, {}))
+      expect(provider).to receive(:execute).with(include("-g").and(include(54321)), hash_including(custom_environment: {}))
       provider.gid = 54321
     end
 
     it "should use -G with the correct argument when the groups property is changed" do
       resource[:groups] = "group1"
-      provider.expects(:execute).with(all_of(includes("-G"), includes("group2")), has_entry(:custom_environment, {}))
+      expect(provider).to receive(:execute).with(include("-G").and(include("group2")), hash_including(custom_environment: {}))
       provider.groups = "group2"
     end
 
     it "should use -G with all the given groups when the groups property is changed with an array" do
       resource[:groups] = ["group1", "group2"]
-      provider.expects(:execute).with(all_of(includes("-G"), includes("group3,group4")), has_entry(:custom_environment, {}))
+      expect(provider).to receive(:execute).with(include("-G").and(include("group3,group4")), hash_including(custom_environment: {}))
       provider.groups = "group3,group4"
     end
 
     it "should use -d with the correct argument when the home property is changed" do
       resource[:home] = "/home/testuser"
-      provider.expects(:execute).with(all_of(includes("-d"), includes("/newhome/testuser")), has_entry(:custom_environment, {}))
+      expect(provider).to receive(:execute).with(include("-d").and(include("/newhome/testuser")), hash_including(custom_environment: {}))
       provider.home = "/newhome/testuser"
     end
 
     it "should use -m and -d with the correct argument when the home property is changed and managehome is enabled" do
       resource[:home] = "/home/testuser"
       resource[:managehome] = true
-      provider.expects(:execute).with(all_of(includes("-d"), includes("/newhome/testuser"), includes("-m")), has_entry(:custom_environment, {}))
+      expect(provider).to receive(:execute).with(include("-d").and(include("/newhome/testuser")).and(include("-m")), hash_including(custom_environment: {}))
       provider.home = "/newhome/testuser"
     end
 
     it "should call the password set function with the correct argument when the password property is changed" do
       resource[:password] = "*"
-      provider.expects(:password=).with("!")
+      expect(provider).to receive(:password=).with("!")
       provider.password = "!"
     end
 
     it "should use -s with the correct argument when the shell property is changed" do
       resource[:shell] = "/bin/sh"
-      provider.expects(:execute).with(all_of(includes("-s"), includes("/bin/tcsh")), has_entry(:custom_environment, {}))
+      expect(provider).to receive(:execute).with(include("-s").and(include("/bin/tcsh")), hash_including(custom_environment: {}))
       provider.shell = "/bin/tcsh"
     end
 
     it "should use -u with the correct argument when the uid property is changed" do
       resource[:uid] = 12345
-      provider.expects(:execute).with(all_of(includes("-u"), includes(54321)), has_entry(:custom_environment, {}))
+      expect(provider).to receive(:execute).with(include("-u").and(include(54321)), hash_including(custom_environment: {}))
       provider.uid = 54321
     end
   end