puppet 3.8.7-x64-mingw32 → 4.0.0.rc1-x64-mingw32

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

@@ -34,19 +34,40 @@ describe provider_class, :unless => Puppet.features.microsoft_windows? do
     before :each do
       Etc.stubs(:getpwent).returns(pwent)
       Etc.stubs(:getpwnam).returns(pwent)
+      resource.stubs(:command).with(:modify).returns '/usr/sam/lbin/usermod.sam'
     end
 
     it "should have feature manages_passwords" do
-      provider_class.should be_manages_passwords
+      expect(provider_class).to be_manages_passwords
     end
 
     it "should return nil if user does not exist" do
       Etc.stubs(:getpwent).returns(nil)
-      provider.password.must be_nil
+      expect(provider.password).to be_nil
     end
 
     it "should return password entry if exists" do
-      provider.password.must == "foopassword"
+      expect(provider.password).to eq("foopassword")
+    end
+  end
+
+  context "check for trusted computing" do
+    before :each do
+      provider.stubs(:command).with(:modify).returns '/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'])
+      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'])
+      provider.uid = 1000
     end
   end
 end

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

@@ -5,23 +5,23 @@ provider_class = Puppet::Type.type(:user).provider(:ldap)
 
 describe provider_class do
   it "should have the Ldap provider class as its baseclass" do
-    provider_class.superclass.should equal(Puppet::Provider::Ldap)
+    expect(provider_class.superclass).to equal(Puppet::Provider::Ldap)
   end
 
   it "should manage :posixAccount and :person objectclasses" do
-    provider_class.manager.objectclasses.should == [:posixAccount, :person]
+    expect(provider_class.manager.objectclasses).to eq([:posixAccount, :person])
   end
 
   it "should use 'ou=People' as its relative base" do
-    provider_class.manager.location.should == "ou=People"
+    expect(provider_class.manager.location).to eq("ou=People")
   end
 
   it "should use :uid as its rdn" do
-    provider_class.manager.rdn.should == :uid
+    expect(provider_class.manager.rdn).to eq(:uid)
   end
 
   it "should be able to manage passwords" do
-    provider_class.should be_manages_passwords
+    expect(provider_class).to be_manages_passwords
   end
 
   {:name => "uid",
@@ -33,7 +33,7 @@ describe provider_class do
     :shell => "loginShell"
   }.each do |puppet, ldap|
     it "should map :#{puppet.to_s} to '#{ldap}'" do
-      provider_class.manager.ldap_name(puppet).should == ldap
+      expect(provider_class.manager.ldap_name(puppet)).to eq(ldap)
     end
   end
 
@@ -132,7 +132,7 @@ describe provider_class do
 
       @instance.flush
 
-      @instance.uid.should == :absent
+      expect(@instance.uid).to eq(:absent)
     end
 
     it "should empty the ldap property hash" do
@@ -140,7 +140,7 @@ describe provider_class do
 
       @instance.flush
 
-      @instance.ldap_properties[:uid].should be_nil
+      expect(@instance.ldap_properties[:uid]).to be_nil
     end
   end
 
@@ -158,20 +158,20 @@ describe provider_class do
       two = {:name => "two"}
       @group_manager.expects(:search).with("memberUid=myname").returns([two, one])
 
-      @instance.groups.should == "one,two"
+      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)
 
-      @instance.groups.should == :absent
+      expect(@instance.groups).to eq(:absent)
     end
 
     it "should cache the group value" do
       @group_manager.expects(:search).with("memberUid=myname").once.returns nil
 
       @instance.groups
-      @instance.groups.should == :absent
+      expect(@instance.groups).to eq(:absent)
     end
   end
 
@@ -195,7 +195,7 @@ describe provider_class do
     it "should fail if the group does not exist" do
       @group_manager.expects(:find).with("mygroup").returns nil
 
-      lambda { @instance.groups = "mygroup" }.should raise_error(Puppet::Error)
+      expect { @instance.groups = "mygroup" }.to raise_error(Puppet::Error)
     end
 
     it "should only pass the attributes it cares about to the group manager" do

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

@@ -0,0 +1,77 @@
+#! /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'
+  end
+
+  let(:resource) do
+    Puppet::Type.type(:user).new(
+      :name       => 'myuser',
+      :managehome => :false,
+      :system     => :false,
+      :loginclass => 'staff',
+      :provider   => provider
+    )
+  end
+
+  let(:provider) { described_class.new(:name => 'myuser') }
+
+  let(:shadow_entry) {
+    return unless Puppet.features.libshadow?
+    entry = Struct::PasswdEntry.new
+    entry[:sp_namp]   = 'myuser' # login name
+    entry[:sp_loginclass] = 'staff' # login class
+    entry
+  }
+
+  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'])
+      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'])
+      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')
+      resource[:expiry] = "1997-06-01"
+      expect(provider.addcmd).to eq(['/usr/sbin/useradd', '-e', 'June 01 1997', 'myuser'])
+    end
+  end
+
+  describe "#loginclass" do
+    before :each do
+      resource
+    end
+
+    it "should return the loginclass if set", :if => Puppet.features.libshadow? do
+      Shadow::Passwd.expects(:getspnam).with('myuser').returns 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
+      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
+      provider.send(:loginclass).should be_nil
+    end
+  end
+end

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

@@ -16,7 +16,7 @@ describe provider_class do
     end
 
     it "should run pw with no additional flags when no properties are given" do
-      provider.addcmd.must == [provider_class.command(:pw), "useradd", "testuser"]
+      expect(provider.addcmd).to eq([provider_class.command(:pw), "useradd", "testuser"])
       provider.expects(:execute).with([provider_class.command(:pw), "useradd", "testuser"], kind_of(Hash))
       provider.create
     end
@@ -97,7 +97,7 @@ describe provider_class do
     # (#7500) -p should not be used to set a password (it means something else)
     it "should not use -p when a password is given" do
       resource[:password] = "*"
-      provider.addcmd.should_not include("-p")
+      expect(provider.addcmd).not_to include("-p")
       provider.expects(:password=)
       provider.expects(:execute).with(Not(includes("-p")), kind_of(Hash))
       provider.create
@@ -108,13 +108,13 @@ describe provider_class do
     it "should run pw with no additional flags" do
       provider = resource.provider
       provider.expects(:exists?).returns true
-      provider.deletecmd.must == [provider_class.command(:pw), "userdel", "testuser"]
+      expect(provider.deletecmd).to eq([provider_class.command(:pw), "userdel", "testuser"])
       provider.expects(:execute).with([provider_class.command(:pw), "userdel", "testuser"])
       provider.delete
     end
 
     # The above test covers this, but given the consequences of
-    # accidently deleting a user's home directory it seems better to
+    # accidentally deleting a user's home directory it seems better to
     # have an explicit test.
     it "should not use -r when managehome is not set" do
       provider = resource.provider
@@ -139,7 +139,7 @@ describe provider_class do
     end
 
     it "should run pw with the correct arguments" do
-      provider.modifycmd("uid", 12345).must == [provider_class.command(:pw), "usermod", "testuser", "-u", 12345]
+      expect(provider.modifycmd("uid", 12345)).to eq([provider_class.command(:pw), "usermod", "testuser", "-u", 12345])
       provider.expects(:execute).with([provider_class.command(:pw), "usermod", "testuser", "-u", 12345])
       provider.uid = 12345
     end

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

@@ -27,19 +27,19 @@ describe Puppet::Type.type(:user).provider(:user_role_add), :unless => Puppet.fe
       provider.stubs(:exists?).returns(false)
       resource.stubs(:[]).with(:ensure).returns(:present)
       provider.class.stubs(:foo)
-      provider.command(:foo).should == "userfoo"
+      expect(provider.command(:foo)).to eq("userfoo")
     end
 
     it "should use the role command when a role" do
       provider.stubs(:is_role?).returns(true)
-      provider.command(:foo).should == "rolefoo"
+      expect(provider.command(:foo)).to eq("rolefoo")
     end
 
     it "should use the role command when !exists and ensure=role" do
       provider.stubs(:is_role?).returns(false)
       provider.stubs(:exists?).returns(false)
       resource.stubs(:[]).with(:ensure).returns(:role)
-      provider.command(:foo).should == "rolefoo"
+      expect(provider.command(:foo)).to eq("rolefoo")
     end
   end
 
@@ -165,7 +165,7 @@ describe Puppet::Type.type(:user).provider(:user_role_add), :unless => Puppet.fe
 
     it "should removed managed attribute (type, auths, roles, etc)" do
       provider.stubs(:user_attributes).returns({ :type => "normal", :foo => "something" })
-      provider.keys.should == { :foo => "something" }
+      expect(provider.keys).to eq({ :foo => "something" })
     end
   end
 
@@ -180,13 +180,13 @@ describe Puppet::Type.type(:user).provider(:user_role_add), :unless => Puppet.fe
     it "should add the elements of the keys hash to an array" do
       resource.stubs(:should).returns ""
       resource.expects(:should).with(:keys).returns({ :foo => "bar"})
-      provider.add_properties.must == ["-K", "foo=bar"]
+      expect(provider.add_properties).to eq(["-K", "foo=bar"])
     end
   end
 
   describe "#build_keys_cmd" do
-    it "should build cmd array with keypairs seperated by -K ending with user" do
-      provider.build_keys_cmd({"foo" => "bar", "baz" => "boo"}).should.eql? ["-K", "foo=bar", "-K", "baz=boo"]
+    it "should build cmd array with keypairs separated by -K ending with user" do
+      expect(provider.build_keys_cmd({"foo" => "bar", "baz" => "boo"})).to eq(["-K", "foo=bar", "-K", "baz=boo"])
     end
   end
 
@@ -237,13 +237,13 @@ describe Puppet::Type.type(:user).provider(:user_role_add), :unless => Puppet.fe
       @array.stubs(:reject).returns(@array)
       @array.stubs(:collect).returns([["username", "hashedpassword"], ["someoneelse", "theirpassword"]])
       File.stubs(:readlines).with("/etc/shadow").returns(@array)
-      provider.password.must == "hashedpassword"
+      expect(provider.password).to eq("hashedpassword")
     end
 
     it "should get the right password" do
       resource.stubs(:[]).with(:name).returns("username")
       File.stubs(:readlines).with("/etc/shadow").returns(["#comment", "   nonsense", "  ", "username:hashedpassword:stuff:foo:bar:::", "other:pword:yay:::"])
-      provider.password.must == "hashedpassword"
+      expect(provider.password).to eq("hashedpassword")
     end
   end
 
@@ -263,7 +263,7 @@ describe Puppet::Type.type(:user).provider(:user_role_add), :unless => Puppet.fe
 fakeval:seriously:15315:0:99999:7:::
 FIXTURE
       provider.password = "totally"
-      File.read(path).should =~ /^fakeval:totally:/
+      expect(File.read(path)).to match(/^fakeval:totally:/)
     end
 
     it "should only update the target user" do
@@ -275,7 +275,7 @@ fakevalish:seriously:15315:0:99999:7:::
 after:seriously:15315:0:99999:7:::
 FIXTURE
       provider.password = "totally"
-      File.read(path).should == <<EOT
+      expect(File.read(path)).to eq <<EOT
 before:seriously:15315:0:99999:7:::
 fakeval:totally:15315:0:99999:7:::
 fakevalish:seriously:15315:0:99999:7:::
@@ -293,7 +293,7 @@ FIXTURE
 
       write_fixture fixture
       provider.password = "totally"
-      File.read(path).should == fixture
+      expect(File.read(path)).to eq(fixture)
     end
 
     it "should update the lastchg field" do
@@ -305,7 +305,7 @@ fakevalish:seriously:15315:0:99999:7:::
 after:seriously:15315:0:99999:7:::
 FIXTURE
       provider.password = "totally"
-      File.read(path).should == <<EOT
+      expect(File.read(path)).to eq <<EOT
 before:seriously:15315:0:99999:7:::
 fakeval:totally:15837:0:99999:7:::
 fakevalish:seriously:15315:0:99999:7:::
@@ -317,41 +317,41 @@ EOT
   describe "#shadow_entry" do
     it "should return the line for the right user" do
       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"])
-      provider.shadow_entry.should == ["fakeval", "*", "20", "10", "30", "7", "2", "", ""]
+      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
       File.stubs(:readlines).returns(["fakeval:NP:12345:0:50::::\n"])
-      provider.password_max_age.should == "50"
+      expect(provider.password_max_age).to eq("50")
     end
 
     it "should return -1 for no maximum" do
       File.stubs(:readlines).returns(["fakeval:NP:12345::::::\n"])
-      provider.password_max_age.should == -1
+      expect(provider.password_max_age).to eq(-1)
     end
 
     it "should return -1 for no maximum when failed attempts are present" do
       File.stubs(:readlines).returns(["fakeval:NP:12345::::::3\n"])
-      provider.password_max_age.should == -1
+      expect(provider.password_max_age).to eq(-1)
     end
   end
 
   describe "#password_min_age" do
     it "should return a minimum age number" do
       File.stubs(:readlines).returns(["fakeval:NP:12345:10:50::::\n"])
-      provider.password_min_age.should == "10"
+      expect(provider.password_min_age).to eq("10")
     end
 
     it "should return -1 for no minimum" do
       File.stubs(:readlines).returns(["fakeval:NP:12345::::::\n"])
-      provider.password_min_age.should == -1
+      expect(provider.password_min_age).to eq(-1)
     end
 
     it "should return -1 for no minimum when failed attempts are present" do
       File.stubs(:readlines).returns(["fakeval:NP:12345::::::3\n"])
-      provider.password_min_age.should == -1
+      expect(provider.password_min_age).to eq(-1)
     end
   end
 end

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

@@ -50,6 +50,22 @@ describe Puppet::Type.type(:user).provider(:useradd) do
       provider.create
     end
 
+    it "should use -G to set groups" do
+      Facter.stubs(:value).with(:osfamily).returns('Not RedHat')
+      resource[:ensure] = :present
+      resource[:groups] = ['group1', 'group2']
+      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
+      Facter.stubs(:value).with(:osfamily).returns('RedHat')
+      resource[:ensure] = :present
+      resource[:groups] = ['group1', 'group2']
+      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
       provider.expects(:execute).with(includes('-o'), kind_of(Hash))
@@ -59,7 +75,7 @@ describe Puppet::Type.type(:user).provider(:useradd) do
     describe "on systems that support has_system", :if => described_class.system_users? do
       it "should add -r when system is enabled" do
         resource[:system] = :true
-        provider.should be_system_users
+        expect(provider).to be_system_users
         provider.expects(:execute).with(includes('-r'), kind_of(Hash))
         provider.create
       end
@@ -68,7 +84,7 @@ describe Puppet::Type.type(:user).provider(:useradd) do
     describe "on systems that do not support has_system", :unless => described_class.system_users? do
       it "should not add -r when system is enabled" do
         resource[:system] = :true
-        provider.should_not be_system_users
+        expect(provider).not_to be_system_users
         provider.expects(:execute).with(['/usr/sbin/useradd', 'myuser'], kind_of(Hash))
         provider.create
       end
@@ -102,7 +118,7 @@ describe Puppet::Type.type(:user).provider(:useradd) do
       it "should raise an exception for duplicate UIDs" do
         resource[:uid] = 505
         provider.stubs(:finduser).returns(true)
-        lambda { provider.create }.should raise_error(Puppet::Error, "UID 505 already exists, use allowdupe to force user creation")
+        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
@@ -178,12 +194,12 @@ describe Puppet::Type.type(:user).provider(:useradd) do
 
     it "should return an array with a flag if dup is allowed" do
       resource[:allowdupe] = :true
-      provider.check_allow_dup.must == ["-o"]
+      expect(provider.check_allow_dup).to eq(["-o"])
     end
 
     it "should return an empty array if no dup is allowed" do
       resource[:allowdupe] = :false
-      provider.check_allow_dup.must == []
+      expect(provider.check_allow_dup).to eq([])
     end
   end
 
@@ -197,19 +213,19 @@ describe Puppet::Type.type(:user).provider(:useradd) do
     it "should return an array with a flag if it's a system user" do
       described_class.expects(:system_users?).returns true
       resource[:system] = :true
-      provider.check_system_users.must == ["-r"]
+      expect(provider.check_system_users).to eq(["-r"])
     end
 
     it "should return an empty array if it's not a system user" do
       described_class.expects(:system_users?).returns true
       resource[:system] = :false
-      provider.check_system_users.must == []
+      expect(provider.check_system_users).to eq([])
     end
 
     it "should return an empty array if system user is not featured" do
       described_class.expects(:system_users?).returns false
       resource[:system] = :true
-      provider.check_system_users.must == []
+      expect(provider.check_system_users).to eq([])
     end
   end
 
@@ -258,32 +274,32 @@ describe Puppet::Type.type(:user).provider(:useradd) do
 
     it "should add properties" do
       provider.expects(:add_properties).returns(['-foo_add_properties'])
-      provider.addcmd.should include '-foo_add_properties'
+      expect(provider.addcmd).to include '-foo_add_properties'
     end
 
     it "should check and add if dup allowed" do
       provider.expects(:check_allow_dup).returns(['-allow_dup_flag'])
-      provider.addcmd.should include '-allow_dup_flag'
+      expect(provider.addcmd).to include '-allow_dup_flag'
     end
 
     it "should check and add if home is managed" do
       provider.expects(:check_manage_home).returns(['-manage_home_flag'])
-      provider.addcmd.should include '-manage_home_flag'
+      expect(provider.addcmd).to include '-manage_home_flag'
     end
 
     it "should add the resource :name" do
-      provider.addcmd.should include 'myuser'
+      expect(provider.addcmd).to include 'myuser'
     end
 
     describe "on systems featuring system_users", :if => described_class.system_users? do
       it "should return an array with -r if system? is true" do
         resource[:system] = :true
-        provider.addcmd.should include("-r")
+        expect(provider.addcmd).to include("-r")
       end
 
       it "should return an array without -r if system? is false" do
         resource[:system] = :false
-        provider.addcmd.should_not include("-r")
+        expect(provider.addcmd).not_to include("-r")
       end
     end
 
@@ -291,7 +307,7 @@ describe Puppet::Type.type(:user).provider(:useradd) do
       [:false, :true].each do |system|
         it "should return an array without -r if system? is #{system}" do
           resource[:system] = system
-          provider.addcmd.should_not include("-r")
+          expect(provider.addcmd).not_to include("-r")
         end
       end
     end
@@ -300,26 +316,26 @@ describe Puppet::Type.type(:user).provider(:useradd) do
       Facter.stubs(:value).with(:operatingsystem).returns 'Solaris'
       described_class.expects(:system_users?).returns true
       resource[:expiry] = "2012-08-18"
-      provider.addcmd.must == ['/usr/sbin/useradd', '-e', '08/18/2012', '-G', 'somegroup', '-o', '-m', '-r', 'myuser']
+      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
       Facter.stubs(:value).with(:operatingsystem).returns 'not_solaris'
       described_class.expects(:system_users?).returns true
       resource[:expiry] = "2012-08-18"
-      provider.addcmd.must == ['/usr/sbin/useradd', '-e', '2012-08-18', '-G', 'somegroup', '-o', '-m', '-r', 'myuser']
+      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
       described_class.expects(:system_users?).returns true
-      provider.addcmd.must == ["/usr/sbin/useradd", "-G", "somegroup", "-o", "-m", "-r", "myuser"]
+      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
       described_class.expects(:system_users?).returns true
       resource[:expiry] = :absent
 
-      provider.addcmd.must == ['/usr/sbin/useradd', '-e', '', '-G', 'somegroup', '-o', '-m', '-r', 'myuser']
+      expect(provider.addcmd).to eq(['/usr/sbin/useradd', '-e', '', '-G', 'somegroup', '-o', '-m', '-r', 'myuser'])
     end
   end
 
@@ -336,17 +352,17 @@ describe Puppet::Type.type(:user).provider(:useradd) do
       it "should return absent if libshadow feature is not present" do
         Puppet.features.stubs(:libshadow?).returns false
         # Shadow::Passwd.expects(:getspnam).never # if we really don't have libshadow we dont have Shadow::Passwd either
-        provider.send(property).should == :absent
+        expect(provider.send(property)).to eq(:absent)
       end
 
       it "should return absent if user cannot be found", :if => Puppet.features.libshadow? do
         Shadow::Passwd.expects(:getspnam).with('myuser').returns nil
-        provider.send(property).should == :absent
+        expect(provider.send(property)).to eq(:absent)
       end
 
       it "should return the correct value if libshadow is present", :if => Puppet.features.libshadow? do
         Shadow::Passwd.expects(:getspnam).with('myuser').returns shadow_entry
-        provider.send(property).should == expected_value
+        expect(provider.send(property)).to eq(expected_value)
       end
     end
   end
@@ -358,23 +374,23 @@ describe Puppet::Type.type(:user).provider(:useradd) do
 
     it "should return absent if libshadow feature is not present" do
       Puppet.features.stubs(:libshadow?).returns false
-      provider.expiry.should == :absent
+      expect(provider.expiry).to eq(:absent)
     end
 
     it "should return absent if user cannot be found", :if => Puppet.features.libshadow? do
       Shadow::Passwd.expects(:getspnam).with('myuser').returns nil
-      provider.expiry.should == :absent
+      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
       Shadow::Passwd.expects(:getspnam).with('myuser').returns shadow_entry
-      provider.expiry.should == :absent
+      expect(provider.expiry).to eq(:absent)
     end
 
     it "should convert to YYYY-MM-DD", :if => Puppet.features.libshadow? do
       Shadow::Passwd.expects(:getspnam).with('myuser').returns shadow_entry
-      provider.expiry.should == '2013-01-01'
+      expect(provider.expiry).to eq('2013-01-01')
     end
   end
 
@@ -395,35 +411,35 @@ describe Puppet::Type.type(:user).provider(:useradd) do
     end
 
     it "should return nil if neither min nor max is set" do
-      provider.passcmd.must be_nil
+      expect(provider.passcmd).to be_nil
     end
 
     it "should return a chage command array with -m <value> and the user name if password_min_age is set" do
       resource[:password_min_age] = 123
-      provider.passcmd.must == ['/usr/bin/chage','-m',123,'myuser']
+      expect(provider.passcmd).to eq(['/usr/bin/chage','-m',123,'myuser'])
     end
 
     it "should return a chage command array with -M <value> if password_max_age is set" do
       resource[:password_max_age] = 999
-      provider.passcmd.must == ['/usr/bin/chage','-M',999,'myuser']
+      expect(provider.passcmd).to eq(['/usr/bin/chage','-M',999,'myuser'])
     end
 
     it "should return a chage command array with -M <value> -m <value> if both password_min_age and password_max_age are set" do
       resource[:password_min_age] = 123
       resource[:password_max_age] = 999
-      provider.passcmd.must == ['/usr/bin/chage','-m',123,'-M',999,'myuser']
+      expect(provider.passcmd).to eq(['/usr/bin/chage','-m',123,'-M',999,'myuser'])
     end
   end
 
   describe "#check_valid_shell" do
     it "should raise an error if shell does not exist" do
       resource[:shell] = 'foo/bin/bash'
-      lambda { provider.check_valid_shell }.should raise_error(Puppet::Error, /Shell foo\/bin\/bash must exist/)
+      expect { provider.check_valid_shell }.to raise_error(Puppet::Error, /Shell foo\/bin\/bash must exist/)
     end
 
     it "should raise an error if the shell is not executable" do
       resource[:shell] = 'LICENSE'
-      lambda { provider.check_valid_shell }.should raise_error(Puppet::Error, /Shell LICENSE must be executable/)
+      expect { provider.check_valid_shell }.to raise_error(Puppet::Error, /Shell LICENSE must be executable/)
     end
   end