Add latest changes from gitlab-org/gitlab@master

14 files changed, 239 insertions, 279 deletions

diff --git a/spec/controllers/profiles/personal_access_tokens_controller_spec.rb b/spec/controllers/profiles/personal_access_tokens_controller_spec.rb
index 160af8cf3f0..8dee0490fd6 100644
--- a/spec/controllers/profiles/personal_access_tokens_controller_spec.rb
+++ b/spec/controllers/profiles/personal_access_tokens_controller_spec.rb
@@ -36,6 +36,14 @@ RSpec.describe Profiles::PersonalAccessTokensController do
       expect(created_token.expires_at).to eq(expires_at)
     end
 
+    it 'does not allow creation when personal access tokens are disabled' do
+      allow(::Gitlab::CurrentSettings).to receive_messages(personal_access_tokens_disabled?: true)
+
+      post :create, params: { personal_access_token: token_attributes }
+
+      expect(response).to have_gitlab_http_status(:not_found)
+    end
+
     it_behaves_like "#create access token" do
       let(:url) { :create }
     end
@@ -70,6 +78,14 @@ RSpec.describe Profiles::PersonalAccessTokensController do
       )
     end
 
+    it 'returns 404 when personal access tokens are disabled' do
+      allow(::Gitlab::CurrentSettings).to receive_messages(personal_access_tokens_disabled?: true)
+
+      get :index
+
+      expect(response).to have_gitlab_http_status(:not_found)
+    end
+
     context "access_token_pagination feature flag is enabled" do
       before do
         stub_feature_flags(access_token_pagination: true)
diff --git a/spec/features/admin/admin_settings_spec.rb b/spec/features/admin/admin_settings_spec.rb
index b2e86112d98..9e7666b920f 100644
--- a/spec/features/admin/admin_settings_spec.rb
+++ b/spec/features/admin/admin_settings_spec.rb
@@ -400,39 +400,19 @@ RSpec.describe 'Admin updates settings' do
       end
 
       context 'Runner Registration' do
-        context 'when feature is enabled' do
-          before do
-            stub_feature_flags(runner_registration_control: true)
-          end
-
-          it 'allows admins to control who has access to register runners' do
-            visit ci_cd_admin_application_settings_path
-
-            expect(current_settings.valid_runner_registrars).to eq(ApplicationSetting::VALID_RUNNER_REGISTRAR_TYPES)
+        it 'allows admins to control who has access to register runners' do
+          visit ci_cd_admin_application_settings_path
 
-            page.within('.as-runner') do
-              find_all('input[type="checkbox"]').each(&:click)
+          expect(current_settings.valid_runner_registrars).to eq(ApplicationSetting::VALID_RUNNER_REGISTRAR_TYPES)
 
-              click_button 'Save changes'
-            end
-
-            expect(current_settings.valid_runner_registrars).to eq([])
-            expect(page).to have_content "Application settings saved successfully"
-          end
-        end
+          page.within('.as-runner') do
+            find_all('input[type="checkbox"]').each(&:click)
 
-        context 'when feature is disabled' do
-          before do
-            stub_feature_flags(runner_registration_control: false)
+            click_button 'Save changes'
           end
 
-          it 'does not allow admins to control who has access to register runners' do
-            visit ci_cd_admin_application_settings_path
-
-            expect(current_settings.valid_runner_registrars).to eq(ApplicationSetting::VALID_RUNNER_REGISTRAR_TYPES)
-
-            expect(page).not_to have_css('.as-runner')
-          end
+          expect(current_settings.valid_runner_registrars).to eq([])
+          expect(page).to have_content "Application settings saved successfully"
         end
       end
 
diff --git a/spec/lib/gitlab/ci/pipeline/chain/cancel_pending_pipelines_spec.rb b/spec/lib/gitlab/ci/pipeline/chain/cancel_pending_pipelines_spec.rb
index 31f596e7e70..fc3de2a14cd 100644
--- a/spec/lib/gitlab/ci/pipeline/chain/cancel_pending_pipelines_spec.rb
+++ b/spec/lib/gitlab/ci/pipeline/chain/cancel_pending_pipelines_spec.rb
@@ -44,6 +44,20 @@ RSpec.describe Gitlab::Ci::Pipeline::Chain::CancelPendingPipelines do
         expect(build_statuses(pipeline)).to contain_exactly('pending')
       end
 
+      it 'logs canceled pipelines' do
+        allow(Gitlab::AppLogger).to receive(:info)
+
+        perform
+
+        expect(Gitlab::AppLogger).to have_received(:info).with(
+          class: described_class.name,
+          message: "Pipeline #{pipeline.id} auto-canceling pipeline #{prev_pipeline.id}",
+          canceled_pipeline_id: prev_pipeline.id,
+          canceled_by_pipeline_id: pipeline.id,
+          canceled_by_pipeline_source: pipeline.source
+        )
+      end
+
       it 'cancels the builds with 2 queries to avoid query timeout' do
         second_query_regex = /WHERE "ci_pipelines"\."id" = \d+ AND \(NOT EXISTS/
         recorder = ActiveRecord::QueryRecorder.new { perform }
diff --git a/spec/lib/gitlab/database/migrations/base_background_runner_spec.rb b/spec/lib/gitlab/database/migrations/base_background_runner_spec.rb
index 34c83c42056..c2dc260b2ff 100644
--- a/spec/lib/gitlab/database/migrations/base_background_runner_spec.rb
+++ b/spec/lib/gitlab/database/migrations/base_background_runner_spec.rb
@@ -3,6 +3,8 @@
 require 'spec_helper'
 
 RSpec.describe Gitlab::Database::Migrations::BaseBackgroundRunner, :freeze_time do
+  let(:connection) { ApplicationRecord.connection }
+
   let(:result_dir) { Dir.mktmpdir }
 
   after do
@@ -10,7 +12,7 @@ RSpec.describe Gitlab::Database::Migrations::BaseBackgroundRunner, :freeze_time
   end
 
   context 'subclassing' do
-    subject { described_class.new(result_dir: result_dir) }
+    subject { described_class.new(result_dir: result_dir, connection: connection) }
 
     it 'requires that jobs_by_migration_name be implemented' do
       expect { subject.jobs_by_migration_name }.to raise_error(NotImplementedError)
diff --git a/spec/lib/gitlab/database/migrations/test_batched_background_runner_spec.rb b/spec/lib/gitlab/database/migrations/test_batched_background_runner_spec.rb
index 3ac483c8ab7..07226f3d025 100644
--- a/spec/lib/gitlab/database/migrations/test_batched_background_runner_spec.rb
+++ b/spec/lib/gitlab/database/migrations/test_batched_background_runner_spec.rb
@@ -6,106 +6,156 @@ RSpec.describe Gitlab::Database::Migrations::TestBatchedBackgroundRunner, :freez
   include Gitlab::Database::MigrationHelpers
   include Database::MigrationTestingHelpers
 
-  let(:result_dir) { Dir.mktmpdir }
-
-  after do
-    FileUtils.rm_rf(result_dir)
+  def queue_migration(
+    job_class_name,
+    batch_table_name,
+    batch_column_name,
+    *job_arguments,
+    job_interval:,
+    batch_size: Gitlab::Database::Migrations::BatchedBackgroundMigrationHelpers::BATCH_SIZE,
+    sub_batch_size: Gitlab::Database::Migrations::BatchedBackgroundMigrationHelpers::SUB_BATCH_SIZE
+  )
+
+    batch_max_value = define_batchable_model(batch_table_name, connection: connection).maximum(batch_column_name)
+
+    Gitlab::Database::SharedModel.using_connection(connection) do
+      Gitlab::Database::BackgroundMigration::BatchedMigration.create!(
+        job_class_name: job_class_name,
+        table_name: batch_table_name,
+        column_name: batch_column_name,
+        job_arguments: job_arguments,
+        interval: job_interval,
+        min_value: Gitlab::Database::Migrations::BatchedBackgroundMigrationHelpers::BATCH_MIN_VALUE,
+        max_value: batch_max_value,
+        batch_class_name: Gitlab::Database::Migrations::BatchedBackgroundMigrationHelpers::BATCH_CLASS_NAME,
+        batch_size: batch_size,
+        sub_batch_size: sub_batch_size,
+        status_event: :execute,
+        max_batch_size: nil,
+        gitlab_schema: gitlab_schema
+      )
+    end
   end
 
-  let(:migration) do
-    ActiveRecord::Migration.new.extend(Gitlab::Database::Migrations::BatchedBackgroundMigrationHelpers)
+  where(:case_name, :base_model, :gitlab_schema) do
+    [
+      ['main database', ApplicationRecord, :gitlab_main],
+      ['ci database', Ci::ApplicationRecord, :gitlab_ci]
+    ]
   end
 
-  let(:connection) { ApplicationRecord.connection }
+  with_them do
+    let(:result_dir) { Dir.mktmpdir }
 
-  let(:table_name) { "_test_column_copying" }
+    after do
+      FileUtils.rm_rf(result_dir)
+    end
 
-  before do
-    connection.execute(<<~SQL)
-      CREATE TABLE #{table_name} (
-        id bigint primary key not null,
-        data bigint default 0
-      );
+    let(:connection) { base_model.connection }
 
-      insert into #{table_name} (id) select i from generate_series(1, 1000) g(i);
-    SQL
+    let(:table_name) { "_test_column_copying" }
 
-    allow(migration).to receive(:transaction_open?).and_return(false)
-  end
+    before do
+      connection.execute(<<~SQL)
+        CREATE TABLE #{table_name} (
+          id bigint primary key not null,
+          data bigint default 0
+        );
 
-  context 'running a real background migration' do
-    it 'runs sampled jobs from the batched background migration' do
-      migration.queue_batched_background_migration('CopyColumnUsingBackgroundMigrationJob',
-                                         table_name, :id,
-                                         :id, :data,
-                                         batch_size: 100,
-                                         job_interval: 5.minutes) # job_interval is skipped when testing
-
-      # Expect that running sampling for this migration processes some of the rows. Sampling doesn't run
-      # over every row in the table, so this does not completely migrate the table.
-      expect { described_class.new(result_dir: result_dir, connection: connection).run_jobs(for_duration: 1.minute) }
-        .to change { define_batchable_model(table_name).where('id IS DISTINCT FROM data').count }
-              .by_at_most(-1)
+        insert into #{table_name} (id) select i from generate_series(1, 1000) g(i);
+      SQL
     end
-  end
 
-  context 'with jobs to run' do
-    let(:migration_name) { 'TestBackgroundMigration' }
+    context 'running a real background migration' do
+      before do
+        queue_migration('CopyColumnUsingBackgroundMigrationJob',
+                        table_name, :id,
+                        :id, :data,
+                        batch_size: 100,
+                        job_interval: 5.minutes) # job_interval is skipped when testing
+      end
 
-    it 'samples jobs' do
-      calls = []
-      define_background_migration(migration_name) do |*args|
-        calls << args
+      subject(:sample_migration) do
+        described_class.new(result_dir: result_dir, connection: connection).run_jobs(for_duration: 1.minute)
       end
 
-      migration.queue_batched_background_migration(migration_name, table_name, :id,
-                                                   job_interval: 5.minutes,
-                                                   batch_size: 100)
+      it 'runs sampled jobs from the batched background migration' do
+        # Expect that running sampling for this migration processes some of the rows. Sampling doesn't run
+        # over every row in the table, so this does not completely migrate the table.
+        expect { subject }.to change {
+                                define_batchable_model(table_name, connection: connection)
+                                  .where('id IS DISTINCT FROM data').count
+                              }.by_at_most(-1)
+      end
 
-      described_class.new(result_dir: result_dir, connection: connection).run_jobs(for_duration: 3.minutes)
+      it 'uses the correct connection to instrument the background migration' do
+        expect_next_instance_of(Gitlab::Database::Migrations::Instrumentation) do |instrumentation|
+          expect(instrumentation).to receive(:observe).with(hash_including(connection: connection))
+                                                      .at_least(:once).and_call_original
+        end
 
-      expect(calls).not_to be_empty
+        subject
+      end
     end
 
-    context 'with multiple jobs to run' do
-      it 'runs all jobs created within the last 3 hours' do
-        old_migration = define_background_migration(migration_name)
-        migration.queue_batched_background_migration(migration_name, table_name, :id,
-                                             job_interval: 5.minutes,
-                                             batch_size: 100)
-
-        travel 4.hours
-
-        new_migration = define_background_migration('NewMigration') { travel 1.second }
-        migration.queue_batched_background_migration('NewMigration', table_name, :id,
-                                           job_interval: 5.minutes,
-                                           batch_size: 10,
-                                           sub_batch_size: 5)
-
-        other_new_migration = define_background_migration('NewMigration2') { travel 2.seconds }
-        migration.queue_batched_background_migration('NewMigration2', table_name, :id,
-                                           job_interval: 5.minutes,
-                                           batch_size: 10,
-                                           sub_batch_size: 5)
-
-        expect_migration_runs(new_migration => 3, other_new_migration => 2, old_migration => 0) do
-          described_class.new(result_dir: result_dir, connection: connection).run_jobs(for_duration: 5.seconds)
+    context 'with jobs to run' do
+      let(:migration_name) { 'TestBackgroundMigration' }
+
+      it 'samples jobs' do
+        calls = []
+        define_background_migration(migration_name) do |*args|
+          calls << args
+        end
+
+        queue_migration(migration_name, table_name, :id,
+                        job_interval: 5.minutes,
+                        batch_size: 100)
+
+        described_class.new(result_dir: result_dir, connection: connection).run_jobs(for_duration: 3.minutes)
+
+        expect(calls).not_to be_empty
+      end
+
+      context 'with multiple jobs to run' do
+        it 'runs all jobs created within the last 3 hours' do
+          old_migration = define_background_migration(migration_name)
+          queue_migration(migration_name, table_name, :id,
+                          job_interval: 5.minutes,
+                          batch_size: 100)
+
+          travel 4.hours
+
+          new_migration = define_background_migration('NewMigration') { travel 1.second }
+          queue_migration('NewMigration', table_name, :id,
+                          job_interval: 5.minutes,
+                          batch_size: 10,
+                          sub_batch_size: 5)
+
+          other_new_migration = define_background_migration('NewMigration2') { travel 2.seconds }
+          queue_migration('NewMigration2', table_name, :id,
+                          job_interval: 5.minutes,
+                          batch_size: 10,
+                          sub_batch_size: 5)
+
+          expect_migration_runs(new_migration => 3, other_new_migration => 2, old_migration => 0) do
+            described_class.new(result_dir: result_dir, connection: connection).run_jobs(for_duration: 5.seconds)
+          end
         end
       end
     end
-  end
 
-  context 'choosing uniform batches to run' do
-    subject { described_class.new(result_dir: result_dir, connection: connection) }
+    context 'choosing uniform batches to run' do
+      subject { described_class.new(result_dir: result_dir, connection: connection) }
 
-    describe '#uniform_fractions' do
-      it 'generates evenly distributed sequences of fractions' do
-        received = subject.uniform_fractions.take(9)
-        expected = [0, 1, 1.0 / 2, 1.0 / 4, 3.0 / 4, 1.0 / 8, 3.0 / 8, 5.0 / 8, 7.0 / 8]
+      describe '#uniform_fractions' do
+        it 'generates evenly distributed sequences of fractions' do
+          received = subject.uniform_fractions.take(9)
+          expected = [0, 1, 1.0 / 2, 1.0 / 4, 3.0 / 4, 1.0 / 8, 3.0 / 8, 5.0 / 8, 7.0 / 8]
 
-        # All the fraction numerators are small integers, and all denominators are powers of 2, so these
-        # fit perfectly into floating point numbers with zero loss of precision
-        expect(received).to eq(expected)
+          # All the fraction numerators are small integers, and all denominators are powers of 2, so these
+          # fit perfectly into floating point numbers with zero loss of precision
+          expect(received).to eq(expected)
+        end
       end
     end
   end
diff --git a/spec/models/environment_spec.rb b/spec/models/environment_spec.rb
index 3e1812aac9d..a5806910b23 100644
--- a/spec/models/environment_spec.rb
+++ b/spec/models/environment_spec.rb
@@ -1617,44 +1617,30 @@ RSpec.describe Environment, :use_clean_rails_memory_store_caching do
       nil        | nil
       'never'    | nil
     end
-    with_them do
-      it 'sets correct auto_stop_in' do
-        freeze_time do
-          if expected_result.is_a?(Integer) || expected_result.nil?
-            subject
 
-            expect(environment.auto_stop_in).to eq(expected_result)
-          else
-            expect(Gitlab::ErrorTracking).to receive(:track_exception).with(
-              an_instance_of(expected_result),
-              project_id: environment.project_id,
-              environment_id: environment.id
-            )
+    with_them do
+      shared_examples 'for given values expected result is set' do
+        it do
+          freeze_time do
+            if expected_result.is_a?(Integer) || expected_result.nil?
+              subject
 
-            expect { subject }.to raise_error(expected_result)
+              expect(environment.auto_stop_in).to eq(expected_result)
+            else
+              expect { subject }.to raise_error(expected_result)
+            end
           end
         end
       end
-    end
 
-    context 'resets earlier value' do
-      let(:environment) { create(:environment, auto_stop_at: 1.day.since.round) }
-
-      where(:value, :expected_result) do
-        '2 days'   | 2.days.to_i
-        '1 week'   | 1.week.to_i
-        '2h20min'  | 2.hours.to_i + 20.minutes.to_i
-        ''         | nil
-        'never'    | nil
+      context 'new assignment sets correct auto_stop_in' do
+        include_examples 'for given values expected result is set'
       end
-      with_them do
-        it 'assigns new value' do
-          freeze_time do
-            subject
 
-            expect(environment.auto_stop_in).to eq(expected_result)
-          end
-        end
+      context 'resets older value' do
+        let(:environment) { create(:environment, auto_stop_at: 1.day.since.round) }
+
+        include_examples 'for given values expected result is set'
       end
     end
   end
diff --git a/spec/policies/group_policy_spec.rb b/spec/policies/group_policy_spec.rb
index 5f8e582b1aa..184f7d676ba 100644
--- a/spec/policies/group_policy_spec.rb
+++ b/spec/policies/group_policy_spec.rb
@@ -1175,28 +1175,14 @@ RSpec.describe GroupPolicy do
       let(:current_user) { admin }
 
       context 'when admin mode is enabled', :enable_admin_mode do
-        context 'with runner_registration_control FF disabled' do
-          before do
-            stub_feature_flags(runner_registration_control: false)
-          end
-
-          it { is_expected.to be_allowed(:register_group_runners) }
-        end
+        it { is_expected.to be_allowed(:register_group_runners) }
 
-        context 'with runner_registration_control FF enabled' do
+        context 'with group runner registration disabled' do
           before do
-            stub_feature_flags(runner_registration_control: true)
+            stub_application_setting(valid_runner_registrars: ['project'])
           end
 
           it { is_expected.to be_allowed(:register_group_runners) }
-
-          context 'with group runner registration disabled' do
-            before do
-              stub_application_setting(valid_runner_registrars: ['project'])
-            end
-
-            it { is_expected.to be_allowed(:register_group_runners) }
-          end
         end
       end
 
@@ -1210,28 +1196,12 @@ RSpec.describe GroupPolicy do
 
       it { is_expected.to be_allowed(:register_group_runners) }
 
-      context 'with runner_registration_control FF disabled' do
-        before do
-          stub_feature_flags(runner_registration_control: false)
-        end
-
-        it { is_expected.to be_allowed(:register_group_runners) }
-      end
-
-      context 'with runner_registration_control FF enabled' do
+      context 'with group runner registration disabled' do
         before do
-          stub_feature_flags(runner_registration_control: true)
+          stub_application_setting(valid_runner_registrars: ['project'])
         end
 
-        it { is_expected.to be_allowed(:register_group_runners) }
-
-        context 'with group runner registration disabled' do
-          before do
-            stub_application_setting(valid_runner_registrars: ['project'])
-          end
-
-          it { is_expected.to be_disallowed(:register_group_runners) }
-        end
+        it { is_expected.to be_disallowed(:register_group_runners) }
       end
     end
 
diff --git a/spec/policies/project_policy_spec.rb b/spec/policies/project_policy_spec.rb
index 49709d47645..a7662634793 100644
--- a/spec/policies/project_policy_spec.rb
+++ b/spec/policies/project_policy_spec.rb
@@ -2630,28 +2630,14 @@ RSpec.describe ProjectPolicy do
       let(:current_user) { admin }
 
       context 'when admin mode is enabled', :enable_admin_mode do
-        context 'with runner_registration_control FF disabled' do
-          before do
-            stub_feature_flags(runner_registration_control: false)
-          end
-
-          it { is_expected.to be_allowed(:register_project_runners) }
-        end
+        it { is_expected.to be_allowed(:register_project_runners) }
 
-        context 'with runner_registration_control FF enabled' do
+        context 'with project runner registration disabled' do
           before do
-            stub_feature_flags(runner_registration_control: true)
+            stub_application_setting(valid_runner_registrars: ['group'])
           end
 
           it { is_expected.to be_allowed(:register_project_runners) }
-
-          context 'with project runner registration disabled' do
-            before do
-              stub_application_setting(valid_runner_registrars: ['group'])
-            end
-
-            it { is_expected.to be_allowed(:register_project_runners) }
-          end
         end
       end
 
@@ -2665,28 +2651,12 @@ RSpec.describe ProjectPolicy do
 
       it { is_expected.to be_allowed(:register_project_runners) }
 
-      context 'with runner_registration_control FF disabled' do
-        before do
-          stub_feature_flags(runner_registration_control: false)
-        end
-
-        it { is_expected.to be_allowed(:register_project_runners) }
-      end
-
-      context 'with runner_registration_control FF enabled' do
+      context 'with project runner registration disabled' do
         before do
-          stub_feature_flags(runner_registration_control: true)
+          stub_application_setting(valid_runner_registrars: ['group'])
         end
 
-        it { is_expected.to be_allowed(:register_project_runners) }
-
-        context 'with project runner registration disabled' do
-          before do
-            stub_application_setting(valid_runner_registrars: ['group'])
-          end
-
-          it { is_expected.to be_disallowed(:register_project_runners) }
-        end
+        it { is_expected.to be_disallowed(:register_project_runners) }
       end
     end
 
diff --git a/spec/requests/admin/impersonation_tokens_controller_spec.rb b/spec/requests/admin/impersonation_tokens_controller_spec.rb
index 2017a512bce..ee0e12ad0c0 100644
--- a/spec/requests/admin/impersonation_tokens_controller_spec.rb
+++ b/spec/requests/admin/impersonation_tokens_controller_spec.rb
@@ -10,6 +10,18 @@ RSpec.describe Admin::ImpersonationTokensController, :enable_admin_mode do
     sign_in(admin)
   end
 
+  context 'when impersonation is enabled' do
+    before do
+      stub_config_setting(impersonation_enabled: true)
+    end
+
+    it 'responds ok' do
+      get admin_user_impersonation_tokens_path(user_id: user.username)
+
+      expect(response).to have_gitlab_http_status(:ok)
+    end
+  end
+
   context "when impersonation is disabled" do
     before do
       stub_config_setting(impersonation_enabled: false)
diff --git a/spec/requests/api/ci/runner/runners_reset_spec.rb b/spec/requests/api/ci/runner/runners_reset_spec.rb
index 8a61012ead1..02b66a89a0a 100644
--- a/spec/requests/api/ci/runner/runners_reset_spec.rb
+++ b/spec/requests/api/ci/runner/runners_reset_spec.rb
@@ -9,7 +9,6 @@ RSpec.describe API::Ci::Runner, :clean_gitlab_redis_shared_state do
 
   before do
     stub_feature_flags(ci_enable_live_trace: true)
-    stub_feature_flags(runner_registration_control: false)
     stub_gitlab_calls
     stub_application_setting(valid_runner_registrars: ApplicationSetting::VALID_RUNNER_REGISTRAR_TYPES)
   end
diff --git a/spec/services/ci/runners/register_runner_service_spec.rb b/spec/services/ci/runners/register_runner_service_spec.rb
index 6d7b39de21e..2d1b109072f 100644
--- a/spec/services/ci/runners/register_runner_service_spec.rb
+++ b/spec/services/ci/runners/register_runner_service_spec.rb
@@ -9,7 +9,6 @@ RSpec.describe ::Ci::Runners::RegisterRunnerService, '#execute' do
   let(:runner) { execute.payload[:runner] }
 
   before do
-    stub_feature_flags(runner_registration_control: false)
     stub_application_setting(runners_registration_token: registration_token)
     stub_application_setting(valid_runner_registrars: ApplicationSetting::VALID_RUNNER_REGISTRAR_TYPES)
   end
@@ -166,25 +165,9 @@ RSpec.describe ::Ci::Runners::RegisterRunnerService, '#execute' do
           stub_application_setting(valid_runner_registrars: ['group'])
         end
 
-        context 'when feature flag is enabled' do
-          before do
-            stub_feature_flags(runner_registration_control: true)
-          end
-
-          it 'returns 403 error' do
-            expect(execute).to be_error
-            expect(execute.http_status).to eq :forbidden
-          end
-        end
-
-        context 'when feature flag is disabled' do
-          it 'registers the runner' do
-            expect(execute).to be_success
-
-            expect(runner).to be_an_instance_of(::Ci::Runner)
-            expect(runner.errors).to be_empty
-            expect(runner.active).to be true
-          end
+        it 'returns 403 error' do
+          expect(execute).to be_error
+          expect(execute.http_status).to eq :forbidden
         end
       end
     end
@@ -244,24 +227,8 @@ RSpec.describe ::Ci::Runners::RegisterRunnerService, '#execute' do
           stub_application_setting(valid_runner_registrars: ['project'])
         end
 
-        context 'when feature flag is enabled' do
-          before do
-            stub_feature_flags(runner_registration_control: true)
-          end
-
-          it 'returns error response' do
-            is_expected.to be_error
-          end
-        end
-
-        context 'when feature flag is disabled' do
-          it 'registers the runner' do
-            expect(execute).to be_success
-
-            expect(runner).to be_an_instance_of(::Ci::Runner)
-            expect(runner.errors).to be_empty
-            expect(runner.active).to be true
-          end
+        it 'returns error response' do
+          is_expected.to be_error
         end
       end
     end
diff --git a/spec/services/users/destroy_service_spec.rb b/spec/services/users/destroy_service_spec.rb
index c8ea7f704e2..efaac06c1f2 100644
--- a/spec/services/users/destroy_service_spec.rb
+++ b/spec/services/users/destroy_service_spec.rb
@@ -408,9 +408,10 @@ RSpec.describe Users::DestroyService do
         expect(resource_label_event.user).to be_nil
       end
 
-      it 'nullifies assigned_merge_requests, last_updated_merge_requests' do
+      it 'nullifies merge request associations' do
         merge_request = create(:merge_request, source_project: project, target_project: project,
                                                assignee: other_user, updated_by: other_user, merge_user: other_user)
+        merge_request.metrics.update!(merged_by: other_user, latest_closed_by: other_user)
 
         described_class.new(user).execute(other_user, skip_authorization: true)
 
@@ -420,6 +421,8 @@ RSpec.describe Users::DestroyService do
           expect(merge_request.updated_by).to be_nil
           expect(merge_request.assignee).to be_nil
           expect(merge_request.assignee_id).to be_nil
+          expect(merge_request.metrics.merged_by).to be_nil
+          expect(merge_request.metrics.latest_closed_by).to be_nil
         end
       end
     end
diff --git a/spec/views/admin/application_settings/ci_cd.html.haml_spec.rb b/spec/views/admin/application_settings/ci_cd.html.haml_spec.rb
index 4d40bf5671e..e4ebdd706d4 100644
--- a/spec/views/admin/application_settings/ci_cd.html.haml_spec.rb
+++ b/spec/views/admin/application_settings/ci_cd.html.haml_spec.rb
@@ -15,42 +15,17 @@ RSpec.describe 'admin/application_settings/ci_cd.html.haml' do
   end
 
   describe 'CI CD Runner Registration' do
-    context 'when feature flag is enabled' do
-      before do
-        stub_feature_flags(runner_registration_control: true)
-      end
+    it 'has the setting section' do
+      render
 
-      it 'has the setting section' do
-        render
-
-        expect(rendered).to have_css("#js-runner-settings")
-      end
-
-      it 'renders the correct setting section content' do
-        render
-
-        expect(rendered).to have_content("Runner registration")
-        expect(rendered).to have_content("If no options are selected, only administrators can register runners.")
-      end
+      expect(rendered).to have_css("#js-runner-settings")
     end
 
-    context 'when feature flag is disabled' do
-      before do
-        stub_feature_flags(runner_registration_control: false)
-      end
-
-      it 'does not have the setting section' do
-        render
-
-        expect(rendered).not_to have_css("#js-runner-settings")
-      end
-
-      it 'does not render the correct setting section content' do
-        render
+    it 'renders the correct setting section content' do
+      render
 
-        expect(rendered).not_to have_content("Runner registration")
-        expect(rendered).not_to have_content("If no options are selected, only administrators can register runners.")
-      end
+      expect(rendered).to have_content("Runner registration")
+      expect(rendered).to have_content("If no options are selected, only administrators can register runners.")
     end
   end
 end
diff --git a/spec/views/layouts/nav/sidebar/_profile.html.haml_spec.rb b/spec/views/layouts/nav/sidebar/_profile.html.haml_spec.rb
index 3d28be68b25..f5a0a7a935c 100644
--- a/spec/views/layouts/nav/sidebar/_profile.html.haml_spec.rb
+++ b/spec/views/layouts/nav/sidebar/_profile.html.haml_spec.rb
@@ -11,4 +11,20 @@ RSpec.describe 'layouts/nav/sidebar/_profile' do
 
   it_behaves_like 'has nav sidebar'
   it_behaves_like 'sidebar includes snowplow attributes', 'render', 'user_side_navigation', 'user_side_navigation'
+
+  it 'has a link to access tokens' do
+    render
+
+    expect(rendered).to have_link(_('Access Tokens'), href: profile_personal_access_tokens_path)
+  end
+
+  context 'when personal access tokens are disabled' do
+    it 'does not have a link to access tokens' do
+      allow(::Gitlab::CurrentSettings).to receive_messages(personal_access_tokens_disabled?: true)
+
+      render
+
+      expect(rendered).not_to have_link(_('Access Tokens'), href: profile_personal_access_tokens_path)
+    end
+  end
 end