Address review feedback

1 files changed, 80 insertions, 65 deletions

diff --git a/spec/controllers/projects/notes_controller_spec.rb b/spec/controllers/projects/notes_controller_spec.rb
index d57d5c0b963..92e38b02615 100644
--- a/spec/controllers/projects/notes_controller_spec.rb
+++ b/spec/controllers/projects/notes_controller_spec.rb
@@ -6,6 +6,14 @@ describe Projects::NotesController do
   let(:issue)   { create(:issue, project: project) }
   let(:note)    { create(:note, noteable: issue, project: project) }
 
+  let(:request_params) do
+    {
+      namespace_id: project.namespace,
+      project_id: project,
+      id: note
+    }
+  end
+
   describe 'POST toggle_award_emoji' do
     before do
       sign_in(user)
@@ -14,123 +22,130 @@ describe Projects::NotesController do
 
     it "toggles the award emoji" do
       expect do
-        post(:toggle_award_emoji, namespace_id: project.namespace.path,
-                                  project_id: project.path, id: note.id, name: "thumbsup")
+        post(:toggle_award_emoji, request_params.merge(name: "thumbsup"))
       end.to change { note.award_emoji.count }.by(1)
 
       expect(response).to have_http_status(200)
     end
 
     it "removes the already awarded emoji" do
-      post(:toggle_award_emoji, namespace_id: project.namespace.path,
-                                project_id: project.path, id: note.id, name: "thumbsup")
+      post(:toggle_award_emoji, request_params.merge(name: "thumbsup"))
 
       expect do
-        post(:toggle_award_emoji, namespace_id: project.namespace.path,
-                                  project_id: project.path, id: note.id, name: "thumbsup")
+        post(:toggle_award_emoji, request_params.merge(name: "thumbsup"))
       end.to change { AwardEmoji.count }.by(-1)
 
       expect(response).to have_http_status(200)
     end
   end
 
-  describe 'POST resolve' do
-    before do
-      sign_in user
-    end
+  describe "resolving and unresolving" do
+    let(:merge_request) { create(:merge_request, source_project: project) }
+    let(:note) { create(:diff_note_on_merge_request, noteable: merge_request, project: project) }
 
-    context "when the user is not authorized to resolve the note" do
-      it "returns status 404" do
-        post :resolve, namespace_id: project.namespace.path, project_id: project.path, id: note.id
-
-        expect(response).to have_http_status(404)
-      end
-    end
-
-    context "when the user is authorized to resolve the note" do
+    describe 'POST resolve' do
       before do
-        project.team << [user, :developer]
+        sign_in user
       end
 
-      context "when the note is not resolvable" do
+      context "when the user is not authorized to resolve the note" do
         it "returns status 404" do
-          post :resolve, namespace_id: project.namespace.path, project_id: project.path, id: note.id
+          post :resolve, request_params
 
           expect(response).to have_http_status(404)
         end
       end
 
-      context "when the note is resolvable" do
-        let(:merge_request) { create(:merge_request, source_project: project) }
-        let(:note) { create(:diff_note_on_merge_request, noteable: merge_request, project: project) }
-
-        it "resolves the note" do
-          expect_any_instance_of(DiffNote).to receive(:resolve!).with(user)
-
-          post :resolve, namespace_id: project.namespace.path, project_id: project.path, id: note.id
+      context "when the user is authorized to resolve the note" do
+        before do
+          project.team << [user, :developer]
         end
 
-        it "checks whether all notes are resolved" do
-          expect_any_instance_of(MergeRequests::AllDiscussionsResolvedService).to receive(:execute).with(merge_request)
+        context "when the note is not resolvable" do
+          before do
+            note.update(system: true)
+          end
 
-          post :resolve, namespace_id: project.namespace.path, project_id: project.path, id: note.id
+          it "returns status 404" do
+            post :resolve, request_params
+
+            expect(response).to have_http_status(404)
+          end
         end
 
-        it "returns the name of the resolving user" do
-          post :resolve, namespace_id: project.namespace.path, project_id: project.path, id: note.id
+        context "when the note is resolvable" do
+          it "resolves the note" do
+            post :resolve, request_params
 
-          expect(JSON.parse(response.body)["resolved_by"]).to eq(user.name)
-        end
+            expect(note.reload.resolved?).to be true
+            expect(note.reload.resolved_by).to eq(user)
+          end
 
-        it "returns status 200" do
-          post :resolve, namespace_id: project.namespace.path, project_id: project.path, id: note.id
+          it "sends notifications if all discussions are resolved" do
+            expect_any_instance_of(MergeRequests::ResolvedDiscussionNotificationService).to receive(:execute).with(merge_request)
 
-          expect(response).to have_http_status(200)
-        end
-      end
-    end
-  end
+            post :resolve, request_params
+          end
 
-  describe 'DELETE unresolve' do
-    before do
-      sign_in user
-    end
+          it "returns the name of the resolving user" do
+            post :resolve, request_params
+
+            expect(JSON.parse(response.body)["resolved_by"]).to eq(user.name)
+          end
 
-    context "when the user is not authorized to resolve the note" do
-      it "returns status 404" do
-        delete :unresolve, namespace_id: project.namespace.path, project_id: project.path, id: note.id
+          it "returns status 200" do
+            post :resolve, request_params
 
-        expect(response).to have_http_status(404)
+            expect(response).to have_http_status(200)
+          end
+        end
       end
     end
 
-    context "when the user is authorized to resolve the note" do
+    describe 'DELETE unresolve' do
       before do
-        project.team << [user, :developer]
+        sign_in user
+
+        note.resolve!(user)
       end
 
-      context "when the note is not resolvable" do
+      context "when the user is not authorized to resolve the note" do
         it "returns status 404" do
-          delete :unresolve, namespace_id: project.namespace.path, project_id: project.path, id: note.id
+          delete :unresolve, request_params
 
           expect(response).to have_http_status(404)
         end
       end
 
-      context "when the note is resolvable" do
-        let(:merge_request) { create(:merge_request, source_project: project) }
-        let(:note) { create(:diff_note_on_merge_request, noteable: merge_request, project: project) }
+      context "when the user is authorized to resolve the note" do
+        before do
+          project.team << [user, :developer]
+        end
+
+        context "when the note is not resolvable" do
+          before do
+            note.update(system: true)
+          end
 
-        it "unresolves the note" do
-          expect_any_instance_of(DiffNote).to receive(:unresolve!)
+          it "returns status 404" do
+            delete :unresolve, request_params
 
-          delete :unresolve, namespace_id: project.namespace.path, project_id: project.path, id: note.id
+            expect(response).to have_http_status(404)
+          end
         end
 
-        it "returns status 200" do
-          delete :unresolve, namespace_id: project.namespace.path, project_id: project.path, id: note.id
+        context "when the note is resolvable" do
+          it "unresolves the note" do
+            delete :unresolve, request_params
+
+            expect(note.reload.resolved?).to be false
+          end
+
+          it "returns status 200" do
+            delete :unresolve, request_params
 
-          expect(response).to have_http_status(200)
+            expect(response).to have_http_status(200)
+          end
         end
       end
     end