Add latest changes from gitlab-org/gitlab@master

34 files changed, 1912 insertions, 124 deletions

diff --git a/spec/controllers/projects/deployments_controller_spec.rb b/spec/controllers/projects/deployments_controller_spec.rb
index b9ee69a617b..66112c95742 100644
--- a/spec/controllers/projects/deployments_controller_spec.rb
+++ b/spec/controllers/projects/deployments_controller_spec.rb
@@ -75,15 +75,13 @@ describe Projects::DeploymentsController do
           }
         end
 
-        before do
+        it 'returns a metrics JSON document' do
           expect_next_instance_of(DeploymentMetrics) do |deployment_metrics|
             allow(deployment_metrics).to receive(:has_metrics?).and_return(true)
 
             expect(deployment_metrics).to receive(:metrics).and_return(empty_metrics)
           end
-        end
 
-        it 'returns a metrics JSON document' do
           get :metrics, params: deployment_params(id: deployment.to_param)
 
           expect(response).to be_ok
@@ -91,6 +89,19 @@ describe Projects::DeploymentsController do
           expect(json_response['metrics']).to eq({})
           expect(json_response['last_update']).to eq(42)
         end
+
+        it 'returns a 404 if the deployment failed' do
+          failed_deployment = create(
+            :deployment,
+            :failed,
+            project: project,
+            environment: environment
+          )
+
+          get :metrics, params: deployment_params(id: failed_deployment.to_param)
+
+          expect(response).to have_gitlab_http_status(404)
+        end
       end
     end
   end
diff --git a/spec/controllers/projects/merge_requests/diffs_controller_spec.rb b/spec/controllers/projects/merge_requests/diffs_controller_spec.rb
index e677e836145..5c02e8d6461 100644
--- a/spec/controllers/projects/merge_requests/diffs_controller_spec.rb
+++ b/spec/controllers/projects/merge_requests/diffs_controller_spec.rb
@@ -82,9 +82,9 @@ describe Projects::MergeRequests::DiffsController do
         end
       end
 
-      context 'when note has no position' do
+      context 'when note is a legacy diff note' do
         before do
-          create(:legacy_diff_note_on_merge_request, project: project, noteable: merge_request, position: nil)
+          create(:legacy_diff_note_on_merge_request, project: project, noteable: merge_request)
         end
 
         it 'serializes merge request diff collection' do
diff --git a/spec/features/projects/environments/environment_spec.rb b/spec/features/projects/environments/environment_spec.rb
index 25823b75d18..dd690699ff6 100644
--- a/spec/features/projects/environments/environment_spec.rb
+++ b/spec/features/projects/environments/environment_spec.rb
@@ -66,8 +66,8 @@ describe 'Environment' do
           create(:deployment, :running, environment: environment, deployable: build)
         end
 
-        it 'does not show deployments' do
-          expect(page).to have_content('You don\'t have any deployments right now.')
+        it 'does show deployments' do
+          expect(page).to have_link("#{build.name} (##{build.id})")
         end
       end
 
@@ -79,8 +79,8 @@ describe 'Environment' do
           create(:deployment, :failed, environment: environment, deployable: build)
         end
 
-        it 'does not show deployments' do
-          expect(page).to have_content('You don\'t have any deployments right now.')
+        it 'does show deployments' do
+          expect(page).to have_link("#{build.name} (##{build.id})")
         end
       end
 
@@ -175,7 +175,7 @@ describe 'Environment' do
                     #
                     # In EE we have to stub EE::Environment since it overwrites
                     # the "terminals" method.
-                    allow_any_instance_of(defined?(EE) ? EE::Environment : Environment)
+                    allow_any_instance_of(Gitlab.ee? ? EE::Environment : Environment)
                       .to receive(:terminals) { nil }
 
                     visit terminal_project_environment_path(project, environment)
diff --git a/spec/fixtures/api/schemas/deployment.json b/spec/fixtures/api/schemas/deployment.json
index b1e3c000ddf..0cfeadfe548 100644
--- a/spec/fixtures/api/schemas/deployment.json
+++ b/spec/fixtures/api/schemas/deployment.json
@@ -61,7 +61,7 @@
       "type": "array",
       "items": { "$ref": "job/job.json" }
     },
-    "status": { "type": "string" }		
+    "status": { "type": "string" }
   },
   "additionalProperties": false
 }
diff --git a/spec/frontend/releases/detail/components/app_spec.js b/spec/frontend/releases/detail/components/app_spec.js
new file mode 100644
index 00000000000..f8eb33a69a8
--- /dev/null
+++ b/spec/frontend/releases/detail/components/app_spec.js
@@ -0,0 +1,70 @@
+import Vuex from 'vuex';
+import { mount } from '@vue/test-utils';
+import ReleaseDetailApp from '~/releases/detail/components/app';
+import { release } from '../../mock_data';
+import { convertObjectPropsToCamelCase } from '~/lib/utils/common_utils';
+
+describe('Release detail component', () => {
+  let wrapper;
+  let releaseClone;
+  let actions;
+
+  beforeEach(() => {
+    gon.api_version = 'v4';
+
+    releaseClone = JSON.parse(JSON.stringify(convertObjectPropsToCamelCase(release)));
+
+    const state = {
+      release: releaseClone,
+      markdownDocsPath: 'path/to/markdown/docs',
+    };
+
+    actions = {
+      fetchRelease: jest.fn(),
+      updateRelease: jest.fn(),
+      navigateToReleasesPage: jest.fn(),
+    };
+
+    const store = new Vuex.Store({ actions, state });
+
+    wrapper = mount(ReleaseDetailApp, { store });
+
+    return wrapper.vm.$nextTick();
+  });
+
+  it('calls fetchRelease when the component is created', () => {
+    expect(actions.fetchRelease).toHaveBeenCalledTimes(1);
+  });
+
+  it('renders the description text at the top of the page', () => {
+    expect(wrapper.find('.js-subtitle-text').text()).toBe(
+      'Releases are based on Git tags. We recommend naming tags that fit within semantic versioning, for example v1.0, v2.0-pre.',
+    );
+  });
+
+  it('renders the correct tag name in the "Tag name" field', () => {
+    expect(wrapper.find('#git-ref').element.value).toBe(releaseClone.tagName);
+  });
+
+  it('renders the correct release title in the "Release title" field', () => {
+    expect(wrapper.find('#release-title').element.value).toBe(releaseClone.name);
+  });
+
+  it('renders the release notes in the "Release notes" textarea', () => {
+    expect(wrapper.find('#release-notes').element.value).toBe(releaseClone.description);
+  });
+
+  it('renders the "Save changes" button as type="submit"', () => {
+    expect(wrapper.find('.js-submit-button').attributes('type')).toBe('submit');
+  });
+
+  it('calls updateRelease when the form is submitted', () => {
+    wrapper.find('form').trigger('submit');
+    expect(actions.updateRelease).toHaveBeenCalledTimes(1);
+  });
+
+  it('calls navigateToReleasesPage when the "Cancel" button is clicked', () => {
+    wrapper.find('.js-cancel-button').vm.$emit('click');
+    expect(actions.navigateToReleasesPage).toHaveBeenCalledTimes(1);
+  });
+});
diff --git a/spec/frontend/releases/detail/store/actions_spec.js b/spec/frontend/releases/detail/store/actions_spec.js
new file mode 100644
index 00000000000..f1c7f3c1048
--- /dev/null
+++ b/spec/frontend/releases/detail/store/actions_spec.js
@@ -0,0 +1,217 @@
+import axios from 'axios';
+import MockAdapter from 'axios-mock-adapter';
+import * as actions from '~/releases/detail/store/actions';
+import testAction from 'helpers/vuex_action_helper';
+import * as types from '~/releases/detail/store/mutation_types';
+import { release } from '../../mock_data';
+import state from '~/releases/detail/store/state';
+import createFlash from '~/flash';
+import { redirectTo } from '~/lib/utils/url_utility';
+import { convertObjectPropsToCamelCase } from '~/lib/utils/common_utils';
+
+jest.mock('~/flash', () => jest.fn());
+
+jest.mock('~/lib/utils/url_utility', () => ({
+  redirectTo: jest.fn(),
+  joinPaths: jest.requireActual('~/lib/utils/url_utility').joinPaths,
+}));
+
+describe('Release detail actions', () => {
+  let stateClone;
+  let releaseClone;
+  let mock;
+  let error;
+
+  beforeEach(() => {
+    stateClone = state();
+    releaseClone = JSON.parse(JSON.stringify(release));
+    mock = new MockAdapter(axios);
+    gon.api_version = 'v4';
+    error = { message: 'An error occurred' };
+    createFlash.mockClear();
+  });
+
+  afterEach(() => {
+    mock.restore();
+  });
+
+  describe('setInitialState', () => {
+    it(`commits ${types.SET_INITIAL_STATE} with the provided object`, () => {
+      const initialState = {};
+
+      return testAction(actions.setInitialState, initialState, stateClone, [
+        { type: types.SET_INITIAL_STATE, payload: initialState },
+      ]);
+    });
+  });
+
+  describe('requestRelease', () => {
+    it(`commits ${types.REQUEST_RELEASE}`, () =>
+      testAction(actions.requestRelease, undefined, stateClone, [{ type: types.REQUEST_RELEASE }]));
+  });
+
+  describe('receiveReleaseSuccess', () => {
+    it(`commits ${types.RECEIVE_RELEASE_SUCCESS}`, () =>
+      testAction(actions.receiveReleaseSuccess, releaseClone, stateClone, [
+        { type: types.RECEIVE_RELEASE_SUCCESS, payload: releaseClone },
+      ]));
+  });
+
+  describe('receiveReleaseError', () => {
+    it(`commits ${types.RECEIVE_RELEASE_ERROR}`, () =>
+      testAction(actions.receiveReleaseError, error, stateClone, [
+        { type: types.RECEIVE_RELEASE_ERROR, payload: error },
+      ]));
+
+    it('shows a flash with an error message', () => {
+      actions.receiveReleaseError({ commit: jest.fn() }, error);
+
+      expect(createFlash).toHaveBeenCalledTimes(1);
+      expect(createFlash).toHaveBeenCalledWith(
+        'Something went wrong while getting the release details',
+      );
+    });
+  });
+
+  describe('fetchRelease', () => {
+    let getReleaseUrl;
+
+    beforeEach(() => {
+      stateClone.projectId = '18';
+      stateClone.tagName = 'v1.3';
+      getReleaseUrl = `/api/v4/projects/${stateClone.projectId}/releases/${stateClone.tagName}`;
+    });
+
+    it(`dispatches requestRelease and receiveReleaseSuccess with the camel-case'd release object`, () => {
+      mock.onGet(getReleaseUrl).replyOnce(200, releaseClone);
+
+      return testAction(
+        actions.fetchRelease,
+        undefined,
+        stateClone,
+        [],
+        [
+          { type: 'requestRelease' },
+          {
+            type: 'receiveReleaseSuccess',
+            payload: convertObjectPropsToCamelCase(releaseClone, { deep: true }),
+          },
+        ],
+      );
+    });
+
+    it(`dispatches requestRelease and receiveReleaseError with an error object`, () => {
+      mock.onGet(getReleaseUrl).replyOnce(500);
+
+      return testAction(
+        actions.fetchRelease,
+        undefined,
+        stateClone,
+        [],
+        [{ type: 'requestRelease' }, { type: 'receiveReleaseError', payload: expect.anything() }],
+      );
+    });
+  });
+
+  describe('updateReleaseTitle', () => {
+    it(`commits ${types.UPDATE_RELEASE_TITLE} with the updated release title`, () => {
+      const newTitle = 'The new release title';
+      return testAction(actions.updateReleaseTitle, newTitle, stateClone, [
+        { type: types.UPDATE_RELEASE_TITLE, payload: newTitle },
+      ]);
+    });
+  });
+
+  describe('updateReleaseNotes', () => {
+    it(`commits ${types.UPDATE_RELEASE_NOTES} with the updated release notes`, () => {
+      const newReleaseNotes = 'The new release notes';
+      return testAction(actions.updateReleaseNotes, newReleaseNotes, stateClone, [
+        { type: types.UPDATE_RELEASE_NOTES, payload: newReleaseNotes },
+      ]);
+    });
+  });
+
+  describe('requestUpdateRelease', () => {
+    it(`commits ${types.REQUEST_UPDATE_RELEASE}`, () =>
+      testAction(actions.requestUpdateRelease, undefined, stateClone, [
+        { type: types.REQUEST_UPDATE_RELEASE },
+      ]));
+  });
+
+  describe('receiveUpdateReleaseSuccess', () => {
+    it(`commits ${types.RECEIVE_UPDATE_RELEASE_SUCCESS}`, () =>
+      testAction(
+        actions.receiveUpdateReleaseSuccess,
+        undefined,
+        stateClone,
+        [{ type: types.RECEIVE_UPDATE_RELEASE_SUCCESS }],
+        [{ type: 'navigateToReleasesPage' }],
+      ));
+  });
+
+  describe('receiveUpdateReleaseError', () => {
+    it(`commits ${types.RECEIVE_UPDATE_RELEASE_ERROR}`, () =>
+      testAction(actions.receiveUpdateReleaseError, error, stateClone, [
+        { type: types.RECEIVE_UPDATE_RELEASE_ERROR, payload: error },
+      ]));
+
+    it('shows a flash with an error message', () => {
+      actions.receiveUpdateReleaseError({ commit: jest.fn() }, error);
+
+      expect(createFlash).toHaveBeenCalledTimes(1);
+      expect(createFlash).toHaveBeenCalledWith(
+        'Something went wrong while saving the release details',
+      );
+    });
+  });
+
+  describe('updateRelease', () => {
+    let getReleaseUrl;
+
+    beforeEach(() => {
+      stateClone.release = releaseClone;
+      stateClone.projectId = '18';
+      stateClone.tagName = 'v1.3';
+      getReleaseUrl = `/api/v4/projects/${stateClone.projectId}/releases/${stateClone.tagName}`;
+    });
+
+    it(`dispatches requestUpdateRelease and receiveUpdateReleaseSuccess`, () => {
+      mock.onPut(getReleaseUrl).replyOnce(200);
+
+      return testAction(
+        actions.updateRelease,
+        undefined,
+        stateClone,
+        [],
+        [{ type: 'requestUpdateRelease' }, { type: 'receiveUpdateReleaseSuccess' }],
+      );
+    });
+
+    it(`dispatches requestUpdateRelease and receiveUpdateReleaseError with an error object`, () => {
+      mock.onPut(getReleaseUrl).replyOnce(500);
+
+      return testAction(
+        actions.updateRelease,
+        undefined,
+        stateClone,
+        [],
+        [
+          { type: 'requestUpdateRelease' },
+          { type: 'receiveUpdateReleaseError', payload: expect.anything() },
+        ],
+      );
+    });
+  });
+
+  describe('navigateToReleasesPage', () => {
+    it(`calls redirectTo() with the URL to the releases page`, () => {
+      const releasesPagePath = 'path/to/releases/page';
+      stateClone.releasesPagePath = releasesPagePath;
+
+      actions.navigateToReleasesPage({ state: stateClone });
+
+      expect(redirectTo).toHaveBeenCalledTimes(1);
+      expect(redirectTo).toHaveBeenCalledWith(releasesPagePath);
+    });
+  });
+});
diff --git a/spec/frontend/releases/detail/store/mutations_spec.js b/spec/frontend/releases/detail/store/mutations_spec.js
new file mode 100644
index 00000000000..106a40c812e
--- /dev/null
+++ b/spec/frontend/releases/detail/store/mutations_spec.js
@@ -0,0 +1,119 @@
+/* eslint-disable jest/valid-describe */
+/*
+ * ESLint disable directive ↑ can be removed once
+ * https://github.com/jest-community/eslint-plugin-jest/issues/203
+ * is resolved
+ */
+
+import state from '~/releases/detail/store/state';
+import mutations from '~/releases/detail/store/mutations';
+import * as types from '~/releases/detail/store/mutation_types';
+import { release } from '../../mock_data';
+
+describe('Release detail mutations', () => {
+  let stateClone;
+  let releaseClone;
+
+  beforeEach(() => {
+    stateClone = state();
+    releaseClone = JSON.parse(JSON.stringify(release));
+  });
+
+  describe(types.SET_INITIAL_STATE, () => {
+    it('populates the state with initial values', () => {
+      const initialState = {
+        projectId: '18',
+        tagName: 'v1.3',
+        releasesPagePath: 'path/to/releases/page',
+        markdownDocsPath: 'path/to/markdown/docs',
+        markdownPreviewPath: 'path/to/markdown/preview',
+      };
+
+      mutations[types.SET_INITIAL_STATE](stateClone, initialState);
+
+      expect(stateClone).toEqual(expect.objectContaining(initialState));
+    });
+  });
+
+  describe(types.REQUEST_RELEASE, () => {
+    it('set state.isFetchingRelease to true', () => {
+      mutations[types.REQUEST_RELEASE](stateClone);
+
+      expect(stateClone.isFetchingRelease).toEqual(true);
+    });
+  });
+
+  describe(types.RECEIVE_RELEASE_SUCCESS, () => {
+    it('handles a successful response from the server', () => {
+      mutations[types.RECEIVE_RELEASE_SUCCESS](stateClone, releaseClone);
+
+      expect(stateClone.fetchError).toEqual(undefined);
+
+      expect(stateClone.isFetchingRelease).toEqual(false);
+
+      expect(stateClone.release).toEqual(releaseClone);
+    });
+  });
+
+  describe(types.RECEIVE_RELEASE_ERROR, () => {
+    it('handles an unsuccessful response from the server', () => {
+      const error = { message: 'An error occurred!' };
+      mutations[types.RECEIVE_RELEASE_ERROR](stateClone, error);
+
+      expect(stateClone.isFetchingRelease).toEqual(false);
+
+      expect(stateClone.release).toBeUndefined();
+
+      expect(stateClone.fetchError).toEqual(error);
+    });
+  });
+
+  describe(types.UPDATE_RELEASE_TITLE, () => {
+    it("updates the release's title", () => {
+      stateClone.release = releaseClone;
+      const newTitle = 'The new release title';
+      mutations[types.UPDATE_RELEASE_TITLE](stateClone, newTitle);
+
+      expect(stateClone.release.name).toEqual(newTitle);
+    });
+  });
+
+  describe(types.UPDATE_RELEASE_NOTES, () => {
+    it("updates the release's notes", () => {
+      stateClone.release = releaseClone;
+      const newNotes = 'The new release notes';
+      mutations[types.UPDATE_RELEASE_NOTES](stateClone, newNotes);
+
+      expect(stateClone.release.description).toEqual(newNotes);
+    });
+  });
+
+  describe(types.REQUEST_UPDATE_RELEASE, () => {
+    it('set state.isUpdatingRelease to true', () => {
+      mutations[types.REQUEST_UPDATE_RELEASE](stateClone);
+
+      expect(stateClone.isUpdatingRelease).toEqual(true);
+    });
+  });
+
+  describe(types.RECEIVE_UPDATE_RELEASE_SUCCESS, () => {
+    it('handles a successful response from the server', () => {
+      mutations[types.RECEIVE_UPDATE_RELEASE_SUCCESS](stateClone, releaseClone);
+
+      expect(stateClone.updateError).toEqual(undefined);
+
+      expect(stateClone.isUpdatingRelease).toEqual(false);
+    });
+  });
+
+  describe(types.RECEIVE_UPDATE_RELEASE_ERROR, () => {
+    it('handles an unsuccessful response from the server', () => {
+      const error = { message: 'An error occurred!' };
+      mutations[types.RECEIVE_UPDATE_RELEASE_ERROR](stateClone, error);
+
+      expect(stateClone.isUpdatingRelease).toEqual(false);
+
+      expect(stateClone.updateError).toEqual(error);
+    });
+  });
+});
diff --git a/spec/helpers/environment_helper_spec.rb b/spec/helpers/environment_helper_spec.rb
new file mode 100644
index 00000000000..53953d72b06
--- /dev/null
+++ b/spec/helpers/environment_helper_spec.rb
@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe EnvironmentHelper do
+  describe '#render_deployment_status' do
+    context 'when using a manual deployment' do
+      it 'renders a span tag' do
+        deploy = build(:deployment, deployable: nil, status: :success)
+        html = helper.render_deployment_status(deploy)
+
+        expect(html).to have_css('span.ci-status.ci-success')
+      end
+    end
+
+    context 'when using a deployment from a build' do
+      it 'renders a link tag' do
+        deploy = build(:deployment, status: :success)
+        html = helper.render_deployment_status(deploy)
+
+        expect(html).to have_css('a.ci-status.ci-success')
+      end
+    end
+  end
+end
diff --git a/spec/javascripts/test_bundle.js b/spec/javascripts/test_bundle.js
index 191df3cc709..cb6b158f01c 100644
--- a/spec/javascripts/test_bundle.js
+++ b/spec/javascripts/test_bundle.js
@@ -70,7 +70,7 @@ window.gl = window.gl || {};
 window.gl.TEST_HOST = TEST_HOST;
 window.gon = window.gon || {};
 window.gon.test_env = true;
-window.gon.ee = process.env.IS_GITLAB_EE;
+window.gon.ee = process.env.IS_EE;
 gon.relative_url_root = '';
 
 let hasUnhandledPromiseRejections = false;
@@ -118,7 +118,7 @@ const axiosDefaultAdapter = getDefaultAdapter();
 // render all of our tests
 const testContexts = [require.context('spec', true, /_spec$/)];
 
-if (process.env.IS_GITLAB_EE) {
+if (process.env.IS_EE) {
   testContexts.push(require.context('ee_spec', true, /_spec$/));
 }
 
@@ -207,7 +207,7 @@ if (process.env.BABEL_ENV === 'coverage') {
   describe('Uncovered files', function() {
     const sourceFilesContexts = [require.context('~', true, /\.(js|vue)$/)];
 
-    if (process.env.IS_GITLAB_EE) {
+    if (process.env.IS_EE) {
       sourceFilesContexts.push(require.context('ee', true, /\.(js|vue)$/));
     }
 
diff --git a/spec/lib/gitlab/ci/ansi2json/line_spec.rb b/spec/lib/gitlab/ci/ansi2json/line_spec.rb
new file mode 100644
index 00000000000..4b5c3f9489e
--- /dev/null
+++ b/spec/lib/gitlab/ci/ansi2json/line_spec.rb
@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Gitlab::Ci::Ansi2json::Line do
+  let(:offset) { 0 }
+  let(:style) { Gitlab::Ci::Ansi2json::Style.new }
+
+  subject { described_class.new(offset: offset, style: style) }
+
+  describe '#<<' do
+    it 'appends new data to the current segment' do
+      expect { subject << 'test 1' }.to change { subject.current_segment.text }
+      expect(subject.current_segment.text).to eq('test 1')
+
+      expect { subject << ', test 2' }.to change { subject.current_segment.text }
+      expect(subject.current_segment.text).to eq('test 1, test 2')
+    end
+  end
+
+  describe '#style' do
+    context 'when style is passed to the initializer' do
+      let(:style) { double }
+
+      it 'returns the same style' do
+        expect(subject.style).to eq(style)
+      end
+    end
+
+    context 'when style is not passed to the initializer' do
+      it 'returns the default style' do
+        expect(subject.style.set?).to be_falsey
+      end
+    end
+  end
+
+  describe '#update_style' do
+    let(:expected_style) do
+      Gitlab::Ci::Ansi2json::Style.new(
+        fg: 'term-fg-l-yellow',
+        bg: 'term-bg-blue',
+        mask: 1)
+    end
+
+    it 'sets the style' do
+      subject.update_style(%w[1 33 44])
+
+      expect(subject.style).to eq(expected_style)
+    end
+  end
+
+  describe '#add_section' do
+    it 'appends a new section to the list' do
+      subject.add_section('section_1')
+      subject.add_section('section_2')
+
+      expect(subject.sections).to eq(%w[section_1 section_2])
+    end
+  end
+
+  describe '#set_as_section_header' do
+    it 'change the section_header to true' do
+      expect { subject.set_as_section_header }
+        .to change { subject.section_header }
+        .to be_truthy
+    end
+  end
+
+  describe '#set_section_duration' do
+    it 'sets and formats the section_duration' do
+      subject.set_section_duration(75)
+
+      expect(subject.section_duration).to eq('01:15')
+    end
+  end
+
+  describe '#flush_current_segment!' do
+    context 'when current segment is not empty' do
+      before do
+        subject << 'some data'
+      end
+
+      it 'adds the segment to the list' do
+        expect { subject.flush_current_segment! }.to change { subject.segments.count }.by(1)
+
+        expect(subject.segments.map { |s| s[:text] }).to eq(['some data'])
+      end
+
+      it 'updates the current segment pointer propagating the style' do
+        previous_segment = subject.current_segment
+
+        subject.flush_current_segment!
+
+        expect(subject.current_segment).not_to eq(previous_segment)
+        expect(subject.current_segment.style).to eq(previous_segment.style)
+      end
+    end
+
+    context 'when current segment is empty' do
+      it 'does not add any segments to the list' do
+        expect { subject.flush_current_segment! }.not_to change { subject.segments.count }
+      end
+
+      it 'does not change the current segment' do
+        expect { subject.flush_current_segment! }.not_to change { subject.current_segment }
+      end
+    end
+  end
+
+  describe '#to_h' do
+    before do
+      subject << 'some data'
+      subject.update_style(['1'])
+    end
+
+    context 'when sections are present' do
+      before do
+        subject.add_section('section_1')
+        subject.add_section('section_2')
+      end
+
+      context 'when section header is set' do
+        before do
+          subject.set_as_section_header
+        end
+
+        it 'serializes the attributes set' do
+          result = {
+            offset: 0,
+            content: [{ text: 'some data', style: 'term-bold' }],
+            section: 'section_2',
+            section_header: true
+          }
+
+          expect(subject.to_h).to eq(result)
+        end
+      end
+
+      context 'when section duration is set' do
+        before do
+          subject.set_section_duration(75)
+        end
+
+        it 'serializes the attributes set' do
+          result = {
+            offset: 0,
+            content: [{ text: 'some data', style: 'term-bold' }],
+            section: 'section_2',
+            section_duration: '01:15'
+          }
+
+          expect(subject.to_h).to eq(result)
+        end
+      end
+    end
+
+    context 'when there are no sections' do
+      it 'serializes the attributes set' do
+        result = {
+          offset: 0,
+          content: [{ text: 'some data', style: 'term-bold' }]
+        }
+
+        expect(subject.to_h).to eq(result)
+      end
+    end
+  end
+end
diff --git a/spec/lib/gitlab/ci/ansi2json/parser_spec.rb b/spec/lib/gitlab/ci/ansi2json/parser_spec.rb
new file mode 100644
index 00000000000..e161e74c1ff
--- /dev/null
+++ b/spec/lib/gitlab/ci/ansi2json/parser_spec.rb
@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+# The rest of the specs for this class are covered in style_spec.rb
+describe Gitlab::Ci::Ansi2json::Parser do
+  subject { described_class }
+
+  describe 'bold?' do
+    it 'returns true if style mask matches bold format' do
+      expect(subject.bold?(0x01)).to be_truthy
+    end
+
+    it 'returns false if style mask does not match bold format' do
+      expect(subject.bold?(0x02)).to be_falsey
+    end
+  end
+
+  describe 'matching_formats' do
+    it 'returns matching formats given a style mask' do
+      expect(subject.matching_formats(0x01)).to eq(%w[term-bold])
+      expect(subject.matching_formats(0x03)).to eq(%w[term-bold term-italic])
+      expect(subject.matching_formats(0x07)).to eq(%w[term-bold term-italic term-underline])
+    end
+
+    it 'returns an empty array if no formats match the style mask' do
+      expect(subject.matching_formats(0)).to eq([])
+    end
+  end
+end
diff --git a/spec/lib/gitlab/ci/ansi2json/style_spec.rb b/spec/lib/gitlab/ci/ansi2json/style_spec.rb
new file mode 100644
index 00000000000..88a0ca35859
--- /dev/null
+++ b/spec/lib/gitlab/ci/ansi2json/style_spec.rb
@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Gitlab::Ci::Ansi2json::Style do
+  describe '#set?' do
+    subject { described_class.new(params).set? }
+
+    context 'when fg color is set' do
+      let(:params) { { fg: 'term-fg-black' } }
+
+      it { is_expected.to be_truthy }
+    end
+
+    context 'when bg color is set' do
+      let(:params) { { bg: 'term-bg-black' } }
+
+      it { is_expected.to be_truthy }
+    end
+
+    context 'when mask is set' do
+      let(:params) { { mask: 0x01 } }
+
+      it { is_expected.to be_truthy }
+    end
+
+    context 'nothing is set' do
+      let(:params) { {} }
+
+      it { is_expected.to be_falsey }
+    end
+  end
+
+  describe '#reset!' do
+    let(:style) { described_class.new(fg: 'term-fg-black', bg: 'term-bg-yellow', mask: 0x01) }
+
+    it 'set the style params to default' do
+      style.reset!
+
+      expect(style.fg).to be_nil
+      expect(style.bg).to be_nil
+      expect(style.mask).to be_zero
+    end
+  end
+
+  describe 'update formats to mimic terminals' do
+    subject { described_class.new(params) }
+
+    context 'when fg color present' do
+      let(:params) { { fg: 'term-fg-black', mask: mask } }
+
+      context 'when mask is set to bold' do
+        let(:mask) { 0x01 }
+
+        it 'changes the fg color to a lighter version' do
+          expect(subject.fg).to eq('term-fg-l-black')
+        end
+      end
+
+      context 'when mask set to another format' do
+        let(:mask) { 0x02 }
+
+        it 'does not change the fg color' do
+          expect(subject.fg).to eq('term-fg-black')
+        end
+      end
+
+      context 'when mask is not set' do
+        let(:mask) { 0 }
+
+        it 'does not change the fg color' do
+          expect(subject.fg).to eq('term-fg-black')
+        end
+      end
+    end
+  end
+
+  describe '#update' do
+    where(:initial_state, :ansi_commands, :result, :description) do
+      [
+        # add format
+        [[], %w[0], '', 'does not set any style'],
+        [[], %w[1], 'term-bold', 'enables format bold'],
+        [[], %w[3], 'term-italic', 'enables format italic'],
+        [[], %w[4], 'term-underline', 'enables format underline'],
+        [[], %w[8], 'term-conceal', 'enables format conceal'],
+        [[], %w[9], 'term-cross', 'enables format cross'],
+        # remove format
+        [%w[1], %w[21], '', 'disables format bold'],
+        [%w[1 3], %w[21], 'term-italic', 'disables format bold and leaves italic'],
+        [%w[1], %w[22], '', 'disables format bold using command 22'],
+        [%w[1 3], %w[22], 'term-italic', 'disables format bold and leaves italic using command 22'],
+        [%w[3], %w[23], '', 'disables format italic'],
+        [%w[1 3], %w[23], 'term-bold', 'disables format italic and leaves bold'],
+        [%w[4], %w[24], '', 'disables format underline'],
+        [%w[1 4], %w[24], 'term-bold', 'disables format underline and leaves bold'],
+        [%w[8], %w[28], '', 'disables format conceal'],
+        [%w[1 8], %w[28], 'term-bold', 'disables format conceal and leaves bold'],
+        [%w[9], %w[29], '', 'disables format cross'],
+        [%w[1 9], %w[29], 'term-bold', 'disables format cross and leaves bold'],
+        # set fg color
+        [[], %w[30], 'term-fg-black', 'sets fg color black'],
+        [[], %w[31], 'term-fg-red', 'sets fg color red'],
+        [[], %w[32], 'term-fg-green', 'sets fg color green'],
+        [[], %w[33], 'term-fg-yellow', 'sets fg color yellow'],
+        [[], %w[34], 'term-fg-blue', 'sets fg color blue'],
+        [[], %w[35], 'term-fg-magenta', 'sets fg color magenta'],
+        [[], %w[36], 'term-fg-cyan', 'sets fg color cyan'],
+        [[], %w[37], 'term-fg-white', 'sets fg color white'],
+        # sets xterm fg color
+        [[], %w[38 5 1], 'xterm-fg-1', 'sets xterm fg color 1'],
+        [[], %w[38 5 2], 'xterm-fg-2', 'sets xterm fg color 2'],
+        [[], %w[38 1], 'term-bold', 'ignores 38 command if not followed by 5 and sets format bold'],
+        # set bg color
+        [[], %w[40], 'term-bg-black', 'sets bg color black'],
+        [[], %w[41], 'term-bg-red', 'sets bg color red'],
+        [[], %w[42], 'term-bg-green', 'sets bg color green'],
+        [[], %w[43], 'term-bg-yellow', 'sets bg color yellow'],
+        [[], %w[44], 'term-bg-blue', 'sets bg color blue'],
+        [[], %w[45], 'term-bg-magenta', 'sets bg color magenta'],
+        [[], %w[46], 'term-bg-cyan', 'sets bg color cyan'],
+        [[], %w[47], 'term-bg-white', 'sets bg color white'],
+        # set xterm bg color
+        [[], %w[48 5 1], 'xterm-bg-1', 'sets xterm bg color 1'],
+        [[], %w[48 5 2], 'xterm-bg-2', 'sets xterm bg color 2'],
+        [[], %w[48 1], 'term-bold', 'ignores 48 command if not followed by 5 and sets format bold'],
+        # set light fg color
+        [[], %w[90], 'term-fg-l-black', 'sets fg color light black'],
+        [[], %w[91], 'term-fg-l-red', 'sets fg color light red'],
+        [[], %w[92], 'term-fg-l-green', 'sets fg color light green'],
+        [[], %w[93], 'term-fg-l-yellow', 'sets fg color light yellow'],
+        [[], %w[94], 'term-fg-l-blue', 'sets fg color light blue'],
+        [[], %w[95], 'term-fg-l-magenta', 'sets fg color light magenta'],
+        [[], %w[96], 'term-fg-l-cyan', 'sets fg color light cyan'],
+        [[], %w[97], 'term-fg-l-white', 'sets fg color light white'],
+        # set light bg color
+        [[], %w[100], 'term-bg-l-black', 'sets bg color light black'],
+        [[], %w[101], 'term-bg-l-red', 'sets bg color light red'],
+        [[], %w[102], 'term-bg-l-green', 'sets bg color light green'],
+        [[], %w[103], 'term-bg-l-yellow', 'sets bg color light yellow'],
+        [[], %w[104], 'term-bg-l-blue', 'sets bg color light blue'],
+        [[], %w[105], 'term-bg-l-magenta', 'sets bg color light magenta'],
+        [[], %w[106], 'term-bg-l-cyan', 'sets bg color light cyan'],
+        [[], %w[107], 'term-bg-l-white', 'sets bg color light white'],
+        # reset
+        [%w[1], %w[0], '', 'resets style from format bold'],
+        [%w[1 3], %w[0], '', 'resets style from format bold and italic'],
+        [%w[1 3 term-fg-l-red term-bg-yellow], %w[0], '', 'resets all formats and colors'],
+        # misc
+        [[], %w[1 30 42 3], 'term-fg-l-black term-bg-green term-bold term-italic', 'adds fg color, bg color and formats from no style'],
+        [%w[3 31], %w[23 1 43], 'term-fg-l-red term-bg-yellow term-bold', 'replaces format italic with bold and adds a yellow background']
+      ]
+    end
+
+    with_them do
+      it 'change the style' do
+        style = described_class.new
+        style.update(initial_state)
+
+        style.update(ansi_commands)
+
+        expect(style.to_s).to eq(result)
+      end
+    end
+  end
+end
diff --git a/spec/lib/gitlab/ci/ansi2json_spec.rb b/spec/lib/gitlab/ci/ansi2json_spec.rb
new file mode 100644
index 00000000000..3c6bc46436b
--- /dev/null
+++ b/spec/lib/gitlab/ci/ansi2json_spec.rb
@@ -0,0 +1,544 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Gitlab::Ci::Ansi2json do
+  subject { described_class }
+
+  describe 'lines' do
+    it 'prints non-ansi as-is' do
+      expect(convert_json('Hello')).to eq([
+        { offset: 0, content: [{ text: 'Hello' }] }
+      ])
+    end
+
+    it 'adds new line in a separate element' do
+      expect(convert_json("Hello\nworld")).to eq([
+        { offset: 0, content: [{ text: 'Hello' }] },
+        { offset: 6, content: [{ text: 'world' }] }
+      ])
+    end
+
+    it 'recognizes color changing ANSI sequences' do
+      expect(convert_json("\e[31mHello\e[0m")).to eq([
+        { offset: 0, content: [{ text: 'Hello', style: 'term-fg-red' }] }
+      ])
+    end
+
+    it 'recognizes color changing ANSI sequences across multiple lines' do
+      expect(convert_json("\e[31mHello\nWorld\e[0m")).to eq([
+        { offset: 0, content: [{ text: 'Hello', style: 'term-fg-red' }] },
+        { offset: 11, content: [{ text: 'World', style: 'term-fg-red' }] }
+      ])
+    end
+
+    it 'recognizes background and foreground colors' do
+      expect(convert_json("\e[31;44mHello")).to eq([
+        { offset: 0, content: [{ text: 'Hello', style: 'term-fg-red term-bg-blue' }] }
+      ])
+    end
+
+    it 'recognizes style changes within the same line' do
+      expect(convert_json("\e[31;44mHello\e[0m world")).to eq([
+        { offset: 0, content: [
+          { text: 'Hello', style: 'term-fg-red term-bg-blue' },
+          { text: ' world' }
+        ] }
+      ])
+    end
+
+    context 'with section markers' do
+      let(:section_name) { 'prepare-script' }
+      let(:section_duration) { 63.seconds }
+      let(:section_start_time) { Time.new(2019, 9, 17).utc }
+      let(:section_end_time) { section_start_time + section_duration }
+      let(:section_start) { "section_start:#{section_start_time.to_i}:#{section_name}\r\033[0K"}
+      let(:section_end) { "section_end:#{section_end_time.to_i}:#{section_name}\r\033[0K"}
+
+      it 'marks the first line of the section as header' do
+        expect(convert_json("Hello#{section_start}world!")).to eq([
+          {
+            offset: 0,
+            content: [{ text: 'Hello' }]
+          },
+          {
+            offset: 5,
+            content: [{ text: 'world!' }],
+            section: 'prepare-script',
+            section_header: true
+          }
+        ])
+      end
+
+      it 'does not marks the other lines of the section as header' do
+        expect(convert_json("outside section#{section_start}Hello\nworld!")).to eq([
+          {
+            offset: 0,
+            content: [{ text: 'outside section' }]
+          },
+          {
+            offset: 15,
+            content: [{ text: 'Hello' }],
+            section: 'prepare-script',
+            section_header: true
+          },
+          {
+            offset: 65,
+            content: [{ text: 'world!' }],
+            section: 'prepare-script'
+          }
+        ])
+      end
+
+      it 'marks the last line of the section as footer' do
+        expect(convert_json("#{section_start}Good\nmorning\nworld!#{section_end}")).to eq([
+          {
+            offset: 0,
+            content: [{ text: 'Good' }],
+            section: 'prepare-script',
+            section_header: true
+          },
+          {
+            offset: 49,
+            content: [{ text: 'morning' }],
+            section: 'prepare-script'
+          },
+          {
+            offset: 57,
+            content: [{ text: 'world!' }],
+            section: 'prepare-script'
+          },
+          {
+            offset: 63,
+            content: [],
+            section_duration: '01:03',
+            section: 'prepare-script'
+          },
+          {
+            offset: 63,
+            content: []
+          }
+        ])
+      end
+
+      it 'marks the first line as header and footer if is the only line in the section' do
+        expect(convert_json("#{section_start}Hello world!#{section_end}")).to eq([
+          {
+            offset: 0,
+            content: [{ text: 'Hello world!' }],
+            section: 'prepare-script',
+            section_header: true
+          },
+          {
+            offset: 56,
+            content: [],
+            section: 'prepare-script',
+            section_duration: '01:03'
+          },
+          {
+            offset: 56,
+            content: []
+          }
+        ])
+      end
+
+      it 'does not add sections attribute to lines after the section is closed' do
+        expect(convert_json("#{section_start}Hello#{section_end}world")).to eq([
+          {
+            offset: 0,
+            content: [{ text: 'Hello' }],
+            section: 'prepare-script',
+            section_header: true
+          },
+          {
+            offset: 49,
+            content: [],
+            section: 'prepare-script',
+            section_duration: '01:03'
+          },
+          {
+            offset: 49,
+            content: [{ text: 'world' }]
+          }
+        ])
+      end
+
+      it 'ignores section_end marker if no section_start exists' do
+        expect(convert_json("Hello #{section_end}world")).to eq([
+          {
+            offset: 0,
+            content: [{ text: 'Hello world' }]
+          }
+        ])
+      end
+
+      context 'when section name contains .-_ and capital letters' do
+        let(:section_name) { 'a.Legit-SeCtIoN_namE' }
+
+        it 'sanitizes the section name' do
+          expect(convert_json("Hello#{section_start}world!")).to eq([
+            {
+              offset: 0,
+              content: [{ text: 'Hello' }]
+            },
+            {
+              offset: 5,
+              content: [{ text: 'world!' }],
+              section: 'a-legit-section-name',
+              section_header: true
+            }
+          ])
+        end
+      end
+
+      context 'when section name includes $' do
+        let(:section_name) { 'my_$ection' }
+
+        it 'ignores the section' do
+          expect(convert_json("#{section_start}hello")).to eq([
+            {
+              offset: 0,
+              content: [{ text: "#{section_start.gsub("\033[0K", '')}hello" }]
+            }
+          ])
+        end
+      end
+
+      context 'when section name includes <' do
+        let(:section_name) { '<a_tag>' }
+
+        it 'ignores the section' do
+          expect(convert_json("#{section_start}hello")).to eq([
+            {
+              offset: 0,
+              content: [{ text: "#{section_start.gsub("\033[0K", '').gsub('<', '&lt;')}hello" }]
+            }
+          ])
+        end
+      end
+
+      it 'prevents XSS injection' do
+        trace = "#{section_start}section_end:1:2<script>alert('XSS Hack!');</script>#{section_end}"
+        expect(convert_json(trace)).to eq([
+          {
+            offset: 0,
+            content: [{ text: "section_end:1:2&lt;script>alert('XSS Hack!');&lt;/script>" }],
+            section: 'prepare-script',
+            section_header: true
+          },
+          {
+            offset: 95,
+            content: [],
+            section: 'prepare-script',
+            section_duration: '01:03'
+          },
+          {
+            offset: 95,
+            content: []
+          }
+        ])
+      end
+
+      context 'with nested section' do
+        let(:nested_section_name) { 'prepare-script-nested' }
+        let(:nested_section_duration) { 2.seconds }
+        let(:nested_section_start_time) { Time.new(2019, 9, 17).utc }
+        let(:nested_section_end_time) { nested_section_start_time + nested_section_duration }
+        let(:nested_section_start) { "section_start:#{nested_section_start_time.to_i}:#{nested_section_name}\r\033[0K"}
+        let(:nested_section_end) { "section_end:#{nested_section_end_time.to_i}:#{nested_section_name}\r\033[0K"}
+
+        it 'adds multiple sections to the lines inside the nested section' do
+          trace = "Hello#{section_start}foo#{nested_section_start}bar#{nested_section_end}baz#{section_end}world"
+
+          expect(convert_json(trace)).to eq([
+              {
+                offset: 0,
+                content: [{ text: 'Hello' }]
+              },
+              {
+                offset: 5,
+                content: [{ text: 'foo' }],
+                section: 'prepare-script',
+                section_header: true
+              },
+              {
+                offset: 52,
+                content: [{ text: 'bar' }],
+                section: 'prepare-script-nested',
+                section_header: true
+              },
+              {
+                offset: 106,
+                content: [],
+                section: 'prepare-script-nested',
+                section_duration: '00:02'
+              },
+              {
+                offset: 106,
+                content: [{ text: 'baz' }],
+                section: 'prepare-script'
+              },
+              {
+                offset: 158,
+                content: [],
+                section: 'prepare-script',
+                section_duration: '01:03'
+              },
+              {
+                offset: 158,
+                content: [{ text: 'world' }]
+              }
+            ])
+        end
+
+        it 'adds multiple sections to the lines inside the nested section and closes all sections together' do
+          trace = "Hello#{section_start}\e[91mfoo\e[0m#{nested_section_start}bar#{nested_section_end}#{section_end}"
+
+          expect(convert_json(trace)).to eq([
+              {
+                offset: 0,
+                content: [{ text: 'Hello' }]
+              },
+              {
+                offset: 5,
+                content: [{ text: 'foo', style: 'term-fg-l-red' }],
+                section: 'prepare-script',
+                section_header: true
+              },
+              {
+                offset: 61,
+                content: [{ text: 'bar' }],
+                section: 'prepare-script-nested',
+                section_header: true
+              },
+              {
+                offset: 115,
+                content: [],
+                section: 'prepare-script-nested',
+                section_duration: '00:02'
+              },
+              {
+                offset: 115,
+                content: [],
+                section: 'prepare-script',
+                section_duration: '01:03'
+              },
+              {
+                offset: 164,
+                content: []
+              }
+            ])
+        end
+      end
+    end
+
+    describe 'incremental updates' do
+      let(:pass1_stream) { StringIO.new(pre_text) }
+      let(:pass2_stream) { StringIO.new(pre_text + text) }
+      let(:pass1) { subject.convert(pass1_stream) }
+      let(:pass2) { subject.convert(pass2_stream, pass1.state) }
+
+      context 'with split word' do
+        let(:pre_text) { "\e[1mHello " }
+        let(:text) { "World" }
+
+        let(:lines) do
+          [
+            { offset: 0, content: [{ text: 'Hello World', style: 'term-bold' }] }
+          ]
+        end
+
+        it 'returns the full line' do
+          expect(pass2.lines).to eq(lines)
+          expect(pass2.append).to be_falsey
+        end
+      end
+
+      context 'with split word on second line' do
+        let(:pre_text) { "Good\nmorning " }
+        let(:text) { "World" }
+
+        let(:lines) do
+          [
+            { offset: 5, content: [{ text: 'morning World' }] }
+          ]
+        end
+
+        it 'returns all lines since last partially processed line' do
+          expect(pass2.lines).to eq(lines)
+          expect(pass2.append).to be_truthy
+        end
+      end
+
+      context 'with split sequence across multiple lines' do
+        let(:pre_text) { "\e[1mgood\nmorning\n" }
+        let(:text) { "\e[3mworld" }
+
+        let(:lines) do
+          [
+            { offset: 17, content: [{ text: 'world', style: 'term-bold term-italic' }] }
+          ]
+        end
+
+        it 'returns the full line' do
+          expect(pass2.lines).to eq(lines)
+          expect(pass2.append).to be_truthy
+        end
+      end
+
+      context 'with split partial sequence' do
+        let(:pre_text) { "hello\e" }
+        let(:text) { "[1m world" }
+
+        let(:lines) do
+          [
+            { offset: 0, content: [
+              { text: 'hello' },
+              { text: ' world', style: 'term-bold' }
+            ] }
+          ]
+        end
+
+        it 'returns the full line' do
+          expect(pass2.lines).to eq(lines)
+          expect(pass2.append).to be_falsey
+        end
+      end
+
+      context 'with split new line' do
+        let(:pre_text) { "hello\r" }
+        let(:text) { "\nworld" }
+
+        let(:lines) do
+          [
+            { offset: 0, content: [{ text: 'hello' }] },
+            { offset: 7, content: [{ text: 'world' }] }
+          ]
+        end
+
+        it 'returns the full line' do
+          expect(pass2.lines).to eq(lines)
+          expect(pass2.append).to be_falsey
+        end
+      end
+
+      context 'with split section' do
+        let(:section_name) { 'prepare-script' }
+        let(:section_duration) { 63.seconds }
+        let(:section_start_time) { Time.new(2019, 9, 17).utc }
+        let(:section_end_time) { section_start_time + section_duration }
+        let(:section_start) { "section_start:#{section_start_time.to_i}:#{section_name}\r\033[0K"}
+        let(:section_end) { "section_end:#{section_end_time.to_i}:#{section_name}\r\033[0K"}
+
+        context 'with split section body' do
+          let(:pre_text) { "#{section_start}this is a header\nand " }
+          let(:text) { "this\n is a body" }
+
+          let(:lines) do
+            [
+              {
+                offset: 61,
+                content: [{ text: 'and this' }],
+                section: 'prepare-script'
+              },
+              {
+                offset: 70,
+                content: [{ text: ' is a body' }],
+                section: 'prepare-script'
+              }
+            ]
+          end
+
+          it 'returns the full line' do
+            expect(pass2.lines).to eq(lines)
+            expect(pass2.append).to be_truthy
+          end
+        end
+
+        context 'with split section where header is also split' do
+          let(:pre_text) { "#{section_start}this is " }
+          let(:text) { "a header\nand body" }
+
+          let(:lines) do
+            [
+              {
+                offset: 0,
+                content: [{ text: 'this is a header' }],
+                section: 'prepare-script',
+                section_header: true
+              },
+              {
+                offset: 61,
+                content: [{ text: 'and body' }],
+                section: 'prepare-script'
+              }
+            ]
+          end
+
+          it 'returns the full line' do
+            expect(pass2.lines).to eq(lines)
+            expect(pass2.append).to be_falsey
+          end
+        end
+
+        context 'with split section end' do
+          let(:pre_text) { "#{section_start}this is a header\nthe" }
+          let(:text) { " body\nthe end#{section_end}" }
+
+          let(:lines) do
+            [
+              {
+                offset: 61,
+                content: [{ text: 'the body' }],
+                section: 'prepare-script'
+              },
+              {
+                offset: 70,
+                content: [{ text: 'the end' }],
+                section: 'prepare-script'
+              },
+              {
+                offset: 77,
+                content: [],
+                section: 'prepare-script',
+                section_duration: '01:03'
+              },
+              {
+                offset: 77,
+                content: []
+              }
+            ]
+          end
+
+          it 'returns the full line' do
+            expect(pass2.lines).to eq(lines)
+            expect(pass2.append).to be_truthy
+          end
+        end
+      end
+    end
+
+    describe 'trucates' do
+      let(:text) { "Hello World" }
+      let(:stream) { StringIO.new(text) }
+      let(:subject) { described_class.convert(stream) }
+
+      before do
+        stream.seek(3, IO::SEEK_SET)
+      end
+
+      it "returns truncated output" do
+        expect(subject.truncated).to be_truthy
+      end
+
+      it "does not append output" do
+        expect(subject.append).to be_falsey
+      end
+    end
+
+    def convert_json(data)
+      stream = StringIO.new(data)
+      subject.convert(stream).lines
+    end
+  end
+end
diff --git a/spec/lib/gitlab/diff/position_collection_spec.rb b/spec/lib/gitlab/diff/position_collection_spec.rb
index de0e631ab03..f2a8312587c 100644
--- a/spec/lib/gitlab/diff/position_collection_spec.rb
+++ b/spec/lib/gitlab/diff/position_collection_spec.rb
@@ -35,14 +35,15 @@ describe Gitlab::Diff::PositionCollection do
   let(:text_position) { build_text_position }
   let(:folded_text_position) { build_text_position(old_line: 1, new_line: 1) }
   let(:image_position) { build_image_position }
+  let(:invalid_position) { 'a position' }
   let(:head_sha) { merge_request.diff_head_sha }
 
   let(:collection) do
-    described_class.new([text_position, folded_text_position, image_position], head_sha)
+    described_class.new([text_position, folded_text_position, image_position, invalid_position], head_sha)
   end
 
   describe '#to_a' do
-    it 'returns all positions' do
+    it 'returns all positions that are Gitlab::Diff::Position' do
       expect(collection.to_a).to eq([text_position, folded_text_position, image_position])
     end
   end
@@ -59,6 +60,14 @@ describe Gitlab::Diff::PositionCollection do
         expect(collection.unfoldable).to be_empty
       end
     end
+
+    context 'when given head_sha is nil' do
+      let(:head_sha) { nil }
+
+      it 'returns unfoldable diff positions unfiltered by head_sha' do
+        expect(collection.unfoldable).to eq([folded_text_position])
+      end
+    end
   end
 
   describe '#concat' do
diff --git a/spec/lib/gitlab/health_checks/probes/collection_spec.rb b/spec/lib/gitlab/health_checks/probes/collection_spec.rb
new file mode 100644
index 00000000000..33efc640257
--- /dev/null
+++ b/spec/lib/gitlab/health_checks/probes/collection_spec.rb
@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Gitlab::HealthChecks::Probes::Collection do
+  let(:readiness) { described_class.new(*checks) }
+
+  describe '#call' do
+    subject { readiness.execute }
+
+    context 'with all checks' do
+      let(:checks) do
+        [
+          Gitlab::HealthChecks::DbCheck,
+          Gitlab::HealthChecks::Redis::RedisCheck,
+          Gitlab::HealthChecks::Redis::CacheCheck,
+          Gitlab::HealthChecks::Redis::QueuesCheck,
+          Gitlab::HealthChecks::Redis::SharedStateCheck,
+          Gitlab::HealthChecks::GitalyCheck
+        ]
+      end
+
+      it 'responds with readiness checks data' do
+        expect(subject.http_status).to eq(200)
+
+        expect(subject.json[:status]).to eq('ok')
+        expect(subject.json['db_check']).to contain_exactly(status: 'ok')
+        expect(subject.json['cache_check']).to contain_exactly(status: 'ok')
+        expect(subject.json['queues_check']).to contain_exactly(status: 'ok')
+        expect(subject.json['shared_state_check']).to contain_exactly(status: 'ok')
+        expect(subject.json['gitaly_check']).to contain_exactly(
+          status: 'ok', labels: { shard: 'default' })
+      end
+
+      context 'when Redis fails' do
+        before do
+          allow(Gitlab::HealthChecks::Redis::RedisCheck).to receive(:readiness).and_return(
+            Gitlab::HealthChecks::Result.new('redis_check', false, "check error"))
+        end
+
+        it 'responds with failure' do
+          expect(subject.http_status).to eq(503)
+
+          expect(subject.json[:status]).to eq('failed')
+          expect(subject.json['cache_check']).to contain_exactly(status: 'ok')
+          expect(subject.json['redis_check']).to contain_exactly(
+            status: 'failed', message: 'check error')
+        end
+      end
+    end
+
+    context 'without checks' do
+      let(:checks) { [] }
+
+      it 'responds with success' do
+        expect(subject.http_status).to eq(200)
+
+        expect(subject.json).to eq(status: 'ok')
+      end
+    end
+  end
+end
diff --git a/spec/lib/gitlab/health_checks/probes/liveness_spec.rb b/spec/lib/gitlab/health_checks/probes/liveness_spec.rb
deleted file mode 100644
index 91066cb8ba0..00000000000
--- a/spec/lib/gitlab/health_checks/probes/liveness_spec.rb
+++ /dev/null
@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe Gitlab::HealthChecks::Probes::Liveness do
-  let(:liveness) { described_class.new }
-
-  describe '#call' do
-    subject { liveness.execute }
-
-    it 'responds with liveness checks data' do
-      expect(subject.http_status).to eq(200)
-
-      expect(subject.json[:status]).to eq('ok')
-    end
-  end
-end
diff --git a/spec/lib/gitlab/health_checks/probes/readiness_spec.rb b/spec/lib/gitlab/health_checks/probes/readiness_spec.rb
deleted file mode 100644
index d88ffd984c2..00000000000
--- a/spec/lib/gitlab/health_checks/probes/readiness_spec.rb
+++ /dev/null
@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe Gitlab::HealthChecks::Probes::Readiness do
-  let(:readiness) { described_class.new }
-
-  describe '#call' do
-    subject { readiness.execute }
-
-    it 'responds with readiness checks data' do
-      expect(subject.http_status).to eq(200)
-
-      expect(subject.json[:status]).to eq('ok')
-      expect(subject.json['db_check']).to contain_exactly(status: 'ok')
-      expect(subject.json['cache_check']).to contain_exactly(status: 'ok')
-      expect(subject.json['queues_check']).to contain_exactly(status: 'ok')
-      expect(subject.json['shared_state_check']).to contain_exactly(status: 'ok')
-      expect(subject.json['gitaly_check']).to contain_exactly(
-        status: 'ok', labels: { shard: 'default' })
-    end
-
-    context 'when Redis fails' do
-      before do
-        allow(Gitlab::HealthChecks::Redis::RedisCheck).to receive(:readiness).and_return(
-          Gitlab::HealthChecks::Result.new('redis_check', false, "check error"))
-      end
-
-      it 'responds with failure' do
-        expect(subject.http_status).to eq(503)
-
-        expect(subject.json[:status]).to eq('failed')
-        expect(subject.json['cache_check']).to contain_exactly(status: 'ok')
-        expect(subject.json['redis_check']).to contain_exactly(
-          status: 'failed', message: 'check error')
-      end
-    end
-  end
-end
diff --git a/spec/lib/gitlab_spec.rb b/spec/lib/gitlab_spec.rb
index c1d171815ba..6bf837f1d3f 100644
--- a/spec/lib/gitlab_spec.rb
+++ b/spec/lib/gitlab_spec.rb
@@ -146,7 +146,7 @@ describe Gitlab do
 
   describe '.ee?' do
     before do
-      stub_env('IS_GITLAB_EE', nil) # Make sure the ENV is clean
+      stub_env('FOSS_ONLY', nil) # Make sure the ENV is clean
       described_class.instance_variable_set(:@is_ee, nil)
     end
 
@@ -154,42 +154,66 @@ describe Gitlab do
       described_class.instance_variable_set(:@is_ee, nil)
     end
 
-    it 'returns true when using Enterprise Edition' do
-      root = Pathname.new('dummy')
-      license_path = double(:path, exist?: true)
+    context 'for EE' do
+      before do
+        root = Pathname.new('dummy')
+        license_path = double(:path, exist?: true)
 
-      allow(described_class)
-        .to receive(:root)
-              .and_return(root)
+        allow(described_class)
+          .to receive(:root)
+                .and_return(root)
 
-      allow(root)
-        .to receive(:join)
-              .with('ee/app/models/license.rb')
-              .and_return(license_path)
+        allow(root)
+          .to receive(:join)
+                .with('ee/app/models/license.rb')
+                .and_return(license_path)
+      end
 
-      expect(described_class.ee?).to eq(true)
-    end
+      context 'when using FOSS_ONLY=1' do
+        before do
+          stub_env('FOSS_ONLY', '1')
+        end
 
-    it 'returns false when using Community Edition' do
-      root = double(:path)
-      license_path = double(:path, exists?: false)
+        it 'returns not to be EE' do
+          expect(described_class).not_to be_ee
+        end
+      end
 
-      allow(described_class)
-        .to receive(:root)
-              .and_return(Pathname.new('dummy'))
+      context 'when using FOSS_ONLY=0' do
+        before do
+          stub_env('FOSS_ONLY', '0')
+        end
 
-      allow(root)
-        .to receive(:join)
-              .with('ee/app/models/license.rb')
-              .and_return(license_path)
+        it 'returns to be EE' do
+          expect(described_class).to be_ee
+        end
+      end
 
-      expect(described_class.ee?).to eq(false)
+      context 'when using default FOSS_ONLY' do
+        it 'returns to be EE' do
+          expect(described_class).to be_ee
+        end
+      end
     end
 
-    it 'returns true when the IS_GITLAB_EE variable is not empty' do
-      stub_env('IS_GITLAB_EE', '1')
+    context 'for CE' do
+      before do
+        root = double(:path)
+        license_path = double(:path, exists?: false)
 
-      expect(described_class.ee?).to eq(true)
+        allow(described_class)
+          .to receive(:root)
+                .and_return(Pathname.new('dummy'))
+
+        allow(root)
+          .to receive(:join)
+                .with('ee/app/models/license.rb')
+                .and_return(license_path)
+      end
+
+      it 'returns not to be EE' do
+        expect(described_class).not_to be_ee
+      end
     end
   end
 
diff --git a/spec/models/application_setting_spec.rb b/spec/models/application_setting_spec.rb
index 84c25b93fc6..702a6fab0e6 100644
--- a/spec/models/application_setting_spec.rb
+++ b/spec/models/application_setting_spec.rb
@@ -56,6 +56,10 @@ describe ApplicationSetting do
     it { is_expected.not_to allow_value(nil).for(:protected_paths) }
     it { is_expected.to allow_value([]).for(:protected_paths) }
 
+    it { is_expected.to allow_value(3).for(:push_event_hooks_limit) }
+    it { is_expected.not_to allow_value('three').for(:push_event_hooks_limit) }
+    it { is_expected.not_to allow_value(nil).for(:push_event_hooks_limit) }
+
     context "when user accepted let's encrypt terms of service" do
       before do
         setting.update(lets_encrypt_terms_of_service_accepted: true)
diff --git a/spec/models/deployment_spec.rb b/spec/models/deployment_spec.rb
index 51ed8e9421b..3a0b3c46ad0 100644
--- a/spec/models/deployment_spec.rb
+++ b/spec/models/deployment_spec.rb
@@ -348,4 +348,17 @@ describe Deployment do
       expect(deployment.deployed_by).to eq(build_user)
     end
   end
+
+  describe '.find_successful_deployment!' do
+    it 'returns a successful deployment' do
+      deploy = create(:deployment, :success)
+
+      expect(described_class.find_successful_deployment!(deploy.iid)).to eq(deploy)
+    end
+
+    it 'raises when no deployment is found' do
+      expect { described_class.find_successful_deployment!(-1) }
+        .to raise_error(ActiveRecord::RecordNotFound)
+    end
+  end
 end
diff --git a/spec/models/environment_spec.rb b/spec/models/environment_spec.rb
index 521c4704c87..786f3b832c4 100644
--- a/spec/models/environment_spec.rb
+++ b/spec/models/environment_spec.rb
@@ -882,4 +882,19 @@ describe Environment, :use_clean_rails_memory_store_caching do
       end
     end
   end
+
+  describe '.find_or_create_by_name' do
+    it 'finds an existing environment if it exists' do
+      env = create(:environment)
+
+      expect(described_class.find_or_create_by_name(env.name)).to eq(env)
+    end
+
+    it 'creates an environment if it does not exist' do
+      env = project.environments.find_or_create_by_name('kittens')
+
+      expect(env).to be_an_instance_of(described_class)
+      expect(env).to be_persisted
+    end
+  end
 end
diff --git a/spec/policies/project_policy_spec.rb b/spec/policies/project_policy_spec.rb
index 6093464c949..e61a064e82c 100644
--- a/spec/policies/project_policy_spec.rb
+++ b/spec/policies/project_policy_spec.rb
@@ -40,14 +40,14 @@ describe ProjectPolicy do
       update_commit_status create_build update_build create_pipeline
       update_pipeline create_merge_request_from create_wiki push_code
       resolve_note create_container_image update_container_image destroy_container_image
-      create_environment create_deployment create_release update_release
+      create_environment create_deployment update_deployment create_release update_release
     ]
   end
 
   let(:base_maintainer_permissions) do
     %i[
       push_to_delete_protected_branch update_project_snippet update_environment
-      update_deployment admin_project_snippet admin_project_member admin_note admin_wiki admin_project
+      admin_project_snippet admin_project_member admin_note admin_wiki admin_project
       admin_commit_status admin_build admin_container_image
       admin_pipeline admin_environment admin_deployment destroy_release add_cluster
       daily_statistics
diff --git a/spec/requests/api/deployments_spec.rb b/spec/requests/api/deployments_spec.rb
index 3dac7225b7a..ad7be531979 100644
--- a/spec/requests/api/deployments_spec.rb
+++ b/spec/requests/api/deployments_spec.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe API::Deployments do
@@ -96,4 +98,164 @@ describe API::Deployments do
       end
     end
   end
+
+  describe 'POST /projects/:id/deployments' do
+    let!(:project) { create(:project, :repository) }
+    let(:sha) { 'b83d6e391c22777fca1ed3012fce84f633d7fed0' }
+
+    context 'as a maintainer' do
+      it 'creates a new deployment' do
+        post(
+          api("/projects/#{project.id}/deployments", user),
+          params: {
+            environment: 'production',
+            sha: sha,
+            ref: 'master',
+            tag: false,
+            status: 'success'
+          }
+        )
+
+        expect(response).to have_gitlab_http_status(201)
+
+        expect(json_response['sha']).to eq(sha)
+        expect(json_response['ref']).to eq('master')
+        expect(json_response['environment']['name']).to eq('production')
+      end
+
+      it 'errors when creating a deployment with an invalid name' do
+        post(
+          api("/projects/#{project.id}/deployments", user),
+          params: {
+            environment: 'a' * 300,
+            sha: sha,
+            ref: 'master',
+            tag: false,
+            status: 'success'
+          }
+        )
+
+        expect(response).to have_gitlab_http_status(500)
+      end
+    end
+
+    context 'as a developer' do
+      it 'creates a new deployment' do
+        developer = create(:user)
+
+        project.add_developer(developer)
+
+        post(
+          api("/projects/#{project.id}/deployments", developer),
+          params: {
+            environment: 'production',
+            sha: sha,
+            ref: 'master',
+            tag: false,
+            status: 'success'
+          }
+        )
+
+        expect(response).to have_gitlab_http_status(201)
+
+        expect(json_response['sha']).to eq(sha)
+        expect(json_response['ref']).to eq('master')
+      end
+    end
+
+    context 'as non member' do
+      it 'returns a 404 status code' do
+        post(
+          api( "/projects/#{project.id}/deployments", non_member),
+          params: {
+            environment: 'production',
+            sha: '123',
+            ref: 'master',
+            tag: false,
+            status: 'success'
+          }
+        )
+
+        expect(response).to have_gitlab_http_status(404)
+      end
+    end
+  end
+
+  describe 'PUT /projects/:id/deployments/:deployment_id' do
+    let(:project) { create(:project) }
+    let(:build) { create(:ci_build, :failed, project: project) }
+    let(:environment) { create(:environment, project: project) }
+    let(:deploy) do
+      create(
+        :deployment,
+        :failed,
+        project: project,
+        environment: environment,
+        deployable: nil
+      )
+    end
+
+    context 'as a maintainer' do
+      it 'returns a 403 when updating a deployment with a build' do
+        deploy.update(deployable: build)
+
+        put(
+          api("/projects/#{project.id}/deployments/#{deploy.id}", user),
+          params: { status: 'success' }
+        )
+
+        expect(response).to have_gitlab_http_status(403)
+      end
+
+      it 'updates a deployment without an associated build' do
+        put(
+          api("/projects/#{project.id}/deployments/#{deploy.id}", user),
+          params: { status: 'success' }
+        )
+
+        expect(response).to have_gitlab_http_status(200)
+        expect(json_response['status']).to eq('success')
+      end
+    end
+
+    context 'as a developer' do
+      let(:developer) { create(:user) }
+
+      before do
+        project.add_developer(developer)
+      end
+
+      it 'returns a 403 when updating a deployment with a build' do
+        deploy.update(deployable: build)
+
+        put(
+          api("/projects/#{project.id}/deployments/#{deploy.id}", developer),
+          params: { status: 'success' }
+        )
+
+        expect(response).to have_gitlab_http_status(403)
+      end
+
+      it 'updates a deployment without an associated build' do
+        put(
+          api("/projects/#{project.id}/deployments/#{deploy.id}", developer),
+          params: { status: 'success' }
+        )
+
+        expect(response).to have_gitlab_http_status(200)
+        expect(json_response['status']).to eq('success')
+      end
+    end
+
+    context 'as non member' do
+      it 'returns a 404 status code' do
+        put(
+          api("/projects/#{project.id}/deployments/#{deploy.id}", non_member),
+          params: { status: 'success' }
+        )
+
+        expect(response).to have_gitlab_http_status(404)
+      end
+    end
+  end
 end
diff --git a/spec/requests/api/members_spec.rb b/spec/requests/api/members_spec.rb
index 7e67ee28bef..eb55d747179 100644
--- a/spec/requests/api/members_spec.rb
+++ b/spec/requests/api/members_spec.rb
@@ -87,6 +87,15 @@ describe API::Members do
         expect(json_response.first['username']).to eq(maintainer.username)
       end
 
+      it 'finds members with the given user_ids' do
+        get api(members_url, developer), params: { user_ids: [maintainer.id, developer.id, stranger.id] }
+
+        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 { |u| u['id'] }).to contain_exactly(maintainer.id, developer.id)
+      end
+
       it 'finds all members with no query specified' do
         get api(members_url, developer), params: { query: '' }
 
@@ -155,10 +164,10 @@ describe API::Members do
     end
   end
 
-  shared_examples 'GET /:source_type/:id/members/:user_id' do |source_type|
-    context "with :source_type == #{source_type.pluralize}" do
+  shared_examples 'GET /:source_type/:id/members/(all/):user_id' do |source_type, all|
+    context "with :source_type == #{source_type.pluralize} and all == #{all}" do
       it_behaves_like 'a 404 response when source is private' do
-        let(:route) { get api("/#{source_type.pluralize}/#{source.id}/members/#{developer.id}", stranger) }
+        let(:route) { get api("/#{source_type.pluralize}/#{source.id}/members/#{all ? 'all/' : ''}#{developer.id}", stranger) }
       end
 
       context 'when authenticated as a non-member' do
@@ -166,7 +175,7 @@ describe API::Members do
           context "as a #{type}" do
             it 'returns 200' do
               user = public_send(type)
-              get api("/#{source_type.pluralize}/#{source.id}/members/#{developer.id}", user)
+              get api("/#{source_type.pluralize}/#{source.id}/members/#{all ? 'all/' : ''}#{developer.id}", user)
 
               expect(response).to have_gitlab_http_status(200)
               # User attributes
@@ -434,12 +443,14 @@ describe API::Members do
     end
   end
 
-  it_behaves_like 'GET /:source_type/:id/members/:user_id', 'project' do
-    let(:source) { project }
-  end
+  [false, true].each do |all|
+    it_behaves_like 'GET /:source_type/:id/members/(all/):user_id', 'project', all do
+      let(:source) { all ? create(:project, :public, group: group) : project }
+    end
 
-  it_behaves_like 'GET /:source_type/:id/members/:user_id', 'group' do
-    let(:source) { group }
+    it_behaves_like 'GET /:source_type/:id/members/(all/):user_id', 'group', all do
+      let(:source) { all ? create(:group, parent: group) : group }
+    end
   end
 
   it_behaves_like 'POST /:source_type/:id/members', 'project' do
diff --git a/spec/requests/api/settings_spec.rb b/spec/requests/api/settings_spec.rb
index d98b9be726a..af1cf80e9d3 100644
--- a/spec/requests/api/settings_spec.rb
+++ b/spec/requests/api/settings_spec.rb
@@ -72,7 +72,8 @@ describe API::Settings, 'Settings' do
             default_branch_protection: ::Gitlab::Access::PROTECTION_DEV_CAN_MERGE,
             local_markdown_version: 3,
             allow_local_requests_from_web_hooks_and_services: true,
-            allow_local_requests_from_system_hooks: false
+            allow_local_requests_from_system_hooks: false,
+            push_event_hooks_limit: 2
           }
 
         expect(response).to have_gitlab_http_status(200)
@@ -102,6 +103,7 @@ describe API::Settings, 'Settings' do
         expect(json_response['local_markdown_version']).to eq(3)
         expect(json_response['allow_local_requests_from_web_hooks_and_services']).to eq(true)
         expect(json_response['allow_local_requests_from_system_hooks']).to eq(false)
+        expect(json_response['push_event_hooks_limit']).to eq(2)
       end
     end
 
diff --git a/spec/services/update_deployment_service_spec.rb b/spec/services/deployments/after_create_service_spec.rb
index 343dab8a974..b34483ea85b 100644
--- a/spec/services/update_deployment_service_spec.rb
+++ b/spec/services/deployments/after_create_service_spec.rb
@@ -2,7 +2,7 @@
 
 require 'spec_helper'
 
-describe UpdateDeploymentService do
+describe Deployments::AfterCreateService do
   let(:user) { create(:user) }
   let(:project) { create(:project, :repository) }
   let(:options) { { name: 'production' } }
diff --git a/spec/services/deployments/create_service_spec.rb b/spec/services/deployments/create_service_spec.rb
new file mode 100644
index 00000000000..e41c8259ea9
--- /dev/null
+++ b/spec/services/deployments/create_service_spec.rb
@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Deployments::CreateService do
+  let(:environment) do
+    double(
+      :environment,
+      deployment_platform: double(:platform, cluster_id: 1),
+      project_id: 2,
+      id: 3
+    )
+  end
+
+  let(:user) { double(:user) }
+
+  describe '#execute' do
+    let(:service) { described_class.new(environment, user, {}) }
+
+    it 'does not run the AfterCreateService service if the deployment is not persisted' do
+      deploy = double(:deployment, persisted?: false)
+
+      expect(service)
+        .to receive(:create_deployment)
+        .and_return(deploy)
+
+      expect(Deployments::AfterCreateService)
+        .not_to receive(:new)
+
+      expect(service.execute).to eq(deploy)
+    end
+
+    it 'runs the AfterCreateService service if the deployment is persisted' do
+      deploy = double(:deployment, persisted?: true)
+      after_service = double(:after_create_service)
+
+      expect(service)
+        .to receive(:create_deployment)
+        .and_return(deploy)
+
+      expect(Deployments::AfterCreateService)
+        .to receive(:new)
+        .with(deploy)
+        .and_return(after_service)
+
+      expect(after_service)
+        .to receive(:execute)
+
+      expect(service.execute).to eq(deploy)
+    end
+  end
+
+  describe '#create_deployment' do
+    it 'creates a deployment' do
+      environment = build(:environment)
+      service = described_class.new(environment, user, {})
+
+      expect(environment.deployments)
+        .to receive(:create)
+        .with(an_instance_of(Hash))
+
+      service.create_deployment
+    end
+  end
+
+  describe '#deployment_attributes' do
+    it 'only includes attributes that we want to persist' do
+      service = described_class.new(
+        environment,
+        user,
+        ref: 'master',
+        tag: true,
+        sha: '123',
+        foo: 'bar',
+        on_stop: 'stop',
+        status: 'running'
+      )
+
+      expect(service.deployment_attributes).to eq(
+        cluster_id: 1,
+        project_id: 2,
+        environment_id: 3,
+        ref: 'master',
+        tag: true,
+        sha: '123',
+        user: user,
+        on_stop: 'stop',
+        status: 'running'
+      )
+    end
+  end
+end
diff --git a/spec/services/deployments/update_service_spec.rb b/spec/services/deployments/update_service_spec.rb
new file mode 100644
index 00000000000..a923099b82c
--- /dev/null
+++ b/spec/services/deployments/update_service_spec.rb
@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Deployments::UpdateService do
+  let(:deploy) { create(:deployment, :running) }
+  let(:service) { described_class.new(deploy, status: 'success') }
+
+  describe '#execute' do
+    it 'updates the status of a deployment' do
+      expect(service.execute).to eq(true)
+      expect(deploy.status).to eq('success')
+    end
+  end
+end
diff --git a/spec/services/git/base_hooks_service_spec.rb b/spec/services/git/base_hooks_service_spec.rb
index e71900e3c0d..90b3eb38469 100644
--- a/spec/services/git/base_hooks_service_spec.rb
+++ b/spec/services/git/base_hooks_service_spec.rb
@@ -8,7 +8,6 @@ describe Git::BaseHooksService do
 
   let(:user) { create(:user) }
   let(:project) { create(:project, :repository) }
-
   let(:oldrev) { Gitlab::Git::BLANK_SHA }
   let(:newrev) { "8a2a6eb295bb170b34c24c76c49ed0e9b2eaf34b" } # gitlab-test: git rev-parse refs/tags/v1.1.0
   let(:ref) { 'refs/tags/v1.1.0' }
@@ -26,7 +25,17 @@ describe Git::BaseHooksService do
 
     let(:project) { create(:project, :repository) }
 
-    subject { TestService.new(project, user, change: { oldrev: oldrev, newrev: newrev, ref: ref }) }
+    let(:params) do
+      {
+        change: {
+          oldrev: oldrev,
+          newrev: newrev,
+          ref: ref
+        }
+      }
+    end
+
+    subject { TestService.new(project, user, params) }
 
     context '#execute_hooks' do
       before do
@@ -83,5 +92,21 @@ describe Git::BaseHooksService do
         end
       end
     end
+
+    context 'execute_project_hooks param set to false' do
+      before do
+        params[:execute_project_hooks] = false
+
+        allow(project).to receive(:has_active_hooks?).and_return(true)
+        allow(project).to receive(:has_active_services?).and_return(true)
+      end
+
+      it 'does not execute hooks and services' do
+        expect(project).not_to receive(:execute_hooks)
+        expect(project).not_to receive(:execute_services)
+
+        subject.execute
+      end
+    end
   end
 end
diff --git a/spec/services/git/process_ref_changes_service_spec.rb b/spec/services/git/process_ref_changes_service_spec.rb
index 4d394a29867..eeb395f6c7b 100644
--- a/spec/services/git/process_ref_changes_service_spec.rb
+++ b/spec/services/git/process_ref_changes_service_spec.rb
@@ -28,12 +28,66 @@ describe Git::ProcessRefChangesService do
     it "calls #{push_service_class}" do
       expect(push_service_class)
         .to receive(:new)
+        .with(project, project.owner, hash_including(execute_project_hooks: true))
         .exactly(changes.count).times
         .and_return(service)
 
       subject.execute
     end
 
+    context 'changes exceed push_event_hooks_limit' do
+      def multiple_changes(change, count)
+        Array.new(count).map.with_index do |n, index|
+          { index: index, oldrev: change[:oldrev], newrev: change[:newrev], ref: "#{change[:ref]}#{n}" }
+        end
+      end
+
+      let(:push_event_hooks_limit) { 3 }
+
+      let(:changes) do
+        multiple_changes(
+          { oldrev: '123456', newrev: '789012', ref: "#{ref_prefix}/test" },
+          push_event_hooks_limit + 1
+        )
+      end
+
+      before do
+        stub_application_setting(push_event_hooks_limit: push_event_hooks_limit)
+      end
+
+      context 'git_push_execute_all_project_hooks is disabled' do
+        before do
+          stub_feature_flags(git_push_execute_all_project_hooks: false)
+        end
+
+        it "calls #{push_service_class} with execute_project_hooks set to false" do
+          expect(push_service_class)
+            .to receive(:new)
+            .with(project, project.owner, hash_including(execute_project_hooks: false))
+            .exactly(changes.count).times
+            .and_return(service)
+
+          subject.execute
+        end
+      end
+
+      context 'git_push_execute_all_project_hooks is enabled' do
+        before do
+          stub_feature_flags(git_push_execute_all_project_hooks: true)
+        end
+
+        it "calls #{push_service_class} with execute_project_hooks set to true" do
+          expect(push_service_class)
+            .to receive(:new)
+            .with(project, project.owner, hash_including(execute_project_hooks: true))
+            .exactly(changes.count).times
+            .and_return(service)
+
+          subject.execute
+        end
+      end
+    end
+
     context 'pipeline creation' do
       context 'with valid .gitlab-ci.yml' do
         before do
diff --git a/spec/support/features/rss_shared_examples.rb b/spec/support/features/rss_shared_examples.rb
index c97eeba87db..bbe793a81bc 100644
--- a/spec/support/features/rss_shared_examples.rb
+++ b/spec/support/features/rss_shared_examples.rb
@@ -8,7 +8,9 @@ end
 
 shared_examples "it has an RSS button with current_user's feed token" do
   it "shows the RSS button with current_user's feed token" do
-    expect(page).to have_css("a:has(.fa-rss)[href*='feed_token=#{user.feed_token}']")
+    expect(page)
+      .to have_css("a:has(.fa-rss)[href*='feed_token=#{user.feed_token}']")
+      .or have_css("a.js-rss-button[href*='feed_token=#{user.feed_token}']")
   end
 end
 
@@ -20,6 +22,8 @@ end
 
 shared_examples "it has an RSS button without a feed token" do
   it "shows the RSS button without a feed token" do
-    expect(page).to have_css("a:has(.fa-rss):not([href*='feed_token'])")
+    expect(page)
+      .to have_css("a:has(.fa-rss):not([href*='feed_token'])")
+      .or have_css("a.js-rss-button:not([href*='feed_token'])")
   end
 end
diff --git a/spec/support/shared_contexts/policies/project_policy_shared_context.rb b/spec/support/shared_contexts/policies/project_policy_shared_context.rb
index 1aa40dcde3d..65398c13d90 100644
--- a/spec/support/shared_contexts/policies/project_policy_shared_context.rb
+++ b/spec/support/shared_contexts/policies/project_policy_shared_context.rb
@@ -38,14 +38,14 @@ RSpec.shared_context 'ProjectPolicy context' do
       update_commit_status create_build update_build create_pipeline
       update_pipeline create_merge_request_from create_wiki push_code
       resolve_note create_container_image update_container_image
-      create_environment create_deployment create_release update_release
+      create_environment create_deployment update_deployment create_release update_release
     ]
   end
 
   let(:base_maintainer_permissions) do
     %i[
       push_to_delete_protected_branch update_project_snippet update_environment
-      update_deployment admin_project_snippet admin_project_member admin_note admin_wiki admin_project
+      admin_project_snippet admin_project_member admin_note admin_wiki admin_project
       admin_commit_status admin_build admin_container_image
       admin_pipeline admin_environment admin_deployment destroy_release add_cluster
       daily_statistics
diff --git a/spec/workers/deployments/success_worker_spec.rb b/spec/workers/deployments/success_worker_spec.rb
index 1c68922b03d..7f2816d7535 100644
--- a/spec/workers/deployments/success_worker_spec.rb
+++ b/spec/workers/deployments/success_worker_spec.rb
@@ -8,8 +8,8 @@ describe Deployments::SuccessWorker do
   context 'when successful deployment' do
     let(:deployment) { create(:deployment, :success) }
 
-    it 'executes UpdateDeploymentService' do
-      expect(UpdateDeploymentService)
+    it 'executes Deployments::AfterCreateService' do
+      expect(Deployments::AfterCreateService)
         .to receive(:new).with(deployment).and_call_original
 
       subject
@@ -19,8 +19,8 @@ describe Deployments::SuccessWorker do
   context 'when canceled deployment' do
     let(:deployment) { create(:deployment, :canceled) }
 
-    it 'does not execute UpdateDeploymentService' do
-      expect(UpdateDeploymentService).not_to receive(:new)
+    it 'does not execute Deployments::AfterCreateService' do
+      expect(Deployments::AfterCreateService).not_to receive(:new)
 
       subject
     end
@@ -29,8 +29,8 @@ describe Deployments::SuccessWorker do
   context 'when deploy record does not exist' do
     let(:deployment) { nil }
 
-    it 'does not execute UpdateDeploymentService' do
-      expect(UpdateDeploymentService).not_to receive(:new)
+    it 'does not execute Deployments::AfterCreateService' do
+      expect(Deployments::AfterCreateService).not_to receive(:new)
 
       subject
     end
diff --git a/spec/workers/post_receive_spec.rb b/spec/workers/post_receive_spec.rb
index 6983fea021c..34aaa9bb1e9 100644
--- a/spec/workers/post_receive_spec.rb
+++ b/spec/workers/post_receive_spec.rb
@@ -93,6 +93,8 @@ describe PostReceive do
     end
 
     context 'with changes' do
+      let(:push_service) { double(execute: true) }
+
       before do
         allow_any_instance_of(Gitlab::GitPostReceive).to receive(:identify).and_return(project.owner)
         allow(Gitlab::GlRepository).to receive(:parse).and_return([project, Gitlab::GlRepository::PROJECT])