authkit 0.5.0 → 0.7.0

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

@@ -1,6 +1,6 @@
 require 'rails_helper'
 
-describe PasswordChangeController do
+RSpec.describe PasswordChangeController do
   render_views
 
   let(:token) { "TOKEN" }
@@ -12,26 +12,26 @@ describe PasswordChangeController do
     it "requires no user" do
       allow(controller).to receive(:email_user).and_return(user)
       expect(controller).to receive(:logout)
-      get 'show', valid_params
+      get 'show', params: valid_params
     end
 
     it "requires an email user" do
       user.save
-      get 'show', valid_params
-      expect(assigns(:user).id).to eq(user.id)
+      get 'show', params: valid_params
+      expect(controller.send(:email_user).id).to eq(user.id)
     end
 
     it "redirects if there is no email user" do
       user.save
       expect {
-        get 'show', {token: token, email: "invalid@example.com"}
+        get 'show', params: {token: token, email: "invalid@example.com"}
       }.to raise_error(ActiveRecord::RecordNotFound)
     end
 
     it "requires a valid token" do
       allow(controller).to receive(:email_user).and_return(user)
       user.reset_password_token = "OTHER TOKEN"
-      get 'show', valid_params
+      get 'show', params: valid_params
       expect(response).to be_redirect
       expect(flash[:error]).to_not be_empty
     end
@@ -39,14 +39,14 @@ describe PasswordChangeController do
     it "requires an unexpired token" do
       allow(controller).to receive(:email_user).and_return(user)
       user.reset_password_token_created_at = 1.year.ago
-      get 'show', valid_params
+      get 'show', params: valid_params
       expect(response).to be_redirect
       expect(flash[:error]).to_not be_empty
     end
 
     it "returns http success" do
       allow(controller).to receive(:email_user).and_return(user)
-      get 'show', valid_params
+      get 'show', params: valid_params
       expect(response).to be_success
     end
   end
@@ -55,26 +55,26 @@ describe PasswordChangeController do
     it "requires no user" do
       allow(controller).to receive(:email_user).and_return(user)
       expect(controller).to receive(:logout)
-      get 'show', valid_params
+      get 'show', params: valid_params
     end
 
     it "requires an email user" do
       user.save
-      post 'create', password_params
-      expect(assigns(:user).id).to eq(user.id)
+      post 'create', params: password_params
+      expect(controller.send(:email_user).id).to eq(user.id)
     end
 
     it "redirects if there is no email user" do
       user.save
       expect {
-        get 'show', {token: token, email: "invalid@example.com"}
+        get 'show', params: {token: token, email: "invalid@example.com"}
       }.to raise_error(ActiveRecord::RecordNotFound)
     end
 
     it "requires a valid token" do
       allow(controller).to receive(:email_user).and_return(user)
       user.reset_password_token = "OTHER TOKEN"
-      post 'create', password_params
+      post 'create', params: password_params
       expect(response).to be_redirect
       expect(flash[:error]).to_not be_empty
     end
@@ -86,7 +86,7 @@ describe PasswordChangeController do
 
       it "changes the password" do
         expect {
-          post 'create', password_params
+          post 'create', params: password_params
         }.to change(user, :password_digest)
 
         expect(user).to be_valid
@@ -94,22 +94,22 @@ describe PasswordChangeController do
 
       it "does not sign the user in" do
         expect(controller).to_not receive(:login)
-        post 'create', password_params
+        post 'create', params: password_params
       end
 
       it "redirects the user" do
-        post 'create', password_params
+        post 'create', params: password_params
         expect(response).to be_redirect
       end
 
       it "sets the flash" do
-        post 'create', password_params
+        post 'create', params: password_params
         expect(flash[:notice]).to match(/successfully/i)
       end
 
       describe "from json" do
         it "returns http success" do
-          post 'create', password_params.merge(format: 'json')
+          post 'create', params: password_params.merge(format: 'json')
           expect(response).to be_success
         end
       end
@@ -122,22 +122,17 @@ describe PasswordChangeController do
 
       it "doesn't sign the user in" do
         expect(controller).to_not receive(:login)
-        post 'create', {token: token, email: user.email, password: 'newpassword', password_confirmation: 'invalid'}
-      end
-
-      it "renders the show template" do
-        post 'create', {token: token, email: user.email, password: 'newpassword', password_confirmation: 'invalid'}
-        expect(response).to render_template(:show)
+        post 'create', params: {token: token, email: user.email, password: 'newpassword', password_confirmation: 'invalid'}
       end
 
       it "has errors" do
-        post 'create', {token: token, email: user.email, password: 'newpassword', password_confirmation: 'invalid'}
+        post 'create', params: {token: token, email: user.email, password: 'newpassword', password_confirmation: 'invalid'}
         expect(user.errors[:password_confirmation].size).to eq(1)
       end
 
       describe "from json" do
         it "returns an error" do
-          post 'create', {token: token, email: user.email, password: 'newpassword', password_confirmation: 'invalid', format: 'json'}
+          post 'create', params: {token: token, email: user.email, password: 'newpassword', password_confirmation: 'invalid', format: 'json'}
           expect(response.code).to eq('422')
           expect(response.body).to match(/doesn't match/i)
         end

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

@@ -1,6 +1,6 @@
 require 'rails_helper'
 
-describe PasswordResetController do
+RSpec.describe PasswordResetController do
   render_views
 
   let(:user) { create(:user) }
@@ -18,38 +18,38 @@ describe PasswordResetController do
     end
 
     it "redirects the user" do
-      post :create, {email: user.email}
+      post :create, params: { email: user.email }
       expect(response).to be_redirect
     end
 
     it "finds the user by the email or user name" do
-      post :create, {email: user.email}
+      post :create, params: { email: user.email }
       expect(controller.send(:user)).to eq(user)
     end
 
     it "logs any current user out if it finds the user" do
       expect(controller).to receive(:logout)
-      post :create, {email: user.email}
+      post :create, params: { email: user.email }
     end
 
     it "resets the password if it finds the user" do
       expect_any_instance_of(User).to receive(:send_reset_password).and_return(true)
-      post :create, {email: user.email}
+      post :create, params: { email: user.email }
     end
 
     it "does not reset the password if it does not find a user" do
       expect_any_instance_of(User).to_not receive(:send_reset_password)
-      post :create, {email: "unknown@example.com"}
+      post :create, params: { email: "unknown@example.com" }
     end
 
     it "downcases the email or user name" do
       expect_any_instance_of(User).to receive(:send_reset_password).and_return(true)
-      post :create, {email: user.email.upcase}
+      post :create, params: { email: user.email.upcase }
     end
 
     describe "from json" do
       it "returns http success" do
-        post :create, {email: user.email, format: "json"}
+        post :create, params: { email: user.email, format: "json" }
         expect(response).to be_success
       end
     end
@@ -57,24 +57,19 @@ describe PasswordResetController do
     describe "with invalid email" do
       describe "from html" do
         it "sets the flash message" do
-          post :create, {email: "unknown@example.com"}
+          post :create, params: { email: "unknown@example.com" }
           expect(flash.now[:error]).to_not be_empty
         end
-
-        it "renders the show page" do
-          post :create, {email: "unknown@example.com"}
-          expect(response).to render_template(:show)
-        end
       end
 
       describe "from json" do
         it "returns an error" do
-          post :create, {email: "unknown@example.com", format: "json"}
+          post :create, params: { email: "unknown@example.com", format: "json" }
           expect(response.body).to match(/invalid user name or email/i)
         end
 
         it "returns forbidden status" do
-          post :create, {email: "unknown@example.com", format: "json"}
+          post :create, params: { email: "unknown@example.com", format: "json" }
           expect(response.code).to eq('422')
         end
       end

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

@@ -3,8 +3,9 @@ require 'rails_helper'
 describe SessionsController do
   render_views
 
-  let(:user) { create(:user) }
-  let(:logged_in_session) { { user_id: user.id } }
+  let(:user_session) { create(:user_session) }
+  let(:user) { user_session.user }
+  let(:logged_in_session) { { user_session_id: user_session.id } }
 
   describe "GET 'new'" do
     it "returns http success" do
@@ -19,47 +20,45 @@ describe SessionsController do
     end
 
     it "redirects the user" do
-      post :create, {email: user.email, password: "example"}
+      post :create, params: { email: user.email, password: "example" }
       expect(response).to be_redirect
     end
 
     it "authenticates if it finds the user" do
       expect_any_instance_of(User).to receive(:authenticate).and_return(true)
-      post :create, {email: user.email, password: "example"}
+      post :create, params: { email: user.email, password: "example" }
     end
 
     it "does not authenticate if it does not find a user" do
       expect_any_instance_of(User).to_not receive(:authenticate)
-      post :create, {email: "unknown@example.com", password: "example"}
+      post :create, params: { email: "unknown@example.com", password: "example" }
     end
 
     it "downcases the email or user name" do
       expect_any_instance_of(User).to receive(:authenticate).and_return(true)
-      post :create, {email: user.email, password: "example"}
+      post :create, params: { email: user.email, password: "example" }
     end
 
     it "signs the user in" do
-      post :create, {email: user.email, password: "example"}
+      post :create, params: { email: user.email, password: "example" }
       expect(controller.send(:current_user)).to eq(user)
     end
 
     it "remembers the user if remember me is chosen" do
-      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"}
+      post :create, params: { 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
-      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: ""}
+      post :create, params: { 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: user.email, password: "example", format: "json"}
+        post :create, params: { email: user.email, password: "example", format: "json" }
         expect(response).to be_success
       end
     end
@@ -67,24 +66,19 @@ describe SessionsController do
     describe "with invalid password" do
       describe "from html" do
         it "sets the flash message" do
-          post :create, {email: user.email, password: "wrongpassword"}
+          post :create, params: { email: user.email, password: "wrongpassword" }
           expect(flash.now[:error]).to_not be_empty
         end
-
-        it "renders the new page" do
-          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: user.email, password: "wrongpassword", format: "json"}
+          post :create, params: { 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: user.email, password: "wrongpassword", format: "json"}
+          post :create, params: { email: user.email, password: "wrongpassword", format: "json" }
           expect(response.code).to eq('422')
         end
       end
@@ -93,20 +87,20 @@ describe SessionsController do
 
   describe "DELETE 'destroy'" do
     it "logs the user out" do
-      delete "destroy", {}, logged_in_session
+      delete "destroy", session: logged_in_session
       expect(controller.send(:current_user)).to be_nil
     end
 
     describe "from html" do
       it "redirects the user" do
-        delete "destroy", {}, logged_in_session
+        delete "destroy", session: logged_in_session
         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
+        delete "destroy", params: { format: 'json' }, session: logged_in_session
         expect(response).to be_success
       end
     end

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

@@ -1,6 +1,6 @@
 require 'rails_helper'
 
-describe SignupController do
+RSpec.describe SignupController do
   render_views
 
   let(:signup_params) { attributes_for(:user) }
@@ -10,7 +10,7 @@ describe SignupController do
     it "returns http success" do
       get :new
       expect(response).to be_success
-      expect(assigns(:signup)).to_not be_nil
+      expect(controller.send(:signup)).to_not be_nil
     end
   end
 
@@ -19,36 +19,34 @@ describe SignupController do
       describe "from html" do
         it "creates a new user" do
           expect {
-            post :create, {signup: signup_params}, {}
+            post :create, params: { signup: signup_params }
           }.to change(User, :count).by(1)
         end
 
         it "confirms the email" do
           expect_any_instance_of(User).to receive(:send_confirmation)
-          post :create, {signup: signup_params}, {}
+          post :create, params: { signup: signup_params }
         end
 
         it "signs the user in" do
-          post :create, {signup: signup_params}, {}
-          expect(controller.send(:current_user)).to eq(assigns(:signup).user)
+          post :create, params: { signup: signup_params }
+          expect(controller.send(:current_user)).to eq(controller.send(:signup).user)
         end
 
         it "remembers the user if remember me is chosen" do
-          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"}, {}
-          expect(controller.send(:current_user)).to eq(assigns(:signup).user)
+          post :create, params: { signup: signup_params, remember_me: "1" }
+          expect(controller.send(:current_user)).to eq(controller.send(:signup).user)
         end
 
         it "does not remember the user if remember me is not chosen" do
-          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: ""}, {}
-          expect(controller.send(:current_user)).to eq(assigns(:signup).user)
+          post :create, params: { signup: signup_params, remember_me: "" }
+          expect(controller.send(:current_user)).to eq(controller.send(:signup).user)
         end
 
         it "redirects to the root" do
-          post :create, {signup: signup_params}
+          post :create, params: { signup: signup_params }
           expect(response).to be_redirect
         end
       end
@@ -56,17 +54,17 @@ describe SignupController do
       describe "from json" do
         it "creates the user" do
           expect {
-            post :create, {signup: signup_params, format: 'json'}, {}
+            post :create, params: { signup: signup_params, format: 'json' }
           }.to change(User, :count).by(1)
         end
 
         it "signs the user in" do
-          post :create, {signup: signup_params, format: 'json'}, {}
-          expect(controller.send(:current_user)).to eq(assigns(:signup).user)
+          post :create, params: { signup: signup_params, format: 'json' }
+          expect(controller.send(:current_user)).to eq(controller.send(:signup).user)
         end
 
         it "returns http success" do
-          post :create, {signup: signup_params, format: 'json'}
+          post :create, params: { signup: signup_params, format: 'json' }
           expect(response).to be_success
         end
       end
@@ -74,36 +72,30 @@ describe SignupController do
 
     describe "with invalid params" do
       describe "from html" do
-        it "renders the new page" do
-          post :create, {signup: invalid_params}, {}
-          expect(response).to render_template("new")
-        end
-
         it "does not create a user" do
           expect {
-            post :create, {signup: invalid_params}, {}
+            post :create, params: { signup: invalid_params }
           }.to_not change(User, :count)
         end
 
         it "sets the errors" do
-          post :create, {signup: invalid_params}, {}
-          expect(assigns(:signup).errors[:password_confirmation].size).to eq(1)
+          post :create, params: { signup: invalid_params }
+          expect(controller.send(: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'}, {}
+          post :create, params: { signup: invalid_params, format: 'json' }
           expect(response.code).to eq('422')
         end
 
         it "includes the errors in the json" do
-          post :create, {signup: invalid_params, format: 'json'}, {}
-          expect(assigns(:signup).errors[:password_confirmation].size).to eq(1)
+          post :create, params: { signup: invalid_params, format: 'json' }
+          expect(controller.send(:signup).errors[:password_confirmation].size).to eq(1)
           expect(response.body).to match(/doesn't match Password/i)
         end
       end
     end
   end
 end
-