fat_free_crm 0.13.6 → 0.14.0

data/spec/controllers/admin/groups_controller_spec.rb

@@ -6,5 +6,4 @@
 require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 
 describe Admin::GroupsController do
-
 end

data/spec/controllers/admin/users_controller_spec.rb

@@ -6,9 +6,8 @@
 require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 
 describe Admin::UsersController do
-
   before(:each) do
-    require_user(:admin => true)
+    require_user(admin: true)
     set_current_tab(:users)
   end
 
@@ -17,22 +16,22 @@ describe Admin::UsersController do
   #----------------------------------------------------------------------------
   describe "GET index" do
     it "assigns all users as @users and renders [index] template" do
-      @users = [ current_user, FactoryGirl.create(:user) ]
+      @users = [current_user, FactoryGirl.create(:user)]
 
       get :index
-      assigns[:users].first.should == @users.last # get_users() sorts by id DESC
-      assigns[:users].last.should == @users.first
-      response.should render_template("admin/users/index")
+      expect(assigns[:users].first).to eq(@users.last) # get_users() sorts by id DESC
+      expect(assigns[:users].last).to eq(@users.first)
+      expect(response).to render_template("admin/users/index")
     end
 
     it "performs lookup using query string" do
-      @amy = FactoryGirl.create(:user, :username => "amy_anderson")
-      @bob = FactoryGirl.create(:user, :username => "bob_builder")
+      @amy = FactoryGirl.create(:user, username: "amy_anderson")
+      @bob = FactoryGirl.create(:user, username: "bob_builder")
 
-      get :index, :query => "amy_anderson"
-      assigns[:users].should == [ @amy ]
-      assigns[:current_query].should == "amy_anderson"
-      session[:users_current_query].should == "amy_anderson"
+      get :index, query: "amy_anderson"
+      expect(assigns[:users]).to eq([@amy])
+      expect(assigns[:current_query]).to eq("amy_anderson")
+      expect(session[:users_current_query]).to eq("amy_anderson")
     end
   end
 
@@ -43,9 +42,9 @@ describe Admin::UsersController do
     it "assigns the requested user as @user and renders [show] template" do
       @user = FactoryGirl.create(:user)
 
-      get :show, :id => @user.id
-      assigns[:user].should == @user
-      response.should render_template("admin/users/show")
+      get :show, id: @user.id
+      expect(assigns[:user]).to eq(@user)
+      expect(response).to render_template("admin/users/show")
     end
   end
 
@@ -56,7 +55,7 @@ describe Admin::UsersController do
     it "assigns a new user as @user and renders [new] template" do
       xhr :get, :new
       expect(assigns[:user]).to be_new_record
-      response.should render_template("admin/users/new")
+      expect(response).to render_template("admin/users/new")
     end
   end
 
@@ -66,27 +65,27 @@ describe Admin::UsersController do
     it "assigns the requested user as @user and renders [edit] template" do
       @user = FactoryGirl.create(:user)
 
-      xhr :get, :edit, :id => @user.id
-      assigns[:user].should == @user
-      assigns[:previous].should == nil
-      response.should render_template("admin/users/edit")
+      xhr :get, :edit, id: @user.id
+      expect(assigns[:user]).to eq(@user)
+      expect(assigns[:previous]).to eq(nil)
+      expect(response).to render_template("admin/users/edit")
     end
 
     it "assigns the previous user as @previous when necessary" do
       @user = FactoryGirl.create(:user)
       @previous = FactoryGirl.create(:user)
 
-      xhr :get, :edit, :id => @user.id, :previous => @previous.id
-      assigns[:previous].should == @previous
+      xhr :get, :edit, id: @user.id, previous: @previous.id
+      expect(assigns[:previous]).to eq(@previous)
     end
 
     it "reloads current page with the flash message if user got deleted" do
       @user = FactoryGirl.create(:user)
       @user.destroy
 
-      xhr :get, :edit, :id => @user.id
-      flash[:warning].should_not == nil
-      response.body.should == "window.location.reload();"
+      xhr :get, :edit, id: @user.id
+      expect(flash[:warning]).not_to eq(nil)
+      expect(response.body).to eq("window.location.reload();")
     end
 
     it "notifies the view if previous user got deleted" do
@@ -94,10 +93,10 @@ describe Admin::UsersController do
       @previous = FactoryGirl.create(:user)
       @previous.destroy
 
-      xhr :get, :edit, :id => @user.id, :previous => @previous.id
-      flash[:warning].should == nil # no warning, just silently remove the div
-      assigns[:previous].should == @previous.id
-      response.should render_template("admin/users/edit")
+      xhr :get, :edit, id: @user.id, previous: @previous.id
+      expect(flash[:warning]).to eq(nil) # no warning, just silently remove the div
+      expect(assigns[:previous]).to eq(@previous.id)
+      expect(response).to render_template("admin/users/edit")
     end
   end
 
@@ -105,7 +104,6 @@ describe Admin::UsersController do
   # POST /admin/users.xml                                                  AJAX
   #----------------------------------------------------------------------------
   describe "POST create" do
-
     describe "with valid params" do
       before(:each) do
         @username = "none"
@@ -114,35 +112,35 @@ describe Admin::UsersController do
       end
 
       it "assigns a newly created user as @user and renders [create] template" do
-        @user = FactoryGirl.build(:user, :username => @username, :email => @email)
-        User.stub(:new).and_return(@user)
+        @user = FactoryGirl.build(:user, username: @username, email: @email)
+        allow(User).to receive(:new).and_return(@user)
 
-        xhr :post, :create, :user => { :username => @username, :email => @email, :password => @password, :password_confirmation => @password }
-        assigns[:user].should == @user
-        response.should render_template("admin/users/create")
+        xhr :post, :create, user: { username: @username, email: @email, password: @password, password_confirmation: @password }
+        expect(assigns[:user]).to eq(@user)
+        expect(response).to render_template("admin/users/create")
       end
 
       it "creates admin user when requested so" do
-        xhr :post, :create, :user => { :username => @username, :email => @email, :admin => "1", :password => @password, :password_confirmation => @password }
-        assigns[:user].admin.should == true
-        response.should render_template("admin/users/create")
+        xhr :post, :create, user: { username: @username, email: @email, admin: "1", password: @password, password_confirmation: @password }
+        expect(assigns[:user].admin).to eq(true)
+        expect(response).to render_template("admin/users/create")
       end
 
       it "doesn't create admin user unless requested so" do
-        xhr :post, :create, :user => { :username => @username, :email => @email, :admin => "0", :password => @password, :password_confirmation => @password }
-        assigns[:user].admin.should == false
-        response.should render_template("admin/users/create")
+        xhr :post, :create, user: { username: @username, email: @email, admin: "0", password: @password, password_confirmation: @password }
+        expect(assigns[:user].admin).to eq(false)
+        expect(response).to render_template("admin/users/create")
       end
     end
 
     describe "with invalid params" do
       it "assigns a newly created but unsaved user as @user and re-renders [create] template" do
-        @user = FactoryGirl.build(:user, :username => "", :email => "")
-        User.stub(:new).and_return(@user)
+        @user = FactoryGirl.build(:user, username: "", email: "")
+        allow(User).to receive(:new).and_return(@user)
 
-        xhr :post, :create, :user => {}
-        assigns[:user].should == @user
-        response.should render_template("admin/users/create")
+        xhr :post, :create, user: {}
+        expect(assigns[:user]).to eq(@user)
+        expect(response).to render_template("admin/users/create")
       end
     end
   end
@@ -151,51 +149,50 @@ describe Admin::UsersController do
   # PUT /admin/users/1.xml                                                 AJAX
   #----------------------------------------------------------------------------
   describe "PUT update" do
-
     describe "with valid params" do
       it "updates the requested user, assigns it to @user, and renders [update] template" do
-        @user = FactoryGirl.create(:user, :username => "flip", :email => "flip@example.com")
+        @user = FactoryGirl.create(:user, username: "flip", email: "flip@example.com")
 
-        xhr :put, :update, :id => @user.id, :user => { :username => "flop", :email => "flop@example.com" }
-        assigns[:user].should == @user.reload
-        assigns[:user].username.should == "flop"
-        response.should render_template("admin/users/update")
+        xhr :put, :update, id: @user.id, user: { username: "flop", email: "flop@example.com" }
+        expect(assigns[:user]).to eq(@user.reload)
+        expect(assigns[:user].username).to eq("flop")
+        expect(response).to render_template("admin/users/update")
       end
 
       it "reloads current page is the user got deleted" do
         @user = FactoryGirl.create(:user)
         @user.destroy
 
-        xhr :put, :update, :id => @user.id, :user => { :username => "flop", :email => "flop@example.com" }
-        flash[:warning].should_not == nil
-        response.body.should == "window.location.reload();"
+        xhr :put, :update, id: @user.id, user: { username: "flop", email: "flop@example.com" }
+        expect(flash[:warning]).not_to eq(nil)
+        expect(response.body).to eq("window.location.reload();")
       end
 
       it "assigns admin rights when requested so" do
-        @user = FactoryGirl.create(:user, :admin => false)
-        xhr :put, :update, :id => @user.id, :user => { :admin => "1", :username => @user.username, :email => @user.email }
-        assigns[:user].should == @user.reload
-        assigns[:user].admin.should == true
-        response.should render_template("admin/users/update")
+        @user = FactoryGirl.create(:user, admin: false)
+        xhr :put, :update, id: @user.id, user: { admin: "1", username: @user.username, email: @user.email }
+        expect(assigns[:user]).to eq(@user.reload)
+        expect(assigns[:user].admin).to eq(true)
+        expect(response).to render_template("admin/users/update")
       end
 
       it "revokes admin rights when requested so" do
-        @user = FactoryGirl.create(:user, :admin => true)
-        xhr :put, :update, :id => @user.id, :user => { :admin => "0", :username => @user.username, :email => @user.email }
-        assigns[:user].should == @user.reload
-        assigns[:user].admin.should == false
-        response.should render_template("admin/users/update")
+        @user = FactoryGirl.create(:user, admin: true)
+        xhr :put, :update, id: @user.id, user: { admin: "0", username: @user.username, email: @user.email }
+        expect(assigns[:user]).to eq(@user.reload)
+        expect(assigns[:user].admin).to eq(false)
+        expect(response).to render_template("admin/users/update")
       end
     end
 
     describe "with invalid params" do
       it "doesn't update the requested user, but assigns it to @user and renders [update] template" do
-        @user = FactoryGirl.create(:user, :username => "flip", :email => "flip@example.com")
+        @user = FactoryGirl.create(:user, username: "flip", email: "flip@example.com")
 
-        xhr :put, :update, :id => @user.id, :user => {}
-        assigns[:user].should == @user.reload
-        assigns[:user].username.should == "flip"
-        response.should render_template("admin/users/update")
+        xhr :put, :update, id: @user.id, user: {}
+        expect(assigns[:user]).to eq(@user.reload)
+        expect(assigns[:user].username).to eq("flip")
+        expect(response).to render_template("admin/users/update")
       end
     end
   end
@@ -206,18 +203,18 @@ describe Admin::UsersController do
     it "assigns the requested user as @user and renders [confirm] template" do
       @user = FactoryGirl.create(:user)
 
-      xhr :get, :confirm, :id => @user.id
-      assigns[:user].should == @user
-      response.should render_template("admin/users/confirm")
+      xhr :get, :confirm, id: @user.id
+      expect(assigns[:user]).to eq(@user)
+      expect(response).to render_template("admin/users/confirm")
     end
 
     it "reloads current page is the user got deleted" do
       @user = FactoryGirl.create(:user)
       @user.destroy
 
-      xhr :get, :confirm, :id => @user.id
-      flash[:warning].should_not == nil
-      response.body.should == "window.location.reload();"
+      xhr :get, :confirm, id: @user.id
+      expect(flash[:warning]).not_to eq(nil)
+      expect(response.body).to eq("window.location.reload();")
     end
   end
 
@@ -228,19 +225,19 @@ describe Admin::UsersController do
     it "destroys the requested user and renders [destroy] template" do
       @user = FactoryGirl.create(:user)
 
-      xhr :delete, :destroy, :id => @user.id
-      lambda { User.find(@user) }.should raise_error(ActiveRecord::RecordNotFound)
-      response.should render_template("admin/users/destroy")
+      xhr :delete, :destroy, id: @user.id
+      expect { User.find(@user.id) }.to raise_error(ActiveRecord::RecordNotFound)
+      expect(response).to render_template("admin/users/destroy")
     end
 
     it "handles the case when the requested user can't be deleted" do
       @user = FactoryGirl.create(:user)
-      @account = FactoryGirl.create(:account, :user => @user) # Plant artifact to prevent the user from being deleted.
+      @account = FactoryGirl.create(:account, user: @user) # Plant artifact to prevent the user from being deleted.
 
-      xhr :delete, :destroy, :id => @user.id
-      flash[:warning].should_not == nil
-      expect { User.find(@user) }.not_to raise_error()
-      response.should render_template("admin/users/destroy")
+      xhr :delete, :destroy, id: @user.id
+      expect(flash[:warning]).not_to eq(nil)
+      expect { User.find(@user.id) }.not_to raise_error
+      expect(response).to render_template("admin/users/destroy")
     end
   end
 
@@ -248,7 +245,7 @@ describe Admin::UsersController do
   #----------------------------------------------------------------------------
   describe "POST auto_complete" do
     before(:each) do
-      @auto_complete_matches = [ FactoryGirl.create(:user, :first_name => "Hello") ]
+      @auto_complete_matches = [FactoryGirl.create(:user, first_name: "Hello")]
     end
 
     it_should_behave_like("auto complete")
@@ -261,26 +258,26 @@ describe Admin::UsersController do
     it "suspends the requested user" do
       @user = FactoryGirl.create(:user)
 
-      xhr :put, :suspend, :id => @user.id
-      assigns[:user].suspended?.should == true
-      response.should render_template("admin/users/suspend")
+      xhr :put, :suspend, id: @user.id
+      expect(assigns[:user].suspended?).to eq(true)
+      expect(response).to render_template("admin/users/suspend")
     end
 
     it "doesn't suspend current user" do
       @user = current_user
 
-      xhr :put, :suspend, :id => @user.id
-      assigns[:user].suspended?.should == false
-      response.should render_template("admin/users/suspend")
+      xhr :put, :suspend, id: @user.id
+      expect(assigns[:user].suspended?).to eq(false)
+      expect(response).to render_template("admin/users/suspend")
     end
 
     it "reloads current page is the user got deleted" do
       @user = FactoryGirl.create(:user)
       @user.destroy
 
-      xhr :put, :suspend, :id => @user.id
-      flash[:warning].should_not == nil
-      response.body.should == "window.location.reload();"
+      xhr :put, :suspend, id: @user.id
+      expect(flash[:warning]).not_to eq(nil)
+      expect(response.body).to eq("window.location.reload();")
     end
   end
 
@@ -289,21 +286,20 @@ describe Admin::UsersController do
   #----------------------------------------------------------------------------
   describe "PUT reactivate" do
     it "re-activates the requested user" do
-      @user = FactoryGirl.create(:user, :suspended_at => Time.now.yesterday)
+      @user = FactoryGirl.create(:user, suspended_at: Time.now.yesterday)
 
-      xhr :put, :reactivate, :id => @user.id
-      assigns[:user].suspended?.should == false
-      response.should render_template("admin/users/reactivate")
+      xhr :put, :reactivate, id: @user.id
+      expect(assigns[:user].suspended?).to eq(false)
+      expect(response).to render_template("admin/users/reactivate")
     end
 
     it "reloads current page is the user got deleted" do
       @user = FactoryGirl.create(:user)
       @user.destroy
 
-      xhr :put, :reactivate, :id => @user.id
-      flash[:warning].should_not == nil
-      response.body.should == "window.location.reload();"
+      xhr :put, :reactivate, id: @user.id
+      expect(flash[:warning]).not_to eq(nil)
+      expect(response.body).to eq("window.location.reload();")
     end
   end
-
 end

data/spec/controllers/applications_controller_spec.rb

@@ -6,40 +6,36 @@
 require 'spec_helper'
 
 describe ApplicationController do
-
   describe "auto_complete_ids_to_exclude" do
-  
     it "should return [] when related is nil" do
-      controller.send(:auto_complete_ids_to_exclude, nil).should == []
+      expect(controller.send(:auto_complete_ids_to_exclude, nil)).to eq([])
     end
-    
+
     it "should return [] when related is ''" do
-      controller.send(:auto_complete_ids_to_exclude, '').should == []
+      expect(controller.send(:auto_complete_ids_to_exclude, '')).to eq([])
     end
-    
+
     it "should return campaign id 5 when related is '5' and controller is campaigns" do
-      controller.send(:auto_complete_ids_to_exclude, '5').sort.should == [5]
+      expect(controller.send(:auto_complete_ids_to_exclude, '5').sort).to eq([5])
     end
-    
+
     it "should return [6, 9] when related is 'campaigns/7'" do
-      controller.stub(:controller_name).and_return('opportunities')
-      campaign = double(Campaign, :opportunities => [double(:id => 6), double(:id => 9)])
-      Campaign.should_receive(:find_by_id).with('7').and_return(campaign)
-      controller.send(:auto_complete_ids_to_exclude, 'campaigns/7').sort.should == [6, 9]
+      allow(controller).to receive(:controller_name).and_return('opportunities')
+      campaign = double(Campaign, opportunities: [double(id: 6), double(id: 9)])
+      expect(Campaign).to receive(:find_by_id).with('7').and_return(campaign)
+      expect(controller.send(:auto_complete_ids_to_exclude, 'campaigns/7').sort).to eq([6, 9])
     end
-    
+
     it "should return [] when related object is not found" do
-      Campaign.should_receive(:find_by_id).with('7').and_return(nil)
-      controller.send(:auto_complete_ids_to_exclude, 'campaigns/7').should == []
+      expect(Campaign).to receive(:find_by_id).with('7').and_return(nil)
+      expect(controller.send(:auto_complete_ids_to_exclude, 'campaigns/7')).to eq([])
     end
-    
+
     it "should return [] when related object association is not found" do
-      controller.stub(:controller_name).and_return('not_a_method_that_exists')
+      allow(controller).to receive(:controller_name).and_return('not_a_method_that_exists')
       campaign = double(Campaign)
-      Campaign.should_receive(:find_by_id).with('7').and_return(campaign)
-      controller.send(:auto_complete_ids_to_exclude, 'campaigns/7').should == []
+      expect(Campaign).to receive(:find_by_id).with('7').and_return(campaign)
+      expect(controller.send(:auto_complete_ids_to_exclude, 'campaigns/7')).to eq([])
     end
-    
   end
-
 end

data/spec/controllers/authentications_controller_spec.rb

@@ -6,7 +6,6 @@
 require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
 
 describe AuthenticationsController do
-
   before(:each) do
     activate_authlogic
     logout
@@ -19,39 +18,39 @@ describe AuthenticationsController do
       describe "DELETE authentication (logout form)" do
         it "displays 'must be logged out message' and redirects to login page" do
           delete :destroy
-          flash[:notice].should_not == nil
-          flash[:notice].should =~ /^You must be logged in/
-          response.should redirect_to(login_path)
+          expect(flash[:notice]).not_to eq(nil)
+          expect(flash[:notice]).to match(/^You must be logged in/)
+          expect(response).to redirect_to(login_path)
         end
 
         it "redirects to login page" do
           get :show
-          response.should redirect_to(login_path)
+          expect(response).to redirect_to(login_path)
         end
       end
     end
 
     describe "user must not be logged in" do
       before(:each) do
-        @user = FactoryGirl.create(:user, :username => "user", :password => "pass", :password_confirmation => "pass")
-        @controller.stub(:current_user).and_return(@user)
+        @user = FactoryGirl.create(:user, username: "user", password: "pass", password_confirmation: "pass")
+        allow(@controller).to receive(:current_user).and_return(@user)
       end
 
       describe "GET authentication (login form)" do
         it "displays 'must be logged out message' and redirects to profile page" do
           get :new
-          flash[:notice].should_not == nil
-          flash[:notice].should =~ /^You must be logged out/
-          response.should redirect_to(profile_path)
+          expect(flash[:notice]).not_to eq(nil)
+          expect(flash[:notice]).to match(/^You must be logged out/)
+          expect(response).to redirect_to(profile_path)
         end
       end
 
       describe "POST authentication" do
         it "displays 'must be logged out message' and redirects to profile page" do
-          post :create, :authentication => @login
-          flash[:notice].should_not == nil
-          flash[:notice].should =~ /^You must be logged out/
-          response.should redirect_to(profile_path)
+          post :create, authentication: @login
+          expect(flash[:notice]).not_to eq(nil)
+          expect(flash[:notice]).to match(/^You must be logged out/)
+          expect(response).to redirect_to(profile_path)
         end
       end
     end
@@ -62,91 +61,88 @@ describe AuthenticationsController do
   #----------------------------------------------------------------------------
   describe "POST authentications" do
     before(:each) do
-      @login = { :username => "user", :password => "pass", :remember_me => "0" }
+      @login = { username: "user", password: "pass", remember_me: "0" }
       @authentication = double(Authentication, @login)
     end
 
     describe "successful authentication " do
       before(:each) do
-        @authentication.stub(:save).and_return(true)
-        Authentication.stub(:new).and_return(@authentication)
+        allow(@authentication).to receive(:save).and_return(true)
+        allow(Authentication).to receive(:new).and_return(@authentication)
       end
 
       it "displays welcome message and redirects to the home page" do
-        @user = FactoryGirl.create(:user, :username => "user", :password => "pass", :password_confirmation => "pass", :login_count => 0)
-        @authentication.stub(:user).and_return(@user)
+        @user = FactoryGirl.create(:user, username: "user", password: "pass", password_confirmation: "pass", login_count: 0)
+        allow(@authentication).to receive(:user).and_return(@user)
 
-        post :create, :authentication => @login
-        flash[:notice].should_not == nil
-        flash[:notice].should_not =~ /last login/
-        response.should redirect_to(root_path)
+        post :create, authentication: @login
+        expect(flash[:notice]).not_to eq(nil)
+        expect(flash[:notice]).not_to match(/last login/)
+        expect(response).to redirect_to(root_path)
       end
 
       it "displays last login time if it's not the first login" do
-        @user = FactoryGirl.create(:user, :username => "user", :password => "pass", :password_confirmation => "pass", :login_count => 42)
-        @authentication.stub(:user).and_return(@user)
+        @user = FactoryGirl.create(:user, username: "user", password: "pass", password_confirmation: "pass", login_count: 42)
+        allow(@authentication).to receive(:user).and_return(@user)
 
-        post :create, :authentication => @login
-        flash[:notice].should =~ /last login/
-        response.should redirect_to(root_path)
+        post :create, authentication: @login
+        expect(flash[:notice]).to match(/last login/)
+        expect(response).to redirect_to(root_path)
       end
     end
 
     describe "authenticaion failure" do
       describe "user is not suspended" do
         it "redirects to login page if username or password are invalid" do
-          @user = FactoryGirl.create(:user, :username => "user", :password => "pass", :password_confirmation => "pass")
-          @authentication.stub(:user).and_return(@user)
-          @authentication.stub(:save).and_return(false) # <--- Authentication failure.
-          Authentication.stub(:new).and_return(@authentication)
-
-          post :create, :authentication => @login
-          flash[:warning].should_not == nil
-          response.should redirect_to(:action => :new)
+          @user = FactoryGirl.create(:user, username: "user", password: "pass", password_confirmation: "pass")
+          allow(@authentication).to receive(:user).and_return(@user)
+          allow(@authentication).to receive(:save).and_return(false) # <--- Authentication failure.
+          allow(Authentication).to receive(:new).and_return(@authentication)
+
+          post :create, authentication: @login
+          expect(flash[:warning]).not_to eq(nil)
+          expect(response).to redirect_to(action: :new)
         end
       end
 
       describe "user has been suspended" do
         before(:each) do
-          @authentication.stub(:save).and_return(true)
-          Authentication.stub(:new).and_return(@authentication)
+          allow(@authentication).to receive(:save).and_return(true)
+          allow(Authentication).to receive(:new).and_return(@authentication)
         end
 
         # This tests :before_save update_info callback in Authentication model.
         it "keeps user login attributes intact" do
-          @user = FactoryGirl.create(:user, :username => "user", :password => "pass", :password_confirmation => "pass", :suspended_at => Date.yesterday, :login_count => 0, :last_login_at => nil, :last_login_ip => nil)
-          @authentication.stub(:user).and_return(@user)
+          @user = FactoryGirl.create(:user, username: "user", password: "pass", password_confirmation: "pass", suspended_at: Date.yesterday, login_count: 0, last_login_at: nil, last_login_ip: nil)
+          allow(@authentication).to receive(:user).and_return(@user)
 
-          post :create, :authentication => @login
-          @authentication.user.login_count.should == 0
-          @authentication.user.last_login_at.should be_nil
-          @authentication.user.last_login_ip.should be_nil
+          post :create, authentication: @login
+          expect(@authentication.user.login_count).to eq(0)
+          expect(@authentication.user.last_login_at).to be_nil
+          expect(@authentication.user.last_login_ip).to be_nil
         end
 
         it "redirects to login page if user is suspended" do
-          @user = FactoryGirl.create(:user, :username => "user", :password => "pass", :password_confirmation => "pass", :suspended_at => Date.yesterday)
-          @authentication.stub(:user).and_return(@user)
+          @user = FactoryGirl.create(:user, username: "user", password: "pass", password_confirmation: "pass", suspended_at: Date.yesterday)
+          allow(@authentication).to receive(:user).and_return(@user)
 
-          post :create, :authentication => @login
-          flash[:warning].should_not == nil # Invalid username/password.
-          flash[:notice].should == nil      # Not approved yet.
-          response.should redirect_to(:action => :new)
+          post :create, authentication: @login
+          expect(flash[:warning]).not_to eq(nil) # Invalid username/password.
+          expect(flash[:notice]).to eq(nil)      # Not approved yet.
+          expect(response).to redirect_to(action: :new)
         end
 
         it "redirects to login page with the message if signup needs approval and user hasn't been activated yet" do
-          Setting.stub(:user_signup).and_return(:needs_approval)
-          @user = FactoryGirl.create(:user, :username => "user", :password => "pass", :password_confirmation => "pass", :suspended_at => Date.yesterday, :login_count => 0)
-          @authentication.stub(:user).and_return(@user)
-
-          post :create, :authentication => @login
-          flash[:warning].should == nil     # Invalid username/password.
-          flash[:notice].should_not == nil  # Not approved yet.
-          response.should redirect_to(:action => :new)
+          allow(Setting).to receive(:user_signup).and_return(:needs_approval)
+          @user = FactoryGirl.create(:user, username: "user", password: "pass", password_confirmation: "pass", suspended_at: Date.yesterday, login_count: 0)
+          allow(@authentication).to receive(:user).and_return(@user)
+
+          post :create, authentication: @login
+          expect(flash[:warning]).to eq(nil)     # Invalid username/password.
+          expect(flash[:notice]).not_to eq(nil)  # Not approved yet.
+          expect(response).to redirect_to(action: :new)
         end
       end
-
     end # authentication failure
   end # POST authenticate
-
 end
-