Add latest changes from gitlab-org/gitlab@master

17 files changed, 307 insertions, 89 deletions

diff --git a/spec/factories/gitlab/database/reindexing/queued_action.rb b/spec/factories/gitlab/database/reindexing/queued_action.rb
new file mode 100644
index 00000000000..30e12a81272
--- /dev/null
+++ b/spec/factories/gitlab/database/reindexing/queued_action.rb
@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+FactoryBot.define do
+  factory :reindexing_queued_action, class: 'Gitlab::Database::Reindexing::QueuedAction' do
+    association :index, factory: :postgres_index
+
+    state { Gitlab::Database::Reindexing::QueuedAction.states[:queued] }
+    index_identifier { index.identifier }
+  end
+end
diff --git a/spec/features/groups/dependency_proxy_spec.rb b/spec/features/groups/dependency_proxy_spec.rb
index d6b0bdc8ea4..623fb065bfc 100644
--- a/spec/features/groups/dependency_proxy_spec.rb
+++ b/spec/features/groups/dependency_proxy_spec.rb
@@ -56,9 +56,14 @@ RSpec.describe 'Group Dependency Proxy' do
           visit settings_path
           wait_for_requests
 
-          click_button 'Enable Proxy'
+          proxy_toggle = find('[data-testid="dependency-proxy-setting-toggle"]')
+          proxy_toggle_button = proxy_toggle.find('button')
 
-          expect(page).to have_button 'Enable Proxy', class: '!is-checked'
+          expect(proxy_toggle).to have_css("button.is-checked")
+
+          proxy_toggle_button.click
+
+          expect(proxy_toggle).not_to have_css("button.is-checked")
 
           visit path
 
diff --git a/spec/features/issues/user_toggles_subscription_spec.rb b/spec/features/issues/user_toggles_subscription_spec.rb
index 9809bb34d26..541bbc8a8e7 100644
--- a/spec/features/issues/user_toggles_subscription_spec.rb
+++ b/spec/features/issues/user_toggles_subscription_spec.rb
@@ -45,7 +45,7 @@ RSpec.describe "User toggles subscription", :js do
 
       it 'is disabled' do
         expect(page).to have_content('Disabled by project owner')
-        expect(page).to have_button('Notifications', class: 'is-disabled')
+        expect(page).to have_selector('[data-testid="subscription-toggle"]', class: 'is-disabled')
       end
     end
   end
diff --git a/spec/features/projects/settings/packages_settings_spec.rb b/spec/features/projects/settings/packages_settings_spec.rb
index 62f31fd027b..e70839e9720 100644
--- a/spec/features/projects/settings/packages_settings_spec.rb
+++ b/spec/features/projects/settings/packages_settings_spec.rb
@@ -19,7 +19,7 @@ RSpec.describe 'Projects > Settings > Packages', :js do
     let(:packages_enabled) { true }
 
     it 'displays the packages toggle button' do
-      expect(page).to have_button('Packages', class: 'gl-toggle')
+      expect(page).to have_selector('[data-testid="toggle-label"]', text: 'Packages')
       expect(page).to have_selector('input[name="project[packages_enabled]"] + button', visible: true)
     end
   end
@@ -28,7 +28,7 @@ RSpec.describe 'Projects > Settings > Packages', :js do
     let(:packages_enabled) { false }
 
     it 'does not show up in UI' do
-      expect(page).not_to have_button('Packages', class: 'gl-toggle')
+      expect(page).not_to have_selector('[data-testid="toggle-label"]', text: 'Packages')
     end
   end
 end
diff --git a/spec/frontend/alerts_settings/components/alerts_settings_form_spec.js b/spec/frontend/alerts_settings/components/alerts_settings_form_spec.js
index 298596085ef..7e0d7ff93a1 100644
--- a/spec/frontend/alerts_settings/components/alerts_settings_form_spec.js
+++ b/spec/frontend/alerts_settings/components/alerts_settings_form_spec.js
@@ -58,7 +58,6 @@ describe('AlertsSettingsForm', () => {
   afterEach(() => {
     if (wrapper) {
       wrapper.destroy();
-      wrapper = null;
     }
   });
 
@@ -69,7 +68,7 @@ describe('AlertsSettingsForm', () => {
 
   const enableIntegration = (index, value) => {
     findFormFields().at(index).setValue(value);
-    findFormToggle().trigger('click');
+    findFormToggle().vm.$emit('change', true);
   };
 
   describe('with default values', () => {
diff --git a/spec/frontend/boards/components/sidebar/board_sidebar_subscription_spec.js b/spec/frontend/boards/components/sidebar/board_sidebar_subscription_spec.js
index 8847f626c1f..6e1b528babc 100644
--- a/spec/frontend/boards/components/sidebar/board_sidebar_subscription_spec.js
+++ b/spec/frontend/boards/components/sidebar/board_sidebar_subscription_spec.js
@@ -14,8 +14,8 @@ describe('~/boards/components/sidebar/board_sidebar_subscription_spec.vue', () =
   let store;
 
   const findNotificationHeader = () => wrapper.find("[data-testid='notification-header-text']");
-  const findToggle = () => wrapper.find(GlToggle);
-  const findGlLoadingIcon = () => wrapper.find(GlLoadingIcon);
+  const findToggle = () => wrapper.findComponent(GlToggle);
+  const findGlLoadingIcon = () => wrapper.findComponent(GlLoadingIcon);
 
   const createComponent = (activeBoardItem = { ...mockActiveIssue }) => {
     store = createStore();
@@ -32,7 +32,6 @@ describe('~/boards/components/sidebar/board_sidebar_subscription_spec.vue', () =
 
   afterEach(() => {
     wrapper.destroy();
-    wrapper = null;
     store = null;
     jest.clearAllMocks();
   });
@@ -104,7 +103,7 @@ describe('~/boards/components/sidebar/board_sidebar_subscription_spec.vue', () =
 
       expect(findGlLoadingIcon().exists()).toBe(false);
 
-      findToggle().trigger('click');
+      findToggle().vm.$emit('change');
 
       await wrapper.vm.$nextTick();
 
@@ -129,7 +128,7 @@ describe('~/boards/components/sidebar/board_sidebar_subscription_spec.vue', () =
 
       expect(findGlLoadingIcon().exists()).toBe(false);
 
-      findToggle().trigger('click');
+      findToggle().vm.$emit('change');
 
       await wrapper.vm.$nextTick();
 
@@ -152,7 +151,7 @@ describe('~/boards/components/sidebar/board_sidebar_subscription_spec.vue', () =
       });
       jest.spyOn(wrapper.vm, 'setError').mockImplementation(() => {});
 
-      findToggle().trigger('click');
+      findToggle().vm.$emit('change');
 
       await wrapper.vm.$nextTick();
       expect(wrapper.vm.setError).toHaveBeenCalled();
diff --git a/spec/frontend/pipelines/graph/graph_component_wrapper_spec.js b/spec/frontend/pipelines/graph/graph_component_wrapper_spec.js
index 2e8979f2b9d..db4de6deeb7 100644
--- a/spec/frontend/pipelines/graph/graph_component_wrapper_spec.js
+++ b/spec/frontend/pipelines/graph/graph_component_wrapper_spec.js
@@ -327,7 +327,7 @@ describe('Pipeline graph wrapper', () => {
         expect(getLinksLayer().exists()).toBe(true);
         expect(getLinksLayer().props('showLinks')).toBe(false);
         expect(getViewSelector().props('type')).toBe(LAYER_VIEW);
-        await getDependenciesToggle().trigger('click');
+        await getDependenciesToggle().vm.$emit('change', true);
         jest.runOnlyPendingTimers();
         await wrapper.vm.$nextTick();
         expect(wrapper.findComponent(LinksLayer).props('showLinks')).toBe(true);
diff --git a/spec/frontend/pipelines/graph/graph_view_selector_spec.js b/spec/frontend/pipelines/graph/graph_view_selector_spec.js
index 5b2a29de443..f4faa25545b 100644
--- a/spec/frontend/pipelines/graph/graph_view_selector_spec.js
+++ b/spec/frontend/pipelines/graph/graph_view_selector_spec.js
@@ -111,7 +111,7 @@ describe('the graph view selector component', () => {
       expect(wrapper.emitted().updateShowLinksState).toBeUndefined();
       expect(findToggleLoader().exists()).toBe(false);
 
-      await findDependenciesToggle().trigger('click');
+      await findDependenciesToggle().vm.$emit('change', true);
       /*
         Loading happens before the event is emitted or timers are run.
         Then we run the timer because the event is emitted in setInterval
diff --git a/spec/lib/gitlab/database/gitlab_schema_spec.rb b/spec/lib/gitlab/database/gitlab_schema_spec.rb
index 02a9f6eef7b..4f94ce2e541 100644
--- a/spec/lib/gitlab/database/gitlab_schema_spec.rb
+++ b/spec/lib/gitlab/database/gitlab_schema_spec.rb
@@ -2,28 +2,37 @@
 require 'spec_helper'
 
 RSpec.describe Gitlab::Database::GitlabSchema do
-  it 'matches all the tables in the database', :aggregate_failures do
-    # These tables do not need a gitlab_schema
-    excluded_tables = %w(ar_internal_metadata schema_migrations)
+  describe '.tables_to_schema' do
+    subject { described_class.tables_to_schema }
 
-    all_tables_in_database = ApplicationRecord.connection.tables
+    it 'all tables have assigned a known gitlab_schema' do
+      is_expected.to all(
+        match([be_a(String), be_in([:gitlab_shared, :gitlab_main, :gitlab_ci])])
+      )
+    end
 
-    all_tables_with_gitlab_schema = described_class.tables_to_schema.keys
+    # This being run across different databases indirectly also tests
+    # a general consistency of structure across databases
+    Gitlab::Database.database_base_models.each do |db_config_name, db_class|
+      let(:db_data_sources) { db_class.connection.data_sources }
 
-    missing = []
-    all_tables_in_database.each do |table_in_database|
-      next if table_in_database.in?(excluded_tables)
+      context "for #{db_config_name} using #{db_class}" do
+        it 'new data sources are added' do
+          missing_tables = db_data_sources.to_set - subject.keys
 
-      missing << table_in_database unless all_tables_with_gitlab_schema.include?(table_in_database)
-    end
+          expect(missing_tables).to be_empty, \
+            "Missing table(s) #{missing_tables.to_a} not found in #{described_class}.tables_to_schema. " \
+            "Any new tables must be added to lib/gitlab/database/gitlab_schemas.yml."
+        end
 
-    extras = []
-    all_tables_with_gitlab_schema.each do |table_with_gitlab_schema|
-      extras << table_with_gitlab_schema unless all_tables_in_database.include?(table_with_gitlab_schema)
-    end
+        it 'non-existing data sources are removed' do
+          extra_tables = subject.keys.to_set - db_data_sources
 
-    expect(missing).to be_empty, "Missing table(s) #{missing} not found in #{described_class}.tables_to_schema. Any new tables must be added to spec/support/database/gitlab_schemas.yml ."
-
-    expect(extras).to be_empty, "Extra table(s) #{extras} found in #{described_class}.tables_to_schema. Any removed or renamed tables must be removed from spec/support/database/gitlab_schemas.yml ."
+          expect(extra_tables).to be_empty, \
+            "Extra table(s) #{extra_tables.to_a} found in #{described_class}.tables_to_schema. " \
+            "Any removed or renamed tables must be removed from lib/gitlab/database/gitlab_schemas.yml."
+        end
+      end
+    end
   end
 end
diff --git a/spec/lib/gitlab/database/migrations/observers/transaction_duration_spec.rb b/spec/lib/gitlab/database/migrations/observers/transaction_duration_spec.rb
new file mode 100644
index 00000000000..e65f89747c4
--- /dev/null
+++ b/spec/lib/gitlab/database/migrations/observers/transaction_duration_spec.rb
@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+require 'spec_helper'
+
+RSpec.describe Gitlab::Database::Migrations::Observers::TransactionDuration do
+  subject(:transaction_duration_observer) { described_class.new(observation, directory_path) }
+
+  let(:observation) { Gitlab::Database::Migrations::Observation.new(migration_version, migration_name) }
+  let(:directory_path) { Dir.mktmpdir }
+  let(:log_file) { "#{directory_path}/#{migration_version}_#{migration_name}-transaction-duration.json" }
+  let(:transaction_duration) { Gitlab::Json.parse(File.read(log_file)) }
+  let(:migration_version) { 20210422152437 }
+  let(:migration_name) { 'test' }
+
+  after do
+    FileUtils.remove_entry(directory_path)
+  end
+
+  it 'records real and sub transactions duration', :delete do
+    observe
+
+    entry = transaction_duration[0]
+    start_time, end_time, transaction_type = entry.values_at('start_time', 'end_time', 'transaction_type')
+    start_time = DateTime.parse(start_time)
+    end_time = DateTime.parse(end_time)
+
+    aggregate_failures do
+      expect(transaction_duration.size).to eq(3)
+      expect(start_time).to be_before(end_time)
+      expect(transaction_type).not_to be_nil
+    end
+  end
+
+  context 'when there are sub-transactions' do
+    it 'records transaction duration' do
+      observe_sub_transaction
+
+      expect(transaction_duration.size).to eq(1)
+
+      entry = transaction_duration[0]['transaction_type']
+
+      expect(entry).to eql 'sub_transaction'
+    end
+  end
+
+  context 'when there are real-transactions' do
+    it 'records transaction duration', :delete do
+      observe_real_transaction
+
+      expect(transaction_duration.size).to eq(1)
+
+      entry = transaction_duration[0]['transaction_type']
+
+      expect(entry).to eql 'real_transaction'
+    end
+  end
+
+  private
+
+  def observe
+    transaction_duration_observer.before
+    run_transaction
+    transaction_duration_observer.after
+    transaction_duration_observer.record
+  end
+
+  def observe_sub_transaction
+    transaction_duration_observer.before
+    run_sub_transactions
+    transaction_duration_observer.after
+    transaction_duration_observer.record
+  end
+
+  def observe_real_transaction
+    transaction_duration_observer.before
+    run_real_transactions
+    transaction_duration_observer.after
+    transaction_duration_observer.record
+  end
+
+  def run_real_transactions
+    ActiveRecord::Base.transaction do
+    end
+  end
+
+  def run_sub_transactions
+    ActiveRecord::Base.transaction(requires_new: true) do
+    end
+  end
+
+  def run_transaction
+    ActiveRecord::Base.connection_pool.with_connection do |connection|
+      Gitlab::Database::SharedModel.using_connection(connection) do
+        Gitlab::Database::SharedModel.transaction do
+          Gitlab::Database::SharedModel.transaction(requires_new: true) do
+            Gitlab::Database::SharedModel.transaction do
+              Gitlab::Database::SharedModel.transaction do
+                Gitlab::Database::SharedModel.transaction(requires_new: true) do
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end
diff --git a/spec/lib/gitlab/database/reindexing_spec.rb b/spec/lib/gitlab/database/reindexing_spec.rb
index 550f9db2b5b..13aff343432 100644
--- a/spec/lib/gitlab/database/reindexing_spec.rb
+++ b/spec/lib/gitlab/database/reindexing_spec.rb
@@ -4,10 +4,63 @@ require 'spec_helper'
 
 RSpec.describe Gitlab::Database::Reindexing do
   include ExclusiveLeaseHelpers
+  include Database::DatabaseHelpers
 
-  describe '.perform' do
-    subject { described_class.perform(candidate_indexes) }
+  describe '.automatic_reindexing' do
+    subject { described_class.automatic_reindexing(maximum_records: limit) }
 
+    let(:limit) { 5 }
+
+    before_all do
+      swapout_view_for_table(:postgres_indexes)
+    end
+
+    before do
+      allow(Gitlab::Database::Reindexing).to receive(:cleanup_leftovers!)
+      allow(Gitlab::Database::Reindexing).to receive(:perform_from_queue).and_return(0)
+      allow(Gitlab::Database::Reindexing).to receive(:perform_with_heuristic).and_return(0)
+    end
+
+    it 'cleans up leftovers, before consuming the queue' do
+      expect(Gitlab::Database::Reindexing).to receive(:cleanup_leftovers!).ordered
+      expect(Gitlab::Database::Reindexing).to receive(:perform_from_queue).ordered
+
+      subject
+    end
+
+    context 'with records in the queue' do
+      before do
+        create(:reindexing_queued_action)
+      end
+
+      context 'with enough records in the queue to reach limit' do
+        let(:limit) { 1 }
+
+        it 'does not perform reindexing with heuristic' do
+          expect(Gitlab::Database::Reindexing).to receive(:perform_from_queue).and_return(limit)
+          expect(Gitlab::Database::Reindexing).not_to receive(:perform_with_heuristic)
+
+          subject
+        end
+      end
+
+      context 'without enough records in the queue to reach limit' do
+        let(:limit) { 2 }
+
+        it 'continues if the queue did not have enough records' do
+          expect(Gitlab::Database::Reindexing).to receive(:perform_from_queue).ordered.and_return(1)
+          expect(Gitlab::Database::Reindexing).to receive(:perform_with_heuristic).with(maximum_records: 1).ordered
+
+          subject
+        end
+      end
+    end
+  end
+
+  describe '.perform_with_heuristic' do
+    subject { described_class.perform_with_heuristic(candidate_indexes, maximum_records: limit) }
+
+    let(:limit) { 2 }
     let(:coordinator) { instance_double(Gitlab::Database::Reindexing::Coordinator) }
     let(:index_selection) { instance_double(Gitlab::Database::Reindexing::IndexSelection) }
     let(:candidate_indexes) { double }
@@ -15,7 +68,7 @@ RSpec.describe Gitlab::Database::Reindexing do
 
     it 'delegates to Coordinator' do
       expect(Gitlab::Database::Reindexing::IndexSelection).to receive(:new).with(candidate_indexes).and_return(index_selection)
-      expect(index_selection).to receive(:take).with(2).and_return(indexes)
+      expect(index_selection).to receive(:take).with(limit).and_return(indexes)
 
       indexes.each do |index|
         expect(Gitlab::Database::Reindexing::Coordinator).to receive(:new).with(index).and_return(coordinator)
@@ -26,6 +79,59 @@ RSpec.describe Gitlab::Database::Reindexing do
     end
   end
 
+  describe '.perform_from_queue' do
+    subject { described_class.perform_from_queue(maximum_records: limit) }
+
+    before_all do
+      swapout_view_for_table(:postgres_indexes)
+    end
+
+    let(:limit) { 2 }
+    let(:queued_actions) { create_list(:reindexing_queued_action, 3) }
+    let(:coordinator) { instance_double(Gitlab::Database::Reindexing::Coordinator) }
+
+    before do
+      queued_actions.take(limit).each do |action|
+        allow(Gitlab::Database::Reindexing::Coordinator).to receive(:new).with(action.index).and_return(coordinator)
+        allow(coordinator).to receive(:perform)
+      end
+    end
+
+    it 'consumes the queue in order of created_at and applies the limit' do
+      queued_actions.take(limit).each do |action|
+        expect(Gitlab::Database::Reindexing::Coordinator).to receive(:new).ordered.with(action.index).and_return(coordinator)
+        expect(coordinator).to receive(:perform)
+      end
+
+      subject
+    end
+
+    it 'updates queued action and sets state to done' do
+      subject
+
+      queue = queued_actions
+
+      queue.shift(limit).each do |action|
+        expect(action.reload.state).to eq('done')
+      end
+
+      queue.each do |action|
+        expect(action.reload.state).to eq('queued')
+      end
+    end
+
+    it 'updates queued action upon error and sets state to failed' do
+      expect(Gitlab::Database::Reindexing::Coordinator).to receive(:new).ordered.with(queued_actions.first.index).and_return(coordinator)
+      expect(coordinator).to receive(:perform).and_raise('something went wrong')
+
+      subject
+
+      states = queued_actions.map(&:reload).map(&:state)
+
+      expect(states).to eq(%w(failed done queued))
+    end
+  end
+
   describe '.cleanup_leftovers!' do
     subject { described_class.cleanup_leftovers! }
 
diff --git a/spec/models/key_spec.rb b/spec/models/key_spec.rb
index 7468c1b9f0a..d41a1604211 100644
--- a/spec/models/key_spec.rb
+++ b/spec/models/key_spec.rb
@@ -85,9 +85,9 @@ RSpec.describe Key, :mailer do
       let_it_be(:expiring_soon_notified) { create(:key, expires_at: 4.days.from_now, user: user, before_expiry_notification_delivered_at: Time.current) }
       let_it_be(:future_expiry) { create(:key, expires_at: 1.month.from_now, user: user) }
 
-      describe '.expired_and_not_notified' do
+      describe '.expired_today_and_not_notified' do
         it 'returns keys that expire today and in the past' do
-          expect(described_class.expired_and_not_notified).to contain_exactly(expired_today_not_notified, expired_yesterday)
+          expect(described_class.expired_today_and_not_notified).to contain_exactly(expired_today_not_notified)
         end
       end
 
diff --git a/spec/models/user_spec.rb b/spec/models/user_spec.rb
index 21c5aea514a..cad9ad81a32 100644
--- a/spec/models/user_spec.rb
+++ b/spec/models/user_spec.rb
@@ -98,7 +98,7 @@ RSpec.describe User do
     it { is_expected.to have_many(:group_members) }
     it { is_expected.to have_many(:groups) }
     it { is_expected.to have_many(:keys).dependent(:destroy) }
-    it { is_expected.to have_many(:expired_and_unnotified_keys) }
+    it { is_expected.to have_many(:expired_today_and_unnotified_keys) }
     it { is_expected.to have_many(:deploy_keys).dependent(:nullify) }
     it { is_expected.to have_many(:group_deploy_keys) }
     it { is_expected.to have_many(:events).dependent(:delete_all) }
diff --git a/spec/services/loose_foreign_keys/batch_cleaner_service_spec.rb b/spec/services/loose_foreign_keys/batch_cleaner_service_spec.rb
index dcef419cc9a..409bbfb4098 100644
--- a/spec/services/loose_foreign_keys/batch_cleaner_service_spec.rb
+++ b/spec/services/loose_foreign_keys/batch_cleaner_service_spec.rb
@@ -79,6 +79,8 @@ RSpec.describe LooseForeignKeys::BatchCleanerService do
   end
 
   context 'when parent records are deleted' do
+    let(:deleted_records_counter) { Gitlab::Metrics.registry.get(:loose_foreign_key_processed_deleted_records) }
+
     before do
       parent_record_1.delete
 
@@ -98,8 +100,15 @@ RSpec.describe LooseForeignKeys::BatchCleanerService do
       expect(loose_fk_child_table_2.where(parent_id_with_different_column: nil).count).to eq(2)
     end
 
-    it 'cleans up the parent DeletedRecord' do
+    it 'cleans up the pending parent DeletedRecord' do
       expect(LooseForeignKeys::DeletedRecord.status_pending.count).to eq(0)
+      expect(LooseForeignKeys::DeletedRecord.status_processed.count).to eq(1)
+    end
+
+    it 'records the DeletedRecord status updates', :prometheus do
+      counter = Gitlab::Metrics.registry.get(:loose_foreign_key_processed_deleted_records)
+
+      expect(counter.get(table: parent_model.table_name, db_config_name: 'main')).to eq(1)
     end
 
     it 'does not delete unrelated records' do
diff --git a/spec/support/shared_examples/features/sidebar_shared_examples.rb b/spec/support/shared_examples/features/sidebar_shared_examples.rb
index 5bfe929e957..d509d124de0 100644
--- a/spec/support/shared_examples/features/sidebar_shared_examples.rb
+++ b/spec/support/shared_examples/features/sidebar_shared_examples.rb
@@ -52,16 +52,17 @@ RSpec.shared_examples 'issue boards sidebar' do
 
     it 'shows toggle as on then as off as user toggles to subscribe and unsubscribe', :aggregate_failures do
       wait_for_requests
+      subscription_button = find('[data-testid="subscription-toggle"]')
 
-      click_button 'Notifications'
+      subscription_button.click
 
-      expect(page).to have_button('Notifications', class: 'is-checked')
+      expect(subscription_button).to have_css("button.is-checked")
 
-      click_button 'Notifications'
+      subscription_button.click
 
       wait_for_requests
 
-      expect(page).not_to have_button('Notifications', class: 'is-checked')
+      expect(subscription_button).to have_css("button:not(.is-checked)")
     end
 
     context 'when notifications have been disabled' do
@@ -73,7 +74,7 @@ RSpec.shared_examples 'issue boards sidebar' do
 
       it 'displays a message that notifications have been disabled' do
         page.within('[data-testid="sidebar-notifications"]') do
-          expect(page).to have_button('Notifications', class: 'is-disabled')
+          expect(page).to have_selector('[data-testid="subscription-toggle"]', class: 'is-disabled')
           expect(page).to have_content('Disabled by project owner')
         end
       end
diff --git a/spec/tasks/gitlab/db_rake_spec.rb b/spec/tasks/gitlab/db_rake_spec.rb
index 5e88b71733d..a273c8cfd7d 100644
--- a/spec/tasks/gitlab/db_rake_spec.rb
+++ b/spec/tasks/gitlab/db_rake_spec.rb
@@ -215,7 +215,7 @@ RSpec.describe 'gitlab:db namespace rake task', :silence_stdout do
         stub_feature_flags(database_async_index_creation: true)
 
         expect(Gitlab::Database::AsyncIndexes).to receive(:create_pending_indexes!).ordered.exactly(databases_count).times
-        expect(Gitlab::Database::Reindexing).to receive(:perform).ordered.exactly(databases_count).times
+        expect(Gitlab::Database::Reindexing).to receive(:automatic_reindexing).ordered.once
 
         run_rake_task('gitlab:db:reindex')
       end
@@ -231,56 +231,30 @@ RSpec.describe 'gitlab:db namespace rake task', :silence_stdout do
       end
     end
 
-    context 'when no index_name is given' do
+    context 'calls automatic reindexing' do
       it 'uses all candidate indexes' do
-        expect(Gitlab::Database::PostgresIndex).to receive(:reindexing_support).exactly(databases_count).times.and_return(indexes)
-        expect(Gitlab::Database::Reindexing).to receive(:perform).with(indexes).exactly(databases_count).times
+        expect(Gitlab::Database::Reindexing).to receive(:automatic_reindexing).once
 
         run_rake_task('gitlab:db:reindex')
       end
     end
+  end
 
-    context 'with index name given' do
-      let(:index) { double('index') }
-
-      before do
-        allow(Gitlab::Database::PostgresIndex).to receive(:reindexing_support).and_return(indexes)
-      end
-
-      it 'calls the index rebuilder with the proper arguments' do
-        allow(indexes).to receive(:where).with(identifier: 'public.foo_idx').and_return([index])
-        expect(Gitlab::Database::Reindexing).to receive(:perform).with([index]).ordered
-        expect(Gitlab::Database::Reindexing).to receive(:perform).with(indexes).ordered if databases.many?
-
-        run_rake_task('gitlab:db:reindex', '[public.foo_idx]')
-      end
-
-      context 'when database name is provided' do
-        it 'calls the index rebuilder with the proper arguments when the database name match' do
-          allow(indexes).to receive(:where).with(identifier: 'public.foo_idx').and_return([index])
-          expect(Gitlab::Database::Reindexing).to receive(:perform).with([index]).ordered
-          expect(Gitlab::Database::Reindexing).to receive(:perform).with(indexes).ordered if databases.many?
-
-          run_rake_task('gitlab:db:reindex', '[public.foo_idx,main]')
-        end
-
-        it 'ignores the index and uses all candidate indexes if database name does not match' do
-          expect(Gitlab::Database::PostgresIndex).to receive(:reindexing_support).exactly(databases_count).times.and_return(indexes)
-          expect(Gitlab::Database::Reindexing).to receive(:perform).with(indexes).exactly(databases_count).times
-
-          run_rake_task('gitlab:db:reindex', '[public.foo_idx,no_such_database]')
-        end
-      end
+  describe 'enqueue_reindexing_action' do
+    let(:index_name) { 'public.users_pkey' }
 
-      it 'raises an error if the index does not exist' do
-        allow(indexes).to receive(:where).with(identifier: 'public.absent_index').and_return([])
+    it 'creates an entry in the queue' do
+      expect do
+        run_rake_task('gitlab:db:enqueue_reindexing_action', "[#{index_name}, main]")
+      end.to change { Gitlab::Database::PostgresIndex.find(index_name).queued_reindexing_actions.size }.from(0).to(1)
+    end
 
-        expect { run_rake_task('gitlab:db:reindex', '[public.absent_index]') }.to raise_error(/Index public.absent_index for main database not found or not supported/)
-      end
+    it 'defaults to main database' do
+      expect(Gitlab::Database::SharedModel).to receive(:using_connection).with(Gitlab::Database.main.scope.connection).and_call_original
 
-      it 'raises an error if the index is not fully qualified with a schema' do
-        expect { run_rake_task('gitlab:db:reindex', '[foo_idx]') }.to raise_error(/Index name is not fully qualified/)
-      end
+      expect do
+        run_rake_task('gitlab:db:enqueue_reindexing_action', "[#{index_name}]")
+      end.to change { Gitlab::Database::PostgresIndex.find(index_name).queued_reindexing_actions.size }.from(0).to(1)
     end
   end
 
diff --git a/spec/workers/ssh_keys/expired_notification_worker_spec.rb b/spec/workers/ssh_keys/expired_notification_worker_spec.rb
index 109d24f03ab..be38391ff8c 100644
--- a/spec/workers/ssh_keys/expired_notification_worker_spec.rb
+++ b/spec/workers/ssh_keys/expired_notification_worker_spec.rb
@@ -20,7 +20,7 @@ RSpec.describe SshKeys::ExpiredNotificationWorker, type: :worker do
         stub_const("SshKeys::ExpiredNotificationWorker::BATCH_SIZE", 5)
       end
 
-      let_it_be_with_reload(:keys) { create_list(:key, 20, expires_at: 3.days.ago, user: user) }
+      let_it_be_with_reload(:keys) { create_list(:key, 20, expires_at: Time.current, user: user) }
 
       it 'updates all keys regardless of batch size' do
         worker.perform
@@ -54,8 +54,8 @@ RSpec.describe SshKeys::ExpiredNotificationWorker, type: :worker do
     context 'when key has expired in the past' do
       let_it_be(:expired_past) { create(:key, expires_at: 1.day.ago, user: user) }
 
-      it 'does update notified column' do
-        expect { worker.perform }.to change { expired_past.reload.expiry_notification_delivered_at }
+      it 'does not update notified column' do
+        expect { worker.perform }.not_to change { expired_past.reload.expiry_notification_delivered_at }
       end
 
       context 'when key has already been notified of expiration' do