Add latest changes from gitlab-org/gitlab@master

spec/services/environments/auto_stop_service_spec.rb

+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Environments::AutoStopService, :clean_gitlab_redis_shared_state do
+  include CreateEnvironmentsHelpers
+  include ExclusiveLeaseHelpers
+
+  let_it_be(:project) { create(:project, :repository) }
+  let_it_be(:user) { create(:user) }
+  let(:service) { described_class.new }
+
+  before_all do
+    project.add_developer(user)
+  end
+
+  describe '#execute' do
+    subject { service.execute }
+
+    let_it_be(:project) { create(:project, :repository) }
+    let_it_be(:user) { create(:user) }
+    let(:environments) { Environment.all }
+
+    before_all do
+      project.add_developer(user)
+      project.repository.add_branch(user, 'review/feature-1', 'master')
+      project.repository.add_branch(user, 'review/feature-2', 'master')
+    end
+
+    before do
+      create_review_app(user, project, 'review/feature-1')
+      create_review_app(user, project, 'review/feature-2')
+    end
+
+    it 'stops environments and play stop jobs' do
+      expect { subject }
+        .to change { Environment.all.map(&:state).uniq }
+        .from(['available']).to(['stopped'])
+
+      expect(Ci::Build.where(name: 'stop_review_app').map(&:status).uniq).to eq(['pending'])
+    end
+
+    context 'when auto_stop_environments feature flag is disabled' do
+      before do
+        stub_feature_flags(auto_stop_environments: false)
+      end
+
+      it 'does not execute Ci::StopEnvironmentsService' do
+        expect(Ci::StopEnvironmentsService).not_to receive(:execute_in_batch)
+
+        subject
+      end
+    end
+
+    context 'when the other sidekiq worker has already been running' do
+      before do
+        stub_exclusive_lease_taken(described_class::EXCLUSIVE_LOCK_KEY)
+      end
+
+      it 'does not execute stop_in_batch' do
+        expect_next_instance_of(described_class) do |service|
+          expect(service).not_to receive(:stop_in_batch)
+        end
+
+        expect { subject }.to raise_error(Gitlab::ExclusiveLeaseHelpers::FailedToObtainLockError)
+      end
+    end
+
+    context 'when loop reached timeout' do
+      before do
+        stub_const("#{described_class}::LOOP_TIMEOUT", 0.seconds)
+        stub_const("#{described_class}::LOOP_LIMIT", 100_000)
+        allow_next_instance_of(described_class) do |service|
+          allow(service).to receive(:stop_in_batch) { true }
+        end
+      end
+
+      it 'returns false and does not continue the process' do
+        is_expected.to eq(false)
+      end
+    end
+
+    context 'when loop reached loop limit' do
+      before do
+        stub_const("#{described_class}::LOOP_LIMIT", 1)
+        stub_const("#{described_class}::BATCH_SIZE", 1)
+      end
+
+      it 'stops only one available environment' do
+        expect { subject }.to change { Environment.available.count }.by(-1)
+      end
+    end
+  end
+end

spec/services/issues/create_service_spec.rb

@@ -171,6 +171,31 @@ describe Issues::CreateService do
         described_class.new(project, user, opts).execute
       end
+
+      context 'after_save callback to store_mentions' do
+        context 'when mentionable attributes change' do
+          let(:opts) { { title: 'Title', description: "Description with #{user.to_reference}" } }
+
+          it 'saves mentions' do
+            expect_next_instance_of(Issue) do |instance|
+              expect(instance).to receive(:store_mentions!).and_call_original
+            end
+            expect(issue.user_mentions.count).to eq 1
+          end
+        end
+
+        context 'when save fails' do
+          let(:opts) { { title: '', label_ids: labels.map(&:id), milestone_id: milestone.id } }
+
+          it 'does not call store_mentions' do
+            expect_next_instance_of(Issue) do |instance|
+              expect(instance).not_to receive(:store_mentions!).and_call_original
+            end
+            expect(issue.valid?).to be false
+            expect(issue.user_mentions.count).to eq 0
+          end
+        end
+      end
     end
     context 'issue create service' do

spec/services/issues/move_service_spec.rb

@@ -6,7 +6,7 @@ describe Issues::MoveService do
   let(:user) { create(:user) }
   let(:author) { create(:user) }
   let(:title) { 'Some issue' }
-  let(:description) { 'Some issue description' }
+  let(:description) { "Some issue description with mention to #{user.to_reference}" }
   let(:group) { create(:group, :private) }
   let(:sub_group_1) { create(:group, :private, parent: group) }
   let(:sub_group_2) { create(:group, :private, parent: group) }
@@ -36,6 +36,9 @@ describe Issues::MoveService do
     end
     context 'issue movable' do
+      let!(:note_with_mention) { create(:note, noteable: old_issue, author: author, project: old_project, note: "note with mention #{user.to_reference}") }
+      let!(:note_with_no_mention) { create(:note, noteable: old_issue, author: author, project: old_project, note: "note without mention") }
+
       include_context 'user can move issue'
       context 'generic issue' do
@@ -94,6 +97,15 @@ describe Issues::MoveService do
         it 'moves the award emoji' do
           expect(old_issue.award_emoji.first.name).to eq new_issue.reload.award_emoji.first.name
         end
+
+        context 'when issue has notes with mentions' do
+          it 'saves user mentions with actual mentions for new issue' do
+            expect(new_issue.user_mentions.where(note_id: nil).first.mentioned_users_ids).to match_array([user.id])
+            expect(new_issue.user_mentions.where.not(note_id: nil).first.mentioned_users_ids).to match_array([user.id])
+            expect(new_issue.user_mentions.where.not(note_id: nil).count).to eq 1
+            expect(new_issue.user_mentions.count).to eq 2
+          end
+        end
       end
       context 'issue with assignee' do

spec/services/issues/update_service_spec.rb

@@ -211,6 +211,49 @@ describe Issues::UpdateService, :mailer do
           expect(note.note).to eq 'locked this issue'
         end
       end
+
+      context 'after_save callback to store_mentions' do
+        let(:issue) { create(:issue, title: 'Old title', description: "simple description", project: project, author: create(:user)) }
+        let(:labels) { create_pair(:label, project: project) }
+        let(:milestone) { create(:milestone, project: project) }
+
+        context 'when mentionable attributes change' do
+          let(:opts) { { description: "Description with #{user.to_reference}" } }
+
+          it 'saves mentions' do
+            expect(issue).to receive(:store_mentions!).and_call_original
+
+            expect { update_issue(opts) }.to change { IssueUserMention.count }.by(1)
+
+            expect(issue.referenced_users).to match_array([user])
+          end
+        end
+
+        context 'when mentionable attributes do not change' do
+          let(:opts) { { label_ids: labels.map(&:id), milestone_id: milestone.id } }
+
+          it 'does not call store_mentions' do
+            expect(issue).not_to receive(:store_mentions!).and_call_original
+
+            expect { update_issue(opts) }.not_to change { IssueUserMention.count }
+
+            expect(issue.referenced_users).to be_empty
+          end
+        end
+
+        context 'when save fails' do
+          let(:opts) { { title: '', label_ids: labels.map(&:id), milestone_id: milestone.id } }
+
+          it 'does not call store_mentions' do
+            expect(issue).not_to receive(:store_mentions!).and_call_original
+
+            expect { update_issue(opts) }.not_to change { IssueUserMention.count }
+
+            expect(issue.referenced_users).to be_empty
+            expect(issue.valid?).to be false
+          end
+        end
+      end
     end
     context 'when description changed' do

spec/services/merge_requests/create_service_spec.rb

@@ -291,6 +291,46 @@ describe MergeRequests::CreateService, :clean_gitlab_redis_shared_state do
         expect { service.execute }.to change { counter.read(:create) }.by(1)
       end
+
+      context 'after_save callback to store_mentions' do
+        let(:labels) { create_pair(:label, project: project) }
+        let(:milestone) { create(:milestone, project: project) }
+        let(:req_opts) { { source_branch: 'feature', target_branch: 'master' } }
+
+        context 'when mentionable attributes change' do
+          let(:opts) { { title: 'Title', description: "Description with #{user.to_reference}" }.merge(req_opts) }
+
+          it 'saves mentions' do
+            expect_next_instance_of(MergeRequest) do |instance|
+              expect(instance).to receive(:store_mentions!).and_call_original
+            end
+            expect(merge_request.user_mentions.count).to eq 1
+          end
+        end
+
+        context 'when mentionable attributes do not change' do
+          let(:opts) { { label_ids: labels.map(&:id), milestone_id: milestone.id }.merge(req_opts) }
+
+          it 'does not call store_mentions' do
+            expect_next_instance_of(MergeRequest) do |instance|
+              expect(instance).not_to receive(:store_mentions!).and_call_original
+            end
+            expect(merge_request.valid?).to be false
+            expect(merge_request.user_mentions.count).to eq 0
+          end
+        end
+
+        context 'when save fails' do
+          let(:opts) { { label_ids: labels.map(&:id), milestone_id: milestone.id } }
+
+          it 'does not call store_mentions' do
+            expect_next_instance_of(MergeRequest) do |instance|
+              expect(instance).not_to receive(:store_mentions!).and_call_original
+            end
+            expect(merge_request.valid?).to be false
+          end
+        end
+      end
     end
     it_behaves_like 'new issuable record that supports quick actions' do

spec/services/merge_requests/update_service_spec.rb

@@ -162,6 +162,52 @@ describe MergeRequests::UpdateService, :mailer do
       end
     end
+    context 'after_save callback to store_mentions' do
+      let(:merge_request) { create(:merge_request, title: 'Old title', description: "simple description", source_branch: 'test', source_project: project, author: user) }
+      let(:labels) { create_pair(:label, project: project) }
+      let(:milestone) { create(:milestone, project: project) }
+      let(:req_opts) { { source_branch: 'feature', target_branch: 'master' } }
+
+      subject { MergeRequests::UpdateService.new(project, user, opts).execute(merge_request) }
+
+      context 'when mentionable attributes change' do
+        let(:opts) { { description: "Description with #{user.to_reference}" }.merge(req_opts) }
+
+        it 'saves mentions' do
+          expect(merge_request).to receive(:store_mentions!).and_call_original
+
+          expect { subject }.to change { MergeRequestUserMention.count }.by(1)
+
+          expect(merge_request.referenced_users).to match_array([user])
+        end
+      end
+
+      context 'when mentionable attributes do not change' do
+        let(:opts) { { label_ids: [label.id, label2.id], milestone_id: milestone.id }.merge(req_opts) }
+
+        it 'does not call store_mentions' do
+          expect(merge_request).not_to receive(:store_mentions!).and_call_original
+
+          expect { subject }.not_to change { MergeRequestUserMention.count }
+
+          expect(merge_request.referenced_users).to be_empty
+        end
+      end
+
+      context 'when save fails' do
+        let(:opts) { { title: '', label_ids: labels.map(&:id), milestone_id: milestone.id } }
+
+        it 'does not call store_mentions' do
+          expect(merge_request).not_to receive(:store_mentions!).and_call_original
+
+          expect { subject }.not_to change { MergeRequestUserMention.count }
+
+          expect(merge_request.referenced_users).to be_empty
+          expect(merge_request.valid?).to be false
+        end
+      end
+    end
+
     context 'merge' do
       let(:opts) do
         {

spec/support/helpers/create_environments_helpers.rb

+# frozen_string_literal: true
+
+module CreateEnvironmentsHelpers
+  def create_review_app(user, project, ref)
+    common = { project: project, ref: ref, user: user }
+    pipeline = create(:ci_pipeline, **common)
+    start_review = create(:ci_build, :start_review_app, :success, **common, pipeline: pipeline)
+    stop_review = create(:ci_build, :stop_review_app, :manual, **common, pipeline: pipeline)
+    environment = create(:environment, :auto_stoppable, project: project, name: ref)
+    create(:deployment, :success, **common, on_stop: stop_review.name,
+      deployable: start_review, environment: environment)
+  end
+end

spec/support/shared_examples/models/mentionable_shared_examples.rb

@@ -86,7 +86,7 @@ RSpec.shared_examples 'a mentionable' do
     end
     it 'sends in cached markdown fields when appropriate' do
-      if subject.is_a?(CacheMarkdownField)
+      if subject.is_a?(CacheMarkdownField) && subject.extractors[author].blank?
         expect_next_instance_of(Gitlab::ReferenceExtractor) do |ext|
           attrs = subject.class.mentionable_attrs.collect(&:first) & subject.cached_markdown_fields.markdown_fields
           attrs.each do |field|
@@ -136,7 +136,7 @@ RSpec.shared_examples 'an editable mentionable' do
       set_mentionable_text.call('This is a text')
-      if subject.is_a?(CacheMarkdownField)
+      if subject.is_a?(CacheMarkdownField) && subject.extractors[author].blank?
         expect_next_instance_of(Gitlab::ReferenceExtractor) do |ext|
           subject.cached_markdown_fields.markdown_fields.each do |field|
             expect(ext).to receive(:analyze).with(subject.send(field), hash_including(rendered: anything))

spec/workers/environments/auto_stop_cron_worker_spec.rb

+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Environments::AutoStopCronWorker do
+  subject { worker.perform }
+
+  let(:worker) { described_class.new }
+
+  it 'executes Environments::AutoStopService' do
+    expect_next_instance_of(Environments::AutoStopService) do |service|
+      expect(service).to receive(:execute)
+    end
+
+    subject
+  end
+end