puppet 6.0.10-universal-darwin → 6.1.0-universal-darwin

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

@@ -8,123 +8,123 @@ describe Puppet::Type.type(:user).provider(:user_role_add), :unless => Puppet::U
   let(:provider) { described_class.new(resource) }
 
   before do
-    allow(resource).to receive(:should).and_return("fakeval")
-    allow(resource).to receive(:should).with(:keys).and_return(Hash.new)
-    allow(resource).to receive(:[]).and_return("fakeval")
+    resource.stubs(:should).returns "fakeval"
+    resource.stubs(:should).with(:keys).returns Hash.new
+    resource.stubs(:[]).returns "fakeval"
   end
 
+
   describe "#command" do
     before do
-      klass = double("provider")
-      allow(klass).to receive(:superclass)
-      allow(klass).to receive(:command).with(:foo).and_return("userfoo")
-      allow(klass).to receive(:command).with(:role_foo).and_return("rolefoo")
-      allow(provider).to receive(:class).and_return(klass)
+      klass = stub("provider")
+      klass.stubs(:command).with(:foo).returns("userfoo")
+      klass.stubs(:command).with(:role_foo).returns("rolefoo")
+      provider.stubs(:class).returns(klass)
     end
 
     it "should use the command if not a role and ensure!=role" do
-      allow(provider).to receive(:is_role?).and_return(false)
-      allow(provider).to receive(:exists?).and_return(false)
-      allow(resource).to receive(:[]).with(:ensure).and_return(:present)
-      allow(provider.class).to receive(:foo)
+      provider.stubs(:is_role?).returns(false)
+      provider.stubs(:exists?).returns(false)
+      resource.stubs(:[]).with(:ensure).returns(:present)
+      provider.class.stubs(:foo)
       expect(provider.command(:foo)).to eq("userfoo")
     end
 
     it "should use the role command when a role" do
-      allow(provider).to receive(:is_role?).and_return(true)
+      provider.stubs(:is_role?).returns(true)
       expect(provider.command(:foo)).to eq("rolefoo")
     end
 
     it "should use the role command when !exists and ensure=role" do
-      allow(provider).to receive(:is_role?).and_return(false)
-      allow(provider).to receive(:exists?).and_return(false)
-      allow(resource).to receive(:[]).with(:ensure).and_return(:role)
+      provider.stubs(:is_role?).returns(false)
+      provider.stubs(:exists?).returns(false)
+      resource.stubs(:[]).with(:ensure).returns(:role)
       expect(provider.command(:foo)).to eq("rolefoo")
     end
   end
 
   describe "#transition" do
     it "should return the type set to whatever is passed in" do
-      expect(provider).to receive(:command).with(:modify).and_return("foomod")
+      provider.expects(:command).with(:modify).returns("foomod")
       provider.transition("bar").include?("type=bar")
     end
   end
 
   describe "#create" do
     before do
-      allow(provider).to receive(:password=)
+      provider.stubs(:password=)
     end
 
     it "should use the add command when the user is not a role" do
-      allow(provider).to receive(:is_role?).and_return(false)
-      expect(provider).to receive(:addcmd).and_return("useradd")
-      expect(provider).to receive(:run).at_least(:once)
+      provider.stubs(:is_role?).returns(false)
+      provider.expects(:addcmd).returns("useradd")
+      provider.expects(:run).at_least_once
       provider.create
     end
 
     it "should use transition(normal) when the user is a role" do
-      allow(provider).to receive(:is_role?).and_return(true)
-      expect(provider).to receive(:transition).with("normal")
-      expect(provider).to receive(:run)
+      provider.stubs(:is_role?).returns(true)
+      provider.expects(:transition).with("normal")
+      provider.expects(:run)
       provider.create
     end
 
     it "should set password age rules" do
       resource = Puppet::Type.type(:user).new :name => "myuser", :password_min_age => 5, :password_max_age => 10, :password_warn_days => 15, :provider => :user_role_add
       provider = described_class.new(resource)
-      allow(provider).to receive(:user_attributes)
-      allow(provider).to receive(:execute)
-      expect(provider).to receive(:execute).with([anything, "-n", 5, "-x", 10, '-w', 15, "myuser"])
+      provider.stubs(:user_attributes)
+      provider.stubs(:execute)
+      provider.expects(:execute).with { |cmd, *args| args == ["-n", 5, "-x", 10, '-w', 15, "myuser"] }
       provider.create
     end
   end
 
   describe "#destroy" do
     it "should use the delete command if the user exists and is not a role" do
-      allow(provider).to receive(:exists?).and_return(true)
-      allow(provider).to receive(:is_role?).and_return(false)
-      expect(provider).to receive(:deletecmd)
-      expect(provider).to receive(:run)
+      provider.stubs(:exists?).returns(true)
+      provider.stubs(:is_role?).returns(false)
+      provider.expects(:deletecmd)
+      provider.expects(:run)
       provider.destroy
     end
 
     it "should use the delete command if the user is a role" do
-      allow(provider).to receive(:exists?).and_return(true)
-      allow(provider).to receive(:is_role?).and_return(true)
-      expect(provider).to receive(:deletecmd)
-      expect(provider).to receive(:run)
+      provider.stubs(:exists?).returns(true)
+      provider.stubs(:is_role?).returns(true)
+      provider.expects(:deletecmd)
+      provider.expects(:run)
       provider.destroy
     end
   end
 
   describe "#create_role" do
     it "should use the transition(role) if the user exists" do
-      allow(provider).to receive(:exists?).and_return(true)
-      allow(provider).to receive(:is_role?).and_return(false)
-      expect(provider).to receive(:transition).with("role")
-      expect(provider).to receive(:run)
+      provider.stubs(:exists?).returns(true)
+      provider.stubs(:is_role?).returns(false)
+      provider.expects(:transition).with("role")
+      provider.expects(:run)
       provider.create_role
     end
 
     it "should use the add command when role doesn't exists" do
-      allow(provider).to receive(:exists?).and_return(false)
-      expect(provider).to receive(:addcmd)
-      expect(provider).to receive(:run)
+      provider.stubs(:exists?).returns(false)
+      provider.expects(:addcmd)
+      provider.expects(:run)
       provider.create_role
     end
   end
 
   describe "with :allow_duplicates" do
     before do
-      allow(resource).to receive(:allowdupe?).and_return(true)
-      allow(provider).to receive(:is_role?).and_return(false)
-      allow(provider).to receive(:execute)
-      allow(resource).to receive(:system?).and_return(false)
-      expect(provider).to receive(:execute).with(include("-o"), any_args)
+      resource.stubs(:allowdupe?).returns true
+      provider.stubs(:is_role?).returns(false)
+      provider.stubs(:execute)
+      resource.stubs(:system?).returns false
+      provider.expects(:execute).with { |args| args.include?("-o") }
     end
 
     it "should add -o when the user is being created" do
-      allow(provider).to receive(:password=)
+      provider.stubs(:password=)
       provider.create
     end
 
@@ -137,14 +137,14 @@ describe Puppet::Type.type(:user).provider(:user_role_add), :unless => Puppet::U
     context "#send" do
       describe "when getting #{val}" do
         it "should get the user_attributes" do
-          expect(provider).to receive(:user_attributes)
+          provider.expects(:user_attributes)
           provider.send(val)
         end
 
         it "should get the #{val} attribute" do
-          attributes = double("attributes")
-          expect(attributes).to receive(:[]).with(val)
-          allow(provider).to receive(:user_attributes).and_return(attributes)
+          attributes = mock("attributes")
+          attributes.expects(:[]).with(val)
+          provider.stubs(:user_attributes).returns(attributes)
           provider.send(val)
         end
       end
@@ -153,33 +153,33 @@ describe Puppet::Type.type(:user).provider(:user_role_add), :unless => Puppet::U
 
   describe "#keys" do
     it "should get the user_attributes" do
-      expect(provider).to receive(:user_attributes)
+      provider.expects(:user_attributes)
       provider.keys
     end
 
     it "should call removed_managed_attributes" do
-      allow(provider).to receive(:user_attributes).and_return({ :type => "normal", :foo => "something" })
-      expect(provider).to receive(:remove_managed_attributes)
+      provider.stubs(:user_attributes).returns({ :type => "normal", :foo => "something" })
+      provider.expects(:remove_managed_attributes)
       provider.keys
     end
 
     it "should removed managed attribute (type, auths, roles, etc)" do
-      allow(provider).to receive(:user_attributes).and_return({ :type => "normal", :foo => "something" })
+      provider.stubs(:user_attributes).returns({ :type => "normal", :foo => "something" })
       expect(provider.keys).to eq({ :foo => "something" })
     end
   end
 
   describe "#add_properties" do
     it "should call build_keys_cmd" do
-      allow(resource).to receive(:should).and_return("")
-      expect(resource).to receive(:should).with(:keys).and_return({ :foo => "bar" })
-      expect(provider).to receive(:build_keys_cmd).and_return([])
+      resource.stubs(:should).returns ""
+      resource.expects(:should).with(:keys).returns({ :foo => "bar" })
+      provider.expects(:build_keys_cmd).returns([])
       provider.add_properties
     end
 
     it "should add the elements of the keys hash to an array" do
-      allow(resource).to receive(:should).and_return("")
-      expect(resource).to receive(:should).with(:keys).and_return({ :foo => "bar"})
+      resource.stubs(:should).returns ""
+      resource.expects(:should).with(:keys).returns({ :foo => "bar"})
       expect(provider.add_properties).to eq(["-K", "foo=bar"])
     end
   end
@@ -192,57 +192,57 @@ describe Puppet::Type.type(:user).provider(:user_role_add), :unless => Puppet::U
 
   describe "#keys=" do
     before do
-      allow(provider).to receive(:is_role?).and_return(false)
+      provider.stubs(:is_role?).returns(false)
     end
 
     it "should run a command" do
-      expect(provider).to receive(:run)
+      provider.expects(:run)
       provider.keys=({})
     end
 
     it "should build the command" do
-      allow(resource).to receive(:[]).with(:name).and_return("someuser")
-      allow(provider).to receive(:command).and_return("usermod")
-      expect(provider).to receive(:build_keys_cmd).and_return(["-K", "foo=bar"])
-      expect(provider).to receive(:run).with(["usermod", "-K", "foo=bar", "someuser"], "modify attribute key pairs")
+      resource.stubs(:[]).with(:name).returns("someuser")
+      provider.stubs(:command).returns("usermod")
+      provider.expects(:build_keys_cmd).returns(["-K", "foo=bar"])
+      provider.expects(:run).with(["usermod", "-K", "foo=bar", "someuser"], "modify attribute key pairs")
       provider.keys=({})
     end
   end
 
   describe "#password" do
     before do
-      @array = double("array")
+      @array = mock "array"
     end
 
     it "should readlines of /etc/shadow" do
-      expect(File).to receive(:readlines).with("/etc/shadow").and_return([])
+      File.expects(:readlines).with("/etc/shadow").returns([])
       provider.password
     end
 
     it "should reject anything that doesn't start with alpha numerics" do
-      expect(@array).to receive(:reject).and_return([])
-      allow(File).to receive(:readlines).with("/etc/shadow").and_return(@array)
+      @array.expects(:reject).returns([])
+      File.stubs(:readlines).with("/etc/shadow").returns(@array)
       provider.password
     end
 
     it "should collect splitting on ':'" do
-      allow(@array).to receive(:reject).and_return(@array)
-      expect(@array).to receive(:collect).and_return([])
-      allow(File).to receive(:readlines).with("/etc/shadow").and_return(@array)
+      @array.stubs(:reject).returns(@array)
+      @array.expects(:collect).returns([])
+      File.stubs(:readlines).with("/etc/shadow").returns(@array)
       provider.password
     end
 
     it "should find the matching user" do
-      allow(resource).to receive(:[]).with(:name).and_return("username")
-      allow(@array).to receive(:reject).and_return(@array)
-      allow(@array).to receive(:collect).and_return([["username", "hashedpassword"], ["someoneelse", "theirpassword"]])
-      allow(File).to receive(:readlines).with("/etc/shadow").and_return(@array)
+      resource.stubs(:[]).with(:name).returns("username")
+      @array.stubs(:reject).returns(@array)
+      @array.stubs(:collect).returns([["username", "hashedpassword"], ["someoneelse", "theirpassword"]])
+      File.stubs(:readlines).with("/etc/shadow").returns(@array)
       expect(provider.password).to eq("hashedpassword")
     end
 
     it "should get the right password" do
-      allow(resource).to receive(:[]).with(:name).and_return("username")
-      allow(File).to receive(:readlines).with("/etc/shadow").and_return(["#comment", "   nonsense", "  ", "username:hashedpassword:stuff:foo:bar:::", "other:pword:yay:::"])
+      resource.stubs(:[]).with(:name).returns("username")
+      File.stubs(:readlines).with("/etc/shadow").returns(["#comment", "   nonsense", "  ", "username:hashedpassword:stuff:foo:bar:::", "other:pword:yay:::"])
       expect(provider.password).to eq("hashedpassword")
     end
   end
@@ -251,7 +251,7 @@ describe Puppet::Type.type(:user).provider(:user_role_add), :unless => Puppet::U
     let(:path) { tmpfile('etc-shadow') }
 
     before :each do
-      allow(provider).to receive(:target_file_path).and_return(path)
+      provider.stubs(:target_file_path).returns(path)
     end
 
     def write_fixture(content)
@@ -267,7 +267,7 @@ FIXTURE
     end
 
     it "should only update the target user" do
-      expect(Date).to receive(:today).and_return(Date.new(2011,12,07))
+      Date.expects(:today).returns Date.new(2011,12,07)
       write_fixture <<FIXTURE
 before:seriously:15315:0:99999:7:::
 fakeval:seriously:15315:0:99999:7:::
@@ -297,7 +297,7 @@ FIXTURE
     end
 
     it "should update the lastchg field" do
-      expect(Date).to receive(:today).and_return(Date.new(2013,5,12)) # 15837 days after 1970-01-01
+      Date.expects(:today).returns Date.new(2013,5,12) # 15837 days after 1970-01-01
       write_fixture <<FIXTURE
 before:seriously:15315:0:99999:7:::
 fakeval:seriously:15629:0:99999:7:::
@@ -316,58 +316,58 @@ EOT
 
   describe "#shadow_entry" do
     it "should return the line for the right user" do
-      allow(File).to receive(:readlines).and_return(["someuser:!:10:5:20:7:1::\n", "fakeval:*:20:10:30:7:2::\n", "testuser:*:30:15:40:7:3::\n"])
+      File.stubs(:readlines).returns(["someuser:!:10:5:20:7:1::\n", "fakeval:*:20:10:30:7:2::\n", "testuser:*:30:15:40:7:3::\n"])
       expect(provider.shadow_entry).to eq(["fakeval", "*", "20", "10", "30", "7", "2", "", ""])
     end
   end
 
   describe "#password_max_age" do
     it "should return a maximum age number" do
-      allow(File).to receive(:readlines).and_return(["fakeval:NP:12345:0:50::::\n"])
+      File.stubs(:readlines).returns(["fakeval:NP:12345:0:50::::\n"])
       expect(provider.password_max_age).to eq("50")
     end
 
     it "should return -1 for no maximum" do
-      allow(File).to receive(:readlines).and_return(["fakeval:NP:12345::::::\n"])
+      File.stubs(:readlines).returns(["fakeval:NP:12345::::::\n"])
       expect(provider.password_max_age).to eq(-1)
     end
 
     it "should return -1 for no maximum when failed attempts are present" do
-      allow(File).to receive(:readlines).and_return(["fakeval:NP:12345::::::3\n"])
+      File.stubs(:readlines).returns(["fakeval:NP:12345::::::3\n"])
       expect(provider.password_max_age).to eq(-1)
     end
   end
 
   describe "#password_min_age" do
     it "should return a minimum age number" do
-      allow(File).to receive(:readlines).and_return(["fakeval:NP:12345:10:50::::\n"])
+      File.stubs(:readlines).returns(["fakeval:NP:12345:10:50::::\n"])
       expect(provider.password_min_age).to eq("10")
     end
 
     it "should return -1 for no minimum" do
-      allow(File).to receive(:readlines).and_return(["fakeval:NP:12345::::::\n"])
+      File.stubs(:readlines).returns(["fakeval:NP:12345::::::\n"])
       expect(provider.password_min_age).to eq(-1)
     end
 
     it "should return -1 for no minimum when failed attempts are present" do
-      allow(File).to receive(:readlines).and_return(["fakeval:NP:12345::::::3\n"])
+      File.stubs(:readlines).returns(["fakeval:NP:12345::::::3\n"])
       expect(provider.password_min_age).to eq(-1)
     end
   end
 
   describe "#password_warn_days" do
     it "should return a warn days number" do
-      allow(File).to receive(:readlines).and_return(["fakeval:NP:12345:10:50:30:::\n"])
+      File.stubs(:readlines).returns(["fakeval:NP:12345:10:50:30:::\n"])
       expect(provider.password_warn_days).to eq("30")
     end
 
     it "should return -1 for no warn days" do
-      allow(File).to receive(:readlines).and_return(["fakeval:NP:12345::::::\n"])
+      File.stubs(:readlines).returns(["fakeval:NP:12345::::::\n"])
       expect(provider.password_warn_days).to eq(-1)
     end
 
     it "should return -1 for no warn days when failed attempts are present" do
-      allow(File).to receive(:readlines).and_return(["fakeval:NP:12345::::::3\n"])
+      File.stubs(:readlines).returns(["fakeval:NP:12345::::::3\n"])
       expect(provider.password_warn_days).to eq(-1)
     end
   end

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

@@ -1,17 +1,17 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
-RSpec::Matchers.define_negated_matcher :excluding, :include
-
 describe Puppet::Type.type(:user).provider(:useradd) do
+
   before :each do
-    allow(described_class).to receive(:command).with(:password).and_return('/usr/bin/chage')
-    allow(described_class).to receive(:command).with(:localpassword).and_return('/usr/sbin/lchage')
-    allow(described_class).to receive(:command).with(:add).and_return('/usr/sbin/useradd')
-    allow(described_class).to receive(:command).with(:localadd).and_return('/usr/sbin/luseradd')
-    allow(described_class).to receive(:command).with(:modify).and_return('/usr/sbin/usermod')
-    allow(described_class).to receive(:command).with(:localmodify).and_return('/usr/sbin/lusermod')
-    allow(described_class).to receive(:command).with(:delete).and_return('/usr/sbin/userdel')
-    allow(described_class).to receive(:command).with(:localdelete).and_return('/usr/sbin/luserdel')
+    described_class.stubs(:command).with(:password).returns '/usr/bin/chage'
+    described_class.stubs(:command).with(:localpassword).returns '/usr/sbin/lchage'
+    described_class.stubs(:command).with(:add).returns '/usr/sbin/useradd'
+    described_class.stubs(:command).with(:localadd).returns '/usr/sbin/luseradd'
+    described_class.stubs(:command).with(:modify).returns '/usr/sbin/usermod'
+    described_class.stubs(:command).with(:localmodify).returns '/usr/sbin/lusermod'
+    described_class.stubs(:command).with(:delete).returns '/usr/sbin/userdel'
+    described_class.stubs(:command).with(:localdelete).returns '/usr/sbin/luserdel'
   end
 
   let(:resource) do
@@ -25,6 +25,7 @@ describe Puppet::Type.type(:user).provider(:useradd) do
 
   let(:provider) { described_class.new(:name => 'myuser') }
 
+
   let(:shadow_entry) {
     return unless Puppet.features.libshadow?
     entry = Struct::PasswdEntry.new
@@ -40,36 +41,37 @@ describe Puppet::Type.type(:user).provider(:useradd) do
   }
 
   describe "#create" do
+
     before do
-      allow(provider).to receive(:exists?).and_return(false)
+      provider.stubs(:exists?).returns(false)
     end
 
     it "should add -g when no gid is specified and group already exists" do
-      allow(Puppet::Util).to receive(:gid).and_return(true)
+      Puppet::Util.stubs(:gid).returns(true)
       resource[:ensure] = :present
-      expect(provider).to receive(:execute).with(include('-g'), kind_of(Hash))
+      provider.expects(:execute).with(includes('-g'), kind_of(Hash))
       provider.create
     end
 
     it "should use -G to set groups" do
-      allow(Facter).to receive(:value).with(:osfamily).and_return('Not RedHat')
+      Facter.stubs(:value).with(:osfamily).returns('Not RedHat')
       resource[:ensure] = :present
       resource[:groups] = ['group1', 'group2']
-      expect(provider).to receive(:execute).with(['/usr/sbin/useradd', '-G', 'group1,group2', 'myuser'], kind_of(Hash))
+      provider.expects(:execute).with(['/usr/sbin/useradd', '-G', 'group1,group2', 'myuser'], kind_of(Hash))
       provider.create
     end
 
     it "should use -G to set groups without -M on RedHat" do
-      allow(Facter).to receive(:value).with(:osfamily).and_return('RedHat')
+      Facter.stubs(:value).with(:osfamily).returns('RedHat')
       resource[:ensure] = :present
       resource[:groups] = ['group1', 'group2']
-      expect(provider).to receive(:execute).with(['/usr/sbin/useradd', '-G', 'group1,group2', '-M', 'myuser'], kind_of(Hash))
+      provider.expects(:execute).with(['/usr/sbin/useradd', '-G', 'group1,group2', '-M', 'myuser'], kind_of(Hash))
       provider.create
     end
 
     it "should add -o when allowdupe is enabled and the user is being created" do
       resource[:allowdupe] = true
-      expect(provider).to receive(:execute).with(include('-o'), kind_of(Hash))
+      provider.expects(:execute).with(includes('-o'), kind_of(Hash))
       provider.create
     end
 
@@ -77,7 +79,7 @@ describe Puppet::Type.type(:user).provider(:useradd) do
       it "should add -r when system is enabled" do
         resource[:system] = :true
         expect(provider).to be_system_users
-        expect(provider).to receive(:execute).with(include('-r'), kind_of(Hash))
+        provider.expects(:execute).with(includes('-r'), kind_of(Hash))
         provider.create
       end
     end
@@ -86,7 +88,7 @@ describe Puppet::Type.type(:user).provider(:useradd) do
       it "should not add -r when system is enabled" do
         resource[:system] = :true
         expect(provider).not_to be_system_users
-        expect(provider).to receive(:execute).with(['/usr/sbin/useradd', 'myuser'], kind_of(Hash))
+        provider.expects(:execute).with(['/usr/sbin/useradd', 'myuser'], kind_of(Hash))
         provider.create
       end
     end
@@ -96,8 +98,8 @@ describe Puppet::Type.type(:user).provider(:useradd) do
       resource[:password_min_age] = 5
       resource[:password_max_age] = 10
       resource[:password_warn_days] = 15
-      expect(provider).to receive(:execute).with(include('/usr/sbin/useradd'), kind_of(Hash))
-      expect(provider).to receive(:execute).with(['/usr/bin/chage', '-m', 5, '-M', 10, '-W', 15, 'myuser'], hash_including(failonfail: true, combine: true, custom_environment: {}))
+      provider.expects(:execute).with(includes('/usr/sbin/useradd'), kind_of(Hash))
+      provider.expects(:execute).with(['/usr/bin/chage', '-m', 5, '-M', 10, '-W', 15, 'myuser'], has_entries({:failonfail => true, :combine => true, :custom_environment => {}}))
       provider.create
     end
 
@@ -106,41 +108,40 @@ describe Puppet::Type.type(:user).provider(:useradd) do
          described_class.has_feature :libuser
          resource[:forcelocal] = true
       end
-
       it "should use luseradd instead of useradd" do
-        expect(provider).to receive(:execute).with(include('/usr/sbin/luseradd'), hash_including(custom_environment: hash_including('LIBUSER_CONF')))
+        provider.expects(:execute).with(includes('/usr/sbin/luseradd'), has_entry(:custom_environment, has_key('LIBUSER_CONF')))
         provider.create
       end
 
       it "should NOT use -o when allowdupe=true" do
         resource[:allowdupe] = :true
-        expect(provider).to receive(:execute).with(excluding('-o'), hash_including(custom_environment: hash_including('LIBUSER_CONF')))
+        provider.expects(:execute).with(Not(includes('-o')), has_entry(:custom_environment, has_key('LIBUSER_CONF')))
         provider.create
       end
 
       it "should raise an exception for duplicate UIDs" do
         resource[:uid] = 505
-        allow(provider).to receive(:finduser).and_return(true)
+        provider.stubs(:finduser).returns(true)
         expect { provider.create }.to raise_error(Puppet::Error, "UID 505 already exists, use allowdupe to force user creation")
       end
 
       it "should not use -G for luseradd and should call usermod with -G after luseradd when groups property is set" do
         resource[:groups] = ['group1', 'group2']
-        expect(provider).to receive(:execute).with(include('/usr/sbin/luseradd').and(excluding('-G')), hash_including(custom_environment: hash_including('LIBUSER_CONF')))
-        expect(provider).to receive(:execute).with(include('/usr/sbin/usermod').and(include('-G')), hash_including(custom_environment: hash_including('LIBUSER_CONF')))
+        provider.expects(:execute).with(all_of(includes('/usr/sbin/luseradd'), Not(includes('-G'))), has_entry(:custom_environment, has_key('LIBUSER_CONF')))
+        provider.expects(:execute).with(all_of(includes('/usr/sbin/usermod'), includes('-G')), has_entry(:custom_environment, has_key('LIBUSER_CONF')))
         provider.create
       end
 
       it "should not use -m when managehome set" do
         resource[:managehome] = :true
-        expect(provider).to receive(:execute).with(excluding('-m'), hash_including(custom_environment: hash_including('LIBUSER_CONF')))
+        provider.expects(:execute).with(Not(includes('-m')), has_entry(:custom_environment, has_key('LIBUSER_CONF')))
         provider.create
       end
 
       it "should not use -e with luseradd, should call usermod with -e after luseradd when expiry is set" do
         resource[:expiry] = '2038-01-24'
-        expect(provider).to receive(:execute).with(include('/usr/sbin/luseradd').and(excluding('-e')), hash_including(custom_environment: hash_including('LIBUSER_CONF')))
-        expect(provider).to receive(:execute).with(include('/usr/sbin/usermod').and(include('-e')), hash_including(custom_environment: hash_including('LIBUSER_CONF')))
+        provider.expects(:execute).with(all_of(includes('/usr/sbin/luseradd'), Not(includes('-e'))), has_entry(:custom_environment, has_key('LIBUSER_CONF')))
+        provider.expects(:execute).with(all_of(includes('/usr/sbin/usermod'), includes('-e')), has_entry(:custom_environment, has_key('LIBUSER_CONF')))
         provider.create
       end
 
@@ -149,8 +150,8 @@ describe Puppet::Type.type(:user).provider(:useradd) do
         resource[:password_min_age] = 5
         resource[:password_max_age] = 10
         resource[:password_warn_days] = 15
-        expect(provider).to receive(:execute).with(include('/usr/sbin/luseradd'), hash_including(custom_environment: hash_including('LIBUSER_CONF')))
-        expect(provider).to receive(:execute).with(['/usr/sbin/lchage', '-m', 5, '-M', 10, '-W', 15, 'myuser'], hash_including(custom_environment: hash_including('LIBUSER_CONF')))
+        provider.expects(:execute).with(includes('/usr/sbin/luseradd'), has_entry(:custom_environment, has_key('LIBUSER_CONF')))
+        provider.expects(:execute).with(['/usr/sbin/lchage', '-m', 5, '-M', 10, '-W', 15, 'myuser'], has_entry(:custom_environment, has_key('LIBUSER_CONF')))
         provider.create
       end
     end
@@ -158,11 +159,12 @@ describe Puppet::Type.type(:user).provider(:useradd) do
     describe "on systems that allow to set shell" do
       it "should trigger shell validation" do
         resource[:shell] = '/bin/bash'
-        expect(provider).to receive(:check_valid_shell)
-        expect(provider).to receive(:execute).with(include('-s'), kind_of(Hash))
+        provider.expects(:check_valid_shell)
+        provider.expects(:execute).with(includes('-s'), kind_of(Hash))
         provider.create
       end
     end
+
   end
 
   describe '#modify' do
@@ -173,34 +175,34 @@ describe Puppet::Type.type(:user).provider(:useradd) do
       end
 
       it "should use usermod" do
-        expect(provider).to receive(:execute).with(['/usr/sbin/usermod', '-u', 150, 'myuser'], hash_including(failonfail: true, combine: true, custom_environment: {}))
+        provider.expects(:execute).with(['/usr/sbin/usermod', '-u', 150, 'myuser'], has_entries({:failonfail => true, :combine => true, :custom_environment => {}}))
         provider.uid = 150
       end
 
       it "should use -o when allowdupe=true" do
         resource[:allowdupe] = :true
-        expect(provider).to receive(:execute).with(include('-o'), hash_including(failonfail: true, combine: true, custom_environment: {}))
+        provider.expects(:execute).with(includes('-o'), has_entries({:failonfail => true, :combine => true, :custom_environment => {}}))
         provider.uid = 505
       end
 
       it 'should use chage for password_min_age' do
-        expect(provider).to receive(:execute).with(['/usr/bin/chage', '-m', 100, 'myuser'], hash_including(failonfail: true, combine: true, custom_environment: {}))
+        provider.expects(:execute).with(['/usr/bin/chage', '-m', 100, 'myuser'], has_entries({:failonfail => true, :combine => true, :custom_environment => {}}))
         provider.password_min_age = 100
       end
 
       it 'should use chage for password_max_age' do
-        expect(provider).to receive(:execute).with(['/usr/bin/chage', '-M', 101, 'myuser'], hash_including(failonfail: true, combine: true, custom_environment: {}))
+        provider.expects(:execute).with(['/usr/bin/chage', '-M', 101, 'myuser'], has_entries({:failonfail => true, :combine => true, :custom_environment => {}}))
         provider.password_max_age = 101
       end
 
       it 'should use chage for password_warn_days' do
-        expect(provider).to receive(:execute).with(['/usr/bin/chage', '-W', 99, 'myuser'], hash_including(failonfail: true, combine: true, custom_environment: {}))
+        provider.expects(:execute).with(['/usr/bin/chage', '-W', 99, 'myuser'], has_entries({:failonfail => true, :combine => true, :custom_environment => {}}))
         provider.password_warn_days = 99
       end
 
       it 'should not call check_allow_dup if not modifying the uid' do
-        expect(provider).not_to receive(:check_allow_dup)
-        expect(provider).to receive(:execute)
+        provider.expects(:check_allow_dup).never
+        provider.expects(:execute)
         provider.home = 'foo/bar'
       end
     end
@@ -212,34 +214,34 @@ describe Puppet::Type.type(:user).provider(:useradd) do
       end
 
       it "should use lusermod and not usermod" do
-        expect(provider).to receive(:execute).with(['/usr/sbin/lusermod', '-u', 150, 'myuser'], hash_including(custom_environment: hash_including('LIBUSER_CONF')))
+        provider.expects(:execute).with(['/usr/sbin/lusermod', '-u', 150, 'myuser'], has_entry(:custom_environment, has_key('LIBUSER_CONF')))
         provider.uid = 150
       end
 
       it "should NOT use -o when allowdupe=true" do
         resource[:allowdupe] = :true
-        expect(provider).to receive(:execute).with(excluding('-o'), hash_including(custom_environment: hash_including('LIBUSER_CONF')))
+        provider.expects(:execute).with(Not(includes('-o')), has_entry(:custom_environment, has_key('LIBUSER_CONF')))
         provider.uid = 505
       end
 
       it "should raise an exception for duplicate UIDs" do
         resource[:uid] = 505
-        allow(provider).to receive(:finduser).and_return(true)
+        provider.stubs(:finduser).returns(true)
         expect { provider.uid = 505 }.to raise_error(Puppet::Error, "UID 505 already exists, use allowdupe to force user creation")
       end
 
       it 'should use lchage for password_warn_days' do
-        expect(provider).to receive(:execute).with(['/usr/sbin/lchage', '-W', 99, 'myuser'], hash_including(custom_environment: hash_including('LIBUSER_CONF')))
+        provider.expects(:execute).with(['/usr/sbin/lchage', '-W', 99, 'myuser'], has_entry(:custom_environment, has_key('LIBUSER_CONF')))
         provider.password_warn_days = 99
       end
 
       it 'should use lchage for password_min_age' do
-        expect(provider).to receive(:execute).with(['/usr/sbin/lchage', '-m', 100, 'myuser'], hash_including(custom_environment: hash_including('LIBUSER_CONF')))
+        provider.expects(:execute).with(['/usr/sbin/lchage', '-m', 100, 'myuser'], has_entry(:custom_environment, has_key('LIBUSER_CONF')))
         provider.password_min_age = 100
       end
 
       it 'should use lchage for password_max_age' do
-        expect(provider).to receive(:execute).with(['/usr/sbin/lchage', '-M', 101, 'myuser'], hash_including(custom_environment: hash_including('LIBUSER_CONF')))
+        provider.expects(:execute).with(['/usr/sbin/lchage', '-M', 101, 'myuser'], has_entry(:custom_environment, has_key('LIBUSER_CONF')))
         provider.password_max_age = 101
       end
     end
@@ -248,34 +250,35 @@ describe Puppet::Type.type(:user).provider(:useradd) do
   describe "#uid=" do
     it "should add -o when allowdupe is enabled and the uid is being modified" do
       resource[:allowdupe] = :true
-      expect(provider).to receive(:execute).with(['/usr/sbin/usermod', '-u', 150, '-o', 'myuser'], hash_including(custom_environment: {}))
+      provider.expects(:execute).with(['/usr/sbin/usermod', '-u', 150, '-o', 'myuser'], has_entry(:custom_environment, {}))
       provider.uid = 150
     end
   end
 
   describe "#expiry=" do
     it "should pass expiry to usermod as MM/DD/YY when on Solaris" do
-      expect(Facter).to receive(:value).with(:operatingsystem).and_return('Solaris')
+      Facter.expects(:value).with(:operatingsystem).returns 'Solaris'
       resource[:expiry] = '2012-10-31'
-      expect(provider).to receive(:execute).with(['/usr/sbin/usermod', '-e', '10/31/2012', 'myuser'], hash_including(custom_environment: {}))
+      provider.expects(:execute).with(['/usr/sbin/usermod', '-e', '10/31/2012', 'myuser'], has_entry(:custom_environment, {}))
       provider.expiry = '2012-10-31'
     end
 
     it "should pass expiry to usermod as YYYY-MM-DD when not on Solaris" do
-      expect(Facter).to receive(:value).with(:operatingsystem).and_return('not_solaris')
+      Facter.expects(:value).with(:operatingsystem).returns 'not_solaris'
       resource[:expiry] = '2012-10-31'
-      expect(provider).to receive(:execute).with(['/usr/sbin/usermod', '-e', '2012-10-31', 'myuser'], hash_including(custom_environment: {}))
+      provider.expects(:execute).with(['/usr/sbin/usermod', '-e', '2012-10-31', 'myuser'], has_entry(:custom_environment, {}))
       provider.expiry = '2012-10-31'
     end
 
     it "should use -e with an empty string when the expiry property is removed" do
       resource[:expiry] = :absent
-      expect(provider).to receive(:execute).with(['/usr/sbin/usermod', '-e', '', 'myuser'], hash_including(custom_environment: {}))
+      provider.expects(:execute).with(['/usr/sbin/usermod', '-e', '', 'myuser'], has_entry(:custom_environment, {}))
       provider.expiry = :absent
     end
   end
 
   describe "#check_allow_dup" do
+
     it "should return an array with a flag if dup is allowed" do
       resource[:allowdupe] = :true
       expect(provider.check_allow_dup).to eq(["-o"])
@@ -289,25 +292,25 @@ describe Puppet::Type.type(:user).provider(:useradd) do
 
   describe "#check_system_users" do
     it "should check system users" do
-      expect(described_class).to receive(:system_users?).and_return(true)
-      expect(resource).to receive(:system?)
+      described_class.expects(:system_users?).returns true
+      resource.expects(:system?)
       provider.check_system_users
     end
 
     it "should return an array with a flag if it's a system user" do
-      expect(described_class).to receive(:system_users?).and_return(true)
+      described_class.expects(:system_users?).returns true
       resource[:system] = :true
       expect(provider.check_system_users).to eq(["-r"])
     end
 
     it "should return an empty array if it's not a system user" do
-      expect(described_class).to receive(:system_users?).and_return(true)
+      described_class.expects(:system_users?).returns true
       resource[:system] = :false
       expect(provider.check_system_users).to eq([])
     end
 
     it "should return an empty array if system user is not featured" do
-      expect(described_class).to receive(:system_users?).and_return(false)
+      described_class.expects(:system_users?).returns false
       resource[:system] = :true
       expect(provider.check_system_users).to eq([])
     end
@@ -316,29 +319,29 @@ describe Puppet::Type.type(:user).provider(:useradd) do
   describe "#check_manage_home" do
     it "should return an array with -m flag if home is managed" do
       resource[:managehome] = :true
-      expect(provider).to receive(:execute).with(include('-m'), hash_including(custom_environment: {}))
+      provider.expects(:execute).with(includes('-m'), has_entry(:custom_environment, {}))
       provider.create
     end
 
     it "should return an array with -r flag if home is managed" do
       resource[:managehome] = :true
       resource[:ensure] = :absent
-      allow(provider).to receive(:exists?).and_return(true)
-      expect(provider).to receive(:execute).with(include('-r'), hash_including(custom_environment: {}))
+      provider.stubs(:exists?).returns(true)
+      provider.expects(:execute).with(includes('-r'), has_entry(:custom_environment, {}))
       provider.delete
     end
 
     it "should use -M flag if home is not managed and on Redhat" do
-      allow(Facter).to receive(:value).with(:osfamily).and_return("RedHat")
+      Facter.stubs(:value).with(:osfamily).returns("RedHat")
       resource[:managehome] = :false
-      expect(provider).to receive(:execute).with(include('-M'), kind_of(Hash))
+      provider.expects(:execute).with(includes('-M'), kind_of(Hash))
       provider.create
     end
 
     it "should not use -M flag if home is not managed and not on Redhat" do
-      allow(Facter).to receive(:value).with(:osfamily).and_return("not RedHat")
+      Facter.stubs(:value).with(:osfamily).returns("not RedHat")
       resource[:managehome] = :false
-      expect(provider).to receive(:execute).with(excluding('-M'), kind_of(Hash))
+      provider.expects(:execute).with(Not(includes('-M')), kind_of(Hash))
       provider.create
     end
   end
@@ -352,22 +355,22 @@ describe Puppet::Type.type(:user).provider(:useradd) do
     end
 
     it "should call command with :add" do
-      expect(provider).to receive(:command).with(:add)
+      provider.expects(:command).with(:add)
       provider.addcmd
     end
 
     it "should add properties" do
-      expect(provider).to receive(:add_properties).and_return(['-foo_add_properties'])
+      provider.expects(:add_properties).returns(['-foo_add_properties'])
       expect(provider.addcmd).to include '-foo_add_properties'
     end
 
     it "should check and add if dup allowed" do
-      expect(provider).to receive(:check_allow_dup).and_return(['-allow_dup_flag'])
+      provider.expects(:check_allow_dup).returns(['-allow_dup_flag'])
       expect(provider.addcmd).to include '-allow_dup_flag'
     end
 
     it "should check and add if home is managed" do
-      expect(provider).to receive(:check_manage_home).and_return(['-manage_home_flag'])
+      provider.expects(:check_manage_home).returns(['-manage_home_flag'])
       expect(provider.addcmd).to include '-manage_home_flag'
     end
 
@@ -397,26 +400,26 @@ describe Puppet::Type.type(:user).provider(:useradd) do
     end
 
     it "should return an array with the full command and expiry as MM/DD/YY when on Solaris" do
-      allow(Facter).to receive(:value).with(:operatingsystem).and_return('Solaris')
-      expect(described_class).to receive(:system_users?).and_return(true)
+      Facter.stubs(:value).with(:operatingsystem).returns 'Solaris'
+      described_class.expects(:system_users?).returns true
       resource[:expiry] = "2012-08-18"
       expect(provider.addcmd).to eq(['/usr/sbin/useradd', '-e', '08/18/2012', '-G', 'somegroup', '-o', '-m', '-r', 'myuser'])
     end
 
     it "should return an array with the full command and expiry as YYYY-MM-DD when not on Solaris" do
-      allow(Facter).to receive(:value).with(:operatingsystem).and_return('not_solaris')
-      expect(described_class).to receive(:system_users?).and_return(true)
+      Facter.stubs(:value).with(:operatingsystem).returns 'not_solaris'
+      described_class.expects(:system_users?).returns true
       resource[:expiry] = "2012-08-18"
       expect(provider.addcmd).to eq(['/usr/sbin/useradd', '-e', '2012-08-18', '-G', 'somegroup', '-o', '-m', '-r', 'myuser'])
     end
 
     it "should return an array without -e if expiry is undefined full command" do
-      expect(described_class).to receive(:system_users?).and_return(true)
+      described_class.expects(:system_users?).returns true
       expect(provider.addcmd).to eq(["/usr/sbin/useradd", "-G", "somegroup", "-o", "-m", "-r", "myuser"])
     end
 
     it "should pass -e \"\" if the expiry has to be removed" do
-      expect(described_class).to receive(:system_users?).and_return(true)
+      described_class.expects(:system_users?).returns true
       resource[:expiry] = :absent
 
       expect(provider.addcmd).to eq(['/usr/sbin/useradd', '-e', '', '-G', 'somegroup', '-o', '-m', '-r', 'myuser'])
@@ -468,18 +471,18 @@ describe Puppet::Type.type(:user).provider(:useradd) do
       end
 
       it "should return absent if libshadow feature is not present" do
-        allow(Puppet.features).to receive(:libshadow?).and_return(false)
+        Puppet.features.stubs(:libshadow?).returns false
         # Shadow::Passwd.expects(:getspnam).never # if we really don't have libshadow we dont have Shadow::Passwd either
         expect(provider.send(property)).to eq(:absent)
       end
 
       it "should return absent if user cannot be found", :if => Puppet.features.libshadow? do
-        expect(Shadow::Passwd).to receive(:getspnam).with('myuser').and_return(nil)
+        Shadow::Passwd.expects(:getspnam).with('myuser').returns nil
         expect(provider.send(property)).to eq(:absent)
       end
 
       it "should return the correct value if libshadow is present", :if => Puppet.features.libshadow? do
-        expect(Shadow::Passwd).to receive(:getspnam).with('myuser').and_return(shadow_entry)
+        Shadow::Passwd.expects(:getspnam).with('myuser').returns shadow_entry
         expect(provider.send(property)).to eq(expected_value)
       end
 
@@ -492,7 +495,7 @@ describe Puppet::Type.type(:user).provider(:useradd) do
         canonical_name = [253, 241].pack('C*').force_encoding(Encoding::EUC_KR)
         provider = described_class.new(:name => '??', :canonical_name => canonical_name)
 
-        expect(Shadow::Passwd).to receive(:getspnam).with(canonical_name).and_return(shadow_entry)
+        Shadow::Passwd.expects(:getspnam).with(canonical_name).returns shadow_entry
         provider.password
       end
     end
@@ -504,23 +507,23 @@ describe Puppet::Type.type(:user).provider(:useradd) do
     end
 
     it "should return absent if libshadow feature is not present" do
-      allow(Puppet.features).to receive(:libshadow?).and_return(false)
+      Puppet.features.stubs(:libshadow?).returns false
       expect(provider.expiry).to eq(:absent)
     end
 
     it "should return absent if user cannot be found", :if => Puppet.features.libshadow? do
-      expect(Shadow::Passwd).to receive(:getspnam).with('myuser').and_return(nil)
+      Shadow::Passwd.expects(:getspnam).with('myuser').returns nil
       expect(provider.expiry).to eq(:absent)
     end
 
     it "should return absent if expiry is -1", :if => Puppet.features.libshadow? do
       shadow_entry.sp_expire = -1
-      expect(Shadow::Passwd).to receive(:getspnam).with('myuser').and_return(shadow_entry)
+      Shadow::Passwd.expects(:getspnam).with('myuser').returns shadow_entry
       expect(provider.expiry).to eq(:absent)
     end
 
     it "should convert to YYYY-MM-DD", :if => Puppet.features.libshadow? do
-      expect(Shadow::Passwd).to receive(:getspnam).with('myuser').and_return(shadow_entry)
+      Shadow::Passwd.expects(:getspnam).with('myuser').returns shadow_entry
       expect(provider.expiry).to eq('2013-01-01')
     end
   end
@@ -537,7 +540,7 @@ describe Puppet::Type.type(:user).provider(:useradd) do
       # command(:password) is only called inside passcmd if
       # password_min_age or password_max_age is set
       resource[:password_min_age] = 123
-      expect(provider).to receive(:command).with(:password)
+      provider.expects(:command).with(:password)
       provider.passcmd
     end
 
@@ -594,7 +597,7 @@ describe Puppet::Type.type(:user).provider(:useradd) do
     end
 
     it "should raise an error if the shell is not executable" do
-      allow(FileTest).to receive(:executable?).with('LICENSE').and_return(false)
+      FileTest.stubs(:executable?).with('LICENSE').returns false
       resource[:shell] = 'LICENSE'
       expect { provider.check_valid_shell }.to raise_error(Puppet::Error, /Shell LICENSE must be executable/)
     end
@@ -602,30 +605,26 @@ describe Puppet::Type.type(:user).provider(:useradd) do
 
   describe "#delete" do
     before do
-       allow(provider).to receive(:exists?).and_return(true)
+       provider.stubs(:exists?).returns(true)
        resource[:ensure] = :absent
     end
-
     describe "on systems with the libuser and forcelocal=false" do
       before do
          described_class.has_feature :libuser
          resource[:forcelocal] = false
       end
-
       it "should use userdel to delete users" do
-        expect(provider).to receive(:execute).with(include('/usr/sbin/userdel'), hash_including(custom_environment: {}))
+        provider.expects(:execute).with(includes('/usr/sbin/userdel'), has_entry(:custom_environment, {}))
         provider.delete
       end
     end
-
     describe "on systems with the libuser and forcelocal=true" do
       before do
          described_class.has_feature :libuser
          resource[:forcelocal] = true
       end
-
       it "should use luserdel to delete users" do
-        expect(provider).to receive(:execute).with(include('/usr/sbin/luserdel'), hash_including(custom_environment: hash_including('LIBUSER_CONF')))
+        provider.expects(:execute).with(includes('/usr/sbin/luserdel'), has_entry(:custom_environment, has_key('LIBUSER_CONF')))
         provider.delete
       end
     end