Merge branch 'master' into feature/gb/manual-actions-protected-branches-permissions

* master: (641 commits)
  Revert "Fix registry for projects with uppercases in path"
  Fix registry for projects with uppercases in path
  Move event icons into events_helper
  Reset New branch button when issue state changes
  Add link to environments on kubernetes.md
  Indent system notes on desktop screens
  Improve webpack-dev-server compatibility with non-localhost setups.
  Add changelog entry
  Fix recent searches icon alignment in Safari
  Use preload to avoid Rails using JOIN
  Fix NUMBER_OF_TRUNCATED_DIFF_LINES re-definition error
  Prepare for zero downtime migrations
  Fix filtered search input width for IE
  Fix the `gitlab:gitlab_shell:check` task
  Fixed random failures with Poll spec
  Include CONTRIBUTING.md file when importing .gitlab-ci.yml templates
  Let uses hide verbose output by default
  Separate examples for each other
  Collapse similar sibling scenarios
  Use empty_project for resources that are independent of the repo
  ...

Conflicts:
	app/views/projects/ci/builds/_build.html.haml

253 files changed, 11083 insertions, 3273 deletions

diff --git a/spec/controllers/application_controller_spec.rb b/spec/controllers/application_controller_spec.rb
index 81cbccd5436..760f33b09c1 100644
--- a/spec/controllers/application_controller_spec.rb
+++ b/spec/controllers/application_controller_spec.rb
@@ -100,8 +100,6 @@ describe ApplicationController do
   end
 
   describe '#route_not_found' do
-    let(:controller) { ApplicationController.new }
-
     it 'renders 404 if authenticated' do
       allow(controller).to receive(:current_user).and_return(user)
       expect(controller).to receive(:not_found)
@@ -115,4 +113,203 @@ describe ApplicationController do
       controller.send(:route_not_found)
     end
   end
+
+  context 'two-factor authentication' do
+    let(:controller) { ApplicationController.new }
+
+    describe '#check_two_factor_requirement' do
+      subject { controller.send :check_two_factor_requirement }
+
+      it 'does not redirect if 2FA is not required' do
+        allow(controller).to receive(:two_factor_authentication_required?).and_return(false)
+        expect(controller).not_to receive(:redirect_to)
+
+        subject
+      end
+
+      it 'does not redirect if user is not logged in' do
+        allow(controller).to receive(:two_factor_authentication_required?).and_return(true)
+        allow(controller).to receive(:current_user).and_return(nil)
+        expect(controller).not_to receive(:redirect_to)
+
+        subject
+      end
+
+      it 'does not redirect if user has 2FA enabled' do
+        allow(controller).to receive(:two_factor_authentication_required?).and_return(true)
+        allow(controller).to receive(:current_user).twice.and_return(user)
+        allow(user).to receive(:two_factor_enabled?).and_return(true)
+        expect(controller).not_to receive(:redirect_to)
+
+        subject
+      end
+
+      it 'does not redirect if 2FA setup can be skipped' do
+        allow(controller).to receive(:two_factor_authentication_required?).and_return(true)
+        allow(controller).to receive(:current_user).twice.and_return(user)
+        allow(user).to receive(:two_factor_enabled?).and_return(false)
+        allow(controller).to receive(:skip_two_factor?).and_return(true)
+        expect(controller).not_to receive(:redirect_to)
+
+        subject
+      end
+
+      it 'redirects to 2FA setup otherwise' do
+        allow(controller).to receive(:two_factor_authentication_required?).and_return(true)
+        allow(controller).to receive(:current_user).twice.and_return(user)
+        allow(user).to receive(:two_factor_enabled?).and_return(false)
+        allow(controller).to receive(:skip_two_factor?).and_return(false)
+        allow(controller).to receive(:profile_two_factor_auth_path)
+        expect(controller).to receive(:redirect_to)
+
+        subject
+      end
+    end
+
+    describe '#two_factor_authentication_required?' do
+      subject { controller.send :two_factor_authentication_required? }
+
+      it 'returns false if no 2FA requirement is present' do
+        allow(controller).to receive(:current_user).and_return(nil)
+
+        expect(subject).to be_falsey
+      end
+
+      it 'returns true if a 2FA requirement is set in the application settings' do
+        stub_application_setting require_two_factor_authentication: true
+        allow(controller).to receive(:current_user).and_return(nil)
+
+        expect(subject).to be_truthy
+      end
+
+      it 'returns true if a 2FA requirement is set on the user' do
+        user.require_two_factor_authentication_from_group = true
+        allow(controller).to receive(:current_user).and_return(user)
+
+        expect(subject).to be_truthy
+      end
+    end
+
+    describe '#two_factor_grace_period' do
+      subject { controller.send :two_factor_grace_period }
+
+      it 'returns the grace period from the application settings' do
+        stub_application_setting two_factor_grace_period: 23
+        allow(controller).to receive(:current_user).and_return(nil)
+
+        expect(subject).to eq 23
+      end
+
+      context 'with a 2FA requirement set on the user' do
+        let(:user) { create :user, require_two_factor_authentication_from_group: true, two_factor_grace_period: 23 }
+
+        it 'returns the user grace period if lower than the application grace period' do
+          stub_application_setting two_factor_grace_period: 24
+          allow(controller).to receive(:current_user).and_return(user)
+
+          expect(subject).to eq 23
+        end
+
+        it 'returns the application grace period if lower than the user grace period' do
+          stub_application_setting two_factor_grace_period: 22
+          allow(controller).to receive(:current_user).and_return(user)
+
+          expect(subject).to eq 22
+        end
+      end
+    end
+
+    describe '#two_factor_grace_period_expired?' do
+      subject { controller.send :two_factor_grace_period_expired? }
+
+      before do
+        allow(controller).to receive(:current_user).and_return(user)
+      end
+
+      it 'returns false if the user has not started their grace period yet' do
+        expect(subject).to be_falsey
+      end
+
+      context 'with grace period started' do
+        let(:user) { create :user, otp_grace_period_started_at: 2.hours.ago }
+
+        it 'returns true if the grace period has expired' do
+          allow(controller).to receive(:two_factor_grace_period).and_return(1)
+
+          expect(subject).to be_truthy
+        end
+
+        it 'returns false if the grace period is still active' do
+          allow(controller).to receive(:two_factor_grace_period).and_return(3)
+
+          expect(subject).to be_falsey
+        end
+      end
+    end
+
+    describe '#two_factor_skippable' do
+      subject { controller.send :two_factor_skippable? }
+
+      before do
+        allow(controller).to receive(:current_user).and_return(user)
+      end
+
+      it 'returns false if 2FA is not required' do
+        allow(controller).to receive(:two_factor_authentication_required?).and_return(false)
+
+        expect(subject).to be_falsey
+      end
+
+      it 'returns false if the user has already enabled 2FA' do
+        allow(controller).to receive(:two_factor_authentication_required?).and_return(true)
+        allow(user).to receive(:two_factor_enabled?).and_return(true)
+
+        expect(subject).to be_falsey
+      end
+
+      it 'returns false if the 2FA grace period has expired' do
+        allow(controller).to receive(:two_factor_authentication_required?).and_return(true)
+        allow(user).to receive(:two_factor_enabled?).and_return(false)
+        allow(controller).to receive(:two_factor_grace_period_expired?).and_return(true)
+
+        expect(subject).to be_falsey
+      end
+
+      it 'returns true otherwise' do
+        allow(controller).to receive(:two_factor_authentication_required?).and_return(true)
+        allow(user).to receive(:two_factor_enabled?).and_return(false)
+        allow(controller).to receive(:two_factor_grace_period_expired?).and_return(false)
+
+        expect(subject).to be_truthy
+      end
+    end
+
+    describe '#skip_two_factor?' do
+      subject { controller.send :skip_two_factor? }
+
+      it 'returns false if 2FA setup was not skipped' do
+        allow(controller).to receive(:session).and_return({})
+
+        expect(subject).to be_falsey
+      end
+
+      context 'with 2FA setup skipped' do
+        before do
+          allow(controller).to receive(:session).and_return({ skip_two_factor: 2.hours.from_now })
+        end
+
+        it 'returns false if the grace period has expired' do
+          Timecop.freeze(3.hours.from_now) do
+            expect(subject).to be_falsey
+          end
+        end
+
+        it 'returns true if the grace period is still active' do
+          Timecop.freeze(1.hour.from_now) do
+            expect(subject).to be_truthy
+          end
+        end
+      end
+    end
+  end
 end
diff --git a/spec/controllers/health_controller_spec.rb b/spec/controllers/health_controller_spec.rb
new file mode 100644
index 00000000000..b8b6e0c3a88
--- /dev/null
+++ b/spec/controllers/health_controller_spec.rb
@@ -0,0 +1,96 @@
+require 'spec_helper'
+
+describe HealthController do
+  include StubENV
+
+  let(:token) { current_application_settings.health_check_access_token }
+  let(:json_response) { JSON.parse(response.body) }
+
+  before do
+    stub_env('IN_MEMORY_APPLICATION_SETTINGS', 'false')
+  end
+
+  describe '#readiness' do
+    context 'authorization token provided' do
+      before do
+        request.headers['TOKEN'] = token
+      end
+
+      it 'returns proper response' do
+        get :readiness
+        expect(json_response['db_check']['status']).to eq('ok')
+        expect(json_response['redis_check']['status']).to eq('ok')
+        expect(json_response['fs_shards_check']['status']).to eq('ok')
+        expect(json_response['fs_shards_check']['labels']['shard']).to eq('default')
+      end
+    end
+
+    context 'without authorization token' do
+      it 'returns proper response' do
+        get :readiness
+        expect(response.status).to eq(404)
+      end
+    end
+  end
+
+  describe '#liveness' do
+    context 'authorization token provided' do
+      before do
+        request.headers['TOKEN'] = token
+      end
+
+      it 'returns proper response' do
+        get :liveness
+        expect(json_response['db_check']['status']).to eq('ok')
+        expect(json_response['redis_check']['status']).to eq('ok')
+        expect(json_response['fs_shards_check']['status']).to eq('ok')
+      end
+    end
+
+    context 'without authorization token' do
+      it 'returns proper response' do
+        get :liveness
+        expect(response.status).to eq(404)
+      end
+    end
+  end
+
+  describe '#metrics' do
+    context 'authorization token provided' do
+      before do
+        request.headers['TOKEN'] = token
+      end
+
+      it 'returns DB ping metrics' do
+        get :metrics
+        expect(response.body).to match(/^db_ping_timeout 0$/)
+        expect(response.body).to match(/^db_ping_success 1$/)
+        expect(response.body).to match(/^db_ping_latency [0-9\.]+$/)
+      end
+
+      it 'returns Redis ping metrics' do
+        get :metrics
+        expect(response.body).to match(/^redis_ping_timeout 0$/)
+        expect(response.body).to match(/^redis_ping_success 1$/)
+        expect(response.body).to match(/^redis_ping_latency [0-9\.]+$/)
+      end
+
+      it 'returns file system check metrics' do
+        get :metrics
+        expect(response.body).to match(/^filesystem_access_latency{shard="default"} [0-9\.]+$/)
+        expect(response.body).to match(/^filesystem_accessible{shard="default"} 1$/)
+        expect(response.body).to match(/^filesystem_write_latency{shard="default"} [0-9\.]+$/)
+        expect(response.body).to match(/^filesystem_writable{shard="default"} 1$/)
+        expect(response.body).to match(/^filesystem_read_latency{shard="default"} [0-9\.]+$/)
+        expect(response.body).to match(/^filesystem_readable{shard="default"} 1$/)
+      end
+    end
+
+    context 'without authorization token' do
+      it 'returns proper response' do
+        get :metrics
+        expect(response.status).to eq(404)
+      end
+    end
+  end
+end
diff --git a/spec/controllers/projects/blob_controller_spec.rb b/spec/controllers/projects/blob_controller_spec.rb
index ec36a64b415..3e9f272a0d8 100644
--- a/spec/controllers/projects/blob_controller_spec.rb
+++ b/spec/controllers/projects/blob_controller_spec.rb
@@ -2,15 +2,10 @@ require 'rails_helper'
 
 describe Projects::BlobController do
   let(:project) { create(:project, :public, :repository) }
-  let(:user)    { create(:user) }
-
-  before do
-    project.team << [user, :master]
-
-    sign_in(user)
-  end
 
   describe 'GET diff' do
+    let(:user) { create(:user) }
+
     render_views
 
     def do_get(opts = {})
@@ -20,6 +15,12 @@ describe Projects::BlobController do
       get :diff, params.merge(opts)
     end
 
+    before do
+      project.team << [user, :master]
+
+      sign_in(user)
+    end
+
     context 'when essential params are missing' do
       it 'renders nothing' do
         do_get
@@ -37,7 +38,69 @@ describe Projects::BlobController do
     end
   end
 
+  describe 'GET edit' do
+    let(:default_params) do
+      {
+        namespace_id: project.namespace,
+        project_id: project,
+        id: 'master/CHANGELOG'
+      }
+    end
+
+    context 'anonymous' do
+      before do
+        get :edit, default_params
+      end
+
+      it 'redirects to sign in and returns' do
+        expect(response).to redirect_to(new_user_session_path)
+      end
+    end
+
+    context 'as guest' do
+      let(:guest) { create(:user) }
+
+      before do
+        sign_in(guest)
+        get :edit, default_params
+      end
+
+      it 'redirects to blob show' do
+        expect(response).to redirect_to(namespace_project_blob_path(project.namespace, project, 'master/CHANGELOG'))
+      end
+    end
+
+    context 'as developer' do
+      let(:developer) { create(:user) }
+
+      before do
+        project.team << [developer, :developer]
+        sign_in(developer)
+        get :edit, default_params
+      end
+
+      it 'redirects to blob show' do
+        expect(response).to have_http_status(200)
+      end
+    end
+
+    context 'as master' do
+      let(:master) { create(:user) }
+
+      before do
+        project.team << [master, :master]
+        sign_in(master)
+        get :edit, default_params
+      end
+
+      it 'redirects to blob show' do
+        expect(response).to have_http_status(200)
+      end
+    end
+  end
+
   describe 'PUT update' do
+    let(:user) { create(:user) }
     let(:default_params) do
       {
         namespace_id: project.namespace,
@@ -53,6 +116,12 @@ describe Projects::BlobController do
       namespace_project_blob_path(project.namespace, project, 'master/CHANGELOG')
     end
 
+    before do
+      project.team << [user, :master]
+
+      sign_in(user)
+    end
+
     it 'redirects to blob' do
       put :update, default_params
 
diff --git a/spec/controllers/projects/builds_controller_spec.rb b/spec/controllers/projects/builds_controller_spec.rb
index 683667129e5..13208d21918 100644
--- a/spec/controllers/projects/builds_controller_spec.rb
+++ b/spec/controllers/projects/builds_controller_spec.rb
@@ -10,6 +10,39 @@ describe Projects::BuildsController do
     sign_in(user)
   end
 
+  describe 'GET index' do
+    context 'number of queries' do
+      before do
+        Ci::Build::AVAILABLE_STATUSES.each do |status|
+          create_build(status, status)
+        end
+
+        RequestStore.begin!
+      end
+
+      after do
+        RequestStore.end!
+        RequestStore.clear!
+      end
+
+      def render
+        get :index, namespace_id: project.namespace,
+                    project_id: project
+      end
+
+      it "verifies number of queries" do
+        recorded = ActiveRecord::QueryRecorder.new { render }
+        expect(recorded.count).to be_within(5).of(8)
+      end
+
+      def create_build(name, status)
+        pipeline = create(:ci_pipeline, project: project)
+        create(:ci_build, :tags, :triggered, :artifacts,
+          pipeline: pipeline, name: name, status: status)
+      end
+    end
+  end
+
   describe 'GET status.json' do
     let(:pipeline) { create(:ci_pipeline, project: project) }
     let(:build) { create(:ci_build, pipeline: pipeline) }
diff --git a/spec/controllers/projects/commit_controller_spec.rb b/spec/controllers/projects/commit_controller_spec.rb
index b223a22ae60..69e4706dc71 100644
--- a/spec/controllers/projects/commit_controller_spec.rb
+++ b/spec/controllers/projects/commit_controller_spec.rb
@@ -266,8 +266,8 @@ describe Projects::CommitController do
             diff_for_path(id: commit2.id, old_path: existing_path, new_path: existing_path)
 
             expect(assigns(:diff_notes_disabled)).to be_falsey
-            expect(assigns(:comments_target)).to eq(noteable_type: 'Commit',
-                                                    commit_id: commit2.id)
+            expect(assigns(:new_diff_note_attrs)).to eq(noteable_type: 'Commit',
+                                                        commit_id: commit2.id)
           end
 
           it 'only renders the diffs for the path given' do
diff --git a/spec/controllers/projects/discussions_controller_spec.rb b/spec/controllers/projects/discussions_controller_spec.rb
index 79ab364a6f3..fe62898fa9b 100644
--- a/spec/controllers/projects/discussions_controller_spec.rb
+++ b/spec/controllers/projects/discussions_controller_spec.rb
@@ -4,7 +4,7 @@ describe Projects::DiscussionsController do
   let(:user) { create(:user) }
   let(:merge_request) { create(:merge_request) }
   let(:project) { merge_request.source_project }
-  let(:note) { create(:diff_note_on_merge_request, noteable: merge_request, project: project) }
+  let(:note) { create(:discussion_note_on_merge_request, noteable: merge_request, project: project) }
   let(:discussion) { note.discussion }
 
   let(:request_params) do
diff --git a/spec/controllers/projects/issues_controller_spec.rb b/spec/controllers/projects/issues_controller_spec.rb
index d5f1d46bf7f..79034b8d24d 100644
--- a/spec/controllers/projects/issues_controller_spec.rb
+++ b/spec/controllers/projects/issues_controller_spec.rb
@@ -519,7 +519,7 @@ describe Projects::IssuesController do
     end
 
     context 'resolving discussions in MergeRequest' do
-      let(:discussion) { Discussion.for_diff_notes([create(:diff_note_on_merge_request)]).first }
+      let(:discussion) { create(:diff_note_on_merge_request).to_discussion }
       let(:merge_request) { discussion.noteable }
       let(:project) { merge_request.source_project }
 
diff --git a/spec/controllers/projects/merge_requests_controller_spec.rb b/spec/controllers/projects/merge_requests_controller_spec.rb
index 99d5583e683..1739d40ab88 100644
--- a/spec/controllers/projects/merge_requests_controller_spec.rb
+++ b/spec/controllers/projects/merge_requests_controller_spec.rb
@@ -586,8 +586,8 @@ describe Projects::MergeRequestsController do
               diff_for_path(id: merge_request.iid, old_path: existing_path, new_path: existing_path)
 
               expect(assigns(:diff_notes_disabled)).to be_falsey
-              expect(assigns(:comments_target)).to eq(noteable_type: 'MergeRequest',
-                                                      noteable_id: merge_request.id)
+              expect(assigns(:new_diff_note_attrs)).to eq(noteable_type: 'MergeRequest',
+                                                          noteable_id: merge_request.id)
             end
 
             it 'only renders the diffs for the path given' do
diff --git a/spec/controllers/projects/notes_controller_spec.rb b/spec/controllers/projects/notes_controller_spec.rb
index d80780b1d90..f140eaef5d5 100644
--- a/spec/controllers/projects/notes_controller_spec.rb
+++ b/spec/controllers/projects/notes_controller_spec.rb
@@ -14,6 +14,109 @@ describe Projects::NotesController do
     }
   end
 
+  describe 'GET index' do
+    let(:request_params) do
+      {
+        namespace_id: project.namespace,
+        project_id: project,
+        target_type: 'issue',
+        target_id: issue.id,
+        format: 'json'
+      }
+    end
+
+    let(:parsed_response) { JSON.parse(response.body).with_indifferent_access }
+    let(:note_json) { parsed_response[:notes].first }
+
+    before do
+      sign_in(user)
+      project.team << [user, :developer]
+    end
+
+    it 'passes last_fetched_at from headers to NotesFinder' do
+      last_fetched_at = 3.hours.ago.to_i
+
+      request.headers['X-Last-Fetched-At'] = last_fetched_at
+
+      expect(NotesFinder).to receive(:new)
+        .with(anything, anything, hash_including(last_fetched_at: last_fetched_at))
+        .and_call_original
+
+      get :index, request_params
+    end
+
+    context 'for a discussion note' do
+      let!(:note) { create(:discussion_note_on_issue, noteable: issue, project: project) }
+
+      it 'responds with the expected attributes' do
+        get :index, request_params
+
+        expect(note_json[:id]).to eq(note.id)
+        expect(note_json[:discussion_html]).not_to be_nil
+        expect(note_json[:diff_discussion_html]).to be_nil
+      end
+    end
+
+    context 'for a diff discussion note' do
+      let(:project) { create(:project, :repository) }
+      let!(:note) { create(:diff_note_on_merge_request, project: project) }
+
+      let(:params) { request_params.merge(target_type: 'merge_request', target_id: note.noteable_id) }
+
+      it 'responds with the expected attributes' do
+        get :index, params
+
+        expect(note_json[:id]).to eq(note.id)
+        expect(note_json[:discussion_html]).not_to be_nil
+        expect(note_json[:diff_discussion_html]).not_to be_nil
+      end
+    end
+
+    context 'for a commit note' do
+      let(:project) { create(:project, :repository) }
+      let!(:note) { create(:note_on_commit, project: project) }
+
+      context 'when displayed on a merge request' do
+        let(:merge_request) { create(:merge_request, source_project: project) }
+
+        let(:params) { request_params.merge(target_type: 'merge_request', target_id: merge_request.id) }
+
+        it 'responds with the expected attributes' do
+          get :index, params
+
+          expect(note_json[:id]).to eq(note.id)
+          expect(note_json[:discussion_html]).not_to be_nil
+          expect(note_json[:diff_discussion_html]).to be_nil
+        end
+      end
+
+      context 'when displayed on the commit' do
+        let(:params) { request_params.merge(target_type: 'commit', target_id: note.commit_id) }
+
+        it 'responds with the expected attributes' do
+          get :index, params
+
+          expect(note_json[:id]).to eq(note.id)
+          expect(note_json[:discussion_html]).to be_nil
+          expect(note_json[:diff_discussion_html]).to be_nil
+        end
+      end
+    end
+
+    context 'for a regular note' do
+      let!(:note) { create(:note, noteable: issue, project: project) }
+
+      it 'responds with the expected attributes' do
+        get :index, request_params
+
+        expect(note_json[:id]).to eq(note.id)
+        expect(note_json[:html]).not_to be_nil
+        expect(note_json[:discussion_html]).to be_nil
+        expect(note_json[:diff_discussion_html]).to be_nil
+      end
+    end
+  end
+
   describe 'POST create' do
     let(:merge_request) { create(:merge_request) }
     let(:project) { merge_request.source_project }
@@ -49,7 +152,8 @@ describe Projects::NotesController do
           note: 'some note',
           noteable_id: merge_request.id.to_s,
           noteable_type: 'MergeRequest',
-          merge_request_diff_head_sha: 'sha'
+          merge_request_diff_head_sha: 'sha',
+          in_reply_to_discussion_id: nil
         }
 
         expect(Notes::CreateService).to receive(:new).with(project, user, service_params).and_return(double(execute: true))
@@ -200,31 +304,4 @@ describe Projects::NotesController do
       end
     end
   end
-
-  describe 'GET index' do
-    let(:last_fetched_at) { '1487756246' }
-    let(:request_params) do
-      {
-        namespace_id: project.namespace,
-        project_id: project,
-        target_type: 'issue',
-        target_id: issue.id
-      }
-    end
-
-    before do
-      sign_in(user)
-      project.team << [user, :developer]
-    end
-
-    it 'passes last_fetched_at from headers to NotesFinder' do
-      request.headers['X-Last-Fetched-At'] = last_fetched_at
-
-      expect(NotesFinder).to receive(:new)
-        .with(anything, anything, hash_including(last_fetched_at: last_fetched_at))
-        .and_call_original
-
-      get :index, request_params
-    end
-  end
 end
diff --git a/spec/controllers/projects/protected_branches_controller_spec.rb b/spec/controllers/projects/protected_branches_controller_spec.rb
index e378b5714fe..80be135b5d8 100644
--- a/spec/controllers/projects/protected_branches_controller_spec.rb
+++ b/spec/controllers/projects/protected_branches_controller_spec.rb
@@ -3,6 +3,7 @@ require('spec_helper')
 describe Projects::ProtectedBranchesController do
   describe "GET #index" do
     let(:project) { create(:project_empty_repo, :public) }
+
     it "redirects empty repo to projects page" do
       get(:index, namespace_id: project.namespace.to_param, project_id: project)
     end
diff --git a/spec/controllers/projects/protected_tags_controller_spec.rb b/spec/controllers/projects/protected_tags_controller_spec.rb
new file mode 100644
index 00000000000..64658988b3f
--- /dev/null
+++ b/spec/controllers/projects/protected_tags_controller_spec.rb
@@ -0,0 +1,11 @@
+require('spec_helper')
+
+describe Projects::ProtectedTagsController do
+  describe "GET #index" do
+    let(:project) { create(:project_empty_repo, :public) }
+
+    it "redirects empty repo to projects page" do
+      get(:index, namespace_id: project.namespace.to_param, project_id: project)
+    end
+  end
+end
diff --git a/spec/controllers/projects/registry/repositories_controller_spec.rb b/spec/controllers/projects/registry/repositories_controller_spec.rb
new file mode 100644
index 00000000000..464302824a8
--- /dev/null
+++ b/spec/controllers/projects/registry/repositories_controller_spec.rb
@@ -0,0 +1,84 @@
+require 'spec_helper'
+
+describe Projects::Registry::RepositoriesController do
+  let(:user)    { create(:user) }
+  let(:project) { create(:empty_project, :private) }
+
+  before do
+    sign_in(user)
+    stub_container_registry_config(enabled: true)
+  end
+
+  context 'when user has access to registry' do
+    before do
+      project.add_developer(user)
+    end
+
+    describe 'GET index' do
+      context 'when root container repository exists' do
+        before do
+          create(:container_repository, :root, project: project)
+        end
+
+        it 'does not create root container repository' do
+          expect { go_to_index }.not_to change { ContainerRepository.all.count }
+        end
+      end
+
+      context 'when root container repository is not created' do
+        context 'when there are tags for this repository' do
+          before do
+            stub_container_registry_tags(repository: project.full_path,
+                                         tags: %w[rc1 latest])
+          end
+
+          it 'successfully renders container repositories' do
+            go_to_index
+
+            expect(response).to have_http_status(:ok)
+          end
+
+          it 'creates a root container repository' do
+            expect { go_to_index }.to change { ContainerRepository.all.count }.by(1)
+            expect(ContainerRepository.first).to be_root_repository
+          end
+        end
+
+        context 'when there are no tags for this repository' do
+          before do
+            stub_container_registry_tags(repository: :any, tags: [])
+          end
+
+          it 'successfully renders container repositories' do
+            go_to_index
+
+            expect(response).to have_http_status(:ok)
+          end
+
+          it 'does not ensure root container repository' do
+            expect { go_to_index }.not_to change { ContainerRepository.all.count }
+          end
+        end
+      end
+    end
+  end
+
+  context 'when user does not have access to registry' do
+    describe 'GET index' do
+      it 'responds with 404' do
+        go_to_index
+
+        expect(response).to have_http_status(:not_found)
+      end
+
+      it 'does not ensure root container repository' do
+        expect { go_to_index }.not_to change { ContainerRepository.all.count }
+      end
+    end
+  end
+
+  def go_to_index
+    get :index, namespace_id: project.namespace,
+                project_id: project
+  end
+end
diff --git a/spec/factories/ci/builds.rb b/spec/factories/ci/builds.rb
index 87a0c95c4dc..b62def83ee4 100644
--- a/spec/factories/ci/builds.rb
+++ b/spec/factories/ci/builds.rb
@@ -111,7 +111,7 @@ FactoryGirl.define do
 
     trait :trace do
       after(:create) do |build, evaluator|
-        build.trace = 'BUILD TRACE'
+        build.trace.set('BUILD TRACE')
       end
     end
 
diff --git a/spec/factories/ci/trigger_schedules.rb b/spec/factories/ci/trigger_schedules.rb
new file mode 100644
index 00000000000..2390706fa41
--- /dev/null
+++ b/spec/factories/ci/trigger_schedules.rb
@@ -0,0 +1,28 @@
+FactoryGirl.define do
+  factory :ci_trigger_schedule, class: Ci::TriggerSchedule do
+    trigger factory: :ci_trigger_for_trigger_schedule
+    cron '0 1 * * *'
+    cron_timezone Gitlab::Ci::CronParser::VALID_SYNTAX_SAMPLE_TIME_ZONE
+    ref 'master'
+    active true
+
+    after(:build) do |trigger_schedule, evaluator|
+      trigger_schedule.project ||= trigger_schedule.trigger.project
+    end
+
+    trait :nightly do
+      cron '0 1 * * *'
+      cron_timezone Gitlab::Ci::CronParser::VALID_SYNTAX_SAMPLE_TIME_ZONE
+    end
+
+    trait :weekly do
+      cron '0 1 * * 6'
+      cron_timezone Gitlab::Ci::CronParser::VALID_SYNTAX_SAMPLE_TIME_ZONE
+    end
+
+    trait :monthly do
+      cron '0 1 22 * *'
+      cron_timezone Gitlab::Ci::CronParser::VALID_SYNTAX_SAMPLE_TIME_ZONE
+    end
+  end
+end
diff --git a/spec/factories/ci/triggers.rb b/spec/factories/ci/triggers.rb
index a27b04424e5..c3a29d8bf04 100644
--- a/spec/factories/ci/triggers.rb
+++ b/spec/factories/ci/triggers.rb
@@ -1,7 +1,14 @@
 FactoryGirl.define do
   factory :ci_trigger_without_token, class: Ci::Trigger do
     factory :ci_trigger do
-      token 'token'
+      sequence(:token) { |n| "token#{n}" }
+
+      factory :ci_trigger_for_trigger_schedule do
+        token { SecureRandom.hex(15) }
+        owner factory: :user
+        project factory: :project
+        ref 'master'
+      end
     end
   end
 end
diff --git a/spec/factories/container_repositories.rb b/spec/factories/container_repositories.rb
new file mode 100644
index 00000000000..3fcad9fd4b3
--- /dev/null
+++ b/spec/factories/container_repositories.rb
@@ -0,0 +1,33 @@
+FactoryGirl.define do
+  factory :container_repository do
+    name 'test_container_image'
+    project
+
+    transient do
+      tags []
+    end
+
+    trait :root do
+      name ''
+    end
+
+    after(:build) do |repository, evaluator|
+      next if evaluator.tags.to_a.none?
+
+      allow(repository.client)
+        .to receive(:repository_tags)
+        .and_return({
+          'name' => repository.path,
+          'tags' => evaluator.tags
+        })
+
+      evaluator.tags.each do |tag|
+        allow(repository.client)
+          .to receive(:repository_tag_digest)
+          .with(repository.path, tag)
+          .and_return('sha256:4c8e63ca4cb663ce6c688cb06f1c3' \
+                      '72b088dac5b6d7ad7d49cd620d85cf72a15')
+      end
+    end
+  end
+end
diff --git a/spec/factories/merge_requests.rb b/spec/factories/merge_requests.rb
index e36fe326e1c..361f9dac191 100644
--- a/spec/factories/merge_requests.rb
+++ b/spec/factories/merge_requests.rb
@@ -44,6 +44,10 @@ FactoryGirl.define do
       state :reopened
     end
 
+    trait :locked do
+      state :locked
+    end
+
     trait :simple do
       source_branch "feature"
       target_branch "master"
diff --git a/spec/factories/notes.rb b/spec/factories/notes.rb
index fe19a404e16..93f4903119c 100644
--- a/spec/factories/notes.rb
+++ b/spec/factories/notes.rb
@@ -16,10 +16,21 @@ FactoryGirl.define do
     factory :note_on_personal_snippet,   traits: [:on_personal_snippet]
     factory :system_note,                traits: [:system]
 
-    factory :legacy_diff_note_on_commit, traits: [:on_commit, :legacy_diff_note], class: LegacyDiffNote do
+    factory :discussion_note_on_merge_request, traits: [:on_merge_request], class: DiscussionNote do
       association :project, :repository
+
+      trait :resolved do
+        resolved_at { Time.now }
+        resolved_by { create(:user) }
+      end
     end
 
+    factory :discussion_note_on_issue, traits: [:on_issue], class: DiscussionNote
+
+    factory :discussion_note_on_commit, traits: [:on_commit], class: DiscussionNote
+
+    factory :legacy_diff_note_on_commit, traits: [:on_commit, :legacy_diff_note], class: LegacyDiffNote
+
     factory :legacy_diff_note_on_merge_request, traits: [:on_merge_request, :legacy_diff_note], class: LegacyDiffNote do
       association :project, :repository
     end
@@ -29,6 +40,7 @@ FactoryGirl.define do
 
       transient do
         line_number 14
+        diff_refs { noteable.try(:diff_refs) }
       end
 
       position do
@@ -37,7 +49,7 @@ FactoryGirl.define do
           new_path: "files/ruby/popen.rb",
           old_line: nil,
           new_line: line_number,
-          diff_refs: noteable.diff_refs
+          diff_refs: diff_refs
         )
       end
 
@@ -108,5 +120,18 @@ FactoryGirl.define do
     trait :with_svg_attachment do
       attachment { fixture_file_upload(Rails.root + "spec/fixtures/unsanitized.svg", "image/svg+xml") }
     end
+
+    transient do
+      in_reply_to nil
+    end
+
+    before(:create) do |note, evaluator|
+      discussion = evaluator.in_reply_to
+      next unless discussion
+      discussion = discussion.to_discussion if discussion.is_a?(Note)
+      next unless discussion
+
+      note.assign_attributes(discussion.reply_attributes.merge(project: discussion.project))
+    end
   end
 end
diff --git a/spec/factories/protected_tags.rb b/spec/factories/protected_tags.rb
new file mode 100644
index 00000000000..d8e90ae1ee1
--- /dev/null
+++ b/spec/factories/protected_tags.rb
@@ -0,0 +1,22 @@
+FactoryGirl.define do
+  factory :protected_tag do
+    name
+    project
+
+    after(:build) do |protected_tag|
+      protected_tag.create_access_levels.new(access_level: Gitlab::Access::MASTER)
+    end
+
+    trait :developers_can_create do
+      after(:create) do |protected_tag|
+        protected_tag.create_access_levels.first.update!(access_level: Gitlab::Access::DEVELOPER)
+      end
+    end
+
+    trait :no_one_can_create do
+      after(:create) do |protected_tag|
+        protected_tag.create_access_levels.first.update!(access_level: Gitlab::Access::NO_ACCESS)
+      end
+    end
+  end
+end
diff --git a/spec/factories/sent_notifications.rb b/spec/factories/sent_notifications.rb
index 6287c40afe9..99253be5a22 100644
--- a/spec/factories/sent_notifications.rb
+++ b/spec/factories/sent_notifications.rb
@@ -2,7 +2,7 @@ FactoryGirl.define do
   factory :sent_notification do
     project factory: :empty_project
     recipient factory: :user
-    noteable factory: :issue
-    reply_key "0123456789abcdef" * 2
+    noteable { create(:issue, project: project) }
+    reply_key { SentNotification.reply_key }
   end
 end
diff --git a/spec/features/admin/admin_deploy_keys_spec.rb b/spec/features/admin/admin_deploy_keys_spec.rb
index 7ce6cce0a5c..c0b6995a84a 100644
--- a/spec/features/admin/admin_deploy_keys_spec.rb
+++ b/spec/features/admin/admin_deploy_keys_spec.rb
@@ -18,7 +18,7 @@ RSpec.describe 'admin deploy keys', type: :feature do
   describe 'create new deploy key' do
     before do
       visit admin_deploy_keys_path
-      click_link 'New Deploy Key'
+      click_link 'New deploy key'
     end
 
     it 'creates new deploy key' do
diff --git a/spec/features/admin/admin_groups_spec.rb b/spec/features/admin/admin_groups_spec.rb
index a871e370ba2..d5f595894d6 100644
--- a/spec/features/admin/admin_groups_spec.rb
+++ b/spec/features/admin/admin_groups_spec.rb
@@ -24,14 +24,23 @@ feature 'Admin Groups', feature: true do
     it 'creates new group' do
       visit admin_groups_path
 
-      click_link "New Group"
-      fill_in 'group_path', with: 'gitlab'
-      fill_in 'group_description', with: 'Group description'
+      click_link "New group"
+      path_component = 'gitlab'
+      group_name = 'GitLab group name'
+      group_description = 'Description of group for GitLab'
+      fill_in 'group_path', with: path_component
+      fill_in 'group_name', with: group_name
+      fill_in 'group_description', with: group_description
       click_button "Create group"
 
-      expect(current_path).to eq admin_group_path(Group.find_by(path: 'gitlab'))
-      expect(page).to have_content('Group: gitlab')
-      expect(page).to have_content('Group description')
+      expect(current_path).to eq admin_group_path(Group.find_by(path: path_component))
+      content = page.find('div#content-body')
+      h3_texts = content.all('h3').collect(&:text).join("\n")
+      expect(h3_texts).to match group_name
+      li_texts = content.all('li').collect(&:text).join("\n")
+      expect(li_texts).to match group_name
+      expect(li_texts).to match path_component
+      expect(li_texts).to match group_description
     end
 
     scenario 'shows the visibility level radio populated with the default value' do
@@ -39,6 +48,15 @@ feature 'Admin Groups', feature: true do
 
       expect_selected_visibility(internal)
     end
+
+    scenario 'when entered in group path, it auto filled the group name', js: true do
+      visit admin_groups_path
+      click_link "New group"
+      group_path = 'gitlab'
+      fill_in 'group_path', with: group_path
+      name_field = find('input#group_name')
+      expect(name_field.value).to eq group_path
+    end
   end
 
   describe 'show a group' do
@@ -59,6 +77,17 @@ feature 'Admin Groups', feature: true do
 
       expect_selected_visibility(group.visibility_level)
     end
+
+    scenario 'edit group path does not change group name', js: true do
+      group = create(:group, :private)
+
+      visit admin_group_edit_path(group)
+      name_field = find('input#group_name')
+      original_name = name_field.value
+      fill_in 'group_path', with: 'this-new-path'
+
+      expect(name_field.value).to eq original_name
+    end
   end
 
   describe 'add user into a group', js: true do
diff --git a/spec/features/admin/admin_hooks_spec.rb b/spec/features/admin/admin_hooks_spec.rb
index 570c374a89b..fb519a9bf12 100644
--- a/spec/features/admin/admin_hooks_spec.rb
+++ b/spec/features/admin/admin_hooks_spec.rb
@@ -33,7 +33,7 @@ describe "Admin::Hooks", feature: true do
       fill_in 'hook_url', with: url
       check 'Enable SSL verification'
 
-      expect { click_button 'Add System Hook' }.to change(SystemHook, :count).by(1)
+      expect { click_button 'Add system hook' }.to change(SystemHook, :count).by(1)
       expect(page).to have_content 'SSL Verification: enabled'
       expect(current_path).to eq(admin_hooks_path)
       expect(page).to have_content(url)
@@ -44,7 +44,7 @@ describe "Admin::Hooks", feature: true do
     before do
       WebMock.stub_request(:post, @system_hook.url)
       visit admin_hooks_path
-      click_link "Test Hook"
+      click_link "Test hook"
     end
 
     it { expect(current_path).to eq(admin_hooks_path) }
diff --git a/spec/features/admin/admin_manage_applications_spec.rb b/spec/features/admin/admin_manage_applications_spec.rb
index c2c618b5659..0079125889b 100644
--- a/spec/features/admin/admin_manage_applications_spec.rb
+++ b/spec/features/admin/admin_manage_applications_spec.rb
@@ -8,7 +8,7 @@ RSpec.describe 'admin manage applications', feature: true do
   it do
     visit admin_applications_path
 
-    click_on 'New Application'
+    click_on 'New application'
     expect(page).to have_content('New application')
 
     fill_in :doorkeeper_application_name, with: 'test'
diff --git a/spec/features/admin/admin_users_impersonation_tokens_spec.rb b/spec/features/admin/admin_users_impersonation_tokens_spec.rb
index ff23d486355..0fb4baeb71c 100644
--- a/spec/features/admin/admin_users_impersonation_tokens_spec.rb
+++ b/spec/features/admin/admin_users_impersonation_tokens_spec.rb
@@ -30,7 +30,7 @@ describe 'Admin > Users > Impersonation Tokens', feature: true, js: true do
       check "api"
       check "read_user"
 
-      expect { click_on "Create Impersonation Token" }.to change { PersonalAccessTokensFinder.new(impersonation: true).execute.count }
+      expect { click_on "Create impersonation token" }.to change { PersonalAccessTokensFinder.new(impersonation: true).execute.count }
       expect(active_impersonation_tokens).to have_text(name)
       expect(active_impersonation_tokens).to have_text('In')
       expect(active_impersonation_tokens).to have_text('api')
diff --git a/spec/features/admin/admin_users_spec.rb b/spec/features/admin/admin_users_spec.rb
index c0807b8c507..f6c3bc6a58d 100644
--- a/spec/features/admin/admin_users_spec.rb
+++ b/spec/features/admin/admin_users_spec.rb
@@ -223,7 +223,7 @@ describe "Admin::Users", feature: true do
       it "changes user entry" do
         user.reload
         expect(user.name).to eq('Big Bang')
-        expect(user.is_admin?).to be_truthy
+        expect(user.admin?).to be_truthy
         expect(user.password_expires_at).to be <= Time.now
       end
     end
diff --git a/spec/features/auto_deploy_spec.rb b/spec/features/auto_deploy_spec.rb
index 009e9c6b04c..6f36c74c911 100644
--- a/spec/features/auto_deploy_spec.rb
+++ b/spec/features/auto_deploy_spec.rb
@@ -56,7 +56,7 @@ describe 'Auto deploy' do
         click_on 'OpenShift'
       end
       wait_for_ajax
-      click_button 'Commit Changes'
+      click_button 'Commit changes'
 
       expect(page).to have_content('New Merge Request From auto-deploy into master')
     end
diff --git a/spec/features/boards/add_issues_modal_spec.rb b/spec/features/boards/add_issues_modal_spec.rb
index 1c0f97d8a1c..248c31115ad 100644
--- a/spec/features/boards/add_issues_modal_spec.rb
+++ b/spec/features/boards/add_issues_modal_spec.rb
@@ -145,7 +145,7 @@ describe 'Issue Boards add issue modal', :feature, :js do
     context 'selecing issues' do
       it 'selects single issue' do
         page.within('.add-issues-modal') do
-          first('.card').click
+          first('.card .card-number').click
 
           page.within('.nav-links') do
             expect(page).to have_content('Selected issues 1')
@@ -155,7 +155,7 @@ describe 'Issue Boards add issue modal', :feature, :js do
 
       it 'changes button text' do
         page.within('.add-issues-modal') do
-          first('.card').click
+          first('.card .card-number').click
 
           expect(first('.add-issues-footer .btn')).to have_content('Add 1 issue')
         end
@@ -163,7 +163,7 @@ describe 'Issue Boards add issue modal', :feature, :js do
 
       it 'changes button text with plural' do
         page.within('.add-issues-modal') do
-          all('.card').each do |el|
+          all('.card .card-number').each do |el|
             el.click
           end
 
@@ -173,7 +173,7 @@ describe 'Issue Boards add issue modal', :feature, :js do
 
       it 'shows only selected issues on selected tab' do
         page.within('.add-issues-modal') do
-          first('.card').click
+          first('.card .card-number').click
 
           click_link 'Selected issues'
 
@@ -203,7 +203,7 @@ describe 'Issue Boards add issue modal', :feature, :js do
 
       it 'selects all that arent already selected' do
         page.within('.add-issues-modal') do
-          first('.card').click
+          first('.card .card-number').click
 
           expect(page).to have_selector('.is-active', count: 1)
 
@@ -215,11 +215,11 @@ describe 'Issue Boards add issue modal', :feature, :js do
 
       it 'unselects from selected tab' do
         page.within('.add-issues-modal') do
-          first('.card').click
+          first('.card .card-number').click
 
           click_link 'Selected issues'
 
-          first('.card').click
+          first('.card .card-number').click
 
           expect(page).not_to have_selector('.is-active')
         end
@@ -229,7 +229,7 @@ describe 'Issue Boards add issue modal', :feature, :js do
     context 'adding issues' do
       it 'adds to board' do
         page.within('.add-issues-modal') do
-          first('.card').click
+          first('.card .card-number').click
 
           click_button 'Add 1 issue'
         end
@@ -241,7 +241,7 @@ describe 'Issue Boards add issue modal', :feature, :js do
 
       it 'adds to second list' do
         page.within('.add-issues-modal') do
-          first('.card').click
+          first('.card .card-number').click
 
           click_button planning.title
 
diff --git a/spec/features/boards/boards_spec.rb b/spec/features/boards/boards_spec.rb
index e168585534d..30ad169e30e 100644
--- a/spec/features/boards/boards_spec.rb
+++ b/spec/features/boards/boards_spec.rb
@@ -590,7 +590,7 @@ describe 'Issue Boards', feature: true, js: true do
   end
 
   def click_filter_link(link_text)
-    page.within('.filtered-search-input-container') do
+    page.within('.filtered-search-box') do
       expect(page).to have_button(link_text)
 
       click_button(link_text)
diff --git a/spec/features/boards/keyboard_shortcut_spec.rb b/spec/features/boards/keyboard_shortcut_spec.rb
index a5fc766401f..a9cc6c49f8e 100644
--- a/spec/features/boards/keyboard_shortcut_spec.rb
+++ b/spec/features/boards/keyboard_shortcut_spec.rb
@@ -14,7 +14,7 @@ describe 'Issue Boards shortcut', feature: true, js: true do
   end
 
   it 'takes user to issue board index' do
-    find('body').native.send_keys('gl')
+    find('body').native.send_keys('gb')
     expect(page).to have_selector('.boards-list')
 
     wait_for_vue_resource
diff --git a/spec/features/boards/modal_filter_spec.rb b/spec/features/boards/modal_filter_spec.rb
index e2281a7da55..4a4c13e79c8 100644
--- a/spec/features/boards/modal_filter_spec.rb
+++ b/spec/features/boards/modal_filter_spec.rb
@@ -219,7 +219,7 @@ describe 'Issue Boards add issue modal filtering', :feature, :js do
   end
 
   def click_filter_link(link_text)
-    page.within('.add-issues-modal .filtered-search-input-container') do
+    page.within('.add-issues-modal .filtered-search-box') do
       expect(page).to have_button(link_text)
 
       click_button(link_text)
diff --git a/spec/features/container_registry_spec.rb b/spec/features/container_registry_spec.rb
index 203e55a36f2..b86609e07c5 100644
--- a/spec/features/container_registry_spec.rb
+++ b/spec/features/container_registry_spec.rb
@@ -1,45 +1,61 @@
 require 'spec_helper'
 
 describe "Container Registry" do
+  let(:user) { create(:user) }
   let(:project) { create(:empty_project) }
-  let(:repository) { project.container_registry_repository }
-  let(:tag_name) { 'latest' }
-  let(:tags) { [tag_name] }
+
+  let(:container_repository) do
+    create(:container_repository, name: 'my/image')
+  end
 
   before do
-    login_as(:user)
-    project.team << [@user, :developer]
-    stub_container_registry_tags(*tags)
+    login_as(user)
+    project.add_developer(user)
     stub_container_registry_config(enabled: true)
-    allow(Auth::ContainerRegistryAuthenticationService).to receive(:full_access_token).and_return('token')
+    stub_container_registry_tags(repository: :any, tags: [])
   end
 
-  describe 'GET /:project/container_registry' do
+  context 'when there are no image repositories' do
+    scenario 'user visits container registry main page' do
+      visit_container_registry
+
+      expect(page).to have_content 'No container image repositories'
+    end
+  end
+
+  context 'when there are image repositories' do
     before do
-      visit namespace_project_container_registry_index_path(project.namespace, project)
+      stub_container_registry_tags(repository: %r{my/image}, tags: %w[latest])
+      project.container_repositories << container_repository
     end
 
-    context 'when no tags' do
-      let(:tags) { [] }
+    scenario 'user wants to see multi-level container repository' do
+      visit_container_registry
 
-      it { expect(page).to have_content('No images in Container Registry for this project') }
+      expect(page).to have_content('my/image')
     end
 
-    context 'when there are tags' do
-      it { expect(page).to have_content(tag_name) }
-      it { expect(page).to have_content('d7a513a66') }
-    end
-  end
+    scenario 'user removes entire container repository' do
+      visit_container_registry
 
-  describe 'DELETE /:project/container_registry/tag' do
-    before do
-      visit namespace_project_container_registry_index_path(project.namespace, project)
+      expect_any_instance_of(ContainerRepository)
+        .to receive(:delete_tags!).and_return(true)
+
+      click_on 'Remove repository'
     end
 
-    it do
-      expect_any_instance_of(::ContainerRegistry::Tag).to receive(:delete).and_return(true)
+    scenario 'user removes a specific tag from container repository' do
+      visit_container_registry
 
-      click_on 'Remove'
+      expect_any_instance_of(ContainerRegistry::Tag)
+        .to receive(:delete).and_return(true)
+
+      click_on 'Remove tag'
     end
   end
+
+  def visit_container_registry
+    visit namespace_project_container_registry_index_path(
+      project.namespace, project)
+  end
 end
diff --git a/spec/features/dashboard/group_spec.rb b/spec/features/dashboard/group_spec.rb
index d5f8470fab0..1d4b86ed4b4 100644
--- a/spec/features/dashboard/group_spec.rb
+++ b/spec/features/dashboard/group_spec.rb
@@ -5,16 +5,18 @@ RSpec.describe 'Dashboard Group', feature: true do
     login_as(:user)
   end
 
-  it 'creates new grpup' do
+  it 'creates new group', js: true do
     visit dashboard_groups_path
-    click_link 'New Group'
+    click_link 'New group'
+    new_path = 'Samurai'
+    new_description = 'Tokugawa Shogunate'
 
-    fill_in 'group_path', with: 'Samurai'
-    fill_in 'group_description', with: 'Tokugawa Shogunate'
+    fill_in 'group_path', with: new_path
+    fill_in 'group_description', with: new_description
     click_button 'Create group'
 
-    expect(current_path).to eq group_path(Group.find_by(name: 'Samurai'))
-    expect(page).to have_content('Samurai')
-    expect(page).to have_content('Tokugawa Shogunate')
+    expect(current_path).to eq group_path(Group.find_by(name: new_path))
+    expect(page).to have_content(new_path)
+    expect(page).to have_content(new_description)
   end
 end
diff --git a/spec/features/dashboard/issuables_counter_spec.rb b/spec/features/dashboard/issuables_counter_spec.rb
index a1718912fc6..4fca7577e74 100644
--- a/spec/features/dashboard/issuables_counter_spec.rb
+++ b/spec/features/dashboard/issuables_counter_spec.rb
@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe 'Navigation bar counter', feature: true, js: true, caching: true do
+describe 'Navigation bar counter', feature: true, caching: true do
   let(:user) { create(:user) }
   let(:project) { create(:empty_project, namespace: user.namespace) }
   let(:issue) { create(:issue, project: project) }
@@ -13,33 +13,48 @@ describe 'Navigation bar counter', feature: true, js: true, caching: true do
   end
 
   it 'reflects dashboard issues count' do
-    visit issues_dashboard_path
+    visit issues_path
 
     expect_counters('issues', '1')
 
     issue.update(assignee: nil)
-    visit issues_dashboard_path
 
-    expect_counters('issues', '1')
+    Timecop.travel(3.minutes.from_now) do
+      visit issues_path
+
+      expect_counters('issues', '0')
+    end
   end
 
   it 'reflects dashboard merge requests count' do
-    visit merge_requests_dashboard_path
+    visit merge_requests_path
 
     expect_counters('merge_requests', '1')
 
     merge_request.update(assignee: nil)
-    visit merge_requests_dashboard_path
 
-    expect_counters('merge_requests', '1')
+    Timecop.travel(3.minutes.from_now) do
+      visit merge_requests_path
+
+      expect_counters('merge_requests', '0')
+    end
+  end
+
+  def issues_path
+    issues_dashboard_path(assignee_id: user.id)
+  end
+
+  def merge_requests_path
+    merge_requests_dashboard_path(assignee_id: user.id)
   end
 
   def expect_counters(issuable_type, count)
-    dashboard_count = find('li.active')
-    find('.global-dropdown-toggle').click
+    dashboard_count = find('.nav-links li.active')
     nav_count = find(".dashboard-shortcuts-#{issuable_type}")
+    header_count = find(".header-content .#{issuable_type.tr('_', '-')}-count")
 
-    expect(nav_count).to have_content(count)
     expect(dashboard_count).to have_content(count)
+    expect(nav_count).to have_content(count)
+    expect(header_count).to have_content(count)
   end
 end
diff --git a/spec/features/dashboard/projects_spec.rb b/spec/features/dashboard/projects_spec.rb
index c4e58d14f75..f1789fc9d43 100644
--- a/spec/features/dashboard/projects_spec.rb
+++ b/spec/features/dashboard/projects_spec.rb
@@ -7,7 +7,6 @@ RSpec.describe 'Dashboard Projects', feature: true do
   before do
     project.team << [user, :developer]
     login_as user
-    visit dashboard_projects_path
   end
 
   it 'shows the project the user in a member of in the list' do
@@ -15,15 +14,19 @@ RSpec.describe 'Dashboard Projects', feature: true do
     expect(page).to have_content('awesome stuff')
   end
 
-  describe "with a pipeline" do
-    let(:pipeline) {  create(:ci_pipeline, :success, project: project, sha: project.commit.sha) }
+  describe "with a pipeline", redis: true do
+    let!(:pipeline) {  create(:ci_pipeline, project: project, sha: project.commit.sha) }
 
     before do
-      pipeline
+      # Since the cache isn't updated when a new pipeline is created
+      # we need the pipeline to advance in the pipeline since the cache was created
+      # by visiting the login page.
+      pipeline.succeed
     end
 
     it 'shows that the last pipeline passed' do
       visit dashboard_projects_path
+
       expect(page).to have_xpath("//a[@href='#{pipelines_namespace_project_commit_path(project.namespace, project, project.commit)}']")
     end
   end
diff --git a/spec/features/dashboard/shortcuts_spec.rb b/spec/features/dashboard/shortcuts_spec.rb
index 3642c0bfb5b..4c9adcabe34 100644
--- a/spec/features/dashboard/shortcuts_spec.rb
+++ b/spec/features/dashboard/shortcuts_spec.rb
@@ -1,31 +1,49 @@
 require 'spec_helper'
 
 feature 'Dashboard shortcuts', feature: true, js: true do
-  before do
-    login_as :user
-    visit dashboard_projects_path
-  end
+  context 'logged in' do
+    before do
+      login_as :user
+      visit root_dashboard_path
+    end
+
+    scenario 'Navigate to tabs' do
+      find('body').native.send_keys([:shift, 'P'])
+
+      check_page_title('Projects')
+
+      find('body').native.send_key([:shift, 'I'])
+
+      check_page_title('Issues')
 
-  scenario 'Navigate to tabs' do
-    find('body').native.send_key('g')
-    find('body').native.send_key('p')
+      find('body').native.send_key([:shift, 'M'])
+
+      check_page_title('Merge Requests')
+
+      find('body').native.send_keys([:shift, 'T'])
+
+      check_page_title('Todos')
+    end
+  end
 
-    check_page_title('Projects')
+  context 'logged out' do
+    before do
+      visit explore_root_path
+    end
 
-    find('body').native.send_key('g')
-    find('body').native.send_key('i')
+    scenario 'Navigate to tabs' do
+      find('body').native.send_keys([:shift, 'P'])
 
-    check_page_title('Issues')
+      expect(page).to have_content('No projects found')
 
-    find('body').native.send_key('g')
-    find('body').native.send_key('m')
+      find('body').native.send_keys([:shift, 'G'])
 
-    check_page_title('Merge Requests')
+      expect(page).to have_content('No public groups')
 
-    find('body').native.send_key('g')
-    find('body').native.send_key('t')
+      find('body').native.send_keys([:shift, 'S'])
 
-    check_page_title('Todos')
+      expect(page).to have_selector('.snippets-list-holder')
+    end
   end
 
   def check_page_title(title)
diff --git a/spec/features/discussion_comments/commit_spec.rb b/spec/features/discussion_comments/commit_spec.rb
new file mode 100644
index 00000000000..96e0b78f6b9
--- /dev/null
+++ b/spec/features/discussion_comments/commit_spec.rb
@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe 'Discussion Comments Merge Request', :feature, :js do
+  include RepoHelpers
+
+  let(:user) { create(:user) }
+  let(:project) { create(:project) }
+  let(:merge_request) { create(:merge_request, source_project: project) }
+
+  before do
+    project.add_master(user)
+    login_as(user)
+
+    visit namespace_project_commit_path(project.namespace, project, sample_commit.id)
+  end
+
+  it_behaves_like 'discussion comments', 'commit'
+end
diff --git a/spec/features/discussion_comments/issue_spec.rb b/spec/features/discussion_comments/issue_spec.rb
new file mode 100644
index 00000000000..ccc9efccd18
--- /dev/null
+++ b/spec/features/discussion_comments/issue_spec.rb
@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe 'Discussion Comments Issue', :feature, :js do
+  let(:user) { create(:user) }
+  let(:project) { create(:empty_project) }
+  let(:issue) { create(:issue, project: project) }
+
+  before do
+    project.add_master(user)
+    login_as(user)
+
+    visit namespace_project_issue_path(project.namespace, project, issue)
+  end
+
+  it_behaves_like 'discussion comments', 'issue'
+end
diff --git a/spec/features/discussion_comments/merge_request_spec.rb b/spec/features/discussion_comments/merge_request_spec.rb
new file mode 100644
index 00000000000..f99ebeb9cd9
--- /dev/null
+++ b/spec/features/discussion_comments/merge_request_spec.rb
@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe 'Discussion Comments Merge Request', :feature, :js do
+  let(:user) { create(:user) }
+  let(:project) { create(:project) }
+  let(:merge_request) { create(:merge_request, source_project: project) }
+
+  before do
+    project.add_master(user)
+    login_as(user)
+
+    visit namespace_project_merge_request_path(project.namespace, project, merge_request)
+  end
+
+  it_behaves_like 'discussion comments', 'merge request'
+end
diff --git a/spec/features/discussion_comments/snippets_spec.rb b/spec/features/discussion_comments/snippets_spec.rb
new file mode 100644
index 00000000000..19a306511b2
--- /dev/null
+++ b/spec/features/discussion_comments/snippets_spec.rb
@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe 'Discussion Comments Issue', :feature, :js do
+  let(:user) { create(:user) }
+  let(:project) { create(:empty_project) }
+  let(:snippet) { create(:project_snippet, :private, project: project, author: user) }
+
+  before do
+    project.add_master(user)
+    login_as(user)
+
+    visit namespace_project_snippet_path(project.namespace, project, snippet)
+  end
+
+  it_behaves_like 'discussion comments', 'snippet'
+end
diff --git a/spec/features/groups_spec.rb b/spec/features/groups_spec.rb
index 8bfe6f4d54b..3d32c47bf09 100644
--- a/spec/features/groups_spec.rb
+++ b/spec/features/groups_spec.rb
@@ -83,7 +83,7 @@ feature 'Group', feature: true do
     end
   end
 
-  describe 'create a nested group' do
+  describe 'create a nested group', js: true do
     let(:group) { create(:group, path: 'foo') }
 
     context 'as admin' do
@@ -153,7 +153,7 @@ feature 'Group', feature: true do
     end
 
     it 'removes group' do
-      click_link 'Remove Group'
+      click_link 'Remove group'
 
       expect(page).to have_content "scheduled for deletion"
     end
diff --git a/spec/features/issues/create_issue_for_discussions_in_merge_request_spec.rb b/spec/features/issues/create_issue_for_discussions_in_merge_request_spec.rb
index 572bca3de21..58f897cba3e 100644
--- a/spec/features/issues/create_issue_for_discussions_in_merge_request_spec.rb
+++ b/spec/features/issues/create_issue_for_discussions_in_merge_request_spec.rb
@@ -4,7 +4,7 @@ feature 'Resolving all open discussions in a merge request from an issue', featu
   let(:user) { create(:user) }
   let(:project) { create(:project) }
   let(:merge_request) { create(:merge_request, source_project: project) }
-  let!(:discussion) { Discussion.for_diff_notes([create(:diff_note_on_merge_request, noteable: merge_request, project: project)]).first }
+  let!(:discussion) { create(:diff_note_on_merge_request, noteable: merge_request, project: project).to_discussion }
 
   describe 'as a user with access to the project' do
     before do
diff --git a/spec/features/issues/filtered_search/dropdown_assignee_spec.rb b/spec/features/issues/filtered_search/dropdown_assignee_spec.rb
index 4dcc56a97d1..3d1a9ed1722 100644
--- a/spec/features/issues/filtered_search/dropdown_assignee_spec.rb
+++ b/spec/features/issues/filtered_search/dropdown_assignee_spec.rb
@@ -194,7 +194,7 @@ describe 'Dropdown assignee', :feature, :js do
 
       new_user = create(:user)
       project.team << [new_user, :master]
-      find('.filtered-search-input-container .clear-search').click
+      find('.filtered-search-box .clear-search').click
       filtered_search.set('assignee')
       filtered_search.send_keys(':')
 
diff --git a/spec/features/issues/filtered_search/dropdown_author_spec.rb b/spec/features/issues/filtered_search/dropdown_author_spec.rb
index 1772a120045..990e3b3e60c 100644
--- a/spec/features/issues/filtered_search/dropdown_author_spec.rb
+++ b/spec/features/issues/filtered_search/dropdown_author_spec.rb
@@ -172,7 +172,7 @@ describe 'Dropdown author', js: true, feature: true do
 
       new_user = create(:user)
       project.team << [new_user, :master]
-      find('.filtered-search-input-container .clear-search').click
+      find('.filtered-search-box .clear-search').click
       filtered_search.set('author')
       send_keys_to_filtered_search(':')
 
diff --git a/spec/features/issues/filtered_search/dropdown_hint_spec.rb b/spec/features/issues/filtered_search/dropdown_hint_spec.rb
index bc8cbe30e66..cae01f37b6b 100644
--- a/spec/features/issues/filtered_search/dropdown_hint_spec.rb
+++ b/spec/features/issues/filtered_search/dropdown_hint_spec.rb
@@ -1,6 +1,6 @@
 require 'rails_helper'
 
-describe 'Dropdown hint', js: true, feature: true do
+describe 'Dropdown hint', :js, :feature do
   include FilteredSearchHelpers
   include WaitForAjax
 
@@ -9,10 +9,6 @@ describe 'Dropdown hint', js: true, feature: true do
   let(:filtered_search) { find('.filtered-search') }
   let(:js_dropdown_hint) { '#js-dropdown-hint' }
 
-  def dropdown_hint_size
-    page.all('#js-dropdown-hint .filter-dropdown .filter-dropdown-item').size
-  end
-
   def click_hint(text)
     find('#js-dropdown-hint .filter-dropdown .filter-dropdown-item', text: text).click
   end
@@ -46,14 +42,16 @@ describe 'Dropdown hint', js: true, feature: true do
     it 'does not filter `Press Enter or click to search`' do
       filtered_search.set('randomtext')
 
-      expect(page).to have_css(js_dropdown_hint, text: 'Press Enter or click to search', visible: false)
-      expect(dropdown_hint_size).to eq(0)
+      hint_dropdown = find(js_dropdown_hint)
+
+      expect(hint_dropdown).to have_content('Press Enter or click to search')
+      expect(hint_dropdown).to have_selector('.filter-dropdown .filter-dropdown-item', count: 0)
     end
 
     it 'filters with text' do
       filtered_search.set('a')
 
-      expect(dropdown_hint_size).to eq(3)
+      expect(find(js_dropdown_hint)).to have_selector('.filter-dropdown .filter-dropdown-item', count: 3)
     end
   end
 
diff --git a/spec/features/issues/filtered_search/dropdown_label_spec.rb b/spec/features/issues/filtered_search/dropdown_label_spec.rb
index b192064b693..abe5d61e38c 100644
--- a/spec/features/issues/filtered_search/dropdown_label_spec.rb
+++ b/spec/features/issues/filtered_search/dropdown_label_spec.rb
@@ -28,12 +28,8 @@ describe 'Dropdown label', js: true, feature: true do
     filter_dropdown.find('.filter-dropdown-item', text: text).click
   end
 
-  def dropdown_label_size
-    filter_dropdown.all('.filter-dropdown-item').size
-  end
-
   def clear_search_field
-    find('.filtered-search-input-container .clear-search').click
+    find('.filtered-search-box .clear-search').click
   end
 
   before do
@@ -81,7 +77,7 @@ describe 'Dropdown label', js: true, feature: true do
       filtered_search.set('label:')
 
       expect(filter_dropdown).to have_content(bug_label.title)
-      expect(dropdown_label_size).to eq(1)
+      expect(filter_dropdown).to have_selector('.filter-dropdown-item', count: 1)
     end
   end
 
@@ -97,7 +93,8 @@ describe 'Dropdown label', js: true, feature: true do
 
       expect(filter_dropdown.find('.filter-dropdown-item', text: bug_label.title)).to be_visible
       expect(filter_dropdown.find('.filter-dropdown-item', text: uppercase_label.title)).to be_visible
-      expect(dropdown_label_size).to eq(2)
+
+      expect(filter_dropdown).to have_selector('.filter-dropdown-item', count: 2)
 
       clear_search_field
       init_label_search
@@ -106,14 +103,14 @@ describe 'Dropdown label', js: true, feature: true do
 
       expect(filter_dropdown.find('.filter-dropdown-item', text: bug_label.title)).to be_visible
       expect(filter_dropdown.find('.filter-dropdown-item', text: uppercase_label.title)).to be_visible
-      expect(dropdown_label_size).to eq(2)
+      expect(filter_dropdown).to have_selector('.filter-dropdown-item', count: 2)
     end
 
     it 'filters by multiple words with or without symbol' do
       filtered_search.send_keys('Hig')
 
       expect(filter_dropdown.find('.filter-dropdown-item', text: two_words_label.title)).to be_visible
-      expect(dropdown_label_size).to eq(1)
+      expect(filter_dropdown).to have_selector('.filter-dropdown-item', count: 1)
 
       clear_search_field
       init_label_search
@@ -121,14 +118,14 @@ describe 'Dropdown label', js: true, feature: true do
       filtered_search.send_keys('~Hig')
 
       expect(filter_dropdown.find('.filter-dropdown-item', text: two_words_label.title)).to be_visible
-      expect(dropdown_label_size).to eq(1)
+      expect(filter_dropdown).to have_selector('.filter-dropdown-item', count: 1)
     end
 
     it 'filters by multiple words containing single quotes with or without symbol' do
       filtered_search.send_keys('won\'t')
 
       expect(filter_dropdown.find('.filter-dropdown-item', text: wont_fix_single_label.title)).to be_visible
-      expect(dropdown_label_size).to eq(1)
+      expect(filter_dropdown).to have_selector('.filter-dropdown-item', count: 1)
 
       clear_search_field
       init_label_search
@@ -136,14 +133,14 @@ describe 'Dropdown label', js: true, feature: true do
       filtered_search.send_keys('~won\'t')
 
       expect(filter_dropdown.find('.filter-dropdown-item', text: wont_fix_single_label.title)).to be_visible
-      expect(dropdown_label_size).to eq(1)
+      expect(filter_dropdown).to have_selector('.filter-dropdown-item', count: 1)
     end
 
     it 'filters by multiple words containing double quotes with or without symbol' do
       filtered_search.send_keys('won"t')
 
       expect(filter_dropdown.find('.filter-dropdown-item', text: wont_fix_label.title)).to be_visible
-      expect(dropdown_label_size).to eq(1)
+      expect(filter_dropdown).to have_selector('.filter-dropdown-item', count: 1)
 
       clear_search_field
       init_label_search
@@ -151,14 +148,14 @@ describe 'Dropdown label', js: true, feature: true do
       filtered_search.send_keys('~won"t')
 
       expect(filter_dropdown.find('.filter-dropdown-item', text: wont_fix_label.title)).to be_visible
-      expect(dropdown_label_size).to eq(1)
+      expect(filter_dropdown).to have_selector('.filter-dropdown-item', count: 1)
     end
 
     it 'filters by special characters with or without symbol' do
       filtered_search.send_keys('^+')
 
       expect(filter_dropdown.find('.filter-dropdown-item', text: special_label.title)).to be_visible
-      expect(dropdown_label_size).to eq(1)
+      expect(filter_dropdown).to have_selector('.filter-dropdown-item', count: 1)
 
       clear_search_field
       init_label_search
@@ -166,7 +163,7 @@ describe 'Dropdown label', js: true, feature: true do
       filtered_search.send_keys('~^+')
 
       expect(filter_dropdown.find('.filter-dropdown-item', text: special_label.title)).to be_visible
-      expect(dropdown_label_size).to eq(1)
+      expect(filter_dropdown).to have_selector('.filter-dropdown-item', count: 1)
     end
   end
 
@@ -280,13 +277,13 @@ describe 'Dropdown label', js: true, feature: true do
       create(:label, project: project, title: 'bug-label')
       init_label_search
 
-      expect(dropdown_label_size).to eq(1)
+      expect(filter_dropdown).to have_selector('.filter-dropdown-item', count: 1)
 
       create(:label, project: project)
       clear_search_field
       init_label_search
 
-      expect(dropdown_label_size).to eq(1)
+      expect(filter_dropdown).to have_selector('.filter-dropdown-item', count: 1)
     end
   end
 end
diff --git a/spec/features/issues/filtered_search/dropdown_milestone_spec.rb b/spec/features/issues/filtered_search/dropdown_milestone_spec.rb
index ce96a420699..448259057b0 100644
--- a/spec/features/issues/filtered_search/dropdown_milestone_spec.rb
+++ b/spec/features/issues/filtered_search/dropdown_milestone_spec.rb
@@ -65,7 +65,7 @@ describe 'Dropdown milestone', :feature, :js do
     it 'should load all the milestones when opened' do
       filtered_search.set('milestone:')
 
-      expect(dropdown_milestone_size).to be > 0
+      expect(filter_dropdown).to have_selector('.filter-dropdown .filter-dropdown-item', count: 6)
     end
   end
 
@@ -84,37 +84,37 @@ describe 'Dropdown milestone', :feature, :js do
     it 'filters by name' do
       filtered_search.send_keys('v1')
 
-      expect(dropdown_milestone_size).to eq(1)
+      expect(filter_dropdown).to have_selector('.filter-dropdown .filter-dropdown-item', count: 1)
     end
 
     it 'filters by case insensitive name' do
       filtered_search.send_keys('V1')
 
-      expect(dropdown_milestone_size).to eq(1)
+      expect(filter_dropdown).to have_selector('.filter-dropdown .filter-dropdown-item', count: 1)
     end
 
     it 'filters by name with symbol' do
       filtered_search.send_keys('%v1')
 
-      expect(dropdown_milestone_size).to eq(1)
+      expect(filter_dropdown).to have_selector('.filter-dropdown .filter-dropdown-item', count: 1)
     end
 
     it 'filters by case insensitive name with symbol' do
       filtered_search.send_keys('%V1')
 
-      expect(dropdown_milestone_size).to eq(1)
+      expect(filter_dropdown).to have_selector('.filter-dropdown .filter-dropdown-item', count: 1)
     end
 
     it 'filters by special characters' do
       filtered_search.send_keys('(+')
 
-      expect(dropdown_milestone_size).to eq(1)
+      expect(filter_dropdown).to have_selector('.filter-dropdown .filter-dropdown-item', count: 1)
     end
 
     it 'filters by special characters with symbol' do
       filtered_search.send_keys('%(+')
 
-      expect(dropdown_milestone_size).to eq(1)
+      expect(filter_dropdown).to have_selector('.filter-dropdown .filter-dropdown-item', count: 1)
     end
   end
 
@@ -252,7 +252,7 @@ describe 'Dropdown milestone', :feature, :js do
       expect(initial_size).to be > 0
 
       create(:milestone, project: project)
-      find('.filtered-search-input-container .clear-search').click
+      find('.filtered-search-box .clear-search').click
       filtered_search.set('milestone:')
 
       expect(dropdown_milestone_size).to eq(initial_size)
diff --git a/spec/features/issues/filtered_search/filter_issues_spec.rb b/spec/features/issues/filtered_search/filter_issues_spec.rb
index 2f880c926e7..6f00066de4d 100644
--- a/spec/features/issues/filtered_search/filter_issues_spec.rb
+++ b/spec/features/issues/filtered_search/filter_issues_spec.rb
@@ -758,10 +758,10 @@ describe 'Filter issues', js: true, feature: true do
 
         expect_issues_list_count(2)
 
-        sort_toggle = find('.filtered-search-container .dropdown-toggle')
+        sort_toggle = find('.filtered-search-wrapper .dropdown-toggle')
         sort_toggle.click
 
-        find('.filtered-search-container .dropdown-menu li a', text: 'Oldest updated').click
+        find('.filtered-search-wrapper .dropdown-menu li a', text: 'Oldest updated').click
         wait_for_ajax
 
         expect(find('.issues-list .issue:first-of-type .issue-title-text a')).to have_content(old_issue.title)
diff --git a/spec/features/issues/filtered_search/recent_searches_spec.rb b/spec/features/issues/filtered_search/recent_searches_spec.rb
new file mode 100644
index 00000000000..f506065a242
--- /dev/null
+++ b/spec/features/issues/filtered_search/recent_searches_spec.rb
@@ -0,0 +1,92 @@
+require 'spec_helper'
+
+describe 'Recent searches', js: true, feature: true do
+  include FilteredSearchHelpers
+  include WaitForAjax
+
+  let!(:group) { create(:group) }
+  let!(:project) { create(:project, group: group) }
+  let!(:user) { create(:user) }
+
+  before do
+    Capybara.ignore_hidden_elements = false
+    project.add_master(user)
+    group.add_developer(user)
+    create(:issue, project: project)
+    login_as(user)
+
+    remove_recent_searches
+  end
+
+  after do
+    Capybara.ignore_hidden_elements = true
+  end
+
+  it 'searching adds to recent searches' do
+    visit namespace_project_issues_path(project.namespace, project)
+
+    input_filtered_search('foo', submit: true)
+    input_filtered_search('bar', submit: true)
+
+    items = all('.filtered-search-history-dropdown-item', visible: false)
+
+    expect(items.count).to eq(2)
+    expect(items[0].text).to eq('bar')
+    expect(items[1].text).to eq('foo')
+  end
+
+  it 'visiting URL with search params adds to recent searches' do
+    visit namespace_project_issues_path(project.namespace, project, label_name: 'foo', search: 'bar')
+    visit namespace_project_issues_path(project.namespace, project, label_name: 'qux', search: 'garply')
+
+    items = all('.filtered-search-history-dropdown-item', visible: false)
+
+    expect(items.count).to eq(2)
+    expect(items[0].text).to eq('label:~qux garply')
+    expect(items[1].text).to eq('label:~foo bar')
+  end
+
+  it 'saved recent searches are restored last on the list' do
+    set_recent_searches('["saved1", "saved2"]')
+
+    visit namespace_project_issues_path(project.namespace, project, search: 'foo')
+
+    items = all('.filtered-search-history-dropdown-item', visible: false)
+
+    expect(items.count).to eq(3)
+    expect(items[0].text).to eq('foo')
+    expect(items[1].text).to eq('saved1')
+    expect(items[2].text).to eq('saved2')
+  end
+
+  it 'clicking item fills search input' do
+    set_recent_searches('["foo", "bar"]')
+    visit namespace_project_issues_path(project.namespace, project)
+
+    all('.filtered-search-history-dropdown-item', visible: false)[0].trigger('click')
+    wait_for_filtered_search('foo')
+
+    expect(find('.filtered-search').value.strip).to eq('foo')
+  end
+
+  it 'clear recent searches button, clears recent searches' do
+    set_recent_searches('["foo"]')
+    visit namespace_project_issues_path(project.namespace, project)
+
+    items_before = all('.filtered-search-history-dropdown-item', visible: false)
+
+    expect(items_before.count).to eq(1)
+
+    find('.filtered-search-history-clear-button', visible: false).trigger('click')
+    items_after = all('.filtered-search-history-dropdown-item', visible: false)
+
+    expect(items_after.count).to eq(0)
+  end
+
+  it 'shows flash error when failed to parse saved history' do
+    set_recent_searches('fail')
+    visit namespace_project_issues_path(project.namespace, project)
+
+    expect(find('.flash-alert')).to have_text('An error occured while parsing recent searches')
+  end
+end
diff --git a/spec/features/issues/filtered_search/search_bar_spec.rb b/spec/features/issues/filtered_search/search_bar_spec.rb
index 59244d65eec..28137f11b92 100644
--- a/spec/features/issues/filtered_search/search_bar_spec.rb
+++ b/spec/features/issues/filtered_search/search_bar_spec.rb
@@ -26,7 +26,7 @@ describe 'Search bar', js: true, feature: true do
       filtered_search.native.send_keys(:down)
 
       page.within '#js-dropdown-hint' do
-        expect(page).to have_selector('.dropdown-active')
+        expect(page).to have_selector('.droplab-item-active')
       end
     end
 
@@ -44,7 +44,7 @@ describe 'Search bar', js: true, feature: true do
       filtered_search.set(search_text)
 
       expect(filtered_search.value).to eq(search_text)
-      find('.filtered-search-input-container .clear-search').click
+      find('.filtered-search-box .clear-search').click
 
       expect(filtered_search.value).to eq('')
     end
@@ -55,7 +55,7 @@ describe 'Search bar', js: true, feature: true do
 
     it 'hides after clicked' do
       filtered_search.set('a')
-      find('.filtered-search-input-container .clear-search').click
+      find('.filtered-search-box .clear-search').click
 
       expect(page).to have_css('.clear-search', visible: false)
     end
@@ -79,28 +79,30 @@ describe 'Search bar', js: true, feature: true do
 
       filtered_search.set('author')
 
-      expect(page.all('#js-dropdown-hint .filter-dropdown .filter-dropdown-item').size).to eq(1)
+      expect(find('#js-dropdown-hint')).to have_selector('.filter-dropdown .filter-dropdown-item', count: 1)
 
-      find('.filtered-search-input-container .clear-search').click
+      find('.filtered-search-box .clear-search').click
       filtered_search.click
 
-      expect(page.all('#js-dropdown-hint .filter-dropdown .filter-dropdown-item').size).to eq(original_size)
+      expect(find('#js-dropdown-hint')).to have_selector('.filter-dropdown .filter-dropdown-item', count: original_size)
     end
 
     it 'resets the dropdown filters' do
+      filtered_search.click
+
+      hint_offset = get_left_style(find('#js-dropdown-hint')['style'])
+
       filtered_search.set('a')
-      hint_style = page.find('#js-dropdown-hint')['style']
-      hint_offset = get_left_style(hint_style)
 
       filtered_search.set('author:')
 
-      expect(page.all('#js-dropdown-hint .filter-dropdown .filter-dropdown-item').size).to eq(0)
+      find('#js-dropdown-hint', visible: false)
 
-      find('.filtered-search-input-container .clear-search').click
+      find('.filtered-search-box .clear-search').click
       filtered_search.click
 
-      expect(page.all('#js-dropdown-hint .filter-dropdown .filter-dropdown-item').size).to be > 0
-      expect(get_left_style(page.find('#js-dropdown-hint')['style'])).to eq(hint_offset)
+      expect(find('#js-dropdown-hint')).to have_selector('.filter-dropdown .filter-dropdown-item', count: 4)
+      expect(get_left_style(find('#js-dropdown-hint')['style'])).to eq(hint_offset)
     end
   end
 end
diff --git a/spec/features/login_spec.rb b/spec/features/login_spec.rb
index f32d1f78b40..11d417c253d 100644
--- a/spec/features/login_spec.rb
+++ b/spec/features/login_spec.rb
@@ -199,52 +199,125 @@ feature 'Login', feature: true do
 
   describe 'with required two-factor authentication enabled' do
     let(:user) { create(:user) }
-    before(:each) { stub_application_setting(require_two_factor_authentication: true) }
+    #  TODO: otp_grace_period_started_at
 
-    context 'with grace period defined' do
-      before(:each) do
-        stub_application_setting(two_factor_grace_period: 48)
-        login_with(user)
-      end
+    context 'global setting' do
+      before(:each) { stub_application_setting(require_two_factor_authentication: true) }
 
-      context 'within the grace period' do
-        it 'redirects to two-factor configuration page' do
-          expect(current_path).to eq profile_two_factor_auth_path
-          expect(page).to have_content('You must enable Two-Factor Authentication for your account before')
+      context 'with grace period defined' do
+        before(:each) do
+          stub_application_setting(two_factor_grace_period: 48)
+          login_with(user)
         end
 
-        it 'allows skipping two-factor configuration', js: true do
-          expect(current_path).to eq profile_two_factor_auth_path
+        context 'within the grace period' do
+          it 'redirects to two-factor configuration page' do
+            expect(current_path).to eq profile_two_factor_auth_path
+            expect(page).to have_content('The global settings require you to enable Two-Factor Authentication for your account. You need to do this before ')
+          end
 
-          click_link 'Configure it later'
-          expect(current_path).to eq root_path
+          it 'allows skipping two-factor configuration', js: true do
+            expect(current_path).to eq profile_two_factor_auth_path
+
+            click_link 'Configure it later'
+            expect(current_path).to eq root_path
+          end
         end
-      end
 
-      context 'after the grace period' do
-        let(:user) { create(:user, otp_grace_period_started_at: 9999.hours.ago) }
+        context 'after the grace period' do
+          let(:user) { create(:user, otp_grace_period_started_at: 9999.hours.ago) }
 
-        it 'redirects to two-factor configuration page' do
-          expect(current_path).to eq profile_two_factor_auth_path
-          expect(page).to have_content('You must enable Two-Factor Authentication for your account.')
+          it 'redirects to two-factor configuration page' do
+            expect(current_path).to eq profile_two_factor_auth_path
+            expect(page).to have_content(
+              'The global settings require you to enable Two-Factor Authentication for your account.'
+            )
+          end
+
+          it 'disallows skipping two-factor configuration', js: true do
+            expect(current_path).to eq profile_two_factor_auth_path
+            expect(page).not_to have_link('Configure it later')
+          end
+        end
+      end
+
+      context 'without grace period defined' do
+        before(:each) do
+          stub_application_setting(two_factor_grace_period: 0)
+          login_with(user)
         end
 
-        it 'disallows skipping two-factor configuration', js: true do
+        it 'redirects to two-factor configuration page' do
           expect(current_path).to eq profile_two_factor_auth_path
-          expect(page).not_to have_link('Configure it later')
+          expect(page).to have_content(
+            'The global settings require you to enable Two-Factor Authentication for your account.'
+          )
         end
       end
     end
 
-    context 'without grace period defined' do
-      before(:each) do
-        stub_application_setting(two_factor_grace_period: 0)
-        login_with(user)
+    context 'group setting' do
+      before do
+        group1 = create :group, name: 'Group 1', require_two_factor_authentication: true
+        group1.add_user(user, GroupMember::DEVELOPER)
+        group2 = create :group, name: 'Group 2', require_two_factor_authentication: true
+        group2.add_user(user, GroupMember::DEVELOPER)
       end
 
-      it 'redirects to two-factor configuration page' do
-        expect(current_path).to eq profile_two_factor_auth_path
-        expect(page).to have_content('You must enable Two-Factor Authentication for your account.')
+      context 'with grace period defined' do
+        before(:each) do
+          stub_application_setting(two_factor_grace_period: 48)
+          login_with(user)
+        end
+
+        context 'within the grace period' do
+          it 'redirects to two-factor configuration page' do
+            expect(current_path).to eq profile_two_factor_auth_path
+            expect(page).to have_content(
+              'The group settings for Group 1 and Group 2 require you to enable ' \
+              'Two-Factor Authentication for your account. You need to do this ' \
+              'before ')
+          end
+
+          it 'allows skipping two-factor configuration', js: true do
+            expect(current_path).to eq profile_two_factor_auth_path
+
+            click_link 'Configure it later'
+            expect(current_path).to eq root_path
+          end
+        end
+
+        context 'after the grace period' do
+          let(:user) { create(:user, otp_grace_period_started_at: 9999.hours.ago) }
+
+          it 'redirects to two-factor configuration page' do
+            expect(current_path).to eq profile_two_factor_auth_path
+            expect(page).to have_content(
+              'The group settings for Group 1 and Group 2 require you to enable ' \
+              'Two-Factor Authentication for your account.'
+            )
+          end
+
+          it 'disallows skipping two-factor configuration', js: true do
+            expect(current_path).to eq profile_two_factor_auth_path
+            expect(page).not_to have_link('Configure it later')
+          end
+        end
+      end
+
+      context 'without grace period defined' do
+        before(:each) do
+          stub_application_setting(two_factor_grace_period: 0)
+          login_with(user)
+        end
+
+        it 'redirects to two-factor configuration page' do
+          expect(current_path).to eq profile_two_factor_auth_path
+          expect(page).to have_content(
+            'The group settings for Group 1 and Group 2 require you to enable ' \
+            'Two-Factor Authentication for your account.'
+          )
+        end
       end
     end
   end
diff --git a/spec/features/merge_requests/check_if_mergeable_with_unresolved_discussions_spec.rb b/spec/features/merge_requests/check_if_mergeable_with_unresolved_discussions_spec.rb
index 7f11db3c417..77b7ba4ac7a 100644
--- a/spec/features/merge_requests/check_if_mergeable_with_unresolved_discussions_spec.rb
+++ b/spec/features/merge_requests/check_if_mergeable_with_unresolved_discussions_spec.rb
@@ -19,7 +19,7 @@ feature 'Check if mergeable with unresolved discussions', js: true, feature: tru
       it 'does not allow to merge' do
         visit_merge_request(merge_request)
 
-        expect(page).not_to have_button 'Accept Merge Request'
+        expect(page).not_to have_button 'Accept merge request'
         expect(page).to have_content('This merge request has unresolved discussions')
       end
     end
@@ -32,7 +32,7 @@ feature 'Check if mergeable with unresolved discussions', js: true, feature: tru
       it 'allows MR to be merged' do
         visit_merge_request(merge_request)
 
-        expect(page).to have_button 'Accept Merge Request'
+        expect(page).to have_button 'Accept merge request'
       end
     end
   end
@@ -46,7 +46,7 @@ feature 'Check if mergeable with unresolved discussions', js: true, feature: tru
       it 'does not allow to merge' do
         visit_merge_request(merge_request)
 
-        expect(page).to have_button 'Accept Merge Request'
+        expect(page).to have_button 'Accept merge request'
       end
     end
 
@@ -58,7 +58,7 @@ feature 'Check if mergeable with unresolved discussions', js: true, feature: tru
       it 'allows MR to be merged' do
         visit_merge_request(merge_request)
 
-        expect(page).to have_button 'Accept Merge Request'
+        expect(page).to have_button 'Accept merge request'
       end
     end
   end
diff --git a/spec/features/merge_requests/create_new_mr_spec.rb b/spec/features/merge_requests/create_new_mr_spec.rb
index d4fe67c224f..3a4ec07b2b0 100644
--- a/spec/features/merge_requests/create_new_mr_spec.rb
+++ b/spec/features/merge_requests/create_new_mr_spec.rb
@@ -26,7 +26,7 @@ feature 'Create New Merge Request', feature: true, js: true do
   end
 
   it 'selects the target branch sha when a tag with the same name exists' do
-    visit namespace_project_merge_requests_path(project.namespace, project)
+    visit namespace_project_merge_requests_path(project.namespace, project)    
 
     click_link 'New merge request'
 
diff --git a/spec/features/merge_requests/diff_notes_avatars_spec.rb b/spec/features/merge_requests/diff_notes_avatars_spec.rb
index a6c72b0b3ac..218d95a88b8 100644
--- a/spec/features/merge_requests/diff_notes_avatars_spec.rb
+++ b/spec/features/merge_requests/diff_notes_avatars_spec.rb
@@ -164,9 +164,7 @@ feature 'Diff note avatars', feature: true, js: true do
 
       context 'multiple comments' do
         before do
-          create(:diff_note_on_merge_request, project: project, noteable: merge_request, position: position)
-          create(:diff_note_on_merge_request, project: project, noteable: merge_request, position: position)
-          create(:diff_note_on_merge_request, project: project, noteable: merge_request, position: position)
+          create_list(:diff_note_on_merge_request, 3, project: project, noteable: merge_request, in_reply_to: note)
 
           visit diffs_namespace_project_merge_request_path(project.namespace, project, merge_request, view: view)
 
diff --git a/spec/features/merge_requests/diff_notes_resolve_spec.rb b/spec/features/merge_requests/diff_notes_resolve_spec.rb
index 69164aabdb2..88d28b649a4 100644
--- a/spec/features/merge_requests/diff_notes_resolve_spec.rb
+++ b/spec/features/merge_requests/diff_notes_resolve_spec.rb
@@ -191,7 +191,7 @@ feature 'Diff notes resolve', feature: true, js: true do
 
     context 'multiple notes' do
       before do
-        create(:diff_note_on_merge_request, project: project, noteable: merge_request)
+        create(:diff_note_on_merge_request, project: project, noteable: merge_request, in_reply_to: note)
         visit_merge_request
       end
 
diff --git a/spec/features/merge_requests/discussion_spec.rb b/spec/features/merge_requests/discussion_spec.rb
new file mode 100644
index 00000000000..f59d0faa274
--- /dev/null
+++ b/spec/features/merge_requests/discussion_spec.rb
@@ -0,0 +1,51 @@
+require 'spec_helper'
+
+feature 'Merge Request Discussions', feature: true do
+  before do
+    login_as :admin
+  end
+
+  context "Diff discussions" do
+    let(:merge_request) { create(:merge_request, importing: true) }
+    let(:project) { merge_request.source_project }
+    let!(:old_merge_request_diff) { merge_request.merge_request_diffs.create(diff_refs: outdated_diff_refs) }
+    let!(:new_merge_request_diff) { merge_request.merge_request_diffs.create }
+
+    let!(:outdated_discussion) { create(:diff_note_on_merge_request, project: project, noteable: merge_request, position: outdated_position).to_discussion }
+    let!(:active_discussion) { create(:diff_note_on_merge_request, noteable: merge_request, project: project).to_discussion }
+
+    let(:outdated_position) do
+      Gitlab::Diff::Position.new(
+        old_path: "files/ruby/popen.rb",
+        new_path: "files/ruby/popen.rb",
+        old_line: nil,
+        new_line: 9,
+        diff_refs: outdated_diff_refs
+      )
+    end
+
+    let(:outdated_diff_refs) { project.commit("874797c3a73b60d2187ed6e2fcabd289ff75171e").diff_refs }
+
+    before(:each) do
+      visit namespace_project_merge_request_path(project.namespace, project, merge_request)
+    end
+
+    context 'active discussions' do
+      it 'shows a link to the diff' do
+        within(".discussion[data-discussion-id='#{active_discussion.id}']") do
+          path = diffs_namespace_project_merge_request_path(project.namespace, project, merge_request, anchor: active_discussion.line_code)
+          expect(page).to have_link('the diff', href: path)
+        end
+      end
+    end
+
+    context 'outdated discussions' do
+      it 'shows a link to the outdated diff' do
+        within(".discussion[data-discussion-id='#{outdated_discussion.id}']") do
+          path = diffs_namespace_project_merge_request_path(project.namespace, project, merge_request, diff_id: old_merge_request_diff.id, anchor: outdated_discussion.line_code)
+          expect(page).to have_link('an outdated diff', href: path)
+        end
+      end
+    end
+  end
+end
diff --git a/spec/features/merge_requests/merge_immediately_with_pipeline_spec.rb b/spec/features/merge_requests/merge_immediately_with_pipeline_spec.rb
index 79105b1ee46..497240803d4 100644
--- a/spec/features/merge_requests/merge_immediately_with_pipeline_spec.rb
+++ b/spec/features/merge_requests/merge_immediately_with_pipeline_spec.rb
@@ -32,7 +32,7 @@ feature 'Merge immediately', :feature, :js do
       page.within '.mr-widget-body' do
         find('.dropdown-toggle').click
 
-        click_link 'Merge Immediately'
+        click_link 'Merge immediately'
 
         expect(find('.js-merge-when-pipeline-succeeds-button')).to have_content('Merge in progress')
 
diff --git a/spec/features/merge_requests/merge_when_pipeline_succeeds_spec.rb b/spec/features/merge_requests/merge_when_pipeline_succeeds_spec.rb
index ed7193b9777..cd540ca113a 100644
--- a/spec/features/merge_requests/merge_when_pipeline_succeeds_spec.rb
+++ b/spec/features/merge_requests/merge_when_pipeline_succeeds_spec.rb
@@ -28,25 +28,25 @@ feature 'Merge When Pipeline Succeeds', :feature, :js do
       visit_merge_request(merge_request)
     end
 
-    it 'displays the Merge When Pipeline Succeeds button' do
-      expect(page).to have_button "Merge When Pipeline Succeeds"
+    it 'displays the Merge when pipeline succeeds button' do
+      expect(page).to have_button "Merge when pipeline succeeds"
     end
 
-    describe 'enabling Merge When Pipeline Succeeds' do
-      shared_examples 'Merge When Pipeline Succeeds activator' do
-        it 'activates the Merge When Pipeline Succeeds feature' do
-          click_button "Merge When Pipeline Succeeds"
+    describe 'enabling Merge when pipeline succeeds' do
+      shared_examples 'Merge when pipeline succeeds activator' do
+        it 'activates the Merge when pipeline succeeds feature' do
+          click_button "Merge when pipeline succeeds"
 
           expect(page).to have_content "Set by #{user.name} to be merged automatically when the pipeline succeeds."
           expect(page).to have_content "The source branch will not be removed."
-          expect(page).to have_link "Cancel Automatic Merge"
+          expect(page).to have_link "Cancel automatic merge"
           visit_merge_request(merge_request) # Needed to refresh the page
           expect(page).to have_content /enabled an automatic merge when the pipeline for \h{8} succeeds/i
         end
       end
 
       context "when enabled immediately" do
-        it_behaves_like 'Merge When Pipeline Succeeds activator'
+        it_behaves_like 'Merge when pipeline succeeds activator'
       end
 
       context 'when enabled after pipeline status changed' do
@@ -60,16 +60,16 @@ feature 'Merge When Pipeline Succeeds', :feature, :js do
           expect(page).to have_content "Pipeline ##{pipeline.id} running"
         end
 
-        it_behaves_like 'Merge When Pipeline Succeeds activator'
+        it_behaves_like 'Merge when pipeline succeeds activator'
       end
 
       context 'when enabled after it was previously canceled' do
         before do
-          click_button "Merge When Pipeline Succeeds"
-          click_link "Cancel Automatic Merge"
+          click_button "Merge when pipeline succeeds"
+          click_link "Cancel automatic merge"
         end
 
-        it_behaves_like 'Merge When Pipeline Succeeds activator'
+        it_behaves_like 'Merge when pipeline succeeds activator'
       end
 
       context 'when it was enabled and then canceled' do
@@ -83,10 +83,23 @@ feature 'Merge When Pipeline Succeeds', :feature, :js do
         end
 
         before do
-          click_link "Cancel Automatic Merge"
+          click_link "Cancel automatic merge"
         end
 
-        it_behaves_like 'Merge When Pipeline Succeeds activator'
+        it_behaves_like 'Merge when pipeline succeeds activator'
+      end
+    end
+
+    describe 'enabling Merge when pipeline succeeds via dropdown' do
+      it 'activates the Merge when pipeline succeeds feature' do
+        click_button 'Select merge moment'
+        within('.js-merge-dropdown') do
+          click_link 'Merge when pipeline succeeds'
+        end
+
+        expect(page).to have_content "Set by #{user.name} to be merged automatically when the pipeline succeeds."
+        expect(page).to have_content "The source branch will not be removed."
+        expect(page).to have_link "Cancel automatic merge"
       end
     end
   end
@@ -110,18 +123,18 @@ feature 'Merge When Pipeline Succeeds', :feature, :js do
     end
 
     it 'allows to cancel the automatic merge' do
-      click_link "Cancel Automatic Merge"
+      click_link "Cancel automatic merge"
 
-      expect(page).to have_button "Merge When Pipeline Succeeds"
+      expect(page).to have_button "Merge when pipeline succeeds"
 
       visit_merge_request(merge_request) # refresh the page
       expect(page).to have_content "canceled the automatic merge"
     end
 
     it "allows the user to remove the source branch" do
-      expect(page).to have_link "Remove Source Branch When Merged"
+      expect(page).to have_link "Remove source branch when merged"
 
-      click_link "Remove Source Branch When Merged"
+      click_link "Remove source branch when merged"
       expect(page).to have_content "The source branch will be removed"
     end
 
@@ -141,7 +154,7 @@ feature 'Merge When Pipeline Succeeds', :feature, :js do
     it "does not allow to enable merge when pipeline succeeds" do
       visit_merge_request(merge_request)
 
-      expect(page).not_to have_link 'Merge When Pipeline Succeeds'
+      expect(page).not_to have_link 'Merge when pipeline succeeds'
     end
   end
 
diff --git a/spec/features/merge_requests/only_allow_merge_if_build_succeeds_spec.rb b/spec/features/merge_requests/only_allow_merge_if_build_succeeds_spec.rb
index 447764566e0..4a590e3bf68 100644
--- a/spec/features/merge_requests/only_allow_merge_if_build_succeeds_spec.rb
+++ b/spec/features/merge_requests/only_allow_merge_if_build_succeeds_spec.rb
@@ -14,7 +14,7 @@ feature 'Only allow merge requests to be merged if the pipeline succeeds', featu
     it 'allows MR to be merged' do
       visit_merge_request(merge_request)
 
-      expect(page).to have_button 'Accept Merge Request'
+      expect(page).to have_button 'Accept merge request'
     end
   end
 
@@ -38,8 +38,8 @@ feature 'Only allow merge requests to be merged if the pipeline succeeds', featu
         it 'does not allow to merge immediately' do
           visit_merge_request(merge_request)
 
-          expect(page).to have_button 'Merge When Pipeline Succeeds'
-          expect(page).not_to have_button 'Select Merge Moment'
+          expect(page).to have_button 'Merge when pipeline succeeds'
+          expect(page).not_to have_button 'Select merge moment'
         end
       end
 
@@ -49,7 +49,7 @@ feature 'Only allow merge requests to be merged if the pipeline succeeds', featu
         it 'does not allow MR to be merged' do
           visit_merge_request(merge_request)
 
-          expect(page).not_to have_button 'Accept Merge Request'
+          expect(page).not_to have_button 'Accept merge request'
           expect(page).to have_content('Please retry the job or push a new commit to fix the failure.')
         end
       end
@@ -60,7 +60,7 @@ feature 'Only allow merge requests to be merged if the pipeline succeeds', featu
         it 'does not allow MR to be merged' do
           visit_merge_request(merge_request)
 
-          expect(page).not_to have_button 'Accept Merge Request'
+          expect(page).not_to have_button 'Accept merge request'
           expect(page).to have_content('Please retry the job or push a new commit to fix the failure.')
         end
       end
@@ -71,7 +71,7 @@ feature 'Only allow merge requests to be merged if the pipeline succeeds', featu
         it 'allows MR to be merged' do
           visit_merge_request(merge_request)
 
-          expect(page).to have_button 'Accept Merge Request'
+          expect(page).to have_button 'Accept merge request'
         end
       end
 
@@ -81,7 +81,7 @@ feature 'Only allow merge requests to be merged if the pipeline succeeds', featu
         it 'allows MR to be merged' do
           visit_merge_request(merge_request)
 
-          expect(page).to have_button 'Accept Merge Request'
+          expect(page).to have_button 'Accept merge request'
         end
       end
     end
@@ -97,10 +97,10 @@ feature 'Only allow merge requests to be merged if the pipeline succeeds', featu
         it 'allows MR to be merged immediately', js: true do
           visit_merge_request(merge_request)
 
-          expect(page).to have_button 'Merge When Pipeline Succeeds'
+          expect(page).to have_button 'Merge when pipeline succeeds'
 
-          click_button 'Select Merge Moment'
-          expect(page).to have_content 'Merge Immediately'
+          click_button 'Select merge moment'
+          expect(page).to have_content 'Merge immediately'
         end
       end
 
@@ -110,7 +110,7 @@ feature 'Only allow merge requests to be merged if the pipeline succeeds', featu
         it 'allows MR to be merged' do
           visit_merge_request(merge_request)
 
-          expect(page).to have_button 'Accept Merge Request'
+          expect(page).to have_button 'Accept merge request'
         end
       end
 
@@ -120,7 +120,7 @@ feature 'Only allow merge requests to be merged if the pipeline succeeds', featu
         it 'allows MR to be merged' do
           visit_merge_request(merge_request)
 
-          expect(page).to have_button 'Accept Merge Request'
+          expect(page).to have_button 'Accept merge request'
         end
       end
     end
diff --git a/spec/features/merge_requests/reset_filters_spec.rb b/spec/features/merge_requests/reset_filters_spec.rb
index 14511707af4..df5943f9136 100644
--- a/spec/features/merge_requests/reset_filters_spec.rb
+++ b/spec/features/merge_requests/reset_filters_spec.rb
@@ -14,7 +14,7 @@ feature 'Merge requests filter clear button', feature: true, js: true do
   let!(:mr2) { create(:merge_request, title: "Bugfix1", source_project: project, target_project: project, source_branch: "Bugfix1") }
 
   let(:merge_request_css) { '.merge-request' }
-  let(:clear_search_css) { '.filtered-search-input-container .clear-search' }
+  let(:clear_search_css) { '.filtered-search-box .clear-search' }
 
   before do
     mr2.labels << bug
diff --git a/spec/features/merge_requests/merge_request_versions_spec.rb b/spec/features/merge_requests/versions_spec.rb
index 04e85ed3f73..68a68f5d3f3 100644
--- a/spec/features/merge_requests/merge_request_versions_spec.rb
+++ b/spec/features/merge_requests/versions_spec.rb
@@ -36,8 +36,23 @@ feature 'Merge Request versions', js: true, feature: true do
       expect(page).to have_content '5 changed files'
     end
 
-    it 'show the message about disabled comments' do
-      expect(page).to have_content 'Comments are disabled'
+    it 'show the message about disabled comment creation' do
+      expect(page).to have_content 'comment creation is disabled'
+    end
+
+    it 'shows comments that were last relevant at that version' do
+      position = Gitlab::Diff::Position.new(
+        old_path: ".gitmodules",
+        new_path: ".gitmodules",
+        old_line: nil,
+        new_line: 4,
+        diff_refs: merge_request_diff1.diff_refs
+      )
+      outdated_diff_note = create(:diff_note_on_merge_request, project: project, noteable: merge_request, position: position)
+      outdated_diff_note.position = outdated_diff_note.original_position
+      outdated_diff_note.save!
+
+      expect(page).to have_css(".diffs .notes[data-discussion-id='#{outdated_diff_note.discussion_id}']")
     end
   end
 
diff --git a/spec/features/merge_requests/widget_spec.rb b/spec/features/merge_requests/widget_spec.rb
index c2db7d8da3c..a62c5435748 100644
--- a/spec/features/merge_requests/widget_spec.rb
+++ b/spec/features/merge_requests/widget_spec.rb
@@ -145,7 +145,7 @@ describe 'Merge request', :feature, :js do
     before do
       allow_any_instance_of(Repository).to receive(:merge).and_return(false)
       visit namespace_project_merge_request_path(project.namespace, project, merge_request)
-      click_button 'Accept Merge Request'
+      click_button 'Accept merge request'
       wait_for_ajax
     end
 
diff --git a/spec/features/notes_on_merge_requests_spec.rb b/spec/features/notes_on_merge_requests_spec.rb
index fab2d532e06..783f2e93909 100644
--- a/spec/features/notes_on_merge_requests_spec.rb
+++ b/spec/features/notes_on_merge_requests_spec.rb
@@ -25,7 +25,7 @@ describe 'Comments', feature: true do
     describe 'the note form' do
       it 'is valid' do
         is_expected.to have_css('.js-main-target-form', visible: true, count: 1)
-        expect(find('.js-main-target-form input[type=submit]').value).
+        expect(find('.js-main-target-form .js-comment-button').value).
           to eq('Comment')
         page.within('.js-main-target-form') do
           expect(page).not_to have_link('Cancel')
diff --git a/spec/features/profiles/personal_access_tokens_spec.rb b/spec/features/profiles/personal_access_tokens_spec.rb
index 99fba594651..27a20e78a43 100644
--- a/spec/features/profiles/personal_access_tokens_spec.rb
+++ b/spec/features/profiles/personal_access_tokens_spec.rb
@@ -41,7 +41,7 @@ describe 'Profile > Personal Access Tokens', feature: true, js: true do
       check "api"
       check "read_user"
 
-      click_on "Create Personal Access Token"
+      click_on "Create personal access token"
       expect(active_personal_access_tokens).to have_text(name)
       expect(active_personal_access_tokens).to have_text('In')
       expect(active_personal_access_tokens).to have_text('api')
@@ -54,7 +54,7 @@ describe 'Profile > Personal Access Tokens', feature: true, js: true do
         visit profile_personal_access_tokens_path
         fill_in "Name", with: 'My PAT'
 
-        expect { click_on "Create Personal Access Token" }.not_to change { PersonalAccessToken.count }
+        expect { click_on "Create personal access token" }.not_to change { PersonalAccessToken.count }
         expect(page).to have_content("Name cannot be nil")
       end
     end
diff --git a/spec/features/projects/blobs/blob_show_spec.rb b/spec/features/projects/blobs/blob_show_spec.rb
new file mode 100644
index 00000000000..01cd268ffe8
--- /dev/null
+++ b/spec/features/projects/blobs/blob_show_spec.rb
@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+feature 'File blob', feature: true do
+  include WaitForAjax
+  include TreeHelper
+
+  let(:project) { create(:project, :public, :test_repo) }
+  let(:merge_request) { create(:merge_request, source_project: project, source_branch: 'feature', target_branch: 'master') }
+  let(:branch) { 'master' }
+  let(:file_path) { project.repository.ls_files(project.repository.root_ref)[1] }
+
+  context 'anonymous' do
+    context 'from blob file path' do
+      before do
+        visit namespace_project_blob_path(project.namespace, project, tree_join(branch, file_path))
+      end
+
+      it 'updates content' do
+        expect(page).to have_link  'Edit'
+      end
+    end
+  end
+end
diff --git a/spec/features/projects/blobs/edit_spec.rb b/spec/features/projects/blobs/edit_spec.rb
index a820d07ab3b..aab5a72678e 100644
--- a/spec/features/projects/blobs/edit_spec.rb
+++ b/spec/features/projects/blobs/edit_spec.rb
@@ -2,44 +2,135 @@ require 'spec_helper'
 
 feature 'Editing file blob', feature: true, js: true do
   include WaitForAjax
+  include TreeHelper
 
-  given(:user) { create(:user) }
-  given(:role) { :developer }
-  given(:merge_request) { create(:merge_request, source_branch: 'feature', target_branch: 'master') }
-  given(:project) { merge_request.target_project }
+  let(:project) { create(:project, :public, :test_repo) }
+  let(:merge_request) { create(:merge_request, source_project: project, source_branch: 'feature', target_branch: 'master') }
+  let(:branch) { 'master' }
+  let(:file_path) { project.repository.ls_files(project.repository.root_ref)[1] }
 
-  background do
-    login_as(user)
-    project.team << [user, role]
-  end
-
-  def edit_and_commit
-    wait_for_ajax
-    first('.file-actions').click_link 'Edit'
-    execute_script('ace.edit("editor").setValue("class NextFeature\nend\n")')
-    click_button 'Commit Changes'
-  end
+  context 'as a developer' do
+    let(:user) { create(:user) }
+    let(:role) { :developer }
 
-  context 'from MR diff' do
     before do
-      visit diffs_namespace_project_merge_request_path(project.namespace, project, merge_request)
-      edit_and_commit
+      project.team << [user, role]
+      login_as(user)
+    end
+
+    def edit_and_commit
+      wait_for_ajax
+      find('.js-edit-blob').click
+      execute_script('ace.edit("editor").setValue("class NextFeature\nend\n")')
+      click_button 'Commit changes'
+    end
+
+    context 'from MR diff' do
+      before do
+        visit diffs_namespace_project_merge_request_path(project.namespace, project, merge_request)
+        edit_and_commit
+      end
+
+      it 'returns me to the mr' do
+        expect(page).to have_content(merge_request.title)
+      end
     end
 
-    scenario 'returns me to the mr' do
-      expect(page).to have_content(merge_request.title)
+    context 'from blob file path' do
+      before do
+        visit namespace_project_blob_path(project.namespace, project, tree_join(branch, file_path))
+        edit_and_commit
+      end
+
+      it 'updates content' do
+        expect(page).to have_content 'successfully committed'
+        expect(page).to have_content 'NextFeature'
+      end
     end
   end
 
-  context 'from blob file path' do
-    before do
-      visit namespace_project_blob_path(project.namespace, project, '/feature/files/ruby/feature.rb')
-      edit_and_commit
+  context 'visit blob edit' do
+    context 'redirects to sign in and returns' do
+      context 'as developer' do
+        let(:user) { create(:user) }
+
+        before do
+          project.team << [user, :developer]
+          visit namespace_project_edit_blob_path(project.namespace, project, tree_join(branch, file_path))
+        end
+
+        it 'redirects to sign in and returns' do
+          expect(page).to have_current_path(new_user_session_path)
+
+          login_as(user)
+
+          expect(page).to have_current_path(namespace_project_edit_blob_path(project.namespace, project, tree_join(branch, file_path)))
+        end
+      end
+
+      context 'as guest' do
+        let(:user) { create(:user) }
+
+        before do
+          visit namespace_project_edit_blob_path(project.namespace, project, tree_join(branch, file_path))
+        end
+
+        it 'redirects to sign in and returns' do
+          expect(page).to have_current_path(new_user_session_path)
+
+          login_as(user)
+
+          expect(page).to have_current_path(namespace_project_blob_path(project.namespace, project, tree_join(branch, file_path)))
+        end
+      end
+    end
+
+    context 'as developer' do
+      let(:user) { create(:user) }
+      let(:protected_branch) { 'protected-branch' }
+
+      before do
+        project.team << [user, :developer]
+        project.repository.add_branch(user, protected_branch, 'master')
+        create(:protected_branch, project: project, name: protected_branch)
+        login_as(user)
+      end
+
+      context 'on some branch' do
+        before do
+          visit namespace_project_edit_blob_path(project.namespace, project, tree_join(branch, file_path))
+        end
+
+        it 'shows blob editor with same branch' do
+          expect(page).to have_current_path(namespace_project_edit_blob_path(project.namespace, project, tree_join(branch, file_path)))
+          expect(find('.js-target-branch .dropdown-toggle-text').text).to eq(branch)
+        end
+      end
+
+      context 'with protected branch' do
+        before do
+          visit namespace_project_edit_blob_path(project.namespace, project, tree_join(protected_branch, file_path))
+        end
+
+        it 'shows blob editor with patch branch' do
+          expect(find('.js-target-branch .dropdown-toggle-text').text).to eq('patch-1')
+        end
+      end
     end
 
-    scenario 'updates content' do
-      expect(page).to have_content 'successfully committed'
-      expect(page).to have_content 'NextFeature'
+    context 'as master' do
+      let(:user) { create(:user) }
+
+      before do
+        project.team << [user, :master]
+        login_as(user)
+        visit namespace_project_edit_blob_path(project.namespace, project, tree_join(branch, file_path))
+      end
+
+      it 'shows blob editor with same branch' do
+        expect(page).to have_current_path(namespace_project_edit_blob_path(project.namespace, project, tree_join(branch, file_path)))
+        expect(find('.js-target-branch .dropdown-toggle-text').text).to eq(branch)
+      end
     end
   end
 end
diff --git a/spec/features/projects/blobs/user_create_spec.rb b/spec/features/projects/blobs/user_create_spec.rb
index d214a531138..fa1a753afcb 100644
--- a/spec/features/projects/blobs/user_create_spec.rb
+++ b/spec/features/projects/blobs/user_create_spec.rb
@@ -22,7 +22,7 @@ feature 'New blob creation', feature: true, js: true do
   end
 
   def commit_file
-    click_button 'Commit Changes'
+    click_button 'Commit changes'
   end
 
   context 'with default target branch' do
diff --git a/spec/features/projects/builds_spec.rb b/spec/features/projects/builds_spec.rb
index 2116721b224..ab10434e10c 100644
--- a/spec/features/projects/builds_spec.rb
+++ b/spec/features/projects/builds_spec.rb
@@ -205,21 +205,13 @@ feature 'Builds', :feature do
         it 'loads job trace' do
           expect(page).to have_content 'BUILD TRACE'
 
-          build.append_trace(' and more trace', 11)
+          build.trace.write do |stream|
+            stream.append(' and more trace', 11)
+          end
 
           expect(page).to have_content 'BUILD TRACE and more trace'
         end
       end
-
-      context 'when build does not have an initial trace' do
-        let(:build) { create(:ci_build, pipeline: pipeline) }
-
-        it 'loads new trace' do
-          build.append_trace('build trace', 0)
-
-          expect(page).to have_content 'build trace'
-        end
-      end
     end
 
     feature 'Variables' do
@@ -390,7 +382,7 @@ feature 'Builds', :feature do
         it 'sends the right headers' do
           expect(page.status_code).to eq(200)
           expect(page.response_headers['Content-Type']).to eq('text/plain; charset=utf-8')
-          expect(page.response_headers['X-Sendfile']).to eq(build.path_to_trace)
+          expect(page.response_headers['X-Sendfile']).to eq(build.trace.send(:current_path))
         end
       end
 
@@ -409,43 +401,24 @@ feature 'Builds', :feature do
 
     context 'storage form' do
       let(:existing_file) { Tempfile.new('existing-trace-file').path }
-      let(:non_existing_file) do
-        file = Tempfile.new('non-existing-trace-file')
-        path = file.path
-        file.unlink
-        path
-      end
 
-      context 'when build has trace in file' do
-        before do
-          Capybara.current_session.driver.header('X-Sendfile-Type', 'X-Sendfile')
-          build.run!
-          visit namespace_project_build_path(project.namespace, project, build)
+      before do
+        Capybara.current_session.driver.header('X-Sendfile-Type', 'X-Sendfile')
 
-          allow_any_instance_of(Project).to receive(:ci_id).and_return(nil)
-          allow_any_instance_of(Ci::Build).to receive(:path_to_trace).and_return(existing_file)
-          allow_any_instance_of(Ci::Build).to receive(:old_path_to_trace).and_return(non_existing_file)
+        build.run!
 
-          page.within('.js-build-sidebar') { click_link 'Raw' }
-        end
+        allow_any_instance_of(Gitlab::Ci::Trace).to receive(:paths)
+          .and_return(paths)
 
-        it 'sends the right headers' do
-          expect(page.status_code).to eq(200)
-          expect(page.response_headers['Content-Type']).to eq('text/plain; charset=utf-8')
-          expect(page.response_headers['X-Sendfile']).to eq(existing_file)
-        end
+        visit namespace_project_build_path(project.namespace, project, build)
       end
 
-      context 'when build has trace in old file' do
-        before do
-          Capybara.current_session.driver.header('X-Sendfile-Type', 'X-Sendfile')
-          build.run!
-          visit namespace_project_build_path(project.namespace, project, build)
-
-          allow_any_instance_of(Project).to receive(:ci_id).and_return(999)
-          allow_any_instance_of(Ci::Build).to receive(:path_to_trace).and_return(non_existing_file)
-          allow_any_instance_of(Ci::Build).to receive(:old_path_to_trace).and_return(existing_file)
+      context 'when build has trace in file' do
+        let(:paths) do
+          [existing_file]
+        end
 
+        before do
           page.within('.js-build-sidebar') { click_link 'Raw' }
         end
 
@@ -457,20 +430,10 @@ feature 'Builds', :feature do
       end
 
       context 'when build has trace in DB' do
-        before do
-          Capybara.current_session.driver.header('X-Sendfile-Type', 'X-Sendfile')
-          build.run!
-          visit namespace_project_build_path(project.namespace, project, build)
-
-          allow_any_instance_of(Project).to receive(:ci_id).and_return(nil)
-          allow_any_instance_of(Ci::Build).to receive(:path_to_trace).and_return(non_existing_file)
-          allow_any_instance_of(Ci::Build).to receive(:old_path_to_trace).and_return(non_existing_file)
-
-          page.within('.js-build-sidebar') { click_link 'Raw' }
-        end
+        let(:paths) { [] }
 
         it 'sends the right headers' do
-          expect(page.status_code).to eq(404)
+          expect(page.status_code).not_to have_link('Raw')
         end
       end
     end
diff --git a/spec/features/projects/files/creating_a_file_spec.rb b/spec/features/projects/files/creating_a_file_spec.rb
index ae448706130..5d7bd3dc4ce 100644
--- a/spec/features/projects/files/creating_a_file_spec.rb
+++ b/spec/features/projects/files/creating_a_file_spec.rb
@@ -19,7 +19,7 @@ feature 'User wants to create a file', feature: true do
     file_content = find('#file-content')
     file_content.set options[:file_content] || 'Some content'
 
-    click_button 'Commit Changes'
+    click_button 'Commit changes'
   end
 
   scenario 'file name contains Chinese characters' do
diff --git a/spec/features/projects/files/editing_a_file_spec.rb b/spec/features/projects/files/editing_a_file_spec.rb
index 36a80d7575d..3e544316f28 100644
--- a/spec/features/projects/files/editing_a_file_spec.rb
+++ b/spec/features/projects/files/editing_a_file_spec.rb
@@ -27,7 +27,7 @@ feature 'User wants to edit a file', feature: true do
   scenario 'file has been updated since the user opened the edit page' do
     Files::UpdateService.new(project, user, commit_params).execute
 
-    click_button 'Commit Changes'
+    click_button 'Commit changes'
 
     expect(page).to have_content 'Someone edited the file the same time you did.'
   end
diff --git a/spec/features/projects/files/project_owner_creates_license_file_spec.rb b/spec/features/projects/files/project_owner_creates_license_file_spec.rb
index 6b281e6d21d..8ff0f5898ec 100644
--- a/spec/features/projects/files/project_owner_creates_license_file_spec.rb
+++ b/spec/features/projects/files/project_owner_creates_license_file_spec.rb
@@ -29,7 +29,7 @@ feature 'project owner creates a license file', feature: true, js: true do
     expect(file_content).to have_content("Copyright (c) #{Time.now.year} #{project.namespace.human_name}")
 
     fill_in :commit_message, with: 'Add a LICENSE file', visible: true
-    click_button 'Commit Changes'
+    click_button 'Commit changes'
 
     expect(current_path).to eq(
       namespace_project_blob_path(project.namespace, project, 'master/LICENSE'))
@@ -53,7 +53,7 @@ feature 'project owner creates a license file', feature: true, js: true do
     expect(file_content).to have_content("Copyright (c) #{Time.now.year} #{project.namespace.human_name}")
 
     fill_in :commit_message, with: 'Add a LICENSE file', visible: true
-    click_button 'Commit Changes'
+    click_button 'Commit changes'
 
     expect(current_path).to eq(
       namespace_project_blob_path(project.namespace, project, 'master/LICENSE'))
@@ -63,7 +63,7 @@ feature 'project owner creates a license file', feature: true, js: true do
 
   def select_template(template)
     page.within('.js-license-selector-wrap') do
-      click_button 'Apply a License template'
+      click_button 'Apply a license template'
       click_link template
       wait_for_ajax
     end
diff --git a/spec/features/projects/files/project_owner_sees_link_to_create_license_file_in_empty_project_spec.rb b/spec/features/projects/files/project_owner_sees_link_to_create_license_file_in_empty_project_spec.rb
index 87322ac2584..1a1910455a1 100644
--- a/spec/features/projects/files/project_owner_sees_link_to_create_license_file_in_empty_project_spec.rb
+++ b/spec/features/projects/files/project_owner_sees_link_to_create_license_file_in_empty_project_spec.rb
@@ -30,7 +30,7 @@ feature 'project owner sees a link to create a license file in empty project', f
     fill_in :commit_message, with: 'Add a LICENSE file', visible: true
     # Remove pre-receive hook so we can push without auth
     FileUtils.rm_f(File.join(project.repository.path, 'hooks', 'pre-receive'))
-    click_button 'Commit Changes'
+    click_button 'Commit changes'
 
     expect(current_path).to eq(
       namespace_project_blob_path(project.namespace, project, 'master/LICENSE'))
@@ -40,7 +40,7 @@ feature 'project owner sees a link to create a license file in empty project', f
 
   def select_template(template)
     page.within('.js-license-selector-wrap') do
-      click_button 'Apply a License template'
+      click_button 'Apply a license template'
       click_link template
       wait_for_ajax
     end
diff --git a/spec/features/projects/files/template_type_dropdown_spec.rb b/spec/features/projects/files/template_type_dropdown_spec.rb
index 5ee5e5b4c4e..9fcf12e6cb9 100644
--- a/spec/features/projects/files/template_type_dropdown_spec.rb
+++ b/spec/features/projects/files/template_type_dropdown_spec.rb
@@ -48,7 +48,7 @@ feature 'Template type dropdown selector', js: true do
 
     context 'user previews changes' do
       before do
-        click_link 'Preview Changes'
+        click_link 'Preview changes'
       end
 
       scenario 'type selector is hidden and shown correctly' do
@@ -102,7 +102,7 @@ def check_type_selector_display(is_visible)
 end
 
 def try_selecting_all_types
-  try_selecting_template_type('LICENSE', 'Apply a License template')
+  try_selecting_template_type('LICENSE', 'Apply a license template')
   try_selecting_template_type('Dockerfile', 'Apply a Dockerfile template')
   try_selecting_template_type('.gitlab-ci.yml', 'Apply a GitLab CI Yaml template')
   try_selecting_template_type('.gitignore', 'Apply a .gitignore template')
@@ -130,6 +130,6 @@ end
 
 def create_and_edit_file(file_name)
   visit namespace_project_new_blob_path(project.namespace, project, 'master', file_name: file_name)
-  click_button "Commit Changes"
+  click_button "Commit changes"
   visit namespace_project_edit_blob_path(project.namespace, project, File.join(project.default_branch, file_name))
 end
diff --git a/spec/features/projects/files/undo_template_spec.rb b/spec/features/projects/files/undo_template_spec.rb
index 5479ea34610..c51851d3f94 100644
--- a/spec/features/projects/files/undo_template_spec.rb
+++ b/spec/features/projects/files/undo_template_spec.rb
@@ -17,7 +17,7 @@ feature 'Template Undo Button', js: true do
     end
     
     scenario 'reverts template application' do
-      try_template_undo('http://www.apache.org/licenses/', 'Apply a License template')
+      try_template_undo('http://www.apache.org/licenses/', 'Apply a license template')
     end
   end
   
@@ -29,7 +29,7 @@ feature 'Template Undo Button', js: true do
     end
 
     scenario 'reverts template application' do
-      try_template_undo('http://www.apache.org/licenses/', 'Apply a License template')
+      try_template_undo('http://www.apache.org/licenses/', 'Apply a license template')
     end
   end
 end
diff --git a/spec/features/projects/merge_request_button_spec.rb b/spec/features/projects/merge_request_button_spec.rb
index b6728960fb8..05f3162f13c 100644
--- a/spec/features/projects/merge_request_button_spec.rb
+++ b/spec/features/projects/merge_request_button_spec.rb
@@ -1,13 +1,13 @@
 require 'spec_helper'
 
 feature 'Merge Request button', feature: true do
-  shared_examples 'Merge Request button only shown when allowed' do
+  shared_examples 'Merge request button only shown when allowed' do
     let(:user) { create(:user) }
     let(:project) { create(:project, :public) }
     let(:forked_project) { create(:project, :public, forked_from_project: project) }
 
     context 'not logged in' do
-      it 'does not show Create Merge Request button' do
+      it 'does not show Create merge request button' do
         visit url
 
         within("#content-body") do
@@ -22,7 +22,7 @@ feature 'Merge Request button', feature: true do
         project.team << [user, :developer]
       end
 
-      it 'shows Create Merge Request button' do
+      it 'shows Create merge request button' do
         href = new_namespace_project_merge_request_path(project.namespace,
                                                         project,
                                                         merge_request: { source_branch: 'feature',
@@ -40,7 +40,7 @@ feature 'Merge Request button', feature: true do
           project.project_feature.update!(merge_requests_access_level: ProjectFeature::DISABLED)
         end
 
-        it 'does not show Create Merge Request button' do
+        it 'does not show Create merge request button' do
           visit url
 
           within("#content-body") do
@@ -55,7 +55,7 @@ feature 'Merge Request button', feature: true do
         login_as(user)
       end
 
-      it 'does not show Create Merge Request button' do
+      it 'does not show Create merge request button' do
         visit url
 
         within("#content-body") do
@@ -66,7 +66,7 @@ feature 'Merge Request button', feature: true do
       context 'on own fork of project' do
         let(:user) { forked_project.owner }
 
-        it 'shows Create Merge Request button' do
+        it 'shows Create merge request button' do
           href = new_namespace_project_merge_request_path(forked_project.namespace,
                                                           forked_project,
                                                           merge_request: { source_branch: 'feature',
@@ -83,24 +83,24 @@ feature 'Merge Request button', feature: true do
   end
 
   context 'on branches page' do
-    it_behaves_like 'Merge Request button only shown when allowed' do
-      let(:label) { 'Merge Request' }
+    it_behaves_like 'Merge request button only shown when allowed' do
+      let(:label) { 'Merge request' }
       let(:url) { namespace_project_branches_path(project.namespace, project) }
       let(:fork_url) { namespace_project_branches_path(forked_project.namespace, forked_project) }
     end
   end
 
   context 'on compare page' do
-    it_behaves_like 'Merge Request button only shown when allowed' do
-      let(:label) { 'Create Merge Request' }
+    it_behaves_like 'Merge request button only shown when allowed' do
+      let(:label) { 'Create merge request' }
       let(:url) { namespace_project_compare_path(project.namespace, project, from: 'master', to: 'feature') }
       let(:fork_url) { namespace_project_compare_path(forked_project.namespace, forked_project, from: 'master', to: 'feature') }
     end
   end
 
   context 'on commits page' do
-    it_behaves_like 'Merge Request button only shown when allowed' do
-      let(:label) { 'Create Merge Request' }
+    it_behaves_like 'Merge request button only shown when allowed' do
+      let(:label) { 'Create merge request' }
       let(:url) { namespace_project_commits_path(project.namespace, project, 'feature') }
       let(:fork_url) { namespace_project_commits_path(forked_project.namespace, forked_project, 'feature') }
     end
diff --git a/spec/features/projects/settings/pipelines_settings_spec.rb b/spec/features/projects/settings/pipelines_settings_spec.rb
index 76cb240ea98..035c57eaa47 100644
--- a/spec/features/projects/settings/pipelines_settings_spec.rb
+++ b/spec/features/projects/settings/pipelines_settings_spec.rb
@@ -32,5 +32,16 @@ feature "Pipelines settings", feature: true do
       expect(page).to have_button('Save changes', disabled: false)
       expect(page).to have_field('Test coverage parsing', with: 'coverage_regex')
     end
+
+    scenario 'updates auto_cancel_pending_pipelines' do
+      page.check('Auto-cancel redundant, pending pipelines')
+      click_on 'Save changes'
+
+      expect(page.status_code).to eq(200)
+      expect(page).to have_button('Save changes', disabled: false)
+
+      checkbox = find_field('project_auto_cancel_pending_pipelines')
+      expect(checkbox).to be_checked
+    end
   end
 end
diff --git a/spec/features/projects/wiki/markdown_preview_spec.rb b/spec/features/projects/wiki/markdown_preview_spec.rb
index a1c386ddc18..43d8b45669e 100644
--- a/spec/features/projects/wiki/markdown_preview_spec.rb
+++ b/spec/features/projects/wiki/markdown_preview_spec.rb
@@ -24,12 +24,16 @@ feature 'Projects > Wiki > User previews markdown changes', feature: true, js: t
   context "while creating a new wiki page" do
     context "when there are no spaces or hyphens in the page name" do
       it "rewrites relative links as expected" do
-        click_link 'New Page'
-        fill_in :new_wiki_path, with: 'a/b/c/d'
-        click_button 'Create Page'
+        click_link 'New page'
+        page.within '#modal-new-wiki' do
+          fill_in :new_wiki_path, with: 'a/b/c/d'
+          click_button 'Create page'
+        end
 
-        fill_in :wiki_content, with: wiki_content
-        click_on "Preview"
+        page.within '.wiki-form' do
+          fill_in :wiki_content, with: wiki_content
+          click_on "Preview"
+        end
 
         expect(page).to have_content("regular link")
 
@@ -42,12 +46,16 @@ feature 'Projects > Wiki > User previews markdown changes', feature: true, js: t
 
     context "when there are spaces in the page name" do
       it "rewrites relative links as expected" do
-        click_link 'New Page'
-        fill_in :new_wiki_path, with: 'a page/b page/c page/d page'
-        click_button 'Create Page'
+        click_link 'New page'
+        page.within '#modal-new-wiki' do
+          fill_in :new_wiki_path, with: 'a page/b page/c page/d page'
+          click_button 'Create page'
+        end
 
-        fill_in :wiki_content, with: wiki_content
-        click_on "Preview"
+        page.within '.wiki-form' do
+          fill_in :wiki_content, with: wiki_content
+          click_on "Preview"
+        end
 
         expect(page).to have_content("regular link")
 
@@ -60,12 +68,16 @@ feature 'Projects > Wiki > User previews markdown changes', feature: true, js: t
 
     context "when there are hyphens in the page name" do
       it "rewrites relative links as expected" do
-        click_link 'New Page'
-        fill_in :new_wiki_path, with: 'a-page/b-page/c-page/d-page'
-        click_button 'Create Page'
-
-        fill_in :wiki_content, with: wiki_content
-        click_on "Preview"
+        click_link 'New page'
+        page.within '#modal-new-wiki' do
+          fill_in :new_wiki_path, with: 'a-page/b-page/c-page/d-page'
+          click_button 'Create page'
+        end
+        
+        page.within '.wiki-form' do
+          fill_in :wiki_content, with: wiki_content
+          click_on "Preview"
+        end
 
         expect(page).to have_content("regular link")
 
@@ -79,11 +91,17 @@ feature 'Projects > Wiki > User previews markdown changes', feature: true, js: t
 
   context "while editing a wiki page" do
     def create_wiki_page(path)
-      click_link 'New Page'
-      fill_in :new_wiki_path, with: path
-      click_button 'Create Page'
-      fill_in :wiki_content, with: 'content'
-      click_on "Create page"
+      click_link 'New page'
+
+      page.within '#modal-new-wiki' do
+        fill_in :new_wiki_path, with: path
+        click_button 'Create page'
+      end
+
+      page.within '.wiki-form' do
+        fill_in :wiki_content, with: 'content'
+        click_on "Create page"
+      end
     end
 
     context "when there are no spaces or hyphens in the page name" do
diff --git a/spec/features/projects/wiki/user_creates_wiki_page_spec.rb b/spec/features/projects/wiki/user_creates_wiki_page_spec.rb
index 7bdaafd1beb..1ffac8cd542 100644
--- a/spec/features/projects/wiki/user_creates_wiki_page_spec.rb
+++ b/spec/features/projects/wiki/user_creates_wiki_page_spec.rb
@@ -21,8 +21,9 @@ feature 'Projects > Wiki > User creates wiki page', feature: true do
 
       scenario 'directly from the wiki home page' do
         fill_in :wiki_content, with: 'My awesome wiki!'
-        click_button 'Create page'
-
+        page.within '.wiki-form' do
+          click_button 'Create page'
+        end
         expect(page).to have_content('Home')
         expect(page).to have_content("Last edited by #{user.name}")
         expect(page).to have_content('My awesome wiki!')
@@ -36,16 +37,20 @@ feature 'Projects > Wiki > User creates wiki page', feature: true do
 
       context 'via the "new wiki page" page' do
         scenario 'when the wiki page has a single word name', js: true do
-          click_link 'New Page'
+          click_link 'New page'
 
-          fill_in :new_wiki_path, with: 'foo'
-          click_button 'Create Page'
+          page.within '#modal-new-wiki' do
+            fill_in :new_wiki_path, with: 'foo'
+            click_button 'Create page'
+          end
 
           # Commit message field should have correct value.
           expect(page).to have_field('wiki[message]', with: 'Create foo')
 
-          fill_in :wiki_content, with: 'My awesome wiki!'
-          click_button 'Create page'
+          page.within '.wiki-form' do
+            fill_in :wiki_content, with: 'My awesome wiki!'
+            click_button 'Create page'
+          end
 
           expect(page).to have_content('Foo')
           expect(page).to have_content("Last edited by #{user.name}")
@@ -53,16 +58,20 @@ feature 'Projects > Wiki > User creates wiki page', feature: true do
         end
 
         scenario 'when the wiki page has spaces in the name', js: true do
-          click_link 'New Page'
+          click_link 'New page'
 
-          fill_in :new_wiki_path, with: 'Spaces in the name'
-          click_button 'Create Page'
+          page.within '#modal-new-wiki' do
+            fill_in :new_wiki_path, with: 'Spaces in the name'
+            click_button 'Create page'
+          end
 
           # Commit message field should have correct value.
           expect(page).to have_field('wiki[message]', with: 'Create spaces in the name')
 
-          fill_in :wiki_content, with: 'My awesome wiki!'
-          click_button 'Create page'
+          page.within '.wiki-form' do
+            fill_in :wiki_content, with: 'My awesome wiki!'
+            click_button 'Create page'
+          end
 
           expect(page).to have_content('Spaces in the name')
           expect(page).to have_content("Last edited by #{user.name}")
@@ -70,16 +79,20 @@ feature 'Projects > Wiki > User creates wiki page', feature: true do
         end
 
         scenario 'when the wiki page has hyphens in the name', js: true do
-          click_link 'New Page'
+          click_link 'New page'
 
-          fill_in :new_wiki_path, with: 'hyphens-in-the-name'
-          click_button 'Create Page'
+          page.within '#modal-new-wiki' do
+            fill_in :new_wiki_path, with: 'hyphens-in-the-name'
+            click_button 'Create page'
+          end
 
           # Commit message field should have correct value.
           expect(page).to have_field('wiki[message]', with: 'Create hyphens in the name')
 
-          fill_in :wiki_content, with: 'My awesome wiki!'
-          click_button 'Create page'
+          page.within '.wiki-form' do
+            fill_in :wiki_content, with: 'My awesome wiki!'
+            click_button 'Create page'
+          end
 
           expect(page).to have_content('Hyphens in the name')
           expect(page).to have_content("Last edited by #{user.name}")
@@ -99,7 +112,9 @@ feature 'Projects > Wiki > User creates wiki page', feature: true do
 
       scenario 'directly from the wiki home page' do
         fill_in :wiki_content, with: 'My awesome wiki!'
-        click_button 'Create page'
+        page.within '.wiki-form' do
+          click_button 'Create page'
+        end
 
         expect(page).to have_content('Home')
         expect(page).to have_content("Last edited by #{user.name}")
@@ -113,16 +128,20 @@ feature 'Projects > Wiki > User creates wiki page', feature: true do
       end
 
       scenario 'via the "new wiki page" page', js: true do
-        click_link 'New Page'
+        click_link 'New page'
 
-        fill_in :new_wiki_path, with: 'foo'
-        click_button 'Create Page'
+        page.within '#modal-new-wiki' do
+          fill_in :new_wiki_path, with: 'foo'
+          click_button 'Create page'
+        end
 
         # Commit message field should have correct value.
         expect(page).to have_field('wiki[message]', with: 'Create foo')
 
-        fill_in :wiki_content, with: 'My awesome wiki!'
-        click_button 'Create page'
+        page.within '.wiki-form' do
+          fill_in :wiki_content, with: 'My awesome wiki!'
+          click_button 'Create page'
+        end
 
         expect(page).to have_content('Foo')
         expect(page).to have_content("Last edited by #{user.name}")
diff --git a/spec/features/protected_branches/access_control_ce_spec.rb b/spec/features/protected_branches/access_control_ce_spec.rb
index e4aca25a339..eb3cea775da 100644
--- a/spec/features/protected_branches/access_control_ce_spec.rb
+++ b/spec/features/protected_branches/access_control_ce_spec.rb
@@ -2,7 +2,9 @@ RSpec.shared_examples "protected branches > access control > CE" do
   ProtectedBranch::PushAccessLevel.human_access_levels.each do |(access_type_id, access_type_name)|
     it "allows creating protected branches that #{access_type_name} can push to" do
       visit namespace_project_protected_branches_path(project.namespace, project)
+
       set_protected_branch_name('master')
+
       within('.new_protected_branch') do
         allowed_to_push_button = find(".js-allowed-to-push")
 
@@ -11,6 +13,7 @@ RSpec.shared_examples "protected branches > access control > CE" do
           within(".dropdown.open .dropdown-menu") { click_on access_type_name }
         end
       end
+
       click_on "Protect"
 
       expect(ProtectedBranch.count).to eq(1)
@@ -19,7 +22,9 @@ RSpec.shared_examples "protected branches > access control > CE" do
 
     it "allows updating protected branches so that #{access_type_name} can push to them" do
       visit namespace_project_protected_branches_path(project.namespace, project)
+
       set_protected_branch_name('master')
+
       click_on "Protect"
 
       expect(ProtectedBranch.count).to eq(1)
@@ -34,6 +39,7 @@ RSpec.shared_examples "protected branches > access control > CE" do
       end
 
       wait_for_ajax
+
       expect(ProtectedBranch.last.push_access_levels.map(&:access_level)).to include(access_type_id)
     end
   end
@@ -41,7 +47,9 @@ RSpec.shared_examples "protected branches > access control > CE" do
   ProtectedBranch::MergeAccessLevel.human_access_levels.each do |(access_type_id, access_type_name)|
     it "allows creating protected branches that #{access_type_name} can merge to" do
       visit namespace_project_protected_branches_path(project.namespace, project)
+
       set_protected_branch_name('master')
+
       within('.new_protected_branch') do
         allowed_to_merge_button = find(".js-allowed-to-merge")
 
@@ -50,6 +58,7 @@ RSpec.shared_examples "protected branches > access control > CE" do
           within(".dropdown.open .dropdown-menu") { click_on access_type_name }
         end
       end
+
       click_on "Protect"
 
       expect(ProtectedBranch.count).to eq(1)
@@ -58,7 +67,9 @@ RSpec.shared_examples "protected branches > access control > CE" do
 
     it "allows updating protected branches so that #{access_type_name} can merge to them" do
       visit namespace_project_protected_branches_path(project.namespace, project)
+
       set_protected_branch_name('master')
+
       click_on "Protect"
 
       expect(ProtectedBranch.count).to eq(1)
@@ -73,6 +84,7 @@ RSpec.shared_examples "protected branches > access control > CE" do
       end
 
       wait_for_ajax
+
       expect(ProtectedBranch.last.merge_access_levels.map(&:access_level)).to include(access_type_id)
     end
   end
diff --git a/spec/features/protected_tags/access_control_ce_spec.rb b/spec/features/protected_tags/access_control_ce_spec.rb
new file mode 100644
index 00000000000..5b2baf8616c
--- /dev/null
+++ b/spec/features/protected_tags/access_control_ce_spec.rb
@@ -0,0 +1,46 @@
+RSpec.shared_examples "protected tags > access control > CE" do
+  ProtectedTag::CreateAccessLevel.human_access_levels.each do |(access_type_id, access_type_name)|
+    it "allows creating protected tags that #{access_type_name} can create" do
+      visit namespace_project_protected_tags_path(project.namespace, project)
+
+      set_protected_tag_name('master')
+
+      within('.js-new-protected-tag') do
+        allowed_to_create_button = find(".js-allowed-to-create")
+
+        unless allowed_to_create_button.text == access_type_name
+          allowed_to_create_button.click
+          within(".dropdown.open .dropdown-menu") { click_on access_type_name }
+        end
+      end
+
+      click_on "Protect"
+
+      expect(ProtectedTag.count).to eq(1)
+      expect(ProtectedTag.last.create_access_levels.map(&:access_level)).to eq([access_type_id])
+    end
+
+    it "allows updating protected tags so that #{access_type_name} can create them" do
+      visit namespace_project_protected_tags_path(project.namespace, project)
+
+      set_protected_tag_name('master')
+
+      click_on "Protect"
+
+      expect(ProtectedTag.count).to eq(1)
+
+      within(".protected-tags-list") do
+        find(".js-allowed-to-create").click
+
+        within('.js-allowed-to-create-container') do
+          expect(first("li")).to have_content("Roles")
+          click_on access_type_name
+        end
+      end
+
+      wait_for_ajax
+
+      expect(ProtectedTag.last.create_access_levels.map(&:access_level)).to include(access_type_id)
+    end
+  end
+end
diff --git a/spec/features/protected_tags_spec.rb b/spec/features/protected_tags_spec.rb
new file mode 100644
index 00000000000..09e8c850de3
--- /dev/null
+++ b/spec/features/protected_tags_spec.rb
@@ -0,0 +1,94 @@
+require 'spec_helper'
+Dir["./spec/features/protected_tags/*.rb"].sort.each { |f| require f }
+
+feature 'Projected Tags', feature: true, js: true do
+  include WaitForAjax
+
+  let(:user) { create(:user, :admin) }
+  let(:project) { create(:project) }
+
+  before { login_as(user) }
+
+  def set_protected_tag_name(tag_name)
+    find(".js-protected-tag-select").click
+    find(".dropdown-input-field").set(tag_name)
+    click_on("Create wildcard #{tag_name}")
+  end
+
+  describe "explicit protected tags" do
+    it "allows creating explicit protected tags" do
+      visit namespace_project_protected_tags_path(project.namespace, project)
+      set_protected_tag_name('some-tag')
+      click_on "Protect"
+
+      within(".protected-tags-list") { expect(page).to have_content('some-tag') }
+      expect(ProtectedTag.count).to eq(1)
+      expect(ProtectedTag.last.name).to eq('some-tag')
+    end
+
+    it "displays the last commit on the matching tag if it exists" do
+      commit = create(:commit, project: project)
+      project.repository.add_tag(user, 'some-tag', commit.id)
+
+      visit namespace_project_protected_tags_path(project.namespace, project)
+      set_protected_tag_name('some-tag')
+      click_on "Protect"
+
+      within(".protected-tags-list") { expect(page).to have_content(commit.id[0..7]) }
+    end
+
+    it "displays an error message if the named tag does not exist" do
+      visit namespace_project_protected_tags_path(project.namespace, project)
+      set_protected_tag_name('some-tag')
+      click_on "Protect"
+
+      within(".protected-tags-list") { expect(page).to have_content('tag was removed') }
+    end
+  end
+
+  describe "wildcard protected tags" do
+    it "allows creating protected tags with a wildcard" do
+      visit namespace_project_protected_tags_path(project.namespace, project)
+      set_protected_tag_name('*-stable')
+      click_on "Protect"
+
+      within(".protected-tags-list") { expect(page).to have_content('*-stable') }
+      expect(ProtectedTag.count).to eq(1)
+      expect(ProtectedTag.last.name).to eq('*-stable')
+    end
+
+    it "displays the number of matching tags" do
+      project.repository.add_tag(user, 'production-stable', 'master')
+      project.repository.add_tag(user, 'staging-stable', 'master')
+
+      visit namespace_project_protected_tags_path(project.namespace, project)
+      set_protected_tag_name('*-stable')
+      click_on "Protect"
+
+      within(".protected-tags-list") { expect(page).to have_content("2 matching tags") }
+    end
+
+    it "displays all the tags matching the wildcard" do
+      project.repository.add_tag(user, 'production-stable', 'master')
+      project.repository.add_tag(user, 'staging-stable', 'master')
+      project.repository.add_tag(user, 'development', 'master')
+
+      visit namespace_project_protected_tags_path(project.namespace, project)
+      set_protected_tag_name('*-stable')
+      click_on "Protect"
+
+      visit namespace_project_protected_tags_path(project.namespace, project)
+      click_on "2 matching tags"
+
+      within(".protected-tags-list") do
+        expect(page).to have_content("production-stable")
+        expect(page).to have_content("staging-stable")
+        expect(page).not_to have_content("development")
+      end
+    end
+  end
+
+  describe "access control" do
+    include_examples "protected tags > access control > CE"
+  end
+end
diff --git a/spec/features/security/project/internal_access_spec.rb b/spec/features/security/project/internal_access_spec.rb
index 1a66d1a6a1e..6ecdc8cbb71 100644
--- a/spec/features/security/project/internal_access_spec.rb
+++ b/spec/features/security/project/internal_access_spec.rb
@@ -443,9 +443,12 @@ describe "Internal Project Access", feature: true  do
   end
 
   describe "GET /:project_path/container_registry" do
+    let(:container_repository) { create(:container_repository) }
+
     before do
-      stub_container_registry_tags('latest')
+      stub_container_registry_tags(repository: :any, tags: ['latest'])
       stub_container_registry_config(enabled: true)
+      project.container_repositories << container_repository
     end
 
     subject { namespace_project_container_registry_index_path(project.namespace, project) }
diff --git a/spec/features/security/project/private_access_spec.rb b/spec/features/security/project/private_access_spec.rb
index ad3bd60a313..a8fc0624588 100644
--- a/spec/features/security/project/private_access_spec.rb
+++ b/spec/features/security/project/private_access_spec.rb
@@ -432,9 +432,12 @@ describe "Private Project Access", feature: true  do
   end
 
   describe "GET /:project_path/container_registry" do
+    let(:container_repository) { create(:container_repository) }
+
     before do
-      stub_container_registry_tags('latest')
+      stub_container_registry_tags(repository: :any, tags: ['latest'])
       stub_container_registry_config(enabled: true)
+      project.container_repositories << container_repository
     end
 
     subject { namespace_project_container_registry_index_path(project.namespace, project) }
diff --git a/spec/features/security/project/public_access_spec.rb b/spec/features/security/project/public_access_spec.rb
index e06aab4e0b2..c4d2f50ca14 100644
--- a/spec/features/security/project/public_access_spec.rb
+++ b/spec/features/security/project/public_access_spec.rb
@@ -443,9 +443,12 @@ describe "Public Project Access", feature: true  do
   end
 
   describe "GET /:project_path/container_registry" do
+    let(:container_repository) { create(:container_repository) }
+
     before do
-      stub_container_registry_tags('latest')
+      stub_container_registry_tags(repository: :any, tags: ['latest'])
       stub_container_registry_config(enabled: true)
+      project.container_repositories << container_repository
     end
 
     subject { namespace_project_container_registry_index_path(project.namespace, project) }
diff --git a/spec/features/tags/master_views_tags_spec.rb b/spec/features/tags/master_views_tags_spec.rb
index 555f84c4772..922ac15a2eb 100644
--- a/spec/features/tags/master_views_tags_spec.rb
+++ b/spec/features/tags/master_views_tags_spec.rb
@@ -16,7 +16,7 @@ feature 'Master views tags', feature: true do
       fill_in :commit_message, with: 'Add a README file', visible: true
       # Remove pre-receive hook so we can push without auth
       FileUtils.rm_f(File.join(project.repository.path, 'hooks', 'pre-receive'))
-      click_button 'Commit Changes'
+      click_button 'Commit changes'
       visit namespace_project_tags_path(project.namespace, project)
     end
 
diff --git a/spec/features/triggers_spec.rb b/spec/features/triggers_spec.rb
index c1ae6db00c6..81fa2de1cc3 100644
--- a/spec/features/triggers_spec.rb
+++ b/spec/features/triggers_spec.rb
@@ -77,6 +77,59 @@ feature 'Triggers', feature: true, js: true do
       expect(page.find('.flash-notice')).to have_content 'Trigger was successfully updated.'
       expect(page.find('.triggers-list')).to have_content new_trigger_title
     end
+
+    context 'scheduled triggers' do
+      let!(:trigger) do
+        create(:ci_trigger, owner: user, project: @project, description: trigger_title)
+      end
+
+      context 'enabling schedule' do
+        before do
+          visit edit_namespace_project_trigger_path(@project.namespace, @project, trigger)
+        end
+
+        scenario 'do fill form with valid data and save' do
+          find('#trigger_trigger_schedule_attributes_active').click
+          fill_in 'trigger_trigger_schedule_attributes_cron', with: '1 * * * *'
+          fill_in 'trigger_trigger_schedule_attributes_cron_timezone', with: 'UTC'
+          fill_in 'trigger_trigger_schedule_attributes_ref', with: 'master'
+          click_button 'Save trigger'
+
+          expect(page.find('.flash-notice')).to have_content 'Trigger was successfully updated.'
+        end
+
+        scenario 'do not fill form with valid data and save' do
+          find('#trigger_trigger_schedule_attributes_active').click
+          click_button 'Save trigger'
+
+          expect(page).to have_content 'The form contains the following errors'
+        end
+      end
+
+      context 'disabling schedule' do
+        before do
+          trigger.create_trigger_schedule(
+            project: trigger.project,
+            active: true,
+            ref: 'master',
+            cron: '1 * * * *',
+            cron_timezone: 'UTC')
+
+          visit edit_namespace_project_trigger_path(@project.namespace, @project, trigger)
+        end
+
+        scenario 'disable and save form' do
+          find('#trigger_trigger_schedule_attributes_active').click
+          click_button 'Save trigger'
+          expect(page.find('.flash-notice')).to have_content 'Trigger was successfully updated.'
+
+          visit edit_namespace_project_trigger_path(@project.namespace, @project, trigger)
+          checkbox = find_field('trigger_trigger_schedule_attributes_active')
+
+          expect(checkbox).not_to be_checked
+        end
+      end
+    end
   end
 
   describe 'trigger "Take ownership" workflow' do
diff --git a/spec/features/u2f_spec.rb b/spec/features/u2f_spec.rb
index 28373098123..c877cfdd978 100644
--- a/spec/features/u2f_spec.rb
+++ b/spec/features/u2f_spec.rb
@@ -6,18 +6,18 @@ feature 'Using U2F (Universal 2nd Factor) Devices for Authentication', :js do
   before { allow_any_instance_of(U2fHelper).to receive(:inject_u2f_api?).and_return(true) }
 
   def manage_two_factor_authentication
-    click_on 'Manage Two-Factor Authentication'
-    expect(page).to have_content("Setup New U2F Device")
+    click_on 'Manage two-factor authentication'
+    expect(page).to have_content("Setup new U2F device")
     wait_for_ajax
   end
 
   def register_u2f_device(u2f_device = nil, name: 'My device')
     u2f_device ||= FakeU2fDevice.new(page, name)
     u2f_device.respond_to_u2f_registration
-    click_on 'Setup New U2F Device'
+    click_on 'Setup new U2F device'
     expect(page).to have_content('Your device was successfully set up')
     fill_in "Pick a name", with: name
-    click_on 'Register U2F Device'
+    click_on 'Register U2F device'
     u2f_device
   end
 
@@ -34,9 +34,9 @@ feature 'Using U2F (Universal 2nd Factor) Devices for Authentication', :js do
 
       it 'does not allow registering a new device' do
         visit profile_account_path
-        click_on 'Enable Two-Factor Authentication'
+        click_on 'Enable two-factor authentication'
 
-        expect(page).to have_button('Setup New U2F Device', disabled: true)
+        expect(page).to have_button('Setup new U2F device', disabled: true)
       end
     end
 
@@ -111,9 +111,9 @@ feature 'Using U2F (Universal 2nd Factor) Devices for Authentication', :js do
 
         # Have the "u2f device" respond with bad data
         page.execute_script("u2f.register = function(_,_,_,callback) { callback('bad response'); };")
-        click_on 'Setup New U2F Device'
+        click_on 'Setup new U2F device'
         expect(page).to have_content('Your device was successfully set up')
-        click_on 'Register U2F Device'
+        click_on 'Register U2F device'
 
         expect(U2fRegistration.count).to eq(0)
         expect(page).to have_content("The form contains the following error")
@@ -126,9 +126,9 @@ feature 'Using U2F (Universal 2nd Factor) Devices for Authentication', :js do
 
         # Failed registration
         page.execute_script("u2f.register = function(_,_,_,callback) { callback('bad response'); };")
-        click_on 'Setup New U2F Device'
+        click_on 'Setup new U2F device'
         expect(page).to have_content('Your device was successfully set up')
-        click_on 'Register U2F Device'
+        click_on 'Register U2F device'
         expect(page).to have_content("The form contains the following error")
 
         # Successful registration
diff --git a/spec/finders/notes_finder_spec.rb b/spec/finders/notes_finder_spec.rb
index 77a04507be1..765bf44d863 100644
--- a/spec/finders/notes_finder_spec.rb
+++ b/spec/finders/notes_finder_spec.rb
@@ -202,4 +202,45 @@ describe NotesFinder do
       end
     end
   end
+
+  describe '#target' do
+    subject { described_class.new(project, user, params) }
+
+    context 'for a issue target' do
+      let(:issue) { create(:issue, project: project) }
+      let(:params) { { target_type: 'issue', target_id: issue.id } }
+
+      it 'returns the issue' do
+        expect(subject.target).to eq(issue)
+      end
+    end
+
+    context 'for a merge request target' do
+      let(:merge_request) { create(:merge_request, source_project: project) }
+      let(:params) { { target_type: 'merge_request', target_id: merge_request.id } }
+
+      it 'returns the merge_request' do
+        expect(subject.target).to eq(merge_request)
+      end
+    end
+
+    context 'for a snippet target' do
+      let(:snippet) { create(:project_snippet, project: project) }
+      let(:params) { { target_type: 'snippet', target_id: snippet.id } }
+
+      it 'returns the snippet' do
+        expect(subject.target).to eq(snippet)
+      end
+    end
+
+    context 'for a commit target' do
+      let(:project) { create(:project, :repository) }
+      let(:commit) { project.commit }
+      let(:params) { { target_type: 'commit', target_id: commit.id } }
+
+      it 'returns the commit' do
+        expect(subject.target).to eq(commit)
+      end
+    end
+  end
 end
diff --git a/spec/helpers/blob_helper_spec.rb b/spec/helpers/blob_helper_spec.rb
index bead7948486..508aeb7cf67 100644
--- a/spec/helpers/blob_helper_spec.rb
+++ b/spec/helpers/blob_helper_spec.rb
@@ -73,7 +73,7 @@ describe BlobHelper do
     let(:project) { create(:project, :repository, namespace: namespace) }
 
     before do
-      allow(self).to receive(:current_user).and_return(double)
+      allow(self).to receive(:current_user).and_return(nil)
       allow(self).to receive(:can_collaborate_with_project?).and_return(true)
     end
 
diff --git a/spec/helpers/ci_status_helper_spec.rb b/spec/helpers/ci_status_helper_spec.rb
index 174cc84a97b..c795fe5a2a3 100644
--- a/spec/helpers/ci_status_helper_spec.rb
+++ b/spec/helpers/ci_status_helper_spec.rb
@@ -19,7 +19,11 @@ describe CiStatusHelper do
 
   describe "#pipeline_status_cache_key" do
     it "builds a cache key for pipeline status" do
-      pipeline_status = Ci::PipelineStatus.new(build(:project), sha: "123abc", status: "success")
+      pipeline_status = Gitlab::Cache::Ci::ProjectPipelineStatus.new(
+        build(:project),
+        sha: "123abc",
+        status: "success"
+      )
       expect(helper.pipeline_status_cache_key(pipeline_status)).to eq("pipeline-status/123abc-success")
     end
   end
diff --git a/spec/helpers/issues_helper_spec.rb b/spec/helpers/issues_helper_spec.rb
index f0554cc068d..540cb0ab1e0 100644
--- a/spec/helpers/issues_helper_spec.rb
+++ b/spec/helpers/issues_helper_spec.rb
@@ -150,7 +150,7 @@ describe IssuesHelper do
     describe "when passing a discussion" do
       let(:diff_note) {  create(:diff_note_on_merge_request) }
       let(:merge_request) { diff_note.noteable }
-      let(:discussion) { Discussion.new([diff_note]) }
+      let(:discussion) { diff_note.to_discussion }
 
       it "links to the merge request with first note if a single discussion was passed" do
         expected_path = Gitlab::UrlBuilder.build(diff_note)
diff --git a/spec/helpers/notes_helper_spec.rb b/spec/helpers/notes_helper_spec.rb
index 9c577501f00..a427de32c4c 100644
--- a/spec/helpers/notes_helper_spec.rb
+++ b/spec/helpers/notes_helper_spec.rb
@@ -36,21 +36,4 @@ describe NotesHelper do
       expect(helper.note_max_access_for_user(other_note)).to eq('Reporter')
     end
   end
-
-  describe '#preload_max_access_for_authors' do
-    before do
-      # This method reads cache from RequestStore, so make sure it's clean.
-      RequestStore.clear!
-    end
-
-    it 'loads multiple users' do
-      expected_access = {
-        owner.id => Gitlab::Access::OWNER,
-        master.id => Gitlab::Access::MASTER,
-        reporter.id => Gitlab::Access::REPORTER
-      }
-
-      expect(helper.preload_max_access_for_authors(notes, project)).to eq(expected_access)
-    end
-  end
 end
diff --git a/spec/helpers/preferences_helper_spec.rb b/spec/helpers/preferences_helper_spec.rb
index f3e79cc7290..2c0e9975f73 100644
--- a/spec/helpers/preferences_helper_spec.rb
+++ b/spec/helpers/preferences_helper_spec.rb
@@ -86,10 +86,10 @@ describe PreferencesHelper do
       context 'when repository is not empty' do
         let(:project) { create(:project, :public, :repository) }
 
-        it 'returns readme if user has repository access' do
+        it 'returns files and readme if user has repository access' do
           allow(helper).to receive(:can?).with(nil, :download_code, project).and_return(true)
 
-          expect(helper.default_project_view).to eq('readme')
+          expect(helper.default_project_view).to eq('files')
         end
 
         it 'returns activity if user does not have repository access' do
diff --git a/spec/helpers/projects_helper_spec.rb b/spec/helpers/projects_helper_spec.rb
index 44312ada438..40efab6e4f7 100644
--- a/spec/helpers/projects_helper_spec.rb
+++ b/spec/helpers/projects_helper_spec.rb
@@ -63,7 +63,7 @@ describe ProjectsHelper do
     end
   end
 
-  describe "#project_list_cache_key" do
+  describe "#project_list_cache_key", redis: true do
     let(:project) { create(:project) }
 
     it "includes the namespace" do
diff --git a/spec/javascripts/build_spec.js b/spec/javascripts/build_spec.js
index beee6cb2969..7174bf1e041 100644
--- a/spec/javascripts/build_spec.js
+++ b/spec/javascripts/build_spec.js
@@ -64,56 +64,33 @@ describe('Build', () => {
       });
     });
 
-    describe('initial build trace', () => {
-      beforeEach(() => {
-        new Build();
-      });
-
-      it('displays the initial build trace', () => {
-        expect($.ajax.calls.count()).toBe(1);
-        const [{ url, dataType, success, context }] = $.ajax.calls.argsFor(0);
-        expect(url).toBe(`${BUILD_URL}.json`);
-        expect(dataType).toBe('json');
-        expect(success).toEqual(jasmine.any(Function));
-        spyOn(gl.utils, 'setCiStatusFavicon').and.callFake(() => {});
-
-        success.call(context, { trace_html: '<span>Example</span>', status: 'running' });
-
-        expect($('#build-trace .js-build-output').text()).toMatch(/Example/);
-      });
-
-      it('removes the spinner', () => {
-        const [{ success, context }] = $.ajax.calls.argsFor(0);
-        spyOn(gl.utils, 'setCiStatusFavicon').and.callFake(() => {});
-        success.call(context, { trace_html: '<span>Example</span>', status: 'success' });
-
-        expect($('.js-build-refresh').length).toBe(0);
-      });
-    });
-
     describe('running build', () => {
       beforeEach(function () {
-        $('.js-build-options').data('buildStatus', 'running');
         this.build = new Build();
-        spyOn(this.build, 'location').and.returnValue(BUILD_URL);
       });
 
       it('updates the build trace on an interval', function () {
+        spyOn(gl.utils, 'visitUrl');
+
         jasmine.clock().tick(4001);
 
-        expect($.ajax.calls.count()).toBe(2);
-        let [{ url, dataType, success, context }] = $.ajax.calls.argsFor(1);
-        expect(url).toBe(
-          `${BUILD_URL}/trace.json?state=`,
-        );
-        expect(dataType).toBe('json');
-        expect(success).toEqual(jasmine.any(Function));
+        expect($.ajax.calls.count()).toBe(1);
+
+        // We have to do it this way to prevent Webpack to fail to compile
+        // when destructuring assignments and reusing
+        // the same variables names inside the same scope
+        let args = $.ajax.calls.argsFor(0)[0];
 
-        success.call(context, {
+        expect(args.url).toBe(`${BUILD_URL}/trace.json`);
+        expect(args.dataType).toBe('json');
+        expect(args.success).toEqual(jasmine.any(Function));
+
+        args.success.call($, {
           html: '<span>Update<span>',
           status: 'running',
           state: 'newstate',
           append: true,
+          complete: false,
         });
 
         expect($('#build-trace .js-build-output').text()).toMatch(/Update/);
@@ -122,16 +99,19 @@ describe('Build', () => {
         jasmine.clock().tick(4001);
 
         expect($.ajax.calls.count()).toBe(3);
-        [{ url, dataType, success, context }] = $.ajax.calls.argsFor(2);
-        expect(url).toBe(`${BUILD_URL}/trace.json?state=newstate`);
-        expect(dataType).toBe('json');
-        expect(success).toEqual(jasmine.any(Function));
 
-        success.call(context, {
+        args = $.ajax.calls.argsFor(2)[0];
+        expect(args.url).toBe(`${BUILD_URL}/trace.json`);
+        expect(args.dataType).toBe('json');
+        expect(args.data.state).toBe('newstate');
+        expect(args.success).toEqual(jasmine.any(Function));
+
+        args.success.call($, {
           html: '<span>More</span>',
           status: 'running',
           state: 'finalstate',
           append: true,
+          complete: true,
         });
 
         expect($('#build-trace .js-build-output').text()).toMatch(/UpdateMore/);
@@ -139,19 +119,22 @@ describe('Build', () => {
       });
 
       it('replaces the entire build trace', () => {
+        spyOn(gl.utils, 'visitUrl');
+
         jasmine.clock().tick(4001);
-        let [{ success, context }] = $.ajax.calls.argsFor(1);
-        success.call(context, {
+        let args = $.ajax.calls.argsFor(0)[0];
+        args.success.call($, {
           html: '<span>Update</span>',
           status: 'running',
-          append: true,
+          append: false,
+          complete: false,
         });
 
         expect($('#build-trace .js-build-output').text()).toMatch(/Update/);
 
         jasmine.clock().tick(4001);
-        [{ success, context }] = $.ajax.calls.argsFor(2);
-        success.call(context, {
+        args = $.ajax.calls.argsFor(2)[0];
+        args.success.call($, {
           html: '<span>Different</span>',
           status: 'running',
           append: false,
@@ -161,15 +144,34 @@ describe('Build', () => {
         expect($('#build-trace .js-build-output').text()).toMatch(/Different/);
       });
 
+      it('shows information about truncated log', () => {
+        jasmine.clock().tick(4001);
+        const [{ success }] = $.ajax.calls.argsFor(0);
+
+        success.call($, {
+          html: '<span>Update</span>',
+          status: 'success',
+          append: false,
+          truncated: true,
+          size: '50',
+        });
+
+        expect(
+          $('#build-trace .js-truncated-info').text().trim(),
+        ).toContain('Showing last 50 KiB of log');
+        expect($('#build-trace .js-truncated-info-size').text()).toMatch('50');
+      });
+
       it('reloads the page when the build is done', () => {
         spyOn(gl.utils, 'visitUrl');
 
         jasmine.clock().tick(4001);
-        const [{ success, context }] = $.ajax.calls.argsFor(1);
-        success.call(context, {
+        const [{ success }] = $.ajax.calls.argsFor(0);
+        success.call($, {
           html: '<span>Final</span>',
           status: 'passed',
           append: true,
+          complete: true,
         });
 
         expect(gl.utils.visitUrl).toHaveBeenCalledWith(BUILD_URL);
diff --git a/spec/javascripts/comment_type_toggle_spec.js b/spec/javascripts/comment_type_toggle_spec.js
new file mode 100644
index 00000000000..dfd0810d52e
--- /dev/null
+++ b/spec/javascripts/comment_type_toggle_spec.js
@@ -0,0 +1,157 @@
+import CommentTypeToggle from '~/comment_type_toggle';
+import * as dropLabSrc from '~/droplab/drop_lab';
+import InputSetter from '~/droplab/plugins/input_setter';
+
+describe('CommentTypeToggle', function () {
+  describe('class constructor', function () {
+    beforeEach(function () {
+      this.dropdownTrigger = {};
+      this.dropdownList = {};
+      this.noteTypeInput = {};
+      this.submitButton = {};
+      this.closeButton = {};
+
+      this.commentTypeToggle = new CommentTypeToggle({
+        dropdownTrigger: this.dropdownTrigger,
+        dropdownList: this.dropdownList,
+        noteTypeInput: this.noteTypeInput,
+        submitButton: this.submitButton,
+        closeButton: this.closeButton,
+      });
+    });
+
+    it('should set .dropdownTrigger', function () {
+      expect(this.commentTypeToggle.dropdownTrigger).toBe(this.dropdownTrigger);
+    });
+
+    it('should set .dropdownList', function () {
+      expect(this.commentTypeToggle.dropdownList).toBe(this.dropdownList);
+    });
+
+    it('should set .noteTypeInput', function () {
+      expect(this.commentTypeToggle.noteTypeInput).toBe(this.noteTypeInput);
+    });
+
+    it('should set .submitButton', function () {
+      expect(this.commentTypeToggle.submitButton).toBe(this.submitButton);
+    });
+
+    it('should set .closeButton', function () {
+      expect(this.commentTypeToggle.closeButton).toBe(this.closeButton);
+    });
+
+    it('should set .reopenButton', function () {
+      expect(this.commentTypeToggle.reopenButton).toBe(this.reopenButton);
+    });
+  });
+
+  describe('initDroplab', function () {
+    beforeEach(function () {
+      this.commentTypeToggle = {
+        dropdownTrigger: {},
+        dropdownList: {},
+        noteTypeInput: {},
+        submitButton: {},
+        closeButton: {},
+        setConfig: () => {},
+      };
+      this.config = {};
+
+      this.droplab = jasmine.createSpyObj('droplab', ['init']);
+
+      spyOn(dropLabSrc, 'default').and.returnValue(this.droplab);
+      spyOn(this.commentTypeToggle, 'setConfig').and.returnValue(this.config);
+
+      CommentTypeToggle.prototype.initDroplab.call(this.commentTypeToggle);
+    });
+
+    it('should instantiate a DropLab instance', function () {
+      expect(dropLabSrc.default).toHaveBeenCalled();
+    });
+
+    it('should set .droplab', function () {
+      expect(this.commentTypeToggle.droplab).toBe(this.droplab);
+    });
+
+    it('should call .setConfig', function () {
+      expect(this.commentTypeToggle.setConfig).toHaveBeenCalled();
+    });
+
+    it('should call DropLab.prototype.init', function () {
+      expect(this.droplab.init).toHaveBeenCalledWith(
+        this.commentTypeToggle.dropdownTrigger,
+        this.commentTypeToggle.dropdownList,
+        [InputSetter],
+        this.config,
+      );
+    });
+  });
+
+  describe('setConfig', function () {
+    describe('if no .closeButton is provided', function () {
+      beforeEach(function () {
+        this.commentTypeToggle = {
+          dropdownTrigger: {},
+          dropdownList: {},
+          noteTypeInput: {},
+          submitButton: {},
+          reopenButton: {},
+        };
+
+        this.setConfig = CommentTypeToggle.prototype.setConfig.call(this.commentTypeToggle);
+      });
+
+      it('should not add .closeButton related InputSetter config', function () {
+        expect(this.setConfig).toEqual({
+          InputSetter: [{
+            input: this.commentTypeToggle.noteTypeInput,
+            valueAttribute: 'data-value',
+          }, {
+            input: this.commentTypeToggle.submitButton,
+            valueAttribute: 'data-submit-text',
+          }, {
+            input: this.commentTypeToggle.reopenButton,
+            valueAttribute: 'data-reopen-text',
+          }, {
+            input: this.commentTypeToggle.reopenButton,
+            valueAttribute: 'data-reopen-text',
+            inputAttribute: 'data-alternative-text',
+          }],
+        });
+      });
+    });
+
+    describe('if no .reopenButton is provided', function () {
+      beforeEach(function () {
+        this.commentTypeToggle = {
+          dropdownTrigger: {},
+          dropdownList: {},
+          noteTypeInput: {},
+          submitButton: {},
+          closeButton: {},
+        };
+
+        this.setConfig = CommentTypeToggle.prototype.setConfig.call(this.commentTypeToggle);
+      });
+
+      it('should not add .reopenButton related InputSetter config', function () {
+        expect(this.setConfig).toEqual({
+          InputSetter: [{
+            input: this.commentTypeToggle.noteTypeInput,
+            valueAttribute: 'data-value',
+          }, {
+            input: this.commentTypeToggle.submitButton,
+            valueAttribute: 'data-submit-text',
+          }, {
+            input: this.commentTypeToggle.closeButton,
+            valueAttribute: 'data-close-text',
+          }, {
+            input: this.commentTypeToggle.closeButton,
+            valueAttribute: 'data-close-text',
+            inputAttribute: 'data-alternative-text',
+          }],
+        });
+      });
+    });
+  });
+});
diff --git a/spec/javascripts/droplab/constants_spec.js b/spec/javascripts/droplab/constants_spec.js
new file mode 100644
index 00000000000..35239e4fb8e
--- /dev/null
+++ b/spec/javascripts/droplab/constants_spec.js
@@ -0,0 +1,29 @@
+/* eslint-disable */
+
+import * as constants from '~/droplab/constants';
+
+describe('constants', function () {
+  describe('DATA_TRIGGER', function () {
+    it('should be `data-dropdown-trigger`', function() {
+      expect(constants.DATA_TRIGGER).toBe('data-dropdown-trigger');
+    });
+  });
+
+  describe('DATA_DROPDOWN', function () {
+    it('should be `data-dropdown`', function() {
+      expect(constants.DATA_DROPDOWN).toBe('data-dropdown');
+    });
+  });
+
+  describe('SELECTED_CLASS', function () {
+    it('should be `droplab-item-selected`', function() {
+      expect(constants.SELECTED_CLASS).toBe('droplab-item-selected');
+    });
+  });
+
+  describe('ACTIVE_CLASS', function () {
+    it('should be `droplab-item-active`', function() {
+      expect(constants.ACTIVE_CLASS).toBe('droplab-item-active');
+    });
+  });
+});
diff --git a/spec/javascripts/droplab/drop_down_spec.js b/spec/javascripts/droplab/drop_down_spec.js
new file mode 100644
index 00000000000..802e2435672
--- /dev/null
+++ b/spec/javascripts/droplab/drop_down_spec.js
@@ -0,0 +1,593 @@
+/* eslint-disable */
+
+import DropDown from '~/droplab/drop_down';
+import utils from '~/droplab/utils';
+import { SELECTED_CLASS } from '~/droplab/constants';
+
+describe('DropDown', function () {
+  describe('class constructor', function () {
+    beforeEach(function () {
+      spyOn(DropDown.prototype, 'getItems');
+      spyOn(DropDown.prototype, 'initTemplateString');
+      spyOn(DropDown.prototype, 'addEvents');
+
+      this.list = { innerHTML: 'innerHTML' };
+      this.dropdown = new DropDown(this.list);
+    });
+
+    it('sets the .hidden property to true', function () {
+      expect(this.dropdown.hidden).toBe(true);
+    })
+
+    it('sets the .list property', function () {
+      expect(this.dropdown.list).toBe(this.list);
+    });
+
+    it('calls .getItems', function () {
+      expect(DropDown.prototype.getItems).toHaveBeenCalled();
+    });
+
+    it('calls .initTemplateString', function () {
+      expect(DropDown.prototype.initTemplateString).toHaveBeenCalled();
+    });
+
+    it('calls .addEvents', function () {
+      expect(DropDown.prototype.addEvents).toHaveBeenCalled();
+    });
+
+    it('sets the .initialState property to the .list.innerHTML', function () {
+      expect(this.dropdown.initialState).toBe(this.list.innerHTML);
+    });
+
+    describe('if the list argument is a string', function () {
+      beforeEach(function () {
+        this.element = {};
+        this.selector = '.selector';
+
+        spyOn(Document.prototype, 'querySelector').and.returnValue(this.element);
+
+        this.dropdown = new DropDown(this.selector);
+      });
+
+      it('calls .querySelector with the selector string', function () {
+        expect(Document.prototype.querySelector).toHaveBeenCalledWith(this.selector);
+      });
+
+      it('sets the .list property element', function () {
+        expect(this.dropdown.list).toBe(this.element);
+      });
+    });
+  });
+
+  describe('getItems', function () {
+    beforeEach(function () {
+      this.list = { querySelectorAll: () => {} };
+      this.dropdown = { list: this.list };
+      this.nodeList = [];
+
+      spyOn(this.list, 'querySelectorAll').and.returnValue(this.nodeList);
+
+      this.getItems = DropDown.prototype.getItems.call(this.dropdown);
+    });
+
+    it('calls .querySelectorAll with a list item query', function () {
+      expect(this.list.querySelectorAll).toHaveBeenCalledWith('li');
+    });
+
+    it('sets the .items property to the returned list items', function () {
+      expect(this.dropdown.items).toEqual(jasmine.any(Array));
+    });
+
+    it('returns the .items', function () {
+      expect(this.getItems).toEqual(jasmine.any(Array));
+    });
+  });
+
+  describe('initTemplateString', function () {
+    beforeEach(function () {
+      this.items = [{ outerHTML: '<a></a>' }, { outerHTML: '<img>' }];
+      this.dropdown = { items: this.items };
+
+      DropDown.prototype.initTemplateString.call(this.dropdown);
+    });
+
+    it('should set .templateString to the last items .outerHTML', function () {
+      expect(this.dropdown.templateString).toBe(this.items[1].outerHTML);
+    });
+
+    it('should not set .templateString to a non-last items .outerHTML', function () {
+      expect(this.dropdown.templateString).not.toBe(this.items[0].outerHTML);
+    });
+
+    describe('if .items is not set', function () {
+      beforeEach(function () {
+        this.dropdown = { getItems: () => {} };
+
+        spyOn(this.dropdown, 'getItems').and.returnValue([]);
+
+        DropDown.prototype.initTemplateString.call(this.dropdown);
+      });
+
+      it('should call .getItems', function () {
+        expect(this.dropdown.getItems).toHaveBeenCalled();
+      });
+    });
+
+    describe('if items array is empty', function () {
+      beforeEach(function () {
+        this.dropdown = { items: [] };
+
+        DropDown.prototype.initTemplateString.call(this.dropdown);
+      });
+
+      it('should set .templateString to an empty string', function () {
+        expect(this.dropdown.templateString).toBe('');
+      });
+    });
+  });
+
+  describe('clickEvent', function () {
+    beforeEach(function () {
+      this.list = { dispatchEvent: () => {} };
+      this.dropdown = { hide: () => {}, list: this.list, addSelectedClass: () => {} };
+      this.event = { preventDefault: () => {}, target: {} };
+      this.customEvent = {};
+      this.closestElement = {};
+
+      spyOn(this.dropdown, 'hide');
+      spyOn(this.dropdown, 'addSelectedClass');
+      spyOn(this.list, 'dispatchEvent');
+      spyOn(this.event, 'preventDefault');
+      spyOn(window, 'CustomEvent').and.returnValue(this.customEvent);
+      spyOn(utils, 'closest').and.returnValues(this.closestElement, undefined);
+
+      DropDown.prototype.clickEvent.call(this.dropdown, this.event);
+    });
+
+    it('should call utils.closest', function () {
+      expect(utils.closest).toHaveBeenCalledWith(this.event.target, 'LI');
+    });
+
+    it('should call addSelectedClass', function () {
+      expect(this.dropdown.addSelectedClass).toHaveBeenCalledWith(this.closestElement);
+    })
+
+    it('should call .preventDefault', function () {
+      expect(this.event.preventDefault).toHaveBeenCalled();
+    });
+
+    it('should call .hide', function () {
+      expect(this.dropdown.hide).toHaveBeenCalled();
+    });
+
+    it('should construct CustomEvent', function () {
+      expect(window.CustomEvent).toHaveBeenCalledWith('click.dl', jasmine.any(Object));
+    });
+
+    it('should call .dispatchEvent with the customEvent', function () {
+      expect(this.list.dispatchEvent).toHaveBeenCalledWith(this.customEvent);
+    });
+
+    describe('if the target is a UL element', function () {
+      beforeEach(function () {
+        this.event = { preventDefault: () => {}, target: { tagName: 'UL' } };
+
+        spyOn(this.event, 'preventDefault');
+        utils.closest.calls.reset();
+
+        DropDown.prototype.clickEvent.call(this.dropdown, this.event);
+      });
+
+      it('should return immediately', function () {
+        expect(utils.closest).not.toHaveBeenCalled();
+      });
+    });
+
+    describe('if no selected element exists', function () {
+      beforeEach(function () {
+        this.event.preventDefault.calls.reset();
+        this.clickEvent = DropDown.prototype.clickEvent.call(this.dropdown, this.event);
+      });
+
+      it('should return undefined', function () {
+        expect(this.clickEvent).toBe(undefined);
+      });
+
+      it('should return before .preventDefault is called', function () {
+        expect(this.event.preventDefault).not.toHaveBeenCalled();
+      });
+    });
+  });
+
+  describe('addSelectedClass', function () {
+    beforeEach(function () {
+      this.items = Array(4).forEach((item, i) => {
+        this.items[i] = { classList: { add: () => {} } };
+        spyOn(this.items[i].classList, 'add');
+      });
+      this.selected = { classList: { add: () => {} } };
+      this.dropdown = { removeSelectedClasses: () => {} };
+
+      spyOn(this.dropdown, 'removeSelectedClasses');
+      spyOn(this.selected.classList, 'add');
+
+      DropDown.prototype.addSelectedClass.call(this.dropdown, this.selected);
+    });
+
+    it('should call .removeSelectedClasses', function () {
+      expect(this.dropdown.removeSelectedClasses).toHaveBeenCalled();
+    });
+
+    it('should call .classList.add', function () {
+      expect(this.selected.classList.add).toHaveBeenCalledWith(SELECTED_CLASS);
+    });
+  });
+
+  describe('removeSelectedClasses', function () {
+    beforeEach(function () {
+      this.items = Array(4);
+      this.items.forEach((item, i) => {
+        this.items[i] = { classList: { add: () => {} } };
+        spyOn(this.items[i].classList, 'add');
+      });
+      this.dropdown = { items: this.items };
+
+      DropDown.prototype.removeSelectedClasses.call(this.dropdown);
+    });
+
+    it('should call .classList.remove for all items', function () {
+      this.items.forEach((item, i) => {
+        expect(this.items[i].classList.add).toHaveBeenCalledWith(SELECTED_CLASS);
+      });
+    });
+
+    describe('if .items is not set', function () {
+      beforeEach(function () {
+        this.dropdown = { getItems: () => {} };
+
+        spyOn(this.dropdown, 'getItems').and.returnValue([]);
+
+        DropDown.prototype.removeSelectedClasses.call(this.dropdown);
+      });
+
+      it('should call .getItems', function () {
+        expect(this.dropdown.getItems).toHaveBeenCalled();
+      });
+    });
+  });
+
+  describe('addEvents', function () {
+    beforeEach(function () {
+      this.list = { addEventListener: () => {} };
+      this.dropdown = { list: this.list, clickEvent: () => {}, eventWrapper: {} };
+
+      spyOn(this.list, 'addEventListener');
+
+      DropDown.prototype.addEvents.call(this.dropdown);
+    });
+
+    it('should call .addEventListener', function () {
+      expect(this.list.addEventListener).toHaveBeenCalledWith('click', jasmine.any(Function));
+    });
+  });
+
+  describe('toggle', function () {
+    beforeEach(function () {
+      this.dropdown = { hidden: true, show: () => {}, hide: () => {} };
+
+      spyOn(this.dropdown, 'show');
+      spyOn(this.dropdown, 'hide');
+
+      DropDown.prototype.toggle.call(this.dropdown);
+    });
+
+    it('should call .show if hidden is true', function () {
+      expect(this.dropdown.show).toHaveBeenCalled();
+    });
+
+    describe('if hidden is false', function () {
+      beforeEach(function () {
+        this.dropdown = { hidden: false, show: () => {}, hide: () => {} };
+
+        spyOn(this.dropdown, 'show');
+        spyOn(this.dropdown, 'hide');
+
+        DropDown.prototype.toggle.call(this.dropdown);
+      });
+
+      it('should call .show if hidden is true', function () {
+        expect(this.dropdown.hide).toHaveBeenCalled();
+      });
+    });
+  });
+
+  describe('setData', function () {
+    beforeEach(function () {
+      this.dropdown = { render: () => {} };
+      this.data = ['data'];
+
+      spyOn(this.dropdown, 'render');
+
+      DropDown.prototype.setData.call(this.dropdown, this.data);
+    });
+
+    it('should set .data', function () {
+      expect(this.dropdown.data).toBe(this.data);
+    });
+
+    it('should call .render with the .data', function () {
+      expect(this.dropdown.render).toHaveBeenCalledWith(this.data);
+    });
+  });
+
+  describe('addData', function () {
+    beforeEach(function () {
+      this.dropdown = { render: () => {}, data: ['data1'] };
+      this.data = ['data2'];
+
+      spyOn(this.dropdown, 'render');
+      spyOn(Array.prototype, 'concat').and.callThrough();
+
+      DropDown.prototype.addData.call(this.dropdown, this.data);
+    });
+
+    it('should call .concat with data', function () {
+      expect(Array.prototype.concat).toHaveBeenCalledWith(this.data);
+    });
+
+    it('should set .data with concatination', function () {
+      expect(this.dropdown.data).toEqual(['data1', 'data2']);
+    });
+
+    it('should call .render with the .data', function () {
+      expect(this.dropdown.render).toHaveBeenCalledWith(['data1', 'data2']);
+    });
+
+    describe('if .data is undefined', function () {
+      beforeEach(function () {
+        this.dropdown = { render: () => {}, data: undefined };
+        this.data = ['data2'];
+
+        spyOn(this.dropdown, 'render');
+
+        DropDown.prototype.addData.call(this.dropdown, this.data);
+      });
+
+      it('should set .data with concatination', function () {
+        expect(this.dropdown.data).toEqual(['data2']);
+      });
+    });
+  });
+
+  describe('render', function () {
+    beforeEach(function () {
+      this.list = { querySelector: () => {} };
+      this.dropdown = { renderChildren: () => {}, list: this.list };
+      this.renderableList = {};
+      this.data = [0, 1];
+
+      spyOn(this.dropdown, 'renderChildren').and.callFake(data => data);
+      spyOn(this.list, 'querySelector').and.returnValue(this.renderableList);
+      spyOn(this.data, 'map').and.callThrough();
+
+      DropDown.prototype.render.call(this.dropdown, this.data);
+    });
+
+    it('should call .map', function () {
+      expect(this.data.map).toHaveBeenCalledWith(jasmine.any(Function));
+    });
+
+    it('should call .renderChildren for each data item', function() {
+      expect(this.dropdown.renderChildren.calls.count()).toBe(this.data.length);
+    });
+
+    it('sets the renderableList .innerHTML', function () {
+      expect(this.renderableList.innerHTML).toBe('01');
+    });
+
+    describe('if no data argument is passed' , function () {
+      beforeEach(function () {
+        this.data.map.calls.reset();
+        this.dropdown.renderChildren.calls.reset();
+
+        DropDown.prototype.render.call(this.dropdown, undefined);
+      });
+
+      it('should not call .map', function () {
+        expect(this.data.map).not.toHaveBeenCalled();
+      });
+
+      it('should not call .renderChildren', function () {
+        expect(this.dropdown.renderChildren).not.toHaveBeenCalled();
+      });
+    });
+
+    describe('if no dynamic list is present', function () {
+      beforeEach(function () {
+        this.list = { querySelector: () => {} };
+        this.dropdown = { renderChildren: () => {}, list: this.list };
+        this.data = [0, 1];
+
+        spyOn(this.dropdown, 'renderChildren').and.callFake(data => data);
+        spyOn(this.list, 'querySelector');
+        spyOn(this.data, 'map').and.callThrough();
+
+        DropDown.prototype.render.call(this.dropdown, this.data);
+      });
+
+      it('sets the .list .innerHTML', function () {
+        expect(this.list.innerHTML).toBe('01');
+      });
+    });
+  });
+
+  describe('renderChildren', function () {
+    beforeEach(function () {
+      this.templateString = 'templateString';
+      this.dropdown = { setImagesSrc: () => {}, templateString: this.templateString };
+      this.data = { droplab_hidden: true };
+      this.html = 'html';
+      this.template = { firstChild: { outerHTML: 'outerHTML', style: {} } };
+
+      spyOn(utils, 't').and.returnValue(this.html);
+      spyOn(document, 'createElement').and.returnValue(this.template);
+      spyOn(this.dropdown, 'setImagesSrc');
+
+      this.renderChildren = DropDown.prototype.renderChildren.call(this.dropdown, this.data);
+    });
+
+    it('should call utils.t with .templateString and data', function () {
+      expect(utils.t).toHaveBeenCalledWith(this.templateString, this.data);
+    });
+
+    it('should call document.createElement', function () {
+      expect(document.createElement).toHaveBeenCalledWith('div');
+    });
+
+    it('should set the templates .innerHTML to the HTML', function () {
+      expect(this.template.innerHTML).toBe(this.html);
+    });
+
+    it('should call .setImagesSrc with the template', function () {
+      expect(this.dropdown.setImagesSrc).toHaveBeenCalledWith(this.template);
+    });
+
+    it('should set the template display to none', function () {
+      expect(this.template.firstChild.style.display).toBe('none');
+    });
+
+    it('should return the templates .firstChild.outerHTML', function () {
+      expect(this.renderChildren).toBe(this.template.firstChild.outerHTML);
+    });
+
+    describe('if droplab_hidden is false', function () {
+      beforeEach(function () {
+        this.data = { droplab_hidden: false };
+        this.renderChildren = DropDown.prototype.renderChildren.call(this.dropdown, this.data);
+      });
+
+      it('should set the template display to block', function () {
+        expect(this.template.firstChild.style.display).toBe('block');
+      });
+    });
+  });
+
+  describe('setImagesSrc', function () {
+    beforeEach(function () {
+      this.dropdown = {};
+      this.template = { querySelectorAll: () => {} };
+
+      spyOn(this.template, 'querySelectorAll').and.returnValue([]);
+
+      DropDown.prototype.setImagesSrc.call(this.dropdown, this.template);
+    });
+
+    it('should call .querySelectorAll', function () {
+      expect(this.template.querySelectorAll).toHaveBeenCalledWith('img[data-src]');
+    });
+  });
+
+  describe('show', function () {
+    beforeEach(function () {
+      this.list = { style: {} };
+      this.dropdown = { list: this.list, hidden: true };
+
+      DropDown.prototype.show.call(this.dropdown);
+    });
+
+    it('it should set .list display to block', function () {
+      expect(this.list.style.display).toBe('block');
+    });
+
+    it('it should set .hidden to false', function () {
+      expect(this.dropdown.hidden).toBe(false);
+    });
+
+    describe('if .hidden is false', function () {
+      beforeEach(function () {
+        this.list = { style: {} };
+        this.dropdown = { list: this.list, hidden: false };
+
+        this.show = DropDown.prototype.show.call(this.dropdown);
+      });
+
+      it('should return undefined', function () {
+        expect(this.show).toEqual(undefined);
+      });
+
+      it('should not set .list display to block', function () {
+        expect(this.list.style.display).not.toEqual('block');
+      });
+    });
+  });
+
+  describe('hide', function () {
+    beforeEach(function () {
+      this.list = { style: {} };
+      this.dropdown = { list: this.list };
+
+      DropDown.prototype.hide.call(this.dropdown);
+    });
+
+    it('it should set .list display to none', function () {
+      expect(this.list.style.display).toBe('none');
+    });
+
+    it('it should set .hidden to true', function () {
+      expect(this.dropdown.hidden).toBe(true);
+    });
+  });
+
+  describe('toggle', function () {
+    beforeEach(function () {
+      this.hidden = true
+      this.dropdown = { hidden: this.hidden, show: () => {}, hide: () => {} };
+
+      spyOn(this.dropdown, 'show');
+      spyOn(this.dropdown, 'hide');
+
+      DropDown.prototype.toggle.call(this.dropdown);
+    });
+
+    it('should call .show', function () {
+      expect(this.dropdown.show).toHaveBeenCalled();
+    });
+
+    describe('if .hidden is false', function () {
+      beforeEach(function () {
+        this.hidden = false
+        this.dropdown = { hidden: this.hidden, show: () => {}, hide: () => {} };
+
+        spyOn(this.dropdown, 'show');
+        spyOn(this.dropdown, 'hide');
+
+        DropDown.prototype.toggle.call(this.dropdown);
+      });
+
+      it('should call .hide', function () {
+        expect(this.dropdown.hide).toHaveBeenCalled();
+      });
+    });
+  });
+
+  describe('destroy', function () {
+    beforeEach(function () {
+      this.list = { removeEventListener: () => {} };
+      this.eventWrapper = { clickEvent: 'clickEvent' };
+      this.dropdown = { list: this.list, hide: () => {}, eventWrapper: this.eventWrapper };
+
+      spyOn(this.list, 'removeEventListener');
+      spyOn(this.dropdown, 'hide');
+
+      DropDown.prototype.destroy.call(this.dropdown);
+    });
+
+    it('it should call .hide', function () {
+      expect(this.dropdown.hide).toHaveBeenCalled();
+    });
+
+    it('it should call .removeEventListener', function () {
+      expect(this.list.removeEventListener).toHaveBeenCalledWith('click', this.eventWrapper.clickEvent);
+    });
+  });
+});
diff --git a/spec/javascripts/droplab/hook_spec.js b/spec/javascripts/droplab/hook_spec.js
new file mode 100644
index 00000000000..8ebdcdd1404
--- /dev/null
+++ b/spec/javascripts/droplab/hook_spec.js
@@ -0,0 +1,82 @@
+/* eslint-disable */
+
+import Hook from '~/droplab/hook';
+import * as dropdownSrc from '~/droplab/drop_down';
+
+describe('Hook', function () {
+  describe('class constructor', function () {
+    beforeEach(function () {
+      this.trigger = { id: 'id' };
+      this.list = {};
+      this.plugins = {};
+      this.config = {};
+      this.dropdown = {};
+
+      spyOn(dropdownSrc, 'default').and.returnValue(this.dropdown);
+
+      this.hook = new Hook(this.trigger, this.list, this.plugins, this.config);
+    });
+
+    it('should set .trigger', function () {
+      expect(this.hook.trigger).toBe(this.trigger);
+    });
+
+    it('should set .list', function () {
+      expect(this.hook.list).toBe(this.dropdown);
+    });
+
+    it('should call DropDown constructor', function () {
+      expect(dropdownSrc.default).toHaveBeenCalledWith(this.list);
+    });
+
+    it('should set .type', function () {
+      expect(this.hook.type).toBe('Hook');
+    });
+
+    it('should set .event', function () {
+      expect(this.hook.event).toBe('click');
+    });
+
+    it('should set .plugins', function () {
+      expect(this.hook.plugins).toBe(this.plugins);
+    });
+
+    it('should set .config', function () {
+      expect(this.hook.config).toBe(this.config);
+    });
+
+    it('should set .id', function () {
+      expect(this.hook.id).toBe(this.trigger.id);
+    });
+
+    describe('if config argument is undefined', function () {
+      beforeEach(function () {
+        this.config = undefined;
+
+        this.hook = new Hook(this.trigger, this.list, this.plugins, this.config);
+      });
+
+      it('should set .config to an empty object', function () {
+        expect(this.hook.config).toEqual({});
+      });
+    });
+
+    describe('if plugins argument is undefined', function () {
+      beforeEach(function () {
+        this.plugins = undefined;
+
+        this.hook = new Hook(this.trigger, this.list, this.plugins, this.config);
+      });
+
+      it('should set .plugins to an empty array', function () {
+        expect(this.hook.plugins).toEqual([]);
+      });
+    });
+  });
+
+  describe('addEvents', function () {
+    it('should exist', function () {
+      expect(Hook.prototype.hasOwnProperty('addEvents')).toBe(true);
+    });
+  });
+});
diff --git a/spec/javascripts/droplab/plugins/input_setter_spec.js b/spec/javascripts/droplab/plugins/input_setter_spec.js
new file mode 100644
index 00000000000..bd625f4ae80
--- /dev/null
+++ b/spec/javascripts/droplab/plugins/input_setter_spec.js
@@ -0,0 +1,212 @@
+/* eslint-disable */
+
+import InputSetter from '~/droplab/plugins/input_setter';
+
+describe('InputSetter', function () {
+  describe('init', function () {
+    beforeEach(function () {
+      this.config = { InputSetter: {} };
+      this.hook = { config: this.config };
+      this.inputSetter = jasmine.createSpyObj('inputSetter', ['addEvents']);
+
+      InputSetter.init.call(this.inputSetter, this.hook);
+    });
+
+    it('should set .hook', function () {
+      expect(this.inputSetter.hook).toBe(this.hook);
+    });
+
+    it('should set .config', function () {
+      expect(this.inputSetter.config).toBe(this.config.InputSetter);
+    });
+
+    it('should set .eventWrapper', function () {
+      expect(this.inputSetter.eventWrapper).toEqual({});
+    });
+
+    it('should call .addEvents', function () {
+      expect(this.inputSetter.addEvents).toHaveBeenCalled();
+    });
+
+    describe('if config.InputSetter is not set', function () {
+      beforeEach(function () {
+        this.config = { InputSetter: undefined };
+        this.hook = { config: this.config };
+
+        InputSetter.init.call(this.inputSetter, this.hook);
+      });
+
+      it('should set .config to an empty object', function () {
+        expect(this.inputSetter.config).toEqual({});
+      });
+
+      it('should set hook.config to an empty object', function () {
+        expect(this.hook.config.InputSetter).toEqual({});
+      });
+    })
+  });
+
+  describe('addEvents', function () {
+    beforeEach(function () {
+      this.hook = { list: { list: jasmine.createSpyObj('list', ['addEventListener']) } };
+      this.inputSetter = { eventWrapper: {}, hook: this.hook, setInputs: () => {} };
+
+      InputSetter.addEvents.call(this.inputSetter);
+    });
+
+    it('should set .eventWrapper.setInputs', function () {
+      expect(this.inputSetter.eventWrapper.setInputs).toEqual(jasmine.any(Function));
+    });
+
+    it('should call .addEventListener', function () {
+      expect(this.hook.list.list.addEventListener)
+        .toHaveBeenCalledWith('click.dl', this.inputSetter.eventWrapper.setInputs);
+    });
+  });
+
+  describe('removeEvents', function () {
+    beforeEach(function () {
+      this.hook = { list: { list: jasmine.createSpyObj('list', ['removeEventListener']) } };
+      this.eventWrapper = jasmine.createSpyObj('eventWrapper', ['setInputs']);
+      this.inputSetter = { eventWrapper: this.eventWrapper, hook: this.hook };
+
+      InputSetter.removeEvents.call(this.inputSetter);
+    });
+
+    it('should call .removeEventListener', function () {
+      expect(this.hook.list.list.removeEventListener)
+        .toHaveBeenCalledWith('click.dl', this.eventWrapper.setInputs);
+    });
+  });
+
+  describe('setInputs', function () {
+    beforeEach(function () {
+      this.event = { detail: { selected: {} } };
+      this.config = [0, 1];
+      this.inputSetter = { config: this.config, setInput: () => {} };
+
+      spyOn(this.inputSetter, 'setInput');
+
+      InputSetter.setInputs.call(this.inputSetter, this.event);
+    });
+
+    it('should call .setInput for each config element', function () {
+      const allArgs = this.inputSetter.setInput.calls.allArgs();
+
+      expect(allArgs.length).toEqual(2);
+
+      allArgs.forEach((args, i) => {
+        expect(args[0]).toBe(this.config[i]);
+        expect(args[1]).toBe(this.event.detail.selected);
+      });
+    });
+
+    describe('if config isnt an array', function () {
+      beforeEach(function () {
+        this.inputSetter = { config: {}, setInput: () => {} };
+
+        InputSetter.setInputs.call(this.inputSetter, this.event);
+      });
+
+      it('should set .config to an array with .config as the first element', function () {
+        expect(this.inputSetter.config).toEqual([{}]);
+      });
+    });
+  });
+
+  describe('setInput', function () {
+    beforeEach(function () {
+      this.selectedItem = { getAttribute: () => {} };
+      this.input = { value: 'oldValue', tagName: 'INPUT', hasAttribute: () => {} };
+      this.config = { valueAttribute: {}, input: this.input };
+      this.inputSetter = { hook: { trigger: {} } };
+      this.newValue = 'newValue';
+
+      spyOn(this.selectedItem, 'getAttribute').and.returnValue(this.newValue);
+      spyOn(this.input, 'hasAttribute').and.returnValue(false);
+
+      InputSetter.setInput.call(this.inputSetter, this.config, this.selectedItem);
+    });
+
+    it('should call .getAttribute', function () {
+      expect(this.selectedItem.getAttribute).toHaveBeenCalledWith(this.config.valueAttribute);
+    });
+
+    it('should call .hasAttribute', function () {
+      expect(this.input.hasAttribute).toHaveBeenCalledWith(undefined);
+    });
+
+    it('should set the value of the input', function () {
+      expect(this.input.value).toBe(this.newValue);
+    });
+
+    describe('if no config.input is provided', function () {
+      beforeEach(function () {
+        this.config = { valueAttribute: {} };
+        this.trigger = { value: 'oldValue', tagName: 'INPUT', hasAttribute: () => {} };
+        this.inputSetter = { hook: { trigger: this.trigger } };
+
+        InputSetter.setInput.call(this.inputSetter, this.config, this.selectedItem);
+      });
+
+      it('should set the value of the hook.trigger', function () {
+        expect(this.trigger.value).toBe(this.newValue);
+      });
+    });
+
+    describe('if the input tag is not INPUT', function () {
+      beforeEach(function () {
+        this.input = { textContent: 'oldValue', tagName: 'SPAN', hasAttribute: () => {} };
+        this.config = { valueAttribute: {}, input: this.input };
+
+        InputSetter.setInput.call(this.inputSetter, this.config, this.selectedItem);
+      });
+
+      it('should set the textContent of the input', function () {
+        expect(this.input.textContent).toBe(this.newValue);
+      });
+    });
+
+    describe('if there is an inputAttribute', function () {
+      beforeEach(function () {
+        this.selectedItem = { getAttribute: () => {} };
+        this.input = { id: 'oldValue', hasAttribute: () => {}, setAttribute: () => {} };
+        this.inputSetter = { hook: { trigger: {} } };
+        this.newValue = 'newValue';
+        this.inputAttribute = 'id';
+        this.config = {
+          valueAttribute: {},
+          input: this.input,
+          inputAttribute: this.inputAttribute,
+        };
+
+        spyOn(this.selectedItem, 'getAttribute').and.returnValue(this.newValue);
+        spyOn(this.input, 'hasAttribute').and.returnValue(true);
+        spyOn(this.input, 'setAttribute');
+
+        InputSetter.setInput.call(this.inputSetter, this.config, this.selectedItem);
+      });
+
+      it('should call setAttribute', function () {
+        expect(this.input.setAttribute).toHaveBeenCalledWith(this.inputAttribute, this.newValue);
+      });
+
+      it('should not set the value or textContent of the input', function () {
+        expect(this.input.value).not.toBe('newValue');
+        expect(this.input.textContent).not.toBe('newValue');
+      });
+    });
+  });
+
+  describe('destroy', function () {
+    beforeEach(function () {
+      this.inputSetter = jasmine.createSpyObj('inputSetter', ['removeEvents']);
+
+      InputSetter.destroy.call(this.inputSetter);
+    });
+
+    it('should call .removeEvents', function () {
+      expect(this.inputSetter.removeEvents).toHaveBeenCalled();
+    });
+  });
+});
diff --git a/spec/javascripts/environments/environment_spec.js b/spec/javascripts/environments/environment_spec.js
index 4431baa4b96..9762688af1a 100644
--- a/spec/javascripts/environments/environment_spec.js
+++ b/spec/javascripts/environments/environment_spec.js
@@ -83,9 +83,10 @@ describe('Environment', () => {
 
       it('should render a table with environments', (done) => {
         setTimeout(() => {
+          expect(component.$el.querySelectorAll('table')).toBeDefined();
           expect(
-            component.$el.querySelectorAll('table tbody tr').length,
-          ).toEqual(1);
+            component.$el.querySelector('.environment-name').textContent.trim(),
+          ).toEqual(environment.name);
           done();
         }, 0);
       });
diff --git a/spec/javascripts/environments/folder/environments_folder_view_spec.js b/spec/javascripts/environments/folder/environments_folder_view_spec.js
index 43a217a67f5..72f3db29a66 100644
--- a/spec/javascripts/environments/folder/environments_folder_view_spec.js
+++ b/spec/javascripts/environments/folder/environments_folder_view_spec.js
@@ -47,9 +47,10 @@ describe('Environments Folder View', () => {
 
     it('should render a table with environments', (done) => {
       setTimeout(() => {
+        expect(component.$el.querySelectorAll('table')).toBeDefined();
         expect(
-          component.$el.querySelectorAll('table tbody tr').length,
-        ).toEqual(2);
+          component.$el.querySelector('.environment-name').textContent.trim(),
+        ).toEqual(environmentsList[0].name);
         done();
       }, 0);
     });
diff --git a/spec/javascripts/filtered_search/components/recent_searches_dropdown_content_spec.js b/spec/javascripts/filtered_search/components/recent_searches_dropdown_content_spec.js
new file mode 100644
index 00000000000..2722882375f
--- /dev/null
+++ b/spec/javascripts/filtered_search/components/recent_searches_dropdown_content_spec.js
@@ -0,0 +1,166 @@
+import Vue from 'vue';
+import eventHub from '~/filtered_search/event_hub';
+import RecentSearchesDropdownContent from '~/filtered_search/components/recent_searches_dropdown_content';
+
+const createComponent = (propsData) => {
+  const Component = Vue.extend(RecentSearchesDropdownContent);
+
+  return new Component({
+    el: document.createElement('div'),
+    propsData,
+  });
+};
+
+// Remove all the newlines and whitespace from the formatted markup
+const trimMarkupWhitespace = text => text.replace(/(\n|\s)+/gm, ' ').trim();
+
+describe('RecentSearchesDropdownContent', () => {
+  const propsDataWithoutItems = {
+    items: [],
+  };
+  const propsDataWithItems = {
+    items: [
+      'foo',
+      'author:@root label:~foo bar',
+    ],
+  };
+
+  let vm;
+  afterEach(() => {
+    if (vm) {
+      vm.$destroy();
+    }
+  });
+
+  describe('with no items', () => {
+    let el;
+
+    beforeEach(() => {
+      vm = createComponent(propsDataWithoutItems);
+      el = vm.$el;
+    });
+
+    it('should render empty state', () => {
+      expect(el.querySelector('.dropdown-info-note')).toBeDefined();
+
+      const items = el.querySelectorAll('.filtered-search-history-dropdown-item');
+      expect(items.length).toEqual(propsDataWithoutItems.items.length);
+    });
+  });
+
+  describe('with items', () => {
+    let el;
+
+    beforeEach(() => {
+      vm = createComponent(propsDataWithItems);
+      el = vm.$el;
+    });
+
+    it('should render clear recent searches button', () => {
+      expect(el.querySelector('.filtered-search-history-clear-button')).toBeDefined();
+    });
+
+    it('should render recent search items', () => {
+      const items = el.querySelectorAll('.filtered-search-history-dropdown-item');
+      expect(items.length).toEqual(propsDataWithItems.items.length);
+
+      expect(trimMarkupWhitespace(items[0].querySelector('.filtered-search-history-dropdown-search-token').textContent)).toEqual('foo');
+
+      const item1Tokens = items[1].querySelectorAll('.filtered-search-history-dropdown-token');
+      expect(item1Tokens.length).toEqual(2);
+      expect(item1Tokens[0].querySelector('.name').textContent).toEqual('author:');
+      expect(item1Tokens[0].querySelector('.value').textContent).toEqual('@root');
+      expect(item1Tokens[1].querySelector('.name').textContent).toEqual('label:');
+      expect(item1Tokens[1].querySelector('.value').textContent).toEqual('~foo');
+      expect(trimMarkupWhitespace(items[1].querySelector('.filtered-search-history-dropdown-search-token').textContent)).toEqual('bar');
+    });
+  });
+
+  describe('computed', () => {
+    describe('processedItems', () => {
+      it('with items', () => {
+        vm = createComponent(propsDataWithItems);
+        const processedItems = vm.processedItems;
+
+        expect(processedItems.length).toEqual(2);
+
+        expect(processedItems[0].text).toEqual(propsDataWithItems.items[0]);
+        expect(processedItems[0].tokens).toEqual([]);
+        expect(processedItems[0].searchToken).toEqual('foo');
+
+        expect(processedItems[1].text).toEqual(propsDataWithItems.items[1]);
+        expect(processedItems[1].tokens.length).toEqual(2);
+        expect(processedItems[1].tokens[0].prefix).toEqual('author:');
+        expect(processedItems[1].tokens[0].suffix).toEqual('@root');
+        expect(processedItems[1].tokens[1].prefix).toEqual('label:');
+        expect(processedItems[1].tokens[1].suffix).toEqual('~foo');
+        expect(processedItems[1].searchToken).toEqual('bar');
+      });
+
+      it('with no items', () => {
+        vm = createComponent(propsDataWithoutItems);
+        const processedItems = vm.processedItems;
+
+        expect(processedItems.length).toEqual(0);
+      });
+    });
+
+    describe('hasItems', () => {
+      it('with items', () => {
+        vm = createComponent(propsDataWithItems);
+        const hasItems = vm.hasItems;
+        expect(hasItems).toEqual(true);
+      });
+
+      it('with no items', () => {
+        vm = createComponent(propsDataWithoutItems);
+        const hasItems = vm.hasItems;
+        expect(hasItems).toEqual(false);
+      });
+    });
+  });
+
+  describe('methods', () => {
+    describe('onItemActivated', () => {
+      let onRecentSearchesItemSelectedSpy;
+
+      beforeEach(() => {
+        onRecentSearchesItemSelectedSpy = jasmine.createSpy('spy');
+        eventHub.$on('recentSearchesItemSelected', onRecentSearchesItemSelectedSpy);
+
+        vm = createComponent(propsDataWithItems);
+      });
+
+      afterEach(() => {
+        eventHub.$off('recentSearchesItemSelected', onRecentSearchesItemSelectedSpy);
+      });
+
+      it('emits event', () => {
+        expect(onRecentSearchesItemSelectedSpy).not.toHaveBeenCalled();
+        vm.onItemActivated('something');
+        expect(onRecentSearchesItemSelectedSpy).toHaveBeenCalledWith('something');
+      });
+    });
+
+    describe('onRequestClearRecentSearches', () => {
+      let onRequestClearRecentSearchesSpy;
+
+      beforeEach(() => {
+        onRequestClearRecentSearchesSpy = jasmine.createSpy('spy');
+        eventHub.$on('requestClearRecentSearches', onRequestClearRecentSearchesSpy);
+
+        vm = createComponent(propsDataWithItems);
+      });
+
+      afterEach(() => {
+        eventHub.$off('requestClearRecentSearches', onRequestClearRecentSearchesSpy);
+      });
+
+      it('emits event', () => {
+        expect(onRequestClearRecentSearchesSpy).not.toHaveBeenCalled();
+        vm.onRequestClearRecentSearches({ stopPropagation: () => {} });
+        expect(onRequestClearRecentSearchesSpy).toHaveBeenCalled();
+      });
+    });
+  });
+});
diff --git a/spec/javascripts/filtered_search/dropdown_user_spec.js b/spec/javascripts/filtered_search/dropdown_user_spec.js
index c16f77c53a2..2b1fe5e3eef 100644
--- a/spec/javascripts/filtered_search/dropdown_user_spec.js
+++ b/spec/javascripts/filtered_search/dropdown_user_spec.js
@@ -33,7 +33,7 @@ require('~/filtered_search/dropdown_user');
       });
     });
 
-    describe('config droplabAjaxFilter\'s endpoint', () => {
+    describe('config AjaxFilter\'s endpoint', () => {
       beforeEach(() => {
         spyOn(gl.DropdownUser.prototype, 'bindEvents').and.callFake(() => {});
         spyOn(gl.DropdownUser.prototype, 'getProjectId').and.callFake(() => {});
@@ -45,13 +45,13 @@ require('~/filtered_search/dropdown_user');
         };
         const dropdown = new gl.DropdownUser();
 
-        expect(dropdown.config.droplabAjaxFilter.endpoint).toBe('/autocomplete/users.json');
+        expect(dropdown.config.AjaxFilter.endpoint).toBe('/autocomplete/users.json');
       });
 
       it('should return endpoint when relative_url_root is undefined', () => {
         const dropdown = new gl.DropdownUser();
 
-        expect(dropdown.config.droplabAjaxFilter.endpoint).toBe('/autocomplete/users.json');
+        expect(dropdown.config.AjaxFilter.endpoint).toBe('/autocomplete/users.json');
       });
 
       it('should return endpoint with relative url when available', () => {
@@ -60,7 +60,7 @@ require('~/filtered_search/dropdown_user');
         };
         const dropdown = new gl.DropdownUser();
 
-        expect(dropdown.config.droplabAjaxFilter.endpoint).toBe('/gitlab_directory/autocomplete/users.json');
+        expect(dropdown.config.AjaxFilter.endpoint).toBe('/gitlab_directory/autocomplete/users.json');
       });
 
       afterEach(() => {
diff --git a/spec/javascripts/filtered_search/filtered_search_manager_spec.js b/spec/javascripts/filtered_search/filtered_search_manager_spec.js
index 5f7c05e9014..97af681429b 100644
--- a/spec/javascripts/filtered_search/filtered_search_manager_spec.js
+++ b/spec/javascripts/filtered_search/filtered_search_manager_spec.js
@@ -29,7 +29,7 @@ const FilteredSearchSpecHelper = require('../helpers/filtered_search_spec_helper
 
     beforeEach(() => {
       setFixtures(`
-        <div class="filtered-search-input-container">
+        <div class="filtered-search-box">
           <form>
             <ul class="tokens-container list-unstyled">
               ${FilteredSearchSpecHelper.createInputHTML(placeholder)}
@@ -264,12 +264,12 @@ const FilteredSearchSpecHelper = require('../helpers/filtered_search_spec_helper
     describe('toggleInputContainerFocus', () => {
       it('toggles on focus', () => {
         input.focus();
-        expect(document.querySelector('.filtered-search-input-container').classList.contains('focus')).toEqual(true);
+        expect(document.querySelector('.filtered-search-box').classList.contains('focus')).toEqual(true);
       });
 
       it('toggles on blur', () => {
         input.blur();
-        expect(document.querySelector('.filtered-search-input-container').classList.contains('focus')).toEqual(false);
+        expect(document.querySelector('.filtered-search-box').classList.contains('focus')).toEqual(false);
       });
     });
   });
diff --git a/spec/javascripts/filtered_search/services/recent_searches_service_spec.js b/spec/javascripts/filtered_search/services/recent_searches_service_spec.js
new file mode 100644
index 00000000000..2a58fb3a7df
--- /dev/null
+++ b/spec/javascripts/filtered_search/services/recent_searches_service_spec.js
@@ -0,0 +1,56 @@
+import RecentSearchesService from '~/filtered_search/services/recent_searches_service';
+
+describe('RecentSearchesService', () => {
+  let service;
+
+  beforeEach(() => {
+    service = new RecentSearchesService();
+    window.localStorage.removeItem(service.localStorageKey);
+  });
+
+  describe('fetch', () => {
+    it('should default to empty array', (done) => {
+      const fetchItemsPromise = service.fetch();
+
+      fetchItemsPromise
+        .then((items) => {
+          expect(items).toEqual([]);
+          done();
+        })
+        .catch((err) => {
+          done.fail('Shouldn\'t reject with empty localStorage key', err);
+        });
+    });
+
+    it('should reject when unable to parse', (done) => {
+      window.localStorage.setItem(service.localStorageKey, 'fail');
+      const fetchItemsPromise = service.fetch();
+
+      fetchItemsPromise
+        .catch(() => {
+          done();
+        });
+    });
+
+    it('should return items from localStorage', (done) => {
+      window.localStorage.setItem(service.localStorageKey, '["foo", "bar"]');
+      const fetchItemsPromise = service.fetch();
+
+      fetchItemsPromise
+        .then((items) => {
+          expect(items).toEqual(['foo', 'bar']);
+          done();
+        });
+    });
+  });
+
+  describe('setRecentSearches', () => {
+    it('should save things in localStorage', () => {
+      const items = ['foo', 'bar'];
+      service.save(items);
+      const newLocalStorageValue =
+        window.localStorage.getItem(service.localStorageKey);
+      expect(JSON.parse(newLocalStorageValue)).toEqual(items);
+    });
+  });
+});
diff --git a/spec/javascripts/filtered_search/stores/recent_searches_store_spec.js b/spec/javascripts/filtered_search/stores/recent_searches_store_spec.js
new file mode 100644
index 00000000000..1eebc6f2367
--- /dev/null
+++ b/spec/javascripts/filtered_search/stores/recent_searches_store_spec.js
@@ -0,0 +1,59 @@
+import RecentSearchesStore from '~/filtered_search/stores/recent_searches_store';
+
+describe('RecentSearchesStore', () => {
+  let store;
+
+  beforeEach(() => {
+    store = new RecentSearchesStore();
+  });
+
+  describe('addRecentSearch', () => {
+    it('should add to the front of the list', () => {
+      store.addRecentSearch('foo');
+      store.addRecentSearch('bar');
+
+      expect(store.state.recentSearches).toEqual(['bar', 'foo']);
+    });
+
+    it('should deduplicate', () => {
+      store.addRecentSearch('foo');
+      store.addRecentSearch('bar');
+      store.addRecentSearch('foo');
+
+      expect(store.state.recentSearches).toEqual(['foo', 'bar']);
+    });
+
+    it('only keeps track of 5 items', () => {
+      store.addRecentSearch('1');
+      store.addRecentSearch('2');
+      store.addRecentSearch('3');
+      store.addRecentSearch('4');
+      store.addRecentSearch('5');
+      store.addRecentSearch('6');
+      store.addRecentSearch('7');
+
+      expect(store.state.recentSearches).toEqual(['7', '6', '5', '4', '3']);
+    });
+  });
+
+  describe('setRecentSearches', () => {
+    it('should override list', () => {
+      store.setRecentSearches([
+        'foo',
+        'bar',
+      ]);
+      store.setRecentSearches([
+        'baz',
+        'qux',
+      ]);
+
+      expect(store.state.recentSearches).toEqual(['baz', 'qux']);
+    });
+
+    it('only keeps track of 5 items', () => {
+      store.setRecentSearches(['1', '2', '3', '4', '5', '6', '7']);
+
+      expect(store.state.recentSearches).toEqual(['1', '2', '3', '4', '5']);
+    });
+  });
+});
diff --git a/spec/javascripts/issue_spec.js b/spec/javascripts/issue_spec.js
index aabc8bea12f..9a2570ef7e9 100644
--- a/spec/javascripts/issue_spec.js
+++ b/spec/javascripts/issue_spec.js
@@ -1,18 +1,17 @@
-/* eslint-disable space-before-function-paren, no-var, one-var, one-var-declaration-per-line, no-use-before-define, comma-dangle, max-len */
+/* eslint-disable space-before-function-paren, one-var, one-var-declaration-per-line, no-use-before-define, comma-dangle, max-len */
 import Issue from '~/issue';
 
 require('~/lib/utils/text_utility');
 
 describe('Issue', function() {
-  var INVALID_URL = 'http://goesnowhere.nothing/whereami';
-  var $boxClosed, $boxOpen, $btnClose, $btnReopen;
+  let $boxClosed, $boxOpen, $btnClose, $btnReopen;
 
   preloadFixtures('issues/closed-issue.html.raw');
   preloadFixtures('issues/issue-with-task-list.html.raw');
   preloadFixtures('issues/open-issue.html.raw');
 
   function expectErrorMessage() {
-    var $flashMessage = $('div.flash-alert');
+    const $flashMessage = $('div.flash-alert');
     expect($flashMessage).toExist();
     expect($flashMessage).toBeVisible();
     expect($flashMessage).toHaveText('Unable to update this issue at this time.');
@@ -26,10 +25,28 @@ describe('Issue', function() {
     expectVisibility($btnReopen, !isIssueOpen);
   }
 
-  function expectPendingRequest(req, $triggeredButton) {
-    expect(req.type).toBe('PUT');
-    expect(req.url).toBe($triggeredButton.attr('href'));
-    expect($triggeredButton).toHaveProp('disabled', true);
+  function expectNewBranchButtonState(isPending, canCreate) {
+    if (Issue.$btnNewBranch.length === 0) {
+      return;
+    }
+
+    const $available = Issue.$btnNewBranch.find('.available');
+    expect($available).toHaveText('New branch');
+
+    if (!isPending && canCreate) {
+      expect($available).toBeVisible();
+    } else {
+      expect($available).toBeHidden();
+    }
+
+    const $unavailable = Issue.$btnNewBranch.find('.unavailable');
+    expect($unavailable).toHaveText('New branch unavailable');
+
+    if (!isPending && !canCreate) {
+      expect($unavailable).toBeVisible();
+    } else {
+      expect($unavailable).toBeHidden();
+    }
   }
 
   function expectVisibility($element, shouldBeVisible) {
@@ -81,100 +98,107 @@ describe('Issue', function() {
     });
   });
 
-  describe('close issue', function() {
-    beforeEach(function() {
-      loadFixtures('issues/open-issue.html.raw');
-      findElements();
-      this.issue = new Issue();
-
-      expectIssueState(true);
-    });
+  [true, false].forEach((isIssueInitiallyOpen) => {
+    describe(`with ${isIssueInitiallyOpen ? 'open' : 'closed'} issue`, function() {
+      const action = isIssueInitiallyOpen ? 'close' : 'reopen';
+
+      function ajaxSpy(req) {
+        if (req.url === this.$triggeredButton.attr('href')) {
+          expect(req.type).toBe('PUT');
+          expect(this.$triggeredButton).toHaveProp('disabled', true);
+          expectNewBranchButtonState(true, false);
+          return this.issueStateDeferred;
+        } else if (req.url === Issue.$btnNewBranch.data('path')) {
+          expect(req.type).toBe('get');
+          expectNewBranchButtonState(true, false);
+          return this.canCreateBranchDeferred;
+        }
+
+        expect(req.url).toBe('unexpected');
+        return null;
+      }
+
+      beforeEach(function() {
+        if (isIssueInitiallyOpen) {
+          loadFixtures('issues/open-issue.html.raw');
+        } else {
+          loadFixtures('issues/closed-issue.html.raw');
+        }
+
+        findElements();
+        this.issue = new Issue();
+        expectIssueState(isIssueInitiallyOpen);
+        this.$triggeredButton = isIssueInitiallyOpen ? $btnClose : $btnReopen;
+
+        this.$projectIssuesCounter = $('.issue_counter');
+        this.$projectIssuesCounter.text('1,001');
+
+        this.issueStateDeferred = new jQuery.Deferred();
+        this.canCreateBranchDeferred = new jQuery.Deferred();
+
+        spyOn(jQuery, 'ajax').and.callFake(ajaxSpy.bind(this));
+      });
 
-    it('closes an issue', function() {
-      spyOn(jQuery, 'ajax').and.callFake(function(req) {
-        expectPendingRequest(req, $btnClose);
-        req.success({
+      it(`${action}s the issue`, function() {
+        this.$triggeredButton.trigger('click');
+        this.issueStateDeferred.resolve({
           id: 34
         });
-      });
-
-      $btnClose.trigger('click');
+        this.canCreateBranchDeferred.resolve({
+          can_create_branch: !isIssueInitiallyOpen
+        });
 
-      expectIssueState(false);
-      expect($btnClose).toHaveProp('disabled', false);
-      expect($('.issue_counter')).toHaveText(0);
-    });
+        expectIssueState(!isIssueInitiallyOpen);
+        expect(this.$triggeredButton).toHaveProp('disabled', false);
+        expect(this.$projectIssuesCounter.text()).toBe(isIssueInitiallyOpen ? '1,000' : '1,002');
+        expectNewBranchButtonState(false, !isIssueInitiallyOpen);
+      });
 
-    it('fails to close an issue with success:false', function() {
-      spyOn(jQuery, 'ajax').and.callFake(function(req) {
-        expectPendingRequest(req, $btnClose);
-        req.success({
+      it(`fails to ${action} the issue if saved:false`, function() {
+        this.$triggeredButton.trigger('click');
+        this.issueStateDeferred.resolve({
           saved: false
         });
-      });
-
-      $btnClose.attr('href', INVALID_URL);
-      $btnClose.trigger('click');
-
-      expectIssueState(true);
-      expect($btnClose).toHaveProp('disabled', false);
-      expectErrorMessage();
-      expect($('.issue_counter')).toHaveText(1);
-    });
+        this.canCreateBranchDeferred.resolve({
+          can_create_branch: isIssueInitiallyOpen
+        });
 
-    it('fails to closes an issue with HTTP error', function() {
-      spyOn(jQuery, 'ajax').and.callFake(function(req) {
-        expectPendingRequest(req, $btnClose);
-        req.error();
+        expectIssueState(isIssueInitiallyOpen);
+        expect(this.$triggeredButton).toHaveProp('disabled', false);
+        expectErrorMessage();
+        expect(this.$projectIssuesCounter.text()).toBe('1,001');
+        expectNewBranchButtonState(false, isIssueInitiallyOpen);
       });
 
-      $btnClose.attr('href', INVALID_URL);
-      $btnClose.trigger('click');
-
-      expectIssueState(true);
-      expect($btnClose).toHaveProp('disabled', true);
-      expectErrorMessage();
-      expect($('.issue_counter')).toHaveText(1);
-    });
-
-    it('updates counter', () => {
-      spyOn(jQuery, 'ajax').and.callFake(function(req) {
-        expectPendingRequest(req, $btnClose);
-        req.success({
-          id: 34
+      it(`fails to ${action} the issue if HTTP error occurs`, function() {
+        this.$triggeredButton.trigger('click');
+        this.issueStateDeferred.reject();
+        this.canCreateBranchDeferred.resolve({
+          can_create_branch: isIssueInitiallyOpen
         });
-      });
 
-      expect($('.issue_counter')).toHaveText(1);
-      $('.issue_counter').text('1,001');
-      expect($('.issue_counter').text()).toEqual('1,001');
-      $btnClose.trigger('click');
-      expect($('.issue_counter').text()).toEqual('1,000');
-    });
-  });
+        expectIssueState(isIssueInitiallyOpen);
+        expect(this.$triggeredButton).toHaveProp('disabled', true);
+        expectErrorMessage();
+        expect(this.$projectIssuesCounter.text()).toBe('1,001');
+        expectNewBranchButtonState(false, isIssueInitiallyOpen);
+      });
 
-  describe('reopen issue', function() {
-    beforeEach(function() {
-      loadFixtures('issues/closed-issue.html.raw');
-      findElements();
-      this.issue = new Issue();
+      it('disables the new branch button if Ajax call fails', function() {
+        this.$triggeredButton.trigger('click');
+        this.issueStateDeferred.reject();
+        this.canCreateBranchDeferred.reject();
 
-      expectIssueState(false);
-    });
-
-    it('reopens an issue', function() {
-      spyOn(jQuery, 'ajax').and.callFake(function(req) {
-        expectPendingRequest(req, $btnReopen);
-        req.success({
-          id: 34
-        });
+        expectNewBranchButtonState(false, false);
       });
 
-      $btnReopen.trigger('click');
+      it('does not trigger Ajax call if new branch button is missing', function() {
+        Issue.$btnNewBranch = $();
+        this.canCreateBranchDeferred = null;
 
-      expectIssueState(true);
-      expect($btnReopen).toHaveProp('disabled', false);
-      expect($('.issue_counter')).toHaveText(1);
+        this.$triggeredButton.trigger('click');
+        this.issueStateDeferred.reject();
+      });
     });
   });
 });
diff --git a/spec/javascripts/lib/utils/poll_spec.js b/spec/javascripts/lib/utils/poll_spec.js
index e3429c2a1cb..918b6d32c43 100644
--- a/spec/javascripts/lib/utils/poll_spec.js
+++ b/spec/javascripts/lib/utils/poll_spec.js
@@ -4,6 +4,20 @@ import Poll from '~/lib/utils/poll';
 
 Vue.use(VueResource);
 
+const waitForAllCallsToFinish = (service, waitForCount, successCallback) => {
+  const timer = () => {
+    setTimeout(() => {
+      if (service.fetch.calls.count() === waitForCount) {
+        successCallback();
+      } else {
+        timer();
+      }
+    }, 5);
+  };
+
+  timer();
+};
+
 class ServiceMock {
   constructor(endpoint) {
     this.service = Vue.resource(endpoint);
@@ -16,6 +30,7 @@ class ServiceMock {
 
 describe('Poll', () => {
   let callbacks;
+  let service;
 
   beforeEach(() => {
     callbacks = {
@@ -23,8 +38,11 @@ describe('Poll', () => {
       error: () => {},
     };
 
+    service = new ServiceMock('endpoint');
+
     spyOn(callbacks, 'success');
     spyOn(callbacks, 'error');
+    spyOn(service, 'fetch').and.callThrough();
   });
 
   it('calls the success callback when no header for interval is provided', (done) => {
@@ -35,19 +53,20 @@ describe('Poll', () => {
     Vue.http.interceptors.push(successInterceptor);
 
     new Poll({
-      resource: new ServiceMock('endpoint'),
+      resource: service,
       method: 'fetch',
       successCallback: callbacks.success,
       errorCallback: callbacks.error,
     }).makeRequest();
 
-    setTimeout(() => {
+    waitForAllCallsToFinish(service, 1, () => {
       expect(callbacks.success).toHaveBeenCalled();
       expect(callbacks.error).not.toHaveBeenCalled();
+
+      Vue.http.interceptors = _.without(Vue.http.interceptors, successInterceptor);
+
       done();
     }, 0);
-
-    Vue.http.interceptors = _.without(Vue.http.interceptors, successInterceptor);
   });
 
   it('calls the error callback whe the http request returns an error', (done) => {
@@ -58,19 +77,19 @@ describe('Poll', () => {
     Vue.http.interceptors.push(errorInterceptor);
 
     new Poll({
-      resource: new ServiceMock('endpoint'),
+      resource: service,
       method: 'fetch',
       successCallback: callbacks.success,
       errorCallback: callbacks.error,
     }).makeRequest();
 
-    setTimeout(() => {
+    waitForAllCallsToFinish(service, 1, () => {
       expect(callbacks.success).not.toHaveBeenCalled();
       expect(callbacks.error).toHaveBeenCalled();
-      done();
-    }, 0);
+      Vue.http.interceptors = _.without(Vue.http.interceptors, errorInterceptor);
 
-    Vue.http.interceptors = _.without(Vue.http.interceptors, errorInterceptor);
+      done();
+    });
   });
 
   it('should call the success callback when the interval header is -1', (done) => {
@@ -81,7 +100,7 @@ describe('Poll', () => {
     Vue.http.interceptors.push(intervalInterceptor);
 
     new Poll({
-      resource: new ServiceMock('endpoint'),
+      resource: service,
       method: 'fetch',
       successCallback: callbacks.success,
       errorCallback: callbacks.error,
@@ -90,10 +109,11 @@ describe('Poll', () => {
     setTimeout(() => {
       expect(callbacks.success).toHaveBeenCalled();
       expect(callbacks.error).not.toHaveBeenCalled();
+
+      Vue.http.interceptors = _.without(Vue.http.interceptors, intervalInterceptor);
+
       done();
     }, 0);
-
-    Vue.http.interceptors = _.without(Vue.http.interceptors, intervalInterceptor);
   });
 
   it('starts polling when http status is 200 and interval header is provided', (done) => {
@@ -103,26 +123,28 @@ describe('Poll', () => {
 
     Vue.http.interceptors.push(pollInterceptor);
 
-    const service = new ServiceMock('endpoint');
-    spyOn(service, 'fetch').and.callThrough();
-
-    new Poll({
+    const Polling = new Poll({
       resource: service,
       method: 'fetch',
       data: { page: 1 },
       successCallback: callbacks.success,
       errorCallback: callbacks.error,
-    }).makeRequest();
+    });
+
+    Polling.makeRequest();
+
+    waitForAllCallsToFinish(service, 2, () => {
+      Polling.stop();
 
-    setTimeout(() => {
       expect(service.fetch.calls.count()).toEqual(2);
       expect(service.fetch).toHaveBeenCalledWith({ page: 1 });
       expect(callbacks.success).toHaveBeenCalled();
       expect(callbacks.error).not.toHaveBeenCalled();
-      done();
-    }, 5);
 
-    Vue.http.interceptors = _.without(Vue.http.interceptors, pollInterceptor);
+      Vue.http.interceptors = _.without(Vue.http.interceptors, pollInterceptor);
+
+      done();
+    });
   });
 
   describe('stop', () => {
@@ -133,9 +155,6 @@ describe('Poll', () => {
 
       Vue.http.interceptors.push(pollInterceptor);
 
-      const service = new ServiceMock('endpoint');
-      spyOn(service, 'fetch').and.callThrough();
-
       const Polling = new Poll({
         resource: service,
         method: 'fetch',
@@ -150,14 +169,15 @@ describe('Poll', () => {
 
       Polling.makeRequest();
 
-      setTimeout(() => {
+      waitForAllCallsToFinish(service, 1, () => {
         expect(service.fetch.calls.count()).toEqual(1);
         expect(service.fetch).toHaveBeenCalledWith({ page: 1 });
         expect(Polling.stop).toHaveBeenCalled();
-        done();
-      }, 100);
 
-      Vue.http.interceptors = _.without(Vue.http.interceptors, pollInterceptor);
+        Vue.http.interceptors = _.without(Vue.http.interceptors, pollInterceptor);
+
+        done();
+      });
     });
   });
 
@@ -169,10 +189,6 @@ describe('Poll', () => {
 
       Vue.http.interceptors.push(pollInterceptor);
 
-      const service = new ServiceMock('endpoint');
-
-      spyOn(service, 'fetch').and.callThrough();
-
       const Polling = new Poll({
         resource: service,
         method: 'fetch',
@@ -187,17 +203,22 @@ describe('Poll', () => {
       });
 
       spyOn(Polling, 'stop').and.callThrough();
+      spyOn(Polling, 'restart').and.callThrough();
 
       Polling.makeRequest();
 
-      setTimeout(() => {
+      waitForAllCallsToFinish(service, 2, () => {
+        Polling.stop();
+
         expect(service.fetch.calls.count()).toEqual(2);
         expect(service.fetch).toHaveBeenCalledWith({ page: 1 });
         expect(Polling.stop).toHaveBeenCalled();
-        done();
-      }, 10);
+        expect(Polling.restart).toHaveBeenCalled();
 
-      Vue.http.interceptors = _.without(Vue.http.interceptors, pollInterceptor);
+        Vue.http.interceptors = _.without(Vue.http.interceptors, pollInterceptor);
+
+        done();
+      });
     });
   });
 });
diff --git a/spec/javascripts/merge_request_tabs_spec.js b/spec/javascripts/merge_request_tabs_spec.js
index 7b9632be84e..e437333d522 100644
--- a/spec/javascripts/merge_request_tabs_spec.js
+++ b/spec/javascripts/merge_request_tabs_spec.js
@@ -1,8 +1,12 @@
 /* eslint-disable no-var, comma-dangle, object-shorthand */
 
 require('~/merge_request_tabs');
+require('~/commit/pipelines/pipelines_bundle.js');
 require('~/breakpoints');
 require('~/lib/utils/common_utils');
+require('~/diff');
+require('~/single_file_diff');
+require('~/files_comment_button');
 require('vendor/jquery.scrollTo');
 
 (function () {
@@ -39,7 +43,8 @@ require('vendor/jquery.scrollTo');
     });
 
     afterEach(function () {
-      this.class.destroy();
+      this.class.unbindEvents();
+      this.class.destroyPipelinesView();
     });
 
     describe('#activateTab', function () {
@@ -65,6 +70,7 @@ require('vendor/jquery.scrollTo');
         expect($('#diffs')).toHaveClass('active');
       });
     });
+
     describe('#opensInNewTab', function () {
       var tabUrl;
       var windowTarget = '_blank';
@@ -116,6 +122,7 @@ require('vendor/jquery.scrollTo');
           stopImmediatePropagation: function () {}
         });
       });
+
       it('opens page tab in a new browser tab with Cmd+Click - Mac', function () {
         spyOn(window, 'open').and.callFake(function (url, name) {
           expect(url).toEqual(tabUrl);
@@ -129,6 +136,7 @@ require('vendor/jquery.scrollTo');
           stopImmediatePropagation: function () {}
         });
       });
+
       it('opens page tab in a new browser tab with Middle-click - Mac/PC', function () {
         spyOn(window, 'open').and.callFake(function (url, name) {
           expect(url).toEqual(tabUrl);
@@ -149,6 +157,7 @@ require('vendor/jquery.scrollTo');
         spyOn($, 'ajax').and.callFake(function () {});
         this.subject = this.class.setCurrentAction;
       });
+
       it('changes from commits', function () {
         setLocation({
           pathname: '/foo/bar/merge_requests/1/commits'
@@ -156,13 +165,16 @@ require('vendor/jquery.scrollTo');
         expect(this.subject('notes')).toBe('/foo/bar/merge_requests/1');
         expect(this.subject('diffs')).toBe('/foo/bar/merge_requests/1/diffs');
       });
+
       it('changes from diffs', function () {
         setLocation({
           pathname: '/foo/bar/merge_requests/1/diffs'
         });
+
         expect(this.subject('notes')).toBe('/foo/bar/merge_requests/1');
         expect(this.subject('commits')).toBe('/foo/bar/merge_requests/1/commits');
       });
+
       it('changes from diffs.html', function () {
         setLocation({
           pathname: '/foo/bar/merge_requests/1/diffs.html'
@@ -170,6 +182,7 @@ require('vendor/jquery.scrollTo');
         expect(this.subject('notes')).toBe('/foo/bar/merge_requests/1');
         expect(this.subject('commits')).toBe('/foo/bar/merge_requests/1/commits');
       });
+
       it('changes from notes', function () {
         setLocation({
           pathname: '/foo/bar/merge_requests/1'
@@ -177,6 +190,7 @@ require('vendor/jquery.scrollTo');
         expect(this.subject('diffs')).toBe('/foo/bar/merge_requests/1/diffs');
         expect(this.subject('commits')).toBe('/foo/bar/merge_requests/1/commits');
       });
+
       it('includes search parameters and hash string', function () {
         setLocation({
           pathname: '/foo/bar/merge_requests/1/diffs',
@@ -185,6 +199,7 @@ require('vendor/jquery.scrollTo');
         });
         expect(this.subject('show')).toBe('/foo/bar/merge_requests/1?view=parallel#L15-35');
       });
+
       it('replaces the current history state', function () {
         var newState;
         setLocation({
@@ -197,6 +212,7 @@ require('vendor/jquery.scrollTo');
           }, document.title, newState);
         }
       });
+
       it('treats "show" like "notes"', function () {
         setLocation({
           pathname: '/foo/bar/merge_requests/1/commits'
@@ -207,12 +223,16 @@ require('vendor/jquery.scrollTo');
 
     describe('#tabShown', () => {
       beforeEach(function () {
+        spyOn($, 'ajax').and.callFake(function (options) {
+          options.success({ html: '' });
+        });
         loadFixtures('merge_requests/merge_request_with_task_list.html.raw');
       });
 
       describe('with "Side-by-side"/parallel diff view', () => {
         beforeEach(function () {
           this.class.diffViewType = () => 'parallel';
+          gl.Diff.prototype.diffViewType = () => 'parallel';
         });
 
         it('maintains `container-limited` for pipelines tab', function (done) {
@@ -224,7 +244,6 @@ require('vendor/jquery.scrollTo');
               });
             });
           };
-
           asyncClick('.merge-request-tabs .pipelines-tab a')
             .then(() => asyncClick('.merge-request-tabs .diffs-tab a'))
             .then(() => asyncClick('.merge-request-tabs .pipelines-tab a'))
@@ -237,6 +256,28 @@ require('vendor/jquery.scrollTo');
               done.fail(`Something went wrong clicking MR tabs: ${err.message}\n${err.stack}`);
             });
         });
+
+        it('maintains `container-limited` when switching from "Changes" tab before it loads', function (done) {
+          const asyncClick = function (selector) {
+            return new Promise((resolve) => {
+              setTimeout(() => {
+                document.querySelector(selector).click();
+                resolve();
+              });
+            });
+          };
+
+          asyncClick('.merge-request-tabs .diffs-tab a')
+            .then(() => asyncClick('.merge-request-tabs .notes-tab a'))
+            .then(() => {
+              const hasContainerLimitedClass = document.querySelector('.content-wrapper .container-fluid').classList.contains('container-limited');
+              expect(hasContainerLimitedClass).toBe(true);
+            })
+            .then(done)
+            .catch((err) => {
+              done.fail(`Something went wrong clicking MR tabs: ${err.message}\n${err.stack}`);
+            });
+        });
       });
     });
 
diff --git a/spec/javascripts/u2f/register_spec.js b/spec/javascripts/u2f/register_spec.js
index 0f390c8b980..3960759f7cb 100644
--- a/spec/javascripts/u2f/register_spec.js
+++ b/spec/javascripts/u2f/register_spec.js
@@ -22,7 +22,7 @@ require('./mock_u2f_device');
     it('allows registering a U2F device', function() {
       var deviceResponse, inProgressMessage, registeredMessage, setupButton;
       setupButton = this.container.find("#js-setup-u2f-device");
-      expect(setupButton.text()).toBe('Setup New U2F Device');
+      expect(setupButton.text()).toBe('Setup new U2F device');
       setupButton.trigger('click');
       inProgressMessage = this.container.children("p");
       expect(inProgressMessage.text()).toContain("Trying to communicate with your device");
diff --git a/spec/javascripts/vue_pipelines_index/async_button_spec.js b/spec/javascripts/vue_pipelines_index/async_button_spec.js
index bc8e504c413..6e910d2dc71 100644
--- a/spec/javascripts/vue_pipelines_index/async_button_spec.js
+++ b/spec/javascripts/vue_pipelines_index/async_button_spec.js
@@ -1,5 +1,5 @@
 import Vue from 'vue';
-import asyncButtonComp from '~/vue_pipelines_index/components/async_button';
+import asyncButtonComp from '~/vue_pipelines_index/components/async_button.vue';
 
 describe('Pipelines Async Button', () => {
   let component;
diff --git a/spec/javascripts/vue_pipelines_index/empty_state_spec.js b/spec/javascripts/vue_pipelines_index/empty_state_spec.js
index 733337168dc..2b10d54babe 100644
--- a/spec/javascripts/vue_pipelines_index/empty_state_spec.js
+++ b/spec/javascripts/vue_pipelines_index/empty_state_spec.js
@@ -1,5 +1,5 @@
 import Vue from 'vue';
-import emptyStateComp from '~/vue_pipelines_index/components/empty_state';
+import emptyStateComp from '~/vue_pipelines_index/components/empty_state.vue';
 
 describe('Pipelines Empty State', () => {
   let component;
diff --git a/spec/javascripts/vue_pipelines_index/error_state_spec.js b/spec/javascripts/vue_pipelines_index/error_state_spec.js
index 524e018b1fa..7999c15c18d 100644
--- a/spec/javascripts/vue_pipelines_index/error_state_spec.js
+++ b/spec/javascripts/vue_pipelines_index/error_state_spec.js
@@ -1,5 +1,5 @@
 import Vue from 'vue';
-import errorStateComp from '~/vue_pipelines_index/components/error_state';
+import errorStateComp from '~/vue_pipelines_index/components/error_state.vue';
 
 describe('Pipelines Error State', () => {
   let component;
diff --git a/spec/lib/banzai/filter/issuable_state_filter_spec.rb b/spec/lib/banzai/filter/issuable_state_filter_spec.rb
new file mode 100644
index 00000000000..603b79a323c
--- /dev/null
+++ b/spec/lib/banzai/filter/issuable_state_filter_spec.rb
@@ -0,0 +1,95 @@
+require 'spec_helper'
+
+describe Banzai::Filter::IssuableStateFilter, lib: true do
+  include ActionView::Helpers::UrlHelper
+  include FilterSpecHelper
+
+  let(:user) { create(:user) }
+
+  def create_link(data)
+    link_to('text', '', class: 'gfm has-tooltip', data: data)
+  end
+
+  it 'ignores non-GFM links' do
+    html = %(See <a href="https://google.com/">Google</a>)
+    doc = filter(html, current_user: user)
+
+    expect(doc.css('a').last.text).to eq('Google')
+  end
+
+  it 'ignores non-issuable links' do
+    project = create(:empty_project, :public)
+    link = create_link(project: project, reference_type: 'issue')
+    doc = filter(link, current_user: user)
+
+    expect(doc.css('a').last.text).to eq('text')
+  end
+
+  context 'for issue references' do
+    it 'ignores open issue references' do
+      issue = create(:issue)
+      link = create_link(issue: issue.id, reference_type: 'issue')
+      doc = filter(link, current_user: user)
+
+      expect(doc.css('a').last.text).to eq('text')
+    end
+
+    it 'ignores reopened issue references' do
+      reopened_issue = create(:issue, :reopened)
+      link = create_link(issue: reopened_issue.id, reference_type: 'issue')
+      doc = filter(link, current_user: user)
+
+      expect(doc.css('a').last.text).to eq('text')
+    end
+
+    it 'appends [closed] to closed issue references' do
+      closed_issue = create(:issue, :closed)
+      link = create_link(issue: closed_issue.id, reference_type: 'issue')
+      doc = filter(link, current_user: user)
+
+      expect(doc.css('a').last.text).to eq('text [closed]')
+    end
+  end
+
+  context 'for merge request references' do
+    it 'ignores open merge request references' do
+      mr = create(:merge_request)
+      link = create_link(merge_request: mr.id, reference_type: 'merge_request')
+      doc = filter(link, current_user: user)
+
+      expect(doc.css('a').last.text).to eq('text')
+    end
+
+    it 'ignores reopened merge request references' do
+      mr = create(:merge_request, :reopened)
+      link = create_link(merge_request: mr.id, reference_type: 'merge_request')
+      doc = filter(link, current_user: user)
+
+      expect(doc.css('a').last.text).to eq('text')
+    end
+
+    it 'ignores locked merge request references' do
+      mr = create(:merge_request, :locked)
+      link = create_link(merge_request: mr.id, reference_type: 'merge_request')
+      doc = filter(link, current_user: user)
+
+      expect(doc.css('a').last.text).to eq('text')
+    end
+
+    it 'appends [closed] to closed merge request references' do
+      mr = create(:merge_request, :closed)
+      link = create_link(merge_request: mr.id, reference_type: 'merge_request')
+      doc = filter(link, current_user: user)
+
+      expect(doc.css('a').last.text).to eq('text [closed]')
+    end
+
+    it 'appends [merged] to merged merge request references' do
+      mr = create(:merge_request, :merged)
+      link = create_link(merge_request: mr.id, reference_type: 'merge_request')
+      doc = filter(link, current_user: user)
+
+      expect(doc.css('a').last.text).to eq('text [merged]')
+    end
+  end
+end
diff --git a/spec/lib/banzai/filter/redactor_filter_spec.rb b/spec/lib/banzai/filter/redactor_filter_spec.rb
index 0140a91c7ba..8a6fe1ad6a3 100644
--- a/spec/lib/banzai/filter/redactor_filter_spec.rb
+++ b/spec/lib/banzai/filter/redactor_filter_spec.rb
@@ -15,6 +15,16 @@ describe Banzai::Filter::RedactorFilter, lib: true do
     link_to('text', '', class: 'gfm', data: data)
   end
 
+  it 'skips when the skip_redaction flag is set' do
+    user = create(:user)
+    project = create(:empty_project)
+
+    link = reference_link(project: project.id, reference_type: 'test')
+    doc = filter(link, current_user: user, skip_redaction: true)
+
+    expect(doc.css('a').length).to eq 1
+  end
+
   context 'with data-project' do
     let(:parser_class) do
       Class.new(Banzai::ReferenceParser::BaseParser) do
diff --git a/spec/lib/banzai/issuable_extractor_spec.rb b/spec/lib/banzai/issuable_extractor_spec.rb
new file mode 100644
index 00000000000..e5d332efb08
--- /dev/null
+++ b/spec/lib/banzai/issuable_extractor_spec.rb
@@ -0,0 +1,52 @@
+require 'spec_helper'
+
+describe Banzai::IssuableExtractor, lib: true do
+  let(:project) { create(:empty_project) }
+  let(:user) { create(:user) }
+  let(:extractor) { described_class.new(project, user) }
+  let(:issue) { create(:issue, project: project) }
+  let(:merge_request) { create(:merge_request, source_project: project) }
+  let(:issue_link) do
+    html_to_node(
+      "<a href='' data-issue='#{issue.id}' data-reference-type='issue' class='gfm'>text</a>"
+    )
+  end
+  let(:merge_request_link) do
+    html_to_node(
+      "<a href='' data-merge-request='#{merge_request.id}' data-reference-type='merge_request' class='gfm'>text</a>"
+    )
+  end
+
+  def html_to_node(html)
+    Nokogiri::HTML.fragment(
+      html
+    ).children[0]
+  end
+
+  it 'returns instances of issuables for nodes with references' do
+    result = extractor.extract([issue_link, merge_request_link])
+
+    expect(result).to eq(issue_link => issue, merge_request_link => merge_request)
+  end
+
+  describe 'caching' do
+    before do
+      RequestStore.begin!
+    end
+
+    after do
+      RequestStore.end!
+      RequestStore.clear!
+    end
+
+    it 'saves records to cache' do
+      extractor.extract([issue_link, merge_request_link])
+
+      second_call_queries = ActiveRecord::QueryRecorder.new do
+        extractor.extract([issue_link, merge_request_link])
+      end.count
+
+      expect(second_call_queries).to eq 0
+    end
+  end
+end
diff --git a/spec/lib/banzai/object_renderer_spec.rb b/spec/lib/banzai/object_renderer_spec.rb
index 6bcda87c999..4817fcd031a 100644
--- a/spec/lib/banzai/object_renderer_spec.rb
+++ b/spec/lib/banzai/object_renderer_spec.rb
@@ -3,128 +3,51 @@ require 'spec_helper'
 describe Banzai::ObjectRenderer do
   let(:project) { create(:empty_project) }
   let(:user) { project.owner }
-
-  def fake_object(attrs = {})
-    object = double(attrs.merge("new_record?" => true, "destroyed?" => true))
-    allow(object).to receive(:markdown_cache_field_for).with(:note).and_return(:note_html)
-    allow(object).to receive(:banzai_render_context).with(:note).and_return(project: nil, author: nil)
-    allow(object).to receive(:update_column).with(:note_html, anything).and_return(true)
-    object
-  end
+  let(:renderer) { described_class.new(project, user, custom_value: 'value') }
+  let(:object) { Note.new(note: 'hello', note_html: '<p>hello</p>') }
 
   describe '#render' do
     it 'renders and redacts an Array of objects' do
-      renderer = described_class.new(project, user)
-      object = fake_object(note: 'hello', note_html: nil)
-
-      expect(renderer).to receive(:render_objects).with([object], :note).
-        and_call_original
-
-      expect(renderer).to receive(:redact_documents).
-        with(an_instance_of(Array)).
-        and_call_original
-
-      expect(object).to receive(:redacted_note_html=).with('<p dir="auto">hello</p>')
-      expect(object).to receive(:user_visible_reference_count=).with(0)
-
       renderer.render([object], :note)
-    end
-  end
-
-  describe '#render_objects' do
-    it 'renders an Array of objects' do
-      object = fake_object(note: 'hello', note_html: nil)
-
-      renderer = described_class.new(project, user)
 
-      expect(renderer).to receive(:render_attributes).with([object], :note).
-        and_call_original
-
-      rendered = renderer.render_objects([object], :note)
-
-      expect(rendered).to be_an_instance_of(Array)
-      expect(rendered[0]).to be_an_instance_of(Nokogiri::HTML::DocumentFragment)
-    end
-  end
-
-  describe '#redact_documents' do
-    it 'redacts a set of documents and returns them as an Array of Hashes' do
-      doc = Nokogiri::HTML.fragment('<p>hello</p>')
-      renderer = described_class.new(project, user)
-
-      expect_any_instance_of(Banzai::Redactor).to receive(:redact).
-        with([doc]).
-        and_call_original
-
-      redacted = renderer.redact_documents([doc])
-
-      expect(redacted.count).to eq(1)
-      expect(redacted.first[:visible_reference_count]).to eq(0)
-      expect(redacted.first[:document].to_html).to eq('<p>hello</p>')
+      expect(object.redacted_note_html).to eq '<p>hello</p>'
+      expect(object.user_visible_reference_count).to eq 0
     end
-  end
 
-  describe '#context_for' do
-    let(:object) { fake_object(note: 'hello') }
-    let(:renderer) { described_class.new(project, user) }
+    it 'calls Banzai::Redactor to perform redaction' do
+      expect_any_instance_of(Banzai::Redactor).to receive(:redact).and_call_original
 
-    it 'returns a Hash' do
-      expect(renderer.context_for(object, :note)).to be_an_instance_of(Hash)
-    end
-
-    it 'includes the banzai render context for the object' do
-      expect(object).to receive(:banzai_render_context).with(:note).and_return(foo: :bar)
-      context = renderer.context_for(object, :note)
-      expect(context).to have_key(:foo)
-      expect(context[:foo]).to eq(:bar)
-    end
-  end
-
-  describe '#render_attributes' do
-    it 'renders the attribute of a list of objects' do
-      objects = [fake_object(note: 'hello', note_html: nil), fake_object(note: 'bye', note_html: nil)]
-      renderer = described_class.new(project, user)
-
-      objects.each do |object|
-        expect(Banzai).to receive(:render_field).with(object, :note).and_call_original
-      end
-
-      docs = renderer.render_attributes(objects, :note)
-
-      expect(docs[0]).to be_an_instance_of(Nokogiri::HTML::DocumentFragment)
-      expect(docs[0].to_html).to eq('<p dir="auto">hello</p>')
-
-      expect(docs[1]).to be_an_instance_of(Nokogiri::HTML::DocumentFragment)
-      expect(docs[1].to_html).to eq('<p dir="auto">bye</p>')
-    end
-
-    it 'returns when no objects to render' do
-      objects = []
-      renderer = described_class.new(project, user, pipeline: :note)
-
-      expect(renderer.render_attributes(objects, :note)).to eq([])
+      renderer.render([object], :note)
     end
-  end
 
-  describe '#base_context' do
-    let(:context) do
-      described_class.new(project, user, foo: :bar).base_context
-    end
+    it 'retrieves field content using Banzai.render_field' do
+      expect(Banzai).to receive(:render_field).with(object, :note).and_call_original
 
-    it 'returns a Hash' do
-      expect(context).to be_an_instance_of(Hash)
-    end
-
-    it 'includes the custom attributes' do
-      expect(context[:foo]).to eq(:bar)
+      renderer.render([object], :note)
     end
 
-    it 'includes the current user' do
-      expect(context[:current_user]).to eq(user)
-    end
+    it 'passes context to PostProcessPipeline' do
+      another_user = create(:user)
+      another_project = create(:empty_project)
+      object = Note.new(
+        note: 'hello',
+        note_html: 'hello',
+        author: another_user,
+        project: another_project
+      )
+
+      expect(Banzai::Pipeline::PostProcessPipeline).to receive(:to_document).with(
+        anything,
+        hash_including(
+          skip_redaction: true,
+          current_user: user,
+          project: another_project,
+          author: another_user,
+          custom_value: 'value'
+        )
+      ).and_call_original
 
-    it 'includes the current project' do
-      expect(context[:project]).to eq(project)
+      renderer.render([object], :note)
     end
   end
 end
diff --git a/spec/lib/banzai/reference_parser/base_parser_spec.rb b/spec/lib/banzai/reference_parser/base_parser_spec.rb
index aa127f0179d..a3141894c74 100644
--- a/spec/lib/banzai/reference_parser/base_parser_spec.rb
+++ b/spec/lib/banzai/reference_parser/base_parser_spec.rb
@@ -92,16 +92,26 @@ describe Banzai::ReferenceParser::BaseParser, lib: true do
   end
 
   describe '#grouped_objects_for_nodes' do
-    it 'returns a Hash grouping objects per ID' do
-      nodes = [double(:node)]
+    it 'returns a Hash grouping objects per node' do
+      link = double(:link)
+
+      expect(link).to receive(:has_attribute?).
+        with('data-user').
+        and_return(true)
+
+      expect(link).to receive(:attr).
+        with('data-user').
+        and_return(user.id.to_s)
+
+      nodes = [link]
 
       expect(subject).to receive(:unique_attribute_values).
         with(nodes, 'data-user').
-        and_return([user.id])
+        and_return([user.id.to_s])
 
       hash = subject.grouped_objects_for_nodes(nodes, User, 'data-user')
 
-      expect(hash).to eq({ user.id => user })
+      expect(hash).to eq({ link => user })
     end
 
     it 'returns an empty Hash when the list of nodes is empty' do
diff --git a/spec/lib/banzai/reference_parser/issue_parser_spec.rb b/spec/lib/banzai/reference_parser/issue_parser_spec.rb
index 6873b7b85f9..7031c47231c 100644
--- a/spec/lib/banzai/reference_parser/issue_parser_spec.rb
+++ b/spec/lib/banzai/reference_parser/issue_parser_spec.rb
@@ -67,6 +67,16 @@ describe Banzai::ReferenceParser::IssueParser, lib: true do
           expect(subject.referenced_by([])).to eq([])
         end
       end
+
+      context 'when issue with given ID does not exist' do
+        before do
+          link['data-issue'] = '-1'
+        end
+
+        it 'returns an empty Array' do
+          expect(subject.referenced_by([link])).to eq([])
+        end
+      end
     end
   end
 
@@ -75,7 +85,7 @@ describe Banzai::ReferenceParser::IssueParser, lib: true do
       link['data-issue'] = issue.id.to_s
       nodes = [link]
 
-      expect(subject.issues_for_nodes(nodes)).to eq({ issue.id => issue })
+      expect(subject.issues_for_nodes(nodes)).to eq({ link => issue })
     end
   end
 end
diff --git a/spec/lib/banzai/reference_parser/user_parser_spec.rb b/spec/lib/banzai/reference_parser/user_parser_spec.rb
index 31ca9d27b0b..4ec998efe53 100644
--- a/spec/lib/banzai/reference_parser/user_parser_spec.rb
+++ b/spec/lib/banzai/reference_parser/user_parser_spec.rb
@@ -180,6 +180,15 @@ describe Banzai::ReferenceParser::UserParser, lib: true do
 
         expect(subject.nodes_user_can_reference(user, [link])).to eq([])
       end
+
+      it 'returns the nodes if the project attribute value equals the current project ID' do
+        other_user = create(:user)
+
+        link['data-project'] = project.id.to_s
+        link['data-author'] = other_user.id.to_s
+
+        expect(subject.nodes_user_can_reference(user, [link])).to eq([link])
+      end
     end
 
     context 'when the link does not have a data-author attribute' do
diff --git a/spec/lib/ci/ansi2html_spec.rb b/spec/lib/ci/ansi2html_spec.rb
index 0762fd7e56a..a5dfb49478a 100644
--- a/spec/lib/ci/ansi2html_spec.rb
+++ b/spec/lib/ci/ansi2html_spec.rb
@@ -1,159 +1,160 @@
 require 'spec_helper'
 
 describe Ci::Ansi2html, lib: true do
-  subject { Ci::Ansi2html }
+  subject { described_class }
 
   it "prints non-ansi as-is" do
-    expect(subject.convert("Hello")[:html]).to eq('Hello')
+    expect(convert_html("Hello")).to eq('Hello')
   end
 
   it "strips non-color-changing controll sequences" do
-    expect(subject.convert("Hello \e[2Kworld")[:html]).to eq('Hello world')
+    expect(convert_html("Hello \e[2Kworld")).to eq('Hello world')
   end
 
   it "prints simply red" do
-    expect(subject.convert("\e[31mHello\e[0m")[:html]).to eq('<span class="term-fg-red">Hello</span>')
+    expect(convert_html("\e[31mHello\e[0m")).to eq('<span class="term-fg-red">Hello</span>')
   end
 
   it "prints simply red without trailing reset" do
-    expect(subject.convert("\e[31mHello")[:html]).to eq('<span class="term-fg-red">Hello</span>')
+    expect(convert_html("\e[31mHello")).to eq('<span class="term-fg-red">Hello</span>')
   end
 
   it "prints simply yellow" do
-    expect(subject.convert("\e[33mHello\e[0m")[:html]).to eq('<span class="term-fg-yellow">Hello</span>')
+    expect(convert_html("\e[33mHello\e[0m")).to eq('<span class="term-fg-yellow">Hello</span>')
   end
 
   it "prints default on blue" do
-    expect(subject.convert("\e[39;44mHello")[:html]).to eq('<span class="term-bg-blue">Hello</span>')
+    expect(convert_html("\e[39;44mHello")).to eq('<span class="term-bg-blue">Hello</span>')
   end
 
   it "prints red on blue" do
-    expect(subject.convert("\e[31;44mHello")[:html]).to eq('<span class="term-fg-red term-bg-blue">Hello</span>')
+    expect(convert_html("\e[31;44mHello")).to eq('<span class="term-fg-red term-bg-blue">Hello</span>')
   end
 
   it "resets colors after red on blue" do
-    expect(subject.convert("\e[31;44mHello\e[0m world")[:html]).to eq('<span class="term-fg-red term-bg-blue">Hello</span> world')
+    expect(convert_html("\e[31;44mHello\e[0m world")).to eq('<span class="term-fg-red term-bg-blue">Hello</span> world')
   end
 
   it "performs color change from red/blue to yellow/blue" do
-    expect(subject.convert("\e[31;44mHello \e[33mworld")[:html]).to eq('<span class="term-fg-red term-bg-blue">Hello </span><span class="term-fg-yellow term-bg-blue">world</span>')
+    expect(convert_html("\e[31;44mHello \e[33mworld")).to eq('<span class="term-fg-red term-bg-blue">Hello </span><span class="term-fg-yellow term-bg-blue">world</span>')
   end
 
   it "performs color change from red/blue to yellow/green" do
-    expect(subject.convert("\e[31;44mHello \e[33;42mworld")[:html]).to eq('<span class="term-fg-red term-bg-blue">Hello </span><span class="term-fg-yellow term-bg-green">world</span>')
+    expect(convert_html("\e[31;44mHello \e[33;42mworld")).to eq('<span class="term-fg-red term-bg-blue">Hello </span><span class="term-fg-yellow term-bg-green">world</span>')
   end
 
   it "performs color change from red/blue to reset to yellow/green" do
-    expect(subject.convert("\e[31;44mHello\e[0m \e[33;42mworld")[:html]).to eq('<span class="term-fg-red term-bg-blue">Hello</span> <span class="term-fg-yellow term-bg-green">world</span>')
+    expect(convert_html("\e[31;44mHello\e[0m \e[33;42mworld")).to eq('<span class="term-fg-red term-bg-blue">Hello</span> <span class="term-fg-yellow term-bg-green">world</span>')
   end
 
   it "ignores unsupported codes" do
-    expect(subject.convert("\e[51mHello\e[0m")[:html]).to eq('Hello')
+    expect(convert_html("\e[51mHello\e[0m")).to eq('Hello')
   end
 
   it "prints light red" do
-    expect(subject.convert("\e[91mHello\e[0m")[:html]).to eq('<span class="term-fg-l-red">Hello</span>')
+    expect(convert_html("\e[91mHello\e[0m")).to eq('<span class="term-fg-l-red">Hello</span>')
   end
 
   it "prints default on light red" do
-    expect(subject.convert("\e[101mHello\e[0m")[:html]).to eq('<span class="term-bg-l-red">Hello</span>')
+    expect(convert_html("\e[101mHello\e[0m")).to eq('<span class="term-bg-l-red">Hello</span>')
   end
 
   it "performs color change from red/blue to default/blue" do
-    expect(subject.convert("\e[31;44mHello \e[39mworld")[:html]).to eq('<span class="term-fg-red term-bg-blue">Hello </span><span class="term-bg-blue">world</span>')
+    expect(convert_html("\e[31;44mHello \e[39mworld")).to eq('<span class="term-fg-red term-bg-blue">Hello </span><span class="term-bg-blue">world</span>')
   end
 
   it "performs color change from light red/blue to default/blue" do
-    expect(subject.convert("\e[91;44mHello \e[39mworld")[:html]).to eq('<span class="term-fg-l-red term-bg-blue">Hello </span><span class="term-bg-blue">world</span>')
+    expect(convert_html("\e[91;44mHello \e[39mworld")).to eq('<span class="term-fg-l-red term-bg-blue">Hello </span><span class="term-bg-blue">world</span>')
   end
 
   it "prints bold text" do
-    expect(subject.convert("\e[1mHello")[:html]).to eq('<span class="term-bold">Hello</span>')
+    expect(convert_html("\e[1mHello")).to eq('<span class="term-bold">Hello</span>')
   end
 
   it "resets bold text" do
-    expect(subject.convert("\e[1mHello\e[21m world")[:html]).to eq('<span class="term-bold">Hello</span> world')
-    expect(subject.convert("\e[1mHello\e[22m world")[:html]).to eq('<span class="term-bold">Hello</span> world')
+    expect(convert_html("\e[1mHello\e[21m world")).to eq('<span class="term-bold">Hello</span> world')
+    expect(convert_html("\e[1mHello\e[22m world")).to eq('<span class="term-bold">Hello</span> world')
   end
 
   it "prints italic text" do
-    expect(subject.convert("\e[3mHello")[:html]).to eq('<span class="term-italic">Hello</span>')
+    expect(convert_html("\e[3mHello")).to eq('<span class="term-italic">Hello</span>')
   end
 
   it "resets italic text" do
-    expect(subject.convert("\e[3mHello\e[23m world")[:html]).to eq('<span class="term-italic">Hello</span> world')
+    expect(convert_html("\e[3mHello\e[23m world")).to eq('<span class="term-italic">Hello</span> world')
   end
 
   it "prints underlined text" do
-    expect(subject.convert("\e[4mHello")[:html]).to eq('<span class="term-underline">Hello</span>')
+    expect(convert_html("\e[4mHello")).to eq('<span class="term-underline">Hello</span>')
   end
 
   it "resets underlined text" do
-    expect(subject.convert("\e[4mHello\e[24m world")[:html]).to eq('<span class="term-underline">Hello</span> world')
+    expect(convert_html("\e[4mHello\e[24m world")).to eq('<span class="term-underline">Hello</span> world')
   end
 
   it "prints concealed text" do
-    expect(subject.convert("\e[8mHello")[:html]).to eq('<span class="term-conceal">Hello</span>')
+    expect(convert_html("\e[8mHello")).to eq('<span class="term-conceal">Hello</span>')
   end
 
   it "resets concealed text" do
-    expect(subject.convert("\e[8mHello\e[28m world")[:html]).to eq('<span class="term-conceal">Hello</span> world')
+    expect(convert_html("\e[8mHello\e[28m world")).to eq('<span class="term-conceal">Hello</span> world')
   end
 
   it "prints crossed-out text" do
-    expect(subject.convert("\e[9mHello")[:html]).to eq('<span class="term-cross">Hello</span>')
+    expect(convert_html("\e[9mHello")).to eq('<span class="term-cross">Hello</span>')
   end
 
   it "resets crossed-out text" do
-    expect(subject.convert("\e[9mHello\e[29m world")[:html]).to eq('<span class="term-cross">Hello</span> world')
+    expect(convert_html("\e[9mHello\e[29m world")).to eq('<span class="term-cross">Hello</span> world')
   end
 
   it "can print 256 xterm fg colors" do
-    expect(subject.convert("\e[38;5;16mHello")[:html]).to eq('<span class="xterm-fg-16">Hello</span>')
+    expect(convert_html("\e[38;5;16mHello")).to eq('<span class="xterm-fg-16">Hello</span>')
   end
 
   it "can print 256 xterm fg colors on normal magenta background" do
-    expect(subject.convert("\e[38;5;16;45mHello")[:html]).to eq('<span class="xterm-fg-16 term-bg-magenta">Hello</span>')
+    expect(convert_html("\e[38;5;16;45mHello")).to eq('<span class="xterm-fg-16 term-bg-magenta">Hello</span>')
   end
 
   it "can print 256 xterm bg colors" do
-    expect(subject.convert("\e[48;5;240mHello")[:html]).to eq('<span class="xterm-bg-240">Hello</span>')
+    expect(convert_html("\e[48;5;240mHello")).to eq('<span class="xterm-bg-240">Hello</span>')
   end
 
   it "can print 256 xterm bg colors on normal magenta foreground" do
-    expect(subject.convert("\e[48;5;16;35mHello")[:html]).to eq('<span class="term-fg-magenta xterm-bg-16">Hello</span>')
+    expect(convert_html("\e[48;5;16;35mHello")).to eq('<span class="term-fg-magenta xterm-bg-16">Hello</span>')
   end
 
   it "prints bold colored text vividly" do
-    expect(subject.convert("\e[1;31mHello\e[0m")[:html]).to eq('<span class="term-fg-l-red term-bold">Hello</span>')
+    expect(convert_html("\e[1;31mHello\e[0m")).to eq('<span class="term-fg-l-red term-bold">Hello</span>')
   end
 
   it "prints bold light colored text correctly" do
-    expect(subject.convert("\e[1;91mHello\e[0m")[:html]).to eq('<span class="term-fg-l-red term-bold">Hello</span>')
+    expect(convert_html("\e[1;91mHello\e[0m")).to eq('<span class="term-fg-l-red term-bold">Hello</span>')
   end
 
   it "prints &lt;" do
-    expect(subject.convert("<")[:html]).to eq('&lt;')
+    expect(convert_html("<")).to eq('&lt;')
   end
 
   it "replaces newlines with line break tags" do
-    expect(subject.convert("\n")[:html]).to eq('<br>')
+    expect(convert_html("\n")).to eq('<br>')
   end
 
   it "groups carriage returns with newlines" do
-    expect(subject.convert("\r\n")[:html]).to eq('<br>')
+    expect(convert_html("\r\n")).to eq('<br>')
   end
 
   describe "incremental update" do
     shared_examples 'stateable converter' do
-      let(:pass1) { subject.convert(pre_text) }
-      let(:pass2) { subject.convert(pre_text + text, pass1[:state]) }
+      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) }
 
       it "to returns html to append" do
-        expect(pass2[:append]).to be_truthy
-        expect(pass2[:html]).to eq(html)
-        expect(pass1[:text] + pass2[:text]).to eq(pre_text + text)
-        expect(pass1[:html] + pass2[:html]).to eq(pre_html + html)
+        expect(pass2.append).to be_truthy
+        expect(pass2.html).to eq(html)
+        expect(pass1.html + pass2.html).to eq(pre_html + html)
       end
     end
 
@@ -193,4 +194,27 @@ describe Ci::Ansi2html, lib: true do
       it_behaves_like 'stateable converter'
     end
   end
+
+  describe "truncates" 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_html(data)
+    stream = StringIO.new(data)
+    subject.convert(stream).html
+  end
 end
diff --git a/spec/lib/container_registry/blob_spec.rb b/spec/lib/container_registry/blob_spec.rb
index bbacdc67ebd..f06e5fd54a2 100644
--- a/spec/lib/container_registry/blob_spec.rb
+++ b/spec/lib/container_registry/blob_spec.rb
@@ -1,110 +1,121 @@
 require 'spec_helper'
 
 describe ContainerRegistry::Blob do
-  let(:digest) { 'sha256:0123456789012345' }
+  let(:group) { create(:group, name: 'group') }
+  let(:project) { create(:empty_project, path: 'test', group: group) }
+
+  let(:repository) do
+    create(:container_repository, name: 'image',
+                                  tags: %w[latest rc1],
+                                  project: project)
+  end
+
   let(:config) do
-    {
-      'digest' => digest,
+    { 'digest' => 'sha256:0123456789012345',
       'mediaType' => 'binary',
-      'size' => 1000
-    }
+      'size' => 1000 }
+  end
+
+  let(:blob) { described_class.new(repository, config) }
+
+  before do
+    stub_container_registry_config(enabled: true,
+                                   api_url: 'http://registry.gitlab',
+                                   host_port: 'registry.gitlab')
   end
-  let(:token) { 'authorization-token' }
-  
-  let(:registry) { ContainerRegistry::Registry.new('http://example.com', token: token) }
-  let(:repository) { registry.repository('group/test') }
-  let(:blob) { repository.blob(config) }
 
   it { expect(blob).to respond_to(:repository) }
   it { expect(blob).to delegate_method(:registry).to(:repository) }
   it { expect(blob).to delegate_method(:client).to(:repository) }
 
-  context '#path' do
-    subject { blob.path }
-
-    it { is_expected.to eq('example.com/group/test@sha256:0123456789012345') }
+  describe '#path' do
+    it 'returns a valid path to the blob' do
+      expect(blob.path).to eq('group/test/image@sha256:0123456789012345')
+    end
   end
 
-  context '#digest' do
-    subject { blob.digest }
-
-    it { is_expected.to eq(digest) }
+  describe '#digest' do
+    it 'return correct digest value' do
+      expect(blob.digest).to eq 'sha256:0123456789012345'
+    end
   end
 
-  context '#type' do
-    subject { blob.type }
-
-    it { is_expected.to eq('binary') }
+  describe '#type' do
+    it 'returns a correct type' do
+      expect(blob.type).to eq 'binary'
+    end
   end
 
-  context '#revision' do
-    subject { blob.revision }
-
-    it { is_expected.to eq('0123456789012345') }
+  describe '#revision' do
+    it 'returns a correct blob SHA' do
+      expect(blob.revision).to eq '0123456789012345'
+    end
   end
 
-  context '#short_revision' do
-    subject { blob.short_revision }
-
-    it { is_expected.to eq('012345678') }
+  describe '#short_revision' do
+    it 'return a short SHA' do
+      expect(blob.short_revision).to eq '012345678'
+    end
   end
 
-  context '#delete' do
+  describe '#delete' do
     before do
-      stub_request(:delete, 'http://example.com/v2/group/test/blobs/sha256:0123456789012345').
-        to_return(status: 200)
+      stub_request(:delete, 'http://registry.gitlab/v2/group/test/image/blobs/sha256:0123456789012345')
+        .to_return(status: 200)
     end
 
-    subject { blob.delete }
-
-    it { is_expected.to be_truthy }
+    it 'returns true when blob has been successfuly deleted' do
+      expect(blob.delete).to be_truthy
+    end
   end
 
-  context '#data' do
-    let(:data) { '{"key":"value"}' }
-
-    subject { blob.data }
-
+  describe '#data' do
     context 'when locally stored' do
       before do
-        stub_request(:get, 'http://example.com/v2/group/test/blobs/sha256:0123456789012345').
+        stub_request(:get, 'http://registry.gitlab/v2/group/test/image/blobs/sha256:0123456789012345').
           to_return(
             status: 200,
             headers: { 'Content-Type' => 'application/json' },
-            body: data)
+            body: '{"key":"value"}')
       end
 
-      it { is_expected.to eq(data) }
+      it 'returns a correct blob data' do
+        expect(blob.data).to eq '{"key":"value"}'
+      end
     end
 
     context 'when externally stored' do
+      let(:location) { 'http://external.com/blob/file' }
+
       before do
-        stub_request(:get, 'http://example.com/v2/group/test/blobs/sha256:0123456789012345').
-          with(headers: { 'Authorization' => "bearer #{token}" }).
-          to_return(
+        stub_request(:get, 'http://registry.gitlab/v2/group/test/image/blobs/sha256:0123456789012345')
+          .with(headers: { 'Authorization' => 'bearer token' })
+          .to_return(
             status: 307,
             headers: { 'Location' => location })
       end
 
       context 'for a valid address' do
-        let(:location) { 'http://external.com/blob/file' }
-
         before do
           stub_request(:get, location).
             with(headers: { 'Authorization' => nil }).
             to_return(
               status: 200,
               headers: { 'Content-Type' => 'application/json' },
-              body: data)
+              body: '{"key":"value"}')
         end
 
-        it { is_expected.to eq(data) }
+        it 'returns correct data' do
+          expect(blob.data).to eq '{"key":"value"}'
+        end
       end
 
       context 'for invalid file' do
         let(:location) { 'file:///etc/passwd' }
 
-        it { expect{ subject }.to raise_error(ArgumentError, 'invalid address') }
+        it 'raises an error' do
+          expect { blob.data }.to raise_error(ArgumentError, 'invalid address')
+        end
       end
     end
   end
diff --git a/spec/lib/container_registry/path_spec.rb b/spec/lib/container_registry/path_spec.rb
new file mode 100644
index 00000000000..b9c4572c269
--- /dev/null
+++ b/spec/lib/container_registry/path_spec.rb
@@ -0,0 +1,212 @@
+require 'spec_helper'
+
+describe ContainerRegistry::Path do
+  subject { described_class.new(path) }
+
+  describe '#components' do
+    let(:path) { 'path/to/some/project' }
+
+    it 'splits components by a forward slash' do
+      expect(subject.components).to eq %w[path to some project]
+    end
+  end
+
+  describe '#nodes' do
+    context 'when repository path is valid' do
+      let(:path) { 'path/to/some/project' }
+
+      it 'return all project path like node in reverse order' do
+        expect(subject.nodes).to eq %w[path/to/some/project
+                                       path/to/some
+                                       path/to]
+      end
+    end
+
+    context 'when repository path is invalid' do
+      let(:path) { '' }
+
+      it 'rasises en error' do
+        expect { subject.nodes }
+          .to raise_error described_class::InvalidRegistryPathError
+      end
+    end
+  end
+
+  describe '#to_s' do
+    let(:path) { 'some/image' }
+
+    it 'return a string with a repository path' do
+      expect(subject.to_s).to eq path
+    end
+  end
+
+  describe '#valid?' do
+    context 'when path has less than two components' do
+      let(:path) { 'something/' }
+
+      it { is_expected.not_to be_valid }
+    end
+
+    context 'when path has more than allowed number of components' do
+      let(:path) { 'a/b/c/d/e/f/g/h/i/j/k/l/m/n/o/p/r/s/t/u/w/y/z' }
+
+      it { is_expected.not_to be_valid }
+    end
+
+    context 'when path has invalid characters' do
+      let(:path) { 'some\path' }
+
+      it { is_expected.not_to be_valid }
+    end
+
+    context 'when path has two or more components' do
+      let(:path) { 'some/path' }
+
+      it { is_expected.to be_valid }
+    end
+
+    context 'when path is related to multi-level image' do
+      let(:path) { 'some/path/my/image' }
+
+      it { is_expected.to be_valid }
+    end
+  end
+
+  describe '#has_repository?' do
+    context 'when project exists' do
+      let(:project) { create(:empty_project) }
+      let(:path) { "#{project.full_path}/my/image" }
+
+      context 'when path already has matching repository' do
+        before do
+          create(:container_repository, project: project, name: 'my/image')
+        end
+
+        it { is_expected.to have_repository }
+        it { is_expected.to have_project }
+      end
+
+      context 'when path does not have matching repository' do
+        it { is_expected.not_to have_repository }
+        it { is_expected.to have_project }
+      end
+    end
+
+    context 'when project does not exist' do
+      let(:path) { 'some/project/my/image' }
+
+      it { is_expected.not_to have_repository }
+      it { is_expected.not_to have_project }
+    end
+  end
+
+  describe '#repository_project' do
+    let(:group) { create(:group, path: 'some_group') }
+
+    context 'when project for given path exists' do
+      let(:path) { 'some_group/some_project' }
+
+      before do
+        create(:empty_project, group: group, name: 'some_project')
+        create(:empty_project, name: 'some_project')
+      end
+
+      it 'returns a correct project' do
+        expect(subject.repository_project.group).to eq group
+      end
+    end
+
+    context 'when project for given path does not exist' do
+      let(:path) { 'not/matching' }
+
+      it 'returns nil' do
+        expect(subject.repository_project).to be_nil
+      end
+    end
+
+    context 'when matching multi-level path' do
+      let(:project) do
+        create(:empty_project, group: group, name: 'some_project')
+      end
+
+      context 'when using the zero-level path' do
+        let(:path) { project.full_path }
+
+        it 'supports zero-level path' do
+          expect(subject.repository_project).to eq project
+        end
+      end
+
+      context 'when using first-level path' do
+        let(:path) { "#{project.full_path}/repository" }
+
+        it 'supports first-level path' do
+          expect(subject.repository_project).to eq project
+        end
+      end
+
+      context 'when using second-level path' do
+        let(:path) { "#{project.full_path}/repository/name" }
+
+        it 'supports second-level path' do
+          expect(subject.repository_project).to eq project
+        end
+      end
+
+      context 'when using too deep nesting in the path' do
+        let(:path) { "#{project.full_path}/repository/name/invalid" }
+
+        it 'does not support three-levels of nesting' do
+          expect(subject.repository_project).to be_nil
+        end
+      end
+    end
+  end
+
+  describe '#repository_name' do
+    context 'when project does not exist' do
+      let(:path) { 'some/name' }
+
+      it 'returns nil' do
+        expect(subject.repository_name).to be_nil
+      end
+    end
+
+    context 'when project exists' do
+      let(:group) { create(:group, path: 'some_group') }
+
+      let(:project) do
+        create(:empty_project, group: group, name: 'some_project')
+      end
+
+      before do
+        allow(path).to receive(:repository_project)
+          .and_return(project)
+      end
+
+      context 'when project path equal repository path' do
+        let(:path) { 'some_group/some_project' }
+
+        it 'returns an empty string' do
+          expect(subject.repository_name).to eq ''
+        end
+      end
+
+      context 'when repository path has one additional level' do
+        let(:path) { 'some_group/some_project/repository' }
+
+        it 'returns a correct repository name' do
+          expect(subject.repository_name).to eq 'repository'
+        end
+      end
+
+      context 'when repository path has two additional levels' do
+        let(:path) { 'some_group/some_project/repository/image' }
+
+        it 'returns a correct repository name' do
+          expect(subject.repository_name).to eq 'repository/image'
+        end
+      end
+    end
+  end
+end
diff --git a/spec/lib/container_registry/registry_spec.rb b/spec/lib/container_registry/registry_spec.rb
index 4f3f8b24fc4..4d6eea94bf0 100644
--- a/spec/lib/container_registry/registry_spec.rb
+++ b/spec/lib/container_registry/registry_spec.rb
@@ -10,7 +10,7 @@ describe ContainerRegistry::Registry do
   it { is_expected.to respond_to(:uri) }
   it { is_expected.to respond_to(:path) }
 
-  it { expect(subject.repository('test')).not_to be_nil }
+  it { expect(subject).not_to be_nil }
 
   context '#path' do
     subject { registry.path }
diff --git a/spec/lib/container_registry/repository_spec.rb b/spec/lib/container_registry/repository_spec.rb
deleted file mode 100644
index c364e759108..00000000000
--- a/spec/lib/container_registry/repository_spec.rb
+++ /dev/null
@@ -1,65 +0,0 @@
-require 'spec_helper'
-
-describe ContainerRegistry::Repository do
-  let(:registry) { ContainerRegistry::Registry.new('http://example.com') }
-  let(:repository) { registry.repository('group/test') }
-
-  it { expect(repository).to respond_to(:registry) }
-  it { expect(repository).to delegate_method(:client).to(:registry) }
-  it { expect(repository.tag('test')).not_to be_nil }
-
-  context '#path' do
-    subject { repository.path }
-
-    it { is_expected.to eq('example.com/group/test') }
-  end
-
-  context 'manifest processing' do
-    before do
-      stub_request(:get, 'http://example.com/v2/group/test/tags/list').
-        with(headers: { 'Accept' => 'application/vnd.docker.distribution.manifest.v2+json' }).
-        to_return(
-          status: 200,
-          body: JSON.dump(tags: ['test']),
-          headers: { 'Content-Type' => 'application/json' })
-    end
-
-    context '#manifest' do
-      subject { repository.manifest }
-
-      it { is_expected.not_to be_nil }
-    end
-
-    context '#valid?' do
-      subject { repository.valid? }
-
-      it { is_expected.to be_truthy }
-    end
-
-    context '#tags' do
-      subject { repository.tags }
-
-      it { is_expected.not_to be_empty }
-    end
-  end
-
-  context '#delete_tags' do
-    let(:tag) { ContainerRegistry::Tag.new(repository, 'tag') }
-
-    before { expect(repository).to receive(:tags).twice.and_return([tag]) }
-
-    subject { repository.delete_tags }
-
-    context 'succeeds' do
-      before { expect(tag).to receive(:delete).and_return(true) }
-
-      it { is_expected.to be_truthy }
-    end
-
-    context 'any fails' do
-      before { expect(tag).to receive(:delete).and_return(false) }
-
-      it { is_expected.to be_falsey }
-    end
-  end
-end
diff --git a/spec/lib/container_registry/tag_spec.rb b/spec/lib/container_registry/tag_spec.rb
index c5e31ae82b6..f8fffbdca41 100644
--- a/spec/lib/container_registry/tag_spec.rb
+++ b/spec/lib/container_registry/tag_spec.rb
@@ -1,25 +1,66 @@
 require 'spec_helper'
 
 describe ContainerRegistry::Tag do
-  let(:registry) { ContainerRegistry::Registry.new('http://example.com') }
-  let(:repository) { registry.repository('group/test') }
-  let(:tag) { repository.tag('tag') }
-  let(:headers) { { 'Accept' => 'application/vnd.docker.distribution.manifest.v2+json' } }
+  let(:group) { create(:group, name: 'group') }
+  let(:project) { create(:project, path: 'test', group: group) }
+
+  let(:repository) do
+    create(:container_repository, name: '', project: project)
+  end
+
+  let(:headers) do
+    { 'Accept' => 'application/vnd.docker.distribution.manifest.v2+json' }
+  end
+
+  let(:tag) { described_class.new(repository, 'tag') }
+
+  before do
+    stub_container_registry_config(enabled: true,
+                                   api_url: 'http://registry.gitlab',
+                                   host_port: 'registry.gitlab')
+  end
 
   it { expect(tag).to respond_to(:repository) }
   it { expect(tag).to delegate_method(:registry).to(:repository) }
   it { expect(tag).to delegate_method(:client).to(:repository) }
 
-  context '#path' do
-    subject { tag.path }
+  describe '#path' do
+    context 'when tag belongs to zero-level repository' do
+      let(:repository) do
+        create(:container_repository, name: '',
+                                      tags: %w[rc1],
+                                      project: project)
+      end
+
+      it 'returns path to the image' do
+        expect(tag.path).to eq('group/test:tag')
+      end
+    end
 
-    it { is_expected.to eq('example.com/group/test:tag') }
+    context 'when tag belongs to first-level repository' do
+      let(:repository) do
+        create(:container_repository, name: 'my_image',
+                                      tags: %w[tag],
+                                      project: project)
+      end
+
+      it 'returns path to the image' do
+        expect(tag.path).to eq('group/test/my_image:tag')
+      end
+    end
+  end
+
+  describe '#location' do
+    it 'returns a full location of the tag' do
+      expect(tag.location)
+        .to eq 'registry.gitlab/group/test:tag'
+    end
   end
 
   context 'manifest processing' do
     context 'schema v1' do
       before do
-        stub_request(:get, 'http://example.com/v2/group/test/manifests/tag').
+        stub_request(:get, 'http://registry.gitlab/v2/group/test/manifests/tag').
           with(headers: headers).
           to_return(
             status: 200,
@@ -56,7 +97,7 @@ describe ContainerRegistry::Tag do
 
     context 'schema v2' do
       before do
-        stub_request(:get, 'http://example.com/v2/group/test/manifests/tag').
+        stub_request(:get, 'http://registry.gitlab/v2/group/test/manifests/tag').
           with(headers: headers).
           to_return(
             status: 200,
@@ -93,7 +134,7 @@ describe ContainerRegistry::Tag do
 
         context 'when locally stored' do
           before do
-            stub_request(:get, 'http://example.com/v2/group/test/blobs/sha256:d7a513a663c1a6dcdba9ed832ca53c02ac2af0c333322cd6ca92936d1d9917ac').
+            stub_request(:get, 'http://registry.gitlab/v2/group/test/blobs/sha256:d7a513a663c1a6dcdba9ed832ca53c02ac2af0c333322cd6ca92936d1d9917ac').
               with(headers: { 'Accept' => 'application/octet-stream' }).
               to_return(
                 status: 200,
@@ -105,7 +146,7 @@ describe ContainerRegistry::Tag do
 
         context 'when externally stored' do
           before do
-            stub_request(:get, 'http://example.com/v2/group/test/blobs/sha256:d7a513a663c1a6dcdba9ed832ca53c02ac2af0c333322cd6ca92936d1d9917ac').
+            stub_request(:get, 'http://registry.gitlab/v2/group/test/blobs/sha256:d7a513a663c1a6dcdba9ed832ca53c02ac2af0c333322cd6ca92936d1d9917ac').
               with(headers: { 'Accept' => 'application/octet-stream' }).
               to_return(
                 status: 307,
@@ -123,29 +164,29 @@ describe ContainerRegistry::Tag do
     end
   end
 
-  context 'manifest digest' do
+  context 'with stubbed digest' do
     before do
-      stub_request(:head, 'http://example.com/v2/group/test/manifests/tag').
-        with(headers: headers).
-        to_return(status: 200, headers: { 'Docker-Content-Digest' => 'sha256:digest' })
+      stub_request(:head, 'http://registry.gitlab/v2/group/test/manifests/tag')
+        .with(headers: headers)
+        .to_return(status: 200, headers: { 'Docker-Content-Digest' => 'sha256:digest' })
     end
 
-    context '#digest' do
-      subject { tag.digest }
-
-      it { is_expected.to eq('sha256:digest') }
+    describe '#digest' do
+      it 'returns a correct tag digest' do
+        expect(tag.digest).to eq 'sha256:digest'
+      end
     end
 
-    context '#delete' do
+    describe '#delete' do
       before do
-        stub_request(:delete, 'http://example.com/v2/group/test/manifests/sha256:digest').
-          with(headers: headers).
-          to_return(status: 200)
+        stub_request(:delete, 'http://registry.gitlab/v2/group/test/manifests/sha256:digest')
+          .with(headers: headers)
+          .to_return(status: 200)
       end
 
-      subject { tag.delete }
-
-      it { is_expected.to be_truthy }
+      it 'correctly deletes the tag' do
+        expect(tag.delete).to be_truthy
+      end
     end
   end
 end
diff --git a/spec/models/ci/pipeline_status_spec.rb b/spec/lib/gitlab/cache/ci/project_pipeline_status_spec.rb
index bc5b71666c2..fced253dd01 100644
--- a/spec/models/ci/pipeline_status_spec.rb
+++ b/spec/lib/gitlab/cache/ci/project_pipeline_status_spec.rb
@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Ci::PipelineStatus do
+describe Gitlab::Cache::Ci::ProjectPipelineStatus do
   let(:project) { create(:project) }
   let(:pipeline_status) { described_class.new(project) }
 
@@ -12,6 +12,20 @@ describe Ci::PipelineStatus do
     end
   end
 
+  describe '.update_for_pipeline' do
+    it 'refreshes the cache if nescessary' do
+      pipeline = build_stubbed(:ci_pipeline, sha: '123456', status: 'success')
+      fake_status = double
+      expect(described_class).to receive(:new).
+                                   with(pipeline.project, sha: '123456', status: 'success', ref: 'master').
+                                   and_return(fake_status)
+
+      expect(fake_status).to receive(:store_in_cache_if_needed)
+
+      described_class.update_for_pipeline(pipeline)
+    end
+  end
+
   describe '#has_status?' do
     it "is false when the status wasn't loaded yet" do
       expect(pipeline_status.has_status?).to be_falsy
@@ -41,14 +55,14 @@ describe Ci::PipelineStatus do
     it 'loads the status from the project commit when there is no cache' do
       allow(pipeline_status).to receive(:has_cache?).and_return(false)
 
-      expect(pipeline_status).to receive(:load_from_commit)
+      expect(pipeline_status).to receive(:load_from_project)
 
       pipeline_status.load_status
     end
 
     it 'stores the status in the cache when it loading it from the project' do
       allow(pipeline_status).to receive(:has_cache?).and_return(false)
-      allow(pipeline_status).to receive(:load_from_commit)
+      allow(pipeline_status).to receive(:load_from_project)
 
       expect(pipeline_status).to receive(:store_in_cache)
 
@@ -70,14 +84,15 @@ describe Ci::PipelineStatus do
     end
   end
 
-  describe "#load_from_commit" do
+  describe "#load_from_project" do
     let!(:pipeline) { create(:ci_pipeline, :success, project: project, sha: project.commit.sha) }
 
     it 'reads the status from the pipeline for the commit' do
-      pipeline_status.load_from_commit
+      pipeline_status.load_from_project
 
       expect(pipeline_status.status).to eq('success')
       expect(pipeline_status.sha).to eq(project.commit.sha)
+      expect(pipeline_status.ref).to eq(project.default_branch)
     end
 
     it "doesn't fail for an empty project" do
@@ -108,10 +123,11 @@ describe Ci::PipelineStatus do
       build_status = described_class.load_for_project(project)
 
       build_status.store_in_cache_if_needed
-      sha, status = Gitlab::Redis.with { |redis| redis.hmget("projects/#{project.id}/build_status", :sha, :status) }
+      sha, status, ref = Gitlab::Redis.with { |redis| redis.hmget("projects/#{project.id}/build_status", :sha, :status, :ref) }
 
       expect(sha).not_to be_nil
       expect(status).not_to be_nil
+      expect(ref).not_to be_nil
     end
 
     it "doesn't store the status in redis when the sha is not the head of the project" do
@@ -126,14 +142,15 @@ describe Ci::PipelineStatus do
 
     it "deletes the cache if the repository doesn't have a head commit" do
       empty_project = create(:empty_project)
-      Gitlab::Redis.with { |redis| redis.mapped_hmset("projects/#{empty_project.id}/build_status", { sha: "sha", status: "pending" }) }
+      Gitlab::Redis.with { |redis| redis.mapped_hmset("projects/#{empty_project.id}/build_status", { sha: "sha", status: "pending", ref: 'master' }) }
       other_status = described_class.new(empty_project, sha: "123456", status: "failed")
 
       other_status.store_in_cache_if_needed
-      sha, status = Gitlab::Redis.with { |redis| redis.hmget("projects/#{empty_project.id}/build_status", :sha, :status) }
+      sha, status, ref = Gitlab::Redis.with { |redis| redis.hmget("projects/#{empty_project.id}/build_status", :sha, :status, :ref) }
 
       expect(sha).to be_nil
       expect(status).to be_nil
+      expect(ref).to be_nil
     end
   end
 
diff --git a/spec/lib/gitlab/checks/change_access_spec.rb b/spec/lib/gitlab/checks/change_access_spec.rb
index e22f88b7a32..959ae02c222 100644
--- a/spec/lib/gitlab/checks/change_access_spec.rb
+++ b/spec/lib/gitlab/checks/change_access_spec.rb
@@ -5,13 +5,10 @@ describe Gitlab::Checks::ChangeAccess, lib: true do
     let(:user) { create(:user) }
     let(:project) { create(:project, :repository) }
     let(:user_access) { Gitlab::UserAccess.new(user, project: project) }
-    let(:changes) do
-      {
-        oldrev: 'be93687618e4b132087f430a4d8fc3a609c9b77c',
-        newrev: '54fcc214b94e78d7a41a9a8fe6d87a5e59500e51',
-        ref: 'refs/heads/master'
-      }
-    end
+    let(:oldrev) { 'be93687618e4b132087f430a4d8fc3a609c9b77c' }
+    let(:newrev) { '54fcc214b94e78d7a41a9a8fe6d87a5e59500e51' }
+    let(:ref) { 'refs/heads/master' }
+    let(:changes) { { oldrev: oldrev, newrev: newrev, ref: ref } }
     let(:protocol) { 'ssh' }
 
     subject do
@@ -23,7 +20,7 @@ describe Gitlab::Checks::ChangeAccess, lib: true do
       ).exec
     end
 
-    before { allow(user_access).to receive(:can_do_action?).with(:push_code).and_return(true) }
+    before { project.add_developer(user) }
 
     context 'without failed checks' do
       it "doesn't return any error" do
@@ -41,25 +38,67 @@ describe Gitlab::Checks::ChangeAccess, lib: true do
     end
 
     context 'tags check' do
-      let(:changes) do
-        {
-          oldrev: 'be93687618e4b132087f430a4d8fc3a609c9b77c',
-          newrev: '54fcc214b94e78d7a41a9a8fe6d87a5e59500e51',
-          ref: 'refs/tags/v1.0.0'
-        }
-      end
+      let(:ref) { 'refs/tags/v1.0.0' }
 
       it 'returns an error if the user is not allowed to update tags' do
+        allow(user_access).to receive(:can_do_action?).with(:push_code).and_return(true)
         expect(user_access).to receive(:can_do_action?).with(:admin_project).and_return(false)
 
         expect(subject.status).to be(false)
         expect(subject.message).to eq('You are not allowed to change existing tags on this project.')
       end
+
+      context 'with protected tag' do
+        let!(:protected_tag) { create(:protected_tag, project: project, name: 'v*') }
+
+        context 'as master' do
+          before { project.add_master(user) }
+
+          context 'deletion' do
+            let(:oldrev) { 'be93687618e4b132087f430a4d8fc3a609c9b77c' }
+            let(:newrev) { '0000000000000000000000000000000000000000' }
+
+            it 'is prevented' do
+              expect(subject.status).to be(false)
+              expect(subject.message).to include('cannot be deleted')
+            end
+          end
+
+          context 'update' do
+            let(:oldrev) { 'be93687618e4b132087f430a4d8fc3a609c9b77c' }
+            let(:newrev) { '54fcc214b94e78d7a41a9a8fe6d87a5e59500e51' }
+
+            it 'is prevented' do
+              expect(subject.status).to be(false)
+              expect(subject.message).to include('cannot be updated')
+            end
+          end
+        end
+
+        context 'creation' do
+          let(:oldrev) { '0000000000000000000000000000000000000000' }
+          let(:newrev) { '54fcc214b94e78d7a41a9a8fe6d87a5e59500e51' }
+          let(:ref) { 'refs/tags/v9.1.0' }
+
+          it 'prevents creation below access level' do
+            expect(subject.status).to be(false)
+            expect(subject.message).to include('allowed to create this tag as it is protected')
+          end
+
+          context 'when user has access' do
+            let!(:protected_tag) { create(:protected_tag, :developers_can_create, project: project, name: 'v*') }
+
+            it 'allows tag creation' do
+              expect(subject.status).to be(true)
+            end
+          end
+        end
+      end
     end
 
     context 'protected branches check' do
       before do
-        allow(project).to receive(:protected_branch?).with('master').and_return(true)
+        allow(ProtectedBranch).to receive(:protected?).with(project, 'master').and_return(true)
       end
 
       it 'returns an error if the user is not allowed to do forced pushes to protected branches' do
@@ -86,13 +125,7 @@ describe Gitlab::Checks::ChangeAccess, lib: true do
       end
 
       context 'branch deletion' do
-        let(:changes) do
-          {
-            oldrev: 'be93687618e4b132087f430a4d8fc3a609c9b77c',
-            newrev: '0000000000000000000000000000000000000000',
-            ref: 'refs/heads/master'
-          }
-        end
+        let(:newrev) { '0000000000000000000000000000000000000000' }
 
         it 'returns an error if the user is not allowed to delete protected branches' do
           expect(subject.status).to be(false)
diff --git a/spec/lib/gitlab/ci/cron_parser_spec.rb b/spec/lib/gitlab/ci/cron_parser_spec.rb
new file mode 100644
index 00000000000..0864bc7258d
--- /dev/null
+++ b/spec/lib/gitlab/ci/cron_parser_spec.rb
@@ -0,0 +1,116 @@
+require 'spec_helper'
+
+describe Gitlab::Ci::CronParser do
+  shared_examples_for "returns time in the future" do
+    it { is_expected.to be > Time.now }
+  end
+
+  describe '#next_time_from' do
+    subject { described_class.new(cron, cron_timezone).next_time_from(Time.now) }
+
+    context 'when cron and cron_timezone are valid' do
+      context 'when specific time' do
+        let(:cron) { '3 4 5 6 *' }
+        let(:cron_timezone) { 'UTC' }
+
+        it_behaves_like "returns time in the future"
+
+        it 'returns exact time' do
+          expect(subject.min).to eq(3)
+          expect(subject.hour).to eq(4)
+          expect(subject.day).to eq(5)
+          expect(subject.month).to eq(6)
+        end
+      end
+
+      context 'when specific day of week' do
+        let(:cron) { '* * * * 0' }
+        let(:cron_timezone) { 'UTC' }
+
+        it_behaves_like "returns time in the future"
+
+        it 'returns exact day of week' do
+          expect(subject.wday).to eq(0)
+        end
+      end
+
+      context 'when slash used' do
+        let(:cron) { '*/10 */6 */10 */10 *' }
+        let(:cron_timezone) { 'UTC' }
+
+        it_behaves_like "returns time in the future"
+
+        it 'returns specific time' do
+          expect(subject.min).to be_in([0, 10, 20, 30, 40, 50])
+          expect(subject.hour).to be_in([0, 6, 12, 18])
+          expect(subject.day).to be_in([1, 11, 21, 31])
+          expect(subject.month).to be_in([1, 11])
+        end
+      end
+
+      context 'when range used' do
+        let(:cron) { '0,20,40 * 1-5 * *' }
+        let(:cron_timezone) { 'UTC' }
+
+        it_behaves_like "returns time in the future"
+
+        it 'returns specific time' do
+          expect(subject.min).to be_in([0, 20, 40])
+          expect(subject.day).to be_in((1..5).to_a)
+        end
+      end
+
+      context 'when cron_timezone is US/Pacific' do
+        let(:cron) { '0 0 * * *' }
+        let(:cron_timezone) { 'US/Pacific' }
+
+        it_behaves_like "returns time in the future"
+
+        it 'converts time in server time zone' do
+          expect(subject.hour).to eq((Time.zone.now.in_time_zone(cron_timezone).utc_offset / 60 / 60).abs)
+        end
+      end
+    end
+
+    context 'when cron and cron_timezone are invalid' do
+      let(:cron) { 'invalid_cron' }
+      let(:cron_timezone) { 'invalid_cron_timezone' }
+
+      it 'returns nil' do
+        is_expected.to be_nil
+      end 
+    end
+  end
+
+  describe '#cron_valid?' do
+    subject { described_class.new(cron, Gitlab::Ci::CronParser::VALID_SYNTAX_SAMPLE_TIME_ZONE).cron_valid? }
+
+    context 'when cron is valid' do
+      let(:cron) { '* * * * *' }
+
+      it { is_expected.to eq(true) }
+    end
+
+    context 'when cron is invalid' do
+      let(:cron) { '*********' }
+
+      it { is_expected.to eq(false) }
+    end
+  end
+
+  describe '#cron_timezone_valid?' do
+    subject { described_class.new(Gitlab::Ci::CronParser::VALID_SYNTAX_SAMPLE_CRON, cron_timezone).cron_timezone_valid? }
+
+    context 'when cron is valid' do
+      let(:cron_timezone) { 'Europe/Istanbul' }
+
+      it { is_expected.to eq(true) }
+    end
+
+    context 'when cron is invalid' do
+      let(:cron_timezone) { 'Invalid-zone' }
+
+      it { is_expected.to eq(false) }
+    end
+  end
+end
diff --git a/spec/lib/gitlab/ci/trace/stream_spec.rb b/spec/lib/gitlab/ci/trace/stream_spec.rb
new file mode 100644
index 00000000000..2e57ccef182
--- /dev/null
+++ b/spec/lib/gitlab/ci/trace/stream_spec.rb
@@ -0,0 +1,201 @@
+require 'spec_helper'
+
+describe Gitlab::Ci::Trace::Stream do
+  describe 'delegates' do
+    subject { described_class.new { nil } }
+
+    it { is_expected.to delegate_method(:close).to(:stream) }
+    it { is_expected.to delegate_method(:tell).to(:stream) }
+    it { is_expected.to delegate_method(:seek).to(:stream) }
+    it { is_expected.to delegate_method(:size).to(:stream) }
+    it { is_expected.to delegate_method(:path).to(:stream) }
+    it { is_expected.to delegate_method(:truncate).to(:stream) }
+    it { is_expected.to delegate_method(:valid?).to(:stream).as(:present?) }
+    it { is_expected.to delegate_method(:file?).to(:path).as(:present?) }
+  end
+
+  describe '#limit' do
+    let(:stream) do
+      described_class.new do
+        StringIO.new("12345678")
+      end
+    end
+
+    it 'if size is larger we start from beggining' do
+      stream.limit(10)
+
+      expect(stream.tell).to eq(0)
+    end
+
+    it 'if size is smaller we start from the end' do
+      stream.limit(2)
+
+      expect(stream.tell).to eq(6)
+    end
+  end
+
+  describe '#append' do
+    let(:stream) do
+      described_class.new do
+        StringIO.new("12345678")
+      end
+    end
+
+    it "truncates and append content" do
+      stream.append("89", 4)
+      stream.seek(0)
+
+      expect(stream.size).to eq(6)
+      expect(stream.raw).to eq("123489")
+    end
+  end
+
+  describe '#set' do
+    let(:stream) do
+      described_class.new do
+        StringIO.new("12345678")
+      end
+    end
+
+    before do
+      stream.set("8901")
+    end
+
+    it "overwrite content" do
+      stream.seek(0)
+
+      expect(stream.size).to eq(4)
+      expect(stream.raw).to eq("8901")
+    end
+  end
+
+  describe '#raw' do
+    let(:path) { __FILE__ }
+    let(:lines) { File.readlines(path) }
+    let(:stream) do
+      described_class.new do
+        File.open(path)
+      end
+    end
+
+    it 'returns all contents if last_lines is not specified' do
+      result = stream.raw
+
+      expect(result).to eq(lines.join)
+      expect(result.encoding).to eq(Encoding.default_external)
+    end
+
+    context 'limit max lines' do
+      before do
+        # specifying BUFFER_SIZE forces to seek backwards
+        allow(described_class).to receive(:BUFFER_SIZE)
+          .and_return(2)
+      end
+
+      it 'returns last few lines' do
+        result = stream.raw(last_lines: 2)
+
+        expect(result).to eq(lines.last(2).join)
+        expect(result.encoding).to eq(Encoding.default_external)
+      end
+
+      it 'returns everything if trying to get too many lines' do
+        result = stream.raw(last_lines: lines.size * 2)
+
+        expect(result).to eq(lines.join)
+        expect(result.encoding).to eq(Encoding.default_external)
+      end
+    end
+  end
+
+  describe '#html_with_state' do
+    let(:stream) do
+      described_class.new do
+        StringIO.new("1234")
+      end
+    end
+
+    it 'returns html content with state' do
+      result = stream.html_with_state
+
+      expect(result.html).to eq("1234")
+    end
+
+    context 'follow-up state' do
+      let!(:last_result) { stream.html_with_state }
+
+      before do
+        stream.append("5678", 4)
+        stream.seek(0)
+      end
+
+      it "returns appended trace" do
+        result = stream.html_with_state(last_result.state)
+
+        expect(result.append).to be_truthy
+        expect(result.html).to eq("5678")
+      end
+    end
+  end
+
+  describe '#html' do
+    let(:stream) do
+      described_class.new do
+        StringIO.new("12\n34\n56")
+      end
+    end
+
+    it "returns html" do
+      expect(stream.html).to eq("12<br>34<br>56")
+    end
+
+    it "returns html for last line only" do
+      expect(stream.html(last_lines: 1)).to eq("56")
+    end
+  end
+
+  describe '#extract_coverage' do
+    let(:stream) do
+      described_class.new do
+        StringIO.new(data)
+      end
+    end
+
+    subject { stream.extract_coverage(regex) }
+
+    context 'valid content & regex' do
+      let(:data) { 'Coverage 1033 / 1051 LOC (98.29%) covered' }
+      let(:regex) { '\(\d+.\d+\%\) covered' }
+
+      it { is_expected.to eq("98.29") }
+    end
+
+    context 'valid content & bad regex' do
+      let(:data) { 'Coverage 1033 / 1051 LOC (98.29%) covered\n' }
+      let(:regex) { 'very covered' }
+
+      it { is_expected.to be_nil }
+    end
+
+    context 'no coverage content & regex' do
+      let(:data) { 'No coverage for today :sad:' }
+      let(:regex) { '\(\d+.\d+\%\) covered' }
+
+      it { is_expected.to be_nil }
+    end
+
+    context 'multiple results in content & regex' do
+      let(:data) { ' (98.39%) covered. (98.29%) covered' }
+      let(:regex) { '\(\d+.\d+\%\) covered' }
+
+      it { is_expected.to eq("98.29") }
+    end
+
+    context 'using a regex capture' do
+      let(:data) { 'TOTAL      9926   3489    65%' }
+      let(:regex) { 'TOTAL\s+\d+\s+\d+\s+(\d{1,3}\%)' }
+
+      it { is_expected.to eq("65") }
+    end
+  end
+end
diff --git a/spec/lib/gitlab/ci/trace_reader_spec.rb b/spec/lib/gitlab/ci/trace_reader_spec.rb
deleted file mode 100644
index ff5551bf703..00000000000
--- a/spec/lib/gitlab/ci/trace_reader_spec.rb
+++ /dev/null
@@ -1,52 +0,0 @@
-require 'spec_helper'
-
-describe Gitlab::Ci::TraceReader do
-  let(:path) { __FILE__ }
-  let(:lines) { File.readlines(path) }
-  let(:bytesize) { lines.sum(&:bytesize) }
-
-  it 'returns last few lines' do
-    10.times do
-      subject = build_subject
-      last_lines = random_lines
-
-      expected = lines.last(last_lines).join
-      result = subject.read(last_lines: last_lines)
-
-      expect(result).to eq(expected)
-      expect(result.encoding).to eq(Encoding.default_external)
-    end
-  end
-
-  it 'returns everything if trying to get too many lines' do
-    result = build_subject.read(last_lines: lines.size * 2)
-
-    expect(result).to eq(lines.join)
-    expect(result.encoding).to eq(Encoding.default_external)
-  end
-
-  it 'returns all contents if last_lines is not specified' do
-    result = build_subject.read
-
-    expect(result).to eq(lines.join)
-    expect(result.encoding).to eq(Encoding.default_external)
-  end
-
-  it 'raises an error if not passing an integer for last_lines' do
-    expect do
-      build_subject.read(last_lines: lines)
-    end.to raise_error(ArgumentError)
-  end
-
-  def random_lines
-    Random.rand(lines.size) + 1
-  end
-
-  def random_buffer
-    Random.rand(bytesize) + 1
-  end
-
-  def build_subject
-    described_class.new(__FILE__, buffer_size: random_buffer)
-  end
-end
diff --git a/spec/lib/gitlab/ci/trace_spec.rb b/spec/lib/gitlab/ci/trace_spec.rb
new file mode 100644
index 00000000000..9cb0b62590a
--- /dev/null
+++ b/spec/lib/gitlab/ci/trace_spec.rb
@@ -0,0 +1,228 @@
+require 'spec_helper'
+
+describe Gitlab::Ci::Trace do
+  let(:build) { create(:ci_build) }
+  let(:trace) { described_class.new(build) }
+
+  describe "associations" do
+    it { expect(trace).to respond_to(:job) }
+    it { expect(trace).to delegate_method(:old_trace).to(:job) }
+  end
+
+  describe '#html' do
+    before do
+      trace.set("12\n34")
+    end
+
+    it "returns formatted html" do
+      expect(trace.html).to eq("12<br>34")
+    end
+
+    it "returns last line of formatted html" do
+      expect(trace.html(last_lines: 1)).to eq("34")
+    end
+  end
+
+  describe '#raw' do
+    before do
+      trace.set("12\n34")
+    end
+
+    it "returns raw output" do
+      expect(trace.raw).to eq("12\n34")
+    end
+
+    it "returns last line of raw output" do
+      expect(trace.raw(last_lines: 1)).to eq("34")
+    end
+  end
+
+  describe '#extract_coverage' do
+    let(:regex) { '\(\d+.\d+\%\) covered' }
+
+    context 'matching coverage' do
+      before do
+        trace.set('Coverage 1033 / 1051 LOC (98.29%) covered')
+      end
+
+      it "returns valid coverage" do
+        expect(trace.extract_coverage(regex)).to eq("98.29")
+      end
+    end
+
+    context 'no coverage' do
+      before do
+        trace.set('No coverage')
+      end
+
+      it 'returs nil' do
+        expect(trace.extract_coverage(regex)).to be_nil
+      end
+    end
+  end
+
+  describe '#set' do
+    before do
+      trace.set("12")
+    end
+
+    it "returns trace" do
+      expect(trace.raw).to eq("12")
+    end
+
+    context 'overwrite trace' do
+      before do
+        trace.set("34")
+      end
+
+      it "returns new trace" do
+        expect(trace.raw).to eq("34")
+      end
+    end
+
+    context 'runners token' do
+      let(:token) { 'my_secret_token' }
+
+      before do
+        build.project.update(runners_token: token)
+        trace.set(token)
+      end
+
+      it "hides token" do
+        expect(trace.raw).not_to include(token)
+      end
+    end
+
+    context 'hides build token' do
+      let(:token) { 'my_secret_token' }
+
+      before do
+        build.update(token: token)
+        trace.set(token)
+      end
+
+      it "hides token" do
+        expect(trace.raw).not_to include(token)
+      end
+    end
+  end
+
+  describe '#append' do
+    before do
+      trace.set("1234")
+    end
+
+    it "returns correct trace" do
+      expect(trace.append("56", 4)).to eq(6)
+      expect(trace.raw).to eq("123456")
+    end
+
+    context 'tries to append trace at different offset' do
+      it "fails with append" do
+        expect(trace.append("56", 2)).to eq(-4)
+        expect(trace.raw).to eq("1234")
+      end
+    end
+
+    context 'runners token' do
+      let(:token) { 'my_secret_token' }
+
+      before do
+        build.project.update(runners_token: token)
+        trace.append(token, 0)
+      end
+
+      it "hides token" do
+        expect(trace.raw).not_to include(token)
+      end
+    end
+
+    context 'build token' do
+      let(:token) { 'my_secret_token' }
+
+      before do
+        build.update(token: token)
+        trace.append(token, 0)
+      end
+
+      it "hides token" do
+        expect(trace.raw).not_to include(token)
+      end
+    end
+  end
+
+  describe 'trace handling' do
+    context 'trace does not exist' do
+      it { expect(trace.exist?).to be(false) }
+    end
+
+    context 'new trace path is used' do
+      before do
+        trace.send(:ensure_directory)
+
+        File.open(trace.send(:default_path), "w") do |file|
+          file.write("data")
+        end
+      end
+
+      it "trace exist" do
+        expect(trace.exist?).to be(true)
+      end
+
+      it "can be erased" do
+        trace.erase!
+        expect(trace.exist?).to be(false)
+      end
+    end
+
+    context 'deprecated path' do
+      let(:path) { trace.send(:deprecated_path) }
+
+      context 'with valid ci_id' do
+        before do
+          build.project.update(ci_id: 1000)
+
+          FileUtils.mkdir_p(File.dirname(path))
+
+          File.open(path, "w") do |file|
+            file.write("data")
+          end
+        end
+
+        it "trace exist" do
+          expect(trace.exist?).to be(true)
+        end
+
+        it "can be erased" do
+          trace.erase!
+          expect(trace.exist?).to be(false)
+        end
+      end
+
+      context 'without valid ci_id' do
+        it "does not return deprecated path" do
+          expect(path).to be_nil
+        end
+      end
+    end
+
+    context 'stored in database' do
+      before do
+        build.send(:write_attribute, :trace, "data")
+      end
+
+      it "trace exist" do
+        expect(trace.exist?).to be(true)
+      end
+
+      it "can be erased" do
+        trace.erase!
+        expect(trace.exist?).to be(false)
+      end
+
+      it "returns database data" do
+        expect(trace.raw).to eq("data")
+      end
+    end
+  end
+end
diff --git a/spec/lib/gitlab/database/migration_helpers_spec.rb b/spec/lib/gitlab/database/migration_helpers_spec.rb
index 4ac79454647..a044b871730 100644
--- a/spec/lib/gitlab/database/migration_helpers_spec.rb
+++ b/spec/lib/gitlab/database/migration_helpers_spec.rb
@@ -175,6 +175,50 @@ describe Gitlab::Database::MigrationHelpers, lib: true do
     end
   end
 
+  describe '#true_value' do
+    context 'using PostgreSQL' do
+      before do
+        expect(Gitlab::Database).to receive(:postgresql?).and_return(true)
+      end
+
+      it 'returns the appropriate value' do
+        expect(model.true_value).to eq("'t'")
+      end
+    end
+
+    context 'using MySQL' do
+      before do
+        expect(Gitlab::Database).to receive(:postgresql?).and_return(false)
+      end
+
+      it 'returns the appropriate value' do
+        expect(model.true_value).to eq(1)
+      end
+    end
+  end
+
+  describe '#false_value' do
+    context 'using PostgreSQL' do
+      before do
+        expect(Gitlab::Database).to receive(:postgresql?).and_return(true)
+      end
+
+      it 'returns the appropriate value' do
+        expect(model.false_value).to eq("'f'")
+      end
+    end
+
+    context 'using MySQL' do
+      before do
+        expect(Gitlab::Database).to receive(:postgresql?).and_return(false)
+      end
+
+      it 'returns the appropriate value' do
+        expect(model.false_value).to eq(0)
+      end
+    end
+  end
+
   describe '#update_column_in_batches' do
     before do
       create_list(:empty_project, 5)
@@ -294,4 +338,392 @@ describe Gitlab::Database::MigrationHelpers, lib: true do
       end
     end
   end
+
+  describe '#rename_column_concurrently' do
+    context 'in a transaction' do
+      it 'raises RuntimeError' do
+        allow(model).to receive(:transaction_open?).and_return(true)
+
+        expect { model.rename_column_concurrently(:users, :old, :new) }.
+          to raise_error(RuntimeError)
+      end
+    end
+
+    context 'outside a transaction' do
+      let(:old_column) do
+        double(:column,
+               type: :integer,
+               limit: 8,
+               default: 0,
+               null: false,
+               precision: 5,
+               scale: 1)
+      end
+
+      let(:trigger_name) { model.rename_trigger_name(:users, :old, :new) }
+
+      before do
+        allow(model).to receive(:transaction_open?).and_return(false)
+        allow(model).to receive(:column_for).and_return(old_column)
+
+        # Since MySQL and PostgreSQL use different quoting styles we'll just
+        # stub the methods used for this to make testing easier.
+        allow(model).to receive(:quote_column_name) { |name| name.to_s }
+        allow(model).to receive(:quote_table_name) { |name| name.to_s }
+      end
+
+      context 'using MySQL' do
+        it 'renames a column concurrently' do
+          allow(Gitlab::Database).to receive(:postgresql?).and_return(false)
+
+          expect(model).to receive(:install_rename_triggers_for_mysql).
+            with(trigger_name, 'users', 'old', 'new')
+
+          expect(model).to receive(:add_column).
+            with(:users, :new, :integer,
+                 limit: old_column.limit,
+                 default: old_column.default,
+                 null: old_column.null,
+                 precision: old_column.precision,
+                 scale: old_column.scale)
+
+          expect(model).to receive(:update_column_in_batches)
+
+          expect(model).to receive(:copy_indexes).with(:users, :old, :new)
+          expect(model).to receive(:copy_foreign_keys).with(:users, :old, :new)
+
+          model.rename_column_concurrently(:users, :old, :new)
+        end
+      end
+
+      context 'using PostgreSQL' do
+        it 'renames a column concurrently' do
+          allow(Gitlab::Database).to receive(:postgresql?).and_return(true)
+
+          expect(model).to receive(:install_rename_triggers_for_postgresql).
+            with(trigger_name, 'users', 'old', 'new')
+
+          expect(model).to receive(:add_column).
+            with(:users, :new, :integer,
+                 limit: old_column.limit,
+                 default: old_column.default,
+                 null: old_column.null,
+                 precision: old_column.precision,
+                 scale: old_column.scale)
+
+          expect(model).to receive(:update_column_in_batches)
+
+          expect(model).to receive(:copy_indexes).with(:users, :old, :new)
+          expect(model).to receive(:copy_foreign_keys).with(:users, :old, :new)
+
+          model.rename_column_concurrently(:users, :old, :new)
+        end
+      end
+    end
+  end
+
+  describe '#cleanup_concurrent_column_rename' do
+    it 'cleans up the renaming procedure for PostgreSQL' do
+      allow(Gitlab::Database).to receive(:postgresql?).and_return(true)
+
+      expect(model).to receive(:remove_rename_triggers_for_postgresql).
+        with(:users, /trigger_.{12}/)
+
+      expect(model).to receive(:remove_column).with(:users, :old)
+
+      model.cleanup_concurrent_column_rename(:users, :old, :new)
+    end
+
+    it 'cleans up the renaming procedure for MySQL' do
+      allow(Gitlab::Database).to receive(:postgresql?).and_return(false)
+
+      expect(model).to receive(:remove_rename_triggers_for_mysql).
+        with(/trigger_.{12}/)
+
+      expect(model).to receive(:remove_column).with(:users, :old)
+
+      model.cleanup_concurrent_column_rename(:users, :old, :new)
+    end
+  end
+
+  describe '#change_column_type_concurrently' do
+    it 'changes the column type' do
+      expect(model).to receive(:rename_column_concurrently).
+        with('users', 'username', 'username_for_type_change', type: :text)
+
+      model.change_column_type_concurrently('users', 'username', :text)
+    end
+  end
+
+  describe '#cleanup_concurrent_column_type_change' do
+    it 'cleans up the type changing procedure' do
+      expect(model).to receive(:cleanup_concurrent_column_rename).
+        with('users', 'username', 'username_for_type_change')
+
+      expect(model).to receive(:rename_column).
+        with('users', 'username_for_type_change', 'username')
+
+      model.cleanup_concurrent_column_type_change('users', 'username')
+    end
+  end
+
+  describe '#install_rename_triggers_for_postgresql' do
+    it 'installs the triggers for PostgreSQL' do
+      expect(model).to receive(:execute).
+        with(/CREATE OR REPLACE FUNCTION foo()/m)
+
+      expect(model).to receive(:execute).
+        with(/CREATE TRIGGER foo/m)
+
+      model.install_rename_triggers_for_postgresql('foo', :users, :old, :new)
+    end
+  end
+
+  describe '#install_rename_triggers_for_mysql' do
+    it 'installs the triggers for MySQL' do
+      expect(model).to receive(:execute).
+        with(/CREATE TRIGGER foo_insert.+ON users/m)
+
+      expect(model).to receive(:execute).
+        with(/CREATE TRIGGER foo_update.+ON users/m)
+
+      model.install_rename_triggers_for_mysql('foo', :users, :old, :new)
+    end
+  end
+
+  describe '#remove_rename_triggers_for_postgresql' do
+    it 'removes the function and trigger' do
+      expect(model).to receive(:execute).with('DROP TRIGGER foo ON bar')
+      expect(model).to receive(:execute).with('DROP FUNCTION foo()')
+
+      model.remove_rename_triggers_for_postgresql('bar', 'foo')
+    end
+  end
+
+  describe '#remove_rename_triggers_for_mysql' do
+    it 'removes the triggers' do
+      expect(model).to receive(:execute).with('DROP TRIGGER foo_insert')
+      expect(model).to receive(:execute).with('DROP TRIGGER foo_update')
+
+      model.remove_rename_triggers_for_mysql('foo')
+    end
+  end
+
+  describe '#rename_trigger_name' do
+    it 'returns a String' do
+      expect(model.rename_trigger_name(:users, :foo, :bar)).
+        to match(/trigger_.{12}/)
+    end
+  end
+
+  describe '#indexes_for' do
+    it 'returns the indexes for a column' do
+      idx1 = double(:idx, columns: %w(project_id))
+      idx2 = double(:idx, columns: %w(user_id))
+
+      allow(model).to receive(:indexes).with('table').and_return([idx1, idx2])
+
+      expect(model.indexes_for('table', :user_id)).to eq([idx2])
+    end
+  end
+
+  describe '#foreign_keys_for' do
+    it 'returns the foreign keys for a column' do
+      fk1 = double(:fk, column: 'project_id')
+      fk2 = double(:fk, column: 'user_id')
+
+      allow(model).to receive(:foreign_keys).with('table').and_return([fk1, fk2])
+
+      expect(model.foreign_keys_for('table', :user_id)).to eq([fk2])
+    end
+  end
+
+  describe '#copy_indexes' do
+    context 'using a regular index using a single column' do
+      it 'copies the index' do
+        index = double(:index,
+                       columns: %w(project_id),
+                       name: 'index_on_issues_project_id',
+                       using: nil,
+                       where: nil,
+                       opclasses: {},
+                       unique: false,
+                       lengths: [],
+                       orders: [])
+
+        allow(model).to receive(:indexes_for).with(:issues, 'project_id').
+          and_return([index])
+
+        expect(model).to receive(:add_concurrent_index).
+          with(:issues,
+               %w(gl_project_id),
+               unique: false,
+               name: 'index_on_issues_gl_project_id',
+               length: [],
+               order: [])
+
+        model.copy_indexes(:issues, :project_id, :gl_project_id)
+      end
+    end
+
+    context 'using a regular index with multiple columns' do
+      it 'copies the index' do
+        index = double(:index,
+                       columns: %w(project_id foobar),
+                       name: 'index_on_issues_project_id_foobar',
+                       using: nil,
+                       where: nil,
+                       opclasses: {},
+                       unique: false,
+                       lengths: [],
+                       orders: [])
+
+        allow(model).to receive(:indexes_for).with(:issues, 'project_id').
+          and_return([index])
+
+        expect(model).to receive(:add_concurrent_index).
+          with(:issues,
+               %w(gl_project_id foobar),
+               unique: false,
+               name: 'index_on_issues_gl_project_id_foobar',
+               length: [],
+               order: [])
+
+        model.copy_indexes(:issues, :project_id, :gl_project_id)
+      end
+    end
+
+    context 'using an index with a WHERE clause' do
+      it 'copies the index' do
+        index = double(:index,
+                       columns: %w(project_id),
+                       name: 'index_on_issues_project_id',
+                       using: nil,
+                       where: 'foo',
+                       opclasses: {},
+                       unique: false,
+                       lengths: [],
+                       orders: [])
+
+        allow(model).to receive(:indexes_for).with(:issues, 'project_id').
+          and_return([index])
+
+        expect(model).to receive(:add_concurrent_index).
+          with(:issues,
+               %w(gl_project_id),
+               unique: false,
+               name: 'index_on_issues_gl_project_id',
+               length: [],
+               order: [],
+               where: 'foo')
+
+        model.copy_indexes(:issues, :project_id, :gl_project_id)
+      end
+    end
+
+    context 'using an index with a USING clause' do
+      it 'copies the index' do
+        index = double(:index,
+                       columns: %w(project_id),
+                       name: 'index_on_issues_project_id',
+                       where: nil,
+                       using: 'foo',
+                       opclasses: {},
+                       unique: false,
+                       lengths: [],
+                       orders: [])
+
+        allow(model).to receive(:indexes_for).with(:issues, 'project_id').
+          and_return([index])
+
+        expect(model).to receive(:add_concurrent_index).
+          with(:issues,
+               %w(gl_project_id),
+               unique: false,
+               name: 'index_on_issues_gl_project_id',
+               length: [],
+               order: [],
+               using: 'foo')
+
+        model.copy_indexes(:issues, :project_id, :gl_project_id)
+      end
+    end
+
+    context 'using an index with custom operator classes' do
+      it 'copies the index' do
+        index = double(:index,
+                       columns: %w(project_id),
+                       name: 'index_on_issues_project_id',
+                       using: nil,
+                       where: nil,
+                       opclasses: { 'project_id' => 'bar' },
+                       unique: false,
+                       lengths: [],
+                       orders: [])
+
+        allow(model).to receive(:indexes_for).with(:issues, 'project_id').
+          and_return([index])
+
+        expect(model).to receive(:add_concurrent_index).
+          with(:issues,
+               %w(gl_project_id),
+               unique: false,
+               name: 'index_on_issues_gl_project_id',
+               length: [],
+               order: [],
+               opclasses: { 'gl_project_id' => 'bar' })
+
+        model.copy_indexes(:issues, :project_id, :gl_project_id)
+      end
+    end
+
+    describe 'using an index of which the name does not contain the source column' do
+      it 'raises RuntimeError' do
+        index = double(:index,
+                       columns: %w(project_id),
+                       name: 'index_foobar_index',
+                       using: nil,
+                       where: nil,
+                       opclasses: {},
+                       unique: false,
+                       lengths: [],
+                       orders: [])
+
+        allow(model).to receive(:indexes_for).with(:issues, 'project_id').
+          and_return([index])
+
+        expect { model.copy_indexes(:issues, :project_id, :gl_project_id) }.
+          to raise_error(RuntimeError)
+      end
+    end
+  end
+
+  describe '#copy_foreign_keys' do
+    it 'copies foreign keys from one column to another' do
+      fk = double(:fk,
+                  from_table: 'issues',
+                  to_table: 'projects',
+                  on_delete: :cascade)
+
+      allow(model).to receive(:foreign_keys_for).with(:issues, :project_id).
+        and_return([fk])
+
+      expect(model).to receive(:add_concurrent_foreign_key).
+        with('issues', 'projects', column: :gl_project_id, on_delete: :cascade)
+
+      model.copy_foreign_keys(:issues, :project_id, :gl_project_id)
+    end
+  end
+
+  describe '#column_for' do
+    it 'returns a column object for an existing column' do
+      column = model.column_for(:users, :id)
+
+      expect(column.name).to eq('id')
+    end
+
+    it 'returns nil when a column does not exist' do
+      expect(model.column_for(:users, :kittens)).to be_nil
+    end
+  end
 end
diff --git a/spec/lib/gitlab/database/multi_threaded_migration_spec.rb b/spec/lib/gitlab/database/multi_threaded_migration_spec.rb
new file mode 100644
index 00000000000..6c45f13bb5a
--- /dev/null
+++ b/spec/lib/gitlab/database/multi_threaded_migration_spec.rb
@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe Gitlab::Database::MultiThreadedMigration do
+  let(:migration) do
+    Class.new { include Gitlab::Database::MultiThreadedMigration }.new
+  end
+
+  describe '#connection' do
+    after do
+      Thread.current[described_class::MULTI_THREAD_AR_CONNECTION] = nil
+    end
+
+    it 'returns the thread-local connection if present' do
+      Thread.current[described_class::MULTI_THREAD_AR_CONNECTION] = 10
+
+      expect(migration.connection).to eq(10)
+    end
+
+    it 'returns the global connection if no thread-local connection was set' do
+      expect(migration.connection).to eq(ActiveRecord::Base.connection)
+    end
+  end
+
+  describe '#with_multiple_threads' do
+    it 'starts multiple threads and yields the supplied block in every thread' do
+      output = Queue.new
+
+      migration.with_multiple_threads(2) do
+        output << migration.connection.execute('SELECT 1')
+      end
+
+      expect(output.size).to eq(2)
+    end
+
+    it 'joins the threads when the join parameter is set' do
+      expect_any_instance_of(Thread).to receive(:join).and_call_original
+
+      migration.with_multiple_threads(1) { }
+    end
+  end
+end
diff --git a/spec/lib/gitlab/database_spec.rb b/spec/lib/gitlab/database_spec.rb
index 4ce4e6e1034..9b1d66a1b1c 100644
--- a/spec/lib/gitlab/database_spec.rb
+++ b/spec/lib/gitlab/database_spec.rb
@@ -150,13 +150,13 @@ describe Gitlab::Database, lib: true do
     it 'returns correct value for PostgreSQL' do
       expect(described_class).to receive(:postgresql?).and_return(true)
 
-      expect(MigrationTest.new.true_value).to eq "'t'"
+      expect(described_class.true_value).to eq "'t'"
     end
 
     it 'returns correct value for MySQL' do
       expect(described_class).to receive(:postgresql?).and_return(false)
 
-      expect(MigrationTest.new.true_value).to eq 1
+      expect(described_class.true_value).to eq 1
     end
   end
 
@@ -164,13 +164,13 @@ describe Gitlab::Database, lib: true do
     it 'returns correct value for PostgreSQL' do
       expect(described_class).to receive(:postgresql?).and_return(true)
 
-      expect(MigrationTest.new.false_value).to eq "'f'"
+      expect(described_class.false_value).to eq "'f'"
     end
 
     it 'returns correct value for MySQL' do
       expect(described_class).to receive(:postgresql?).and_return(false)
 
-      expect(MigrationTest.new.false_value).to eq 0
+      expect(described_class.false_value).to eq 0
     end
   end
 end
diff --git a/spec/lib/gitlab/email/handler/create_note_handler_spec.rb b/spec/lib/gitlab/email/handler/create_note_handler_spec.rb
index b300feaabe1..3f79eaf7afb 100644
--- a/spec/lib/gitlab/email/handler/create_note_handler_spec.rb
+++ b/spec/lib/gitlab/email/handler/create_note_handler_spec.rb
@@ -143,6 +143,7 @@ describe Gitlab::Email::Handler::CreateNoteHandler, lib: true do
       expect(new_note.author).to eq(sent_notification.recipient)
       expect(new_note.position).to eq(note.position)
       expect(new_note.note).to include("I could not disagree more.")
+      expect(new_note.in_reply_to?(note)).to be_truthy
     end
 
     it "adds all attachments" do
diff --git a/spec/lib/gitlab/etag_caching/middleware_spec.rb b/spec/lib/gitlab/etag_caching/middleware_spec.rb
index c872d8232b0..24df04e985a 100644
--- a/spec/lib/gitlab/etag_caching/middleware_spec.rb
+++ b/spec/lib/gitlab/etag_caching/middleware_spec.rb
@@ -91,6 +91,12 @@ describe Gitlab::EtagCaching::Middleware do
       expect(status).to eq 304
     end
 
+    it 'returns empty body' do
+      _, _, body = middleware.call(build_env(path, if_none_match))
+
+      expect(body).to be_empty
+    end
+
     it 'tracks "etag_caching_cache_hit" event' do
       expect(Gitlab::Metrics).to receive(:add_event)
         .with(:etag_caching_middleware_used, endpoint: 'issue_notes')
diff --git a/spec/lib/gitlab/etag_caching/router_spec.rb b/spec/lib/gitlab/etag_caching/router_spec.rb
new file mode 100644
index 00000000000..f3dacb4ef04
--- /dev/null
+++ b/spec/lib/gitlab/etag_caching/router_spec.rb
@@ -0,0 +1,83 @@
+require 'spec_helper'
+
+describe Gitlab::EtagCaching::Router do
+  it 'matches issue notes endpoint' do
+    env = build_env(
+      '/my-group/and-subgroup/here-comes-the-project/noteable/issue/1/notes'
+    )
+
+    result = described_class.match(env)
+
+    expect(result).to be_present
+    expect(result.name).to eq 'issue_notes'
+  end
+
+  it 'matches issue title endpoint' do
+    env = build_env(
+      '/my-group/my-project/issues/123/rendered_title'
+    )
+
+    result = described_class.match(env)
+
+    expect(result).to be_present
+    expect(result.name).to eq 'issue_title'
+  end
+
+  it 'matches project pipelines endpoint' do
+    env = build_env(
+      '/my-group/my-project/pipelines.json'
+    )
+
+    result = described_class.match(env)
+
+    expect(result).to be_present
+    expect(result.name).to eq 'project_pipelines'
+  end
+
+  it 'matches commit pipelines endpoint' do
+    env = build_env(
+      '/my-group/my-project/commit/aa8260d253a53f73f6c26c734c72fdd600f6e6d4/pipelines.json'
+    )
+
+    result = described_class.match(env)
+
+    expect(result).to be_present
+    expect(result.name).to eq 'commit_pipelines'
+  end
+
+  it 'matches new merge request pipelines endpoint' do
+    env = build_env(
+      '/my-group/my-project/merge_requests/new.json'
+    )
+
+    result = described_class.match(env)
+
+    expect(result).to be_present
+    expect(result.name).to eq 'new_merge_request_pipelines'
+  end
+
+  it 'matches merge request pipelines endpoint' do
+    env = build_env(
+      '/my-group/my-project/merge_requests/234/pipelines.json'
+    )
+
+    result = described_class.match(env)
+
+    expect(result).to be_present
+    expect(result.name).to eq 'merge_request_pipelines'
+  end
+
+  it 'does not match blob with confusing name' do
+    env = build_env(
+      '/my-group/my-project/blob/master/pipelines.json'
+    )
+
+    result = described_class.match(env)
+
+    expect(result).to be_blank
+  end
+
+  def build_env(path)
+    { 'PATH_INFO' => path }
+  end
+end
diff --git a/spec/lib/gitlab/git/env_spec.rb b/spec/lib/gitlab/git/env_spec.rb
new file mode 100644
index 00000000000..d9df99bfe05
--- /dev/null
+++ b/spec/lib/gitlab/git/env_spec.rb
@@ -0,0 +1,102 @@
+require 'spec_helper'
+
+describe Gitlab::Git::Env do
+  describe "#set" do
+    context 'with RequestStore.store disabled' do
+      before do
+        allow(RequestStore).to receive(:active?).and_return(false)
+      end
+
+      it 'does not store anything' do
+        described_class.set(GIT_OBJECT_DIRECTORY: 'foo')
+
+        expect(described_class.all).to be_empty
+      end
+    end
+
+    context 'with RequestStore.store enabled' do
+      before do
+        allow(RequestStore).to receive(:active?).and_return(true)
+      end
+
+      it 'whitelist some `GIT_*` variables and stores them using RequestStore' do
+        described_class.set(
+          GIT_OBJECT_DIRECTORY: 'foo',
+          GIT_ALTERNATE_OBJECT_DIRECTORIES: 'bar',
+          GIT_EXEC_PATH: 'baz',
+          PATH: '~/.bin:/bin')
+
+        expect(described_class[:GIT_OBJECT_DIRECTORY]).to eq('foo')
+        expect(described_class[:GIT_ALTERNATE_OBJECT_DIRECTORIES]).to eq('bar')
+        expect(described_class[:GIT_EXEC_PATH]).to be_nil
+        expect(described_class[:bar]).to be_nil
+      end
+    end
+  end
+
+  describe "#all" do
+    context 'with RequestStore.store enabled' do
+      before do
+        allow(RequestStore).to receive(:active?).and_return(true)
+        described_class.set(
+          GIT_OBJECT_DIRECTORY: 'foo',
+          GIT_ALTERNATE_OBJECT_DIRECTORIES: 'bar')
+      end
+
+      it 'returns an env hash' do
+        expect(described_class.all).to eq({
+          'GIT_OBJECT_DIRECTORY' => 'foo',
+          'GIT_ALTERNATE_OBJECT_DIRECTORIES' => 'bar'
+        })
+      end
+    end
+  end
+
+  describe "#[]" do
+    context 'with RequestStore.store enabled' do
+      before do
+        allow(RequestStore).to receive(:active?).and_return(true)
+      end
+
+      before do
+        described_class.set(
+          GIT_OBJECT_DIRECTORY: 'foo',
+          GIT_ALTERNATE_OBJECT_DIRECTORIES: 'bar')
+      end
+
+      it 'returns a stored value for an existing key' do
+        expect(described_class[:GIT_OBJECT_DIRECTORY]).to eq('foo')
+      end
+
+      it 'returns nil for an non-existing key' do
+        expect(described_class[:foo]).to be_nil
+      end
+    end
+  end
+
+  describe 'thread-safety' do
+    context 'with RequestStore.store enabled' do
+      before do
+        allow(RequestStore).to receive(:active?).and_return(true)
+        described_class.set(GIT_OBJECT_DIRECTORY: 'foo')
+      end
+
+      it 'is thread-safe' do
+        another_thread = Thread.new do
+          described_class.set(GIT_OBJECT_DIRECTORY: 'bar')
+
+          Thread.stop
+          described_class[:GIT_OBJECT_DIRECTORY]
+        end
+
+        # Ensure another_thread runs first
+        sleep 0.1 until another_thread.stop?
+
+        expect(described_class[:GIT_OBJECT_DIRECTORY]).to eq('foo')
+
+        another_thread.run
+        expect(another_thread.value).to eq('bar')
+      end
+    end
+  end
+end
diff --git a/spec/lib/gitlab/git/repository_spec.rb b/spec/lib/gitlab/git/repository_spec.rb
index 7e8bb796e03..3d6d7292b42 100644
--- a/spec/lib/gitlab/git/repository_spec.rb
+++ b/spec/lib/gitlab/git/repository_spec.rb
@@ -24,18 +24,49 @@ describe Gitlab::Git::Repository, seed_helper: true do
       end
     end
 
-    context 'with gitaly enabled' do
-      before { stub_gitaly }
+    # TODO: Uncomment when feature is reenabled
+    # context 'with gitaly enabled' do
+    #   before { stub_gitaly }
+    #
+    #   it 'gets the branch name from GitalyClient' do
+    #     expect_any_instance_of(Gitlab::GitalyClient::Ref).to receive(:default_branch_name)
+    #     repository.root_ref
+    #   end
+    #
+    #   it 'wraps GRPC exceptions' do
+    #     expect_any_instance_of(Gitlab::GitalyClient::Ref).to receive(:default_branch_name).
+    #       and_raise(GRPC::Unknown)
+    #     expect { repository.root_ref }.to raise_error(Gitlab::Git::CommandError)
+    #   end
+    # end
+  end
 
-      it 'gets the branch name from GitalyClient' do
-        expect_any_instance_of(Gitlab::GitalyClient::Ref).to receive(:default_branch_name)
-        repository.root_ref
+  describe "#rugged" do
+    context 'with no Git env stored' do
+      before do
+        expect(Gitlab::Git::Env).to receive(:all).and_return({})
+      end
+
+      it "whitelist some variables and pass them via the alternates keyword argument" do
+        expect(Rugged::Repository).to receive(:new).with(repository.path, alternates: [])
+
+        repository.rugged
       end
+    end
 
-      it 'wraps GRPC exceptions' do
-        expect_any_instance_of(Gitlab::GitalyClient::Ref).to receive(:default_branch_name).
-          and_raise(GRPC::Unknown)
-        expect { repository.root_ref }.to raise_error(Gitlab::Git::CommandError)
+    context 'with some Git env stored' do
+      before do
+        expect(Gitlab::Git::Env).to receive(:all).and_return({
+          'GIT_OBJECT_DIRECTORY' => 'foo',
+          'GIT_ALTERNATE_OBJECT_DIRECTORIES' => 'bar',
+          'GIT_OTHER' => 'another_env'
+        })
+      end
+
+      it "whitelist some variables and pass them via the alternates keyword argument" do
+        expect(Rugged::Repository).to receive(:new).with(repository.path, alternates: %w[foo bar])
+
+        repository.rugged
       end
     end
   end
@@ -82,20 +113,21 @@ describe Gitlab::Git::Repository, seed_helper: true do
     it { is_expected.to include("master") }
     it { is_expected.not_to include("branch-from-space") }
 
-    context 'with gitaly enabled' do
-      before { stub_gitaly }
-
-      it 'gets the branch names from GitalyClient' do
-        expect_any_instance_of(Gitlab::GitalyClient::Ref).to receive(:branch_names)
-        subject
-      end
-
-      it 'wraps GRPC exceptions' do
-        expect_any_instance_of(Gitlab::GitalyClient::Ref).to receive(:branch_names).
-          and_raise(GRPC::Unknown)
-        expect { subject }.to raise_error(Gitlab::Git::CommandError)
-      end
-    end
+    # TODO: Uncomment when feature is reenabled
+    # context 'with gitaly enabled' do
+    #   before { stub_gitaly }
+    #
+    #   it 'gets the branch names from GitalyClient' do
+    #     expect_any_instance_of(Gitlab::GitalyClient::Ref).to receive(:branch_names)
+    #     subject
+    #   end
+    #
+    #   it 'wraps GRPC exceptions' do
+    #     expect_any_instance_of(Gitlab::GitalyClient::Ref).to receive(:branch_names).
+    #       and_raise(GRPC::Unknown)
+    #     expect { subject }.to raise_error(Gitlab::Git::CommandError)
+    #   end
+    # end
   end
 
   describe '#tag_names' do
@@ -113,20 +145,21 @@ describe Gitlab::Git::Repository, seed_helper: true do
     it { is_expected.to include("v1.0.0") }
     it { is_expected.not_to include("v5.0.0") }
 
-    context 'with gitaly enabled' do
-      before { stub_gitaly }
-
-      it 'gets the tag names from GitalyClient' do
-        expect_any_instance_of(Gitlab::GitalyClient::Ref).to receive(:tag_names)
-        subject
-      end
-
-      it 'wraps GRPC exceptions' do
-        expect_any_instance_of(Gitlab::GitalyClient::Ref).to receive(:tag_names).
-          and_raise(GRPC::Unknown)
-        expect { subject }.to raise_error(Gitlab::Git::CommandError)
-      end
-    end
+    # TODO: Uncomment when feature is reenabled
+    # context 'with gitaly enabled' do
+    #   before { stub_gitaly }
+    #
+    #   it 'gets the tag names from GitalyClient' do
+    #     expect_any_instance_of(Gitlab::GitalyClient::Ref).to receive(:tag_names)
+    #     subject
+    #   end
+    #
+    #   it 'wraps GRPC exceptions' do
+    #     expect_any_instance_of(Gitlab::GitalyClient::Ref).to receive(:tag_names).
+    #       and_raise(GRPC::Unknown)
+    #     expect { subject }.to raise_error(Gitlab::Git::CommandError)
+    #   end
+    # end
   end
 
   shared_examples 'archive check' do |extenstion|
diff --git a/spec/lib/gitlab/git/rev_list_spec.rb b/spec/lib/gitlab/git/rev_list_spec.rb
index d48629a296d..78894ba9409 100644
--- a/spec/lib/gitlab/git/rev_list_spec.rb
+++ b/spec/lib/gitlab/git/rev_list_spec.rb
@@ -3,58 +3,54 @@ require 'spec_helper'
 describe Gitlab::Git::RevList, lib: true do
   let(:project) { create(:project, :repository) }
 
-  context "validations" do
-    described_class::ALLOWED_VARIABLES.each do |var|
-      context var do
-        it "accepts values starting with the project repo path" do
-          env = { var => "#{project.repository.path_to_repo}/objects" }
-          rev_list = described_class.new('oldrev', 'newrev', project: project, env: env)
-
-          expect(rev_list).to be_valid
-        end
-
-        it "rejects values starting not with the project repo path" do
-          env = { var => "/some/other/path" }
-          rev_list = described_class.new('oldrev', 'newrev', project: project, env: env)
-
-          expect(rev_list).not_to be_valid
-        end
-
-        it "rejects values containing the project repo path but not starting with it" do
-          env = { var => "/some/other/path/#{project.repository.path_to_repo}" }
-          rev_list = described_class.new('oldrev', 'newrev', project: project, env: env)
-
-          expect(rev_list).not_to be_valid
-        end
-
-        it "ignores nil values" do
-          env = { var => nil }
-          rev_list = described_class.new('oldrev', 'newrev', project: project, env: env)
-
-          expect(rev_list).to be_valid
-        end
-      end
-    end
+  before do
+    expect(Gitlab::Git::Env).to receive(:all).and_return({
+      GIT_OBJECT_DIRECTORY: 'foo',
+      GIT_ALTERNATE_OBJECT_DIRECTORIES: 'bar'
+    })
   end
 
-  context "#execute" do
-    let(:env) { { "GIT_OBJECT_DIRECTORY" => project.repository.path_to_repo } }
-    let(:rev_list) { Gitlab::Git::RevList.new('oldrev', 'newrev', project: project, env: env) }
-
-    it "calls out to `popen` without environment variables if the record is invalid" do
-      allow(rev_list).to receive(:valid?).and_return(false)
-
-      expect(Open3).to receive(:popen3).with(hash_excluding(env), any_args)
-
-      rev_list.execute
+  context "#new_refs" do
+    let(:rev_list) { Gitlab::Git::RevList.new(newrev: 'newrev', path_to_repo: project.repository.path_to_repo) }
+
+    it 'calls out to `popen`' do
+      expect(Gitlab::Popen).to receive(:popen).with([
+        Gitlab.config.git.bin_path,
+        "--git-dir=#{project.repository.path_to_repo}",
+        'rev-list',
+        'newrev',
+        '--not',
+        '--all'
+      ],
+      nil,
+      {
+        'GIT_OBJECT_DIRECTORY' => 'foo',
+        'GIT_ALTERNATE_OBJECT_DIRECTORIES' => 'bar'
+      }).and_return(["sha1\nsha2", 0])
+
+      expect(rev_list.new_refs).to eq(%w[sha1 sha2])
     end
+  end
 
-    it "calls out to `popen` with environment variables if the record is valid" do
-      allow(rev_list).to receive(:valid?).and_return(true)
-
-      expect(Open3).to receive(:popen3).with(hash_including(env), any_args)
-
-      rev_list.execute
+  context "#missed_ref" do
+    let(:rev_list) { Gitlab::Git::RevList.new(oldrev: 'oldrev', newrev: 'newrev', path_to_repo: project.repository.path_to_repo) }
+
+    it 'calls out to `popen`' do
+      expect(Gitlab::Popen).to receive(:popen).with([
+        Gitlab.config.git.bin_path,
+        "--git-dir=#{project.repository.path_to_repo}",
+        'rev-list',
+        '--max-count=1',
+        'oldrev',
+        '^newrev'
+      ],
+      nil,
+      {
+        'GIT_OBJECT_DIRECTORY' => 'foo',
+        'GIT_ALTERNATE_OBJECT_DIRECTORIES' => 'bar'
+      }).and_return(["sha1\nsha2", 0])
+
+      expect(rev_list.missed_ref).to eq(%w[sha1 sha2])
     end
   end
 end
diff --git a/spec/lib/gitlab/gitaly_client/commit_spec.rb b/spec/lib/gitlab/gitaly_client/commit_spec.rb
index 4684b1d1ac0..58f11ff8906 100644
--- a/spec/lib/gitlab/gitaly_client/commit_spec.rb
+++ b/spec/lib/gitlab/gitaly_client/commit_spec.rb
@@ -4,7 +4,7 @@ describe Gitlab::GitalyClient::Commit do
   describe '.diff_from_parent' do
     let(:diff_stub) { double('Gitaly::Diff::Stub') }
     let(:project) { create(:project, :repository) }
-    let(:repository_message) { Gitaly::Repository.new(path: project.repository.path) }
+    let(:repository_message) { project.repository.gitaly_repository }
     let(:commit) { project.commit('913c66a37b4a45b9769037c55c2d238bd0942d2e') }
 
     before do
diff --git a/spec/lib/gitlab/gitaly_client/notifications_spec.rb b/spec/lib/gitlab/gitaly_client/notifications_spec.rb
index 39c2048fef8..b87dacb175b 100644
--- a/spec/lib/gitlab/gitaly_client/notifications_spec.rb
+++ b/spec/lib/gitlab/gitaly_client/notifications_spec.rb
@@ -4,7 +4,7 @@ describe Gitlab::GitalyClient::Notifications do
   describe '#post_receive' do
     let(:project) { create(:empty_project) }
     let(:repo_path) { project.repository.path_to_repo }
-    subject { described_class.new(project.repository_storage, project.full_path + '.git') }
+    subject { described_class.new(project.repository) }
 
     it 'sends a post_receive message' do
       expect_any_instance_of(Gitaly::Notifications::Stub).
diff --git a/spec/lib/gitlab/gitaly_client/ref_spec.rb b/spec/lib/gitlab/gitaly_client/ref_spec.rb
index 79c9ca993e4..5405eafd281 100644
--- a/spec/lib/gitlab/gitaly_client/ref_spec.rb
+++ b/spec/lib/gitlab/gitaly_client/ref_spec.rb
@@ -3,7 +3,7 @@ require 'spec_helper'
 describe Gitlab::GitalyClient::Ref do
   let(:project) { create(:empty_project) }
   let(:repo_path) { project.repository.path_to_repo }
-  let(:client) { Gitlab::GitalyClient::Ref.new(project.repository_storage, project.full_path + '.git') }
+  let(:client) { Gitlab::GitalyClient::Ref.new(project.repository) }
 
   before do
     allow(Gitlab.config.gitaly).to receive(:enabled).and_return(true)
diff --git a/spec/lib/gitlab/healthchecks/db_check_spec.rb b/spec/lib/gitlab/healthchecks/db_check_spec.rb
new file mode 100644
index 00000000000..33c6c24449c
--- /dev/null
+++ b/spec/lib/gitlab/healthchecks/db_check_spec.rb
@@ -0,0 +1,6 @@
+require 'spec_helper'
+require_relative './simple_check_shared'
+
+describe Gitlab::HealthChecks::DbCheck do
+  include_examples 'simple_check', 'db_ping', 'Db', '1'
+end
diff --git a/spec/lib/gitlab/healthchecks/fs_shards_check_spec.rb b/spec/lib/gitlab/healthchecks/fs_shards_check_spec.rb
new file mode 100644
index 00000000000..4cd8cf313a5
--- /dev/null
+++ b/spec/lib/gitlab/healthchecks/fs_shards_check_spec.rb
@@ -0,0 +1,127 @@
+require 'spec_helper'
+
+describe Gitlab::HealthChecks::FsShardsCheck do
+  let(:metric_class) { Gitlab::HealthChecks::Metric }
+  let(:result_class) { Gitlab::HealthChecks::Result }
+  let(:repository_storages) { [:default] }
+  let(:tmp_dir) { Dir.mktmpdir }
+
+  let(:storages_paths) do
+    {
+      default: { path: tmp_dir }
+    }.with_indifferent_access
+  end
+
+  before do
+    allow(described_class).to receive(:repository_storages) { repository_storages }
+    allow(described_class).to receive(:storages_paths) { storages_paths }
+  end
+
+  after do
+    FileUtils.remove_entry_secure(tmp_dir) if Dir.exist?(tmp_dir)
+  end
+
+  shared_examples 'filesystem checks' do
+    describe '#readiness' do
+      subject { described_class.readiness }
+
+      context 'storage points to not existing folder' do
+        let(:storages_paths) do
+          {
+            default: { path: 'tmp/this/path/doesnt/exist' }
+          }.with_indifferent_access
+        end
+
+        it { is_expected.to include(result_class.new(false, 'cannot stat storage', shard: :default)) }
+      end
+
+      context 'storage points to directory that has both read and write rights' do
+        before do
+          FileUtils.chmod_R(0755, tmp_dir)
+        end
+
+        it { is_expected.to include(result_class.new(true, nil, shard: :default)) }
+
+        it 'cleans up files used for testing' do
+          expect(described_class).to receive(:storage_write_test).with(any_args).and_call_original
+
+          subject
+
+          expect(Dir.entries(tmp_dir).count).to eq(2)
+        end
+
+        context 'read test fails' do
+          before do
+            allow(described_class).to receive(:storage_read_test).with(any_args).and_return(false)
+          end
+
+          it { is_expected.to include(result_class.new(false, 'cannot read from storage', shard: :default)) }
+        end
+
+        context 'write test fails' do
+          before do
+            allow(described_class).to receive(:storage_write_test).with(any_args).and_return(false)
+          end
+
+          it { is_expected.to include(result_class.new(false, 'cannot write to storage', shard: :default)) }
+        end
+      end
+    end
+
+    describe '#metrics' do
+      subject { described_class.metrics }
+
+      context 'storage points to not existing folder' do
+        let(:storages_paths) do
+          {
+            default: { path: 'tmp/this/path/doesnt/exist' }
+          }.with_indifferent_access
+        end
+
+        it { is_expected.to include(metric_class.new(:filesystem_accessible, 0, shard: :default)) }
+        it { is_expected.to include(metric_class.new(:filesystem_readable, 0, shard: :default)) }
+        it { is_expected.to include(metric_class.new(:filesystem_writable, 0, shard: :default)) }
+
+        it { is_expected.to include(have_attributes(name: :filesystem_access_latency, value: be > 0, labels: { shard: :default })) }
+        it { is_expected.to include(have_attributes(name: :filesystem_read_latency, value: be > 0, labels: { shard: :default })) }
+        it { is_expected.to include(have_attributes(name: :filesystem_write_latency, value: be > 0, labels: { shard: :default })) }
+      end
+
+      context 'storage points to directory that has both read and write rights' do
+        before do
+          FileUtils.chmod_R(0755, tmp_dir)
+        end
+
+        it { is_expected.to include(metric_class.new(:filesystem_accessible, 1, shard: :default)) }
+        it { is_expected.to include(metric_class.new(:filesystem_readable, 1, shard: :default)) }
+        it { is_expected.to include(metric_class.new(:filesystem_writable, 1, shard: :default)) }
+
+        it { is_expected.to include(have_attributes(name: :filesystem_access_latency, value: be > 0, labels: { shard: :default })) }
+        it { is_expected.to include(have_attributes(name: :filesystem_read_latency, value: be > 0, labels: { shard: :default })) }
+        it { is_expected.to include(have_attributes(name: :filesystem_write_latency, value: be > 0, labels: { shard: :default })) }
+      end
+    end
+  end
+
+  context 'when popen always finds required binaries' do
+    before do
+      allow(Gitlab::Popen).to receive(:popen).and_wrap_original do |method, *args, &block|
+        begin
+          method.call(*args, &block)
+        rescue RuntimeError
+          raise 'expected not to happen'
+        end
+      end
+    end
+
+    it_behaves_like 'filesystem checks'
+  end
+
+  context 'when popen never finds required binaries' do
+    before do
+      allow(Gitlab::Popen).to receive(:popen).and_raise(Errno::ENOENT)
+    end
+
+    it_behaves_like 'filesystem checks'
+  end
+end
diff --git a/spec/lib/gitlab/healthchecks/redis_check_spec.rb b/spec/lib/gitlab/healthchecks/redis_check_spec.rb
new file mode 100644
index 00000000000..734cdcb893e
--- /dev/null
+++ b/spec/lib/gitlab/healthchecks/redis_check_spec.rb
@@ -0,0 +1,6 @@
+require 'spec_helper'
+require_relative './simple_check_shared'
+
+describe Gitlab::HealthChecks::RedisCheck do
+  include_examples 'simple_check', 'redis_ping', 'Redis', 'PONG'
+end
diff --git a/spec/lib/gitlab/healthchecks/simple_check_shared.rb b/spec/lib/gitlab/healthchecks/simple_check_shared.rb
new file mode 100644
index 00000000000..1fa6d0faef9
--- /dev/null
+++ b/spec/lib/gitlab/healthchecks/simple_check_shared.rb
@@ -0,0 +1,66 @@
+shared_context 'simple_check' do |metrics_prefix, check_name, success_result|
+  describe '#metrics' do
+    subject { described_class.metrics }
+    context 'Check is passing' do
+      before do
+        allow(described_class).to receive(:check).and_return success_result
+      end
+
+      it { is_expected.to include(have_attributes(name: "#{metrics_prefix}_success", value: 1)) }
+      it { is_expected.to include(have_attributes(name: "#{metrics_prefix}_timeout", value: 0)) }
+      it { is_expected.to include(have_attributes(name: "#{metrics_prefix}_latency", value: be > 0)) }
+    end
+
+    context 'Check is misbehaving' do
+      before do
+        allow(described_class).to receive(:check).and_return 'error!'
+      end
+
+      it { is_expected.to include(have_attributes(name: "#{metrics_prefix}_success", value: 0)) }
+      it { is_expected.to include(have_attributes(name: "#{metrics_prefix}_timeout", value: 0)) }
+      it { is_expected.to include(have_attributes(name: "#{metrics_prefix}_latency", value: be > 0)) }
+    end
+
+    context 'Check is timeouting' do
+      before do
+        allow(described_class).to receive(:check).and_return Timeout::Error.new
+      end
+
+      it { is_expected.to include(have_attributes(name: "#{metrics_prefix}_success", value: 0)) }
+      it { is_expected.to include(have_attributes(name: "#{metrics_prefix}_timeout", value: 1)) }
+      it { is_expected.to include(have_attributes(name: "#{metrics_prefix}_latency", value: be > 0)) }
+    end
+  end
+
+  describe '#readiness' do
+    subject { described_class.readiness }
+    context 'Check returns ok' do
+      before do
+        allow(described_class).to receive(:check).and_return success_result
+      end
+
+      it { is_expected.to have_attributes(success: true) }
+    end
+
+    context 'Check is misbehaving' do
+      before do
+        allow(described_class).to receive(:check).and_return 'error!'
+      end
+
+      it { is_expected.to have_attributes(success: false, message: "unexpected #{check_name} check result: error!") }
+    end
+
+    context 'Check is timeouting' do
+      before do
+        allow(described_class).to receive(:check ).and_return Timeout::Error.new
+      end
+
+      it { is_expected.to have_attributes(success: false, message: "#{check_name} check timed out") }
+    end
+  end
+
+  describe '#liveness' do
+    subject { described_class.readiness }
+    it { is_expected.to eq(Gitlab::HealthChecks::Result.new(true)) }
+  end
+end
diff --git a/spec/lib/gitlab/import_export/all_models.yml b/spec/lib/gitlab/import_export/all_models.yml
index 24654bf6afd..0abf89d060c 100644
--- a/spec/lib/gitlab/import_export/all_models.yml
+++ b/spec/lib/gitlab/import_export/all_models.yml
@@ -89,16 +89,28 @@ pipelines:
 - statuses
 - builds
 - trigger_requests
+- auto_canceled_by
+- auto_canceled_pipelines
+- auto_canceled_jobs
+- pending_builds
+- retryable_builds
+- cancelable_statuses
+- manual_actions
+- artifacts
 statuses:
 - project
 - pipeline
 - user
+- auto_canceled_by
 variables:
 - project
 triggers:
 - project
 - trigger_requests
 - owner
+- trigger_schedule
+trigger_schedule:
+- trigger
 deploy_keys:
 - user
 - deploy_keys_projects
@@ -112,10 +124,18 @@ protected_branches:
 - project
 - merge_access_levels
 - push_access_levels
+protected_tags:
+- project
+- create_access_levels
 merge_access_levels:
 - protected_branch
 push_access_levels:
 - protected_branch
+create_access_levels:
+- protected_tag
+container_repositories:
+- project
+- name
 project:
 - taggings
 - base_tags
@@ -143,6 +163,7 @@ project:
 - asana_service
 - gemnasium_service
 - slack_service
+- microsoft_teams_service
 - mattermost_service
 - buildkite_service
 - bamboo_service
@@ -172,6 +193,7 @@ project:
 - snippets
 - hooks
 - protected_branches
+- protected_tags
 - project_members
 - users
 - requesters
@@ -192,8 +214,10 @@ project:
 - builds
 - runner_projects
 - runners
+- active_runners
 - variables
 - triggers
+- trigger_schedules
 - environments
 - deployments
 - project_feature
@@ -202,6 +226,7 @@ project:
 - project_authorizations
 - route
 - statistics
+- container_repositories
 - uploads
 award_emoji:
 - awardable
diff --git a/spec/lib/gitlab/import_export/project.json b/spec/lib/gitlab/import_export/project.json
index d9b67426818..7a0b0b06d4b 100644
--- a/spec/lib/gitlab/import_export/project.json
+++ b/spec/lib/gitlab/import_export/project.json
@@ -7455,6 +7455,24 @@
       ]
     }
   ],
+  "protected_tags": [
+    {
+      "id": 1,
+      "project_id": 9,
+      "name": "v*",
+      "created_at": "2017-04-04T13:48:13.426Z",
+      "updated_at": "2017-04-04T13:48:13.426Z",
+      "create_access_levels": [
+        {
+          "id": 1,
+          "protected_tag_id": 1,
+          "access_level": 40,
+          "created_at": "2017-04-04T13:48:13.458Z",
+          "updated_at": "2017-04-04T13:48:13.458Z"
+        }
+      ]
+    }
+  ],
   "project_feature": {
     "builds_access_level": 0,
     "created_at": "2014-12-26T09:26:45.000Z",
diff --git a/spec/lib/gitlab/import_export/project_tree_restorer_spec.rb b/spec/lib/gitlab/import_export/project_tree_restorer_spec.rb
index af9c25acb02..0e9607c5bd3 100644
--- a/spec/lib/gitlab/import_export/project_tree_restorer_spec.rb
+++ b/spec/lib/gitlab/import_export/project_tree_restorer_spec.rb
@@ -64,6 +64,10 @@ describe Gitlab::ImportExport::ProjectTreeRestorer, services: true do
         expect(ProtectedBranch.first.push_access_levels).not_to be_empty
       end
 
+      it 'contains the create access levels on a protected tag' do
+        expect(ProtectedTag.first.create_access_levels).not_to be_empty
+      end
+
       context 'event at forth level of the tree' do
         let(:event) { Event.where(title: 'test levels').first }
 
diff --git a/spec/lib/gitlab/import_export/safe_model_attributes.yml b/spec/lib/gitlab/import_export/safe_model_attributes.yml
index 1ad16a9b57d..0372e3f7dbf 100644
--- a/spec/lib/gitlab/import_export/safe_model_attributes.yml
+++ b/spec/lib/gitlab/import_export/safe_model_attributes.yml
@@ -183,6 +183,7 @@ Ci::Pipeline:
 - duration
 - user_id
 - lock_version
+- auto_canceled_by_id
 CommitStatus:
 - id
 - project_id
@@ -223,6 +224,7 @@ CommitStatus:
 - token
 - lock_version
 - coverage_regex
+- auto_canceled_by_id
 Ci::Variable:
 - id
 - project_id
@@ -240,6 +242,19 @@ Ci::Trigger:
 - updated_at
 - owner_id
 - description
+- ref
+Ci::TriggerSchedule:
+- id
+- project_id
+- trigger_id
+- deleted_at
+- created_at
+- updated_at
+- cron
+- cron_timezone
+- next_run_at
+- ref
+- active
 DeployKey:
 - id
 - user_id
@@ -300,6 +315,12 @@ ProtectedBranch:
 - name
 - created_at
 - updated_at
+ProtectedTag:
+- id
+- project_id
+- name
+- created_at
+- updated_at
 Project:
 - description
 - issues_enabled
@@ -333,6 +354,14 @@ ProtectedBranch::PushAccessLevel:
 - access_level
 - created_at
 - updated_at
+ProtectedTag::CreateAccessLevel:
+- id
+- protected_tag_id
+- access_level
+- created_at
+- updated_at
+- user_id
+- group_id
 AwardEmoji:
 - id
 - user_id
diff --git a/spec/lib/gitlab/user_access_spec.rb b/spec/lib/gitlab/user_access_spec.rb
index 369e55f61f1..611cdbbc865 100644
--- a/spec/lib/gitlab/user_access_spec.rb
+++ b/spec/lib/gitlab/user_access_spec.rb
@@ -142,4 +142,73 @@ describe Gitlab::UserAccess, lib: true do
       end
     end
   end
+
+  describe 'can_create_tag?' do
+    describe 'push to none protected tag' do
+      it 'returns true if user is a master' do
+        project.add_user(user, :master)
+
+        expect(access.can_create_tag?('random_tag')).to be_truthy
+      end
+
+      it 'returns true if user is a developer' do
+        project.add_user(user, :developer)
+
+        expect(access.can_create_tag?('random_tag')).to be_truthy
+      end
+
+      it 'returns false if user is a reporter' do
+        project.add_user(user, :reporter)
+
+        expect(access.can_create_tag?('random_tag')).to be_falsey
+      end
+    end
+
+    describe 'push to protected tag' do
+      let(:tag) { create(:protected_tag, project: project, name: "test") }
+      let(:not_existing_tag) { create :protected_tag, project: project }
+
+      it 'returns true if user is a master' do
+        project.add_user(user, :master)
+
+        expect(access.can_create_tag?(tag.name)).to be_truthy
+      end
+
+      it 'returns false if user is a developer' do
+        project.add_user(user, :developer)
+
+        expect(access.can_create_tag?(tag.name)).to be_falsey
+      end
+
+      it 'returns false if user is a reporter' do
+        project.add_user(user, :reporter)
+
+        expect(access.can_create_tag?(tag.name)).to be_falsey
+      end
+    end
+
+    describe 'push to protected tag if allowed for developers' do
+      before do
+        @tag = create(:protected_tag, :developers_can_create, project: project)
+      end
+
+      it 'returns true if user is a master' do
+        project.add_user(user, :master)
+
+        expect(access.can_create_tag?(@tag.name)).to be_truthy
+      end
+
+      it 'returns true if user is a developer' do
+        project.add_user(user, :developer)
+
+        expect(access.can_create_tag?(@tag.name)).to be_truthy
+      end
+
+      it 'returns false if user is a reporter' do
+        project.add_user(user, :reporter)
+
+        expect(access.can_create_tag?(@tag.name)).to be_falsey
+      end
+    end
+  end
 end
diff --git a/spec/lib/microsoft_teams/activity_spec.rb b/spec/lib/microsoft_teams/activity_spec.rb
new file mode 100644
index 00000000000..7890ae2e7b0
--- /dev/null
+++ b/spec/lib/microsoft_teams/activity_spec.rb
@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe MicrosoftTeams::Activity do
+  subject { described_class.new(title: 'title', subtitle: 'subtitle', text: 'text', image: 'image') }
+
+  describe '#prepare' do
+    it 'returns the correct JSON object' do
+      expect(subject.prepare).to eq({
+        'activityTitle' => 'title',
+        'activitySubtitle' => 'subtitle',
+        'activityText' => 'text',
+        'activityImage' => 'image'
+      })
+    end
+  end
+end
diff --git a/spec/lib/microsoft_teams/notifier_spec.rb b/spec/lib/microsoft_teams/notifier_spec.rb
new file mode 100644
index 00000000000..3035693812f
--- /dev/null
+++ b/spec/lib/microsoft_teams/notifier_spec.rb
@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+describe MicrosoftTeams::Notifier do
+  subject { described_class.new(webhook_url) }
+
+  let(:webhook_url) { 'https://example.gitlab.com/'}
+  let(:header) { { 'Content-Type' => 'application/json' } }
+  let(:options) do
+    {
+      title: 'JohnDoe4/project2',
+      pretext: '[[JohnDoe4/project2](http://localhost/namespace2/gitlabhq)] Issue [#1 Awesome issue](http://localhost/namespace2/gitlabhq/issues/1) opened by user6',
+      activity: {
+        title: 'Issue opened by user6',
+        subtitle: 'in [JohnDoe4/project2](http://localhost/namespace2/gitlabhq)',
+        text: '[#1 Awesome issue](http://localhost/namespace2/gitlabhq/issues/1)',
+        image: 'http://someimage.com'
+      },
+      attachments: 'please fix'
+    }
+  end
+
+  let(:body) do
+    {
+      'sections' => [
+        {
+          'activityTitle' => 'Issue opened by user6',
+          'activitySubtitle' => 'in [JohnDoe4/project2](http://localhost/namespace2/gitlabhq)',
+          'activityText' => '[#1 Awesome issue](http://localhost/namespace2/gitlabhq/issues/1)',
+          'activityImage' => 'http://someimage.com'
+        },
+        {
+          'title' => 'Details',
+          'facts' => [
+            {
+              'name' => 'Attachments',
+              'value' => 'please fix'
+            }
+          ]
+        }
+      ],
+      'title' => 'JohnDoe4/project2',
+      'summary' => '[[JohnDoe4/project2](http://localhost/namespace2/gitlabhq)] Issue [#1 Awesome issue](http://localhost/namespace2/gitlabhq/issues/1) opened by user6'
+    }
+  end
+
+  describe '#ping' do
+    before do
+      stub_request(:post, webhook_url).with(body: JSON(body), headers: { 'Content-Type' => 'application/json' }).to_return(status: 200, body: "", headers: {})
+    end
+
+    it 'expects to receive successfull answer' do
+      expect(subject.ping(options)).to be true
+    end
+  end
+end
diff --git a/spec/mailers/notify_spec.rb b/spec/mailers/notify_spec.rb
index 6a89b007f96..e6f0a3b5920 100644
--- a/spec/mailers/notify_spec.rb
+++ b/spec/mailers/notify_spec.rb
@@ -63,7 +63,7 @@ describe Notify do
 
             it 'contains a link to note author' do
               is_expected.to have_html_escaped_body_text(issue.author_name)
-              is_expected.to have_body_text 'wrote:'
+              is_expected.to have_body_text 'created an issue:'
             end
           end
         end
@@ -215,7 +215,7 @@ describe Notify do
 
             it 'contains a link to note author' do
               is_expected.to have_html_escaped_body_text merge_request.author_name
-              is_expected.to have_body_text 'wrote:'
+              is_expected.to have_body_text 'created a merge request:'
             end
           end
         end
@@ -554,7 +554,7 @@ describe Notify do
         end
 
         it 'does not contain note author' do
-          is_expected.not_to have_body_text 'wrote:'
+          is_expected.not_to have_body_text note.author_name
         end
 
         context 'when enabled email_author_in_body' do
@@ -564,7 +564,6 @@ describe Notify do
 
           it 'contains a link to note author' do
             is_expected.to have_html_escaped_body_text note.author_name
-            is_expected.to have_body_text 'wrote:'
           end
         end
       end
@@ -637,7 +636,7 @@ describe Notify do
       end
     end
 
-    context 'items that are noteable, emails for a note on a diff' do
+    context 'items that are noteable, the email for a discussion note' do
       let(:project) { create(:project, :repository) }
       let(:note_author) { create(:user, name: 'author_name') }
 
@@ -645,8 +644,118 @@ describe Notify do
         allow(Note).to receive(:find).with(note.id).and_return(note)
       end
 
-      shared_examples 'a note email on a diff' do  |model|
-        let(:note) { create(model, project: project, author: note_author) }
+      shared_examples 'a discussion note email' do |model|
+        it_behaves_like 'it should have Gmail Actions links'
+
+        it 'is sent to the given recipient as the author' do
+          sender = subject.header[:from].addrs[0]
+
+          aggregate_failures do
+            expect(sender.display_name).to eq(note_author.name)
+            expect(sender.address).to eq(gitlab_sender)
+            expect(subject).to deliver_to(recipient.notification_email)
+          end
+        end
+
+        it 'contains the message from the note' do
+          is_expected.to have_body_text note.note
+        end
+
+        it 'contains an introduction' do
+          is_expected.to have_body_text 'started a new discussion'
+        end
+
+        context 'when a comment on an existing discussion' do
+          let!(:second_note) { create(model, author: note_author, noteable: nil, in_reply_to: note) }
+
+          it 'contains an introduction' do
+            is_expected.to have_body_text 'commented on a'
+          end
+        end
+      end
+
+      describe 'on a commit' do
+        let(:commit) { project.commit }
+        let(:note) { create(:discussion_note_on_commit, commit_id: commit.id, project: project, author: note_author) }
+
+        before(:each) { allow(note).to receive(:noteable).and_return(commit) }
+
+        subject { Notify.note_commit_email(recipient.id, note.id) }
+
+        it_behaves_like 'a discussion note email', :discussion_note_on_commit
+        it_behaves_like 'an answer to an existing thread with reply-by-email enabled' do
+          let(:model) { commit }
+        end
+        it_behaves_like 'it should show Gmail Actions View Commit link'
+        it_behaves_like 'a user cannot unsubscribe through footer link'
+
+        it 'has the correct subject' do
+          is_expected.to have_subject "Re: #{project.name} | #{commit.title.strip} (#{commit.short_id})"
+        end
+
+        it 'contains a link to the commit' do
+          is_expected.to have_body_text commit.short_id
+        end
+      end
+
+      describe 'on a merge request' do
+        let(:merge_request) { create(:merge_request, source_project: project, target_project: project) }
+        let(:note) { create(:discussion_note_on_merge_request, noteable: merge_request, project: project, author: note_author) }
+        let(:note_on_merge_request_path) { namespace_project_merge_request_path(project.namespace, project, merge_request, anchor: "note_#{note.id}") }
+        before(:each) { allow(note).to receive(:noteable).and_return(merge_request) }
+
+        subject { Notify.note_merge_request_email(recipient.id, note.id) }
+
+        it_behaves_like 'a discussion note email', :discussion_note_on_merge_request
+        it_behaves_like 'an answer to an existing thread with reply-by-email enabled' do
+          let(:model) { merge_request }
+        end
+        it_behaves_like 'it should show Gmail Actions View Merge request link'
+        it_behaves_like 'an unsubscribeable thread'
+
+        it 'has the correct subject' do
+          is_expected.to have_referable_subject(merge_request, reply: true)
+        end
+
+        it 'contains a link to the merge request note' do
+          is_expected.to have_body_text note_on_merge_request_path
+        end
+      end
+
+      describe 'on an issue' do
+        let(:issue) { create(:issue, project: project) }
+        let(:note) { create(:discussion_note_on_issue, noteable: issue, project: project, author: note_author) }
+        let(:note_on_issue_path) { namespace_project_issue_path(project.namespace, project, issue, anchor: "note_#{note.id}") }
+        before(:each) { allow(note).to receive(:noteable).and_return(issue) }
+
+        subject { Notify.note_issue_email(recipient.id, note.id) }
+
+        it_behaves_like 'a discussion note email', :discussion_note_on_issue
+        it_behaves_like 'an answer to an existing thread with reply-by-email enabled' do
+          let(:model) { issue }
+        end
+        it_behaves_like 'it should show Gmail Actions View Issue link'
+        it_behaves_like 'an unsubscribeable thread'
+
+        it 'has the correct subject' do
+          is_expected.to have_referable_subject(issue, reply: true)
+        end
+
+        it 'contains a link to the issue note' do
+          is_expected.to have_body_text note_on_issue_path
+        end
+      end
+    end
+
+    context 'items that are noteable, the email for a diff discussion note' do
+      let(:note_author) { create(:user, name: 'author_name') }
+
+      before :each do
+        allow(Note).to receive(:find).with(note.id).and_return(note)
+      end
+
+      shared_examples 'an email for a note on a diff discussion' do  |model|
+        let(:note) { create(model, author: note_author) }
 
         it "includes diffs with character-level highlighting" do
           is_expected.to have_body_text '<span class="p">}</span></span>'
@@ -672,18 +781,15 @@ describe Notify do
           is_expected.to have_html_escaped_body_text note.note
         end
 
-        it 'does not contain note author' do
-          is_expected.not_to have_body_text 'wrote:'
+        it 'contains an introduction' do
+          is_expected.to have_body_text 'started a new discussion on'
         end
 
-        context 'when enabled email_author_in_body' do
-          before do
-            stub_application_setting(email_author_in_body: true)
-          end
+        context 'when a comment on an existing discussion' do
+          let!(:second_note) { create(model, author: note_author, noteable: nil, in_reply_to: note) }
 
-          it 'contains a link to note author' do
-            is_expected.to have_html_escaped_body_text note.author_name
-            is_expected.to have_body_text 'wrote:'
+          it 'contains an introduction' do
+            is_expected.to have_body_text 'commented on a discussion on'
           end
         end
       end
@@ -694,7 +800,7 @@ describe Notify do
 
         subject { Notify.note_commit_email(recipient.id, note.id) }
 
-        it_behaves_like 'a note email on a diff', :diff_note_on_commit
+        it_behaves_like 'an email for a note on a diff discussion', :diff_note_on_commit
         it_behaves_like 'it should show Gmail Actions View Commit link'
         it_behaves_like 'a user cannot unsubscribe through footer link'
       end
@@ -705,7 +811,7 @@ describe Notify do
 
         subject { Notify.note_merge_request_email(recipient.id, note.id) }
 
-        it_behaves_like 'a note email on a diff', :diff_note_on_merge_request
+        it_behaves_like 'an email for a note on a diff discussion', :diff_note_on_merge_request
         it_behaves_like 'it should show Gmail Actions View Merge request link'
         it_behaves_like 'an unsubscribeable thread'
       end
diff --git a/spec/mailers/previews/notify_preview.rb b/spec/mailers/previews/notify_preview.rb
index 0e1ccb5b847..580f0d56a92 100644
--- a/spec/mailers/previews/notify_preview.rb
+++ b/spec/mailers/previews/notify_preview.rb
@@ -1,4 +1,100 @@
 class NotifyPreview < ActionMailer::Preview
+  def note_merge_request_email_for_individual_note
+    note_email(:note_merge_request_email) do
+      note = <<-MD.strip_heredoc
+        This is an individual note on a merge request :smiley:
+
+        In this notification email, we expect to see:
+
+        - The note contents (that's what you're looking at)
+        - A link to view this note on Gitlab
+        - An explanation for why the user is receiving this notification
+      MD
+
+      create_note(noteable_type: 'merge_request', noteable_id: merge_request.id, note: note)
+    end
+  end
+
+  def note_merge_request_email_for_discussion
+    note_email(:note_merge_request_email) do
+      note = <<-MD.strip_heredoc
+        This is a new discussion on a merge request :smiley:
+
+        In this notification email, we expect to see:
+
+        - A line saying who started this discussion
+        - The note contents (that's what you're looking at)
+        - A link to view this discussion on Gitlab
+        - An explanation for why the user is receiving this notification
+      MD
+
+      create_note(noteable_type: 'merge_request', noteable_id: merge_request.id, type: 'DiscussionNote', note: note)
+    end
+  end
+
+  def note_merge_request_email_for_diff_discussion
+    note_email(:note_merge_request_email) do
+      note = <<-MD.strip_heredoc
+        This is a new discussion on a merge request :smiley:
+
+        In this notification email, we expect to see:
+
+        - A line saying who started this discussion and on what file
+        - The diff
+        - The note contents (that's what you're looking at)
+        - A link to view this discussion on Gitlab
+        - An explanation for why the user is receiving this notification
+      MD
+
+      position = Gitlab::Diff::Position.new(
+        old_path: "files/ruby/popen.rb",
+        new_path: "files/ruby/popen.rb",
+        old_line: nil,
+        new_line: 14,
+        diff_refs: merge_request.diff_refs
+      )
+
+      create_note(noteable_type: 'merge_request', noteable_id: merge_request.id, type: 'DiffNote', position: position, note: note)
+    end
+  end
+
+  private
+
+  def project
+    @project ||= Project.find_by_full_path('gitlab-org/gitlab-test')
+  end
+
+  def merge_request
+    @merge_request ||= project.merge_requests.find_by(source_branch: 'master', target_branch: 'feature')
+  end
+
+  def user
+    @user ||= User.last
+  end
+
+  def create_note(params)
+    Notes::CreateService.new(project, user, params).execute
+  end
+
+  def note_email(method)
+    cleanup do
+      note = yield
+
+      Notify.public_send(method, user.id, note)
+    end
+  end
+
+  def cleanup
+    email = nil
+
+    ActiveRecord::Base.transaction do
+      email = yield
+      raise ActiveRecord::Rollback
+    end
+
+    email
+  end
+
   def pipeline_success_email
     pipeline = Ci::Pipeline.last
     Notify.pipeline_success_email(pipeline, pipeline.user.try(:email))
diff --git a/spec/migrations/migrate_user_project_view_spec.rb b/spec/migrations/migrate_user_project_view_spec.rb
new file mode 100644
index 00000000000..dacaa834aa9
--- /dev/null
+++ b/spec/migrations/migrate_user_project_view_spec.rb
@@ -0,0 +1,17 @@
+# encoding: utf-8
+
+require 'spec_helper'
+require Rails.root.join('db', 'post_migrate', '20170406142253_migrate_user_project_view.rb')
+
+describe MigrateUserProjectView do
+  let(:migration) { described_class.new }
+  let!(:user) { create(:user, project_view: 'readme') }
+
+  describe '#up' do
+    it 'updates project view setting with new value' do
+      migration.up
+
+      expect(user.reload.project_view).to eq('files')
+    end
+  end
+end
diff --git a/spec/migrations/schema_spec.rb b/spec/migrations/schema_spec.rb
new file mode 100644
index 00000000000..e132529d8d8
--- /dev/null
+++ b/spec/migrations/schema_spec.rb
@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+# Check consistency of db/schema.rb version, migrations' timestamps, and the latest migration timestamp
+# stored in the database's schema_migrations table.
+
+describe ActiveRecord::Schema do
+  let(:latest_migration_timestamp) do
+    migrations = Dir[Rails.root.join('db', 'migrate', '*'), Rails.root.join('db', 'post_migrate', '*')]
+    migrations.map { |migration| File.basename(migration).split('_').first.to_i }.max
+  end
+
+  it '> schema version equals last migration timestamp' do
+    defined_schema_version = File.open(Rails.root.join('db', 'schema.rb')) do |file|
+      file.find { |line| line =~ /ActiveRecord::Schema.define/ }
+    end.match(/(\d+)/)[0].to_i
+
+    expect(defined_schema_version).to eq(latest_migration_timestamp)
+  end
+
+  it '> schema version should equal the latest migration timestamp stored in schema_migrations table' do
+    expect(latest_migration_timestamp).to eq(ActiveRecord::Migrator.current_version.to_i)
+  end
+end
diff --git a/spec/models/award_emoji_spec.rb b/spec/models/award_emoji_spec.rb
index cb3c592f8cd..2a9a27752c1 100644
--- a/spec/models/award_emoji_spec.rb
+++ b/spec/models/award_emoji_spec.rb
@@ -25,6 +25,20 @@ describe AwardEmoji, models: true do
 
         expect(new_award).not_to be_valid
       end
+
+      # Assume User A and User B both created award emoji of the same name
+      # on the same awardable. When User A is deleted, User A's award emoji
+      # is moved to the ghost user. When User B is deleted, User B's award emoji
+      # also needs to be moved to the ghost user - this cannot happen unless
+      # the uniqueness validation is disabled for ghost users.
+      it "allows duplicate award emoji for ghost users" do
+        user  = create(:user, :ghost)
+        issue = create(:issue)
+        create(:award_emoji, user: user, awardable: issue)
+        new_award = build(:award_emoji, user: user, awardable: issue)
+
+        expect(new_award).to be_valid
+      end
     end
   end
 end
diff --git a/spec/models/blob_spec.rb b/spec/models/blob_spec.rb
index 0f29766db41..e5dd57fc4bb 100644
--- a/spec/models/blob_spec.rb
+++ b/spec/models/blob_spec.rb
@@ -55,13 +55,13 @@ describe Blob do
 
   describe '#pdf?' do
     it 'is falsey when file extension is not .pdf' do
-      git_blob = double(name: 'git_blob.txt')
+      git_blob = Gitlab::Git::Blob.new(name: 'git_blob.txt')
 
       expect(described_class.decorate(git_blob)).not_to be_pdf
     end
 
     it 'is truthy when file extension is .pdf' do
-      git_blob = double(name: 'git_blob.pdf')
+      git_blob = Gitlab::Git::Blob.new(name: 'git_blob.pdf')
 
       expect(described_class.decorate(git_blob)).to be_pdf
     end
@@ -140,7 +140,7 @@ describe Blob do
         stl?: false
       )
 
-      described_class.decorate(double).tap do |blob|
+      described_class.decorate(Gitlab::Git::Blob.new({})).tap do |blob|
         allow(blob).to receive_messages(overrides)
       end
     end
@@ -158,7 +158,7 @@ describe Blob do
 
     it 'handles SVGs' do
       blob = stubbed_blob(text?: true, svg?: true)
-      expect(blob.to_partial_path(project)).to eq 'image'
+      expect(blob.to_partial_path(project)).to eq 'svg'
     end
 
     it 'handles images' do
@@ -167,7 +167,7 @@ describe Blob do
     end
 
     it 'handles text' do
-      blob = stubbed_blob(text?: true)
+      blob = stubbed_blob(text?: true, name: 'test.txt')
       expect(blob.to_partial_path(project)).to eq 'text'
     end
 
diff --git a/spec/models/ci/build_spec.rb b/spec/models/ci/build_spec.rb
index cdceca975e5..b2f9a61f7f3 100644
--- a/spec/models/ci/build_spec.rb
+++ b/spec/models/ci/build_spec.rb
@@ -17,8 +17,9 @@ describe Ci::Build, :models do
   it { is_expected.to belong_to(:trigger_request) }
   it { is_expected.to belong_to(:erased_by) }
   it { is_expected.to have_many(:deployments) }
-  it { is_expected.to validate_presence_of :ref }
-  it { is_expected.to respond_to :trace_html }
+  it { is_expected.to validate_presence_of(:ref) }
+  it { is_expected.to respond_to(:has_trace?) }
+  it { is_expected.to respond_to(:trace) }
 
   describe '#actionize' do
     context 'when build is a created' do
@@ -78,32 +79,6 @@ describe Ci::Build, :models do
     end
   end
 
-  describe '#append_trace' do
-    subject { build.trace_html }
-
-    context 'when build.trace hides runners token' do
-      let(:token) { 'my_secret_token' }
-
-      before do
-        build.project.update(runners_token: token)
-        build.append_trace(token, 0)
-      end
-
-      it { is_expected.not_to include(token) }
-    end
-
-    context 'when build.trace hides build token' do
-      let(:token) { 'my_secret_token' }
-
-      before do
-        build.update(token: token)
-        build.append_trace(token, 0)
-      end
-
-      it { is_expected.not_to include(token) }
-    end
-  end
-
   describe '#artifacts?' do
     subject { build.artifacts? }
 
@@ -272,12 +247,98 @@ describe Ci::Build, :models do
 
   describe '#update_coverage' do
     context "regarding coverage_regex's value," do
-      it "saves the correct extracted coverage value" do
+      before do
         build.coverage_regex = '\(\d+.\d+\%\) covered'
-        allow(build).to receive(:trace) { 'Coverage 1033 / 1051 LOC (98.29%) covered' }
-        expect(build).to receive(:update_attributes).with(coverage: 98.29) { true }
-        expect(build.update_coverage).to be true
+        build.trace.set('Coverage 1033 / 1051 LOC (98.29%) covered')
+      end
+
+      it "saves the correct extracted coverage value" do
+        expect(build.update_coverage).to be(true)
+        expect(build.coverage).to eq(98.29)
+      end
+    end
+  end
+
+  describe '#trace' do
+    subject { build.trace }
+
+    it { is_expected.to be_a(Gitlab::Ci::Trace) }
+  end
+
+  describe '#has_trace?' do
+    subject { build.has_trace? }
+
+    it "expect to call exist? method" do
+      expect_any_instance_of(Gitlab::Ci::Trace).to receive(:exist?)
+        .and_return(true)
+
+      is_expected.to be(true)
+    end
+  end
+
+  describe '#trace=' do
+    it "expect to fail trace=" do
+      expect { build.trace = "new" }.to raise_error(NotImplementedError)
+    end
+  end
+
+  describe '#old_trace' do
+    subject { build.old_trace }
+
+    before do
+      build.update_column(:trace, 'old trace')
+    end
+
+    it "expect to receive data from database" do
+      is_expected.to eq('old trace')
+    end
+  end
+
+  describe '#erase_old_trace!' do
+    subject { build.send(:read_attribute, :trace) }
+
+    before do
+      build.send(:write_attribute, :trace, 'old trace')
+    end
+
+    it "expect to receive data from database" do
+      build.erase_old_trace!
+
+      is_expected.to be_nil
+    end
+  end
+
+  describe '#hide_secrets' do
+    let(:subject) { build.hide_secrets(data) }
+
+    context 'hide runners token' do
+      let(:data) { 'new token data'}
+
+      before do
+        build.project.update(runners_token: 'token')
+      end
+
+      it { is_expected.to eq('new xxxxx data') }
+    end
+
+    context 'hide build token' do
+      let(:data) { 'new token data'}
+
+      before do
+        build.update(token: 'token')
+      end
+
+      it { is_expected.to eq('new xxxxx data') }
+    end
+
+    context 'hide build token' do
+      let(:data) { 'new token data'}
+
+      before do
+        build.update(token: 'token')
       end
+
+      it { is_expected.to eq('new xxxxx data') }
     end
   end
 
@@ -438,7 +499,7 @@ describe Ci::Build, :models do
       end
 
       it 'erases build trace in trace file' do
-        expect(build.trace).to be_empty
+        expect(build).not_to have_trace
       end
 
       it 'sets erased to true' do
@@ -532,38 +593,6 @@ describe Ci::Build, :models do
     end
   end
 
-  describe '#extract_coverage' do
-    context 'valid content & regex' do
-      subject { build.extract_coverage('Coverage 1033 / 1051 LOC (98.29%) covered', '\(\d+.\d+\%\) covered') }
-
-      it { is_expected.to eq(98.29) }
-    end
-
-    context 'valid content & bad regex' do
-      subject { build.extract_coverage('Coverage 1033 / 1051 LOC (98.29%) covered', 'very covered') }
-
-      it { is_expected.to be_nil }
-    end
-
-    context 'no coverage content & regex' do
-      subject { build.extract_coverage('No coverage for today :sad:', '\(\d+.\d+\%\) covered') }
-
-      it { is_expected.to be_nil }
-    end
-
-    context 'multiple results in content & regex' do
-      subject { build.extract_coverage(' (98.39%) covered. (98.29%) covered', '\(\d+.\d+\%\) covered') }
-
-      it { is_expected.to eq(98.29) }
-    end
-
-    context 'using a regex capture' do
-      subject { build.extract_coverage('TOTAL      9926   3489    65%', 'TOTAL\s+\d+\s+\d+\s+(\d{1,3}\%)') }
-
-      it { is_expected.to eq(65) }
-    end
-  end
-
   describe '#first_pending' do
     let!(:first) { create(:ci_build, pipeline: pipeline, status: 'pending', created_at: Date.yesterday) }
     let!(:second) { create(:ci_build, pipeline: pipeline, status: 'pending') }
@@ -735,40 +764,6 @@ describe Ci::Build, :models do
     end
   end
 
-  describe '#has_commands?' do
-    context 'when build has commands' do
-      let(:build) do
-        create(:ci_build, commands: 'rspec')
-      end
-
-      it 'has commands' do
-        expect(build).to have_commands
-      end
-    end
-
-    context 'when does not have commands' do
-      context 'when commands are an empty string' do
-        let(:build) do
-          create(:ci_build, commands: '')
-        end
-
-        it 'has no commands' do
-          expect(build).not_to have_commands
-        end
-      end
-
-      context 'when commands are not set at all' do
-        let(:build) do
-          create(:ci_build, commands: nil)
-        end
-
-        it 'has no commands' do
-          expect(build).not_to have_commands
-        end
-      end
-    end
-  end
-
   describe '#has_tags?' do
     context 'when build has tags' do
       subject { create(:ci_build, tag_list: ['tag']) }
@@ -969,32 +964,6 @@ describe Ci::Build, :models do
     it { is_expected.to eq(project.name) }
   end
 
-  describe '#raw_trace' do
-    subject { build.raw_trace }
-
-    context 'when build.trace hides runners token' do
-      let(:token) { 'my_secret_token' }
-
-      before do
-        build.project.update(runners_token: token)
-        build.update(trace: token)
-      end
-
-      it { is_expected.not_to include(token) }
-    end
-
-    context 'when build.trace hides build token' do
-      let(:token) { 'my_secret_token' }
-
-      before do
-        build.update(token: token)
-        build.update(trace: token)
-      end
-
-      it { is_expected.not_to include(token) }
-    end
-  end
-
   describe '#ref_slug' do
     {
       'master'    => 'master',
@@ -1060,61 +1029,6 @@ describe Ci::Build, :models do
     end
   end
 
-  describe '#trace' do
-    it 'obfuscates project runners token' do
-      allow(build).to receive(:raw_trace).and_return("Test: #{build.project.runners_token}")
-
-      expect(build.trace).to eq("Test: xxxxxxxxxxxxxxxxxxxx")
-    end
-
-    it 'empty project runners token' do
-      allow(build).to receive(:raw_trace).and_return(test_trace)
-      # runners_token can't normally be set to nil
-      allow(build.project).to receive(:runners_token).and_return(nil)
-
-      expect(build.trace).to eq(test_trace)
-    end
-
-    context 'when build does not have trace' do
-      it 'is is empty' do
-        expect(build.trace).to be_nil
-      end
-    end
-
-    context 'when trace contains text' do
-      let(:text) { 'example output' }
-      before do
-        build.trace = text
-      end
-
-      it { expect(build.trace).to eq(text) }
-    end
-
-    context 'when trace hides runners token' do
-      let(:token) { 'my_secret_token' }
-
-      before do
-        build.update(trace: token)
-        build.project.update(runners_token: token)
-      end
-
-      it { expect(build.trace).not_to include(token) }
-      it { expect(build.raw_trace).to include(token) }
-    end
-
-    context 'when build.trace hides build token' do
-      let(:token) { 'my_secret_token' }
-
-      before do
-        build.update(trace: token)
-        build.update(token: token)
-      end
-
-      it { expect(build.trace).not_to include(token) }
-      it { expect(build.raw_trace).to include(token) }
-    end
-  end
-
   describe '#has_expiring_artifacts?' do
     context 'when artifacts have expiration date set' do
       before { build.update(artifacts_expire_at: 1.day.from_now) }
@@ -1133,66 +1047,6 @@ describe Ci::Build, :models do
     end
   end
 
-  describe '#has_trace_file?' do
-    context 'when there is no trace' do
-      it { expect(build.has_trace_file?).to be_falsey }
-      it { expect(build.trace).to be_nil }
-    end
-
-    context 'when there is a trace' do
-      context 'when trace is stored in file' do
-        let(:build_with_trace) { create(:ci_build, :trace) }
-
-        it { expect(build_with_trace.has_trace_file?).to be_truthy }
-        it { expect(build_with_trace.trace).to eq('BUILD TRACE') }
-      end
-
-      context 'when trace is stored in old file' do
-        before do
-          allow(build.project).to receive(:ci_id).and_return(999)
-          allow(File).to receive(:exist?).with(build.path_to_trace).and_return(false)
-          allow(File).to receive(:exist?).with(build.old_path_to_trace).and_return(true)
-          allow(File).to receive(:read).with(build.old_path_to_trace).and_return(test_trace)
-        end
-
-        it { expect(build.has_trace_file?).to be_truthy }
-        it { expect(build.trace).to eq(test_trace) }
-      end
-
-      context 'when trace is stored in DB' do
-        before do
-          allow(build.project).to receive(:ci_id).and_return(nil)
-          allow(build).to receive(:read_attribute).with(:trace).and_return(test_trace)
-          allow(File).to receive(:exist?).with(build.path_to_trace).and_return(false)
-          allow(File).to receive(:exist?).with(build.old_path_to_trace).and_return(false)
-        end
-
-        it { expect(build.has_trace_file?).to be_falsey }
-        it { expect(build.trace).to eq(test_trace) }
-      end
-    end
-  end
-
-  describe '#trace_file_path' do
-    context 'when trace is stored in file' do
-      before do
-        allow(build).to receive(:has_trace_file?).and_return(true)
-        allow(build).to receive(:has_old_trace_file?).and_return(false)
-      end
-
-      it { expect(build.trace_file_path).to eq(build.path_to_trace) }
-    end
-
-    context 'when trace is stored in old file' do
-      before do
-        allow(build).to receive(:has_trace_file?).and_return(true)
-        allow(build).to receive(:has_old_trace_file?).and_return(true)
-      end
-
-      it { expect(build.trace_file_path).to eq(build.old_path_to_trace) }
-    end
-  end
-
   describe '#update_project_statistics' do
     let!(:build) { create(:ci_build, artifacts_size: 23) }
 
@@ -1446,7 +1300,7 @@ describe Ci::Build, :models do
         { key: 'CI_REGISTRY',  value: 'registry.example.com',  public: true }
       end
       let(:ci_registry_image) do
-        { key: 'CI_REGISTRY_IMAGE',  value: project.container_registry_repository_url, public: true }
+        { key: 'CI_REGISTRY_IMAGE',  value: project.container_registry_url, public: true }
       end
 
       context 'and is disabled for project' do
diff --git a/spec/models/ci/pipeline_spec.rb b/spec/models/ci/pipeline_spec.rb
index e4a24fd63c2..d7d6a75d38d 100644
--- a/spec/models/ci/pipeline_spec.rb
+++ b/spec/models/ci/pipeline_spec.rb
@@ -12,10 +12,13 @@ describe Ci::Pipeline, models: true do
 
   it { is_expected.to belong_to(:project) }
   it { is_expected.to belong_to(:user) }
+  it { is_expected.to belong_to(:auto_canceled_by) }
 
   it { is_expected.to have_many(:statuses) }
   it { is_expected.to have_many(:trigger_requests) }
   it { is_expected.to have_many(:builds) }
+  it { is_expected.to have_many(:auto_canceled_pipelines) }
+  it { is_expected.to have_many(:auto_canceled_jobs) }
 
   it { is_expected.to validate_presence_of :sha }
   it { is_expected.to validate_presence_of :status }
@@ -134,6 +137,43 @@ describe Ci::Pipeline, models: true do
     end
   end
 
+  describe '#auto_canceled?' do
+    subject { pipeline.auto_canceled? }
+
+    context 'when it is canceled' do
+      before do
+        pipeline.cancel
+      end
+
+      context 'when there is auto_canceled_by' do
+        before do
+          pipeline.update(auto_canceled_by: create(:ci_empty_pipeline))
+        end
+
+        it 'is auto canceled' do
+          is_expected.to be_truthy
+        end
+      end
+
+      context 'when there is no auto_canceled_by' do
+        it 'is not auto canceled' do
+          is_expected.to be_falsey
+        end
+      end
+
+      context 'when it is retried and canceled manually' do
+        before do
+          pipeline.enqueue
+          pipeline.cancel
+        end
+
+        it 'is not auto canceled' do
+          is_expected.to be_falsey
+        end
+      end
+    end
+  end
+
   describe 'pipeline stages' do
     before do
       create(:commit_status, pipeline: pipeline,
@@ -335,6 +375,14 @@ describe Ci::Pipeline, models: true do
       end
     end
 
+    describe 'pipeline caching' do
+      it 'executes ExpirePipelinesCacheService' do
+        expect_any_instance_of(Ci::ExpirePipelineCacheService).to receive(:execute).with(pipeline)
+
+        pipeline.cancel
+      end
+    end
+
     def create_build(name, queued_at = current, started_from = 0)
       create(:ci_build,
              name: name,
@@ -1031,19 +1079,6 @@ describe Ci::Pipeline, models: true do
     end
   end
 
-  describe '#update_status' do
-    let(:pipeline) { create(:ci_pipeline, sha: '123456') }
-
-    it 'updates the cached status' do
-      fake_status = double
-      # after updating the status, the status is set to `skipped` for this pipeline's builds
-      expect(Ci::PipelineStatus).to receive(:new).with(pipeline.project, sha: '123456', status: 'skipped').and_return(fake_status)
-      expect(fake_status).to receive(:store_in_cache_if_needed)
-
-      pipeline.update_status
-    end
-  end
-
   describe 'notifications when pipeline success or failed' do
     let(:project) { create(:project, :repository) }
 
diff --git a/spec/models/ci/trigger_schedule_spec.rb b/spec/models/ci/trigger_schedule_spec.rb
new file mode 100644
index 00000000000..75d21541cee
--- /dev/null
+++ b/spec/models/ci/trigger_schedule_spec.rb
@@ -0,0 +1,76 @@
+require 'spec_helper'
+
+describe Ci::TriggerSchedule, models: true do
+  it { is_expected.to belong_to(:project) }
+  it { is_expected.to belong_to(:trigger) }
+  it { is_expected.to respond_to(:ref) }
+
+  describe '#set_next_run_at' do
+    context 'when creates new TriggerSchedule' do
+      before do
+        trigger_schedule = create(:ci_trigger_schedule, :nightly)
+        @expected_next_run_at = Gitlab::Ci::CronParser.new(trigger_schedule.cron, trigger_schedule.cron_timezone)
+                                                      .next_time_from(Time.now)
+      end
+
+      it 'updates next_run_at automatically' do
+        expect(Ci::TriggerSchedule.last.next_run_at).to eq(@expected_next_run_at)
+      end
+    end
+
+    context 'when updates cron of exsisted TriggerSchedule' do
+      before do
+        trigger_schedule = create(:ci_trigger_schedule, :nightly)
+        new_cron = '0 0 1 1 *'
+        trigger_schedule.update!(cron: new_cron) # Subject
+        @expected_next_run_at = Gitlab::Ci::CronParser.new(new_cron, trigger_schedule.cron_timezone)
+                                                      .next_time_from(Time.now)
+      end
+
+      it 'updates next_run_at automatically' do
+        expect(Ci::TriggerSchedule.last.next_run_at).to eq(@expected_next_run_at)
+      end
+    end
+  end
+
+  describe '#schedule_next_run!' do
+    context 'when reschedules after 10 days from now' do
+      before do
+        trigger_schedule = create(:ci_trigger_schedule, :nightly)
+        time_future = Time.now + 10.days
+        allow(Time).to receive(:now).and_return(time_future)
+        trigger_schedule.schedule_next_run! # Subject
+        @expected_next_run_at = Gitlab::Ci::CronParser.new(trigger_schedule.cron, trigger_schedule.cron_timezone)
+                                                      .next_time_from(time_future)
+      end
+
+      it 'points to proper next_run_at' do
+        expect(Ci::TriggerSchedule.last.next_run_at).to eq(@expected_next_run_at)
+      end
+    end
+
+    context 'when cron is invalid' do
+      before do
+        trigger_schedule = create(:ci_trigger_schedule, :nightly)
+        trigger_schedule.cron = 'Invalid-cron'
+        trigger_schedule.schedule_next_run! # Subject
+      end
+
+      it 'sets nil to next_run_at' do
+        expect(Ci::TriggerSchedule.last.next_run_at).to be_nil
+      end
+    end
+
+    context 'when cron_timezone is invalid' do
+      before do
+        trigger_schedule = create(:ci_trigger_schedule, :nightly)
+        trigger_schedule.cron_timezone = 'Invalid-cron_timezone'
+        trigger_schedule.schedule_next_run! # Subject
+      end
+
+      it 'sets nil to next_run_at' do
+        expect(Ci::TriggerSchedule.last.next_run_at).to be_nil
+      end
+    end
+  end
+end
diff --git a/spec/models/ci/trigger_spec.rb b/spec/models/ci/trigger_spec.rb
index 1bcb673cb16..d26121018ce 100644
--- a/spec/models/ci/trigger_spec.rb
+++ b/spec/models/ci/trigger_spec.rb
@@ -7,6 +7,7 @@ describe Ci::Trigger, models: true do
     it { is_expected.to belong_to(:project) }
     it { is_expected.to belong_to(:owner) }
     it { is_expected.to have_many(:trigger_requests) }
+    it { is_expected.to have_one(:trigger_schedule) }
   end
 
   describe 'before_validation' do
@@ -16,8 +17,8 @@ describe Ci::Trigger, models: true do
       expect(trigger.token).not_to be_nil
     end
 
-    it 'does not set an random token if one provided' do
-      trigger = create(:ci_trigger, project: project)
+    it 'does not set a random token if one provided' do
+      trigger = create(:ci_trigger, project: project, token: 'token')
 
       expect(trigger.token).to eq('token')
     end
diff --git a/spec/models/commit_spec.rb b/spec/models/commit_spec.rb
index 980a1b70ef5..ce31c8ed94c 100644
--- a/spec/models/commit_spec.rb
+++ b/spec/models/commit_spec.rb
@@ -389,31 +389,32 @@ eos
     end
   end
 
-  describe '#raw_diffs' do
-    context 'Gitaly commit_raw_diffs feature enabled' do
-      before do
-        allow(Gitlab::GitalyClient).to receive(:feature_enabled?).with(:commit_raw_diffs).and_return(true)
-      end
-
-      context 'when a truthy deltas_only is not passed to args' do
-        it 'fetches diffs from Gitaly server' do
-          expect(Gitlab::GitalyClient::Commit).to receive(:diff_from_parent).
-            with(commit)
-
-          commit.raw_diffs
-        end
-      end
-
-      context 'when a truthy deltas_only is passed to args' do
-        it 'fetches diffs using Rugged' do
-          opts = { deltas_only: true }
-
-          expect(Gitlab::GitalyClient::Commit).not_to receive(:diff_from_parent)
-          expect(commit.raw).to receive(:diffs).with(opts)
-
-          commit.raw_diffs(opts)
-        end
-      end
-    end
-  end
+  # describe '#raw_diffs' do
+  # TODO: Uncomment when feature is reenabled
+  #   context 'Gitaly commit_raw_diffs feature enabled' do
+  #     before do
+  #       allow(Gitlab::GitalyClient).to receive(:feature_enabled?).with(:commit_raw_diffs).and_return(true)
+  #     end
+  #
+  #     context 'when a truthy deltas_only is not passed to args' do
+  #       it 'fetches diffs from Gitaly server' do
+  #         expect(Gitlab::GitalyClient::Commit).to receive(:diff_from_parent).
+  #           with(commit)
+  #
+  #         commit.raw_diffs
+  #       end
+  #     end
+  #
+  #     context 'when a truthy deltas_only is passed to args' do
+  #       it 'fetches diffs using Rugged' do
+  #         opts = { deltas_only: true }
+  #
+  #         expect(Gitlab::GitalyClient::Commit).not_to receive(:diff_from_parent)
+  #         expect(commit.raw).to receive(:diffs).with(opts)
+  #
+  #         commit.raw_diffs(opts)
+  #       end
+  #     end
+  #   end
+  # end
 end
diff --git a/spec/models/commit_status_spec.rb b/spec/models/commit_status_spec.rb
index 7343b735a74..0ee85489574 100644
--- a/spec/models/commit_status_spec.rb
+++ b/spec/models/commit_status_spec.rb
@@ -16,6 +16,7 @@ describe CommitStatus, :models do
   it { is_expected.to belong_to(:pipeline) }
   it { is_expected.to belong_to(:user) }
   it { is_expected.to belong_to(:project) }
+  it { is_expected.to belong_to(:auto_canceled_by) }
 
   it { is_expected.to validate_presence_of(:name) }
   it { is_expected.to validate_inclusion_of(:status).in_array(%w(pending running failed success canceled)) }
@@ -101,6 +102,32 @@ describe CommitStatus, :models do
     end
   end
 
+  describe '#auto_canceled?' do
+    subject { commit_status.auto_canceled? }
+
+    context 'when it is canceled' do
+      before do
+        commit_status.update(status: 'canceled')
+      end
+
+      context 'when there is auto_canceled_by' do
+        before do
+          commit_status.update(auto_canceled_by: create(:ci_empty_pipeline))
+        end
+
+        it 'is auto canceled' do
+          is_expected.to be_truthy
+        end
+      end
+
+      context 'when there is no auto_canceled_by' do
+        it 'is not auto canceled' do
+          is_expected.to be_falsey
+        end
+      end
+    end
+  end
+
   describe '#duration' do
     subject { commit_status.duration }
 
diff --git a/spec/models/concerns/discussion_on_diff_spec.rb b/spec/models/concerns/discussion_on_diff_spec.rb
new file mode 100644
index 00000000000..0002a00770f
--- /dev/null
+++ b/spec/models/concerns/discussion_on_diff_spec.rb
@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe DiffDiscussion, DiscussionOnDiff, model: true do
+  subject { create(:diff_note_on_merge_request).to_discussion }
+
+  describe "#truncated_diff_lines" do
+    let(:truncated_lines) { subject.truncated_diff_lines }
+
+    context "when diff is greater than allowed number of truncated diff lines " do
+      it "returns fewer lines"  do
+        expect(subject.diff_lines.count).to be > described_class::NUMBER_OF_TRUNCATED_DIFF_LINES
+
+        expect(truncated_lines.count).to be <= described_class::NUMBER_OF_TRUNCATED_DIFF_LINES
+      end
+    end
+
+    context "when some diff lines are meta" do
+      it "returns no meta lines"  do
+        expect(subject.diff_lines).to include(be_meta)
+        expect(truncated_lines).not_to include(be_meta)
+      end
+    end
+  end
+end
diff --git a/spec/models/concerns/has_status_spec.rb b/spec/models/concerns/has_status_spec.rb
index 82abad0e2f6..67dae7cf4c0 100644
--- a/spec/models/concerns/has_status_spec.rb
+++ b/spec/models/concerns/has_status_spec.rb
@@ -231,6 +231,18 @@ describe HasStatus do
       end
     end
 
+    describe '.created_or_pending' do
+      subject { CommitStatus.created_or_pending }
+
+      %i[created pending].each do |status|
+        it_behaves_like 'containing the job', status
+      end
+
+      %i[running failed success].each do |status|
+        it_behaves_like 'not containing the job', status
+      end
+    end
+
     describe '.finished' do
       subject { CommitStatus.finished }
 
diff --git a/spec/models/concerns/ignorable_column_spec.rb b/spec/models/concerns/ignorable_column_spec.rb
new file mode 100644
index 00000000000..dba9fe43327
--- /dev/null
+++ b/spec/models/concerns/ignorable_column_spec.rb
@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+describe IgnorableColumn do
+  let :base_class do
+    Class.new do
+      def self.columns
+        # This method does not have access to "double"
+        [Struct.new(:name).new('id'), Struct.new(:name).new('title')]
+      end
+    end
+  end
+
+  let :model do
+    Class.new(base_class) do
+      include IgnorableColumn
+    end
+  end
+
+  describe '.columns' do
+    it 'returns the columns, excluding the ignored ones' do
+      model.ignore_column(:title)
+
+      expect(model.columns.map(&:name)).to eq(%w(id))
+    end
+  end
+
+  describe '.ignored_columns' do
+    it 'returns a Set' do
+      expect(model.ignored_columns).to be_an_instance_of(Set)
+    end
+
+    it 'returns the names of the ignored columns' do
+      model.ignore_column(:title)
+
+      expect(model.ignored_columns).to eq(Set.new(%w(title)))
+    end
+  end
+end
diff --git a/spec/models/concerns/noteable_spec.rb b/spec/models/concerns/noteable_spec.rb
new file mode 100644
index 00000000000..92cc8859a8c
--- /dev/null
+++ b/spec/models/concerns/noteable_spec.rb
@@ -0,0 +1,261 @@
+require 'spec_helper'
+
+describe MergeRequest, Noteable, model: true do
+  let!(:active_diff_note1) { create(:diff_note_on_merge_request) }
+  let(:project) { active_diff_note1.project }
+  subject { active_diff_note1.noteable }
+  let!(:active_diff_note2) { create(:diff_note_on_merge_request, project: project, noteable: subject, in_reply_to: active_diff_note1) }
+  let!(:active_diff_note3) { create(:diff_note_on_merge_request, project: project, noteable: subject, position: active_position2) }
+  let!(:outdated_diff_note1) { create(:diff_note_on_merge_request, project: project, noteable: subject, position: outdated_position) }
+  let!(:outdated_diff_note2) { create(:diff_note_on_merge_request, project: project, noteable: subject, in_reply_to: outdated_diff_note1) }
+  let!(:discussion_note1) { create(:discussion_note_on_merge_request, project: project, noteable: subject) }
+  let!(:discussion_note2) { create(:discussion_note_on_merge_request, in_reply_to: discussion_note1) }
+  let!(:commit_diff_note1) { create(:diff_note_on_commit, project: project) }
+  let!(:commit_diff_note2) { create(:diff_note_on_commit, project: project, in_reply_to: commit_diff_note1) }
+  let!(:commit_note1) { create(:note_on_commit, project: project) }
+  let!(:commit_note2) { create(:note_on_commit, project: project) }
+  let!(:commit_discussion_note1) { create(:discussion_note_on_commit, project: project) }
+  let!(:commit_discussion_note2) { create(:discussion_note_on_commit, in_reply_to: commit_discussion_note1) }
+  let!(:commit_discussion_note3) { create(:discussion_note_on_commit, project: project) }
+  let!(:note1) { create(:note, project: project, noteable: subject) }
+  let!(:note2) { create(:note, project: project, noteable: subject) }
+
+  let(:active_position2) do
+    Gitlab::Diff::Position.new(
+      old_path: "files/ruby/popen.rb",
+      new_path: "files/ruby/popen.rb",
+      old_line: 16,
+      new_line: 22,
+      diff_refs: subject.diff_refs
+    )
+  end
+
+  let(:outdated_position) do
+    Gitlab::Diff::Position.new(
+      old_path: "files/ruby/popen.rb",
+      new_path: "files/ruby/popen.rb",
+      old_line: nil,
+      new_line: 9,
+      diff_refs: project.commit("874797c3a73b60d2187ed6e2fcabd289ff75171e").diff_refs
+    )
+  end
+
+  describe '#discussions' do
+    let(:discussions) { subject.discussions }
+
+    it 'includes discussions for diff notes, commit diff notes, commit notes, and regular notes' do
+      expect(discussions).to eq([
+        DiffDiscussion.new([active_diff_note1, active_diff_note2], subject),
+        DiffDiscussion.new([active_diff_note3], subject),
+        DiffDiscussion.new([outdated_diff_note1, outdated_diff_note2], subject),
+        Discussion.new([discussion_note1, discussion_note2], subject),
+        DiffDiscussion.new([commit_diff_note1, commit_diff_note2], subject),
+        OutOfContextDiscussion.new([commit_note1, commit_note2], subject),
+        Discussion.new([commit_discussion_note1, commit_discussion_note2], subject),
+        Discussion.new([commit_discussion_note3], subject),
+        IndividualNoteDiscussion.new([note1], subject),
+        IndividualNoteDiscussion.new([note2], subject)
+      ])
+    end
+  end
+
+  describe '#grouped_diff_discussions' do
+    let(:grouped_diff_discussions) { subject.grouped_diff_discussions }
+
+    it "includes active discussions" do
+      discussions = grouped_diff_discussions.values.flatten
+
+      expect(discussions.count).to eq(2)
+      expect(discussions.map(&:id)).to eq([active_diff_note1.discussion_id, active_diff_note3.discussion_id])
+      expect(discussions.all?(&:active?)).to be true
+
+      expect(discussions.first.notes).to eq([active_diff_note1, active_diff_note2])
+      expect(discussions.last.notes).to eq([active_diff_note3])
+    end
+
+    it "doesn't include outdated discussions" do
+      expect(grouped_diff_discussions.values.flatten.map(&:id)).not_to include(outdated_diff_note1.discussion_id)
+    end
+
+    it "groups the discussions by line code" do
+      expect(grouped_diff_discussions[active_diff_note1.line_code].first.id).to eq(active_diff_note1.discussion_id)
+      expect(grouped_diff_discussions[active_diff_note3.line_code].first.id).to eq(active_diff_note3.discussion_id)
+    end
+  end
+
+  context "discussion status" do
+    let(:first_discussion) { build_stubbed(:discussion_note_on_merge_request, noteable: subject, project: project).to_discussion }
+    let(:second_discussion) { build_stubbed(:discussion_note_on_merge_request, noteable: subject, project: project).to_discussion }
+    let(:third_discussion) { build_stubbed(:discussion_note_on_merge_request, noteable: subject, project: project).to_discussion }
+
+    before do
+      allow(subject).to receive(:resolvable_discussions).and_return([first_discussion, second_discussion, third_discussion])
+    end
+
+    describe "#discussions_resolvable?" do
+      context "when all discussions are unresolvable" do
+        before do
+          allow(first_discussion).to receive(:resolvable?).and_return(false)
+          allow(second_discussion).to receive(:resolvable?).and_return(false)
+          allow(third_discussion).to receive(:resolvable?).and_return(false)
+        end
+
+        it "returns false" do
+          expect(subject.discussions_resolvable?).to be false
+        end
+      end
+
+      context "when some discussions are unresolvable and some discussions are resolvable" do
+        before do
+          allow(first_discussion).to receive(:resolvable?).and_return(true)
+          allow(second_discussion).to receive(:resolvable?).and_return(false)
+          allow(third_discussion).to receive(:resolvable?).and_return(true)
+        end
+
+        it "returns true" do
+          expect(subject.discussions_resolvable?).to be true
+        end
+      end
+
+      context "when all discussions are resolvable" do
+        before do
+          allow(first_discussion).to receive(:resolvable?).and_return(true)
+          allow(second_discussion).to receive(:resolvable?).and_return(true)
+          allow(third_discussion).to receive(:resolvable?).and_return(true)
+        end
+
+        it "returns true" do
+          expect(subject.discussions_resolvable?).to be true
+        end
+      end
+    end
+
+    describe "#discussions_resolved?" do
+      context "when discussions are not resolvable" do
+        before do
+          allow(subject).to receive(:discussions_resolvable?).and_return(false)
+        end
+
+        it "returns false" do
+          expect(subject.discussions_resolved?).to be false
+        end
+      end
+
+      context "when discussions are resolvable" do
+        before do
+          allow(subject).to receive(:discussions_resolvable?).and_return(true)
+
+          allow(first_discussion).to receive(:resolvable?).and_return(true)
+          allow(second_discussion).to receive(:resolvable?).and_return(false)
+          allow(third_discussion).to receive(:resolvable?).and_return(true)
+        end
+
+        context "when all resolvable discussions are resolved" do
+          before do
+            allow(first_discussion).to receive(:resolved?).and_return(true)
+            allow(third_discussion).to receive(:resolved?).and_return(true)
+          end
+
+          it "returns true" do
+            expect(subject.discussions_resolved?).to be true
+          end
+        end
+
+        context "when some resolvable discussions are not resolved" do
+          before do
+            allow(first_discussion).to receive(:resolved?).and_return(true)
+            allow(third_discussion).to receive(:resolved?).and_return(false)
+          end
+
+          it "returns false" do
+            expect(subject.discussions_resolved?).to be false
+          end
+        end
+      end
+    end
+
+    describe "#discussions_to_be_resolved?" do
+      context "when discussions are not resolvable" do
+        before do
+          allow(subject).to receive(:discussions_resolvable?).and_return(false)
+        end
+
+        it "returns false" do
+          expect(subject.discussions_to_be_resolved?).to be false
+        end
+      end
+
+      context "when discussions are resolvable" do
+        before do
+          allow(subject).to receive(:discussions_resolvable?).and_return(true)
+
+          allow(first_discussion).to receive(:resolvable?).and_return(true)
+          allow(second_discussion).to receive(:resolvable?).and_return(false)
+          allow(third_discussion).to receive(:resolvable?).and_return(true)
+        end
+
+        context "when all resolvable discussions are resolved" do
+          before do
+            allow(first_discussion).to receive(:resolved?).and_return(true)
+            allow(third_discussion).to receive(:resolved?).and_return(true)
+          end
+
+          it "returns false" do
+            expect(subject.discussions_to_be_resolved?).to be false
+          end
+        end
+
+        context "when some resolvable discussions are not resolved" do
+          before do
+            allow(first_discussion).to receive(:resolved?).and_return(true)
+            allow(third_discussion).to receive(:resolved?).and_return(false)
+          end
+
+          it "returns true" do
+            expect(subject.discussions_to_be_resolved?).to be true
+          end
+        end
+      end
+    end
+
+    describe "#discussions_to_be_resolved" do
+      before do
+        allow(first_discussion).to receive(:to_be_resolved?).and_return(true)
+        allow(second_discussion).to receive(:to_be_resolved?).and_return(false)
+        allow(third_discussion).to receive(:to_be_resolved?).and_return(false)
+      end
+
+      it 'includes only discussions that need to be resolved' do
+        expect(subject.discussions_to_be_resolved).to eq([first_discussion])
+      end
+    end
+
+    describe '#discussions_can_be_resolved_by?' do
+      let(:user) { build(:user) }
+
+      context 'all discussions can be resolved by the user' do
+        before do
+          allow(first_discussion).to receive(:can_resolve?).with(user).and_return(true)
+          allow(second_discussion).to receive(:can_resolve?).with(user).and_return(true)
+          allow(third_discussion).to receive(:can_resolve?).with(user).and_return(true)
+        end
+
+        it 'allows a user to resolve the discussions' do
+          expect(subject.discussions_can_be_resolved_by?(user)).to be(true)
+        end
+      end
+
+      context 'one discussion cannot be resolved by the user' do
+        before do
+          allow(first_discussion).to receive(:can_resolve?).with(user).and_return(true)
+          allow(second_discussion).to receive(:can_resolve?).with(user).and_return(true)
+          allow(third_discussion).to receive(:can_resolve?).with(user).and_return(false)
+        end
+
+        it 'allows a user to resolve the discussions' do
+          expect(subject.discussions_can_be_resolved_by?(user)).to be(false)
+        end
+      end
+    end
+  end
+end
diff --git a/spec/models/concerns/resolvable_discussion_spec.rb b/spec/models/concerns/resolvable_discussion_spec.rb
new file mode 100644
index 00000000000..18327fe262d
--- /dev/null
+++ b/spec/models/concerns/resolvable_discussion_spec.rb
@@ -0,0 +1,548 @@
+require 'spec_helper'
+
+describe Discussion, ResolvableDiscussion, models: true do
+  subject { described_class.new([first_note, second_note, third_note]) }
+
+  let(:first_note) { create(:discussion_note_on_merge_request) }
+  let(:merge_request) { first_note.noteable }
+  let(:project) { first_note.project }
+  let(:second_note) { create(:discussion_note_on_merge_request, noteable: merge_request, project: project, in_reply_to: first_note) }
+  let(:third_note) { create(:discussion_note_on_merge_request, noteable: merge_request, project: project) }
+
+  describe "#resolvable?" do
+    context "when potentially resolvable" do
+      before do
+        allow(subject).to receive(:potentially_resolvable?).and_return(true)
+      end
+
+      context "when all notes are unresolvable" do
+        before do
+          allow(first_note).to receive(:resolvable?).and_return(false)
+          allow(second_note).to receive(:resolvable?).and_return(false)
+          allow(third_note).to receive(:resolvable?).and_return(false)
+        end
+
+        it "returns false" do
+          expect(subject.resolvable?).to be false
+        end
+      end
+
+      context "when some notes are unresolvable and some notes are resolvable" do
+        before do
+          allow(first_note).to receive(:resolvable?).and_return(true)
+          allow(second_note).to receive(:resolvable?).and_return(false)
+          allow(third_note).to receive(:resolvable?).and_return(true)
+        end
+
+        it "returns true" do
+          expect(subject.resolvable?).to be true
+        end
+      end
+
+      context "when all notes are resolvable" do
+        before do
+          allow(first_note).to receive(:resolvable?).and_return(true)
+          allow(second_note).to receive(:resolvable?).and_return(true)
+          allow(third_note).to receive(:resolvable?).and_return(true)
+        end
+
+        it "returns true" do
+          expect(subject.resolvable?).to be true
+        end
+      end
+    end
+
+    context "when not potentially resolvable" do
+      before do
+        allow(subject).to receive(:potentially_resolvable?).and_return(false)
+      end
+
+      it "returns false" do
+        expect(subject.resolvable?).to be false
+      end
+    end
+  end
+
+  describe "#resolved?" do
+    context "when not resolvable" do
+      before do
+        allow(subject).to receive(:resolvable?).and_return(false)
+      end
+
+      it "returns false" do
+        expect(subject.resolved?).to be false
+      end
+    end
+
+    context "when resolvable" do
+      before do
+        allow(subject).to receive(:resolvable?).and_return(true)
+
+        allow(first_note).to receive(:resolvable?).and_return(true)
+        allow(second_note).to receive(:resolvable?).and_return(false)
+        allow(third_note).to receive(:resolvable?).and_return(true)
+      end
+
+      context "when all resolvable notes are resolved" do
+        before do
+          allow(first_note).to receive(:resolved?).and_return(true)
+          allow(third_note).to receive(:resolved?).and_return(true)
+        end
+
+        it "returns true" do
+          expect(subject.resolved?).to be true
+        end
+      end
+
+      context "when some resolvable notes are not resolved" do
+        before do
+          allow(first_note).to receive(:resolved?).and_return(true)
+          allow(third_note).to receive(:resolved?).and_return(false)
+        end
+
+        it "returns false" do
+          expect(subject.resolved?).to be false
+        end
+      end
+    end
+  end
+
+  describe "#to_be_resolved?" do
+    context "when not resolvable" do
+      before do
+        allow(subject).to receive(:resolvable?).and_return(false)
+      end
+
+      it "returns false" do
+        expect(subject.to_be_resolved?).to be false
+      end
+    end
+
+    context "when resolvable" do
+      before do
+        allow(subject).to receive(:resolvable?).and_return(true)
+
+        allow(first_note).to receive(:resolvable?).and_return(true)
+        allow(second_note).to receive(:resolvable?).and_return(false)
+        allow(third_note).to receive(:resolvable?).and_return(true)
+      end
+
+      context "when all resolvable notes are resolved" do
+        before do
+          allow(first_note).to receive(:resolved?).and_return(true)
+          allow(third_note).to receive(:resolved?).and_return(true)
+        end
+
+        it "returns false" do
+          expect(subject.to_be_resolved?).to be false
+        end
+      end
+
+      context "when some resolvable notes are not resolved" do
+        before do
+          allow(first_note).to receive(:resolved?).and_return(true)
+          allow(third_note).to receive(:resolved?).and_return(false)
+        end
+
+        it "returns true" do
+          expect(subject.to_be_resolved?).to be true
+        end
+      end
+    end
+  end
+
+  describe "#can_resolve?" do
+    let(:current_user) { create(:user) }
+
+    context "when not resolvable" do
+      before do
+        allow(subject).to receive(:resolvable?).and_return(false)
+      end
+
+      it "returns false" do
+        expect(subject.can_resolve?(current_user)).to be false
+      end
+    end
+
+    context "when resolvable" do
+      before do
+        allow(subject).to receive(:resolvable?).and_return(true)
+      end
+
+      context "when not signed in" do
+        let(:current_user) { nil }
+
+        it "returns false" do
+          expect(subject.can_resolve?(current_user)).to be false
+        end
+      end
+
+      context "when signed in" do
+        context "when the signed in user is the noteable author" do
+          before do
+            subject.noteable.author = current_user
+          end
+
+          it "returns true" do
+            expect(subject.can_resolve?(current_user)).to be true
+          end
+        end
+
+        context "when the signed in user can push to the project" do
+          before do
+            subject.project.team << [current_user, :master]
+          end
+
+          it "returns true" do
+            expect(subject.can_resolve?(current_user)).to be true
+          end
+        end
+
+        context "when the signed in user is a random user" do
+          it "returns false" do
+            expect(subject.can_resolve?(current_user)).to be false
+          end
+        end
+      end
+    end
+  end
+
+  describe "#resolve!" do
+    let(:current_user) { create(:user) }
+
+    context "when not resolvable" do
+      before do
+        allow(subject).to receive(:resolvable?).and_return(false)
+      end
+
+      it "returns nil" do
+        expect(subject.resolve!(current_user)).to be_nil
+      end
+
+      it "doesn't set resolved_at" do
+        subject.resolve!(current_user)
+
+        expect(subject.resolved_at).to be_nil
+      end
+
+      it "doesn't set resolved_by" do
+        subject.resolve!(current_user)
+
+        expect(subject.resolved_by).to be_nil
+      end
+
+      it "doesn't mark as resolved" do
+        subject.resolve!(current_user)
+
+        expect(subject.resolved?).to be false
+      end
+    end
+
+    context "when resolvable" do
+      let(:user) { create(:user) }
+      let(:second_note) { create(:diff_note_on_commit) } # unresolvable
+
+      before do
+        allow(subject).to receive(:resolvable?).and_return(true)
+      end
+
+      context "when all resolvable notes are resolved" do
+        before do
+          first_note.resolve!(user)
+          third_note.resolve!(user)
+
+          first_note.reload
+          third_note.reload
+        end
+
+        it "doesn't change resolved_at on the resolved notes" do
+          expect(first_note.resolved_at).not_to be_nil
+          expect(third_note.resolved_at).not_to be_nil
+
+          expect { subject.resolve!(current_user) }.not_to change { first_note.resolved_at }
+          expect { subject.resolve!(current_user) }.not_to change { third_note.resolved_at }
+        end
+
+        it "doesn't change resolved_by on the resolved notes" do
+          expect(first_note.resolved_by).to eq(user)
+          expect(third_note.resolved_by).to eq(user)
+
+          expect { subject.resolve!(current_user) }.not_to change { first_note.resolved_by }
+          expect { subject.resolve!(current_user) }.not_to change { third_note.resolved_by }
+        end
+
+        it "doesn't change the resolved state on the resolved notes" do
+          expect(first_note.resolved?).to be true
+          expect(third_note.resolved?).to be true
+
+          expect { subject.resolve!(current_user) }.not_to change { first_note.resolved? }
+          expect { subject.resolve!(current_user) }.not_to change { third_note.resolved? }
+        end
+
+        it "doesn't change resolved_at" do
+          expect(subject.resolved_at).not_to be_nil
+
+          expect { subject.resolve!(current_user) }.not_to change { subject.resolved_at }
+        end
+
+        it "doesn't change resolved_by" do
+          expect(subject.resolved_by).to eq(user)
+
+          expect { subject.resolve!(current_user) }.not_to change { subject.resolved_by }
+        end
+
+        it "doesn't change resolved state" do
+          expect(subject.resolved?).to be true
+
+          expect { subject.resolve!(current_user) }.not_to change { subject.resolved? }
+        end
+      end
+
+      context "when some resolvable notes are resolved" do
+        before do
+          first_note.resolve!(user)
+        end
+
+        it "doesn't change resolved_at on the resolved note" do
+          expect(first_note.resolved_at).not_to be_nil
+
+          expect { subject.resolve!(current_user) }.
+            not_to change { first_note.reload.resolved_at }
+        end
+
+        it "doesn't change resolved_by on the resolved note" do
+          expect(first_note.resolved_by).to eq(user)
+
+          expect { subject.resolve!(current_user) }.
+            not_to change { first_note.reload && first_note.resolved_by }
+        end
+
+        it "doesn't change the resolved state on the resolved note" do
+          expect(first_note.resolved?).to be true
+
+          expect { subject.resolve!(current_user) }.
+            not_to change { first_note.reload && first_note.resolved? }
+        end
+
+        it "sets resolved_at on the unresolved note" do
+          subject.resolve!(current_user)
+          third_note.reload
+
+          expect(third_note.resolved_at).not_to be_nil
+        end
+
+        it "sets resolved_by on the unresolved note" do
+          subject.resolve!(current_user)
+          third_note.reload
+
+          expect(third_note.resolved_by).to eq(current_user)
+        end
+
+        it "marks the unresolved note as resolved" do
+          subject.resolve!(current_user)
+          third_note.reload
+
+          expect(third_note.resolved?).to be true
+        end
+
+        it "sets resolved_at" do
+          subject.resolve!(current_user)
+
+          expect(subject.resolved_at).not_to be_nil
+        end
+
+        it "sets resolved_by" do
+          subject.resolve!(current_user)
+
+          expect(subject.resolved_by).to eq(current_user)
+        end
+
+        it "marks as resolved" do
+          subject.resolve!(current_user)
+
+          expect(subject.resolved?).to be true
+        end
+      end
+
+      context "when no resolvable notes are resolved" do
+        it "sets resolved_at on the unresolved notes" do
+          subject.resolve!(current_user)
+          first_note.reload
+          third_note.reload
+
+          expect(first_note.resolved_at).not_to be_nil
+          expect(third_note.resolved_at).not_to be_nil
+        end
+
+        it "sets resolved_by on the unresolved notes" do
+          subject.resolve!(current_user)
+          first_note.reload
+          third_note.reload
+
+          expect(first_note.resolved_by).to eq(current_user)
+          expect(third_note.resolved_by).to eq(current_user)
+        end
+
+        it "marks the unresolved notes as resolved" do
+          subject.resolve!(current_user)
+          first_note.reload
+          third_note.reload
+
+          expect(first_note.resolved?).to be true
+          expect(third_note.resolved?).to be true
+        end
+
+        it "sets resolved_at" do
+          subject.resolve!(current_user)
+          first_note.reload
+          third_note.reload
+
+          expect(subject.resolved_at).not_to be_nil
+        end
+
+        it "sets resolved_by" do
+          subject.resolve!(current_user)
+          first_note.reload
+          third_note.reload
+
+          expect(subject.resolved_by).to eq(current_user)
+        end
+
+        it "marks as resolved" do
+          subject.resolve!(current_user)
+          first_note.reload
+          third_note.reload
+
+          expect(subject.resolved?).to be true
+        end
+      end
+    end
+  end
+
+  describe "#unresolve!" do
+    context "when not resolvable" do
+      before do
+        allow(subject).to receive(:resolvable?).and_return(false)
+      end
+
+      it "returns nil" do
+        expect(subject.unresolve!).to be_nil
+      end
+    end
+
+    context "when resolvable" do
+      let(:user) { create(:user) }
+
+      before do
+        allow(subject).to receive(:resolvable?).and_return(true)
+
+        allow(first_note).to receive(:resolvable?).and_return(true)
+        allow(second_note).to receive(:resolvable?).and_return(false)
+        allow(third_note).to receive(:resolvable?).and_return(true)
+      end
+
+      context "when all resolvable notes are resolved" do
+        before do
+          first_note.resolve!(user)
+          third_note.resolve!(user)
+        end
+
+        it "unsets resolved_at on the resolved notes" do
+          subject.unresolve!
+          first_note.reload
+          third_note.reload
+
+          expect(first_note.resolved_at).to be_nil
+          expect(third_note.resolved_at).to be_nil
+        end
+
+        it "unsets resolved_by on the resolved notes" do
+          subject.unresolve!
+          first_note.reload
+          third_note.reload
+
+          expect(first_note.resolved_by).to be_nil
+          expect(third_note.resolved_by).to be_nil
+        end
+
+        it "unmarks the resolved notes as resolved" do
+          subject.unresolve!
+          first_note.reload
+          third_note.reload
+
+          expect(first_note.resolved?).to be false
+          expect(third_note.resolved?).to be false
+        end
+
+        it "unsets resolved_at" do
+          subject.unresolve!
+          first_note.reload
+          third_note.reload
+
+          expect(subject.resolved_at).to be_nil
+        end
+
+        it "unsets resolved_by" do
+          subject.unresolve!
+          first_note.reload
+          third_note.reload
+
+          expect(subject.resolved_by).to be_nil
+        end
+
+        it "unmarks as resolved" do
+          subject.unresolve!
+
+          expect(subject.resolved?).to be false
+        end
+      end
+
+      context "when some resolvable notes are resolved" do
+        before do
+          first_note.resolve!(user)
+        end
+
+        it "unsets resolved_at on the resolved note" do
+          subject.unresolve!
+
+          expect(subject.first_note.resolved_at).to be_nil
+        end
+
+        it "unsets resolved_by on the resolved note" do
+          subject.unresolve!
+
+          expect(subject.first_note.resolved_by).to be_nil
+        end
+
+        it "unmarks the resolved note as resolved" do
+          subject.unresolve!
+
+          expect(subject.first_note.resolved?).to be false
+        end
+      end
+    end
+  end
+
+  describe "#first_note_to_resolve" do
+    it "returns the first note that still needs to be resolved" do
+      allow(first_note).to receive(:to_be_resolved?).and_return(false)
+      allow(second_note).to receive(:to_be_resolved?).and_return(true)
+
+      expect(subject.first_note_to_resolve).to eq(second_note)
+    end
+  end
+
+  describe "#last_resolved_note" do
+    let(:current_user) { create(:user) }
+
+    before do
+      first_note.resolve!(current_user)
+      third_note.resolve!(current_user)
+      second_note.resolve!(current_user)
+    end
+
+    it "returns the last note that was resolved" do
+      expect(subject.last_resolved_note).to eq(second_note)
+    end
+  end
+end
diff --git a/spec/models/concerns/resolvable_note_spec.rb b/spec/models/concerns/resolvable_note_spec.rb
new file mode 100644
index 00000000000..1503ccdff11
--- /dev/null
+++ b/spec/models/concerns/resolvable_note_spec.rb
@@ -0,0 +1,329 @@
+require 'spec_helper'
+
+describe Note, ResolvableNote, models: true do
+  let(:project) { create(:project) }
+  let(:merge_request) { create(:merge_request, source_project: project) }
+  subject { create(:discussion_note_on_merge_request, noteable: merge_request, project: project) }
+
+  context 'resolvability scopes' do
+    let!(:note1) { create(:note, project: project) }
+    let!(:note2) { create(:diff_note_on_commit, project: project) }
+    let!(:note3) { create(:diff_note_on_merge_request, :resolved, noteable: merge_request, project: project) }
+    let!(:note4) { create(:discussion_note_on_merge_request, noteable: merge_request, project: project) }
+    let!(:note5) { create(:discussion_note_on_issue, project: project) }
+    let!(:note6) { create(:discussion_note_on_merge_request, :system, noteable: merge_request, project: project) }
+
+    describe '.potentially_resolvable' do
+      it 'includes diff and discussion notes on merge requests' do
+        expect(Note.potentially_resolvable).to match_array([note3, note4, note6])
+      end
+    end
+
+    describe '.resolvable' do
+      it 'includes non-system diff and discussion notes on merge requests' do
+        expect(Note.resolvable).to match_array([note3, note4])
+      end
+    end
+
+    describe '.resolved' do
+      it 'includes resolved non-system diff and discussion notes on merge requests' do
+        expect(Note.resolved).to match_array([note3])
+      end
+    end
+
+    describe '.unresolved' do
+      it 'includes non-resolved non-system diff and discussion notes on merge requests' do
+        expect(Note.unresolved).to match_array([note4])
+      end
+    end
+  end
+
+  describe ".resolve!" do
+    let(:current_user) { create(:user) }
+    let!(:commit_note) { create(:diff_note_on_commit, project: project) }
+    let!(:resolved_note) { create(:discussion_note_on_merge_request, :resolved, noteable: merge_request, project: project) }
+    let!(:unresolved_note) { create(:discussion_note_on_merge_request, noteable: merge_request, project: project) }
+
+    before do
+      described_class.resolve!(current_user)
+
+      commit_note.reload
+      resolved_note.reload
+      unresolved_note.reload
+    end
+
+    it 'resolves only the resolvable, not yet resolved notes' do
+      expect(commit_note.resolved_at).to be_nil
+      expect(resolved_note.resolved_by).not_to eq(current_user)
+      expect(unresolved_note.resolved_at).not_to be_nil
+      expect(unresolved_note.resolved_by).to eq(current_user)
+    end
+  end
+
+  describe ".unresolve!" do
+    let!(:resolved_note) { create(:discussion_note_on_merge_request, :resolved, noteable: merge_request, project: project) }
+
+    before do
+      described_class.unresolve!
+
+      resolved_note.reload
+    end
+
+    it 'unresolves the resolved notes' do
+      expect(resolved_note.resolved_by).to be_nil
+      expect(resolved_note.resolved_at).to be_nil
+    end
+  end
+
+  describe '#resolvable?' do
+    context "when potentially resolvable" do
+      before do
+        allow(subject).to receive(:potentially_resolvable?).and_return(true)
+      end
+
+      context "when a system note" do
+        before do
+          subject.system = true
+        end
+
+        it "returns false" do
+          expect(subject.resolvable?).to be false
+        end
+      end
+
+      context "when a regular note" do
+        it "returns true" do
+          expect(subject.resolvable?).to be true
+        end
+      end
+    end
+
+    context "when not potentially resolvable" do
+      before do
+        allow(subject).to receive(:potentially_resolvable?).and_return(false)
+      end
+
+      it "returns false" do
+        expect(subject.resolvable?).to be false
+      end
+    end
+  end
+
+  describe "#to_be_resolved?" do
+    context "when not resolvable" do
+      before do
+        allow(subject).to receive(:resolvable?).and_return(false)
+      end
+
+      it "returns false" do
+        expect(subject.to_be_resolved?).to be false
+      end
+    end
+
+    context "when resolvable" do
+      before do
+        allow(subject).to receive(:resolvable?).and_return(true)
+      end
+
+      context "when resolved" do
+        before do
+          allow(subject).to receive(:resolved?).and_return(true)
+        end
+
+        it "returns false" do
+          expect(subject.to_be_resolved?).to be false
+        end
+      end
+
+      context "when not resolved" do
+        before do
+          allow(subject).to receive(:resolved?).and_return(false)
+        end
+
+        it "returns true" do
+          expect(subject.to_be_resolved?).to be true
+        end
+      end
+    end
+  end
+
+  describe "#resolved?" do
+    let(:current_user) { create(:user) }
+
+    context 'when not resolvable' do
+      before do
+        subject.resolve!(current_user)
+
+        allow(subject).to receive(:resolvable?).and_return(false)
+      end
+
+      it 'returns false' do
+        expect(subject.resolved?).to be_falsey
+      end
+    end
+
+    context 'when resolvable' do
+      context 'when the note has been resolved' do
+        before do
+          subject.resolve!(current_user)
+        end
+
+        it 'returns true' do
+          expect(subject.resolved?).to be_truthy
+        end
+      end
+
+      context 'when the note has not been resolved' do
+        it 'returns false' do
+          expect(subject.resolved?).to be_falsey
+        end
+      end
+    end
+  end
+
+  describe "#resolve!" do
+    let(:current_user) { create(:user) }
+
+    context "when not resolvable" do
+      before do
+        allow(subject).to receive(:resolvable?).and_return(false)
+      end
+
+      it "returns nil" do
+        expect(subject.resolve!(current_user)).to be_nil
+      end
+
+      it "doesn't set resolved_at" do
+        subject.resolve!(current_user)
+
+        expect(subject.resolved_at).to be_nil
+      end
+
+      it "doesn't set resolved_by" do
+        subject.resolve!(current_user)
+
+        expect(subject.resolved_by).to be_nil
+      end
+
+      it "doesn't mark as resolved" do
+        subject.resolve!(current_user)
+
+        expect(subject.resolved?).to be false
+      end
+    end
+
+    context "when resolvable" do
+      before do
+        allow(subject).to receive(:resolvable?).and_return(true)
+      end
+
+      context "when already resolved" do
+        let(:user) { create(:user) }
+
+        before do
+          subject.resolve!(user)
+        end
+
+        it "returns nil" do
+          expect(subject.resolve!(current_user)).to be_nil
+        end
+
+        it "doesn't change resolved_at" do
+          expect(subject.resolved_at).not_to be_nil
+
+          expect { subject.resolve!(current_user) }.not_to change { subject.resolved_at }
+        end
+
+        it "doesn't change resolved_by" do
+          expect(subject.resolved_by).to eq(user)
+
+          expect { subject.resolve!(current_user) }.not_to change { subject.resolved_by }
+        end
+
+        it "doesn't change resolved status" do
+          expect(subject.resolved?).to be true
+
+          expect { subject.resolve!(current_user) }.not_to change { subject.resolved? }
+        end
+      end
+
+      context "when not yet resolved" do
+        it "returns true" do
+          expect(subject.resolve!(current_user)).to be true
+        end
+
+        it "sets resolved_at" do
+          subject.resolve!(current_user)
+
+          expect(subject.resolved_at).not_to be_nil
+        end
+
+        it "sets resolved_by" do
+          subject.resolve!(current_user)
+
+          expect(subject.resolved_by).to eq(current_user)
+        end
+
+        it "marks as resolved" do
+          subject.resolve!(current_user)
+
+          expect(subject.resolved?).to be true
+        end
+      end
+    end
+  end
+
+  describe "#unresolve!" do
+    context "when not resolvable" do
+      before do
+        allow(subject).to receive(:resolvable?).and_return(false)
+      end
+
+      it "returns nil" do
+        expect(subject.unresolve!).to be_nil
+      end
+    end
+
+    context "when resolvable" do
+      before do
+        allow(subject).to receive(:resolvable?).and_return(true)
+      end
+
+      context "when resolved" do
+        let(:user) { create(:user) }
+
+        before do
+          subject.resolve!(user)
+        end
+
+        it "returns true" do
+          expect(subject.unresolve!).to be true
+        end
+
+        it "unsets resolved_at" do
+          subject.unresolve!
+
+          expect(subject.resolved_at).to be_nil
+        end
+
+        it "unsets resolved_by" do
+          subject.unresolve!
+
+          expect(subject.resolved_by).to be_nil
+        end
+
+        it "unmarks as resolved" do
+          subject.unresolve!
+
+          expect(subject.resolved?).to be false
+        end
+      end
+
+      context "when not resolved" do
+        it "returns nil" do
+          expect(subject.unresolve!).to be_nil
+        end
+      end
+    end
+  end
+end
diff --git a/spec/models/concerns/routable_spec.rb b/spec/models/concerns/routable_spec.rb
index 677e60e1282..f191605dbdb 100644
--- a/spec/models/concerns/routable_spec.rb
+++ b/spec/models/concerns/routable_spec.rb
@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 describe Group, 'Routable' do
-  let!(:group) { create(:group) }
+  let!(:group) { create(:group, name: 'foo') }
 
   describe 'Validations' do
     it { is_expected.to validate_presence_of(:route) }
@@ -81,6 +81,113 @@ describe Group, 'Routable' do
     it { is_expected.to eq([nested_group]) }
   end
 
+  describe '.member_self_and_descendants' do
+    let!(:user) { create(:user) }
+    let!(:nested_group) { create(:group, parent: group) }
+
+    before { group.add_owner(user) }
+    subject { described_class.member_self_and_descendants(user.id) }
+
+    it { is_expected.to match_array [group, nested_group] }
+  end
+
+  describe '.member_hierarchy' do
+    # foo/bar would also match foo/barbaz instead of just foo/bar and foo/bar/baz
+    let!(:user) { create(:user) }
+
+    #                group
+    #        _______ (foo) _______
+    #       |                     |
+    #       |                     |
+    # nested_group_1        nested_group_2
+    # (bar)                 (barbaz)
+    #       |                     |
+    #       |                     |
+    # nested_group_1_1      nested_group_2_1
+    # (baz)                 (baz)
+    #
+    let!(:nested_group_1) { create :group, parent: group, name: 'bar' }
+    let!(:nested_group_1_1) { create :group, parent: nested_group_1, name: 'baz' }
+    let!(:nested_group_2) { create :group, parent: group, name: 'barbaz' }
+    let!(:nested_group_2_1) { create :group, parent: nested_group_2, name: 'baz' }
+
+    context 'user is not a member of any group' do
+      subject { described_class.member_hierarchy(user.id) }
+
+      it 'returns an empty array' do
+        is_expected.to eq []
+      end
+    end
+
+    context 'user is member of all groups' do
+      before do
+        group.add_owner(user)
+        nested_group_1.add_owner(user)
+        nested_group_1_1.add_owner(user)
+        nested_group_2.add_owner(user)
+        nested_group_2_1.add_owner(user)
+      end
+      subject { described_class.member_hierarchy(user.id) }
+
+      it 'returns all groups' do
+        is_expected.to match_array [
+          group,
+          nested_group_1, nested_group_1_1,
+          nested_group_2, nested_group_2_1
+        ]
+      end
+    end
+
+    context 'user is member of the top group' do
+      before { group.add_owner(user) }
+      subject { described_class.member_hierarchy(user.id) }
+
+      it 'returns all groups' do
+        is_expected.to match_array [
+          group,
+          nested_group_1, nested_group_1_1,
+          nested_group_2, nested_group_2_1
+        ]
+      end
+    end
+
+    context 'user is member of the first child (internal node), branch 1' do
+      before { nested_group_1.add_owner(user) }
+      subject { described_class.member_hierarchy(user.id) }
+
+      it 'returns the groups in the hierarchy' do
+        is_expected.to match_array [
+          group,
+          nested_group_1, nested_group_1_1
+        ]
+      end
+    end
+
+    context 'user is member of the first child (internal node), branch 2' do
+      before { nested_group_2.add_owner(user) }
+      subject { described_class.member_hierarchy(user.id) }
+
+      it 'returns the groups in the hierarchy' do
+        is_expected.to match_array [
+          group,
+          nested_group_2, nested_group_2_1
+        ]
+      end
+    end
+
+    context 'user is member of the last child (leaf node)' do
+      before { nested_group_1_1.add_owner(user) }
+      subject { described_class.member_hierarchy(user.id) }
+
+      it 'returns the groups in the hierarchy' do
+        is_expected.to match_array [
+          group,
+          nested_group_1, nested_group_1_1
+        ]
+      end
+    end
+  end
+
   describe '#full_path' do
     let(:group) { create(:group) }
     let(:nested_group) { create(:group, parent: group) }
diff --git a/spec/models/container_repository_spec.rb b/spec/models/container_repository_spec.rb
new file mode 100644
index 00000000000..6d6c9f2adfc
--- /dev/null
+++ b/spec/models/container_repository_spec.rb
@@ -0,0 +1,224 @@
+require 'spec_helper'
+
+describe ContainerRepository do
+  let(:group) { create(:group, name: 'group') }
+  let(:project) { create(:project, path: 'test', group: group) }
+
+  let(:repository) do
+    create(:container_repository, name: 'my_image', project: project)
+  end
+
+  before do
+    stub_container_registry_config(enabled: true,
+                                   api_url: 'http://registry.gitlab',
+                                   host_port: 'registry.gitlab')
+
+    stub_request(:get, 'http://registry.gitlab/v2/group/test/my_image/tags/list')
+      .with(headers: { 'Accept' => 'application/vnd.docker.distribution.manifest.v2+json' })
+      .to_return(
+        status: 200,
+        body: JSON.dump(tags: ['test_tag']),
+        headers: { 'Content-Type' => 'application/json' })
+  end
+
+  describe 'associations' do
+    it 'belongs to the project' do
+      expect(repository).to belong_to(:project)
+    end
+  end
+
+  describe '#tag' do
+    it 'has a test tag' do
+      expect(repository.tag('test')).not_to be_nil
+    end
+  end
+
+  describe '#path' do
+    it 'returns a full path to the repository' do
+      expect(repository.path).to eq('group/test/my_image')
+    end
+  end
+
+  describe '#manifest' do
+    it 'returns non-empty manifest' do
+      expect(repository.manifest).not_to be_nil
+    end
+  end
+
+  describe '#valid?' do
+    it 'is a valid repository' do
+      expect(repository).to be_valid
+    end
+  end
+
+  describe '#tags' do
+    it 'returns non-empty tags list' do
+      expect(repository.tags).not_to be_empty
+    end
+  end
+
+  describe '#has_tags?' do
+    it 'has tags' do
+      expect(repository).to have_tags
+    end
+  end
+
+  describe '#delete_tags!' do
+    let(:repository) do
+      create(:container_repository, name: 'my_image',
+                                    tags: %w[latest rc1],
+                                    project: project)
+    end
+
+    context 'when action succeeds' do
+      it 'returns status that indicates success' do
+        expect(repository.client)
+          .to receive(:delete_repository_tag)
+          .and_return(true)
+
+        expect(repository.delete_tags!).to be_truthy
+      end
+    end
+
+    context 'when action fails' do
+      it 'returns status that indicates failure' do
+        expect(repository.client)
+          .to receive(:delete_repository_tag)
+          .and_return(false)
+
+        expect(repository.delete_tags!).to be_falsey
+      end
+    end
+  end
+
+  describe '#location' do
+    context 'when registry is running on a custom port' do
+      before do
+        stub_container_registry_config(enabled: true,
+                                       api_url: 'http://registry.gitlab:5000',
+                                       host_port: 'registry.gitlab:5000')
+      end
+
+      it 'returns a full location of the repository' do
+        expect(repository.location)
+          .to eq 'registry.gitlab:5000/group/test/my_image'
+      end
+    end
+  end
+
+  describe '#root_repository?' do
+    context 'when repository is a root repository' do
+      let(:repository) { create(:container_repository, :root) }
+
+      it 'returns true' do
+        expect(repository).to be_root_repository
+      end
+    end
+
+    context 'when repository is not a root repository' do
+      it 'returns false' do
+        expect(repository).not_to be_root_repository
+      end
+    end
+  end
+
+  describe '.build_from_path' do
+    let(:registry_path) do
+      ContainerRegistry::Path.new(project.full_path + '/some/image')
+    end
+
+    let(:repository) do
+      described_class.build_from_path(registry_path)
+    end
+
+    it 'fabricates repository assigned to a correct project' do
+      expect(repository.project).to eq project
+    end
+
+    it 'fabricates repository with a correct name' do
+      expect(repository.name).to eq 'some/image'
+    end
+
+    it 'is not persisted' do
+      expect(repository).not_to be_persisted
+    end
+  end
+
+  describe '.create_from_path!' do
+    let(:repository) do
+      described_class.create_from_path!(ContainerRegistry::Path.new(path))
+    end
+
+    let(:repository_path) { ContainerRegistry::Path.new(path) }
+
+    context 'when received multi-level repository path' do
+      let(:path) { project.full_path + '/some/image' }
+
+      it 'fabricates repository assigned to a correct project' do
+        expect(repository.project).to eq project
+      end
+
+      it 'fabricates repository with a correct name' do
+        expect(repository.name).to eq 'some/image'
+      end
+    end
+
+    context 'when path is too long' do
+      let(:path) do
+        project.full_path + '/a/b/c/d/e/f/g/h/i/j/k/l/n/o/p/s/t/u/x/y/z'
+      end
+
+      it 'does not create repository and raises error' do
+        expect { repository }.to raise_error(
+          ContainerRegistry::Path::InvalidRegistryPathError)
+      end
+    end
+
+    context 'when received multi-level repository with nested groups' do
+      let(:group) { create(:group, :nested, name: 'nested') }
+      let(:path) { project.full_path + '/some/image' }
+
+      it 'fabricates repository assigned to a correct project' do
+        expect(repository.project).to eq project
+      end
+
+      it 'fabricates repository with a correct name' do
+        expect(repository.name).to eq 'some/image'
+      end
+
+      it 'has path including a nested group' do
+        expect(repository.path).to include 'nested/test/some/image'
+      end
+    end
+
+    context 'when received root repository path' do
+      let(:path) { project.full_path }
+
+      it 'fabricates repository assigned to a correct project' do
+        expect(repository.project).to eq project
+      end
+
+      it 'fabricates repository with an empty name' do
+        expect(repository.name).to be_empty
+      end
+    end
+  end
+
+  describe '.build_root_repository' do
+    let(:repository) do
+      described_class.build_root_repository(project)
+    end
+
+    it 'fabricates a root repository object' do
+      expect(repository).to be_root_repository
+    end
+
+    it 'assignes it to the correct project' do
+      expect(repository.project).to eq project
+    end
+
+    it 'does not persist it' do
+      expect(repository).not_to be_persisted
+    end
+  end
+end
diff --git a/spec/models/diff_discussion_spec.rb b/spec/models/diff_discussion_spec.rb
new file mode 100644
index 00000000000..48e7c0a822c
--- /dev/null
+++ b/spec/models/diff_discussion_spec.rb
@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe DiffDiscussion, model: true do
+  subject { described_class.new([first_note, second_note, third_note]) }
+
+  let(:first_note) { create(:diff_note_on_merge_request) }
+  let(:merge_request) { first_note.noteable }
+  let(:project) { first_note.project }
+  let(:second_note) { create(:diff_note_on_merge_request, noteable: merge_request, project: project, in_reply_to: first_note) }
+  let(:third_note) { create(:diff_note_on_merge_request, noteable: merge_request, project: project, in_reply_to: first_note) }
+
+  describe '#reply_attributes' do
+    it 'includes position and original_position' do
+      attributes = subject.reply_attributes
+      expect(attributes[:position]).to eq(first_note.position.to_json)
+      expect(attributes[:original_position]).to eq(first_note.original_position.to_json)
+    end
+  end
+end
diff --git a/spec/models/diff_note_spec.rb b/spec/models/diff_note_spec.rb
index 9ea3a4b7020..f32b6b99b3d 100644
--- a/spec/models/diff_note_spec.rb
+++ b/spec/models/diff_note_spec.rb
@@ -31,43 +31,6 @@ describe DiffNote, models: true do
 
   subject { create(:diff_note_on_merge_request, project: project, position: position, noteable: merge_request) }
 
-  describe ".resolve!" do
-    let(:current_user) { create(:user) }
-    let!(:commit_note) { create(:diff_note_on_commit) }
-    let!(:resolved_note) { create(:diff_note_on_merge_request, :resolved) }
-    let!(:unresolved_note) { create(:diff_note_on_merge_request) }
-
-    before do
-      described_class.resolve!(current_user)
-
-      commit_note.reload
-      resolved_note.reload
-      unresolved_note.reload
-    end
-
-    it 'resolves only the resolvable, not yet resolved notes' do
-      expect(commit_note.resolved_at).to be_nil
-      expect(resolved_note.resolved_by).not_to eq(current_user)
-      expect(unresolved_note.resolved_at).not_to be_nil
-      expect(unresolved_note.resolved_by).to eq(current_user)
-    end
-  end
-
-  describe ".unresolve!" do
-    let!(:resolved_note) { create(:diff_note_on_merge_request, :resolved) }
-
-    before do
-      described_class.unresolve!
-
-      resolved_note.reload
-    end
-
-    it 'unresolves the resolved notes' do
-      expect(resolved_note.resolved_by).to be_nil
-      expect(resolved_note.resolved_at).to be_nil
-    end
-  end
-
   describe "#position=" do
     context "when provided a string" do
       it "sets the position" do
@@ -94,6 +57,32 @@ describe DiffNote, models: true do
     end
   end
 
+  describe "#original_position=" do
+    context "when provided a string" do
+      it "sets the original position" do
+        subject.original_position = new_position.to_json
+
+        expect(subject.original_position).to eq(new_position)
+      end
+    end
+
+    context "when provided a hash" do
+      it "sets the original position" do
+        subject.original_position = new_position.to_h
+
+        expect(subject.original_position).to eq(new_position)
+      end
+    end
+
+    context "when provided a position object" do
+      it "sets the original position" do
+        subject.original_position = new_position
+
+        expect(subject.original_position).to eq(new_position)
+      end
+    end
+  end
+
   describe "#diff_file" do
     it "returns the correct diff file" do
       diff_file = subject.diff_file
@@ -166,6 +155,23 @@ describe DiffNote, models: true do
     end
   end
 
+  describe '#latest_merge_request_diff' do
+    context 'when active' do
+      it 'returns the current merge request diff' do
+        expect(subject.latest_merge_request_diff).to eq(merge_request.merge_request_diff)
+      end
+    end
+
+    context 'when outdated' do
+      let!(:old_merge_request_diff) { merge_request.merge_request_diff }
+      let!(:new_merge_request_diff) { merge_request.merge_request_diffs.create(diff_refs: commit.diff_refs) }
+
+      it 'returns the latest merge request diff that this diff note applied to' do
+        expect(subject.latest_merge_request_diff).to eq(old_merge_request_diff)
+      end
+    end
+  end
+
   describe "creation" do
     describe "updating of position" do
       context "when noteable is a commit" do
@@ -226,252 +232,6 @@ describe DiffNote, models: true do
     end
   end
 
-  describe "#resolvable?" do
-    context "when noteable is a commit" do
-      subject { create(:diff_note_on_commit, project: project, position: position) }
-
-      it "returns false" do
-        expect(subject.resolvable?).to be false
-      end
-    end
-
-    context "when noteable is a merge request" do
-      context "when a system note" do
-        before do
-          subject.system = true
-        end
-
-        it "returns false" do
-          expect(subject.resolvable?).to be false
-        end
-      end
-
-      context "when a regular note" do
-        it "returns true" do
-          expect(subject.resolvable?).to be true
-        end
-      end
-    end
-  end
-
-  describe "#to_be_resolved?" do
-    context "when not resolvable" do
-      before do
-        allow(subject).to receive(:resolvable?).and_return(false)
-      end
-
-      it "returns false" do
-        expect(subject.to_be_resolved?).to be false
-      end
-    end
-
-    context "when resolvable" do
-      before do
-        allow(subject).to receive(:resolvable?).and_return(true)
-      end
-
-      context "when resolved" do
-        before do
-          allow(subject).to receive(:resolved?).and_return(true)
-        end
-
-        it "returns false" do
-          expect(subject.to_be_resolved?).to be false
-        end
-      end
-
-      context "when not resolved" do
-        before do
-          allow(subject).to receive(:resolved?).and_return(false)
-        end
-
-        it "returns true" do
-          expect(subject.to_be_resolved?).to be true
-        end
-      end
-    end
-  end
-
-  describe "#resolve!" do
-    let(:current_user) { create(:user) }
-
-    context "when not resolvable" do
-      before do
-        allow(subject).to receive(:resolvable?).and_return(false)
-      end
-
-      it "returns nil" do
-        expect(subject.resolve!(current_user)).to be_nil
-      end
-
-      it "doesn't set resolved_at" do
-        subject.resolve!(current_user)
-
-        expect(subject.resolved_at).to be_nil
-      end
-
-      it "doesn't set resolved_by" do
-        subject.resolve!(current_user)
-
-        expect(subject.resolved_by).to be_nil
-      end
-
-      it "doesn't mark as resolved" do
-        subject.resolve!(current_user)
-
-        expect(subject.resolved?).to be false
-      end
-    end
-
-    context "when resolvable" do
-      before do
-        allow(subject).to receive(:resolvable?).and_return(true)
-      end
-
-      context "when already resolved" do
-        let(:user) { create(:user) }
-
-        before do
-          subject.resolve!(user)
-        end
-
-        it "returns nil" do
-          expect(subject.resolve!(current_user)).to be_nil
-        end
-
-        it "doesn't change resolved_at" do
-          expect(subject.resolved_at).not_to be_nil
-
-          expect { subject.resolve!(current_user) }.not_to change { subject.resolved_at }
-        end
-
-        it "doesn't change resolved_by" do
-          expect(subject.resolved_by).to eq(user)
-
-          expect { subject.resolve!(current_user) }.not_to change { subject.resolved_by }
-        end
-
-        it "doesn't change resolved status" do
-          expect(subject.resolved?).to be true
-
-          expect { subject.resolve!(current_user) }.not_to change { subject.resolved? }
-        end
-      end
-
-      context "when not yet resolved" do
-        it "returns true" do
-          expect(subject.resolve!(current_user)).to be true
-        end
-
-        it "sets resolved_at" do
-          subject.resolve!(current_user)
-
-          expect(subject.resolved_at).not_to be_nil
-        end
-
-        it "sets resolved_by" do
-          subject.resolve!(current_user)
-
-          expect(subject.resolved_by).to eq(current_user)
-        end
-
-        it "marks as resolved" do
-          subject.resolve!(current_user)
-
-          expect(subject.resolved?).to be true
-        end
-      end
-    end
-  end
-
-  describe "#unresolve!" do
-    context "when not resolvable" do
-      before do
-        allow(subject).to receive(:resolvable?).and_return(false)
-      end
-
-      it "returns nil" do
-        expect(subject.unresolve!).to be_nil
-      end
-    end
-
-    context "when resolvable" do
-      before do
-        allow(subject).to receive(:resolvable?).and_return(true)
-      end
-
-      context "when resolved" do
-        let(:user) { create(:user) }
-
-        before do
-          subject.resolve!(user)
-        end
-
-        it "returns true" do
-          expect(subject.unresolve!).to be true
-        end
-
-        it "unsets resolved_at" do
-          subject.unresolve!
-
-          expect(subject.resolved_at).to be_nil
-        end
-
-        it "unsets resolved_by" do
-          subject.unresolve!
-
-          expect(subject.resolved_by).to be_nil
-        end
-
-        it "unmarks as resolved" do
-          subject.unresolve!
-
-          expect(subject.resolved?).to be false
-        end
-      end
-
-      context "when not resolved" do
-        it "returns nil" do
-          expect(subject.unresolve!).to be_nil
-        end
-      end
-    end
-  end
-
-  describe "#discussion" do
-    context "when not resolvable" do
-      before do
-        allow(subject).to receive(:resolvable?).and_return(false)
-      end
-
-      it "returns nil" do
-        expect(subject.discussion).to be_nil
-      end
-    end
-
-    context "when resolvable" do
-      let!(:diff_note2) { create(:diff_note_on_merge_request, project: project, noteable: merge_request, position: subject.position) }
-      let!(:diff_note3) { create(:diff_note_on_merge_request, project: project, noteable: merge_request, position: active_position2) }
-
-      let(:active_position2) do
-        Gitlab::Diff::Position.new(
-          old_path: "files/ruby/popen.rb",
-          new_path: "files/ruby/popen.rb",
-          old_line: 16,
-          new_line: 22,
-          diff_refs: merge_request.diff_refs
-        )
-      end
-
-      it "returns the discussion this note is in" do
-        discussion = subject.discussion
-
-        expect(discussion.id).to eq(subject.discussion_id)
-        expect(discussion.notes).to eq([subject, diff_note2])
-      end
-    end
-  end
-
   describe "#discussion_id" do
     let(:note) { create(:diff_note_on_merge_request) }
 
@@ -496,29 +256,4 @@ describe DiffNote, models: true do
       end
     end
   end
-
-  describe "#original_discussion_id" do
-    let(:note) { create(:diff_note_on_merge_request) }
-
-    context "when it is newly created" do
-      it "has a discussion id" do
-        expect(note.original_discussion_id).not_to be_nil
-        expect(note.original_discussion_id).to match(/\A\h{40}\z/)
-      end
-    end
-
-    context "when it didn't store a discussion id before" do
-      before do
-        note.update_column(:original_discussion_id, nil)
-      end
-
-      it "has a discussion id" do
-        # The original_discussion_id is set in `after_initialize`, so `reload` won't work
-        reloaded_note = Note.find(note.id)
-
-        expect(reloaded_note.original_discussion_id).not_to be_nil
-        expect(reloaded_note.original_discussion_id).to match(/\A\h{40}\z/)
-      end
-    end
-  end
 end
diff --git a/spec/models/discussion_spec.rb b/spec/models/discussion_spec.rb
index bc32fadd391..0221e23ced8 100644
--- a/spec/models/discussion_spec.rb
+++ b/spec/models/discussion_spec.rb
@@ -4,618 +4,27 @@ describe Discussion, model: true do
   subject { described_class.new([first_note, second_note, third_note]) }
 
   let(:first_note) { create(:diff_note_on_merge_request) }
-  let(:second_note) { create(:diff_note_on_merge_request) }
+  let(:merge_request) { first_note.noteable }
+  let(:second_note) { create(:diff_note_on_merge_request, in_reply_to: first_note) }
   let(:third_note) { create(:diff_note_on_merge_request) }
 
-  describe "#resolvable?" do
-    context "when a diff discussion" do
-      before do
-        allow(subject).to receive(:diff_discussion?).and_return(true)
-      end
-
-      context "when all notes are unresolvable" do
-        before do
-          allow(first_note).to receive(:resolvable?).and_return(false)
-          allow(second_note).to receive(:resolvable?).and_return(false)
-          allow(third_note).to receive(:resolvable?).and_return(false)
-        end
-
-        it "returns false" do
-          expect(subject.resolvable?).to be false
-        end
-      end
-
-      context "when some notes are unresolvable and some notes are resolvable" do
-        before do
-          allow(first_note).to receive(:resolvable?).and_return(true)
-          allow(second_note).to receive(:resolvable?).and_return(false)
-          allow(third_note).to receive(:resolvable?).and_return(true)
-        end
-
-        it "returns true" do
-          expect(subject.resolvable?).to be true
-        end
-      end
-
-      context "when all notes are resolvable" do
-        before do
-          allow(first_note).to receive(:resolvable?).and_return(true)
-          allow(second_note).to receive(:resolvable?).and_return(true)
-          allow(third_note).to receive(:resolvable?).and_return(true)
-        end
-
-        it "returns true" do
-          expect(subject.resolvable?).to be true
-        end
-      end
-    end
-
-    context "when not a diff discussion" do
-      before do
-        allow(subject).to receive(:diff_discussion?).and_return(false)
-      end
-
-      it "returns false" do
-        expect(subject.resolvable?).to be false
-      end
-    end
-  end
-
-  describe "#resolved?" do
-    context "when not resolvable" do
-      before do
-        allow(subject).to receive(:resolvable?).and_return(false)
-      end
-
-      it "returns false" do
-        expect(subject.resolved?).to be false
-      end
-    end
-
-    context "when resolvable" do
-      before do
-        allow(subject).to receive(:resolvable?).and_return(true)
-
-        allow(first_note).to receive(:resolvable?).and_return(true)
-        allow(second_note).to receive(:resolvable?).and_return(false)
-        allow(third_note).to receive(:resolvable?).and_return(true)
-      end
-
-      context "when all resolvable notes are resolved" do
-        before do
-          allow(first_note).to receive(:resolved?).and_return(true)
-          allow(third_note).to receive(:resolved?).and_return(true)
-        end
-
-        it "returns true" do
-          expect(subject.resolved?).to be true
-        end
-      end
-
-      context "when some resolvable notes are not resolved" do
-        before do
-          allow(first_note).to receive(:resolved?).and_return(true)
-          allow(third_note).to receive(:resolved?).and_return(false)
-        end
-
-        it "returns false" do
-          expect(subject.resolved?).to be false
-        end
-      end
-    end
-  end
-
-  describe "#to_be_resolved?" do
-    context "when not resolvable" do
-      before do
-        allow(subject).to receive(:resolvable?).and_return(false)
-      end
-
-      it "returns false" do
-        expect(subject.to_be_resolved?).to be false
-      end
-    end
-
-    context "when resolvable" do
-      before do
-        allow(subject).to receive(:resolvable?).and_return(true)
-
-        allow(first_note).to receive(:resolvable?).and_return(true)
-        allow(second_note).to receive(:resolvable?).and_return(false)
-        allow(third_note).to receive(:resolvable?).and_return(true)
-      end
-
-      context "when all resolvable notes are resolved" do
-        before do
-          allow(first_note).to receive(:resolved?).and_return(true)
-          allow(third_note).to receive(:resolved?).and_return(true)
-        end
-
-        it "returns false" do
-          expect(subject.to_be_resolved?).to be false
-        end
-      end
-
-      context "when some resolvable notes are not resolved" do
-        before do
-          allow(first_note).to receive(:resolved?).and_return(true)
-          allow(third_note).to receive(:resolved?).and_return(false)
-        end
-
-        it "returns true" do
-          expect(subject.to_be_resolved?).to be true
-        end
-      end
-    end
-  end
-
-  describe "#can_resolve?" do
-    let(:current_user) { create(:user) }
-
-    context "when not resolvable" do
-      before do
-        allow(subject).to receive(:resolvable?).and_return(false)
-      end
-
-      it "returns false" do
-        expect(subject.can_resolve?(current_user)).to be false
-      end
-    end
-
-    context "when resolvable" do
-      before do
-        allow(subject).to receive(:resolvable?).and_return(true)
-      end
-
-      context "when not signed in" do
-        let(:current_user) { nil }
-
-        it "returns false" do
-          expect(subject.can_resolve?(current_user)).to be false
-        end
-      end
-
-      context "when signed in" do
-        context "when the signed in user is the noteable author" do
-          before do
-            subject.noteable.author = current_user
-          end
-
-          it "returns true" do
-            expect(subject.can_resolve?(current_user)).to be true
-          end
-        end
-
-        context "when the signed in user can push to the project" do
-          before do
-            subject.project.team << [current_user, :master]
-          end
-
-          it "returns true" do
-            expect(subject.can_resolve?(current_user)).to be true
-          end
-        end
-
-        context "when the signed in user is a random user" do
-          it "returns false" do
-            expect(subject.can_resolve?(current_user)).to be false
-          end
-        end
-      end
-    end
-  end
-
-  describe "#resolve!" do
-    let(:current_user) { create(:user) }
-
-    context "when not resolvable" do
-      before do
-        allow(subject).to receive(:resolvable?).and_return(false)
-      end
-
-      it "returns nil" do
-        expect(subject.resolve!(current_user)).to be_nil
-      end
-
-      it "doesn't set resolved_at" do
-        subject.resolve!(current_user)
-
-        expect(subject.resolved_at).to be_nil
-      end
-
-      it "doesn't set resolved_by" do
-        subject.resolve!(current_user)
-
-        expect(subject.resolved_by).to be_nil
-      end
-
-      it "doesn't mark as resolved" do
-        subject.resolve!(current_user)
-
-        expect(subject.resolved?).to be false
-      end
-    end
-
-    context "when resolvable" do
-      let(:user) { create(:user) }
-      let(:second_note) { create(:diff_note_on_commit) } # unresolvable
-
-      before do
-        allow(subject).to receive(:resolvable?).and_return(true)
-      end
-
-      context "when all resolvable notes are resolved" do
-        before do
-          first_note.resolve!(user)
-          third_note.resolve!(user)
-
-          first_note.reload
-          third_note.reload
-        end
-
-        it "doesn't change resolved_at on the resolved notes" do
-          expect(first_note.resolved_at).not_to be_nil
-          expect(third_note.resolved_at).not_to be_nil
-
-          expect { subject.resolve!(current_user) }.not_to change { first_note.resolved_at }
-          expect { subject.resolve!(current_user) }.not_to change { third_note.resolved_at }
-        end
-
-        it "doesn't change resolved_by on the resolved notes" do
-          expect(first_note.resolved_by).to eq(user)
-          expect(third_note.resolved_by).to eq(user)
-
-          expect { subject.resolve!(current_user) }.not_to change { first_note.resolved_by }
-          expect { subject.resolve!(current_user) }.not_to change { third_note.resolved_by }
-        end
-
-        it "doesn't change the resolved state on the resolved notes" do
-          expect(first_note.resolved?).to be true
-          expect(third_note.resolved?).to be true
-
-          expect { subject.resolve!(current_user) }.not_to change { first_note.resolved? }
-          expect { subject.resolve!(current_user) }.not_to change { third_note.resolved? }
-        end
-
-        it "doesn't change resolved_at" do
-          expect(subject.resolved_at).not_to be_nil
-
-          expect { subject.resolve!(current_user) }.not_to change { subject.resolved_at }
-        end
-
-        it "doesn't change resolved_by" do
-          expect(subject.resolved_by).to eq(user)
-
-          expect { subject.resolve!(current_user) }.not_to change { subject.resolved_by }
-        end
-
-        it "doesn't change resolved state" do
-          expect(subject.resolved?).to be true
-
-          expect { subject.resolve!(current_user) }.not_to change { subject.resolved? }
-        end
-      end
-
-      context "when some resolvable notes are resolved" do
-        before do
-          first_note.resolve!(user)
-        end
-
-        it "doesn't change resolved_at on the resolved note" do
-          expect(first_note.resolved_at).not_to be_nil
-
-          expect { subject.resolve!(current_user) }.
-            not_to change { first_note.reload.resolved_at }
-        end
-
-        it "doesn't change resolved_by on the resolved note" do
-          expect(first_note.resolved_by).to eq(user)
-
-          expect { subject.resolve!(current_user) }.
-            not_to change { first_note.reload && first_note.resolved_by }
-        end
-
-        it "doesn't change the resolved state on the resolved note" do
-          expect(first_note.resolved?).to be true
-
-          expect { subject.resolve!(current_user) }.
-            not_to change { first_note.reload && first_note.resolved? }
-        end
-
-        it "sets resolved_at on the unresolved note" do
-          subject.resolve!(current_user)
-          third_note.reload
-
-          expect(third_note.resolved_at).not_to be_nil
-        end
-
-        it "sets resolved_by on the unresolved note" do
-          subject.resolve!(current_user)
-          third_note.reload
-
-          expect(third_note.resolved_by).to eq(current_user)
-        end
-
-        it "marks the unresolved note as resolved" do
-          subject.resolve!(current_user)
-          third_note.reload
-
-          expect(third_note.resolved?).to be true
-        end
-
-        it "sets resolved_at" do
-          subject.resolve!(current_user)
-
-          expect(subject.resolved_at).not_to be_nil
-        end
-
-        it "sets resolved_by" do
-          subject.resolve!(current_user)
-
-          expect(subject.resolved_by).to eq(current_user)
-        end
-
-        it "marks as resolved" do
-          subject.resolve!(current_user)
-
-          expect(subject.resolved?).to be true
-        end
-      end
-
-      context "when no resolvable notes are resolved" do
-        it "sets resolved_at on the unresolved notes" do
-          subject.resolve!(current_user)
-          first_note.reload
-          third_note.reload
-
-          expect(first_note.resolved_at).not_to be_nil
-          expect(third_note.resolved_at).not_to be_nil
-        end
-
-        it "sets resolved_by on the unresolved notes" do
-          subject.resolve!(current_user)
-          first_note.reload
-          third_note.reload
-
-          expect(first_note.resolved_by).to eq(current_user)
-          expect(third_note.resolved_by).to eq(current_user)
-        end
-
-        it "marks the unresolved notes as resolved" do
-          subject.resolve!(current_user)
-          first_note.reload
-          third_note.reload
-
-          expect(first_note.resolved?).to be true
-          expect(third_note.resolved?).to be true
-        end
-
-        it "sets resolved_at" do
-          subject.resolve!(current_user)
-          first_note.reload
-          third_note.reload
-
-          expect(subject.resolved_at).not_to be_nil
-        end
-
-        it "sets resolved_by" do
-          subject.resolve!(current_user)
-          first_note.reload
-          third_note.reload
-
-          expect(subject.resolved_by).to eq(current_user)
-        end
-
-        it "marks as resolved" do
-          subject.resolve!(current_user)
-          first_note.reload
-          third_note.reload
-
-          expect(subject.resolved?).to be true
-        end
-      end
-    end
-  end
-
-  describe "#unresolve!" do
-    context "when not resolvable" do
-      before do
-        allow(subject).to receive(:resolvable?).and_return(false)
-      end
-
-      it "returns nil" do
-        expect(subject.unresolve!).to be_nil
-      end
-    end
-
-    context "when resolvable" do
-      let(:user) { create(:user) }
-
-      before do
-        allow(subject).to receive(:resolvable?).and_return(true)
-
-        allow(first_note).to receive(:resolvable?).and_return(true)
-        allow(second_note).to receive(:resolvable?).and_return(false)
-        allow(third_note).to receive(:resolvable?).and_return(true)
-      end
-
-      context "when all resolvable notes are resolved" do
-        before do
-          first_note.resolve!(user)
-          third_note.resolve!(user)
-        end
-
-        it "unsets resolved_at on the resolved notes" do
-          subject.unresolve!
-          first_note.reload
-          third_note.reload
-
-          expect(first_note.resolved_at).to be_nil
-          expect(third_note.resolved_at).to be_nil
-        end
-
-        it "unsets resolved_by on the resolved notes" do
-          subject.unresolve!
-          first_note.reload
-          third_note.reload
-
-          expect(first_note.resolved_by).to be_nil
-          expect(third_note.resolved_by).to be_nil
-        end
-
-        it "unmarks the resolved notes as resolved" do
-          subject.unresolve!
-          first_note.reload
-          third_note.reload
-
-          expect(first_note.resolved?).to be false
-          expect(third_note.resolved?).to be false
-        end
-
-        it "unsets resolved_at" do
-          subject.unresolve!
-          first_note.reload
-          third_note.reload
-
-          expect(subject.resolved_at).to be_nil
-        end
-
-        it "unsets resolved_by" do
-          subject.unresolve!
-          first_note.reload
-          third_note.reload
-
-          expect(subject.resolved_by).to be_nil
-        end
-
-        it "unmarks as resolved" do
-          subject.unresolve!
-
-          expect(subject.resolved?).to be false
-        end
-      end
-
-      context "when some resolvable notes are resolved" do
-        before do
-          first_note.resolve!(user)
-        end
-
-        it "unsets resolved_at on the resolved note" do
-          subject.unresolve!
-
-          expect(subject.first_note.resolved_at).to be_nil
-        end
-
-        it "unsets resolved_by on the resolved note" do
-          subject.unresolve!
-
-          expect(subject.first_note.resolved_by).to be_nil
-        end
-
-        it "unmarks the resolved note as resolved" do
-          subject.unresolve!
-
-          expect(subject.first_note.resolved?).to be false
-        end
-      end
+  describe '.build' do
+    it 'returns a discussion of the right type' do
+      discussion = described_class.build([first_note, second_note], merge_request)
+      expect(discussion).to be_a(DiffDiscussion)
+      expect(discussion.notes.count).to be(2)
+      expect(discussion.first_note).to be(first_note)
+      expect(discussion.noteable).to be(merge_request)
     end
   end
 
-  describe "#first_note_to_resolve" do
-    it "returns the first not that still needs to be resolved" do
-      allow(first_note).to receive(:to_be_resolved?).and_return(false)
-      allow(second_note).to receive(:to_be_resolved?).and_return(true)
-
-      expect(subject.first_note_to_resolve).to eq(second_note)
-    end
-  end
-
-  describe "#collapsed?" do
-    context "when a diff discussion" do
-      before do
-        allow(subject).to receive(:diff_discussion?).and_return(true)
-      end
-
-      context "when resolvable" do
-        before do
-          allow(subject).to receive(:resolvable?).and_return(true)
-        end
-
-        context "when resolved" do
-          before do
-            allow(subject).to receive(:resolved?).and_return(true)
-          end
-
-          it "returns true" do
-            expect(subject.collapsed?).to be true
-          end
-        end
-
-        context "when not resolved" do
-          before do
-            allow(subject).to receive(:resolved?).and_return(false)
-          end
-
-          it "returns false" do
-            expect(subject.collapsed?).to be false
-          end
-        end
-      end
-
-      context "when not resolvable" do
-        before do
-          allow(subject).to receive(:resolvable?).and_return(false)
-        end
-
-        context "when active" do
-          before do
-            allow(subject).to receive(:active?).and_return(true)
-          end
-
-          it "returns false" do
-            expect(subject.collapsed?).to be false
-          end
-        end
-
-        context "when outdated" do
-          before do
-            allow(subject).to receive(:active?).and_return(false)
-          end
-
-          it "returns true" do
-            expect(subject.collapsed?).to be true
-          end
-        end
-      end
-    end
-
-    context "when not a diff discussion" do
-      before do
-        allow(subject).to receive(:diff_discussion?).and_return(false)
-      end
-
-      it "returns false" do
-        expect(subject.collapsed?).to be false
-      end
-    end
-  end
-
-  describe "#truncated_diff_lines" do
-    let(:truncated_lines) { subject.truncated_diff_lines }
-
-    context "when diff is greater than allowed number of truncated diff lines " do
-      it "returns fewer lines"  do
-        expect(subject.diff_lines.count).to be > described_class::NUMBER_OF_TRUNCATED_DIFF_LINES
-
-        expect(truncated_lines.count).to be <= described_class::NUMBER_OF_TRUNCATED_DIFF_LINES
-      end
-    end
-
-    context "when some diff lines are meta" do
-      it "returns no meta lines"  do
-        expect(subject.diff_lines).to include(be_meta)
-        expect(truncated_lines).not_to include(be_meta)
-      end
+  describe '.build_collection' do
+    it 'returns an array of discussions of the right type' do
+      discussions = described_class.build_collection([first_note, second_note, third_note], merge_request)
+      expect(discussions).to eq([
+        DiffDiscussion.new([first_note, second_note], merge_request),
+        DiffDiscussion.new([third_note], merge_request)
+      ])
     end
   end
 end
diff --git a/spec/models/environment_spec.rb b/spec/models/environment_spec.rb
index 9e00f2247e8..28e5c3f80f4 100644
--- a/spec/models/environment_spec.rb
+++ b/spec/models/environment_spec.rb
@@ -100,13 +100,28 @@ describe Environment, models: true do
     let(:head_commit)   { project.commit }
     let(:commit)        { project.commit.parent }
 
-    it 'returns deployment id for the environment' do
-      expect(environment.first_deployment_for(commit)).to eq deployment1
-    end
+    context 'Gitaly find_ref_name feature disabled' do
+      it 'returns deployment id for the environment' do
+        expect(environment.first_deployment_for(commit)).to eq deployment1
+      end
 
-    it 'return nil when no deployment is found' do
-      expect(environment.first_deployment_for(head_commit)).to eq nil
+      it 'return nil when no deployment is found' do
+        expect(environment.first_deployment_for(head_commit)).to eq nil
+      end
     end
+
+    # TODO: Uncomment when feature is reenabled
+    # context 'Gitaly find_ref_name feature enabled' do
+    #   before do
+    #     allow(Gitlab::GitalyClient).to receive(:feature_enabled?).with(:find_ref_name).and_return(true)
+    #   end
+    #
+    #   it 'calls GitalyClient' do
+    #     expect_any_instance_of(Gitlab::GitalyClient::Ref).to receive(:find_ref_name)
+    #
+    #     environment.first_deployment_for(commit)
+    #   end
+    # end
   end
 
   describe '#environment_type' do
diff --git a/spec/models/group_spec.rb b/spec/models/group_spec.rb
index 5d87938235a..8ffde6f7fbb 100644
--- a/spec/models/group_spec.rb
+++ b/spec/models/group_spec.rb
@@ -55,6 +55,8 @@ describe Group, models: true do
     it { is_expected.to validate_uniqueness_of(:name).scoped_to(:parent_id) }
     it { is_expected.to validate_presence_of :path }
     it { is_expected.not_to validate_presence_of :owner }
+    it { is_expected.to validate_presence_of :two_factor_grace_period }
+    it { is_expected.to validate_numericality_of(:two_factor_grace_period).is_greater_than_or_equal_to(0) }
   end
 
   describe '.visible_to_user' do
@@ -315,4 +317,44 @@ describe Group, models: true do
         to include(master.id, developer.id)
     end
   end
+
+  describe '#update_two_factor_requirement' do
+    let(:user) { create(:user) }
+
+    before do
+      group.add_user(user, GroupMember::OWNER)
+    end
+
+    it 'is called when require_two_factor_authentication is changed' do
+      expect_any_instance_of(User).to receive(:update_two_factor_requirement)
+
+      group.update!(require_two_factor_authentication: true)
+    end
+
+    it 'is called when two_factor_grace_period is changed' do
+      expect_any_instance_of(User).to receive(:update_two_factor_requirement)
+
+      group.update!(two_factor_grace_period: 23)
+    end
+
+    it 'is not called when other attributes are changed' do
+      expect_any_instance_of(User).not_to receive(:update_two_factor_requirement)
+
+      group.update!(description: 'foobar')
+    end
+
+    it 'calls #update_two_factor_requirement on each group member' do
+      other_user = create(:user)
+      group.add_user(other_user, GroupMember::OWNER)
+
+      calls = 0
+      allow_any_instance_of(User).to receive(:update_two_factor_requirement) do
+        calls += 1
+      end
+
+      group.update!(require_two_factor_authentication: true, two_factor_grace_period: 23)
+
+      expect(calls).to eq 2
+    end
+  end
 end
diff --git a/spec/models/issue_spec.rb b/spec/models/issue_spec.rb
index 4bdd46a581d..d057c9cf6e9 100644
--- a/spec/models/issue_spec.rb
+++ b/spec/models/issue_spec.rb
@@ -134,15 +134,6 @@ describe Issue, models: true do
     end
   end
 
-  describe '#is_being_reassigned?' do
-    it 'returns issues assigned to user' do
-      user = create(:user)
-      create_list(:issue, 2, assignee: user)
-
-      expect(Issue.open_for(user).count).to eq 2
-    end
-  end
-
   describe '#closed_by_merge_requests' do
     let(:project) { create(:project, :repository) }
     let(:issue) { create(:issue, project: project)}
diff --git a/spec/models/label_spec.rb b/spec/models/label_spec.rb
index a9139f7d4ab..80ca19acdda 100644
--- a/spec/models/label_spec.rb
+++ b/spec/models/label_spec.rb
@@ -42,11 +42,27 @@ describe Label, models: true do
     end
   end
 
+  describe '#color' do
+    it 'strips color' do
+      label = described_class.new(color: '   #abcdef   ')
+      label.valid?
+
+      expect(label.color).to eq('#abcdef')
+    end
+  end
+
   describe '#title' do
     it 'sanitizes title' do
       label = described_class.new(title: '<b>foo & bar?</b>')
       expect(label.title).to eq('foo & bar?')
     end
+
+    it 'strips title' do
+      label = described_class.new(title: '   label   ')
+      label.valid?
+
+      expect(label.title).to eq('label')
+    end
   end
 
   describe 'priorization' do
diff --git a/spec/models/legacy_diff_discussion_spec.rb b/spec/models/legacy_diff_discussion_spec.rb
new file mode 100644
index 00000000000..153e757a0ef
--- /dev/null
+++ b/spec/models/legacy_diff_discussion_spec.rb
@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe LegacyDiffDiscussion, models: true do
+  subject { create(:legacy_diff_note_on_merge_request).to_discussion }
+
+  describe '#reply_attributes' do
+    it 'includes line_code' do
+      expect(subject.reply_attributes[:line_code]).to eq(subject.line_code)
+    end
+  end
+end
diff --git a/spec/models/legacy_diff_note_spec.rb b/spec/models/legacy_diff_note_spec.rb
deleted file mode 100644
index 81517a18b74..00000000000
--- a/spec/models/legacy_diff_note_spec.rb
+++ /dev/null
@@ -1,101 +0,0 @@
-require 'spec_helper'
-
-describe LegacyDiffNote, models: true do
-  describe "Commit diff line notes" do
-    let!(:note) { create(:legacy_diff_note_on_commit, note: "+1 from me") }
-    let!(:commit) { note.noteable }
-
-    it "saves a valid note" do
-      expect(note.commit_id).to eq(commit.id)
-      expect(note.noteable.id).to eq(commit.id)
-    end
-
-    it "is recognized by #legacy_diff_note?" do
-      expect(note).to be_legacy_diff_note
-    end
-  end
-
-  describe '#active?' do
-    it 'is always true when the note has no associated diff line' do
-      note = build(:legacy_diff_note_on_merge_request)
-
-      expect(note).to receive(:diff_line).and_return(nil)
-
-      expect(note).to be_active
-    end
-
-    it 'is never true when the note has no noteable associated' do
-      note = build(:legacy_diff_note_on_merge_request)
-
-      expect(note).to receive(:diff_line).and_return(double)
-      expect(note).to receive(:noteable).and_return(nil)
-
-      expect(note).not_to be_active
-    end
-
-    it 'returns the memoized value if defined' do
-      note = build(:legacy_diff_note_on_merge_request)
-
-      note.instance_variable_set(:@active, 'foo')
-      expect(note).not_to receive(:find_noteable_diff)
-
-      expect(note.active?).to eq 'foo'
-    end
-
-    context 'for a merge request noteable' do
-      it 'is false when noteable has no matching diff' do
-        merge = build_stubbed(:merge_request, :simple)
-        note = build(:legacy_diff_note_on_merge_request, noteable: merge)
-
-        allow(note).to receive(:diff_line).and_return(double)
-        expect(note).to receive(:find_noteable_diff).and_return(nil)
-
-        expect(note).not_to be_active
-      end
-
-      it 'is true when noteable has a matching diff' do
-        merge = create(:merge_request, :simple)
-
-        # Generate a real line_code value so we know it will match. We use a
-        # random line from a random diff just for funsies.
-        diff = merge.raw_diffs.to_a.sample
-        line = Gitlab::Diff::Parser.new.parse(diff.diff.each_line).to_a.sample
-        code = Gitlab::Diff::LineCode.generate(diff.new_path, line.new_pos, line.old_pos)
-
-        # We're persisting in order to trigger the set_diff callback
-        note = create(:legacy_diff_note_on_merge_request,  noteable: merge,
-                                                           line_code: code,
-                                                           project: merge.source_project)
-
-        # Make sure we don't get a false positive from a guard clause
-        expect(note).to receive(:find_noteable_diff).and_call_original
-        expect(note).to be_active
-      end
-    end
-  end
-
-  describe "#discussion_id" do
-    let(:note) { create(:note) }
-
-    context "when it is newly created" do
-      it "has a discussion id" do
-        expect(note.discussion_id).not_to be_nil
-        expect(note.discussion_id).to match(/\A\h{40}\z/)
-      end
-    end
-
-    context "when it didn't store a discussion id before" do
-      before do
-        note.update_column(:discussion_id, nil)
-      end
-
-      it "has a discussion id" do
-        # The discussion_id is set in `after_initialize`, so `reload` won't work
-        reloaded_note = Note.find(note.id)
-
-        expect(reloaded_note.discussion_id).not_to be_nil
-        expect(reloaded_note.discussion_id).to match(/\A\h{40}\z/)
-      end
-    end
-  end
-end
diff --git a/spec/models/members/group_member_spec.rb b/spec/models/members/group_member_spec.rb
index 370aeb9e0a9..024380b7ebb 100644
--- a/spec/models/members/group_member_spec.rb
+++ b/spec/models/members/group_member_spec.rb
@@ -61,7 +61,7 @@ describe GroupMember, models: true do
 
     describe '#after_accept_request' do
       it 'calls NotificationService.accept_group_access_request' do
-        member = create(:group_member, user: build_stubbed(:user), requested_at: Time.now)
+        member = create(:group_member, user: build(:user), requested_at: Time.now)
 
         expect_any_instance_of(NotificationService).to receive(:new_group_member)
 
@@ -75,4 +75,19 @@ describe GroupMember, models: true do
       it { is_expected.to eq 'Group' }
     end
   end
+
+  describe '#update_two_factor_requirement' do
+    let(:user) { build :user }
+    let(:group_member) { build :group_member, user: user }
+
+    it 'is called after creation and deletion' do
+      expect(user).to receive(:update_two_factor_requirement)
+
+      group_member.save
+
+      expect(user).to receive(:update_two_factor_requirement)
+
+      group_member.destroy
+    end
+  end
 end
diff --git a/spec/models/merge_request_spec.rb b/spec/models/merge_request_spec.rb
index 24e7c1b17d9..90b3a2ba42d 100644
--- a/spec/models/merge_request_spec.rb
+++ b/spec/models/merge_request_spec.rb
@@ -441,7 +441,7 @@ describe MergeRequest, models: true do
     end
 
     it "can't be removed when its a protected branch" do
-      allow(subject.source_project).to receive(:protected_branch?).and_return(true)
+      allow(ProtectedBranch).to receive(:protected?).and_return(true)
       expect(subject.can_remove_source_branch?(user)).to be_falsey
     end
 
@@ -1224,182 +1224,6 @@ describe MergeRequest, models: true do
     end
   end
 
-  context "discussion status" do
-    let(:first_discussion) { Discussion.new([create(:diff_note_on_merge_request)]) }
-    let(:second_discussion) { Discussion.new([create(:diff_note_on_merge_request)]) }
-    let(:third_discussion) { Discussion.new([create(:diff_note_on_merge_request)]) }
-
-    before do
-      allow(subject).to receive(:diff_discussions).and_return([first_discussion, second_discussion, third_discussion])
-    end
-
-    describe '#resolvable_discussions' do
-      before do
-        allow(first_discussion).to receive(:to_be_resolved?).and_return(true)
-        allow(second_discussion).to receive(:to_be_resolved?).and_return(false)
-        allow(third_discussion).to receive(:to_be_resolved?).and_return(false)
-      end
-
-      it 'includes only discussions that need to be resolved' do
-        expect(subject.resolvable_discussions).to eq([first_discussion])
-      end
-    end
-
-    describe '#discussions_can_be_resolved_by? user' do
-      let(:user) { build(:user) }
-
-      context 'all discussions can be resolved by the user' do
-        before do
-          allow(first_discussion).to receive(:can_resolve?).with(user).and_return(true)
-          allow(second_discussion).to receive(:can_resolve?).with(user).and_return(true)
-          allow(third_discussion).to receive(:can_resolve?).with(user).and_return(true)
-        end
-
-        it 'allows a user to resolve the discussions' do
-          expect(subject.discussions_can_be_resolved_by?(user)).to be(true)
-        end
-      end
-
-      context 'one discussion cannot be resolved by the user' do
-        before do
-          allow(first_discussion).to receive(:can_resolve?).with(user).and_return(true)
-          allow(second_discussion).to receive(:can_resolve?).with(user).and_return(true)
-          allow(third_discussion).to receive(:can_resolve?).with(user).and_return(false)
-        end
-
-        it 'allows a user to resolve the discussions' do
-          expect(subject.discussions_can_be_resolved_by?(user)).to be(false)
-        end
-      end
-    end
-
-    describe "#discussions_resolvable?" do
-      context "when all discussions are unresolvable" do
-        before do
-          allow(first_discussion).to receive(:resolvable?).and_return(false)
-          allow(second_discussion).to receive(:resolvable?).and_return(false)
-          allow(third_discussion).to receive(:resolvable?).and_return(false)
-        end
-
-        it "returns false" do
-          expect(subject.discussions_resolvable?).to be false
-        end
-      end
-
-      context "when some discussions are unresolvable and some discussions are resolvable" do
-        before do
-          allow(first_discussion).to receive(:resolvable?).and_return(true)
-          allow(second_discussion).to receive(:resolvable?).and_return(false)
-          allow(third_discussion).to receive(:resolvable?).and_return(true)
-        end
-
-        it "returns true" do
-          expect(subject.discussions_resolvable?).to be true
-        end
-      end
-
-      context "when all discussions are resolvable" do
-        before do
-          allow(first_discussion).to receive(:resolvable?).and_return(true)
-          allow(second_discussion).to receive(:resolvable?).and_return(true)
-          allow(third_discussion).to receive(:resolvable?).and_return(true)
-        end
-
-        it "returns true" do
-          expect(subject.discussions_resolvable?).to be true
-        end
-      end
-    end
-
-    describe "#discussions_resolved?" do
-      context "when discussions are not resolvable" do
-        before do
-          allow(subject).to receive(:discussions_resolvable?).and_return(false)
-        end
-
-        it "returns false" do
-          expect(subject.discussions_resolved?).to be false
-        end
-      end
-
-      context "when discussions are resolvable" do
-        before do
-          allow(subject).to receive(:discussions_resolvable?).and_return(true)
-
-          allow(first_discussion).to receive(:resolvable?).and_return(true)
-          allow(second_discussion).to receive(:resolvable?).and_return(false)
-          allow(third_discussion).to receive(:resolvable?).and_return(true)
-        end
-
-        context "when all resolvable discussions are resolved" do
-          before do
-            allow(first_discussion).to receive(:resolved?).and_return(true)
-            allow(third_discussion).to receive(:resolved?).and_return(true)
-          end
-
-          it "returns true" do
-            expect(subject.discussions_resolved?).to be true
-          end
-        end
-
-        context "when some resolvable discussions are not resolved" do
-          before do
-            allow(first_discussion).to receive(:resolved?).and_return(true)
-            allow(third_discussion).to receive(:resolved?).and_return(false)
-          end
-
-          it "returns false" do
-            expect(subject.discussions_resolved?).to be false
-          end
-        end
-      end
-    end
-
-    describe "#discussions_to_be_resolved?" do
-      context "when discussions are not resolvable" do
-        before do
-          allow(subject).to receive(:discussions_resolvable?).and_return(false)
-        end
-
-        it "returns false" do
-          expect(subject.discussions_to_be_resolved?).to be false
-        end
-      end
-
-      context "when discussions are resolvable" do
-        before do
-          allow(subject).to receive(:discussions_resolvable?).and_return(true)
-
-          allow(first_discussion).to receive(:resolvable?).and_return(true)
-          allow(second_discussion).to receive(:resolvable?).and_return(false)
-          allow(third_discussion).to receive(:resolvable?).and_return(true)
-        end
-
-        context "when all resolvable discussions are resolved" do
-          before do
-            allow(first_discussion).to receive(:resolved?).and_return(true)
-            allow(third_discussion).to receive(:resolved?).and_return(true)
-          end
-
-          it "returns false" do
-            expect(subject.discussions_to_be_resolved?).to be false
-          end
-        end
-
-        context "when some resolvable discussions are not resolved" do
-          before do
-            allow(first_discussion).to receive(:resolved?).and_return(true)
-            allow(third_discussion).to receive(:resolved?).and_return(false)
-          end
-
-          it "returns true" do
-            expect(subject.discussions_to_be_resolved?).to be true
-          end
-        end
-      end
-    end
-  end
-
   describe '#conflicts_can_be_resolved_in_ui?' do
     def create_merge_request(source_branch)
       create(:merge_request, source_branch: source_branch, target_branch: 'conflict-start') do |mr|
diff --git a/spec/models/milestone_spec.rb b/spec/models/milestone_spec.rb
index f3f48f951a8..e3e8e6d571c 100644
--- a/spec/models/milestone_spec.rb
+++ b/spec/models/milestone_spec.rb
@@ -109,18 +109,6 @@ describe Milestone, models: true do
     it { expect(milestone.percent_complete(user)).to eq(75) }
   end
 
-  describe '#is_empty?' do
-    before do
-      milestone.issues << create(:issue, project: project)
-      milestone.issues << create(:closed_issue, project: project)
-      milestone.merge_requests << create(:merge_request)
-    end
-
-    it { expect(milestone.closed_items_count(user)).to eq(1) }
-    it { expect(milestone.total_items_count(user)).to eq(3) }
-    it { expect(milestone.is_empty?(user)).to be_falsey }
-  end
-
   describe '#can_be_closed?' do
     it { expect(milestone.can_be_closed?).to be_truthy }
   end
diff --git a/spec/models/namespace_spec.rb b/spec/models/namespace_spec.rb
index d9216112259..e406d0a16bd 100644
--- a/spec/models/namespace_spec.rb
+++ b/spec/models/namespace_spec.rb
@@ -148,18 +148,22 @@ describe Namespace, models: true do
       expect(@namespace.move_dir).to be_truthy
     end
 
-    context "when any project has container tags" do
+    context "when any project has container images" do
+      let(:container_repository) { create(:container_repository) }
+
       before do
         stub_container_registry_config(enabled: true)
-        stub_container_registry_tags('tag')
+        stub_container_registry_tags(repository: :any, tags: ['tag'])
 
-        create(:empty_project, namespace: @namespace)
+        create(:empty_project, namespace: @namespace, container_repositories: [container_repository])
 
         allow(@namespace).to receive(:path_was).and_return(@namespace.path)
         allow(@namespace).to receive(:path).and_return('new_path')
       end
 
-      it { expect { @namespace.move_dir }.to raise_error('Namespace cannot be moved, because at least one project has tags in container registry') }
+      it 'raises an error about not movable project' do
+        expect { @namespace.move_dir }.to raise_error(/Namespace cannot be moved/)
+      end
     end
 
     context 'with subgroups' do
diff --git a/spec/models/note_spec.rb b/spec/models/note_spec.rb
index 33536487c41..557ea97b008 100644
--- a/spec/models/note_spec.rb
+++ b/spec/models/note_spec.rb
@@ -245,14 +245,28 @@ describe Note, models: true do
     end
   end
 
+  describe '.find_discussion' do
+    let!(:note) { create(:discussion_note_on_merge_request) }
+    let!(:note2) { create(:discussion_note_on_merge_request, in_reply_to: note) }
+    let(:merge_request) { note.noteable }
+
+    it 'returns a discussion with multiple notes' do
+      discussion = merge_request.notes.find_discussion(note.discussion_id)
+
+      expect(discussion).not_to be_nil
+      expect(discussion.notes).to match_array([note, note2])
+      expect(discussion.first_note.discussion_id).to eq(note.discussion_id)
+    end
+  end
+
   describe ".grouped_diff_discussions" do
     let!(:merge_request) { create(:merge_request) }
     let(:project) { merge_request.project }
     let!(:active_diff_note1) { create(:diff_note_on_merge_request, project: project, noteable: merge_request) }
-    let!(:active_diff_note2) { create(:diff_note_on_merge_request, project: project, noteable: merge_request) }
+    let!(:active_diff_note2) { create(:diff_note_on_merge_request, project: project, noteable: merge_request, in_reply_to: active_diff_note1) }
     let!(:active_diff_note3) { create(:diff_note_on_merge_request, project: project, noteable: merge_request, position: active_position2) }
     let!(:outdated_diff_note1) { create(:diff_note_on_merge_request, project: project, noteable: merge_request, position: outdated_position) }
-    let!(:outdated_diff_note2) { create(:diff_note_on_merge_request, project: project, noteable: merge_request, position: outdated_position) }
+    let!(:outdated_diff_note2) { create(:diff_note_on_merge_request, project: project, noteable: merge_request, in_reply_to: outdated_diff_note1) }
 
     let(:active_position2) do
       Gitlab::Diff::Position.new(
@@ -277,7 +291,7 @@ describe Note, models: true do
     subject { merge_request.notes.grouped_diff_discussions }
 
     it "includes active discussions" do
-      discussions = subject.values
+      discussions = subject.values.flatten
 
       expect(discussions.count).to eq(2)
       expect(discussions.map(&:id)).to eq([active_diff_note1.discussion_id, active_diff_note3.discussion_id])
@@ -288,37 +302,12 @@ describe Note, models: true do
     end
 
     it "doesn't include outdated discussions" do
-      expect(subject.values.map(&:id)).not_to include(outdated_diff_note1.discussion_id)
+      expect(subject.values.flatten.map(&:id)).not_to include(outdated_diff_note1.discussion_id)
     end
 
     it "groups the discussions by line code" do
-      expect(subject[active_diff_note1.line_code].id).to eq(active_diff_note1.discussion_id)
-      expect(subject[active_diff_note3.line_code].id).to eq(active_diff_note3.discussion_id)
-    end
-  end
-
-  describe "#discussion_id" do
-    let(:note) { create(:note) }
-
-    context "when it is newly created" do
-      it "has a discussion id" do
-        expect(note.discussion_id).not_to be_nil
-        expect(note.discussion_id).to match(/\A\h{40}\z/)
-      end
-    end
-
-    context "when it didn't store a discussion id before" do
-      before do
-        note.update_column(:discussion_id, nil)
-      end
-
-      it "has a discussion id" do
-        # The discussion_id is set in `after_initialize`, so `reload` won't work
-        reloaded_note = Note.find(note.id)
-
-        expect(reloaded_note.discussion_id).not_to be_nil
-        expect(reloaded_note.discussion_id).to match(/\A\h{40}\z/)
-      end
+      expect(subject[active_diff_note1.line_code].first.id).to eq(active_diff_note1.discussion_id)
+      expect(subject[active_diff_note3.line_code].first.id).to eq(active_diff_note3.discussion_id)
     end
   end
 
@@ -388,15 +377,267 @@ describe Note, models: true do
     end
   end
 
+  describe '#can_be_discussion_note?' do
+    context 'for a note on a merge request' do
+      it 'returns true' do
+        note = build(:note_on_merge_request)
+
+        expect(note.can_be_discussion_note?).to be_truthy
+      end
+    end
+
+    context 'for a note on an issue' do
+      it 'returns true' do
+        note = build(:note_on_issue)
+
+        expect(note.can_be_discussion_note?).to be_truthy
+      end
+    end
+
+    context 'for a note on a commit' do
+      it 'returns true' do
+        note = build(:note_on_commit)
+
+        expect(note.can_be_discussion_note?).to be_truthy
+      end
+    end
+
+    context 'for a note on a snippet' do
+      it 'returns true' do
+        note = build(:note_on_project_snippet)
+
+        expect(note.can_be_discussion_note?).to be_truthy
+      end
+    end
+
+    context 'for a diff note on merge request' do
+      it 'returns false' do
+        note = build(:diff_note_on_merge_request)
+
+        expect(note.can_be_discussion_note?).to be_falsey
+      end
+    end
+
+    context 'for a diff note on commit' do
+      it 'returns false' do
+        note = build(:diff_note_on_commit)
+
+        expect(note.can_be_discussion_note?).to be_falsey
+      end
+    end
+
+    context 'for a discussion note' do
+      it 'returns false' do
+        note = build(:discussion_note_on_merge_request)
+
+        expect(note.can_be_discussion_note?).to be_falsey
+      end
+    end
+  end
+
+  describe '#discussion_class' do
+    let(:note) { build(:note_on_commit) }
+    let(:merge_request) { create(:merge_request) }
+
+    context 'when the note is displayed out of context' do
+      it 'returns OutOfContextDiscussion' do
+        expect(note.discussion_class(merge_request)).to be(OutOfContextDiscussion)
+      end
+    end
+
+    context 'when the note is displayed in the original context' do
+      it 'returns IndividualNoteDiscussion' do
+        expect(note.discussion_class(note.noteable)).to be(IndividualNoteDiscussion)
+      end
+    end
+  end
+
+  describe "#discussion_id" do
+    let(:note) { create(:note_on_commit) }
+
+    context "when it is newly created" do
+      it "has a discussion id" do
+        expect(note.discussion_id).not_to be_nil
+        expect(note.discussion_id).to match(/\A\h{40}\z/)
+      end
+    end
+
+    context "when it didn't store a discussion id before" do
+      before do
+        note.update_column(:discussion_id, nil)
+      end
+
+      it "has a discussion id" do
+        # The discussion_id is set in `after_initialize`, so `reload` won't work
+        reloaded_note = Note.find(note.id)
+
+        expect(reloaded_note.discussion_id).not_to be_nil
+        expect(reloaded_note.discussion_id).to match(/\A\h{40}\z/)
+      end
+    end
+
+    context 'when the note is displayed out of context' do
+      let(:merge_request) { create(:merge_request) }
+
+      it 'overrides the discussion id' do
+        expect(note.discussion_id(merge_request)).not_to eq(note.discussion_id)
+      end
+    end
+  end
+
+  describe '#to_discussion' do
+    subject { create(:discussion_note_on_merge_request) }
+    let!(:note2) { create(:discussion_note_on_merge_request, project: subject.project, noteable: subject.noteable, in_reply_to: subject) }
+
+    it "returns a discussion with just this note" do
+      discussion = subject.to_discussion
+
+      expect(discussion.id).to eq(subject.discussion_id)
+      expect(discussion.notes).to eq([subject])
+    end
+  end
+
+  describe "#discussion" do
+    let!(:note1) { create(:discussion_note_on_merge_request) }
+    let!(:note2) { create(:diff_note_on_merge_request, project: note1.project, noteable: note1.noteable) }
+
+    context 'when the note is part of a discussion' do
+      subject { create(:discussion_note_on_merge_request, project: note1.project, noteable: note1.noteable, in_reply_to: note1) }
+
+      it "returns the discussion this note is in" do
+        discussion = subject.discussion
+
+        expect(discussion.id).to eq(subject.discussion_id)
+        expect(discussion.notes).to eq([note1, subject])
+      end
+    end
+
+    context 'when the note is not part of a discussion' do
+      subject { create(:note) }
+
+      it "returns a discussion with just this note" do
+        discussion = subject.discussion
+
+        expect(discussion.id).to eq(subject.discussion_id)
+        expect(discussion.notes).to eq([subject])
+      end
+    end
+  end
+
+  describe "#part_of_discussion?" do
+    context 'for a regular note' do
+      let(:note) { build(:note) }
+
+      it 'returns false' do
+        expect(note.part_of_discussion?).to be_falsey
+      end
+    end
+
+    context 'for a diff note' do
+      let(:note) { build(:diff_note_on_commit) }
+
+      it 'returns true' do
+        expect(note.part_of_discussion?).to be_truthy
+      end
+    end
+
+    context 'for a discussion note' do
+      let(:note) { build(:discussion_note_on_merge_request) }
+
+      it 'returns true' do
+        expect(note.part_of_discussion?).to be_truthy
+      end
+    end
+  end
+
+  describe '#in_reply_to?' do
+    context 'for a note' do
+      context 'when part of a discussion' do
+        subject { create(:discussion_note_on_issue) }
+        let(:note) { create(:discussion_note_on_issue, in_reply_to: subject) }
+
+        it 'checks if the note is in reply to the other discussion' do
+          expect(subject).to receive(:in_reply_to?).with(note).and_call_original
+          expect(subject).to receive(:in_reply_to?).with(note.noteable).and_call_original
+          expect(subject).to receive(:in_reply_to?).with(note.to_discussion).and_call_original
+
+          subject.in_reply_to?(note)
+        end
+      end
+
+      context 'when not part of a discussion' do
+        subject { create(:note) }
+        let(:note) { create(:note, in_reply_to: subject) }
+
+        it 'checks if the note is in reply to the other noteable' do
+          expect(subject).to receive(:in_reply_to?).with(note).and_call_original
+          expect(subject).to receive(:in_reply_to?).with(note.noteable).and_call_original
+
+          subject.in_reply_to?(note)
+        end
+      end
+    end
+
+    context 'for a discussion' do
+      context 'when part of the same discussion' do
+        subject { create(:diff_note_on_merge_request) }
+        let(:note) { create(:diff_note_on_merge_request, in_reply_to: subject) }
+
+        it 'returns true' do
+          expect(subject.in_reply_to?(note.to_discussion)).to be_truthy
+        end
+      end
+
+      context 'when not part of the same discussion' do
+        subject { create(:diff_note_on_merge_request) }
+        let(:note) { create(:diff_note_on_merge_request) }
+
+        it 'returns false' do
+          expect(subject.in_reply_to?(note.to_discussion)).to be_falsey
+        end
+      end
+    end
+
+    context 'for a noteable' do
+      context 'when a comment on the same noteable' do
+        subject { create(:note) }
+        let(:note) { create(:note, in_reply_to: subject) }
+
+        it 'returns true' do
+          expect(subject.in_reply_to?(note.noteable)).to be_truthy
+        end
+      end
+
+      context 'when not a comment on the same noteable' do
+        subject { create(:note) }
+        let(:note) { create(:note) }
+
+        it 'returns false' do
+          expect(subject.in_reply_to?(note.noteable)).to be_falsey
+        end
+      end
+    end
+  end
+
   describe 'expiring ETag cache' do
     let(:note) { build(:note_on_issue) }
 
-    it "expires cache for note's issue when note is saved" do
+    def expect_expiration(note)
       expect_any_instance_of(Gitlab::EtagCaching::Store)
         .to receive(:touch)
         .with("/#{note.project.namespace.to_param}/#{note.project.to_param}/noteable/issue/#{note.noteable.id}/notes")
+    end
+
+    it "expires cache for note's issue when note is saved" do
+      expect_expiration(note)
 
       note.save!
     end
+
+    it "expires cache for note's issue when note is destroyed" do
+      expect_expiration(note)
+
+      note.destroy!
+    end
   end
 end
diff --git a/spec/models/project_services/chat_message/issue_message_spec.rb b/spec/models/project_services/chat_message/issue_message_spec.rb
index 190ff4c535d..34e2d94b1ed 100644
--- a/spec/models/project_services/chat_message/issue_message_spec.rb
+++ b/spec/models/project_services/chat_message/issue_message_spec.rb
@@ -7,7 +7,8 @@ describe ChatMessage::IssueMessage, models: true do
     {
       user: {
         name: 'Test User',
-        username: 'test.user'
+        username: 'test.user',
+        avatar_url: 'http://someavatar.com'
       },
       project_name: 'project_name',
       project_url: 'http://somewhere.com',
@@ -25,43 +26,84 @@ describe ChatMessage::IssueMessage, models: true do
     }
   end
 
-  let(:color) { '#C95823' }
+  context 'without markdown' do
+    let(:color) { '#C95823' }
 
-  context '#initialize' do
-    before do
-      args[:object_attributes][:description] = nil
+    context '#initialize' do
+      before do
+        args[:object_attributes][:description] = nil
+      end
+
+      it 'returns a non-null description' do
+        expect(subject.description).to eq('')
+      end
     end
 
-    it 'returns a non-null description' do
-      expect(subject.description).to eq('')
+    context 'open' do
+      it 'returns a message regarding opening of issues' do
+        expect(subject.pretext).to eq(
+          '[<http://somewhere.com|project_name>] Issue opened by test.user')
+        expect(subject.attachments).to eq([
+          {
+            title: "#100 Issue title",
+            title_link: "http://url.com",
+            text: "issue description",
+            color: color,
+          }
+        ])
+      end
     end
-  end
 
-  context 'open' do
-    it 'returns a message regarding opening of issues' do
-      expect(subject.pretext).to eq(
-        '[<http://somewhere.com|project_name>] Issue opened by test.user')
-      expect(subject.attachments).to eq([
-        {
-          title: "#100 Issue title",
-          title_link: "http://url.com",
-          text: "issue description",
-          color: color,
-        }
-      ])
+    context 'close' do
+      before do
+        args[:object_attributes][:action] = 'close'
+        args[:object_attributes][:state] = 'closed'
+      end
+
+      it 'returns a message regarding closing of issues' do
+        expect(subject.pretext). to eq(
+          '[<http://somewhere.com|project_name>] Issue <http://url.com|#100 Issue title> closed by test.user')
+        expect(subject.attachments).to be_empty
+      end
     end
   end
 
-  context 'close' do
+  context 'with markdown' do
     before do
-      args[:object_attributes][:action] = 'close'
-      args[:object_attributes][:state] = 'closed'
+      args[:markdown] = true
     end
 
-    it 'returns a message regarding closing of issues' do
-      expect(subject.pretext). to eq(
-        '[<http://somewhere.com|project_name>] Issue <http://url.com|#100 Issue title> closed by test.user')
-      expect(subject.attachments).to be_empty
+    context 'open' do
+      it 'returns a message regarding opening of issues' do
+        expect(subject.pretext).to eq(
+          '[[project_name](http://somewhere.com)] Issue opened by test.user')
+        expect(subject.attachments).to eq('issue description')
+        expect(subject.activity).to eq({
+          title: 'Issue opened by test.user',
+          subtitle: 'in [project_name](http://somewhere.com)',
+          text: '[#100 Issue title](http://url.com)',
+          image: 'http://someavatar.com'
+        })
+      end
+    end
+
+    context 'close' do
+      before do
+        args[:object_attributes][:action] = 'close'
+        args[:object_attributes][:state] = 'closed'
+      end
+
+      it 'returns a message regarding closing of issues' do
+        expect(subject.pretext). to eq(
+          '[[project_name](http://somewhere.com)] Issue [#100 Issue title](http://url.com) closed by test.user')
+        expect(subject.attachments).to be_empty
+        expect(subject.activity).to eq({
+          title: 'Issue closed by test.user',
+          subtitle: 'in [project_name](http://somewhere.com)',
+          text: '[#100 Issue title](http://url.com)',
+          image: 'http://someavatar.com'
+        })
+      end
     end
   end
 end
diff --git a/spec/models/project_services/chat_message/merge_message_spec.rb b/spec/models/project_services/chat_message/merge_message_spec.rb
index cc154112e90..fa0a1f4a5b7 100644
--- a/spec/models/project_services/chat_message/merge_message_spec.rb
+++ b/spec/models/project_services/chat_message/merge_message_spec.rb
@@ -7,45 +7,84 @@ describe ChatMessage::MergeMessage, models: true do
     {
       user: {
           name: 'Test User',
-          username: 'test.user'
+          username: 'test.user',
+          avatar_url: 'http://someavatar.com'
       },
       project_name: 'project_name',
       project_url: 'http://somewhere.com',
 
       object_attributes: {
-        title: "Issue title\nSecond line",
+        title: "Merge Request title\nSecond line",
         id: 10,
         iid: 100,
         assignee_id: 1,
         url: 'http://url.com',
         state: 'opened',
-        description: 'issue description',
+        description: 'merge request description',
         source_branch: 'source_branch',
         target_branch: 'target_branch',
       }
     }
   end
 
-  let(:color) { '#345' }
+  context 'without markdown' do
+    let(:color) { '#345' }
 
-  context 'open' do
-    it 'returns a message regarding opening of merge requests' do
-      expect(subject.pretext).to eq(
-        'test.user opened <http://somewhere.com/merge_requests/100|merge request !100> '\
-        'in <http://somewhere.com|project_name>: *Issue title*')
-      expect(subject.attachments).to be_empty
+    context 'open' do
+      it 'returns a message regarding opening of merge requests' do
+        expect(subject.pretext).to eq(
+          'test.user opened <http://somewhere.com/merge_requests/100|!100 *Merge Request title*> in <http://somewhere.com|project_name>: *Merge Request title*')
+        expect(subject.attachments).to be_empty
+      end
+    end
+
+    context 'close' do
+      before do
+        args[:object_attributes][:state] = 'closed'
+      end
+      it 'returns a message regarding closing of merge requests' do
+        expect(subject.pretext).to eq(
+          'test.user closed <http://somewhere.com/merge_requests/100|!100 *Merge Request title*> in <http://somewhere.com|project_name>: *Merge Request title*')
+        expect(subject.attachments).to be_empty
+      end
     end
   end
 
-  context 'close' do
+  context 'with markdown' do
     before do
-      args[:object_attributes][:state] = 'closed'
+      args[:markdown] = true
+    end
+
+    context 'open' do
+      it 'returns a message regarding opening of merge requests' do
+        expect(subject.pretext).to eq(
+          'test.user opened [!100 *Merge Request title*](http://somewhere.com/merge_requests/100) in [project_name](http://somewhere.com): *Merge Request title*')
+        expect(subject.attachments).to be_empty
+        expect(subject.activity).to eq({
+          title: 'Merge Request opened by test.user',
+          subtitle: 'in [project_name](http://somewhere.com)',
+          text: '[!100 *Merge Request title*](http://somewhere.com/merge_requests/100)',
+          image: 'http://someavatar.com'
+        })
+      end
     end
-    it 'returns a message regarding closing of merge requests' do
-      expect(subject.pretext).to eq(
-        'test.user closed <http://somewhere.com/merge_requests/100|merge request !100> '\
-        'in <http://somewhere.com|project_name>: *Issue title*')
-      expect(subject.attachments).to be_empty
+
+    context 'close' do
+      before do
+        args[:object_attributes][:state] = 'closed'
+      end
+
+      it 'returns a message regarding closing of merge requests' do
+        expect(subject.pretext).to eq(
+          'test.user closed [!100 *Merge Request title*](http://somewhere.com/merge_requests/100) in [project_name](http://somewhere.com): *Merge Request title*')
+        expect(subject.attachments).to be_empty
+        expect(subject.activity).to eq({
+          title: 'Merge Request closed by test.user',
+          subtitle: 'in [project_name](http://somewhere.com)',
+          text: '[!100 *Merge Request title*](http://somewhere.com/merge_requests/100)',
+          image: 'http://someavatar.com'
+        })
+      end
     end
   end
 end
diff --git a/spec/models/project_services/chat_message/note_message_spec.rb b/spec/models/project_services/chat_message/note_message_spec.rb
index da700a08e57..7cd9c61ee2b 100644
--- a/spec/models/project_services/chat_message/note_message_spec.rb
+++ b/spec/models/project_services/chat_message/note_message_spec.rb
@@ -1,130 +1,190 @@
 require 'spec_helper'
 
 describe ChatMessage::NoteMessage, models: true do
-  let(:color) { '#345' }
+  subject { described_class.new(args) }
 
-  before do
-    @args = {
-        user: {
-            name: 'Test User',
-            username: 'test.user',
-            avatar_url: 'http://fakeavatar'
-        },
-        project_name: 'project_name',
-        project_url: 'http://somewhere.com',
-        repository: {
-            name: 'project_name',
-            url: 'http://somewhere.com',
-        },
-        object_attributes: {
-            id: 10,
-            note: 'comment on a commit',
-            url: 'http://url.com',
-            noteable_type: 'Commit'
-        }
+  let(:color) { '#345' }
+  let(:args) do
+    {
+      user: {
+        name: 'Test User',
+        username: 'test.user',
+        avatar_url: 'http://fakeavatar'
+      },
+      project_name: 'project_name',
+      project_url: 'http://somewhere.com',
+      repository: {
+        name: 'project_name',
+        url: 'http://somewhere.com',
+      },
+      object_attributes: {
+        id: 10,
+        note: 'comment on a commit',
+        url: 'http://url.com',
+        noteable_type: 'Commit'
+      }
     }
   end
 
   context 'commit notes' do
     before do
-      @args[:object_attributes][:note] = 'comment on a commit'
-      @args[:object_attributes][:noteable_type] = 'Commit'
-      @args[:commit] = {
-          id: '5f163b2b95e6f53cbd428f5f0b103702a52b9a23',
-          message: "Added a commit message\ndetails\n123\n"
+      args[:object_attributes][:note] = 'comment on a commit'
+      args[:object_attributes][:noteable_type] = 'Commit'
+      args[:commit] = {
+        id: '5f163b2b95e6f53cbd428f5f0b103702a52b9a23',
+        message: "Added a commit message\ndetails\n123\n"
       }
     end
 
-    it 'returns a message regarding notes on commits' do
-      message = described_class.new(@args)
-      expect(message.pretext).to eq("test.user <http://url.com|commented on " \
-      "commit 5f163b2b> in <http://somewhere.com|project_name>: " \
-      "*Added a commit message*")
-      expected_attachments = [
-          {
-              text: "comment on a commit",
-              color: color,
-          }
-      ]
-      expect(message.attachments).to eq(expected_attachments)
+    context 'without markdown' do
+      it 'returns a message regarding notes on commits' do
+        expect(subject.pretext).to eq("test.user <http://url.com|commented on " \
+          "commit 5f163b2b> in <http://somewhere.com|project_name>: " \
+          "*Added a commit message*")
+        expect(subject.attachments).to eq([{
+          text: 'comment on a commit',
+          color: color
+        }])
+      end
+    end
+
+    context 'with markdown' do
+      before do
+        args[:markdown] = true
+      end
+
+      it 'returns a message regarding notes on commits' do
+        expect(subject.pretext).to eq(
+          'test.user [commented on commit 5f163b2b](http://url.com) in [project_name](http://somewhere.com): *Added a commit message*'
+        )
+        expect(subject.attachments).to eq('comment on a commit')
+        expect(subject.activity).to eq({
+          title: 'test.user [commented on commit 5f163b2b](http://url.com)',
+          subtitle: 'in [project_name](http://somewhere.com)',
+          text: 'Added a commit message',
+          image: 'http://fakeavatar'
+        })
+      end
     end
   end
 
   context 'merge request notes' do
     before do
-      @args[:object_attributes][:note] = 'comment on a merge request'
-      @args[:object_attributes][:noteable_type] = 'MergeRequest'
-      @args[:merge_request] = {
-          id: 1,
-          iid: 30,
-          title: "merge request title\ndetails\n"
+      args[:object_attributes][:note] = 'comment on a merge request'
+      args[:object_attributes][:noteable_type] = 'MergeRequest'
+      args[:merge_request] = {
+        id: 1,
+        iid: 30,
+        title: "merge request title\ndetails\n"
       }
     end
 
-    it 'returns a message regarding notes on a merge request' do
-      message = described_class.new(@args)
-      expect(message.pretext).to eq("test.user <http://url.com|commented on " \
-      "merge request !30> in <http://somewhere.com|project_name>: " \
-      "*merge request title*")
-      expected_attachments = [
-          {
-              text: "comment on a merge request",
-              color: color,
-          }
-      ]
-      expect(message.attachments).to eq(expected_attachments)
+    context 'without markdown' do
+      it 'returns a message regarding notes on a merge request' do
+        expect(subject.pretext).to eq("test.user <http://url.com|commented on " \
+          "merge request !30> in <http://somewhere.com|project_name>: " \
+          "*merge request title*")
+        expect(subject.attachments).to eq([{
+          text: 'comment on a merge request',
+          color: color
+        }])
+      end
+    end
+
+    context 'with markdown' do
+      before do
+        args[:markdown] = true
+      end
+
+      it 'returns a message regarding notes on a merge request' do
+        expect(subject.pretext).to eq(
+          'test.user [commented on merge request !30](http://url.com) in [project_name](http://somewhere.com): *merge request title*')
+        expect(subject.attachments).to eq('comment on a merge request')
+        expect(subject.activity).to eq({
+          title: 'test.user [commented on merge request !30](http://url.com)',
+          subtitle: 'in [project_name](http://somewhere.com)',
+          text: 'merge request title',
+          image: 'http://fakeavatar'
+        })
+      end
     end
   end
 
   context 'issue notes' do
     before do
-      @args[:object_attributes][:note] = 'comment on an issue'
-      @args[:object_attributes][:noteable_type] = 'Issue'
-      @args[:issue] = {
-          id: 1,
-          iid: 20,
-          title: "issue title\ndetails\n"
+      args[:object_attributes][:note] = 'comment on an issue'
+      args[:object_attributes][:noteable_type] = 'Issue'
+      args[:issue] = {
+        id: 1,
+        iid: 20,
+        title: "issue title\ndetails\n"
       }
     end
 
-    it 'returns a message regarding notes on an issue' do
-      message = described_class.new(@args)
-      expect(message.pretext).to eq(
-        "test.user <http://url.com|commented on " \
-        "issue #20> in <http://somewhere.com|project_name>: " \
-        "*issue title*")
-      expected_attachments = [
-          {
-              text: "comment on an issue",
-              color: color,
-          }
-      ]
-      expect(message.attachments).to eq(expected_attachments)
+    context 'without markdown' do
+      it 'returns a message regarding notes on an issue' do
+        expect(subject.pretext).to eq(
+          "test.user <http://url.com|commented on " \
+            "issue #20> in <http://somewhere.com|project_name>: " \
+            "*issue title*")
+        expect(subject.attachments).to eq([{
+          text: 'comment on an issue',
+          color: color
+        }])
+      end
+    end
+
+    context 'with markdown' do
+      before do
+        args[:markdown] = true
+      end
+
+      it 'returns a message regarding notes on an issue' do
+        expect(subject.pretext).to eq(
+          'test.user [commented on issue #20](http://url.com) in [project_name](http://somewhere.com): *issue title*')
+        expect(subject.attachments).to eq('comment on an issue')
+        expect(subject.activity).to eq({
+          title: 'test.user [commented on issue #20](http://url.com)',
+          subtitle: 'in [project_name](http://somewhere.com)',
+          text: 'issue title',
+          image: 'http://fakeavatar'
+        })
+      end
     end
   end
 
   context 'project snippet notes' do
     before do
-      @args[:object_attributes][:note] = 'comment on a snippet'
-      @args[:object_attributes][:noteable_type] = 'Snippet'
-      @args[:snippet] = {
-          id: 5,
-          title: "snippet title\ndetails\n"
+      args[:object_attributes][:note] = 'comment on a snippet'
+      args[:object_attributes][:noteable_type] = 'Snippet'
+      args[:snippet] = {
+        id: 5,
+        title: "snippet title\ndetails\n"
       }
     end
 
-    it 'returns a message regarding notes on a project snippet' do
-      message = described_class.new(@args)
-      expect(message.pretext).to eq("test.user <http://url.com|commented on " \
-      "snippet #5> in <http://somewhere.com|project_name>: " \
-      "*snippet title*")
-      expected_attachments = [
-          {
-              text: "comment on a snippet",
-              color: color,
-          }
-      ]
-      expect(message.attachments).to eq(expected_attachments)
+    context 'without markdown' do
+      it 'returns a message regarding notes on a project snippet' do
+        expect(subject.pretext).to eq("test.user <http://url.com|commented on " \
+          "snippet $5> in <http://somewhere.com|project_name>: " \
+          "*snippet title*")
+        expect(subject.attachments).to eq([{
+          text: 'comment on a snippet',
+          color: color
+        }])
+      end
+    end
+
+    context 'with markdown' do
+      before do
+        args[:markdown] = true
+      end
+
+      it 'returns a message regarding notes on a project snippet' do
+        expect(subject.pretext).to eq(
+          'test.user [commented on snippet $5](http://url.com) in [project_name](http://somewhere.com): *snippet title*')
+        expect(subject.attachments).to eq('comment on a snippet')
+      end
     end
   end
 end
diff --git a/spec/models/project_services/chat_message/pipeline_message_spec.rb b/spec/models/project_services/chat_message/pipeline_message_spec.rb
index bf2a9616455..ec5c6c5e0ed 100644
--- a/spec/models/project_services/chat_message/pipeline_message_spec.rb
+++ b/spec/models/project_services/chat_message/pipeline_message_spec.rb
@@ -2,8 +2,8 @@ require 'spec_helper'
 
 describe ChatMessage::PipelineMessage do
   subject { described_class.new(args) }
-  let(:user) { { name: 'hacker' } }
 
+  let(:user) { { name: 'hacker' } }
   let(:args) do
     {
       object_attributes: {
@@ -14,54 +14,122 @@ describe ChatMessage::PipelineMessage do
         status: status,
         duration: duration
       },
-      project: { path_with_namespace: 'project_name',
-                 web_url: 'http://example.gitlab.com' },
+      project: {
+        path_with_namespace: 'project_name',
+        web_url: 'http://example.gitlab.com'
+      },
       user: user
     }
   end
 
-  let(:message) { build_message }
+  context 'without markdown' do
+    context 'pipeline succeeded' do
+      let(:status) { 'success' }
+      let(:color) { 'good' }
+      let(:duration) { 10 }
+      let(:message) { build_message('passed') }
+
+      it 'returns a message with information about succeeded build' do
+        expect(subject.pretext).to be_empty
+        expect(subject.fallback).to eq(message)
+        expect(subject.attachments).to eq([text: message, color: color])
+      end
+    end
 
-  context 'pipeline succeeded' do
-    let(:status) { 'success' }
-    let(:color) { 'good' }
-    let(:duration) { 10 }
-    let(:message) { build_message('passed') }
+    context 'pipeline failed' do
+      let(:status) { 'failed' }
+      let(:color) { 'danger' }
+      let(:duration) { 10 }
+      let(:message) { build_message }
 
-    it 'returns a message with information about succeeded build' do
-      verify_message
+      it 'returns a message with information about failed build' do
+        expect(subject.pretext).to be_empty
+        expect(subject.fallback).to eq(message)
+        expect(subject.attachments).to eq([text: message, color: color])
+      end
+
+      context 'when triggered by API therefore lacking user' do
+        let(:user) { nil }
+        let(:message) { build_message(status, 'API') }
+
+        it 'returns a message stating it is by API' do
+          expect(subject.pretext).to be_empty
+          expect(subject.fallback).to eq(message)
+          expect(subject.attachments).to eq([text: message, color: color])
+        end
+      end
     end
-  end
 
-  context 'pipeline failed' do
-    let(:status) { 'failed' }
-    let(:color) { 'danger' }
-    let(:duration) { 10 }
+    def build_message(status_text = status, name = user[:name])
+      "<http://example.gitlab.com|project_name>:" \
+        " Pipeline <http://example.gitlab.com/pipelines/123|#123>" \
+        " of <http://example.gitlab.com/commits/develop|develop> branch" \
+        " by #{name} #{status_text} in #{duration} #{'second'.pluralize(duration)}"
+    end
+  end
 
-    it 'returns a message with information about failed build' do
-      verify_message
+  context 'with markdown' do
+    before do
+      args[:markdown] = true
     end
 
-    context 'when triggered by API therefore lacking user' do
-      let(:user) { nil }
-      let(:message) { build_message(status, 'API') }
+    context 'pipeline succeeded' do
+      let(:status) { 'success' }
+      let(:color) { 'good' }
+      let(:duration) { 10 }
+      let(:message) { build_markdown_message('passed') }
 
-      it 'returns a message stating it is by API' do
-        verify_message
+      it 'returns a message with information about succeeded build' do
+        expect(subject.pretext).to be_empty
+        expect(subject.attachments).to eq(message)
+        expect(subject.activity).to eq({
+          title: 'Pipeline [#123](http://example.gitlab.com/pipelines/123) of [develop](http://example.gitlab.com/commits/develop) branch by hacker passed',
+          subtitle: 'in [project_name](http://example.gitlab.com)',
+          text: 'in 10 seconds',
+          image: ''
+        })
       end
     end
-  end
 
-  def verify_message
-    expect(subject.pretext).to be_empty
-    expect(subject.fallback).to eq(message)
-    expect(subject.attachments).to eq([text: message, color: color])
-  end
+    context 'pipeline failed' do
+      let(:status) { 'failed' }
+      let(:color) { 'danger' }
+      let(:duration) { 10 }
+      let(:message) { build_markdown_message }
+
+      it 'returns a message with information about failed build' do
+        expect(subject.pretext).to be_empty
+        expect(subject.attachments).to eq(message)
+        expect(subject.activity).to eq({
+          title: 'Pipeline [#123](http://example.gitlab.com/pipelines/123) of [develop](http://example.gitlab.com/commits/develop) branch by hacker failed',
+          subtitle: 'in [project_name](http://example.gitlab.com)',
+          text: 'in 10 seconds',
+          image: ''
+        })
+      end
 
-  def build_message(status_text = status, name = user[:name])
-    "<http://example.gitlab.com|project_name>:" \
-    " Pipeline <http://example.gitlab.com/pipelines/123|#123>" \
-    " of <http://example.gitlab.com/commits/develop|develop> branch" \
-    " by #{name} #{status_text} in #{duration} #{'second'.pluralize(duration)}"
+      context 'when triggered by API therefore lacking user' do
+        let(:user) { nil }
+        let(:message) { build_markdown_message(status, 'API') }
+
+        it 'returns a message stating it is by API' do
+          expect(subject.pretext).to be_empty
+          expect(subject.attachments).to eq(message)
+          expect(subject.activity).to eq({
+            title: 'Pipeline [#123](http://example.gitlab.com/pipelines/123) of [develop](http://example.gitlab.com/commits/develop) branch by API failed',
+            subtitle: 'in [project_name](http://example.gitlab.com)',
+            text: 'in 10 seconds',
+            image: ''
+          })
+        end
+      end
+    end
+
+    def build_markdown_message(status_text = status, name = user[:name])
+      "[project_name](http://example.gitlab.com):" \
+        " Pipeline [#123](http://example.gitlab.com/pipelines/123)" \
+        " of [develop](http://example.gitlab.com/commits/develop)" \
+        " branch by #{name} #{status_text} in #{duration} #{'second'.pluralize(duration)}"
+    end
   end
 end
diff --git a/spec/models/project_services/chat_message/push_message_spec.rb b/spec/models/project_services/chat_message/push_message_spec.rb
index 24928873bad..63eb078c44e 100644
--- a/spec/models/project_services/chat_message/push_message_spec.rb
+++ b/spec/models/project_services/chat_message/push_message_spec.rb
@@ -10,6 +10,7 @@ describe ChatMessage::PushMessage, models: true do
       project_name: 'project_name',
       ref: 'refs/heads/master',
       user_name: 'test.user',
+      user_avatar: 'http://someavatar.com',
       project_url: 'http://url.com'
     }
   end
@@ -24,18 +25,36 @@ describe ChatMessage::PushMessage, models: true do
       ]
     end
 
-    it 'returns a message regarding pushes' do
-      expect(subject.pretext).to eq(
-        'test.user pushed to branch <http://url.com/commits/master|master> of '\
-        '<http://url.com|project_name> (<http://url.com/compare/before...after|Compare changes>)'
-      )
-      expect(subject.attachments).to eq([
-        {
-          text: "<http://url1.com|abcdefgh>: message1 - author1\n"\
-                "<http://url2.com|12345678>: message2 - author2",
+    context 'without markdown' do
+      it 'returns a message regarding pushes' do
+        expect(subject.pretext).to eq(
+          'test.user pushed to branch <http://url.com/commits/master|master> of '\
+            '<http://url.com|project_name> (<http://url.com/compare/before...after|Compare changes>)')
+        expect(subject.attachments).to eq([{
+          text: "<http://url1.com|abcdefgh>: message1 - author1\n\n"\
+            "<http://url2.com|12345678>: message2 - author2",
           color: color,
-        }
-      ])
+        }])
+      end
+    end
+
+    context 'with markdown' do
+      before do
+        args[:markdown] = true
+      end
+
+      it 'returns a message regarding pushes' do
+        expect(subject.pretext).to eq(
+          'test.user pushed to branch [master](http://url.com/commits/master) of [project_name](http://url.com) ([Compare changes](http://url.com/compare/before...after))')
+        expect(subject.attachments).to eq(
+          "[abcdefgh](http://url1.com): message1 - author1\n\n[12345678](http://url2.com): message2 - author2")
+        expect(subject.activity).to eq({
+          title: 'test.user pushed to branch',
+          subtitle: 'in [project_name](http://url.com)',
+          text: '[Compare changes](http://url.com/compare/before...after)',
+          image: 'http://someavatar.com'
+        })
+      end
     end
   end
 
@@ -47,15 +66,36 @@ describe ChatMessage::PushMessage, models: true do
         project_name: 'project_name',
         ref: 'refs/tags/new_tag',
         user_name: 'test.user',
+        user_avatar: 'http://someavatar.com',
         project_url: 'http://url.com'
       }
     end
 
-    it 'returns a message regarding pushes' do
-      expect(subject.pretext).to eq('test.user pushed new tag ' \
-                                    '<http://url.com/commits/new_tag|new_tag> to ' \
-                                    '<http://url.com|project_name>')
-      expect(subject.attachments).to be_empty
+    context 'without markdown' do
+      it 'returns a message regarding pushes' do
+        expect(subject.pretext).to eq('test.user pushed new tag ' \
+          '<http://url.com/commits/new_tag|new_tag> to ' \
+          '<http://url.com|project_name>')
+        expect(subject.attachments).to be_empty
+      end
+    end
+
+    context 'with markdown' do
+      before do
+        args[:markdown] = true
+      end
+
+      it 'returns a message regarding pushes' do
+        expect(subject.pretext).to eq(
+          'test.user pushed new tag [new_tag](http://url.com/commits/new_tag) to [project_name](http://url.com)')
+        expect(subject.attachments).to be_empty
+        expect(subject.activity).to eq({
+          title: 'test.user created tag',
+          subtitle: 'in [project_name](http://url.com)',
+          text: '[Compare changes](http://url.com/compare/0000000000000000000000000000000000000000...after)',
+          image: 'http://someavatar.com'
+        })
+      end
     end
   end
 
@@ -64,12 +104,31 @@ describe ChatMessage::PushMessage, models: true do
       args[:before] = Gitlab::Git::BLANK_SHA
     end
 
-    it 'returns a message regarding a new branch' do
-      expect(subject.pretext).to eq(
-        'test.user pushed new branch <http://url.com/commits/master|master> to '\
-        '<http://url.com|project_name>'
-      )
-      expect(subject.attachments).to be_empty
+    context 'without markdown' do
+      it 'returns a message regarding a new branch' do
+        expect(subject.pretext).to eq(
+          'test.user pushed new branch <http://url.com/commits/master|master> to '\
+            '<http://url.com|project_name>')
+        expect(subject.attachments).to be_empty
+      end
+    end
+
+    context 'with markdown' do
+      before do
+        args[:markdown] = true
+      end
+
+      it 'returns a message regarding a new branch' do
+        expect(subject.pretext).to eq(
+          'test.user pushed new branch [master](http://url.com/commits/master) to [project_name](http://url.com)')
+        expect(subject.attachments).to be_empty
+        expect(subject.activity).to eq({
+          title: 'test.user created branch',
+          subtitle: 'in [project_name](http://url.com)',
+          text: '[Compare changes](http://url.com/compare/0000000000000000000000000000000000000000...after)',
+          image: 'http://someavatar.com'
+        })
+      end
     end
   end
 
@@ -78,11 +137,30 @@ describe ChatMessage::PushMessage, models: true do
       args[:after] = Gitlab::Git::BLANK_SHA
     end
 
-    it 'returns a message regarding a removed branch' do
-      expect(subject.pretext).to eq(
-        'test.user removed branch master from <http://url.com|project_name>'
-      )
-      expect(subject.attachments).to be_empty
+    context 'without markdown' do
+      it 'returns a message regarding a removed branch' do
+        expect(subject.pretext).to eq(
+          'test.user removed branch master from <http://url.com|project_name>')
+        expect(subject.attachments).to be_empty
+      end
+    end
+
+    context 'with markdown' do
+      before do
+        args[:markdown] = true
+      end
+
+      it 'returns a message regarding a removed branch' do
+        expect(subject.pretext).to eq(
+          'test.user removed branch master from [project_name](http://url.com)')
+        expect(subject.attachments).to be_empty
+        expect(subject.activity).to eq({
+          title: 'test.user removed branch',
+          subtitle: 'in [project_name](http://url.com)',
+          text: '[Compare changes](http://url.com/compare/before...0000000000000000000000000000000000000000)',
+          image: 'http://someavatar.com'
+        })
+      end
     end
   end
 end
diff --git a/spec/models/project_services/chat_message/wiki_page_message_spec.rb b/spec/models/project_services/chat_message/wiki_page_message_spec.rb
index a2ad61e38e7..0df7db2abc2 100644
--- a/spec/models/project_services/chat_message/wiki_page_message_spec.rb
+++ b/spec/models/project_services/chat_message/wiki_page_message_spec.rb
@@ -7,7 +7,8 @@ describe ChatMessage::WikiPageMessage, models: true do
     {
       user: {
         name: 'Test User',
-        username: 'test.user'
+        username: 'test.user',
+        avatar_url: 'http://someavatar.com'
       },
       project_name: 'project_name',
       project_url: 'http://somewhere.com',
@@ -19,54 +20,128 @@ describe ChatMessage::WikiPageMessage, models: true do
     }
   end
 
-  describe '#pretext' do
-    context 'when :action == "create"' do
-      before { args[:object_attributes][:action] = 'create' }
+  context 'without markdown' do
+    describe '#pretext' do
+      context 'when :action == "create"' do
+        before { args[:object_attributes][:action] = 'create' }
 
-      it 'returns a message that a new wiki page was created' do
-        expect(subject.pretext).to eq(
-          'test.user created <http://url.com|wiki page> in <http://somewhere.com|project_name>: '\
-          '*Wiki page title*')
+        it 'returns a message that a new wiki page was created' do
+          expect(subject.pretext).to eq(
+            'test.user created <http://url.com|wiki page> in <http://somewhere.com|project_name>: '\
+              '*Wiki page title*')
+        end
+      end
+
+      context 'when :action == "update"' do
+        before { args[:object_attributes][:action] = 'update' }
+
+        it 'returns a message that a wiki page was updated' do
+          expect(subject.pretext).to eq(
+            'test.user edited <http://url.com|wiki page> in <http://somewhere.com|project_name>: '\
+              '*Wiki page title*')
+        end
       end
     end
 
-    context 'when :action == "update"' do
-      before { args[:object_attributes][:action] = 'update' }
+    describe '#attachments' do
+      let(:color) { '#345' }
 
-      it 'returns a message that a wiki page was updated' do
-        expect(subject.pretext).to eq(
-          'test.user edited <http://url.com|wiki page> in <http://somewhere.com|project_name>: '\
-          '*Wiki page title*')
+      context 'when :action == "create"' do
+        before { args[:object_attributes][:action] = 'create' }
+
+        it 'returns the attachment for a new wiki page' do
+          expect(subject.attachments).to eq([
+            {
+              text: "Wiki page description",
+              color: color,
+            }
+          ])
+        end
+      end
+
+      context 'when :action == "update"' do
+        before { args[:object_attributes][:action] = 'update' }
+
+        it 'returns the attachment for an updated wiki page' do
+          expect(subject.attachments).to eq([
+            {
+              text: "Wiki page description",
+              color: color,
+            }
+          ])
+        end
       end
     end
   end
 
-  describe '#attachments' do
-    let(:color) { '#345' }
+  context 'with markdown' do
+    before do
+      args[:markdown] = true
+    end
+
+    describe '#pretext' do
+      context 'when :action == "create"' do
+        before { args[:object_attributes][:action] = 'create' }
+
+        it 'returns a message that a new wiki page was created' do
+          expect(subject.pretext).to eq(
+            'test.user created [wiki page](http://url.com) in [project_name](http://somewhere.com): *Wiki page title*')
+        end
+      end
 
-    context 'when :action == "create"' do
-      before { args[:object_attributes][:action] = 'create' }
+      context 'when :action == "update"' do
+        before { args[:object_attributes][:action] = 'update' }
 
-      it 'returns the attachment for a new wiki page' do
-        expect(subject.attachments).to eq([
-          {
-            text: "Wiki page description",
-            color: color,
-          }
-        ])
+        it 'returns a message that a wiki page was updated' do
+          expect(subject.pretext).to eq(
+            'test.user edited [wiki page](http://url.com) in [project_name](http://somewhere.com): *Wiki page title*')
+        end
       end
     end
 
-    context 'when :action == "update"' do
-      before { args[:object_attributes][:action] = 'update' }
+    describe '#attachments' do
+      context 'when :action == "create"' do
+        before { args[:object_attributes][:action] = 'create' }
+
+        it 'returns the attachment for a new wiki page' do
+          expect(subject.attachments).to eq('Wiki page description')
+        end
+      end
+
+      context 'when :action == "update"' do
+        before { args[:object_attributes][:action] = 'update' }
+
+        it 'returns the attachment for an updated wiki page' do
+          expect(subject.attachments).to eq('Wiki page description')
+        end
+      end
+    end
+
+    describe '#activity' do
+      context 'when :action == "create"' do
+        before { args[:object_attributes][:action] = 'create' }
+
+        it 'returns the attachment for a new wiki page' do
+          expect(subject.activity).to eq({
+            title: 'test.user created [wiki page](http://url.com)',
+            subtitle: 'in [project_name](http://somewhere.com)',
+            text: 'Wiki page title',
+            image: 'http://someavatar.com'
+          })
+        end
+      end
+
+      context 'when :action == "update"' do
+        before { args[:object_attributes][:action] = 'update' }
 
-      it 'returns the attachment for an updated wiki page' do
-        expect(subject.attachments).to eq([
-          {
-            text: "Wiki page description",
-            color: color,
-          }
-        ])
+        it 'returns the attachment for an updated wiki page' do
+          expect(subject.activity).to eq({
+            title: 'test.user edited [wiki page](http://url.com)',
+            subtitle: 'in [project_name](http://somewhere.com)',
+            text: 'Wiki page title',
+            image: 'http://someavatar.com'
+          })
+        end
       end
     end
   end
diff --git a/spec/models/project_services/microsoft_teams_service_spec.rb b/spec/models/project_services/microsoft_teams_service_spec.rb
new file mode 100644
index 00000000000..facc034f69c
--- /dev/null
+++ b/spec/models/project_services/microsoft_teams_service_spec.rb
@@ -0,0 +1,277 @@
+require 'spec_helper'
+
+describe MicrosoftTeamsService, models: true do
+  let(:chat_service) { described_class.new }
+  let(:webhook_url) { 'https://example.gitlab.com/' }
+
+  describe "Associations" do
+    it { is_expected.to belong_to :project }
+    it { is_expected.to have_one :service_hook }
+  end
+
+  describe 'Validations' do
+    context 'when service is active' do
+      before { subject.active = true }
+
+      it { is_expected.to validate_presence_of(:webhook) }
+      it_behaves_like 'issue tracker service URL attribute', :webhook
+    end
+
+    context 'when service is inactive' do
+      before { subject.active = false }
+
+      it { is_expected.not_to validate_presence_of(:webhook) }
+    end
+  end
+
+  describe "#execute" do
+    let(:user)    { create(:user) }
+    let(:project) { create(:project, :repository) }
+
+    before do
+      allow(chat_service).to receive_messages(
+        project: project,
+        project_id: project.id,
+        service_hook: true,
+        webhook: webhook_url
+      )
+
+      WebMock.stub_request(:post, webhook_url)
+    end
+
+    context 'with push events' do
+      let(:push_sample_data) do
+        Gitlab::DataBuilder::Push.build_sample(project, user)
+      end
+
+      it "calls Microsoft Teams API for push events" do
+        chat_service.execute(push_sample_data)
+
+        expect(WebMock).to have_requested(:post, webhook_url).once
+      end
+
+      it 'specifies the webhook when it is configured' do
+        expect(MicrosoftTeams::Notifier).to receive(:new).with(webhook_url).and_return(double(:microsoft_teams_service).as_null_object)
+
+        chat_service.execute(push_sample_data)
+      end
+    end
+
+    context 'with issue events' do
+      let(:opts) { { title: 'Awesome issue', description: 'please fix' } }
+      let(:issues_sample_data) do
+        service = Issues::CreateService.new(project, user, opts)
+        issue = service.execute
+        service.hook_data(issue, 'open')
+      end
+
+      it "calls Microsoft Teams API" do
+        chat_service.execute(issues_sample_data)
+
+        expect(WebMock).to have_requested(:post, webhook_url).once
+      end
+    end
+
+    context 'with merge events' do
+      let(:opts) do
+        {
+          title: 'Awesome merge_request',
+          description: 'please fix',
+          source_branch: 'feature',
+          target_branch: 'master'
+        }
+      end
+
+      let(:merge_sample_data) do
+        service = MergeRequests::CreateService.new(project, user, opts)
+        merge_request = service.execute
+        service.hook_data(merge_request, 'open')
+      end
+
+      it "calls Microsoft Teams API" do
+        chat_service.execute(merge_sample_data)
+
+        expect(WebMock).to have_requested(:post, webhook_url).once
+      end
+    end
+
+    context 'with wiki page events' do
+      let(:opts) do
+        {
+          title: "Awesome wiki_page",
+          content: "Some text describing some thing or another",
+          format: "md",
+          message: "user created page: Awesome wiki_page"
+        }
+      end
+
+      let(:wiki_page_sample_data) do
+        service = WikiPages::CreateService.new(project, user, opts)
+        wiki_page = service.execute
+        service.hook_data(wiki_page, 'create')
+      end
+
+      it "calls Microsoft Teams API" do
+        chat_service.execute(wiki_page_sample_data)
+
+        expect(WebMock).to have_requested(:post, webhook_url).once
+      end
+    end
+  end
+
+  describe "Note events" do
+    let(:user) { create(:user) }
+    let(:project) { create(:project, :repository, creator: user) }
+
+    before do
+      allow(chat_service).to receive_messages(
+        project: project,
+        project_id: project.id,
+        service_hook: true,
+        webhook: webhook_url
+      )
+
+      WebMock.stub_request(:post, webhook_url)
+    end
+
+    context 'when commit comment event executed' do
+      let(:commit_note) do
+        create(:note_on_commit, author: user,
+                                project: project,
+                                commit_id: project.repository.commit.id,
+                                note: 'a comment on a commit')
+      end
+
+      it "calls Microsoft Teams API for commit comment events" do
+        data = Gitlab::DataBuilder::Note.build(commit_note, user)
+
+        chat_service.execute(data)
+
+        expect(WebMock).to have_requested(:post, webhook_url).once
+      end
+    end
+
+    context 'when merge request comment event executed' do
+      let(:merge_request_note) do
+        create(:note_on_merge_request, project: project,
+                                       note: "merge request note")
+      end
+
+      it "calls Microsoft Teams API for merge request comment events" do
+        data = Gitlab::DataBuilder::Note.build(merge_request_note, user)
+
+        chat_service.execute(data)
+
+        expect(WebMock).to have_requested(:post, webhook_url).once
+      end
+    end
+
+    context 'when issue comment event executed' do
+      let(:issue_note) do
+        create(:note_on_issue, project: project, note: "issue note")
+      end
+
+      it "calls Microsoft Teams API for issue comment events" do
+        data = Gitlab::DataBuilder::Note.build(issue_note, user)
+
+        chat_service.execute(data)
+
+        expect(WebMock).to have_requested(:post, webhook_url).once
+      end
+    end
+
+    context 'when snippet comment event executed' do
+      let(:snippet_note) do
+        create(:note_on_project_snippet, project: project,
+                                         note: "snippet note")
+      end
+
+      it "calls Microsoft Teams API for snippet comment events" do
+        data = Gitlab::DataBuilder::Note.build(snippet_note, user)
+
+        chat_service.execute(data)
+
+        expect(WebMock).to have_requested(:post, webhook_url).once
+      end
+    end
+  end
+
+  describe 'Pipeline events' do
+    let(:user) { create(:user) }
+    let(:project) { create(:project, :repository) }
+
+    let(:pipeline) do
+      create(:ci_pipeline,
+             project: project, status: status,
+             sha: project.commit.sha, ref: project.default_branch)
+    end
+
+    before do
+      allow(chat_service).to receive_messages(
+        project: project,
+        service_hook: true,
+        webhook: webhook_url
+      )
+    end
+
+    shared_examples 'call Microsoft Teams API' do
+      before do
+        WebMock.stub_request(:post, webhook_url)
+      end
+
+      it 'calls Microsoft Teams API for pipeline events' do
+        data = Gitlab::DataBuilder::Pipeline.build(pipeline)
+
+        chat_service.execute(data)
+
+        expect(WebMock).to have_requested(:post, webhook_url).once
+      end
+    end
+
+    context 'with failed pipeline' do
+      let(:status) { 'failed' }
+
+      it_behaves_like 'call Microsoft Teams API'
+    end
+
+    context 'with succeeded pipeline' do
+      let(:status) { 'success' }
+
+      context 'with default to notify_only_broken_pipelines' do
+        it 'does not call Microsoft Teams API for pipeline events' do
+          data = Gitlab::DataBuilder::Pipeline.build(pipeline)
+          result = chat_service.execute(data)
+
+          expect(result).to be_falsy
+        end
+      end
+
+      context 'with setting notify_only_broken_pipelines to false' do
+        before do
+          chat_service.notify_only_broken_pipelines = false
+        end
+
+        it_behaves_like 'call Microsoft Teams API'
+      end
+    end
+
+    context 'only notify for the default branch' do
+      context 'when enabled' do
+        let(:pipeline) do
+          create(:ci_pipeline, project: project, status: 'failed', ref: 'not-the-default-branch')
+        end
+
+        before do
+          chat_service.notify_only_default_branch = true
+        end
+
+        it 'does not call the Microsoft Teams API for pipeline events' do
+          data = Gitlab::DataBuilder::Pipeline.build(pipeline)
+          result = chat_service.execute(data)
+
+          expect(result).to be_falsy
+        end
+      end
+    end
+  end
+end
diff --git a/spec/models/project_spec.rb b/spec/models/project_spec.rb
index 59a2560ca06..92d420337f9 100644
--- a/spec/models/project_spec.rb
+++ b/spec/models/project_spec.rb
@@ -22,6 +22,7 @@ describe Project, models: true do
     it { is_expected.to have_many(:protected_branches).dependent(:destroy) }
     it { is_expected.to have_one(:forked_project_link).dependent(:destroy) }
     it { is_expected.to have_one(:slack_service).dependent(:destroy) }
+    it { is_expected.to have_one(:microsoft_teams_service).dependent(:destroy) }
     it { is_expected.to have_one(:mattermost_service).dependent(:destroy) }
     it { is_expected.to have_one(:pushover_service).dependent(:destroy) }
     it { is_expected.to have_one(:asana_service).dependent(:destroy) }
@@ -57,6 +58,7 @@ describe Project, models: true do
     it { is_expected.to have_many(:builds) }
     it { is_expected.to have_many(:runner_projects) }
     it { is_expected.to have_many(:runners) }
+    it { is_expected.to have_many(:active_runners) }
     it { is_expected.to have_many(:variables) }
     it { is_expected.to have_many(:triggers) }
     it { is_expected.to have_many(:pages_domains) }
@@ -702,25 +704,6 @@ describe Project, models: true do
     end
   end
 
-  describe '#open_branches' do
-    let(:project) { create(:project, :repository) }
-
-    before do
-      project.protected_branches.create(name: 'master')
-    end
-
-    it { expect(project.open_branches.map(&:name)).to include('feature') }
-    it { expect(project.open_branches.map(&:name)).not_to include('master') }
-
-    it "includes branches matching a protected branch wildcard" do
-      expect(project.open_branches.map(&:name)).to include('feature')
-
-      create(:protected_branch, name: 'feat*', project: project)
-
-      expect(Project.find(project.id).open_branches.map(&:name)).to include('feature')
-    end
-  end
-
   describe '#star_count' do
     it 'counts stars from multiple users' do
       user1 = create :user
@@ -1157,11 +1140,12 @@ describe Project, models: true do
       # Project#gitlab_shell returns a new instance of Gitlab::Shell on every
       # call. This makes testing a bit easier.
       allow(project).to receive(:gitlab_shell).and_return(gitlab_shell)
-
       allow(project).to receive(:previous_changes).and_return('path' => ['foo'])
     end
 
     it 'renames a repository' do
+      stub_container_registry_config(enabled: false)
+
       expect(gitlab_shell).to receive(:mv_repository).
         ordered.
         with(project.repository_storage_path, "#{project.namespace.full_path}/foo", "#{project.full_path}").
@@ -1185,10 +1169,13 @@ describe Project, models: true do
       project.rename_repo
     end
 
-    context 'container registry with tags' do
+    context 'container registry with images' do
+      let(:container_repository) { create(:container_repository) }
+
       before do
         stub_container_registry_config(enabled: true)
-        stub_container_registry_tags('tag')
+        stub_container_registry_tags(repository: :any, tags: ['tag'])
+        project.container_repositories << container_repository
       end
 
       subject { project.rename_repo }
@@ -1291,62 +1278,6 @@ describe Project, models: true do
     end
   end
 
-  describe '#protected_branch?' do
-    context 'existing project' do
-      let(:project) { create(:project, :repository) }
-
-      it 'returns true when the branch matches a protected branch via direct match' do
-        create(:protected_branch, project: project, name: "foo")
-
-        expect(project.protected_branch?('foo')).to eq(true)
-      end
-
-      it 'returns true when the branch matches a protected branch via wildcard match' do
-        create(:protected_branch, project: project, name: "production/*")
-
-        expect(project.protected_branch?('production/some-branch')).to eq(true)
-      end
-
-      it 'returns false when the branch does not match a protected branch via direct match' do
-        expect(project.protected_branch?('foo')).to eq(false)
-      end
-
-      it 'returns false when the branch does not match a protected branch via wildcard match' do
-        create(:protected_branch, project: project, name: "production/*")
-
-        expect(project.protected_branch?('staging/some-branch')).to eq(false)
-      end
-    end
-
-    context "new project" do
-      let(:project) { create(:empty_project) }
-
-      it 'returns false when default_protected_branch is unprotected' do
-        stub_application_setting(default_branch_protection: Gitlab::Access::PROTECTION_NONE)
-
-        expect(project.protected_branch?('master')).to be false
-      end
-
-      it 'returns false when default_protected_branch lets developers push' do
-        stub_application_setting(default_branch_protection: Gitlab::Access::PROTECTION_DEV_CAN_PUSH)
-
-        expect(project.protected_branch?('master')).to be false
-      end
-
-      it 'returns true when default_branch_protection does not let developers push but let developer merge branches' do
-        stub_application_setting(default_branch_protection: Gitlab::Access::PROTECTION_DEV_CAN_MERGE)
-
-        expect(project.protected_branch?('master')).to be true
-      end
-
-      it 'returns true when default_branch_protection is in full protection' do
-        stub_application_setting(default_branch_protection: Gitlab::Access::PROTECTION_FULL)
-
-        expect(project.protected_branch?('master')).to be true
-      end
-    end
-  end
-
   describe '#user_can_push_to_empty_repo?' do
     let(:project) { create(:empty_project) }
     let(:user)    { create(:user) }
@@ -1386,38 +1317,17 @@ describe Project, models: true do
     end
   end
 
-  describe '#container_registry_path_with_namespace' do
-    let(:project) { create(:empty_project, path: 'PROJECT') }
-
-    subject { project.container_registry_path_with_namespace }
-
-    it { is_expected.not_to eq(project.path_with_namespace) }
-    it { is_expected.to eq(project.path_with_namespace.downcase) }
-  end
-
-  describe '#container_registry_repository' do
+  describe '#container_registry_url' do
     let(:project) { create(:empty_project) }
 
-    before { stub_container_registry_config(enabled: true) }
-
-    subject { project.container_registry_repository }
-
-    it { is_expected.not_to be_nil }
-  end
-
-  describe '#container_registry_repository_url' do
-    let(:project) { create(:empty_project) }
-
-    subject { project.container_registry_repository_url }
+    subject { project.container_registry_url }
 
     before { stub_container_registry_config(**registry_settings) }
 
     context 'for enabled registry' do
       let(:registry_settings) do
-        {
-          enabled: true,
-          host_port: 'example.com',
-        }
+        { enabled: true,
+          host_port: 'example.com' }
       end
 
       it { is_expected.not_to be_nil }
@@ -1425,9 +1335,7 @@ describe Project, models: true do
 
     context 'for disabled registry' do
       let(:registry_settings) do
-        {
-          enabled: false
-        }
+        { enabled: false }
       end
 
       it { is_expected.to be_nil }
@@ -1437,28 +1345,60 @@ describe Project, models: true do
   describe '#has_container_registry_tags?' do
     let(:project) { create(:empty_project) }
 
-    subject { project.has_container_registry_tags? }
-
-    context 'for enabled registry' do
+    context 'when container registry is enabled' do
       before { stub_container_registry_config(enabled: true) }
 
-      context 'with tags' do
-        before { stub_container_registry_tags('test', 'test2') }
+      context 'when tags are present for multi-level registries' do
+        before do
+          create(:container_repository, project: project, name: 'image')
 
-        it { is_expected.to be_truthy }
+          stub_container_registry_tags(repository: /image/,
+                                       tags: %w[latest rc1])
+        end
+
+        it 'should have image tags' do
+          expect(project).to have_container_registry_tags
+        end
       end
 
-      context 'when no tags' do
-        before { stub_container_registry_tags }
+      context 'when tags are present for root repository' do
+        before do
+          stub_container_registry_tags(repository: project.full_path,
+                                       tags: %w[latest rc1 pre1])
+        end
+
+        it 'should have image tags' do
+          expect(project).to have_container_registry_tags
+        end
+      end
+
+      context 'when there are no tags at all' do
+        before do
+          stub_container_registry_tags(repository: :any, tags: [])
+        end
 
-        it { is_expected.to be_falsey }
+        it 'should not have image tags' do
+          expect(project).not_to have_container_registry_tags
+        end
       end
     end
 
-    context 'for disabled registry' do
+    context 'when container registry is disabled' do
       before { stub_container_registry_config(enabled: false) }
 
-      it { is_expected.to be_falsey }
+      it 'should not have image tags' do
+        expect(project).not_to have_container_registry_tags
+      end
+
+      it 'should not check root repository tags' do
+        expect(project).not_to receive(:full_path)
+        expect(project).not_to have_container_registry_tags
+      end
+
+      it 'should iterate through container repositories' do
+        expect(project).to receive(:container_repositories)
+        expect(project).not_to have_container_registry_tags
+      end
     end
   end
 
@@ -1934,7 +1874,7 @@ describe Project, models: true do
   describe '#pipeline_status' do
     let(:project) { create(:project) }
     it 'builds a pipeline status' do
-      expect(project.pipeline_status).to be_a(Ci::PipelineStatus)
+      expect(project.pipeline_status).to be_a(Gitlab::Cache::Ci::ProjectPipelineStatus)
     end
 
     it 'hase a loaded pipeline status' do
diff --git a/spec/models/protectable_dropdown_spec.rb b/spec/models/protectable_dropdown_spec.rb
new file mode 100644
index 00000000000..4c9bade592b
--- /dev/null
+++ b/spec/models/protectable_dropdown_spec.rb
@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe ProtectableDropdown, models: true do
+  let(:project) { create(:project, :repository) }
+  let(:subject) { described_class.new(project, :branches) }
+
+  describe '#protectable_ref_names' do
+    before do
+      project.protected_branches.create(name: 'master')
+    end
+
+    it { expect(subject.protectable_ref_names).to include('feature') }
+    it { expect(subject.protectable_ref_names).not_to include('master') }
+
+    it "includes branches matching a protected branch wildcard" do
+      expect(subject.protectable_ref_names).to include('feature')
+
+      create(:protected_branch, name: 'feat*', project: project)
+
+      subject = described_class.new(project.reload, :branches)
+
+      expect(subject.protectable_ref_names).to include('feature')
+    end
+  end
+end
diff --git a/spec/models/protected_branch_spec.rb b/spec/models/protected_branch_spec.rb
index 8bf0d24a128..179a443c43d 100644
--- a/spec/models/protected_branch_spec.rb
+++ b/spec/models/protected_branch_spec.rb
@@ -113,8 +113,8 @@ describe ProtectedBranch, models: true do
         staging = build(:protected_branch, name: "staging")
 
         expect(ProtectedBranch.matching("production")).to be_empty
-        expect(ProtectedBranch.matching("production", protected_branches: [production, staging])).to include(production)
-        expect(ProtectedBranch.matching("production", protected_branches: [production, staging])).not_to include(staging)
+        expect(ProtectedBranch.matching("production", protected_refs: [production, staging])).to include(production)
+        expect(ProtectedBranch.matching("production", protected_refs: [production, staging])).not_to include(staging)
       end
     end
 
@@ -132,8 +132,64 @@ describe ProtectedBranch, models: true do
         staging = build(:protected_branch, name: "staging/*")
 
         expect(ProtectedBranch.matching("production/some-branch")).to be_empty
-        expect(ProtectedBranch.matching("production/some-branch", protected_branches: [production, staging])).to include(production)
-        expect(ProtectedBranch.matching("production/some-branch", protected_branches: [production, staging])).not_to include(staging)
+        expect(ProtectedBranch.matching("production/some-branch", protected_refs: [production, staging])).to include(production)
+        expect(ProtectedBranch.matching("production/some-branch", protected_refs: [production, staging])).not_to include(staging)
+      end
+    end
+  end
+
+  describe '#protected?' do
+    context 'existing project' do
+      let(:project) { create(:project, :repository) }
+
+      it 'returns true when the branch matches a protected branch via direct match' do
+        create(:protected_branch, project: project, name: "foo")
+
+        expect(ProtectedBranch.protected?(project, 'foo')).to eq(true)
+      end
+
+      it 'returns true when the branch matches a protected branch via wildcard match' do
+        create(:protected_branch, project: project, name: "production/*")
+
+        expect(ProtectedBranch.protected?(project, 'production/some-branch')).to eq(true)
+      end
+
+      it 'returns false when the branch does not match a protected branch via direct match' do
+        expect(ProtectedBranch.protected?(project, 'foo')).to eq(false)
+      end
+
+      it 'returns false when the branch does not match a protected branch via wildcard match' do
+        create(:protected_branch, project: project, name: "production/*")
+
+        expect(ProtectedBranch.protected?(project, 'staging/some-branch')).to eq(false)
+      end
+    end
+
+    context "new project" do
+      let(:project) { create(:empty_project) }
+
+      it 'returns false when default_protected_branch is unprotected' do
+        stub_application_setting(default_branch_protection: Gitlab::Access::PROTECTION_NONE)
+
+        expect(ProtectedBranch.protected?(project, 'master')).to be false
+      end
+
+      it 'returns false when default_protected_branch lets developers push' do
+        stub_application_setting(default_branch_protection: Gitlab::Access::PROTECTION_DEV_CAN_PUSH)
+
+        expect(ProtectedBranch.protected?(project, 'master')).to be false
+      end
+
+      it 'returns true when default_branch_protection does not let developers push but let developer merge branches' do
+        stub_application_setting(default_branch_protection: Gitlab::Access::PROTECTION_DEV_CAN_MERGE)
+
+        expect(ProtectedBranch.protected?(project, 'master')).to be true
+      end
+
+      it 'returns true when default_branch_protection is in full protection' do
+        stub_application_setting(default_branch_protection: Gitlab::Access::PROTECTION_FULL)
+
+        expect(ProtectedBranch.protected?(project, 'master')).to be true
       end
     end
   end
diff --git a/spec/models/protected_tag_spec.rb b/spec/models/protected_tag_spec.rb
new file mode 100644
index 00000000000..51353852a93
--- /dev/null
+++ b/spec/models/protected_tag_spec.rb
@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe ProtectedTag, models: true do
+  describe 'Associations' do
+    it { is_expected.to belong_to(:project) }
+  end
+
+  describe 'Validation' do
+    it { is_expected.to validate_presence_of(:project) }
+    it { is_expected.to validate_presence_of(:name) }
+  end
+end
diff --git a/spec/models/repository_spec.rb b/spec/models/repository_spec.rb
index d805e65b3c6..5e5c2b016b6 100644
--- a/spec/models/repository_spec.rb
+++ b/spec/models/repository_spec.rb
@@ -1283,8 +1283,6 @@ describe Repository, models: true do
   describe '#after_import' do
     it 'flushes and builds the cache' do
       expect(repository).to receive(:expire_content_cache)
-      expect(repository).to receive(:expire_tags_cache)
-      expect(repository).to receive(:expire_branches_cache)
 
       repository.after_import
     end
@@ -1831,16 +1829,17 @@ describe Repository, models: true do
     end
   end
 
-  describe '#is_ancestor?' do
-    context 'Gitaly is_ancestor feature enabled' do
-      it 'asks Gitaly server if it\'s an ancestor' do
-        commit = repository.commit
-        allow(Gitlab::GitalyClient).to receive(:feature_enabled?).with(:is_ancestor).and_return(true)
-        expect(Gitlab::GitalyClient::Commit).to receive(:is_ancestor).
-          with(repository.raw_repository, commit.id, commit.id).and_return(true)
-
-        expect(repository.is_ancestor?(commit.id, commit.id)).to be true
-      end
-    end
-  end
+  # TODO: Uncomment when feature is reenabled
+  # describe '#is_ancestor?' do
+  #   context 'Gitaly is_ancestor feature enabled' do
+  #     it 'asks Gitaly server if it\'s an ancestor' do
+  #       commit = repository.commit
+  #       allow(Gitlab::GitalyClient).to receive(:feature_enabled?).with(:is_ancestor).and_return(true)
+  #       expect(Gitlab::GitalyClient::Commit).to receive(:is_ancestor).
+  #         with(repository.raw_repository, commit.id, commit.id).and_return(true)
+  #
+  #       expect(repository.is_ancestor?(commit.id, commit.id)).to be true
+  #     end
+  #   end
+  # end
 end
diff --git a/spec/models/sent_notification_spec.rb b/spec/models/sent_notification_spec.rb
new file mode 100644
index 00000000000..6b7eef388be
--- /dev/null
+++ b/spec/models/sent_notification_spec.rb
@@ -0,0 +1,166 @@
+require 'spec_helper'
+
+describe SentNotification, model: true do
+  describe 'validation' do
+    describe 'note validity' do
+      context "when the project doesn't match the noteable's project" do
+        subject { build(:sent_notification, noteable: create(:issue)) }
+
+        it "is invalid" do
+          expect(subject).not_to be_valid
+        end
+      end
+
+      context "when the project doesn't match the discussion project" do
+        let(:discussion_id) { create(:note).discussion_id }
+        subject { build(:sent_notification, in_reply_to_discussion_id: discussion_id) }
+
+        it "is invalid" do
+          expect(subject).not_to be_valid
+        end
+      end
+
+      context "when the noteable project and discussion project match" do
+        let(:project) { create(:project) }
+        let(:issue) { create(:issue, project: project) }
+        let(:discussion_id) { create(:note, project: project, noteable: issue).discussion_id }
+        subject { build(:sent_notification, project: project, noteable: issue, in_reply_to_discussion_id: discussion_id) }
+
+        it "is valid" do
+          expect(subject).to be_valid
+        end
+      end
+    end
+  end
+
+  describe '.record' do
+    let(:user) { create(:user) }
+    let(:issue) { create(:issue) }
+
+    it 'creates a new SentNotification' do
+      expect { described_class.record(issue, user.id) }.to change { SentNotification.count }.by(1)
+    end
+  end
+
+  describe '.record_note' do
+    let(:user) { create(:user) }
+    let(:note) { create(:diff_note_on_merge_request) }
+
+    it 'creates a new SentNotification' do
+      expect { described_class.record_note(note, user.id) }.to change { SentNotification.count }.by(1)
+    end
+  end
+
+  describe '#create_reply' do
+    context 'for issue' do
+      let(:issue) { create(:issue) }
+      subject { described_class.record(issue, issue.author.id) }
+
+      it 'creates a comment on the issue' do
+        note = subject.create_reply('Test')
+        expect(note.in_reply_to?(issue)).to be_truthy
+      end
+    end
+
+    context 'for issue comment' do
+      let(:note) { create(:note_on_issue) }
+      subject { described_class.record_note(note, note.author.id) }
+
+      it 'creates a comment on the issue' do
+        new_note = subject.create_reply('Test')
+        expect(new_note.in_reply_to?(note)).to be_truthy
+      end
+    end
+
+    context 'for issue discussion' do
+      let(:note) { create(:discussion_note_on_issue) }
+      subject { described_class.record_note(note, note.author.id) }
+
+      it 'creates a reply on the discussion' do
+        new_note = subject.create_reply('Test')
+        expect(new_note.in_reply_to?(note)).to be_truthy
+      end
+    end
+
+    context 'for merge request' do
+      let(:merge_request) { create(:merge_request) }
+      subject { described_class.record(merge_request, merge_request.author.id) }
+
+      it 'creates a comment on the merge_request' do
+        note = subject.create_reply('Test')
+        expect(note.in_reply_to?(merge_request)).to be_truthy
+      end
+    end
+
+    context 'for merge request comment' do
+      let(:note) { create(:note_on_merge_request) }
+      subject { described_class.record_note(note, note.author.id) }
+
+      it 'creates a comment on the merge request' do
+        new_note = subject.create_reply('Test')
+        expect(new_note.in_reply_to?(note)).to be_truthy
+      end
+    end
+
+    context 'for merge request diff discussion' do
+      let(:note) { create(:diff_note_on_merge_request) }
+      subject { described_class.record_note(note, note.author.id) }
+
+      it 'creates a reply on the discussion' do
+        new_note = subject.create_reply('Test')
+        expect(new_note.in_reply_to?(note)).to be_truthy
+      end
+    end
+
+    context 'for merge request non-diff discussion' do
+      let(:note) { create(:discussion_note_on_merge_request) }
+      subject { described_class.record_note(note, note.author.id) }
+
+      it 'creates a reply on the discussion' do
+        new_note = subject.create_reply('Test')
+        expect(new_note.in_reply_to?(note)).to be_truthy
+      end
+    end
+
+    context 'for commit' do
+      let(:project) { create(:project) }
+      let(:commit) { project.commit }
+      subject { described_class.record(commit, project.creator.id) }
+
+      it 'creates a comment on the commit' do
+        note = subject.create_reply('Test')
+        expect(note.in_reply_to?(commit)).to be_truthy
+      end
+    end
+
+    context 'for commit comment' do
+      let(:note) { create(:note_on_commit) }
+      subject { described_class.record_note(note, note.author.id) }
+
+      it 'creates a comment on the commit' do
+        new_note = subject.create_reply('Test')
+        expect(new_note.in_reply_to?(note)).to be_truthy
+      end
+    end
+
+    context 'for commit diff discussion' do
+      let(:note) { create(:diff_note_on_commit) }
+      subject { described_class.record_note(note, note.author.id) }
+
+      it 'creates a reply on the discussion' do
+        new_note = subject.create_reply('Test')
+        expect(new_note.in_reply_to?(note)).to be_truthy
+      end
+    end
+
+    context 'for commit non-diff discussion' do
+      let(:note) { create(:discussion_note_on_commit) }
+      subject { described_class.record_note(note, note.author.id) }
+
+      it 'creates a reply on the discussion' do
+        new_note = subject.create_reply('Test')
+        expect(new_note.in_reply_to?(note)).to be_truthy
+      end
+    end
+  end
+end
diff --git a/spec/models/user_spec.rb b/spec/models/user_spec.rb
index a9e37be1157..9de16c41e94 100644
--- a/spec/models/user_spec.rb
+++ b/spec/models/user_spec.rb
@@ -28,7 +28,6 @@ describe User, models: true do
     it { is_expected.to have_many(:merge_requests).dependent(:destroy) }
     it { is_expected.to have_many(:assigned_merge_requests).dependent(:nullify) }
     it { is_expected.to have_many(:identities).dependent(:destroy) }
-    it { is_expected.to have_one(:abuse_report) }
     it { is_expected.to have_many(:spam_logs).dependent(:destroy) }
     it { is_expected.to have_many(:todos).dependent(:destroy) }
     it { is_expected.to have_many(:award_emoji).dependent(:destroy) }
@@ -37,6 +36,34 @@ describe User, models: true do
     it { is_expected.to have_many(:pipelines).dependent(:nullify) }
     it { is_expected.to have_many(:chat_names).dependent(:destroy) }
     it { is_expected.to have_many(:uploads).dependent(:destroy) }
+    it { is_expected.to have_many(:reported_abuse_reports).dependent(:destroy).class_name('AbuseReport') }
+
+    describe "#abuse_report" do
+      let(:current_user) { create(:user) }
+      let(:other_user) { create(:user) }
+
+      it { is_expected.to have_one(:abuse_report) }
+
+      it "refers to the abuse report whose user_id is the current user" do
+        abuse_report = create(:abuse_report, reporter: other_user, user: current_user)
+
+        expect(current_user.abuse_report).to eq(abuse_report)
+      end
+
+      it "does not refer to the abuse report whose reporter_id is the current user" do
+        create(:abuse_report, reporter: current_user, user: other_user)
+
+        expect(current_user.abuse_report).to be_nil
+      end
+
+      it "does not update the user_id of an abuse report when the user is updated" do
+        abuse_report = create(:abuse_report, reporter: current_user, user: other_user)
+
+        current_user.block
+
+        expect(abuse_report.reload.user).to eq(other_user)
+      end
+    end
 
     describe '#group_members' do
       it 'does not include group memberships for which user is a requester' do
@@ -288,7 +315,7 @@ describe User, models: true do
   end
 
   describe "Respond to" do
-    it { is_expected.to respond_to(:is_admin?) }
+    it { is_expected.to respond_to(:admin?) }
     it { is_expected.to respond_to(:name) }
     it { is_expected.to respond_to(:private_token) }
     it { is_expected.to respond_to(:external?) }
@@ -559,7 +586,7 @@ describe User, models: true do
     describe 'normal user' do
       let(:user) { create(:user, name: 'John Smith') }
 
-      it { expect(user.is_admin?).to be_falsey }
+      it { expect(user.admin?).to be_falsey }
       it { expect(user.require_ssh_key?).to be_truthy }
       it { expect(user.can_create_group?).to be_truthy }
       it { expect(user.can_create_project?).to be_truthy }
@@ -1407,6 +1434,17 @@ describe User, models: true do
     it { expect(user.nested_groups).to eq([nested_group]) }
   end
 
+  describe '#all_expanded_groups' do
+    let!(:user) { create(:user) }
+    let!(:group) { create(:group) }
+    let!(:nested_group_1) { create(:group, parent: group) }
+    let!(:nested_group_2) { create(:group, parent: group) }
+
+    before { nested_group_1.add_owner(user) }
+
+    it { expect(user.all_expanded_groups).to match_array [group, nested_group_1] }
+  end
+
   describe '#nested_groups_projects' do
     let!(:user) { create(:user) }
     let!(:group) { create(:group) }
@@ -1521,4 +1559,76 @@ describe User, models: true do
       end
     end
   end
+
+  describe '#update_two_factor_requirement' do
+    let(:user) { create :user }
+
+    context 'with 2FA requirement on groups' do
+      let(:group1) { create :group, require_two_factor_authentication: true, two_factor_grace_period: 23 }
+      let(:group2) { create :group, require_two_factor_authentication: true, two_factor_grace_period: 32 }
+
+      before do
+        group1.add_user(user, GroupMember::OWNER)
+        group2.add_user(user, GroupMember::OWNER)
+
+        user.update_two_factor_requirement
+      end
+
+      it 'requires 2FA' do
+        expect(user.require_two_factor_authentication_from_group).to be true
+      end
+
+      it 'uses the shortest grace period' do
+        expect(user.two_factor_grace_period).to be 23
+      end
+    end
+
+    context 'with 2FA requirement on nested parent group' do
+      let!(:group1) { create :group, require_two_factor_authentication: true }
+      let!(:group1a) { create :group, require_two_factor_authentication: false, parent: group1 }
+
+      before do
+        group1a.add_user(user, GroupMember::OWNER)
+
+        user.update_two_factor_requirement
+      end
+
+      it 'requires 2FA' do
+        expect(user.require_two_factor_authentication_from_group).to be true
+      end
+    end
+
+    context 'with 2FA requirement on nested child group' do
+      let!(:group1) { create :group, require_two_factor_authentication: false }
+      let!(:group1a) { create :group, require_two_factor_authentication: true, parent: group1 }
+
+      before do
+        group1.add_user(user, GroupMember::OWNER)
+
+        user.update_two_factor_requirement
+      end
+
+      it 'requires 2FA' do
+        expect(user.require_two_factor_authentication_from_group).to be true
+      end
+    end
+
+    context 'without 2FA requirement on groups' do
+      let(:group) { create :group }
+
+      before do
+        group.add_user(user, GroupMember::OWNER)
+
+        user.update_two_factor_requirement
+      end
+
+      it 'does not require 2FA' do
+        expect(user.require_two_factor_authentication_from_group).to be false
+      end
+
+      it 'falls back to the default grace period' do
+        expect(user.two_factor_grace_period).to be 48
+      end
+    end
+  end
 end
diff --git a/spec/policies/group_policy_spec.rb b/spec/policies/group_policy_spec.rb
index 5c34ff04152..2077c14ff7a 100644
--- a/spec/policies/group_policy_spec.rb
+++ b/spec/policies/group_policy_spec.rb
@@ -22,7 +22,8 @@ describe GroupPolicy, models: true do
       :admin_group,
       :admin_namespace,
       :admin_group_member,
-      :change_visibility_level
+      :change_visibility_level,
+      :create_subgroup
     ]
   end
 
diff --git a/spec/presenters/ci/build_presenter_spec.rb b/spec/presenters/ci/build_presenter_spec.rb
index 7a35da38b2b..2190ab0e82e 100644
--- a/spec/presenters/ci/build_presenter_spec.rb
+++ b/spec/presenters/ci/build_presenter_spec.rb
@@ -57,6 +57,32 @@ describe Ci::BuildPresenter do
     end
   end
 
+  describe '#status_title' do
+    context 'when build is auto-canceled' do
+      before do
+        expect(build).to receive(:auto_canceled?).and_return(true)
+        expect(build).to receive(:auto_canceled_by_id).and_return(1)
+      end
+
+      it 'shows that the build is auto-canceled' do
+        status_title = presenter.status_title
+
+        expect(status_title).to include('auto-canceled')
+        expect(status_title).to include('Pipeline #1')
+      end
+    end
+
+    context 'when build is not auto-canceled' do
+      before do
+        expect(build).to receive(:auto_canceled?).and_return(false)
+      end
+
+      it 'does not have a status title' do
+        expect(presenter.status_title).to be_nil
+      end
+    end
+  end
+
   describe 'quack like a Ci::Build permission-wise' do
     context 'user is not allowed' do
       let(:project) { build_stubbed(:empty_project, public_builds: false) }
diff --git a/spec/presenters/ci/pipeline_presenter_spec.rb b/spec/presenters/ci/pipeline_presenter_spec.rb
new file mode 100644
index 00000000000..9134d1cc31c
--- /dev/null
+++ b/spec/presenters/ci/pipeline_presenter_spec.rb
@@ -0,0 +1,54 @@
+require 'spec_helper'
+
+describe Ci::PipelinePresenter do
+  let(:project) { create(:empty_project) }
+  let(:pipeline) { create(:ci_pipeline, project: project) }
+
+  subject(:presenter) do
+    described_class.new(pipeline)
+  end
+
+  it 'inherits from Gitlab::View::Presenter::Delegated' do
+    expect(described_class.superclass).to eq(Gitlab::View::Presenter::Delegated)
+  end
+
+  describe '#initialize' do
+    it 'takes a pipeline and optional params' do
+      expect { presenter }.not_to raise_error
+    end
+
+    it 'exposes pipeline' do
+      expect(presenter.pipeline).to eq(pipeline)
+    end
+
+    it 'forwards missing methods to pipeline' do
+      expect(presenter.ref).to eq(pipeline.ref)
+    end
+  end
+
+  describe '#status_title' do
+    context 'when pipeline is auto-canceled' do
+      before do
+        expect(pipeline).to receive(:auto_canceled?).and_return(true)
+        expect(pipeline).to receive(:auto_canceled_by_id).and_return(1)
+      end
+
+      it 'shows that the pipeline is auto-canceled' do
+        status_title = presenter.status_title
+
+        expect(status_title).to include('auto-canceled')
+        expect(status_title).to include('Pipeline #1')
+      end
+    end
+
+    context 'when pipeline is not auto-canceled' do
+      before do
+        expect(pipeline).to receive(:auto_canceled?).and_return(false)
+      end
+
+      it 'does not have a status title' do
+        expect(presenter.status_title).to be_nil
+      end
+    end
+  end
+end
diff --git a/spec/requests/api/internal_spec.rb b/spec/requests/api/internal_spec.rb
index eed45d37444..4be67df5a00 100644
--- a/spec/requests/api/internal_spec.rb
+++ b/spec/requests/api/internal_spec.rb
@@ -153,6 +153,22 @@ describe API::Internal, api: true  do
         project.team << [user, :developer]
       end
 
+      context 'with env passed as a JSON' do
+        it 'sets env in RequestStore' do
+          expect(Gitlab::Git::Env).to receive(:set).with({
+            'GIT_OBJECT_DIRECTORY' => 'foo',
+            'GIT_ALTERNATE_OBJECT_DIRECTORIES' => 'bar'
+          })
+
+          push(key, project.wiki, env: {
+            GIT_OBJECT_DIRECTORY: 'foo',
+            GIT_ALTERNATE_OBJECT_DIRECTORIES: 'bar'
+          }.to_json)
+
+          expect(response).to have_http_status(200)
+        end
+      end
+
       context "git push with project.wiki" do
         it 'responds with success' do
           push(key, project.wiki)
@@ -463,7 +479,7 @@ describe API::Internal, api: true  do
     )
   end
 
-  def push(key, project, protocol = 'ssh')
+  def push(key, project, protocol = 'ssh', env: nil)
     post(
       api("/internal/allowed"),
       changes: 'd14d6c0abdd253381df51a723d58691b2ee1ab08 570e7b2abdd848b95f2f578043fc23bd6f6fd24d refs/heads/master',
@@ -471,7 +487,8 @@ describe API::Internal, api: true  do
       project: project.repository.path_to_repo,
       action: 'git-receive-pack',
       secret_token: secret_token,
-      protocol: protocol
+      protocol: protocol,
+      env: env
     )
   end
 
diff --git a/spec/requests/api/issues_spec.rb b/spec/requests/api/issues_spec.rb
index 2b27ce6390a..551aae7d701 100644
--- a/spec/requests/api/issues_spec.rb
+++ b/spec/requests/api/issues_spec.rb
@@ -840,7 +840,7 @@ describe API::Issues, api: true  do
     end
 
     context 'resolving discussions' do
-      let(:discussion) { Discussion.for_diff_notes([create(:diff_note_on_merge_request)]).first }
+      let(:discussion) { create(:diff_note_on_merge_request).to_discussion }
       let(:merge_request) { discussion.noteable }
       let(:project) { merge_request.source_project }
 
diff --git a/spec/requests/api/jobs_spec.rb b/spec/requests/api/jobs_spec.rb
index 9450701064b..d8a56c02a63 100644
--- a/spec/requests/api/jobs_spec.rb
+++ b/spec/requests/api/jobs_spec.rb
@@ -320,7 +320,7 @@ describe API::Jobs, api: true do
     context 'authorized user' do
       it 'returns specific job trace' do
         expect(response).to have_http_status(200)
-        expect(response.body).to eq(build.trace)
+        expect(response.body).to eq(build.trace.raw)
       end
     end
 
@@ -408,7 +408,7 @@ describe API::Jobs, api: true do
 
       it 'erases job content' do
         expect(response).to have_http_status(201)
-        expect(build.trace).to be_empty
+        expect(build).not_to have_trace
         expect(build.artifacts_file.exists?).to be_falsy
         expect(build.artifacts_metadata.exists?).to be_falsy
       end
diff --git a/spec/requests/api/project_hooks_spec.rb b/spec/requests/api/project_hooks_spec.rb
index b1f8c249092..b1603233f9e 100644
--- a/spec/requests/api/project_hooks_spec.rb
+++ b/spec/requests/api/project_hooks_spec.rb
@@ -22,8 +22,8 @@ describe API::ProjectHooks, 'ProjectHooks', api: true do
     context "authorized user" do
       it "returns project hooks" do
         get api("/projects/#{project.id}/hooks", user)
-        expect(response).to have_http_status(200)
 
+        expect(response).to have_http_status(200)
         expect(json_response).to be_an Array
         expect(response).to include_pagination_headers
         expect(json_response.count).to eq(1)
@@ -43,6 +43,7 @@ describe API::ProjectHooks, 'ProjectHooks', api: true do
     context "unauthorized user" do
       it "does not access project hooks" do
         get api("/projects/#{project.id}/hooks", user3)
+
         expect(response).to have_http_status(403)
       end
     end
@@ -52,6 +53,7 @@ describe API::ProjectHooks, 'ProjectHooks', api: true do
     context "authorized user" do
       it "returns a project hook" do
         get api("/projects/#{project.id}/hooks/#{hook.id}", user)
+
         expect(response).to have_http_status(200)
         expect(json_response['url']).to eq(hook.url)
         expect(json_response['issues_events']).to eq(hook.issues_events)
@@ -67,6 +69,7 @@ describe API::ProjectHooks, 'ProjectHooks', api: true do
 
       it "returns a 404 error if hook id is not available" do
         get api("/projects/#{project.id}/hooks/1234", user)
+
         expect(response).to have_http_status(404)
       end
     end
@@ -88,7 +91,8 @@ describe API::ProjectHooks, 'ProjectHooks', api: true do
     it "adds hook to project" do
       expect do
         post api("/projects/#{project.id}/hooks", user),
-          url: "http://example.com", issues_events: true, wiki_page_events: true
+          url: "http://example.com", issues_events: true, wiki_page_events: true,
+          job_events: true
       end.to change {project.hooks.count}.by(1)
 
       expect(response).to have_http_status(201)
@@ -98,7 +102,7 @@ describe API::ProjectHooks, 'ProjectHooks', api: true do
       expect(json_response['merge_requests_events']).to eq(false)
       expect(json_response['tag_push_events']).to eq(false)
       expect(json_response['note_events']).to eq(false)
-      expect(json_response['job_events']).to eq(false)
+      expect(json_response['job_events']).to eq(true)
       expect(json_response['pipeline_events']).to eq(false)
       expect(json_response['wiki_page_events']).to eq(true)
       expect(json_response['enable_ssl_verification']).to eq(true)
@@ -136,7 +140,8 @@ describe API::ProjectHooks, 'ProjectHooks', api: true do
   describe "PUT /projects/:id/hooks/:hook_id" do
     it "updates an existing project hook" do
       put api("/projects/#{project.id}/hooks/#{hook.id}", user),
-        url: 'http://example.org', push_events: false
+        url: 'http://example.org', push_events: false, job_events: true
+
       expect(response).to have_http_status(200)
       expect(json_response['url']).to eq('http://example.org')
       expect(json_response['issues_events']).to eq(hook.issues_events)
diff --git a/spec/requests/api/projects_spec.rb b/spec/requests/api/projects_spec.rb
index 2e291eb3cea..74bc4847247 100644
--- a/spec/requests/api/projects_spec.rb
+++ b/spec/requests/api/projects_spec.rb
@@ -1076,6 +1076,13 @@ describe API::Projects, :api  do
     before { project_member3 }
     before { project_member2 }
 
+    it 'returns 400 when nothing sent' do
+      project_param = {}
+      put api("/projects/#{project.id}", user), project_param
+      expect(response).to have_http_status(400)
+      expect(json_response['error']).to match('at least one parameter must be provided')
+    end
+
     context 'when unauthenticated' do
       it 'returns authentication error' do
         project_param = { name: 'bar' }
diff --git a/spec/requests/api/runner_spec.rb b/spec/requests/api/runner_spec.rb
index 1cfac7353d4..409a59d6c23 100644
--- a/spec/requests/api/runner_spec.rb
+++ b/spec/requests/api/runner_spec.rb
@@ -592,7 +592,7 @@ describe API::Runner do
           update_job(trace: 'BUILD TRACE UPDATED')
 
           expect(response).to have_http_status(200)
-          expect(job.reload.trace).to eq 'BUILD TRACE UPDATED'
+          expect(job.reload.trace.raw).to eq 'BUILD TRACE UPDATED'
         end
       end
 
@@ -600,7 +600,7 @@ describe API::Runner do
         it 'does not override trace information' do
           update_job
 
-          expect(job.reload.trace).to eq 'BUILD TRACE'
+          expect(job.reload.trace.raw).to eq 'BUILD TRACE'
         end
       end
 
@@ -631,7 +631,7 @@ describe API::Runner do
       context 'when request is valid' do
         it 'gets correct response' do
           expect(response.status).to eq 202
-          expect(job.reload.trace).to eq 'BUILD TRACE appended'
+          expect(job.reload.trace.raw).to eq 'BUILD TRACE appended'
           expect(response.header).to have_key 'Range'
           expect(response.header).to have_key 'Job-Status'
         end
@@ -642,7 +642,7 @@ describe API::Runner do
           it "changes the job's trace" do
             patch_the_trace
 
-            expect(job.reload.trace).to eq 'BUILD TRACE appended appended'
+            expect(job.reload.trace.raw).to eq 'BUILD TRACE appended appended'
           end
 
           context 'when Runner makes a force-patch' do
@@ -651,7 +651,7 @@ describe API::Runner do
             it "doesn't change the build.trace" do
               force_patch_the_trace
 
-              expect(job.reload.trace).to eq 'BUILD TRACE appended'
+              expect(job.reload.trace.raw).to eq 'BUILD TRACE appended'
             end
           end
         end
@@ -664,7 +664,7 @@ describe API::Runner do
           it 'changes the job.trace' do
             patch_the_trace
 
-            expect(job.reload.trace).to eq 'BUILD TRACE appended appended'
+            expect(job.reload.trace.raw).to eq 'BUILD TRACE appended appended'
           end
 
           context 'when Runner makes a force-patch' do
@@ -673,7 +673,7 @@ describe API::Runner do
             it "doesn't change the job.trace" do
               force_patch_the_trace
 
-              expect(job.reload.trace).to eq 'BUILD TRACE appended'
+              expect(job.reload.trace.raw).to eq 'BUILD TRACE appended'
             end
           end
         end
@@ -698,7 +698,7 @@ describe API::Runner do
 
         it 'gets correct response' do
           expect(response.status).to eq 202
-          expect(job.reload.trace).to eq 'BUILD TRACE appended'
+          expect(job.reload.trace.raw).to eq 'BUILD TRACE appended'
           expect(response.header).to have_key 'Range'
           expect(response.header).to have_key 'Job-Status'
         end
@@ -738,9 +738,11 @@ describe API::Runner do
 
       def patch_the_trace(content = ' appended', request_headers = nil)
         unless request_headers
-          offset = job.trace_length
-          limit = offset + content.length - 1
-          request_headers = headers.merge({ 'Content-Range' => "#{offset}-#{limit}" })
+          job.trace.read do |stream|
+            offset = stream.size
+            limit = offset + content.length - 1
+            request_headers = headers.merge({ 'Content-Range' => "#{offset}-#{limit}" })
+          end
         end
 
         Timecop.travel(job.updated_at + update_interval) do
diff --git a/spec/requests/api/session_spec.rb b/spec/requests/api/session_spec.rb
index 28fab2011a5..393bf076616 100644
--- a/spec/requests/api/session_spec.rb
+++ b/spec/requests/api/session_spec.rb
@@ -13,7 +13,7 @@ describe API::Session, api: true  do
 
         expect(json_response['email']).to eq(user.email)
         expect(json_response['private_token']).to eq(user.private_token)
-        expect(json_response['is_admin']).to eq(user.is_admin?)
+        expect(json_response['is_admin']).to eq(user.admin?)
         expect(json_response['can_create_project']).to eq(user.can_create_project?)
         expect(json_response['can_create_group']).to eq(user.can_create_group?)
       end
@@ -37,7 +37,7 @@ describe API::Session, api: true  do
 
         expect(json_response['email']).to eq user.email
         expect(json_response['private_token']).to eq user.private_token
-        expect(json_response['is_admin']).to eq user.is_admin?
+        expect(json_response['is_admin']).to eq user.admin?
         expect(json_response['can_create_project']).to eq user.can_create_project?
         expect(json_response['can_create_group']).to eq user.can_create_group?
       end
@@ -50,7 +50,7 @@ describe API::Session, api: true  do
 
         expect(json_response['email']).to eq user.email
         expect(json_response['private_token']).to eq user.private_token
-        expect(json_response['is_admin']).to eq user.is_admin?
+        expect(json_response['is_admin']).to eq user.admin?
         expect(json_response['can_create_project']).to eq user.can_create_project?
         expect(json_response['can_create_group']).to eq user.can_create_group?
       end
diff --git a/spec/requests/api/v3/builds_spec.rb b/spec/requests/api/v3/builds_spec.rb
index a50c22a6dd1..e97d2b0cee0 100644
--- a/spec/requests/api/v3/builds_spec.rb
+++ b/spec/requests/api/v3/builds_spec.rb
@@ -330,7 +330,7 @@ describe API::V3::Builds, api: true do
     context 'authorized user' do
       it 'returns specific job trace' do
         expect(response).to have_http_status(200)
-        expect(response.body).to eq(build.trace)
+        expect(response.body).to eq(build.trace.raw)
       end
     end
 
@@ -418,7 +418,7 @@ describe API::V3::Builds, api: true do
 
       it 'erases job content' do
         expect(response.status).to eq 201
-        expect(build.trace).to be_empty
+        expect(build).not_to have_trace
         expect(build.artifacts_file.exists?).to be_falsy
         expect(build.artifacts_metadata.exists?).to be_falsy
       end
diff --git a/spec/requests/api/v3/issues_spec.rb b/spec/requests/api/v3/issues_spec.rb
index b1b398a897e..91d9057075f 100644
--- a/spec/requests/api/v3/issues_spec.rb
+++ b/spec/requests/api/v3/issues_spec.rb
@@ -824,7 +824,7 @@ describe API::V3::Issues, api: true  do
     end
 
     context 'resolving issues in a merge request' do
-      let(:discussion) { Discussion.for_diff_notes([create(:diff_note_on_merge_request)]).first }
+      let(:discussion) { create(:diff_note_on_merge_request).to_discussion }
       let(:merge_request) { discussion.noteable }
       let(:project) { merge_request.source_project }
       before do
diff --git a/spec/requests/ci/api/builds_spec.rb b/spec/requests/ci/api/builds_spec.rb
index c879f37f50d..ef30d8638dd 100644
--- a/spec/requests/ci/api/builds_spec.rb
+++ b/spec/requests/ci/api/builds_spec.rb
@@ -285,7 +285,7 @@ describe Ci::API::Builds do
       end
 
       it 'does not override trace information when no trace is given' do
-        expect(build.reload.trace).to eq 'BUILD TRACE'
+        expect(build.reload.trace.raw).to eq 'BUILD TRACE'
       end
 
       context 'job has been erased' do
@@ -309,9 +309,11 @@ describe Ci::API::Builds do
 
       def patch_the_trace(content = ' appended', request_headers = nil)
         unless request_headers
-          offset = build.trace_length
-          limit = offset + content.length - 1
-          request_headers = headers.merge({ 'Content-Range' => "#{offset}-#{limit}" })
+          build.trace.read do |stream|
+            offset = stream.size
+            limit = offset + content.length - 1
+            request_headers = headers.merge({ 'Content-Range' => "#{offset}-#{limit}" })
+          end
         end
 
         Timecop.travel(build.updated_at + update_interval) do
@@ -335,7 +337,7 @@ describe Ci::API::Builds do
       context 'when request is valid' do
         it 'gets correct response' do
           expect(response.status).to eq 202
-          expect(build.reload.trace).to eq 'BUILD TRACE appended'
+          expect(build.reload.trace.raw).to eq 'BUILD TRACE appended'
           expect(response.header).to have_key 'Range'
           expect(response.header).to have_key 'Build-Status'
         end
@@ -346,7 +348,7 @@ describe Ci::API::Builds do
           it 'changes the build trace' do
             patch_the_trace
 
-            expect(build.reload.trace).to eq 'BUILD TRACE appended appended'
+            expect(build.reload.trace.raw).to eq 'BUILD TRACE appended appended'
           end
 
           context 'when Runner makes a force-patch' do
@@ -355,7 +357,7 @@ describe Ci::API::Builds do
             it "doesn't change the build.trace" do
               force_patch_the_trace
 
-              expect(build.reload.trace).to eq 'BUILD TRACE appended'
+              expect(build.reload.trace.raw).to eq 'BUILD TRACE appended'
             end
           end
         end
@@ -368,7 +370,7 @@ describe Ci::API::Builds do
           it 'changes the build.trace' do
             patch_the_trace
 
-            expect(build.reload.trace).to eq 'BUILD TRACE appended appended'
+            expect(build.reload.trace.raw).to eq 'BUILD TRACE appended appended'
           end
 
           context 'when Runner makes a force-patch' do
@@ -377,7 +379,7 @@ describe Ci::API::Builds do
             it "doesn't change the build.trace" do
               force_patch_the_trace
 
-              expect(build.reload.trace).to eq 'BUILD TRACE appended'
+              expect(build.reload.trace.raw).to eq 'BUILD TRACE appended'
             end
           end
         end
@@ -403,7 +405,7 @@ describe Ci::API::Builds do
 
         it 'gets correct response' do
           expect(response.status).to eq 202
-          expect(build.reload.trace).to eq 'BUILD TRACE appended'
+          expect(build.reload.trace.raw).to eq 'BUILD TRACE appended'
           expect(response.header).to have_key 'Range'
           expect(response.header).to have_key 'Build-Status'
         end
diff --git a/spec/serializers/pipeline_serializer_spec.rb b/spec/serializers/pipeline_serializer_spec.rb
index 8642b803844..f6249ab4664 100644
--- a/spec/serializers/pipeline_serializer_spec.rb
+++ b/spec/serializers/pipeline_serializer_spec.rb
@@ -93,6 +93,44 @@ describe PipelineSerializer do
         end
       end
     end
+
+    context 'number of queries' do
+      let(:resource) { Ci::Pipeline.all }
+      let(:project) { create(:empty_project) }
+
+      before do
+        Ci::Pipeline::AVAILABLE_STATUSES.each do |status|
+          create_pipeline(status)
+        end
+
+        RequestStore.begin!
+      end
+
+      after do
+        RequestStore.end!
+        RequestStore.clear!
+      end
+
+      it "verifies number of queries" do
+        recorded = ActiveRecord::QueryRecorder.new { subject }
+        expect(recorded.count).to be_within(1).of(50)
+        expect(recorded.cached_count).to eq(0)
+      end
+
+      def create_pipeline(status)
+        create(:ci_empty_pipeline, project: project, status: status).tap do |pipeline|
+          Ci::Build::AVAILABLE_STATUSES.each do |status|
+            create_build(pipeline, status, status)
+          end
+        end
+      end
+
+      def create_build(pipeline, stage, status)
+        create(:ci_build, :tags, :triggered, :artifacts,
+          pipeline: pipeline, stage: stage,
+          name: stage, status: status)
+      end
+    end
   end
 
   describe '#represent_status' do
diff --git a/spec/services/auth/container_registry_authentication_service_spec.rb b/spec/services/auth/container_registry_authentication_service_spec.rb
index b91234ddb1e..e273dfe1552 100644
--- a/spec/services/auth/container_registry_authentication_service_spec.rb
+++ b/spec/services/auth/container_registry_authentication_service_spec.rb
@@ -6,14 +6,15 @@ describe Auth::ContainerRegistryAuthenticationService, services: true do
   let(:current_params) { {} }
   let(:rsa_key) { OpenSSL::PKey::RSA.generate(512) }
   let(:payload) { JWT.decode(subject[:token], rsa_key).first }
+
   let(:authentication_abilities) do
-    [
-      :read_container_image,
-      :create_container_image
-    ]
+    [:read_container_image, :create_container_image]
   end
 
-  subject { described_class.new(current_project, current_user, current_params).execute(authentication_abilities: authentication_abilities) }
+  subject do
+    described_class.new(current_project, current_user, current_params)
+      .execute(authentication_abilities: authentication_abilities)
+  end
 
   before do
     allow(Gitlab.config.registry).to receive_messages(enabled: true, issuer: 'rspec', key: nil)
@@ -40,13 +41,11 @@ describe Auth::ContainerRegistryAuthenticationService, services: true do
     end
   end
 
-  shared_examples 'a accessible' do
+  shared_examples 'an accessible' do
     let(:access) do
-      [{
-         'type' => 'repository',
+      [{ 'type' => 'repository',
          'name' => project.path_with_namespace,
-         'actions' => actions,
-       }]
+         'actions' => actions }]
     end
 
     it_behaves_like 'a valid token'
@@ -59,19 +58,19 @@ describe Auth::ContainerRegistryAuthenticationService, services: true do
   end
 
   shared_examples 'a pullable' do
-    it_behaves_like 'a accessible' do
+    it_behaves_like 'an accessible' do
       let(:actions) { ['pull'] }
     end
   end
 
   shared_examples 'a pushable' do
-    it_behaves_like 'a accessible' do
+    it_behaves_like 'an accessible' do
       let(:actions) { ['push'] }
     end
   end
 
   shared_examples 'a pullable and pushable' do
-    it_behaves_like 'a accessible' do
+    it_behaves_like 'an accessible' do
       let(:actions) { %w(pull push) }
     end
   end
@@ -81,15 +80,30 @@ describe Auth::ContainerRegistryAuthenticationService, services: true do
     it { is_expected.not_to include(:token) }
   end
 
+  shared_examples 'container repository factory' do
+    it 'creates a new container repository resource' do
+      expect { subject }
+        .to change { project.container_repositories.count }.by(1)
+    end
+  end
+
+  shared_examples 'not a container repository factory' do
+    it 'does not create a new container repository resource' do
+      expect { subject }.not_to change { ContainerRepository.count }
+    end
+  end
+
   describe '#full_access_token' do
     let(:project) { create(:empty_project) }
     let(:token) { described_class.full_access_token(project.path_with_namespace) }
 
     subject { { token: token } }
 
-    it_behaves_like 'a accessible' do
+    it_behaves_like 'an accessible' do
       let(:actions) { ['*'] }
     end
+
+    it_behaves_like 'not a container repository factory'
   end
 
   context 'user authorization' do
@@ -110,16 +124,20 @@ describe Auth::ContainerRegistryAuthenticationService, services: true do
         end
 
         it_behaves_like 'a pushable'
+        it_behaves_like 'container repository factory'
       end
 
       context 'allow reporter to pull images' do
         before { project.team << [current_user, :reporter] }
 
-        let(:current_params) do
-          { scope: "repository:#{project.path_with_namespace}:pull" }
-        end
+        context 'when pulling from root level repository' do
+          let(:current_params) do
+            { scope: "repository:#{project.path_with_namespace}:pull" }
+          end
 
-        it_behaves_like 'a pullable'
+          it_behaves_like 'a pullable'
+          it_behaves_like 'not a container repository factory'
+        end
       end
 
       context 'return a least of privileges' do
@@ -130,6 +148,7 @@ describe Auth::ContainerRegistryAuthenticationService, services: true do
         end
 
         it_behaves_like 'a pullable'
+        it_behaves_like 'not a container repository factory'
       end
 
       context 'disallow guest to pull or push images' do
@@ -140,6 +159,7 @@ describe Auth::ContainerRegistryAuthenticationService, services: true do
         end
 
         it_behaves_like 'an inaccessible'
+        it_behaves_like 'not a container repository factory'
       end
     end
 
@@ -152,6 +172,7 @@ describe Auth::ContainerRegistryAuthenticationService, services: true do
         end
 
         it_behaves_like 'a pullable'
+        it_behaves_like 'not a container repository factory'
       end
 
       context 'disallow anyone to push images' do
@@ -160,6 +181,16 @@ describe Auth::ContainerRegistryAuthenticationService, services: true do
         end
 
         it_behaves_like 'an inaccessible'
+        it_behaves_like 'not a container repository factory'
+      end
+
+      context 'when repository name is invalid' do
+        let(:current_params) do
+          { scope: 'repository:invalid:push' }
+        end
+
+        it_behaves_like 'an inaccessible'
+        it_behaves_like 'not a container repository factory'
       end
     end
 
@@ -173,6 +204,7 @@ describe Auth::ContainerRegistryAuthenticationService, services: true do
           end
 
           it_behaves_like 'a pullable'
+          it_behaves_like 'not a container repository factory'
         end
 
         context 'disallow anyone to push images' do
@@ -181,6 +213,7 @@ describe Auth::ContainerRegistryAuthenticationService, services: true do
           end
 
           it_behaves_like 'an inaccessible'
+          it_behaves_like 'not a container repository factory'
         end
       end
 
@@ -191,6 +224,7 @@ describe Auth::ContainerRegistryAuthenticationService, services: true do
         end
 
         it_behaves_like 'an inaccessible'
+        it_behaves_like 'not a container repository factory'
       end
     end
   end
@@ -198,11 +232,9 @@ describe Auth::ContainerRegistryAuthenticationService, services: true do
   context 'build authorized as user' do
     let(:current_project) { create(:empty_project) }
     let(:current_user) { create(:user) }
+
     let(:authentication_abilities) do
-      [
-        :build_read_container_image,
-        :build_create_container_image
-      ]
+      [:build_read_container_image, :build_create_container_image]
     end
 
     before do
@@ -219,6 +251,10 @@ describe Auth::ContainerRegistryAuthenticationService, services: true do
       it_behaves_like 'a pullable and pushable' do
         let(:project) { current_project }
       end
+
+      it_behaves_like 'container repository factory' do
+        let(:project) { current_project }
+      end
     end
 
     context 'for other projects' do
@@ -231,11 +267,13 @@ describe Auth::ContainerRegistryAuthenticationService, services: true do
           let(:project) { create(:empty_project, :public) }
 
           it_behaves_like 'a pullable'
+          it_behaves_like 'not a container repository factory'
         end
 
         shared_examples 'pullable for being team member' do
           context 'when you are not member' do
             it_behaves_like 'an inaccessible'
+            it_behaves_like 'not a container repository factory'
           end
 
           context 'when you are member' do
@@ -244,12 +282,14 @@ describe Auth::ContainerRegistryAuthenticationService, services: true do
             end
 
             it_behaves_like 'a pullable'
+            it_behaves_like 'not a container repository factory'
           end
 
           context 'when you are owner' do
             let(:project) { create(:empty_project, namespace: current_user.namespace) }
 
             it_behaves_like 'a pullable'
+            it_behaves_like 'not a container repository factory'
           end
         end
 
@@ -263,6 +303,7 @@ describe Auth::ContainerRegistryAuthenticationService, services: true do
 
             context 'when you are not member' do
               it_behaves_like 'an inaccessible'
+              it_behaves_like 'not a container repository factory'
             end
 
             context 'when you are member' do
@@ -271,12 +312,14 @@ describe Auth::ContainerRegistryAuthenticationService, services: true do
               end
 
               it_behaves_like 'a pullable'
+              it_behaves_like 'not a container repository factory'
             end
 
             context 'when you are owner' do
               let(:project) { create(:empty_project, namespace: current_user.namespace) }
 
               it_behaves_like 'a pullable'
+              it_behaves_like 'not a container repository factory'
             end
           end
         end
@@ -296,12 +339,14 @@ describe Auth::ContainerRegistryAuthenticationService, services: true do
             end
 
             it_behaves_like 'an inaccessible'
+            it_behaves_like 'not a container repository factory'
           end
 
           context 'when you are owner' do
             let(:project) { create(:empty_project, :public, namespace: current_user.namespace) }
 
             it_behaves_like 'an inaccessible'
+            it_behaves_like 'not a container repository factory'
           end
         end
       end
@@ -318,6 +363,7 @@ describe Auth::ContainerRegistryAuthenticationService, services: true do
         end
 
         it_behaves_like 'an inaccessible'
+        it_behaves_like 'not a container repository factory'
       end
     end
   end
@@ -325,6 +371,7 @@ describe Auth::ContainerRegistryAuthenticationService, services: true do
   context 'unauthorized' do
     context 'disallow to use scope-less authentication' do
       it_behaves_like 'a forbidden'
+      it_behaves_like 'not a container repository factory'
     end
 
     context 'for invalid scope' do
@@ -333,6 +380,7 @@ describe Auth::ContainerRegistryAuthenticationService, services: true do
       end
 
       it_behaves_like 'a forbidden'
+      it_behaves_like 'not a container repository factory'
     end
 
     context 'for private project' do
@@ -354,6 +402,7 @@ describe Auth::ContainerRegistryAuthenticationService, services: true do
         end
 
         it_behaves_like 'a pullable'
+        it_behaves_like 'not a container repository factory'
       end
 
       context 'when pushing' do
@@ -362,6 +411,7 @@ describe Auth::ContainerRegistryAuthenticationService, services: true do
         end
 
         it_behaves_like 'a forbidden'
+        it_behaves_like 'not a container repository factory'
       end
     end
   end
diff --git a/spec/services/ci/create_pipeline_service_spec.rb b/spec/services/ci/create_pipeline_service_spec.rb
index d2f0337c260..fa5014cee07 100644
--- a/spec/services/ci/create_pipeline_service_spec.rb
+++ b/spec/services/ci/create_pipeline_service_spec.rb
@@ -9,72 +9,140 @@ describe Ci::CreatePipelineService, services: true do
   end
 
   describe '#execute' do
-    def execute(params)
+    def execute_service(after: project.commit.id, message: 'Message', ref: 'refs/heads/master')
+      params = { ref: ref,
+                 before: '00000000',
+                 after: after,
+                 commits: [{ message: message }] }
+
       described_class.new(project, user, params).execute
     end
 
     context 'valid params' do
-      let(:pipeline) do
-        execute(ref: 'refs/heads/master',
-                before: '00000000',
-                after: project.commit.id,
-                commits: [{ message: "Message" }])
+      let(:pipeline) { execute_service }
+
+      let(:pipeline_on_previous_commit) do
+        execute_service(
+          after: previous_commit_sha_from_ref('master')
+        )
       end
 
       it { expect(pipeline).to be_kind_of(Ci::Pipeline) }
       it { expect(pipeline).to be_valid }
-      it { expect(pipeline).to be_persisted }
       it { expect(pipeline).to eq(project.pipelines.last) }
       it { expect(pipeline).to have_attributes(user: user) }
+      it { expect(pipeline).to have_attributes(status: 'pending') }
       it { expect(pipeline.builds.first).to be_kind_of(Ci::Build) }
+
+      context 'auto-cancel enabled' do
+        before do
+          project.update(auto_cancel_pending_pipelines: 'enabled')
+        end
+
+        it 'does not cancel HEAD pipeline' do
+          pipeline
+          pipeline_on_previous_commit
+
+          expect(pipeline.reload).to have_attributes(status: 'pending', auto_canceled_by_id: nil)
+        end
+
+        it 'auto cancel pending non-HEAD pipelines' do
+          pipeline_on_previous_commit
+          pipeline
+
+          expect(pipeline_on_previous_commit.reload).to have_attributes(status: 'canceled', auto_canceled_by_id: pipeline.id)
+        end
+
+        it 'does not cancel running outdated pipelines' do
+          pipeline_on_previous_commit.run
+          execute_service
+
+          expect(pipeline_on_previous_commit.reload).to have_attributes(status: 'running', auto_canceled_by_id: nil)
+        end
+
+        it 'cancel created outdated pipelines' do
+          pipeline_on_previous_commit.update(status: 'created')
+          pipeline
+
+          expect(pipeline_on_previous_commit.reload).to have_attributes(status: 'canceled', auto_canceled_by_id: pipeline.id)
+        end
+
+        it 'does not cancel pipelines from the other branches' do
+          pending_pipeline = execute_service(
+            ref: 'refs/heads/feature',
+            after: previous_commit_sha_from_ref('feature')
+          )
+          pipeline
+
+          expect(pending_pipeline.reload).to have_attributes(status: 'pending', auto_canceled_by_id: nil)
+        end
+      end
+
+      context 'auto-cancel disabled' do
+        before do
+          project.update(auto_cancel_pending_pipelines: 'disabled')
+        end
+
+        it 'does not auto cancel pending non-HEAD pipelines' do
+          pipeline_on_previous_commit
+          pipeline
+
+          expect(pipeline_on_previous_commit.reload)
+            .to have_attributes(status: 'pending', auto_canceled_by_id: nil)
+        end
+      end
+
+      def previous_commit_sha_from_ref(ref)
+        project.commit(ref).parent.sha
+      end
     end
 
     context "skip tag if there is no build for it" do
       it "creates commit if there is appropriate job" do
-        result = execute(ref: 'refs/heads/master',
-                         before: '00000000',
-                         after: project.commit.id,
-                         commits: [{ message: "Message" }])
-        expect(result).to be_persisted
+        expect(execute_service).to be_persisted
       end
 
       it "creates commit if there is no appropriate job but deploy job has right ref setting" do
         config = YAML.dump({ deploy: { script: "ls", only: ["master"] } })
         stub_ci_pipeline_yaml_file(config)
-        result = execute(ref: 'refs/heads/master',
-                         before: '00000000',
-                         after: project.commit.id,
-                         commits: [{ message: "Message" }])
 
-        expect(result).to be_persisted
+        expect(execute_service).to be_persisted
       end
     end
 
     it 'skips creating pipeline for refs without .gitlab-ci.yml' do
       stub_ci_pipeline_yaml_file(nil)
-      result = execute(ref: 'refs/heads/master',
-                       before: '00000000',
-                       after: project.commit.id,
-                       commits: [{ message: 'Message' }])
 
-      expect(result).not_to be_persisted
+      expect(execute_service).not_to be_persisted
       expect(Ci::Pipeline.count).to eq(0)
     end
 
-    it 'fails commits if yaml is invalid' do
-      message = 'message'
-      allow_any_instance_of(Ci::Pipeline).to receive(:git_commit_message) { message }
-      stub_ci_pipeline_yaml_file('invalid: file: file')
-      commits = [{ message: message }]
-      pipeline = execute(ref: 'refs/heads/master',
-                         before: '00000000',
-                         after: project.commit.id,
-                         commits: commits)
-
-      expect(pipeline).to be_persisted
-      expect(pipeline.builds.any?).to be false
-      expect(pipeline.status).to eq('failed')
-      expect(pipeline.yaml_errors).not_to be_nil
+    shared_examples 'a failed pipeline' do
+      it 'creates failed pipeline' do
+        stub_ci_pipeline_yaml_file(ci_yaml)
+
+        pipeline = execute_service(message: message)
+
+        expect(pipeline).to be_persisted
+        expect(pipeline.builds.any?).to be false
+        expect(pipeline.status).to eq('failed')
+        expect(pipeline.yaml_errors).not_to be_nil
+      end
+    end
+
+    context 'when yaml is invalid' do
+      let(:ci_yaml) { 'invalid: file: fiile' }
+      let(:message) { 'Message' }
+
+      it_behaves_like 'a failed pipeline'
+
+      context 'when receive git commit' do
+        before do
+          allow_any_instance_of(Ci::Pipeline).to receive(:git_commit_message) { message }
+        end
+
+        it_behaves_like 'a failed pipeline'
+      end
     end
 
     context 'when commit contains a [ci skip] directive' do
@@ -97,11 +165,7 @@ describe Ci::CreatePipelineService, services: true do
 
       ci_messages.each do |ci_message|
         it "skips builds creation if the commit message is #{ci_message}" do
-          commits = [{ message: ci_message }]
-          pipeline = execute(ref: 'refs/heads/master',
-                             before: '00000000',
-                             after: project.commit.id,
-                             commits: commits)
+          pipeline = execute_service(message: ci_message)
 
           expect(pipeline).to be_persisted
           expect(pipeline.builds.any?).to be false
@@ -109,58 +173,34 @@ describe Ci::CreatePipelineService, services: true do
         end
       end
 
-      it "does not skips builds creation if there is no [ci skip] or [skip ci] tag in commit message" do
-        allow_any_instance_of(Ci::Pipeline).to receive(:git_commit_message) { "some message" }
+      shared_examples 'creating a pipeline' do
+        it 'does not skip pipeline creation' do
+          allow_any_instance_of(Ci::Pipeline).to receive(:git_commit_message) { commit_message }
 
-        commits = [{ message: "some message" }]
-        pipeline = execute(ref: 'refs/heads/master',
-                           before: '00000000',
-                           after: project.commit.id,
-                           commits: commits)
+          pipeline = execute_service(message: commit_message)
 
-        expect(pipeline).to be_persisted
-        expect(pipeline.builds.first.name).to eq("rspec")
+          expect(pipeline).to be_persisted
+          expect(pipeline.builds.first.name).to eq("rspec")
+        end
       end
 
-      it "does not skip builds creation if the commit message is nil" do
-        allow_any_instance_of(Ci::Pipeline).to receive(:git_commit_message) { nil }
-
-        commits = [{ message: nil }]
-        pipeline = execute(ref: 'refs/heads/master',
-                           before: '00000000',
-                           after: project.commit.id,
-                           commits: commits)
+      context 'when commit message does not contain [ci skip] nor [skip ci]' do
+        let(:commit_message) { 'some message' }
 
-        expect(pipeline).to be_persisted
-        expect(pipeline.builds.first.name).to eq("rspec")
+        it_behaves_like 'creating a pipeline'
       end
 
-      it "fails builds creation if there is [ci skip] tag in commit message and yaml is invalid" do
-        stub_ci_pipeline_yaml_file('invalid: file: fiile')
-        commits = [{ message: message }]
-        pipeline = execute(ref: 'refs/heads/master',
-                           before: '00000000',
-                           after: project.commit.id,
-                           commits: commits)
+      context 'when commit message is nil' do
+        let(:commit_message) { nil }
 
-        expect(pipeline).to be_persisted
-        expect(pipeline.builds.any?).to be false
-        expect(pipeline.status).to eq("failed")
-        expect(pipeline.yaml_errors).not_to be_nil
+        it_behaves_like 'creating a pipeline'
       end
-    end
 
-    it "creates commit with failed status if yaml is invalid" do
-      stub_ci_pipeline_yaml_file('invalid: file')
-      commits = [{ message: "some message" }]
-      pipeline = execute(ref: 'refs/heads/master',
-                         before: '00000000',
-                         after: project.commit.id,
-                         commits: commits)
-
-      expect(pipeline).to be_persisted
-      expect(pipeline.status).to eq("failed")
-      expect(pipeline.builds.any?).to be false
+      context 'when there is [ci skip] tag in commit message and yaml is invalid' do
+        let(:ci_yaml) { 'invalid: file: fiile' }
+
+        it_behaves_like 'a failed pipeline'
+      end
     end
 
     context 'when there are no jobs for this pipeline' do
@@ -170,10 +210,7 @@ describe Ci::CreatePipelineService, services: true do
       end
 
       it 'does not create a new pipeline' do
-        result = execute(ref: 'refs/heads/master',
-                         before: '00000000',
-                         after: project.commit.id,
-                         commits: [{ message: 'some msg' }])
+        result = execute_service
 
         expect(result).not_to be_persisted
         expect(Ci::Build.all).to be_empty
@@ -188,10 +225,7 @@ describe Ci::CreatePipelineService, services: true do
       end
 
       it 'does not create a new pipeline' do
-        result = execute(ref: 'refs/heads/master',
-                         before: '00000000',
-                         after: project.commit.id,
-                         commits: [{ message: 'some msg' }])
+        result = execute_service
 
         expect(result).to be_persisted
         expect(result.manual_actions).not_to be_empty
@@ -205,10 +239,7 @@ describe Ci::CreatePipelineService, services: true do
       end
 
       it 'creates the environment' do
-        result = execute(ref: 'refs/heads/master',
-                         before: '00000000',
-                         after: project.commit.id,
-                         commits: [{ message: 'some msg' }])
+        result = execute_service
 
         expect(result).to be_persisted
         expect(Environment.find_by(name: "review/master")).not_to be_nil
diff --git a/spec/services/ci/expire_pipeline_cache_service_spec.rb b/spec/services/ci/expire_pipeline_cache_service_spec.rb
new file mode 100644
index 00000000000..166c6dfc93e
--- /dev/null
+++ b/spec/services/ci/expire_pipeline_cache_service_spec.rb
@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe Ci::ExpirePipelineCacheService, services: true do
+  let(:user) { create(:user) }
+  let(:project) { create(:empty_project) }
+  let(:pipeline) { create(:ci_pipeline, project: project) }
+  subject { described_class.new(project, user) }
+
+  describe '#execute' do
+    it 'invalidate Etag caching for project pipelines path' do
+      pipelines_path = "/#{project.full_path}/pipelines.json"
+      new_mr_pipelines_path = "/#{project.full_path}/merge_requests/new.json"
+
+      expect_any_instance_of(Gitlab::EtagCaching::Store).to receive(:touch).with(pipelines_path)
+      expect_any_instance_of(Gitlab::EtagCaching::Store).to receive(:touch).with(new_mr_pipelines_path)
+
+      subject.execute(pipeline)
+    end
+
+    it 'updates the cached status for a project' do
+      expect(Gitlab::Cache::Ci::ProjectPipelineStatus).to receive(:update_for_pipeline).
+                                                            with(pipeline)
+
+      subject.execute(pipeline)
+    end
+  end
+end
diff --git a/spec/services/ci/process_pipeline_service_spec.rb b/spec/services/ci/process_pipeline_service_spec.rb
index 7df6a81b0ab..cf773866a6f 100644
--- a/spec/services/ci/process_pipeline_service_spec.rb
+++ b/spec/services/ci/process_pipeline_service_spec.rb
@@ -469,7 +469,9 @@ describe Ci::ProcessPipelineService, '#execute', :services do
     builds.find_by(name: name).play(user)
   end
 
-  delegate :manual_actions, to: :pipeline
+  def manual_actions
+    pipeline.manual_actions(true)
+  end
 
   def create_build(name, **opts)
     create(:ci_build, :created, pipeline: pipeline, name: name, **opts)
diff --git a/spec/services/ci/retry_build_service_spec.rb b/spec/services/ci/retry_build_service_spec.rb
index 8567817147b..b2d37657770 100644
--- a/spec/services/ci/retry_build_service_spec.rb
+++ b/spec/services/ci/retry_build_service_spec.rb
@@ -16,20 +16,21 @@ describe Ci::RetryBuildService, :services do
     %i[id status user token coverage trace runner artifacts_expire_at
        artifacts_file artifacts_metadata artifacts_size created_at
        updated_at started_at finished_at queued_at erased_by
-       erased_at].freeze
+       erased_at auto_canceled_by].freeze
 
   IGNORE_ACCESSORS =
     %i[type lock_version target_url base_tags
        commit_id deployments erased_by_id last_deployment project_id
        runner_id tag_taggings taggings tags trigger_request_id
-       user_id].freeze
+       user_id auto_canceled_by_id].freeze
 
   shared_examples 'build duplication' do
     let(:build) do
       create(:ci_build, :failed, :artifacts_expired, :erased,
              :queued, :coverage, :tags, :allowed_to_fail, :on_tag,
              :teardown_environment, :triggered, :trace,
-             description: 'some build', pipeline: pipeline)
+             description: 'some build', pipeline: pipeline,
+             auto_canceled_by: create(:ci_empty_pipeline))
     end
 
     describe 'clone accessors' do
diff --git a/spec/services/discussions/resolve_service_spec.rb b/spec/services/discussions/resolve_service_spec.rb
index 12c3cdf28c6..ab8df7b74cd 100644
--- a/spec/services/discussions/resolve_service_spec.rb
+++ b/spec/services/discussions/resolve_service_spec.rb
@@ -2,7 +2,7 @@ require 'spec_helper'
 
 describe Discussions::ResolveService do
   describe '#execute' do
-    let(:discussion) { Discussion.for_diff_notes([create(:diff_note_on_merge_request)]).first }
+    let(:discussion) { create(:diff_note_on_merge_request).to_discussion }
     let(:project) { merge_request.project }
     let(:merge_request) { discussion.noteable }
     let(:user) { create(:user) }
@@ -41,7 +41,7 @@ describe Discussions::ResolveService do
     end
 
     it 'can resolve multiple discussions at once' do
-      other_discussion = Discussion.for_diff_notes([create(:diff_note_on_merge_request, noteable: discussion.noteable, project: discussion.noteable.source_project)]).first
+      other_discussion = create(:diff_note_on_merge_request, noteable: discussion.noteable, project: discussion.noteable.source_project).to_discussion
 
       service.execute([discussion, other_discussion])
 
diff --git a/spec/services/issues/build_service_spec.rb b/spec/services/issues/build_service_spec.rb
index 17990f41b3b..55d635235b0 100644
--- a/spec/services/issues/build_service_spec.rb
+++ b/spec/services/issues/build_service_spec.rb
@@ -11,7 +11,7 @@ describe Issues::BuildService, services: true do
   context 'for a single discussion' do
     describe '#execute' do
       let(:merge_request) { create(:merge_request, title: "Hello world", source_project: project) }
-      let(:discussion) { Discussion.new([create(:diff_note_on_merge_request, project: project, noteable: merge_request, note: "Almost done")]) }
+      let(:discussion) { create(:diff_note_on_merge_request, project: project, noteable: merge_request, note: "Almost done").to_discussion }
       let(:service) { described_class.new(project, user, merge_request_to_resolve_discussions_of: merge_request.iid, discussion_to_resolve: discussion.id) }
 
       it 'references the noteable title in the issue title' do
@@ -47,7 +47,7 @@ describe Issues::BuildService, services: true do
       let(:service) { described_class.new(project, user, merge_request_to_resolve_discussions_of: merge_request.iid) }
 
       it 'mentions the author of the note' do
-        discussion = Discussion.new([create(:diff_note_on_merge_request, author: create(:user, username: 'author'))])
+        discussion = create(:diff_note_on_merge_request, author: create(:user, username: 'author')).to_discussion
         expect(service.item_for_discussion(discussion)).to include('@author')
       end
 
@@ -60,7 +60,7 @@ describe Issues::BuildService, services: true do
         note_result = "    > This is a string\n"\
                       "    > > with a blockquote\n"\
                       "    > > > That has a quote\n"
-        discussion = Discussion.new([create(:diff_note_on_merge_request, note: note_text)])
+        discussion = create(:diff_note_on_merge_request, note: note_text).to_discussion
         expect(service.item_for_discussion(discussion)).to include(note_result)
       end
     end
@@ -91,25 +91,23 @@ describe Issues::BuildService, services: true do
       end
 
       describe 'with multiple discussions' do
-        before do
-          create(:diff_note_on_merge_request, noteable: merge_request, project: merge_request.target_project, line_number: 15)
-        end
+        let!(:diff_note) { create(:diff_note_on_merge_request, noteable: merge_request, project: merge_request.target_project, line_number: 15) }
 
         it 'mentions all the authors in the description' do
-          authors = merge_request.diff_discussions.map(&:author)
+          authors = merge_request.resolvable_discussions.map(&:author)
 
           expect(issue.description).to include(*authors.map(&:to_reference))
         end
 
         it 'has a link for each unresolved discussion in the description' do
-          notes = merge_request.diff_discussions.map(&:first_note)
+          notes = merge_request.resolvable_discussions.map(&:first_note)
           links = notes.map { |note| Gitlab::UrlBuilder.build(note) }
 
           expect(issue.description).to include(*links)
         end
 
         it 'mentions additional notes' do
-          create_list(:diff_note_on_merge_request, 2, noteable: merge_request, project: merge_request.target_project, line_number: 15)
+          create_list(:diff_note_on_merge_request, 2, noteable: merge_request, project: merge_request.target_project, in_reply_to: diff_note)
 
           expect(issue.description).to include('(+2 comments)')
         end
diff --git a/spec/services/issues/create_service_spec.rb b/spec/services/issues/create_service_spec.rb
index 776cbc4296b..80bfb731550 100644
--- a/spec/services/issues/create_service_spec.rb
+++ b/spec/services/issues/create_service_spec.rb
@@ -141,7 +141,7 @@ describe Issues::CreateService, services: true do
     it_behaves_like 'new issuable record that supports slash commands'
 
     context 'resolving discussions' do
-      let(:discussion) { Discussion.for_diff_notes([create(:diff_note_on_merge_request)]).first }
+      let(:discussion) { create(:diff_note_on_merge_request).to_discussion }
       let(:merge_request) { discussion.noteable }
       let(:project) { merge_request.source_project }
 
diff --git a/spec/services/issues/resolve_discussions_spec.rb b/spec/services/issues/resolve_discussions_spec.rb
index 3a72f92383c..4a4929daefc 100644
--- a/spec/services/issues/resolve_discussions_spec.rb
+++ b/spec/services/issues/resolve_discussions_spec.rb
@@ -18,7 +18,7 @@ describe DummyService, services: true do
   end
 
   describe "for resolving discussions" do
-    let(:discussion) { Discussion.new([create(:diff_note_on_merge_request, project: project, note: "Almost done")]) }
+    let(:discussion) { create(:diff_note_on_merge_request, project: project, note: "Almost done").to_discussion }
     let(:merge_request) { discussion.noteable }
     let(:other_merge_request) { create(:merge_request, source_project: project, source_branch: "other") }
 
diff --git a/spec/services/notes/build_service_spec.rb b/spec/services/notes/build_service_spec.rb
new file mode 100644
index 00000000000..f9dd5541b10
--- /dev/null
+++ b/spec/services/notes/build_service_spec.rb
@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+describe Notes::BuildService, services: true do
+  let(:note) { create(:discussion_note_on_issue) }
+  let(:project) { note.project }
+  let(:author) { note.author }
+
+  describe '#execute' do
+    context 'when in_reply_to_discussion_id is specified' do
+      context 'when a note with that original discussion ID exists' do
+        it 'sets the note up to be in reply to that note' do
+          new_note = described_class.new(project, author, note: 'Test', in_reply_to_discussion_id: note.discussion_id).execute
+          expect(new_note).to be_valid
+          expect(new_note.in_reply_to?(note)).to be_truthy
+        end
+      end
+
+      context 'when a note with that discussion ID exists' do
+        it 'sets the note up to be in reply to that note' do
+          new_note = described_class.new(project, author, note: 'Test', in_reply_to_discussion_id: note.discussion_id).execute
+          expect(new_note).to be_valid
+          expect(new_note.in_reply_to?(note)).to be_truthy
+        end
+      end
+
+      context 'when no note with that discussion ID exists' do
+        it 'sets an error' do
+          new_note = described_class.new(project, author, note: 'Test', in_reply_to_discussion_id: 'foo').execute
+          expect(new_note.errors[:base]).to include('Discussion to reply to cannot be found')
+        end
+      end
+    end
+
+    it 'builds a note without saving it' do
+      new_note = described_class.new(project, author, noteable_type: note.noteable_type, noteable_id: note.noteable_id, note: 'Test').execute
+      expect(new_note).to be_valid
+      expect(new_note).not_to be_persisted
+    end
+  end
+end
diff --git a/spec/services/notification_service_spec.rb b/spec/services/notification_service_spec.rb
index e3146a56495..989fd90cda9 100644
--- a/spec/services/notification_service_spec.rb
+++ b/spec/services/notification_service_spec.rb
@@ -439,7 +439,7 @@ describe NotificationService, services: true do
 
           notification.new_note(note)
 
-          expect(SentNotification.last.position).to eq(note.position)
+          expect(SentNotification.last.in_reply_to_discussion_id).to eq(note.discussion_id)
         end
       end
     end
@@ -1181,6 +1181,22 @@ describe NotificationService, services: true do
         should_not_email(@u_disabled)
       end
     end
+
+    describe '#project_exported' do
+      it do
+        notification.project_exported(project, @u_disabled)
+
+        should_only_email(@u_disabled)
+      end
+    end
+
+    describe '#project_not_exported' do
+      it do
+        notification.project_not_exported(project, @u_disabled, ['error'])
+
+        should_only_email(@u_disabled)
+      end
+    end
   end
 
   describe 'GroupMember' do
diff --git a/spec/services/projects/destroy_service_spec.rb b/spec/services/projects/destroy_service_spec.rb
index b1e10f4562e..4b8589b2736 100644
--- a/spec/services/projects/destroy_service_spec.rb
+++ b/spec/services/projects/destroy_service_spec.rb
@@ -7,6 +7,11 @@ describe Projects::DestroyService, services: true do
   let!(:remove_path) { path.sub(/\.git\Z/, "+#{project.id}+deleted.git") }
   let!(:async) { false } # execute or async_execute
 
+  before do
+    stub_container_registry_config(enabled: true)
+    stub_container_registry_tags(repository: :any, tags: [])
+  end
+
   shared_examples 'deleting the project' do
     it 'deletes the project' do
       expect(Project.unscoped.all).not_to include(project)
@@ -89,30 +94,64 @@ describe Projects::DestroyService, services: true do
     it_behaves_like 'deleting the project with pipeline and build'
   end
 
-  context 'container registry' do
-    before do
-      stub_container_registry_config(enabled: true)
-      stub_container_registry_tags('tag')
-    end
+  describe 'container registry' do
+    context 'when there are regular container repositories' do
+      let(:container_repository) { create(:container_repository) }
+
+      before do
+        stub_container_registry_tags(repository: project.full_path + '/image',
+                                     tags: ['tag'])
+        project.container_repositories << container_repository
+      end
+
+      context 'when image repository deletion succeeds' do
+        it 'removes tags' do
+          expect_any_instance_of(ContainerRepository)
+            .to receive(:delete_tags!).and_return(true)
+
+          destroy_project(project, user)
+        end
+      end
 
-    context 'tags deletion succeeds' do
-      it do
-        expect_any_instance_of(ContainerRegistry::Tag).to receive(:delete).and_return(true)
+      context 'when image repository deletion fails' do
+        it 'raises an exception' do
+          expect_any_instance_of(ContainerRepository)
+            .to receive(:delete_tags!).and_return(false)
 
-        destroy_project(project, user, {})
+          expect{ destroy_project(project, user) }
+            .to raise_error(ActiveRecord::RecordNotDestroyed)
+        end
       end
     end
 
-    context 'tags deletion fails' do
-      before { expect_any_instance_of(ContainerRegistry::Tag).to receive(:delete).and_return(false) }
+    context 'when there are tags for legacy root repository' do
+      before do
+        stub_container_registry_tags(repository: project.full_path,
+                                     tags: ['tag'])
+      end
+
+      context 'when image repository tags deletion succeeds' do
+        it 'removes tags' do
+          expect_any_instance_of(ContainerRepository)
+            .to receive(:delete_tags!).and_return(true)
 
-      subject { destroy_project(project, user, {}) }
+          destroy_project(project, user)
+        end
+      end
+
+      context 'when image repository tags deletion fails' do
+        it 'raises an exception' do
+          expect_any_instance_of(ContainerRepository)
+            .to receive(:delete_tags!).and_return(false)
 
-      it { expect{subject}.to raise_error(Projects::DestroyService::DestroyError) }
+          expect { destroy_project(project, user) }
+            .to raise_error(Projects::DestroyService::DestroyError)
+        end
+      end
     end
   end
 
-  def destroy_project(project, user, params)
+  def destroy_project(project, user, params = {})
     if async
       Projects::DestroyService.new(project, user, params).async_execute
     else
diff --git a/spec/services/projects/transfer_service_spec.rb b/spec/services/projects/transfer_service_spec.rb
index f8187fefc14..29ccce59c53 100644
--- a/spec/services/projects/transfer_service_spec.rb
+++ b/spec/services/projects/transfer_service_spec.rb
@@ -29,9 +29,12 @@ describe Projects::TransferService, services: true do
   end
 
   context 'disallow transfering of project with tags' do
+    let(:container_repository) { create(:container_repository) }
+
     before do
       stub_container_registry_config(enabled: true)
-      stub_container_registry_tags('tag')
+      stub_container_registry_tags(repository: :any, tags: ['tag'])
+      project.container_repositories << container_repository
     end
 
     subject { transfer_project(project, user, group) }
diff --git a/spec/services/protected_branches/update_service_spec.rb b/spec/services/protected_branches/update_service_spec.rb
new file mode 100644
index 00000000000..62bdd49a4d7
--- /dev/null
+++ b/spec/services/protected_branches/update_service_spec.rb
@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe ProtectedBranches::UpdateService, services: true do
+  let(:protected_branch) { create(:protected_branch) }
+  let(:project) { protected_branch.project }
+  let(:user) { project.owner }
+  let(:params) { { name: 'new protected branch name' } }
+
+  describe '#execute' do
+    subject(:service) { described_class.new(project, user, params) }
+
+    it 'updates a protected branch' do
+      result = service.execute(protected_branch)
+
+      expect(result.reload.name).to eq(params[:name])
+    end
+
+    context 'without admin_project permissions' do
+      let(:user) { create(:user) }
+
+      it "raises error" do
+        expect{ service.execute(protected_branch) }.to raise_error(Gitlab::Access::AccessDeniedError)
+      end
+    end
+  end
+end
diff --git a/spec/services/protected_tags/create_service_spec.rb b/spec/services/protected_tags/create_service_spec.rb
new file mode 100644
index 00000000000..d91a58e8de5
--- /dev/null
+++ b/spec/services/protected_tags/create_service_spec.rb
@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe ProtectedTags::CreateService, services: true do
+  let(:project) { create(:empty_project) }
+  let(:user) { project.owner }
+  let(:params) do
+    {
+      name: 'master',
+      create_access_levels_attributes: [{ access_level: Gitlab::Access::MASTER }]
+    }
+  end
+
+  describe '#execute' do
+    subject(:service) { described_class.new(project, user, params) }
+
+    it 'creates a new protected tag' do
+      expect { service.execute }.to change(ProtectedTag, :count).by(1)
+      expect(project.protected_tags.last.create_access_levels.map(&:access_level)).to eq([Gitlab::Access::MASTER])
+    end
+  end
+end
diff --git a/spec/services/protected_tags/update_service_spec.rb b/spec/services/protected_tags/update_service_spec.rb
new file mode 100644
index 00000000000..e78fde4c48d
--- /dev/null
+++ b/spec/services/protected_tags/update_service_spec.rb
@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe ProtectedTags::UpdateService, services: true do
+  let(:protected_tag) { create(:protected_tag) }
+  let(:project) { protected_tag.project }
+  let(:user) { project.owner }
+  let(:params) { { name: 'new protected tag name' } }
+
+  describe '#execute' do
+    subject(:service) { described_class.new(project, user, params) }
+
+    it 'updates a protected tag' do
+      result = service.execute(protected_tag)
+
+      expect(result.reload.name).to eq(params[:name])
+    end
+
+    context 'without admin_project permissions' do
+      let(:user) { create(:user) }
+
+      it "raises error" do
+        expect{ service.execute(protected_tag) }.to raise_error(Gitlab::Access::AccessDeniedError)
+      end
+    end
+  end
+end
diff --git a/spec/services/system_note_service_spec.rb b/spec/services/system_note_service_spec.rb
index 5ec1ed8237b..42d63a9f9ba 100644
--- a/spec/services/system_note_service_spec.rb
+++ b/spec/services/system_note_service_spec.rb
@@ -796,7 +796,7 @@ describe SystemNoteService, services: true do
   end
 
   describe '.discussion_continued_in_issue' do
-    let(:discussion) { Discussion.for_diff_notes([create(:diff_note_on_merge_request)]).first }
+    let(:discussion) { create(:diff_note_on_merge_request).to_discussion }
     let(:merge_request) { discussion.noteable }
     let(:project) { merge_request.source_project }
     let(:issue) { create(:issue, project: project) }
diff --git a/spec/services/users/destroy_spec.rb b/spec/services/users/destroy_service_spec.rb
index 66c61b7f8ff..43c18992d1a 100644
--- a/spec/services/users/destroy_spec.rb
+++ b/spec/services/users/destroy_service_spec.rb
@@ -46,43 +46,47 @@ describe Users::DestroyService, services: true do
         project.add_developer(user)
       end
 
-      context "for an issue the user has created" do
-        let!(:issue) { create(:issue, project: project, author: user) }
+      context "for an issue the user was assigned to" do
+        let!(:issue) { create(:issue, project: project, assignee: user) }
 
         before do
           service.execute(user)
         end
 
-        it 'does not delete the issue' do
+        it 'does not delete issues the user is assigned to' do
           expect(Issue.find_by_id(issue.id)).to be_present
         end
 
-        it 'migrates the issue so that the "Ghost User" is the issue owner' do
+        it 'migrates the issue so that it is "Unassigned"' do
           migrated_issue = Issue.find_by_id(issue.id)
 
-          expect(migrated_issue.author).to eq(User.ghost)
+          expect(migrated_issue.assignee).to be_nil
         end
+      end
+    end
 
-        it 'blocks the user before migrating issues to the "Ghost User' do
-          expect(user).to be_blocked
-        end
+    context "a deleted user's merge_requests" do
+      let(:project) { create(:project) }
+
+      before do
+        project.add_developer(user)
       end
 
-      context "for an issue the user was assigned to" do
-        let!(:issue) { create(:issue, project: project, assignee: user) }
+      context "for an merge request the user was assigned to" do
+        let!(:merge_request) { create(:merge_request, source_project: project, assignee: user) }
 
         before do
           service.execute(user)
         end
 
-        it 'does not delete issues the user is assigned to' do
-          expect(Issue.find_by_id(issue.id)).to be_present
+        it 'does not delete merge requests the user is assigned to' do
+          expect(MergeRequest.find_by_id(merge_request.id)).to be_present
         end
 
-        it 'migrates the issue so that it is "Unassigned"' do
-          migrated_issue = Issue.find_by_id(issue.id)
+        it 'migrates the merge request so that it is "Unassigned"' do
+          migrated_merge_request = MergeRequest.find_by_id(merge_request.id)
 
-          expect(migrated_issue.assignee).to be_nil
+          expect(migrated_merge_request.assignee).to be_nil
         end
       end
     end
@@ -141,5 +145,13 @@ describe Users::DestroyService, services: true do
         expect(User.exists?(user.id)).to be(false)
       end
     end
+
+    context "migrating associated records" do
+      it 'delegates to the `MigrateToGhostUser` service to move associated records to the ghost user' do
+        expect_any_instance_of(Users::MigrateToGhostUserService).to receive(:execute).once
+
+        service.execute(user)
+      end
+    end
   end
 end
diff --git a/spec/services/users/migrate_to_ghost_user_service_spec.rb b/spec/services/users/migrate_to_ghost_user_service_spec.rb
new file mode 100644
index 00000000000..8c5b7e41c15
--- /dev/null
+++ b/spec/services/users/migrate_to_ghost_user_service_spec.rb
@@ -0,0 +1,64 @@
+require 'spec_helper'
+
+describe Users::MigrateToGhostUserService, services: true do
+  let!(:user)      { create(:user) }
+  let!(:project)   { create(:project) }
+  let(:service)    { described_class.new(user) }
+
+  context "migrating a user's associated records to the ghost user" do
+    context 'issues'  do
+      include_examples "migrating a deleted user's associated records to the ghost user", Issue do
+        let(:created_record) { create(:issue, project: project, author: user) }
+        let(:assigned_record) { create(:issue, project: project, assignee: user) }
+      end
+    end
+
+    context 'merge requests' do
+      include_examples "migrating a deleted user's associated records to the ghost user", MergeRequest do
+        let(:created_record) { create(:merge_request, source_project: project, author: user, target_branch: "first") }
+        let(:assigned_record) { create(:merge_request, source_project: project, assignee: user, target_branch: 'second') }
+      end
+    end
+
+    context 'notes' do
+      include_examples "migrating a deleted user's associated records to the ghost user", Note do
+        let(:created_record) { create(:note, project: project, author: user) }
+      end
+    end
+
+    context 'abuse reports' do
+      include_examples "migrating a deleted user's associated records to the ghost user", AbuseReport do
+        let(:created_record) { create(:abuse_report, reporter: user, user: create(:user)) }
+      end
+    end
+
+    context 'award emoji' do
+      include_examples "migrating a deleted user's associated records to the ghost user", AwardEmoji do
+        let(:created_record) { create(:award_emoji, user: user) }
+        let(:author_alias) { :user }
+
+        context "when the awardable already has an award emoji of the same name assigned to the ghost user" do
+          let(:awardable) { create(:issue) }
+          let!(:existing_award_emoji) { create(:award_emoji, user: User.ghost, name: "thumbsup", awardable: awardable) }
+          let!(:award_emoji) { create(:award_emoji, user: user, name: "thumbsup", awardable: awardable) }
+
+          it "migrates the award emoji regardless" do
+            service.execute
+
+            migrated_record = AwardEmoji.find_by_id(award_emoji.id)
+
+            expect(migrated_record.user).to eq(User.ghost)
+          end
+
+          it "does not leave the migrated award emoji in an invalid state" do
+            service.execute
+
+            migrated_record = AwardEmoji.find_by_id(award_emoji.id)
+
+            expect(migrated_record).to be_valid
+          end
+        end
+      end
+    end
+  end
+end
diff --git a/spec/spec_helper.rb b/spec/spec_helper.rb
index 4eb5b150af5..a3665795452 100644
--- a/spec/spec_helper.rb
+++ b/spec/spec_helper.rb
@@ -59,6 +59,10 @@ RSpec.configure do |config|
     TestEnv.init
   end
 
+  config.after(:suite) do
+    TestEnv.cleanup
+  end
+
   if ENV['CI']
     # Retry only on feature specs that use JS
     config.around :each, :js do |ex|
diff --git a/spec/support/features/discussion_comments_shared_example.rb b/spec/support/features/discussion_comments_shared_example.rb
new file mode 100644
index 00000000000..1a061ef069e
--- /dev/null
+++ b/spec/support/features/discussion_comments_shared_example.rb
@@ -0,0 +1,213 @@
+shared_examples 'discussion comments' do |resource_name|
+  let(:form_selector) { '.js-main-target-form' }
+  let(:dropdown_selector) { "#{form_selector} .comment-type-dropdown" }
+  let(:toggle_selector) { "#{dropdown_selector} .dropdown-toggle" }
+  let(:menu_selector) { "#{dropdown_selector} .dropdown-menu" }
+  let(:submit_selector) { "#{form_selector} .js-comment-submit-button" }
+  let(:close_selector) { "#{form_selector} .btn-comment-and-close" }
+  let(:comments_selector) { '.timeline > .note.timeline-entry' }
+
+  it 'clicking "Comment" will post a comment' do
+    expect(page).to have_selector toggle_selector
+
+    find("#{form_selector} .note-textarea").send_keys('a')
+
+    find(submit_selector).click
+
+    find(comments_selector, match: :first)
+    new_comment = all(comments_selector).last
+
+    expect(new_comment).to have_content 'a'
+    expect(new_comment).not_to have_selector '.discussion'
+  end
+
+  if resource_name == 'issue'
+    it "clicking 'Comment & close #{resource_name}' will post a comment and close the #{resource_name}" do
+      find("#{form_selector} .note-textarea").send_keys('a')
+
+      find(close_selector).click
+
+      find(comments_selector, match: :first)
+      find("#{comments_selector}.system-note")
+      entries = all(comments_selector)
+      close_note = entries.last
+      new_comment = entries[-2]
+
+      expect(close_note).to have_content 'closed'
+      expect(new_comment).not_to have_selector '.discussion'
+    end
+  end
+
+  describe 'when the toggle is clicked' do
+    before do
+      find("#{form_selector} .note-textarea").send_keys('a')
+
+      find(toggle_selector).click
+    end
+
+    it 'has a "Comment" item (selected by default) and "Start discussion" item' do
+      expect(page).to have_selector menu_selector
+
+      find("#{menu_selector} li", match: :first)
+      items = all("#{menu_selector} li")
+
+      expect(items.first).to have_content 'Comment'
+      expect(items.first).to have_content "Add a general comment to this #{resource_name}."
+      expect(items.first).to have_selector '.fa-check'
+      expect(items.first['class']).to match 'droplab-item-selected'
+
+      expect(items.last).to have_content 'Start discussion'
+      expect(items.last).to have_content "Discuss a specific suggestion or question#{' that needs to be resolved' if resource_name == 'merge request'}."
+      expect(items.last).not_to have_selector '.fa-check'
+      expect(items.last['class']).not_to match 'droplab-item-selected'
+    end
+
+    it 'closes the menu when clicking the toggle or body' do
+      find(toggle_selector).click
+
+      expect(page).not_to have_selector menu_selector
+
+      find(toggle_selector).click
+      find('body').click
+
+      expect(page).not_to have_selector menu_selector
+    end
+
+    it 'clicking the ul padding should not change the text' do
+      find(menu_selector).trigger 'click'
+
+      expect(find(dropdown_selector)).to have_content 'Comment'
+    end
+
+    describe 'when selecting "Start discussion"' do
+      before do
+        find("#{menu_selector} li", match: :first)
+        all("#{menu_selector} li").last.click
+      end
+
+      it 'updates the submit button text, note_type input and closes the dropdown' do
+        expect(find(dropdown_selector)).to have_content 'Start discussion'
+        expect(find("#{form_selector} #note_type", visible: false).value).to eq('DiscussionNote')
+        expect(page).not_to have_selector menu_selector
+      end
+
+      if resource_name =~ /(issue|merge request)/
+        it 'updates the close button text' do
+          expect(find(close_selector)).to have_content "Start discussion & close #{resource_name}"
+        end
+
+        it 'typing does not change the close button text' do
+          find("#{form_selector} .note-textarea").send_keys('b')
+
+          expect(find(close_selector)).to have_content "Start discussion & close #{resource_name}"
+        end
+      end
+
+      it 'clicking "Start discussion" will post a discussion' do
+        find(submit_selector).click
+
+        find(comments_selector, match: :first)
+        new_comment = all(comments_selector).last
+
+        expect(new_comment).to have_content 'a'
+        expect(new_comment).to have_selector '.discussion'
+      end
+
+      if resource_name == 'issue'
+        it "clicking 'Start discussion & close #{resource_name}' will post a discussion and close the #{resource_name}" do
+          find(close_selector).click
+
+          find(comments_selector, match: :first)
+          find("#{comments_selector}.system-note")
+          entries = all(comments_selector)
+          close_note = entries.last
+          new_discussion = entries[-2]
+
+          expect(close_note).to have_content 'closed'
+          expect(new_discussion).to have_selector '.discussion'
+        end
+      end
+
+      describe 'when opening the menu' do
+        before do
+          find(toggle_selector).click
+        end
+
+        it 'should have "Start discussion" selected' do
+          find("#{menu_selector} li", match: :first)
+          items = all("#{menu_selector} li")
+
+          expect(items.first).to have_content 'Comment'
+          expect(items.first).not_to have_selector '.fa-check'
+          expect(items.first['class']).not_to match 'droplab-item-selected'
+
+          expect(items.last).to have_content 'Start discussion'
+          expect(items.last).to have_selector '.fa-check'
+          expect(items.last['class']).to match 'droplab-item-selected'
+        end
+
+        describe 'when selecting "Comment"' do
+          before do
+            find("#{menu_selector} li", match: :first).click
+          end
+
+          it 'updates the submit button text, clears the note_type input and closes the dropdown' do
+            expect(find(dropdown_selector)).to have_content 'Comment'
+            expect(find("#{form_selector} #note_type", visible: false).value).to eq('')
+            expect(page).not_to have_selector menu_selector
+          end
+
+          if resource_name =~ /(issue|merge request)/
+            it 'updates the close button text' do
+              expect(find(close_selector)).to have_content "Comment & close #{resource_name}"
+            end
+
+            it 'typing does not change the close button text' do
+              find("#{form_selector} .note-textarea").send_keys('b')
+
+              expect(find(close_selector)).to have_content "Comment & close #{resource_name}"
+            end
+          end
+
+          it 'should have "Comment" selected when opening the menu' do
+            find(toggle_selector).click
+
+            find("#{menu_selector} li", match: :first)
+            items = all("#{menu_selector} li")
+
+            expect(items.first).to have_content 'Comment'
+            expect(items.first).to have_selector '.fa-check'
+            expect(items.first['class']).to match 'droplab-item-selected'
+
+            expect(items.last).to have_content 'Start discussion'
+            expect(items.last).not_to have_selector '.fa-check'
+            expect(items.last['class']).not_to match 'droplab-item-selected'
+          end
+        end
+      end
+    end
+  end
+
+  if resource_name =~ /(issue|merge request)/
+    describe "on a closed #{resource_name}" do
+      before do
+        find("#{form_selector} .js-note-target-close").click
+
+        find("#{form_selector} .note-textarea").send_keys('a')
+      end
+
+      it "should show a 'Comment & reopen #{resource_name}' button" do
+        expect(find("#{form_selector} .js-note-target-reopen")).to have_content "Comment & reopen #{resource_name}"
+      end
+
+      it "should show a 'Start discussion & reopen #{resource_name}' button when 'Start discussion' is selected" do
+        find(toggle_selector).click
+
+        find("#{menu_selector} li", match: :first)
+        all("#{menu_selector} li").last.click
+
+        expect(find("#{form_selector} .js-note-target-reopen")).to have_content "Start discussion & reopen #{resource_name}"
+      end
+    end
+  end
+end
diff --git a/spec/support/filtered_search_helpers.rb b/spec/support/filtered_search_helpers.rb
index 6b009b132b6..36be0bb6bf8 100644
--- a/spec/support/filtered_search_helpers.rb
+++ b/spec/support/filtered_search_helpers.rb
@@ -30,7 +30,7 @@ module FilteredSearchHelpers
   end
 
   def clear_search_field
-    find('.filtered-search-input-container .clear-search').click
+    find('.filtered-search-box .clear-search').click
   end
 
   def reset_filters
@@ -51,7 +51,7 @@ module FilteredSearchHelpers
   # Iterates through each visual token inside
   # .tokens-container to make sure the correct names and values are rendered
   def expect_tokens(tokens)
-    page.find '.filtered-search-input-container .tokens-container' do
+    page.find '.filtered-search-box .tokens-container' do
       page.all(:css, '.tokens-container li').each_with_index do |el, index|
         token_name = tokens[index][:name]
         token_value = tokens[index][:value]
@@ -71,4 +71,18 @@ module FilteredSearchHelpers
   def get_filtered_search_placeholder
     find('.filtered-search')['placeholder']
   end
+
+  def remove_recent_searches
+    execute_script('window.localStorage.removeItem(\'issue-recent-searches\');')
+  end
+
+  def set_recent_searches(input)
+    execute_script("window.localStorage.setItem('issue-recent-searches', '#{input}');")
+  end
+
+  def wait_for_filtered_search(text)
+    Timeout.timeout(Capybara.default_max_wait_time) do
+      loop until find('.filtered-search').value.strip == text
+    end
+  end
 end
diff --git a/spec/support/gitaly.rb b/spec/support/gitaly.rb
new file mode 100644
index 00000000000..7aca902fc61
--- /dev/null
+++ b/spec/support/gitaly.rb
@@ -0,0 +1,7 @@
+if Gitlab::GitalyClient.enabled?
+  RSpec.configure do |config|
+    config.before(:each) do
+      allow(Gitlab::GitalyClient).to receive(:feature_enabled?).and_return(true)
+    end
+  end
+end
diff --git a/spec/support/query_recorder.rb b/spec/support/query_recorder.rb
index e40d5ebd9a8..55b531b4cf7 100644
--- a/spec/support/query_recorder.rb
+++ b/spec/support/query_recorder.rb
@@ -1,21 +1,29 @@
 module ActiveRecord
   class QueryRecorder
-    attr_reader :log
+    attr_reader :log, :cached
 
     def initialize(&block)
       @log = []
+      @cached = []
       ActiveSupport::Notifications.subscribed(method(:callback), 'sql.active_record', &block)
     end
 
     def callback(name, start, finish, message_id, values)
-      return if %w(CACHE SCHEMA).include?(values[:name])
-      @log << values[:sql]
+      if values[:name]&.include?("CACHE")
+        @cached << values[:sql]
+      elsif !values[:name]&.include?("SCHEMA")
+        @log << values[:sql]
+      end
     end
 
     def count
       @log.count
     end
 
+    def cached_count
+      @cached.count
+    end
+
     def log_message
       @log.join("\n\n")
     end
diff --git a/spec/support/services/migrate_to_ghost_user_service_shared_examples.rb b/spec/support/services/migrate_to_ghost_user_service_shared_examples.rb
new file mode 100644
index 00000000000..0eac587e973
--- /dev/null
+++ b/spec/support/services/migrate_to_ghost_user_service_shared_examples.rb
@@ -0,0 +1,39 @@
+require "spec_helper"
+
+shared_examples "migrating a deleted user's associated records to the ghost user" do |record_class|
+  record_class_name = record_class.to_s.titleize.downcase
+
+  let(:project) { create(:project) }
+
+  before do
+    project.add_developer(user)
+  end
+
+  context "for a #{record_class_name} the user has created" do
+    let!(:record) { created_record }
+
+    it "does not delete the #{record_class_name}" do
+      service.execute
+
+      expect(record_class.find_by_id(record.id)).to be_present
+    end
+
+    it "migrates the #{record_class_name} so that the 'Ghost User' is the #{record_class_name} owner" do
+      service.execute
+
+      migrated_record = record_class.find_by_id(record.id)
+
+      if migrated_record.respond_to?(:author)
+        expect(migrated_record.author).to eq(User.ghost)
+      else
+        expect(migrated_record.send(author_alias)).to eq(User.ghost)
+      end
+    end
+
+    it "blocks the user before migrating #{record_class_name}s to the 'Ghost User'" do
+      service.execute
+
+      expect(user).to be_blocked
+    end
+  end
+end
diff --git a/spec/support/slash_commands_helpers.rb b/spec/support/slash_commands_helpers.rb
index 0d91fe5fd5d..4bfe481115f 100644
--- a/spec/support/slash_commands_helpers.rb
+++ b/spec/support/slash_commands_helpers.rb
@@ -3,7 +3,7 @@ module SlashCommandsHelpers
     Sidekiq::Testing.fake! do
       page.within('.js-main-target-form') do
         fill_in 'note[note]', with: text
-        find('.comment-btn').trigger('click')
+        find('.js-comment-submit-button').trigger('click')
       end
     end
   end
diff --git a/spec/support/stub_gitlab_calls.rb b/spec/support/stub_gitlab_calls.rb
index a01ef576234..ded2d593059 100644
--- a/spec/support/stub_gitlab_calls.rb
+++ b/spec/support/stub_gitlab_calls.rb
@@ -27,23 +27,40 @@ module StubGitlabCalls
 
   def stub_container_registry_config(registry_settings)
     allow(Gitlab.config.registry).to receive_messages(registry_settings)
-    allow(Auth::ContainerRegistryAuthenticationService).to receive(:full_access_token).and_return('token')
+    allow(Auth::ContainerRegistryAuthenticationService)
+      .to receive(:full_access_token).and_return('token')
   end
 
-  def stub_container_registry_tags(*tags)
-    allow_any_instance_of(ContainerRegistry::Client).to receive(:repository_tags).and_return(
-      { "tags" => tags }
-    )
-    allow_any_instance_of(ContainerRegistry::Client).to receive(:repository_manifest).and_return(
-      JSON.parse(File.read(Rails.root + 'spec/fixtures/container_registry/tag_manifest.json'))
-    )
-    allow_any_instance_of(ContainerRegistry::Client).to receive(:blob).and_return(
-      File.read(Rails.root + 'spec/fixtures/container_registry/config_blob.json')
-    )
+  def stub_container_registry_tags(repository: :any, tags:)
+    repository = any_args if repository == :any
+
+    allow_any_instance_of(ContainerRegistry::Client)
+      .to receive(:repository_tags).with(repository)
+      .and_return({ 'tags' => tags })
+
+    allow_any_instance_of(ContainerRegistry::Client)
+      .to receive(:repository_manifest).with(repository)
+      .and_return(stub_container_registry_tag_manifest)
+
+    allow_any_instance_of(ContainerRegistry::Client)
+      .to receive(:blob).with(repository)
+      .and_return(stub_container_registry_blob)
   end
 
   private
 
+  def stub_container_registry_tag_manifest
+    fixture_path = 'spec/fixtures/container_registry/tag_manifest.json'
+
+    JSON.parse(File.read(Rails.root + fixture_path))
+  end
+
+  def stub_container_registry_blob
+    fixture_path = 'spec/fixtures/container_registry/config_blob.json'
+
+    File.read(Rails.root + fixture_path)
+  end
+
   def gitlab_url
     Gitlab.config.gitlab.url
   end
diff --git a/spec/support/test_env.rb b/spec/support/test_env.rb
index 1b5cb71a6b0..60c2096a126 100644
--- a/spec/support/test_env.rb
+++ b/spec/support/test_env.rb
@@ -64,6 +64,8 @@ module TestEnv
     # Setup GitLab shell for test instance
     setup_gitlab_shell
 
+    setup_gitaly if Gitlab::GitalyClient.enabled?
+
     # Create repository for FactoryGirl.create(:project)
     setup_factory_repo
 
@@ -71,6 +73,10 @@ module TestEnv
     setup_forked_repo
   end
 
+  def cleanup
+    stop_gitaly
+  end
+
   def disable_mailer
     allow_any_instance_of(NotificationService).to receive(:mailer).
       and_return(double.as_null_object)
@@ -92,7 +98,7 @@ module TestEnv
     tmp_test_path = Rails.root.join('tmp', 'tests', '**')
 
     Dir[tmp_test_path].each do |entry|
-      unless File.basename(entry) =~ /\Agitlab-(shell|test|test_bare|test-fork|test-fork_bare)\z/
+      unless File.basename(entry) =~ /\A(gitaly|gitlab-(shell|test|test_bare|test-fork|test-fork_bare))\z/
         FileUtils.rm_rf(entry)
       end
     end
@@ -110,6 +116,28 @@ module TestEnv
     end
   end
 
+  def setup_gitaly
+    socket_path = Gitlab::GitalyClient.get_address('default').sub(/\Aunix:/, '')
+    gitaly_dir = File.dirname(socket_path)
+
+    unless File.directory?(gitaly_dir) || system('rake', "gitlab:gitaly:install[#{gitaly_dir}]")
+      raise "Can't clone gitaly"
+    end
+
+    start_gitaly(gitaly_dir, socket_path)
+  end
+
+  def start_gitaly(gitaly_dir, socket_path)
+    gitaly_exec = File.join(gitaly_dir, 'gitaly')
+    @gitaly_pid = spawn({ "GITALY_SOCKET_PATH" => socket_path }, gitaly_exec, [:out, :err] => '/dev/null')
+  end
+
+  def stop_gitaly
+    return unless @gitaly_pid
+
+    Process.kill('KILL', @gitaly_pid)
+  end
+
   def setup_factory_repo
     setup_repo(factory_repo_path, factory_repo_path_bare, factory_repo_name,
                BRANCH_SHA)
diff --git a/spec/support/time_tracking_shared_examples.rb b/spec/support/time_tracking_shared_examples.rb
index 52f4fabdc47..01bc80f957e 100644
--- a/spec/support/time_tracking_shared_examples.rb
+++ b/spec/support/time_tracking_shared_examples.rb
@@ -77,6 +77,6 @@ end
 
 def submit_time(slash_command)
   fill_in 'note[note]', with: slash_command
-  find('.comment-btn').trigger('click')
+  find('.js-comment-submit-button').trigger('click')
   wait_for_ajax
 end
diff --git a/spec/tasks/gitlab/gitaly_rake_spec.rb b/spec/tasks/gitlab/gitaly_rake_spec.rb
index d95baddf546..b369dcbb305 100644
--- a/spec/tasks/gitlab/gitaly_rake_spec.rb
+++ b/spec/tasks/gitlab/gitaly_rake_spec.rb
@@ -75,4 +75,36 @@ describe 'gitlab:gitaly namespace rake task' do
       end
     end
   end
+
+  describe 'storage_config' do
+    it 'prints storage configuration in a TOML format' do
+      config = {
+        'default' => { 'path' => '/path/to/default' },
+        'nfs_01' => { 'path' => '/path/to/nfs_01' },
+      }
+      allow(Gitlab.config.repositories).to receive(:storages).and_return(config)
+
+      orig_stdout = $stdout
+      $stdout = StringIO.new
+
+      header = ''
+      Timecop.freeze do
+        header = <<~TOML
+          # Gitaly storage configuration generated from #{Gitlab.config.source} on #{Time.current.to_s(:long)}
+          # This is in TOML format suitable for use in Gitaly's config.toml file.
+        TOML
+        run_rake_task('gitlab:gitaly:storage_config')
+      end
+
+      output = $stdout.string
+      $stdout = orig_stdout
+
+      expect(output).to include(header)
+
+      parsed_output = TOML.parse(output)
+      config.each do |name, params|
+        expect(parsed_output['storage']).to include({ 'name' => name, 'path' => params['path'] })
+      end
+    end
+  end
 end
diff --git a/spec/views/projects/builds/show.html.haml_spec.rb b/spec/views/projects/builds/show.html.haml_spec.rb
index 55b64808fb3..0f39df0f250 100644
--- a/spec/views/projects/builds/show.html.haml_spec.rb
+++ b/spec/views/projects/builds/show.html.haml_spec.rb
@@ -9,7 +9,7 @@ describe 'projects/builds/show', :view do
   end
 
   before do
-    assign(:build, build)
+    assign(:build, build.present)
     assign(:project, project)
 
     allow(view).to receive(:can?).and_return(true)
diff --git a/spec/views/projects/notes/_form.html.haml_spec.rb b/spec/views/projects/notes/_form.html.haml_spec.rb
index b61f016967f..a364f9bce92 100644
--- a/spec/views/projects/notes/_form.html.haml_spec.rb
+++ b/spec/views/projects/notes/_form.html.haml_spec.rb
@@ -4,7 +4,7 @@ describe 'projects/notes/_form' do
   include Devise::Test::ControllerHelpers
 
   let(:user) { create(:user) }
-  let(:project) { create(:empty_project) }
+  let(:project) { create(:project, :repository) }
 
   before do
     project.team << [user, :master]
@@ -20,7 +20,7 @@ describe 'projects/notes/_form' do
     context "with a note on #{noteable}" do
       let(:note) { build(:"note_on_#{noteable}", project: project) }
 
-      it 'says that only markdown is supported, not slash commands' do
+      it 'says that markdown and slash commands are supported' do
         expect(rendered).to have_content('Markdown and slash commands are supported')
       end
     end
diff --git a/spec/views/projects/pipelines/show.html.haml_spec.rb b/spec/views/projects/pipelines/show.html.haml_spec.rb
index dca78dec6df..bb39ec8efbf 100644
--- a/spec/views/projects/pipelines/show.html.haml_spec.rb
+++ b/spec/views/projects/pipelines/show.html.haml_spec.rb
@@ -5,7 +5,13 @@ describe 'projects/pipelines/show' do
 
   let(:user) { create(:user) }
   let(:project) { create(:project, :repository) }
-  let(:pipeline) { create(:ci_empty_pipeline, project: project, sha: project.commit.id, user: user) }
+
+  let(:pipeline) do
+    create(:ci_empty_pipeline,
+           project: project,
+           sha: project.commit.id,
+           user: user)
+  end
 
   before do
     controller.prepend_view_path('app/views/projects')
@@ -21,7 +27,7 @@ describe 'projects/pipelines/show' do
     create(:generic_commit_status, pipeline: pipeline, stage: 'external', name: 'jenkins', stage_idx: 3)
 
     assign(:project, project)
-    assign(:pipeline, pipeline)
+    assign(:pipeline, pipeline.present(current_user: user))
     assign(:commit, project.commit)
 
     allow(view).to receive(:can?).and_return(true)
diff --git a/spec/views/projects/registry/repositories/index.html.haml_spec.rb b/spec/views/projects/registry/repositories/index.html.haml_spec.rb
new file mode 100644
index 00000000000..ceeace3dc8d
--- /dev/null
+++ b/spec/views/projects/registry/repositories/index.html.haml_spec.rb
@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+describe 'projects/registry/repositories/index', :view do
+  let(:group) { create(:group, path: 'group') }
+  let(:project) { create(:empty_project, group: group, path: 'test') }
+
+  let(:repository) do
+    create(:container_repository, project: project, name: 'image')
+  end
+
+  before do
+    stub_container_registry_config(enabled: true,
+                                   host_port: 'registry.gitlab',
+                                   api_url: 'http://registry.gitlab')
+
+    stub_container_registry_tags(repository: :any, tags: [:latest])
+
+    assign(:project, project)
+    assign(:images, [repository])
+
+    allow(view).to receive(:can?).and_return(true)
+  end
+
+  it 'contains container repository path' do
+    render
+
+    expect(rendered).to have_content 'group/test/image'
+  end
+
+  it 'contains attribute for copying tag location into clipboard' do
+    render
+
+    expect(rendered).to have_css 'button[data-clipboard-text="docker pull ' \
+                                 'registry.gitlab/group/test/image:latest"]'
+  end
+end
diff --git a/spec/workers/trigger_schedule_worker_spec.rb b/spec/workers/trigger_schedule_worker_spec.rb
new file mode 100644
index 00000000000..861bed4442e
--- /dev/null
+++ b/spec/workers/trigger_schedule_worker_spec.rb
@@ -0,0 +1,73 @@
+require 'spec_helper'
+
+describe TriggerScheduleWorker do
+  let(:worker) { described_class.new }
+
+  before do
+    stub_ci_pipeline_to_return_yaml_file
+  end
+
+  context 'when there is a scheduled trigger within next_run_at' do
+    let(:next_run_at) { 2.days.ago }
+
+    let!(:trigger_schedule) do
+      create(:ci_trigger_schedule, :nightly)
+    end
+
+    before do
+      trigger_schedule.update_column(:next_run_at, next_run_at)
+    end
+
+    it 'creates a new trigger request' do
+      expect { worker.perform }.to change { Ci::TriggerRequest.count }
+    end
+
+    it 'creates a new pipeline' do
+      expect { worker.perform }.to change { Ci::Pipeline.count }
+      expect(Ci::Pipeline.last).to be_pending
+    end
+
+    it 'updates next_run_at' do
+      worker.perform
+
+      expect(trigger_schedule.reload.next_run_at).not_to eq(next_run_at)
+    end
+
+    context 'inactive schedule' do
+      before do
+        trigger_schedule.update(active: false)
+      end
+
+      it 'does not create a new trigger' do
+        expect { worker.perform }.not_to change { Ci::TriggerRequest.count }
+      end
+    end
+  end
+
+  context 'when there are no scheduled triggers within next_run_at' do
+    before { create(:ci_trigger_schedule, :nightly) }
+
+    it 'does not create a new pipeline' do
+      expect { worker.perform }.not_to change { Ci::Pipeline.count }
+    end
+
+    it 'does not update next_run_at' do
+      expect { worker.perform }.not_to change { Ci::TriggerSchedule.last.next_run_at }
+    end
+  end
+
+  context 'when next_run_at is nil' do
+    before do
+      schedule = create(:ci_trigger_schedule, :nightly)
+      schedule.update_column(:next_run_at, nil)
+    end
+
+    it 'does not create a new pipeline' do
+      expect { worker.perform }.not_to change { Ci::Pipeline.count }
+    end
+
+    it 'does not update next_run_at' do
+      expect { worker.perform }.not_to change { Ci::TriggerSchedule.last.next_run_at }
+    end
+  end
+end