Merge branch 'master' into bootstrap4

55 files changed, 1494 insertions, 540 deletions

diff --git a/spec/controllers/projects/pipelines_controller_spec.rb b/spec/controllers/projects/pipelines_controller_spec.rb
index a451bbb97b6..9e7bc20a6d1 100644
--- a/spec/controllers/projects/pipelines_controller_spec.rb
+++ b/spec/controllers/projects/pipelines_controller_spec.rb
@@ -35,10 +35,16 @@ describe Projects::PipelinesController do
 
       expect(json_response).to include('pipelines')
       expect(json_response['pipelines'].count).to eq 4
-      expect(json_response['count']['all']).to eq 4
-      expect(json_response['count']['running']).to eq 1
-      expect(json_response['count']['pending']).to eq 1
-      expect(json_response['count']['finished']).to eq 1
+      expect(json_response['count']['all']).to eq '4'
+      expect(json_response['count']['running']).to eq '1'
+      expect(json_response['count']['pending']).to eq '1'
+      expect(json_response['count']['finished']).to eq '1'
+    end
+
+    it 'does not include coverage data for the pipelines' do
+      subject
+
+      expect(json_response['pipelines'][0]).not_to include('coverage')
     end
 
     context 'when performing gitaly calls', :request_store do
diff --git a/spec/factories/gitaly/tag.rb b/spec/factories/gitaly/tag.rb
new file mode 100644
index 00000000000..e99776d524a
--- /dev/null
+++ b/spec/factories/gitaly/tag.rb
@@ -0,0 +1,9 @@
+FactoryBot.define do
+  factory :gitaly_tag, class: Gitaly::Tag do
+    skip_create
+
+    name { 'v3.1.4' }
+    message { 'Pie release' }
+    target_commit factory: :gitaly_commit
+  end
+end
diff --git a/spec/features/projects/environments/environments_spec.rb b/spec/features/projects/environments/environments_spec.rb
index 5248a783db4..f9defa22d35 100644
--- a/spec/features/projects/environments/environments_spec.rb
+++ b/spec/features/projects/environments/environments_spec.rb
@@ -42,6 +42,22 @@ feature 'Environments page', :js do
           expect(page).to have_content('You don\'t have any environments right now')
         end
       end
+
+      context 'when cluster is not reachable' do
+        let!(:cluster) { create(:cluster, :provided_by_gcp, projects: [project]) }
+        let!(:application_prometheus) { create(:clusters_applications_prometheus, :installed, cluster: cluster) }
+
+        before do
+          allow_any_instance_of(Kubeclient::Client).to receive(:proxy_url).and_raise(Kubeclient::HttpError.new(401, 'Unauthorized', nil))
+        end
+
+        it 'should show one environment without error' do
+          visit_environments(project, scope: 'available')
+
+          expect(page).to have_css('.environments-container')
+          expect(page.all('.environment-name').length).to eq(1)
+        end
+      end
     end
 
     describe 'with one stopped environment' do
diff --git a/spec/features/projects/user_uses_shortcuts_spec.rb b/spec/features/projects/user_uses_shortcuts_spec.rb
index 47c5a8161d9..495a010b32c 100644
--- a/spec/features/projects/user_uses_shortcuts_spec.rb
+++ b/spec/features/projects/user_uses_shortcuts_spec.rb
@@ -13,6 +13,8 @@ describe 'User uses shortcuts', :js do
 
   context 'when navigating to the Project pages' do
     it 'redirects to the details page' do
+      visit project_issues_path(project)
+
       find('body').native.send_key('g')
       find('body').native.send_key('p')
 
@@ -22,7 +24,7 @@ describe 'User uses shortcuts', :js do
 
     it 'redirects to the activity page' do
       find('body').native.send_key('g')
-      find('body').native.send_key('e')
+      find('body').native.send_key('v')
 
       expect(page).to have_active_navigation('Project')
       expect(page).to have_active_sub_navigation('Activity')
@@ -72,10 +74,19 @@ describe 'User uses shortcuts', :js do
       expect(page).to have_active_sub_navigation('List')
     end
 
+    it 'redirects to the issue board page' do
+      find('body').native.send_key('g')
+      find('body').native.send_key('b')
+
+      expect(page).to have_active_navigation('Issues')
+      expect(page).to have_active_sub_navigation('Board')
+    end
+
     it 'redirects to the new issue page' do
       find('body').native.send_key('i')
 
       expect(page).to have_content(project.title)
+      expect(page).to have_content('New Issue')
     end
   end
 
@@ -88,6 +99,34 @@ describe 'User uses shortcuts', :js do
     end
   end
 
+  context 'when navigating to the CI / CD pages' do
+    it 'redirects to the Jobs page' do
+      find('body').native.send_key('g')
+      find('body').native.send_key('j')
+
+      expect(page).to have_active_navigation('CI / CD')
+      expect(page).to have_active_sub_navigation('Jobs')
+    end
+  end
+
+  context 'when navigating to the Operations pages' do
+    it 'redirects to the Environments page' do
+      find('body').native.send_key('g')
+      find('body').native.send_key('e')
+
+      expect(page).to have_active_navigation('Operations')
+      expect(page).to have_active_sub_navigation('Environments')
+    end
+
+    it 'redirects to the Kubernetes page' do
+      find('body').native.send_key('g')
+      find('body').native.send_key('k')
+
+      expect(page).to have_active_navigation('Operations')
+      expect(page).to have_active_sub_navigation('Kubernetes')
+    end
+  end
+
   context 'when navigating to the Snippets pages' do
     it 'redirects to the snippets page' do
       find('body').native.send_key('g')
diff --git a/spec/features/projects/wiki/markdown_preview_spec.rb b/spec/features/projects/wiki/markdown_preview_spec.rb
index 6586ccaa400..e473739a6aa 100644
--- a/spec/features/projects/wiki/markdown_preview_spec.rb
+++ b/spec/features/projects/wiki/markdown_preview_spec.rb
@@ -155,4 +155,27 @@ feature 'Projects > Wiki > User previews markdown changes', :js do
       end
     end
   end
+
+  it "does not linkify double brackets inside code blocks as expected" do
+    click_link 'New page'
+    page.within '#modal-new-wiki' do
+      fill_in :new_wiki_path, with: 'linkify_test'
+      click_button 'Create page'
+    end
+
+    page.within '.wiki-form' do
+      fill_in :wiki_content, with: <<-HEREDOC
+        `[[do_not_linkify]]`
+        ```
+        [[also_do_not_linkify]]
+        ```
+      HEREDOC
+      click_on "Preview"
+    end
+
+    expect(page).to have_content("do_not_linkify")
+
+    expect(page.html).to include('[[do_not_linkify]]')
+    expect(page.html).to include('[[also_do_not_linkify]]')
+  end
 end
diff --git a/spec/features/users/user_browses_projects_on_user_page_spec.rb b/spec/features/users/user_browses_projects_on_user_page_spec.rb
index a70637c8370..7bede0b0d48 100644
--- a/spec/features/users/user_browses_projects_on_user_page_spec.rb
+++ b/spec/features/users/user_browses_projects_on_user_page_spec.rb
@@ -27,8 +27,8 @@ describe 'Users > User browses projects on user page', :js do
   end
 
   it 'paginates projects', :js do
-    project = create(:project, namespace: user.namespace)
-    project2 = create(:project, namespace: user.namespace)
+    project = create(:project, namespace: user.namespace, updated_at: 2.minutes.since)
+    project2 = create(:project, namespace: user.namespace, updated_at: 1.minute.since)
     allow(Project).to receive(:default_per_page).and_return(1)
 
     sign_in(user)
@@ -41,11 +41,11 @@ describe 'Users > User browses projects on user page', :js do
 
     wait_for_requests
 
-    expect(page).to have_content(project2.name)
+    expect(page).to have_content(project.name)
 
     click_link('Next')
 
-    expect(page).to have_content(project.name)
+    expect(page).to have_content(project2.name)
   end
 
   context 'when not signed in' do
diff --git a/spec/finders/issues_finder_spec.rb b/spec/finders/issues_finder_spec.rb
index 45439640ea3..74e91b02f0f 100644
--- a/spec/finders/issues_finder_spec.rb
+++ b/spec/finders/issues_finder_spec.rb
@@ -372,7 +372,7 @@ describe IssuesFinder do
     end
 
     context 'personal scope' do
-      let(:scope) { 'assigned-to-me' }
+      let(:scope) { 'assigned_to_me' }
 
       it 'returns issue assigned to the user' do
         expect(issues).to contain_exactly(issue1, issue2)
diff --git a/spec/finders/personal_projects_finder_spec.rb b/spec/finders/personal_projects_finder_spec.rb
index 5e52898e9c0..00c551a1f65 100644
--- a/spec/finders/personal_projects_finder_spec.rb
+++ b/spec/finders/personal_projects_finder_spec.rb
@@ -4,14 +4,16 @@ describe PersonalProjectsFinder do
   let(:source_user)     { create(:user) }
   let(:current_user)    { create(:user) }
   let(:finder)          { described_class.new(source_user) }
-  let!(:public_project) { create(:project, :public, namespace: source_user.namespace) }
+  let!(:public_project) do
+    create(:project, :public, namespace: source_user.namespace, updated_at: 1.hour.ago)
+  end
 
   let!(:private_project) do
-    create(:project, :private, namespace: source_user.namespace, path: 'mepmep')
+    create(:project, :private, namespace: source_user.namespace, updated_at: 3.hours.ago, path: 'mepmep')
   end
 
   let!(:internal_project) do
-    create(:project, :internal, namespace: source_user.namespace, path: 'C')
+    create(:project, :internal, namespace: source_user.namespace, updated_at: 2.hours.ago, path: 'C')
   end
 
   before do
@@ -28,7 +30,7 @@ describe PersonalProjectsFinder do
     subject { finder.execute(current_user) }
 
     context 'normal user' do
-      it { is_expected.to eq([internal_project, private_project, public_project]) }
+      it { is_expected.to eq([public_project, internal_project, private_project]) }
     end
 
     context 'external' do
@@ -36,7 +38,7 @@ describe PersonalProjectsFinder do
         current_user.update_attributes(external: true)
       end
 
-      it { is_expected.to eq([private_project, public_project]) }
+      it { is_expected.to eq([public_project, private_project]) }
     end
   end
 end
diff --git a/spec/javascripts/environments/environments_app_spec.js b/spec/javascripts/environments/environments_app_spec.js
index e4c3bf2bef1..615168645b4 100644
--- a/spec/javascripts/environments/environments_app_spec.js
+++ b/spec/javascripts/environments/environments_app_spec.js
@@ -1,8 +1,8 @@
-import _ from 'underscore';
 import Vue from 'vue';
+import MockAdapter from 'axios-mock-adapter';
+import axios from '~/lib/utils/axios_utils';
 import environmentsComponent from '~/environments/components/environments_app.vue';
 import mountComponent from 'spec/helpers/vue_mount_component_helper';
-import { headersInterceptor } from 'spec/helpers/vue_resource_helper';
 import { environment, folder } from './mock_data';
 
 describe('Environment', () => {
@@ -18,103 +18,76 @@ describe('Environment', () => {
 
   let EnvironmentsComponent;
   let component;
+  let mock;
 
   beforeEach(() => {
+    mock = new MockAdapter(axios);
+
     EnvironmentsComponent = Vue.extend(environmentsComponent);
   });
 
+  afterEach(() => {
+    component.$destroy();
+    mock.restore();
+  });
+
   describe('successfull request', () => {
     describe('without environments', () => {
-      const environmentsEmptyResponseInterceptor = (request, next) => {
-        next(request.respondWith(JSON.stringify([]), {
-          status: 200,
-        }));
-      };
-
-      beforeEach(() => {
-        Vue.http.interceptors.push(environmentsEmptyResponseInterceptor);
-        Vue.http.interceptors.push(headersInterceptor);
-      });
-
-      afterEach(() => {
-        Vue.http.interceptors = _.without(
-          Vue.http.interceptors, environmentsEmptyResponseInterceptor,
-        );
-        Vue.http.interceptors = _.without(Vue.http.interceptors, headersInterceptor);
-      });
+      beforeEach((done) => {
+        mock.onGet(mockData.endpoint).reply(200, { environments: [] });
 
-      it('should render the empty state', (done) => {
         component = mountComponent(EnvironmentsComponent, mockData);
 
         setTimeout(() => {
-          expect(
-            component.$el.querySelector('.js-new-environment-button').textContent,
-          ).toContain('New environment');
-
-          expect(
-            component.$el.querySelector('.js-blank-state-title').textContent,
-          ).toContain('You don\'t have any environments right now.');
-
           done();
         }, 0);
       });
+
+      it('should render the empty state', () => {
+        expect(
+          component.$el.querySelector('.js-new-environment-button').textContent,
+        ).toContain('New environment');
+
+        expect(
+          component.$el.querySelector('.js-blank-state-title').textContent,
+        ).toContain('You don\'t have any environments right now.');
+      });
     });
 
     describe('with paginated environments', () => {
-      let backupInterceptors;
-      const environmentsResponseInterceptor = (request, next) => {
-        next((response) => {
-          response.headers.set('X-nExt-pAge', '2');
-        });
-
-        next(request.respondWith(JSON.stringify({
+      beforeEach((done) => {
+        mock.onGet(mockData.endpoint).reply(200, {
           environments: [environment],
           stopped_count: 1,
           available_count: 0,
-        }), {
-          status: 200,
-          headers: {
-            'X-nExt-pAge': '2',
-            'x-page': '1',
-            'X-Per-Page': '1',
-            'X-Prev-Page': '',
-            'X-TOTAL': '37',
-            'X-Total-Pages': '2',
-          },
-        }));
-      };
-
-      beforeEach(() => {
-        backupInterceptors = Vue.http.interceptors;
-        Vue.http.interceptors = [
-          environmentsResponseInterceptor,
-          headersInterceptor,
-        ];
-        component = mountComponent(EnvironmentsComponent, mockData);
-      });
+        }, {
+          'X-nExt-pAge': '2',
+          'x-page': '1',
+          'X-Per-Page': '1',
+          'X-Prev-Page': '',
+          'X-TOTAL': '37',
+          'X-Total-Pages': '2',
+        });
 
-      afterEach(() => {
-        Vue.http.interceptors = backupInterceptors;
-      });
+        component = mountComponent(EnvironmentsComponent, mockData);
 
-      it('should render a table with environments', (done) => {
         setTimeout(() => {
-          expect(component.$el.querySelectorAll('table')).not.toBeNull();
-          expect(
-            component.$el.querySelector('.environment-name').textContent.trim(),
-          ).toEqual(environment.name);
           done();
         }, 0);
       });
 
+      it('should render a table with environments', () => {
+        expect(component.$el.querySelectorAll('table')).not.toBeNull();
+        expect(
+          component.$el.querySelector('.environment-name').textContent.trim(),
+        ).toEqual(environment.name);
+      });
+
       describe('pagination', () => {
-        it('should render pagination', (done) => {
-          setTimeout(() => {
-            expect(
-              component.$el.querySelectorAll('.gl-pagination li').length,
-            ).toEqual(5);
-            done();
-          }, 0);
+        it('should render pagination', () => {
+          expect(
+            component.$el.querySelectorAll('.gl-pagination li').length,
+          ).toEqual(5);
         });
 
         it('should make an API request when page is clicked', (done) => {
@@ -133,50 +106,39 @@ describe('Environment', () => {
 
             expect(component.updateContent).toHaveBeenCalledWith({ scope: 'stopped', page: '1' });
             done();
-          });
+          }, 0);
         });
       });
     });
   });
 
   describe('unsuccessfull request', () => {
-    const environmentsErrorResponseInterceptor = (request, next) => {
-      next(request.respondWith(JSON.stringify([]), {
-        status: 500,
-      }));
-    };
-
-    beforeEach(() => {
-      Vue.http.interceptors.push(environmentsErrorResponseInterceptor);
-    });
+    beforeEach((done) => {
+      mock.onGet(mockData.endpoint).reply(500, {});
 
-    afterEach(() => {
-      Vue.http.interceptors = _.without(
-        Vue.http.interceptors, environmentsErrorResponseInterceptor,
-      );
-    });
-
-    it('should render empty state', (done) => {
       component = mountComponent(EnvironmentsComponent, mockData);
 
       setTimeout(() => {
-        expect(
-          component.$el.querySelector('.js-blank-state-title').textContent,
-        ).toContain('You don\'t have any environments right now.');
         done();
       }, 0);
     });
+
+    it('should render empty state', () => {
+      expect(
+        component.$el.querySelector('.js-blank-state-title').textContent,
+      ).toContain('You don\'t have any environments right now.');
+    });
   });
 
   describe('expandable folders', () => {
-    const environmentsResponseInterceptor = (request, next) => {
-      next(request.respondWith(JSON.stringify({
-        environments: [folder],
-        stopped_count: 0,
-        available_count: 1,
-      }), {
-        status: 200,
-        headers: {
+    beforeEach(() => {
+      mock.onGet(mockData.endpoint).reply(200,
+        {
+          environments: [folder],
+          stopped_count: 0,
+          available_count: 1,
+        },
+        {
           'X-nExt-pAge': '2',
           'x-page': '1',
           'X-Per-Page': '1',
@@ -184,18 +146,11 @@ describe('Environment', () => {
           'X-TOTAL': '37',
           'X-Total-Pages': '2',
         },
-      }));
-    };
+      );
 
-    beforeEach(() => {
-      Vue.http.interceptors.push(environmentsResponseInterceptor);
-      component = mountComponent(EnvironmentsComponent, mockData);
-    });
+      mock.onGet(environment.folder_path).reply(200, { environments: [environment] });
 
-    afterEach(() => {
-      Vue.http.interceptors = _.without(
-        Vue.http.interceptors, environmentsResponseInterceptor,
-      );
+      component = mountComponent(EnvironmentsComponent, mockData);
     });
 
     it('should open a closed folder', (done) => {
@@ -211,7 +166,7 @@ describe('Environment', () => {
           ).not.toContain('display: none');
           done();
         });
-      });
+      }, 0);
     });
 
     it('should close an opened folder', (done) => {
@@ -233,7 +188,7 @@ describe('Environment', () => {
             done();
           });
         });
-      });
+      }, 0);
     });
 
     it('should show children environments and a button to show all environments', (done) => {
@@ -242,49 +197,32 @@ describe('Environment', () => {
         component.$el.querySelector('.folder-name').click();
 
         Vue.nextTick(() => {
-          const folderInterceptor = (request, next) => {
-            next(request.respondWith(JSON.stringify({
-              environments: [environment],
-            }), { status: 200 }));
-          };
-
-          Vue.http.interceptors.push(folderInterceptor);
-
           // wait for next async request
           setTimeout(() => {
             expect(component.$el.querySelectorAll('.js-child-row').length).toEqual(1);
             expect(component.$el.querySelector('.text-center > a.btn').textContent).toContain('Show all');
-
-            Vue.http.interceptors = _.without(Vue.http.interceptors, folderInterceptor);
             done();
           });
         });
-      });
+      }, 0);
     });
   });
 
   describe('methods', () => {
-    const environmentsEmptyResponseInterceptor = (request, next) => {
-      next(request.respondWith(JSON.stringify([]), {
-        status: 200,
-      }));
-    };
-
     beforeEach(() => {
-      Vue.http.interceptors.push(environmentsEmptyResponseInterceptor);
-      Vue.http.interceptors.push(headersInterceptor);
+      mock.onGet(mockData.endpoint).reply(200,
+        {
+          environments: [],
+          stopped_count: 0,
+          available_count: 1,
+        },
+        {},
+      );
 
       component = mountComponent(EnvironmentsComponent, mockData);
       spyOn(history, 'pushState').and.stub();
     });
 
-    afterEach(() => {
-      Vue.http.interceptors = _.without(
-        Vue.http.interceptors, environmentsEmptyResponseInterceptor,
-      );
-      Vue.http.interceptors = _.without(Vue.http.interceptors, headersInterceptor);
-    });
-
     describe('updateContent', () => {
       it('should set given parameters', (done) => {
         component.updateContent({ scope: 'stopped', page: '3' })
diff --git a/spec/javascripts/environments/folder/environments_folder_view_spec.js b/spec/javascripts/environments/folder/environments_folder_view_spec.js
index 906a1116974..f5ce4df0bfe 100644
--- a/spec/javascripts/environments/folder/environments_folder_view_spec.js
+++ b/spec/javascripts/environments/folder/environments_folder_view_spec.js
@@ -1,13 +1,15 @@
-import _ from 'underscore';
 import Vue from 'vue';
+import MockAdapter from 'axios-mock-adapter';
+import axios from '~/lib/utils/axios_utils';
 import environmentsFolderViewComponent from '~/environments/folder/environments_folder_view.vue';
-import { headersInterceptor } from 'spec/helpers/vue_resource_helper';
 import mountComponent from 'spec/helpers/vue_mount_component_helper';
 import { environmentsList } from '../mock_data';
 
 describe('Environments Folder View', () => {
   let Component;
   let component;
+  let mock;
+
   const mockData = {
     endpoint: 'environments.json',
     folderName: 'review',
@@ -17,46 +19,35 @@ describe('Environments Folder View', () => {
   };
 
   beforeEach(() => {
+    mock = new MockAdapter(axios);
+
     Component = Vue.extend(environmentsFolderViewComponent);
   });
 
   afterEach(() => {
+    mock.restore();
+
     component.$destroy();
   });
 
   describe('successfull request', () => {
-    const environmentsResponseInterceptor = (request, next) => {
-      next(request.respondWith(JSON.stringify({
+    beforeEach(() => {
+      mock.onGet(mockData.endpoint).reply(200, {
         environments: environmentsList,
         stopped_count: 1,
         available_count: 0,
-      }), {
-        status: 200,
-        headers: {
-          'X-nExt-pAge': '2',
-          'x-page': '1',
-          'X-Per-Page': '2',
-          'X-Prev-Page': '',
-          'X-TOTAL': '20',
-          'X-Total-Pages': '10',
-        },
-      }));
-    };
-
-    beforeEach(() => {
-      Vue.http.interceptors.push(environmentsResponseInterceptor);
-      Vue.http.interceptors.push(headersInterceptor);
+      }, {
+        'X-nExt-pAge': '2',
+        'x-page': '1',
+        'X-Per-Page': '2',
+        'X-Prev-Page': '',
+        'X-TOTAL': '20',
+        'X-Total-Pages': '10',
+      });
 
       component = mountComponent(Component, mockData);
     });
 
-    afterEach(() => {
-      Vue.http.interceptors = _.without(
-        Vue.http.interceptors, environmentsResponseInterceptor,
-      );
-      Vue.http.interceptors = _.without(Vue.http.interceptors, headersInterceptor);
-    });
-
     it('should render a table with environments', (done) => {
       setTimeout(() => {
         expect(component.$el.querySelectorAll('table')).not.toBeNull();
@@ -135,25 +126,15 @@ describe('Environments Folder View', () => {
   });
 
   describe('unsuccessfull request', () => {
-    const environmentsErrorResponseInterceptor = (request, next) => {
-      next(request.respondWith(JSON.stringify([]), {
-        status: 500,
-      }));
-    };
-
     beforeEach(() => {
-      Vue.http.interceptors.push(environmentsErrorResponseInterceptor);
-    });
+      mock.onGet(mockData.endpoint).reply(500, {
+        environments: [],
+      });
 
-    afterEach(() => {
-      Vue.http.interceptors = _.without(
-        Vue.http.interceptors, environmentsErrorResponseInterceptor,
-      );
+      component = mountComponent(Component, mockData);
     });
 
     it('should not render a table', (done) => {
-      component = mountComponent(Component, mockData);
-
       setTimeout(() => {
         expect(
           component.$el.querySelector('table'),
@@ -190,27 +171,15 @@ describe('Environments Folder View', () => {
   });
 
   describe('methods', () => {
-    const environmentsEmptyResponseInterceptor = (request, next) => {
-      next(request.respondWith(JSON.stringify([]), {
-        status: 200,
-      }));
-    };
-
     beforeEach(() => {
-      Vue.http.interceptors.push(environmentsEmptyResponseInterceptor);
-      Vue.http.interceptors.push(headersInterceptor);
+      mock.onGet(mockData.endpoint).reply(200, {
+        environments: [],
+      });
 
       component = mountComponent(Component, mockData);
       spyOn(history, 'pushState').and.stub();
     });
 
-    afterEach(() => {
-      Vue.http.interceptors = _.without(
-        Vue.http.interceptors, environmentsEmptyResponseInterceptor,
-      );
-      Vue.http.interceptors = _.without(Vue.http.interceptors, headersInterceptor);
-    });
-
     describe('updateContent', () => {
       it('should set given parameters', (done) => {
         component.updateContent({ scope: 'stopped', page: '4' })
diff --git a/spec/javascripts/environments/mock_data.js b/spec/javascripts/environments/mock_data.js
index 15e11aa686b..8a1e26935d9 100644
--- a/spec/javascripts/environments/mock_data.js
+++ b/spec/javascripts/environments/mock_data.js
@@ -82,6 +82,7 @@ export const environment = {
     stop_path: '/root/review-app/environments/7/stop',
     created_at: '2017-01-31T10:53:46.894Z',
     updated_at: '2017-01-31T10:53:46.894Z',
+    folder_path: '/root/review-app/environments/7',
   },
 };
 
diff --git a/spec/javascripts/pipelines/graph/action_component_spec.js b/spec/javascripts/pipelines/graph/action_component_spec.js
index d646bef96f5..568e679abe9 100644
--- a/spec/javascripts/pipelines/graph/action_component_spec.js
+++ b/spec/javascripts/pipelines/graph/action_component_spec.js
@@ -1,13 +1,19 @@
 import Vue from 'vue';
+import MockAdapter from 'axios-mock-adapter';
+import axios from '~/lib/utils/axios_utils';
 import actionComponent from '~/pipelines/components/graph/action_component.vue';
-import eventHub from '~/pipelines/event_hub';
 import mountComponent from '../../helpers/vue_mount_component_helper';
 
 describe('pipeline graph action component', () => {
   let component;
+  let mock;
 
   beforeEach(done => {
     const ActionComponent = Vue.extend(actionComponent);
+    mock = new MockAdapter(axios);
+
+    mock.onPost('foo.json').reply(200);
+
     component = mountComponent(ActionComponent, {
       tooltipText: 'bar',
       link: 'foo',
@@ -18,15 +24,10 @@ describe('pipeline graph action component', () => {
   });
 
   afterEach(() => {
+    mock.restore();
     component.$destroy();
   });
 
-  it('should emit an event with the provided link', () => {
-    eventHub.$on('postAction', link => {
-      expect(link).toEqual('foo');
-    });
-  });
-
   it('should render the provided title as a bootstrap tooltip', () => {
     expect(component.$el.getAttribute('data-original-title')).toEqual('bar');
   });
@@ -34,10 +35,12 @@ describe('pipeline graph action component', () => {
   it('should update bootstrap tooltip when title changes', done => {
     component.tooltipText = 'changed';
 
-    setTimeout(() => {
+    component.$nextTick()
+    .then(() => {
       expect(component.$el.getAttribute('data-original-title')).toBe('changed');
-      done();
-    });
+    })
+    .then(done)
+    .catch(done.fail);
   });
 
   it('should render an svg', () => {
@@ -45,44 +48,18 @@ describe('pipeline graph action component', () => {
     expect(component.$el.querySelector('svg')).toBeDefined();
   });
 
-  it('disables the button when clicked', done => {
-    component.$el.click();
+  describe('on click', () => {
+    it('emits `pipelineActionRequestComplete` after a successfull request', done => {
+      spyOn(component, '$emit');
 
-    component.$nextTick(() => {
-      expect(component.$el.getAttribute('disabled')).toEqual('disabled');
-      done();
-    });
-  });
-
-  it('re-enabled the button when `requestFinishedFor` matches `linkRequested`', done => {
-    component.$el.click();
-
-    component
-      .$nextTick()
-      .then(() => {
-        expect(component.$el.getAttribute('disabled')).toEqual('disabled');
-        component.requestFinishedFor = 'foo';
-      })
-      .then(() => {
-        expect(component.$el.getAttribute('disabled')).toBeNull();
-      })
-      .then(done)
-      .catch(done.fail);
-  });
-
-  it('does not re-enable the button when `requestFinishedFor` does not matches `linkRequested`', done => {
-    component.$el.click();
+      component.$el.click();
 
-    component
-      .$nextTick()
-      .then(() => {
-        expect(component.$el.getAttribute('disabled')).toEqual('disabled');
-        component.requestFinishedFor = 'bar';
-      })
-      .then(() => {
-        expect(component.$el.getAttribute('disabled')).toEqual('disabled');
-      })
-      .then(done)
-      .catch(done.fail);
+      component.$nextTick()
+        .then(() => {
+          expect(component.$emit).toHaveBeenCalledWith('pipelineActionRequestComplete');
+        })
+        .then(done)
+        .catch(done.fail);
+    });
   });
 });
diff --git a/spec/javascripts/pipelines/stage_spec.js b/spec/javascripts/pipelines/stage_spec.js
index 75156e7bdfd..16f6db39d6a 100644
--- a/spec/javascripts/pipelines/stage_spec.js
+++ b/spec/javascripts/pipelines/stage_spec.js
@@ -102,4 +102,31 @@ describe('Pipelines stage component', () => {
       });
     });
   });
+
+  describe('pipelineActionRequestComplete', () => {
+    beforeEach(() => {
+      mock.onGet('path.json').reply(200, stageReply);
+
+      mock.onPost(`${stageReply.latest_statuses[0].status.action.path}.json`).reply(200);
+    });
+
+    describe('within pipeline table', () => {
+      it('emits `refreshPipelinesTable` event when `pipelineActionRequestComplete` is triggered', done => {
+        spyOn(eventHub, '$emit');
+
+        component.type = 'PIPELINES_TABLE';
+        component.$el.querySelector('button').click();
+
+        setTimeout(() => {
+          component.$el.querySelector('.js-ci-action').click();
+          component.$nextTick()
+          .then(() => {
+            expect(eventHub.$emit).toHaveBeenCalledWith('refreshPipelinesTable');
+          })
+          .then(done)
+          .catch(done.fail);
+        }, 0);
+      });
+    });
+  });
 });
diff --git a/spec/lib/banzai/filter/gollum_tags_filter_spec.rb b/spec/lib/banzai/filter/gollum_tags_filter_spec.rb
index ca76d6f0881..0e178b859c4 100644
--- a/spec/lib/banzai/filter/gollum_tags_filter_spec.rb
+++ b/spec/lib/banzai/filter/gollum_tags_filter_spec.rb
@@ -91,6 +91,12 @@ describe Banzai::Filter::GollumTagsFilter do
       expect(doc.at_css('a').text).to eq 'link-text'
       expect(doc.at_css('a')['href']).to eq expected_path
     end
+
+    it "inside back ticks will be exempt from linkification" do
+      doc = filter('<code>[[link-in-backticks]]</code>', project_wiki: project_wiki)
+
+      expect(doc.at_css('code').text).to eq '[[link-in-backticks]]'
+    end
   end
 
   context 'table of contents' do
diff --git a/spec/lib/gitlab/auth/ldap/access_spec.rb b/spec/lib/gitlab/auth/ldap/access_spec.rb
index 6b251d824f7..eff21985108 100644
--- a/spec/lib/gitlab/auth/ldap/access_spec.rb
+++ b/spec/lib/gitlab/auth/ldap/access_spec.rb
@@ -8,6 +8,7 @@ describe Gitlab::Auth::LDAP::Access do
 
   describe '.allowed?' do
     it 'updates the users `last_credential_check_at' do
+      allow(access).to receive(:update_user)
       expect(access).to receive(:allowed?) { true }
       expect(described_class).to receive(:open).and_yield(access)
 
@@ -16,12 +17,21 @@ describe Gitlab::Auth::LDAP::Access do
     end
   end
 
+  describe '#find_ldap_user' do
+    it 'finds a user by dn first' do
+      expect(Gitlab::Auth::LDAP::Person).to receive(:find_by_dn).and_return(:ldap_user)
+
+      access.find_ldap_user
+    end
+  end
+
   describe '#allowed?' do
     subject { access.allowed? }
 
     context 'when the user cannot be found' do
       before do
         allow(Gitlab::Auth::LDAP::Person).to receive(:find_by_dn).and_return(nil)
+        allow(Gitlab::Auth::LDAP::Person).to receive(:find_by_email).and_return(nil)
       end
 
       it { is_expected.to be_falsey }
@@ -54,7 +64,7 @@ describe Gitlab::Auth::LDAP::Access do
         end
       end
 
-      context 'and has no disabled flag in active diretory' do
+      context 'and has no disabled flag in active directory' do
         before do
           allow(Gitlab::Auth::LDAP::Person).to receive(:disabled_via_active_directory?).and_return(false)
         end
@@ -100,6 +110,7 @@ describe Gitlab::Auth::LDAP::Access do
         context 'when user cannot be found' do
           before do
             allow(Gitlab::Auth::LDAP::Person).to receive(:find_by_dn).and_return(nil)
+            allow(Gitlab::Auth::LDAP::Person).to receive(:find_by_email).and_return(nil)
           end
 
           it { is_expected.to be_falsey }
diff --git a/spec/lib/gitlab/auth/ldap/config_spec.rb b/spec/lib/gitlab/auth/ldap/config_spec.rb
index 82587e2ba55..d3ab599d5a0 100644
--- a/spec/lib/gitlab/auth/ldap/config_spec.rb
+++ b/spec/lib/gitlab/auth/ldap/config_spec.rb
@@ -23,7 +23,7 @@ describe Gitlab::Auth::LDAP::Config do
     end
 
     it 'raises an error if a unknown provider is used' do
-      expect { described_class.new 'unknown' }.to raise_error(RuntimeError)
+      expect { described_class.new 'unknown' }.to raise_error(described_class::InvalidProvider)
     end
   end
 
@@ -370,4 +370,38 @@ describe Gitlab::Auth::LDAP::Config do
       })
     end
   end
+
+  describe '#base' do
+    context 'when the configured base is not normalized' do
+      it 'returns the normalized base' do
+        stub_ldap_config(options: { 'base' => 'DC=example, DC= com' })
+
+        expect(config.base).to eq('dc=example,dc=com')
+      end
+    end
+
+    context 'when the configured base is normalized' do
+      it 'returns the base unaltered' do
+        stub_ldap_config(options: { 'base' => 'dc=example,dc=com' })
+
+        expect(config.base).to eq('dc=example,dc=com')
+      end
+    end
+
+    context 'when the configured base is malformed' do
+      it 'returns the base unaltered' do
+        stub_ldap_config(options: { 'base' => 'invalid,dc=example,dc=com' })
+
+        expect(config.base).to eq('invalid,dc=example,dc=com')
+      end
+    end
+
+    context 'when the configured base is blank' do
+      it 'returns the base unaltered' do
+        stub_ldap_config(options: { 'base' => '' })
+
+        expect(config.base).to eq('')
+      end
+    end
+  end
 end
diff --git a/spec/lib/gitlab/auth/ldap/user_spec.rb b/spec/lib/gitlab/auth/ldap/user_spec.rb
index 653c19942ea..44bb9d20e47 100644
--- a/spec/lib/gitlab/auth/ldap/user_spec.rb
+++ b/spec/lib/gitlab/auth/ldap/user_spec.rb
@@ -1,6 +1,8 @@
 require 'spec_helper'
 
 describe Gitlab::Auth::LDAP::User do
+  include LdapHelpers
+
   let(:ldap_user) { described_class.new(auth_hash) }
   let(:gl_user) { ldap_user.gl_user }
   let(:info) do
@@ -177,8 +179,7 @@ describe Gitlab::Auth::LDAP::User do
 
   describe 'blocking' do
     def configure_block(value)
-      allow_any_instance_of(Gitlab::Auth::LDAP::Config)
-          .to receive(:block_auto_created_users).and_return(value)
+      stub_ldap_config(block_auto_created_users: value)
     end
 
     context 'signup' do
diff --git a/spec/lib/gitlab/ci/config/entry/policy_spec.rb b/spec/lib/gitlab/ci/config/entry/policy_spec.rb
index 08718c382b9..83d39b82068 100644
--- a/spec/lib/gitlab/ci/config/entry/policy_spec.rb
+++ b/spec/lib/gitlab/ci/config/entry/policy_spec.rb
@@ -111,7 +111,15 @@ describe Gitlab::Ci::Config::Entry::Policy do
     context 'when specifying invalid variables expressions token' do
       let(:config) { { variables: ['$MY_VAR == 123'] } }
 
-      it 'reports an error about invalid statement' do
+      it 'reports an error about invalid expression' do
+        expect(entry.errors).to include /invalid expression syntax/
+      end
+    end
+
+    context 'when using invalid variables expressions regexp' do
+      let(:config) { { variables: ['$MY_VAR =~ /some ( thing/'] } }
+
+      it 'reports an error about invalid expression' do
         expect(entry.errors).to include /invalid expression syntax/
       end
     end
diff --git a/spec/lib/gitlab/ci/pipeline/expression/lexeme/matches_spec.rb b/spec/lib/gitlab/ci/pipeline/expression/lexeme/matches_spec.rb
new file mode 100644
index 00000000000..49e5af52f4d
--- /dev/null
+++ b/spec/lib/gitlab/ci/pipeline/expression/lexeme/matches_spec.rb
@@ -0,0 +1,80 @@
+require 'fast_spec_helper'
+require_dependency 're2'
+
+describe Gitlab::Ci::Pipeline::Expression::Lexeme::Matches do
+  let(:left) { double('left') }
+  let(:right) { double('right') }
+
+  describe '.build' do
+    it 'creates a new instance of the token' do
+      expect(described_class.build('=~', left, right))
+        .to be_a(described_class)
+    end
+  end
+
+  describe '.type' do
+    it 'is an operator' do
+      expect(described_class.type).to eq :operator
+    end
+  end
+
+  describe '#evaluate' do
+    it 'returns false when left and right do not match' do
+      allow(left).to receive(:evaluate).and_return('my-string')
+      allow(right).to receive(:evaluate)
+        .and_return(Gitlab::UntrustedRegexp.new('something'))
+
+      operator = described_class.new(left, right)
+
+      expect(operator.evaluate).to eq false
+    end
+
+    it 'returns true when left and right match' do
+      allow(left).to receive(:evaluate).and_return('my-awesome-string')
+      allow(right).to receive(:evaluate)
+        .and_return(Gitlab::UntrustedRegexp.new('awesome.string$'))
+
+      operator = described_class.new(left, right)
+
+      expect(operator.evaluate).to eq true
+    end
+
+    it 'supports matching against a nil value' do
+      allow(left).to receive(:evaluate).and_return(nil)
+      allow(right).to receive(:evaluate)
+        .and_return(Gitlab::UntrustedRegexp.new('pattern'))
+
+      operator = described_class.new(left, right)
+
+      expect(operator.evaluate).to eq false
+    end
+
+    it 'supports multiline strings' do
+      allow(left).to receive(:evaluate).and_return <<~TEXT
+        My awesome contents
+
+        My-text-string!
+      TEXT
+
+      allow(right).to receive(:evaluate)
+        .and_return(Gitlab::UntrustedRegexp.new('text-string'))
+
+      operator = described_class.new(left, right)
+
+      expect(operator.evaluate).to eq true
+    end
+
+    it 'supports regexp flags' do
+      allow(left).to receive(:evaluate).and_return <<~TEXT
+        My AWESOME content
+      TEXT
+
+      allow(right).to receive(:evaluate)
+        .and_return(Gitlab::UntrustedRegexp.new('(?i)awesome'))
+
+      operator = described_class.new(left, right)
+
+      expect(operator.evaluate).to eq true
+    end
+  end
+end
diff --git a/spec/lib/gitlab/ci/pipeline/expression/lexeme/pattern_spec.rb b/spec/lib/gitlab/ci/pipeline/expression/lexeme/pattern_spec.rb
new file mode 100644
index 00000000000..3ebc2e94727
--- /dev/null
+++ b/spec/lib/gitlab/ci/pipeline/expression/lexeme/pattern_spec.rb
@@ -0,0 +1,96 @@
+require 'fast_spec_helper'
+
+describe Gitlab::Ci::Pipeline::Expression::Lexeme::Pattern do
+  describe '.build' do
+    it 'creates a new instance of the token' do
+      expect(described_class.build('/.*/'))
+        .to be_a(described_class)
+    end
+
+    it 'raises an error if pattern is invalid' do
+      expect { described_class.build('/ some ( thin/i') }
+        .to raise_error(Gitlab::Ci::Pipeline::Expression::Lexer::SyntaxError)
+    end
+  end
+
+  describe '.type' do
+    it 'is a value lexeme' do
+      expect(described_class.type).to eq :value
+    end
+  end
+
+  describe '.scan' do
+    it 'correctly identifies a pattern token' do
+      scanner = StringScanner.new('/pattern/')
+
+      token = described_class.scan(scanner)
+
+      expect(token).not_to be_nil
+      expect(token.build.evaluate)
+        .to eq Gitlab::UntrustedRegexp.new('pattern')
+    end
+
+    it 'is a greedy scanner for regexp boundaries' do
+      scanner = StringScanner.new('/some .* / pattern/')
+
+      token = described_class.scan(scanner)
+
+      expect(token).not_to be_nil
+      expect(token.build.evaluate)
+        .to eq Gitlab::UntrustedRegexp.new('some .* / pattern')
+    end
+
+    it 'does not allow to use an empty pattern' do
+      scanner = StringScanner.new(%(//))
+
+      token = described_class.scan(scanner)
+
+      expect(token).to be_nil
+    end
+
+    it 'support single flag' do
+      scanner = StringScanner.new('/pattern/i')
+
+      token = described_class.scan(scanner)
+
+      expect(token).not_to be_nil
+      expect(token.build.evaluate)
+        .to eq Gitlab::UntrustedRegexp.new('(?i)pattern')
+    end
+
+    it 'support multiple flags' do
+      scanner = StringScanner.new('/pattern/im')
+
+      token = described_class.scan(scanner)
+
+      expect(token).not_to be_nil
+      expect(token.build.evaluate)
+        .to eq Gitlab::UntrustedRegexp.new('(?im)pattern')
+    end
+
+    it 'does not support arbitrary flags' do
+      scanner = StringScanner.new('/pattern/x')
+
+      token = described_class.scan(scanner)
+
+      expect(token).to be_nil
+    end
+  end
+
+  describe '#evaluate' do
+    it 'returns a regular expression' do
+      regexp = described_class.new('/abc/')
+
+      expect(regexp.evaluate).to eq Gitlab::UntrustedRegexp.new('abc')
+    end
+
+    it 'raises error if evaluated regexp is not valid' do
+      allow(Gitlab::UntrustedRegexp).to receive(:valid?).and_return(true)
+
+      regexp = described_class.new('/invalid ( .*/')
+
+      expect { regexp.evaluate }
+        .to raise_error(Gitlab::Ci::Pipeline::Expression::RuntimeError)
+    end
+  end
+end
diff --git a/spec/lib/gitlab/ci/pipeline/expression/lexer_spec.rb b/spec/lib/gitlab/ci/pipeline/expression/lexer_spec.rb
index 230ceeb07f8..3f11b3f7673 100644
--- a/spec/lib/gitlab/ci/pipeline/expression/lexer_spec.rb
+++ b/spec/lib/gitlab/ci/pipeline/expression/lexer_spec.rb
@@ -6,7 +6,7 @@ describe Gitlab::Ci::Pipeline::Expression::Lexer do
   end
 
   describe '#tokens' do
-    it 'tokenss single value' do
+    it 'returns single value' do
       tokens = described_class.new('$VARIABLE').tokens
 
       expect(tokens).to be_one
@@ -20,14 +20,14 @@ describe Gitlab::Ci::Pipeline::Expression::Lexer do
       expect(tokens).to all(be_an_instance_of(token_class))
     end
 
-    it 'tokenss multiple values of the same token' do
+    it 'returns multiple values of the same token' do
       tokens = described_class.new("$VARIABLE1 $VARIABLE2").tokens
 
       expect(tokens.size).to eq 2
       expect(tokens).to all(be_an_instance_of(token_class))
     end
 
-    it 'tokenss multiple values with different tokens' do
+    it 'returns multiple values with different tokens' do
       tokens = described_class.new('$VARIABLE "text" "value"').tokens
 
       expect(tokens.size).to eq 3
@@ -36,7 +36,7 @@ describe Gitlab::Ci::Pipeline::Expression::Lexer do
       expect(tokens.third.value).to eq '"value"'
     end
 
-    it 'tokenss tokens and operators' do
+    it 'returns tokens and operators' do
       tokens = described_class.new('$VARIABLE == "text"').tokens
 
       expect(tokens.size).to eq 3
diff --git a/spec/lib/gitlab/ci/pipeline/expression/parser_spec.rb b/spec/lib/gitlab/ci/pipeline/expression/parser_spec.rb
index e8e6f585310..2b78b1dd4a7 100644
--- a/spec/lib/gitlab/ci/pipeline/expression/parser_spec.rb
+++ b/spec/lib/gitlab/ci/pipeline/expression/parser_spec.rb
@@ -1,4 +1,4 @@
-require 'spec_helper'
+require 'fast_spec_helper'
 
 describe Gitlab::Ci::Pipeline::Expression::Parser do
   describe '#tree' do
diff --git a/spec/lib/gitlab/ci/pipeline/expression/statement_spec.rb b/spec/lib/gitlab/ci/pipeline/expression/statement_spec.rb
index 6685bf5385b..11e73294f18 100644
--- a/spec/lib/gitlab/ci/pipeline/expression/statement_spec.rb
+++ b/spec/lib/gitlab/ci/pipeline/expression/statement_spec.rb
@@ -1,4 +1,5 @@
-require 'spec_helper'
+require 'fast_spec_helper'
+require 'rspec-parameterized'
 
 describe Gitlab::Ci::Pipeline::Expression::Statement do
   subject do
@@ -36,7 +37,7 @@ describe Gitlab::Ci::Pipeline::Expression::Statement do
         '== "123"',      # invalid left side
         '"some string"', # only string provided
         '$VAR ==',       # invalid right side
-        '12345',         # unknown syntax
+        'null',          # missing lexemes
         ''               # empty statement
       ]
 
@@ -44,7 +45,7 @@ describe Gitlab::Ci::Pipeline::Expression::Statement do
         context "when expression grammar is #{syntax.inspect}" do
           let(:text) { syntax }
 
-          it 'aises a statement error exception' do
+          it 'raises a statement error exception' do
             expect { subject.parse_tree }
               .to raise_error described_class::StatementError
           end
@@ -82,48 +83,66 @@ describe Gitlab::Ci::Pipeline::Expression::Statement do
   end
 
   describe '#evaluate' do
-    statements = [
-      ['$PRESENT_VARIABLE == "my variable"', true],
-      ["$PRESENT_VARIABLE == 'my variable'", true],
-      ['"my variable" == $PRESENT_VARIABLE', true],
-      ['$PRESENT_VARIABLE == null', false],
-      ['$EMPTY_VARIABLE == null', false],
-      ['"" == $EMPTY_VARIABLE', true],
-      ['$EMPTY_VARIABLE', ''],
-      ['$UNDEFINED_VARIABLE == null', true],
-      ['null == $UNDEFINED_VARIABLE', true],
-      ['$PRESENT_VARIABLE', 'my variable'],
-      ['$UNDEFINED_VARIABLE', nil]
-    ]
-
-    statements.each do |expression, value|
-      context "when using expression `#{expression}`" do
-        let(:text) { expression }
-
-        it "evaluates to `#{value.inspect}`" do
-          expect(subject.evaluate).to eq value
-        end
+    using RSpec::Parameterized::TableSyntax
+
+    where(:expression, :value) do
+      '$PRESENT_VARIABLE == "my variable"' | true
+      '"my variable" == $PRESENT_VARIABLE' | true
+      '$PRESENT_VARIABLE == null'          | false
+      '$EMPTY_VARIABLE == null'            | false
+      '"" == $EMPTY_VARIABLE'              | true
+      '$EMPTY_VARIABLE'                    | ''
+      '$UNDEFINED_VARIABLE == null'        | true
+      'null == $UNDEFINED_VARIABLE'        | true
+      '$PRESENT_VARIABLE'                  | 'my variable'
+      '$UNDEFINED_VARIABLE'                | nil
+      "$PRESENT_VARIABLE =~ /var.*e$/"     | true
+      "$PRESENT_VARIABLE =~ /^var.*/"      | false
+      "$EMPTY_VARIABLE =~ /var.*/"         | false
+      "$UNDEFINED_VARIABLE =~ /var.*/"     | false
+      "$PRESENT_VARIABLE =~ /VAR.*/i"      | true
+    end
+
+    with_them do
+      let(:text) { expression }
+
+      it "evaluates to `#{params[:value].inspect}`" do
+        expect(subject.evaluate).to eq value
       end
     end
   end
 
   describe '#truthful?' do
-    statements = [
-      ['$PRESENT_VARIABLE == "my variable"', true],
-      ["$PRESENT_VARIABLE == 'no match'", false],
-      ['$UNDEFINED_VARIABLE == null', true],
-      ['$PRESENT_VARIABLE', true],
-      ['$UNDEFINED_VARIABLE', false],
-      ['$EMPTY_VARIABLE', false]
-    ]
-
-    statements.each do |expression, value|
-      context "when using expression `#{expression}`" do
-        let(:text) { expression }
-
-        it "returns `#{value.inspect}`" do
-          expect(subject.truthful?).to eq value
-        end
+    using RSpec::Parameterized::TableSyntax
+
+    where(:expression, :value) do
+      '$PRESENT_VARIABLE == "my variable"' | true
+      "$PRESENT_VARIABLE == 'no match'"    | false
+      '$UNDEFINED_VARIABLE == null'        | true
+      '$PRESENT_VARIABLE'                  | true
+      '$UNDEFINED_VARIABLE'                | false
+      '$EMPTY_VARIABLE'                    | false
+      '$INVALID = 1'                       | false
+      "$PRESENT_VARIABLE =~ /var.*/"       | true
+      "$UNDEFINED_VARIABLE =~ /var.*/"     | false
+    end
+
+    with_them do
+      let(:text) { expression }
+
+      it "returns `#{params[:value].inspect}`" do
+        expect(subject.truthful?).to eq value
+      end
+    end
+
+    context 'when evaluating expression raises an error' do
+      let(:text) { '$PRESENT_VARIABLE' }
+
+      it 'returns false' do
+        allow(subject).to receive(:evaluate)
+          .and_raise(described_class::StatementError)
+
+        expect(subject.truthful?).to be_falsey
       end
     end
   end
diff --git a/spec/lib/gitlab/ci/pipeline/expression/token_spec.rb b/spec/lib/gitlab/ci/pipeline/expression/token_spec.rb
index 6d7453f0de5..cedfe270f9d 100644
--- a/spec/lib/gitlab/ci/pipeline/expression/token_spec.rb
+++ b/spec/lib/gitlab/ci/pipeline/expression/token_spec.rb
@@ -1,4 +1,4 @@
-require 'spec_helper'
+require 'fast_spec_helper'
 
 describe Gitlab::Ci::Pipeline::Expression::Token do
   let(:value) { '$VARIABLE' }
diff --git a/spec/lib/gitlab/ci/pipeline/preloader_spec.rb b/spec/lib/gitlab/ci/pipeline/preloader_spec.rb
new file mode 100644
index 00000000000..477c7477df0
--- /dev/null
+++ b/spec/lib/gitlab/ci/pipeline/preloader_spec.rb
@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Gitlab::Ci::Pipeline::Preloader do
+  describe '.preload' do
+    it 'preloads the author of every pipeline commit' do
+      commit = double(:commit)
+      pipeline = double(:pipeline, commit: commit)
+
+      expect(commit)
+        .to receive(:lazy_author)
+
+      expect(pipeline)
+        .to receive(:number_of_warnings)
+
+      described_class.preload([pipeline])
+    end
+  end
+end
diff --git a/spec/lib/gitlab/database_spec.rb b/spec/lib/gitlab/database_spec.rb
index 1fe1d3926ad..8ac36ae8bab 100644
--- a/spec/lib/gitlab/database_spec.rb
+++ b/spec/lib/gitlab/database_spec.rb
@@ -32,6 +32,12 @@ describe Gitlab::Database do
   end
 
   describe '.version' do
+    around do |example|
+      described_class.instance_variable_set(:@version, nil)
+      example.run
+      described_class.instance_variable_set(:@version, nil)
+    end
+
     context "on mysql" do
       it "extracts the version number" do
         allow(described_class).to receive(:database_version)
@@ -49,6 +55,14 @@ describe Gitlab::Database do
         expect(described_class.version).to eq '9.4.4'
       end
     end
+
+    it 'memoizes the result' do
+      count = ActiveRecord::QueryRecorder
+        .new { 2.times { described_class.version } }
+        .count
+
+      expect(count).to eq(1)
+    end
   end
 
   describe '.join_lateral_supported?' do
diff --git a/spec/lib/gitlab/git/commit_spec.rb b/spec/lib/gitlab/git/commit_spec.rb
index 2e068584c2e..08c6d1e55e9 100644
--- a/spec/lib/gitlab/git/commit_spec.rb
+++ b/spec/lib/gitlab/git/commit_spec.rb
@@ -66,7 +66,8 @@ describe Gitlab::Git::Commit, seed_helper: true do
   describe "Commit info from gitaly commit" do
     let(:subject) { "My commit".force_encoding('ASCII-8BIT') }
     let(:body) { subject + "My body".force_encoding('ASCII-8BIT') }
-    let(:gitaly_commit) { build(:gitaly_commit, subject: subject, body: body) }
+    let(:body_size) { body.length }
+    let(:gitaly_commit) { build(:gitaly_commit, subject: subject, body: body, body_size: body_size) }
     let(:id) { gitaly_commit.id }
     let(:committer) { gitaly_commit.committer }
     let(:author) { gitaly_commit.author }
@@ -83,10 +84,30 @@ describe Gitlab::Git::Commit, seed_helper: true do
     it { expect(commit.committer_email).to eq(committer.email) }
     it { expect(commit.parent_ids).to eq(gitaly_commit.parent_ids) }
 
-    context 'no body' do
+    context 'body_size != body.size' do
       let(:body) { "".force_encoding('ASCII-8BIT') }
 
-      it { expect(commit.safe_message).to eq(subject) }
+      context 'zero body_size' do
+        it { expect(commit.safe_message).to eq(subject) }
+      end
+
+      context 'body_size less than threshold' do
+        let(:body_size) { 123 }
+
+        it 'fetches commit message seperately' do
+          expect(described_class).to receive(:get_message).with(repository, id)
+
+          commit.safe_message
+        end
+      end
+
+      context 'body_size greater than threshold' do
+        let(:body_size) { described_class::MAX_COMMIT_MESSAGE_DISPLAY_SIZE + 1 }
+
+        it 'returns the suject plus a notice about message size' do
+          expect(commit.safe_message).to eq("My commit\n\n--commit message is too big")
+        end
+      end
     end
   end
 
@@ -589,6 +610,35 @@ describe Gitlab::Git::Commit, seed_helper: true do
     it { is_expected.not_to include("feature") }
   end
 
+  describe '.get_message' do
+    let(:commit_ids) { %w[6d394385cf567f80a8fd85055db1ab4c5295806f cfe32cf61b73a0d5e9f13e774abde7ff789b1660] }
+
+    subject do
+      commit_ids.map { |id| described_class.get_message(repository, id) }
+    end
+
+    shared_examples 'getting commit messages' do
+      it 'gets commit messages' do
+        expect(subject).to contain_exactly(
+          "Added contributing guide\n\nSigned-off-by: Dmitriy Zaporozhets <dmitriy.zaporozhets@gmail.com>\n",
+          "Add submodule\n\nSigned-off-by: Dmitriy Zaporozhets <dmitriy.zaporozhets@gmail.com>\n"
+        )
+      end
+    end
+
+    context 'when Gitaly commit_messages feature is enabled' do
+      it_behaves_like 'getting commit messages'
+
+      it 'gets messages in one batch', :request_store do
+        expect { subject.map(&:itself) }.to change { Gitlab::GitalyClient.get_request_count }.by(1)
+      end
+    end
+
+    context 'when Gitaly commit_messages feature is disabled', :disable_gitaly do
+      it_behaves_like 'getting commit messages'
+    end
+  end
+
   def sample_commit_hash
     {
       author_email: "dmitriy.zaporozhets@gmail.com",
diff --git a/spec/lib/gitlab/git/repository_spec.rb b/spec/lib/gitlab/git/repository_spec.rb
index fcb690d8aa3..af6a486ab20 100644
--- a/spec/lib/gitlab/git/repository_spec.rb
+++ b/spec/lib/gitlab/git/repository_spec.rb
@@ -249,10 +249,6 @@ describe Gitlab::Git::Repository, seed_helper: true do
 
     subject(:metadata) { repository.archive_metadata(ref, storage_path, format, append_sha: append_sha) }
 
-    it 'sets RepoPath to the repository path' do
-      expect(metadata['RepoPath']).to eq(repository.path)
-    end
-
     it 'sets CommitId to the commit SHA' do
       expect(metadata['CommitId']).to eq(SeedRepo::LastCommit::ID)
     end
@@ -600,6 +596,10 @@ describe Gitlab::Git::Repository, seed_helper: true do
         end
       end
 
+      it 'does not fail when deleting an empty list of refs' do
+        expect { repo.delete_refs(*[]) }.not_to raise_error
+      end
+
       it 'raises an error if it failed' do
         expect { repo.delete_refs('refs\heads\fix') }.to raise_error(Gitlab::Git::Repository::GitError)
       end
@@ -2247,66 +2247,42 @@ describe Gitlab::Git::Repository, seed_helper: true do
   end
 
   describe '#checksum' do
-    shared_examples 'calculating checksum' do
-      it 'calculates the checksum for non-empty repo' do
-        expect(repository.checksum).to eq '54f21be4c32c02f6788d72207fa03ad3bce725e4'
-      end
-
-      it 'returns 0000000000000000000000000000000000000000 for an empty repo' do
-        FileUtils.rm_rf(File.join(storage_path, 'empty-repo.git'))
-
-        system(git_env, *%W(#{Gitlab.config.git.bin_path} init --bare empty-repo.git),
-               chdir: storage_path,
-               out:   '/dev/null',
-               err:   '/dev/null')
+    it 'calculates the checksum for non-empty repo' do
+      expect(repository.checksum).to eq '54f21be4c32c02f6788d72207fa03ad3bce725e4'
+    end
 
-        empty_repo = described_class.new('default', 'empty-repo.git', '')
+    it 'returns 0000000000000000000000000000000000000000 for an empty repo' do
+      FileUtils.rm_rf(File.join(storage_path, 'empty-repo.git'))
 
-        expect(empty_repo.checksum).to eq '0000000000000000000000000000000000000000'
-      end
+      system(git_env, *%W(#{Gitlab.config.git.bin_path} init --bare empty-repo.git),
+             chdir: storage_path,
+             out:   '/dev/null',
+             err:   '/dev/null')
 
-      it 'raises Gitlab::Git::Repository::InvalidRepository error for non-valid git repo' do
-        FileUtils.rm_rf(File.join(storage_path, 'non-valid.git'))
+      empty_repo = described_class.new('default', 'empty-repo.git', '')
 
-        system(git_env, *%W(#{Gitlab.config.git.bin_path} clone --bare #{TEST_REPO_PATH} non-valid.git),
-               chdir: SEED_STORAGE_PATH,
-               out: '/dev/null',
-               err: '/dev/null')
+      expect(empty_repo.checksum).to eq '0000000000000000000000000000000000000000'
+    end
 
-        File.truncate(File.join(storage_path, 'non-valid.git/HEAD'), 0)
+    it 'raises Gitlab::Git::Repository::InvalidRepository error for non-valid git repo' do
+      FileUtils.rm_rf(File.join(storage_path, 'non-valid.git'))
 
-        non_valid = described_class.new('default', 'non-valid.git', '')
+      system(git_env, *%W(#{Gitlab.config.git.bin_path} clone --bare #{TEST_REPO_PATH} non-valid.git),
+             chdir: SEED_STORAGE_PATH,
+             out: '/dev/null',
+             err: '/dev/null')
 
-        expect { non_valid.checksum }.to raise_error(Gitlab::Git::Repository::InvalidRepository)
-      end
+      File.truncate(File.join(storage_path, 'non-valid.git/HEAD'), 0)
 
-      it 'raises Gitlab::Git::Repository::NoRepository error when there is no repo' do
-        broken_repo = described_class.new('default', 'a/path.git', '')
+      non_valid = described_class.new('default', 'non-valid.git', '')
 
-        expect { broken_repo.checksum }.to raise_error(Gitlab::Git::Repository::NoRepository)
-      end
-    end
-
-    context 'when calculate_checksum Gitaly feature is enabled' do
-      it_behaves_like 'calculating checksum'
+      expect { non_valid.checksum }.to raise_error(Gitlab::Git::Repository::InvalidRepository)
     end
 
-    context 'when calculate_checksum Gitaly feature is disabled', :disable_gitaly do
-      it_behaves_like 'calculating checksum'
-
-      describe 'when storage is broken', :broken_storage  do
-        it 'raises a storage exception when storage is not available' do
-          broken_repo = described_class.new('broken', 'a/path.git', '')
-
-          expect { broken_repo.rugged }.to raise_error(Gitlab::Git::Storage::Inaccessible)
-        end
-      end
-
-      it "raises a Gitlab::Git::Repository::Failure error if the `popen` call to git returns a non-zero exit code" do
-        allow(repository).to receive(:popen).and_return(['output', nil])
+    it 'raises Gitlab::Git::Repository::NoRepository error when there is no repo' do
+      broken_repo = described_class.new('default', 'a/path.git', '')
 
-        expect { repository.checksum }.to raise_error Gitlab::Git::Repository::ChecksumError
-      end
+      expect { broken_repo.checksum }.to raise_error(Gitlab::Git::Repository::NoRepository)
     end
   end
 
diff --git a/spec/lib/gitlab/git/tag_spec.rb b/spec/lib/gitlab/git/tag_spec.rb
index 6c4f538bf01..be2f5bfb819 100644
--- a/spec/lib/gitlab/git/tag_spec.rb
+++ b/spec/lib/gitlab/git/tag_spec.rb
@@ -32,4 +32,56 @@ describe Gitlab::Git::Tag, seed_helper: true do
   context 'when Gitaly tags feature is disabled', :skip_gitaly_mock do
     it_behaves_like 'Gitlab::Git::Repository#tags'
   end
+
+  describe '.get_message' do
+    let(:tag_ids) { %w[f4e6814c3e4e7a0de82a9e7cd20c626cc963a2f8 8a2a6eb295bb170b34c24c76c49ed0e9b2eaf34b] }
+
+    subject do
+      tag_ids.map { |id| described_class.get_message(repository, id) }
+    end
+
+    shared_examples 'getting tag messages' do
+      it 'gets tag messages' do
+        expect(subject[0]).to eq("Release\n")
+        expect(subject[1]).to eq("Version 1.1.0\n")
+      end
+    end
+
+    context 'when Gitaly tag_messages feature is enabled' do
+      it_behaves_like 'getting tag messages'
+
+      it 'gets messages in one batch', :request_store do
+        expect { subject.map(&:itself) }.to change { Gitlab::GitalyClient.get_request_count }.by(1)
+      end
+    end
+
+    context 'when Gitaly tag_messages feature is disabled', :disable_gitaly do
+      it_behaves_like 'getting tag messages'
+    end
+  end
+
+  describe 'tag into from Gitaly tag' do
+    context 'message_size != message.size' do
+      let(:gitaly_tag) { build(:gitaly_tag, message: ''.b, message_size: message_size) }
+      let(:tag) { described_class.new(repository, gitaly_tag) }
+
+      context 'message_size less than threshold' do
+        let(:message_size) { 123 }
+
+        it 'fetches tag message seperately' do
+          expect(described_class).to receive(:get_message).with(repository, gitaly_tag.id)
+
+          tag.message
+        end
+      end
+
+      context 'message_size greater than threshold' do
+        let(:message_size) { described_class::MAX_TAG_MESSAGE_DISPLAY_SIZE + 1 }
+
+        it 'returns a notice about message size' do
+          expect(tag.message).to eq("--tag message is too big")
+        end
+      end
+    end
+  end
 end
diff --git a/spec/lib/gitlab/incoming_email_spec.rb b/spec/lib/gitlab/incoming_email_spec.rb
index ad087f42e06..4c0c3fcbcc7 100644
--- a/spec/lib/gitlab/incoming_email_spec.rb
+++ b/spec/lib/gitlab/incoming_email_spec.rb
@@ -83,6 +83,10 @@ describe Gitlab::IncomingEmail do
     it "returns reply key" do
       expect(described_class.key_from_address("replies+key@example.com")).to eq("key")
     end
+
+    it 'does not match emails with extra bits' do
+      expect(described_class.key_from_address('somereplies+somekey@example.com.someotherdomain.com')).to be nil
+    end
   end
 
   context 'self.key_from_fallback_message_id' do
diff --git a/spec/lib/gitlab/untrusted_regexp_spec.rb b/spec/lib/gitlab/untrusted_regexp_spec.rb
index 0ee7fa1e570..0a6ac0aa294 100644
--- a/spec/lib/gitlab/untrusted_regexp_spec.rb
+++ b/spec/lib/gitlab/untrusted_regexp_spec.rb
@@ -1,6 +1,49 @@
-require 'spec_helper'
+require 'fast_spec_helper'
+require 'support/shared_examples/malicious_regexp_shared_examples'
 
 describe Gitlab::UntrustedRegexp do
+  describe '.valid?' do
+    it 'returns true if regexp is valid' do
+      expect(described_class.valid?('/some ( thing/'))
+        .to be false
+    end
+
+    it 'returns true if regexp is invalid' do
+      expect(described_class.valid?('/some .* thing/'))
+        .to be true
+    end
+  end
+
+  describe '.fabricate' do
+    context 'when regexp is using /regexp/ scheme with flags' do
+      it 'fabricates regexp with a single flag' do
+        regexp = described_class.fabricate('/something/i')
+
+        expect(regexp).to eq described_class.new('(?i)something')
+        expect(regexp.scan('SOMETHING')).to be_one
+      end
+
+      it 'fabricates regexp with multiple flags' do
+        regexp = described_class.fabricate('/something/im')
+
+        expect(regexp).to eq described_class.new('(?im)something')
+      end
+
+      it 'fabricates regexp without flags' do
+        regexp = described_class.fabricate('/something/')
+
+        expect(regexp).to eq described_class.new('something')
+      end
+    end
+
+    context 'when regexp is a raw pattern' do
+      it 'raises an error' do
+        expect { described_class.fabricate('some .* thing') }
+          .to raise_error(RegexpError)
+      end
+    end
+  end
+
   describe '#initialize' do
     subject { described_class.new(pattern) }
 
diff --git a/spec/lib/gitlab/workhorse_spec.rb b/spec/lib/gitlab/workhorse_spec.rb
index e732b089d44..660671cefaf 100644
--- a/spec/lib/gitlab/workhorse_spec.rb
+++ b/spec/lib/gitlab/workhorse_spec.rb
@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 describe Gitlab::Workhorse do
-  let(:project)    { create(:project, :repository) }
+  set(:project)    { create(:project, :repository) }
   let(:repository) { project.repository }
 
   def decode_workhorse_header(array)
@@ -55,16 +55,6 @@ describe Gitlab::Workhorse do
       end
     end
 
-    context 'when Gitaly workhorse_archive feature is disabled', :disable_gitaly do
-      it 'sets the header correctly' do
-        key, command, params = decode_workhorse_header(subject)
-
-        expect(key).to eq('Gitlab-Workhorse-Send-Data')
-        expect(command).to eq('git-archive')
-        expect(params).to eq(base_params)
-      end
-    end
-
     context "when the repository doesn't have an archive file path" do
       before do
         allow(project.repository).to receive(:archive_metadata).and_return(Hash.new)
diff --git a/spec/models/ci/build_spec.rb b/spec/models/ci/build_spec.rb
index dc810489011..96173889ccd 100644
--- a/spec/models/ci/build_spec.rb
+++ b/spec/models/ci/build_spec.rb
@@ -629,6 +629,14 @@ describe Ci::Build do
 
         it { is_expected.to eq('review/host') }
       end
+
+      context 'when using persisted variables' do
+        let(:build) do
+          create(:ci_build, environment: 'review/x$CI_BUILD_ID')
+        end
+
+        it { is_expected.to eq('review/x') }
+      end
     end
 
     describe '#starts_environment?' do
@@ -1270,6 +1278,46 @@ describe Ci::Build do
     end
   end
 
+  describe '#playable?' do
+    context 'when build is a manual action' do
+      context 'when build has been skipped' do
+        subject { build_stubbed(:ci_build, :manual, status: :skipped) }
+
+        it { is_expected.not_to be_playable }
+      end
+
+      context 'when build has been canceled' do
+        subject { build_stubbed(:ci_build, :manual, status: :canceled) }
+
+        it { is_expected.to be_playable }
+      end
+
+      context 'when build is successful' do
+        subject { build_stubbed(:ci_build, :manual, status: :success) }
+
+        it { is_expected.to be_playable }
+      end
+
+      context 'when build has failed' do
+        subject { build_stubbed(:ci_build, :manual, status: :failed) }
+
+        it { is_expected.to be_playable }
+      end
+
+      context 'when build is a manual untriggered action' do
+        subject { build_stubbed(:ci_build, :manual, status: :manual) }
+
+        it { is_expected.to be_playable }
+      end
+    end
+
+    context 'when build is not a manual action' do
+      subject { build_stubbed(:ci_build, :success) }
+
+      it { is_expected.not_to be_playable }
+    end
+  end
+
   describe 'project settings' do
     describe '#allow_git_fetch' do
       it 'return project allow_git_fetch configuration' do
@@ -1485,6 +1533,7 @@ describe Ci::Build do
     let(:container_registry_enabled) { false }
     let(:predefined_variables) do
       [
+        { key: 'CI_PIPELINE_ID', value: pipeline.id.to_s, public: true },
         { key: 'CI_JOB_ID', value: build.id.to_s, public: true },
         { key: 'CI_JOB_TOKEN', value: build.token, public: false },
         { key: 'CI_BUILD_ID', value: build.id.to_s, public: true },
@@ -1516,7 +1565,6 @@ describe Ci::Build do
         { key: 'CI_PROJECT_NAMESPACE', value: project.namespace.full_path, public: true },
         { key: 'CI_PROJECT_URL', value: project.web_url, public: true },
         { key: 'CI_PROJECT_VISIBILITY', value: 'private', public: true },
-        { key: 'CI_PIPELINE_ID', value: pipeline.id.to_s, public: true },
         { key: 'CI_CONFIG_PATH', value: pipeline.ci_yaml_file_path, public: true },
         { key: 'CI_PIPELINE_SOURCE', value: pipeline.source, public: true },
         { key: 'CI_COMMIT_MESSAGE', value: pipeline.git_commit_message, public: true },
@@ -2044,7 +2092,7 @@ describe Ci::Build do
 
       let(:deploy_token_variables) do
         [
-          { key: 'CI_DEPLOY_USER', value: deploy_token.name, public: true },
+          { key: 'CI_DEPLOY_USER', value: deploy_token.username, public: true },
           { key: 'CI_DEPLOY_PASSWORD', value: deploy_token.token, public: false }
         ]
       end
diff --git a/spec/models/ci/pipeline_spec.rb b/spec/models/ci/pipeline_spec.rb
index ddd66a6be87..e4f4c62bd22 100644
--- a/spec/models/ci/pipeline_spec.rb
+++ b/spec/models/ci/pipeline_spec.rb
@@ -167,13 +167,39 @@ describe Ci::Pipeline, :mailer do
     end
   end
 
+  describe '#persisted_variables' do
+    context 'when pipeline is not persisted yet' do
+      subject { build(:ci_pipeline).persisted_variables }
+
+      it 'does not contain some variables' do
+        keys = subject.map { |variable| variable[:key] }
+
+        expect(keys).not_to include 'CI_PIPELINE_ID'
+      end
+    end
+
+    context 'when pipeline is persisted' do
+      subject { build_stubbed(:ci_pipeline).persisted_variables }
+
+      it 'does contains persisted variables' do
+        keys = subject.map { |variable| variable[:key] }
+
+        expect(keys).to eq %w[CI_PIPELINE_ID]
+      end
+    end
+  end
+
   describe '#predefined_variables' do
     subject { pipeline.predefined_variables }
 
     it 'includes all predefined variables in a valid order' do
       keys = subject.map { |variable| variable[:key] }
 
-      expect(keys).to eq %w[CI_PIPELINE_ID CI_CONFIG_PATH CI_PIPELINE_SOURCE CI_COMMIT_MESSAGE CI_COMMIT_TITLE CI_COMMIT_DESCRIPTION]
+      expect(keys).to eq %w[CI_CONFIG_PATH
+                            CI_PIPELINE_SOURCE
+                            CI_COMMIT_MESSAGE
+                            CI_COMMIT_TITLE
+                            CI_COMMIT_DESCRIPTION]
     end
   end
 
@@ -774,6 +800,33 @@ describe Ci::Pipeline, :mailer do
     end
   end
 
+  describe '#number_of_warnings' do
+    it 'returns the number of warnings' do
+      create(:ci_build, :allowed_to_fail, :failed, pipeline: pipeline, name: 'rubocop')
+
+      expect(pipeline.number_of_warnings).to eq(1)
+    end
+
+    it 'supports eager loading of the number of warnings' do
+      pipeline2 = create(:ci_empty_pipeline, status: :created, project: project)
+
+      create(:ci_build, :allowed_to_fail, :failed, pipeline: pipeline, name: 'rubocop')
+      create(:ci_build, :allowed_to_fail, :failed, pipeline: pipeline2, name: 'rubocop')
+
+      pipelines = project.pipelines.to_a
+
+      pipelines.each(&:number_of_warnings)
+
+      # To run the queries we need to actually use the lazy objects, which we do
+      # by just sending "to_i" to them.
+      amount = ActiveRecord::QueryRecorder
+        .new { pipelines.each { |p| p.number_of_warnings.to_i } }
+        .count
+
+      expect(amount).to eq(1)
+    end
+  end
+
   shared_context 'with some outdated pipelines' do
     before do
       create_pipeline(:canceled, 'ref', 'A', project)
diff --git a/spec/models/clusters/applications/prometheus_spec.rb b/spec/models/clusters/applications/prometheus_spec.rb
index aeca6ee903a..407e2fc598a 100644
--- a/spec/models/clusters/applications/prometheus_spec.rb
+++ b/spec/models/clusters/applications/prometheus_spec.rb
@@ -85,6 +85,16 @@ describe Clusters::Applications::Prometheus do
       it 'copies options and headers from kube client to proxy client' do
         expect(subject.prometheus_client.options).to eq(kube_client.rest_client.options.merge(headers: kube_client.headers))
       end
+
+      context 'when cluster is not reachable' do
+        before do
+          allow(kube_client).to receive(:proxy_url).and_raise(Kubeclient::HttpError.new(401, 'Unauthorized', nil))
+        end
+
+        it 'returns nil' do
+          expect(subject.prometheus_client).to be_nil
+        end
+      end
     end
   end
 
diff --git a/spec/models/commit_spec.rb b/spec/models/commit_spec.rb
index 448b813c2e1..090f91168ad 100644
--- a/spec/models/commit_spec.rb
+++ b/spec/models/commit_spec.rb
@@ -52,22 +52,98 @@ describe Commit do
     end
   end
 
-  describe '#author' do
+  describe '#author', :request_store do
     it 'looks up the author in a case-insensitive way' do
       user = create(:user, email: commit.author_email.upcase)
       expect(commit.author).to eq(user)
     end
 
-    it 'caches the author', :request_store do
+    it 'caches the author' do
       user = create(:user, email: commit.author_email)
-      expect(User).to receive(:find_by_any_email).and_call_original
 
       expect(commit.author).to eq(user)
+
       key = "Commit:author:#{commit.author_email.downcase}"
-      expect(RequestStore.store[key]).to eq(user)
 
+      expect(RequestStore.store[key]).to eq(user)
       expect(commit.author).to eq(user)
     end
+
+    context 'using eager loading' do
+      let!(:alice) { create(:user, email: 'alice@example.com') }
+      let!(:bob) { create(:user, email: 'hunter2@example.com') }
+
+      let(:alice_commit) do
+        described_class.new(RepoHelpers.sample_commit, project).tap do |c|
+          c.author_email = 'alice@example.com'
+        end
+      end
+
+      let(:bob_commit) do
+        # The commit for Bob uses one of his alternative Emails, instead of the
+        # primary one.
+        described_class.new(RepoHelpers.sample_commit, project).tap do |c|
+          c.author_email = 'bob@example.com'
+        end
+      end
+
+      let(:eve_commit) do
+        described_class.new(RepoHelpers.sample_commit, project).tap do |c|
+          c.author_email = 'eve@example.com'
+        end
+      end
+
+      let!(:commits) { [alice_commit, bob_commit, eve_commit] }
+
+      before do
+        create(:email, user: bob, email: 'bob@example.com')
+      end
+
+      it 'executes only two SQL queries' do
+        recorder = ActiveRecord::QueryRecorder.new do
+          # Running this first ensures we don't run one query for every
+          # commit.
+          commits.each(&:lazy_author)
+
+          # This forces the execution of the SQL queries necessary to load the
+          # data.
+          commits.each { |c| c.author.try(:id) }
+        end
+
+        expect(recorder.count).to eq(2)
+      end
+
+      it "preloads the authors for Commits matching a user's primary Email" do
+        commits.each(&:lazy_author)
+
+        expect(alice_commit.author).to eq(alice)
+      end
+
+      it "preloads the authors for Commits using a User's alternative Email" do
+        commits.each(&:lazy_author)
+
+        expect(bob_commit.author).to eq(bob)
+      end
+
+      it 'sets the author to Nil if an author could not be found for a Commit' do
+        commits.each(&:lazy_author)
+
+        expect(eve_commit.author).to be_nil
+      end
+
+      it 'does not execute SQL queries once the authors are preloaded' do
+        commits.each(&:lazy_author)
+        commits.each { |c| c.author.try(:id) }
+
+        recorder = ActiveRecord::QueryRecorder.new do
+          alice_commit.author
+          bob_commit.author
+          eve_commit.author
+        end
+
+        expect(recorder.count).to be_zero
+      end
+    end
   end
 
   describe '#to_reference' do
diff --git a/spec/models/commit_status_spec.rb b/spec/models/commit_status_spec.rb
index 2ed29052dc1..f3f2bc28d2c 100644
--- a/spec/models/commit_status_spec.rb
+++ b/spec/models/commit_status_spec.rb
@@ -565,4 +565,10 @@ describe CommitStatus do
       it_behaves_like 'commit status enqueued'
     end
   end
+
+  describe '#present' do
+    subject { commit_status.present }
+
+    it { is_expected.to be_a(CommitStatusPresenter) }
+  end
 end
diff --git a/spec/models/concerns/issuable_spec.rb b/spec/models/concerns/issuable_spec.rb
index 3d3092b8ac9..bd6bf5b0712 100644
--- a/spec/models/concerns/issuable_spec.rb
+++ b/spec/models/concerns/issuable_spec.rb
@@ -266,6 +266,19 @@ describe Issuable do
     end
   end
 
+  describe '#time_estimate=' do
+    it 'coerces the value below Gitlab::Database::MAX_INT_VALUE' do
+      expect { issue.time_estimate = 100 }.to change { issue.time_estimate }.to(100)
+      expect { issue.time_estimate = Gitlab::Database::MAX_INT_VALUE + 100 }.to change { issue.time_estimate }.to(Gitlab::Database::MAX_INT_VALUE)
+    end
+
+    it 'skips coercion for not Integer values' do
+      expect { issue.time_estimate = nil }.to change { issue.time_estimate }.to(nil)
+      expect { issue.time_estimate = 'invalid time' }.not_to raise_error(StandardError)
+      expect { issue.time_estimate = 22.33 }.not_to raise_error(StandardError)
+    end
+  end
+
   describe '#to_hook_data' do
     let(:builder) { double }
 
diff --git a/spec/models/concerns/redis_cacheable_spec.rb b/spec/models/concerns/redis_cacheable_spec.rb
index 3d7963120b6..23c6c6233e9 100644
--- a/spec/models/concerns/redis_cacheable_spec.rb
+++ b/spec/models/concerns/redis_cacheable_spec.rb
@@ -1,21 +1,36 @@
 require 'spec_helper'
 
 describe RedisCacheable do
-  let(:model) { double }
+  let(:model) do
+    Struct.new(:id, :attributes) do
+      def read_attribute(attribute)
+        attributes[attribute]
+      end
+
+      def cast_value_from_cache(attribute, cached_value)
+        cached_value
+      end
+
+      def has_attribute?(attribute)
+        attributes.has_key?(attribute)
+      end
+    end
+  end
+
+  let(:payload) { { name: 'value', time: Time.zone.now } }
+  let(:instance) { model.new(1, payload) }
+  let(:cache_key) { instance.__send__(:cache_attribute_key) }
 
   before do
-    model.extend(described_class)
-    allow(model).to receive(:cache_attribute_key).and_return('key')
+    model.include(described_class)
   end
 
   describe '#cached_attribute' do
-    let(:payload) { { attribute: 'value' } }
-
-    subject { model.cached_attribute(payload.keys.first) }
+    subject { instance.cached_attribute(payload.keys.first) }
 
     it 'gets the cache attribute' do
       Gitlab::Redis::SharedState.with do |redis|
-        expect(redis).to receive(:get).with('key')
+        expect(redis).to receive(:get).with(cache_key)
           .and_return(payload.to_json)
       end
 
@@ -24,16 +39,62 @@ describe RedisCacheable do
   end
 
   describe '#cache_attributes' do
-    let(:values) { { name: 'new_name' } }
-
-    subject { model.cache_attributes(values) }
+    subject { instance.cache_attributes(payload) }
 
     it 'sets the cache attributes' do
       Gitlab::Redis::SharedState.with do |redis|
-        expect(redis).to receive(:set).with('key', values.to_json, anything)
+        expect(redis).to receive(:set).with(cache_key, payload.to_json, anything)
       end
 
       subject
     end
   end
+
+  describe '#cached_attr_reader', :clean_gitlab_redis_shared_state do
+    subject { instance.name }
+
+    before do
+      model.cached_attr_reader(:name)
+    end
+
+    context 'when there is no cached value' do
+      it 'reads the attribute' do
+        expect(instance).to receive(:read_attribute).and_call_original
+
+        expect(subject).to eq(payload[:name])
+      end
+    end
+
+    context 'when there is a cached value' do
+      it 'reads the cached value' do
+        expect(instance).not_to receive(:read_attribute)
+
+        instance.cache_attributes(payload)
+
+        expect(subject).to eq(payload[:name])
+      end
+    end
+
+    it 'always returns the latest values' do
+      expect(instance.name).to eq(payload[:name])
+
+      instance.cache_attributes(name: 'new_value')
+
+      expect(instance.name).to eq('new_value')
+    end
+  end
+
+  describe '#cast_value_from_cache' do
+    subject { instance.__send__(:cast_value_from_cache, attribute, value) }
+
+    context 'with runner contacted_at' do
+      let(:instance) { Ci::Runner.new }
+      let(:attribute) { :contacted_at }
+      let(:value) { '2018-05-07 13:53:08 UTC' }
+
+      it 'converts cache string to appropriate type' do
+        expect(subject).to be_an_instance_of(ActiveSupport::TimeWithZone)
+      end
+    end
+  end
 end
diff --git a/spec/models/concerns/sortable_spec.rb b/spec/models/concerns/sortable_spec.rb
new file mode 100644
index 00000000000..b821a84d5e0
--- /dev/null
+++ b/spec/models/concerns/sortable_spec.rb
@@ -0,0 +1,108 @@
+require 'spec_helper'
+
+describe Sortable do
+  describe '.order_by' do
+    let(:relation) { Group.all }
+
+    describe 'ordering by id' do
+      it 'ascending' do
+        expect(relation).to receive(:reorder).with(id: :asc)
+
+        relation.order_by('id_asc')
+      end
+
+      it 'descending' do
+        expect(relation).to receive(:reorder).with(id: :desc)
+
+        relation.order_by('id_desc')
+      end
+    end
+
+    describe 'ordering by created day' do
+      it 'ascending' do
+        expect(relation).to receive(:reorder).with(created_at: :asc)
+
+        relation.order_by('created_asc')
+      end
+
+      it 'descending' do
+        expect(relation).to receive(:reorder).with(created_at: :desc)
+
+        relation.order_by('created_desc')
+      end
+
+      it 'order by "date"' do
+        expect(relation).to receive(:reorder).with(created_at: :desc)
+
+        relation.order_by('created_date')
+      end
+    end
+
+    describe 'ordering by name' do
+      it 'ascending' do
+        expect(relation).to receive(:reorder).with("lower(name) asc")
+
+        relation.order_by('name_asc')
+      end
+
+      it 'descending' do
+        expect(relation).to receive(:reorder).with("lower(name) desc")
+
+        relation.order_by('name_desc')
+      end
+    end
+
+    describe 'ordering by Updated Time' do
+      it 'ascending' do
+        expect(relation).to receive(:reorder).with(updated_at: :asc)
+
+        relation.order_by('updated_asc')
+      end
+
+      it 'descending' do
+        expect(relation).to receive(:reorder).with(updated_at: :desc)
+
+        relation.order_by('updated_desc')
+      end
+    end
+
+    it 'does not call reorder in case of unrecognized ordering' do
+      expect(relation).not_to receive(:reorder)
+
+      relation.order_by('random_ordering')
+    end
+  end
+
+  describe 'sorting groups' do
+    def ordered_group_names(order)
+      Group.all.order_by(order).map(&:name)
+    end
+
+    let!(:ref_time) { Time.parse('2018-05-01 00:00:00') }
+    let!(:group1) { create(:group, name: 'aa', id: 1, created_at: ref_time - 15.seconds, updated_at: ref_time) }
+    let!(:group2) { create(:group, name: 'AAA', id: 2, created_at: ref_time - 10.seconds, updated_at: ref_time - 5.seconds) }
+    let!(:group3) { create(:group, name: 'BB', id: 3, created_at: ref_time - 5.seconds, updated_at: ref_time - 10.seconds) }
+    let!(:group4) { create(:group, name: 'bbb', id: 4, created_at: ref_time, updated_at: ref_time - 15.seconds) }
+
+    it 'sorts groups by id' do
+      expect(ordered_group_names('id_asc')).to eq(%w(aa AAA BB bbb))
+      expect(ordered_group_names('id_desc')).to eq(%w(bbb BB AAA aa))
+    end
+
+    it 'sorts groups by name via case-insentitive comparision' do
+      expect(ordered_group_names('name_asc')).to eq(%w(aa AAA BB bbb))
+      expect(ordered_group_names('name_desc')).to eq(%w(bbb BB AAA aa))
+    end
+
+    it 'sorts groups by created_at' do
+      expect(ordered_group_names('created_asc')).to eq(%w(aa AAA BB bbb))
+      expect(ordered_group_names('created_desc')).to eq(%w(bbb BB AAA aa))
+      expect(ordered_group_names('created_date')).to eq(%w(bbb BB AAA aa))
+    end
+
+    it 'sorts groups by updated_at' do
+      expect(ordered_group_names('updated_asc')).to eq(%w(bbb BB AAA aa))
+      expect(ordered_group_names('updated_desc')).to eq(%w(aa AAA BB bbb))
+    end
+  end
+end
diff --git a/spec/models/generic_commit_status_spec.rb b/spec/models/generic_commit_status_spec.rb
index 673049d1cc4..a3e68d2e646 100644
--- a/spec/models/generic_commit_status_spec.rb
+++ b/spec/models/generic_commit_status_spec.rb
@@ -78,4 +78,10 @@ describe GenericCommitStatus do
       it { is_expected.not_to be_nil }
     end
   end
+
+  describe '#present' do
+    subject { generic_commit_status.present }
+
+    it { is_expected.to be_a(GenericCommitStatusPresenter) }
+  end
 end
diff --git a/spec/models/repository_spec.rb b/spec/models/repository_spec.rb
index ac8d9a32d4e..6bc148a1392 100644
--- a/spec/models/repository_spec.rb
+++ b/spec/models/repository_spec.rb
@@ -671,7 +671,7 @@ describe Repository do
     end
   end
 
-  describe "search_files_by_content" do
+  shared_examples "search_files_by_content" do
     let(:results) { repository.search_files_by_content('feature', 'master') }
     subject { results }
 
@@ -718,7 +718,7 @@ describe Repository do
     end
   end
 
-  describe "search_files_by_name" do
+  shared_examples "search_files_by_name" do
     let(:results) { repository.search_files_by_name('files', 'master') }
 
     it 'returns result' do
@@ -758,6 +758,16 @@ describe Repository do
     end
   end
 
+  describe 'with gitaly enabled' do
+    it_behaves_like 'search_files_by_content'
+    it_behaves_like 'search_files_by_name'
+  end
+
+  describe 'with gitaly disabled', :disable_gitaly do
+    it_behaves_like 'search_files_by_content'
+    it_behaves_like 'search_files_by_name'
+  end
+
   describe '#async_remove_remote' do
     before do
       masterrev = repository.find_branch('master').dereferenced_target
diff --git a/spec/presenters/ci/build_presenter_spec.rb b/spec/presenters/ci/build_presenter_spec.rb
index 4bc005df2fc..efd175247b5 100644
--- a/spec/presenters/ci/build_presenter_spec.rb
+++ b/spec/presenters/ci/build_presenter_spec.rb
@@ -10,7 +10,7 @@ describe Ci::BuildPresenter do
   end
 
   it 'inherits from Gitlab::View::Presenter::Delegated' do
-    expect(described_class.superclass).to eq(Gitlab::View::Presenter::Delegated)
+    expect(described_class.ancestors).to include(Gitlab::View::Presenter::Delegated)
   end
 
   describe '#initialize' do
diff --git a/spec/presenters/commit_status_presenter_spec.rb b/spec/presenters/commit_status_presenter_spec.rb
new file mode 100644
index 00000000000..f81ee44e371
--- /dev/null
+++ b/spec/presenters/commit_status_presenter_spec.rb
@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe CommitStatusPresenter do
+  let(:project) { create(:project) }
+  let(:pipeline) { create(:ci_pipeline, project: project) }
+  let(:build) { create(:ci_build, pipeline: pipeline) }
+
+  subject(:presenter) do
+    described_class.new(build)
+  end
+
+  it 'inherits from Gitlab::View::Presenter::Delegated' do
+    expect(described_class.superclass).to eq(Gitlab::View::Presenter::Delegated)
+  end
+end
diff --git a/spec/requests/api/groups_spec.rb b/spec/requests/api/groups_spec.rb
index bb0034e3237..7d923932309 100644
--- a/spec/requests/api/groups_spec.rb
+++ b/spec/requests/api/groups_spec.rb
@@ -738,13 +738,16 @@ describe API::Groups do
   describe "DELETE /groups/:id" do
     context "when authenticated as user" do
       it "removes group" do
-        delete api("/groups/#{group1.id}", user1)
+        Sidekiq::Testing.fake! do
+          expect { delete api("/groups/#{group1.id}", user1) }.to change(GroupDestroyWorker.jobs, :size).by(1)
+        end
 
-        expect(response).to have_gitlab_http_status(204)
+        expect(response).to have_gitlab_http_status(202)
       end
 
       it_behaves_like '412 response' do
         let(:request) { api("/groups/#{group1.id}", user1) }
+        let(:success_status) { 202 }
       end
 
       it "does not remove a group if not an owner" do
@@ -773,7 +776,7 @@ describe API::Groups do
       it "removes any existing group" do
         delete api("/groups/#{group2.id}", admin)
 
-        expect(response).to have_gitlab_http_status(204)
+        expect(response).to have_gitlab_http_status(202)
       end
 
       it "does not remove a non existing group" do
diff --git a/spec/requests/api/issues_spec.rb b/spec/requests/api/issues_spec.rb
index 60e174ff92a..3106083293f 100644
--- a/spec/requests/api/issues_spec.rb
+++ b/spec/requests/api/issues_spec.rb
@@ -126,6 +126,15 @@ describe API::Issues do
       it 'returns issues assigned to me' do
         issue2 = create(:issue, assignees: [user2], project: project)
 
+        get api('/issues', user2), scope: 'assigned_to_me'
+
+        expect_paginated_array_response(size: 1)
+        expect(first_issue['id']).to eq(issue2.id)
+      end
+
+      it 'returns issues assigned to me (kebab-case)' do
+        issue2 = create(:issue, assignees: [user2], project: project)
+
         get api('/issues', user2), scope: 'assigned-to-me'
 
         expect_paginated_array_response(size: 1)
diff --git a/spec/requests/api/markdown_spec.rb b/spec/requests/api/markdown_spec.rb
new file mode 100644
index 00000000000..a55796cf343
--- /dev/null
+++ b/spec/requests/api/markdown_spec.rb
@@ -0,0 +1,112 @@
+require "spec_helper"
+
+describe API::Markdown do
+  RSpec::Matchers.define_negated_matcher :exclude, :include
+
+  describe "POST /markdown" do
+    let(:user) {} # No-op. It gets overwritten in the contexts below.
+
+    before do
+      post api("/markdown", user), params
+    end
+
+    shared_examples "rendered markdown text without GFM" do
+      it "renders markdown text" do
+        expect(response).to have_http_status(201)
+        expect(response.headers["Content-Type"]).to eq("application/json")
+        expect(json_response).to be_a(Hash)
+        expect(json_response["html"]).to eq("<p>#{text}</p>")
+      end
+    end
+
+    shared_examples "404 Project Not Found" do
+      it "responses with 404 Not Found" do
+        expect(response).to have_http_status(404)
+        expect(response.headers["Content-Type"]).to eq("application/json")
+        expect(json_response).to be_a(Hash)
+        expect(json_response["message"]).to eq("404 Project Not Found")
+      end
+    end
+
+    context "when arguments are invalid" do
+      context "when text is missing" do
+        let(:params) { {} }
+
+        it "responses with 400 Bad Request" do
+          expect(response).to have_http_status(400)
+          expect(response.headers["Content-Type"]).to eq("application/json")
+          expect(json_response).to be_a(Hash)
+          expect(json_response["error"]).to eq("text is missing")
+        end
+      end
+
+      context "when project is not found" do
+        let(:params) { { text: "Hello world!", gfm: true, project: "Dummy project" } }
+
+        it_behaves_like "404 Project Not Found"
+      end
+    end
+
+    context "when arguments are valid" do
+      set(:project) { create(:project) }
+      set(:issue) { create(:issue, project: project) }
+      let(:text) { ":tada: Hello world! :100: #{issue.to_reference}" }
+
+      context "when not using gfm" do
+        context "without project" do
+          let(:params) { { text: text } }
+
+          it_behaves_like "rendered markdown text without GFM"
+        end
+
+        context "with project" do
+          let(:params) { { text: text, project: project.full_path } }
+
+          context "when not authorized" do
+            it_behaves_like "404 Project Not Found"
+          end
+
+          context "when authorized" do
+            let(:user) { project.owner }
+
+            it_behaves_like "rendered markdown text without GFM"
+          end
+        end
+      end
+
+      context "when using gfm" do
+        context "without project" do
+          let(:params) { { text: text, gfm: true } }
+
+          it "renders markdown text" do
+            expect(response).to have_http_status(201)
+            expect(response.headers["Content-Type"]).to eq("application/json")
+            expect(json_response).to be_a(Hash)
+            expect(json_response["html"]).to include("Hello world!")
+                                        .and include('data-name="tada"')
+                                        .and include('data-name="100"')
+                                        .and include("#1")
+                                        .and exclude("<a href=\"#{IssuesHelper.url_for_issue(issue.iid, project)}\"")
+                                        .and exclude("#1</a>")
+          end
+        end
+
+        context "with project" do
+          let(:params) { { text: text, gfm: true, project: project.full_path } }
+          let(:user) { project.owner }
+
+          it "renders markdown text" do
+            expect(response).to have_http_status(201)
+            expect(response.headers["Content-Type"]).to eq("application/json")
+            expect(json_response).to be_a(Hash)
+            expect(json_response["html"]).to include("Hello world!")
+                                        .and include('data-name="tada"')
+                                        .and include('data-name="100"')
+                                        .and include("<a href=\"#{IssuesHelper.url_for_issue(issue.iid, project)}\"")
+                                        .and include("#1</a>")
+          end
+        end
+      end
+    end
+  end
+end
diff --git a/spec/requests/api/merge_requests_spec.rb b/spec/requests/api/merge_requests_spec.rb
index f64623d7018..1eeeb4f1045 100644
--- a/spec/requests/api/merge_requests_spec.rb
+++ b/spec/requests/api/merge_requests_spec.rb
@@ -34,8 +34,7 @@ describe API::MergeRequests do
       it 'returns an array of all merge requests' do
         get api('/merge_requests', user), scope: 'all'
 
-        expect(response).to have_gitlab_http_status(200)
-        expect(json_response).to be_an Array
+        expect_paginated_array_response
       end
 
       it "returns authentication error without any scope" do
@@ -50,11 +49,23 @@ describe API::MergeRequests do
         expect(response).to have_gitlab_http_status(401)
       end
 
+      it "returns authentication error when scope is assigned_to_me" do
+        get api("/merge_requests"), scope: 'assigned_to_me'
+
+        expect(response).to have_gitlab_http_status(401)
+      end
+
       it "returns authentication error  when scope is created-by-me" do
         get api("/merge_requests"), scope: 'created-by-me'
 
         expect(response).to have_gitlab_http_status(401)
       end
+
+      it "returns authentication error when scope is created_by_me" do
+        get api("/merge_requests"), scope: 'created_by_me'
+
+        expect(response).to have_gitlab_http_status(401)
+      end
     end
 
     context 'when authenticated' do
@@ -62,27 +73,14 @@ describe API::MergeRequests do
       let!(:merge_request2) { create(:merge_request, :simple, author: user, assignee: user, source_project: project2, target_project: project2) }
       let(:user2) { create(:user) }
 
-      it 'returns an array of all merge requests' do
-        get api('/merge_requests', user), scope: :all
-
-        expect(response).to have_gitlab_http_status(200)
-        expect(response).to include_pagination_headers
-        expect(json_response).to be_an Array
-        expect(json_response.map { |mr| mr['id'] })
-          .to contain_exactly(merge_request.id, merge_request_closed.id, merge_request_merged.id, merge_request2.id)
-      end
-
-      it 'does not return unauthorized merge requests' do
+      it 'returns an array of all merge requests except unauthorized ones' do
         private_project = create(:project, :private)
         merge_request3 = create(:merge_request, :simple, source_project: private_project, target_project: private_project, source_branch: 'other-branch')
 
         get api('/merge_requests', user), scope: :all
 
-        expect(response).to have_gitlab_http_status(200)
-        expect(response).to include_pagination_headers
-        expect(json_response).to be_an Array
-        expect(json_response.map { |mr| mr['id'] })
-          .not_to include(merge_request3.id)
+        expect_response_contain_exactly(merge_request2, merge_request_merged, merge_request_closed, merge_request)
+        expect(json_response.map { |mr| mr['id'] }).not_to include(merge_request3.id)
       end
 
       it 'returns an array of merge requests created by current user if no scope is given' do
@@ -90,10 +88,7 @@ describe API::MergeRequests do
 
         get api('/merge_requests', user2)
 
-        expect(response).to have_gitlab_http_status(200)
-        expect(json_response).to be_an Array
-        expect(json_response.length).to eq(1)
-        expect(json_response.first['id']).to eq(merge_request3.id)
+        expect_response_ordered_exactly(merge_request3)
       end
 
       it 'returns an array of merge requests authored by the given user' do
@@ -101,10 +96,7 @@ describe API::MergeRequests do
 
         get api('/merge_requests', user), author_id: user2.id, scope: :all
 
-        expect(response).to have_gitlab_http_status(200)
-        expect(json_response).to be_an Array
-        expect(json_response.length).to eq(1)
-        expect(json_response.first['id']).to eq(merge_request3.id)
+        expect_response_ordered_exactly(merge_request3)
       end
 
       it 'returns an array of merge requests assigned to the given user' do
@@ -112,32 +104,39 @@ describe API::MergeRequests do
 
         get api('/merge_requests', user), assignee_id: user2.id, scope: :all
 
-        expect(response).to have_gitlab_http_status(200)
-        expect(json_response).to be_an Array
-        expect(json_response.length).to eq(1)
-        expect(json_response.first['id']).to eq(merge_request3.id)
+        expect_response_ordered_exactly(merge_request3)
       end
 
       it 'returns an array of merge requests assigned to me' do
         merge_request3 = create(:merge_request, :simple, author: user, assignee: user2, source_project: project2, target_project: project2, source_branch: 'other-branch')
 
+        get api('/merge_requests', user2), scope: 'assigned_to_me'
+
+        expect_response_ordered_exactly(merge_request3)
+      end
+
+      it 'returns an array of merge requests assigned to me (kebab-case)' do
+        merge_request3 = create(:merge_request, :simple, author: user, assignee: user2, source_project: project2, target_project: project2, source_branch: 'other-branch')
+
         get api('/merge_requests', user2), scope: 'assigned-to-me'
 
-        expect(response).to have_gitlab_http_status(200)
-        expect(json_response).to be_an Array
-        expect(json_response.length).to eq(1)
-        expect(json_response.first['id']).to eq(merge_request3.id)
+        expect_response_ordered_exactly(merge_request3)
       end
 
       it 'returns an array of merge requests created by me' do
         merge_request3 = create(:merge_request, :simple, author: user2, assignee: user, source_project: project2, target_project: project2, source_branch: 'other-branch')
 
+        get api('/merge_requests', user2), scope: 'created_by_me'
+
+        expect_response_ordered_exactly(merge_request3)
+      end
+
+      it 'returns an array of merge requests created by me (kebab-case)' do
+        merge_request3 = create(:merge_request, :simple, author: user2, assignee: user, source_project: project2, target_project: project2, source_branch: 'other-branch')
+
         get api('/merge_requests', user2), scope: 'created-by-me'
 
-        expect(response).to have_gitlab_http_status(200)
-        expect(json_response).to be_an Array
-        expect(json_response.length).to eq(1)
-        expect(json_response.first['id']).to eq(merge_request3.id)
+        expect_response_ordered_exactly(merge_request3)
       end
 
       it 'returns merge requests reacted by the authenticated user by the given emoji' do
@@ -146,19 +145,14 @@ describe API::MergeRequests do
 
         get api('/merge_requests', user2), my_reaction_emoji: award_emoji.name, scope: 'all'
 
-        expect(response).to have_gitlab_http_status(200)
-        expect(json_response).to be_an Array
-        expect(json_response.length).to eq(1)
-        expect(json_response.first['id']).to eq(merge_request3.id)
+        expect_response_ordered_exactly(merge_request3)
       end
 
       context 'source_branch param' do
         it 'returns merge requests with the given source branch' do
           get api('/merge_requests', user), source_branch: merge_request_closed.source_branch, state: 'all'
 
-          expect(json_response.length).to eq(2)
-          expect(json_response.map { |mr| mr['id'] })
-            .to contain_exactly(merge_request_closed.id, merge_request_merged.id)
+          expect_response_contain_exactly(merge_request_closed, merge_request_merged)
         end
       end
 
@@ -166,9 +160,7 @@ describe API::MergeRequests do
         it 'returns merge requests with the given target branch' do
           get api('/merge_requests', user), target_branch: merge_request_closed.target_branch, state: 'all'
 
-          expect(json_response.length).to eq(2)
-          expect(json_response.map { |mr| mr['id'] })
-            .to contain_exactly(merge_request_closed.id, merge_request_merged.id)
+          expect_response_contain_exactly(merge_request_closed, merge_request_merged)
         end
       end
 
@@ -177,8 +169,7 @@ describe API::MergeRequests do
 
         get api('/merge_requests?created_before=2000-01-02T00:00:00.060Z', user)
 
-        expect(json_response.size).to eq(1)
-        expect(json_response.first['id']).to eq(merge_request2.id)
+        expect_response_ordered_exactly(merge_request2)
       end
 
       it 'returns merge requests created after a specific date' do
@@ -186,8 +177,7 @@ describe API::MergeRequests do
 
         get api("/merge_requests?created_after=#{merge_request2.created_at}", user)
 
-        expect(json_response.size).to eq(1)
-        expect(json_response.first['id']).to eq(merge_request2.id)
+        expect_response_ordered_exactly(merge_request2)
       end
 
       it 'returns merge requests updated before a specific date' do
@@ -195,8 +185,7 @@ describe API::MergeRequests do
 
         get api('/merge_requests?updated_before=2000-01-02T00:00:00.060Z', user)
 
-        expect(json_response.size).to eq(1)
-        expect(json_response.first['id']).to eq(merge_request2.id)
+        expect_response_ordered_exactly(merge_request2)
       end
 
       it 'returns merge requests updated after a specific date' do
@@ -204,8 +193,7 @@ describe API::MergeRequests do
 
         get api("/merge_requests?updated_after=#{merge_request2.updated_at}", user)
 
-        expect(json_response.size).to eq(1)
-        expect(json_response.first['id']).to eq(merge_request2.id)
+        expect_response_ordered_exactly(merge_request2)
       end
 
       context 'search params' do
@@ -216,15 +204,13 @@ describe API::MergeRequests do
         it 'returns merge requests matching given search string for title' do
           get api("/merge_requests", user), search: merge_request.title
 
-          expect(json_response.length).to eq(1)
-          expect(json_response.first['id']).to eq(merge_request.id)
+          expect_response_ordered_exactly(merge_request)
         end
 
         it 'returns merge requests for project matching given search string for description' do
           get api("/merge_requests", user), project_id: project.id, search: merge_request.description
 
-          expect(json_response.length).to eq(1)
-          expect(json_response.first['id']).to eq(merge_request.id)
+          expect_response_ordered_exactly(merge_request)
         end
       end
     end
@@ -235,8 +221,7 @@ describe API::MergeRequests do
       it 'returns merge requests for public projects' do
         get api("/projects/#{project.id}/merge_requests")
 
-        expect(response).to have_gitlab_http_status(200)
-        expect(json_response).to be_an Array
+        expect_paginated_array_response
       end
 
       it "returns 404 for non public projects" do
@@ -265,10 +250,7 @@ describe API::MergeRequests do
       it "returns an array of all merge_requests" do
         get api("/projects/#{project.id}/merge_requests", user)
 
-        expect(response).to have_gitlab_http_status(200)
-        expect(response).to include_pagination_headers
-        expect(json_response).to be_an Array
-        expect(json_response.length).to eq(3)
+        expect_response_ordered_exactly(merge_request_merged, merge_request_closed, merge_request)
         expect(json_response.last['title']).to eq(merge_request.title)
         expect(json_response.last).to have_key('web_url')
         expect(json_response.last['sha']).to eq(merge_request.diff_head_sha)
@@ -286,11 +268,8 @@ describe API::MergeRequests do
       it "returns an array of all merge_requests using simple mode" do
         get api("/projects/#{project.id}/merge_requests?view=simple", user)
 
-        expect(response).to have_gitlab_http_status(200)
-        expect(response).to include_pagination_headers
+        expect_response_ordered_exactly(merge_request_merged, merge_request_closed, merge_request)
         expect(json_response.last.keys).to match_array(%w(id iid title web_url created_at description project_id state updated_at))
-        expect(json_response).to be_an Array
-        expect(json_response.length).to eq(3)
         expect(json_response.last['iid']).to eq(merge_request.iid)
         expect(json_response.last['title']).to eq(merge_request.title)
         expect(json_response.last).to have_key('web_url')
@@ -302,51 +281,36 @@ describe API::MergeRequests do
       it "returns an array of all merge_requests" do
         get api("/projects/#{project.id}/merge_requests?state", user)
 
-        expect(response).to have_gitlab_http_status(200)
-        expect(response).to include_pagination_headers
-        expect(json_response).to be_an Array
-        expect(json_response.length).to eq(3)
+        expect_response_ordered_exactly(merge_request_merged, merge_request_closed, merge_request)
         expect(json_response.last['title']).to eq(merge_request.title)
       end
 
       it "returns an array of open merge_requests" do
         get api("/projects/#{project.id}/merge_requests?state=opened", user)
 
-        expect(response).to have_gitlab_http_status(200)
-        expect(response).to include_pagination_headers
-        expect(json_response).to be_an Array
-        expect(json_response.length).to eq(1)
+        expect_response_ordered_exactly(merge_request)
         expect(json_response.last['title']).to eq(merge_request.title)
       end
 
       it "returns an array of closed merge_requests" do
         get api("/projects/#{project.id}/merge_requests?state=closed", user)
 
-        expect(response).to have_gitlab_http_status(200)
-        expect(response).to include_pagination_headers
-        expect(json_response).to be_an Array
-        expect(json_response.length).to eq(1)
+        expect_response_ordered_exactly(merge_request_closed)
         expect(json_response.first['title']).to eq(merge_request_closed.title)
       end
 
       it "returns an array of merged merge_requests" do
         get api("/projects/#{project.id}/merge_requests?state=merged", user)
 
-        expect(response).to have_gitlab_http_status(200)
-        expect(response).to include_pagination_headers
-        expect(json_response).to be_an Array
-        expect(json_response.length).to eq(1)
+        expect_response_ordered_exactly(merge_request_merged)
         expect(json_response.first['title']).to eq(merge_request_merged.title)
       end
 
       it 'returns merge_request by "iids" array' do
         get api("/projects/#{project.id}/merge_requests", user), iids: [merge_request.iid, merge_request_closed.iid]
 
-        expect(response).to have_gitlab_http_status(200)
-        expect(json_response).to be_an Array
-        expect(json_response.length).to eq(2)
+        expect_response_ordered_exactly(merge_request_closed, merge_request)
         expect(json_response.first['title']).to eq merge_request_closed.title
-        expect(json_response.first['id']).to eq merge_request_closed.id
       end
 
       it 'matches V4 response schema' do
@@ -359,16 +323,14 @@ describe API::MergeRequests do
       it 'returns an empty array if no issue matches milestone' do
         get api("/projects/#{project.id}/merge_requests", user), milestone: '1.0.0'
 
-        expect(response).to have_gitlab_http_status(200)
-        expect(json_response).to be_an Array
+        expect_paginated_array_response
         expect(json_response.length).to eq(0)
       end
 
       it 'returns an empty array if milestone does not exist' do
         get api("/projects/#{project.id}/merge_requests", user), milestone: 'foo'
 
-        expect(response).to have_gitlab_http_status(200)
-        expect(json_response).to be_an Array
+        expect_paginated_array_response
         expect(json_response.length).to eq(0)
       end
 
@@ -382,17 +344,13 @@ describe API::MergeRequests do
       it 'returns an array of merge requests matching state in milestone' do
         get api("/projects/#{project.id}/merge_requests", user), milestone: '0.9', state: 'closed'
 
-        expect(response).to have_gitlab_http_status(200)
-        expect(json_response).to be_an Array
-        expect(json_response.length).to eq(1)
-        expect(json_response.first['id']).to eq(merge_request_closed.id)
+        expect_response_ordered_exactly(merge_request_closed)
       end
 
       it 'returns an array of labeled merge requests' do
         get api("/projects/#{project.id}/merge_requests?labels=#{label.title}", user)
 
-        expect(response).to have_gitlab_http_status(200)
-        expect(json_response).to be_an Array
+        expect_paginated_array_response
         expect(json_response.length).to eq(1)
         expect(json_response.first['labels']).to eq([label2.title, label.title])
       end
@@ -400,16 +358,14 @@ describe API::MergeRequests do
       it 'returns an array of labeled merge requests where all labels match' do
         get api("/projects/#{project.id}/merge_requests?labels=#{label.title},foo,bar", user)
 
-        expect(response).to have_gitlab_http_status(200)
-        expect(json_response).to be_an Array
+        expect_paginated_array_response
         expect(json_response.length).to eq(0)
       end
 
       it 'returns an empty array if no merge request matches labels' do
         get api("/projects/#{project.id}/merge_requests?labels=foo,bar", user)
 
-        expect(response).to have_gitlab_http_status(200)
-        expect(json_response).to be_an Array
+        expect_paginated_array_response
         expect(json_response.length).to eq(0)
       end
 
@@ -427,13 +383,12 @@ describe API::MergeRequests do
 
         get api("/projects/#{project.id}/merge_requests?labels=#{bug_label.title}&milestone=#{milestone1.title}&state=merged", user)
 
-        expect(response).to have_gitlab_http_status(200)
-        expect(json_response).to be_an Array
-        expect(json_response.length).to eq(1)
-        expect(json_response.first['id']).to eq(mr2.id)
+        expect_response_ordered_exactly(mr2)
       end
 
       context "with ordering" do
+        let(:merge_requests) { [merge_request_merged, merge_request_closed, merge_request] }
+
         before do
           @mr_later = mr_with_later_created_and_updated_at_time
           @mr_earlier = mr_with_earlier_created_and_updated_at_time
@@ -442,45 +397,25 @@ describe API::MergeRequests do
         it "returns an array of merge_requests in ascending order" do
           get api("/projects/#{project.id}/merge_requests?sort=asc", user)
 
-          expect(response).to have_gitlab_http_status(200)
-          expect(response).to include_pagination_headers
-          expect(json_response).to be_an Array
-          expect(json_response.length).to eq(3)
-          response_dates = json_response.map { |merge_request| merge_request['created_at'] }
-          expect(response_dates).to eq(response_dates.sort)
+          expect_response_ordered_exactly(*merge_requests.sort_by { |mr| mr['created_at'] })
         end
 
         it "returns an array of merge_requests in descending order" do
           get api("/projects/#{project.id}/merge_requests?sort=desc", user)
 
-          expect(response).to have_gitlab_http_status(200)
-          expect(response).to include_pagination_headers
-          expect(json_response).to be_an Array
-          expect(json_response.length).to eq(3)
-          response_dates = json_response.map { |merge_request| merge_request['created_at'] }
-          expect(response_dates).to eq(response_dates.sort.reverse)
+          expect_response_ordered_exactly(*merge_requests.sort_by { |mr| mr['created_at'] }.reverse)
         end
 
         it "returns an array of merge_requests ordered by updated_at" do
           get api("/projects/#{project.id}/merge_requests?order_by=updated_at", user)
 
-          expect(response).to have_gitlab_http_status(200)
-          expect(response).to include_pagination_headers
-          expect(json_response).to be_an Array
-          expect(json_response.length).to eq(3)
-          response_dates = json_response.map { |merge_request| merge_request['updated_at'] }
-          expect(response_dates).to eq(response_dates.sort.reverse)
+          expect_response_ordered_exactly(*merge_requests.sort_by { |mr| mr['updated_at'] }.reverse)
         end
 
         it "returns an array of merge_requests ordered by created_at" do
           get api("/projects/#{project.id}/merge_requests?order_by=created_at&sort=asc", user)
 
-          expect(response).to have_gitlab_http_status(200)
-          expect(response).to include_pagination_headers
-          expect(json_response).to be_an Array
-          expect(json_response.length).to eq(3)
-          response_dates = json_response.map { |merge_request| merge_request['created_at'] }
-          expect(response_dates).to eq(response_dates.sort)
+          expect_response_ordered_exactly(*merge_requests.sort_by { |mr| mr['created_at'] })
         end
       end
 
@@ -488,9 +423,7 @@ describe API::MergeRequests do
         it 'returns merge requests with the given source branch' do
           get api('/merge_requests', user), source_branch: merge_request_closed.source_branch, state: 'all'
 
-          expect(json_response.length).to eq(2)
-          expect(json_response.map { |mr| mr['id'] })
-            .to contain_exactly(merge_request_closed.id, merge_request_merged.id)
+          expect_response_contain_exactly(merge_request_closed, merge_request_merged)
         end
       end
 
@@ -498,9 +431,7 @@ describe API::MergeRequests do
         it 'returns merge requests with the given target branch' do
           get api('/merge_requests', user), target_branch: merge_request_closed.target_branch, state: 'all'
 
-          expect(json_response.length).to eq(2)
-          expect(json_response.map { |mr| mr['id'] })
-            .to contain_exactly(merge_request_closed.id, merge_request_merged.id)
+          expect_response_contain_exactly(merge_request_closed, merge_request_merged)
         end
       end
     end
@@ -1341,4 +1272,22 @@ describe API::MergeRequests do
     merge_request_closed.save
     merge_request_closed
   end
+
+  def expect_response_contain_exactly(*items)
+    expect_paginated_array_response
+    expect(json_response.length).to eq(items.size)
+    expect(json_response.map { |element| element['id'] }).to contain_exactly(*items.map(&:id))
+  end
+
+  def expect_response_ordered_exactly(*items)
+    expect_paginated_array_response
+    expect(json_response.length).to eq(items.size)
+    expect(json_response.map { |element| element['id'] }).to eq(items.map(&:id))
+  end
+
+  def expect_paginated_array_response
+    expect(response).to have_gitlab_http_status(200)
+    expect(response).to include_pagination_headers
+    expect(json_response).to be_an Array
+  end
 end
diff --git a/spec/requests/api/runner_spec.rb b/spec/requests/api/runner_spec.rb
index da392c5ab81..efb9bddde44 100644
--- a/spec/requests/api/runner_spec.rb
+++ b/spec/requests/api/runner_spec.rb
@@ -918,6 +918,22 @@ describe API::Runner, :clean_gitlab_redis_shared_state do
             expect(job.reload.trace.raw).to eq 'BUILD TRACE appended appended'
           end
 
+          context 'when job is cancelled' do
+            before do
+              job.cancel
+            end
+
+            context 'when trace is patched' do
+              before do
+                patch_the_trace
+              end
+
+              it 'returns Forbidden ' do
+                expect(response.status).to eq(403)
+              end
+            end
+          end
+
           context 'when redis data are flushed' do
             before do
               redis_shared_state_cleanup!
diff --git a/spec/requests/api/v3/groups_spec.rb b/spec/requests/api/v3/groups_spec.rb
index a1cdf583de3..34d4b8e9565 100644
--- a/spec/requests/api/v3/groups_spec.rb
+++ b/spec/requests/api/v3/groups_spec.rb
@@ -458,9 +458,11 @@ describe API::V3::Groups do
   describe "DELETE /groups/:id" do
     context "when authenticated as user" do
       it "removes group" do
-        delete v3_api("/groups/#{group1.id}", user1)
+        Sidekiq::Testing.fake! do
+          expect { delete v3_api("/groups/#{group1.id}", user1) }.to change(GroupDestroyWorker.jobs, :size).by(1)
+        end
 
-        expect(response).to have_gitlab_http_status(200)
+        expect(response).to have_gitlab_http_status(202)
       end
 
       it "does not remove a group if not an owner" do
@@ -489,7 +491,7 @@ describe API::V3::Groups do
       it "removes any existing group" do
         delete v3_api("/groups/#{group2.id}", admin)
 
-        expect(response).to have_gitlab_http_status(200)
+        expect(response).to have_gitlab_http_status(202)
       end
 
       it "does not remove a non existing group" do
diff --git a/spec/serializers/pipeline_entity_spec.rb b/spec/serializers/pipeline_entity_spec.rb
index 2473c561f4b..e67d12b7a89 100644
--- a/spec/serializers/pipeline_entity_spec.rb
+++ b/spec/serializers/pipeline_entity_spec.rb
@@ -26,6 +26,13 @@ describe PipelineEntity do
         expect(subject).to include :updated_at, :created_at
       end
 
+      it 'excludes coverage data when disabled' do
+        entity = described_class
+          .represent(pipeline, request: request, disable_coverage: true)
+
+        expect(entity.as_json).not_to include(:coverage)
+      end
+
       it 'contains details' do
         expect(subject).to include :details
         expect(subject[:details])
diff --git a/spec/services/ci/create_pipeline_service_spec.rb b/spec/services/ci/create_pipeline_service_spec.rb
index 9a0b6efd8a9..2b88fcc9a96 100644
--- a/spec/services/ci/create_pipeline_service_spec.rb
+++ b/spec/services/ci/create_pipeline_service_spec.rb
@@ -395,7 +395,27 @@ describe Ci::CreatePipelineService do
         result = execute_service
 
         expect(result).to be_persisted
-        expect(Environment.find_by(name: "review/master")).not_to be_nil
+        expect(Environment.find_by(name: "review/master")).to be_present
+      end
+    end
+
+    context 'with environment name including persisted variables' do
+      before do
+        config = YAML.dump(
+          deploy: {
+            environment: { name: "review/id1$CI_PIPELINE_ID/id2$CI_BUILD_ID" },
+            script: 'ls'
+          }
+        )
+
+        stub_ci_pipeline_yaml_file(config)
+      end
+
+      it 'skipps persisted variables in environment name' do
+        result = execute_service
+
+        expect(result).to be_persisted
+        expect(Environment.find_by(name: "review/id1/id2")).to be_present
       end
     end
 
diff --git a/spec/services/keys/destroy_service_spec.rb b/spec/services/keys/destroy_service_spec.rb
new file mode 100644
index 00000000000..28ac72ddd42
--- /dev/null
+++ b/spec/services/keys/destroy_service_spec.rb
@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe Keys::DestroyService do
+  let(:user) { create(:user) }
+
+  subject { described_class.new(user) }
+
+  it 'destroys a key' do
+    key = create(:key)
+
+    expect { subject.execute(key) }.to change(Key, :count).by(-1)
+  end
+end
diff --git a/spec/services/projects/update_remote_mirror_service_spec.rb b/spec/services/projects/update_remote_mirror_service_spec.rb
index be09afd9f36..723cb374c37 100644
--- a/spec/services/projects/update_remote_mirror_service_spec.rb
+++ b/spec/services/projects/update_remote_mirror_service_spec.rb
@@ -343,7 +343,11 @@ describe Projects::UpdateRemoteMirrorService do
       tag = repository.find_tag(name)
       target = tag.try(:target)
       target_commit = tag.try(:dereferenced_target)
-      tags << Gitlab::Git::Tag.new(repository.raw_repository, name, target, target_commit)
+      tags << Gitlab::Git::Tag.new(repository.raw_repository, {
+        name: name,
+        target: target,
+        target_commit: target_commit
+      })
     end
   end
 
diff --git a/spec/support/shared_examples/malicious_regexp_shared_examples.rb b/spec/support/shared_examples/malicious_regexp_shared_examples.rb
index ac5d22298bb..65026f1d7c0 100644
--- a/spec/support/shared_examples/malicious_regexp_shared_examples.rb
+++ b/spec/support/shared_examples/malicious_regexp_shared_examples.rb
@@ -1,3 +1,5 @@
+require 'timeout'
+
 shared_examples 'malicious regexp' do
   let(:malicious_text)  { 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa!' }
   let(:malicious_regexp) { '(?i)^(([a-z])+.)+[A-Z]([a-z])+$' }