1 files changed, 235 insertions, 124 deletions

diff --git a/spec/requests/api/error_tracking/project_settings_spec.rb b/spec/requests/api/error_tracking/project_settings_spec.rb
index 5906cdf105a..bde90627983 100644
--- a/spec/requests/api/error_tracking/project_settings_spec.rb
+++ b/spec/requests/api/error_tracking/project_settings_spec.rb
@@ -4,9 +4,9 @@ require 'spec_helper'
 
 RSpec.describe API::ErrorTracking::ProjectSettings, feature_category: :error_tracking do
   let_it_be(:user) { create(:user) }
-
-  let(:setting) { create(:project_error_tracking_setting) }
-  let(:project) { setting.project }
+  let_it_be(:project) { create(:project) }
+  let_it_be(:setting) { create(:project_error_tracking_setting, project: project) }
+  let_it_be(:project_without_setting) { create(:project) }
 
   shared_examples 'returns project settings' do
     it 'returns correct project settings' do
@@ -38,7 +38,7 @@ RSpec.describe API::ErrorTracking::ProjectSettings, feature_category: :error_tra
     end
   end
 
-  shared_examples 'returns 404' do
+  shared_examples 'returns no project settings' do
     it 'returns no project settings' do
       make_request
 
@@ -48,8 +48,60 @@ RSpec.describe API::ErrorTracking::ProjectSettings, feature_category: :error_tra
     end
   end
 
+  shared_examples 'returns 400' do
+    it 'rejects request' do
+      make_request
+
+      expect(response).to have_gitlab_http_status(:bad_request)
+    end
+  end
+
+  shared_examples 'returns 401' do
+    it 'rejects request' do
+      make_request
+
+      expect(response).to have_gitlab_http_status(:unauthorized)
+    end
+  end
+
+  shared_examples 'returns 403' do
+    it 'rejects request' do
+      make_request
+
+      expect(response).to have_gitlab_http_status(:forbidden)
+    end
+  end
+
+  shared_examples 'returns 404' do
+    it 'rejects request' do
+      make_request
+
+      expect(response).to have_gitlab_http_status(:not_found)
+    end
+  end
+
+  shared_examples 'returns 400 with `integrated` param required or invalid' do |error|
+    it 'returns 400' do
+      make_request
+
+      expect(response).to have_gitlab_http_status(:bad_request)
+      expect(json_response['error'])
+        .to eq(error)
+    end
+  end
+
+  shared_examples "returns error from UpdateService" do
+    it "returns errors" do
+      make_request
+
+      expect(json_response['http_status']).to eq('forbidden')
+      expect(json_response['message']).to eq('An error occurred')
+    end
+  end
+
   describe "PATCH /projects/:id/error_tracking/settings" do
-    let(:params) { { active: false } }
+    let(:params) { { active: false, integrated: integrated } }
+    let(:integrated) { false }
 
     def make_request
       patch api("/projects/#{project.id}/error_tracking/settings", user), params: params
@@ -60,95 +112,97 @@ RSpec.describe API::ErrorTracking::ProjectSettings, feature_category: :error_tra
         project.add_maintainer(user)
       end
 
-      context 'patch settings' do
-        context 'integrated_error_tracking feature enabled' do
-          it_behaves_like 'returns project settings'
-        end
-
-        context 'integrated_error_tracking feature disabled' do
-          before do
-            stub_feature_flags(integrated_error_tracking: false)
-          end
+      context 'with integrated_error_tracking feature enabled' do
+        it_behaves_like 'returns project settings'
+      end
 
-          it_behaves_like 'returns project settings with false for integrated'
+      context 'with integrated_error_tracking feature disabled' do
+        before do
+          stub_feature_flags(integrated_error_tracking: false)
         end
 
-        it 'updates enabled flag' do
-          expect(setting).to be_enabled
+        it_behaves_like 'returns project settings with false for integrated'
+      end
 
-          make_request
+      it 'updates enabled flag' do
+        expect(setting).to be_enabled
 
-          expect(json_response).to include('active' => false)
-          expect(setting.reload).not_to be_enabled
-        end
+        make_request
+
+        expect(json_response).to include('active' => false)
+        expect(setting.reload).not_to be_enabled
+      end
 
-        context 'active is invalid' do
-          let(:params) { { active: "randomstring" } }
+      context 'when active is invalid' do
+        let(:params) { { active: "randomstring" } }
 
-          it 'returns active is invalid if non boolean' do
-            make_request
+        it 'returns active is invalid if non boolean' do
+          make_request
 
-            expect(response).to have_gitlab_http_status(:bad_request)
-            expect(json_response['error'])
-              .to eq('active is invalid')
-          end
+          expect(response).to have_gitlab_http_status(:bad_request)
+          expect(json_response['error'])
+            .to eq('active is invalid')
         end
+      end
 
-        context 'active is empty' do
-          let(:params) { { active: '' } }
+      context 'when active is empty' do
+        let(:params) { { active: '' } }
 
-          it 'returns 400' do
-            make_request
+        it 'returns 400' do
+          make_request
 
-            expect(response).to have_gitlab_http_status(:bad_request)
-            expect(json_response['error'])
-              .to eq('active is empty')
-          end
+          expect(response).to have_gitlab_http_status(:bad_request)
+          expect(json_response['error'])
+            .to eq('active is empty')
         end
+      end
 
-        context 'with integrated param' do
-          let(:params) { { active: true, integrated: true } }
+      context 'with integrated param' do
+        let(:params) { { active: true, integrated: true } }
 
-          context 'integrated_error_tracking feature enabled' do
-            before do
-              stub_feature_flags(integrated_error_tracking: true)
-            end
+        context 'when integrated_error_tracking feature enabled' do
+          before do
+            stub_feature_flags(integrated_error_tracking: true)
+          end
 
-            it 'updates the integrated flag' do
-              expect(setting.integrated).to be_falsey
+          it 'updates the integrated flag' do
+            expect(setting.integrated).to be_falsey
 
-              make_request
+            make_request
 
-              expect(json_response).to include('integrated' => true)
-              expect(setting.reload.integrated).to be_truthy
-            end
+            expect(json_response).to include('integrated' => true)
+            expect(setting.reload.integrated).to be_truthy
           end
         end
       end
 
       context 'without a project setting' do
-        let(:project) { create(:project) }
+        let(:project) { project_without_setting }
 
         before do
           project.add_maintainer(user)
         end
 
-        context 'patch settings' do
-          it_behaves_like 'returns 404'
-        end
+        it_behaves_like 'returns no project settings'
       end
-    end
 
-    context 'when authenticated as reporter' do
-      before do
-        project.add_reporter(user)
-      end
+      context "when ::Projects::Operations::UpdateService responds with an error" do
+        before do
+          allow_next_instance_of(::Projects::Operations::UpdateService) do |service|
+            allow(service)
+              .to receive(:execute)
+              .and_return({ status: :error, message: 'An error occurred', http_status: :forbidden })
+          end
+        end
 
-      context 'patch request' do
-        it 'returns 403' do
-          make_request
+        context "when integrated" do
+          let(:integrated) { true }
 
-          expect(response).to have_gitlab_http_status(:forbidden)
+          it_behaves_like 'returns error from UpdateService'
+        end
+
+        context "without integrated" do
+          it_behaves_like 'returns error from UpdateService'
         end
       end
     end
@@ -158,35 +212,17 @@ RSpec.describe API::ErrorTracking::ProjectSettings, feature_category: :error_tra
         project.add_developer(user)
       end
 
-      context 'patch request' do
-        it 'returns 403' do
-          make_request
-
-          expect(response).to have_gitlab_http_status(:forbidden)
-        end
-      end
+      it_behaves_like 'returns 403'
     end
 
     context 'when authenticated as non-member' do
-      context 'patch request' do
-        it 'returns 404' do
-          make_request
-
-          expect(response).to have_gitlab_http_status(:not_found)
-        end
-      end
+      it_behaves_like 'returns 404'
     end
 
     context 'when unauthenticated' do
       let(:user) { nil }
 
-      context 'patch request' do
-        it 'returns 401 for update request' do
-          make_request
-
-          expect(response).to have_gitlab_http_status(:unauthorized)
-        end
-      end
+      it_behaves_like 'returns 401'
     end
   end
 
@@ -200,77 +236,152 @@ RSpec.describe API::ErrorTracking::ProjectSettings, feature_category: :error_tra
         project.add_maintainer(user)
       end
 
-      context 'get settings' do
-        context 'integrated_error_tracking feature enabled' do
-          before do
-            stub_feature_flags(integrated_error_tracking: true)
-          end
+      it_behaves_like 'returns project settings'
 
-          it_behaves_like 'returns project settings'
+      context 'when integrated_error_tracking feature disabled' do
+        before do
+          stub_feature_flags(integrated_error_tracking: false)
         end
 
-        context 'integrated_error_tracking feature disabled' do
-          before do
-            stub_feature_flags(integrated_error_tracking: false)
-          end
-
-          it_behaves_like 'returns project settings with false for integrated'
-        end
+        it_behaves_like 'returns project settings with false for integrated'
       end
     end
 
     context 'without a project setting' do
-      let(:project) { create(:project) }
+      let(:project) { project_without_setting }
 
       before do
         project.add_maintainer(user)
       end
 
-      context 'get settings' do
-        it_behaves_like 'returns 404'
-      end
+      it_behaves_like 'returns no project settings'
     end
 
-    context 'when authenticated as reporter' do
+    context 'when authenticated as developer' do
       before do
-        project.add_reporter(user)
+        project.add_developer(user)
       end
 
-      it 'returns 403' do
-        make_request
+      it_behaves_like 'returns 403'
+    end
 
-        expect(response).to have_gitlab_http_status(:forbidden)
-      end
+    context 'when authenticated as non-member' do
+      it_behaves_like 'returns 404'
     end
 
-    context 'when authenticated as developer' do
-      before do
-        project.add_developer(user)
-      end
+    context 'when unauthenticated' do
+      let(:user) { nil }
 
-      it 'returns 403' do
-        make_request
+      it_behaves_like 'returns 401'
+    end
+  end
 
-        expect(response).to have_gitlab_http_status(:forbidden)
-      end
+  describe "PUT /projects/:id/error_tracking/settings" do
+    let(:params) { { active: active, integrated: integrated } }
+    let(:active) { true }
+    let(:integrated) { true }
+
+    def make_request
+      put api("/projects/#{project.id}/error_tracking/settings", user), params: params
     end
 
-    context 'when authenticated as non-member' do
-      it 'returns 404' do
-        make_request
+    context 'when authenticated' do
+      context 'as maintainer' do
+        before do
+          project.add_maintainer(user)
+        end
+
+        context "when integrated" do
+          context "with existing setting" do
+            let(:project) { setting.project }
+            let(:setting) { create(:project_error_tracking_setting, :integrated) }
+            let(:active) { false }
+
+            it "updates a setting" do
+              expect { make_request }.not_to change { ErrorTracking::ProjectErrorTrackingSetting.count }
 
-        expect(response).to have_gitlab_http_status(:not_found)
+              expect(response).to have_gitlab_http_status(:ok)
+
+              expect(json_response).to eq(
+                "active" => false,
+                "api_url" => nil,
+                "integrated" => integrated,
+                "project_name" => nil,
+                "sentry_external_url" => nil
+              )
+            end
+          end
+
+          context "without setting" do
+            let(:project) { project_without_setting }
+            let(:active) { true }
+
+            it "creates a setting" do
+              expect { make_request }.to change { ErrorTracking::ProjectErrorTrackingSetting.count }
+
+              expect(response).to have_gitlab_http_status(:ok)
+
+              expect(json_response).to eq(
+                "active" => true,
+                "api_url" => nil,
+                "integrated" => true,
+                "project_name" => nil,
+                "sentry_external_url" => nil
+              )
+            end
+          end
+
+          context "when ::Projects::Operations::UpdateService responds with an error" do
+            before do
+              allow_next_instance_of(::Projects::Operations::UpdateService) do |service|
+                allow(service)
+                  .to receive(:execute)
+                        .and_return({ status: :error, message: 'An error occurred', http_status: :forbidden })
+              end
+            end
+
+            it_behaves_like 'returns error from UpdateService'
+          end
+        end
+
+        context "when integrated_error_tracking feature disabled" do
+          before do
+            stub_feature_flags(integrated_error_tracking: false)
+          end
+
+          it_behaves_like 'returns 404'
+        end
+
+        context "when integrated param is invalid" do
+          let(:params) { { active: active, integrated: 'invalid_string' } }
+
+          it_behaves_like 'returns 400 with `integrated` param required or invalid', 'integrated is invalid'
+        end
+
+        context "when integrated param is missing" do
+          let(:params) { { active: active } }
+
+          it_behaves_like 'returns 400 with `integrated` param required or invalid', 'integrated is missing'
+        end
       end
-    end
 
-    context 'when unauthenticated' do
-      let(:user) { nil }
+      context "as developer" do
+        before do
+          project.add_developer(user)
+        end
 
-      it 'returns 401' do
-        make_request
+        it_behaves_like 'returns 403'
+      end
 
-        expect(response).to have_gitlab_http_status(:unauthorized)
+      context 'as non-member' do
+        it_behaves_like 'returns 404'
       end
     end
+
+    context "when unauthorized" do
+      let(:user) { nil }
+
+      it_behaves_like 'returns 401'
+    end
   end
 end