authkit 0.4.0 → 0.5.0

data/lib/generators/authkit/templates/spec/controllers/sessions_controller_spec.rb

@@ -1,15 +1,15 @@
-require 'spec_helper'
+require 'rails_helper'
 
 describe SessionsController do
   render_views
 
-  let(:user) { create(:user, email: "test@example.com") }
+  let(:user) { create(:user) }
   let(:logged_in_session) { { user_id: user.id } }
 
   describe "GET 'new'" do
     it "returns http success" do
       get 'new'
-      response.should be_success
+      expect(response).to be_success
     end
   end
 
@@ -19,73 +19,73 @@ describe SessionsController do
     end
 
     it "redirects the user" do
-      post :create, {email: "test@example.com", password: "example"}
-      response.should be_redirect
+      post :create, {email: user.email, password: "example"}
+      expect(response).to be_redirect
     end
 
     it "authenticates if it finds the user" do
-      User.any_instance.should_receive(:authenticate).and_return(true)
-      post :create, {email: "test@example.com", password: "example"}
+      expect_any_instance_of(User).to receive(:authenticate).and_return(true)
+      post :create, {email: user.email, password: "example"}
     end
 
     it "does not authenticate if it does not find a user" do
-      User.any_instance.should_not_receive(:authenticate)
+      expect_any_instance_of(User).to_not receive(:authenticate)
       post :create, {email: "unknown@example.com", password: "example"}
     end
 
     it "downcases the email or user name" do
-      User.any_instance.should_receive(:authenticate).and_return(true)
-      post :create, {email: "TEST@EXAMPLE.COM", password: "example"}
+      expect_any_instance_of(User).to receive(:authenticate).and_return(true)
+      post :create, {email: user.email, password: "example"}
     end
 
     it "signs the user in" do
-      post :create, {email: "test@example.com", password: "example"}
-      controller.send(:current_user).should == user
+      post :create, {email: user.email, password: "example"}
+      expect(controller.send(:current_user)).to eq(user)
     end
 
     it "remembers the user if remember me is chosen" do
-      User.any_instance.should_receive(:set_remember_token)
-      controller.should_receive(:set_remember_cookie)
-      post :create, {email: "test@example.com", password: "example", remember_me: "1"}
-      controller.send(:current_user).should == user
+      expect_any_instance_of(User).to receive(:set_remember_token)
+      expect(controller).to receive(:set_remember_cookie)
+      post :create, {email: user.email, password: "example", remember_me: "1"}
+      expect(controller.send(:current_user)).to eq(user)
     end
 
     it "does not remember the user if remember me is not chosen" do
-      User.any_instance.should_not_receive(:set_remember_token)
-      controller.should_not_receive(:set_remember_cookie)
-      post :create, {email: "test@example.com", password: "example", remember_me: ""}
-      controller.send(:current_user).should == user
+      expect_any_instance_of(User).to_not receive(:set_remember_token)
+      expect(controller).to_not receive(:set_remember_cookie)
+      post :create, {email: user.email, password: "example", remember_me: ""}
+      expect(controller.send(:current_user)).to eq(user)
     end
 
     describe "from json" do
       it "returns http success" do
-        post :create, {email: "test@example.com", password: "example", format: "json"}
-        response.should be_success
+        post :create, {email: user.email, password: "example", format: "json"}
+        expect(response).to be_success
       end
     end
 
     describe "with invalid password" do
       describe "from html" do
         it "sets the flash message" do
-          post :create, {email: "test@example.com", password: "wrongpassword"}
-          flash.now[:error].should_not be_empty
+          post :create, {email: user.email, password: "wrongpassword"}
+          expect(flash.now[:error]).to_not be_empty
         end
 
         it "renders the new page" do
-          post :create, {email: "test@example.com", password: "wrongpassword"}
-          response.should render_template(:new)
+          post :create, {email: user.email, password: "wrongpassword"}
+          expect(response).to render_template(:new)
         end
       end
 
       describe "from json" do
         it "returns an error" do
-          post :create, {email: "test@example.com", password: "wrongpassword", format: "json"}
-          response.body.should =~ /invalid user name or password/i
+          post :create, {email: user.email, password: "wrongpassword", format: "json"}
+          expect(response.body).to match(/invalid user name or password/i)
         end
 
         it "returns forbidden status" do
-          post :create, {email: "test@example.com", password: "wrongpassword", format: "json"}
-          response.code.should == '422'
+          post :create, {email: user.email, password: "wrongpassword", format: "json"}
+          expect(response.code).to eq('422')
         end
       end
     end
@@ -94,20 +94,20 @@ describe SessionsController do
   describe "DELETE 'destroy'" do
     it "logs the user out" do
       delete "destroy", {}, logged_in_session
-      controller.send(:current_user).should be_nil
+      expect(controller.send(:current_user)).to be_nil
     end
 
     describe "from html" do
       it "redirects the user" do
         delete "destroy", {}, logged_in_session
-        response.should redirect_to(root_path)
+        expect(response).to redirect_to(root_path)
       end
     end
 
     describe "from json" do
       it "returns http success" do
         delete "destroy", {format: 'json'}, logged_in_session
-        response.should be_success
+        expect(response).to be_success
       end
     end
   end

data/lib/generators/authkit/templates/spec/controllers/signup_controller_spec.rb

@@ -1,4 +1,4 @@
-require 'spec_helper'
+require 'rails_helper'
 
 describe SignupController do
   render_views
@@ -9,8 +9,8 @@ describe SignupController do
   describe "GET 'new'" do
     it "returns http success" do
       get :new
-      response.should be_success
-      assigns(:signup).should_not be_nil
+      expect(response).to be_success
+      expect(assigns(:signup)).to_not be_nil
     end
   end
 
@@ -24,32 +24,32 @@ describe SignupController do
         end
 
         it "confirms the email" do
-          User.any_instance.should_receive(:send_confirmation)
+          expect_any_instance_of(User).to receive(:send_confirmation)
           post :create, {signup: signup_params}, {}
         end
 
         it "signs the user in" do
           post :create, {signup: signup_params}, {}
-          controller.send(:current_user).should == assigns(:signup).user
+          expect(controller.send(:current_user)).to eq(assigns(:signup).user)
         end
 
         it "remembers the user if remember me is chosen" do
-          User.any_instance.should_receive(:set_remember_token)
-          controller.should_receive(:set_remember_cookie)
+          expect_any_instance_of(User).to receive(:set_remember_token)
+          expect(controller).to receive(:set_remember_cookie)
           post :create, {signup: signup_params, remember_me: "1"}, {}
-          controller.send(:current_user).should == assigns(:signup).user
+          expect(controller.send(:current_user)).to eq(assigns(:signup).user)
         end
 
         it "does not remember the user if remember me is not chosen" do
-          User.any_instance.should_not_receive(:set_remember_token)
-          controller.should_not_receive(:set_remember_cookie)
+          expect_any_instance_of(User).to_not receive(:set_remember_token)
+          expect(controller).to_not receive(:set_remember_cookie)
           post :create, {signup: signup_params, remember_me: ""}, {}
-          controller.send(:current_user).should == assigns(:signup).user
+          expect(controller.send(:current_user)).to eq(assigns(:signup).user)
         end
 
         it "redirects to the root" do
           post :create, {signup: signup_params}
-          response.should be_redirect
+          expect(response).to be_redirect
         end
       end
 
@@ -62,12 +62,12 @@ describe SignupController do
 
         it "signs the user in" do
           post :create, {signup: signup_params, format: 'json'}, {}
-          controller.send(:current_user).should == assigns(:signup).user
+          expect(controller.send(:current_user)).to eq(assigns(:signup).user)
         end
 
         it "returns http success" do
           post :create, {signup: signup_params, format: 'json'}
-          response.should be_success
+          expect(response).to be_success
         end
       end
     end
@@ -76,7 +76,7 @@ describe SignupController do
       describe "from html" do
         it "renders the new page" do
           post :create, {signup: invalid_params}, {}
-          response.should render_template("new")
+          expect(response).to render_template("new")
         end
 
         it "does not create a user" do
@@ -87,20 +87,20 @@ describe SignupController do
 
         it "sets the errors" do
           post :create, {signup: invalid_params}, {}
-          assigns(:signup).should have(2).errors_on(:password_confirmation)
+          expect(assigns(:signup).errors[:password_confirmation].size).to eq(1)
         end
       end
 
       describe "from json" do
         it "returns a 422" do
           post :create, {signup: invalid_params, format: 'json'}, {}
-          response.code.should == '422'
+          expect(response.code).to eq('422')
         end
 
         it "includes the errors in the json" do
           post :create, {signup: invalid_params, format: 'json'}, {}
-          assigns(:signup).should have(2).errors_on(:password_confirmation)
-          response.body.should =~ /doesn't match Password/i
+          expect(assigns(:signup).errors[:password_confirmation].size).to eq(1)
+          expect(response.body).to match(/doesn't match Password/i)
         end
       end
     end

data/lib/generators/authkit/templates/spec/controllers/users_controller_spec.rb

@@ -1,9 +1,9 @@
-require 'spec_helper'
+require 'rails_helper'
 
 describe UsersController do
   render_views
 
-  let(:user) { create(:user, email: "test@example.com") }
+  let(:user) { create(:user) }
   let(:user_params) { attributes_for(:user) }
   let(:invalid_params) { user_params.merge(password: 'newpassword', password_confirmation: 'wrongpassword') }
   let(:logged_in_session) { { user_id: user.id } }
@@ -11,49 +11,49 @@ describe UsersController do
   describe "GET 'edit'" do
     it "redirects if there is no current user" do
       get :edit
-      response.should be_redirect
+      expect(response).to be_redirect
     end
 
     it "edits the current user" do
       get :edit, {}, logged_in_session
-      response.should be_success
+      expect(response).to be_success
     end
   end
 
   describe "PUT 'update'" do
     it "redirects if there is no current user" do
       put :update, {user: user_params.merge(first_name: "Alvarez")}
-      response.should be_redirect
+      expect(response).to be_redirect
     end
 
     describe "with valid params" do
       describe "when changing the email" do
         before(:each) do
-          controller.stub(:current_user).and_return(user)
+          allow(controller).to receive(:current_user).and_return(user)
         end
 
         it "doesn't send the confirmation the email if unchanged" do
           user.email = user.confirmation_email
           user.confirmation_email = nil
-          user.should_not_receive(:send_confirmation)
-          put :update, {user: user_params.merge(confirmation_email: "test@example.com")}, logged_in_session
+          expect(user).to_not receive(:send_confirmation)
+          put :update, {user: user_params.merge(confirmation_email: user.email)}, logged_in_session
         end
 
         it "doesn't reconfirm if the confirmation email is unchanged" do
-          user.should_not_receive(:send_confirmation)
-          put :update, {user: user_params.merge(confirmation_email: "test@example.com")}, logged_in_session
+          expect(user).to_not receive(:send_confirmation)
+          put :update, {user: user_params.merge(confirmation_email: user.email)}, logged_in_session
         end
 
         it "confirms the confirmation email" do
           user.email = "old@example.com"
-          user.should_receive(:send_confirmation).and_return(true)
+          expect(user).to receive(:send_confirmation).and_return(true)
           put :update, {user: user_params.merge(confirmation_email: "new@example.com")}, logged_in_session
         end
       end
 
       describe "from html" do
         before(:each) do
-          controller.stub(:current_user).and_return(user)
+          allow(controller).to receive(:current_user).and_return(user)
         end
 
         it "updates the user" do
@@ -64,13 +64,13 @@ describe UsersController do
 
         it "redirects the user" do
           put :update, {user: user_params}, logged_in_session
-          response.should be_redirect
+          expect(response).to be_redirect
         end
       end
 
       describe "from json" do
         before(:each) do
-          controller.stub(:current_user).and_return(user)
+          allow(controller).to receive(:current_user).and_return(user)
         end
 
         it "updates the user" do
@@ -83,7 +83,7 @@ describe UsersController do
 
     describe "with invalid params" do
       before(:each) do
-        controller.stub(:current_user).and_return(user)
+        allow(controller).to receive(:current_user).and_return(user)
       end
 
       describe "from html" do
@@ -92,12 +92,12 @@ describe UsersController do
         end
 
         it "renders the edit page" do
-          response.should render_template('edit')
-          response.should be_success
+          expect(response).to render_template('edit')
+          expect(response).to be_success
         end
 
         it "sets the errors" do
-          user.should have(2).errors_on(:password_confirmation)
+          expect(user.errors[:password_confirmation].size).to eq(1)
         end
       end
 
@@ -107,12 +107,12 @@ describe UsersController do
         end
 
         it "returns a 422" do
-          response.code.should == '422'
+          expect(response.code).to eq('422')
         end
 
         it "includes the errors in the json" do
-          user.should have(2).errors_on(:password_confirmation)
-          response.body.should =~ /doesn't match Password/i
+          expect(user.errors[:password_confirmation].size).to eq(1)
+          expect(response.body).to match(/doesn't match Password/i)
         end
       end
     end

data/lib/generators/authkit/templates/spec/factories/user.rb

@@ -1,8 +1,8 @@
 FactoryGirl.define do
   factory :user do
-    email "test@example.com"
-    username "test"
-    password "example"
+    sequence(:email) { |n| "user-#{n}@example.com" }
+    <% if username? %>sequence(:username) { |n| "user-#{n}" }
+    <% end %>password "example"
     password_confirmation "example"
     first_name "John"
     last_name "Example"

data/lib/generators/authkit/templates/spec/forms/signup_spec.rb

@@ -1,93 +1,94 @@
-require 'spec_helper'
+require 'rails_helper'
 
 describe Signup do
   let(:signup) { Signup.new }
 
   it "should not be persisted" do
-    signup.should_not be_persisted
+    expect(signup).to_not be_persisted
   end
 
   describe "validation" do
     it "should validate terms of service acceptance" do
       signup.terms_of_service = "1"
       signup.valid?
-      signup.should_not have(1).errors_on(:terms_of_service)
+      expect(signup.errors[:terms_of_service].size).to eq(0)
     end
 
     it "should validate models" do
       signup.user = User.new
-      signup.user.should_receive(:valid?).and_return(true)
+      expect(signup.user).to receive(:valid?).and_return(true)
       signup.valid?
     end
 
     it "should copy errors from the user to the signup" do
       signup.user = User.new
       signup.valid?
-      signup.should have(1).errors_on(:password)
+      expect(signup.errors[:password].size).to eq(1)
     end
   end
 
   describe "saving" do
     it "should validate" do
-      signup.should_receive(:valid?)
+      expect(signup).to receive(:valid?)
       signup.save
     end
 
     describe "when valid" do
       it "should persist" do
-        signup.user = User.new
-        signup.should_receive(:valid?).and_return(true)
-        signup.user.should_receive(:save!)
-        signup.user.should_receive(:send_confirmation)
+        signup.user = build(:user)
+        expect(signup).to receive(:valid?).and_return(true)
+        expect(signup.user).to receive(:save!)
         signup.save
       end
 
       it "should send the welcome" do
-        signup.user = User.new
-        signup.should_receive(:valid?).and_return(true)
-        signup.stub(:persist!)
-        signup.user.should_receive(:send_confirmation)
-        signup.user.should_receive(:send_welcome)
+        signup.user = build(:user)
+        signup.email = signup.user.email
+        expect(signup).to receive(:valid?).and_return(true)
+        allow(signup).to receive(:persist!)
+        expect(signup.user).to receive(:send_welcome)
         signup.save
       end
 
       it "should send the confirmation" do
-        signup.user = User.new
-        signup.should_receive(:valid?).and_return(true)
-        signup.stub(:persist!)
-        signup.user.should_receive(:send_confirmation)
+        signup.user = build(:user)
+        signup.email = signup.user.email
+        expect(signup).to receive(:valid?).and_return(true)
+        allow(signup).to receive(:persist!)
+        expect(signup.user).to receive(:send_confirmation)
         signup.save
       end
     end
 
     describe "when invalid" do
       it "should not persist" do
-        signup.should_receive(:valid?).and_return(false)
-        signup.should_not_receive(:persist!)
+        expect(signup).to receive(:valid?).and_return(false)
+        expect(signup).to_not receive(:persist!)
         signup.save
       end
 
       it "should not send the welcome" do
-        signup.should_receive(:valid?).and_return(false)
-        signup.should_not_receive(:send_welcome)
+        expect(signup).to receive(:valid?).and_return(false)
+        expect(signup).to_not receive(:send_welcome!)
         signup.save
       end
 
       it "should not send the confirmation" do
-        signup.should_receive(:valid?).and_return(false)
-        signup.should_not_receive(:send_confirmation)
+        expect(signup).to receive(:valid?).and_return(false)
+        expect(signup).to_not receive(:send_confirmation!)
         signup.save
       end
     end
   end
 
   it "should create a new user" do
-    user = User.new
-    User.should_receive(:new).and_return(user)
-    user.stub(:valid?).and_return(true)
-    user.should_receive(:save!)
-    user.should_receive(:send_confirmation)
-    signup.stub(:valid?).and_return(true)
+    user = build(:user)
+    expect(User).to receive(:new).and_return(user)
+    allow(user).to receive(:valid?).and_return(true)
+    expect(user).to receive(:save!)
+    expect(user).to receive(:send_confirmation)
+    allow(signup).to receive(:valid?).and_return(true)
+    signup.email = "new@example.com"
     signup.save
   end