REFACTOR: notifications controller specs to requests

spec/requests/notifications_controller_spec.rb

@@ -2,14 +2,19 @@ require 'rails_helper'
 
 def create_notification(user_id, resp_code, matcher)
   notification_count = Notification.count
-  post :create, params: { notification_type: Notification.types[:mentioned], user_id: user_id, data: { message: 'tada' }.to_json }, format: :json
+  post "/notifications.json",
+    params: {
+      notification_type: Notification.types[:mentioned],
+      user_id: user_id,
+      data: { message: 'tada' }.to_json
+    }
   expect(response.status).to eq(resp_code)
   expect(Notification.count).send(matcher, eq(notification_count))
 end
 
 def update_notification(topic_id, resp_code, matcher)
   notification = Fabricate(:notification)
-  post :update, params: { id: notification.id, topic_id: topic_id }, format: :json
+  put "/notifications/#{notification.id}.json", params: { topic_id: topic_id }
   expect(response.status).to eq(resp_code)
   notification.reload
   expect(notification.topic_id).send(matcher, eq(topic_id))
@@ -18,67 +23,62 @@ end
 def delete_notification(resp_code, matcher)
   notification = Fabricate(:notification)
   notification_count = Notification.count
-  delete :destroy, params: { id: notification.id }, format: :json
+  delete "/notifications/#{notification.id}.json"
   expect(response.status).to eq(resp_code)
   expect(Notification.count).send(matcher, eq(notification_count))
 end
 
 describe NotificationsController do
-
   context 'when logged in' do
-
     context 'as normal user' do
-
-      let!(:user) { log_in }
+      let!(:user) { sign_in(Fabricate(:user)) }
 
       describe '#index' do
         it 'should succeed for recent' do
-          get :index, params: { recent: true }
+          get "/notifications", params: { recent: true }
           expect(response).to be_success
         end
 
         it 'should succeed for history' do
-          get :index
+          get "/notifications"
           expect(response).to be_success
         end
 
         it 'should mark notifications as viewed' do
-          _notification = Fabricate(:notification, user: user)
+          Fabricate(:notification, user: user)
           expect(user.reload.unread_notifications).to eq(1)
           expect(user.reload.total_unread_notifications).to eq(1)
-          get :index, params: { recent: true }, format: :json
+          get "/notifications.json", params: { recent: true }
           expect(user.reload.unread_notifications).to eq(0)
           expect(user.reload.total_unread_notifications).to eq(1)
         end
 
         it 'should not mark notifications as viewed if silent param is present' do
-          _notification = Fabricate(:notification, user: user)
+          Fabricate(:notification, user: user)
           expect(user.reload.unread_notifications).to eq(1)
           expect(user.reload.total_unread_notifications).to eq(1)
-          get :index, params: { recent: true, silent: true }
+          get "/notifications", params: { recent: true, silent: true }
           expect(user.reload.unread_notifications).to eq(1)
           expect(user.reload.total_unread_notifications).to eq(1)
         end
 
         context 'when username params is not valid' do
           it 'should raise the right error' do
-            get :index, params: { username: 'somedude' }, format: :json
-
-            expect(response).to_not be_success
+            get "/notifications.json", params: { username: 'somedude' }
             expect(response.status).to eq(404)
           end
         end
       end
 
       it 'should succeed' do
-        put :mark_read, format: :json
+        put "/notifications/mark-read.json"
         expect(response).to be_success
       end
 
       it "can update a single notification" do
         notification = Fabricate(:notification, user: user)
         notification2 = Fabricate(:notification, user: user)
-        put :mark_read, params: { id: notification.id }, format: :json
+        put "/notifications/mark-read.json", params: { id: notification.id }
         expect(response).to be_success
 
         notification.reload
@@ -89,10 +89,10 @@ describe NotificationsController do
       end
 
       it "updates the `read` status" do
-        _notification = Fabricate(:notification, user: user)
+        Fabricate(:notification, user: user)
         expect(user.reload.unread_notifications).to eq(1)
         expect(user.reload.total_unread_notifications).to eq(1)
-        put :mark_read, format: :json
+        put "/notifications/mark-read.json"
         user.reload
         expect(user.reload.unread_notifications).to eq(0)
         expect(user.reload.total_unread_notifications).to eq(0)
@@ -115,12 +115,10 @@ describe NotificationsController do
           delete_notification(403, :to)
         end
       end
-
     end
 
     context 'as admin' do
-
-      let!(:admin) { log_in(:admin) }
+      let!(:admin) { sign_in(Fabricate(:admin)) }
 
       describe '#create' do
         it "can create notification" do
@@ -141,16 +139,14 @@ describe NotificationsController do
           delete_notification(200, :to_not)
         end
       end
-
     end
-
   end
 
   context 'when not logged in' do
 
     describe '#index' do
       it 'should raise an error' do
-        get :index, params: { recent: true }, format: :json
+        get "/notifications.json", params: { recent: true }
         expect(response.status).to eq(403)
       end
     end
@@ -173,7 +169,5 @@ describe NotificationsController do
         delete_notification(403, :to)
       end
     end
-
   end
-
 end