Merge branch 'master' of gitlab.com:gitlab-org/gitlab-ce into docs-pages-introdocs-pages-intro

33 files changed, 1463 insertions, 598 deletions

diff --git a/spec/services/after_branch_delete_service_spec.rb b/spec/services/after_branch_delete_service_spec.rb
deleted file mode 100644
index bc9747d1413..00000000000
--- a/spec/services/after_branch_delete_service_spec.rb
+++ /dev/null
@@ -1,15 +0,0 @@
-require 'spec_helper'
-
-describe AfterBranchDeleteService do
-  let(:project) { create(:project, :repository) }
-  let(:user) { create(:user) }
-  let(:service) { described_class.new(project, user) }
-
-  describe '#execute' do
-    it 'stops environments attached to branch' do
-      expect(service).to receive(:stop_environments)
-
-      service.execute('feature')
-    end
-  end
-end
diff --git a/spec/services/application_settings/update_service_spec.rb b/spec/services/application_settings/update_service_spec.rb
index a4a733eff77..258e5635113 100644
--- a/spec/services/application_settings/update_service_spec.rb
+++ b/spec/services/application_settings/update_service_spec.rb
@@ -1,6 +1,8 @@
 require 'spec_helper'
 
 describe ApplicationSettings::UpdateService do
+  include ExternalAuthorizationServiceHelpers
+
   let(:application_settings) { create(:application_setting) }
   let(:admin) { create(:user, :admin) }
   let(:params) { {} }
@@ -143,4 +145,37 @@ describe ApplicationSettings::UpdateService do
       end
     end
   end
+
+  context 'when external authorization is enabled' do
+    before do
+      enable_external_authorization_service_check
+    end
+
+    it 'does not save the settings with an error if the service denies access' do
+      expect(::Gitlab::ExternalAuthorization)
+        .to receive(:access_allowed?).with(admin, 'new-label') { false }
+
+      described_class.new(application_settings, admin, { external_authorization_service_default_label: 'new-label' }).execute
+
+      expect(application_settings.errors[:external_authorization_service_default_label]).to be_present
+    end
+
+    it 'saves the setting when the user has access to the label' do
+      expect(::Gitlab::ExternalAuthorization)
+        .to receive(:access_allowed?).with(admin, 'new-label') { true }
+
+      described_class.new(application_settings, admin, { external_authorization_service_default_label: 'new-label' }).execute
+
+      # Read the attribute directly to avoid the stub from
+      # `enable_external_authorization_service_check`
+      expect(application_settings[:external_authorization_service_default_label]).to eq('new-label')
+    end
+
+    it 'does not validate the label if it was not passed' do
+      expect(::Gitlab::ExternalAuthorization)
+        .not_to receive(:access_allowed?)
+
+      described_class.new(application_settings, admin, { home_page_url: 'http://foo.bar' }).execute
+    end
+  end
 end
diff --git a/spec/services/ci/create_pipeline_service_spec.rb b/spec/services/ci/create_pipeline_service_spec.rb
index 866d709d446..101b91e9cd8 100644
--- a/spec/services/ci/create_pipeline_service_spec.rb
+++ b/spec/services/ci/create_pipeline_service_spec.rb
@@ -418,8 +418,7 @@ describe Ci::CreatePipelineService do
 
     context 'when push options contain ci.skip' do
       let(:push_options) do
-        ['ci.skip',
-         'another push option']
+        { 'ci' => { 'skip' => true } }
       end
 
       it 'creates a pipline in the skipped state' do
diff --git a/spec/services/ci/retry_build_service_spec.rb b/spec/services/ci/retry_build_service_spec.rb
index 87185891470..17e2b17a499 100644
--- a/spec/services/ci/retry_build_service_spec.rb
+++ b/spec/services/ci/retry_build_service_spec.rb
@@ -35,7 +35,7 @@ describe Ci::RetryBuildService do
        commit_id deployment erased_by_id project_id
        runner_id tag_taggings taggings tags trigger_request_id
        user_id auto_canceled_by_id retried failure_reason
-       artifacts_file_store artifacts_metadata_store
+       sourced_pipelines artifacts_file_store artifacts_metadata_store
        metadata runner_session trace_chunks].freeze
 
   shared_examples 'build duplication' do
@@ -95,7 +95,8 @@ describe Ci::RetryBuildService do
     end
 
     it 'has correct number of known attributes' do
-      known_accessors = CLONE_ACCESSORS + REJECT_ACCESSORS + IGNORE_ACCESSORS
+      processed_accessors = CLONE_ACCESSORS + REJECT_ACCESSORS
+      known_accessors = processed_accessors + IGNORE_ACCESSORS
 
       # :tag_list is a special case, this accessor does not exist
       # in reflected associations, comes from `act_as_taggable` and
@@ -108,7 +109,8 @@ describe Ci::RetryBuildService do
 
       current_accessors.uniq!
 
-      expect(known_accessors).to contain_exactly(*current_accessors)
+      expect(current_accessors).to include(*processed_accessors)
+      expect(known_accessors).to include(*current_accessors)
     end
   end
 
diff --git a/spec/services/git/branch_hooks_service_spec.rb b/spec/services/git/branch_hooks_service_spec.rb
new file mode 100644
index 00000000000..bb87267db7d
--- /dev/null
+++ b/spec/services/git/branch_hooks_service_spec.rb
@@ -0,0 +1,339 @@
+require 'spec_helper'
+
+describe Git::BranchHooksService do
+  include RepoHelpers
+
+  let(:project) { create(:project, :repository) }
+  let(:user) { project.creator }
+
+  let(:branch) { project.default_branch }
+  let(:ref) { "refs/heads/#{branch}" }
+  let(:commit) { project.commit(sample_commit.id) }
+  let(:oldrev) { commit.parent_id }
+  let(:newrev) { commit.id }
+
+  let(:service) do
+    described_class.new(project, user, oldrev: oldrev, newrev: newrev, ref: ref)
+  end
+
+  describe "Git Push Data" do
+    subject(:push_data) { service.execute }
+
+    it 'has expected push data attributes' do
+      is_expected.to match a_hash_including(
+        object_kind: 'push',
+        before: oldrev,
+        after: newrev,
+        ref: ref,
+        user_id: user.id,
+        user_name: user.name,
+        project_id: project.id
+      )
+    end
+
+    context "with repository data" do
+      subject { push_data[:repository] }
+
+      it 'has expected attributes' do
+        is_expected.to match a_hash_including(
+          name: project.name,
+          url: project.url_to_repo,
+          description: project.description,
+          homepage: project.web_url
+        )
+      end
+    end
+
+    context "with commits" do
+      subject { push_data[:commits] }
+
+      it { is_expected.to be_an(Array) }
+
+      it 'has 1 element' do
+        expect(subject.size).to eq(1)
+      end
+
+      context "the commit" do
+        subject { push_data[:commits].first }
+
+        it { expect(subject[:timestamp].in_time_zone).to eq(commit.date.in_time_zone) }
+
+        it 'includes expected commit data' do
+          is_expected.to match a_hash_including(
+            id: commit.id,
+            message: commit.safe_message,
+            url: [
+              Gitlab.config.gitlab.url,
+              project.namespace.to_param,
+              project.to_param,
+              'commit',
+              commit.id
+            ].join('/')
+          )
+        end
+
+        context "with a author" do
+          subject { push_data[:commits].first[:author] }
+
+          it 'includes expected author data' do
+            is_expected.to match a_hash_including(
+              name: commit.author_name,
+              email: commit.author_email
+            )
+          end
+        end
+      end
+    end
+  end
+
+  describe 'Push Event' do
+    let(:event) { Event.find_by_action(Event::PUSHED) }
+
+    before do
+      service.execute
+    end
+
+    context "with an existing branch" do
+      it 'generates a push event with one commit' do
+        expect(event).to be_an_instance_of(PushEvent)
+        expect(event.project).to eq(project)
+        expect(event.action).to eq(Event::PUSHED)
+        expect(event.push_event_payload).to be_an_instance_of(PushEventPayload)
+        expect(event.push_event_payload.commit_from).to eq(oldrev)
+        expect(event.push_event_payload.commit_to).to eq(newrev)
+        expect(event.push_event_payload.ref).to eq('master')
+        expect(event.push_event_payload.commit_count).to eq(1)
+      end
+    end
+
+    context "with a new branch" do
+      let(:oldrev) { Gitlab::Git::BLANK_SHA }
+
+      it 'generates a push event with more than one commit' do
+        expect(event).to be_an_instance_of(PushEvent)
+        expect(event.project).to eq(project)
+        expect(event.action).to eq(Event::PUSHED)
+        expect(event.push_event_payload).to be_an_instance_of(PushEventPayload)
+        expect(event.push_event_payload.commit_from).to be_nil
+        expect(event.push_event_payload.commit_to).to eq(newrev)
+        expect(event.push_event_payload.ref).to eq('master')
+        expect(event.push_event_payload.commit_count).to be > 1
+      end
+    end
+
+    context 'removing a branch' do
+      let(:newrev) { Gitlab::Git::BLANK_SHA }
+
+      it 'generates a push event with no commits' do
+        expect(event).to be_an_instance_of(PushEvent)
+        expect(event.project).to eq(project)
+        expect(event.action).to eq(Event::PUSHED)
+        expect(event.push_event_payload).to be_an_instance_of(PushEventPayload)
+        expect(event.push_event_payload.commit_from).to eq(oldrev)
+        expect(event.push_event_payload.commit_to).to be_nil
+        expect(event.push_event_payload.ref).to eq('master')
+        expect(event.push_event_payload.commit_count).to eq(0)
+      end
+    end
+  end
+
+  describe 'Invalidating project cache' do
+    let(:commit_id) do
+      project.repository.update_file(
+        user, 'README.md', '', message: 'Update', branch_name: branch
+      )
+    end
+
+    let(:commit) { project.repository.commit(commit_id) }
+    let(:blank_sha) { Gitlab::Git::BLANK_SHA }
+
+    def clears_cache(extended: [])
+      expect(ProjectCacheWorker)
+        .to receive(:perform_async)
+        .with(project.id, extended, %i[commit_count repository_size])
+
+      service.execute
+    end
+
+    def clears_extended_cache
+      clears_cache(extended: %i[readme])
+    end
+
+    context 'on default branch' do
+      context 'create' do
+        # FIXME: When creating the default branch,the cache worker runs twice
+        before do
+          allow(ProjectCacheWorker).to receive(:perform_async)
+        end
+
+        let(:oldrev) { blank_sha }
+
+        it { clears_cache }
+      end
+
+      context 'update' do
+        it { clears_extended_cache }
+      end
+
+      context 'remove' do
+        let(:newrev) { blank_sha }
+
+        # TODO: this case should pass, but we only take account of added files
+        it { clears_cache }
+      end
+    end
+
+    context 'on ordinary branch' do
+      let(:branch) { 'fix' }
+
+      context 'create' do
+        let(:oldrev) { blank_sha }
+
+        it { clears_cache }
+      end
+
+      context 'update' do
+        it { clears_cache }
+      end
+
+      context 'remove' do
+        let(:newrev) { blank_sha }
+
+        it { clears_cache }
+      end
+    end
+  end
+
+  describe 'GPG signatures' do
+    context 'when the commit has a signature' do
+      context 'when the signature is already cached' do
+        before do
+          create(:gpg_signature, commit_sha: commit.id)
+        end
+
+        it 'does not queue a CreateGpgSignatureWorker' do
+          expect(CreateGpgSignatureWorker).not_to receive(:perform_async)
+
+          service.execute
+        end
+      end
+
+      context 'when the signature is not yet cached' do
+        it 'queues a CreateGpgSignatureWorker' do
+          expect(CreateGpgSignatureWorker).to receive(:perform_async).with([commit.id], project.id)
+
+          service.execute
+        end
+
+        it 'can queue several commits to create the gpg signature' do
+          allow(Gitlab::Git::Commit)
+            .to receive(:shas_with_signatures)
+            .and_return([sample_commit.id, another_sample_commit.id])
+
+          expect(CreateGpgSignatureWorker)
+            .to receive(:perform_async)
+            .with([sample_commit.id, another_sample_commit.id], project.id)
+
+          service.execute
+        end
+      end
+    end
+
+    context 'when the commit does not have a signature' do
+      before do
+        allow(Gitlab::Git::Commit)
+          .to receive(:shas_with_signatures)
+          .with(project.repository, [sample_commit.id])
+          .and_return([])
+      end
+
+      it 'does not queue a CreateGpgSignatureWorker' do
+        expect(CreateGpgSignatureWorker)
+          .not_to receive(:perform_async)
+          .with(sample_commit.id, project.id)
+
+        service.execute
+      end
+    end
+  end
+
+  describe 'Processing commit messages' do
+    # Create 4 commits, 2 of which have references. Limiting to 2 commits, we
+    # expect to see one commit message processor enqueued.
+    let(:commit_ids) do
+      Array.new(4) do |i|
+        message = "Issue #{'#' if i.even?}#{i}"
+        project.repository.update_file(
+          user, 'README.md', '', message: message, branch_name: branch
+        )
+      end
+    end
+
+    let(:oldrev) { commit_ids.first }
+    let(:newrev) { commit_ids.last }
+
+    before do
+      stub_const("::Git::BaseHooksService::PROCESS_COMMIT_LIMIT", 2)
+    end
+
+    context 'creating the default branch' do
+      let(:oldrev) { Gitlab::Git::BLANK_SHA }
+
+      it 'does not process commit messages' do
+        expect(ProcessCommitWorker).not_to receive(:perform_async)
+
+        service.execute
+      end
+    end
+
+    context 'updating the default branch' do
+      it 'processes a limited number of commit messages' do
+        expect(ProcessCommitWorker).to receive(:perform_async).once
+
+        service.execute
+      end
+    end
+
+    context 'removing the default branch' do
+      let(:newrev) { Gitlab::Git::BLANK_SHA }
+
+      it 'does not process commit messages' do
+        expect(ProcessCommitWorker).not_to receive(:perform_async)
+
+        service.execute
+      end
+    end
+
+    context 'creating a normal branch' do
+      let(:branch) { 'fix' }
+      let(:oldrev) { Gitlab::Git::BLANK_SHA }
+
+      it 'processes a limited number of commit messages' do
+        expect(ProcessCommitWorker).to receive(:perform_async).once
+
+        service.execute
+      end
+    end
+
+    context 'updating a normal branch' do
+      let(:branch) { 'fix' }
+
+      it 'processes a limited number of commit messages' do
+        expect(ProcessCommitWorker).to receive(:perform_async).once
+
+        service.execute
+      end
+    end
+
+    context 'removing a normal branch' do
+      let(:branch) { 'fix' }
+      let(:newrev) { Gitlab::Git::BLANK_SHA }
+
+      it 'does not process commit messages' do
+        expect(ProcessCommitWorker).not_to receive(:perform_async)
+
+        service.execute
+      end
+    end
+  end
+end
diff --git a/spec/services/git/branch_push_service_spec.rb b/spec/services/git/branch_push_service_spec.rb
index d0e2169b4a6..322e40a8112 100644
--- a/spec/services/git/branch_push_service_spec.rb
+++ b/spec/services/git/branch_push_service_spec.rb
@@ -8,7 +8,8 @@ describe Git::BranchPushService, services: true do
   let(:blankrev) { Gitlab::Git::BLANK_SHA }
   let(:oldrev)   { sample_commit.parent_id }
   let(:newrev)   { sample_commit.id }
-  let(:ref)      { 'refs/heads/master' }
+  let(:branch)   { 'master' }
+  let(:ref)      { "refs/heads/#{branch}" }
 
   before do
     project.add_maintainer(user)
@@ -132,64 +133,6 @@ describe Git::BranchPushService, services: true do
     end
   end
 
-  describe "Git Push Data" do
-    let(:commit) { project.commit(newrev) }
-
-    subject { push_data_from_service(project, user, oldrev, newrev, ref) }
-
-    it { is_expected.to include(object_kind: 'push') }
-    it { is_expected.to include(before: oldrev) }
-    it { is_expected.to include(after: newrev) }
-    it { is_expected.to include(ref: ref) }
-    it { is_expected.to include(user_id: user.id) }
-    it { is_expected.to include(user_name: user.name) }
-    it { is_expected.to include(project_id: project.id) }
-
-    context "with repository data" do
-      subject { push_data_from_service(project, user, oldrev, newrev, ref)[:repository] }
-
-      it { is_expected.to include(name: project.name) }
-      it { is_expected.to include(url: project.url_to_repo) }
-      it { is_expected.to include(description: project.description) }
-      it { is_expected.to include(homepage: project.web_url) }
-    end
-
-    context "with commits" do
-      subject { push_data_from_service(project, user, oldrev, newrev, ref)[:commits] }
-
-      it { is_expected.to be_an(Array) }
-      it 'has 1 element' do
-        expect(subject.size).to eq(1)
-      end
-
-      context "the commit" do
-        subject { push_data_from_service(project, user, oldrev, newrev, ref)[:commits].first }
-
-        it { is_expected.to include(id: commit.id) }
-        it { is_expected.to include(message: commit.safe_message) }
-        it { expect(subject[:timestamp].in_time_zone).to eq(commit.date.in_time_zone) }
-        it do
-          is_expected.to include(
-            url: [
-              Gitlab.config.gitlab.url,
-              project.namespace.to_param,
-              project.to_param,
-              'commit',
-              commit.id
-            ].join('/')
-          )
-        end
-
-        context "with a author" do
-          subject { push_data_from_service(project, user, oldrev, newrev, ref)[:commits].first[:author] }
-
-          it { is_expected.to include(name: commit.author_name) }
-          it { is_expected.to include(email: commit.author_email) }
-        end
-      end
-    end
-  end
-
   describe "Pipelines" do
     subject { execute_service(project, user, oldrev, newrev, ref) }
 
@@ -203,59 +146,13 @@ describe Git::BranchPushService, services: true do
     end
   end
 
-  describe "Push Event" do
-    context "with an existing branch" do
-      let!(:push_data) { push_data_from_service(project, user, oldrev, newrev, ref) }
-      let(:event) { Event.find_by_action(Event::PUSHED) }
-
-      it 'generates a push event with one commit' do
-        expect(event).to be_an_instance_of(PushEvent)
-        expect(event.project).to eq(project)
-        expect(event.action).to eq(Event::PUSHED)
-        expect(event.push_event_payload).to be_an_instance_of(PushEventPayload)
-        expect(event.push_event_payload.commit_from).to eq(oldrev)
-        expect(event.push_event_payload.commit_to).to eq(newrev)
-        expect(event.push_event_payload.ref).to eq('master')
-        expect(event.push_event_payload.commit_count).to eq(1)
-      end
-    end
-
-    context "with a new branch" do
-      let!(:new_branch_data) { push_data_from_service(project, user, Gitlab::Git::BLANK_SHA, newrev, ref) }
-      let(:event) { Event.find_by_action(Event::PUSHED) }
-
-      it 'generates a push event with more than one commit' do
-        expect(event).to be_an_instance_of(PushEvent)
-        expect(event.project).to eq(project)
-        expect(event.action).to eq(Event::PUSHED)
-        expect(event.push_event_payload).to be_an_instance_of(PushEventPayload)
-        expect(event.push_event_payload.commit_from).to be_nil
-        expect(event.push_event_payload.commit_to).to eq(newrev)
-        expect(event.push_event_payload.ref).to eq('master')
-        expect(event.push_event_payload.commit_count).to be > 1
-      end
-    end
-
-    context "Updates merge requests" do
-      it "when pushing a new branch for the first time" do
-        expect(UpdateMergeRequestsWorker).to receive(:perform_async)
-                                                .with(project.id, user.id, blankrev, 'newrev', ref)
-        execute_service(project, user, blankrev, 'newrev', ref )
-      end
-    end
-
-    describe 'system hooks' do
-      let!(:push_data) { push_data_from_service(project, user, oldrev, newrev, ref) }
-      let!(:system_hooks_service) { SystemHooksService.new }
+  describe "Updates merge requests" do
+    it "when pushing a new branch for the first time" do
+      expect(UpdateMergeRequestsWorker)
+        .to receive(:perform_async)
+        .with(project.id, user.id, blankrev, 'newrev', ref)
 
-      it "sends a system hook after pushing a branch" do
-        allow(SystemHooksService).to receive(:new).and_return(system_hooks_service)
-        allow(system_hooks_service).to receive(:execute_hooks)
-
-        execute_service(project, user, oldrev, newrev, ref)
-
-        expect(system_hooks_service).to have_received(:execute_hooks).with(push_data, :push_hooks)
-      end
+      execute_service(project, user, blankrev, 'newrev', ref )
     end
   end
 
@@ -700,125 +597,64 @@ describe Git::BranchPushService, services: true do
     end
   end
 
-  describe '#update_caches' do
-    let(:service) do
-      described_class.new(project,
-                          user,
-                          oldrev: oldrev,
-                          newrev: newrev,
-                          ref: ref)
-    end
-
-    context 'on the default branch' do
-      before do
-        allow(service).to receive(:default_branch?).and_return(true)
-      end
-
-      it 'flushes the caches of any special files that have been changed' do
-        commit = double(:commit)
-        diff = double(:diff, new_path: 'README.md')
-
-        expect(commit).to receive(:raw_deltas)
-          .and_return([diff])
-
-        service.push_commits = [commit]
+  describe "CI environments" do
+    context 'create branch' do
+      let(:oldrev) { blankrev }
 
-        expect(ProjectCacheWorker).to receive(:perform_async)
-          .with(project.id, %i(readme), %i(commit_count repository_size))
+      it 'does nothing' do
+        expect(::Ci::StopEnvironmentsService).not_to receive(:new)
 
-        service.update_caches
+        execute_service(project, user, oldrev, newrev, ref)
       end
     end
 
-    context 'on a non-default branch' do
-      before do
-        allow(service).to receive(:default_branch?).and_return(false)
-      end
-
-      it 'does not flush any conditional caches' do
-        expect(ProjectCacheWorker).to receive(:perform_async)
-          .with(project.id, [], %i(commit_count repository_size))
-          .and_call_original
+    context 'update branch' do
+      it 'does nothing' do
+        expect(::Ci::StopEnvironmentsService).not_to receive(:new)
 
-        service.update_caches
+        execute_service(project, user, oldrev, newrev, ref)
       end
     end
-  end
-
-  describe '#process_commit_messages' do
-    let(:service) do
-      described_class.new(project,
-                          user,
-                          oldrev: oldrev,
-                          newrev: newrev,
-                          ref: ref)
-    end
 
-    it 'only schedules a limited number of commits' do
-      service.push_commits = Array.new(1000, double(:commit, to_hash: {}, matches_cross_reference_regex?: true))
-
-      expect(ProcessCommitWorker).to receive(:perform_async).exactly(100).times
-
-      service.process_commit_messages
-    end
-
-    it "skips commits which don't include cross-references" do
-      service.push_commits = [double(:commit, to_hash: {}, matches_cross_reference_regex?: false)]
-
-      expect(ProcessCommitWorker).not_to receive(:perform_async)
-
-      service.process_commit_messages
-    end
-  end
-
-  describe '#update_signatures' do
-    let(:service) do
-      described_class.new(
-        project,
-        user,
-        oldrev: oldrev,
-        newrev: newrev,
-        ref: 'refs/heads/master'
-      )
-    end
+    context 'delete branch' do
+      let(:newrev) { blankrev }
 
-    context 'when the commit has a signature' do
-      context 'when the signature is already cached' do
-        before do
-          create(:gpg_signature, commit_sha: sample_commit.id)
+      it 'stops environments' do
+        expect_next_instance_of(::Ci::StopEnvironmentsService) do |stop_service|
+          expect(stop_service.project).to eq(project)
+          expect(stop_service.current_user).to eq(user)
+          expect(stop_service).to receive(:execute).with(branch)
         end
 
-        it 'does not queue a CreateGpgSignatureWorker' do
-          expect(CreateGpgSignatureWorker).not_to receive(:perform_async)
-
-          execute_service(project, user, oldrev, newrev, ref)
-        end
+        execute_service(project, user, oldrev, newrev, ref)
       end
+    end
+  end
 
-      context 'when the signature is not yet cached' do
-        it 'queues a CreateGpgSignatureWorker' do
-          expect(CreateGpgSignatureWorker).to receive(:perform_async).with([sample_commit.id], project.id)
+  describe 'Hooks' do
+    context 'run on a branch' do
+      it 'delegates to Git::BranchHooksService' do
+        expect_next_instance_of(::Git::BranchHooksService) do |hooks_service|
+          expect(hooks_service.project).to eq(project)
+          expect(hooks_service.current_user).to eq(user)
+          expect(hooks_service.params).to include(
+            oldrev: oldrev,
+            newrev: newrev,
+            ref: ref
+          )
 
-          execute_service(project, user, oldrev, newrev, ref)
+          expect(hooks_service).to receive(:execute)
         end
 
-        it 'can queue several commits to create the gpg signature' do
-          allow(Gitlab::Git::Commit).to receive(:shas_with_signatures).and_return([sample_commit.id, another_sample_commit.id])
-
-          expect(CreateGpgSignatureWorker).to receive(:perform_async).with([sample_commit.id, another_sample_commit.id], project.id)
-
-          execute_service(project, user, oldrev, newrev, ref)
-        end
+        execute_service(project, user, oldrev, newrev, ref)
       end
     end
 
-    context 'when the commit does not have a signature' do
-      before do
-        allow(Gitlab::Git::Commit).to receive(:shas_with_signatures).with(project.repository, [sample_commit.id]).and_return([])
-      end
+    context 'run on a tag' do
+      let(:ref) { 'refs/tags/v1.1.0' }
 
-      it 'does not queue a CreateGpgSignatureWorker' do
-        expect(CreateGpgSignatureWorker).not_to receive(:perform_async).with(sample_commit.id, project.id)
+      it 'does nothing' do
+        expect(::Git::BranchHooksService).not_to receive(:new)
 
         execute_service(project, user, oldrev, newrev, ref)
       end
@@ -830,8 +666,4 @@ describe Git::BranchPushService, services: true do
     service.execute
     service
   end
-
-  def push_data_from_service(project, user, oldrev, newrev, ref)
-    execute_service(project, user, oldrev, newrev, ref).push_data
-  end
 end
diff --git a/spec/services/git/tag_hooks_service_spec.rb b/spec/services/git/tag_hooks_service_spec.rb
new file mode 100644
index 00000000000..8f91ce3b4c5
--- /dev/null
+++ b/spec/services/git/tag_hooks_service_spec.rb
@@ -0,0 +1,144 @@
+require 'spec_helper'
+
+describe Git::TagHooksService, :service do
+  let(:user) { create(:user) }
+  let(:project) { create(:project, :repository) }
+
+  let(:oldrev) { Gitlab::Git::BLANK_SHA }
+  let(:newrev) { "8a2a6eb295bb170b34c24c76c49ed0e9b2eaf34b" } # gitlab-test: git rev-parse refs/tags/v1.1.0
+  let(:ref) { "refs/tags/#{tag_name}" }
+  let(:tag_name) { 'v1.1.0' }
+
+  let(:tag) { project.repository.find_tag(tag_name) }
+  let(:commit) { tag.dereferenced_target }
+
+  let(:service) do
+    described_class.new(project, user, oldrev: oldrev, newrev: newrev, ref: ref)
+  end
+
+  describe 'System hooks' do
+    it 'Executes system hooks' do
+      push_data = service.execute
+
+      expect_next_instance_of(SystemHooksService) do |system_hooks_service|
+        expect(system_hooks_service)
+          .to receive(:execute_hooks)
+          .with(push_data, :tag_push_hooks)
+      end
+
+      service.execute
+    end
+  end
+
+  describe "Webhooks" do
+    it "executes hooks on the project" do
+      expect(project).to receive(:execute_hooks)
+
+      service.execute
+    end
+  end
+
+  describe "Pipelines" do
+    before do
+      stub_ci_pipeline_to_return_yaml_file
+      project.add_developer(user)
+    end
+
+    it "creates a new pipeline" do
+      expect { service.execute }.to change { Ci::Pipeline.count }
+
+      expect(Ci::Pipeline.last).to be_push
+    end
+  end
+
+  describe 'Push data' do
+    shared_examples_for 'tag push data expectations' do
+      subject(:push_data) { service.execute }
+      it 'has expected push data attributes' do
+        is_expected.to match a_hash_including(
+          object_kind: 'tag_push',
+          ref: ref,
+          before: oldrev,
+          after: newrev,
+          message: tag.message,
+          user_id: user.id,
+          user_name: user.name,
+          project_id: project.id
+        )
+      end
+
+      context "with repository data" do
+        subject { push_data[:repository] }
+
+        it 'has expected repository attributes' do
+          is_expected.to match a_hash_including(
+            name: project.name,
+            url: project.url_to_repo,
+            description: project.description,
+            homepage: project.web_url
+          )
+        end
+      end
+
+      context "with commits" do
+        subject { push_data[:commits] }
+
+        it { is_expected.to be_an(Array) }
+
+        it 'has 1 element' do
+          expect(subject.size).to eq(1)
+        end
+
+        context "the commit" do
+          subject { push_data[:commits].first }
+
+          it { is_expected.to include(timestamp: commit.date.xmlschema) }
+
+          it 'has expected commit attributes' do
+            is_expected.to match a_hash_including(
+              id: commit.id,
+              message: commit.safe_message,
+              url: [
+               Gitlab.config.gitlab.url,
+               project.namespace.to_param,
+               project.to_param,
+               'commit',
+               commit.id
+              ].join('/')
+            )
+          end
+
+          context "with an author" do
+            subject { push_data[:commits].first[:author] }
+
+            it 'has expected author attributes' do
+              is_expected.to match a_hash_including(
+                name: commit.author_name,
+                email: commit.author_email
+              )
+            end
+          end
+        end
+      end
+    end
+
+    context 'annotated tag' do
+      include_examples 'tag push data expectations'
+    end
+
+    context 'lightweight tag' do
+      let(:tag_name) { 'light-tag' }
+      let(:newrev) { '5937ac0a7beb003549fc5fd26fc247adbce4a52e' }
+
+      before do
+        # Create the lightweight tag
+        rugged_repo(project.repository).tags.create(tag_name, newrev)
+
+        # Clear tag list cache
+        project.repository.expire_tags_cache
+      end
+
+      include_examples 'tag push data expectations'
+    end
+  end
+end
diff --git a/spec/services/git/tag_push_service_spec.rb b/spec/services/git/tag_push_service_spec.rb
index 2d960fc9f08..5e89a912060 100644
--- a/spec/services/git/tag_push_service_spec.rb
+++ b/spec/services/git/tag_push_service_spec.rb
@@ -31,178 +31,27 @@ describe Git::TagPushService do
     end
   end
 
-  describe 'System Hooks' do
-    let!(:push_data) { service.tap(&:execute).push_data }
-
-    it "executes system hooks after pushing a tag" do
-      expect_next_instance_of(SystemHooksService) do |system_hooks_service|
-        expect(system_hooks_service)
-          .to receive(:execute_hooks)
-          .with(push_data, :tag_push_hooks)
-      end
-
-      service.execute
-    end
-  end
-
-  describe "Pipelines" do
-    subject { service.execute }
-
-    before do
-      stub_ci_pipeline_to_return_yaml_file
-      project.add_developer(user)
-    end
-
-    it "creates a new pipeline" do
-      expect { subject }.to change { Ci::Pipeline.count }
-      expect(Ci::Pipeline.last).to be_push
-    end
-  end
-
-  describe "Git Tag Push Data" do
-    subject { @push_data }
-    let(:tag) { project.repository.find_tag(tag_name) }
-    let(:commit) { tag.dereferenced_target }
-
-    context 'annotated tag' do
-      let(:tag_name) { Gitlab::Git.ref_name(ref) }
-
-      before do
-        service.execute
-        @push_data = service.push_data
-      end
-
-      it { is_expected.to include(object_kind: 'tag_push') }
-      it { is_expected.to include(ref: ref) }
-      it { is_expected.to include(before: oldrev) }
-      it { is_expected.to include(after: newrev) }
-      it { is_expected.to include(message: tag.message) }
-      it { is_expected.to include(user_id: user.id) }
-      it { is_expected.to include(user_name: user.name) }
-      it { is_expected.to include(project_id: project.id) }
-
-      context "with repository data" do
-        subject { @push_data[:repository] }
-
-        it { is_expected.to include(name: project.name) }
-        it { is_expected.to include(url: project.url_to_repo) }
-        it { is_expected.to include(description: project.description) }
-        it { is_expected.to include(homepage: project.web_url) }
-      end
-
-      context "with commits" do
-        subject { @push_data[:commits] }
-
-        it { is_expected.to be_an(Array) }
-        it 'has 1 element' do
-          expect(subject.size).to eq(1)
-        end
-
-        context "the commit" do
-          subject { @push_data[:commits].first }
-
-          it { is_expected.to include(id: commit.id) }
-          it { is_expected.to include(message: commit.safe_message) }
-          it { is_expected.to include(timestamp: commit.date.xmlschema) }
-          it do
-            is_expected.to include(
-              url: [
-               Gitlab.config.gitlab.url,
-               project.namespace.to_param,
-               project.to_param,
-               'commit',
-               commit.id
-              ].join('/')
-            )
-          end
-
-          context "with a author" do
-            subject { @push_data[:commits].first[:author] }
-
-            it { is_expected.to include(name: commit.author_name) }
-            it { is_expected.to include(email: commit.author_email) }
-          end
+  describe 'Hooks' do
+    context 'run on a tag' do
+      it 'delegates to Git::TagHooksService' do
+        expect_next_instance_of(::Git::TagHooksService) do |hooks_service|
+          expect(hooks_service.project).to eq(service.project)
+          expect(hooks_service.current_user).to eq(service.current_user)
+          expect(hooks_service.params).to eq(service.params)
+
+          expect(hooks_service).to receive(:execute)
         end
-      end
-    end
-
-    context 'lightweight tag' do
-      let(:tag_name) { 'light-tag' }
-      let(:newrev) { '5937ac0a7beb003549fc5fd26fc247adbce4a52e' }
-      let(:ref) { "refs/tags/light-tag" }
-
-      before do
-        # Create the lightweight tag
-        rugged_repo(project.repository).tags.create(tag_name, newrev)
-
-        # Clear tag list cache
-        project.repository.expire_tags_cache
 
         service.execute
-        @push_data = service.push_data
-      end
-
-      it { is_expected.to include(object_kind: 'tag_push') }
-      it { is_expected.to include(ref: ref) }
-      it { is_expected.to include(before: oldrev) }
-      it { is_expected.to include(after: newrev) }
-      it { is_expected.to include(message: tag.message) }
-      it { is_expected.to include(user_id: user.id) }
-      it { is_expected.to include(user_name: user.name) }
-      it { is_expected.to include(project_id: project.id) }
-
-      context "with repository data" do
-        subject { @push_data[:repository] }
-
-        it { is_expected.to include(name: project.name) }
-        it { is_expected.to include(url: project.url_to_repo) }
-        it { is_expected.to include(description: project.description) }
-        it { is_expected.to include(homepage: project.web_url) }
-      end
-
-      context "with commits" do
-        subject { @push_data[:commits] }
-
-        it { is_expected.to be_an(Array) }
-        it 'has 1 element' do
-          expect(subject.size).to eq(1)
-        end
-
-        context "the commit" do
-          subject { @push_data[:commits].first }
-
-          it { is_expected.to include(id: commit.id) }
-          it { is_expected.to include(message: commit.safe_message) }
-          it { is_expected.to include(timestamp: commit.date.xmlschema) }
-          it do
-            is_expected.to include(
-              url: [
-               Gitlab.config.gitlab.url,
-               project.namespace.to_param,
-               project.to_param,
-               'commit',
-               commit.id
-              ].join('/')
-            )
-          end
-
-          context "with a author" do
-            subject { @push_data[:commits].first[:author] }
-
-            it { is_expected.to include(name: commit.author_name) }
-            it { is_expected.to include(email: commit.author_email) }
-          end
-        end
       end
     end
-  end
 
-  describe "Webhooks" do
-    context "execute webhooks" do
-      let(:service) { described_class.new(project, user, oldrev: 'oldrev', newrev: 'newrev', ref: 'refs/tags/v1.0.0') }
+    context 'run on a branch' do
+      let(:ref) { 'refs/heads/master' }
+
+      it 'does nothing' do
+        expect(::Git::BranchHooksService).not_to receive(:new)
 
-      it "when pushing tags" do
-        expect(project).to receive(:execute_hooks)
         service.execute
       end
     end
diff --git a/spec/services/issuable/bulk_update_service_spec.rb b/spec/services/issuable/bulk_update_service_spec.rb
index ca366cdf1df..363b7266940 100644
--- a/spec/services/issuable/bulk_update_service_spec.rb
+++ b/spec/services/issuable/bulk_update_service_spec.rb
@@ -76,14 +76,14 @@ describe Issuable::BulkUpdateService do
   end
 
   describe 'updating merge request assignee' do
-    let(:merge_request) { create(:merge_request, target_project: project, source_project: project, assignee: user) }
+    let(:merge_request) { create(:merge_request, target_project: project, source_project: project, assignees: [user]) }
 
     context 'when the new assignee ID is a valid user' do
       it 'succeeds' do
         new_assignee = create(:user)
         project.add_developer(new_assignee)
 
-        result = bulk_update(merge_request, assignee_id: new_assignee.id)
+        result = bulk_update(merge_request, assignee_ids: [user.id, new_assignee.id])
 
         expect(result[:success]).to be_truthy
         expect(result[:count]).to eq(1)
@@ -93,22 +93,22 @@ describe Issuable::BulkUpdateService do
         assignee = create(:user)
         project.add_developer(assignee)
 
-        expect { bulk_update(merge_request, assignee_id: assignee.id) }
-          .to change { merge_request.reload.assignee }.from(user).to(assignee)
+        expect { bulk_update(merge_request, assignee_ids: [assignee.id]) }
+          .to change { merge_request.reload.assignee_ids }.from([user.id]).to([assignee.id])
       end
     end
 
     context "when the new assignee ID is #{IssuableFinder::NONE}" do
       it 'unassigns the issues' do
-        expect { bulk_update(merge_request, assignee_id: IssuableFinder::NONE) }
-          .to change { merge_request.reload.assignee }.to(nil)
+        expect { bulk_update(merge_request, assignee_ids: [IssuableFinder::NONE]) }
+          .to change { merge_request.reload.assignee_ids }.to([])
       end
     end
 
     context 'when the new assignee ID is not present' do
       it 'does not unassign' do
-        expect { bulk_update(merge_request, assignee_id: nil) }
-          .not_to change { merge_request.reload.assignee }
+        expect { bulk_update(merge_request, assignee_ids: []) }
+          .not_to change { merge_request.reload.assignee_ids }
       end
     end
   end
diff --git a/spec/services/issuable/destroy_service_spec.rb b/spec/services/issuable/destroy_service_spec.rb
index 8ccbba7fa58..15d1bb73ca3 100644
--- a/spec/services/issuable/destroy_service_spec.rb
+++ b/spec/services/issuable/destroy_service_spec.rb
@@ -34,7 +34,7 @@ describe Issuable::DestroyService do
     end
 
     context 'when issuable is a merge request' do
-      let!(:merge_request) { create(:merge_request, target_project: project, source_project: project, author: user, assignee: user) }
+      let!(:merge_request) { create(:merge_request, target_project: project, source_project: project, author: user, assignees: [user]) }
 
       it 'destroys the merge request' do
         expect { service.execute(merge_request) }.to change { project.merge_requests.count }.by(-1)
diff --git a/spec/services/members/destroy_service_spec.rb b/spec/services/members/destroy_service_spec.rb
index d37ca13ebd2..91bf4dccd77 100644
--- a/spec/services/members/destroy_service_spec.rb
+++ b/spec/services/members/destroy_service_spec.rb
@@ -43,9 +43,9 @@ describe Members::DestroyService do
   shared_examples 'a service destroying a member with access' do
     it_behaves_like 'a service destroying a member'
 
-    it 'invalidates cached counts for todos and assigned issues and merge requests', :aggregate_failures do
+    it 'invalidates cached counts for assigned issues and merge requests', :aggregate_failures do
       create(:issue, project: group_project, assignees: [member_user])
-      create(:merge_request, source_project: group_project, assignee: member_user)
+      create(:merge_request, source_project: group_project, assignees: [member_user])
       create(:todo, :pending, project: group_project, user: member_user)
       create(:todo, :done, project: group_project, user: member_user)
 
diff --git a/spec/services/merge_requests/close_service_spec.rb b/spec/services/merge_requests/close_service_spec.rb
index 433ffbd97f0..706bcea8199 100644
--- a/spec/services/merge_requests/close_service_spec.rb
+++ b/spec/services/merge_requests/close_service_spec.rb
@@ -4,7 +4,7 @@ describe MergeRequests::CloseService do
   let(:user) { create(:user) }
   let(:user2) { create(:user) }
   let(:guest) { create(:user) }
-  let(:merge_request) { create(:merge_request, assignee: user2, author: create(:user)) }
+  let(:merge_request) { create(:merge_request, assignees: [user2], author: create(:user)) }
   let(:project) { merge_request.project }
   let!(:todo) { create(:todo, :assigned, user: user, project: project, target: merge_request, author: user2) }
 
diff --git a/spec/services/merge_requests/create_from_issue_service_spec.rb b/spec/services/merge_requests/create_from_issue_service_spec.rb
index 393299cce00..20bf1cbb8b6 100644
--- a/spec/services/merge_requests/create_from_issue_service_spec.rb
+++ b/spec/services/merge_requests/create_from_issue_service_spec.rb
@@ -118,7 +118,7 @@ describe MergeRequests::CreateFromIssueService do
 
       result = service.execute
 
-      expect(result[:merge_request].assignee).to eq(user)
+      expect(result[:merge_request].assignees).to eq([user])
     end
 
     context 'when ref branch is set' do
diff --git a/spec/services/merge_requests/create_service_spec.rb b/spec/services/merge_requests/create_service_spec.rb
index dc5d1cf2f04..30271e04c8e 100644
--- a/spec/services/merge_requests/create_service_spec.rb
+++ b/spec/services/merge_requests/create_service_spec.rb
@@ -32,7 +32,7 @@ describe MergeRequests::CreateService do
         expect(merge_request).to be_valid
         expect(merge_request.work_in_progress?).to be(false)
         expect(merge_request.title).to eq('Awesome merge_request')
-        expect(merge_request.assignee).to be_nil
+        expect(merge_request.assignees).to be_empty
         expect(merge_request.merge_params['force_remove_source_branch']).to eq('1')
       end
 
@@ -73,7 +73,7 @@ describe MergeRequests::CreateService do
               description: "well this is not done yet\n/wip",
               source_branch: 'feature',
               target_branch: 'master',
-              assignee: assignee
+              assignees: [assignee]
             }
           end
 
@@ -89,7 +89,7 @@ describe MergeRequests::CreateService do
               description: "well this is not done yet\n/wip",
               source_branch: 'feature',
               target_branch: 'master',
-              assignee: assignee
+              assignees: [assignee]
             }
           end
 
@@ -106,11 +106,11 @@ describe MergeRequests::CreateService do
             description: 'please fix',
             source_branch: 'feature',
             target_branch: 'master',
-            assignee: assignee
+            assignees: [assignee]
           }
         end
 
-        it { expect(merge_request.assignee).to eq assignee }
+        it { expect(merge_request.assignees).to eq([assignee]) }
 
         it 'creates a todo for new assignee' do
           attributes = {
@@ -301,7 +301,7 @@ describe MergeRequests::CreateService do
 
         let(:opts) do
           {
-            assignee_id: create(:user).id,
+            assignee_ids: create(:user).id,
             milestone_id: 1,
             title: 'Title',
             description: %(/assign @#{assignee.username}\n/milestone %"#{milestone.name}"),
@@ -317,7 +317,7 @@ describe MergeRequests::CreateService do
 
         it 'assigns and sets milestone to issuable from command' do
           expect(merge_request).to be_persisted
-          expect(merge_request.assignee).to eq(assignee)
+          expect(merge_request.assignees).to eq([assignee])
           expect(merge_request.milestone).to eq(milestone)
         end
       end
@@ -332,28 +332,28 @@ describe MergeRequests::CreateService do
         end
 
         it 'removes assignee_id when user id is invalid' do
-          opts = { title: 'Title', description: 'Description', assignee_id: -1 }
+          opts = { title: 'Title', description: 'Description', assignee_ids: [-1] }
 
           merge_request = described_class.new(project, user, opts).execute
 
-          expect(merge_request.assignee_id).to be_nil
+          expect(merge_request.assignee_ids).to be_empty
         end
 
         it 'removes assignee_id when user id is 0' do
-          opts = { title: 'Title', description: 'Description', assignee_id: 0 }
+          opts = { title: 'Title', description: 'Description', assignee_ids: [0] }
 
           merge_request = described_class.new(project, user, opts).execute
 
-          expect(merge_request.assignee_id).to be_nil
+          expect(merge_request.assignee_ids).to be_empty
         end
 
         it 'saves assignee when user id is valid' do
           project.add_maintainer(assignee)
-          opts = { title: 'Title', description: 'Description', assignee_id: assignee.id }
+          opts = { title: 'Title', description: 'Description', assignee_ids: [assignee.id] }
 
           merge_request = described_class.new(project, user, opts).execute
 
-          expect(merge_request.assignee).to eq(assignee)
+          expect(merge_request.assignees).to eq([assignee])
         end
 
         context 'when assignee is set' do
@@ -361,7 +361,7 @@ describe MergeRequests::CreateService do
             {
               title: 'Title',
               description: 'Description',
-              assignee_id: assignee.id,
+              assignee_ids: [assignee.id],
               source_branch: 'feature',
               target_branch: 'master'
             }
@@ -387,7 +387,7 @@ describe MergeRequests::CreateService do
           levels.each do |level|
             it "removes not authorized assignee when project is #{Gitlab::VisibilityLevel.level_name(level)}" do
               project.update(visibility_level: level)
-              opts = { title: 'Title', description: 'Description', assignee_id: assignee.id }
+              opts = { title: 'Title', description: 'Description', assignee_ids: [assignee.id] }
 
               merge_request = described_class.new(project, user, opts).execute
 
diff --git a/spec/services/merge_requests/ff_merge_service_spec.rb b/spec/services/merge_requests/ff_merge_service_spec.rb
index 1430e12a07e..a87d8b8752c 100644
--- a/spec/services/merge_requests/ff_merge_service_spec.rb
+++ b/spec/services/merge_requests/ff_merge_service_spec.rb
@@ -7,7 +7,7 @@ describe MergeRequests::FfMergeService do
     create(:merge_request,
            source_branch: 'flatten-dir',
            target_branch: 'improve/awesome',
-           assignee: user2,
+           assignees: [user2],
            author: create(:user))
   end
   let(:project) { merge_request.project }
diff --git a/spec/services/merge_requests/merge_service_spec.rb b/spec/services/merge_requests/merge_service_spec.rb
index 887ec17171e..b0b3273e3dc 100644
--- a/spec/services/merge_requests/merge_service_spec.rb
+++ b/spec/services/merge_requests/merge_service_spec.rb
@@ -3,7 +3,7 @@ require 'spec_helper'
 describe MergeRequests::MergeService do
   set(:user) { create(:user) }
   set(:user2) { create(:user) }
-  let(:merge_request) { create(:merge_request, :simple, author: user2, assignee: user2) }
+  let(:merge_request) { create(:merge_request, :simple, author: user2, assignees: [user2]) }
   let(:project) { merge_request.project }
 
   before do
@@ -111,7 +111,7 @@ describe MergeRequests::MergeService do
     end
 
     context 'closes related todos' do
-      let(:merge_request) { create(:merge_request, assignee: user, author: user) }
+      let(:merge_request) { create(:merge_request, assignees: [user], author: user) }
       let(:project) { merge_request.project }
       let(:service) { described_class.new(project, user, commit_message: 'Awesome message') }
       let!(:todo) do
diff --git a/spec/services/merge_requests/merge_to_ref_service_spec.rb b/spec/services/merge_requests/merge_to_ref_service_spec.rb
index a3b48abae26..24d09c1fd00 100644
--- a/spec/services/merge_requests/merge_to_ref_service_spec.rb
+++ b/spec/services/merge_requests/merge_to_ref_service_spec.rb
@@ -149,7 +149,7 @@ describe MergeRequests::MergeToRefService do
     end
 
     context 'does not close related todos' do
-      let(:merge_request) { create(:merge_request, assignee: user, author: user) }
+      let(:merge_request) { create(:merge_request, assignees: [user], author: user) }
       let(:project) { merge_request.project }
       let!(:todo) do
         create(:todo, :assigned,
diff --git a/spec/services/merge_requests/post_merge_service_spec.rb b/spec/services/merge_requests/post_merge_service_spec.rb
index 5ad6f5528f9..2cebefee5d6 100644
--- a/spec/services/merge_requests/post_merge_service_spec.rb
+++ b/spec/services/merge_requests/post_merge_service_spec.rb
@@ -2,7 +2,7 @@ require 'spec_helper'
 
 describe MergeRequests::PostMergeService do
   let(:user) { create(:user) }
-  let(:merge_request) { create(:merge_request, assignee: user) }
+  let(:merge_request) { create(:merge_request, assignees: [user]) }
   let(:project) { merge_request.project }
 
   before do
diff --git a/spec/services/merge_requests/push_options_handler_service_spec.rb b/spec/services/merge_requests/push_options_handler_service_spec.rb
new file mode 100644
index 00000000000..f7a39bb42d5
--- /dev/null
+++ b/spec/services/merge_requests/push_options_handler_service_spec.rb
@@ -0,0 +1,404 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe MergeRequests::PushOptionsHandlerService do
+  include ProjectForksHelper
+
+  let(:user) { create(:user) }
+  let(:project) { create(:project, :public, :repository) }
+  let(:forked_project) { fork_project(project, user, repository: true) }
+  let(:service) { described_class.new(project, user, changes, push_options) }
+  let(:source_branch) { 'fix' }
+  let(:target_branch) { 'feature' }
+  let(:new_branch_changes) { "#{Gitlab::Git::BLANK_SHA} 570e7b2abdd848b95f2f578043fc23bd6f6fd24d refs/heads/#{source_branch}" }
+  let(:existing_branch_changes) { "d14d6c0abdd253381df51a723d58691b2ee1ab08 570e7b2abdd848b95f2f578043fc23bd6f6fd24d refs/heads/#{source_branch}" }
+  let(:deleted_branch_changes) { "d14d6c0abdd253381df51a723d58691b2ee1ab08 #{Gitlab::Git::BLANK_SHA} refs/heads/#{source_branch}" }
+  let(:default_branch_changes) { "d14d6c0abdd253381df51a723d58691b2ee1ab08 570e7b2abdd848b95f2f578043fc23bd6f6fd24d refs/heads/#{project.default_branch}" }
+
+  before do
+    project.add_developer(user)
+  end
+
+  shared_examples_for 'a service that can create a merge request' do
+    subject(:last_mr) { MergeRequest.last }
+
+    it 'creates a merge request' do
+      expect { service.execute }.to change { MergeRequest.count }.by(1)
+    end
+
+    it 'sets the correct target branch' do
+      branch = push_options[:target] || project.default_branch
+
+      service.execute
+
+      expect(last_mr.target_branch).to eq(branch)
+    end
+
+    it 'assigns the MR to the user' do
+      service.execute
+
+      expect(last_mr.assignees).to contain_exactly(user)
+    end
+
+    context 'when project has been forked' do
+      let(:forked_project) { fork_project(project, user, repository: true) }
+      let(:service) { described_class.new(forked_project, user, changes, push_options) }
+
+      before do
+        allow(forked_project).to receive(:empty_repo?).and_return(false)
+      end
+
+      it 'sets the correct source project' do
+        service.execute
+
+        expect(last_mr.source_project).to eq(forked_project)
+      end
+
+      it 'sets the correct target project' do
+        service.execute
+
+        expect(last_mr.target_project).to eq(project)
+      end
+    end
+  end
+
+  shared_examples_for 'a service that can set the target of a merge request' do
+    subject(:last_mr) { MergeRequest.last }
+
+    it 'sets the target_branch' do
+      service.execute
+
+      expect(last_mr.target_branch).to eq(target_branch)
+    end
+  end
+
+  shared_examples_for 'a service that can set the merge request to merge when pipeline succeeds' do
+    subject(:last_mr) { MergeRequest.last }
+
+    it 'sets merge_when_pipeline_succeeds' do
+      service.execute
+
+      expect(last_mr.merge_when_pipeline_succeeds).to eq(true)
+    end
+
+    it 'sets merge_user to the user' do
+      service.execute
+
+      expect(last_mr.merge_user).to eq(user)
+    end
+  end
+
+  shared_examples_for 'a service that does not create a merge request' do
+    it do
+      expect { service.execute }.not_to change { MergeRequest.count }
+    end
+  end
+
+  shared_examples_for 'a service that does not update a merge request' do
+    it do
+      expect { service.execute }.not_to change { MergeRequest.maximum(:updated_at) }
+    end
+  end
+
+  shared_examples_for 'a service that does nothing' do
+    include_examples 'a service that does not create a merge request'
+    include_examples 'a service that does not update a merge request'
+  end
+
+  describe '`create` push option' do
+    let(:push_options) { { create: true } }
+
+    context 'with a new branch' do
+      let(:changes) { new_branch_changes }
+
+      it_behaves_like 'a service that can create a merge request'
+    end
+
+    context 'with an existing branch but no open MR' do
+      let(:changes) { existing_branch_changes }
+
+      it_behaves_like 'a service that can create a merge request'
+    end
+
+    context 'with an existing branch that has a merge request open' do
+      let(:changes) { existing_branch_changes }
+      let!(:merge_request) { create(:merge_request, source_project: project, source_branch: source_branch)}
+
+      it_behaves_like 'a service that does not create a merge request'
+    end
+
+    context 'with a deleted branch' do
+      let(:changes) { deleted_branch_changes }
+
+      it_behaves_like 'a service that does nothing'
+    end
+
+    context 'with the project default branch' do
+      let(:changes) { default_branch_changes }
+
+      it_behaves_like 'a service that does nothing'
+    end
+  end
+
+  describe '`merge_when_pipeline_succeeds` push option' do
+    let(:push_options) { { merge_when_pipeline_succeeds: true } }
+
+    context 'with a new branch' do
+      let(:changes) { new_branch_changes }
+
+      it_behaves_like 'a service that does not create a merge request'
+
+      it 'adds an error to the service' do
+        error = "A merge_request.create push option is required to create a merge request for branch #{source_branch}"
+
+        service.execute
+
+        expect(service.errors).to include(error)
+      end
+
+      context 'when coupled with the `create` push option' do
+        let(:push_options) { { create: true, merge_when_pipeline_succeeds: true } }
+
+        it_behaves_like 'a service that can create a merge request'
+        it_behaves_like 'a service that can set the merge request to merge when pipeline succeeds'
+      end
+    end
+
+    context 'with an existing branch but no open MR' do
+      let(:changes) { existing_branch_changes }
+
+      it_behaves_like 'a service that does not create a merge request'
+
+      it 'adds an error to the service' do
+        error = "A merge_request.create push option is required to create a merge request for branch #{source_branch}"
+
+        service.execute
+
+        expect(service.errors).to include(error)
+      end
+
+      context 'when coupled with the `create` push option' do
+        let(:push_options) { { create: true, merge_when_pipeline_succeeds: true } }
+
+        it_behaves_like 'a service that can create a merge request'
+        it_behaves_like 'a service that can set the merge request to merge when pipeline succeeds'
+      end
+    end
+
+    context 'with an existing branch that has a merge request open' do
+      let(:changes) { existing_branch_changes }
+      let!(:merge_request) { create(:merge_request, source_project: project, source_branch: source_branch)}
+
+      it_behaves_like 'a service that does not create a merge request'
+      it_behaves_like 'a service that can set the merge request to merge when pipeline succeeds'
+    end
+
+    context 'with a deleted branch' do
+      let(:changes) { deleted_branch_changes }
+
+      it_behaves_like 'a service that does nothing'
+    end
+
+    context 'with the project default branch' do
+      let(:changes) { default_branch_changes }
+
+      it_behaves_like 'a service that does nothing'
+    end
+  end
+
+  describe '`target` push option' do
+    let(:push_options) { { target: target_branch } }
+
+    context 'with a new branch' do
+      let(:changes) { new_branch_changes }
+
+      it_behaves_like 'a service that does not create a merge request'
+
+      it 'adds an error to the service' do
+        error = "A merge_request.create push option is required to create a merge request for branch #{source_branch}"
+
+        service.execute
+
+        expect(service.errors).to include(error)
+      end
+
+      context 'when coupled with the `create` push option' do
+        let(:push_options) { { create: true, target: target_branch } }
+
+        it_behaves_like 'a service that can create a merge request'
+        it_behaves_like 'a service that can set the target of a merge request'
+      end
+    end
+
+    context 'with an existing branch but no open MR' do
+      let(:changes) { existing_branch_changes }
+
+      it_behaves_like 'a service that does not create a merge request'
+
+      it 'adds an error to the service' do
+        error = "A merge_request.create push option is required to create a merge request for branch #{source_branch}"
+
+        service.execute
+
+        expect(service.errors).to include(error)
+      end
+
+      context 'when coupled with the `create` push option' do
+        let(:push_options) { { create: true, target: target_branch } }
+
+        it_behaves_like 'a service that can create a merge request'
+        it_behaves_like 'a service that can set the target of a merge request'
+      end
+    end
+
+    context 'with an existing branch that has a merge request open' do
+      let(:changes) { existing_branch_changes }
+      let!(:merge_request) { create(:merge_request, source_project: project, source_branch: source_branch)}
+
+      it_behaves_like 'a service that does not create a merge request'
+      it_behaves_like 'a service that can set the target of a merge request'
+    end
+
+    context 'with a deleted branch' do
+      let(:changes) { deleted_branch_changes }
+
+      it_behaves_like 'a service that does nothing'
+    end
+
+    context 'with the project default branch' do
+      let(:changes) { default_branch_changes }
+
+      it_behaves_like 'a service that does nothing'
+    end
+  end
+
+  describe 'multiple pushed branches' do
+    let(:push_options) { { create: true } }
+    let(:changes) do
+      [
+        new_branch_changes,
+        "#{Gitlab::Git::BLANK_SHA} 570e7b2abdd848b95f2f578043fc23bd6f6fd24d refs/heads/feature_conflict"
+      ]
+    end
+
+    it 'creates a merge request per branch' do
+      expect { service.execute }.to change { MergeRequest.count }.by(2)
+    end
+
+    context 'when there are too many pushed branches' do
+      let(:limit) { MergeRequests::PushOptionsHandlerService::LIMIT }
+      let(:changes) do
+        TestEnv::BRANCH_SHA.to_a[0..limit].map do |x|
+          "#{Gitlab::Git::BLANK_SHA} #{x.first} refs/heads/#{x.last}"
+        end
+      end
+
+      it 'records an error' do
+        service.execute
+
+        expect(service.errors).to eq(["Too many branches pushed (#{limit + 1} were pushed, limit is #{limit})"])
+      end
+    end
+  end
+
+  describe 'no push options' do
+    let(:push_options) { {} }
+    let(:changes) { new_branch_changes }
+
+    it_behaves_like 'a service that does nothing'
+  end
+
+  describe 'no user' do
+    let(:user) { nil }
+    let(:push_options) { { create: true } }
+    let(:changes) { new_branch_changes }
+
+    it 'records an error' do
+      service.execute
+
+      expect(service.errors).to eq(['User is required'])
+    end
+  end
+
+  describe 'unauthorized user' do
+    let(:push_options) { { create: true } }
+    let(:changes) { new_branch_changes }
+
+    it 'records an error' do
+      Members::DestroyService.new(user).execute(ProjectMember.find_by!(user_id: user.id))
+
+      service.execute
+
+      expect(service.errors).to eq(['User access was denied'])
+    end
+  end
+
+  describe 'handling unexpected exceptions' do
+    let(:push_options) { { create: true } }
+    let(:changes) { new_branch_changes }
+    let(:exception) { StandardError.new('My standard error') }
+
+    def run_service_with_exception
+      allow_any_instance_of(
+        MergeRequests::BuildService
+      ).to receive(:execute).and_raise(exception)
+
+      service.execute
+    end
+
+    it 'records an error' do
+      run_service_with_exception
+
+      expect(service.errors).to eq(['An unknown error occurred'])
+    end
+
+    it 'writes to Gitlab::AppLogger' do
+      expect(Gitlab::AppLogger).to receive(:error).with(exception)
+
+      run_service_with_exception
+    end
+  end
+
+  describe 'when target is not a valid branch name' do
+    let(:push_options) { { create: true, target: 'my-branch' } }
+    let(:changes) { new_branch_changes }
+
+    it 'records an error' do
+      service.execute
+
+      expect(service.errors).to eq(['Branch my-branch does not exist'])
+    end
+  end
+
+  describe 'when MRs are not enabled' do
+    let(:push_options) { { create: true } }
+    let(:changes) { new_branch_changes }
+
+    it 'records an error' do
+      expect(project).to receive(:merge_requests_enabled?).and_return(false)
+
+      service.execute
+
+      expect(service.errors).to eq(["Merge requests are not enabled for project #{project.full_path}"])
+    end
+  end
+
+  describe 'when MR has ActiveRecord errors' do
+    let(:push_options) { { create: true } }
+    let(:changes) { new_branch_changes }
+
+    it 'adds the error to its errors property' do
+      invalid_merge_request = MergeRequest.new
+      invalid_merge_request.errors.add(:base, 'my error')
+
+      expect_any_instance_of(
+        MergeRequests::CreateService
+      ).to receive(:execute).and_return(invalid_merge_request)
+
+      service.execute
+
+      expect(service.errors).to eq(['my error'])
+    end
+  end
+end
diff --git a/spec/services/merge_requests/refresh_service_spec.rb b/spec/services/merge_requests/refresh_service_spec.rb
index bd10523bc94..5ed06df7072 100644
--- a/spec/services/merge_requests/refresh_service_spec.rb
+++ b/spec/services/merge_requests/refresh_service_spec.rb
@@ -146,7 +146,10 @@ describe MergeRequests::RefreshService do
         stub_ci_pipeline_yaml_file(YAML.dump(config))
       end
 
-      subject { service.new(@project, @user).execute(@oldrev, @newrev, 'refs/heads/master') }
+      subject { service.new(project, @user).execute(@oldrev, @newrev, ref) }
+
+      let(:ref) { 'refs/heads/master' }
+      let(:project) { @project }
 
       context "when .gitlab-ci.yml has merge_requests keywords" do
         let(:config) do
@@ -162,14 +165,17 @@ describe MergeRequests::RefreshService do
         it 'create detached merge request pipeline with commits' do
           expect { subject }
             .to change { @merge_request.merge_request_pipelines.count }.by(1)
-            .and change { @fork_merge_request.merge_request_pipelines.count }.by(1)
             .and change { @another_merge_request.merge_request_pipelines.count }.by(0)
 
           expect(@merge_request.has_commits?).to be_truthy
-          expect(@fork_merge_request.has_commits?).to be_truthy
           expect(@another_merge_request.has_commits?).to be_falsy
         end
 
+        it 'does not create detached merge request pipeline for forked project' do
+          expect { subject }
+            .not_to change { @fork_merge_request.merge_request_pipelines.count }
+        end
+
         it 'create detached merge request pipeline for non-fork merge request' do
           subject
 
@@ -177,11 +183,25 @@ describe MergeRequests::RefreshService do
             .to be_detached_merge_request_pipeline
         end
 
-        it 'create legacy detached merge request pipeline for fork merge request' do
-          subject
+        context 'when service is hooked by target branch' do
+          let(:ref) { 'refs/heads/feature' }
 
-          expect(@fork_merge_request.merge_request_pipelines.first)
-            .to be_legacy_detached_merge_request_pipeline
+          it 'does not create detached merge request pipeline' do
+            expect { subject }
+              .not_to change { @merge_request.merge_request_pipelines.count }
+          end
+        end
+
+        context 'when service runs on forked project' do
+          let(:project) { @fork_project }
+
+          it 'creates legacy detached merge request pipeline for fork merge request' do
+            expect { subject }
+              .to change { @fork_merge_request.merge_request_pipelines.count }.by(1)
+
+            expect(@fork_merge_request.merge_request_pipelines.first)
+              .to be_legacy_detached_merge_request_pipeline
+          end
         end
 
         context 'when ci_use_merge_request_ref feature flag is false' do
diff --git a/spec/services/merge_requests/reopen_service_spec.rb b/spec/services/merge_requests/reopen_service_spec.rb
index 21e71509ed6..8b6db1ce33e 100644
--- a/spec/services/merge_requests/reopen_service_spec.rb
+++ b/spec/services/merge_requests/reopen_service_spec.rb
@@ -4,7 +4,7 @@ describe MergeRequests::ReopenService do
   let(:user) { create(:user) }
   let(:user2) { create(:user) }
   let(:guest) { create(:user) }
-  let(:merge_request) { create(:merge_request, :closed, assignee: user2, author: create(:user)) }
+  let(:merge_request) { create(:merge_request, :closed, assignees: [user2], author: create(:user)) }
   let(:project) { merge_request.project }
 
   before do
diff --git a/spec/services/merge_requests/update_service_spec.rb b/spec/services/merge_requests/update_service_spec.rb
index 8e367db031c..0525899ebfa 100644
--- a/spec/services/merge_requests/update_service_spec.rb
+++ b/spec/services/merge_requests/update_service_spec.rb
@@ -13,7 +13,7 @@ describe MergeRequests::UpdateService, :mailer do
   let(:merge_request) do
     create(:merge_request, :simple, title: 'Old title',
                                     description: "FYI #{user2.to_reference}",
-                                    assignee_id: user3.id,
+                                    assignee_ids: [user3.id],
                                     source_project: project,
                                     author: create(:user))
   end
@@ -48,7 +48,7 @@ describe MergeRequests::UpdateService, :mailer do
         {
           title: 'New title',
           description: 'Also please fix',
-          assignee_id: user2.id,
+          assignee_ids: [user.id],
           state_event: 'close',
           label_ids: [label.id],
           target_branch: 'target',
@@ -71,7 +71,7 @@ describe MergeRequests::UpdateService, :mailer do
       it 'matches base expectations' do
         expect(@merge_request).to be_valid
         expect(@merge_request.title).to eq('New title')
-        expect(@merge_request.assignee).to eq(user2)
+        expect(@merge_request.assignees).to match_array([user])
         expect(@merge_request).to be_closed
         expect(@merge_request.labels.count).to eq(1)
         expect(@merge_request.labels.first.title).to eq(label.name)
@@ -106,7 +106,7 @@ describe MergeRequests::UpdateService, :mailer do
         note = find_note('assigned to')
 
         expect(note).not_to be_nil
-        expect(note.note).to include "assigned to #{user2.to_reference}"
+        expect(note.note).to include "assigned to #{user.to_reference} and unassigned #{user3.to_reference}"
       end
 
       it 'creates a resource label event' do
@@ -293,7 +293,7 @@ describe MergeRequests::UpdateService, :mailer do
 
       context 'when is reassigned' do
         before do
-          update_merge_request({ assignee: user2 })
+          update_merge_request({ assignee_ids: [user2.id] })
         end
 
         it 'marks previous assignee pending todos as done' do
@@ -387,7 +387,7 @@ describe MergeRequests::UpdateService, :mailer do
 
       context 'when the assignee changes' do
         it 'updates open merge request counter for assignees when merge request is reassigned' do
-          update_merge_request(assignee_id: user2.id)
+          update_merge_request(assignee_ids: [user2.id])
 
           expect(user3.assigned_open_merge_requests_count).to eq 0
           expect(user2.assigned_open_merge_requests_count).to eq 1
@@ -541,36 +541,36 @@ describe MergeRequests::UpdateService, :mailer do
       end
     end
 
-    context 'updating asssignee_id' do
+    context 'updating asssignee_ids' do
       it 'does not update assignee when assignee_id is invalid' do
-        merge_request.update(assignee_id: user.id)
+        merge_request.update(assignee_ids: [user.id])
 
-        update_merge_request(assignee_id: -1)
+        update_merge_request(assignee_ids: [-1])
 
-        expect(merge_request.reload.assignee).to eq(user)
+        expect(merge_request.reload.assignees).to eq([user])
       end
 
       it 'unassigns assignee when user id is 0' do
-        merge_request.update(assignee_id: user.id)
+        merge_request.update(assignee_ids: [user.id])
 
-        update_merge_request(assignee_id: 0)
+        update_merge_request(assignee_ids: [0])
 
-        expect(merge_request.assignee_id).to be_nil
+        expect(merge_request.assignee_ids).to be_empty
       end
 
       it 'saves assignee when user id is valid' do
-        update_merge_request(assignee_id: user.id)
+        update_merge_request(assignee_ids: [user.id])
 
-        expect(merge_request.assignee_id).to eq(user.id)
+        expect(merge_request.assignee_ids).to eq([user.id])
       end
 
       it 'does not update assignee_id when user cannot read issue' do
-        non_member        = create(:user)
-        original_assignee = merge_request.assignee
+        non_member = create(:user)
+        original_assignees = merge_request.assignees
 
-        update_merge_request(assignee_id: non_member.id)
+        update_merge_request(assignee_ids: [non_member.id])
 
-        expect(merge_request.assignee_id).to eq(original_assignee.id)
+        expect(merge_request.reload.assignees).to eq(original_assignees)
       end
 
       context "when issuable feature is private" do
@@ -583,7 +583,7 @@ describe MergeRequests::UpdateService, :mailer do
             feature_visibility_attr = :"#{merge_request.model_name.plural}_access_level"
             project.project_feature.update_attribute(feature_visibility_attr, ProjectFeature::PRIVATE)
 
-            expect { update_merge_request(assignee_id: assignee) }.not_to change { merge_request.assignee }
+            expect { update_merge_request(assignee_ids: [assignee]) }.not_to change { merge_request.reload.assignees }
           end
         end
       end
@@ -619,7 +619,7 @@ describe MergeRequests::UpdateService, :mailer do
       end
 
       it 'is allowed by a user that can push to the source and can update the merge request' do
-        merge_request.update!(assignee: user)
+        merge_request.update!(assignees: [user])
         source_project.add_developer(user)
 
         update_merge_request(allow_collaboration: true, title: 'Updated title')
diff --git a/spec/services/note_summary_spec.rb b/spec/services/note_summary_spec.rb
index a6cc2251e48..f6ee15f750c 100644
--- a/spec/services/note_summary_spec.rb
+++ b/spec/services/note_summary_spec.rb
@@ -21,16 +21,20 @@ describe NoteSummary do
 
   describe '#note' do
     it 'returns note hash' do
-      expect(create_note_summary.note).to eq(noteable: noteable, project: project, author: user, note: 'note')
+      Timecop.freeze do
+        expect(create_note_summary.note).to eq(noteable: noteable, project: project, author: user, note: 'note',
+                                               created_at: Time.now)
+      end
     end
 
     context 'when noteable is a commit' do
-      let(:noteable) { build(:commit) }
+      let(:noteable) { build(:commit, system_note_timestamp: Time.at(43)) }
 
       it 'returns note hash specific to commit' do
         expect(create_note_summary.note).to eq(
           noteable: nil, project: project, author: user, note: 'note',
-          noteable_type: 'Commit', commit_id: noteable.id
+          noteable_type: 'Commit', commit_id: noteable.id,
+          created_at: Time.at(43)
         )
       end
     end
diff --git a/spec/services/notification_service_spec.rb b/spec/services/notification_service_spec.rb
index 9ba4a11104a..ac4aabf3fbd 100644
--- a/spec/services/notification_service_spec.rb
+++ b/spec/services/notification_service_spec.rb
@@ -2,6 +2,7 @@ require 'spec_helper'
 
 describe NotificationService, :mailer do
   include EmailSpec::Matchers
+  include ExternalAuthorizationServiceHelpers
   include NotificationHelpers
 
   let(:notification) { described_class.new }
@@ -125,11 +126,7 @@ describe NotificationService, :mailer do
 
   shared_examples 'participating by assignee notification' do
     it 'emails the participant' do
-      if issuable.is_a?(Issue)
-        issuable.assignees << participant
-      else
-        issuable.update_attribute(:assignee, participant)
-      end
+      issuable.assignees << participant
 
       notification_trigger
 
@@ -620,13 +617,13 @@ describe NotificationService, :mailer do
     context "merge request diff note" do
       let(:project) { create(:project, :repository) }
       let(:user) { create(:user) }
-      let(:merge_request) { create(:merge_request, source_project: project, assignee: user, author: create(:user)) }
+      let(:merge_request) { create(:merge_request, source_project: project, assignees: [user], author: create(:user)) }
       let(:note) { create(:diff_note_on_merge_request, project: project, noteable: merge_request) }
 
       before do
         build_team(note.project)
         project.add_maintainer(merge_request.author)
-        project.add_maintainer(merge_request.assignee)
+        merge_request.assignees.each { |assignee| project.add_maintainer(assignee) }
       end
 
       describe '#new_note' do
@@ -637,7 +634,7 @@ describe NotificationService, :mailer do
           notification.new_note(note)
 
           expect(SentNotification.last(3).map(&:recipient).map(&:id))
-            .to contain_exactly(merge_request.assignee.id, merge_request.author.id, @u_watcher.id)
+            .to contain_exactly(*merge_request.assignees.pluck(:id), merge_request.author.id, @u_watcher.id)
           expect(SentNotification.last.in_reply_to_discussion_id).to eq(note.discussion_id)
         end
       end
@@ -1223,11 +1220,12 @@ describe NotificationService, :mailer do
     let(:group) { create(:group) }
     let(:project) { create(:project, :public, :repository, namespace: group) }
     let(:another_project) { create(:project, :public, namespace: group) }
-    let(:merge_request) { create :merge_request, source_project: project, assignee: create(:user), description: 'cc @participant' }
+    let(:assignee) { create(:user) }
+    let(:merge_request) { create :merge_request, source_project: project, assignees: [assignee], description: 'cc @participant' }
 
     before do
       project.add_maintainer(merge_request.author)
-      project.add_maintainer(merge_request.assignee)
+      merge_request.assignees.each { |assignee| project.add_maintainer(assignee) }
       build_team(merge_request.target_project)
       add_users_with_subscription(merge_request.target_project, merge_request)
       update_custom_notification(:new_merge_request, @u_guest_custom, resource: project)
@@ -1239,7 +1237,7 @@ describe NotificationService, :mailer do
       it do
         notification.new_merge_request(merge_request, @u_disabled)
 
-        should_email(merge_request.assignee)
+        merge_request.assignees.each { |assignee| should_email(assignee) }
         should_email(@u_watcher)
         should_email(@watcher_and_subscriber)
         should_email(@u_participant_mentioned)
@@ -1254,9 +1252,11 @@ describe NotificationService, :mailer do
       it 'adds "assigned" reason for assignee, if any' do
         notification.new_merge_request(merge_request, @u_disabled)
 
-        email = find_email_for(merge_request.assignee)
+        merge_request.assignees.each do |assignee|
+          email = find_email_for(assignee)
 
-        expect(email).to have_header('X-GitLab-NotificationReason', NotificationReason::ASSIGNED)
+          expect(email).to have_header('X-GitLab-NotificationReason', NotificationReason::ASSIGNED)
+        end
       end
 
       it "emails any mentioned users with the mention level" do
@@ -1347,9 +1347,9 @@ describe NotificationService, :mailer do
       end
 
       it do
-        notification.reassigned_merge_request(merge_request, current_user, merge_request.author)
+        notification.reassigned_merge_request(merge_request, current_user, [assignee])
 
-        should_email(merge_request.assignee)
+        merge_request.assignees.each { |assignee| should_email(assignee) }
         should_email(merge_request.author)
         should_email(@u_watcher)
         should_email(@u_participant_mentioned)
@@ -1365,17 +1365,19 @@ describe NotificationService, :mailer do
       end
 
       it 'adds "assigned" reason for new assignee' do
-        notification.reassigned_merge_request(merge_request, current_user, merge_request.author)
+        notification.reassigned_merge_request(merge_request, current_user, [assignee])
 
-        email = find_email_for(merge_request.assignee)
+        merge_request.assignees.each do |assignee|
+          email = find_email_for(assignee)
 
-        expect(email).to have_header('X-GitLab-NotificationReason', NotificationReason::ASSIGNED)
+          expect(email).to have_header('X-GitLab-NotificationReason', NotificationReason::ASSIGNED)
+        end
       end
 
       it_behaves_like 'participating notifications' do
         let(:participant) { create(:user, username: 'user-participant') }
         let(:issuable) { merge_request }
-        let(:notification_trigger) { notification.reassigned_merge_request(merge_request, current_user, merge_request.author) }
+        let(:notification_trigger) { notification.reassigned_merge_request(merge_request, current_user, [assignee]) }
       end
     end
 
@@ -1388,7 +1390,7 @@ describe NotificationService, :mailer do
       it do
         notification.push_to_merge_request(merge_request, @u_disabled)
 
-        should_email(merge_request.assignee)
+        merge_request.assignees.each { |assignee| should_email(assignee) }
         should_email(@u_guest_custom)
         should_email(@u_custom_global)
         should_email(@u_participant_mentioned)
@@ -1430,7 +1432,7 @@ describe NotificationService, :mailer do
         should_email(subscriber_1_to_group_label_2)
         should_email(subscriber_2_to_group_label_2)
         should_email(subscriber_to_label_2)
-        should_not_email(merge_request.assignee)
+        merge_request.assignees.each { |assignee| should_not_email(assignee) }
         should_not_email(merge_request.author)
         should_not_email(@u_watcher)
         should_not_email(@u_participant_mentioned)
@@ -1499,7 +1501,7 @@ describe NotificationService, :mailer do
       it do
         notification.close_mr(merge_request, @u_disabled)
 
-        should_email(merge_request.assignee)
+        merge_request.assignees.each { |assignee| should_email(assignee) }
         should_email(@u_watcher)
         should_email(@u_guest_watcher)
         should_email(@u_guest_custom)
@@ -1529,7 +1531,7 @@ describe NotificationService, :mailer do
       it do
         notification.merge_mr(merge_request, @u_disabled)
 
-        should_email(merge_request.assignee)
+        merge_request.assignees.each { |assignee| should_email(assignee) }
         should_email(@u_watcher)
         should_email(@u_guest_watcher)
         should_email(@u_guest_custom)
@@ -1581,7 +1583,7 @@ describe NotificationService, :mailer do
       it do
         notification.reopen_mr(merge_request, @u_disabled)
 
-        should_email(merge_request.assignee)
+        merge_request.assignees.each { |assignee| should_email(assignee) }
         should_email(@u_watcher)
         should_email(@u_participant_mentioned)
         should_email(@subscriber)
@@ -1606,7 +1608,7 @@ describe NotificationService, :mailer do
       it do
         notification.resolve_all_discussions(merge_request, @u_disabled)
 
-        should_email(merge_request.assignee)
+        merge_request.assignees.each { |assignee| should_email(assignee) }
         should_email(@u_watcher)
         should_email(@u_participant_mentioned)
         should_email(@subscriber)
@@ -1850,8 +1852,8 @@ describe NotificationService, :mailer do
     let(:guest) { create(:user) }
     let(:developer) { create(:user) }
     let(:assignee) { create(:user) }
-    let(:merge_request) { create(:merge_request, source_project: private_project, assignee: assignee) }
-    let(:merge_request1) { create(:merge_request, source_project: private_project, assignee: assignee, description: "cc @#{guest.username}") }
+    let(:merge_request) { create(:merge_request, source_project: private_project, assignees: [assignee]) }
+    let(:merge_request1) { create(:merge_request, source_project: private_project, assignees: [assignee], description: "cc @#{guest.username}") }
     let(:note) { create(:note, noteable: merge_request, project: private_project) }
 
     before do
@@ -2217,6 +2219,46 @@ describe NotificationService, :mailer do
     end
   end
 
+  context 'with external authorization service' do
+    let(:issue) { create(:issue) }
+    let(:project) { issue.project }
+    let(:note) { create(:note, noteable: issue, project: project) }
+    let(:member) { create(:user) }
+
+    subject { NotificationService.new }
+
+    before do
+      project.add_maintainer(member)
+      member.global_notification_setting.update!(level: :watch)
+    end
+
+    it 'sends email when the service is not enabled' do
+      expect(Notify).to receive(:new_issue_email).at_least(:once).with(member.id, issue.id, nil).and_call_original
+
+      subject.new_issue(issue, member)
+    end
+
+    context 'when the service is enabled' do
+      before do
+        enable_external_authorization_service_check
+      end
+
+      it 'does not send an email' do
+        expect(Notify).not_to receive(:new_issue_email)
+
+        subject.new_issue(issue, member)
+      end
+
+      it 'still delivers email to admins' do
+        member.update!(admin: true)
+
+        expect(Notify).to receive(:new_issue_email).at_least(:once).with(member.id, issue.id, nil).and_call_original
+
+        subject.new_issue(issue, member)
+      end
+    end
+  end
+
   def build_team(project)
     @u_watcher               = create_global_setting_for(create(:user), :watch)
     @u_participating         = create_global_setting_for(create(:user), :participating)
diff --git a/spec/services/projects/create_service_spec.rb b/spec/services/projects/create_service_spec.rb
index e8418b09dc2..e1ec932918e 100644
--- a/spec/services/projects/create_service_spec.rb
+++ b/spec/services/projects/create_service_spec.rb
@@ -1,6 +1,7 @@
 require 'spec_helper'
 
 describe Projects::CreateService, '#execute' do
+  include ExternalAuthorizationServiceHelpers
   include GitHelpers
 
   let(:gitlab_shell) { Gitlab::Shell.new }
@@ -344,6 +345,42 @@ describe Projects::CreateService, '#execute' do
     expect(rugged.config['gitlab.fullpath']).to eq project.full_path
   end
 
+  context 'with external authorization enabled' do
+    before do
+      enable_external_authorization_service_check
+    end
+
+    it 'does not save the project with an error if the service denies access' do
+      expect(::Gitlab::ExternalAuthorization)
+        .to receive(:access_allowed?).with(user, 'new-label', any_args) { false }
+
+      project = create_project(user, opts.merge({ external_authorization_classification_label: 'new-label' }))
+
+      expect(project.errors[:external_authorization_classification_label]).to be_present
+      expect(project).not_to be_persisted
+    end
+
+    it 'saves the project when the user has access to the label' do
+      expect(::Gitlab::ExternalAuthorization)
+        .to receive(:access_allowed?).with(user, 'new-label', any_args) { true }
+
+      project = create_project(user, opts.merge({ external_authorization_classification_label: 'new-label' }))
+
+      expect(project).to be_persisted
+      expect(project.external_authorization_classification_label).to eq('new-label')
+    end
+
+    it 'does not save the project when the user has no access to the default label and no label is provided' do
+      expect(::Gitlab::ExternalAuthorization)
+        .to receive(:access_allowed?).with(user, 'default_label', any_args) { false }
+
+      project = create_project(user, opts)
+
+      expect(project.errors[:external_authorization_classification_label]).to be_present
+      expect(project).not_to be_persisted
+    end
+  end
+
   def create_project(user, opts)
     Projects::CreateService.new(user, opts).execute
   end
diff --git a/spec/services/projects/update_service_spec.rb b/spec/services/projects/update_service_spec.rb
index 90eaea9c872..95eb17b5e3a 100644
--- a/spec/services/projects/update_service_spec.rb
+++ b/spec/services/projects/update_service_spec.rb
@@ -1,6 +1,7 @@
 require 'spec_helper'
 
 describe Projects::UpdateService do
+  include ExternalAuthorizationServiceHelpers
   include ProjectForksHelper
 
   let(:user) { create(:user) }
@@ -361,6 +362,46 @@ describe Projects::UpdateService do
         call_service
       end
     end
+
+    context 'with external authorization enabled' do
+      before do
+        enable_external_authorization_service_check
+      end
+
+      it 'does not save the project with an error if the service denies access' do
+        expect(::Gitlab::ExternalAuthorization)
+          .to receive(:access_allowed?).with(user, 'new-label') { false }
+
+        result = update_project(project, user, { external_authorization_classification_label: 'new-label' })
+
+        expect(result[:message]).to be_present
+        expect(result[:status]).to eq(:error)
+      end
+
+      it 'saves the new label if the service allows access' do
+        expect(::Gitlab::ExternalAuthorization)
+          .to receive(:access_allowed?).with(user, 'new-label') { true }
+
+        result = update_project(project, user, { external_authorization_classification_label: 'new-label' })
+
+        expect(result[:status]).to eq(:success)
+        expect(project.reload.external_authorization_classification_label).to eq('new-label')
+      end
+
+      it 'checks the default label when the classification label was cleared' do
+        expect(::Gitlab::ExternalAuthorization)
+          .to receive(:access_allowed?).with(user, 'default_label') { true }
+
+        update_project(project, user, { external_authorization_classification_label: '' })
+      end
+
+      it 'does not check the label when it does not change' do
+        expect(::Gitlab::ExternalAuthorization)
+          .not_to receive(:access_allowed?)
+
+        update_project(project, user, { name: 'New name' })
+      end
+    end
   end
 
   describe '#run_auto_devops_pipeline?' do
diff --git a/spec/services/projects/update_statistics_service_spec.rb b/spec/services/projects/update_statistics_service_spec.rb
new file mode 100644
index 00000000000..7e351c9ce54
--- /dev/null
+++ b/spec/services/projects/update_statistics_service_spec.rb
@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+describe Projects::UpdateStatisticsService do
+  let(:service) { described_class.new(project, nil, statistics: statistics)}
+  let(:statistics) { %w(repository_size) }
+
+  describe '#execute' do
+    context 'with a non-existing project' do
+      let(:project) { nil }
+
+      it 'does nothing' do
+        expect_any_instance_of(ProjectStatistics).not_to receive(:refresh!)
+
+        service.execute
+      end
+    end
+
+    context 'with an existing project without a repository' do
+      let(:project) { create(:project) }
+
+      it 'does nothing' do
+        expect_any_instance_of(ProjectStatistics).not_to receive(:refresh!)
+
+        service.execute
+      end
+    end
+
+    context 'with an existing project with a repository' do
+      let(:project) { create(:project, :repository) }
+
+      it 'refreshes the project statistics' do
+        expect_any_instance_of(ProjectStatistics).to receive(:refresh!)
+          .with(only: statistics.map(&:to_sym))
+          .and_call_original
+
+        service.execute
+      end
+    end
+  end
+end
diff --git a/spec/services/quick_actions/interpret_service_spec.rb b/spec/services/quick_actions/interpret_service_spec.rb
index c7e5cca324f..95a131e8c86 100644
--- a/spec/services/quick_actions/interpret_service_spec.rb
+++ b/spec/services/quick_actions/interpret_service_spec.rb
@@ -16,7 +16,9 @@ describe QuickActions::InterpretService do
   let(:service) { described_class.new(project, developer) }
 
   before do
-    stub_licensed_features(multiple_issue_assignees: false)
+    stub_licensed_features(multiple_issue_assignees: false,
+                           multiple_merge_request_assignees: false)
+
     project.add_developer(developer)
   end
 
@@ -527,7 +529,7 @@ describe QuickActions::InterpretService do
         let(:issuable) { issue }
       end
 
-      it_behaves_like 'assign command' do
+      it_behaves_like 'assign command', :quarantine do
         let(:content) { "/assign @#{developer.username} @#{developer2.username}" }
         let(:issuable) { merge_request }
       end
diff --git a/spec/services/releases/create_service_spec.rb b/spec/services/releases/create_service_spec.rb
index 612e9f152e7..0efe37f1167 100644
--- a/spec/services/releases/create_service_spec.rb
+++ b/spec/services/releases/create_service_spec.rb
@@ -19,6 +19,8 @@ describe Releases::CreateService do
     shared_examples 'a successful release creation' do
       it 'creates a new release' do
         result = service.execute
+
+        expect(project.releases.count).to eq(1)
         expect(result[:status]).to eq(:success)
         expect(result[:tag]).not_to be_nil
         expect(result[:release]).not_to be_nil
@@ -69,4 +71,12 @@ describe Releases::CreateService do
       end
     end
   end
+
+  describe '#find_or_build_release' do
+    it 'does not save the built release' do
+      service.find_or_build_release
+
+      expect(project.releases.count).to eq(0)
+    end
+  end
 end
diff --git a/spec/services/system_note_service_spec.rb b/spec/services/system_note_service_spec.rb
index b917de14b2e..51c5a803dbd 100644
--- a/spec/services/system_note_service_spec.rb
+++ b/spec/services/system_note_service_spec.rb
@@ -1,6 +1,9 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe SystemNoteService do
+  include ProjectForksHelper
   include Gitlab::Routing
   include RepoHelpers
   include AssetsHelpers
@@ -11,6 +14,14 @@ describe SystemNoteService do
   let(:noteable) { create(:issue, project: project) }
   let(:issue)    { noteable }
 
+  shared_examples_for 'a note with overridable created_at' do
+    let(:noteable) { create(:issue, project: project, system_note_timestamp: Time.at(42)) }
+
+    it 'the note has the correct time' do
+      expect(subject.created_at).to eq Time.at(42)
+    end
+  end
+
   shared_examples_for 'a system note' do
     let(:expected_noteable) { noteable }
     let(:commit_count)      { nil }
@@ -137,6 +148,8 @@ describe SystemNoteService do
     end
 
     context 'when assignee added' do
+      it_behaves_like 'a note with overridable created_at'
+
       it 'sets the note text' do
         expect(subject.note).to eq "assigned to @#{assignee.username}"
       end
@@ -145,14 +158,16 @@ describe SystemNoteService do
     context 'when assignee removed' do
       let(:assignee) { nil }
 
+      it_behaves_like 'a note with overridable created_at'
+
       it 'sets the note text' do
         expect(subject.note).to eq 'removed assignee'
       end
     end
   end
 
-  describe '.change_issue_assignees' do
-    subject { described_class.change_issue_assignees(noteable, project, author, [assignee]) }
+  describe '.change_issuable_assignees' do
+    subject { described_class.change_issuable_assignees(noteable, project, author, [assignee]) }
 
     let(:assignee) { create(:user) }
     let(:assignee1) { create(:user) }
@@ -165,9 +180,11 @@ describe SystemNoteService do
 
     def build_note(old_assignees, new_assignees)
       issue.assignees = new_assignees
-      described_class.change_issue_assignees(issue, project, author, old_assignees).note
+      described_class.change_issuable_assignees(issue, project, author, old_assignees).note
     end
 
+    it_behaves_like 'a note with overridable created_at'
+
     it 'builds a correct phrase when an assignee is added to a non-assigned issue' do
       expect(build_note([], [assignee1])).to eq "assigned to @#{assignee1.username}"
     end
@@ -213,6 +230,8 @@ describe SystemNoteService do
 
           expect(subject.note).to eq "changed milestone to #{reference}"
         end
+
+        it_behaves_like 'a note with overridable created_at'
       end
 
       context 'when milestone removed' do
@@ -221,6 +240,8 @@ describe SystemNoteService do
         it 'sets the note text' do
           expect(subject.note).to eq 'removed milestone'
         end
+
+        it_behaves_like 'a note with overridable created_at'
       end
     end
 
@@ -237,6 +258,8 @@ describe SystemNoteService do
         it 'sets the note text to use the milestone name' do
           expect(subject.note).to eq "changed milestone to #{milestone.to_reference(format: :name)}"
         end
+
+        it_behaves_like 'a note with overridable created_at'
       end
 
       context 'when milestone removed' do
@@ -245,6 +268,8 @@ describe SystemNoteService do
         it 'sets the note text' do
           expect(subject.note).to eq 'removed milestone'
         end
+
+        it_behaves_like 'a note with overridable created_at'
       end
     end
   end
@@ -254,6 +279,8 @@ describe SystemNoteService do
 
     let(:due_date) { Date.today }
 
+    it_behaves_like 'a note with overridable created_at'
+
     it_behaves_like 'a system note' do
       let(:action) { 'due_date' }
     end
@@ -280,6 +307,8 @@ describe SystemNoteService do
       let(:status) { 'reopened' }
       let(:source) { nil }
 
+      it_behaves_like 'a note with overridable created_at'
+
       it_behaves_like 'a system note' do
         let(:action) { 'opened' }
       end
@@ -289,6 +318,8 @@ describe SystemNoteService do
       let(:status) { 'opened' }
       let(:source) { double('commit', gfm_reference: 'commit 123456') }
 
+      it_behaves_like 'a note with overridable created_at'
+
       it 'sets the note text' do
         expect(subject.note).to eq "#{status} via commit 123456"
       end
@@ -338,6 +369,8 @@ describe SystemNoteService do
         let(:action) { 'title' }
       end
 
+      it_behaves_like 'a note with overridable created_at'
+
       it 'sets the note text' do
         expect(subject.note)
           .to eq "changed title from **{-Old title-}** to **{+Lorem ipsum+}**"
@@ -353,6 +386,8 @@ describe SystemNoteService do
         let(:action) { 'description' }
       end
 
+      it_behaves_like 'a note with overridable created_at'
+
       it 'sets the note text' do
         expect(subject.note).to eq('changed the description')
       end
@@ -478,6 +513,8 @@ describe SystemNoteService do
         let(:action) { 'cross_reference' }
       end
 
+      it_behaves_like 'a note with overridable created_at'
+
       describe 'note_body' do
         context 'cross-project' do
           let(:project2) { create(:project, :repository) }
@@ -619,7 +656,7 @@ describe SystemNoteService do
 
     context 'commit with cross-reference from fork' do
       let(:author2) { create(:project_member, :reporter, user: create(:user), project: project).user }
-      let(:forked_project) { Projects::ForkService.new(project, author2).execute }
+      let(:forked_project) { fork_project(project, author2, repository: true) }
       let(:commit2) { forked_project.commit }
 
       before do
@@ -896,6 +933,28 @@ describe SystemNoteService do
     end
   end
 
+  describe '.change_time_estimate' do
+    subject { described_class.change_time_estimate(noteable, project, author) }
+
+    it_behaves_like 'a system note' do
+      let(:action) { 'time_tracking' }
+    end
+
+    context 'with a time estimate' do
+      it 'sets the note text' do
+        noteable.update_attribute(:time_estimate, 277200)
+
+        expect(subject.note).to eq "changed time estimate to 1w 4d 5h"
+      end
+    end
+
+    context 'without a time estimate' do
+      it 'sets the note text' do
+        expect(subject.note).to eq "removed time estimate"
+      end
+    end
+  end
+
   describe '.discussion_continued_in_issue' do
     let(:discussion) { create(:diff_note_on_merge_request, project: project).to_discussion }
     let(:merge_request) { discussion.noteable }
@@ -922,28 +981,6 @@ describe SystemNoteService do
     end
   end
 
-  describe '.change_time_estimate' do
-    subject { described_class.change_time_estimate(noteable, project, author) }
-
-    it_behaves_like 'a system note' do
-      let(:action) { 'time_tracking' }
-    end
-
-    context 'with a time estimate' do
-      it 'sets the note text' do
-        noteable.update_attribute(:time_estimate, 277200)
-
-        expect(subject.note).to eq "changed time estimate to 1w 4d 5h"
-      end
-    end
-
-    context 'without a time estimate' do
-      it 'sets the note text' do
-        expect(subject.note).to eq "removed time estimate"
-      end
-    end
-  end
-
   describe '.change_time_spent' do
     # We need a custom noteable in order to the shared examples to be green.
     let(:noteable) do
diff --git a/spec/services/todo_service_spec.rb b/spec/services/todo_service_spec.rb
index 8631f3f9a33..89411b2e908 100644
--- a/spec/services/todo_service_spec.rb
+++ b/spec/services/todo_service_spec.rb
@@ -272,28 +272,6 @@ describe TodoService do
       end
     end
 
-    describe '#reassigned_issue' do
-      it 'creates a pending todo for new assignee' do
-        unassigned_issue.assignees << john_doe
-        service.reassigned_issue(unassigned_issue, author)
-
-        should_create_todo(user: john_doe, target: unassigned_issue, action: Todo::ASSIGNED)
-      end
-
-      it 'does not create a todo if unassigned' do
-        issue.assignees.destroy_all # rubocop: disable DestroyAll
-
-        should_not_create_any_todo { service.reassigned_issue(issue, author) }
-      end
-
-      it 'creates a todo if new assignee is the current user' do
-        unassigned_issue.assignees << john_doe
-        service.reassigned_issue(unassigned_issue, john_doe)
-
-        should_create_todo(user: john_doe, target: unassigned_issue, author: john_doe, action: Todo::ASSIGNED)
-      end
-    end
-
     describe '#mark_pending_todos_as_done' do
       it 'marks related pending todos to the target for the user as done' do
         first_todo = create(:todo, :assigned, user: john_doe, project: project, target: issue, author: author)
@@ -504,10 +482,60 @@ describe TodoService do
     end
   end
 
+  describe '#reassigned_issuable' do
+    shared_examples 'reassigned issuable' do
+      it 'creates a pending todo for new assignee' do
+        issuable_unassigned.assignees = [john_doe]
+        service.reassigned_issuable(issuable_unassigned, author)
+
+        should_create_todo(user: john_doe, target: issuable_unassigned, action: Todo::ASSIGNED)
+      end
+
+      it 'does not create a todo if unassigned' do
+        issuable_assigned.assignees = []
+
+        should_not_create_any_todo { service.reassigned_issuable(issuable_assigned, author) }
+      end
+
+      it 'creates a todo if new assignee is the current user' do
+        issuable_assigned.assignees = [john_doe]
+        service.reassigned_issuable(issuable_assigned, john_doe)
+
+        should_create_todo(user: john_doe, target: issuable_assigned, author: john_doe, action: Todo::ASSIGNED)
+      end
+
+      it 'does not create a todo for guests' do
+        service.reassigned_issuable(issuable_assigned, author)
+        should_not_create_todo(user: guest, target: issuable_assigned, action: Todo::MENTIONED)
+      end
+
+      it 'does not create a directly addressed todo for guests' do
+        service.reassigned_issuable(addressed_issuable_assigned, author)
+        should_not_create_todo(user: guest, target: addressed_issuable_assigned, action: Todo::DIRECTLY_ADDRESSED)
+      end
+    end
+
+    context 'issuable is a merge request' do
+      it_behaves_like 'reassigned issuable' do
+        let(:issuable_assigned) { create(:merge_request, source_project: project, author: author, assignees: [john_doe], description: "- [ ] Task 1\n- [ ] Task 2 #{mentions}") }
+        let(:addressed_issuable_assigned) { create(:merge_request, source_project: project, author: author, assignees: [john_doe], description: "#{directly_addressed}\n- [ ] Task 1\n- [ ] Task 2") }
+        let(:issuable_unassigned) { create(:merge_request, source_project: project, author: author, assignees: []) }
+      end
+    end
+
+    context 'issuable is an issue' do
+      it_behaves_like 'reassigned issuable' do
+        let(:issuable_assigned) { create(:issue, project: project, author: author, assignees: [john_doe], description: "- [ ] Task 1\n- [ ] Task 2 #{mentions}") }
+        let(:addressed_issuable_assigned) { create(:issue, project: project, author: author, assignees: [john_doe], description: "#{directly_addressed}\n- [ ] Task 1\n- [ ] Task 2") }
+        let(:issuable_unassigned) { create(:issue, project: project, author: author, assignees: []) }
+      end
+    end
+  end
+
   describe 'Merge Requests' do
-    let(:mr_assigned) { create(:merge_request, source_project: project, author: author, assignee: john_doe, description: "- [ ] Task 1\n- [ ] Task 2 #{mentions}") }
-    let(:addressed_mr_assigned) { create(:merge_request, source_project: project, author: author, assignee: john_doe, description: "#{directly_addressed}\n- [ ] Task 1\n- [ ] Task 2") }
-    let(:mr_unassigned) { create(:merge_request, source_project: project, author: author, assignee: nil) }
+    let(:mr_assigned) { create(:merge_request, source_project: project, author: author, assignees: [john_doe], description: "- [ ] Task 1\n- [ ] Task 2 #{mentions}") }
+    let(:addressed_mr_assigned) { create(:merge_request, source_project: project, author: author, assignees: [john_doe], description: "#{directly_addressed}\n- [ ] Task 1\n- [ ] Task 2") }
+    let(:mr_unassigned) { create(:merge_request, source_project: project, author: author, assignees: []) }
 
     describe '#new_merge_request' do
       it 'creates a pending todo if assigned' do
@@ -659,38 +687,6 @@ describe TodoService do
       end
     end
 
-    describe '#reassigned_merge_request' do
-      it 'creates a pending todo for new assignee' do
-        mr_unassigned.update_attribute(:assignee, john_doe)
-        service.reassigned_merge_request(mr_unassigned, author)
-
-        should_create_todo(user: john_doe, target: mr_unassigned, action: Todo::ASSIGNED)
-      end
-
-      it 'does not create a todo if unassigned' do
-        mr_assigned.update_attribute(:assignee, nil)
-
-        should_not_create_any_todo { service.reassigned_merge_request(mr_assigned, author) }
-      end
-
-      it 'creates a todo if new assignee is the current user' do
-        mr_assigned.update_attribute(:assignee, john_doe)
-        service.reassigned_merge_request(mr_assigned, john_doe)
-
-        should_create_todo(user: john_doe, target: mr_assigned, author: john_doe, action: Todo::ASSIGNED)
-      end
-
-      it 'does not create a todo for guests' do
-        service.reassigned_merge_request(mr_assigned, author)
-        should_not_create_todo(user: guest, target: mr_assigned, action: Todo::MENTIONED)
-      end
-
-      it 'does not create a directly addressed todo for guests' do
-        service.reassigned_merge_request(addressed_mr_assigned, author)
-        should_not_create_todo(user: guest, target: addressed_mr_assigned, action: Todo::DIRECTLY_ADDRESSED)
-      end
-    end
-
     describe '#merge_merge_request' do
       it 'marks related pending todos to the target for the user as done' do
         first_todo = create(:todo, :assigned, user: john_doe, project: project, target: mr_assigned, author: author)
diff --git a/spec/services/users/destroy_service_spec.rb b/spec/services/users/destroy_service_spec.rb
index 83f1495a1c6..450e76d5f58 100644
--- a/spec/services/users/destroy_service_spec.rb
+++ b/spec/services/users/destroy_service_spec.rb
@@ -78,7 +78,7 @@ describe Users::DestroyService do
       end
 
       context "for an merge request the user was assigned to" do
-        let!(:merge_request) { create(:merge_request, source_project: project, assignee: user) }
+        let!(:merge_request) { create(:merge_request, source_project: project, assignees: [user]) }
 
         before do
           service.execute(user)
@@ -91,7 +91,7 @@ describe Users::DestroyService do
         it 'migrates the merge request so that it is "Unassigned"' do
           migrated_merge_request = MergeRequest.find_by_id(merge_request.id)
 
-          expect(migrated_merge_request.assignee).to be_nil
+          expect(migrated_merge_request.assignees).to be_empty
         end
       end
     end
diff --git a/spec/services/verify_pages_domain_service_spec.rb b/spec/services/verify_pages_domain_service_spec.rb
index ddf9d2b4917..b60b13bb3fc 100644
--- a/spec/services/verify_pages_domain_service_spec.rb
+++ b/spec/services/verify_pages_domain_service_spec.rb
@@ -27,6 +27,7 @@ describe VerifyPagesDomainService do
 
           expect(domain).to be_verified
           expect(domain).to be_enabled
+          expect(domain.remove_at).to be_nil
         end
       end
 
@@ -48,18 +49,32 @@ describe VerifyPagesDomainService do
         end
       end
 
+      shared_examples 'unverifies and disables domain' do
+        it 'unverifies domain' do
+          expect(service.execute).to eq(error_status)
+          expect(domain).not_to be_verified
+        end
+
+        it 'disables domain and shedules it for removal' do
+          Timecop.freeze do
+            service.execute
+            expect(domain).not_to be_enabled
+            expect(domain.remove_at).to be_within(1.second).of(1.week.from_now)
+          end
+        end
+      end
+
       context 'when domain is disabled(or new)' do
         let(:domain) { create(:pages_domain, :disabled) }
 
         include_examples 'successful enablement and verification'
 
-        shared_examples 'unverifies and disables domain' do
-          it 'unverifies and disables domain' do
-            expect(service.execute).to eq(error_status)
-
-            expect(domain).not_to be_verified
-            expect(domain).not_to be_enabled
+        context 'when txt record does not contain verification code' do
+          before do
+            stub_resolver(domain_name => 'something else')
           end
+
+          include_examples 'unverifies and disables domain'
         end
 
         context 'when txt record does not contain verification code' do
@@ -84,16 +99,25 @@ describe VerifyPagesDomainService do
 
         include_examples 'successful enablement and verification'
 
-        context 'when txt record does not contain verification code' do
-          before do
-            stub_resolver(domain_name => 'something else')
-          end
-
+        shared_examples 'unverifing domain' do
           it 'unverifies but does not disable domain' do
             expect(service.execute).to eq(error_status)
             expect(domain).not_to be_verified
             expect(domain).to be_enabled
           end
+
+          it 'does not schedule domain for removal' do
+            service.execute
+            expect(domain.remove_at).to be_nil
+          end
+        end
+
+        context 'when txt record does not contain verification code' do
+          before do
+            stub_resolver(domain_name => 'something else')
+          end
+
+          include_examples 'unverifing domain'
         end
 
         context 'when no txt records are present' do
@@ -101,11 +125,7 @@ describe VerifyPagesDomainService do
             stub_resolver
           end
 
-          it 'unverifies but does not disable domain' do
-            expect(service.execute).to eq(error_status)
-            expect(domain).not_to be_verified
-            expect(domain).to be_enabled
-          end
+          include_examples 'unverifing domain'
         end
       end
 
@@ -125,13 +145,40 @@ describe VerifyPagesDomainService do
             stub_resolver
           end
 
-          it 'disables domain' do
-            error_status[:message] += '. It is now disabled.'
+          let(:error_status) { { status: :error, message: "Couldn't verify #{domain.domain}. It is now disabled." } }
 
-            expect(service.execute).to eq(error_status)
+          include_examples 'unverifies and disables domain'
+        end
+      end
 
-            expect(domain).not_to be_verified
-            expect(domain).not_to be_enabled
+      context 'when domain is disabled and scheduled for removal' do
+        let(:domain) { create(:pages_domain, :disabled, :scheduled_for_removal) }
+
+        context 'when the right code is present' do
+          before do
+            stub_resolver(domain.domain => domain.keyed_verification_code)
+          end
+
+          it 'verifies and enables domain' do
+            expect(service.execute).to eq(status: :success)
+
+            expect(domain).to be_verified
+            expect(domain).to be_enabled
+          end
+
+          it 'prevent domain from being removed' do
+            expect { service.execute }.to change { domain.remove_at }.to(nil)
+          end
+        end
+
+        context 'when the right code is not present' do
+          before do
+            stub_resolver
+          end
+
+          it 'keeps domain scheduled for removal but does not change removal time' do
+            expect { service.execute }.not_to change { domain.remove_at }
+            expect(domain.remove_at).to be_present
           end
         end
       end