Add latest changes from gitlab-org/gitlab@master

15 files changed, 402 insertions, 106 deletions

diff --git a/spec/frontend/notes/components/comment_form_spec.js b/spec/frontend/notes/components/comment_form_spec.js
index 45b99b71e06..475ea4f0f7d 100644
--- a/spec/frontend/notes/components/comment_form_spec.js
+++ b/spec/frontend/notes/components/comment_form_spec.js
@@ -38,6 +38,7 @@ describe('issue_comment_form component', () => {
       },
       store,
       sync: false,
+      attachToDocument: true,
     });
   };
 
diff --git a/spec/frontend/notes/components/discussion_actions_spec.js b/spec/frontend/notes/components/discussion_actions_spec.js
index 91f9dab2530..3ccfea121b0 100644
--- a/spec/frontend/notes/components/discussion_actions_spec.js
+++ b/spec/frontend/notes/components/discussion_actions_spec.js
@@ -37,6 +37,8 @@ describe('DiscussionActions', () => {
         shouldShowJumpToNextDiscussion: true,
         ...props,
       },
+      sync: false,
+      attachToDocument: true,
     });
   };
 
diff --git a/spec/frontend/notes/components/discussion_jump_to_next_button_spec.js b/spec/frontend/notes/components/discussion_jump_to_next_button_spec.js
index fd439ba46bd..ed173eacfab 100644
--- a/spec/frontend/notes/components/discussion_jump_to_next_button_spec.js
+++ b/spec/frontend/notes/components/discussion_jump_to_next_button_spec.js
@@ -7,6 +7,7 @@ describe('JumpToNextDiscussionButton', () => {
   beforeEach(() => {
     wrapper = shallowMount(JumpToNextDiscussionButton, {
       sync: false,
+      attachToDocument: true,
     });
   });
 
diff --git a/spec/frontend/notes/components/discussion_keyboard_navigator_spec.js b/spec/frontend/notes/components/discussion_keyboard_navigator_spec.js
index 8881bedf3cc..b38cfa8fb4a 100644
--- a/spec/frontend/notes/components/discussion_keyboard_navigator_spec.js
+++ b/spec/frontend/notes/components/discussion_keyboard_navigator_spec.js
@@ -37,6 +37,7 @@ describe('notes/components/discussion_keyboard_navigator', () => {
       isDiff ? NEXT_DIFF_ID : NEXT_ID;
     notes.getters.previousUnresolvedDiscussionId = () => (currId, isDiff) =>
       isDiff ? PREV_DIFF_ID : PREV_ID;
+    notes.getters.getDiscussion = () => id => ({ id });
 
     storeOptions = {
       modules: {
@@ -63,14 +64,18 @@ describe('notes/components/discussion_keyboard_navigator', () => {
     it('calls jumpToNextDiscussion when pressing `n`', () => {
       Mousetrap.trigger('n');
 
-      expect(wrapper.vm.jumpToDiscussion).toHaveBeenCalledWith(expectedNextId);
+      expect(wrapper.vm.jumpToDiscussion).toHaveBeenCalledWith(
+        expect.objectContaining({ id: expectedNextId }),
+      );
       expect(wrapper.vm.currentDiscussionId).toEqual(expectedNextId);
     });
 
     it('calls jumpToPreviousDiscussion when pressing `p`', () => {
       Mousetrap.trigger('p');
 
-      expect(wrapper.vm.jumpToDiscussion).toHaveBeenCalledWith(expectedPrevId);
+      expect(wrapper.vm.jumpToDiscussion).toHaveBeenCalledWith(
+        expect.objectContaining({ id: expectedPrevId }),
+      );
       expect(wrapper.vm.currentDiscussionId).toEqual(expectedPrevId);
     });
   });
diff --git a/spec/frontend/notes/components/discussion_notes_spec.js b/spec/frontend/notes/components/discussion_notes_spec.js
index f77236b14bc..5ab26d742ca 100644
--- a/spec/frontend/notes/components/discussion_notes_spec.js
+++ b/spec/frontend/notes/components/discussion_notes_spec.js
@@ -36,6 +36,7 @@ describe('DiscussionNotes', () => {
         'avatar-badge': '<span class="avatar-badge-slot-content" />',
       },
       sync: false,
+      attachToDocument: true,
     });
   };
 
diff --git a/spec/javascripts/notes/components/discussion_counter_spec.js b/spec/javascripts/notes/components/discussion_counter_spec.js
index fecc0d604b1..2ad9428dd6f 100644
--- a/spec/javascripts/notes/components/discussion_counter_spec.js
+++ b/spec/javascripts/notes/components/discussion_counter_spec.js
@@ -27,6 +27,8 @@ describe('DiscussionCounter component', () => {
   describe('methods', () => {
     describe('jumpToFirstUnresolvedDiscussion', () => {
       it('expands unresolved discussion', () => {
+        window.mrTabs.currentAction = 'show';
+
         spyOn(vm, 'expandDiscussion').and.stub();
         const discussions = [
           {
@@ -47,14 +49,39 @@ describe('DiscussionCounter component', () => {
           ...store.state,
           discussions,
         });
-        setFixtures(`
-          <div class="discussion" data-discussion-id="${firstDiscussionId}"></div>
-        `);
-
         vm.jumpToFirstUnresolvedDiscussion();
 
         expect(vm.expandDiscussion).toHaveBeenCalledWith({ discussionId: firstDiscussionId });
       });
+
+      it('jumps to first unresolved discussion from diff tab if all diff discussions are resolved', () => {
+        window.mrTabs.currentAction = 'diff';
+        spyOn(vm, 'switchToDiscussionsTabAndJumpTo').and.stub();
+
+        const unresolvedId = discussionMock.id + 1;
+        const discussions = [
+          {
+            ...discussionMock,
+            id: discussionMock.id,
+            diff_discussion: true,
+            notes: [{ ...discussionMock.notes[0], resolvable: true, resolved: true }],
+            resolved: true,
+          },
+          {
+            ...discussionMock,
+            id: unresolvedId,
+            notes: [{ ...discussionMock.notes[0], resolvable: true, resolved: false }],
+            resolved: false,
+          },
+        ];
+        store.replaceState({
+          ...store.state,
+          discussions,
+        });
+        vm.jumpToFirstUnresolvedDiscussion();
+
+        expect(vm.switchToDiscussionsTabAndJumpTo).toHaveBeenCalledWith(unresolvedId);
+      });
     });
   });
 });
diff --git a/spec/javascripts/releases/list/components/app_spec.js b/spec/javascripts/releases/list/components/app_spec.js
index 471c442e497..994488581d7 100644
--- a/spec/javascripts/releases/list/components/app_spec.js
+++ b/spec/javascripts/releases/list/components/app_spec.js
@@ -1,15 +1,22 @@
 import Vue from 'vue';
+import _ from 'underscore';
 import app from '~/releases/list/components/app.vue';
 import createStore from '~/releases/list/store';
 import api from '~/api';
 import { mountComponentWithStore } from 'spec/helpers/vue_mount_component_helper';
 import { resetStore } from '../store/helpers';
-import { releases } from '../../mock_data';
+import {
+  pageInfoHeadersWithoutPagination,
+  pageInfoHeadersWithPagination,
+  release,
+  releases,
+} from '../../mock_data';
 
 describe('Releases App ', () => {
   const Component = Vue.extend(app);
   let store;
   let vm;
+  let releasesPagination;
 
   const props = {
     projectId: 'gitlab-ce',
@@ -19,6 +26,7 @@ describe('Releases App ', () => {
 
   beforeEach(() => {
     store = createStore();
+    releasesPagination = _.range(21).map(index => ({ ...release, tag_name: `${index}.00` }));
   });
 
   afterEach(() => {
@@ -28,7 +36,7 @@ describe('Releases App ', () => {
 
   describe('while loading', () => {
     beforeEach(() => {
-      spyOn(api, 'releases').and.returnValue(Promise.resolve({ data: [] }));
+      spyOn(api, 'releases').and.returnValue(Promise.resolve({ data: [], headers: {} }));
       vm = mountComponentWithStore(Component, { props, store });
     });
 
@@ -36,6 +44,7 @@ describe('Releases App ', () => {
       expect(vm.$el.querySelector('.js-loading')).not.toBeNull();
       expect(vm.$el.querySelector('.js-empty-state')).toBeNull();
       expect(vm.$el.querySelector('.js-success-state')).toBeNull();
+      expect(vm.$el.querySelector('.gl-pagination')).toBeNull();
 
       setTimeout(() => {
         done();
@@ -45,7 +54,9 @@ describe('Releases App ', () => {
 
   describe('with successful request', () => {
     beforeEach(() => {
-      spyOn(api, 'releases').and.returnValue(Promise.resolve({ data: releases }));
+      spyOn(api, 'releases').and.returnValue(
+        Promise.resolve({ data: releases, headers: pageInfoHeadersWithoutPagination }),
+      );
       vm = mountComponentWithStore(Component, { props, store });
     });
 
@@ -54,6 +65,27 @@ describe('Releases App ', () => {
         expect(vm.$el.querySelector('.js-loading')).toBeNull();
         expect(vm.$el.querySelector('.js-empty-state')).toBeNull();
         expect(vm.$el.querySelector('.js-success-state')).not.toBeNull();
+        expect(vm.$el.querySelector('.gl-pagination')).toBeNull();
+
+        done();
+      }, 0);
+    });
+  });
+
+  describe('with successful request and pagination', () => {
+    beforeEach(() => {
+      spyOn(api, 'releases').and.returnValue(
+        Promise.resolve({ data: releasesPagination, headers: pageInfoHeadersWithPagination }),
+      );
+      vm = mountComponentWithStore(Component, { props, store });
+    });
+
+    it('renders success state', done => {
+      setTimeout(() => {
+        expect(vm.$el.querySelector('.js-loading')).toBeNull();
+        expect(vm.$el.querySelector('.js-empty-state')).toBeNull();
+        expect(vm.$el.querySelector('.js-success-state')).not.toBeNull();
+        expect(vm.$el.querySelector('.gl-pagination')).not.toBeNull();
 
         done();
       }, 0);
@@ -62,7 +94,7 @@ describe('Releases App ', () => {
 
   describe('with empty request', () => {
     beforeEach(() => {
-      spyOn(api, 'releases').and.returnValue(Promise.resolve({ data: [] }));
+      spyOn(api, 'releases').and.returnValue(Promise.resolve({ data: [], headers: {} }));
       vm = mountComponentWithStore(Component, { props, store });
     });
 
@@ -71,6 +103,7 @@ describe('Releases App ', () => {
         expect(vm.$el.querySelector('.js-loading')).toBeNull();
         expect(vm.$el.querySelector('.js-empty-state')).not.toBeNull();
         expect(vm.$el.querySelector('.js-success-state')).toBeNull();
+        expect(vm.$el.querySelector('.gl-pagination')).toBeNull();
 
         done();
       }, 0);
diff --git a/spec/javascripts/releases/list/store/actions_spec.js b/spec/javascripts/releases/list/store/actions_spec.js
index 8e78a631a5f..c4b49c39e28 100644
--- a/spec/javascripts/releases/list/store/actions_spec.js
+++ b/spec/javascripts/releases/list/store/actions_spec.js
@@ -7,14 +7,17 @@ import {
 import state from '~/releases/list/store/state';
 import * as types from '~/releases/list/store/mutation_types';
 import api from '~/api';
+import { parseIntPagination } from '~/lib/utils/common_utils';
 import testAction from 'spec/helpers/vuex_action_helper';
-import { releases } from '../../mock_data';
+import { pageInfoHeadersWithoutPagination, releases } from '../../mock_data';
 
 describe('Releases State actions', () => {
   let mockedState;
+  let pageInfo;
 
   beforeEach(() => {
     mockedState = state();
+    pageInfo = parseIntPagination(pageInfoHeadersWithoutPagination);
   });
 
   describe('requestReleases', () => {
@@ -25,12 +28,16 @@ describe('Releases State actions', () => {
 
   describe('fetchReleases', () => {
     describe('success', () => {
-      it('dispatches requestReleases and receiveReleasesSuccess ', done => {
-        spyOn(api, 'releases').and.returnValue(Promise.resolve({ data: releases }));
+      it('dispatches requestReleases and receiveReleasesSuccess', done => {
+        spyOn(api, 'releases').and.callFake((id, options) => {
+          expect(id).toEqual(1);
+          expect(options.page).toEqual('1');
+          return Promise.resolve({ data: releases, headers: pageInfoHeadersWithoutPagination });
+        });
 
         testAction(
           fetchReleases,
-          releases,
+          { projectId: 1 },
           mockedState,
           [],
           [
@@ -38,7 +45,31 @@ describe('Releases State actions', () => {
               type: 'requestReleases',
             },
             {
-              payload: releases,
+              payload: { data: releases, headers: pageInfoHeadersWithoutPagination },
+              type: 'receiveReleasesSuccess',
+            },
+          ],
+          done,
+        );
+      });
+
+      it('dispatches requestReleases and receiveReleasesSuccess on page two', done => {
+        spyOn(api, 'releases').and.callFake((_, options) => {
+          expect(options.page).toEqual('2');
+          return Promise.resolve({ data: releases, headers: pageInfoHeadersWithoutPagination });
+        });
+
+        testAction(
+          fetchReleases,
+          { page: '2', projectId: 1 },
+          mockedState,
+          [],
+          [
+            {
+              type: 'requestReleases',
+            },
+            {
+              payload: { data: releases, headers: pageInfoHeadersWithoutPagination },
               type: 'receiveReleasesSuccess',
             },
           ],
@@ -48,12 +79,12 @@ describe('Releases State actions', () => {
     });
 
     describe('error', () => {
-      it('dispatches requestReleases and receiveReleasesError ', done => {
+      it('dispatches requestReleases and receiveReleasesError', done => {
         spyOn(api, 'releases').and.returnValue(Promise.reject());
 
         testAction(
           fetchReleases,
-          null,
+          { projectId: null },
           mockedState,
           [],
           [
@@ -74,9 +105,9 @@ describe('Releases State actions', () => {
     it('should commit RECEIVE_RELEASES_SUCCESS mutation', done => {
       testAction(
         receiveReleasesSuccess,
-        releases,
+        { data: releases, headers: pageInfoHeadersWithoutPagination },
         mockedState,
-        [{ type: types.RECEIVE_RELEASES_SUCCESS, payload: releases }],
+        [{ type: types.RECEIVE_RELEASES_SUCCESS, payload: { pageInfo, data: releases } }],
         [],
         done,
       );
diff --git a/spec/javascripts/releases/list/store/mutations_spec.js b/spec/javascripts/releases/list/store/mutations_spec.js
index d2577891495..d756c69d53b 100644
--- a/spec/javascripts/releases/list/store/mutations_spec.js
+++ b/spec/javascripts/releases/list/store/mutations_spec.js
@@ -1,13 +1,16 @@
 import state from '~/releases/list/store/state';
 import mutations from '~/releases/list/store/mutations';
 import * as types from '~/releases/list/store/mutation_types';
-import { releases } from '../../mock_data';
+import { parseIntPagination } from '~/lib/utils/common_utils';
+import { pageInfoHeadersWithoutPagination, releases } from '../../mock_data';
 
 describe('Releases Store Mutations', () => {
   let stateCopy;
+  let pageInfo;
 
   beforeEach(() => {
     stateCopy = state();
+    pageInfo = parseIntPagination(pageInfoHeadersWithoutPagination);
   });
 
   describe('REQUEST_RELEASES', () => {
@@ -20,7 +23,7 @@ describe('Releases Store Mutations', () => {
 
   describe('RECEIVE_RELEASES_SUCCESS', () => {
     beforeEach(() => {
-      mutations[types.RECEIVE_RELEASES_SUCCESS](stateCopy, releases);
+      mutations[types.RECEIVE_RELEASES_SUCCESS](stateCopy, { pageInfo, data: releases });
     });
 
     it('sets is loading to false', () => {
@@ -34,6 +37,10 @@ describe('Releases Store Mutations', () => {
     it('sets data', () => {
       expect(stateCopy.releases).toEqual(releases);
     });
+
+    it('sets pageInfo', () => {
+      expect(stateCopy.pageInfo).toEqual(pageInfo);
+    });
   });
 
   describe('RECEIVE_RELEASES_ERROR', () => {
@@ -42,6 +49,7 @@ describe('Releases Store Mutations', () => {
 
       expect(stateCopy.isLoading).toEqual(false);
       expect(stateCopy.releases).toEqual([]);
+      expect(stateCopy.pageInfo).toEqual({});
     });
   });
 });
diff --git a/spec/javascripts/releases/mock_data.js b/spec/javascripts/releases/mock_data.js
index 7197eb7bca8..72875dff172 100644
--- a/spec/javascripts/releases/mock_data.js
+++ b/spec/javascripts/releases/mock_data.js
@@ -1,3 +1,21 @@
+export const pageInfoHeadersWithoutPagination = {
+  'X-NEXT-PAGE': '',
+  'X-PAGE': '1',
+  'X-PER-PAGE': '20',
+  'X-PREV-PAGE': '',
+  'X-TOTAL': '19',
+  'X-TOTAL-PAGES': '1',
+};
+
+export const pageInfoHeadersWithPagination = {
+  'X-NEXT-PAGE': '2',
+  'X-PAGE': '1',
+  'X-PER-PAGE': '20',
+  'X-PREV-PAGE': '',
+  'X-TOTAL': '21',
+  'X-TOTAL-PAGES': '2',
+};
+
 export const release = {
   name: 'Bionic Beaver',
   tag_name: '18.04',
diff --git a/spec/lib/gitlab/ci/config/entry/default_spec.rb b/spec/lib/gitlab/ci/config/entry/default_spec.rb
index dad4f408e50..0366a63ef05 100644
--- a/spec/lib/gitlab/ci/config/entry/default_spec.rb
+++ b/spec/lib/gitlab/ci/config/entry/default_spec.rb
@@ -26,7 +26,8 @@ describe Gitlab::Ci::Config::Entry::Default do
       it 'contains the expected node names' do
         expect(described_class.nodes.keys)
           .to match_array(%i[before_script image services
-                             after_script cache interruptible])
+                             after_script cache interruptible
+                             timeout])
       end
     end
   end
diff --git a/spec/lib/gitlab/ci/config/entry/job_spec.rb b/spec/lib/gitlab/ci/config/entry/job_spec.rb
index fe83171c57a..b0e08e49d78 100644
--- a/spec/lib/gitlab/ci/config/entry/job_spec.rb
+++ b/spec/lib/gitlab/ci/config/entry/job_spec.rb
@@ -24,7 +24,7 @@ describe Gitlab::Ci::Config::Entry::Job do
       let(:result) do
         %i[before_script script stage type after_script cache
            image services only except rules needs variables artifacts
-           environment coverage retry interruptible]
+           environment coverage retry interruptible timeout]
       end
 
       it { is_expected.to match_array result }
@@ -417,21 +417,21 @@ describe Gitlab::Ci::Config::Entry::Job do
 
       context 'when timeout value is not correct' do
         context 'when it is higher than instance wide timeout' do
-          let(:config) { { timeout: '3 months' } }
+          let(:config) { { timeout: '3 months', script: 'test' } }
 
           it 'returns error about value too high' do
             expect(entry).not_to be_valid
             expect(entry.errors)
-              .to include "job timeout should not exceed the limit"
+              .to include "timeout config should not exceed the limit"
           end
         end
 
         context 'when it is not a duration' do
-          let(:config) { { timeout: 100 } }
+          let(:config) { { timeout: 100, script: 'test' } }
 
           it 'returns error about wrong value' do
             expect(entry).not_to be_valid
-            expect(entry.errors).to include 'job timeout should be a duration'
+            expect(entry.errors).to include 'timeout config should be a duration'
           end
         end
       end
diff --git a/spec/lib/gitlab/ci/yaml_processor_spec.rb b/spec/lib/gitlab/ci/yaml_processor_spec.rb
index 4b1c7483b11..66f6402b9a2 100644
--- a/spec/lib/gitlab/ci/yaml_processor_spec.rb
+++ b/spec/lib/gitlab/ci/yaml_processor_spec.rb
@@ -1375,7 +1375,7 @@ module Gitlab
           end
 
           it 'raises an error for invalid number' do
-            expect { builds }.to raise_error('jobs:deploy_to_production timeout should be a duration')
+            expect { builds }.to raise_error(Gitlab::Ci::YamlProcessor::ValidationError, 'jobs:deploy_to_production:timeout config should be a duration')
           end
         end
 
diff --git a/spec/lib/gitlab/sidekiq_middleware/metrics_spec.rb b/spec/lib/gitlab/sidekiq_middleware/metrics_spec.rb
index 0d8cff3a295..36c6f377bde 100644
--- a/spec/lib/gitlab/sidekiq_middleware/metrics_spec.rb
+++ b/spec/lib/gitlab/sidekiq_middleware/metrics_spec.rb
@@ -3,106 +3,201 @@
 require 'fast_spec_helper'
 
 describe Gitlab::SidekiqMiddleware::Metrics do
-  let(:middleware) { described_class.new }
-  let(:concurrency_metric) { double('concurrency metric') }
-
-  let(:queue_duration_seconds) { double('queue duration seconds metric') }
-  let(:completion_seconds_metric) { double('completion seconds metric') }
-  let(:user_execution_seconds_metric) { double('user execution seconds metric') }
-  let(:failed_total_metric) { double('failed total metric') }
-  let(:retried_total_metric) { double('retried total metric') }
-  let(:running_jobs_metric) { double('running jobs metric') }
-
-  before do
-    allow(Gitlab::Metrics).to receive(:histogram).with(:sidekiq_jobs_queue_duration_seconds, anything, anything, anything).and_return(queue_duration_seconds)
-    allow(Gitlab::Metrics).to receive(:histogram).with(:sidekiq_jobs_completion_seconds, anything, anything, anything).and_return(completion_seconds_metric)
-    allow(Gitlab::Metrics).to receive(:histogram).with(:sidekiq_jobs_cpu_seconds, anything, anything, anything).and_return(user_execution_seconds_metric)
-    allow(Gitlab::Metrics).to receive(:counter).with(:sidekiq_jobs_failed_total, anything).and_return(failed_total_metric)
-    allow(Gitlab::Metrics).to receive(:counter).with(:sidekiq_jobs_retried_total, anything).and_return(retried_total_metric)
-    allow(Gitlab::Metrics).to receive(:gauge).with(:sidekiq_running_jobs, anything, {}, :all).and_return(running_jobs_metric)
-    allow(Gitlab::Metrics).to receive(:gauge).with(:sidekiq_concurrency, anything, {}, :all).and_return(concurrency_metric)
-
-    allow(concurrency_metric).to receive(:set)
-  end
+  context "with worker attribution" do
+    subject { described_class.new }
 
-  describe '#initialize' do
-    it 'sets general metrics' do
-      expect(concurrency_metric).to receive(:set).with({}, Sidekiq.options[:concurrency].to_i)
+    let(:queue) { :test }
+    let(:worker_class) { worker.class }
+    let(:job) { {} }
+    let(:job_status) { :done }
+    let(:labels_with_job_status) { labels.merge(job_status: job_status.to_s) }
+    let(:default_labels) { { queue: queue.to_s, boundary: "", external_dependencies: "no", feature_category: "", latency_sensitive: "no" } }
+
+    shared_examples "a metrics middleware" do
+      context "with mocked prometheus" do
+        let(:concurrency_metric) { double('concurrency metric') }
+
+        let(:queue_duration_seconds) { double('queue duration seconds metric') }
+        let(:completion_seconds_metric) { double('completion seconds metric') }
+        let(:user_execution_seconds_metric) { double('user execution seconds metric') }
+        let(:failed_total_metric) { double('failed total metric') }
+        let(:retried_total_metric) { double('retried total metric') }
+        let(:running_jobs_metric) { double('running jobs metric') }
+
+        before do
+          allow(Gitlab::Metrics).to receive(:histogram).with(:sidekiq_jobs_queue_duration_seconds, anything, anything, anything).and_return(queue_duration_seconds)
+          allow(Gitlab::Metrics).to receive(:histogram).with(:sidekiq_jobs_completion_seconds, anything, anything, anything).and_return(completion_seconds_metric)
+          allow(Gitlab::Metrics).to receive(:histogram).with(:sidekiq_jobs_cpu_seconds, anything, anything, anything).and_return(user_execution_seconds_metric)
+          allow(Gitlab::Metrics).to receive(:counter).with(:sidekiq_jobs_failed_total, anything).and_return(failed_total_metric)
+          allow(Gitlab::Metrics).to receive(:counter).with(:sidekiq_jobs_retried_total, anything).and_return(retried_total_metric)
+          allow(Gitlab::Metrics).to receive(:gauge).with(:sidekiq_running_jobs, anything, {}, :all).and_return(running_jobs_metric)
+          allow(Gitlab::Metrics).to receive(:gauge).with(:sidekiq_concurrency, anything, {}, :all).and_return(concurrency_metric)
+
+          allow(concurrency_metric).to receive(:set)
+        end
+
+        describe '#initialize' do
+          it 'sets concurrency metrics' do
+            expect(concurrency_metric).to receive(:set).with({}, Sidekiq.options[:concurrency].to_i)
+
+            subject
+          end
+        end
+
+        describe '#call' do
+          let(:thread_cputime_before) { 1 }
+          let(:thread_cputime_after) { 2 }
+          let(:thread_cputime_duration) { thread_cputime_after - thread_cputime_before }
+
+          let(:monotonic_time_before) { 11 }
+          let(:monotonic_time_after) { 20 }
+          let(:monotonic_time_duration) { monotonic_time_after - monotonic_time_before }
+
+          let(:queue_duration_for_job) { 0.01 }
+
+          before do
+            allow(subject).to receive(:get_thread_cputime).and_return(thread_cputime_before, thread_cputime_after)
+            allow(Gitlab::Metrics::System).to receive(:monotonic_time).and_return(monotonic_time_before, monotonic_time_after)
+            allow(Gitlab::InstrumentationHelper).to receive(:queue_duration_for_job).with(job).and_return(queue_duration_for_job)
+
+            expect(running_jobs_metric).to receive(:increment).with(labels, 1)
+            expect(running_jobs_metric).to receive(:increment).with(labels, -1)
+
+            expect(queue_duration_seconds).to receive(:observe).with(labels, queue_duration_for_job) if queue_duration_for_job
+            expect(user_execution_seconds_metric).to receive(:observe).with(labels_with_job_status, thread_cputime_duration)
+            expect(completion_seconds_metric).to receive(:observe).with(labels_with_job_status, monotonic_time_duration)
+          end
+
+          it 'yields block' do
+            expect { |b| subject.call(worker, job, :test, &b) }.to yield_control.once
+          end
+
+          it 'sets queue specific metrics' do
+            subject.call(worker, job, :test) { nil }
+          end
+
+          context 'when job_duration is not available' do
+            let(:queue_duration_for_job) { nil }
+
+            it 'does not set the queue_duration_seconds histogram' do
+              expect(queue_duration_seconds).not_to receive(:observe)
+
+              subject.call(worker, job, :test) { nil }
+            end
+          end
+
+          context 'when error is raised' do
+            let(:job_status) { :fail }
+
+            it 'sets sidekiq_jobs_failed_total and reraises' do
+              expect(failed_total_metric).to receive(:increment).with(labels, 1)
+
+              expect { subject.call(worker, job, :test) { raise StandardError, "Failed" } }.to raise_error(StandardError, "Failed")
+            end
+          end
+
+          context 'when job is retried' do
+            let(:job) { { 'retry_count' => 1 } }
+
+            it 'sets sidekiq_jobs_retried_total metric' do
+              expect(retried_total_metric).to receive(:increment)
+
+              subject.call(worker, job, :test) { nil }
+            end
+          end
+        end
+      end
 
-      middleware
-    end
-  end
+      context "with prometheus integrated" do
+        describe '#call' do
+          it 'yields block' do
+            expect { |b| subject.call(worker, job, :test, &b) }.to yield_control.once
+          end
 
-  it 'ignore user execution when measured 0' do
-    allow(completion_seconds_metric).to receive(:observe)
+          context 'when error is raised' do
+            let(:job_status) { :fail }
 
-    expect(user_execution_seconds_metric).not_to receive(:observe)
-  end
+            it 'sets sidekiq_jobs_failed_total and reraises' do
+              expect { subject.call(worker, job, :test) { raise StandardError, "Failed" } }.to raise_error(StandardError, "Failed")
+            end
+          end
+        end
+      end
+    end
 
-  describe '#call' do
-    let(:worker) { double(:worker) }
+    context "when workers are not attributed" do
+      class TestNonAttributedWorker
+        include Sidekiq::Worker
+      end
+      let(:worker) { TestNonAttributedWorker.new }
+      let(:labels) { default_labels }
 
-    let(:job) { {} }
-    let(:job_status) { :done }
-    let(:labels) { { queue: :test } }
-    let(:labels_with_job_status) { { queue: :test, job_status: job_status } }
+      it_behaves_like "a metrics middleware"
+    end
 
-    let(:thread_cputime_before) { 1 }
-    let(:thread_cputime_after) { 2 }
-    let(:thread_cputime_duration) { thread_cputime_after - thread_cputime_before }
+    context "when workers are attributed" do
+      def create_attributed_worker_class(latency_sensitive, external_dependencies, resource_boundary, category)
+        Class.new do
+          include Sidekiq::Worker
+          include WorkerAttributes
+
+          latency_sensitive_worker! if latency_sensitive
+          worker_has_external_dependencies! if external_dependencies
+          worker_resource_boundary resource_boundary unless resource_boundary == :unknown
+          feature_category category unless category.nil?
+        end
+      end
 
-    let(:monotonic_time_before) { 11 }
-    let(:monotonic_time_after) { 20 }
-    let(:monotonic_time_duration) { monotonic_time_after - monotonic_time_before }
+      let(:latency_sensitive) { false }
+      let(:external_dependencies) { false }
+      let(:resource_boundary) { :unknown }
+      let(:feature_category) { nil }
+      let(:worker_class) { create_attributed_worker_class(latency_sensitive, external_dependencies, resource_boundary, feature_category) }
+      let(:worker) { worker_class.new }
 
-    let(:queue_duration_for_job) { 0.01 }
+      context "latency sensitive" do
+        let(:latency_sensitive) { true }
+        let(:labels) { default_labels.merge(latency_sensitive: "yes") }
 
-    before do
-      allow(middleware).to receive(:get_thread_cputime).and_return(thread_cputime_before, thread_cputime_after)
-      allow(Gitlab::Metrics::System).to receive(:monotonic_time).and_return(monotonic_time_before, monotonic_time_after)
-      allow(Gitlab::InstrumentationHelper).to receive(:queue_duration_for_job).with(job).and_return(queue_duration_for_job)
+        it_behaves_like "a metrics middleware"
+      end
 
-      expect(running_jobs_metric).to receive(:increment).with(labels, 1)
-      expect(running_jobs_metric).to receive(:increment).with(labels, -1)
+      context "external dependencies" do
+        let(:external_dependencies) { true }
+        let(:labels) { default_labels.merge(external_dependencies: "yes") }
 
-      expect(queue_duration_seconds).to receive(:observe).with(labels, queue_duration_for_job) if queue_duration_for_job
-      expect(user_execution_seconds_metric).to receive(:observe).with(labels_with_job_status, thread_cputime_duration)
-      expect(completion_seconds_metric).to receive(:observe).with(labels_with_job_status, monotonic_time_duration)
-    end
+        it_behaves_like "a metrics middleware"
+      end
 
-    it 'yields block' do
-      expect { |b| middleware.call(worker, job, :test, &b) }.to yield_control.once
-    end
+      context "cpu boundary" do
+        let(:resource_boundary) { :cpu }
+        let(:labels) { default_labels.merge(boundary: "cpu") }
 
-    it 'sets queue specific metrics' do
-      middleware.call(worker, job, :test) { nil }
-    end
+        it_behaves_like "a metrics middleware"
+      end
 
-    context 'when job_duration is not available' do
-      let(:queue_duration_for_job) { nil }
+      context "memory boundary" do
+        let(:resource_boundary) { :memory }
+        let(:labels) { default_labels.merge(boundary: "memory") }
 
-      it 'does not set the queue_duration_seconds histogram' do
-        middleware.call(worker, job, :test) { nil }
+        it_behaves_like "a metrics middleware"
       end
-    end
 
-    context 'when job is retried' do
-      let(:job) { { 'retry_count' => 1 } }
+      context "feature category" do
+        let(:feature_category) { :authentication }
+        let(:labels) { default_labels.merge(feature_category: "authentication") }
 
-      it 'sets sidekiq_jobs_retried_total metric' do
-        expect(retried_total_metric).to receive(:increment)
-
-        middleware.call(worker, job, :test) { nil }
+        it_behaves_like "a metrics middleware"
       end
-    end
-
-    context 'when error is raised' do
-      let(:job_status) { :fail }
 
-      it 'sets sidekiq_jobs_failed_total and reraises' do
-        expect(failed_total_metric).to receive(:increment).with(labels, 1)
+      context "combined" do
+        let(:latency_sensitive) { true }
+        let(:external_dependencies) { true }
+        let(:resource_boundary) { :cpu }
+        let(:feature_category) { :authentication }
+        let(:labels) { default_labels.merge(latency_sensitive: "yes", external_dependencies: "yes", boundary: "cpu", feature_category: "authentication") }
 
-        expect { middleware.call(worker, job, :test) { raise StandardError, "Failed" } }.to raise_error(StandardError, "Failed")
+        it_behaves_like "a metrics middleware"
       end
     end
   end
diff --git a/spec/models/concerns/issuable_spec.rb b/spec/models/concerns/issuable_spec.rb
index f7bef9e71e2..4a6a9026f77 100644
--- a/spec/models/concerns/issuable_spec.rb
+++ b/spec/models/concerns/issuable_spec.rb
@@ -852,4 +852,77 @@ describe Issuable do
       it_behaves_like 'matches_cross_reference_regex? fails fast'
     end
   end
+
+  describe 'release scopes' do
+    let_it_be(:project) { create(:project) }
+
+    let_it_be(:release_1) { create(:release, tag: 'v1.0', project: project) }
+    let_it_be(:release_2) { create(:release, tag: 'v2.0', project: project) }
+    let_it_be(:release_3) { create(:release, tag: 'v3.0', project: project) }
+    let_it_be(:release_4) { create(:release, tag: 'v4.0', project: project) }
+
+    let_it_be(:milestone_1) { create(:milestone, releases: [release_1], title: 'm1', project: project) }
+    let_it_be(:milestone_2) { create(:milestone, releases: [release_1, release_2], title: 'm2', project: project) }
+    let_it_be(:milestone_3) { create(:milestone, releases: [release_2, release_4], title: 'm3', project: project) }
+    let_it_be(:milestone_4) { create(:milestone, releases: [release_3], title: 'm4', project: project) }
+    let_it_be(:milestone_5) { create(:milestone, releases: [release_3], title: 'm5', project: project) }
+    let_it_be(:milestone_6) { create(:milestone, title: 'm6', project: project) }
+
+    let_it_be(:issue_1) { create(:issue, milestone: milestone_1, project: project) }
+    let_it_be(:issue_2) { create(:issue, milestone: milestone_1, project: project) }
+    let_it_be(:issue_3) { create(:issue, milestone: milestone_2, project: project) }
+    let_it_be(:issue_4) { create(:issue, milestone: milestone_5, project: project) }
+    let_it_be(:issue_5) { create(:issue, milestone: milestone_6, project: project) }
+    let_it_be(:issue_6) { create(:issue, project: project) }
+
+    let_it_be(:items) { Issue.all }
+
+    describe '#without_release' do
+      it 'returns the issues not tied to any milestone and the ones tied to milestone with no release' do
+        expect(items.without_release).to contain_exactly(issue_5, issue_6)
+      end
+    end
+
+    describe '#any_release' do
+      it 'returns all issues tied to a release' do
+        expect(items.any_release).to contain_exactly(issue_1, issue_2, issue_3, issue_4)
+      end
+    end
+
+    describe '#with_release' do
+      it 'returns the issues tied a specfic release' do
+        expect(items.with_release('v1.0', project.id)).to contain_exactly(issue_1, issue_2, issue_3)
+      end
+
+      context 'when a release has a milestone with one issue and another one with no issue' do
+        it 'returns that one issue' do
+          expect(items.with_release('v2.0', project.id)).to contain_exactly(issue_3)
+        end
+
+        context 'when the milestone with no issue is added as a filter' do
+          it 'returns an empty list' do
+            expect(items.with_release('v2.0', project.id).with_milestone('m3')).to be_empty
+          end
+        end
+
+        context 'when the milestone with the issue is added as a filter' do
+          it 'returns this issue' do
+            expect(items.with_release('v2.0', project.id).with_milestone('m2')).to contain_exactly(issue_3)
+          end
+        end
+      end
+
+      context 'when there is no issue under a specific release' do
+        it 'returns no issue' do
+          expect(items.with_release('v4.0', project.id)).to be_empty
+        end
+      end
+
+      context 'when a non-existent release tag is passed in' do
+        it 'returns no issue' do
+          expect(items.with_release('v999.0', project.id)).to be_empty
+        end
+      end
+    end
+  end
 end