Merge branch 'master' into backstage/gb/migrate-stages-statuses

* master: (319 commits)
  remove redundant changelog entries
  Merge branch '24570-use-re2-for-user-supplied-regexp-9-3' into 'security-9-3'
  Merge branch '33303-404-for-unauthorized-project' into 'security-9-3'
  Merge branch '33359-pers-snippet-files-location' into 'security-9-3'
  Merge branch 'bvl-remove-appearance-symlink' into 'security-9-3'
  Hide description about protected branches to non-member
  Update CHANGELOG.md for 9.0.11
  Update CHANGELOG.md for 9.1.8
  Update CHANGELOG.md for 8.17.7
  Update CHANGELOG.md for 9.2.8
  Update CHANGELOG.md for 9.3.8
  Respect blockquote line breaks in markdown
  35209 Add wip message to new navigation preference section
  Add github imported projects count to usage data
  Add versions to Prometheus metrics doc
  Add Bulgarian translations of Pipeline Schedules
  Add Esperanto translations of Pipeline Schedules
  Add Traditional Chinese in HongKong translations of Pipeline Schedules
  Add Simplified Chinese translations of Pipeline Schedules
  Resolve "Clarify k8s service keys"
  ...

Conflicts:
	db/schema.rb

202 files changed, 4044 insertions, 1003 deletions

diff --git a/spec/config/mail_room_spec.rb b/spec/config/mail_room_spec.rb
index 092048a6259..a31e44fa928 100644
--- a/spec/config/mail_room_spec.rb
+++ b/spec/config/mail_room_spec.rb
@@ -5,12 +5,12 @@ describe 'mail_room.yml' do
 
   let(:mailroom_config_path) { 'config/mail_room.yml' }
   let(:gitlab_config_path) { 'config/mail_room.yml' }
-  let(:redis_config_path) { 'config/resque.yml' }
+  let(:queues_config_path) { 'config/redis.queues.yml' }
 
   let(:configuration) do
     vars = {
       'MAIL_ROOM_GITLAB_CONFIG_FILE' => absolute_path(gitlab_config_path),
-      'GITLAB_REDIS_CONFIG_FILE' => absolute_path(redis_config_path)
+      'GITLAB_REDIS_QUEUES_CONFIG_FILE' => absolute_path(queues_config_path)
     }
     cmd = "puts ERB.new(File.read(#{absolute_path(mailroom_config_path).inspect})).result"
 
@@ -21,12 +21,12 @@ describe 'mail_room.yml' do
   end
 
   before(:each) do
-    stub_env('GITLAB_REDIS_CONFIG_FILE', absolute_path(redis_config_path))
-    clear_redis_raw_config
+    stub_env('GITLAB_REDIS_QUEUES_CONFIG_FILE', absolute_path(queues_config_path))
+    clear_queues_raw_config
   end
 
   after(:each) do
-    clear_redis_raw_config
+    clear_queues_raw_config
   end
 
   context 'when incoming email is disabled' do
@@ -39,9 +39,9 @@ describe 'mail_room.yml' do
 
   context 'when incoming email is enabled' do
     let(:gitlab_config_path) { 'spec/fixtures/config/mail_room_enabled.yml' }
-    let(:redis_config_path) { 'spec/fixtures/config/redis_new_format_host.yml' }
+    let(:queues_config_path) { 'spec/fixtures/config/redis_queues_new_format_host.yml' }
 
-    let(:gitlab_redis) { Gitlab::Redis.new(Rails.env) }
+    let(:gitlab_redis_queues) { Gitlab::Redis::Queues.new(Rails.env) }
 
     it 'contains the intended configuration' do
       expect(configuration[:mailboxes].length).to eq(1)
@@ -56,8 +56,8 @@ describe 'mail_room.yml' do
       expect(mailbox[:name]).to eq('inbox')
       expect(mailbox[:idle_timeout]).to eq(60)
 
-      redis_url = gitlab_redis.url
-      sentinels = gitlab_redis.sentinels
+      redis_url = gitlab_redis_queues.url
+      sentinels = gitlab_redis_queues.sentinels
 
       expect(mailbox[:delivery_options][:redis_url]).to be_present
       expect(mailbox[:delivery_options][:redis_url]).to eq(redis_url)
@@ -73,8 +73,8 @@ describe 'mail_room.yml' do
     end
   end
 
-  def clear_redis_raw_config
-    Gitlab::Redis.remove_instance_variable(:@_raw_config)
+  def clear_queues_raw_config
+    Gitlab::Redis::Queues.remove_instance_variable(:@_raw_config)
   rescue NameError
     # raised if @_raw_config was not set; ignore
   end
diff --git a/spec/controllers/application_controller_spec.rb b/spec/controllers/application_controller_spec.rb
index a2720c9b81e..1641bddea11 100644
--- a/spec/controllers/application_controller_spec.rb
+++ b/spec/controllers/application_controller_spec.rb
@@ -30,6 +30,15 @@ describe ApplicationController do
       expect(controller).not_to receive(:redirect_to)
       controller.send(:check_password_expiration)
     end
+
+    it 'does not redirect if the user is over their password expiry but sign-in is disabled' do
+      stub_application_setting(password_authentication_enabled: false)
+      user.password_expires_at = Time.new(2002)
+      allow(controller).to receive(:current_user).and_return(user)
+      expect(controller).not_to receive(:redirect_to)
+
+      controller.send(:check_password_expiration)
+    end
   end
 
   describe "#authenticate_user_from_token!" do
diff --git a/spec/controllers/autocomplete_controller_spec.rb b/spec/controllers/autocomplete_controller_spec.rb
index b40f647644d..58486f33229 100644
--- a/spec/controllers/autocomplete_controller_spec.rb
+++ b/spec/controllers/autocomplete_controller_spec.rb
@@ -97,6 +97,21 @@ describe AutocompleteController do
       it { expect(body.size).to eq User.count }
     end
 
+    context 'user order' do
+      it 'shows exact matches first' do
+        reported_user = create(:user, username: 'reported_user', name: 'Doug')
+        user = create(:user, username: 'user', name: 'User')
+        user1 = create(:user, username: 'user1', name: 'Ian')
+
+        sign_in(user)
+        get(:users, search: 'user')
+
+        response_usernames = JSON.parse(response.body).map { |user| user['username']  }
+
+        expect(response_usernames.take(3)).to match_array([user.username, reported_user.username, user1.username])
+      end
+    end
+
     context 'limited users per page' do
       let(:per_page) { 2 }
 
diff --git a/spec/controllers/dashboard/todos_controller_spec.rb b/spec/controllers/dashboard/todos_controller_spec.rb
index 085f3fd8543..4a48621abe1 100644
--- a/spec/controllers/dashboard/todos_controller_spec.rb
+++ b/spec/controllers/dashboard/todos_controller_spec.rb
@@ -12,6 +12,36 @@ describe Dashboard::TodosController do
   end
 
   describe 'GET #index' do
+    context 'project authorization' do
+      it 'renders 404 when user does not have read access on given project' do
+        unauthorized_project = create(:empty_project, :private)
+
+        get :index, project_id: unauthorized_project.id
+
+        expect(response).to have_http_status(404)
+      end
+
+      it 'renders 404 when given project does not exists' do
+        get :index, project_id: 999
+
+        expect(response).to have_http_status(404)
+      end
+
+      it 'renders 200 when filtering for "any project" todos' do
+        get :index, project_id: ''
+
+        expect(response).to have_http_status(200)
+      end
+
+      it 'renders 200 when user has access on given project' do
+        authorized_project = create(:empty_project, :public)
+
+        get :index, project_id: authorized_project.id
+
+        expect(response).to have_http_status(200)
+      end
+    end
+
     context 'when using pagination' do
       let(:last_page) { user.todos.page.total_pages }
       let!(:issues) { create_list(:issue, 2, project: project, assignees: [user]) }
diff --git a/spec/controllers/health_check_controller_spec.rb b/spec/controllers/health_check_controller_spec.rb
index 58c16cc57e6..03da6287774 100644
--- a/spec/controllers/health_check_controller_spec.rb
+++ b/spec/controllers/health_check_controller_spec.rb
@@ -3,52 +3,79 @@ require 'spec_helper'
 describe HealthCheckController do
   include StubENV
 
-  let(:token) { current_application_settings.health_check_access_token }
   let(:json_response) { JSON.parse(response.body) }
   let(:xml_response) { Hash.from_xml(response.body)['hash'] }
+  let(:token) { current_application_settings.health_check_access_token }
+  let(:whitelisted_ip) { '127.0.0.1' }
+  let(:not_whitelisted_ip) { '127.0.0.2' }
 
   before do
+    allow(Settings.monitoring).to receive(:ip_whitelist).and_return([whitelisted_ip])
     stub_env('IN_MEMORY_APPLICATION_SETTINGS', 'false')
   end
 
   describe 'GET #index' do
-    context 'when services are up but NO access token' do
+    context 'when services are up but accessed from outside whitelisted ips' do
+      before do
+        allow(Gitlab::RequestContext).to receive(:client_ip).and_return(not_whitelisted_ip)
+      end
+
       it 'returns a not found page' do
         get :index
+
         expect(response).to be_not_found
       end
+
+      context 'when services are accessed with token' do
+        it 'supports passing the token in the header' do
+          request.headers['TOKEN'] = token
+
+          get :index
+
+          expect(response).to be_success
+          expect(response.content_type).to eq 'text/plain'
+        end
+
+        it 'supports passing the token in query params' do
+          get :index, token: token
+
+          expect(response).to be_success
+          expect(response.content_type).to eq 'text/plain'
+        end
+      end
     end
 
-    context 'when services are up and an access token is provided' do
-      it 'supports passing the token in the header' do
-        request.headers['TOKEN'] = token
-        get :index
-        expect(response).to be_success
-        expect(response.content_type).to eq 'text/plain'
+    context 'when services are up and accessed from whitelisted ips' do
+      before do
+        allow(Gitlab::RequestContext).to receive(:client_ip).and_return(whitelisted_ip)
       end
 
-      it 'supports successful plaintest response' do
-        get :index, token: token
+      it 'supports successful plaintext response' do
+        get :index
+
         expect(response).to be_success
         expect(response.content_type).to eq 'text/plain'
       end
 
       it 'supports successful json response' do
-        get :index, token: token, format: :json
+        get :index, format: :json
+
         expect(response).to be_success
         expect(response.content_type).to eq 'application/json'
         expect(json_response['healthy']).to be true
       end
 
       it 'supports successful xml response' do
-        get :index, token: token, format: :xml
+        get :index, format: :xml
+
         expect(response).to be_success
         expect(response.content_type).to eq 'application/xml'
         expect(xml_response['healthy']).to be true
       end
 
       it 'supports successful responses for specific checks' do
-        get :index, token: token, checks: 'email', format: :json
+        get :index, checks: 'email', format: :json
+
         expect(response).to be_success
         expect(response.content_type).to eq 'application/json'
         expect(json_response['healthy']).to be true
@@ -58,33 +85,29 @@ describe HealthCheckController do
     context 'when a service is down but NO access token' do
       it 'returns a not found page' do
         get :index
+
         expect(response).to be_not_found
       end
     end
 
-    context 'when a service is down and an access token is provided' do
+    context 'when a service is down and an endpoint is accessed from whitelisted ip' do
       before do
         allow(HealthCheck::Utils).to receive(:process_checks).with(['standard']).and_return('The server is on fire')
         allow(HealthCheck::Utils).to receive(:process_checks).with(['email']).and_return('Email is on fire')
+        allow(Gitlab::RequestContext).to receive(:client_ip).and_return(whitelisted_ip)
       end
 
-      it 'supports passing the token in the header' do
-        request.headers['TOKEN'] = token
+      it 'supports failure plaintext response' do
         get :index
-        expect(response).to have_http_status(500)
-        expect(response.content_type).to eq 'text/plain'
-        expect(response.body).to include('The server is on fire')
-      end
 
-      it 'supports failure plaintest response' do
-        get :index, token: token
         expect(response).to have_http_status(500)
         expect(response.content_type).to eq 'text/plain'
         expect(response.body).to include('The server is on fire')
       end
 
       it 'supports failure json response' do
-        get :index, token: token, format: :json
+        get :index, format: :json
+
         expect(response).to have_http_status(500)
         expect(response.content_type).to eq 'application/json'
         expect(json_response['healthy']).to be false
@@ -92,7 +115,8 @@ describe HealthCheckController do
       end
 
       it 'supports failure xml response' do
-        get :index, token: token, format: :xml
+        get :index, format: :xml
+
         expect(response).to have_http_status(500)
         expect(response.content_type).to eq 'application/xml'
         expect(xml_response['healthy']).to be false
@@ -100,7 +124,8 @@ describe HealthCheckController do
       end
 
       it 'supports failure responses for specific checks' do
-        get :index, token: token, checks: 'email', format: :json
+        get :index, checks: 'email', format: :json
+
         expect(response).to have_http_status(500)
         expect(response.content_type).to eq 'application/json'
         expect(json_response['healthy']).to be false
diff --git a/spec/controllers/health_controller_spec.rb b/spec/controllers/health_controller_spec.rb
index e7c19b47a6a..cc389e554ad 100644
--- a/spec/controllers/health_controller_spec.rb
+++ b/spec/controllers/health_controller_spec.rb
@@ -3,55 +3,120 @@ require 'spec_helper'
 describe HealthController do
   include StubENV
 
-  let(:token) { current_application_settings.health_check_access_token }
   let(:json_response) { JSON.parse(response.body) }
+  let(:token) { current_application_settings.health_check_access_token }
+  let(:whitelisted_ip) { '127.0.0.1' }
+  let(:not_whitelisted_ip) { '127.0.0.2' }
 
   before do
+    allow(Settings.monitoring).to receive(:ip_whitelist).and_return([whitelisted_ip])
     stub_env('IN_MEMORY_APPLICATION_SETTINGS', 'false')
   end
 
   describe '#readiness' do
-    context 'authorization token provided' do
-      before do
-        request.headers['TOKEN'] = token
-      end
+    shared_context 'endpoint responding with readiness data' do
+      let(:request_params) { {} }
+
+      subject { get :readiness, request_params }
+
+      it 'responds with readiness checks data' do
+        subject
 
-      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['cache_check']['status']).to eq('ok')
+        expect(json_response['queues_check']['status']).to eq('ok')
+        expect(json_response['shared_state_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
+    context 'accessed from whitelisted ip' do
+      before do
+        allow(Gitlab::RequestContext).to receive(:client_ip).and_return(whitelisted_ip)
+      end
+
+      it_behaves_like 'endpoint responding with readiness data'
+    end
+
+    context 'accessed from not whitelisted ip' do
+      before do
+        allow(Gitlab::RequestContext).to receive(:client_ip).and_return(not_whitelisted_ip)
+      end
+
+      it 'responds with resource not found' do
         get :readiness
+
         expect(response.status).to eq(404)
       end
+
+      context 'accessed with valid token' do
+        context 'token passed in request header' do
+          before do
+            request.headers['TOKEN'] = token
+          end
+
+          it_behaves_like 'endpoint responding with readiness data'
+        end
+      end
+
+      context 'token passed as URL param' do
+        it_behaves_like 'endpoint responding with readiness data' do
+          let(:request_params) { { token: token } }
+        end
+      end
     end
   end
 
   describe '#liveness' do
-    context 'authorization token provided' do
-      before do
-        request.headers['TOKEN'] = token
-      end
+    shared_context 'endpoint responding with liveness data' do
+      subject { get :liveness }
+
+      it 'responds with liveness checks data' do
+        subject
 
-      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['cache_check']['status']).to eq('ok')
+        expect(json_response['queues_check']['status']).to eq('ok')
+        expect(json_response['shared_state_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
+    context 'accessed from whitelisted ip' do
+      before do
+        allow(Gitlab::RequestContext).to receive(:client_ip).and_return(whitelisted_ip)
+      end
+
+      it_behaves_like 'endpoint responding with liveness data'
+    end
+
+    context 'accessed from not whitelisted ip' do
+      before do
+        allow(Gitlab::RequestContext).to receive(:client_ip).and_return(not_whitelisted_ip)
+      end
+
+      it 'responds with resource not found' do
         get :liveness
+
         expect(response.status).to eq(404)
       end
+
+      context 'accessed with valid token' do
+        context 'token passed in request header' do
+          before do
+            request.headers['TOKEN'] = token
+          end
+
+          it_behaves_like 'endpoint responding with liveness data'
+        end
+
+        context 'token passed as URL param' do
+          it_behaves_like 'endpoint responding with liveness data' do
+            subject { get :liveness, token: token }
+          end
+        end
+      end
     end
   end
 end
diff --git a/spec/controllers/metrics_controller_spec.rb b/spec/controllers/metrics_controller_spec.rb
index 044c9f179ed..7b0976e3e67 100644
--- a/spec/controllers/metrics_controller_spec.rb
+++ b/spec/controllers/metrics_controller_spec.rb
@@ -3,28 +3,28 @@ require 'spec_helper'
 describe MetricsController do
   include StubENV
 
-  let(:token) { current_application_settings.health_check_access_token }
   let(:json_response) { JSON.parse(response.body) }
   let(:metrics_multiproc_dir) { Dir.mktmpdir }
+  let(:whitelisted_ip) { '127.0.0.1' }
+  let(:whitelisted_ip_range) { '10.0.0.0/24' }
+  let(:ip_in_whitelisted_range) { '10.0.0.1' }
+  let(:not_whitelisted_ip) { '10.0.1.1' }
 
   before do
     stub_env('IN_MEMORY_APPLICATION_SETTINGS', 'false')
-    stub_env('prometheus_multiproc_dir', metrics_multiproc_dir)
+    allow(Prometheus::Client.configuration).to receive(:multiprocess_files_dir).and_return(metrics_multiproc_dir)
     allow(Gitlab::Metrics).to receive(:prometheus_metrics_enabled?).and_return(true)
+    allow(Settings.monitoring).to receive(:ip_whitelist).and_return([whitelisted_ip, whitelisted_ip_range])
   end
 
   describe '#index' do
-    context 'authorization token provided' do
-      before do
-        request.headers['TOKEN'] = token
-      end
-
+    shared_examples_for 'endpoint providing metrics' do
       it 'returns DB ping metrics' do
         get :index
 
         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\.]+$/)
+        expect(response.body).to match(/^db_ping_latency_seconds [0-9\.]+$/)
       end
 
       it 'returns Redis ping metrics' do
@@ -32,17 +32,41 @@ describe MetricsController do
 
         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\.]+$/)
+        expect(response.body).to match(/^redis_ping_latency_seconds [0-9\.]+$/)
+      end
+
+      it 'returns Caching ping metrics' do
+        get :index
+
+        expect(response.body).to match(/^redis_cache_ping_timeout 0$/)
+        expect(response.body).to match(/^redis_cache_ping_success 1$/)
+        expect(response.body).to match(/^redis_cache_ping_latency_seconds [0-9\.]+$/)
+      end
+
+      it 'returns Queues ping metrics' do
+        get :index
+
+        expect(response.body).to match(/^redis_queues_ping_timeout 0$/)
+        expect(response.body).to match(/^redis_queues_ping_success 1$/)
+        expect(response.body).to match(/^redis_queues_ping_latency_seconds [0-9\.]+$/)
+      end
+
+      it 'returns SharedState ping metrics' do
+        get :index
+
+        expect(response.body).to match(/^redis_shared_state_ping_timeout 0$/)
+        expect(response.body).to match(/^redis_shared_state_ping_success 1$/)
+        expect(response.body).to match(/^redis_shared_state_ping_latency_seconds [0-9\.]+$/)
       end
 
       it 'returns file system check metrics' do
         get :index
 
-        expect(response.body).to match(/^filesystem_access_latency{shard="default"} [0-9\.]+$/)
+        expect(response.body).to match(/^filesystem_access_latency_seconds{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_write_latency_seconds{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_read_latency_seconds{shard="default"} [0-9\.]+$/)
         expect(response.body).to match(/^filesystem_readable{shard="default"} 1$/)
       end
 
@@ -59,7 +83,27 @@ describe MetricsController do
       end
     end
 
-    context 'without authorization token' do
+    context 'accessed from whitelisted ip' do
+      before do
+        allow(Gitlab::RequestContext).to receive(:client_ip).and_return(whitelisted_ip)
+      end
+
+      it_behaves_like 'endpoint providing metrics'
+    end
+
+    context 'accessed from ip in whitelisted range' do
+      before do
+        allow(Gitlab::RequestContext).to receive(:client_ip).and_return(ip_in_whitelisted_range)
+      end
+
+      it_behaves_like 'endpoint providing metrics'
+    end
+
+    context 'accessed from not whitelisted ip' do
+      before do
+        allow(Gitlab::RequestContext).to receive(:client_ip).and_return(not_whitelisted_ip)
+      end
+
       it 'returns proper response' do
         get :index
 
diff --git a/spec/controllers/passwords_controller_spec.rb b/spec/controllers/passwords_controller_spec.rb
new file mode 100644
index 00000000000..2955d01fad0
--- /dev/null
+++ b/spec/controllers/passwords_controller_spec.rb
@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+describe PasswordsController do
+  describe '#check_password_authentication_available' do
+    before do
+      @request.env["devise.mapping"] = Devise.mappings[:user]
+    end
+
+    context 'when password authentication is disabled' do
+      it 'prevents a password reset' do
+        stub_application_setting(password_authentication_enabled: false)
+
+        post :create
+
+        expect(flash[:alert]).to eq 'Password authentication is unavailable.'
+      end
+    end
+
+    context 'when reset email belongs to an ldap user' do
+      let(:user) { create(:omniauth_user, provider: 'ldapmain', email: 'ldapuser@gitlab.com') }
+
+      it 'prevents a password reset' do
+        post :create, user: { email: user.email }
+
+        expect(flash[:alert]).to eq 'Password authentication is unavailable.'
+      end
+    end
+  end
+end
diff --git a/spec/controllers/profiles/accounts_controller_spec.rb b/spec/controllers/profiles/accounts_controller_spec.rb
index 2f9d18e3a0e..d387aba227b 100644
--- a/spec/controllers/profiles/accounts_controller_spec.rb
+++ b/spec/controllers/profiles/accounts_controller_spec.rb
@@ -29,7 +29,7 @@ describe Profiles::AccountsController do
       end
     end
 
-    [:twitter, :facebook, :google_oauth2, :gitlab, :github, :bitbucket, :crowd, :auth0].each do |provider|
+    [:twitter, :facebook, :google_oauth2, :gitlab, :github, :bitbucket, :crowd, :auth0, :authentiq].each do |provider|
       describe "#{provider} provider" do
         let(:user) { create(:omniauth_user, provider: provider.to_s) }
 
diff --git a/spec/controllers/projects/commit_controller_spec.rb b/spec/controllers/projects/commit_controller_spec.rb
index eb61a0c080c..df53863482d 100644
--- a/spec/controllers/projects/commit_controller_spec.rb
+++ b/spec/controllers/projects/commit_controller_spec.rb
@@ -343,7 +343,8 @@ describe Projects::CommitController do
             get_pipelines(id: commit.id, format: :json)
 
             expect(response).to be_ok
-            expect(JSON.parse(response.body)).not_to be_empty
+            expect(JSON.parse(response.body)['pipelines']).not_to be_empty
+            expect(JSON.parse(response.body)['count']['all']).to eq 1
           end
         end
       end
diff --git a/spec/controllers/projects/issues_controller_spec.rb b/spec/controllers/projects/issues_controller_spec.rb
index 22aad0b3225..18d0be3c103 100644
--- a/spec/controllers/projects/issues_controller_spec.rb
+++ b/spec/controllers/projects/issues_controller_spec.rb
@@ -7,14 +7,16 @@ describe Projects::IssuesController do
 
   describe "GET #index" do
     context 'external issue tracker' do
+      let!(:service) do
+        create(:custom_issue_tracker_service, project: project, title: 'Custom Issue Tracker', project_url: 'http://test.com')
+      end
+
       it 'redirects to the external issue tracker' do
-        external = double(project_path: 'https://example.com/project')
-        allow(project).to receive(:external_issue_tracker).and_return(external)
         controller.instance_variable_set(:@project, project)
 
         get :index, namespace_id: project.namespace, project_id: project
 
-        expect(response).to redirect_to('https://example.com/project')
+        expect(response).to redirect_to(service.issue_tracker_path)
       end
     end
 
@@ -139,19 +141,21 @@ describe Projects::IssuesController do
     end
 
     context 'external issue tracker' do
+      let!(:service) do
+        create(:custom_issue_tracker_service, project: project, title: 'Custom Issue Tracker', new_issue_url: 'http://test.com')
+      end
+
       before do
         sign_in(user)
         project.team << [user, :developer]
       end
 
       it 'redirects to the external issue tracker' do
-        external = double(new_issue_path: 'https://example.com/issues/new')
-        allow(project).to receive(:external_issue_tracker).and_return(external)
         controller.instance_variable_set(:@project, project)
 
         get :new, namespace_id: project.namespace, project_id: project
 
-        expect(response).to redirect_to('https://example.com/issues/new')
+        expect(response).to redirect_to('http://test.com')
       end
     end
   end
@@ -512,6 +516,36 @@ describe Projects::IssuesController do
       end
     end
 
+    describe 'GET #realtime_changes' do
+      it_behaves_like 'restricted action', success: 200
+
+      def go(id:)
+        get :realtime_changes,
+          namespace_id: project.namespace.to_param,
+          project_id: project,
+          id: id
+      end
+
+      context 'when an issue was edited by a deleted user' do
+        let(:deleted_user) { create(:user) }
+
+        before do
+          project.team << [user, :developer]
+
+          issue.update!(last_edited_by: deleted_user, last_edited_at: Time.now)
+
+          deleted_user.destroy
+          sign_in(user)
+        end
+
+        it 'returns 200' do
+          go(id: issue.iid)
+
+          expect(response).to have_http_status(200)
+        end
+      end
+    end
+
     describe 'GET #edit' do
       it_behaves_like 'restricted action', success: 200
 
diff --git a/spec/controllers/projects/merge_requests_controller_spec.rb b/spec/controllers/projects/merge_requests_controller_spec.rb
index 6f9ce60cf75..c193babead0 100644
--- a/spec/controllers/projects/merge_requests_controller_spec.rb
+++ b/spec/controllers/projects/merge_requests_controller_spec.rb
@@ -481,7 +481,8 @@ describe Projects::MergeRequestsController do
     end
 
     it 'responds with serialized pipelines' do
-      expect(json_response).not_to be_empty
+      expect(json_response['pipelines']).not_to be_empty
+      expect(json_response['count']['all']).to eq 1
     end
   end
 
diff --git a/spec/controllers/projects_controller_spec.rb b/spec/controllers/projects_controller_spec.rb
index f96fe7ad5cb..192cca45d99 100644
--- a/spec/controllers/projects_controller_spec.rb
+++ b/spec/controllers/projects_controller_spec.rb
@@ -211,24 +211,43 @@ describe ProjectsController do
 
     let(:admin) { create(:admin) }
     let(:project) { create(:project, :repository) }
-    let(:new_path) { 'renamed_path' }
-    let(:project_params) { { path: new_path } }
 
     before do
       sign_in(admin)
     end
 
-    it "sets the repository to the right path after a rename" do
-      controller.instance_variable_set(:@project, project)
+    context 'when only renaming a project path' do
+      it "sets the repository to the right path after a rename" do
+        expect { update_project path: 'renamed_path' }
+          .to change { project.reload.path }
 
-      put :update,
-          namespace_id: project.namespace,
-          id: project.id,
-          project: project_params
+        expect(project.path).to include 'renamed_path'
+        expect(assigns(:repository).path).to include project.path
+        expect(response).to have_http_status(302)
+      end
+    end
 
-      expect(project.repository.path).to include(new_path)
-      expect(assigns(:repository).path).to eq(project.repository.path)
-      expect(response).to have_http_status(302)
+    context 'when project has container repositories with tags' do
+      before do
+        stub_container_registry_config(enabled: true)
+        stub_container_registry_tags(repository: /image/, tags: %w[rc1])
+        create(:container_repository, project: project, name: :image)
+      end
+
+      it 'does not allow to rename the project' do
+        expect { update_project path: 'renamed_path' }
+          .not_to change { project.reload.path }
+
+        expect(controller).to set_flash[:alert].to(/container registry tags/)
+        expect(response).to have_http_status(200)
+      end
+    end
+
+    def update_project(**parameters)
+      put :update,
+          namespace_id: project.namespace.path,
+          id: project.path,
+          project: parameters
     end
   end
 
diff --git a/spec/controllers/sessions_controller_spec.rb b/spec/controllers/sessions_controller_spec.rb
index bf922260b2f..2b4e8723b48 100644
--- a/spec/controllers/sessions_controller_spec.rb
+++ b/spec/controllers/sessions_controller_spec.rb
@@ -47,7 +47,7 @@ describe SessionsController do
         end
       end
 
-      context 'when using valid password', :redis do
+      context 'when using valid password', :clean_gitlab_redis_shared_state do
         include UserActivitiesHelpers
 
         let(:user) { create(:user) }
diff --git a/spec/controllers/snippets_controller_spec.rb b/spec/controllers/snippets_controller_spec.rb
index 15416a89017..475ceda11fe 100644
--- a/spec/controllers/snippets_controller_spec.rb
+++ b/spec/controllers/snippets_controller_spec.rb
@@ -186,8 +186,8 @@ describe SnippetsController do
     end
 
     context 'when the snippet description contains a file' do
-      let(:picture_file) { '/temp/secret56/picture.jpg' }
-      let(:text_file) { '/temp/secret78/text.txt' }
+      let(:picture_file) { '/system/temp/secret56/picture.jpg' }
+      let(:text_file) { '/system/temp/secret78/text.txt' }
       let(:description) do
         "Description with picture: ![picture](/uploads#{picture_file}) and "\
         "text: [text.txt](/uploads#{text_file})"
@@ -208,8 +208,8 @@ describe SnippetsController do
         snippet = subject
 
         expected_description = "Description with picture: "\
-          "![picture](/uploads/personal_snippet/#{snippet.id}/secret56/picture.jpg) and "\
-          "text: [text.txt](/uploads/personal_snippet/#{snippet.id}/secret78/text.txt)"
+          "![picture](/uploads/system/personal_snippet/#{snippet.id}/secret56/picture.jpg) and "\
+          "text: [text.txt](/uploads/system/personal_snippet/#{snippet.id}/secret78/text.txt)"
 
         expect(snippet.description).to eq(expected_description)
       end
diff --git a/spec/controllers/uploads_controller_spec.rb b/spec/controllers/uploads_controller_spec.rb
index 01a0659479b..96f719e2b82 100644
--- a/spec/controllers/uploads_controller_spec.rb
+++ b/spec/controllers/uploads_controller_spec.rb
@@ -102,7 +102,7 @@ describe UploadsController do
           subject
 
           expect(response.body).to match '\"alt\":\"rails_sample\"'
-          expect(response.body).to match "\"url\":\"/uploads/temp"
+          expect(response.body).to match "\"url\":\"/uploads/system/temp"
         end
 
         it 'does not create an Upload record' do
@@ -119,7 +119,7 @@ describe UploadsController do
           subject
 
           expect(response.body).to match '\"alt\":\"doc_sample.txt\"'
-          expect(response.body).to match "\"url\":\"/uploads/temp"
+          expect(response.body).to match "\"url\":\"/uploads/system/temp"
         end
 
         it 'does not create an Upload record' do
diff --git a/spec/factories/ci/triggers.rb b/spec/factories/ci/triggers.rb
index c3a29d8bf04..40c4663c6d8 100644
--- a/spec/factories/ci/triggers.rb
+++ b/spec/factories/ci/triggers.rb
@@ -2,13 +2,6 @@ FactoryGirl.define do
   factory :ci_trigger_without_token, class: Ci::Trigger do
     factory :ci_trigger do
       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/commits.rb b/spec/factories/commits.rb
index 36b9645438a..89e260cf65b 100644
--- a/spec/factories/commits.rb
+++ b/spec/factories/commits.rb
@@ -4,14 +4,19 @@ FactoryGirl.define do
   factory :commit do
     git_commit RepoHelpers.sample_commit
     project factory: :empty_project
-    author { build(:author) }
 
     initialize_with do
       new(git_commit, project)
     end
 
+    after(:build) do |commit|
+      allow(commit).to receive(:author).and_return build(:author)
+    end
+
     trait :without_author do
-      author nil
+      after(:build) do |commit|
+        allow(commit).to receive(:author).and_return nil
+      end
     end
   end
 end
diff --git a/spec/factories/uploads.rb b/spec/factories/uploads.rb
index 1383420fb44..3222c41c3d8 100644
--- a/spec/factories/uploads.rb
+++ b/spec/factories/uploads.rb
@@ -1,7 +1,7 @@
 FactoryGirl.define do
   factory :upload do
     model { build(:project) }
-    path { "uploads/system/project/avatar/avatar.jpg" }
+    path { "uploads/-/system/project/avatar/avatar.jpg" }
     size 100.kilobytes
     uploader "AvatarUploader"
   end
diff --git a/spec/features/admin/admin_appearance_spec.rb b/spec/features/admin/admin_appearance_spec.rb
index 1e2cb8569ec..b9e361328df 100644
--- a/spec/features/admin/admin_appearance_spec.rb
+++ b/spec/features/admin/admin_appearance_spec.rb
@@ -63,11 +63,11 @@ feature 'Admin Appearance', feature: true do
   end
 
   def logo_selector
-    '//img[@src^="/uploads/system/appearance/logo"]'
+    '//img[@src^="/uploads/-/system/appearance/logo"]'
   end
 
   def header_logo_selector
-    '//img[@src^="/uploads/system/appearance/header_logo"]'
+    '//img[@src^="/uploads/-/system/appearance/header_logo"]'
   end
 
   def logo_fixture
diff --git a/spec/features/admin/admin_users_impersonation_tokens_spec.rb b/spec/features/admin/admin_users_impersonation_tokens_spec.rb
index cd7040891e9..d01722805c4 100644
--- a/spec/features/admin/admin_users_impersonation_tokens_spec.rb
+++ b/spec/features/admin/admin_users_impersonation_tokens_spec.rb
@@ -8,8 +8,8 @@ describe 'Admin > Users > Impersonation Tokens', feature: true, js: true do
     find(".table.active-tokens")
   end
 
-  def inactive_impersonation_tokens
-    find(".table.inactive-tokens")
+  def no_personal_access_tokens_message
+    find(".settings-message")
   end
 
   before do
@@ -60,15 +60,17 @@ describe 'Admin > Users > Impersonation Tokens', feature: true, js: true do
 
       click_on "Revoke"
 
-      expect(inactive_impersonation_tokens).to have_text(impersonation_token.name)
+      expect(page).to have_selector(".settings-message")
+      expect(no_personal_access_tokens_message).to have_text("This user has no active Impersonation Tokens.")
     end
 
-    it "moves expired tokens to the 'inactive' section" do
+    it "removes expired tokens from 'active' section" do
       impersonation_token.update(expires_at: 5.days.ago)
 
       visit admin_user_impersonation_tokens_path(user_id: user.username)
 
-      expect(inactive_impersonation_tokens).to have_text(impersonation_token.name)
+      expect(page).to have_selector(".settings-message")
+      expect(no_personal_access_tokens_message).to have_text("This user has no active Impersonation Tokens.")
     end
   end
 end
diff --git a/spec/features/boards/boards_spec.rb b/spec/features/boards/boards_spec.rb
index 3d7e26c7e19..b939fb5e89e 100644
--- a/spec/features/boards/boards_spec.rb
+++ b/spec/features/boards/boards_spec.rb
@@ -3,7 +3,8 @@ require 'rails_helper'
 describe 'Issue Boards', feature: true, js: true do
   include DragTo
 
-  let(:project) { create(:empty_project, :public) }
+  let(:group) { create(:group, :nested) }
+  let(:project) { create(:empty_project, :public, namespace: group) }
   let(:board)   { create(:board, project: project) }
   let(:user)    { create(:user) }
   let!(:user2)  { create(:user) }
diff --git a/spec/features/dashboard/activity_spec.rb b/spec/features/dashboard/activity_spec.rb
index ebfe7340eb7..a96270c9147 100644
--- a/spec/features/dashboard/activity_spec.rb
+++ b/spec/features/dashboard/activity_spec.rb
@@ -1,13 +1,162 @@
 require 'spec_helper'
 
-RSpec.describe 'Dashboard Activity', feature: true do
+feature 'Dashboard > Activity' do
   let(:user) { create(:user) }
 
   before do
     sign_in(user)
-    visit activity_dashboard_path
   end
 
-  it_behaves_like "it has an RSS button with current_user's RSS token"
-  it_behaves_like "an autodiscoverable RSS feed with current_user's RSS token"
+  context 'rss' do
+    before do
+      visit activity_dashboard_path
+    end
+
+    it_behaves_like "it has an RSS button with current_user's RSS token"
+    it_behaves_like "an autodiscoverable RSS feed with current_user's RSS token"
+  end
+
+  context 'event filters', :js do
+    let(:project) { create(:empty_project) }
+
+    let(:merge_request) do
+      create(:merge_request, author: user, source_project: project, target_project: project)
+    end
+
+    let(:push_event_data) do
+      {
+        before: Gitlab::Git::BLANK_SHA,
+        after: '0220c11b9a3e6c69dc8fd35321254ca9a7b98f7e',
+        ref: 'refs/heads/new_design',
+        user_id: user.id,
+        user_name: user.name,
+        repository: {
+          name: project.name,
+          url: 'localhost/rubinius',
+          description: '',
+          homepage: 'localhost/rubinius',
+          private: true
+        }
+      }
+    end
+
+    let(:note) { create(:note, project: project, noteable: merge_request) }
+
+    let!(:push_event) do
+      create(:event, :pushed, data: push_event_data, project: project, author: user)
+    end
+
+    let!(:merged_event) do
+      create(:event, :merged, project: project, target: merge_request, author: user)
+    end
+
+    let!(:joined_event) do
+      create(:event, :joined, project: project, author: user)
+    end
+
+    let!(:closed_event) do
+      create(:event, :closed, project: project, target: merge_request, author: user)
+    end
+
+    let!(:comments_event) do
+      create(:event, :commented, project: project, target: note, author: user)
+    end
+
+    before do
+      project.add_master(user)
+
+      visit activity_dashboard_path
+      wait_for_requests
+    end
+
+    scenario 'user should see all events' do
+      within '.content_list' do
+        expect(page).to have_content('pushed new branch')
+        expect(page).to have_content('joined')
+        expect(page).to have_content('accepted')
+        expect(page).to have_content('closed')
+        expect(page).to have_content('commented on')
+      end
+    end
+
+    scenario 'user should see only pushed events' do
+      click_link('Push events')
+      wait_for_requests
+
+      within '.content_list' do
+        expect(page).to have_content('pushed new branch')
+        expect(page).not_to have_content('joined')
+        expect(page).not_to have_content('accepted')
+        expect(page).not_to have_content('closed')
+        expect(page).not_to have_content('commented on')
+      end
+    end
+
+    scenario 'user should see only merged events' do
+      click_link('Merge events')
+      wait_for_requests
+
+      within '.content_list' do
+        expect(page).not_to have_content('pushed new branch')
+        expect(page).not_to have_content('joined')
+        expect(page).to have_content('accepted')
+        expect(page).not_to have_content('closed')
+        expect(page).not_to have_content('commented on')
+      end
+    end
+
+    scenario 'user should see only issues events' do
+      click_link('Issue events')
+      wait_for_requests
+
+      within '.content_list' do
+        expect(page).not_to have_content('pushed new branch')
+        expect(page).not_to have_content('joined')
+        expect(page).not_to have_content('accepted')
+        expect(page).to have_content('closed')
+        expect(page).not_to have_content('commented on')
+      end
+    end
+
+    scenario 'user should see only comments events' do
+      click_link('Comments')
+      wait_for_requests
+
+      within '.content_list' do
+        expect(page).not_to have_content('pushed new branch')
+        expect(page).not_to have_content('joined')
+        expect(page).not_to have_content('accepted')
+        expect(page).not_to have_content('closed')
+        expect(page).to have_content('commented on')
+      end
+    end
+
+    scenario 'user should see only joined events' do
+      click_link('Team')
+      wait_for_requests
+
+      within '.content_list' do
+        expect(page).not_to have_content('pushed new branch')
+        expect(page).to have_content('joined')
+        expect(page).not_to have_content('accepted')
+        expect(page).not_to have_content('closed')
+        expect(page).not_to have_content('commented on')
+      end
+    end
+
+    scenario 'user see selected event after page reloading' do
+      click_link('Push events')
+      wait_for_requests
+      visit activity_dashboard_path
+      wait_for_requests
+
+      within '.content_list' do
+        expect(page).to have_content('pushed new branch')
+        expect(page).not_to have_content('joined')
+        expect(page).not_to have_content('accepted')
+        expect(page).not_to have_content('closed')
+        expect(page).not_to have_content('commented on')
+      end
+    end
+  end
 end
diff --git a/spec/features/dashboard/groups_list_spec.rb b/spec/features/dashboard/groups_list_spec.rb
index 54a01e837de..533df7a325c 100644
--- a/spec/features/dashboard/groups_list_spec.rb
+++ b/spec/features/dashboard/groups_list_spec.rb
@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe 'Dashboard Groups page', js: true, feature: true do
+feature 'Dashboard Groups page', :js do
   let!(:user) { create :user }
   let!(:group) { create(:group) }
   let!(:nested_group) { create(:group, :nested) }
@@ -41,7 +41,7 @@ describe 'Dashboard Groups page', js: true, feature: true do
       fill_in 'filter_groups', with: group.name
       wait_for_requests
 
-      fill_in 'filter_groups', with: ""
+      fill_in 'filter_groups', with: ''
       wait_for_requests
 
       expect(page).to have_content(group.full_name)
diff --git a/spec/features/dashboard/issuables_counter_spec.rb b/spec/features/dashboard/issuables_counter_spec.rb
index 285724f4b48..6b666934563 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, caching: true do
+describe 'Navigation bar counter', :use_clean_rails_memory_store_caching, feature: true do
   let(:user) { create(:user) }
   let(:project) { create(:empty_project, namespace: user.namespace) }
   let(:issue) { create(:issue, project: project) }
diff --git a/spec/features/dashboard_issues_spec.rb b/spec/features/dashboard/issues_filter_spec.rb
index f235fef1aa4..9b84f67b555 100644
--- a/spec/features/dashboard_issues_spec.rb
+++ b/spec/features/dashboard/issues_filter_spec.rb
@@ -1,21 +1,23 @@
 require 'spec_helper'
 
-describe "Dashboard Issues filtering", feature: true, js: true do
+feature 'Dashboard Issues filtering', js: true do
+  include SortingHelper
+
   let(:user)      { create(:user) }
   let(:project)   { create(:empty_project) }
   let(:milestone) { create(:milestone, project: project) }
 
-  context 'filtering by milestone' do
-    before do
-      project.team << [user, :master]
-      sign_in(user)
+  let!(:issue)  { create(:issue, project: project, author: user, assignees: [user]) }
+  let!(:issue2) { create(:issue, project: project, author: user, assignees: [user], milestone: milestone) }
 
-      create(:issue, project: project, author: user, assignees: [user])
-      create(:issue, project: project, author: user, assignees: [user], milestone: milestone)
+  before do
+    project.add_master(user)
+    sign_in(user)
 
-      visit_issues
-    end
+    visit_issues
+  end
 
+  context 'filtering by milestone' do
     it 'shows all issues with no milestone' do
       show_milestone_dropdown
 
@@ -62,6 +64,46 @@ describe "Dashboard Issues filtering", feature: true, js: true do
     end
   end
 
+  context 'filtering by label' do
+    let(:label) { create(:label, project: project) }
+    let!(:label_link) { create(:label_link, label: label, target: issue) }
+
+    it 'shows all issues without filter' do
+      page.within 'ul.content-list' do
+        expect(page).to have_content issue.title
+        expect(page).to have_content issue2.title
+      end
+    end
+
+    it 'shows all issues with the selected label' do
+      page.within '.labels-filter' do
+        find('.dropdown').click
+        click_link label.title
+      end
+
+      page.within 'ul.content-list' do
+        expect(page).to have_content issue.title
+        expect(page).not_to have_content issue2.title
+      end
+    end
+  end
+
+  context 'sorting' do
+    it 'shows sorted issues' do
+      sorting_by('Oldest updated')
+      visit_issues
+
+      expect(find('.issues-filters')).to have_content('Oldest updated')
+    end
+
+    it 'keeps sorting issues after visiting Projects Issues page' do
+      sorting_by('Oldest updated')
+      visit project_issues_path(project)
+
+      expect(find('.issues-filters')).to have_content('Oldest updated')
+    end
+  end
+
   def show_milestone_dropdown
     click_button 'Milestone'
     expect(page).to have_selector('.dropdown-content', visible: true)
diff --git a/spec/features/dashboard/issues_spec.rb b/spec/features/dashboard/issues_spec.rb
index 86ac24ea06e..69c1a2ed89a 100644
--- a/spec/features/dashboard/issues_spec.rb
+++ b/spec/features/dashboard/issues_spec.rb
@@ -62,7 +62,7 @@ RSpec.describe 'Dashboard Issues', feature: true do
 
     it 'state filter tabs work' do
       find('#state-closed').click
-      expect(page).to have_current_path(issues_dashboard_url(assignee_id: current_user.id, scope: 'all', state: 'closed'), url: true)
+      expect(page).to have_current_path(issues_dashboard_url(assignee_id: current_user.id, state: 'closed'), url: true)
     end
 
     it_behaves_like "it has an RSS button with current_user's RSS token"
diff --git a/spec/features/dashboard/merge_requests_spec.rb b/spec/features/dashboard/merge_requests_spec.rb
index bb1fb5b3feb..42d6fadc0c1 100644
--- a/spec/features/dashboard/merge_requests_spec.rb
+++ b/spec/features/dashboard/merge_requests_spec.rb
@@ -2,6 +2,7 @@ require 'spec_helper'
 
 feature 'Dashboard Merge Requests' do
   include FilterItemSelectHelper
+  include SortingHelper
 
   let(:current_user) { create :user }
   let(:project) { create(:empty_project) }
@@ -109,5 +110,21 @@ feature 'Dashboard Merge Requests' do
       expect(page).to have_content(assigned_merge_request_from_fork.title)
       expect(page).to have_content(other_merge_request.title)
     end
+
+    it 'shows sorted merge requests' do
+      sorting_by('Oldest updated')
+
+      visit merge_requests_dashboard_path(assignee_id: current_user.id)
+
+      expect(find('.issues-filters')).to have_content('Oldest updated')
+    end
+
+    it 'keeps sorting merge requests after visiting Projects MR page' do
+      sorting_by('Oldest updated')
+
+      visit project_merge_requests_path(project)
+
+      expect(find('.issues-filters')).to have_content('Oldest updated')
+    end
   end
 end
diff --git a/spec/features/dashboard_milestones_spec.rb b/spec/features/dashboard/milestones_spec.rb
index 7a6a448d4c2..7a6a448d4c2 100644
--- a/spec/features/dashboard_milestones_spec.rb
+++ b/spec/features/dashboard/milestones_spec.rb
diff --git a/spec/features/dashboard/projects_spec.rb b/spec/features/dashboard/projects_spec.rb
index 7ca002fc821..abb9e5eef96 100644
--- a/spec/features/dashboard/projects_spec.rb
+++ b/spec/features/dashboard/projects_spec.rb
@@ -61,7 +61,7 @@ feature 'Dashboard Projects' do
     end
   end
 
-  describe 'with a pipeline', redis: true do
+  describe 'with a pipeline', clean_gitlab_redis_shared_state: true do
     let(:pipeline) { create(:ci_pipeline, project: project, sha: project.commit.sha) }
 
     before do
@@ -74,7 +74,50 @@ feature 'Dashboard Projects' do
     it 'shows that the last pipeline passed' do
       visit dashboard_projects_path
 
-      expect(page).to have_xpath("//a[@href='#{pipelines_project_commit_path(project, project.commit)}']")
+      page.within('.controls') do
+        expect(page).to have_xpath("//a[@href='#{pipelines_project_commit_path(project, project.commit)}']")
+        expect(page).to have_css('.ci-status-link')
+        expect(page).to have_css('.ci-status-icon-success')
+        expect(page).to have_link('Commit: passed')
+      end
+    end
+  end
+
+  context 'last push widget' do
+    let(:push_event_data) do
+      {
+        before: Gitlab::Git::BLANK_SHA,
+        after: '0220c11b9a3e6c69dc8fd35321254ca9a7b98f7e',
+        ref: 'refs/heads/feature',
+        user_id: user.id,
+        user_name: user.name,
+        repository: {
+          name: project.name,
+          url: 'localhost/rubinius',
+          description: '',
+          homepage: 'localhost/rubinius',
+          private: true
+        }
+      }
+    end
+    let!(:push_event) { create(:event, :pushed, data: push_event_data, project: project, author: user) }
+
+    before do
+      visit dashboard_projects_path
+    end
+
+    scenario 'shows "Create merge request" button' do
+      expect(page).to have_content 'You pushed to feature'
+
+      within('#content-body') do
+        find_link('Create merge request', visible: false).click
+      end
+
+      expect(page).to have_selector('.merge-request-form')
+      expect(current_path).to eq project_new_merge_request_path(project)
+      expect(find('#merge_request_target_project_id').value).to eq project.id.to_s
+      expect(find('input#merge_request_source_branch').value).to eq 'feature'
+      expect(find('input#merge_request_target_branch').value).to eq 'master'
     end
   end
 end
diff --git a/spec/features/groups/members/sort_members_spec.rb b/spec/features/groups/members/sort_members_spec.rb
index 169827f5d0d..92ff45e0cdc 100644
--- a/spec/features/groups/members/sort_members_spec.rb
+++ b/spec/features/groups/members/sort_members_spec.rb
@@ -68,7 +68,7 @@ feature 'Groups > Members > Sort members', feature: true do
     expect(page).to have_css('.member-sort-dropdown .dropdown-toggle-text', text: 'Name, descending')
   end
 
-  scenario 'sorts by recent sign in', :redis do
+  scenario 'sorts by recent sign in', :clean_gitlab_redis_shared_state do
     visit_members_list(sort: :recent_sign_in)
 
     expect(first_member).to include(owner.name)
@@ -76,7 +76,7 @@ feature 'Groups > Members > Sort members', feature: true do
     expect(page).to have_css('.member-sort-dropdown .dropdown-toggle-text', text: 'Recent sign in')
   end
 
-  scenario 'sorts by oldest sign in', :redis do
+  scenario 'sorts by oldest sign in', :clean_gitlab_redis_shared_state do
     visit_members_list(sort: :oldest_sign_in)
 
     expect(first_member).to include(developer.name)
diff --git a/spec/features/issues/issue_detail_spec.rb b/spec/features/issues/issue_detail_spec.rb
new file mode 100644
index 00000000000..e1c55d246ab
--- /dev/null
+++ b/spec/features/issues/issue_detail_spec.rb
@@ -0,0 +1,43 @@
+require 'rails_helper'
+
+feature 'Issue Detail', js: true, feature: true do
+  let(:user)      { create(:user) }
+  let(:project)   { create(:project, :public) }
+  let(:issue)     { create(:issue, project: project, author: user) }
+
+  context 'when user displays the issue' do
+    before do
+      visit project_issue_path(project, issue)
+      wait_for_requests
+    end
+
+    it 'shows the issue' do
+      page.within('.issuable-details') do
+        expect(find('h2')).to have_content(issue.title)
+      end
+    end
+  end
+
+  context 'when edited by a user who is later deleted' do
+    before do
+      sign_in(user)
+      visit project_issue_path(project, issue)
+      wait_for_requests
+
+      click_link 'Edit'
+      fill_in 'issue-title', with: 'issue title'
+      click_button 'Save'
+
+      visit profile_account_path
+      click_link 'Delete account'
+
+      visit project_issue_path(project, issue)
+    end
+
+    it 'shows the issue' do
+      page.within('.issuable-details') do
+        expect(find('h2')).to have_content(issue.reload.title)
+      end
+    end
+  end
+end
diff --git a/spec/features/login_spec.rb b/spec/features/login_spec.rb
index a8055b21cee..2a2213b67ed 100644
--- a/spec/features/login_spec.rb
+++ b/spec/features/login_spec.rb
@@ -41,7 +41,7 @@ feature 'Login', feature: true do
       expect(page).to have_content('Your account has been blocked.')
     end
 
-    it 'does not update Devise trackable attributes', :redis do
+    it 'does not update Devise trackable attributes', :clean_gitlab_redis_shared_state do
       user = create(:user, :blocked)
 
       expect { gitlab_sign_in(user) }.not_to change { user.reload.sign_in_count }
@@ -55,7 +55,7 @@ feature 'Login', feature: true do
       expect(page).to have_content('Invalid Login or password.')
     end
 
-    it 'does not update Devise trackable attributes', :redis do
+    it 'does not update Devise trackable attributes', :clean_gitlab_redis_shared_state do
       expect { gitlab_sign_in(User.ghost) }.not_to change { User.ghost.reload.sign_in_count }
     end
   end
diff --git a/spec/features/merge_requests/conflicts_spec.rb b/spec/features/merge_requests/conflicts_spec.rb
index 3e01ea69122..5c0909b6a59 100644
--- a/spec/features/merge_requests/conflicts_spec.rb
+++ b/spec/features/merge_requests/conflicts_spec.rb
@@ -4,6 +4,11 @@ feature 'Merge request conflict resolution', js: true, feature: true do
   let(:user) { create(:user) }
   let(:project) { create(:project) }
 
+  before do
+    # In order to have the diffs collapsed, we need to disable the increase feature
+    stub_feature_flags(gitlab_git_diff_size_limit_increase: false)
+  end
+
   def create_merge_request(source_branch)
     create(:merge_request, source_branch: source_branch, target_branch: 'conflict-start', source_project: project) do |mr|
       mr.mark_as_unmergeable
diff --git a/spec/features/merge_requests/filter_merge_requests_spec.rb b/spec/features/merge_requests/filter_merge_requests_spec.rb
index 2a161b83aa0..e8085ec36aa 100644
--- a/spec/features/merge_requests/filter_merge_requests_spec.rb
+++ b/spec/features/merge_requests/filter_merge_requests_spec.rb
@@ -132,19 +132,13 @@ describe 'Filter merge requests', feature: true do
     end
   end
 
-  describe 'for assignee and label from issues#index' do
+  describe 'for assignee and label from mr#index' do
     let(:search_query) { "assignee:@#{user.username} label:~#{label.title}" }
 
     before do
-      input_filtered_search("assignee:@#{user.username}")
-
-      expect_mr_list_count(1)
-      expect_tokens([{ name: 'assignee', value: "@#{user.username}" }])
-      expect_filtered_search_input_empty
-
-      input_filtered_search_keys("label:~#{label.title}")
+      input_filtered_search(search_query)
 
-      expect_mr_list_count(1)
+      expect_mr_list_count(0)
     end
 
     context 'assignee and label', js: true do
diff --git a/spec/features/participants_autocomplete_spec.rb b/spec/features/participants_autocomplete_spec.rb
index 382d83ca051..81b0a2f541b 100644
--- a/spec/features/participants_autocomplete_spec.rb
+++ b/spec/features/participants_autocomplete_spec.rb
@@ -54,7 +54,8 @@ feature 'Member autocomplete', :js do
     let(:note) { create(:note_on_commit, project: project, commit_id: project.commit.id) }
 
     before do
-      allow_any_instance_of(Commit).to receive(:author).and_return(author)
+      allow(User).to receive(:find_by_any_email)
+        .with(noteable.author_email.downcase).and_return(author)
 
       visit project_commit_path(project, noteable)
     end
diff --git a/spec/features/profiles/password_spec.rb b/spec/features/profiles/password_spec.rb
index 67975a68ee2..26d6d6658aa 100644
--- a/spec/features/profiles/password_spec.rb
+++ b/spec/features/profiles/password_spec.rb
@@ -1,44 +1,74 @@
 require 'spec_helper'
 
 describe 'Profile > Password', feature: true do
-  let(:user) { create(:user, password_automatically_set: true) }
+  context 'Password authentication enabled' do
+    let(:user) { create(:user, password_automatically_set: true) }
 
-  before do
-    sign_in(user)
-    visit edit_profile_password_path
-  end
+    before do
+      sign_in(user)
+      visit edit_profile_password_path
+    end
 
-  def fill_passwords(password, confirmation)
-    fill_in 'New password',          with: password
-    fill_in 'Password confirmation', with: confirmation
+    def fill_passwords(password, confirmation)
+      fill_in 'New password',          with: password
+      fill_in 'Password confirmation', with: confirmation
 
-    click_button 'Save password'
-  end
+      click_button 'Save password'
+    end
+
+    context 'User with password automatically set' do
+      describe 'User puts different passwords in the field and in the confirmation' do
+        it 'shows an error message' do
+          fill_passwords('mypassword', 'mypassword2')
 
-  context 'User with password automatically set' do
-    describe 'User puts different passwords in the field and in the confirmation' do
-      it 'shows an error message' do
-        fill_passwords('mypassword', 'mypassword2')
+          page.within('.alert-danger') do
+            expect(page).to have_content("Password confirmation doesn't match Password")
+          end
+        end
+
+        it 'does not contain the current password field after an error' do
+          fill_passwords('mypassword', 'mypassword2')
 
-        page.within('.alert-danger') do
-          expect(page).to have_content("Password confirmation doesn't match Password")
+          expect(page).to have_no_field('user[current_password]')
         end
       end
 
-      it 'does not contain the current password field after an error' do
-        fill_passwords('mypassword', 'mypassword2')
+      describe 'User puts the same passwords in the field and in the confirmation' do
+        it 'shows a success message' do
+          fill_passwords('mypassword', 'mypassword')
 
-        expect(page).to have_no_field('user[current_password]')
+          page.within('.flash-notice') do
+            expect(page).to have_content('Password was successfully updated. Please login with it')
+          end
+        end
       end
     end
+  end
 
-    describe 'User puts the same passwords in the field and in the confirmation' do
-      it 'shows a success message' do
-        fill_passwords('mypassword', 'mypassword')
+  context 'Password authentication unavailable' do
+    before do
+      gitlab_sign_in(user)
+    end
 
-        page.within('.flash-notice') do
-          expect(page).to have_content('Password was successfully updated. Please login with it')
-        end
+    context 'Regular user' do
+      let(:user) { create(:user) }
+
+      it 'renders 404 when sign-in is disabled' do
+        stub_application_setting(password_authentication_enabled: false)
+
+        visit edit_profile_password_path
+
+        expect(page).to have_http_status(404)
+      end
+    end
+
+    context 'LDAP user' do
+      let(:user) { create(:omniauth_user, provider: 'ldapmain') }
+
+      it 'renders 404' do
+        visit edit_profile_password_path
+
+        expect(page).to have_http_status(404)
       end
     end
   end
diff --git a/spec/features/profiles/personal_access_tokens_spec.rb b/spec/features/profiles/personal_access_tokens_spec.rb
index 44b7ee101c9..3c08b6bc091 100644
--- a/spec/features/profiles/personal_access_tokens_spec.rb
+++ b/spec/features/profiles/personal_access_tokens_spec.rb
@@ -7,8 +7,8 @@ describe 'Profile > Personal Access Tokens', feature: true, js: true do
     find(".table.active-tokens")
   end
 
-  def inactive_personal_access_tokens
-    find(".table.inactive-tokens")
+  def no_personal_access_tokens_message
+    find(".settings-message")
   end
 
   def created_personal_access_token
@@ -80,14 +80,16 @@ describe 'Profile > Personal Access Tokens', feature: true, js: true do
       visit profile_personal_access_tokens_path
       click_on "Revoke"
 
-      expect(inactive_personal_access_tokens).to have_text(personal_access_token.name)
+      expect(page).to have_selector(".settings-message")
+      expect(no_personal_access_tokens_message).to have_text("This user has no active Personal Access Tokens.")
     end
 
-    it "moves expired tokens to the 'inactive' section" do
+    it "removes expired tokens from 'active' section" do
       personal_access_token.update(expires_at: 5.days.ago)
       visit profile_personal_access_tokens_path
 
-      expect(inactive_personal_access_tokens).to have_text(personal_access_token.name)
+      expect(page).to have_selector(".settings-message")
+      expect(no_personal_access_tokens_message).to have_text("This user has no active Personal Access Tokens.")
     end
 
     context "when revocation fails" do
diff --git a/spec/features/projects/branches_spec.rb b/spec/features/projects/branches_spec.rb
index 4fae324d8d5..d18cd3d6adc 100644
--- a/spec/features/projects/branches_spec.rb
+++ b/spec/features/projects/branches_spec.rb
@@ -24,7 +24,6 @@ describe 'Branches', feature: true do
         repository.branches_sorted_by(:name).first(20).each do |branch|
           expect(page).to have_content("#{branch.name}")
         end
-        expect(page).to have_content("Protected branches can be managed in project settings")
       end
 
       it 'sorts the branches by name' do
@@ -130,6 +129,14 @@ describe 'Branches', feature: true do
       project.team << [user, :master]
     end
 
+    describe 'Initial branches page' do
+      it 'shows description for admin' do
+        visit project_branches_path(project)
+
+        expect(page).to have_content("Protected branches can be managed in project settings")
+      end
+    end
+
     describe 'Delete protected branch' do
       before do
         visit project_protected_branches_path(project)
diff --git a/spec/features/projects/diffs/diff_show_spec.rb b/spec/features/projects/diffs/diff_show_spec.rb
index b528b283495..4baccb24806 100644
--- a/spec/features/projects/diffs/diff_show_spec.rb
+++ b/spec/features/projects/diffs/diff_show_spec.rb
@@ -110,6 +110,10 @@ feature 'Diff file viewer', :js, feature: true do
 
   context 'binary file that appears to be text in the first 1024 bytes' do
     before do
+      # The file we're visiting is smaller than 10 KB and we want it collapsed
+      # so we need to disable the size increase feature.
+      stub_feature_flags(gitlab_git_diff_size_limit_increase: false)
+
       visit_commit('7b1cf4336b528e0f3d1d140ee50cafdbc703597c')
     end
 
diff --git a/spec/features/projects/issuable_counts_caching_spec.rb b/spec/features/projects/issuable_counts_caching_spec.rb
new file mode 100644
index 00000000000..703d1cbd327
--- /dev/null
+++ b/spec/features/projects/issuable_counts_caching_spec.rb
@@ -0,0 +1,132 @@
+require 'spec_helper'
+
+describe 'Issuable counts caching', :use_clean_rails_memory_store_caching do
+  let!(:member) { create(:user) }
+  let!(:member_2) { create(:user) }
+  let!(:non_member) { create(:user) }
+  let!(:project) { create(:empty_project, :public) }
+  let!(:open_issue) { create(:issue, project: project) }
+  let!(:confidential_issue) { create(:issue, :confidential, project: project, author: non_member) }
+  let!(:closed_issue) { create(:issue, :closed, project: project) }
+
+  before do
+    project.add_developer(member)
+    project.add_developer(member_2)
+  end
+
+  it 'caches issuable counts correctly for non-members' do
+    # We can't use expect_any_instance_of because that uses a single instance.
+    counts = 0
+
+    allow_any_instance_of(IssuesFinder).to receive(:count_by_state).and_wrap_original do |m, *args|
+      counts += 1
+
+      m.call(*args)
+    end
+
+    aggregate_failures 'only counts once on first load with no params, and caches for later loads' do
+      expect { visit project_issues_path(project) }
+        .to change { counts }.by(1)
+
+      expect { visit project_issues_path(project) }
+        .not_to change { counts }
+    end
+
+    aggregate_failures 'uses counts from cache on load from non-member' do
+      sign_in(non_member)
+
+      expect { visit project_issues_path(project) }
+        .not_to change { counts }
+
+      sign_out(non_member)
+    end
+
+    aggregate_failures 'does not use the same cache for a member' do
+      sign_in(member)
+
+      expect { visit project_issues_path(project) }
+        .to change { counts }.by(1)
+
+      sign_out(member)
+    end
+
+    aggregate_failures 'uses the same cache for all members' do
+      sign_in(member_2)
+
+      expect { visit project_issues_path(project) }
+        .not_to change { counts }
+
+      sign_out(member_2)
+    end
+
+    aggregate_failures 'shares caches when params are passed' do
+      expect { visit project_issues_path(project, author_username: non_member.username) }
+        .to change { counts }.by(1)
+
+      sign_in(member)
+
+      expect { visit project_issues_path(project, author_username: non_member.username) }
+        .to change { counts }.by(1)
+
+      sign_in(non_member)
+
+      expect { visit project_issues_path(project, author_username: non_member.username) }
+        .not_to change { counts }
+
+      sign_in(member_2)
+
+      expect { visit project_issues_path(project, author_username: non_member.username) }
+        .not_to change { counts }
+
+      sign_out(member_2)
+    end
+
+    aggregate_failures 'resets caches on issue close' do
+      Issues::CloseService.new(project, member).execute(open_issue)
+
+      expect { visit project_issues_path(project) }
+        .to change { counts }.by(1)
+
+      sign_in(member)
+
+      expect { visit project_issues_path(project) }
+        .to change { counts }.by(1)
+
+      sign_in(non_member)
+
+      expect { visit project_issues_path(project) }
+        .not_to change { counts }
+
+      sign_in(member_2)
+
+      expect { visit project_issues_path(project) }
+        .not_to change { counts }
+
+      sign_out(member_2)
+    end
+
+    aggregate_failures 'does not reset caches on issue update' do
+      Issues::UpdateService.new(project, member, title: 'new title').execute(open_issue)
+
+      expect { visit project_issues_path(project) }
+        .not_to change { counts }
+
+      sign_in(member)
+
+      expect { visit project_issues_path(project) }
+        .not_to change { counts }
+
+      sign_in(non_member)
+
+      expect { visit project_issues_path(project) }
+        .not_to change { counts }
+
+      sign_in(member_2)
+
+      expect { visit project_issues_path(project) }
+        .not_to change { counts }
+
+      sign_out(member_2)
+    end
+  end
+end
diff --git a/spec/features/projects/members/sorting_spec.rb b/spec/features/projects/members/sorting_spec.rb
index afb613f034e..dc7236fa120 100644
--- a/spec/features/projects/members/sorting_spec.rb
+++ b/spec/features/projects/members/sorting_spec.rb
@@ -67,7 +67,7 @@ feature 'Projects > Members > Sorting', feature: true do
     expect(page).to have_css('.member-sort-dropdown .dropdown-toggle-text', text: 'Name, descending')
   end
 
-  scenario 'sorts by recent sign in', :redis do
+  scenario 'sorts by recent sign in', :clean_gitlab_redis_shared_state do
     visit_members_list(sort: :recent_sign_in)
 
     expect(first_member).to include(master.name)
@@ -75,7 +75,7 @@ feature 'Projects > Members > Sorting', feature: true do
     expect(page).to have_css('.member-sort-dropdown .dropdown-toggle-text', text: 'Recent sign in')
   end
 
-  scenario 'sorts by oldest sign in', :redis do
+  scenario 'sorts by oldest sign in', :clean_gitlab_redis_shared_state do
     visit_members_list(sort: :oldest_sign_in)
 
     expect(first_member).to include(developer.name)
diff --git a/spec/features/projects/merge_request_button_spec.rb b/spec/features/projects/merge_request_button_spec.rb
index 12b4747602d..8cbd26551bc 100644
--- a/spec/features/projects/merge_request_button_spec.rb
+++ b/spec/features/projects/merge_request_button_spec.rb
@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-feature 'Merge Request button', feature: true do
+feature 'Merge Request button' do
   shared_examples 'Merge request button only shown when allowed' do
     let(:user) { create(:user) }
     let(:project) { create(:project, :public) }
@@ -10,16 +10,14 @@ feature 'Merge Request button', feature: true do
       it 'does not show Create merge request button' do
         visit url
 
-        within("#content-body") do
-          expect(page).not_to have_link(label)
-        end
+        expect(page).not_to have_link(label)
       end
     end
 
     context 'logged in as developer' do
       before do
         sign_in(user)
-        project.team << [user, :developer]
+        project.add_developer(user)
       end
 
       it 'shows Create merge request button' do
@@ -29,7 +27,7 @@ feature 'Merge Request button', feature: true do
 
         visit url
 
-        within("#content-body") do
+        within('#content-body') do
           expect(page).to have_link(label, href: href)
         end
       end
@@ -42,7 +40,7 @@ feature 'Merge Request button', feature: true do
         it 'does not show Create merge request button' do
           visit url
 
-          within("#content-body") do
+          within('#content-body') do
             expect(page).not_to have_link(label)
           end
         end
@@ -57,7 +55,7 @@ feature 'Merge Request button', feature: true do
       it 'does not show Create merge request button' do
         visit url
 
-        within("#content-body") do
+        within('#content-body') do
           expect(page).not_to have_link(label)
         end
       end
diff --git a/spec/features/projects/no_password_spec.rb b/spec/features/projects/no_password_spec.rb
index 53ac18fa7cc..d22a6daac08 100644
--- a/spec/features/projects/no_password_spec.rb
+++ b/spec/features/projects/no_password_spec.rb
@@ -30,7 +30,7 @@ feature 'No Password Alert' do
     let(:user) { create(:omniauth_user, extern_uid: 'my-uid', provider: 'saml') }
 
     before do
-      stub_application_setting(signin_enabled?: false)
+      stub_application_setting(password_authentication_enabled?: false)
       stub_omniauth_saml_config(enabled: true, auto_link_saml_user: true, allow_single_sign_on: ['saml'], providers: [mock_saml_config])
     end
 
diff --git a/spec/features/projects/pipeline_schedules_spec.rb b/spec/features/projects/pipeline_schedules_spec.rb
index 992a68b25a5..033ccf06124 100644
--- a/spec/features/projects/pipeline_schedules_spec.rb
+++ b/spec/features/projects/pipeline_schedules_spec.rb
@@ -9,188 +9,222 @@ feature 'Pipeline Schedules', :feature, js: true do
   let(:scope) { nil }
   let!(:user) { create(:user) }
 
-  before do
-    project.add_master(user)
-    sign_in(user)
-  end
-
-  describe 'GET /projects/pipeline_schedules' do
+  context 'logged in as master' do
     before do
-      visit_pipelines_schedules
+      project.add_master(user)
+      gitlab_sign_in(user)
     end
 
-    describe 'The view' do
-      it 'displays the required information description' do
-        page.within('.pipeline-schedule-table-row') do
-          expect(page).to have_content('pipeline schedule')
-          expect(find(".next-run-cell time")['data-original-title'])
-            .to include(pipeline_schedule.real_next_run.strftime('%b %-d, %Y'))
-          expect(page).to have_link('master')
-          expect(page).to have_link("##{pipeline.id}")
-        end
+    describe 'GET /projects/pipeline_schedules' do
+      before do
+        visit_pipelines_schedules
       end
 
-      it 'creates a new scheduled pipeline' do
-        click_link 'New schedule'
+      describe 'The view' do
+        it 'displays the required information description' do
+          page.within('.pipeline-schedule-table-row') do
+            expect(page).to have_content('pipeline schedule')
+            expect(find(".next-run-cell time")['data-original-title'])
+              .to include(pipeline_schedule.real_next_run.strftime('%b %-d, %Y'))
+            expect(page).to have_link('master')
+            expect(page).to have_link("##{pipeline.id}")
+          end
+        end
 
-        expect(page).to have_content('Schedule a new pipeline')
-      end
+        it 'creates a new scheduled pipeline' do
+          click_link 'New schedule'
 
-      it 'changes ownership of the pipeline' do
-        click_link 'Take ownership'
-        page.within('.pipeline-schedule-table-row') do
-          expect(page).not_to have_content('No owner')
-          expect(page).to have_link('John Doe')
+          expect(page).to have_content('Schedule a new pipeline')
         end
-      end
 
-      it 'edits the pipeline' do
-        page.within('.pipeline-schedule-table-row') do
-          click_link 'Edit'
+        it 'changes ownership of the pipeline' do
+          click_link 'Take ownership'
+          page.within('.pipeline-schedule-table-row') do
+            expect(page).not_to have_content('No owner')
+            expect(page).to have_link('John Doe')
+          end
         end
 
-        expect(page).to have_content('Edit Pipeline Schedule')
+        it 'edits the pipeline' do
+          page.within('.pipeline-schedule-table-row') do
+            click_link 'Edit'
+          end
+
+          expect(page).to have_content('Edit Pipeline Schedule')
+        end
+
+        it 'deletes the pipeline' do
+          click_link 'Delete'
+
+          expect(page).not_to have_css(".pipeline-schedule-table-row")
+        end
       end
 
-      it 'deletes the pipeline' do
-        click_link 'Delete'
+      context 'when ref is nil' do
+        before do
+          pipeline_schedule.update_attribute(:ref, nil)
+          visit_pipelines_schedules
+        end
 
-        expect(page).not_to have_css(".pipeline-schedule-table-row")
+        it 'shows a list of the pipeline schedules with empty ref column' do
+          expect(first('.branch-name-cell').text).to eq('')
+        end
       end
     end
 
-    context 'when ref is nil' do
+    describe 'POST /projects/pipeline_schedules/new' do
       before do
-        pipeline_schedule.update_attribute(:ref, nil)
-        visit_pipelines_schedules
+        visit_new_pipeline_schedule
       end
 
-      it 'shows a list of the pipeline schedules with empty ref column' do
-        expect(first('.branch-name-cell').text).to eq('')
+      it 'sets defaults for timezone and target branch' do
+        expect(page).to have_button('master')
+        expect(page).to have_button('UTC')
       end
-    end
-  end
 
-  describe 'POST /projects/pipeline_schedules/new' do
-    before do
-      visit_new_pipeline_schedule
-    end
+      it 'it creates a new scheduled pipeline' do
+        fill_in_schedule_form
+        save_pipeline_schedule
 
-    it 'sets defaults for timezone and target branch' do
-      expect(page).to have_button('master')
-      expect(page).to have_button('UTC')
-    end
+        expect(page).to have_content('my fancy description')
+      end
 
-    it 'it creates a new scheduled pipeline' do
-      fill_in_schedule_form
-      save_pipeline_schedule
+      it 'it prevents an invalid form from being submitted' do
+        save_pipeline_schedule
 
-      expect(page).to have_content('my fancy description')
+        expect(page).to have_content('This field is required')
+      end
     end
 
-    it 'it prevents an invalid form from being submitted' do
-      save_pipeline_schedule
+    describe 'PATCH /projects/pipelines_schedules/:id/edit' do
+      before do
+        edit_pipeline_schedule
+      end
 
-      expect(page).to have_content('This field is required')
-    end
-  end
+      it 'it displays existing properties' do
+        description = find_field('schedule_description').value
+        expect(description).to eq('pipeline schedule')
+        expect(page).to have_button('master')
+        expect(page).to have_button('UTC')
+      end
 
-  describe 'PATCH /projects/pipelines_schedules/:id/edit' do
-    before do
-      edit_pipeline_schedule
-    end
+      it 'edits the scheduled pipeline' do
+        fill_in 'schedule_description', with: 'my brand new description'
 
-    it 'it displays existing properties' do
-      description = find_field('schedule_description').value
-      expect(description).to eq('pipeline schedule')
-      expect(page).to have_button('master')
-      expect(page).to have_button('UTC')
-    end
+        save_pipeline_schedule
 
-    it 'edits the scheduled pipeline' do
-      fill_in 'schedule_description', with: 'my brand new description'
+        expect(page).to have_content('my brand new description')
+      end
 
-      save_pipeline_schedule
+      context 'when ref is nil' do
+        before do
+          pipeline_schedule.update_attribute(:ref, nil)
+          edit_pipeline_schedule
+        end
 
-      expect(page).to have_content('my brand new description')
+        it 'shows the pipeline schedule with default ref' do
+          page.within('.js-target-branch-dropdown') do
+            expect(first('.dropdown-toggle-text').text).to eq('master')
+          end
+        end
+      end
     end
 
-    context 'when ref is nil' do
-      before do
-        pipeline_schedule.update_attribute(:ref, nil)
-        edit_pipeline_schedule
+    context 'when user creates a new pipeline schedule with variables' do
+      background do
+        visit_pipelines_schedules
+        click_link 'New schedule'
+        fill_in_schedule_form
+        all('[name="schedule[variables_attributes][][key]"]')[0].set('AAA')
+        all('[name="schedule[variables_attributes][][value]"]')[0].set('AAA123')
+        all('[name="schedule[variables_attributes][][key]"]')[1].set('BBB')
+        all('[name="schedule[variables_attributes][][value]"]')[1].set('BBB123')
+        save_pipeline_schedule
       end
 
-      it 'shows the pipeline schedule with default ref' do
-        page.within('.js-target-branch-dropdown') do
-          expect(first('.dropdown-toggle-text').text).to eq('master')
+      scenario 'user sees the new variable in edit window' do
+        find(".content-list .pipeline-schedule-table-row:nth-child(1) .btn-group a[title='Edit']").click
+        page.within('.pipeline-variable-list') do
+          expect(find(".pipeline-variable-row:nth-child(1) .pipeline-variable-key-input").value).to eq('AAA')
+          expect(find(".pipeline-variable-row:nth-child(1) .pipeline-variable-value-input").value).to eq('AAA123')
+          expect(find(".pipeline-variable-row:nth-child(2) .pipeline-variable-key-input").value).to eq('BBB')
+          expect(find(".pipeline-variable-row:nth-child(2) .pipeline-variable-value-input").value).to eq('BBB123')
         end
       end
     end
-  end
 
-  context 'when user creates a new pipeline schedule with variables' do
-    background do
-      visit_pipelines_schedules
-      click_link 'New schedule'
-      fill_in_schedule_form
-      all('[name="schedule[variables_attributes][][key]"]')[0].set('AAA')
-      all('[name="schedule[variables_attributes][][value]"]')[0].set('AAA123')
-      all('[name="schedule[variables_attributes][][key]"]')[1].set('BBB')
-      all('[name="schedule[variables_attributes][][value]"]')[1].set('BBB123')
-      save_pipeline_schedule
-    end
+    context 'when user edits a variable of a pipeline schedule' do
+      background do
+        create(:ci_pipeline_schedule, project: project, owner: user).tap do |pipeline_schedule|
+          create(:ci_pipeline_schedule_variable, key: 'AAA', value: 'AAA123', pipeline_schedule: pipeline_schedule)
+        end
 
-    scenario 'user sees the new variable in edit window' do
-      find(".content-list .pipeline-schedule-table-row:nth-child(1) .btn-group a[title='Edit']").click
-      page.within('.pipeline-variable-list') do
-        expect(find(".pipeline-variable-row:nth-child(1) .pipeline-variable-key-input").value).to eq('AAA')
-        expect(find(".pipeline-variable-row:nth-child(1) .pipeline-variable-value-input").value).to eq('AAA123')
-        expect(find(".pipeline-variable-row:nth-child(2) .pipeline-variable-key-input").value).to eq('BBB')
-        expect(find(".pipeline-variable-row:nth-child(2) .pipeline-variable-value-input").value).to eq('BBB123')
+        visit_pipelines_schedules
+        find(".content-list .pipeline-schedule-table-row:nth-child(1) .btn-group a[title='Edit']").click
+        all('[name="schedule[variables_attributes][][key]"]')[0].set('foo')
+        all('[name="schedule[variables_attributes][][value]"]')[0].set('bar')
+        click_button 'Save pipeline schedule'
       end
-    end
-  end
 
-  context 'when user edits a variable of a pipeline schedule' do
-    background do
-      create(:ci_pipeline_schedule, project: project, owner: user).tap do |pipeline_schedule|
-        create(:ci_pipeline_schedule_variable, key: 'AAA', value: 'AAA123', pipeline_schedule: pipeline_schedule)
+      scenario 'user sees the updated variable in edit window' do
+        find(".content-list .pipeline-schedule-table-row:nth-child(1) .btn-group a[title='Edit']").click
+        page.within('.pipeline-variable-list') do
+          expect(find(".pipeline-variable-row:nth-child(1) .pipeline-variable-key-input").value).to eq('foo')
+          expect(find(".pipeline-variable-row:nth-child(1) .pipeline-variable-value-input").value).to eq('bar')
+        end
       end
-
-      visit_pipelines_schedules
-      find(".content-list .pipeline-schedule-table-row:nth-child(1) .btn-group a[title='Edit']").click
-      all('[name="schedule[variables_attributes][][key]"]')[0].set('foo')
-      all('[name="schedule[variables_attributes][][value]"]')[0].set('bar')
-      click_button 'Save pipeline schedule'
     end
 
-    scenario 'user sees the updated variable in edit window' do
-      find(".content-list .pipeline-schedule-table-row:nth-child(1) .btn-group a[title='Edit']").click
-      page.within('.pipeline-variable-list') do
-        expect(find(".pipeline-variable-row:nth-child(1) .pipeline-variable-key-input").value).to eq('foo')
-        expect(find(".pipeline-variable-row:nth-child(1) .pipeline-variable-value-input").value).to eq('bar')
+    context 'when user removes a variable of a pipeline schedule' do
+      background do
+        create(:ci_pipeline_schedule, project: project, owner: user).tap do |pipeline_schedule|
+          create(:ci_pipeline_schedule_variable, key: 'AAA', value: 'AAA123', pipeline_schedule: pipeline_schedule)
+        end
+
+        visit_pipelines_schedules
+        find(".content-list .pipeline-schedule-table-row:nth-child(1) .btn-group a[title='Edit']").click
+        find('.pipeline-variable-list .pipeline-variable-row-remove-button').click
+        click_button 'Save pipeline schedule'
+      end
+
+      scenario 'user does not see the removed variable in edit window' do
+        find(".content-list .pipeline-schedule-table-row:nth-child(1) .btn-group a[title='Edit']").click
+        page.within('.pipeline-variable-list') do
+          expect(find(".pipeline-variable-row:nth-child(1) .pipeline-variable-key-input").value).to eq('')
+          expect(find(".pipeline-variable-row:nth-child(1) .pipeline-variable-value-input").value).to eq('')
+        end
       end
     end
   end
 
-  context 'when user removes a variable of a pipeline schedule' do
-    background do
-      create(:ci_pipeline_schedule, project: project, owner: user).tap do |pipeline_schedule|
-        create(:ci_pipeline_schedule_variable, key: 'AAA', value: 'AAA123', pipeline_schedule: pipeline_schedule)
+  context 'logged in as non-member' do
+    before do
+      gitlab_sign_in(user)
+    end
+
+    describe 'GET /projects/pipeline_schedules' do
+      before do
+        visit_pipelines_schedules
       end
 
-      visit_pipelines_schedules
-      find(".content-list .pipeline-schedule-table-row:nth-child(1) .btn-group a[title='Edit']").click
-      find('.pipeline-variable-list .pipeline-variable-row-remove-button').click
-      click_button 'Save pipeline schedule'
+      describe 'The view' do
+        it 'does not show create schedule button' do
+          expect(page).not_to have_link('New schedule')
+        end
+      end
     end
+  end
+
+  context 'not logged in' do
+    describe 'GET /projects/pipeline_schedules' do
+      before do
+        visit_pipelines_schedules
+      end
 
-    scenario 'user does not see the removed variable in edit window' do
-      find(".content-list .pipeline-schedule-table-row:nth-child(1) .btn-group a[title='Edit']").click
-      page.within('.pipeline-variable-list') do
-        expect(find(".pipeline-variable-row:nth-child(1) .pipeline-variable-key-input").value).to eq('')
-        expect(find(".pipeline-variable-row:nth-child(1) .pipeline-variable-value-input").value).to eq('')
+      describe 'The view' do
+        it 'does not show create schedule button' do
+          expect(page).not_to have_link('New schedule')
+        end
       end
     end
   end
diff --git a/spec/features/projects/user_browses_files_spec.rb b/spec/features/projects/user_browses_files_spec.rb
new file mode 100644
index 00000000000..263a3a29a66
--- /dev/null
+++ b/spec/features/projects/user_browses_files_spec.rb
@@ -0,0 +1,188 @@
+require 'spec_helper'
+
+describe 'User browses files' do
+  include DropzoneHelper
+
+  let(:fork_message) do
+    "You're not allowed to make changes to this project directly. "\
+    "A fork of this project has been created that you can make changes in, so you can submit a merge request."
+  end
+  let(:project) { create(:project, name: 'Shop') }
+  let(:project2) { create(:project, :repository, name: 'Another Project', path: 'another-project') }
+  let(:project2_tree_path_root_ref) { project_tree_path(project2, project2.repository.root_ref) }
+  let(:tree_path_ref_6d39438) { project_tree_path(project, '6d39438') }
+  let(:tree_path_root_ref) { project_tree_path(project, project.repository.root_ref) }
+  let(:user) { create(:user) }
+
+  before do
+    project.team << [user, :master]
+    sign_in(user)
+  end
+
+  context 'when browsing the master branch' do
+    before do
+      visit(tree_path_root_ref)
+    end
+
+    it 'shows files from a repository' do
+      expect(page).to have_content('VERSION')
+      expect(page).to have_content('.gitignore')
+      expect(page).to have_content('LICENSE')
+    end
+
+    it 'shows the "Browse Directory" link' do
+      click_link('files')
+      click_link('History')
+
+      expect(page).to have_link('Browse Directory')
+      expect(page).not_to have_link('Browse Code')
+    end
+
+    it 'shows the "Browse File" link' do
+      page.within('.tree-table') do
+        click_link('README.md')
+      end
+      click_link('History')
+
+      expect(page).to have_link('Browse File')
+      expect(page).not_to have_link('Browse Files')
+    end
+
+    it 'shows the "Browse Code" link' do
+      click_link('History')
+
+      expect(page).to have_link('Browse Files')
+      expect(page).not_to have_link('Browse Directory')
+    end
+
+    it 'redirects to the permalink URL' do
+      click_link('.gitignore')
+      click_link('Permalink')
+
+      permalink_path = project_blob_path(project, "#{project.repository.commit.sha}/.gitignore")
+
+      expect(current_path).to eq(permalink_path)
+    end
+  end
+
+  context 'when browsing a specific ref' do
+    before do
+      visit(tree_path_ref_6d39438)
+    end
+
+    it 'shows files from a repository for "6d39438"' do
+      expect(current_path).to eq(tree_path_ref_6d39438)
+      expect(page).to have_content('.gitignore')
+      expect(page).to have_content('LICENSE')
+    end
+
+    it 'shows files from a repository with apostroph in its name', js: true do
+      first('.js-project-refs-dropdown').click
+
+      page.within('.project-refs-form') do
+        click_link("'test'")
+      end
+
+      expect(page).to have_selector('.dropdown-toggle-text', text: "'test'")
+
+      visit(project_tree_path(project, "'test'"))
+
+      expect(page).to have_css('.tree-commit-link', visible: true)
+      expect(page).not_to have_content('Loading commit data...')
+    end
+
+    it 'shows the code with a leading dot in the directory', js: true do
+      first('.js-project-refs-dropdown').click
+
+      page.within('.project-refs-form') do
+        click_link('fix')
+      end
+
+      visit(project_tree_path(project, 'fix/.testdir'))
+
+      expect(page).to have_css('.tree-commit-link', visible: true)
+      expect(page).not_to have_content('Loading commit data...')
+    end
+
+    it 'does not show the permalink link' do
+      click_link('.gitignore')
+
+      expect(page).not_to have_link('permalink')
+    end
+  end
+
+  context 'when browsing a file content' do
+    before do
+      visit(tree_path_root_ref)
+      click_link('.gitignore')
+    end
+
+    it 'shows a file content', js: true do
+      wait_for_requests
+      expect(page).to have_content('*.rbc')
+    end
+  end
+
+  context 'when browsing a raw file' do
+    before do
+      visit(project_blob_path(project, File.join(RepoHelpers.sample_commit.id, RepoHelpers.sample_blob.path)))
+    end
+
+    it 'shows a raw file content' do
+      click_link('Open raw')
+      expect(source).to eq('') # Body is filled in by gitlab-workhorse
+    end
+  end
+
+  context 'when browsing an LFS object' do
+    before do
+      allow_any_instance_of(Project).to receive(:lfs_enabled?).and_return(true)
+      visit(project_tree_path(project, 'lfs'))
+    end
+
+    it 'shows an LFS object' do
+      click_link('files')
+      click_link('lfs')
+      click_link('lfs_object.iso')
+
+      expect(page).to have_content('Download (1.5 MB)')
+      expect(page).not_to have_content('version https://git-lfs.github.com/spec/v1')
+      expect(page).not_to have_content('oid sha256:91eff75a492a3ed0dfcb544d7f31326bc4014c8551849c192fd1e48d4dd2c897')
+      expect(page).not_to have_content('size 1575078')
+
+      page.within('.content') do
+        expect(page).to have_content('Delete')
+        expect(page).to have_content('History')
+        expect(page).to have_content('Permalink')
+        expect(page).to have_content('Replace')
+        expect(page).not_to have_content('Annotate')
+        expect(page).not_to have_content('Blame')
+        expect(page).not_to have_content('Edit')
+        expect(page).to have_link('Download')
+      end
+    end
+  end
+
+  context 'when previewing a file content' do
+    before do
+      visit(tree_path_root_ref)
+    end
+
+    it 'shows a preview of a file content', js: true do
+      find('.add-to-tree').click
+      click_link('Upload file')
+      drop_in_dropzone(File.join(Rails.root, 'spec', 'fixtures', 'logo_sample.svg'))
+
+      page.within('#modal-upload-blob') do
+        fill_in(:commit_message, with: 'New commit message')
+      end
+
+      fill_in(:branch_name, with: 'new_branch_name', visible: true)
+      click_button('Upload file')
+
+      visit(project_blob_path(project, 'new_branch_name/logo_sample.svg'))
+
+      expect(page).to have_css('.file-content img')
+    end
+  end
+end
diff --git a/spec/features/projects/user_create_dir_spec.rb b/spec/features/projects/user_create_dir_spec.rb
deleted file mode 100644
index 5e302da8a63..00000000000
--- a/spec/features/projects/user_create_dir_spec.rb
+++ /dev/null
@@ -1,57 +0,0 @@
-require 'spec_helper'
-
-feature 'New directory creation', feature: true, js: true do
-  given(:user) { create(:user) }
-  given(:role) { :developer }
-  given(:project) { create(:project) }
-
-  background do
-    sign_in(user)
-    project.team << [user, role]
-    visit project_tree_path(project, 'master')
-    open_new_directory_modal
-    fill_in 'dir_name', with: 'new_directory'
-  end
-
-  def open_new_directory_modal
-    first('.add-to-tree').click
-    click_link 'New directory'
-  end
-
-  def create_directory
-    click_button 'Create directory'
-  end
-
-  context 'with default target branch' do
-    background do
-      create_directory
-    end
-
-    scenario 'creates the directory in the default branch' do
-      expect(page).to have_content 'master'
-      expect(page).to have_content 'The directory has been successfully created'
-      expect(page).to have_content 'new_directory'
-    end
-  end
-
-  context 'with a new target branch' do
-    given(:new_branch_name) { 'new-feature' }
-
-    background do
-      fill_in :branch_name, with: new_branch_name
-      create_directory
-    end
-
-    scenario 'creates the directory in the new branch' do
-      expect(page).to have_content new_branch_name
-      expect(page).to have_content 'The directory has been successfully created'
-    end
-
-    scenario 'redirects to the merge request' do
-      expect(page).to have_content 'New Merge Request'
-      expect(page).to have_content "From #{new_branch_name} into master"
-      expect(page).to have_content 'Add new directory'
-      expect(current_path).to eq(project_new_merge_request_path(project))
-    end
-  end
-end
diff --git a/spec/features/projects/user_creates_directory_spec.rb b/spec/features/projects/user_creates_directory_spec.rb
new file mode 100644
index 00000000000..635bd4493dd
--- /dev/null
+++ b/spec/features/projects/user_creates_directory_spec.rb
@@ -0,0 +1,87 @@
+require 'spec_helper'
+
+feature 'User creates a directory', js: true do
+  let(:fork_message) do
+    "You're not allowed to make changes to this project directly. "\
+    "A fork of this project has been created that you can make changes in, so you can submit a merge request."
+  end
+  let(:project) { create(:project) }
+  let(:project2) { create(:project, :repository, name: 'Another Project', path: 'another-project') }
+  let(:project2_tree_path_root_ref) { project_tree_path(project2, project2.repository.root_ref) }
+  let(:user) { create(:user) }
+
+  before do
+    project.team << [user, :developer]
+    sign_in(user)
+    visit project_tree_path(project, 'master')
+  end
+
+  context 'with default target branch' do
+    before do
+      first('.add-to-tree').click
+      click_link('New directory')
+    end
+
+    it 'creates the directory in the default branch' do
+      fill_in(:dir_name, with: 'new_directory')
+      click_button('Create directory')
+
+      expect(page).to have_content('master')
+      expect(page).to have_content('The directory has been successfully created')
+      expect(page).to have_content('new_directory')
+    end
+
+    it 'does not create a directory with a name of already existed directory' do
+      fill_in(:dir_name, with: 'files')
+      fill_in(:commit_message, with: 'New commit message', visible: true)
+      click_button('Create directory')
+
+      expect(page).to have_content('A directory with this name already exists')
+      expect(current_path).to eq(project_tree_path(project, 'master'))
+    end
+  end
+
+  context 'with a new target branch' do
+    before do
+      first('.add-to-tree').click
+      click_link('New directory')
+      fill_in(:dir_name, with: 'new_directory')
+      fill_in(:branch_name, with: 'new-feature')
+      click_button('Create directory')
+    end
+
+    it 'creates the directory in the new branch and redirect to the merge request' do
+      expect(page).to have_content('new-feature')
+      expect(page).to have_content('The directory has been successfully created')
+      expect(page).to have_content('New Merge Request')
+      expect(page).to have_content('From new-feature into master')
+      expect(page).to have_content('Add new directory')
+
+      expect(current_path).to eq(project_new_merge_request_path(project))
+    end
+  end
+
+  context 'when an user does not have write access' do
+    before do
+      project2.team << [user, :reporter]
+      visit(project2_tree_path_root_ref)
+    end
+
+    it 'creates a directory in a forked project' do
+      find('.add-to-tree').click
+      click_link('New directory')
+
+      expect(page).to have_content(fork_message)
+
+      find('.add-to-tree').click
+      click_link('New directory')
+      fill_in(:dir_name, with: 'new_directory')
+      fill_in(:commit_message, with: 'New commit message', visible: true)
+      click_button('Create directory')
+
+      fork = user.fork_of(project2)
+
+      expect(current_path).to eq(project_new_merge_request_path(fork))
+    end
+  end
+end
diff --git a/spec/features/projects/user_creates_files_spec.rb b/spec/features/projects/user_creates_files_spec.rb
new file mode 100644
index 00000000000..0c7f1a775c1
--- /dev/null
+++ b/spec/features/projects/user_creates_files_spec.rb
@@ -0,0 +1,153 @@
+require 'spec_helper'
+
+describe 'User creates files' do
+  let(:fork_message) do
+    "You're not allowed to make changes to this project directly. "\
+    "A fork of this project has been created that you can make changes in, so you can submit a merge request."
+  end
+  let(:project) { create(:project, name: 'Shop') }
+  let(:project2) { create(:project, :repository, name: 'Another Project', path: 'another-project') }
+  let(:project_tree_path_root_ref) { project_tree_path(project, project.repository.root_ref) }
+  let(:project2_tree_path_root_ref) { project_tree_path(project2, project2.repository.root_ref) }
+  let(:user) { create(:user) }
+
+  before do
+    project.team << [user, :master]
+    sign_in(user)
+  end
+
+  context 'without commiting a new file' do
+    context 'when an user has write access' do
+      before do
+        visit(project_tree_path_root_ref)
+      end
+
+      it 'opens new file page' do
+        find('.add-to-tree').click
+        click_link('New file')
+
+        expect(page).to have_content('New file')
+        expect(page).to have_content('Commit message')
+      end
+    end
+
+    context 'when an user does not have write access' do
+      before do
+        project2.team << [user, :reporter]
+        visit(project2_tree_path_root_ref)
+      end
+
+      it 'opens new file page on a forked project' do
+        find('.add-to-tree').click
+        click_link('New file')
+
+        expect(page).to have_selector('.file-editor')
+        expect(page).to have_content(fork_message)
+        expect(page).to have_content('New file')
+        expect(page).to have_content('Commit message')
+      end
+    end
+  end
+
+  context 'with commiting a new file' do
+    context 'when an user has write access' do
+      before do
+        visit(project_tree_path_root_ref)
+
+        find('.add-to-tree').click
+        click_link('New file')
+      end
+
+      it 'creates and commit a new file', js: true do
+        expect(page).to have_selector('.file-editor')
+
+        execute_script("ace.edit('editor').setValue('*.rbca')")
+        fill_in(:file_name, with: 'not_a_file.md')
+        fill_in(:commit_message, with: 'New commit message', visible: true)
+        click_button('Commit changes')
+
+        new_file_path = project_blob_path(project, 'master/not_a_file.md')
+
+        expect(current_path).to eq(new_file_path)
+
+        wait_for_requests
+
+        expect(page).to have_content('*.rbca')
+      end
+
+      it 'creates and commit a new file with new lines at the end of file', js: true do
+        execute_script('ace.edit("editor").setValue("Sample\n\n\n")')
+        fill_in(:file_name, with: 'not_a_file.md')
+        fill_in(:commit_message, with: 'New commit message', visible: true)
+        click_button('Commit changes')
+
+        new_file_path = project_blob_path(project, 'master/not_a_file.md')
+
+        expect(current_path).to eq(new_file_path)
+
+        find('.js-edit-blob').click
+
+        expect(evaluate_script('ace.edit("editor").getValue()')).to eq("Sample\n\n\n")
+      end
+
+      it 'creates and commit a new file with a directory name', js: true do
+        fill_in(:file_name, with: 'foo/bar/baz.txt')
+
+        expect(page).to have_selector('.file-editor')
+
+        execute_script("ace.edit('editor').setValue('*.rbca')")
+        fill_in(:commit_message, with: 'New commit message', visible: true)
+        click_button('Commit changes')
+
+        expect(current_path).to eq(project_blob_path(project, 'master/foo/bar/baz.txt'))
+
+        wait_for_requests
+
+        expect(page).to have_content('*.rbca')
+      end
+
+      it 'creates and commit a new file specifying a new branch', js: true do
+        expect(page).to have_selector('.file-editor')
+
+        execute_script("ace.edit('editor').setValue('*.rbca')")
+        fill_in(:file_name, with: 'not_a_file.md')
+        fill_in(:commit_message, with: 'New commit message', visible: true)
+        fill_in(:branch_name, with: 'new_branch_name', visible: true)
+        click_button('Commit changes')
+
+        expect(current_path).to eq(project_new_merge_request_path(project))
+
+        click_link('Changes')
+
+        wait_for_requests
+
+        expect(page).to have_content('*.rbca')
+      end
+    end
+
+    context 'when an user does not have write access' do
+      before do
+        project2.team << [user, :reporter]
+        visit(project2_tree_path_root_ref)
+      end
+
+      it 'creates and commit new file in forked project', js: true do
+        find('.add-to-tree').click
+        click_link('New file')
+
+        expect(page).to have_selector('.file-editor')
+
+        execute_script("ace.edit('editor').setValue('*.rbca')")
+
+        fill_in(:file_name, with: 'not_a_file.md')
+        fill_in(:commit_message, with: 'New commit message', visible: true)
+        click_button('Commit changes')
+
+        fork = user.fork_of(project2)
+
+        expect(current_path).to eq(project_new_merge_request_path(fork))
+        expect(page).to have_content('New commit message')
+      end
+    end
+  end
+end
diff --git a/spec/features/projects/user_deletes_files_spec.rb b/spec/features/projects/user_deletes_files_spec.rb
new file mode 100644
index 00000000000..97e60862b4f
--- /dev/null
+++ b/spec/features/projects/user_deletes_files_spec.rb
@@ -0,0 +1,68 @@
+require 'spec_helper'
+
+describe 'User deletes files' do
+  let(:fork_message) do
+    "You're not allowed to make changes to this project directly. "\
+    "A fork of this project has been created that you can make changes in, so you can submit a merge request."
+  end
+  let(:project) { create(:project, name: 'Shop') }
+  let(:project2) { create(:project, :repository, name: 'Another Project', path: 'another-project') }
+  let(:project_tree_path_root_ref) { project_tree_path(project, project.repository.root_ref) }
+  let(:project2_tree_path_root_ref) { project_tree_path(project2, project2.repository.root_ref) }
+  let(:user) { create(:user) }
+
+  before do
+    sign_in(user)
+  end
+
+  context 'when an user has write access' do
+    before do
+      project.team << [user, :master]
+      visit(project_tree_path_root_ref)
+    end
+
+    it 'deletes the file', js: true do
+      click_link('.gitignore')
+
+      expect(page).to have_content('.gitignore')
+
+      click_on('Delete')
+      fill_in(:commit_message, with: 'New commit message', visible: true)
+      click_button('Delete file')
+
+      expect(current_path).to eq(project_tree_path(project, 'master'))
+      expect(page).not_to have_content('.gitignore')
+    end
+  end
+
+  context 'when an user does not have write access' do
+    before do
+      project2.team << [user, :reporter]
+      visit(project2_tree_path_root_ref)
+    end
+
+    it 'deletes the file in a forked project', js: true do
+      click_link('.gitignore')
+
+      expect(page).to have_content('.gitignore')
+
+      click_on('Delete')
+
+      expect(page).to have_link('Fork')
+      expect(page).to have_button('Cancel')
+
+      click_link('Fork')
+
+      expect(page).to have_content(fork_message)
+
+      click_on('Delete')
+      fill_in(:commit_message, with: 'New commit message', visible: true)
+      click_button('Delete file')
+
+      fork = user.fork_of(project2)
+
+      expect(current_path).to eq(project_new_merge_request_path(fork))
+      expect(page).to have_content('New commit message')
+    end
+  end
+end
diff --git a/spec/features/projects/user_edits_files_spec.rb b/spec/features/projects/user_edits_files_spec.rb
new file mode 100644
index 00000000000..eb26f1bc123
--- /dev/null
+++ b/spec/features/projects/user_edits_files_spec.rb
@@ -0,0 +1,122 @@
+require 'spec_helper'
+
+describe 'User edits files' do
+  let(:fork_message) do
+    "You're not allowed to make changes to this project directly. "\
+    "A fork of this project has been created that you can make changes in, so you can submit a merge request."
+  end
+  let(:project) { create(:project, name: 'Shop') }
+  let(:project2) { create(:project, :repository, name: 'Another Project', path: 'another-project') }
+  let(:project_tree_path_root_ref) { project_tree_path(project, project.repository.root_ref) }
+  let(:project2_tree_path_root_ref) { project_tree_path(project2, project2.repository.root_ref) }
+  let(:user) { create(:user) }
+
+  before do
+    sign_in(user)
+  end
+
+  context 'when an user has write access' do
+    before do
+      project.team << [user, :master]
+      visit(project_tree_path_root_ref)
+    end
+
+    it 'inserts a content of a file', js: true do
+      click_link('.gitignore')
+      find('.js-edit-blob').click
+      execute_script("ace.edit('editor').setValue('*.rbca')")
+
+      expect(evaluate_script('ace.edit("editor").getValue()')).to eq('*.rbca')
+    end
+
+    it 'does not show the edit link if a file is binary' do
+      binary_file = File.join(project.repository.root_ref, 'files/images/logo-black.png')
+      visit(project_blob_path(project, binary_file))
+
+      expect(page).not_to have_link('edit')
+    end
+
+    it 'commits an edited file', js: true do
+      click_link('.gitignore')
+      find('.js-edit-blob').click
+      execute_script("ace.edit('editor').setValue('*.rbca')")
+      fill_in(:commit_message, with: 'New commit message', visible: true)
+      click_button('Commit changes')
+
+      expect(current_path).to eq(project_blob_path(project, 'master/.gitignore'))
+
+      wait_for_requests
+
+      expect(page).to have_content('*.rbca')
+    end
+
+    it 'commits an edited file to a new branch', js: true do
+      click_link('.gitignore')
+      find('.js-edit-blob').click
+      execute_script("ace.edit('editor').setValue('*.rbca')")
+      fill_in(:commit_message, with: 'New commit message', visible: true)
+      fill_in(:branch_name, with: 'new_branch_name', visible: true)
+      click_button('Commit changes')
+
+      expect(current_path).to eq(project_new_merge_request_path(project))
+
+      click_link('Changes')
+
+      wait_for_requests
+      expect(page).to have_content('*.rbca')
+    end
+
+    it 'shows the diff of an edited file', js: true do
+      click_link('.gitignore')
+      find('.js-edit-blob').click
+      execute_script("ace.edit('editor').setValue('*.rbca')")
+      click_link('Preview changes')
+
+      expect(page).to have_css('.line_holder.new')
+    end
+  end
+
+  context 'when an user does not have write access' do
+    before do
+      project2.team << [user, :reporter]
+      visit(project2_tree_path_root_ref)
+    end
+
+    it 'inserts a content of a file in a forked project', js: true do
+      click_link('.gitignore')
+      find('.js-edit-blob').click
+
+      expect(page).to have_link('Fork')
+      expect(page).to have_button('Cancel')
+
+      click_link('Fork')
+
+      expect(page).to have_content(fork_message)
+
+      execute_script("ace.edit('editor').setValue('*.rbca')")
+
+      expect(evaluate_script('ace.edit("editor").getValue()')).to eq('*.rbca')
+    end
+
+    it 'commits an edited file in a forked project', js: true do
+      click_link('.gitignore')
+      find('.js-edit-blob').click
+
+      expect(page).to have_link('Fork')
+      expect(page).to have_button('Cancel')
+
+      click_link('Fork')
+      execute_script("ace.edit('editor').setValue('*.rbca')")
+      fill_in(:commit_message, with: 'New commit message', visible: true)
+      click_button('Commit changes')
+
+      fork = user.fork_of(project2)
+
+      expect(current_path).to eq(project_new_merge_request_path(fork))
+
+      wait_for_requests
+
+      expect(page).to have_content('New commit message')
+    end
+  end
+end
diff --git a/spec/features/projects/user_replaces_files_spec.rb b/spec/features/projects/user_replaces_files_spec.rb
new file mode 100644
index 00000000000..50f2ffc4bbf
--- /dev/null
+++ b/spec/features/projects/user_replaces_files_spec.rb
@@ -0,0 +1,87 @@
+require 'spec_helper'
+
+describe 'User replaces files' do
+  include DropzoneHelper
+
+  let(:fork_message) do
+    "You're not allowed to make changes to this project directly. "\
+    "A fork of this project has been created that you can make changes in, so you can submit a merge request."
+  end
+  let(:project) { create(:project, name: 'Shop') }
+  let(:project2) { create(:project, :repository, name: 'Another Project', path: 'another-project') }
+  let(:project_tree_path_root_ref) { project_tree_path(project, project.repository.root_ref) }
+  let(:project2_tree_path_root_ref) { project_tree_path(project2, project2.repository.root_ref) }
+  let(:user) { create(:user) }
+
+  before do
+    sign_in(user)
+  end
+
+  context 'when an user has write access' do
+    before do
+      project.team << [user, :master]
+      visit(project_tree_path_root_ref)
+    end
+
+    it 'replaces an existed file with a new one', js: true do
+      click_link('.gitignore')
+
+      expect(page).to have_content('.gitignore')
+
+      click_on('Replace')
+      drop_in_dropzone(File.join(Rails.root, 'spec', 'fixtures', 'doc_sample.txt'))
+
+      page.within('#modal-upload-blob') do
+        fill_in(:commit_message, with: 'Replacement file commit message')
+      end
+
+      click_button('Replace file')
+
+      expect(page).to have_content('Lorem ipsum dolor sit amet')
+      expect(page).to have_content('Sed ut perspiciatis unde omnis')
+      expect(page).to have_content('Replacement file commit message')
+    end
+  end
+
+  context 'when an user does not have write access' do
+    before do
+      project2.team << [user, :reporter]
+      visit(project2_tree_path_root_ref)
+    end
+
+    it 'replaces an existed file with a new one in a forked project', js: true do
+      click_link('.gitignore')
+
+      expect(page).to have_content('.gitignore')
+
+      click_on('Replace')
+
+      expect(page).to have_link('Fork')
+      expect(page).to have_button('Cancel')
+
+      click_link('Fork')
+
+      expect(page).to have_content(fork_message)
+
+      click_on('Replace')
+      drop_in_dropzone(File.join(Rails.root, 'spec', 'fixtures', 'doc_sample.txt'))
+
+      page.within('#modal-upload-blob') do
+        fill_in(:commit_message, with: 'Replacement file commit message')
+      end
+
+      click_button('Replace file')
+
+      expect(page).to have_content('Replacement file commit message')
+
+      fork = user.fork_of(project2)
+
+      expect(current_path).to eq(project_new_merge_request_path(fork))
+
+      click_link('Changes')
+
+      expect(page).to have_content('Lorem ipsum dolor sit amet')
+      expect(page).to have_content('Sed ut perspiciatis unde omnis')
+    end
+  end
+end
diff --git a/spec/features/projects/user_uploads_files_spec.rb b/spec/features/projects/user_uploads_files_spec.rb
new file mode 100644
index 00000000000..64a1439badd
--- /dev/null
+++ b/spec/features/projects/user_uploads_files_spec.rb
@@ -0,0 +1,82 @@
+require 'spec_helper'
+
+describe 'User uploads files' do
+  include DropzoneHelper
+
+  let(:fork_message) do
+    "You're not allowed to make changes to this project directly. "\
+    "A fork of this project has been created that you can make changes in, so you can submit a merge request."
+  end
+  let(:project) { create(:project, name: 'Shop') }
+  let(:project2) { create(:project, :repository, name: 'Another Project', path: 'another-project') }
+  let(:project_tree_path_root_ref) { project_tree_path(project, project.repository.root_ref) }
+  let(:project2_tree_path_root_ref) { project_tree_path(project2, project2.repository.root_ref) }
+  let(:user) { create(:user) }
+
+  before do
+    project.team << [user, :master]
+    sign_in(user)
+  end
+
+  context 'when an user has write access' do
+    before do
+      visit(project_tree_path_root_ref)
+    end
+
+    it 'uploads and commit a new file', js: true do
+      find('.add-to-tree').click
+      click_link('Upload file')
+      drop_in_dropzone(File.join(Rails.root, 'spec', 'fixtures', 'doc_sample.txt'))
+
+      page.within('#modal-upload-blob') do
+        fill_in(:commit_message, with: 'New commit message')
+      end
+
+      fill_in(:branch_name, with: 'new_branch_name', visible: true)
+      click_button('Upload file')
+
+      expect(page).to have_content('New commit message')
+      expect(current_path).to eq(project_new_merge_request_path(project))
+
+      click_link('Changes')
+
+      expect(page).to have_content('Lorem ipsum dolor sit amet')
+      expect(page).to have_content('Sed ut perspiciatis unde omnis')
+    end
+  end
+
+  context 'when an user does not have write access' do
+    before do
+      project2.team << [user, :reporter]
+      visit(project2_tree_path_root_ref)
+    end
+
+    it 'uploads and commit a new fileto a forked project', js: true do
+      find('.add-to-tree').click
+      click_link('Upload file')
+
+      expect(page).to have_content(fork_message)
+
+      find('.add-to-tree').click
+      click_link('Upload file')
+      drop_in_dropzone(File.join(Rails.root, 'spec', 'fixtures', 'doc_sample.txt'))
+
+      page.within('#modal-upload-blob') do
+        fill_in(:commit_message, with: 'New commit message')
+      end
+
+      click_button('Upload file')
+
+      expect(page).to have_content('New commit message')
+
+      fork = user.fork_of(project2)
+
+      expect(current_path).to eq(project_new_merge_request_path(fork))
+
+      click_link('Changes')
+
+      expect(page).to have_content('Lorem ipsum dolor sit amet')
+      expect(page).to have_content('Sed ut perspiciatis unde omnis')
+    end
+  end
+end
diff --git a/spec/features/snippets/user_creates_snippet_spec.rb b/spec/features/snippets/user_creates_snippet_spec.rb
index 57dec14b480..698d3b5d3e3 100644
--- a/spec/features/snippets/user_creates_snippet_spec.rb
+++ b/spec/features/snippets/user_creates_snippet_spec.rb
@@ -41,7 +41,7 @@ feature 'User creates snippet', :js, feature: true do
       expect(page).to have_content('My Snippet')
 
       link = find('a.no-attachment-icon img[alt="banana_sample"]')['src']
-      expect(link).to match(%r{/uploads/temp/\h{32}/banana_sample\.gif\z})
+      expect(link).to match(%r{/uploads/system/temp/\h{32}/banana_sample\.gif\z})
 
       visit(link)
       expect(page.status_code).to eq(200)
@@ -59,7 +59,7 @@ feature 'User creates snippet', :js, feature: true do
     wait_for_requests
 
     link = find('a.no-attachment-icon img[alt="banana_sample"]')['src']
-    expect(link).to match(%r{/uploads/personal_snippet/#{Snippet.last.id}/\h{32}/banana_sample\.gif\z})
+    expect(link).to match(%r{/uploads/system/personal_snippet/#{Snippet.last.id}/\h{32}/banana_sample\.gif\z})
 
     visit(link)
     expect(page.status_code).to eq(200)
@@ -84,7 +84,7 @@ feature 'User creates snippet', :js, feature: true do
     end
     expect(page).to have_content('Hello World!')
     link = find('a.no-attachment-icon img[alt="banana_sample"]')['src']
-    expect(link).to match(%r{/uploads/personal_snippet/#{Snippet.last.id}/\h{32}/banana_sample\.gif\z})
+    expect(link).to match(%r{/uploads/system/personal_snippet/#{Snippet.last.id}/\h{32}/banana_sample\.gif\z})
 
     visit(link)
     expect(page.status_code).to eq(200)
diff --git a/spec/features/snippets/user_edits_snippet_spec.rb b/spec/features/snippets/user_edits_snippet_spec.rb
index cff64423873..c9f9741b4bb 100644
--- a/spec/features/snippets/user_edits_snippet_spec.rb
+++ b/spec/features/snippets/user_edits_snippet_spec.rb
@@ -33,7 +33,7 @@ feature 'User edits snippet', :js, feature: true do
     wait_for_requests
 
     link = find('a.no-attachment-icon img[alt="banana_sample"]')['src']
-    expect(link).to match(%r{/uploads/personal_snippet/#{snippet.id}/\h{32}/banana_sample\.gif\z})
+    expect(link).to match(%r{/uploads/system/personal_snippet/#{snippet.id}/\h{32}/banana_sample\.gif\z})
   end
 
   it 'updates the snippet to make it internal' do
diff --git a/spec/features/uploads/user_uploads_avatar_to_group_spec.rb b/spec/features/uploads/user_uploads_avatar_to_group_spec.rb
index 32784de1613..5843f18d89f 100644
--- a/spec/features/uploads/user_uploads_avatar_to_group_spec.rb
+++ b/spec/features/uploads/user_uploads_avatar_to_group_spec.rb
@@ -18,7 +18,7 @@ feature 'User uploads avatar to group', feature: true do
 
     visit group_path(group)
 
-    expect(page).to have_selector(%Q(img[src$="/uploads/system/group/avatar/#{group.id}/dk.png"]))
+    expect(page).to have_selector(%Q(img[src$="/uploads/-/system/group/avatar/#{group.id}/dk.png"]))
 
     # Cheating here to verify something that isn't user-facing, but is important
     expect(group.reload.avatar.file).to exist
diff --git a/spec/features/uploads/user_uploads_avatar_to_profile_spec.rb b/spec/features/uploads/user_uploads_avatar_to_profile_spec.rb
index 82c356735b9..e8171dcaeb0 100644
--- a/spec/features/uploads/user_uploads_avatar_to_profile_spec.rb
+++ b/spec/features/uploads/user_uploads_avatar_to_profile_spec.rb
@@ -16,7 +16,7 @@ feature 'User uploads avatar to profile', feature: true do
 
     visit user_path(user)
 
-    expect(page).to have_selector(%Q(img[src$="/uploads/system/user/avatar/#{user.id}/dk.png"]))
+    expect(page).to have_selector(%Q(img[src$="/uploads/-/system/user/avatar/#{user.id}/dk.png"]))
 
     # Cheating here to verify something that isn't user-facing, but is important
     expect(user.reload.avatar.file).to exist
diff --git a/spec/fixtures/api/schemas/entities/merge_request.json b/spec/fixtures/api/schemas/entities/merge_request.json
index b6a59a6cc47..7ffa82fc4bd 100644
--- a/spec/fixtures/api/schemas/entities/merge_request.json
+++ b/spec/fixtures/api/schemas/entities/merge_request.json
@@ -75,6 +75,7 @@
       "additionalProperties": false
     },
     "target_branch_commits_path": { "type": "string" },
+    "target_branch_tree_path": { "type": "string" },
     "source_branch_path": { "type": "string" },
     "conflict_resolution_path": { "type": ["string", "null"] },
     "cancel_merge_when_pipeline_succeeds_path": { "type": "string" },
diff --git a/spec/fixtures/api/schemas/public_api/v4/user/admin.json b/spec/fixtures/api/schemas/public_api/v4/user/admin.json
new file mode 100644
index 00000000000..f733914fbf8
--- /dev/null
+++ b/spec/fixtures/api/schemas/public_api/v4/user/admin.json
@@ -0,0 +1,34 @@
+{
+  "type": "object",
+  "required": [
+    "id",
+    "username",
+    "email",
+    "name",
+    "state",
+    "avatar_url",
+    "web_url",
+    "created_at",
+    "is_admin",
+    "bio",
+    "location",
+    "skype",
+    "linkedin",
+    "twitter",
+    "website_url",
+    "organization",
+    "last_sign_in_at",
+    "confirmed_at",
+    "color_scheme_id",
+    "projects_limit",
+    "current_sign_in_at",
+    "identities",
+    "can_create_group",
+    "can_create_project",
+    "two_factor_enabled",
+    "external"
+  ],
+  "properties": {
+    "$ref": "full.json"
+  }
+}
diff --git a/spec/fixtures/config/redis_cache_config_with_env.yml b/spec/fixtures/config/redis_cache_config_with_env.yml
new file mode 100644
index 00000000000..52fd5a06460
--- /dev/null
+++ b/spec/fixtures/config/redis_cache_config_with_env.yml
@@ -0,0 +1,2 @@
+test:
+  url: <%= ENV['TEST_GITLAB_REDIS_CACHE_URL'] %>
diff --git a/spec/fixtures/config/redis_cache_new_format_host.yml b/spec/fixtures/config/redis_cache_new_format_host.yml
new file mode 100644
index 00000000000..a24f3716391
--- /dev/null
+++ b/spec/fixtures/config/redis_cache_new_format_host.yml
@@ -0,0 +1,29 @@
+# redis://[:password@]host[:port][/db-number][?option=value]
+# more details: http://www.iana.org/assignments/uri-schemes/prov/redis
+development:
+  url: redis://:mynewpassword@localhost:6380/10
+  sentinels:
+    -
+      host: localhost
+      port: 26380 # point to sentinel, not to redis port
+    -
+      host: slave2
+      port: 26380 # point to sentinel, not to redis port
+test:
+  url: redis://:mynewpassword@localhost:6380/10
+  sentinels:
+    -
+      host: localhost
+      port: 26380 # point to sentinel, not to redis port
+    -
+      host: slave2
+      port: 26380 # point to sentinel, not to redis port
+production:
+  url: redis://:mynewpassword@localhost:6380/10
+  sentinels:
+    -
+      host: slave1
+      port: 26380 # point to sentinel, not to redis port
+    -
+      host: slave2
+      port: 26380 # point to sentinel, not to redis port
diff --git a/spec/fixtures/config/redis_cache_new_format_socket.yml b/spec/fixtures/config/redis_cache_new_format_socket.yml
new file mode 100644
index 00000000000..3634c550163
--- /dev/null
+++ b/spec/fixtures/config/redis_cache_new_format_socket.yml
@@ -0,0 +1,6 @@
+development:
+  url: unix:/path/to/redis.cache.sock
+test:
+  url: unix:/path/to/redis.cache.sock
+production:
+  url: unix:/path/to/redis.cache.sock
diff --git a/spec/fixtures/config/redis_cache_old_format_host.yml b/spec/fixtures/config/redis_cache_old_format_host.yml
new file mode 100644
index 00000000000..3609dcd022e
--- /dev/null
+++ b/spec/fixtures/config/redis_cache_old_format_host.yml
@@ -0,0 +1,5 @@
+# redis://[:password@]host[:port][/db-number][?option=value]
+# more details: http://www.iana.org/assignments/uri-schemes/prov/redis
+development: redis://:mypassword@localhost:6380/10
+test: redis://:mypassword@localhost:6380/10
+production: redis://:mypassword@localhost:6380/10
diff --git a/spec/fixtures/config/redis_cache_old_format_socket.yml b/spec/fixtures/config/redis_cache_old_format_socket.yml
new file mode 100644
index 00000000000..26fa0eda245
--- /dev/null
+++ b/spec/fixtures/config/redis_cache_old_format_socket.yml
@@ -0,0 +1,3 @@
+development: unix:/path/to/old/redis.cache.sock
+test: unix:/path/to/old/redis.cache.sock
+production: unix:/path/to/old/redis.cache.sock
diff --git a/spec/fixtures/config/redis_new_format_host.yml b/spec/fixtures/config/redis_new_format_host.yml
index 13772677a45..8d134d467e9 100644
--- a/spec/fixtures/config/redis_new_format_host.yml
+++ b/spec/fixtures/config/redis_new_format_host.yml
@@ -5,25 +5,25 @@ development:
   sentinels:
     -
       host: localhost
-      port: 26380 # point to sentinel, not to redis port
+      port: 26379 # point to sentinel, not to redis port
     -
       host: slave2
-      port: 26381 # point to sentinel, not to redis port
+      port: 26379 # point to sentinel, not to redis port
 test:
   url: redis://:mynewpassword@localhost:6379/99
   sentinels:
     -
       host: localhost
-      port: 26380 # point to sentinel, not to redis port
+      port: 26379 # point to sentinel, not to redis port
     -
       host: slave2
-      port: 26381 # point to sentinel, not to redis port
+      port: 26379 # point to sentinel, not to redis port
 production:
   url: redis://:mynewpassword@localhost:6379/99
   sentinels:
     -
       host: slave1
-      port: 26380 # point to sentinel, not to redis port
+      port: 26379 # point to sentinel, not to redis port
     -
       host: slave2
-      port: 26381 # point to sentinel, not to redis port
+      port: 26379 # point to sentinel, not to redis port
diff --git a/spec/fixtures/config/redis_queues_config_with_env.yml b/spec/fixtures/config/redis_queues_config_with_env.yml
new file mode 100644
index 00000000000..d16a9d8a7f8
--- /dev/null
+++ b/spec/fixtures/config/redis_queues_config_with_env.yml
@@ -0,0 +1,2 @@
+test:
+  url: <%= ENV['TEST_GITLAB_REDIS_QUEUES_URL'] %>
diff --git a/spec/fixtures/config/redis_queues_new_format_host.yml b/spec/fixtures/config/redis_queues_new_format_host.yml
new file mode 100644
index 00000000000..1535584d779
--- /dev/null
+++ b/spec/fixtures/config/redis_queues_new_format_host.yml
@@ -0,0 +1,29 @@
+# redis://[:password@]host[:port][/db-number][?option=value]
+# more details: http://www.iana.org/assignments/uri-schemes/prov/redis
+development:
+  url: redis://:mynewpassword@localhost:6381/11
+  sentinels:
+    -
+      host: localhost
+      port: 26381 # point to sentinel, not to redis port
+    -
+      host: slave2
+      port: 26381 # point to sentinel, not to redis port
+test:
+  url: redis://:mynewpassword@localhost:6381/11
+  sentinels:
+    -
+      host: localhost
+      port: 26381 # point to sentinel, not to redis port
+    -
+      host: slave2
+      port: 26381 # point to sentinel, not to redis port
+production:
+  url: redis://:mynewpassword@localhost:6381/11
+  sentinels:
+    -
+      host: slave1
+      port: 26381 # point to sentinel, not to redis port
+    -
+      host: slave2
+      port: 26381 # point to sentinel, not to redis port
diff --git a/spec/fixtures/config/redis_queues_new_format_socket.yml b/spec/fixtures/config/redis_queues_new_format_socket.yml
new file mode 100644
index 00000000000..b488d84d022
--- /dev/null
+++ b/spec/fixtures/config/redis_queues_new_format_socket.yml
@@ -0,0 +1,6 @@
+development:
+  url: unix:/path/to/redis.queues.sock
+test:
+  url: unix:/path/to/redis.queues.sock
+production:
+  url: unix:/path/to/redis.queues.sock
diff --git a/spec/fixtures/config/redis_queues_old_format_host.yml b/spec/fixtures/config/redis_queues_old_format_host.yml
new file mode 100644
index 00000000000..6531748a8d7
--- /dev/null
+++ b/spec/fixtures/config/redis_queues_old_format_host.yml
@@ -0,0 +1,5 @@
+# redis://[:password@]host[:port][/db-number][?option=value]
+# more details: http://www.iana.org/assignments/uri-schemes/prov/redis
+development: redis://:mypassword@localhost:6381/11
+test: redis://:mypassword@localhost:6381/11
+production: redis://:mypassword@localhost:6381/11
diff --git a/spec/fixtures/config/redis_queues_old_format_socket.yml b/spec/fixtures/config/redis_queues_old_format_socket.yml
new file mode 100644
index 00000000000..53f5db72758
--- /dev/null
+++ b/spec/fixtures/config/redis_queues_old_format_socket.yml
@@ -0,0 +1,3 @@
+development: unix:/path/to/old/redis.queues.sock
+test: unix:/path/to/old/redis.queues.sock
+production: unix:/path/to/old/redis.queues.sock
diff --git a/spec/fixtures/config/redis_shared_state_config_with_env.yml b/spec/fixtures/config/redis_shared_state_config_with_env.yml
new file mode 100644
index 00000000000..eab7203d0de
--- /dev/null
+++ b/spec/fixtures/config/redis_shared_state_config_with_env.yml
@@ -0,0 +1,2 @@
+test:
+  url: <%= ENV['TEST_GITLAB_REDIS_SHARED_STATE_URL'] %>
diff --git a/spec/fixtures/config/redis_shared_state_new_format_host.yml b/spec/fixtures/config/redis_shared_state_new_format_host.yml
new file mode 100644
index 00000000000..1180b2b4a82
--- /dev/null
+++ b/spec/fixtures/config/redis_shared_state_new_format_host.yml
@@ -0,0 +1,29 @@
+# redis://[:password@]host[:port][/db-number][?option=value]
+# more details: http://www.iana.org/assignments/uri-schemes/prov/redis
+development:
+  url: redis://:mynewpassword@localhost:6382/12
+  sentinels:
+    -
+      host: localhost
+      port: 26382 # point to sentinel, not to redis port
+    -
+      host: slave2
+      port: 26382 # point to sentinel, not to redis port
+test:
+  url: redis://:mynewpassword@localhost:6382/12
+  sentinels:
+    -
+      host: localhost
+      port: 26382 # point to sentinel, not to redis port
+    -
+      host: slave2
+      port: 26382 # point to sentinel, not to redis port
+production:
+  url: redis://:mynewpassword@localhost:6382/12
+  sentinels:
+    -
+      host: slave1
+      port: 26382 # point to sentinel, not to redis port
+    -
+      host: slave2
+      port: 26382 # point to sentinel, not to redis port
diff --git a/spec/fixtures/config/redis_shared_state_new_format_socket.yml b/spec/fixtures/config/redis_shared_state_new_format_socket.yml
new file mode 100644
index 00000000000..1b0e699729e
--- /dev/null
+++ b/spec/fixtures/config/redis_shared_state_new_format_socket.yml
@@ -0,0 +1,6 @@
+development:
+  url: unix:/path/to/redis.shared_state.sock
+test:
+  url: unix:/path/to/redis.shared_state.sock
+production:
+  url: unix:/path/to/redis.shared_state.sock
diff --git a/spec/fixtures/config/redis_shared_state_old_format_host.yml b/spec/fixtures/config/redis_shared_state_old_format_host.yml
new file mode 100644
index 00000000000..fef5e768c5d
--- /dev/null
+++ b/spec/fixtures/config/redis_shared_state_old_format_host.yml
@@ -0,0 +1,5 @@
+# redis://[:password@]host[:port][/db-number][?option=value]
+# more details: http://www.iana.org/assignments/uri-schemes/prov/redis
+development: redis://:mypassword@localhost:6382/12
+test: redis://:mypassword@localhost:6382/12
+production: redis://:mypassword@localhost:6382/12
diff --git a/spec/fixtures/config/redis_shared_state_old_format_socket.yml b/spec/fixtures/config/redis_shared_state_old_format_socket.yml
new file mode 100644
index 00000000000..4746afbb5ef
--- /dev/null
+++ b/spec/fixtures/config/redis_shared_state_old_format_socket.yml
@@ -0,0 +1,3 @@
+development: unix:/path/to/old/redis.shared_state.sock
+test: unix:/path/to/old/redis.shared_state.sock
+production: unix:/path/to/old/redis.shared_state.sock
diff --git a/spec/helpers/application_helper_spec.rb b/spec/helpers/application_helper_spec.rb
index e0cad1da86a..f5e139685e8 100644
--- a/spec/helpers/application_helper_spec.rb
+++ b/spec/helpers/application_helper_spec.rb
@@ -59,13 +59,13 @@ describe ApplicationHelper do
   describe 'project_icon' do
     it 'returns an url for the avatar' do
       project = create(:empty_project, avatar: File.open(uploaded_image_temp_path))
-      avatar_url = "/uploads/system/project/avatar/#{project.id}/banana_sample.gif"
+      avatar_url = "/uploads/-/system/project/avatar/#{project.id}/banana_sample.gif"
 
       expect(helper.project_icon(project.full_path).to_s)
         .to eq "<img src=\"#{avatar_url}\" alt=\"Banana sample\" />"
 
       allow(ActionController::Base).to receive(:asset_host).and_return(gitlab_host)
-      avatar_url = "#{gitlab_host}/uploads/system/project/avatar/#{project.id}/banana_sample.gif"
+      avatar_url = "#{gitlab_host}/uploads/-/system/project/avatar/#{project.id}/banana_sample.gif"
 
       expect(helper.project_icon(project.full_path).to_s)
         .to eq "<img src=\"#{avatar_url}\" alt=\"Banana sample\" />"
@@ -88,7 +88,7 @@ describe ApplicationHelper do
       context 'when there is a matching user' do
         it 'returns a relative URL for the avatar' do
           expect(helper.avatar_icon(user.email).to_s)
-            .to eq("/uploads/system/user/avatar/#{user.id}/banana_sample.gif")
+            .to eq("/uploads/-/system/user/avatar/#{user.id}/banana_sample.gif")
         end
 
         context 'when an asset_host is set in the config' do
@@ -100,14 +100,14 @@ describe ApplicationHelper do
 
           it 'returns an absolute URL on that asset host' do
             expect(helper.avatar_icon(user.email, only_path: false).to_s)
-              .to eq("#{asset_host}/uploads/system/user/avatar/#{user.id}/banana_sample.gif")
+              .to eq("#{asset_host}/uploads/-/system/user/avatar/#{user.id}/banana_sample.gif")
           end
         end
 
         context 'when only_path is set to false' do
           it 'returns an absolute URL for the avatar' do
             expect(helper.avatar_icon(user.email, only_path: false).to_s)
-              .to eq("#{gitlab_host}/uploads/system/user/avatar/#{user.id}/banana_sample.gif")
+              .to eq("#{gitlab_host}/uploads/-/system/user/avatar/#{user.id}/banana_sample.gif")
           end
         end
 
@@ -120,7 +120,7 @@ describe ApplicationHelper do
 
           it 'returns a relative URL with the correct prefix' do
             expect(helper.avatar_icon(user.email).to_s)
-              .to eq("/gitlab/uploads/system/user/avatar/#{user.id}/banana_sample.gif")
+              .to eq("/gitlab/uploads/-/system/user/avatar/#{user.id}/banana_sample.gif")
           end
         end
       end
@@ -138,14 +138,14 @@ describe ApplicationHelper do
       context 'when only_path is true' do
         it 'returns a relative URL for the avatar' do
           expect(helper.avatar_icon(user, only_path: true).to_s)
-            .to eq("/uploads/system/user/avatar/#{user.id}/banana_sample.gif")
+            .to eq("/uploads/-/system/user/avatar/#{user.id}/banana_sample.gif")
         end
       end
 
       context 'when only_path is false' do
         it 'returns an absolute URL for the avatar' do
           expect(helper.avatar_icon(user, only_path: false).to_s)
-            .to eq("#{gitlab_host}/uploads/system/user/avatar/#{user.id}/banana_sample.gif")
+            .to eq("#{gitlab_host}/uploads/-/system/user/avatar/#{user.id}/banana_sample.gif")
         end
       end
     end
diff --git a/spec/helpers/auth_helper_spec.rb b/spec/helpers/auth_helper_spec.rb
index a0e1265efff..c94fedd615b 100644
--- a/spec/helpers/auth_helper_spec.rb
+++ b/spec/helpers/auth_helper_spec.rb
@@ -70,7 +70,7 @@ describe AuthHelper do
       end
     end
 
-    [:twitter, :facebook, :google_oauth2, :gitlab, :github, :bitbucket, :crowd, :auth0].each do |provider|
+    [:twitter, :facebook, :google_oauth2, :gitlab, :github, :bitbucket, :crowd, :auth0, :authentiq].each do |provider|
       it "returns false if the provider is #{provider}" do
         expect(helper.unlink_allowed?(provider)).to be true
       end
diff --git a/spec/helpers/award_emoji_helper_spec.rb b/spec/helpers/award_emoji_helper_spec.rb
index 7dfd6a3f6b4..035960ed96e 100644
--- a/spec/helpers/award_emoji_helper_spec.rb
+++ b/spec/helpers/award_emoji_helper_spec.rb
@@ -40,7 +40,7 @@ describe AwardEmojiHelper do
       it 'returns correct url' do
         @project = merge_request.project
 
-        expected_url = "/#{@project.namespace.path}/#{@project.path}/merge_requests/#{merge_request.id}/toggle_award_emoji"
+        expected_url = "/#{@project.namespace.path}/#{@project.path}/merge_requests/#{merge_request.iid}/toggle_award_emoji"
 
         expect(helper.toggle_award_url(merge_request)).to eq(expected_url)
       end
@@ -52,7 +52,7 @@ describe AwardEmojiHelper do
       it 'returns correct url' do
         @project = issue.project
 
-        expected_url = "/#{@project.namespace.path}/#{@project.path}/issues/#{issue.id}/toggle_award_emoji"
+        expected_url = "/#{@project.namespace.path}/#{@project.path}/issues/#{issue.iid}/toggle_award_emoji"
 
         expect(helper.toggle_award_url(issue)).to eq(expected_url)
       end
diff --git a/spec/helpers/button_helper_spec.rb b/spec/helpers/button_helper_spec.rb
index 661327d4432..7ecb75da8ce 100644
--- a/spec/helpers/button_helper_spec.rb
+++ b/spec/helpers/button_helper_spec.rb
@@ -35,7 +35,7 @@ describe ButtonHelper do
 
     context 'with internal auth disabled' do
       before do
-        stub_application_setting(signin_enabled?: false)
+        stub_application_setting(password_authentication_enabled?: false)
       end
 
       context 'when user has no personal access tokens' do
diff --git a/spec/helpers/emails_helper_spec.rb b/spec/helpers/emails_helper_spec.rb
index c68e4f56b05..2390c1f3e5d 100644
--- a/spec/helpers/emails_helper_spec.rb
+++ b/spec/helpers/emails_helper_spec.rb
@@ -52,7 +52,7 @@ describe EmailsHelper do
         )
 
         expect(header_logo).to eq(
-          %{<img style="height: 50px" src="/uploads/system/appearance/header_logo/#{appearance.id}/dk.png" alt="Dk" />}
+          %{<img style="height: 50px" src="/uploads/-/system/appearance/header_logo/#{appearance.id}/dk.png" alt="Dk" />}
         )
       end
     end
diff --git a/spec/helpers/groups_helper_spec.rb b/spec/helpers/groups_helper_spec.rb
index e3f9d9db9eb..3a246f10283 100644
--- a/spec/helpers/groups_helper_spec.rb
+++ b/spec/helpers/groups_helper_spec.rb
@@ -11,7 +11,7 @@ describe GroupsHelper do
       group.avatar = fixture_file_upload(avatar_file_path)
       group.save!
       expect(group_icon(group.path).to_s)
-        .to match("/uploads/system/group/avatar/#{group.id}/banana_sample.gif")
+        .to match("/uploads/-/system/group/avatar/#{group.id}/banana_sample.gif")
     end
 
     it 'gives default avatar_icon when no avatar is present' do
diff --git a/spec/helpers/issuables_helper_spec.rb b/spec/helpers/issuables_helper_spec.rb
index d2e918ef014..7789cfa3554 100644
--- a/spec/helpers/issuables_helper_spec.rb
+++ b/spec/helpers/issuables_helper_spec.rb
@@ -60,7 +60,7 @@ describe IssuablesHelper do
       end
     end
 
-    describe 'counter caching based on issuable type and params', :caching do
+    describe 'counter caching based on issuable type and params', :use_clean_rails_memory_store_caching do
       let(:params) do
         {
           scope: 'created-by-me',
@@ -244,5 +244,25 @@ describe IssuablesHelper do
 
     it { expect(helper.updated_at_by(unedited_issuable)).to eq({}) }
     it { expect(helper.updated_at_by(edited_issuable)).to eq(edited_updated_at_by) }
+
+    context 'when updated by a deleted user' do
+      let(:edited_updated_at_by) do
+        {
+          updatedAt: edited_issuable.updated_at.to_time.iso8601,
+          updatedBy: {
+            name: User.ghost.name,
+            path: user_path(User.ghost)
+          }
+        }
+      end
+
+      before do
+        user.destroy
+      end
+
+      it 'returns "Ghost user" as edited_by' do
+        expect(helper.updated_at_by(edited_issuable.reload)).to eq(edited_updated_at_by)
+      end
+    end
   end
 end
diff --git a/spec/helpers/page_layout_helper_spec.rb b/spec/helpers/page_layout_helper_spec.rb
index 95b4032616e..9aca3987657 100644
--- a/spec/helpers/page_layout_helper_spec.rb
+++ b/spec/helpers/page_layout_helper_spec.rb
@@ -60,7 +60,7 @@ describe PageLayoutHelper do
     %w(project user group).each do |type|
       context "with @#{type} assigned" do
         it "uses #{type.titlecase} avatar if available" do
-          object = double(avatar_url: 'http://example.com/uploads/system/avatar.png')
+          object = double(avatar_url: 'http://example.com/uploads/-/system/avatar.png')
           assign(type, object)
 
           expect(helper.page_image).to eq object.avatar_url
diff --git a/spec/helpers/projects_helper_spec.rb b/spec/helpers/projects_helper_spec.rb
index 487d9800707..45066a60f50 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", redis: true do
+  describe "#project_list_cache_key", clean_gitlab_redis_shared_state: true do
     let(:project) { create(:project) }
 
     it "includes the route" do
@@ -160,7 +160,7 @@ describe ProjectsHelper do
 
     context 'user requires a personal access token' do
       it 'returns true' do
-        stub_application_setting(signin_enabled?: false)
+        stub_application_setting(password_authentication_enabled?: false)
 
         expect(helper.show_no_password_message?).to be_truthy
       end
@@ -184,7 +184,7 @@ describe ProjectsHelper do
       let(:user) { create(:user) }
 
       it 'returns link to create a personal access token' do
-        stub_application_setting(signin_enabled?: false)
+        stub_application_setting(password_authentication_enabled?: false)
 
         expect(helper.link_to_set_password).to match %r{<a href="#{profile_personal_access_tokens_path}">create a personal access token</a>}
       end
diff --git a/spec/javascripts/commit/pipelines/pipelines_spec.js b/spec/javascripts/commit/pipelines/pipelines_spec.js
index 694f94efcff..a34cadec0ab 100644
--- a/spec/javascripts/commit/pipelines/pipelines_spec.js
+++ b/spec/javascripts/commit/pipelines/pipelines_spec.js
@@ -85,6 +85,41 @@ describe('Pipelines table in Commits and Merge requests', () => {
         }, 0);
       });
     });
+
+    describe('pipeline badge counts', () => {
+      const pipelinesResponse = (request, next) => {
+        next(request.respondWith(JSON.stringify([pipeline]), {
+          status: 200,
+        }));
+      };
+
+      beforeEach(() => {
+        Vue.http.interceptors.push(pipelinesResponse);
+      });
+
+      afterEach(() => {
+        Vue.http.interceptors = _.without(Vue.http.interceptors, pipelinesResponse);
+        this.component.$destroy();
+      });
+
+      it('should receive update-pipelines-count event', (done) => {
+        const element = document.createElement('div');
+        document.body.appendChild(element);
+
+        element.addEventListener('update-pipelines-count', (event) => {
+          expect(event.detail.pipelines).toEqual([pipeline]);
+          done();
+        });
+
+        this.component = new PipelinesTable({
+          propsData: {
+            endpoint: 'endpoint',
+            helpPagePath: 'foo',
+          },
+        }).$mount();
+        element.appendChild(this.component.$el);
+      });
+    });
   });
 
   describe('unsuccessfull request', () => {
diff --git a/spec/javascripts/environments/environment_spec.js b/spec/javascripts/environments/environment_spec.js
index 6639a6b5e7b..0c8817a8148 100644
--- a/spec/javascripts/environments/environment_spec.js
+++ b/spec/javascripts/environments/environment_spec.js
@@ -2,6 +2,7 @@ import Vue from 'vue';
 import '~/flash';
 import environmentsComponent from '~/environments/components/environment.vue';
 import { environment, folder } from './mock_data';
+import { headersInterceptor } from '../helpers/vue_resource_helper';
 
 describe('Environment', () => {
   preloadFixtures('static/environments/environments.html.raw');
@@ -25,12 +26,14 @@ describe('Environment', () => {
 
       beforeEach(() => {
         Vue.http.interceptors.push(environmentsEmptyResponseInterceptor);
+        Vue.http.interceptors.push(headersInterceptor);
       });
 
       afterEach(() => {
         Vue.http.interceptors = _.without(
           Vue.http.interceptors, environmentsEmptyResponseInterceptor,
         );
+        Vue.http.interceptors = _.without(Vue.http.interceptors, headersInterceptor);
       });
 
       it('should render the empty state', (done) => {
@@ -54,6 +57,10 @@ describe('Environment', () => {
 
     describe('with paginated environments', () => {
       const environmentsResponseInterceptor = (request, next) => {
+        next((response) => {
+          response.headers.set('X-nExt-pAge', '2');
+        });
+
         next(request.respondWith(JSON.stringify({
           environments: [environment],
           stopped_count: 1,
@@ -73,6 +80,7 @@ describe('Environment', () => {
 
       beforeEach(() => {
         Vue.http.interceptors.push(environmentsResponseInterceptor);
+        Vue.http.interceptors.push(headersInterceptor);
         component = new EnvironmentsComponent({
           el: document.querySelector('#environments-list-view'),
         });
@@ -82,6 +90,7 @@ describe('Environment', () => {
         Vue.http.interceptors = _.without(
           Vue.http.interceptors, environmentsResponseInterceptor,
         );
+        Vue.http.interceptors = _.without(Vue.http.interceptors, headersInterceptor);
       });
 
       it('should render a table with environments', (done) => {
diff --git a/spec/javascripts/environments/folder/environments_folder_view_spec.js b/spec/javascripts/environments/folder/environments_folder_view_spec.js
index 350078ad5f5..fdaea5c0b0c 100644
--- a/spec/javascripts/environments/folder/environments_folder_view_spec.js
+++ b/spec/javascripts/environments/folder/environments_folder_view_spec.js
@@ -2,6 +2,7 @@ import Vue from 'vue';
 import '~/flash';
 import environmentsFolderViewComponent from '~/environments/folder/environments_folder_view.vue';
 import { environmentsList } from '../mock_data';
+import { headersInterceptor } from '../../helpers/vue_resource_helper';
 
 describe('Environments Folder View', () => {
   preloadFixtures('static/environments/environments_folder_view.html.raw');
@@ -36,6 +37,8 @@ describe('Environments Folder View', () => {
 
     beforeEach(() => {
       Vue.http.interceptors.push(environmentsResponseInterceptor);
+      Vue.http.interceptors.push(headersInterceptor);
+
       component = new EnvironmentsFolderViewComponent({
         el: document.querySelector('#environments-folder-list-view'),
       });
@@ -45,6 +48,7 @@ describe('Environments Folder View', () => {
       Vue.http.interceptors = _.without(
         Vue.http.interceptors, environmentsResponseInterceptor,
       );
+      Vue.http.interceptors = _.without(Vue.http.interceptors, headersInterceptor);
     });
 
     it('should render a table with environments', (done) => {
diff --git a/spec/javascripts/helpers/vue_resource_helper.js b/spec/javascripts/helpers/vue_resource_helper.js
new file mode 100644
index 00000000000..0d1bf5e2e80
--- /dev/null
+++ b/spec/javascripts/helpers/vue_resource_helper.js
@@ -0,0 +1,11 @@
+// eslint-disable-next-line import/prefer-default-export
+export const headersInterceptor = (request, next) => {
+  next((response) => {
+    const headers = {};
+    response.headers.forEach((value, key) => {
+      headers[key] = value;
+    });
+    // eslint-disable-next-line no-param-reassign
+    response.headers = headers;
+  });
+};
diff --git a/spec/javascripts/issue_show/components/app_spec.js b/spec/javascripts/issue_show/components/app_spec.js
index bc13373a27e..81ce18bf2fb 100644
--- a/spec/javascripts/issue_show/components/app_spec.js
+++ b/spec/javascripts/issue_show/components/app_spec.js
@@ -3,7 +3,6 @@ import '~/render_math';
 import '~/render_gfm';
 import issuableApp from '~/issue_show/components/app.vue';
 import eventHub from '~/issue_show/event_hub';
-import Poll from '~/lib/utils/poll';
 import issueShowData from '../mock_data';
 
 function formatText(text) {
@@ -11,16 +10,26 @@ function formatText(text) {
 }
 
 describe('Issuable output', () => {
+  let requestData = issueShowData.initialRequest;
+
   document.body.innerHTML = '<span id="task_status"></span>';
 
+  const interceptor = (request, next) => {
+    next(request.respondWith(JSON.stringify(requestData), {
+      status: 200,
+    }));
+  };
+
   let vm;
 
-  beforeEach(() => {
+  beforeEach((done) => {
     spyOn(eventHub, '$emit');
-    spyOn(Poll.prototype, 'makeRequest');
 
     const IssuableDescriptionComponent = Vue.extend(issuableApp);
 
+    requestData = issueShowData.initialRequest;
+    Vue.http.interceptors.push(interceptor);
+
     vm = new IssuableDescriptionComponent({
       propsData: {
         canUpdate: true,
@@ -40,15 +49,17 @@ describe('Issuable output', () => {
         projectPath: '/',
       },
     }).$mount();
+
+    setTimeout(done);
   });
 
-  it('should render a title/description/edited and update title/description/edited on update', (done) => {
-    vm.poll.options.successCallback({
-      json() {
-        return issueShowData.initialRequest;
-      },
-    });
+  afterEach(() => {
+    Vue.http.interceptors = _.without(Vue.http.interceptors, interceptor);
 
+    vm.poll.stop();
+  });
+
+  it('should render a title/description/edited and update title/description/edited on update', (done) => {
     let editedText;
     Vue.nextTick()
     .then(() => {
@@ -64,13 +75,10 @@ describe('Issuable output', () => {
       expect(editedText.querySelector('time')).toBeTruthy();
     })
     .then(() => {
-      vm.poll.options.successCallback({
-        json() {
-          return issueShowData.secondRequest;
-        },
-      });
+      requestData = issueShowData.secondRequest;
+      vm.poll.makeRequest();
     })
-    .then(Vue.nextTick)
+    .then(() => new Promise(resolve => setTimeout(resolve)))
     .then(() => {
       expect(document.querySelector('title').innerText).toContain('2 (#1)');
       expect(vm.$el.querySelector('.title').innerHTML).toContain('<p>2</p>');
@@ -304,7 +312,7 @@ describe('Issuable output', () => {
 
     it('stops polling when deleting', (done) => {
       spyOn(gl.utils, 'visitUrl');
-      spyOn(vm.poll, 'stop');
+      spyOn(vm.poll, 'stop').and.callThrough();
       spyOn(vm.service, 'deleteIssuable').and.callFake(() => new Promise((resolve) => {
         resolve({
           json() {
@@ -347,23 +355,14 @@ describe('Issuable output', () => {
 
   describe('open form', () => {
     it('shows locked warning if form is open & data is different', (done) => {
-      vm.poll.options.successCallback({
-        json() {
-          return issueShowData.initialRequest;
-        },
-      });
-
       Vue.nextTick()
         .then(() => {
           vm.openForm();
 
-          vm.poll.options.successCallback({
-            json() {
-              return issueShowData.secondRequest;
-            },
-          });
+          requestData = issueShowData.secondRequest;
+          vm.poll.makeRequest();
         })
-        .then(Vue.nextTick)
+        .then(() => new Promise(resolve => setTimeout(resolve)))
         .then(() => {
           expect(
             vm.formState.lockedWarningVisible,
diff --git a/spec/javascripts/lib/utils/poll_spec.js b/spec/javascripts/lib/utils/poll_spec.js
index 22f30191ab9..2aa7011ca51 100644
--- a/spec/javascripts/lib/utils/poll_spec.js
+++ b/spec/javascripts/lib/utils/poll_spec.js
@@ -25,23 +25,28 @@ function mockServiceCall(service, response, shouldFail = false) {
 
 describe('Poll', () => {
   const service = jasmine.createSpyObj('service', ['fetch']);
-  const callbacks = jasmine.createSpyObj('callbacks', ['success', 'error']);
+  const callbacks = jasmine.createSpyObj('callbacks', ['success', 'error', 'notification']);
+
+  function setup() {
+    return new Poll({
+      resource: service,
+      method: 'fetch',
+      successCallback: callbacks.success,
+      errorCallback: callbacks.error,
+      notificationCallback: callbacks.notification,
+    }).makeRequest();
+  }
 
   afterEach(() => {
     callbacks.success.calls.reset();
     callbacks.error.calls.reset();
+    callbacks.notification.calls.reset();
     service.fetch.calls.reset();
   });
 
   it('calls the success callback when no header for interval is provided', (done) => {
     mockServiceCall(service, { status: 200 });
-
-    new Poll({
-      resource: service,
-      method: 'fetch',
-      successCallback: callbacks.success,
-      errorCallback: callbacks.error,
-    }).makeRequest();
+    setup();
 
     waitForAllCallsToFinish(service, 1, () => {
       expect(callbacks.success).toHaveBeenCalled();
@@ -51,15 +56,9 @@ describe('Poll', () => {
     });
   });
 
-  it('calls the error callback whe the http request returns an error', (done) => {
+  it('calls the error callback when the http request returns an error', (done) => {
     mockServiceCall(service, { status: 500 }, true);
-
-    new Poll({
-      resource: service,
-      method: 'fetch',
-      successCallback: callbacks.success,
-      errorCallback: callbacks.error,
-    }).makeRequest();
+    setup();
 
     waitForAllCallsToFinish(service, 1, () => {
       expect(callbacks.success).not.toHaveBeenCalled();
@@ -69,15 +68,22 @@ describe('Poll', () => {
     });
   });
 
+  it('skips the error callback when request is aborted', (done) => {
+    mockServiceCall(service, { status: 0 }, true);
+    setup();
+
+    waitForAllCallsToFinish(service, 1, () => {
+      expect(callbacks.success).not.toHaveBeenCalled();
+      expect(callbacks.error).not.toHaveBeenCalled();
+      expect(callbacks.notification).toHaveBeenCalled();
+
+      done();
+    });
+  });
+
   it('should call the success callback when the interval header is -1', (done) => {
     mockServiceCall(service, { status: 200, headers: { 'poll-interval': -1 } });
-
-    new Poll({
-      resource: service,
-      method: 'fetch',
-      successCallback: callbacks.success,
-      errorCallback: callbacks.error,
-    }).makeRequest().then(() => {
+    setup().then(() => {
       expect(callbacks.success).toHaveBeenCalled();
       expect(callbacks.error).not.toHaveBeenCalled();
 
diff --git a/spec/javascripts/vue_mr_widget/components/mr_widget_header_spec.js b/spec/javascripts/vue_mr_widget/components/mr_widget_header_spec.js
index 7f3eea7d2e5..06f89fabf42 100644
--- a/spec/javascripts/vue_mr_widget/components/mr_widget_header_spec.js
+++ b/spec/javascripts/vue_mr_widget/components/mr_widget_header_spec.js
@@ -54,6 +54,7 @@ describe('MRWidgetHeader', () => {
       sourceBranch: 'mr-widget-refactor',
       sourceBranchLink: `<a href="${sourceBranchPath}">mr-widget-refactor</a>`,
       targetBranchPath: 'foo/bar/commits-path',
+      targetBranchTreePath: 'foo/bar/tree/path',
       targetBranch: 'master',
       isOpen: true,
       emailPatchesPath: '/mr/email-patches',
@@ -69,12 +70,14 @@ describe('MRWidgetHeader', () => {
       expect(el.classList.contains('mr-source-target')).toBeTruthy();
       const sourceBranchLink = el.querySelectorAll('.label-branch')[0];
       const targetBranchLink = el.querySelectorAll('.label-branch')[1];
+      const commitsCount = el.querySelector('.diverged-commits-count');
 
       expect(sourceBranchLink.textContent).toContain(mr.sourceBranch);
       expect(targetBranchLink.textContent).toContain(mr.targetBranch);
       expect(sourceBranchLink.querySelector('a').getAttribute('href')).toEqual(sourceBranchPath);
-      expect(targetBranchLink.querySelector('a').getAttribute('href')).toEqual(mr.targetBranchPath);
-      expect(el.querySelector('.diverged-commits-count').textContent).toContain('12 commits behind');
+      expect(targetBranchLink.querySelector('a').getAttribute('href')).toEqual(mr.targetBranchTreePath);
+      expect(commitsCount.textContent).toContain('12 commits behind');
+      expect(commitsCount.querySelector('a').getAttribute('href')).toEqual(mr.targetBranchPath);
 
       expect(el.textContent).toContain('Check out branch');
       expect(el.querySelectorAll('.dropdown li a')[0].getAttribute('href')).toEqual(mr.emailPatchesPath);
diff --git a/spec/javascripts/vue_shared/components/commit_spec.js b/spec/javascripts/vue_shared/components/commit_spec.js
index 1c3188cdda2..d5754aaa9e7 100644
--- a/spec/javascripts/vue_shared/components/commit_spec.js
+++ b/spec/javascripts/vue_shared/components/commit_spec.js
@@ -22,7 +22,7 @@ describe('Commit component', () => {
         shortSha: 'b7836edd',
         title: 'Commit message',
         author: {
-          avatar_url: 'https://gitlab.com/uploads/system/user/avatar/300478/avatar.png',
+          avatar_url: 'https://gitlab.com/uploads/-/system/user/avatar/300478/avatar.png',
           web_url: 'https://gitlab.com/jschatz1',
           path: '/jschatz1',
           username: 'jschatz1',
@@ -45,7 +45,7 @@ describe('Commit component', () => {
         shortSha: 'b7836edd',
         title: 'Commit message',
         author: {
-          avatar_url: 'https://gitlab.com/uploads/system/user/avatar/300478/avatar.png',
+          avatar_url: 'https://gitlab.com/uploads/-/system/user/avatar/300478/avatar.png',
           web_url: 'https://gitlab.com/jschatz1',
           path: '/jschatz1',
           username: 'jschatz1',
diff --git a/spec/lib/ci/gitlab_ci_yaml_processor_spec.rb b/spec/lib/ci/gitlab_ci_yaml_processor_spec.rb
index ef58ef1b0cd..ea79389e67e 100644
--- a/spec/lib/ci/gitlab_ci_yaml_processor_spec.rb
+++ b/spec/lib/ci/gitlab_ci_yaml_processor_spec.rb
@@ -163,7 +163,10 @@ module Ci
           commands: "pwd\nrspec",
           coverage_regex: nil,
           tag_list: [],
-          options: {},
+          options: {
+            before_script: ["pwd"],
+            script: ["rspec"]
+          },
           allow_failure: false,
           when: "on_success",
           environment: nil,
@@ -616,10 +619,12 @@ module Ci
             coverage_regex: nil,
             tag_list: [],
             options: {
-                image: { name: "ruby:2.1", entrypoint: ["/usr/local/bin/init", "run"] },
-                services: [{ name: "mysql" },
-                           { name: "docker:dind", alias: "docker", entrypoint: ["/usr/local/bin/init", "run"],
-                             command: ["/usr/local/bin/init", "run"] }]
+              before_script: ["pwd"],
+              script: ["rspec"],
+              image: { name: "ruby:2.1", entrypoint: ["/usr/local/bin/init", "run"] },
+              services: [{ name: "mysql" },
+                         { name: "docker:dind", alias: "docker", entrypoint: ["/usr/local/bin/init", "run"],
+                           command: ["/usr/local/bin/init", "run"] }]
             },
             allow_failure: false,
             when: "on_success",
@@ -649,10 +654,12 @@ module Ci
             coverage_regex: nil,
             tag_list: [],
             options: {
-                image: { name: "ruby:2.5", entrypoint: ["/usr/local/bin/init", "run"] },
-                services: [{ name: "postgresql", alias: "db-pg", entrypoint: ["/usr/local/bin/init", "run"],
-                             command: ["/usr/local/bin/init", "run"] },
-                           { name: "docker:dind" }]
+              before_script: ["pwd"],
+              script: ["rspec"],
+              image: { name: "ruby:2.5", entrypoint: ["/usr/local/bin/init", "run"] },
+              services: [{ name: "postgresql", alias: "db-pg", entrypoint: ["/usr/local/bin/init", "run"],
+                           command: ["/usr/local/bin/init", "run"] },
+                         { name: "docker:dind" }]
             },
             allow_failure: false,
             when: "on_success",
@@ -680,6 +687,8 @@ module Ci
             coverage_regex: nil,
             tag_list: [],
             options: {
+              before_script: ["pwd"],
+              script: ["rspec"],
               image: { name: "ruby:2.1" },
               services: [{ name: "mysql" }, { name: "docker:dind" }]
             },
@@ -707,8 +716,10 @@ module Ci
             coverage_regex: nil,
             tag_list: [],
             options: {
-                image: { name: "ruby:2.5" },
-                services: [{ name: "postgresql" }, { name: "docker:dind" }]
+              before_script: ["pwd"],
+              script: ["rspec"],
+              image: { name: "ruby:2.5" },
+              services: [{ name: "postgresql" }, { name: "docker:dind" }]
             },
             allow_failure: false,
             when: "on_success",
@@ -951,6 +962,8 @@ module Ci
           coverage_regex: nil,
           tag_list: [],
           options: {
+            before_script: ["pwd"],
+            script: ["rspec"],
             image: { name: "ruby:2.1" },
             services: [{ name: "mysql" }],
             artifacts: {
@@ -1162,7 +1175,9 @@ module Ci
             commands: "test",
             coverage_regex: nil,
             tag_list: [],
-            options: {},
+            options: {
+              script: ["test"]
+            },
             when: "on_success",
             allow_failure: false,
             environment: nil,
@@ -1208,7 +1223,9 @@ module Ci
             commands: "execute-script-for-job",
             coverage_regex: nil,
             tag_list: [],
-            options: {},
+            options: {
+              script: ["execute-script-for-job"]
+            },
             when: "on_success",
             allow_failure: false,
             environment: nil,
@@ -1221,7 +1238,9 @@ module Ci
             commands: "execute-script-for-job",
             coverage_regex: nil,
             tag_list: [],
-            options: {},
+            options: {
+              script: ["execute-script-for-job"]
+            },
             when: "on_success",
             allow_failure: false,
             environment: nil,
diff --git a/spec/lib/gitlab/auth/unique_ips_limiter_spec.rb b/spec/lib/gitlab/auth/unique_ips_limiter_spec.rb
index fc72df575be..15b3db0ed3d 100644
--- a/spec/lib/gitlab/auth/unique_ips_limiter_spec.rb
+++ b/spec/lib/gitlab/auth/unique_ips_limiter_spec.rb
@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Gitlab::Auth::UniqueIpsLimiter, :redis, lib: true do
+describe Gitlab::Auth::UniqueIpsLimiter, :clean_gitlab_redis_shared_state, lib: true do
   include_context 'unique ips sign in limit'
   let(:user) { create(:user) }
 
diff --git a/spec/lib/gitlab/auth_spec.rb b/spec/lib/gitlab/auth_spec.rb
index d09da951869..55780518230 100644
--- a/spec/lib/gitlab/auth_spec.rb
+++ b/spec/lib/gitlab/auth_spec.rb
@@ -206,7 +206,7 @@ describe Gitlab::Auth, lib: true do
     end
 
     it 'throws an error suggesting user create a PAT when internal auth is disabled' do
-      allow_any_instance_of(ApplicationSetting).to receive(:signin_enabled?) { false }
+      allow_any_instance_of(ApplicationSetting).to receive(:password_authentication_enabled?) { false }
 
       expect { gl_auth.find_for_git_client('foo', 'bar', project: nil, ip: 'ip') }.to raise_error(Gitlab::Auth::MissingPersonalTokenError)
     end
@@ -279,6 +279,16 @@ describe Gitlab::Auth, lib: true do
         gl_auth.find_with_user_password('ldap_user', 'password')
       end
     end
+
+    context "with sign-in disabled" do
+      before do
+        stub_application_setting(password_authentication_enabled: false)
+      end
+
+      it "does not find user by valid login/password" do
+        expect(gl_auth.find_with_user_password(username, password)).to be_nil
+      end
+    end
   end
 
   private
diff --git a/spec/lib/gitlab/background_migration/migrate_system_uploads_to_new_folder_spec.rb b/spec/lib/gitlab/background_migration/migrate_system_uploads_to_new_folder_spec.rb
new file mode 100644
index 00000000000..a910fb105a5
--- /dev/null
+++ b/spec/lib/gitlab/background_migration/migrate_system_uploads_to_new_folder_spec.rb
@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe Gitlab::BackgroundMigration::MigrateSystemUploadsToNewFolder do
+  let(:migration) { described_class.new }
+
+  before do
+    allow(migration).to receive(:logger).and_return(Logger.new(nil))
+  end
+
+  describe '#perform' do
+    it 'renames the path of system-uploads', truncate: true do
+      upload = create(:upload, model: create(:empty_project), path: 'uploads/system/project/avatar.jpg')
+
+      migration.perform('uploads/system/', 'uploads/-/system/')
+
+      expect(upload.reload.path).to eq('uploads/-/system/project/avatar.jpg')
+    end
+  end
+end
diff --git a/spec/lib/gitlab/background_migration_spec.rb b/spec/lib/gitlab/background_migration_spec.rb
index 64f82fe27b2..cfa59280139 100644
--- a/spec/lib/gitlab/background_migration_spec.rb
+++ b/spec/lib/gitlab/background_migration_spec.rb
@@ -1,46 +1,120 @@
 require 'spec_helper'
 
 describe Gitlab::BackgroundMigration do
+  describe '.queue' do
+    it 'returns background migration worker queue' do
+      expect(described_class.queue)
+        .to eq BackgroundMigrationWorker.sidekiq_options['queue']
+    end
+  end
+
   describe '.steal' do
-    it 'steals jobs from a queue' do
-      queue = [double(:job, args: ['Foo', [10, 20]])]
+    context 'when there are enqueued jobs present' do
+      let(:queue) do
+        [double(args: ['Foo', [10, 20]], queue: described_class.queue)]
+      end
+
+      before do
+        allow(Sidekiq::Queue).to receive(:new)
+          .with(described_class.queue)
+          .and_return(queue)
+      end
+
+      context 'when queue contains unprocessed jobs' do
+        it 'steals jobs from a queue' do
+          expect(queue[0]).to receive(:delete).and_return(true)
+
+          expect(described_class).to receive(:perform)
+            .with('Foo', [10, 20], anything)
+
+          described_class.steal('Foo')
+        end
+
+        it 'does not steal job that has already been taken' do
+          expect(queue[0]).to receive(:delete).and_return(false)
+
+          expect(described_class).not_to receive(:perform)
+
+          described_class.steal('Foo')
+        end
+
+        it 'does not steal jobs for a different migration' do
+          expect(described_class).not_to receive(:perform)
 
-      allow(Sidekiq::Queue).to receive(:new)
-        .with(BackgroundMigrationWorker.sidekiq_options['queue'])
-        .and_return(queue)
+          expect(queue[0]).not_to receive(:delete)
 
-      expect(queue[0]).to receive(:delete)
+          described_class.steal('Bar')
+        end
+      end
 
-      expect(described_class).to receive(:perform).with('Foo', [10, 20])
+      context 'when one of the jobs raises an error' do
+        let(:migration) { spy(:migration) }
 
-      described_class.steal('Foo')
+        let(:queue) do
+          [double(args: ['Foo', [10, 20]], queue: described_class.queue),
+           double(args: ['Foo', [20, 30]], queue: described_class.queue)]
+        end
+
+        before do
+          stub_const("#{described_class}::Foo", migration)
+
+          allow(queue[0]).to receive(:delete).and_return(true)
+          allow(queue[1]).to receive(:delete).and_return(true)
+        end
+
+        it 'enqueues the migration again and re-raises the error' do
+          allow(migration).to receive(:perform).with(10, 20)
+            .and_raise(Exception, 'Migration error').once
+
+          expect(BackgroundMigrationWorker).to receive(:perform_async)
+            .with('Foo', [10, 20]).once
+
+          expect { described_class.steal('Foo') }.to raise_error(Exception)
+        end
+      end
     end
 
-    it 'does not steal jobs for a different migration' do
-      queue = [double(:job, args: ['Foo', [10, 20]])]
+    context 'when there are scheduled jobs present', :sidekiq, :redis do
+      it 'steals all jobs from the scheduled sets' do
+        Sidekiq::Testing.disable! do
+          BackgroundMigrationWorker.perform_in(10.minutes, 'Object')
 
-      allow(Sidekiq::Queue).to receive(:new)
-        .with(BackgroundMigrationWorker.sidekiq_options['queue'])
-        .and_return(queue)
+          expect(Sidekiq::ScheduledSet.new).to be_one
+          expect(described_class).to receive(:perform).with('Object', any_args)
 
-      expect(described_class).not_to receive(:perform)
+          described_class.steal('Object')
 
-      expect(queue[0]).not_to receive(:delete)
+          expect(Sidekiq::ScheduledSet.new).to be_none
+        end
+      end
+    end
 
-      described_class.steal('Bar')
+    context 'when there are enqueued and scheduled jobs present', :sidekiq, :redis do
+      it 'steals from the scheduled sets queue first' do
+        Sidekiq::Testing.disable! do
+          expect(described_class).to receive(:perform)
+            .with('Object', [1], anything).ordered
+          expect(described_class).to receive(:perform)
+            .with('Object', [2], anything).ordered
+
+          BackgroundMigrationWorker.perform_async('Object', [2])
+          BackgroundMigrationWorker.perform_in(10.minutes, 'Object', [1])
+
+          described_class.steal('Object')
+        end
+      end
     end
   end
 
   describe '.perform' do
-    it 'performs a background migration' do
-      instance = double(:instance)
-      klass = double(:klass, new: instance)
+    let(:migration) { spy(:migration) }
 
-      expect(described_class).to receive(:const_get)
-        .with('Foo')
-        .and_return(klass)
+    before do
+      stub_const("#{described_class.name}::Foo", migration)
+    end
 
-      expect(instance).to receive(:perform).with(10, 20)
+    it 'performs a background migration' do
+      expect(migration).to receive(:perform).with(10, 20).once
 
       described_class.perform('Foo', [10, 20])
     end
diff --git a/spec/lib/gitlab/cache/ci/project_pipeline_status_spec.rb b/spec/lib/gitlab/cache/ci/project_pipeline_status_spec.rb
index 07db6c3a640..0daf41a7c86 100644
--- a/spec/lib/gitlab/cache/ci/project_pipeline_status_spec.rb
+++ b/spec/lib/gitlab/cache/ci/project_pipeline_status_spec.rb
@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Gitlab::Cache::Ci::ProjectPipelineStatus, :redis do
+describe Gitlab::Cache::Ci::ProjectPipelineStatus, :clean_gitlab_redis_cache do
   let!(:project) { create(:project) }
   let(:pipeline_status) { described_class.new(project) }
   let(:cache_key) { "projects/#{project.id}/pipeline_status" }
@@ -28,8 +28,8 @@ describe Gitlab::Cache::Ci::ProjectPipelineStatus, :redis do
         expect(project.instance_variable_get('@pipeline_status')).to be_a(described_class)
       end
 
-      describe 'without a status in redis' do
-        it 'loads the status from a commit when it was not in redis' do
+      describe 'without a status in redis_cache' do
+        it 'loads the status from a commit when it was not in redis_cache' do
           empty_status = { sha: nil, status: nil, ref: nil }
           fake_pipeline = described_class.new(
             project_without_status,
@@ -48,9 +48,9 @@ describe Gitlab::Cache::Ci::ProjectPipelineStatus, :redis do
           described_class.load_in_batch_for_projects([project_without_status])
         end
 
-        it 'only connects to redis twice' do
+        it 'only connects to redis_cache twice' do
           # Once to load, once to store in the cache
-          expect(Gitlab::Redis).to receive(:with).exactly(2).and_call_original
+          expect(Gitlab::Redis::Cache).to receive(:with).exactly(2).and_call_original
 
           described_class.load_in_batch_for_projects([project_without_status])
 
@@ -58,9 +58,9 @@ describe Gitlab::Cache::Ci::ProjectPipelineStatus, :redis do
         end
       end
 
-      describe 'when a status was cached in redis' do
+      describe 'when a status was cached in redis_cache' do
         before do
-          Gitlab::Redis.with do |redis|
+          Gitlab::Redis::Cache.with do |redis|
             redis.mapped_hmset(cache_key,
                                { sha: sha, status: status, ref: ref })
           end
@@ -76,8 +76,8 @@ describe Gitlab::Cache::Ci::ProjectPipelineStatus, :redis do
           expect(pipeline_status.ref).to eq(ref)
         end
 
-        it 'only connects to redis once' do
-          expect(Gitlab::Redis).to receive(:with).exactly(1).and_call_original
+        it 'only connects to redis_cache once' do
+          expect(Gitlab::Redis::Cache).to receive(:with).exactly(1).and_call_original
 
           described_class.load_in_batch_for_projects([project])
 
@@ -94,8 +94,8 @@ describe Gitlab::Cache::Ci::ProjectPipelineStatus, :redis do
     end
 
     describe '.cached_results_for_projects' do
-      it 'loads a status from redis for all projects' do
-        Gitlab::Redis.with do |redis|
+      it 'loads a status from caching for all projects' do
+        Gitlab::Redis::Cache.with do |redis|
           redis.mapped_hmset(cache_key, { sha: sha, status: status, ref: ref })
         end
 
@@ -183,7 +183,7 @@ describe Gitlab::Cache::Ci::ProjectPipelineStatus, :redis do
     end
   end
 
-  describe "#load_from_project" do
+  describe "#load_from_project", :clean_gitlab_redis_cache do
     let!(:pipeline) { create(:ci_pipeline, :success, project: project, sha: project.commit.sha) }
 
     it 'reads the status from the pipeline for the commit' do
@@ -203,40 +203,40 @@ describe Gitlab::Cache::Ci::ProjectPipelineStatus, :redis do
     end
   end
 
-  describe "#store_in_cache", :redis do
-    it "sets the object in redis" do
+  describe "#store_in_cache", :clean_gitlab_redis_cache do
+    it "sets the object in caching" do
       pipeline_status.sha = '123456'
       pipeline_status.status = 'failed'
 
       pipeline_status.store_in_cache
-      read_sha, read_status = Gitlab::Redis.with { |redis| redis.hmget(cache_key, :sha, :status) }
+      read_sha, read_status = Gitlab::Redis::Cache.with { |redis| redis.hmget(cache_key, :sha, :status) }
 
       expect(read_sha).to eq('123456')
       expect(read_status).to eq('failed')
     end
   end
 
-  describe '#store_in_cache_if_needed', :redis do
+  describe '#store_in_cache_if_needed', :clean_gitlab_redis_cache do
     it 'stores the state in the cache when the sha is the HEAD of the project' do
       create(:ci_pipeline, :success, project: project, sha: project.commit.sha)
       pipeline_status = described_class.load_for_project(project)
 
       pipeline_status.store_in_cache_if_needed
-      sha, status, ref = Gitlab::Redis.with { |redis| redis.hmget(cache_key, :sha, :status, :ref) }
+      sha, status, ref = Gitlab::Redis::Cache.with { |redis| redis.hmget(cache_key, :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
+    it "doesn't store the status in redis_cache when the sha is not the head of the project" do
       other_status = described_class.new(
         project,
         pipeline_info: { sha: "123456", status: "failed" }
       )
 
       other_status.store_in_cache_if_needed
-      sha, status = Gitlab::Redis.with { |redis| redis.hmget(cache_key, :sha, :status) }
+      sha, status = Gitlab::Redis::Cache.with { |redis| redis.hmget(cache_key, :sha, :status) }
 
       expect(sha).to be_nil
       expect(status).to be_nil
@@ -244,7 +244,7 @@ describe Gitlab::Cache::Ci::ProjectPipelineStatus, :redis do
 
     it "deletes the cache if the repository doesn't have a head commit" do
       empty_project = create(:empty_project)
-      Gitlab::Redis.with do |redis|
+      Gitlab::Redis::Cache.with do |redis|
         redis.mapped_hmset(cache_key,
                            { sha: 'sha', status: 'pending', ref: 'master' })
       end
@@ -255,7 +255,7 @@ describe Gitlab::Cache::Ci::ProjectPipelineStatus, :redis do
                                          })
 
       other_status.store_in_cache_if_needed
-      sha, status, ref = Gitlab::Redis.with { |redis| redis.hmget("projects/#{empty_project.id}/pipeline_status", :sha, :status, :ref) }
+      sha, status, ref = Gitlab::Redis::Cache.with { |redis| redis.hmget("projects/#{empty_project.id}/pipeline_status", :sha, :status, :ref) }
 
       expect(sha).to be_nil
       expect(status).to be_nil
@@ -263,20 +263,20 @@ describe Gitlab::Cache::Ci::ProjectPipelineStatus, :redis do
     end
   end
 
-  describe "with a status in redis", :redis do
+  describe "with a status in caching", :clean_gitlab_redis_cache do
     let(:status) { 'success' }
     let(:sha) { '424d1b73bc0d3cb726eb7dc4ce17a4d48552f8c6' }
     let(:ref) { 'master' }
 
     before do
-      Gitlab::Redis.with do |redis|
+      Gitlab::Redis::Cache.with do |redis|
         redis.mapped_hmset(cache_key,
                            { sha: sha, status: status, ref: ref })
       end
     end
 
     describe '#load_from_cache' do
-      it 'reads the status from redis' do
+      it 'reads the status from redis_cache' do
         pipeline_status.load_from_cache
 
         expect(pipeline_status.sha).to eq(sha)
@@ -292,10 +292,10 @@ describe Gitlab::Cache::Ci::ProjectPipelineStatus, :redis do
     end
 
     describe '#delete_from_cache' do
-      it 'deletes values from redis'  do
+      it 'deletes values from redis_cache'  do
         pipeline_status.delete_from_cache
 
-        key_exists = Gitlab::Redis.with { |redis| redis.exists(cache_key) }
+        key_exists = Gitlab::Redis::Cache.with { |redis| redis.exists(cache_key) }
 
         expect(key_exists).to be_falsy
       end
diff --git a/spec/lib/gitlab/cache/request_cache_spec.rb b/spec/lib/gitlab/cache/request_cache_spec.rb
new file mode 100644
index 00000000000..5b82c216a13
--- /dev/null
+++ b/spec/lib/gitlab/cache/request_cache_spec.rb
@@ -0,0 +1,133 @@
+require 'spec_helper'
+
+describe Gitlab::Cache::RequestCache do
+  let(:klass) do
+    Class.new do
+      extend Gitlab::Cache::RequestCache
+
+      attr_accessor :id, :name, :result, :extra
+
+      def self.name
+        'ExpensiveAlgorithm'
+      end
+
+      def initialize(id, name, result, extra = nil)
+        self.id = id
+        self.name = name
+        self.result = result
+        self.extra = nil
+      end
+
+      request_cache def compute(arg)
+        result << arg
+      end
+
+      request_cache def repute(arg)
+        result << arg
+      end
+
+      def dispute(arg)
+        result << arg
+      end
+      request_cache(:dispute) { extra }
+    end
+  end
+
+  let(:algorithm) { klass.new('id', 'name', []) }
+
+  shared_examples 'cache for the same instance' do
+    it 'does not compute twice for the same argument' do
+      algorithm.compute(true)
+      result = algorithm.compute(true)
+
+      expect(result).to eq([true])
+    end
+
+    it 'computes twice for the different argument' do
+      algorithm.compute(true)
+      result = algorithm.compute(false)
+
+      expect(result).to eq([true, false])
+    end
+
+    it 'computes twice for the different class name' do
+      algorithm.compute(true)
+      allow(klass).to receive(:name).and_return('CheapAlgo')
+      result = algorithm.compute(true)
+
+      expect(result).to eq([true, true])
+    end
+
+    it 'computes twice for the different method' do
+      algorithm.compute(true)
+      result = algorithm.repute(true)
+
+      expect(result).to eq([true, true])
+    end
+
+    context 'when request_cache_key is provided' do
+      before do
+        klass.request_cache_key do
+          [id, name]
+        end
+      end
+
+      it 'computes twice for the different keys, id' do
+        algorithm.compute(true)
+        algorithm.id = 'ad'
+        result = algorithm.compute(true)
+
+        expect(result).to eq([true, true])
+      end
+
+      it 'computes twice for the different keys, name' do
+        algorithm.compute(true)
+        algorithm.name = 'same'
+        result = algorithm.compute(true)
+
+        expect(result).to eq([true, true])
+      end
+
+      it 'uses extra method cache key if provided' do
+        algorithm.dispute(true) # miss
+        algorithm.extra = true
+        algorithm.dispute(true) # miss
+        result = algorithm.dispute(true) # hit
+
+        expect(result).to eq([true, true])
+      end
+    end
+  end
+
+  context 'when RequestStore is active', :request_store do
+    it_behaves_like 'cache for the same instance'
+
+    it 'computes once for different instances when keys are the same' do
+      algorithm.compute(true)
+      result = klass.new('id', 'name', algorithm.result).compute(true)
+
+      expect(result).to eq([true])
+    end
+
+    it 'computes twice if RequestStore starts over' do
+      algorithm.compute(true)
+      RequestStore.end!
+      RequestStore.clear!
+      RequestStore.begin!
+      result = algorithm.compute(true)
+
+      expect(result).to eq([true, true])
+    end
+  end
+
+  context 'when RequestStore is inactive' do
+    it_behaves_like 'cache for the same instance'
+
+    it 'computes twice for different instances even if keys are the same' do
+      algorithm.compute(true)
+      result = klass.new('id', 'name', algorithm.result).compute(true)
+
+      expect(result).to eq([true, true])
+    end
+  end
+end
diff --git a/spec/lib/gitlab/ci/build/step_spec.rb b/spec/lib/gitlab/ci/build/step_spec.rb
index 49457b129e3..5a21282712a 100644
--- a/spec/lib/gitlab/ci/build/step_spec.rb
+++ b/spec/lib/gitlab/ci/build/step_spec.rb
@@ -1,21 +1,50 @@
 require 'spec_helper'
 
 describe Gitlab::Ci::Build::Step do
-  let(:job) { create(:ci_build, :no_options, commands: "ls -la\ndate") }
-
   describe '#from_commands' do
-    subject { described_class.from_commands(job) }
-
-    it 'fabricates an object' do
-      expect(subject.name).to eq(:script)
-      expect(subject.script).to eq(['ls -la', 'date'])
-      expect(subject.timeout).to eq(job.timeout)
-      expect(subject.when).to eq('on_success')
-      expect(subject.allow_failure).to be_falsey
+    shared_examples 'has correct script' do
+      subject { described_class.from_commands(job) }
+
+      it 'fabricates an object' do
+        expect(subject.name).to eq(:script)
+        expect(subject.script).to eq(script)
+        expect(subject.timeout).to eq(job.timeout)
+        expect(subject.when).to eq('on_success')
+        expect(subject.allow_failure).to be_falsey
+      end
+    end
+
+    context 'when commands are specified' do
+      it_behaves_like 'has correct script' do
+        let(:job) { create(:ci_build, :no_options, commands: "ls -la\ndate") }
+        let(:script) { ['ls -la', 'date'] }
+      end
+    end
+
+    context 'when script option is specified' do
+      it_behaves_like 'has correct script' do
+        let(:job) { create(:ci_build, :no_options, options: { script: ["ls -la\necho aaa", "date"] }) }
+        let(:script) { ["ls -la\necho aaa", 'date'] }
+      end
+    end
+
+    context 'when before and script option is specified' do
+      it_behaves_like 'has correct script' do
+        let(:job) do
+          create(:ci_build, options: {
+            before_script: ["ls -la\necho aaa"],
+            script: ["date"]
+          })
+        end
+
+        let(:script) { ["ls -la\necho aaa", 'date'] }
+      end
     end
   end
 
   describe '#from_after_script' do
+    let(:job) { create(:ci_build) }
+
     subject { described_class.from_after_script(job) }
 
     context 'when after_script is empty' do
diff --git a/spec/lib/gitlab/ci/trace/stream_spec.rb b/spec/lib/gitlab/ci/trace/stream_spec.rb
index bbb3f9912a3..13f0338b6aa 100644
--- a/spec/lib/gitlab/ci/trace/stream_spec.rb
+++ b/spec/lib/gitlab/ci/trace/stream_spec.rb
@@ -293,5 +293,12 @@ describe Gitlab::Ci::Trace::Stream do
 
       it { is_expected.to eq("65") }
     end
+
+    context 'malicious regexp' do
+      let(:data) { malicious_text }  
+      let(:regex) { malicious_regexp }
+
+      include_examples 'malicious regexp'
+    end
   end
 end
diff --git a/spec/lib/gitlab/current_settings_spec.rb b/spec/lib/gitlab/current_settings_spec.rb
index a566f24f6a6..d57ffcae8e1 100644
--- a/spec/lib/gitlab/current_settings_spec.rb
+++ b/spec/lib/gitlab/current_settings_spec.rb
@@ -27,10 +27,23 @@ describe Gitlab::CurrentSettings do
       end
 
       it 'falls back to DB if Redis fails' do
+        db_settings = ApplicationSetting.create!(ApplicationSetting.defaults)
+
         expect(ApplicationSetting).to receive(:cached).and_raise(::Redis::BaseError)
-        expect(ApplicationSetting).to receive(:last).and_call_original
+        expect(Rails.cache).to receive(:fetch).with(ApplicationSetting::CACHE_KEY).and_raise(Redis::BaseError)
 
-        expect(current_application_settings).to be_a(ApplicationSetting)
+        expect(current_application_settings).to eq(db_settings)
+      end
+
+      it 'creates default ApplicationSettings if none are present' do
+        expect(ApplicationSetting).to receive(:cached).and_raise(::Redis::BaseError)
+        expect(Rails.cache).to receive(:fetch).with(ApplicationSetting::CACHE_KEY).and_raise(Redis::BaseError)
+
+        settings = current_application_settings
+
+        expect(settings).to be_a(ApplicationSetting)
+        expect(settings).to be_persisted
+        expect(settings).to have_attributes(ApplicationSetting.defaults)
       end
 
       context 'with migrations pending' do
diff --git a/spec/lib/gitlab/database/migration_helpers_spec.rb b/spec/lib/gitlab/database/migration_helpers_spec.rb
index 4259be3f522..a2acd15c8fb 100644
--- a/spec/lib/gitlab/database/migration_helpers_spec.rb
+++ b/spec/lib/gitlab/database/migration_helpers_spec.rb
@@ -174,13 +174,23 @@ describe Gitlab::Database::MigrationHelpers, lib: true do
           allow(Gitlab::Database).to receive(:mysql?).and_return(false)
         end
 
-        it 'creates a concurrent foreign key' do
+        it 'creates a concurrent foreign key and validates it' do
           expect(model).to receive(:disable_statement_timeout)
           expect(model).to receive(:execute).ordered.with(/NOT VALID/)
           expect(model).to receive(:execute).ordered.with(/VALIDATE CONSTRAINT/)
 
           model.add_concurrent_foreign_key(:projects, :users, column: :user_id)
         end
+
+        it 'appends a valid ON DELETE statement' do
+          expect(model).to receive(:disable_statement_timeout)
+          expect(model).to receive(:execute).with(/ON DELETE SET NULL/)
+          expect(model).to receive(:execute).ordered.with(/VALIDATE CONSTRAINT/)
+
+          model.add_concurrent_foreign_key(:projects, :users,
+                                           column: :user_id,
+                                           on_delete: :nullify)
+        end
       end
     end
   end
diff --git a/spec/lib/gitlab/database/rename_reserved_paths_migration/v1/rename_base_spec.rb b/spec/lib/gitlab/database/rename_reserved_paths_migration/v1/rename_base_spec.rb
index 8813f129ef5..df7d1b5d27a 100644
--- a/spec/lib/gitlab/database/rename_reserved_paths_migration/v1/rename_base_spec.rb
+++ b/spec/lib/gitlab/database/rename_reserved_paths_migration/v1/rename_base_spec.rb
@@ -236,7 +236,7 @@ describe Gitlab::Database::RenameReservedPathsMigration::V1::RenameBase, :trunca
       subject.track_rename('namespace', 'path/to/namespace', 'path/to/renamed')
 
       old_path, new_path = [nil, nil]
-      Gitlab::Redis.with do |redis|
+      Gitlab::Redis::SharedState.with do |redis|
         rename_info = redis.lpop(key)
         old_path, new_path = JSON.parse(rename_info)
       end
@@ -268,7 +268,7 @@ describe Gitlab::Database::RenameReservedPathsMigration::V1::RenameBase, :trunca
       key = 'rename:FakeRenameReservedPathMigrationV1:project'
       stored_renames = nil
       rename_count = 0
-      Gitlab::Redis.with do |redis|
+      Gitlab::Redis::SharedState.with do |redis|
         stored_renames = redis.lrange(key, 0, 1)
         rename_count = redis.llen(key)
       end
diff --git a/spec/lib/gitlab/exclusive_lease_spec.rb b/spec/lib/gitlab/exclusive_lease_spec.rb
index 81bbd70ffb8..590d6da4113 100644
--- a/spec/lib/gitlab/exclusive_lease_spec.rb
+++ b/spec/lib/gitlab/exclusive_lease_spec.rb
@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Gitlab::ExclusiveLease, type: :redis do
+describe Gitlab::ExclusiveLease, type: :clean_gitlab_redis_shared_state do
   let(:unique_key) { SecureRandom.hex(10) }
 
   describe '#try_obtain' do
diff --git a/spec/lib/gitlab/fake_application_settings_spec.rb b/spec/lib/gitlab/fake_application_settings_spec.rb
index b793176d84a..34322c2a693 100644
--- a/spec/lib/gitlab/fake_application_settings_spec.rb
+++ b/spec/lib/gitlab/fake_application_settings_spec.rb
@@ -1,25 +1,25 @@
 require 'spec_helper'
 
 describe Gitlab::FakeApplicationSettings do
-  let(:defaults) { { signin_enabled: false, foobar: 'asdf', signup_enabled: true, 'test?' => 123 } }
+  let(:defaults) { { password_authentication_enabled: false, foobar: 'asdf', signup_enabled: true, 'test?' => 123 } }
 
   subject { described_class.new(defaults) }
 
   it 'wraps OpenStruct variables properly' do
-    expect(subject.signin_enabled).to be_falsey
+    expect(subject.password_authentication_enabled).to be_falsey
     expect(subject.signup_enabled).to be_truthy
     expect(subject.foobar).to eq('asdf')
   end
 
   it 'defines predicate methods' do
-    expect(subject.signin_enabled?).to be_falsey
+    expect(subject.password_authentication_enabled?).to be_falsey
     expect(subject.signup_enabled?).to be_truthy
   end
 
   it 'predicate method changes when value is updated' do
-    subject.signin_enabled = true
+    subject.password_authentication_enabled = true
 
-    expect(subject.signin_enabled?).to be_truthy
+    expect(subject.password_authentication_enabled?).to be_truthy
   end
 
   it 'does not define a predicate method' do
diff --git a/spec/lib/gitlab/git/branch_spec.rb b/spec/lib/gitlab/git/branch_spec.rb
index d1d7ed1d02a..cdf1b8beee3 100644
--- a/spec/lib/gitlab/git/branch_spec.rb
+++ b/spec/lib/gitlab/git/branch_spec.rb
@@ -7,51 +7,6 @@ describe Gitlab::Git::Branch, seed_helper: true do
 
   it { is_expected.to be_kind_of Array }
 
-  describe 'initialize' do
-    let(:commit_id) { 'f00' }
-    let(:commit_subject) { "My commit".force_encoding('ASCII-8BIT') }
-    let(:committer) do
-      Gitaly::FindLocalBranchCommitAuthor.new(
-        name: generate(:name),
-        email: generate(:email),
-        date: Google::Protobuf::Timestamp.new(seconds: 123)
-      )
-    end
-    let(:author) do
-      Gitaly::FindLocalBranchCommitAuthor.new(
-        name: generate(:name),
-        email: generate(:email),
-        date: Google::Protobuf::Timestamp.new(seconds: 456)
-      )
-    end
-    let(:gitaly_branch) do
-      Gitaly::FindLocalBranchResponse.new(
-        name: 'foo', commit_id: commit_id, commit_subject: commit_subject,
-        commit_author: author, commit_committer: committer
-      )
-    end
-    let(:attributes) do
-      {
-        id: commit_id,
-        message: commit_subject,
-        authored_date: Time.at(author.date.seconds),
-        author_name: author.name,
-        author_email: author.email,
-        committed_date: Time.at(committer.date.seconds),
-        committer_name: committer.name,
-        committer_email: committer.email
-      }
-    end
-    let(:branch) { described_class.new(repository, 'foo', gitaly_branch) }
-
-    it 'parses Gitaly::FindLocalBranchResponse correctly' do
-      expect(Gitlab::Git::Commit).to receive(:decorate)
-        .with(hash_including(attributes)).and_call_original
-
-      expect(branch.dereferenced_target.message).to be_utf8
-    end
-  end
-
   describe '#size' do
     subject { super().size }
     it { is_expected.to eq(SeedRepo::Repo::BRANCHES.size) }
diff --git a/spec/lib/gitlab/git/commit_spec.rb b/spec/lib/gitlab/git/commit_spec.rb
index f20a14155dc..60de91324f0 100644
--- a/spec/lib/gitlab/git/commit_spec.rb
+++ b/spec/lib/gitlab/git/commit_spec.rb
@@ -64,6 +64,52 @@ describe Gitlab::Git::Commit, seed_helper: true do
     end
   end
 
+  describe "Commit info from gitaly commit" do
+    let(:id) { 'f00' }
+    let(:subject) { "My commit".force_encoding('ASCII-8BIT') }
+    let(:body) { subject + "My body".force_encoding('ASCII-8BIT') }
+    let(:committer) do
+      Gitaly::CommitAuthor.new(
+        name: generate(:name),
+        email: generate(:email),
+        date: Google::Protobuf::Timestamp.new(seconds: 123)
+      )
+    end
+    let(:author) do
+      Gitaly::CommitAuthor.new(
+        name: generate(:name),
+        email: generate(:email),
+        date: Google::Protobuf::Timestamp.new(seconds: 456)
+      )
+    end
+    let(:gitaly_commit) do
+      Gitaly::GitCommit.new(
+        id: id,
+        subject: subject,
+        body: body,
+        author: author,
+        committer: committer
+      )
+    end
+    let(:commit) { described_class.new(gitaly_commit) }
+
+    it { expect(commit.short_id).to eq(id[0..10]) }
+    it { expect(commit.id).to eq(id) }
+    it { expect(commit.sha).to eq(id) }
+    it { expect(commit.safe_message).to eq(body) }
+    it { expect(commit.created_at).to eq(Time.at(committer.date.seconds)) }
+    it { expect(commit.author_email).to eq(author.email) }
+    it { expect(commit.author_name).to eq(author.name) }
+    it { expect(commit.committer_name).to eq(committer.name) }
+    it { expect(commit.committer_email).to eq(committer.email) }
+
+    context 'no body' do
+      let(:body) { "".force_encoding('ASCII-8BIT') }
+
+      it { expect(commit.safe_message).to eq(subject) }
+    end
+  end
+
   context 'Class methods' do
     describe '.find' do
       it "should return first head commit if without params" do
diff --git a/spec/lib/gitlab/git/diff_spec.rb b/spec/lib/gitlab/git/diff_spec.rb
index d97e85364c2..7ea3386ac2a 100644
--- a/spec/lib/gitlab/git/diff_spec.rb
+++ b/spec/lib/gitlab/git/diff_spec.rb
@@ -34,7 +34,7 @@ EOT
   describe 'size limit feature toggles' do
     context 'when the feature gitlab_git_diff_size_limit_increase is enabled' do
       before do
-        Feature.enable('gitlab_git_diff_size_limit_increase')
+        stub_feature_flags(gitlab_git_diff_size_limit_increase: true)
       end
 
       it 'returns 200 KB for size_limit' do
@@ -48,7 +48,7 @@ EOT
 
     context 'when the feature gitlab_git_diff_size_limit_increase is disabled' do
       before do
-        Feature.disable('gitlab_git_diff_size_limit_increase')
+        stub_feature_flags(gitlab_git_diff_size_limit_increase: false)
       end
 
       it 'returns 100 KB for size_limit' do
@@ -241,7 +241,7 @@ EOT
   end
 
   describe '.filter_diff_options' do
-    let(:options) { { max_size: 100, invalid_opt: true } }
+    let(:options) { { max_files: 100, invalid_opt: true } }
 
     context "without default options" do
       let(:filtered_options) { described_class.filter_diff_options(options) }
@@ -253,7 +253,7 @@ EOT
 
     context "with default options" do
       let(:filtered_options) do
-        default_options = { max_size: 5, bad_opt: 1, ignore_whitespace: true }
+        default_options = { max_files: 5, bad_opt: 1, ignore_whitespace_change: true }
         described_class.filter_diff_options(options, default_options)
       end
 
@@ -263,12 +263,12 @@ EOT
       end
 
       it "should merge with default options" do
-        expect(filtered_options).to have_key(:ignore_whitespace)
+        expect(filtered_options).to have_key(:ignore_whitespace_change)
       end
 
       it "should override default options" do
-        expect(filtered_options).to have_key(:max_size)
-        expect(filtered_options[:max_size]).to eq(100)
+        expect(filtered_options).to have_key(:max_files)
+        expect(filtered_options[:max_files]).to eq(100)
       end
     end
   end
diff --git a/spec/lib/gitlab/git/hook_spec.rb b/spec/lib/gitlab/git/hook_spec.rb
index 73518656bde..19f45ea1cb2 100644
--- a/spec/lib/gitlab/git/hook_spec.rb
+++ b/spec/lib/gitlab/git/hook_spec.rb
@@ -2,6 +2,12 @@ require 'spec_helper'
 require 'fileutils'
 
 describe Gitlab::Git::Hook, lib: true do
+  before do
+    # We need this because in the spec/spec_helper.rb we define it like this:
+    # allow_any_instance_of(Gitlab::Git::Hook).to receive(:trigger).and_return([true, nil])
+    allow_any_instance_of(Gitlab::Git::Hook).to receive(:trigger).and_call_original
+  end
+
   describe "#trigger" do
     let(:project) { create(:project, :repository) }
     let(:repo_path) { project.repository.path }
diff --git a/spec/lib/gitlab/git/repository_spec.rb b/spec/lib/gitlab/git/repository_spec.rb
index acffd335e43..83d067b2c31 100644
--- a/spec/lib/gitlab/git/repository_spec.rb
+++ b/spec/lib/gitlab/git/repository_spec.rb
@@ -45,11 +45,11 @@ describe Gitlab::Git::Repository, seed_helper: true do
     end
 
     it 'gets the branch name from GitalyClient' do
-      expect_any_instance_of(Gitlab::GitalyClient::Ref).to receive(:default_branch_name)
+      expect_any_instance_of(Gitlab::GitalyClient::RefService).to receive(:default_branch_name)
       repository.root_ref
     end
 
-    it_behaves_like 'wrapping gRPC errors', Gitlab::GitalyClient::Ref, :default_branch_name do
+    it_behaves_like 'wrapping gRPC errors', Gitlab::GitalyClient::RefService, :default_branch_name do
       subject { repository.root_ref }
     end
   end
@@ -132,11 +132,11 @@ describe Gitlab::Git::Repository, seed_helper: true do
     it { is_expected.not_to include("branch-from-space") }
 
     it 'gets the branch names from GitalyClient' do
-      expect_any_instance_of(Gitlab::GitalyClient::Ref).to receive(:branch_names)
+      expect_any_instance_of(Gitlab::GitalyClient::RefService).to receive(:branch_names)
       subject
     end
 
-    it_behaves_like 'wrapping gRPC errors', Gitlab::GitalyClient::Ref, :branch_names
+    it_behaves_like 'wrapping gRPC errors', Gitlab::GitalyClient::RefService, :branch_names
   end
 
   describe '#tag_names' do
@@ -160,11 +160,11 @@ describe Gitlab::Git::Repository, seed_helper: true do
     it { is_expected.not_to include("v5.0.0") }
 
     it 'gets the tag names from GitalyClient' do
-      expect_any_instance_of(Gitlab::GitalyClient::Ref).to receive(:tag_names)
+      expect_any_instance_of(Gitlab::GitalyClient::RefService).to receive(:tag_names)
       subject
     end
 
-    it_behaves_like 'wrapping gRPC errors', Gitlab::GitalyClient::Ref, :tag_names
+    it_behaves_like 'wrapping gRPC errors', Gitlab::GitalyClient::RefService, :tag_names
   end
 
   shared_examples 'archive check' do |extenstion|
@@ -234,33 +234,6 @@ describe Gitlab::Git::Repository, seed_helper: true do
     it { expect(repository.bare?).to be_truthy }
   end
 
-  describe '#heads' do
-    let(:heads) { repository.heads }
-    subject { heads }
-
-    it { is_expected.to be_kind_of Array }
-
-    describe '#size' do
-      subject { super().size }
-      it { is_expected.to eq(SeedRepo::Repo::BRANCHES.size) }
-    end
-
-    context :head do
-      subject { heads.first }
-
-      describe '#name' do
-        subject { super().name }
-        it { is_expected.to eq("feature") }
-      end
-
-      context :commit do
-        subject { heads.first.dereferenced_target.sha }
-
-        it { is_expected.to eq("0b4bc9a49b562e85de7cc9e834518ea6828729b9") }
-      end
-    end
-  end
-
   describe '#ref_names' do
     let(:ref_names) { repository.ref_names }
     subject { ref_names }
@@ -278,42 +251,6 @@ describe Gitlab::Git::Repository, seed_helper: true do
     end
   end
 
-  describe '#search_files' do
-    let(:results) { repository.search_files('rails', 'master') }
-    subject { results }
-
-    it { is_expected.to be_kind_of Array }
-
-    describe '#first' do
-      subject { super().first }
-      it { is_expected.to be_kind_of Gitlab::Git::BlobSnippet }
-    end
-
-    context 'blob result' do
-      subject { results.first }
-
-      describe '#ref' do
-        subject { super().ref }
-        it { is_expected.to eq('master') }
-      end
-
-      describe '#filename' do
-        subject { super().filename }
-        it { is_expected.to eq('CHANGELOG') }
-      end
-
-      describe '#startline' do
-        subject { super().startline }
-        it { is_expected.to eq(35) }
-      end
-
-      describe '#data' do
-        subject { super().data }
-        it { is_expected.to include "Ability to filter by multiple labels" }
-      end
-    end
-  end
-
   describe '#submodule_url_for' do
     let(:repository) { Gitlab::Git::Repository.new('default', TEST_REPO_PATH) }
     let(:ref) { 'master' }
@@ -431,7 +368,7 @@ describe Gitlab::Git::Repository, seed_helper: true do
 
     context 'when Gitaly commit_count feature is enabled' do
       it_behaves_like 'counting commits'
-      it_behaves_like 'wrapping gRPC errors', Gitlab::GitalyClient::Commit, :commit_count do
+      it_behaves_like 'wrapping gRPC errors', Gitlab::GitalyClient::CommitService, :commit_count do
         subject { repository.commit_count('master') }
       end
     end
@@ -521,7 +458,7 @@ describe Gitlab::Git::Repository, seed_helper: true do
       end
 
       it "should refresh the repo's #heads collection" do
-        head_names = @normal_repo.heads.map { |h| h.name }
+        head_names = @normal_repo.branches.map { |h| h.name }
         expect(head_names).to include(new_branch)
       end
 
@@ -542,7 +479,7 @@ describe Gitlab::Git::Repository, seed_helper: true do
             eq(normal_repo.rugged.branches["master"].target.oid)
           )
 
-          head_names = normal_repo.heads.map { |h| h.name }
+          head_names = normal_repo.branches.map { |h| h.name }
           expect(head_names).not_to include(new_branch)
         end
 
@@ -589,10 +526,6 @@ describe Gitlab::Git::Repository, seed_helper: true do
       expect(@repo.rugged.branches["feature"]).to be_nil
     end
 
-    it "should update the repo's #heads collection" do
-      expect(@repo.heads).not_to include("feature")
-    end
-
     after(:all) do
       FileUtils.rm_rf(TEST_MUTABLE_REPO_PATH)
       ensure_seeds
@@ -705,9 +638,9 @@ describe Gitlab::Git::Repository, seed_helper: true do
       # Add new commits so that there's a renamed file in the commit history
       repo = Gitlab::Git::Repository.new('default', TEST_REPO_PATH).rugged
 
-      commit_with_old_name = new_commit_edit_old_file(repo)
-      rename_commit = new_commit_move_file(repo)
-      commit_with_new_name = new_commit_edit_new_file(repo)
+      commit_with_old_name = Gitlab::Git::Commit.decorate(new_commit_edit_old_file(repo))
+      rename_commit = Gitlab::Git::Commit.decorate(new_commit_move_file(repo))
+      commit_with_new_name = Gitlab::Git::Commit.decorate(new_commit_edit_new_file(repo))
     end
 
     after(:context) do
@@ -880,8 +813,8 @@ describe Gitlab::Git::Repository, seed_helper: true do
 
     context "compare results between log_by_walk and log_by_shell" do
       let(:options) { { ref: "master" } }
-      let(:commits_by_walk) { repository.log(options).map(&:oid) }
-      let(:commits_by_shell) { repository.log(options.merge({ disable_walk: true })).map(&:oid) }
+      let(:commits_by_walk) { repository.log(options).map(&:id) }
+      let(:commits_by_shell) { repository.log(options.merge({ disable_walk: true })).map(&:id) }
 
       it { expect(commits_by_walk).to eq(commits_by_shell) }
 
@@ -924,7 +857,7 @@ describe Gitlab::Git::Repository, seed_helper: true do
 
         expect(commits.size).to be > 0
         expect(commits).to satisfy do |commits|
-          commits.all? { |commit| commit.time >= options[:after] }
+          commits.all? { |commit| commit.committed_date >= options[:after] }
         end
       end
     end
@@ -937,7 +870,7 @@ describe Gitlab::Git::Repository, seed_helper: true do
 
         expect(commits.size).to be > 0
         expect(commits).to satisfy do |commits|
-          commits.all? { |commit| commit.time <= options[:before] }
+          commits.all? { |commit| commit.committed_date <= options[:before] }
         end
       end
     end
@@ -946,7 +879,7 @@ describe Gitlab::Git::Repository, seed_helper: true do
       let(:options) { { ref: 'master', path: ['PROCESS.md', 'README.md'] } }
 
       def commit_files(commit)
-        commit.diff(commit.parent_ids.first).deltas.flat_map do |delta|
+        commit.diff_from_parent.deltas.flat_map do |delta|
           [delta.old_file[:path], delta.new_file[:path]].uniq.compact
         end
       end
@@ -1292,12 +1225,12 @@ describe Gitlab::Git::Repository, seed_helper: true do
     end
 
     it 'gets the branches from GitalyClient' do
-      expect_any_instance_of(Gitlab::GitalyClient::Ref).to receive(:local_branches)
+      expect_any_instance_of(Gitlab::GitalyClient::RefService).to receive(:local_branches)
         .and_return([])
       @repo.local_branches
     end
 
-    it_behaves_like 'wrapping gRPC errors', Gitlab::GitalyClient::Ref, :local_branches do
+    it_behaves_like 'wrapping gRPC errors', Gitlab::GitalyClient::RefService, :local_branches do
       subject { @repo.local_branches }
     end
   end
diff --git a/spec/lib/gitlab/gitaly_client/commit_spec.rb b/spec/lib/gitlab/gitaly_client/commit_service_spec.rb
index dff5b25c712..93affb12f2b 100644
--- a/spec/lib/gitlab/gitaly_client/commit_spec.rb
+++ b/spec/lib/gitlab/gitaly_client/commit_service_spec.rb
@@ -1,7 +1,6 @@
 require 'spec_helper'
 
-describe Gitlab::GitalyClient::Commit do
-  let(:diff_stub) { double('Gitaly::Diff::Stub') }
+describe Gitlab::GitalyClient::CommitService do
   let(:project) { create(:project, :repository) }
   let(:repository) { project.repository }
   let(:repository_message) { repository.gitaly_repository }
@@ -16,7 +15,7 @@ describe Gitlab::GitalyClient::Commit do
           right_commit_id: commit.id
         )
 
-        expect_any_instance_of(Gitaly::Diff::Stub).to receive(:commit_diff).with(request, kind_of(Hash))
+        expect_any_instance_of(Gitaly::DiffService::Stub).to receive(:commit_diff).with(request, kind_of(Hash))
 
         described_class.new(repository).diff_from_parent(commit)
       end
@@ -31,7 +30,7 @@ describe Gitlab::GitalyClient::Commit do
           right_commit_id: initial_commit.id
         )
 
-        expect_any_instance_of(Gitaly::Diff::Stub).to receive(:commit_diff).with(request, kind_of(Hash))
+        expect_any_instance_of(Gitaly::DiffService::Stub).to receive(:commit_diff).with(request, kind_of(Hash))
 
         described_class.new(repository).diff_from_parent(initial_commit)
       end
@@ -61,7 +60,7 @@ describe Gitlab::GitalyClient::Commit do
           right_commit_id: commit.id
         )
 
-        expect_any_instance_of(Gitaly::Diff::Stub).to receive(:commit_delta).with(request, kind_of(Hash)).and_return([])
+        expect_any_instance_of(Gitaly::DiffService::Stub).to receive(:commit_delta).with(request, kind_of(Hash)).and_return([])
 
         described_class.new(repository).commit_deltas(commit)
       end
@@ -76,10 +75,25 @@ describe Gitlab::GitalyClient::Commit do
           right_commit_id: initial_commit.id
         )
 
-        expect_any_instance_of(Gitaly::Diff::Stub).to receive(:commit_delta).with(request, kind_of(Hash)).and_return([])
+        expect_any_instance_of(Gitaly::DiffService::Stub).to receive(:commit_delta).with(request, kind_of(Hash)).and_return([])
 
         described_class.new(repository).commit_deltas(initial_commit)
       end
     end
   end
+
+  describe '#between' do
+    let(:from) { 'master' }
+    let(:to) { '4b825dc642cb6eb9a060e54bf8d69288fbee4904' }
+    it 'sends an RPC request' do
+      request = Gitaly::CommitsBetweenRequest.new(
+        repository: repository_message, from: from, to: to
+      )
+
+      expect_any_instance_of(Gitaly::CommitService::Stub).to receive(:commits_between)
+        .with(request, kind_of(Hash)).and_return([])
+
+      described_class.new(repository).between(from, to)
+    end
+  end
 end
diff --git a/spec/lib/gitlab/gitaly_client/notifications_spec.rb b/spec/lib/gitlab/gitaly_client/notification_service_spec.rb
index 7404ffe0f06..d9597c4aa78 100644
--- a/spec/lib/gitlab/gitaly_client/notifications_spec.rb
+++ b/spec/lib/gitlab/gitaly_client/notification_service_spec.rb
@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Gitlab::GitalyClient::Notifications do
+describe Gitlab::GitalyClient::NotificationService do
   describe '#post_receive' do
     let(:project) { create(:empty_project) }
     let(:storage_name) { project.repository_storage }
@@ -8,7 +8,7 @@ describe Gitlab::GitalyClient::Notifications do
     subject { described_class.new(project.repository) }
 
     it 'sends a post_receive message' do
-      expect_any_instance_of(Gitaly::Notifications::Stub)
+      expect_any_instance_of(Gitaly::NotificationService::Stub)
         .to receive(:post_receive).with(gitaly_request_with_path(storage_name, relative_path), kind_of(Hash))
 
       subject.post_receive
diff --git a/spec/lib/gitlab/gitaly_client/ref_spec.rb b/spec/lib/gitlab/gitaly_client/ref_service_spec.rb
index 7c090460764..1e8ed9d645b 100644
--- a/spec/lib/gitlab/gitaly_client/ref_spec.rb
+++ b/spec/lib/gitlab/gitaly_client/ref_service_spec.rb
@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Gitlab::GitalyClient::Ref do
+describe Gitlab::GitalyClient::RefService do
   let(:project) { create(:empty_project) }
   let(:storage_name) { project.repository_storage }
   let(:relative_path) { project.path_with_namespace + '.git' }
@@ -8,7 +8,7 @@ describe Gitlab::GitalyClient::Ref do
 
   describe '#branch_names' do
     it 'sends a find_all_branch_names message' do
-      expect_any_instance_of(Gitaly::Ref::Stub)
+      expect_any_instance_of(Gitaly::RefService::Stub)
         .to receive(:find_all_branch_names)
         .with(gitaly_request_with_path(storage_name, relative_path), kind_of(Hash))
         .and_return([])
@@ -19,7 +19,7 @@ describe Gitlab::GitalyClient::Ref do
 
   describe '#tag_names' do
     it 'sends a find_all_tag_names message' do
-      expect_any_instance_of(Gitaly::Ref::Stub)
+      expect_any_instance_of(Gitaly::RefService::Stub)
         .to receive(:find_all_tag_names)
         .with(gitaly_request_with_path(storage_name, relative_path), kind_of(Hash))
         .and_return([])
@@ -30,7 +30,7 @@ describe Gitlab::GitalyClient::Ref do
 
   describe '#default_branch_name' do
     it 'sends a find_default_branch_name message' do
-      expect_any_instance_of(Gitaly::Ref::Stub)
+      expect_any_instance_of(Gitaly::RefService::Stub)
         .to receive(:find_default_branch_name)
         .with(gitaly_request_with_path(storage_name, relative_path), kind_of(Hash))
         .and_return(double(name: 'foo'))
@@ -41,7 +41,7 @@ describe Gitlab::GitalyClient::Ref do
 
   describe '#local_branches' do
     it 'sends a find_local_branches message' do
-      expect_any_instance_of(Gitaly::Ref::Stub)
+      expect_any_instance_of(Gitaly::RefService::Stub)
         .to receive(:find_local_branches)
         .with(gitaly_request_with_path(storage_name, relative_path), kind_of(Hash))
         .and_return([])
@@ -50,7 +50,7 @@ describe Gitlab::GitalyClient::Ref do
     end
 
     it 'parses and sends the sort parameter' do
-      expect_any_instance_of(Gitaly::Ref::Stub)
+      expect_any_instance_of(Gitaly::RefService::Stub)
         .to receive(:find_local_branches)
         .with(gitaly_request_with_params(sort_by: :UPDATED_DESC), kind_of(Hash))
         .and_return([])
@@ -59,7 +59,7 @@ describe Gitlab::GitalyClient::Ref do
     end
 
     it 'translates known mismatches on sort param values' do
-      expect_any_instance_of(Gitaly::Ref::Stub)
+      expect_any_instance_of(Gitaly::RefService::Stub)
         .to receive(:find_local_branches)
         .with(gitaly_request_with_params(sort_by: :NAME), kind_of(Hash))
         .and_return([])
diff --git a/spec/lib/gitlab/gitaly_client_spec.rb b/spec/lib/gitlab/gitaly_client_spec.rb
index ce7b18b784a..558ddb3fbd6 100644
--- a/spec/lib/gitlab/gitaly_client_spec.rb
+++ b/spec/lib/gitlab/gitaly_client_spec.rb
@@ -16,9 +16,9 @@ describe Gitlab::GitalyClient, lib: true, skip_gitaly_mock: true do
           'default' => { 'gitaly_address' => address }
         })
 
-        expect(Gitaly::Commit::Stub).to receive(:new).with(address, any_args)
+        expect(Gitaly::CommitService::Stub).to receive(:new).with(address, any_args)
 
-        described_class.stub(:commit, 'default')
+        described_class.stub(:commit_service, 'default')
       end
     end
 
@@ -31,9 +31,9 @@ describe Gitlab::GitalyClient, lib: true, skip_gitaly_mock: true do
           'default' => { 'gitaly_address' => prefixed_address }
         })
 
-        expect(Gitaly::Commit::Stub).to receive(:new).with(address, any_args)
+        expect(Gitaly::CommitService::Stub).to receive(:new).with(address, any_args)
 
-        described_class.stub(:commit, 'default')
+        described_class.stub(:commit_service, 'default')
       end
     end
   end
diff --git a/spec/lib/gitlab/health_checks/fs_shards_check_spec.rb b/spec/lib/gitlab/health_checks/fs_shards_check_spec.rb
index b333e162909..3de73a9ff65 100644
--- a/spec/lib/gitlab/health_checks/fs_shards_check_spec.rb
+++ b/spec/lib/gitlab/health_checks/fs_shards_check_spec.rb
@@ -109,9 +109,9 @@ describe Gitlab::HealthChecks::FsShardsCheck do
           expect(subject).to include(an_object_having_attributes(name: :filesystem_readable, value: 0))
           expect(subject).to include(an_object_having_attributes(name: :filesystem_writable, value: 0))
 
-          expect(subject).to include(an_object_having_attributes(name: :filesystem_access_latency, value: be >= 0))
-          expect(subject).to include(an_object_having_attributes(name: :filesystem_read_latency, value: be >= 0))
-          expect(subject).to include(an_object_having_attributes(name: :filesystem_write_latency, value: be >= 0))
+          expect(subject).to include(an_object_having_attributes(name: :filesystem_access_latency_seconds, value: be >= 0))
+          expect(subject).to include(an_object_having_attributes(name: :filesystem_read_latency_seconds, value: be >= 0))
+          expect(subject).to include(an_object_having_attributes(name: :filesystem_write_latency_seconds, value: be >= 0))
         end
       end
 
@@ -127,9 +127,9 @@ describe Gitlab::HealthChecks::FsShardsCheck do
           expect(subject).to include(an_object_having_attributes(name: :filesystem_readable, value: 1))
           expect(subject).to include(an_object_having_attributes(name: :filesystem_writable, value: 1))
 
-          expect(subject).to include(an_object_having_attributes(name: :filesystem_access_latency, value: be >= 0))
-          expect(subject).to include(an_object_having_attributes(name: :filesystem_read_latency, value: be >= 0))
-          expect(subject).to include(an_object_having_attributes(name: :filesystem_write_latency, value: be >= 0))
+          expect(subject).to include(an_object_having_attributes(name: :filesystem_access_latency_seconds, value: be >= 0))
+          expect(subject).to include(an_object_having_attributes(name: :filesystem_read_latency_seconds, value: be >= 0))
+          expect(subject).to include(an_object_having_attributes(name: :filesystem_write_latency_seconds, value: be >= 0))
         end
       end
     end
@@ -159,9 +159,9 @@ describe Gitlab::HealthChecks::FsShardsCheck do
         expect(subject).to include(an_object_having_attributes(name: :filesystem_readable, value: 0))
         expect(subject).to include(an_object_having_attributes(name: :filesystem_writable, value: 0))
 
-        expect(subject).to include(an_object_having_attributes(name: :filesystem_access_latency, value: be >= 0))
-        expect(subject).to include(an_object_having_attributes(name: :filesystem_read_latency, value: be >= 0))
-        expect(subject).to include(an_object_having_attributes(name: :filesystem_write_latency, value: be >= 0))
+        expect(subject).to include(an_object_having_attributes(name: :filesystem_access_latency_seconds, value: be >= 0))
+        expect(subject).to include(an_object_having_attributes(name: :filesystem_read_latency_seconds, value: be >= 0))
+        expect(subject).to include(an_object_having_attributes(name: :filesystem_write_latency_seconds, value: be >= 0))
       end
     end
   end
diff --git a/spec/lib/gitlab/health_checks/redis/cache_check_spec.rb b/spec/lib/gitlab/health_checks/redis/cache_check_spec.rb
new file mode 100644
index 00000000000..3693f52b51b
--- /dev/null
+++ b/spec/lib/gitlab/health_checks/redis/cache_check_spec.rb
@@ -0,0 +1,6 @@
+require 'spec_helper'
+require_relative '../simple_check_shared'
+
+describe Gitlab::HealthChecks::Redis::CacheCheck do
+  include_examples 'simple_check', 'redis_cache_ping', 'RedisCache', 'PONG'
+end
diff --git a/spec/lib/gitlab/health_checks/redis/queues_check_spec.rb b/spec/lib/gitlab/health_checks/redis/queues_check_spec.rb
new file mode 100644
index 00000000000..c69443d205d
--- /dev/null
+++ b/spec/lib/gitlab/health_checks/redis/queues_check_spec.rb
@@ -0,0 +1,6 @@
+require 'spec_helper'
+require_relative '../simple_check_shared'
+
+describe Gitlab::HealthChecks::Redis::QueuesCheck do
+  include_examples 'simple_check', 'redis_queues_ping', 'RedisQueues', 'PONG'
+end
diff --git a/spec/lib/gitlab/health_checks/redis/redis_check_spec.rb b/spec/lib/gitlab/health_checks/redis/redis_check_spec.rb
new file mode 100644
index 00000000000..03afc1cd761
--- /dev/null
+++ b/spec/lib/gitlab/health_checks/redis/redis_check_spec.rb
@@ -0,0 +1,6 @@
+require 'spec_helper'
+require_relative '../simple_check_shared'
+
+describe Gitlab::HealthChecks::Redis::RedisCheck do
+  include_examples 'simple_check', 'redis_ping', 'Redis', 'PONG'
+end
diff --git a/spec/lib/gitlab/health_checks/redis/shared_state_check_spec.rb b/spec/lib/gitlab/health_checks/redis/shared_state_check_spec.rb
new file mode 100644
index 00000000000..b72e152bbe2
--- /dev/null
+++ b/spec/lib/gitlab/health_checks/redis/shared_state_check_spec.rb
@@ -0,0 +1,6 @@
+require 'spec_helper'
+require_relative '../simple_check_shared'
+
+describe Gitlab::HealthChecks::Redis::SharedStateCheck do
+  include_examples 'simple_check', 'redis_shared_state_ping', 'RedisSharedState', 'PONG'
+end
diff --git a/spec/lib/gitlab/health_checks/redis_check_spec.rb b/spec/lib/gitlab/health_checks/redis_check_spec.rb
deleted file mode 100644
index 734cdcb893e..00000000000
--- a/spec/lib/gitlab/health_checks/redis_check_spec.rb
+++ /dev/null
@@ -1,6 +0,0 @@
-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/health_checks/simple_check_shared.rb b/spec/lib/gitlab/health_checks/simple_check_shared.rb
index 3f871d66034..e2643458aca 100644
--- a/spec/lib/gitlab/health_checks/simple_check_shared.rb
+++ b/spec/lib/gitlab/health_checks/simple_check_shared.rb
@@ -8,7 +8,7 @@ shared_context 'simple_check' do |metrics_prefix, check_name, success_result|
 
       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)) }
+      it { is_expected.to include(have_attributes(name: "#{metrics_prefix}_latency_seconds", value: be >= 0)) }
     end
 
     context 'Check is misbehaving' do
@@ -18,7 +18,7 @@ shared_context 'simple_check' do |metrics_prefix, check_name, success_result|
 
       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)) }
+      it { is_expected.to include(have_attributes(name: "#{metrics_prefix}_latency_seconds", value: be >= 0)) }
     end
 
     context 'Check is timeouting' do
@@ -28,7 +28,7 @@ shared_context 'simple_check' do |metrics_prefix, check_name, success_result|
 
       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)) }
+      it { is_expected.to include(have_attributes(name: "#{metrics_prefix}_latency_seconds", value: be >= 0)) }
     end
   end
 
@@ -47,7 +47,7 @@ shared_context 'simple_check' do |metrics_prefix, check_name, success_result|
         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!") }
+      it { is_expected.to have_attributes(success: false, message: "unexpected #{described_class.human_name} check result: error!") }
     end
 
     context 'Check is timeouting' do
@@ -55,7 +55,7 @@ shared_context 'simple_check' do |metrics_prefix, check_name, success_result|
         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") }
+      it { is_expected.to have_attributes(success: false, message: "#{described_class.human_name} check timed out") }
     end
   end
 
diff --git a/spec/lib/gitlab/issuable_metadata_spec.rb b/spec/lib/gitlab/issuable_metadata_spec.rb
new file mode 100644
index 00000000000..f9f4b290dbf
--- /dev/null
+++ b/spec/lib/gitlab/issuable_metadata_spec.rb
@@ -0,0 +1,59 @@
+require 'spec_helper'
+
+describe Gitlab::IssuableMetadata, lib: true do
+  let(:user)        { create(:user) }
+  let!(:project)    { create(:project, :public, :repository, creator: user, namespace: user.namespace) }
+
+  subject { Class.new { include Gitlab::IssuableMetadata }.new }
+
+  it 'returns an empty Hash if an empty collection is provided' do
+    expect(subject.issuable_meta_data(Issue.none, 'Issue')).to eq({})
+  end
+
+  context 'issues' do
+    let!(:issue) { create(:issue, author: user, project: project) }
+    let!(:closed_issue) { create(:issue, state: :closed, author: user, project: project) }
+    let!(:downvote) { create(:award_emoji, :downvote, awardable: closed_issue) }
+    let!(:upvote) { create(:award_emoji, :upvote, awardable: issue) }
+    let!(:merge_request) { create(:merge_request, :simple, author: user, assignee: user, source_project: project, target_project: project, title: "Test") }
+    let!(:closing_issues) { create(:merge_requests_closing_issues, issue: issue, merge_request: merge_request) }
+
+    it 'aggregates stats on issues' do
+      data = subject.issuable_meta_data(Issue.all, 'Issue')
+
+      expect(data.count).to eq(2)
+      expect(data[issue.id].upvotes).to eq(1)
+      expect(data[issue.id].downvotes).to eq(0)
+      expect(data[issue.id].notes_count).to eq(0)
+      expect(data[issue.id].merge_requests_count).to eq(1)
+
+      expect(data[closed_issue.id].upvotes).to eq(0)
+      expect(data[closed_issue.id].downvotes).to eq(1)
+      expect(data[closed_issue.id].notes_count).to eq(0)
+      expect(data[closed_issue.id].merge_requests_count).to eq(0)
+    end
+  end
+
+  context 'merge requests' do
+    let!(:merge_request) { create(:merge_request, :simple, author: user, assignee: user, source_project: project, target_project: project, title: "Test") }
+    let!(:merge_request_closed) { create(:merge_request, state: "closed", source_project: project, target_project: project, title: "Closed Test") }
+    let!(:downvote) { create(:award_emoji, :downvote, awardable: merge_request) }
+    let!(:upvote) { create(:award_emoji, :upvote, awardable: merge_request) }
+    let!(:note) { create(:note_on_merge_request, author: user, project: project, noteable: merge_request, note: "a comment on a MR") }
+
+    it 'aggregates stats on merge requests' do
+      data = subject.issuable_meta_data(MergeRequest.all, 'MergeRequest')
+
+      expect(data.count).to eq(2)
+      expect(data[merge_request.id].upvotes).to eq(1)
+      expect(data[merge_request.id].downvotes).to eq(1)
+      expect(data[merge_request.id].notes_count).to eq(1)
+      expect(data[merge_request.id].merge_requests_count).to eq(0)
+
+      expect(data[merge_request_closed.id].upvotes).to eq(0)
+      expect(data[merge_request_closed.id].downvotes).to eq(0)
+      expect(data[merge_request_closed.id].notes_count).to eq(0)
+      expect(data[merge_request_closed.id].merge_requests_count).to eq(0)
+    end
+  end
+end
diff --git a/spec/lib/gitlab/metrics/connection_rack_middleware_spec.rb b/spec/lib/gitlab/metrics/requests_rack_middleware_spec.rb
index 94251af305f..461b1e4182a 100644
--- a/spec/lib/gitlab/metrics/connection_rack_middleware_spec.rb
+++ b/spec/lib/gitlab/metrics/requests_rack_middleware_spec.rb
@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Gitlab::Metrics::ConnectionRackMiddleware do
+describe Gitlab::Metrics::RequestsRackMiddleware do
   let(:app) { double('app') }
   subject { described_class.new(app) }
 
@@ -22,14 +22,8 @@ describe Gitlab::Metrics::ConnectionRackMiddleware do
         allow(app).to receive(:call).and_return([200, nil, nil])
       end
 
-      it 'increments response count with status label' do
-        expect(described_class).to receive_message_chain(:rack_response_count, :increment).with(include(status: 200, method: 'get'))
-
-        subject.call(env)
-      end
-
       it 'increments requests count' do
-        expect(described_class).to receive_message_chain(:rack_request_count, :increment).with(method: 'get')
+        expect(described_class).to receive_message_chain(:http_request_total, :increment).with(method: 'get')
 
         subject.call(env)
       end
@@ -38,20 +32,21 @@ describe Gitlab::Metrics::ConnectionRackMiddleware do
         execution_time = 10
         allow(app).to receive(:call) do |*args|
           Timecop.freeze(execution_time.seconds)
+          [200, nil, nil]
         end
 
-        expect(described_class).to receive_message_chain(:rack_execution_time, :observe).with({}, execution_time)
+        expect(described_class).to receive_message_chain(:http_request_duration_seconds, :observe).with({ status: 200, method: 'get' }, execution_time)
 
         subject.call(env)
       end
     end
 
     context '@app.call throws exception' do
-      let(:rack_response_count) { double('rack_response_count') }
+      let(:http_request_duration_seconds) { double('http_request_duration_seconds') }
 
       before do
         allow(app).to receive(:call).and_raise(StandardError)
-        allow(described_class).to receive(:rack_response_count).and_return(rack_response_count)
+        allow(described_class).to receive(:http_request_duration_seconds).and_return(http_request_duration_seconds)
       end
 
       it 'increments exceptions count' do
@@ -61,25 +56,13 @@ describe Gitlab::Metrics::ConnectionRackMiddleware do
       end
 
       it 'increments requests count' do
-        expect(described_class).to receive_message_chain(:rack_request_count, :increment).with(method: 'get')
-
-        expect { subject.call(env) }.to raise_error(StandardError)
-      end
-
-      it "does't increment response count" do
-        expect(described_class.rack_response_count).not_to receive(:increment)
+        expect(described_class).to receive_message_chain(:http_request_total, :increment).with(method: 'get')
 
         expect { subject.call(env) }.to raise_error(StandardError)
       end
 
-      it 'measures execution time' do
-        execution_time = 10
-        allow(app).to receive(:call) do |*args|
-          Timecop.freeze(execution_time.seconds)
-          raise StandardError
-        end
-
-        expect(described_class).to receive_message_chain(:rack_execution_time, :observe).with({}, execution_time)
+      it "does't measure request execution time" do
+        expect(described_class.http_request_duration_seconds).not_to receive(:increment)
 
         expect { subject.call(env) }.to raise_error(StandardError)
       end
diff --git a/spec/lib/gitlab/performance_bar_spec.rb b/spec/lib/gitlab/performance_bar_spec.rb
index 8a586bdbf63..b8a2267f1a4 100644
--- a/spec/lib/gitlab/performance_bar_spec.rb
+++ b/spec/lib/gitlab/performance_bar_spec.rb
@@ -7,7 +7,7 @@ describe Gitlab::PerformanceBar do
       described_class.enabled?(user)
     end
 
-    it 'caches the allowed user IDs in cache', :caching do
+    it 'caches the allowed user IDs in cache', :use_clean_rails_memory_store_caching do
       expect do
         expect(described_class.enabled?(user)).to be_truthy
       end.not_to exceed_query_limit(0)
diff --git a/spec/lib/gitlab/redis/cache_spec.rb b/spec/lib/gitlab/redis/cache_spec.rb
new file mode 100644
index 00000000000..5a4f17cfcf6
--- /dev/null
+++ b/spec/lib/gitlab/redis/cache_spec.rb
@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe Gitlab::Redis::Cache do
+  let(:config_file_name) { "config/redis.cache.yml" }
+  let(:environment_config_file_name) { "GITLAB_REDIS_CACHE_CONFIG_FILE" }
+  let(:config_old_format_socket) { "spec/fixtures/config/redis_cache_old_format_socket.yml" }
+  let(:config_new_format_socket) { "spec/fixtures/config/redis_cache_new_format_socket.yml" }
+  let(:old_socket_path) {"/path/to/old/redis.cache.sock" }
+  let(:new_socket_path) {"/path/to/redis.cache.sock" }
+  let(:config_old_format_host) { "spec/fixtures/config/redis_cache_old_format_host.yml" }
+  let(:config_new_format_host) { "spec/fixtures/config/redis_cache_new_format_host.yml" }
+  let(:redis_port) { 6380 }
+  let(:redis_database) { 10 }
+  let(:sentinel_port) { redis_port + 20000 }
+  let(:config_with_environment_variable_inside) { "spec/fixtures/config/redis_cache_config_with_env.yml"}
+  let(:config_env_variable_url) {"TEST_GITLAB_REDIS_CACHE_URL"}
+  let(:class_redis_url) { Gitlab::Redis::Cache::DEFAULT_REDIS_CACHE_URL }
+
+  include_examples "redis_shared_examples"
+end
diff --git a/spec/lib/gitlab/redis/queues_spec.rb b/spec/lib/gitlab/redis/queues_spec.rb
new file mode 100644
index 00000000000..01ca25635a9
--- /dev/null
+++ b/spec/lib/gitlab/redis/queues_spec.rb
@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe Gitlab::Redis::Queues do
+  let(:config_file_name) { "config/redis.queues.yml" }
+  let(:environment_config_file_name) { "GITLAB_REDIS_QUEUES_CONFIG_FILE" }
+  let(:config_old_format_socket) { "spec/fixtures/config/redis_queues_old_format_socket.yml" }
+  let(:config_new_format_socket) { "spec/fixtures/config/redis_queues_new_format_socket.yml" }
+  let(:old_socket_path) {"/path/to/old/redis.queues.sock" }
+  let(:new_socket_path) {"/path/to/redis.queues.sock" }
+  let(:config_old_format_host) { "spec/fixtures/config/redis_queues_old_format_host.yml" }
+  let(:config_new_format_host) { "spec/fixtures/config/redis_queues_new_format_host.yml" }
+  let(:redis_port) { 6381 }
+  let(:redis_database) { 11 }
+  let(:sentinel_port) { redis_port + 20000 }
+  let(:config_with_environment_variable_inside) { "spec/fixtures/config/redis_queues_config_with_env.yml"}
+  let(:config_env_variable_url) {"TEST_GITLAB_REDIS_QUEUES_URL"}
+  let(:class_redis_url) { Gitlab::Redis::Queues::DEFAULT_REDIS_QUEUES_URL }
+
+  include_examples "redis_shared_examples"
+end
diff --git a/spec/lib/gitlab/redis/shared_state_spec.rb b/spec/lib/gitlab/redis/shared_state_spec.rb
new file mode 100644
index 00000000000..24b73745dc5
--- /dev/null
+++ b/spec/lib/gitlab/redis/shared_state_spec.rb
@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe Gitlab::Redis::SharedState do
+  let(:config_file_name) { "config/redis.shared_state.yml" }
+  let(:environment_config_file_name) { "GITLAB_REDIS_SHARED_STATE_CONFIG_FILE" }
+  let(:config_old_format_socket) { "spec/fixtures/config/redis_shared_state_old_format_socket.yml" }
+  let(:config_new_format_socket) { "spec/fixtures/config/redis_shared_state_new_format_socket.yml" }
+  let(:old_socket_path) {"/path/to/old/redis.shared_state.sock" }
+  let(:new_socket_path) {"/path/to/redis.shared_state.sock" }
+  let(:config_old_format_host) { "spec/fixtures/config/redis_shared_state_old_format_host.yml" }
+  let(:config_new_format_host) { "spec/fixtures/config/redis_shared_state_new_format_host.yml" }
+  let(:redis_port) { 6382 }
+  let(:redis_database) { 12 }
+  let(:sentinel_port) { redis_port + 20000 }
+  let(:config_with_environment_variable_inside) { "spec/fixtures/config/redis_shared_state_config_with_env.yml"}
+  let(:config_env_variable_url) {"TEST_GITLAB_REDIS_SHARED_STATE_URL"}
+  let(:class_redis_url) { Gitlab::Redis::SharedState::DEFAULT_REDIS_SHARED_STATE_URL }
+
+  include_examples "redis_shared_examples"
+end
diff --git a/spec/lib/gitlab/redis/wrapper_spec.rb b/spec/lib/gitlab/redis/wrapper_spec.rb
new file mode 100644
index 00000000000..e1becd0a614
--- /dev/null
+++ b/spec/lib/gitlab/redis/wrapper_spec.rb
@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe Gitlab::Redis::Wrapper do
+  let(:config_file_name) { "config/resque.yml" }
+  let(:environment_config_file_name) { "GITLAB_REDIS_CONFIG_FILE" }
+  let(:config_old_format_socket) { "spec/fixtures/config/redis_old_format_socket.yml" }
+  let(:config_new_format_socket) { "spec/fixtures/config/redis_new_format_socket.yml" }
+  let(:old_socket_path) {"/path/to/old/redis.sock" }
+  let(:new_socket_path) {"/path/to/redis.sock" }
+  let(:config_old_format_host) { "spec/fixtures/config/redis_old_format_host.yml" }
+  let(:config_new_format_host) { "spec/fixtures/config/redis_new_format_host.yml" }
+  let(:redis_port) { 6379 }
+  let(:redis_database) { 99 }
+  let(:sentinel_port) { redis_port + 20000 }
+  let(:config_with_environment_variable_inside) { "spec/fixtures/config/redis_config_with_env.yml"}
+  let(:config_env_variable_url) {"TEST_GITLAB_REDIS_URL"}
+  let(:class_redis_url) { Gitlab::Redis::Wrapper::DEFAULT_REDIS_URL }
+
+  include_examples "redis_shared_examples"
+end
diff --git a/spec/lib/gitlab/route_map_spec.rb b/spec/lib/gitlab/route_map_spec.rb
index 21c00c6e5b8..e8feb21e4d7 100644
--- a/spec/lib/gitlab/route_map_spec.rb
+++ b/spec/lib/gitlab/route_map_spec.rb
@@ -55,6 +55,19 @@ describe Gitlab::RouteMap, lib: true do
   end
 
   describe '#public_path_for_source_path' do
+    context 'malicious regexp' do
+      include_examples 'malicious regexp'
+
+      subject do
+        map = described_class.new(<<-"MAP".strip_heredoc)
+        - source: '#{malicious_regexp}'
+          public: '/'
+        MAP
+
+        map.public_path_for_source_path(malicious_text)
+      end
+    end
+
     subject do
       described_class.new(<<-'MAP'.strip_heredoc)
         # Team data
diff --git a/spec/lib/gitlab/sidekiq_status_spec.rb b/spec/lib/gitlab/sidekiq_status_spec.rb
index 496e50fbae4..c2e77ef6b6c 100644
--- a/spec/lib/gitlab/sidekiq_status_spec.rb
+++ b/spec/lib/gitlab/sidekiq_status_spec.rb
@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 describe Gitlab::SidekiqStatus do
-  describe '.set', :redis do
+  describe '.set', :clean_gitlab_redis_shared_state do
     it 'stores the job ID' do
       described_class.set('123')
 
@@ -14,7 +14,7 @@ describe Gitlab::SidekiqStatus do
     end
   end
 
-  describe '.unset', :redis do
+  describe '.unset', :clean_gitlab_redis_shared_state do
     it 'removes the job ID' do
       described_class.set('123')
       described_class.unset('123')
@@ -27,7 +27,7 @@ describe Gitlab::SidekiqStatus do
     end
   end
 
-  describe '.all_completed?', :redis do
+  describe '.all_completed?', :clean_gitlab_redis_shared_state do
     it 'returns true if all jobs have been completed' do
       expect(described_class.all_completed?(%w(123))).to eq(true)
     end
@@ -39,7 +39,7 @@ describe Gitlab::SidekiqStatus do
     end
   end
 
-  describe '.num_running', :redis do
+  describe '.num_running', :clean_gitlab_redis_shared_state do
     it 'returns 0 if all jobs have been completed' do
       expect(described_class.num_running(%w(123))).to eq(0)
     end
@@ -52,7 +52,7 @@ describe Gitlab::SidekiqStatus do
     end
   end
 
-  describe '.num_completed', :redis do
+  describe '.num_completed', :clean_gitlab_redis_shared_state do
     it 'returns 1 if all jobs have been completed' do
       expect(described_class.num_completed(%w(123))).to eq(1)
     end
@@ -74,7 +74,7 @@ describe Gitlab::SidekiqStatus do
     end
   end
 
-  describe 'completed', :redis do
+  describe 'completed', :clean_gitlab_redis_shared_state do
     it 'returns the completed job' do
       expect(described_class.completed_jids(%w(123))).to eq(['123'])
     end
diff --git a/spec/lib/gitlab/untrusted_regexp_spec.rb b/spec/lib/gitlab/untrusted_regexp_spec.rb
new file mode 100644
index 00000000000..66045917cb3
--- /dev/null
+++ b/spec/lib/gitlab/untrusted_regexp_spec.rb
@@ -0,0 +1,80 @@
+require 'spec_helper'
+
+describe Gitlab::UntrustedRegexp do
+  describe '#initialize' do
+    subject { described_class.new(pattern) }
+
+    context 'invalid regexp' do
+      let(:pattern) { '[' }
+
+      it { expect { subject }.to raise_error(RegexpError) }
+    end
+  end
+
+  describe '#replace_all' do
+    it 'replaces all instances of the match in a string' do
+      result = described_class.new('foo').replace_all('foo bar foo', 'oof')
+
+      expect(result).to eq('oof bar oof')
+    end
+  end
+
+  describe '#replace' do
+    it 'replaces the first instance of the match in a string' do
+      result = described_class.new('foo').replace('foo bar foo', 'oof')
+
+      expect(result).to eq('oof bar foo')
+    end
+  end
+
+  describe '#===' do
+    it 'returns true for a match' do
+      result = described_class.new('foo') === 'a foo here'
+
+      expect(result).to be_truthy
+    end
+
+    it 'returns false for no match' do
+      result = described_class.new('foo') === 'a bar here'
+
+      expect(result).to be_falsy
+    end
+  end
+
+  describe '#scan' do
+    subject { described_class.new(regexp).scan(text) }
+    context 'malicious regexp' do
+      let(:text) { malicious_text }
+      let(:regexp) { malicious_regexp }
+ 
+      include_examples 'malicious regexp'
+    end
+
+    context 'no capture group' do
+      let(:regexp) { '.+' }
+      let(:text) { 'foo' }
+
+      it 'returns the whole match' do
+        is_expected.to eq(['foo'])
+      end
+    end
+
+    context 'one capture group' do
+      let(:regexp) { '(f).+' }
+      let(:text) { 'foo' }
+
+      it 'returns the captured part' do
+        is_expected.to eq([%w[f]])
+      end
+    end
+
+    context 'two capture groups' do
+      let(:regexp) { '(f).(o)' }
+      let(:text) { 'foo' }
+
+      it 'returns the captured parts' do
+        is_expected.to eq([%w[f o]])
+      end
+    end
+  end
+end
diff --git a/spec/lib/gitlab/usage_data_spec.rb b/spec/lib/gitlab/usage_data_spec.rb
index c6718827028..daf097f8d51 100644
--- a/spec/lib/gitlab/usage_data_spec.rb
+++ b/spec/lib/gitlab/usage_data_spec.rb
@@ -48,6 +48,7 @@ describe Gitlab::UsageData do
         milestones
         notes
         projects
+        projects_imported_from_github
         projects_prometheus_active
         pages_domains
         protected_branches
diff --git a/spec/lib/gitlab/user_activities_spec.rb b/spec/lib/gitlab/user_activities_spec.rb
index 187d88c8c58..a4ea0ac59e9 100644
--- a/spec/lib/gitlab/user_activities_spec.rb
+++ b/spec/lib/gitlab/user_activities_spec.rb
@@ -1,27 +1,27 @@
 require 'spec_helper'
 
-describe Gitlab::UserActivities, :redis, lib: true do
+describe Gitlab::UserActivities, :clean_gitlab_redis_shared_state, lib: true do
   let(:now) { Time.now }
 
   describe '.record' do
     context 'with no time given' do
-      it 'uses Time.now and records an activity in Redis' do
+      it 'uses Time.now and records an activity in SharedState' do
         Timecop.freeze do
           now # eager-load now
           described_class.record(42)
         end
 
-        Gitlab::Redis.with do |redis|
+        Gitlab::Redis::SharedState.with do |redis|
           expect(redis.hscan(described_class::KEY, 0)).to eq(['0', [['42', now.to_i.to_s]]])
         end
       end
     end
 
     context 'with a time given' do
-      it 'uses the given time and records an activity in Redis' do
+      it 'uses the given time and records an activity in SharedState' do
         described_class.record(42, now)
 
-        Gitlab::Redis.with do |redis|
+        Gitlab::Redis::SharedState.with do |redis|
           expect(redis.hscan(described_class::KEY, 0)).to eq(['0', [['42', now.to_i.to_s]]])
         end
       end
@@ -31,30 +31,30 @@ describe Gitlab::UserActivities, :redis, lib: true do
   describe '.delete' do
     context 'with a single key' do
       context 'and key exists' do
-        it 'removes the pair from Redis' do
+        it 'removes the pair from SharedState' do
           described_class.record(42, now)
 
-          Gitlab::Redis.with do |redis|
+          Gitlab::Redis::SharedState.with do |redis|
             expect(redis.hscan(described_class::KEY, 0)).to eq(['0', [['42', now.to_i.to_s]]])
           end
 
           subject.delete(42)
 
-          Gitlab::Redis.with do |redis|
+          Gitlab::Redis::SharedState.with do |redis|
             expect(redis.hscan(described_class::KEY, 0)).to eq(['0', []])
           end
         end
       end
 
       context 'and key does not exist' do
-        it 'removes the pair from Redis' do
-          Gitlab::Redis.with do |redis|
+        it 'removes the pair from SharedState' do
+          Gitlab::Redis::SharedState.with do |redis|
             expect(redis.hscan(described_class::KEY, 0)).to eq(['0', []])
           end
 
           subject.delete(42)
 
-          Gitlab::Redis.with do |redis|
+          Gitlab::Redis::SharedState.with do |redis|
             expect(redis.hscan(described_class::KEY, 0)).to eq(['0', []])
           end
         end
@@ -63,33 +63,33 @@ describe Gitlab::UserActivities, :redis, lib: true do
 
     context 'with multiple keys' do
       context 'and all keys exist' do
-        it 'removes the pair from Redis' do
+        it 'removes the pair from SharedState' do
           described_class.record(41, now)
           described_class.record(42, now)
 
-          Gitlab::Redis.with do |redis|
+          Gitlab::Redis::SharedState.with do |redis|
             expect(redis.hscan(described_class::KEY, 0)).to eq(['0', [['41', now.to_i.to_s], ['42', now.to_i.to_s]]])
           end
 
           subject.delete(41, 42)
 
-          Gitlab::Redis.with do |redis|
+          Gitlab::Redis::SharedState.with do |redis|
             expect(redis.hscan(described_class::KEY, 0)).to eq(['0', []])
           end
         end
       end
 
       context 'and some keys does not exist' do
-        it 'removes the existing pair from Redis' do
+        it 'removes the existing pair from SharedState' do
           described_class.record(42, now)
 
-          Gitlab::Redis.with do |redis|
+          Gitlab::Redis::SharedState.with do |redis|
             expect(redis.hscan(described_class::KEY, 0)).to eq(['0', [['42', now.to_i.to_s]]])
           end
 
           subject.delete(41, 42)
 
-          Gitlab::Redis.with do |redis|
+          Gitlab::Redis::SharedState.with do |redis|
             expect(redis.hscan(described_class::KEY, 0)).to eq(['0', []])
           end
         end
diff --git a/spec/lib/gitlab/workhorse_spec.rb b/spec/lib/gitlab/workhorse_spec.rb
index 493ff3bb5fb..124f66a6e0e 100644
--- a/spec/lib/gitlab/workhorse_spec.rb
+++ b/spec/lib/gitlab/workhorse_spec.rb
@@ -276,7 +276,7 @@ describe Gitlab::Workhorse, lib: true do
       end
 
       it 'set and notify' do
-        expect_any_instance_of(Redis).to receive(:publish)
+        expect_any_instance_of(::Redis).to receive(:publish)
           .with(described_class::NOTIFICATION_CHANNEL, "test-key=test-value")
 
         subject
@@ -310,11 +310,49 @@ describe Gitlab::Workhorse, lib: true do
         end
 
         it 'does not notify' do
-          expect_any_instance_of(Redis).not_to receive(:publish)
+          expect_any_instance_of(::Redis).not_to receive(:publish)
 
           subject
         end
       end
     end
   end
+
+  describe '.send_git_blob' do
+    include FakeBlobHelpers
+
+    let(:blob) { fake_blob }
+
+    subject { described_class.send_git_blob(repository, blob) }
+
+    context 'when Gitaly project_raw_show feature is enabled' do
+      it 'sets the header correctly' do
+        key, command, params = decode_workhorse_header(subject)
+
+        expect(key).to eq('Gitlab-Workhorse-Send-Data')
+        expect(command).to eq('git-blob')
+        expect(params).to eq({
+          'GitalyServer' => {
+            address: Gitlab::GitalyClient.address(project.repository_storage),
+            token: Gitlab::GitalyClient.token(project.repository_storage)
+          },
+          'GetBlobRequest' => {
+            repository: repository.gitaly_repository.to_h,
+            oid: blob.id,
+            limit: -1
+          }
+        }.deep_stringify_keys)
+      end
+    end
+
+    context 'when Gitaly project_raw_show feature is disabled', skip_gitaly_mock: true do
+      it 'sets the header correctly' do
+        key, command, params = decode_workhorse_header(subject)
+
+        expect(key).to eq('Gitlab-Workhorse-Send-Data')
+        expect(command).to eq('git-blob')
+        expect(params).to eq('RepoPath' => repository.path_to_repo, 'BlobId' => blob.id)
+      end
+    end
+  end
 end
diff --git a/spec/migrations/add_foreign_key_to_merge_requests_spec.rb b/spec/migrations/add_foreign_key_to_merge_requests_spec.rb
new file mode 100644
index 00000000000..d9ad9a585f0
--- /dev/null
+++ b/spec/migrations/add_foreign_key_to_merge_requests_spec.rb
@@ -0,0 +1,39 @@
+require 'spec_helper'
+require Rails.root.join('db', 'migrate', '20170713104829_add_foreign_key_to_merge_requests.rb')
+
+describe AddForeignKeyToMergeRequests, :migration do
+  let(:projects) { table(:projects) }
+  let(:merge_requests) { table(:merge_requests) }
+  let(:pipelines) { table(:ci_pipelines) }
+
+  before do
+    projects.create!(name: 'gitlab', path: 'gitlab-org/gitlab-ce')
+    pipelines.create!(project_id: projects.first.id,
+                      ref: 'some-branch',
+                      sha: 'abc12345')
+
+    # merge request without a pipeline
+    create_merge_request(head_pipeline_id: nil)
+
+    # merge request with non-existent pipeline
+    create_merge_request(head_pipeline_id: 1234)
+
+    # merge reqeust with existing pipeline assigned
+    create_merge_request(head_pipeline_id: pipelines.first.id)
+  end
+
+  it 'correctly adds a foreign key to head_pipeline_id' do
+    migrate!
+
+    expect(merge_requests.first.head_pipeline_id).to be_nil
+    expect(merge_requests.second.head_pipeline_id).to be_nil
+    expect(merge_requests.third.head_pipeline_id).to eq pipelines.first.id
+  end
+
+  def create_merge_request(**opts)
+    merge_requests.create!(source_project_id: projects.first.id,
+                           target_project_id: projects.first.id,
+                           source_branch: 'some-branch',
+                           target_branch: 'master', **opts)
+  end
+end
diff --git a/spec/migrations/clean_appearance_symlinks_spec.rb b/spec/migrations/clean_appearance_symlinks_spec.rb
new file mode 100644
index 00000000000..9225dc0d894
--- /dev/null
+++ b/spec/migrations/clean_appearance_symlinks_spec.rb
@@ -0,0 +1,46 @@
+require 'spec_helper'
+require Rails.root.join('db', 'post_migrate', '20170613111224_clean_appearance_symlinks.rb')
+
+describe CleanAppearanceSymlinks do
+  let(:migration) { described_class.new }
+  let(:test_dir) { File.join(Rails.root, "tmp", "tests", "clean_appearance_test") }
+  let(:uploads_dir) { File.join(test_dir, "public", "uploads") }
+  let(:new_uploads_dir) { File.join(uploads_dir, "system") }
+  let(:original_path) { File.join(new_uploads_dir, 'appearance') }
+  let(:symlink_path) { File.join(uploads_dir, 'appearance') }
+
+  before do
+    FileUtils.remove_dir(test_dir) if File.directory?(test_dir)
+    FileUtils.mkdir_p(uploads_dir)
+    allow(migration).to receive(:base_directory).and_return(test_dir)
+    allow(migration).to receive(:say)
+  end
+
+  describe "#up" do
+    before do
+      FileUtils.mkdir_p(original_path)
+      FileUtils.ln_s(original_path, symlink_path)
+    end
+
+    it 'removes the symlink' do
+      migration.up
+
+      expect(File.symlink?(symlink_path)).to be(false)
+    end
+  end
+
+  describe '#down' do
+    before do
+      FileUtils.mkdir_p(File.join(original_path))
+      FileUtils.touch(File.join(original_path, 'dummy.file'))
+    end
+
+    it 'creates a symlink' do
+      expected_path = File.join(symlink_path, "dummy.file")
+      migration.down
+
+      expect(File.exist?(expected_path)).to be(true)
+      expect(File.symlink?(symlink_path)).to be(true)
+    end
+  end
+end
diff --git a/spec/migrations/cleanup_move_system_upload_folder_symlink_spec.rb b/spec/migrations/cleanup_move_system_upload_folder_symlink_spec.rb
new file mode 100644
index 00000000000..3a9fa8c7113
--- /dev/null
+++ b/spec/migrations/cleanup_move_system_upload_folder_symlink_spec.rb
@@ -0,0 +1,35 @@
+require 'spec_helper'
+require Rails.root.join("db", "post_migrate", "20170717111152_cleanup_move_system_upload_folder_symlink.rb")
+
+describe CleanupMoveSystemUploadFolderSymlink do
+  let(:migration) { described_class.new }
+  let(:test_base) { File.join(Rails.root, 'tmp', 'tests', 'move-system-upload-folder') }
+  let(:test_folder) { File.join(test_base, '-', 'system') }
+
+  before do
+    allow(migration).to receive(:base_directory).and_return(test_base)
+    FileUtils.rm_rf(test_base)
+    FileUtils.mkdir_p(test_folder)
+    allow(migration).to receive(:say)
+  end
+
+  describe '#up' do
+    before do
+      FileUtils.ln_s(test_folder, File.join(test_base, 'system'))
+    end
+
+    it 'removes the symlink' do
+      migration.up
+
+      expect(File.exist?(File.join(test_base, 'system'))).to be_falsey
+    end
+  end
+
+  describe '#down' do
+    it 'creates the symlink' do
+      migration.down
+
+      expect(File.symlink?(File.join(test_base, 'system'))).to be_truthy
+    end
+  end
+end
diff --git a/spec/migrations/migrate_process_commit_worker_jobs_spec.rb b/spec/migrations/migrate_process_commit_worker_jobs_spec.rb
index 4223d2337a8..5b633dd349b 100644
--- a/spec/migrations/migrate_process_commit_worker_jobs_spec.rb
+++ b/spec/migrations/migrate_process_commit_worker_jobs_spec.rb
@@ -54,7 +54,7 @@ describe MigrateProcessCommitWorkerJobs do
     end
   end
 
-  describe '#up', :redis do
+  describe '#up', :clean_gitlab_redis_shared_state do
     let(:migration) { described_class.new }
 
     def job_count
@@ -172,7 +172,7 @@ describe MigrateProcessCommitWorkerJobs do
     end
   end
 
-  describe '#down', :redis do
+  describe '#down', :clean_gitlab_redis_shared_state do
     let(:migration) { described_class.new }
 
     def job_count
diff --git a/spec/migrations/migrate_user_activities_to_users_last_activity_on_spec.rb b/spec/migrations/migrate_user_activities_to_users_last_activity_on_spec.rb
index e3b42b5eac8..063829be546 100644
--- a/spec/migrations/migrate_user_activities_to_users_last_activity_on_spec.rb
+++ b/spec/migrations/migrate_user_activities_to_users_last_activity_on_spec.rb
@@ -3,13 +3,13 @@
 require 'spec_helper'
 require Rails.root.join('db', 'post_migrate', '20170324160416_migrate_user_activities_to_users_last_activity_on.rb')
 
-describe MigrateUserActivitiesToUsersLastActivityOn, :redis, :truncate do
+describe MigrateUserActivitiesToUsersLastActivityOn, :clean_gitlab_redis_shared_state, :truncate do
   let(:migration) { described_class.new }
   let!(:user_active_1) { create(:user) }
   let!(:user_active_2) { create(:user) }
 
   def record_activity(user, time)
-    Gitlab::Redis.with do |redis|
+    Gitlab::Redis::SharedState.with do |redis|
       redis.zadd(described_class::USER_ACTIVITY_SET_KEY, time.to_i, user.username)
     end
   end
diff --git a/spec/migrations/move_personal_snippets_files_spec.rb b/spec/migrations/move_personal_snippets_files_spec.rb
new file mode 100644
index 00000000000..8505c7bf3e3
--- /dev/null
+++ b/spec/migrations/move_personal_snippets_files_spec.rb
@@ -0,0 +1,180 @@
+require 'spec_helper'
+require Rails.root.join('db', 'post_migrate', '20170612071012_move_personal_snippets_files.rb')
+
+describe MovePersonalSnippetsFiles do
+  let(:migration) { described_class.new }
+  let(:test_dir) { File.join(Rails.root, "tmp", "tests", "move_snippet_files_test") }
+  let(:uploads_dir) { File.join(test_dir, 'uploads') }
+  let(:new_uploads_dir) { File.join(uploads_dir, 'system') }
+
+  before do
+    allow(CarrierWave).to receive(:root).and_return(test_dir)
+    allow(migration).to receive(:base_directory).and_return(test_dir)
+    FileUtils.remove_dir(test_dir) if File.directory?(test_dir)
+    allow(migration).to receive(:say)
+  end
+
+  describe "#up" do
+    let(:snippet) do
+      snippet = create(:personal_snippet)
+      create_upload('picture.jpg', snippet)
+      snippet.update(description: markdown_linking_file('picture.jpg', snippet))
+      snippet
+    end
+
+    let(:snippet_with_missing_file) do
+      snippet = create(:snippet)
+      create_upload('picture.jpg', snippet, create_file: false)
+      snippet.update(description: markdown_linking_file('picture.jpg', snippet))
+      snippet
+    end
+
+    it 'moves the files' do
+      source_path = File.join(uploads_dir, model_file_path('picture.jpg', snippet))
+      destination_path = File.join(new_uploads_dir, model_file_path('picture.jpg', snippet))
+
+      migration.up
+
+      expect(File.exist?(source_path)).to be_falsy
+      expect(File.exist?(destination_path)).to be_truthy
+    end
+
+    describe 'updating the markdown' do
+      it 'includes the new path when the file exists' do
+        secret = "secret#{snippet.id}"
+        file_location = "/uploads/system/personal_snippet/#{snippet.id}/#{secret}/picture.jpg"
+
+        migration.up
+
+        expect(snippet.reload.description).to include(file_location)
+      end
+
+      it 'does not update the markdown when the file is missing' do
+        secret = "secret#{snippet_with_missing_file.id}"
+        file_location = "/uploads/personal_snippet/#{snippet_with_missing_file.id}/#{secret}/picture.jpg"
+
+        migration.up
+
+        expect(snippet_with_missing_file.reload.description).to include(file_location)
+      end
+
+      it 'updates the note markdown' do
+        secret = "secret#{snippet.id}"
+        file_location = "/uploads/system/personal_snippet/#{snippet.id}/#{secret}/picture.jpg"
+        markdown = markdown_linking_file('picture.jpg', snippet)
+        note = create(:note_on_personal_snippet, noteable: snippet, note: "with #{markdown}")
+
+        migration.up
+
+        expect(note.reload.note).to include(file_location)
+      end
+    end
+  end
+
+  describe "#down" do
+    let(:snippet) do
+      snippet = create(:personal_snippet)
+      create_upload('picture.jpg', snippet, in_new_path: true)
+      snippet.update(description: markdown_linking_file('picture.jpg', snippet, in_new_path: true))
+      snippet
+    end
+
+    let(:snippet_with_missing_file) do
+      snippet = create(:personal_snippet)
+      create_upload('picture.jpg', snippet, create_file: false, in_new_path: true)
+      snippet.update(description: markdown_linking_file('picture.jpg', snippet, in_new_path: true))
+      snippet
+    end
+
+    it 'moves the files' do
+      source_path = File.join(new_uploads_dir, model_file_path('picture.jpg', snippet))
+      destination_path = File.join(uploads_dir, model_file_path('picture.jpg', snippet))
+
+      migration.down
+
+      expect(File.exist?(source_path)).to be_falsey
+      expect(File.exist?(destination_path)).to be_truthy
+    end
+
+    describe 'updating the markdown' do
+      it 'includes the new path when the file exists' do
+        secret = "secret#{snippet.id}"
+        file_location = "/uploads/personal_snippet/#{snippet.id}/#{secret}/picture.jpg"
+
+        migration.down
+
+        expect(snippet.reload.description).to include(file_location)
+      end
+
+      it 'keeps the markdown as is when the file is missing' do
+        secret = "secret#{snippet_with_missing_file.id}"
+        file_location = "/uploads/system/personal_snippet/#{snippet_with_missing_file.id}/#{secret}/picture.jpg"
+
+        migration.down
+
+        expect(snippet_with_missing_file.reload.description).to include(file_location)
+      end
+
+      it 'updates the note markdown' do
+        markdown = markdown_linking_file('picture.jpg', snippet, in_new_path: true)
+        secret = "secret#{snippet.id}"
+        file_location = "/uploads/personal_snippet/#{snippet.id}/#{secret}/picture.jpg"
+        note = create(:note_on_personal_snippet, noteable: snippet, note: "with #{markdown}")
+
+        migration.down
+
+        expect(note.reload.note).to include(file_location)
+      end
+    end
+  end
+
+  describe '#update_markdown' do
+    it 'escapes sql in the snippet description' do
+      migration.instance_variable_set('@source_relative_location', '/uploads/personal_snippet')
+      migration.instance_variable_set('@destination_relative_location', '/uploads/system/personal_snippet')
+
+      secret = '123456789'
+      filename = 'hello.jpg'
+      snippet = create(:personal_snippet)
+
+      path_before = "/uploads/personal_snippet/#{snippet.id}/#{secret}/#{filename}"
+      path_after = "/uploads/system/personal_snippet/#{snippet.id}/#{secret}/#{filename}"
+      description_before = "Hello world; ![image](#{path_before})'; select * from users;"
+      description_after = "Hello world; ![image](#{path_after})'; select * from users;"
+
+      migration.update_markdown(snippet.id, secret, filename, description_before)
+
+      expect(snippet.reload.description).to eq(description_after)
+    end
+  end
+
+  def create_upload(filename, snippet, create_file: true, in_new_path: false)
+    secret = "secret#{snippet.id}"
+    absolute_path = if in_new_path
+                      File.join(new_uploads_dir, model_file_path(filename, snippet))
+                    else
+                      File.join(uploads_dir, model_file_path(filename, snippet))
+                    end
+
+    if create_file
+      FileUtils.mkdir_p(File.dirname(absolute_path))
+      FileUtils.touch(absolute_path)
+    end
+
+    create(:upload, model: snippet, path: "#{secret}/#{filename}", uploader: PersonalFileUploader)
+  end
+
+  def markdown_linking_file(filename, snippet, in_new_path: false)
+    markdown =  "![#{filename.split('.')[0]}]"
+    markdown += '(/uploads'
+    markdown += '/system' if in_new_path
+    markdown += "/#{model_file_path(filename, snippet)})"
+    markdown
+  end
+
+  def model_file_path(filename, snippet)
+    secret = "secret#{snippet.id}"
+
+    File.join('personal_snippet', snippet.id.to_s, secret, filename)
+  end
+end
diff --git a/spec/migrations/move_system_upload_folder_spec.rb b/spec/migrations/move_system_upload_folder_spec.rb
new file mode 100644
index 00000000000..b622b4e9536
--- /dev/null
+++ b/spec/migrations/move_system_upload_folder_spec.rb
@@ -0,0 +1,62 @@
+require 'spec_helper'
+require Rails.root.join("db", "migrate", "20170717074009_move_system_upload_folder.rb")
+
+describe MoveSystemUploadFolder do
+  let(:migration) { described_class.new }
+  let(:test_base) { File.join(Rails.root, 'tmp', 'tests', 'move-system-upload-folder') }
+
+  before do
+    allow(migration).to receive(:base_directory).and_return(test_base)
+    FileUtils.rm_rf(test_base)
+    FileUtils.mkdir_p(test_base)
+    allow(migration).to receive(:say)
+  end
+
+  describe '#up' do
+    let(:test_folder) { File.join(test_base, 'system') }
+    let(:test_file) { File.join(test_folder, 'file') }
+
+    before do
+      FileUtils.mkdir_p(test_folder)
+      FileUtils.touch(test_file)
+    end
+
+    it 'moves the related folder' do
+      migration.up
+
+      expect(File.exist?(File.join(test_base, '-', 'system', 'file'))).to be_truthy
+    end
+
+    it 'creates a symlink linking making the new folder available on the old path' do
+      migration.up
+
+      expect(File.symlink?(File.join(test_base, 'system'))).to be_truthy
+      expect(File.exist?(File.join(test_base, 'system', 'file'))).to be_truthy
+    end
+  end
+
+  describe '#down' do
+    let(:test_folder) { File.join(test_base, '-', 'system') }
+    let(:test_file) { File.join(test_folder, 'file') }
+
+    before do
+      FileUtils.mkdir_p(test_folder)
+      FileUtils.touch(test_file)
+    end
+
+    it 'moves the system folder back to the old location' do
+      migration.down
+
+      expect(File.exist?(File.join(test_base, 'system', 'file'))).to be_truthy
+    end
+
+    it 'removes the symlink if it existed' do
+      FileUtils.ln_s(test_folder, File.join(test_base, 'system'))
+
+      migration.down
+
+      expect(File.directory?(File.join(test_base, 'system'))).to be_truthy
+      expect(File.symlink?(File.join(test_base, 'system'))).to be_falsey
+    end
+  end
+end
diff --git a/spec/models/application_setting_spec.rb b/spec/models/application_setting_spec.rb
index fb485d0b2c6..e600eab6565 100644
--- a/spec/models/application_setting_spec.rb
+++ b/spec/models/application_setting_spec.rb
@@ -155,6 +155,18 @@ describe ApplicationSetting, models: true do
     end
   end
 
+  describe '.current' do
+    context 'redis unavailable' do
+      it 'returns an ApplicationSetting' do
+        allow(Rails.cache).to receive(:fetch).and_call_original
+        allow(ApplicationSetting).to receive(:last).and_return(:last)
+        expect(Rails.cache).to receive(:fetch).with(ApplicationSetting::CACHE_KEY).and_raise(ArgumentError)
+
+        expect(ApplicationSetting.current).to eq(:last)
+      end
+    end
+  end
+
   context 'restricted signup domains' do
     it 'sets single domain' do
       setting.domain_whitelist_raw = 'example.com'
diff --git a/spec/models/ci/runner_spec.rb b/spec/models/ci/runner_spec.rb
index 76ce558eea0..4b9cce28e0e 100644
--- a/spec/models/ci/runner_spec.rb
+++ b/spec/models/ci/runner_spec.rb
@@ -276,14 +276,14 @@ describe Ci::Runner, models: true do
     it 'sets a new last_update value when it is called the first time' do
       last_update = runner.ensure_runner_queue_value
 
-      expect_value_in_redis.to eq(last_update)
+      expect_value_in_queues.to eq(last_update)
     end
 
     it 'does not change if it is not expired and called again' do
       last_update = runner.ensure_runner_queue_value
 
       expect(runner.ensure_runner_queue_value).to eq(last_update)
-      expect_value_in_redis.to eq(last_update)
+      expect_value_in_queues.to eq(last_update)
     end
 
     context 'updates runner queue after changing editable value' do
@@ -294,7 +294,7 @@ describe Ci::Runner, models: true do
       end
 
       it 'sets a new last_update value' do
-        expect_value_in_redis.not_to eq(last_update)
+        expect_value_in_queues.not_to eq(last_update)
       end
     end
 
@@ -306,12 +306,12 @@ describe Ci::Runner, models: true do
       end
 
       it 'has an old last_update value' do
-        expect_value_in_redis.to eq(last_update)
+        expect_value_in_queues.to eq(last_update)
       end
     end
 
-    def expect_value_in_redis
-      Gitlab::Redis.with do |redis|
+    def expect_value_in_queues
+      Gitlab::Redis::Queues.with do |redis|
         runner_queue_key = runner.send(:runner_queue_key)
         expect(redis.get(runner_queue_key))
       end
@@ -330,7 +330,7 @@ describe Ci::Runner, models: true do
       end
 
       it 'cleans up the queue' do
-        Gitlab::Redis.with do |redis|
+        Gitlab::Redis::Queues.with do |redis|
           expect(redis.get(queue_key)).to be_nil
         end
       end
diff --git a/spec/models/commit_spec.rb b/spec/models/commit_spec.rb
index 6056d78da4e..528b211c9d6 100644
--- a/spec/models/commit_spec.rb
+++ b/spec/models/commit_spec.rb
@@ -19,17 +19,15 @@ describe Commit, models: true do
       expect(commit.author).to eq(user)
     end
 
-    it 'caches the author' do
-      allow(RequestStore).to receive(:active?).and_return(true)
+    it 'caches the author', :request_store do
       user = create(:user, email: commit.author_email)
-      expect_any_instance_of(Commit).to receive(:find_author_by_any_email).and_call_original
+      expect(User).to receive(:find_by_any_email).and_call_original
 
       expect(commit.author).to eq(user)
-      key = "commit_author:#{commit.author_email}"
+      key = "Commit:author:#{commit.author_email.downcase}"
       expect(RequestStore.store[key]).to eq(user)
 
       expect(commit.author).to eq(user)
-      RequestStore.store.clear
     end
   end
 
diff --git a/spec/models/concerns/reactive_caching_spec.rb b/spec/models/concerns/reactive_caching_spec.rb
index 808247ebfd5..5f9b7e0a367 100644
--- a/spec/models/concerns/reactive_caching_spec.rb
+++ b/spec/models/concerns/reactive_caching_spec.rb
@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe ReactiveCaching, caching: true do
+describe ReactiveCaching, :use_clean_rails_memory_store_caching do
   include ReactiveCachingHelpers
 
   class CacheTest
diff --git a/spec/models/concerns/sortable_spec.rb b/spec/models/concerns/sortable_spec.rb
deleted file mode 100644
index d1e17c4f684..00000000000
--- a/spec/models/concerns/sortable_spec.rb
+++ /dev/null
@@ -1,21 +0,0 @@
-require 'spec_helper'
-
-describe Sortable do
-  let(:relation) { Issue.all }
-
-  describe '#where' do
-    it 'orders by id, descending' do
-      order_node = relation.where(iid: 1).order_values.first
-      expect(order_node).to be_a(Arel::Nodes::Descending)
-      expect(order_node.expr.name).to eq(:id)
-    end
-  end
-
-  describe '#find_by' do
-    it 'does not order' do
-      expect(relation).to receive(:unscope).with(:order).and_call_original
-
-      relation.find_by(iid: 1)
-    end
-  end
-end
diff --git a/spec/models/group_spec.rb b/spec/models/group_spec.rb
index 066d7b9307f..770176451fe 100644
--- a/spec/models/group_spec.rb
+++ b/spec/models/group_spec.rb
@@ -189,7 +189,7 @@ describe Group, models: true do
     let!(:group) { create(:group, :access_requestable, :with_avatar) }
     let(:user) { create(:user) }
     let(:gitlab_host) { "http://#{Gitlab.config.gitlab.host}" }
-    let(:avatar_path) { "/uploads/system/group/avatar/#{group.id}/dk.png" }
+    let(:avatar_path) { "/uploads/-/system/group/avatar/#{group.id}/dk.png" }
 
     context 'when avatar file is uploaded' do
       before do
diff --git a/spec/models/namespace_spec.rb b/spec/models/namespace_spec.rb
index 62c4ea01ce1..a4090b37f65 100644
--- a/spec/models/namespace_spec.rb
+++ b/spec/models/namespace_spec.rb
@@ -44,7 +44,7 @@ describe Namespace, models: true do
       end
 
       context "is case insensitive" do
-        let(:group) { build(:group, path: "System") }
+        let(:group) { build(:group, path: "Groups") }
 
         it { expect(group).not_to be_valid }
       end
@@ -63,6 +63,14 @@ describe Namespace, models: true do
     it { is_expected.to respond_to(:has_parent?) }
   end
 
+  describe 'inclusions' do
+    it { is_expected.to include_module(Gitlab::VisibilityLevel) }
+  end
+
+  describe '#visibility_level_field' do
+    it { expect(namespace.visibility_level_field).to eq(:visibility_level) }
+  end
+
   describe '#to_param' do
     it { expect(namespace.to_param).to eq(namespace.full_path) }
   end
diff --git a/spec/models/project_services/bamboo_service_spec.rb b/spec/models/project_services/bamboo_service_spec.rb
index 7b1a554d1fb..99190d763f2 100644
--- a/spec/models/project_services/bamboo_service_spec.rb
+++ b/spec/models/project_services/bamboo_service_spec.rb
@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe BambooService, models: true, caching: true do
+describe BambooService, :use_clean_rails_memory_store_caching, models: true do
   include ReactiveCachingHelpers
 
   let(:bamboo_url) { 'http://gitlab.com/bamboo' }
diff --git a/spec/models/project_services/buildkite_service_spec.rb b/spec/models/project_services/buildkite_service_spec.rb
index dd529597067..b4ee6691e67 100644
--- a/spec/models/project_services/buildkite_service_spec.rb
+++ b/spec/models/project_services/buildkite_service_spec.rb
@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe BuildkiteService, models: true, caching: true do
+describe BuildkiteService, :use_clean_rails_memory_store_caching, models: true do
   include ReactiveCachingHelpers
 
   let(:project) { create(:empty_project) }
diff --git a/spec/models/project_services/drone_ci_service_spec.rb b/spec/models/project_services/drone_ci_service_spec.rb
index 1400175427f..c9ac256ff38 100644
--- a/spec/models/project_services/drone_ci_service_spec.rb
+++ b/spec/models/project_services/drone_ci_service_spec.rb
@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe DroneCiService, models: true, caching: true do
+describe DroneCiService, :use_clean_rails_memory_store_caching, models: true do
   include ReactiveCachingHelpers
 
   describe 'associations' do
diff --git a/spec/models/project_services/gitlab_issue_tracker_service_spec.rb b/spec/models/project_services/gitlab_issue_tracker_service_spec.rb
index dcb70ee28a8..d45e0a441d4 100644
--- a/spec/models/project_services/gitlab_issue_tracker_service_spec.rb
+++ b/spec/models/project_services/gitlab_issue_tracker_service_spec.rb
@@ -23,38 +23,29 @@ describe GitlabIssueTrackerService, models: true do
 
   describe 'project and issue urls' do
     let(:project) { create(:empty_project) }
+    let(:service) { project.create_gitlab_issue_tracker_service(active: true) }
 
     context 'with absolute urls' do
       before do
-        GitlabIssueTrackerService.default_url_options[:script_name] = "/gitlab/root"
-        @service = project.create_gitlab_issue_tracker_service(active: true)
-      end
-
-      after do
-        @service.destroy!
+        allow(GitlabIssueTrackerService).to receive(:default_url_options).and_return(script_name: "/gitlab/root")
       end
 
       it 'gives the correct path' do
-        expect(@service.project_url).to eq("http://#{Gitlab.config.gitlab.host}/gitlab/root/#{project.path_with_namespace}/issues")
-        expect(@service.new_issue_url).to eq("http://#{Gitlab.config.gitlab.host}/gitlab/root/#{project.path_with_namespace}/issues/new")
-        expect(@service.issue_url(432)).to eq("http://#{Gitlab.config.gitlab.host}/gitlab/root/#{project.path_with_namespace}/issues/432")
+        expect(service.project_url).to eq("http://#{Gitlab.config.gitlab.host}/gitlab/root/#{project.path_with_namespace}/issues")
+        expect(service.new_issue_url).to eq("http://#{Gitlab.config.gitlab.host}/gitlab/root/#{project.path_with_namespace}/issues/new")
+        expect(service.issue_url(432)).to eq("http://#{Gitlab.config.gitlab.host}/gitlab/root/#{project.path_with_namespace}/issues/432")
       end
     end
 
     context 'with relative urls' do
       before do
-        GitlabIssueTrackerService.default_url_options[:script_name] = "/gitlab/root"
-        @service = project.create_gitlab_issue_tracker_service(active: true)
-      end
-
-      after do
-        @service.destroy!
+        allow(GitlabIssueTrackerService).to receive(:default_url_options).and_return(script_name: "/gitlab/root")
       end
 
       it 'gives the correct path' do
-        expect(@service.project_path).to eq("/gitlab/root/#{project.path_with_namespace}/issues")
-        expect(@service.new_issue_path).to eq("/gitlab/root/#{project.path_with_namespace}/issues/new")
-        expect(@service.issue_path(432)).to eq("/gitlab/root/#{project.path_with_namespace}/issues/432")
+        expect(service.issue_tracker_path).to eq("/gitlab/root/#{project.path_with_namespace}/issues")
+        expect(service.new_issue_path).to eq("/gitlab/root/#{project.path_with_namespace}/issues/new")
+        expect(service.issue_path(432)).to eq("/gitlab/root/#{project.path_with_namespace}/issues/432")
       end
     end
   end
diff --git a/spec/models/project_services/kubernetes_service_spec.rb b/spec/models/project_services/kubernetes_service_spec.rb
index 5ba523a478a..b66bb5321ab 100644
--- a/spec/models/project_services/kubernetes_service_spec.rb
+++ b/spec/models/project_services/kubernetes_service_spec.rb
@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe KubernetesService, models: true, caching: true do
+describe KubernetesService, :use_clean_rails_memory_store_caching, models: true do
   include KubernetesHelpers
   include ReactiveCachingHelpers
 
diff --git a/spec/models/project_services/prometheus_service_spec.rb b/spec/models/project_services/prometheus_service_spec.rb
index 37f23b1243c..3fb134ec3b7 100644
--- a/spec/models/project_services/prometheus_service_spec.rb
+++ b/spec/models/project_services/prometheus_service_spec.rb
@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe PrometheusService, models: true, caching: true do
+describe PrometheusService, :use_clean_rails_memory_store_caching, models: true do
   include PrometheusHelpers
   include ReactiveCachingHelpers
 
diff --git a/spec/models/project_services/teamcity_service_spec.rb b/spec/models/project_services/teamcity_service_spec.rb
index 6b004098510..3f3a74d0f96 100644
--- a/spec/models/project_services/teamcity_service_spec.rb
+++ b/spec/models/project_services/teamcity_service_spec.rb
@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe TeamcityService, models: true, caching: true do
+describe TeamcityService, :use_clean_rails_memory_store_caching, models: true do
   include ReactiveCachingHelpers
 
   let(:teamcity_url) { 'http://gitlab.com/teamcity' }
diff --git a/spec/models/project_spec.rb b/spec/models/project_spec.rb
index 99bfab70088..90769b580cd 100644
--- a/spec/models/project_spec.rb
+++ b/spec/models/project_spec.rb
@@ -807,7 +807,7 @@ describe Project, models: true do
 
     context 'when avatar file is uploaded' do
       let(:project) { create(:empty_project, :with_avatar) }
-      let(:avatar_path) { "/uploads/system/project/avatar/#{project.id}/dk.png" }
+      let(:avatar_path) { "/uploads/-/system/project/avatar/#{project.id}/dk.png" }
       let(:gitlab_host) { "http://#{Gitlab.config.gitlab.host}" }
 
       it 'shows correct url' do
@@ -899,7 +899,7 @@ describe Project, models: true do
     end
   end
 
-  describe '.cached_count', caching: true do
+  describe '.cached_count', :use_clean_rails_memory_store_caching do
     let(:group)     { create(:group, :public) }
     let!(:project1) { create(:empty_project, :public, group: group) }
     let!(:project2) { create(:empty_project, :public, group: group) }
@@ -1236,7 +1236,7 @@ describe Project, models: true do
 
       subject { project.rename_repo }
 
-      it { expect{subject}.to raise_error(Exception) }
+      it { expect{subject}.to raise_error(StandardError) }
     end
   end
 
diff --git a/spec/models/repository_spec.rb b/spec/models/repository_spec.rb
index af305e9b234..7635b0868e7 100644
--- a/spec/models/repository_spec.rb
+++ b/spec/models/repository_spec.rb
@@ -561,7 +561,7 @@ describe Repository, models: true do
     end
   end
 
-  describe "#changelog", caching: true do
+  describe "#changelog", :use_clean_rails_memory_store_caching do
     it 'accepts changelog' do
       expect(repository.tree).to receive(:blobs).and_return([TestBlob.new('changelog')])
 
@@ -593,7 +593,7 @@ describe Repository, models: true do
     end
   end
 
-  describe "#license_blob", caching: true do
+  describe "#license_blob", :use_clean_rails_memory_store_caching do
     before do
       repository.delete_file(
         user, 'LICENSE', message: 'Remove LICENSE', branch_name: 'master')
@@ -638,7 +638,7 @@ describe Repository, models: true do
     end
   end
 
-  describe '#license_key', caching: true do
+  describe '#license_key', :use_clean_rails_memory_store_caching do
     before do
       repository.delete_file(user, 'LICENSE',
         message: 'Remove LICENSE', branch_name: 'master')
@@ -703,7 +703,7 @@ describe Repository, models: true do
     end
   end
 
-  describe "#gitlab_ci_yml", caching: true do
+  describe "#gitlab_ci_yml", :use_clean_rails_memory_store_caching do
     it 'returns valid file' do
       files = [TestBlob.new('file'), TestBlob.new('.gitlab-ci.yml'), TestBlob.new('copying')]
       expect(repository.tree).to receive(:blobs).and_return(files)
@@ -1611,7 +1611,7 @@ describe Repository, models: true do
     end
   end
 
-  describe '#contribution_guide', caching: true do
+  describe '#contribution_guide', :use_clean_rails_memory_store_caching do
     it 'returns and caches the output' do
       expect(repository).to receive(:file_on_head)
         .with(:contributing)
@@ -1625,7 +1625,7 @@ describe Repository, models: true do
     end
   end
 
-  describe '#gitignore', caching: true do
+  describe '#gitignore', :use_clean_rails_memory_store_caching do
     it 'returns and caches the output' do
       expect(repository).to receive(:file_on_head)
         .with(:gitignore)
@@ -1638,7 +1638,7 @@ describe Repository, models: true do
     end
   end
 
-  describe '#koding_yml', caching: true do
+  describe '#koding_yml', :use_clean_rails_memory_store_caching do
     it 'returns and caches the output' do
       expect(repository).to receive(:file_on_head)
         .with(:koding)
@@ -1651,7 +1651,7 @@ describe Repository, models: true do
     end
   end
 
-  describe '#readme', caching: true do
+  describe '#readme', :use_clean_rails_memory_store_caching do
     context 'with a non-existing repository' do
       it 'returns nil' do
         allow(repository).to receive(:tree).with(:head).and_return(nil)
@@ -1822,7 +1822,7 @@ describe Repository, models: true do
     end
   end
 
-  describe '#cache_method_output', caching: true do
+  describe '#cache_method_output', :use_clean_rails_memory_store_caching do
     context 'with a non-existing repository' do
       let(:value) do
         repository.cache_method_output(:cats, fallback: 10) do
diff --git a/spec/models/user_spec.rb b/spec/models/user_spec.rb
index 448555d2190..a1d6d7e6e0b 100644
--- a/spec/models/user_spec.rb
+++ b/spec/models/user_spec.rb
@@ -348,7 +348,7 @@ describe User, models: true do
     end
   end
 
-  describe '#update_tracked_fields!', :redis do
+  describe '#update_tracked_fields!', :clean_gitlab_redis_shared_state do
     let(:request) { OpenStruct.new(remote_ip: "127.0.0.1") }
     let(:user) { create(:user) }
 
@@ -763,7 +763,7 @@ describe User, models: true do
       end
 
       it 'returns users with a partially matching name' do
-        expect(described_class.search(user.name[0..2])).to eq([user2, user])
+        expect(described_class.search(user.name[0..2])).to eq([user, user2])
       end
 
       it 'returns users with a matching name regardless of the casing' do
@@ -777,7 +777,7 @@ describe User, models: true do
       end
 
       it 'returns users with a partially matching Email' do
-        expect(described_class.search(user.email[0..2])).to eq([user2, user])
+        expect(described_class.search(user.email[0..2])).to eq([user, user2])
       end
 
       it 'returns users with a matching Email regardless of the casing' do
@@ -791,7 +791,7 @@ describe User, models: true do
       end
 
       it 'returns users with a partially matching username' do
-        expect(described_class.search(user.username[0..2])).to eq([user2, user])
+        expect(described_class.search(user.username[0..2])).to eq([user, user2])
       end
 
       it 'returns users with a matching username regardless of the casing' do
@@ -1028,7 +1028,7 @@ describe User, models: true do
 
     context 'when avatar file is uploaded' do
       let(:gitlab_host) { "http://#{Gitlab.config.gitlab.host}" }
-      let(:avatar_path) { "/uploads/system/user/avatar/#{user.id}/dk.png" }
+      let(:avatar_path) { "/uploads/-/system/user/avatar/#{user.id}/dk.png" }
 
       it 'shows correct avatar url' do
         expect(user.avatar_url).to eq(avatar_path)
@@ -1159,6 +1159,18 @@ describe User, models: true do
     end
   end
 
+  describe '#sanitize_attrs' do
+    let(:user) { build(:user, name: 'test & user', skype: 'test&user') }
+
+    it 'encodes HTML entities in the Skype attribute' do
+      expect { user.sanitize_attrs }.to change { user.skype }.to('test&amp;user')
+    end
+
+    it 'does not encode HTML entities in the name attribute' do
+      expect { user.sanitize_attrs }.not_to change { user.name }
+    end
+  end
+
   describe '#starred?' do
     it 'determines if user starred a project' do
       user = create :user
@@ -1684,7 +1696,7 @@ describe User, models: true do
     end
   end
 
-  describe '#refresh_authorized_projects', redis: true do
+  describe '#refresh_authorized_projects', clean_gitlab_redis_shared_state: true do
     let(:project1) { create(:empty_project) }
     let(:project2) { create(:empty_project) }
     let(:user) { create(:user) }
@@ -1920,4 +1932,26 @@ describe User, models: true do
       user.invalidate_merge_request_cache_counts
     end
   end
+
+  describe '#allow_password_authentication?' do
+    context 'regular user' do
+      let(:user) { build(:user) }
+
+      it 'returns true when sign-in is enabled' do
+        expect(user.allow_password_authentication?).to be_truthy
+      end
+
+      it 'returns false when sign-in is disabled' do
+        stub_application_setting(password_authentication_enabled: false)
+
+        expect(user.allow_password_authentication?).to be_falsey
+      end
+    end
+
+    it 'returns false for ldap user' do
+      user = create(:omniauth_user, provider: 'ldapmain')
+
+      expect(user.allow_password_authentication?).to be_falsey
+    end
+  end
 end
diff --git a/spec/policies/ci/build_policy_spec.rb b/spec/policies/ci/build_policy_spec.rb
index ace95ac7067..9f3212b1a63 100644
--- a/spec/policies/ci/build_policy_spec.rb
+++ b/spec/policies/ci/build_policy_spec.rb
@@ -103,12 +103,7 @@ describe Ci::BuildPolicy, :models do
         project.add_developer(user)
       end
 
-      context 'when branch build is assigned to is protected' do
-        before do
-          create(:protected_branch, :no_one_can_push,
-                 name: 'some-ref', project: project)
-        end
-
+      shared_examples 'protected ref' do
         context 'when build is a manual action' do
           let(:build) do
             create(:ci_build, :manual, ref: 'some-ref', pipeline: pipeline)
@@ -130,6 +125,43 @@ describe Ci::BuildPolicy, :models do
         end
       end
 
+      context 'when build is against a protected branch' do
+        before do
+          create(:protected_branch, :no_one_can_push,
+                 name: 'some-ref', project: project)
+        end
+
+        it_behaves_like 'protected ref'
+      end
+
+      context 'when build is against a protected tag' do
+        before do
+          create(:protected_tag, :no_one_can_create,
+                 name: 'some-ref', project: project)
+
+          build.update(tag: true)
+        end
+
+        it_behaves_like 'protected ref'
+      end
+
+      context 'when build is against a protected tag but it is not a tag' do
+        before do
+          create(:protected_tag, :no_one_can_create,
+                 name: 'some-ref', project: project)
+        end
+
+        context 'when build is a manual action' do
+          let(:build) do
+            create(:ci_build, :manual, ref: 'some-ref', pipeline: pipeline)
+          end
+
+          it 'includes ability to update build' do
+            expect(policy).to be_allowed :update_build
+          end
+        end
+      end
+
       context 'when branch build is assigned to is not protected' do
         context 'when build is a manual action' do
           let(:build) { create(:ci_build, :manual, pipeline: pipeline) }
diff --git a/spec/presenters/merge_request_presenter_spec.rb b/spec/presenters/merge_request_presenter_spec.rb
index f5a14b1d04d..c1a0313b13c 100644
--- a/spec/presenters/merge_request_presenter_spec.rb
+++ b/spec/presenters/merge_request_presenter_spec.rb
@@ -332,7 +332,31 @@ describe MergeRequestPresenter do
       end
     end
 
-    context 'when target branch does not exists' do
+    context 'when target branch does not exist' do
+      it 'returns nil' do
+        allow(resource).to receive(:target_branch_exists?) { false }
+
+        is_expected.to be_nil
+      end
+    end
+  end
+
+  describe '#target_branch_tree_path' do
+    subject do
+      described_class.new(resource, current_user: user)
+        .target_branch_tree_path
+    end
+
+    context 'when target branch exists' do
+      it 'returns path' do
+        allow(resource).to receive(:target_branch_exists?) { true }
+
+        is_expected
+          .to eq("/#{resource.target_project.full_path}/tree/#{resource.target_branch}")
+      end
+    end
+
+    context 'when target branch does not exist' do
       it 'returns nil' do
         allow(resource).to receive(:target_branch_exists?) { false }
 
@@ -355,7 +379,7 @@ describe MergeRequestPresenter do
       end
     end
 
-    context 'when source branch does not exists' do
+    context 'when source branch does not exist' do
       it 'returns nil' do
         allow(resource).to receive(:source_branch_exists?) { false }
 
@@ -363,4 +387,17 @@ describe MergeRequestPresenter do
       end
     end
   end
+
+  describe '#source_branch_with_namespace_link' do
+    subject do
+      described_class.new(resource, current_user: user).source_branch_with_namespace_link
+    end
+
+    it 'returns link' do
+      allow(resource).to receive(:source_branch_exists?) { true }
+
+      is_expected
+        .to eq("<a href=\"/#{resource.source_project.full_path}/tree/#{resource.source_branch}\">#{resource.source_branch}</a>")
+    end
+  end
 end
diff --git a/spec/requests/api/internal_spec.rb b/spec/requests/api/internal_spec.rb
index cde4fa888a0..cab3089c6b1 100644
--- a/spec/requests/api/internal_spec.rb
+++ b/spec/requests/api/internal_spec.rb
@@ -35,6 +35,17 @@ describe API::Internal do
         expect(json_response).to be_empty
       end
     end
+
+    context 'nil broadcast message' do
+      it 'returns nothing' do
+        allow(BroadcastMessage).to receive(:current).and_return(nil)
+
+        get api('/internal/broadcast_message'), secret_token: secret_token
+
+        expect(response).to have_http_status(200)
+        expect(json_response).to be_empty
+      end
+    end
   end
 
   describe 'GET /internal/broadcast_messages' do
@@ -168,7 +179,7 @@ describe API::Internal do
     end
   end
 
-  describe "POST /internal/allowed", :redis do
+  describe "POST /internal/allowed", :clean_gitlab_redis_shared_state do
     context "access granted" do
       before do
         project.team << [user, :developer]
@@ -583,10 +594,10 @@ describe API::Internal do
   #   end
   #
   #   it "calls the Gitaly client with the project's repository" do
-  #     expect(Gitlab::GitalyClient::Notifications).
+  #     expect(Gitlab::GitalyClient::NotificationService).
   #       to receive(:new).with(gitlab_git_repository_with(path: project.repository.path)).
   #       and_call_original
-  #     expect_any_instance_of(Gitlab::GitalyClient::Notifications).
+  #     expect_any_instance_of(Gitlab::GitalyClient::NotificationService).
   #       to receive(:post_receive)
   #
   #     post api("/internal/notify_post_receive"), valid_params
@@ -595,10 +606,10 @@ describe API::Internal do
   #   end
   #
   #   it "calls the Gitaly client with the wiki's repository if it's a wiki" do
-  #     expect(Gitlab::GitalyClient::Notifications).
+  #     expect(Gitlab::GitalyClient::NotificationService).
   #       to receive(:new).with(gitlab_git_repository_with(path: project.wiki.repository.path)).
   #       and_call_original
-  #     expect_any_instance_of(Gitlab::GitalyClient::Notifications).
+  #     expect_any_instance_of(Gitlab::GitalyClient::NotificationService).
   #       to receive(:post_receive)
   #
   #     post api("/internal/notify_post_receive"), valid_wiki_params
@@ -607,7 +618,7 @@ describe API::Internal do
   #   end
   #
   #   it "returns 500 if the gitaly call fails" do
-  #     expect_any_instance_of(Gitlab::GitalyClient::Notifications).
+  #     expect_any_instance_of(Gitlab::GitalyClient::NotificationService).
   #       to receive(:post_receive).and_raise(GRPC::Unavailable)
   #
   #     post api("/internal/notify_post_receive"), valid_params
@@ -625,10 +636,10 @@ describe API::Internal do
   #     end
   #
   #     it "calls the Gitaly client with the project's repository" do
-  #       expect(Gitlab::GitalyClient::Notifications).
+  #       expect(Gitlab::GitalyClient::NotificationService).
   #         to receive(:new).with(gitlab_git_repository_with(path: project.repository.path)).
   #         and_call_original
-  #       expect_any_instance_of(Gitlab::GitalyClient::Notifications).
+  #       expect_any_instance_of(Gitlab::GitalyClient::NotificationService).
   #         to receive(:post_receive)
   #
   #       post api("/internal/notify_post_receive"), valid_params
@@ -637,10 +648,10 @@ describe API::Internal do
   #     end
   #
   #     it "calls the Gitaly client with the wiki's repository if it's a wiki" do
-  #       expect(Gitlab::GitalyClient::Notifications).
+  #       expect(Gitlab::GitalyClient::NotificationService).
   #         to receive(:new).with(gitlab_git_repository_with(path: project.wiki.repository.path)).
   #         and_call_original
-  #       expect_any_instance_of(Gitlab::GitalyClient::Notifications).
+  #       expect_any_instance_of(Gitlab::GitalyClient::NotificationService).
   #         to receive(:post_receive)
   #
   #       post api("/internal/notify_post_receive"), valid_wiki_params
diff --git a/spec/requests/api/merge_requests_spec.rb b/spec/requests/api/merge_requests_spec.rb
index 4d0bd67c571..9098ae6bcda 100644
--- a/spec/requests/api/merge_requests_spec.rb
+++ b/spec/requests/api/merge_requests_spec.rb
@@ -16,7 +16,11 @@ describe API::MergeRequests do
   let!(:label) do
     create(:label, title: 'label', color: '#FFAABB', project: project)
   end
+  let!(:label2) { create(:label, title: 'a-test', color: '#FFFFFF', project: project) }
   let!(:label_link) { create(:label_link, label: label, target: merge_request) }
+  let!(:label_link2) { create(:label_link, label: label2, target: merge_request) }
+  let!(:downvote) { create(:award_emoji, :downvote, awardable: merge_request) }
+  let!(:upvote) { create(:award_emoji, :upvote, awardable: merge_request) }
 
   before do
     project.team << [user, :reporter]
@@ -32,6 +36,18 @@ describe API::MergeRequests do
     end
 
     context "when authenticated" do
+      it 'avoids N+1 queries' do
+        control_count = ActiveRecord::QueryRecorder.new do
+          get api("/projects/#{project.id}/merge_requests", user)
+        end.count
+
+        create(:merge_request, state: 'closed', milestone: milestone1, author: user, assignee: user, source_project: project, target_project: project, title: "Test", created_at: base_time)
+
+        expect do
+          get api("/projects/#{project.id}/merge_requests", user)
+        end.not_to exceed_query_limit(control_count)
+      end
+
       it "returns an array of all merge_requests" do
         get api("/projects/#{project.id}/merge_requests", user)
 
@@ -44,12 +60,31 @@ describe API::MergeRequests do
         expect(json_response.last['sha']).to eq(merge_request.diff_head_sha)
         expect(json_response.last['merge_commit_sha']).to be_nil
         expect(json_response.last['merge_commit_sha']).to eq(merge_request.merge_commit_sha)
+        expect(json_response.last['downvotes']).to eq(1)
+        expect(json_response.last['upvotes']).to eq(1)
+        expect(json_response.last['labels']).to eq([label2.title, label.title])
         expect(json_response.first['title']).to eq(merge_request_merged.title)
         expect(json_response.first['sha']).to eq(merge_request_merged.diff_head_sha)
         expect(json_response.first['merge_commit_sha']).not_to be_nil
         expect(json_response.first['merge_commit_sha']).to eq(merge_request_merged.merge_commit_sha)
       end
 
+      it "returns an array of all merge_requests using simple mode" do
+        get api("/projects/#{project.id}/merge_requests?view=simple", user)
+
+        expect(response).to have_http_status(200)
+        expect(response).to include_pagination_headers
+        expect(json_response.last.keys).to match_array(%w(id iid title web_url created_at description project_id state updated_at))
+        expect(json_response).to be_an Array
+        expect(json_response.length).to eq(3)
+        expect(json_response.last['iid']).to eq(merge_request.iid)
+        expect(json_response.last['title']).to eq(merge_request.title)
+        expect(json_response.last).to have_key('web_url')
+        expect(json_response.first['iid']).to eq(merge_request_merged.iid)
+        expect(json_response.first['title']).to eq(merge_request_merged.title)
+        expect(json_response.first).to have_key('web_url')
+      end
+
       it "returns an array of all merge_requests" do
         get api("/projects/#{project.id}/merge_requests?state", user)
 
@@ -145,7 +180,7 @@ describe API::MergeRequests do
         expect(response).to have_http_status(200)
         expect(json_response).to be_an Array
         expect(json_response.length).to eq(1)
-        expect(json_response.first['labels']).to eq([label.title])
+        expect(json_response.first['labels']).to eq([label2.title, label.title])
       end
 
       it 'returns an array of labeled merge requests where all labels match' do
@@ -236,8 +271,8 @@ describe API::MergeRequests do
       expect(json_response['author']).to be_a Hash
       expect(json_response['target_branch']).to eq(merge_request.target_branch)
       expect(json_response['source_branch']).to eq(merge_request.source_branch)
-      expect(json_response['upvotes']).to eq(0)
-      expect(json_response['downvotes']).to eq(0)
+      expect(json_response['upvotes']).to eq(1)
+      expect(json_response['downvotes']).to eq(1)
       expect(json_response['source_project_id']).to eq(merge_request.source_project.id)
       expect(json_response['target_project_id']).to eq(merge_request.target_project.id)
       expect(json_response['work_in_progress']).to be_falsy
diff --git a/spec/requests/api/projects_spec.rb b/spec/requests/api/projects_spec.rb
index fa704f23857..6dbde8bad31 100644
--- a/spec/requests/api/projects_spec.rb
+++ b/spec/requests/api/projects_spec.rb
@@ -442,7 +442,7 @@ describe API::Projects do
       post api('/projects', user), project
 
       project_id = json_response['id']
-      expect(json_response['avatar_url']).to eq("http://localhost/uploads/system/project/avatar/#{project_id}/banana_sample.gif")
+      expect(json_response['avatar_url']).to eq("http://localhost/uploads/-/system/project/avatar/#{project_id}/banana_sample.gif")
     end
 
     it 'sets a project as allowing merge even if build fails' do
diff --git a/spec/requests/api/settings_spec.rb b/spec/requests/api/settings_spec.rb
index ede48b1c888..b71ac6c30b5 100644
--- a/spec/requests/api/settings_spec.rb
+++ b/spec/requests/api/settings_spec.rb
@@ -10,7 +10,7 @@ describe API::Settings, 'Settings' do
       expect(response).to have_http_status(200)
       expect(json_response).to be_an Hash
       expect(json_response['default_projects_limit']).to eq(42)
-      expect(json_response['signin_enabled']).to be_truthy
+      expect(json_response['password_authentication_enabled']).to be_truthy
       expect(json_response['repository_storage']).to eq('default')
       expect(json_response['koding_enabled']).to be_falsey
       expect(json_response['koding_url']).to be_nil
@@ -32,7 +32,7 @@ describe API::Settings, 'Settings' do
       it "updates application settings" do
         put api("/application/settings", admin),
           default_projects_limit: 3,
-          signin_enabled: false,
+          password_authentication_enabled: false,
           repository_storage: 'custom',
           koding_enabled: true,
           koding_url: 'http://koding.example.com',
@@ -46,7 +46,7 @@ describe API::Settings, 'Settings' do
           help_page_support_url: 'http://example.com/help'
         expect(response).to have_http_status(200)
         expect(json_response['default_projects_limit']).to eq(3)
-        expect(json_response['signin_enabled']).to be_falsey
+        expect(json_response['password_authentication_enabled']).to be_falsey
         expect(json_response['repository_storage']).to eq('custom')
         expect(json_response['repository_storages']).to eq(['custom'])
         expect(json_response['koding_enabled']).to be_truthy
diff --git a/spec/requests/api/users_spec.rb b/spec/requests/api/users_spec.rb
index c34b88f0741..877bde3b9a6 100644
--- a/spec/requests/api/users_spec.rb
+++ b/spec/requests/api/users_spec.rb
@@ -943,11 +943,11 @@ describe API::Users do
           expect(response).to have_http_status(403)
         end
 
-        it 'returns initial current user without private token when sudo not defined' do
+        it 'returns initial current user without private token but with is_admin when sudo not defined' do
           get api("/user?private_token=#{admin_personal_access_token}")
 
           expect(response).to have_http_status(200)
-          expect(response).to match_response_schema('public_api/v4/user/public')
+          expect(response).to match_response_schema('public_api/v4/user/admin')
           expect(json_response['id']).to eq(admin.id)
         end
       end
@@ -961,11 +961,11 @@ describe API::Users do
           expect(json_response['id']).to eq(user.id)
         end
 
-        it 'returns initial current user without private token when sudo not defined' do
+        it 'returns initial current user without private token but with is_admin when sudo not defined' do
           get api("/user?private_token=#{admin.private_token}")
 
           expect(response).to have_http_status(200)
-          expect(response).to match_response_schema('public_api/v4/user/public')
+          expect(response).to match_response_schema('public_api/v4/user/admin')
           expect(json_response['id']).to eq(admin.id)
         end
       end
@@ -1313,7 +1313,7 @@ describe API::Users do
     end
   end
 
-  context "user activities", :redis do
+  context "user activities", :clean_gitlab_redis_shared_state do
     let!(:old_active_user) { create(:user, last_activity_on: Time.utc(2000, 1, 1)) }
     let!(:newly_active_user) { create(:user, last_activity_on: 2.days.ago.midday) }
 
diff --git a/spec/requests/api/v3/settings_spec.rb b/spec/requests/api/v3/settings_spec.rb
index 41d039b7da0..291f6dcc2aa 100644
--- a/spec/requests/api/v3/settings_spec.rb
+++ b/spec/requests/api/v3/settings_spec.rb
@@ -10,7 +10,7 @@ describe API::V3::Settings, 'Settings' do
       expect(response).to have_http_status(200)
       expect(json_response).to be_an Hash
       expect(json_response['default_projects_limit']).to eq(42)
-      expect(json_response['signin_enabled']).to be_truthy
+      expect(json_response['password_authentication_enabled']).to be_truthy
       expect(json_response['repository_storage']).to eq('default')
       expect(json_response['koding_enabled']).to be_falsey
       expect(json_response['koding_url']).to be_nil
@@ -28,11 +28,11 @@ describe API::V3::Settings, 'Settings' do
 
       it "updates application settings" do
         put v3_api("/application/settings", admin),
-          default_projects_limit: 3, signin_enabled: false, repository_storage: 'custom', koding_enabled: true, koding_url: 'http://koding.example.com',
+          default_projects_limit: 3, password_authentication_enabled: false, repository_storage: 'custom', koding_enabled: true, koding_url: 'http://koding.example.com',
           plantuml_enabled: true, plantuml_url: 'http://plantuml.example.com'
         expect(response).to have_http_status(200)
         expect(json_response['default_projects_limit']).to eq(3)
-        expect(json_response['signin_enabled']).to be_falsey
+        expect(json_response['password_authentication_enabled']).to be_falsey
         expect(json_response['repository_storage']).to eq('custom')
         expect(json_response['repository_storages']).to eq(['custom'])
         expect(json_response['koding_enabled']).to be_truthy
diff --git a/spec/requests/api/version_spec.rb b/spec/requests/api/version_spec.rb
index 8870d48bbc9..7bbf34422b8 100644
--- a/spec/requests/api/version_spec.rb
+++ b/spec/requests/api/version_spec.rb
@@ -6,7 +6,7 @@ describe API::Version do
       it 'returns authentication error' do
         get api('/version')
 
-        expect(response).to have_http_status(401)
+        expect(response).to have_gitlab_http_status(401)
       end
     end
 
@@ -16,7 +16,7 @@ describe API::Version do
       it 'returns the version information' do
         get api('/version', user)
 
-        expect(response).to have_http_status(200)
+        expect(response).to have_gitlab_http_status(200)
         expect(json_response['version']).to eq(Gitlab::VERSION)
         expect(json_response['revision']).to eq(Gitlab::REVISION)
       end
diff --git a/spec/requests/git_http_spec.rb b/spec/requests/git_http_spec.rb
index 185679e1a0f..d043ab2a974 100644
--- a/spec/requests/git_http_spec.rb
+++ b/spec/requests/git_http_spec.rb
@@ -406,7 +406,7 @@ describe 'Git HTTP requests', lib: true do
                   end
                 end
 
-                it 'updates the user last activity', :redis do
+                it 'updates the user last activity', :clean_gitlab_redis_shared_state do
                   expect(user_activity(user)).to be_nil
 
                   download(path, env) do |response|
@@ -463,7 +463,7 @@ describe 'Git HTTP requests', lib: true do
 
               context 'when internal auth is disabled' do
                 before do
-                  allow_any_instance_of(ApplicationSetting).to receive(:signin_enabled?) { false }
+                  allow_any_instance_of(ApplicationSetting).to receive(:password_authentication_enabled?) { false }
                 end
 
                 it 'rejects pulls with personal access token error message' do
diff --git a/spec/requests/jwt_controller_spec.rb b/spec/requests/jwt_controller_spec.rb
index 5e4cf05748e..8d79ea3dd40 100644
--- a/spec/requests/jwt_controller_spec.rb
+++ b/spec/requests/jwt_controller_spec.rb
@@ -101,7 +101,7 @@ describe JwtController do
 
       context 'when internal auth is disabled' do
         it 'rejects the authorization attempt with personal access token message' do
-          allow_any_instance_of(ApplicationSetting).to receive(:signin_enabled?) { false }
+          allow_any_instance_of(ApplicationSetting).to receive(:password_authentication_enabled?) { false }
           get '/jwt/auth', parameters, headers
 
           expect(response).to have_http_status(401)
diff --git a/spec/requests/openid_connect_spec.rb b/spec/requests/openid_connect_spec.rb
index 6d1f0b24196..a927de952d0 100644
--- a/spec/requests/openid_connect_spec.rb
+++ b/spec/requests/openid_connect_spec.rb
@@ -79,7 +79,7 @@ describe 'OpenID Connect requests' do
           'email_verified' => true,
           'website'        => 'https://example.com',
           'profile'        => 'http://localhost/alice',
-          'picture'        => "http://localhost/uploads/system/user/avatar/#{user.id}/dk.png"
+          'picture'        => "http://localhost/uploads/-/system/user/avatar/#{user.id}/dk.png"
         })
       end
     end
@@ -98,7 +98,7 @@ describe 'OpenID Connect requests' do
         expect(@payload['sub']).to eq hashed_subject
       end
 
-      it 'includes the time of the last authentication', :redis do
+      it 'includes the time of the last authentication', :clean_gitlab_redis_shared_state do
         expect(@payload['auth_time']).to eq user.current_sign_in_at.to_i
       end
 
diff --git a/spec/rubocop/cop/migration/hash_index_spec.rb b/spec/rubocop/cop/migration/hash_index_spec.rb
new file mode 100644
index 00000000000..9a8576a19e5
--- /dev/null
+++ b/spec/rubocop/cop/migration/hash_index_spec.rb
@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+require 'rubocop'
+require 'rubocop/rspec/support'
+
+require_relative '../../../../rubocop/cop/migration/hash_index'
+
+describe RuboCop::Cop::Migration::HashIndex do
+  include CopHelper
+
+  subject(:cop) { described_class.new }
+
+  context 'in migration' do
+    before do
+      allow(cop).to receive(:in_migration?).and_return(true)
+    end
+
+    it 'registers an offense when creating a hash index' do
+      inspect_source(cop, 'def change; add_index :table, :column, using: :hash; end')
+
+      aggregate_failures do
+        expect(cop.offenses.size).to eq(1)
+        expect(cop.offenses.map(&:line)).to eq([1])
+      end
+    end
+
+    it 'registers an offense when creating a concurrent hash index' do
+      inspect_source(cop, 'def change; add_concurrent_index :table, :column, using: :hash; end')
+
+      aggregate_failures do
+        expect(cop.offenses.size).to eq(1)
+        expect(cop.offenses.map(&:line)).to eq([1])
+      end
+    end
+
+    it 'registers an offense when creating a hash index using t.index' do
+      inspect_source(cop, 'def change; t.index :table, :column, using: :hash; end')
+
+      aggregate_failures do
+        expect(cop.offenses.size).to eq(1)
+        expect(cop.offenses.map(&:line)).to eq([1])
+      end
+    end
+  end
+
+  context 'outside of migration' do
+    it 'registers no offense' do
+      inspect_source(cop, 'def change; index :table, :column, using: :hash; end')
+
+      expect(cop.offenses.size).to eq(0)
+    end
+  end
+end
diff --git a/spec/serializers/merge_request_entity_spec.rb b/spec/serializers/merge_request_entity_spec.rb
index d38433c2365..b3d58b2636f 100644
--- a/spec/serializers/merge_request_entity_spec.rb
+++ b/spec/serializers/merge_request_entity_spec.rb
@@ -47,7 +47,7 @@ describe MergeRequestEntity do
                                :cancel_merge_when_pipeline_succeeds_path,
                                :create_issue_to_resolve_discussions_path,
                                :source_branch_path, :target_branch_commits_path,
-                               :commits_count)
+                               :target_branch_tree_path, :commits_count)
   end
 
   it 'has email_patches_path' do
diff --git a/spec/services/ci/create_pipeline_service_spec.rb b/spec/services/ci/create_pipeline_service_spec.rb
index 77c07b71c68..e71c462b99a 100644
--- a/spec/services/ci/create_pipeline_service_spec.rb
+++ b/spec/services/ci/create_pipeline_service_spec.rb
@@ -40,7 +40,7 @@ describe Ci::CreatePipelineService, :services do
 
       it 'increments the prometheus counter' do
         expect(Gitlab::Metrics).to receive(:counter)
-          .with(:pipelines_created_count, "Pipelines created count")
+          .with(:pipelines_created_total, "Counter of pipelines created")
           .and_call_original
 
         pipeline
diff --git a/spec/services/event_create_service_spec.rb b/spec/services/event_create_service_spec.rb
index b06cefe071d..8d067c194cc 100644
--- a/spec/services/event_create_service_spec.rb
+++ b/spec/services/event_create_service_spec.rb
@@ -113,7 +113,7 @@ describe EventCreateService, services: true do
     end
   end
 
-  describe '#push', :redis do
+  describe '#push', :clean_gitlab_redis_shared_state do
     let(:project) { create(:empty_project) }
     let(:user) { create(:user) }
 
diff --git a/spec/services/git_push_service_spec.rb b/spec/services/git_push_service_spec.rb
index 8e8816870e1..c493c08a7ae 100644
--- a/spec/services/git_push_service_spec.rb
+++ b/spec/services/git_push_service_spec.rb
@@ -108,7 +108,7 @@ describe GitPushService, services: true do
 
         it { is_expected.to include(id: @commit.id) }
         it { is_expected.to include(message: @commit.safe_message) }
-        it { is_expected.to include(timestamp: @commit.date.xmlschema) }
+        it { expect(subject[:timestamp].in_time_zone).to eq(@commit.date.in_time_zone) }
         it do
           is_expected.to include(
             url: [
@@ -163,7 +163,7 @@ describe GitPushService, services: true do
         execute_service(project, user, @blankrev, 'newrev', 'refs/heads/master' )
       end
     end
-    
+
     context "Sends System Push data" do
       it "when pushing on a branch" do
         expect(SystemHookPushWorker).to receive(:perform_async).with(@push_data, :push_hooks)
@@ -527,14 +527,18 @@ describe GitPushService, services: true do
     let(:housekeeping) { Projects::HousekeepingService.new(project) }
 
     before do
-      # Flush any raw Redis data stored by the housekeeping code.
-      Gitlab::Redis.with { |conn| conn.flushall }
+      # Flush any raw key-value data stored by the housekeeping code.
+      Gitlab::Redis::Cache.with { |conn| conn.flushall }
+      Gitlab::Redis::Queues.with { |conn| conn.flushall }
+      Gitlab::Redis::SharedState.with { |conn| conn.flushall }
 
       allow(Projects::HousekeepingService).to receive(:new).and_return(housekeeping)
     end
 
     after do
-      Gitlab::Redis.with { |conn| conn.flushall }
+      Gitlab::Redis::Cache.with { |conn| conn.flushall }
+      Gitlab::Redis::Queues.with { |conn| conn.flushall }
+      Gitlab::Redis::SharedState.with { |conn| conn.flushall }
     end
 
     it 'does not perform housekeeping when not needed' do
diff --git a/spec/services/milestones/destroy_service_spec.rb b/spec/services/milestones/destroy_service_spec.rb
new file mode 100644
index 00000000000..8d1fe3ae2c1
--- /dev/null
+++ b/spec/services/milestones/destroy_service_spec.rb
@@ -0,0 +1,51 @@
+require 'spec_helper'
+
+describe Milestones::DestroyService, services: true do
+  let(:user) { create(:user) }
+  let(:project) { create(:project) }
+  let(:milestone) { create(:milestone, title: 'Milestone v1.0', project: project) }
+  let(:issue) { create(:issue, project: project, milestone: milestone) }
+  let(:merge_request) { create(:merge_request, source_project: project, milestone: milestone) }
+
+  before do
+    project.team << [user, :master]
+  end
+
+  def service
+    described_class.new(project, user, {})
+  end
+
+  describe '#execute' do
+    it 'deletes milestone' do
+      service.execute(milestone)
+
+      expect { milestone.reload }.to raise_error ActiveRecord::RecordNotFound
+    end
+
+    it 'deletes milestone id from issuables' do
+      service.execute(milestone)
+
+      expect(issue.reload.milestone).to be_nil
+      expect(merge_request.reload.milestone).to be_nil
+    end
+
+    context 'group milestones' do
+      let(:group) { create(:group) }
+      let(:group_milestone) { create(:milestone, group: group) }
+
+      before do
+        project.update(namespace: group)
+        group.add_developer(user)
+      end
+
+      it { expect(service.execute(group_milestone)).to be_nil }
+
+      it 'does not update milestone issuables' do
+        expect(MergeRequests::UpdateService).not_to receive(:new)
+        expect(Issues::UpdateService).not_to receive(:new)
+
+        service.execute(group_milestone)
+      end
+    end
+  end
+end
diff --git a/spec/services/notification_service_spec.rb b/spec/services/notification_service_spec.rb
index f1e00c1163b..4fc5eb0a527 100644
--- a/spec/services/notification_service_spec.rb
+++ b/spec/services/notification_service_spec.rb
@@ -383,7 +383,7 @@ describe NotificationService, services: true do
       before do
         build_team(note.project)
         reset_delivered_emails!
-        allow_any_instance_of(Commit).to receive(:author).and_return(@u_committer)
+        allow(note.noteable).to receive(:author).and_return(@u_committer)
         update_custom_notification(:new_note, @u_guest_custom, resource: project)
         update_custom_notification(:new_note, @u_custom_global)
       end
diff --git a/spec/services/projects/destroy_service_spec.rb b/spec/services/projects/destroy_service_spec.rb
index 697dc18feb0..b399d3402fd 100644
--- a/spec/services/projects/destroy_service_spec.rb
+++ b/spec/services/projects/destroy_service_spec.rb
@@ -60,14 +60,14 @@ describe Projects::DestroyService, services: true do
     before do
       new_user = create(:user)
       project.team.add_user(new_user, Gitlab::Access::DEVELOPER)
-      allow_any_instance_of(Projects::DestroyService).to receive(:flush_caches).and_raise(Redis::CannotConnectError)
+      allow_any_instance_of(Projects::DestroyService).to receive(:flush_caches).and_raise(::Redis::CannotConnectError)
     end
 
     it 'keeps project team intact upon an error' do
       Sidekiq::Testing.inline! do
         begin
           destroy_project(project, user, {})
-        rescue Redis::CannotConnectError
+        rescue ::Redis::CannotConnectError
         end
       end
 
diff --git a/spec/services/projects/participants_service_spec.rb b/spec/services/projects/participants_service_spec.rb
index d75851134ee..3688f6d4e23 100644
--- a/spec/services/projects/participants_service_spec.rb
+++ b/spec/services/projects/participants_service_spec.rb
@@ -13,7 +13,7 @@ describe Projects::ParticipantsService, services: true do
         groups = participants.groups
 
         expect(groups.size).to eq 1
-        expect(groups.first[:avatar_url]).to eq("/uploads/system/group/avatar/#{group.id}/dk.png")
+        expect(groups.first[:avatar_url]).to eq("/uploads/-/system/group/avatar/#{group.id}/dk.png")
       end
 
       it 'should return an url for the avatar with relative url' do
@@ -24,7 +24,7 @@ describe Projects::ParticipantsService, services: true do
         groups = participants.groups
 
         expect(groups.size).to eq 1
-        expect(groups.first[:avatar_url]).to eq("/gitlab/uploads/system/group/avatar/#{group.id}/dk.png")
+        expect(groups.first[:avatar_url]).to eq("/gitlab/uploads/-/system/group/avatar/#{group.id}/dk.png")
       end
     end
   end
diff --git a/spec/services/projects/update_service_spec.rb b/spec/services/projects/update_service_spec.rb
index 05b18fef061..fd4011ad606 100644
--- a/spec/services/projects/update_service_spec.rb
+++ b/spec/services/projects/update_service_spec.rb
@@ -1,11 +1,14 @@
 require 'spec_helper'
 
-describe Projects::UpdateService, services: true do
+describe Projects::UpdateService, '#execute', :services do
   let(:user) { create(:user) }
   let(:admin) { create(:admin) }
-  let(:project) { create(:empty_project, creator_id: user.id, namespace: user.namespace) }
 
-  describe 'update_by_user' do
+  let(:project) do
+    create(:empty_project, creator: user, namespace: user.namespace)
+  end
+
+  context 'when changing visibility level' do
     context 'when visibility_level is INTERNAL' do
       it 'updates the project to internal' do
         result = update_project(project, user, visibility_level: Gitlab::VisibilityLevel::INTERNAL)
@@ -40,7 +43,7 @@ describe Projects::UpdateService, services: true do
         it 'does not update the project to public' do
           result = update_project(project, user, visibility_level: Gitlab::VisibilityLevel::PUBLIC)
 
-          expect(result).to eq({ status: :error, message: 'Visibility level unallowed' })
+          expect(result).to eq({ status: :error, message: 'New visibility level not allowed!' })
           expect(project).to be_private
         end
 
@@ -55,12 +58,13 @@ describe Projects::UpdateService, services: true do
     end
   end
 
-  describe 'visibility_level' do
+  describe 'when updating project that has forks' do
     let(:project) { create(:empty_project, :internal) }
     let(:forked_project) { create(:forked_project_with_submodules, :internal) }
 
     before do
-      forked_project.build_forked_project_link(forked_to_project_id: forked_project.id, forked_from_project_id: project.id)
+      forked_project.build_forked_project_link(forked_to_project_id: forked_project.id,
+                                               forked_from_project_id: project.id)
       forked_project.save
     end
 
@@ -89,10 +93,38 @@ describe Projects::UpdateService, services: true do
     end
   end
 
-  it 'returns an error result when record cannot be updated' do
-    result = update_project(project, admin, { name: 'foo&bar' })
+  context 'when updating a default branch' do
+    let(:project) { create(:project, :repository) }
+
+    it 'changes a default branch' do
+      update_project(project, admin, default_branch: 'feature')
+
+      expect(Project.find(project.id).default_branch).to eq 'feature'
+    end
+  end
 
-    expect(result).to eq({ status: :error, message: 'Project could not be updated' })
+  context 'when renaming project that contains container images' do
+    before do
+      stub_container_registry_config(enabled: true)
+      stub_container_registry_tags(repository: /image/, tags: %w[rc1])
+      create(:container_repository, project: project, name: :image)
+    end
+
+    it 'does not allow to rename the project' do
+      result = update_project(project, admin, path: 'renamed')
+
+      expect(result).to include(status: :error)
+      expect(result[:message]).to match(/contains container registry tags/)
+    end
+  end
+
+  context 'when passing invalid parameters' do
+    it 'returns an error result when record cannot be updated' do
+      result = update_project(project, admin, { name: 'foo&bar' })
+
+      expect(result).to eq({ status: :error,
+                             message: 'Project could not be updated!' })
+    end
   end
 
   def update_project(project, user, opts)
diff --git a/spec/services/todo_service_spec.rb b/spec/services/todo_service_spec.rb
index 175a42a32d9..de41cbab14c 100644
--- a/spec/services/todo_service_spec.rb
+++ b/spec/services/todo_service_spec.rb
@@ -908,7 +908,7 @@ describe TodoService, services: true do
       end
     end
 
-    it 'caches the number of todos of a user', :caching do
+    it 'caches the number of todos of a user', :use_clean_rails_memory_store_caching do
       create(:todo, :mentioned, user: john_doe, target: issue, project: project)
       todo = create(:todo, :mentioned, user: john_doe, target: issue, project: project)
       TodoService.new.mark_todos_as_done([todo], john_doe)
diff --git a/spec/services/users/activity_service_spec.rb b/spec/services/users/activity_service_spec.rb
index 2e009d4ce1c..e5330d1d3e4 100644
--- a/spec/services/users/activity_service_spec.rb
+++ b/spec/services/users/activity_service_spec.rb
@@ -7,7 +7,7 @@ describe Users::ActivityService, services: true do
 
   subject(:service) { described_class.new(user, 'type') }
 
-  describe '#execute', :redis do
+  describe '#execute', :clean_gitlab_redis_shared_state do
     context 'when last activity is nil' do
       before do
         service.execute
diff --git a/spec/services/users/migrate_to_ghost_user_service_spec.rb b/spec/services/users/migrate_to_ghost_user_service_spec.rb
index 9e1edf1ac30..e52ecd6d614 100644
--- a/spec/services/users/migrate_to_ghost_user_service_spec.rb
+++ b/spec/services/users/migrate_to_ghost_user_service_spec.rb
@@ -7,16 +7,32 @@ describe Users::MigrateToGhostUserService, services: true do
 
   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) }
+      context 'deleted user is present as both author and edited_user' do
+        include_examples "migrating a deleted user's associated records to the ghost user", Issue, [:author, :last_edited_by] do
+          let(:created_record) do
+            create(:issue, project: project, author: user, last_edited_by: user)
+          end
+        end
+      end
+
+      context 'deleted user is present only as edited_user' do
+        include_examples "migrating a deleted user's associated records to the ghost user", Issue, [:last_edited_by] do
+          let(:created_record) { create(:issue, project: project, author: create(:user), last_edited_by: user) }
+        end
       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') }
+      context 'deleted user is present as both author and merge_user' do
+        include_examples "migrating a deleted user's associated records to the ghost user", MergeRequest, [:author, :merge_user] do
+          let(:created_record) { create(:merge_request, source_project: project, author: user, merge_user: user, target_branch: "first") }
+        end
+      end
+
+      context 'deleted user is present only as both merge_user' do
+        include_examples "migrating a deleted user's associated records to the ghost user", MergeRequest, [:merge_user] do
+          let(:created_record) { create(:merge_request, source_project: project, merge_user: user, target_branch: "first") }
+        end
       end
     end
 
@@ -33,9 +49,8 @@ describe Users::MigrateToGhostUserService, services: true do
     end
 
     context 'award emoji' do
-      include_examples "migrating a deleted user's associated records to the ghost user", AwardEmoji do
+      include_examples "migrating a deleted user's associated records to the ghost user", AwardEmoji, [:user] 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) }
diff --git a/spec/services/users/refresh_authorized_projects_service_spec.rb b/spec/services/users/refresh_authorized_projects_service_spec.rb
index b65cadbb2f5..1c0f55d2965 100644
--- a/spec/services/users/refresh_authorized_projects_service_spec.rb
+++ b/spec/services/users/refresh_authorized_projects_service_spec.rb
@@ -8,7 +8,7 @@ describe Users::RefreshAuthorizedProjectsService do
   let(:user) { project.namespace.owner }
   let(:service) { described_class.new(user) }
 
-  describe '#execute', :redis do
+  describe '#execute', :clean_gitlab_redis_shared_state do
     it 'refreshes the authorizations using a lease' do
       expect_any_instance_of(Gitlab::ExclusiveLease).to receive(:try_obtain)
         .and_return('foo')
diff --git a/spec/spec_helper.rb b/spec/spec_helper.rb
index a497b8613bb..5d5715b10ff 100644
--- a/spec/spec_helper.rb
+++ b/spec/spec_helper.rb
@@ -3,7 +3,6 @@ SimpleCovEnv.start!
 
 ENV["RAILS_ENV"] ||= 'test'
 ENV["IN_MEMORY_APPLICATION_SETTINGS"] = 'true'
-# ENV['prometheus_multiproc_dir'] = 'tmp/prometheus_multiproc_dir_test'
 
 require File.expand_path("../../config/environment", __FILE__)
 require 'rspec/rails'
@@ -59,6 +58,7 @@ RSpec.configure do |config|
   config.include ApiHelpers, :api
   config.include Gitlab::Routing, type: :routing
   config.include MigrationsHelpers, :migration
+  config.include StubFeatureFlags
 
   config.infer_spec_type_from_file_location!
 
@@ -76,6 +76,13 @@ RSpec.configure do |config|
     TestEnv.cleanup
   end
 
+  config.before(:example) do
+    # Skip pre-receive hook check so we can use the web editor and merge.
+    allow_any_instance_of(Gitlab::Git::Hook).to receive(:trigger).and_return([true, nil])
+    # Enable all features by default for testing
+    allow(Feature).to receive(:enabled?) { true }
+  end
+
   config.before(:example, :request_store) do
     RequestStore.begin!
   end
@@ -91,20 +98,30 @@ RSpec.configure do |config|
     end
   end
 
-  config.around(:each, :caching) do |example|
+  config.around(:each, :use_clean_rails_memory_store_caching) do |example|
     caching_store = Rails.cache
-    Rails.cache = ActiveSupport::Cache::MemoryStore.new if example.metadata[:caching]
+    Rails.cache = ActiveSupport::Cache::MemoryStore.new
+
     example.run
+
     Rails.cache = caching_store
   end
 
-  config.around(:each, :redis) do |example|
-    Gitlab::Redis.with(&:flushall)
+  config.around(:each, :clean_gitlab_redis_cache) do |example|
+    Gitlab::Redis::Cache.with(&:flushall)
+
+    example.run
+
+    Gitlab::Redis::Cache.with(&:flushall)
+  end
+
+  config.around(:each, :clean_gitlab_redis_shared_state) do |example|
+    Gitlab::Redis::SharedState.with(&:flushall)
     Sidekiq.redis(&:flushall)
 
     example.run
 
-    Gitlab::Redis.with(&:flushall)
+    Gitlab::Redis::SharedState.with(&:flushall)
     Sidekiq.redis(&:flushall)
   end
 
diff --git a/spec/support/dropzone_helper.rb b/spec/support/dropzone_helper.rb
index 02fdeb08afe..fe72d320fcf 100644
--- a/spec/support/dropzone_helper.rb
+++ b/spec/support/dropzone_helper.rb
@@ -54,4 +54,23 @@ module DropzoneHelper
       loop until page.evaluate_script('window._dropzoneComplete === true')
     end
   end
+
+  def drop_in_dropzone(file_path)
+    # Generate a fake input selector
+    page.execute_script <<-JS
+      var fakeFileInput = window.$('<input/>').attr(
+        {id: 'fakeFileInput', type: 'file'}
+      ).appendTo('body');
+    JS
+
+    # Attach the file to the fake input selector with Capybara
+    attach_file('fakeFileInput', file_path)
+
+    # Add the file to a fileList array and trigger the fake drop event
+    page.execute_script <<-JS
+      var fileList = [$('#fakeFileInput')[0].files[0]];
+      var e = jQuery.Event('drop', { dataTransfer : { files : fileList } });
+      $('.dropzone')[0].dropzone.listeners[0].events.drop(e);
+    JS
+  end
 end
diff --git a/spec/support/malicious_regexp_shared_examples.rb b/spec/support/malicious_regexp_shared_examples.rb
new file mode 100644
index 00000000000..ac5d22298bb
--- /dev/null
+++ b/spec/support/malicious_regexp_shared_examples.rb
@@ -0,0 +1,8 @@
+shared_examples 'malicious regexp' do
+  let(:malicious_text)  { 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa!' }
+  let(:malicious_regexp) { '(?i)^(([a-z])+.)+[A-Z]([a-z])+$' }
+
+  it 'takes under a second' do
+    expect { Timeout.timeout(1) { subject } }.not_to raise_error
+  end
+end
diff --git a/spec/support/matchers/have_gitlab_http_status.rb b/spec/support/matchers/have_gitlab_http_status.rb
new file mode 100644
index 00000000000..3198f1b9edd
--- /dev/null
+++ b/spec/support/matchers/have_gitlab_http_status.rb
@@ -0,0 +1,14 @@
+RSpec::Matchers.define :have_gitlab_http_status do |expected|
+  match do |actual|
+    expect(actual).to have_http_status(expected)
+  end
+
+  description do
+    "respond with numeric status code #{expected}"
+  end
+
+  failure_message do |actual|
+    "expected the response to have status code #{expected.inspect}" \
+    " but it was #{actual.response_code}. The response was: #{actual.body}"
+  end
+end
diff --git a/spec/lib/gitlab/redis_spec.rb b/spec/support/redis/redis_shared_examples.rb
index 593aa5038ad..f9552e41894 100644
--- a/spec/lib/gitlab/redis_spec.rb
+++ b/spec/support/redis/redis_shared_examples.rb
@@ -1,12 +1,10 @@
-require 'spec_helper'
-
-describe Gitlab::Redis do
+RSpec.shared_examples "redis_shared_examples" do
   include StubENV
 
-  let(:config) { 'config/resque.yml' }
+  let(:test_redis_url)  { "redis://redishost:#{redis_port}"}
 
   before(:each) do
-    stub_env('GITLAB_REDIS_CONFIG_FILE', Rails.root.join(config).to_s)
+    stub_env(environment_config_file_name, Rails.root.join(config_file_name))
     clear_raw_config
   end
 
@@ -26,46 +24,40 @@ describe Gitlab::Redis do
     end
 
     context 'when url contains unix socket reference' do
-      let(:config_old) { 'spec/fixtures/config/redis_old_format_socket.yml' }
-      let(:config_new) { 'spec/fixtures/config/redis_new_format_socket.yml' }
-
       context 'with old format' do
-        let(:config) { config_old }
+        let(:config_file_name) { config_old_format_socket }
 
         it 'returns path key instead' do
-          is_expected.to include(path: '/path/to/old/redis.sock')
+          is_expected.to include(path: old_socket_path)
           is_expected.not_to have_key(:url)
         end
       end
 
       context 'with new format' do
-        let(:config) { config_new }
+        let(:config_file_name) { config_new_format_socket }
 
         it 'returns path key instead' do
-          is_expected.to include(path: '/path/to/redis.sock')
+          is_expected.to include(path: new_socket_path)
           is_expected.not_to have_key(:url)
         end
       end
     end
 
     context 'when url is host based' do
-      let(:config_old) { 'spec/fixtures/config/redis_old_format_host.yml' }
-      let(:config_new) { 'spec/fixtures/config/redis_new_format_host.yml' }
-
       context 'with old format' do
-        let(:config) { config_old }
+        let(:config_file_name) { config_old_format_host }
 
         it 'returns hash with host, port, db, and password' do
-          is_expected.to include(host: 'localhost', password: 'mypassword', port: 6379, db: 99)
+          is_expected.to include(host: 'localhost', password: 'mypassword', port: redis_port, db: redis_database)
           is_expected.not_to have_key(:url)
         end
       end
 
       context 'with new format' do
-        let(:config) { config_new }
+        let(:config_file_name) { config_new_format_host }
 
         it 'returns hash with host, port, db, and password' do
-          is_expected.to include(host: 'localhost', password: 'mynewpassword', port: 6379, db: 99)
+          is_expected.to include(host: 'localhost', password: 'mynewpassword', port: redis_port, db: redis_database)
           is_expected.not_to have_key(:url)
         end
       end
@@ -73,30 +65,22 @@ describe Gitlab::Redis do
   end
 
   describe '.url' do
-    it 'withstands mutation' do
-      url1 = described_class.url
-      url2 = described_class.url
-      url1 << 'foobar'
-
-      expect(url2).not_to end_with('foobar')
-    end
-
     context 'when yml file with env variable' do
-      let(:config) { 'spec/fixtures/config/redis_config_with_env.yml' }
+      let(:config_file_name) { config_with_environment_variable_inside }
 
       before  do
-        stub_env('TEST_GITLAB_REDIS_URL', 'redis://redishost:6379')
+        stub_env(config_env_variable_url, test_redis_url)
       end
 
       it 'reads redis url from env variable' do
-        expect(described_class.url).to eq 'redis://redishost:6379'
+        expect(described_class.url).to eq test_redis_url
       end
     end
   end
 
   describe '._raw_config' do
     subject { described_class._raw_config }
-    let(:config) { '/var/empty/doesnotexist' }
+    let(:config_file_name) { '/var/empty/doesnotexist' }
 
     it 'should be frozen' do
       expect(subject).to be_frozen
@@ -105,6 +89,12 @@ describe Gitlab::Redis do
     it 'returns false when the file does not exist' do
       expect(subject).to eq(false)
     end
+
+    it "returns false when the filename can't be determined" do
+      expect(described_class).to receive(:config_file_name).and_return(nil)
+
+      expect(subject).to eq(false)
+    end
   end
 
   describe '.with' do
@@ -124,7 +114,7 @@ describe Gitlab::Redis do
       it 'instantiates a connection pool with size 5' do
         expect(ConnectionPool).to receive(:new).with(size: 5).and_call_original
 
-        described_class.with { |_redis| true }
+        described_class.with { |_redis_shared_example| true }
       end
     end
 
@@ -137,7 +127,7 @@ describe Gitlab::Redis do
       it 'instantiates a connection pool with a size based on the concurrency of the worker' do
         expect(ConnectionPool).to receive(:new).with(size: 18 + 5).and_call_original
 
-        described_class.with { |_redis| true }
+        described_class.with { |_redis_shared_example| true }
       end
     end
   end
@@ -146,16 +136,16 @@ describe Gitlab::Redis do
     subject { described_class.new(Rails.env).sentinels }
 
     context 'when sentinels are defined' do
-      let(:config) { 'spec/fixtures/config/redis_new_format_host.yml' }
+      let(:config_file_name) { config_new_format_host }
 
       it 'returns an array of hashes with host and port keys' do
-        is_expected.to include(host: 'localhost', port: 26380)
-        is_expected.to include(host: 'slave2', port: 26381)
+        is_expected.to include(host: 'localhost', port: sentinel_port)
+        is_expected.to include(host: 'slave2', port: sentinel_port)
       end
     end
 
     context 'when sentinels are not defined' do
-      let(:config) { 'spec/fixtures/config/redis_old_format_host.yml' }
+      let(:config_file_name) { config_old_format_host }
 
       it 'returns nil' do
         is_expected.to be_nil
@@ -167,7 +157,7 @@ describe Gitlab::Redis do
     subject { described_class.new(Rails.env).sentinels? }
 
     context 'when sentinels are defined' do
-      let(:config) { 'spec/fixtures/config/redis_new_format_host.yml' }
+      let(:config_file_name) { config_new_format_host }
 
       it 'returns true' do
         is_expected.to be_truthy
@@ -175,7 +165,7 @@ describe Gitlab::Redis do
     end
 
     context 'when sentinels are not defined' do
-      let(:config) { 'spec/fixtures/config/redis_old_format_host.yml' }
+      let(:config_file_name) { config_old_format_host }
 
       it 'returns false' do
         is_expected.to be_falsey
@@ -187,12 +177,12 @@ describe Gitlab::Redis do
     it 'returns default redis url when no config file is present' do
       expect(subject).to receive(:fetch_config) { false }
 
-      expect(subject.send(:raw_config_hash)).to eq(url: Gitlab::Redis::DEFAULT_REDIS_URL)
+      expect(subject.send(:raw_config_hash)).to eq(url: class_redis_url )
     end
 
     it 'returns old-style single url config in a hash' do
-      expect(subject).to receive(:fetch_config) { 'redis://myredis:6379' }
-      expect(subject.send(:raw_config_hash)).to eq(url: 'redis://myredis:6379')
+      expect(subject).to receive(:fetch_config) { test_redis_url }
+      expect(subject.send(:raw_config_hash)).to eq(url: test_redis_url)
     end
   end
 
@@ -200,7 +190,13 @@ describe Gitlab::Redis do
     it 'returns false when no config file is present' do
       allow(described_class).to receive(:_raw_config) { false }
 
-      expect(subject.send(:fetch_config)).to be_falsey
+      expect(subject.send(:fetch_config)).to eq false
+    end
+
+    it 'returns false when config file is present but has invalid YAML' do
+      allow(described_class).to receive(:_raw_config) { "# development: true" }
+
+      expect(subject.send(:fetch_config)).to eq false
     end
   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
index dcc562c684b..855051921f0 100644
--- a/spec/support/services/migrate_to_ghost_user_service_shared_examples.rb
+++ b/spec/support/services/migrate_to_ghost_user_service_shared_examples.rb
@@ -1,6 +1,6 @@
 require "spec_helper"
 
-shared_examples "migrating a deleted user's associated records to the ghost user" do |record_class|
+shared_examples "migrating a deleted user's associated records to the ghost user" do |record_class, fields|
   record_class_name = record_class.to_s.titleize.downcase
 
   let(:project) { create(:project) }
@@ -11,6 +11,7 @@ shared_examples "migrating a deleted user's associated records to the ghost user
 
   context "for a #{record_class_name} the user has created" do
     let!(:record) { created_record }
+    let(:migrated_fields) { fields || [:author] }
 
     it "does not delete the #{record_class_name}" do
       service.execute
@@ -18,22 +19,20 @@ shared_examples "migrating a deleted user's associated records to the ghost user
       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
+    it "blocks the user before migrating #{record_class_name}s to the 'Ghost User'" 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
+      expect(user).to be_blocked
     end
 
-    it "blocks the user before migrating #{record_class_name}s to the 'Ghost User'" do
+    it 'migrates all associated fields to te "Ghost user"' do
       service.execute
 
-      expect(user).to be_blocked
+      migrated_record = record_class.find_by_id(record.id)
+
+      migrated_fields.each do |field|
+        expect(migrated_record.public_send(field)).to eq(User.ghost)
+      end
     end
 
     context "race conditions" do
diff --git a/spec/support/sidekiq.rb b/spec/support/sidekiq.rb
index 5478fea4e64..d143014692d 100644
--- a/spec/support/sidekiq.rb
+++ b/spec/support/sidekiq.rb
@@ -8,4 +8,8 @@ RSpec.configure do |config|
   config.after(:each, :sidekiq) do
     Sidekiq::Worker.clear_all
   end
+
+  config.after(:each, :sidekiq, :redis) do
+    Sidekiq.redis { |redis| redis.flushdb }
+  end
 end
diff --git a/spec/support/sorting_helper.rb b/spec/support/sorting_helper.rb
new file mode 100644
index 00000000000..577518d726c
--- /dev/null
+++ b/spec/support/sorting_helper.rb
@@ -0,0 +1,18 @@
+# Helper allows you to sort items
+#
+# Params
+#   value - value for sorting
+#
+# Usage:
+#   include SortingHelper
+#
+#   sorting_by('Oldest updated')
+#
+module SortingHelper
+  def sorting_by(value)
+    find('button.dropdown-toggle').click
+    page.within('.content ul.dropdown-menu.dropdown-menu-align-right li') do
+      click_link value
+    end
+  end
+end
diff --git a/spec/support/stub_feature_flags.rb b/spec/support/stub_feature_flags.rb
new file mode 100644
index 00000000000..b96338bf548
--- /dev/null
+++ b/spec/support/stub_feature_flags.rb
@@ -0,0 +1,8 @@
+module StubFeatureFlags
+  def stub_feature_flags(features)
+    features.each do |feature_name, enabled|
+      allow(Feature).to receive(:enabled?).with(feature_name) { enabled }
+      allow(Feature).to receive(:enabled?).with(feature_name.to_s) { enabled }
+    end
+  end
+end
diff --git a/spec/support/test_env.rb b/spec/support/test_env.rb
index 0cae5620920..0a194ca4c90 100644
--- a/spec/support/test_env.rb
+++ b/spec/support/test_env.rb
@@ -206,6 +206,7 @@ module TestEnv
   # Otherwise they'd be created by the first test, often timing out and
   # causing a transient test failure
   def eager_load_driver_server
+    return unless ENV['CI']
     return unless defined?(Capybara)
 
     puts "Starting the Capybara driver server..."
diff --git a/spec/support/unique_ip_check_shared_examples.rb b/spec/support/unique_ip_check_shared_examples.rb
index 1986d202c4a..ff0b47899f5 100644
--- a/spec/support/unique_ip_check_shared_examples.rb
+++ b/spec/support/unique_ip_check_shared_examples.rb
@@ -1,7 +1,9 @@
 shared_context 'unique ips sign in limit' do
   include StubENV
   before(:each) do
-    Gitlab::Redis.with(&:flushall)
+    Gitlab::Redis::Cache.with(&:flushall)
+    Gitlab::Redis::Queues.with(&:flushall)
+    Gitlab::Redis::SharedState.with(&:flushall)
   end
 
   before do
diff --git a/spec/uploaders/attachment_uploader_spec.rb b/spec/uploaders/attachment_uploader_spec.rb
index d82dbe871d5..04ee6e9bfad 100644
--- a/spec/uploaders/attachment_uploader_spec.rb
+++ b/spec/uploaders/attachment_uploader_spec.rb
@@ -5,7 +5,7 @@ describe AttachmentUploader do
 
   describe "#store_dir" do
     it "stores in the system dir" do
-      expect(uploader.store_dir).to start_with("uploads/system/user")
+      expect(uploader.store_dir).to start_with("uploads/-/system/user")
     end
 
     it "uses the old path when using object storage" do
diff --git a/spec/uploaders/avatar_uploader_spec.rb b/spec/uploaders/avatar_uploader_spec.rb
index 201fe6949aa..1dc574699d8 100644
--- a/spec/uploaders/avatar_uploader_spec.rb
+++ b/spec/uploaders/avatar_uploader_spec.rb
@@ -5,7 +5,7 @@ describe AvatarUploader do
 
   describe "#store_dir" do
     it "stores in the system dir" do
-      expect(uploader.store_dir).to start_with("uploads/system/user")
+      expect(uploader.store_dir).to start_with("uploads/-/system/user")
     end
 
     it "uses the old path when using object storage" do
diff --git a/spec/uploaders/file_mover_spec.rb b/spec/uploaders/file_mover_spec.rb
index 896cb410ed5..d7c1b390f9a 100644
--- a/spec/uploaders/file_mover_spec.rb
+++ b/spec/uploaders/file_mover_spec.rb
@@ -4,11 +4,11 @@ describe FileMover do
   let(:filename) { 'banana_sample.gif' }
   let(:file) { fixture_file_upload(Rails.root.join('spec', 'fixtures', filename)) }
   let(:temp_description) do
-    'test ![banana_sample](/uploads/temp/secret55/banana_sample.gif) same ![banana_sample]'\
-    '(/uploads/temp/secret55/banana_sample.gif)'
+    'test ![banana_sample](/uploads/system/temp/secret55/banana_sample.gif) same ![banana_sample]'\
+    '(/uploads/system/temp/secret55/banana_sample.gif)'
   end
   let(:temp_file_path) { File.join('secret55', filename).to_s }
-  let(:file_path) { File.join('uploads', 'personal_snippet', snippet.id.to_s, 'secret55', filename).to_s }
+  let(:file_path) { File.join('uploads', 'system', 'personal_snippet', snippet.id.to_s, 'secret55', filename).to_s }
 
   let(:snippet) { create(:personal_snippet, description: temp_description) }
 
@@ -28,8 +28,8 @@ describe FileMover do
 
         expect(snippet.reload.description)
           .to eq(
-            "test ![banana_sample](/uploads/personal_snippet/#{snippet.id}/secret55/banana_sample.gif)"\
-            " same ![banana_sample](/uploads/personal_snippet/#{snippet.id}/secret55/banana_sample.gif)"
+            "test ![banana_sample](/uploads/system/personal_snippet/#{snippet.id}/secret55/banana_sample.gif)"\
+            " same ![banana_sample](/uploads/system/personal_snippet/#{snippet.id}/secret55/banana_sample.gif)"
           )
       end
 
@@ -50,8 +50,8 @@ describe FileMover do
 
         expect(snippet.reload.description)
           .to eq(
-            "test ![banana_sample](/uploads/temp/secret55/banana_sample.gif)"\
-            " same ![banana_sample](/uploads/temp/secret55/banana_sample.gif)"
+            "test ![banana_sample](/uploads/system/temp/secret55/banana_sample.gif)"\
+            " same ![banana_sample](/uploads/system/temp/secret55/banana_sample.gif)"
           )
       end
 
diff --git a/spec/uploaders/personal_file_uploader_spec.rb b/spec/uploaders/personal_file_uploader_spec.rb
index fb92f2ae3ab..eb55e8ebd24 100644
--- a/spec/uploaders/personal_file_uploader_spec.rb
+++ b/spec/uploaders/personal_file_uploader_spec.rb
@@ -10,7 +10,7 @@ describe PersonalFileUploader do
 
       dynamic_segment = "personal_snippet/#{snippet.id}"
 
-      expect(described_class.absolute_path(upload)).to end_with("#{dynamic_segment}/secret/foo.jpg")
+      expect(described_class.absolute_path(upload)).to end_with("/system/#{dynamic_segment}/secret/foo.jpg")
     end
   end
 
@@ -19,7 +19,7 @@ describe PersonalFileUploader do
       uploader = described_class.new(snippet, 'secret')
 
       allow(uploader).to receive(:file).and_return(double(extension: 'txt', filename: 'file_name'))
-      expected_url = "/uploads/personal_snippet/#{snippet.id}/secret/file_name"
+      expected_url = "/uploads/system/personal_snippet/#{snippet.id}/secret/file_name"
 
       expect(uploader.to_h).to eq(
         alt: 'file_name',
diff --git a/spec/workers/schedule_update_user_activity_worker_spec.rb b/spec/workers/schedule_update_user_activity_worker_spec.rb
index e583c3203aa..32c59381b01 100644
--- a/spec/workers/schedule_update_user_activity_worker_spec.rb
+++ b/spec/workers/schedule_update_user_activity_worker_spec.rb
@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe ScheduleUpdateUserActivityWorker, :redis do
+describe ScheduleUpdateUserActivityWorker, :clean_gitlab_redis_shared_state do
   let(:now) { Time.now }
 
   before do
diff --git a/spec/workers/update_user_activity_worker_spec.rb b/spec/workers/update_user_activity_worker_spec.rb
index 43e9511f116..268ca1d81f2 100644
--- a/spec/workers/update_user_activity_worker_spec.rb
+++ b/spec/workers/update_user_activity_worker_spec.rb
@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe UpdateUserActivityWorker, :redis do
+describe UpdateUserActivityWorker, :clean_gitlab_redis_shared_state do
   let(:user_active_2_days_ago) { create(:user, current_sign_in_at: 10.months.ago) }
   let(:user_active_yesterday_1) { create(:user) }
   let(:user_active_yesterday_2) { create(:user) }
@@ -25,7 +25,7 @@ describe UpdateUserActivityWorker, :redis do
     end
   end
 
-  it 'deletes the pairs from Redis' do
+  it 'deletes the pairs from SharedState' do
     data.each { |id, time| Gitlab::UserActivities.record(id, time) }
 
     subject.perform(data)