chef 12.0.0.alpha.2-x86-mingw32 → 12.0.0.rc.0-x86-mingw32

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

@@ -56,64 +56,64 @@ describe Chef::Provider::User::Pw do
     }
     field_list.each do |attribute, option|
       it "should check for differences in #{attribute} between the new and current resources" do
-        @current_resource.should_receive(attribute)
-        @new_resource.should_receive(attribute)
+        expect(@current_resource).to receive(attribute)
+        expect(@new_resource).to receive(attribute)
         @provider.set_options
       end
 
       it "should set the option for #{attribute} if the new resources #{attribute} is not null" do
-        @new_resource.stub(attribute).and_return("hola")
-        @provider.set_options.should eql(" #{@new_resource.username} #{option} '#{@new_resource.send(attribute)}' -m")
+        allow(@new_resource).to receive(attribute).and_return("hola")
+        expect(@provider.set_options).to eql(" #{@new_resource.username} #{option} '#{@new_resource.send(attribute)}' -m")
       end
 
       it "should set the option for #{attribute} if the new resources #{attribute} is not null, without homedir management" do
-        @new_resource.stub(:supports).and_return({:manage_home => false})
-        @new_resource.stub(attribute).and_return("hola")
-        @provider.set_options.should eql(" #{@new_resource.username} #{option} '#{@new_resource.send(attribute)}'")
+        allow(@new_resource).to receive(:supports).and_return({:manage_home => false})
+        allow(@new_resource).to receive(attribute).and_return("hola")
+        expect(@provider.set_options).to eql(" #{@new_resource.username} #{option} '#{@new_resource.send(attribute)}'")
       end
     end
 
     it "should combine all the possible options" do
       match_string = " adam"
       field_list.sort{ |a,b| a[0] <=> b[0] }.each do |attribute, option|
-        @new_resource.stub(attribute).and_return("hola")
+        allow(@new_resource).to receive(attribute).and_return("hola")
         match_string << " #{option} 'hola'"
       end
       match_string << " -m"
-      @provider.set_options.should eql(match_string)
+      expect(@provider.set_options).to eql(match_string)
     end
   end
 
   describe "create_user" do
     before(:each) do
-      @provider.stub(:run_command).and_return(true)
-      @provider.stub(:modify_password).and_return(true)
+      allow(@provider).to receive(:run_command).and_return(true)
+      allow(@provider).to receive(:modify_password).and_return(true)
     end
 
     it "should run pw useradd with the return of set_options" do
-      @provider.should_receive(:run_command).with({ :command => "pw useradd adam -m" }).and_return(true)
+      expect(@provider).to receive(:run_command).with({ :command => "pw useradd adam -m" }).and_return(true)
       @provider.create_user
     end
 
     it "should modify the password" do
-      @provider.should_receive(:modify_password).and_return(true)
+      expect(@provider).to receive(:modify_password).and_return(true)
       @provider.create_user
     end
   end
 
   describe "manage_user" do
     before(:each) do
-      @provider.stub(:run_command).and_return(true)
-      @provider.stub(:modify_password).and_return(true)
+      allow(@provider).to receive(:run_command).and_return(true)
+      allow(@provider).to receive(:modify_password).and_return(true)
     end
 
     it "should run pw usermod with the return of set_options" do
-      @provider.should_receive(:run_command).with({ :command => "pw usermod adam -m" }).and_return(true)
+      expect(@provider).to receive(:run_command).with({ :command => "pw usermod adam -m" }).and_return(true)
       @provider.manage_user
     end
 
     it "should modify the password" do
-      @provider.should_receive(:modify_password).and_return(true)
+      expect(@provider).to receive(:modify_password).and_return(true)
       @provider.create_user
     end
   end
@@ -121,38 +121,38 @@ describe Chef::Provider::User::Pw do
   describe "remove_user" do
     it "should run pw userdel with the new resources user name" do
       @new_resource.supports :manage_home => false
-      @provider.should_receive(:run_command).with({ :command => "pw userdel #{@new_resource.username}" }).and_return(true)
+      expect(@provider).to receive(:run_command).with({ :command => "pw userdel #{@new_resource.username}" }).and_return(true)
       @provider.remove_user
     end
 
     it "should run pw userdel with the new resources user name and -r if manage_home is true" do
-      @provider.should_receive(:run_command).with({ :command => "pw userdel #{@new_resource.username} -r"}).and_return(true)
+      expect(@provider).to receive(:run_command).with({ :command => "pw userdel #{@new_resource.username} -r"}).and_return(true)
       @provider.remove_user
     end
   end
 
   describe "determining if the user is locked" do
     it "should return true if user is locked" do
-      @current_resource.stub(:password).and_return("*LOCKED*abracadabra")
-      @provider.check_lock.should eql(true)
+      allow(@current_resource).to receive(:password).and_return("*LOCKED*abracadabra")
+      expect(@provider.check_lock).to eql(true)
     end
 
     it "should return false if user is not locked" do
-      @current_resource.stub(:password).and_return("abracadabra")
-      @provider.check_lock.should eql(false)
+      allow(@current_resource).to receive(:password).and_return("abracadabra")
+      expect(@provider.check_lock).to eql(false)
     end
   end
 
   describe "when locking the user" do
     it "should run pw lock with the new resources username" do
-      @provider.should_receive(:run_command).with({ :command => "pw lock #{@new_resource.username}"})
+      expect(@provider).to receive(:run_command).with({ :command => "pw lock #{@new_resource.username}"})
       @provider.lock_user
     end
   end
 
   describe "when unlocking the user" do
     it "should run pw unlock with the new resources username" do
-      @provider.should_receive(:run_command).with({ :command => "pw unlock #{@new_resource.username}"})
+      expect(@provider).to receive(:run_command).with({ :command => "pw unlock #{@new_resource.username}"})
       @provider.unlock_user
     end
   end
@@ -160,76 +160,76 @@ describe Chef::Provider::User::Pw do
   describe "when modifying the password" do
     before(:each) do
       @status = double("Status", :exitstatus => 0)
-      @provider.stub(:popen4).and_return(@status)
+      allow(@provider).to receive(:popen4).and_return(@status)
       @pid, @stdin, @stdout, @stderr = nil, nil, nil, nil
     end
 
     describe "and the new password has not been specified" do
       before(:each) do
-        @new_resource.stub(:password).and_return(nil)
+        allow(@new_resource).to receive(:password).and_return(nil)
       end
 
       it "logs an appropriate message" do
-        Chef::Log.should_receive(:debug).with("user[adam] no change needed to password")
+        expect(Chef::Log).to receive(:debug).with("user[adam] no change needed to password")
         @provider.modify_password
       end
     end
 
     describe "and the new password has been specified" do
       before(:each) do
-        @new_resource.stub(:password).and_return("abracadabra")
+        allow(@new_resource).to receive(:password).and_return("abracadabra")
       end
 
       it "should check for differences in password between the new and current resources" do
-        @current_resource.should_receive(:password)
-        @new_resource.should_receive(:password)
+        expect(@current_resource).to receive(:password)
+        expect(@new_resource).to receive(:password)
         @provider.modify_password
       end
     end
 
     describe "and the passwords are identical" do
       before(:each) do
-        @new_resource.stub(:password).and_return("abracadabra")
-        @current_resource.stub(:password).and_return("abracadabra")
+        allow(@new_resource).to receive(:password).and_return("abracadabra")
+        allow(@current_resource).to receive(:password).and_return("abracadabra")
       end
 
       it "logs an appropriate message" do
-        Chef::Log.should_receive(:debug).with("user[adam] no change needed to password")
+        expect(Chef::Log).to receive(:debug).with("user[adam] no change needed to password")
         @provider.modify_password
       end
     end
 
     describe "and the passwords are different" do
       before(:each) do
-        @new_resource.stub(:password).and_return("abracadabra")
-        @current_resource.stub(:password).and_return("sesame")
+        allow(@new_resource).to receive(:password).and_return("abracadabra")
+        allow(@current_resource).to receive(:password).and_return("sesame")
       end
 
       it "should log an appropriate message" do
-        Chef::Log.should_receive(:debug).with("user[adam] updating password")
+        expect(Chef::Log).to receive(:debug).with("user[adam] updating password")
         @provider.modify_password
       end
 
       it "should run pw usermod with the username and the option -H 0" do
-        @provider.should_receive(:popen4).with("pw usermod adam -H 0", :waitlast => true).and_return(@status)
+        expect(@provider).to receive(:popen4).with("pw usermod adam -H 0", :waitlast => true).and_return(@status)
         @provider.modify_password
       end
 
       it "should send the new password to the stdin of pw usermod" do
         @stdin = StringIO.new
-        @provider.stub(:popen4).and_yield(@pid, @stdin, @stdout, @stderr).and_return(@status)
+        allow(@provider).to receive(:popen4).and_yield(@pid, @stdin, @stdout, @stderr).and_return(@status)
         @provider.modify_password
-        @stdin.string.should == "abracadabra\n"
+        expect(@stdin.string).to eq("abracadabra\n")
       end
 
       it "should raise an exception if pw usermod fails" do
-        @status.should_receive(:exitstatus).and_return(1)
-        lambda { @provider.modify_password }.should raise_error(Chef::Exceptions::User)
+        expect(@status).to receive(:exitstatus).and_return(1)
+        expect { @provider.modify_password }.to raise_error(Chef::Exceptions::User)
       end
 
       it "should not raise an exception if pw usermod succeeds" do
-        @status.should_receive(:exitstatus).and_return(0)
-        lambda { @provider.modify_password }.should_not raise_error
+        expect(@status).to receive(:exitstatus).and_return(0)
+        expect { @provider.modify_password }.not_to raise_error
       end
     end
   end
@@ -240,13 +240,13 @@ describe Chef::Provider::User::Pw do
     end
 
     it "should raise an error if the required binary /usr/sbin/pw doesn't exist" do
-      File.should_receive(:exists?).with("/usr/sbin/pw").and_return(false)
-      lambda { @provider.load_current_resource }.should raise_error(Chef::Exceptions::User)
+      expect(File).to receive(:exists?).with("/usr/sbin/pw").and_return(false)
+      expect { @provider.load_current_resource }.to raise_error(Chef::Exceptions::User)
     end
 
     it "shouldn't raise an error if /usr/sbin/pw exists" do
-      File.stub(:exists?).and_return(true)
-      lambda { @provider.load_current_resource }.should_not raise_error
+      allow(File).to receive(:exists?).and_return(true)
+      expect { @provider.load_current_resource }.not_to raise_error
     end
   end
 end

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

@@ -27,7 +27,7 @@ describe Chef::Provider::User::Solaris do
     p.current_resource = @current_resource
 
     # Prevent the useradd-based provider tests from trying to write /etc/shadow
-    p.stub(:write_shadow_file)
+    allow(p).to receive(:write_shadow_file)
     p
   end
 
@@ -51,28 +51,28 @@ describe Chef::Provider::User::Solaris do
 
       @new_resource.password "hocus-pocus"
 
-      # Let these tests run #write_shadow_file
-      provider.unstub(:write_shadow_file)
     end
 
     it "should use its own shadow file writer to set the password" do
-      provider.should_receive(:write_shadow_file)
-      provider.stub(:shell_out!).and_return(true)
+      expect(provider).to receive(:write_shadow_file)
+      allow(provider).to receive(:shell_out!).and_return(true)
       provider.manage_user
     end
 
     it "should write out a modified version of the password file" do
+      # Let this test run #write_shadow_file
+      allow(provider).to receive(:write_shadow_file).and_call_original
       password_file = Tempfile.new("shadow")
       password_file.puts "adam:existingpassword:15441::::::"
       password_file.close
       provider.password_file = password_file.path
-      provider.stub(:shell_out!).and_return(true)
+      allow(provider).to receive(:shell_out!).and_return(true)
       # may not be able to write to /etc for tests...
       temp_file = Tempfile.new("shadow")
-      Tempfile.stub(:new).with("shadow", "/etc").and_return(temp_file)
+      allow(Tempfile).to receive(:new).with("shadow", "/etc").and_return(temp_file)
       @new_resource.password "verysecurepassword"
       provider.manage_user
-      ::File.open(password_file.path, "r").read.should =~ /adam:verysecurepassword:/
+      expect(::File.open(password_file.path, "r").read).to match(/adam:verysecurepassword:/)
       password_file.unlink
     end
   end

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

@@ -43,7 +43,7 @@ describe Chef::Provider::User::Useradd do
     # CHEF-5247: Chef::Provider::User::Solaris subclasses Chef::Provider::User::Useradd, but does not use usermod to change passwords.
     # Thus, a call to Solaris#manage_user calls Solaris#manage_password and Useradd#manage_user, but the latter should be a no-op.
     it "should not run the command if universal_options is an empty array" do
-      provider.stub(:universal_options).and_return([])
+      allow(provider).to receive(:universal_options).and_return([])
       expect(provider).not_to receive(:shell_out!)
       provider.manage_user
     end

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

@@ -36,7 +36,7 @@ describe Chef::Provider::User::Windows do
     @current_resource = Chef::Resource::User.new("monkey")
 
     @net_user = double("Chef::Util::Windows::NetUser")
-    Chef::Util::Windows::NetUser.stub(:new).and_return(@net_user)
+    allow(Chef::Util::Windows::NetUser).to receive(:new).and_return(@net_user)
 
     @provider = Chef::Provider::User::Windows.new(@new_resource, @run_context)
     @provider.current_resource = @current_resource
@@ -62,27 +62,27 @@ describe Chef::Provider::User::Windows do
 
     describe "and the attributes match" do
       it "doesn't set the comment field to be updated" do
-        @provider.set_options.should_not have_key(:full_name)
+        expect(@provider.set_options).not_to have_key(:full_name)
       end
 
       it "doesn't set the home directory to be updated" do
-        @provider.set_options.should_not have_key(:home_dir)
+        expect(@provider.set_options).not_to have_key(:home_dir)
       end
 
       it "doesn't set the group id to be updated" do
-        @provider.set_options.should_not have_key(:primary_group_id)
+        expect(@provider.set_options).not_to have_key(:primary_group_id)
       end
 
       it "doesn't set the user id to be updated" do
-        @provider.set_options.should_not have_key(:user_id)
+        expect(@provider.set_options).not_to have_key(:user_id)
       end
 
       it "doesn't set the shell to be updated" do
-        @provider.set_options.should_not have_key(:script_path)
+        expect(@provider.set_options).not_to have_key(:script_path)
       end
 
       it "doesn't set the password to be updated" do
-        @provider.set_options.should_not have_key(:password)
+        expect(@provider.set_options).not_to have_key(:password)
       end
 
     end
@@ -100,53 +100,53 @@ describe Chef::Provider::User::Windows do
       end
 
       it "marks the full_name field to be updated" do
-        @provider.set_options[:full_name].should == "Adam Jacob"
+        expect(@provider.set_options[:full_name]).to eq("Adam Jacob")
       end
 
       it "marks the home_dir attribute to be updated" do
-        @provider.set_options[:home_dir].should == '/home/adam'
+        expect(@provider.set_options[:home_dir]).to eq('/home/adam')
       end
 
       it "marks the primary_group_id attribute to be updated" do
-        @provider.set_options[:primary_group_id].should == 1000
+        expect(@provider.set_options[:primary_group_id]).to eq(1000)
       end
 
       it "marks the user_id attribute to be updated" do
-        @provider.set_options[:user_id].should == 1000
+        expect(@provider.set_options[:user_id]).to eq(1000)
       end
 
       it "marks the script_path attribute to be updated" do
-        @provider.set_options[:script_path].should == '/usr/bin/zsh'
+        expect(@provider.set_options[:script_path]).to eq('/usr/bin/zsh')
       end
 
       it "marks the password attribute to be updated" do
-        @provider.set_options[:password].should == 'abracadabra'
+        expect(@provider.set_options[:password]).to eq('abracadabra')
       end
     end
   end
 
   describe "when creating the user" do
     it "should call @net_user.add with the return of set_options" do
-      @provider.stub(:set_options).and_return(:name=> "monkey")
-      @net_user.should_receive(:add).with(:name=> "monkey")
+      allow(@provider).to receive(:set_options).and_return(:name=> "monkey")
+      expect(@net_user).to receive(:add).with(:name=> "monkey")
       @provider.create_user
     end
   end
 
   describe "manage_user" do
     before(:each) do
-      @provider.stub(:set_options).and_return(:name=> "monkey")
+      allow(@provider).to receive(:set_options).and_return(:name=> "monkey")
     end
 
     it "should call @net_user.update with the return of set_options" do
-      @net_user.should_receive(:update).with(:name=> "monkey")
+      expect(@net_user).to receive(:update).with(:name=> "monkey")
       @provider.manage_user
     end
   end
 
   describe "when removing the user" do
     it "should call @net_user.delete" do
-      @net_user.should_receive(:delete)
+      expect(@net_user).to receive(:delete)
       @provider.remove_user
     end
   end
@@ -157,28 +157,28 @@ describe Chef::Provider::User::Windows do
     end
 
     it "should return true if user is locked" do
-      @net_user.stub(:check_enabled).and_return(true)
-      @provider.check_lock.should eql(true)
+      allow(@net_user).to receive(:check_enabled).and_return(true)
+      expect(@provider.check_lock).to eql(true)
     end
 
     it "should return false if user is not locked" do
-      @net_user.stub(:check_enabled).and_return(false)
-      @provider.check_lock.should eql(false)
+      allow(@net_user).to receive(:check_enabled).and_return(false)
+      expect(@provider.check_lock).to eql(false)
     end
   end
 
   describe "locking the user" do
     it "should call @net_user.disable_account" do
-      @net_user.stub(:check_enabled).and_return(true)
-      @net_user.should_receive(:disable_account)
+      allow(@net_user).to receive(:check_enabled).and_return(true)
+      expect(@net_user).to receive(:disable_account)
       @provider.lock_user
     end
   end
 
   describe "unlocking the user" do
     it "should call @net_user.enable_account" do
-      @net_user.stub(:check_enabled).and_return(false)
-      @net_user.should_receive(:enable_account)
+      allow(@net_user).to receive(:check_enabled).and_return(false)
+      expect(@net_user).to receive(:enable_account)
       @provider.unlock_user
     end
   end

data/spec/unit/provider/user_spec.rb

@@ -47,11 +47,11 @@ describe Chef::Provider::User do
 
   describe "when first created" do
     it "assume the user exists by default" do
-      @provider.user_exists.should eql(true)
+      expect(@provider.user_exists).to eql(true)
     end
 
     it "does not know the locked state" do
-      @provider.locked.should eql(nil)
+      expect(@provider.locked).to eql(nil)
     end
   end
 
@@ -69,7 +69,7 @@ describe Chef::Provider::User do
       #  :password => nil,
       #  :updated => nil
       #)
-      Chef::Resource::User.stub(:new).and_return(@current_resource)
+      allow(Chef::Resource::User).to receive(:new).and_return(@current_resource)
       @pw_user = EtcPwnamIsh.new
       @pw_user.name = "adam"
       @pw_user.gid = 1000
@@ -78,34 +78,34 @@ describe Chef::Provider::User do
       @pw_user.dir = "/home/adam"
       @pw_user.shell = "/usr/bin/zsh"
       @pw_user.passwd = "*"
-      Etc.stub(:getpwnam).and_return(@pw_user)
+      allow(Etc).to receive(:getpwnam).and_return(@pw_user)
     end
 
     it "should create a current resource with the same name as the new resource" do
       @provider.load_current_resource
-      @provider.current_resource.name.should == 'adam'
+      expect(@provider.current_resource.name).to eq('adam')
     end
 
     it "should set the username of the current resource to the username of the new resource" do
       @provider.load_current_resource
-      @current_resource.username.should == @new_resource.username
+      expect(@current_resource.username).to eq(@new_resource.username)
     end
 
     it "should change the encoding of gecos to the encoding of the new resource", :ruby_gte_19_only do
       @pw_user.gecos.force_encoding('ASCII-8BIT')
       @provider.load_current_resource
-      @provider.current_resource.comment.encoding.should == @new_resource.comment.encoding
+      expect(@provider.current_resource.comment.encoding).to eq(@new_resource.comment.encoding)
     end
 
     it "should look up the user in /etc/passwd with getpwnam" do
-      Etc.should_receive(:getpwnam).with(@new_resource.username).and_return(@pw_user)
+      expect(Etc).to receive(:getpwnam).with(@new_resource.username).and_return(@pw_user)
       @provider.load_current_resource
     end
 
     it "should set user_exists to false if the user is not found with getpwnam" do
-      Etc.should_receive(:getpwnam).and_raise(ArgumentError)
+      expect(Etc).to receive(:getpwnam).and_raise(ArgumentError)
       @provider.load_current_resource
-      @provider.user_exists.should eql(false)
+      expect(@provider.user_exists).to eql(false)
     end
 
     # The mapping between the Chef::Resource::User and Getpwnam struct
@@ -118,24 +118,24 @@ describe Chef::Provider::User do
     }
     user_attrib_map.each do |user_attrib, getpwnam_attrib|
       it "should set the current resources #{user_attrib} based on getpwnam #{getpwnam_attrib}" do
-        @current_resource.should_receive(user_attrib).with(@pw_user.send(getpwnam_attrib))
+        expect(@current_resource).to receive(user_attrib).with(@pw_user.send(getpwnam_attrib))
         @provider.load_current_resource
       end
     end
 
     it "should attempt to convert the group gid if one has been supplied" do
-      @provider.should_receive(:convert_group_name)
+      expect(@provider).to receive(:convert_group_name)
       @provider.load_current_resource
     end
 
     it "shouldn't try and convert the group gid if none has been supplied" do
-      @new_resource.stub(:gid).and_return(nil)
-      @provider.should_not_receive(:convert_group_name)
+      allow(@new_resource).to receive(:gid).and_return(nil)
+      expect(@provider).not_to receive(:convert_group_name)
       @provider.load_current_resource
     end
 
     it "should return the current resource" do
-      @provider.load_current_resource.should eql(@current_resource)
+      expect(@provider.load_current_resource).to eql(@current_resource)
     end
 
     describe "and running assertions" do
@@ -156,7 +156,7 @@ describe Chef::Provider::User do
         user.name = "root"
         user.passwd = "x"
         @new_resource.password "some new password"
-        Etc.stub(:getpwnam).and_return(user)
+        allow(Etc).to receive(:getpwnam).and_return(user)
       end
 
       unless shadow_lib_unavail?
@@ -167,10 +167,10 @@ describe Chef::Provider::User do
             it "should pass assertions when ruby-shadow can be loaded" do
               @provider.action = 'create'
               original_method = @provider.method(:require)
-              @provider.should_receive(:require) { |*args| original_method.call(*args) }
+              expect(@provider).to receive(:require) { |*args| original_method.call(*args) }
               passwd_info = Struct::PasswdEntry.new(:sp_namp => "adm ", :sp_pwdp => "$1$T0N0Q.lc$nyG6pFI3Dpqa5cxUz/57j0", :sp_lstchg => 14861, :sp_min => 0, :sp_max => 99999,
                                                     :sp_warn => 7, :sp_inact => -1, :sp_expire => -1, :sp_flag => -1)
-              Shadow::Passwd.should_receive(:getspnam).with("adam").and_return(passwd_info)
+              expect(Shadow::Passwd).to receive(:getspnam).with("adam").and_return(passwd_info)
               @provider.load_current_resource
               @provider.define_resource_requirements
               @provider.process_resource_requirements
@@ -180,10 +180,10 @@ describe Chef::Provider::User do
       end
 
       it "should fail assertions when ruby-shadow cannot be loaded" do
-        @provider.should_receive(:require).with("shadow") { raise LoadError }
+        expect(@provider).to receive(:require).with("shadow") { raise LoadError }
         @provider.load_current_resource
         @provider.define_resource_requirements
-        lambda {@provider.process_resource_requirements}.should raise_error Chef::Exceptions::MissingLibrary
+        expect {@provider.process_resource_requirements}.to raise_error Chef::Exceptions::MissingLibrary
       end
 
     end
@@ -206,7 +206,7 @@ describe Chef::Provider::User do
       it "should return true if #{attribute} doesn't match" do
         @new_resource.send(attribute, mapping[attribute][0])
         @current_resource.send(attribute, mapping[attribute][1])
-        @provider.compare_user.should eql(true)
+        expect(@provider.compare_user).to eql(true)
       end
     end
 
@@ -214,18 +214,18 @@ describe Chef::Provider::User do
       it "should return false if string #{attribute} matches fixnum" do
         @new_resource.send(attribute, "100")
         @current_resource.send(attribute, 100)
-        @provider.compare_user.should eql(false)
+        expect(@provider.compare_user).to eql(false)
       end
     end
 
     it "should return false if the objects are identical" do
-      @provider.compare_user.should eql(false)
+      expect(@provider.compare_user).to eql(false)
     end
   end
 
   describe "action_create" do
     before(:each) do
-      @provider.stub(:load_current_resource)
+      allow(@provider).to receive(:load_current_resource)
       # @current_resource = double("Chef::Resource::User",
       #   :null_object => true,
       #   :username => "adam",
@@ -246,58 +246,58 @@ describe Chef::Provider::User do
 
     it "should call create_user if the user does not exist" do
       @provider.user_exists = false
-      @provider.should_receive(:create_user).and_return(true)
+      expect(@provider).to receive(:create_user).and_return(true)
       @provider.action_create
       @provider.set_updated_status
-      @new_resource.should be_updated
+      expect(@new_resource).to be_updated
     end
 
     it "should call manage_user if the user exists and has mismatched attributes" do
       @provider.user_exists = true
-      @provider.stub(:compare_user).and_return(true)
-      @provider.should_receive(:manage_user).and_return(true)
+      allow(@provider).to receive(:compare_user).and_return(true)
+      expect(@provider).to receive(:manage_user).and_return(true)
       @provider.action_create
     end
 
     it "should set the new_resources updated flag when it creates the user if we call manage_user" do
       @provider.user_exists = true
-      @provider.stub(:compare_user).and_return(true)
-      @provider.stub(:manage_user).and_return(true)
+      allow(@provider).to receive(:compare_user).and_return(true)
+      allow(@provider).to receive(:manage_user).and_return(true)
       @provider.action_create
       @provider.set_updated_status
-      @new_resource.should be_updated
+      expect(@new_resource).to be_updated
     end
   end
 
   describe "action_remove" do
     before(:each) do
-      @provider.stub(:load_current_resource)
+      allow(@provider).to receive(:load_current_resource)
     end
 
     it "should not call remove_user if the user does not exist" do
       @provider.user_exists = false
-      @provider.should_not_receive(:remove_user)
+      expect(@provider).not_to receive(:remove_user)
       @provider.action_remove
     end
 
     it "should call remove_user if the user exists" do
       @provider.user_exists = true
-      @provider.should_receive(:remove_user)
+      expect(@provider).to receive(:remove_user)
       @provider.action_remove
     end
 
     it "should set the new_resources updated flag to true if the user is removed" do
       @provider.user_exists = true
-      @provider.should_receive(:remove_user)
+      expect(@provider).to receive(:remove_user)
       @provider.action_remove
       @provider.set_updated_status
-      @new_resource.should be_updated
+      expect(@new_resource).to be_updated
     end
   end
 
   describe "action_manage" do
     before(:each) do
-      @provider.stub(:load_current_resource)
+      allow(@provider).to receive(:load_current_resource)
       # @node = Chef::Node.new
       # @new_resource = double("Chef::Resource::User",
       #   :null_object => true
@@ -312,35 +312,35 @@ describe Chef::Provider::User do
     end
 
     it "should run manage_user if the user exists and has mismatched attributes" do
-      @provider.should_receive(:compare_user).and_return(true)
-      @provider.should_receive(:manage_user).and_return(true)
+      expect(@provider).to receive(:compare_user).and_return(true)
+      expect(@provider).to receive(:manage_user).and_return(true)
       @provider.action_manage
     end
 
     it "should set the new resources updated flag to true if manage_user is called" do
-      @provider.stub(:compare_user).and_return(true)
-      @provider.stub(:manage_user).and_return(true)
+      allow(@provider).to receive(:compare_user).and_return(true)
+      allow(@provider).to receive(:manage_user).and_return(true)
       @provider.action_manage
       @provider.set_updated_status
-      @new_resource.should be_updated
+      expect(@new_resource).to be_updated
     end
 
     it "should not run manage_user if the user does not exist" do
       @provider.user_exists = false
-      @provider.should_not_receive(:manage_user)
+      expect(@provider).not_to receive(:manage_user)
       @provider.action_manage
     end
 
     it "should not run manage_user if the user exists but has no differing attributes" do
-      @provider.should_receive(:compare_user).and_return(false)
-      @provider.should_not_receive(:manage_user)
+      expect(@provider).to receive(:compare_user).and_return(false)
+      expect(@provider).not_to receive(:manage_user)
       @provider.action_manage
     end
   end
 
   describe "action_modify" do
     before(:each) do
-      @provider.stub(:load_current_resource)
+      allow(@provider).to receive(:load_current_resource)
       # @node = Chef::Node.new
       # @new_resource = double("Chef::Resource::User",
       #   :null_object => true
@@ -355,61 +355,61 @@ describe Chef::Provider::User do
     end
 
     it "should run manage_user if the user exists and has mismatched attributes" do
-      @provider.should_receive(:compare_user).and_return(true)
-      @provider.should_receive(:manage_user).and_return(true)
+      expect(@provider).to receive(:compare_user).and_return(true)
+      expect(@provider).to receive(:manage_user).and_return(true)
       @provider.action_modify
     end
 
     it "should set the new resources updated flag to true if manage_user is called" do
-      @provider.stub(:compare_user).and_return(true)
-      @provider.stub(:manage_user).and_return(true)
+      allow(@provider).to receive(:compare_user).and_return(true)
+      allow(@provider).to receive(:manage_user).and_return(true)
       @provider.action_modify
       @provider.set_updated_status
-      @new_resource.should be_updated
+      expect(@new_resource).to be_updated
     end
 
     it "should not run manage_user if the user exists but has no differing attributes" do
-      @provider.should_receive(:compare_user).and_return(false)
-      @provider.should_not_receive(:manage_user)
+      expect(@provider).to receive(:compare_user).and_return(false)
+      expect(@provider).not_to receive(:manage_user)
       @provider.action_modify
     end
 
     it "should raise a Chef::Exceptions::User if the user doesn't exist" do
       @provider.user_exists = false
-      lambda { @provider.action = :modify; @provider.run_action }.should raise_error(Chef::Exceptions::User)
+      expect { @provider.action = :modify; @provider.run_action }.to raise_error(Chef::Exceptions::User)
     end
   end
 
 
   describe "action_lock" do
     before(:each) do
-      @provider.stub(:load_current_resource)
+      allow(@provider).to receive(:load_current_resource)
     end
     it "should lock the user if it exists and is unlocked" do
-      @provider.stub(:check_lock).and_return(false)
-      @provider.should_receive(:lock_user).and_return(true)
+      allow(@provider).to receive(:check_lock).and_return(false)
+      expect(@provider).to receive(:lock_user).and_return(true)
       @provider.action_lock
     end
 
     it "should set the new resources updated flag to true if lock_user is called" do
-      @provider.stub(:check_lock).and_return(false)
-      @provider.should_receive(:lock_user)
+      allow(@provider).to receive(:check_lock).and_return(false)
+      expect(@provider).to receive(:lock_user)
       @provider.action_lock
       @provider.set_updated_status
-      @new_resource.should be_updated
+      expect(@new_resource).to be_updated
     end
 
     it "should raise a Chef::Exceptions::User if we try and lock a user that does not exist" do
       @provider.user_exists = false
       @provider.action = :lock
 
-      lambda { @provider.run_action }.should raise_error(Chef::Exceptions::User)
+      expect { @provider.run_action }.to raise_error(Chef::Exceptions::User)
     end
   end
 
   describe "action_unlock" do
     before(:each) do
-      @provider.stub(:load_current_resource)
+      allow(@provider).to receive(:load_current_resource)
       # @node = Chef::Node.new
       # @new_resource = double("Chef::Resource::User",
       #   :null_object => true
@@ -425,17 +425,17 @@ describe Chef::Provider::User do
     end
 
     it "should unlock the user if it exists and is locked" do
-      @provider.stub(:check_lock).and_return(true)
-      @provider.should_receive(:unlock_user).and_return(true)
+      allow(@provider).to receive(:check_lock).and_return(true)
+      expect(@provider).to receive(:unlock_user).and_return(true)
       @provider.action_unlock
       @provider.set_updated_status
-      @new_resource.should be_updated
+      expect(@new_resource).to be_updated
     end
 
     it "should raise a Chef::Exceptions::User if we try and unlock a user that does not exist" do
       @provider.user_exists = false
       @provider.action = :unlock
-      lambda { @provider.run_action }.should raise_error(Chef::Exceptions::User)
+      expect { @provider.run_action }.to raise_error(Chef::Exceptions::User)
     end
   end
 
@@ -446,21 +446,21 @@ describe Chef::Provider::User do
     end
 
     it "should lookup the group name locally" do
-      Etc.should_receive(:getgrnam).with("999").and_return(@group)
-      @provider.convert_group_name.should == 999
+      expect(Etc).to receive(:getgrnam).with("999").and_return(@group)
+      expect(@provider.convert_group_name).to eq(999)
     end
 
     it "should raise an error if we can't translate the group name during resource assertions" do
-      Etc.should_receive(:getgrnam).and_raise(ArgumentError)
+      expect(Etc).to receive(:getgrnam).and_raise(ArgumentError)
       @provider.define_resource_requirements
       @provider.convert_group_name
-      lambda { @provider.process_resource_requirements }.should raise_error(Chef::Exceptions::User)
+      expect { @provider.process_resource_requirements }.to raise_error(Chef::Exceptions::User)
     end
 
     it "should set the new resources gid to the integerized version if available" do
-      Etc.should_receive(:getgrnam).with("999").and_return(@group)
+      expect(Etc).to receive(:getgrnam).with("999").and_return(@group)
       @provider.convert_group_name
-      @new_resource.gid.should == 999
+      expect(@new_resource.gid).to eq(999)
     end
   end
 end