Add latest changes from gitlab-org/gitlab@16-2-stable-eev16.2.0-rc42

48 files changed, 356 insertions, 1069 deletions

diff --git a/spec/lib/gitlab/database/async_indexes/migration_helpers_spec.rb b/spec/lib/gitlab/database/async_indexes/migration_helpers_spec.rb
index b2ba1a60fbb..309bbf1e3f0 100644
--- a/spec/lib/gitlab/database/async_indexes/migration_helpers_spec.rb
+++ b/spec/lib/gitlab/database/async_indexes/migration_helpers_spec.rb
@@ -223,6 +223,21 @@ RSpec.describe Gitlab::Database::AsyncIndexes::MigrationHelpers, feature_categor
                 expect(async_index).to have_attributes(table_name: table_name, definition: index_definition)
               end
             end
+
+            context 'when the given SQL has whitespace' do
+              let(:index_definition) { "    #{super()}" }
+              let(:async_index) { index_model.find_by(name: index_name) }
+
+              it 'creates the async index record' do
+                expect { prepare_async_index_from_sql }.to change { index_model.where(name: index_name).count }.by(1)
+              end
+
+              it 'sets the async index attributes correctly' do
+                prepare_async_index_from_sql
+
+                expect(async_index).to have_attributes(table_name: table_name, definition: index_definition.strip)
+              end
+            end
           end
         end
       end
diff --git a/spec/lib/gitlab/database/async_indexes/postgres_async_index_spec.rb b/spec/lib/gitlab/database/async_indexes/postgres_async_index_spec.rb
index 9e37124ba28..7e111dbe08f 100644
--- a/spec/lib/gitlab/database/async_indexes/postgres_async_index_spec.rb
+++ b/spec/lib/gitlab/database/async_indexes/postgres_async_index_spec.rb
@@ -55,6 +55,21 @@ RSpec.describe Gitlab::Database::AsyncIndexes::PostgresAsyncIndex, type: :model,
 
       it_behaves_like 'table_name is invalid'
     end
+
+    context 'when passing a definition with beginning or trailing whitespace' do
+      let(:model) { super().tap { |m| m.definition = definition } }
+      let(:definition) do
+        <<-SQL
+          CREATE UNIQUE INDEX CONCURRENTLY foo_index ON bar_field (uuid);
+        SQL
+      end
+
+      it "strips the definition field" do
+        expect(model).to be_valid
+        model.save!
+        expect(model.definition).to eq(definition.strip)
+      end
+    end
   end
 
   describe 'scopes' do
diff --git a/spec/lib/gitlab/database/click_house_client_spec.rb b/spec/lib/gitlab/database/click_house_client_spec.rb
new file mode 100644
index 00000000000..502d879bf6a
--- /dev/null
+++ b/spec/lib/gitlab/database/click_house_client_spec.rb
@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe 'ClickHouse::Client', feature_category: :database do
+  context 'when click_house spec tag is not added' do
+    it 'does not have any ClickHouse databases configured' do
+      databases = ClickHouse::Client.configuration.databases
+
+      expect(databases).to be_empty
+    end
+  end
+
+  describe 'when click_house spec tag is added', :click_house do
+    around do |example|
+      with_net_connect_allowed do
+        example.run
+      end
+    end
+
+    it 'has a ClickHouse database configured' do
+      databases = ClickHouse::Client.configuration.databases
+
+      expect(databases).not_to be_empty
+    end
+
+    it 'returns data from the DB via `select` method' do
+      result = ClickHouse::Client.select("SELECT 1 AS value", :main)
+
+      # returns JSON if successful. Otherwise error
+      expect(result).to eq([{ 'value' => 1 }])
+    end
+
+    it 'does not return data via `execute` method' do
+      result = ClickHouse::Client.execute("SELECT 1 AS value", :main)
+
+      # does not return data, just true if successful. Otherwise error.
+      expect(result).to eq(true)
+    end
+
+    describe 'data manipulation' do
+      describe 'inserting' do
+        let_it_be(:group) { create(:group) }
+        let_it_be(:project) { create(:project) }
+
+        let_it_be(:author1) { create(:user).tap { |u| project.add_developer(u) } }
+        let_it_be(:author2) { create(:user).tap { |u| project.add_developer(u) } }
+
+        let_it_be(:issue1) { create(:issue, project: project) }
+        let_it_be(:issue2) { create(:issue, project: project) }
+        let_it_be(:merge_request) { create(:merge_request, source_project: project) }
+
+        let_it_be(:event1) { create(:event, :created, target: issue1, author: author1) }
+        let_it_be(:event2) { create(:event, :closed, target: issue2, author: author2) }
+        let_it_be(:event3) { create(:event, :merged, target: merge_request, author: author1) }
+
+        let(:events) { [event1, event2, event3] }
+
+        def format_row(event)
+          path = event.project.reload.project_namespace.traversal_ids.join('/')
+
+          action = Event.actions[event.action]
+          [
+            event.id,
+            "'#{path}/'",
+            event.author_id,
+            event.target_id,
+            "'#{event.target_type}'",
+            action,
+            event.created_at.to_f,
+            event.updated_at.to_f
+          ].join(',')
+        end
+
+        describe 'RSpec hooks' do
+          it 'ensures that tables are empty' do
+            results = ClickHouse::Client.select('SELECT * FROM events', :main)
+            expect(results).to be_empty
+          end
+        end
+
+        it 'inserts and modifies data' do
+          insert_query = <<~SQL
+          INSERT INTO events
+          (id, path, author_id, target_id, target_type, action, created_at, updated_at)
+          VALUES
+          (#{format_row(event1)}),
+          (#{format_row(event2)}),
+          (#{format_row(event3)})
+          SQL
+
+          ClickHouse::Client.execute(insert_query, :main)
+
+          results = ClickHouse::Client.select('SELECT * FROM events ORDER BY id', :main)
+          expect(results.size).to eq(3)
+
+          last = results.last
+          expect(last).to match(a_hash_including(
+            'id' => event3.id,
+            'author_id' => event3.author_id,
+            'created_at' => be_within(0.05).of(event3.created_at),
+            'target_type' => event3.target_type
+          ))
+
+          ClickHouse::Client.execute("DELETE FROM events WHERE id = #{event3.id}", :main)
+
+          results = ClickHouse::Client.select("SELECT * FROM events WHERE id = #{event3.id}", :main)
+          expect(results).to be_empty
+        end
+      end
+    end
+  end
+end
diff --git a/spec/lib/gitlab/database/each_database_spec.rb b/spec/lib/gitlab/database/each_database_spec.rb
index 2653297c81a..d0e3c83076c 100644
--- a/spec/lib/gitlab/database/each_database_spec.rb
+++ b/spec/lib/gitlab/database/each_database_spec.rb
@@ -3,7 +3,7 @@
 require 'spec_helper'
 
 RSpec.describe Gitlab::Database::EachDatabase do
-  describe '.each_database_connection', :add_ci_connection do
+  describe '.each_connection', :add_ci_connection do
     let(:database_base_models) { { main: ActiveRecord::Base, ci: Ci::ApplicationRecord }.with_indifferent_access }
 
     before do
@@ -17,7 +17,7 @@ RSpec.describe Gitlab::Database::EachDatabase do
       expect(Gitlab::Database::SharedModel).to receive(:using_connection)
         .with(Ci::ApplicationRecord.connection).ordered.and_yield
 
-      expect { |b| described_class.each_database_connection(&b) }
+      expect { |b| described_class.each_connection(&b) }
         .to yield_successive_args(
           [ActiveRecord::Base.connection, 'main'],
           [Ci::ApplicationRecord.connection, 'ci']
@@ -29,7 +29,7 @@ RSpec.describe Gitlab::Database::EachDatabase do
         expect(Gitlab::Database::SharedModel).to receive(:using_connection)
           .with(Ci::ApplicationRecord.connection).ordered.and_yield
 
-        expect { |b| described_class.each_database_connection(only: 'ci', &b) }
+        expect { |b| described_class.each_connection(only: 'ci', &b) }
           .to yield_successive_args([Ci::ApplicationRecord.connection, 'ci'])
       end
 
@@ -38,7 +38,7 @@ RSpec.describe Gitlab::Database::EachDatabase do
           expect(Gitlab::Database::SharedModel).to receive(:using_connection)
             .with(Ci::ApplicationRecord.connection).ordered.and_yield
 
-          expect { |b| described_class.each_database_connection(only: :ci, &b) }
+          expect { |b| described_class.each_connection(only: :ci, &b) }
             .to yield_successive_args([Ci::ApplicationRecord.connection, 'ci'])
         end
       end
@@ -46,7 +46,7 @@ RSpec.describe Gitlab::Database::EachDatabase do
       context 'when the selected names are invalid' do
         it 'does not yield any connections' do
           expect do |b|
-            described_class.each_database_connection(only: :notvalid, &b)
+            described_class.each_connection(only: :notvalid, &b)
           rescue ArgumentError => e
             expect(e.message).to match(/notvalid is not a valid database name/)
           end.not_to yield_control
@@ -54,7 +54,7 @@ RSpec.describe Gitlab::Database::EachDatabase do
 
         it 'raises an error' do
           expect do
-            described_class.each_database_connection(only: :notvalid) {}
+            described_class.each_connection(only: :notvalid) {}
           end.to raise_error(ArgumentError, /notvalid is not a valid database name/)
         end
       end
@@ -78,7 +78,7 @@ RSpec.describe Gitlab::Database::EachDatabase do
           db_config.name != 'main' ? 'main' : nil
         end
 
-        expect { |b| described_class.each_database_connection(include_shared: false, &b) }
+        expect { |b| described_class.each_connection(include_shared: false, &b) }
           .to yield_successive_args([ActiveRecord::Base.connection, 'main'])
       end
     end
diff --git a/spec/lib/gitlab/database/gitlab_schema_spec.rb b/spec/lib/gitlab/database/gitlab_schema_spec.rb
index 48f5cdb995b..1c864239ae6 100644
--- a/spec/lib/gitlab/database/gitlab_schema_spec.rb
+++ b/spec/lib/gitlab/database/gitlab_schema_spec.rb
@@ -29,6 +29,9 @@ RSpec.describe Gitlab::Database::GitlabSchema, feature_category: :database do
       'audit_events_part_5fc467ac26'                 | :gitlab_main
       '_test_gitlab_main_table'                      | :gitlab_main
       '_test_gitlab_ci_table'                        | :gitlab_ci
+      '_test_gitlab_main_clusterwide_table'          | :gitlab_main_clusterwide
+      '_test_gitlab_main_cell_table'                 | :gitlab_main_cell
+      '_test_gitlab_pm_table'                        | :gitlab_pm
       '_test_my_table'                               | :gitlab_shared
       'pg_attribute'                                 | :gitlab_internal
     end
diff --git a/spec/lib/gitlab/database/health_status_spec.rb b/spec/lib/gitlab/database/health_status_spec.rb
index bc923635b1d..4a2b9eee45a 100644
--- a/spec/lib/gitlab/database/health_status_spec.rb
+++ b/spec/lib/gitlab/database/health_status_spec.rb
@@ -98,7 +98,7 @@ RSpec.describe Gitlab::Database::HealthStatus, feature_category: :database do
         end
 
         let(:deferred_worker_health_checker) do
-          Gitlab::SidekiqMiddleware::DeferJobs::DatabaseHealthStatusChecker.new(
+          Gitlab::SidekiqMiddleware::SkipJobs::DatabaseHealthStatusChecker.new(
             123,
             deferred_worker.name
           )
@@ -116,7 +116,7 @@ RSpec.describe Gitlab::Database::HealthStatus, feature_category: :database do
         it 'captures sidekiq job class in the log' do
           expect(Gitlab::Database::HealthStatus::Logger).to receive(:info).with(
             status_checker_id: deferred_worker_health_checker.id,
-            status_checker_type: 'Gitlab::SidekiqMiddleware::DeferJobs::DatabaseHealthStatusChecker',
+            status_checker_type: 'Gitlab::SidekiqMiddleware::SkipJobs::DatabaseHealthStatusChecker',
             job_class_name: deferred_worker_health_checker.job_class_name,
             health_status_indicator: autovacuum_indicator_class.to_s,
             indicator_signal: 'Stop',
diff --git a/spec/lib/gitlab/database/load_balancing/host_spec.rb b/spec/lib/gitlab/database/load_balancing/host_spec.rb
index caae06ce43a..5ef6d9173c4 100644
--- a/spec/lib/gitlab/database/load_balancing/host_spec.rb
+++ b/spec/lib/gitlab/database/load_balancing/host_spec.rb
@@ -9,7 +9,7 @@ RSpec.describe Gitlab::Database::LoadBalancing::Host do
   end
 
   let(:host) do
-    Gitlab::Database::LoadBalancing::Host.new('localhost', load_balancer)
+    described_class.new('localhost', load_balancer)
   end
 
   before do
diff --git a/spec/lib/gitlab/database/load_balancing/load_balancer_spec.rb b/spec/lib/gitlab/database/load_balancing/load_balancer_spec.rb
index 997c7a31cba..26c8969efd8 100644
--- a/spec/lib/gitlab/database/load_balancing/load_balancer_spec.rb
+++ b/spec/lib/gitlab/database/load_balancing/load_balancer_spec.rb
@@ -2,7 +2,7 @@
 
 require 'spec_helper'
 
-RSpec.describe Gitlab::Database::LoadBalancing::LoadBalancer, :request_store do
+RSpec.describe Gitlab::Database::LoadBalancing::LoadBalancer, :request_store, feature_category: :database do
   let(:conflict_error) { Class.new(RuntimeError) }
   let(:model) { ActiveRecord::Base }
   let(:db_host) { model.connection_pool.db_config.host }
@@ -71,7 +71,30 @@ RSpec.describe Gitlab::Database::LoadBalancing::LoadBalancer, :request_store do
     end
   end
 
+  shared_examples 'logs service discovery thread interruption' do |lb_method|
+    context 'with service discovery' do
+      let(:service_discovery) do
+        instance_double(
+          Gitlab::Database::LoadBalancing::ServiceDiscovery,
+          log_refresh_thread_interruption: true
+        )
+      end
+
+      before do
+        allow(lb).to receive(:service_discovery).and_return(service_discovery)
+      end
+
+      it 'calls logs service discovery thread interruption' do
+        expect(service_discovery).to receive(:log_refresh_thread_interruption)
+
+        lb.public_send(lb_method) {}
+      end
+    end
+  end
+
   describe '#read' do
+    it_behaves_like 'logs service discovery thread interruption', :read
+
     it 'yields a connection for a read' do
       connection = double(:connection)
       host = double(:host)
@@ -203,6 +226,8 @@ RSpec.describe Gitlab::Database::LoadBalancing::LoadBalancer, :request_store do
   end
 
   describe '#read_write' do
+    it_behaves_like 'logs service discovery thread interruption', :read_write
+
     it 'yields a connection for a write' do
       connection = ActiveRecord::Base.connection_pool.connection
 
diff --git a/spec/lib/gitlab/database/load_balancing/primary_host_spec.rb b/spec/lib/gitlab/database/load_balancing/primary_host_spec.rb
index 02c9499bedb..53605d14c17 100644
--- a/spec/lib/gitlab/database/load_balancing/primary_host_spec.rb
+++ b/spec/lib/gitlab/database/load_balancing/primary_host_spec.rb
@@ -9,7 +9,7 @@ RSpec.describe Gitlab::Database::LoadBalancing::PrimaryHost do
     )
   end
 
-  let(:host) { Gitlab::Database::LoadBalancing::PrimaryHost.new(load_balancer) }
+  let(:host) { described_class.new(load_balancer) }
 
   describe '#connection' do
     it 'returns a connection from the pool' do
diff --git a/spec/lib/gitlab/database/load_balancing/service_discovery_spec.rb b/spec/lib/gitlab/database/load_balancing/service_discovery_spec.rb
index 9a559c7ccb4..789919d2a51 100644
--- a/spec/lib/gitlab/database/load_balancing/service_discovery_spec.rb
+++ b/spec/lib/gitlab/database/load_balancing/service_discovery_spec.rb
@@ -58,14 +58,14 @@ RSpec.describe Gitlab::Database::LoadBalancing::ServiceDiscovery, feature_catego
     end
   end
 
-  describe '#start' do
+  describe '#start', :freeze_time do
     before do
       allow(service)
         .to receive(:loop)
         .and_yield
     end
 
-    it 'starts service discovery in a new thread' do
+    it 'starts service discovery in a new thread with proper assignments' do
       expect(Thread).to receive(:new).ordered.and_call_original # Thread starts
 
       expect(service).to receive(:perform_service_discovery).ordered.and_return(5)
@@ -73,6 +73,9 @@ RSpec.describe Gitlab::Database::LoadBalancing::ServiceDiscovery, feature_catego
       expect(service).to receive(:sleep).ordered.with(7) # Sleep runs after thread starts
 
       service.start.join
+
+      expect(service.refresh_thread_last_run).to eq(Time.current)
+      expect(service.refresh_thread).to be_present
     end
   end
 
@@ -142,21 +145,6 @@ RSpec.describe Gitlab::Database::LoadBalancing::ServiceDiscovery, feature_catego
         service.perform_service_discovery
       end
     end
-
-    context 'with Exception' do
-      it 'logs error and re-raises the exception' do
-        error = Exception.new('uncaught-test-error')
-
-        expect(service).to receive(:refresh_if_necessary).and_raise(error)
-
-        expect(Gitlab::Database::LoadBalancing::Logger).to receive(:error).with(
-          event: :service_discovery_unexpected_exception,
-          message: "Service discovery encountered an uncaught error: uncaught-test-error"
-        )
-
-        expect { service.perform_service_discovery }.to raise_error(Exception, error.message)
-      end
-    end
   end
 
   describe '#refresh_if_necessary' do
@@ -427,4 +415,64 @@ RSpec.describe Gitlab::Database::LoadBalancing::ServiceDiscovery, feature_catego
       end
     end
   end
+
+  describe '#log_refresh_thread_interruption' do
+    before do
+      service.refresh_thread = refresh_thread
+      service.refresh_thread_last_run = last_run_timestamp
+    end
+
+    let(:refresh_thread) { nil }
+    let(:last_run_timestamp) { nil }
+
+    subject { service.log_refresh_thread_interruption }
+
+    context 'without refresh thread timestamp' do
+      it 'does not log any interruption' do
+        expect(service.refresh_thread_last_run).to be_nil
+
+        expect(Gitlab::Database::LoadBalancing::Logger).not_to receive(:error)
+
+        subject
+      end
+    end
+
+    context 'with refresh thread timestamp' do
+      let(:last_run_timestamp) { Time.current }
+
+      it 'does not log if last run time plus delta is in future' do
+        expect(Gitlab::Database::LoadBalancing::Logger).not_to receive(:error)
+
+        subject
+      end
+
+      context 'with way past last run timestamp' do
+        let(:refresh_thread) { instance_double(Thread, status: :run, backtrace: %w[backtrace foo]) }
+        let(:last_run_timestamp) { 20.minutes.before + described_class::DISCOVERY_THREAD_REFRESH_DELTA.minutes }
+
+        it 'does not log if the interruption is already logged' do
+          service.refresh_thread_interruption_logged = true
+
+          expect(Gitlab::Database::LoadBalancing::Logger).not_to receive(:error)
+
+          subject
+        end
+
+        it 'logs the error if the interruption was not logged before' do
+          expect(service.refresh_thread_interruption_logged).not_to be_present
+
+          expect(Gitlab::Database::LoadBalancing::Logger).to receive(:error).with(
+            event: :service_discovery_refresh_thread_interrupt,
+            refresh_thread_last_run: last_run_timestamp,
+            thread_status: refresh_thread.status.to_s,
+            thread_backtrace: 'backtrace\nfoo'
+          )
+
+          subject
+
+          expect(service.refresh_thread_interruption_logged).to be_truthy
+        end
+      end
+    end
+  end
 end
diff --git a/spec/lib/gitlab/database/migration_helpers/automatic_lock_writes_on_tables_spec.rb b/spec/lib/gitlab/database/migration_helpers/automatic_lock_writes_on_tables_spec.rb
index e4241348b54..577bf00ba2f 100644
--- a/spec/lib/gitlab/database/migration_helpers/automatic_lock_writes_on_tables_spec.rb
+++ b/spec/lib/gitlab/database/migration_helpers/automatic_lock_writes_on_tables_spec.rb
@@ -9,7 +9,10 @@ RSpec.describe Gitlab::Database::MigrationHelpers::AutomaticLockWritesOnTables,
   let(:schema_class) { Class.new(Gitlab::Database::Migration[2.1]) }
   let(:skip_automatic_lock_on_writes) { false }
   let(:gitlab_main_table_name) { :_test_gitlab_main_table }
+  let(:gitlab_main_clusterwide_table_name) { :_test_gitlab_main_clusterwide_table }
+  let(:gitlab_main_cell_table_name) { :_test_gitlab_main_cell_table }
   let(:gitlab_ci_table_name) { :_test_gitlab_ci_table }
+  let(:gitlab_pm_table_name) { :_test_gitlab_pm_table }
   let(:gitlab_geo_table_name) { :_test_gitlab_geo_table }
   let(:gitlab_shared_table_name) { :_test_table }
 
@@ -24,8 +27,11 @@ RSpec.describe Gitlab::Database::MigrationHelpers::AutomaticLockWritesOnTables,
   # Drop the created test tables, because we use non-transactional tests
   after do
     drop_table_if_exists(gitlab_main_table_name)
+    drop_table_if_exists(gitlab_main_clusterwide_table_name)
+    drop_table_if_exists(gitlab_main_cell_table_name)
     drop_table_if_exists(gitlab_ci_table_name)
     drop_table_if_exists(gitlab_geo_table_name)
+    drop_table_if_exists(gitlab_pm_table_name)
     drop_table_if_exists(gitlab_shared_table_name)
     drop_table_if_exists(renamed_gitlab_main_table_name)
     drop_table_if_exists(renamed_gitlab_ci_table_name)
@@ -82,8 +88,12 @@ RSpec.describe Gitlab::Database::MigrationHelpers::AutomaticLockWritesOnTables,
     context 'when single database' do
       let(:config_model) { Gitlab::Database.database_base_models[:main] }
       let(:create_gitlab_main_table_migration_class) { create_table_migration(gitlab_main_table_name) }
+      let(:create_gitlab_main_cell_table_migration_class) { create_table_migration(gitlab_main_cell_table_name) }
       let(:create_gitlab_ci_table_migration_class) { create_table_migration(gitlab_ci_table_name) }
       let(:create_gitlab_shared_table_migration_class) { create_table_migration(gitlab_shared_table_name) }
+      let(:create_gitlab_main_clusterwide_table_migration_class) do
+        create_table_migration(gitlab_main_clusterwide_table_name)
+      end
 
       before do
         skip_if_database_exists(:ci)
@@ -93,13 +103,19 @@ RSpec.describe Gitlab::Database::MigrationHelpers::AutomaticLockWritesOnTables,
         expect(Gitlab::Database::LockWritesManager).not_to receive(:new)
 
         create_gitlab_main_table_migration_class.migrate(:up)
+        create_gitlab_main_cell_table_migration_class.migrate(:up)
+        create_gitlab_main_clusterwide_table_migration_class.migrate(:up)
         create_gitlab_ci_table_migration_class.migrate(:up)
         create_gitlab_shared_table_migration_class.migrate(:up)
 
         expect do
           create_gitlab_main_table_migration_class.connection.execute("DELETE FROM #{gitlab_main_table_name}")
+          create_gitlab_main_cell_table_migration_class.connection.execute("DELETE FROM #{gitlab_main_cell_table_name}")
           create_gitlab_ci_table_migration_class.connection.execute("DELETE FROM #{gitlab_ci_table_name}")
           create_gitlab_shared_table_migration_class.connection.execute("DELETE FROM #{gitlab_shared_table_name}")
+          create_gitlab_main_clusterwide_table_migration_class.connection.execute(
+            "DELETE FROM #{gitlab_main_clusterwide_table_name}"
+          )
         end.not_to raise_error
       end
     end
@@ -163,6 +179,27 @@ RSpec.describe Gitlab::Database::MigrationHelpers::AutomaticLockWritesOnTables,
         end
       end
 
+      context 'for creating a gitlab_main_clusterwide table' do
+        let(:table_name) { gitlab_main_clusterwide_table_name }
+
+        it_behaves_like 'does not lock writes on table', Gitlab::Database.database_base_models[:main]
+        it_behaves_like 'locks writes on table', Gitlab::Database.database_base_models[:ci]
+      end
+
+      context 'for creating a gitlab_main_cell table' do
+        let(:table_name) { gitlab_main_cell_table_name }
+
+        it_behaves_like 'does not lock writes on table', Gitlab::Database.database_base_models[:main]
+        it_behaves_like 'locks writes on table', Gitlab::Database.database_base_models[:ci]
+      end
+
+      context 'for creating a gitlab_pm table' do
+        let(:table_name) { gitlab_pm_table_name }
+
+        it_behaves_like 'does not lock writes on table', Gitlab::Database.database_base_models[:main]
+        it_behaves_like 'locks writes on table', Gitlab::Database.database_base_models[:ci]
+      end
+
       context 'for creating a gitlab_ci table' do
         let(:table_name) { gitlab_ci_table_name }
 
diff --git a/spec/lib/gitlab/database/migrations/lock_retry_mixin_spec.rb b/spec/lib/gitlab/database/migrations/lock_retry_mixin_spec.rb
index 6092d985ce8..dcc088c2e21 100644
--- a/spec/lib/gitlab/database/migrations/lock_retry_mixin_spec.rb
+++ b/spec/lib/gitlab/database/migrations/lock_retry_mixin_spec.rb
@@ -71,7 +71,7 @@ RSpec.describe Gitlab::Database::Migrations::LockRetryMixin do
         def use_transaction?(migration)
           receiver.use_transaction?(migration)
         end
-      end.prepend(Gitlab::Database::Migrations::LockRetryMixin::ActiveRecordMigratorLockRetries)
+      end.prepend(described_class)
     end
 
     subject { class_def.new(receiver) }
diff --git a/spec/lib/gitlab/database/migrations/redis_helpers_spec.rb b/spec/lib/gitlab/database/migrations/redis_helpers_spec.rb
new file mode 100644
index 00000000000..5f3a48289e2
--- /dev/null
+++ b/spec/lib/gitlab/database/migrations/redis_helpers_spec.rb
@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Gitlab::Database::Migrations::RedisHelpers, feature_category: :redis do
+  let(:migration) do
+    ActiveRecord::Migration.new.extend(described_class)
+  end
+
+  describe "#queue_redis_migration_job" do
+    let(:job_name) { 'SampleJob' }
+
+    subject { migration.queue_redis_migration_job(job_name) }
+
+    context 'when migrator does not exist' do
+      it 'raises error and fails the migration' do
+        expect { subject }.to raise_error(NotImplementedError)
+      end
+    end
+
+    context 'when migrator exists' do
+      before do
+        allow(RedisMigrationWorker).to receive(:fetch_migrator!)
+      end
+
+      it 'checks migrator and enqueues job' do
+        expect(RedisMigrationWorker).to receive(:perform_async).with(job_name, '0')
+
+        subject
+      end
+    end
+  end
+end
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 6bcefa455cf..31a194ae883 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
@@ -153,6 +153,25 @@ RSpec.describe Gitlab::Database::Migrations::TestBatchedBackgroundRunner, :freez
         expect(calls.size).to eq(1)
       end
 
+      it 'does not sample a job if there are zero rows to sample' do
+        calls = []
+        define_background_migration(migration_name, with_base_class: true, scoping: ->(relation) {
+                                                                                      relation.none
+                                                                                    }) do |*args|
+          calls << args
+        end
+
+        queue_migration(migration_name, table_name, :id,
+                        job_interval: 5.minutes,
+                        batch_size: num_rows_in_table * 2,
+                        sub_batch_size: num_rows_in_table * 2)
+
+        described_class.new(result_dir: result_dir, connection: connection,
+                            from_id: from_id).run_jobs(for_duration: 3.minutes)
+
+        expect(calls.count).to eq(0)
+      end
+
       context 'with multiple jobs to run' do
         let(:last_id) do
           Gitlab::Database::SharedModel.using_connection(connection) do
diff --git a/spec/lib/gitlab/database/partitioning_spec.rb b/spec/lib/gitlab/database/partitioning_spec.rb
index 8724716dd3d..a1ae75ac916 100644
--- a/spec/lib/gitlab/database/partitioning_spec.rb
+++ b/spec/lib/gitlab/database/partitioning_spec.rb
@@ -257,7 +257,7 @@ RSpec.describe Gitlab::Database::Partitioning, feature_category: :database do
     end
 
     it 'drops detached partitions for each database' do
-      expect(Gitlab::Database::EachDatabase).to receive(:each_database_connection).and_yield
+      expect(Gitlab::Database::EachDatabase).to receive(:each_connection).and_yield
 
       expect { described_class.drop_detached_partitions }
         .to change { Postgresql::DetachedPartition.count }.from(2).to(0)
diff --git a/spec/lib/gitlab/database/postgresql_adapter/empty_query_ping_spec.rb b/spec/lib/gitlab/database/postgresql_adapter/empty_query_ping_spec.rb
deleted file mode 100644
index 6e1e53e0e41..00000000000
--- a/spec/lib/gitlab/database/postgresql_adapter/empty_query_ping_spec.rb
+++ /dev/null
@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe Gitlab::Database::PostgresqlAdapter::EmptyQueryPing do
-  describe '#active?' do
-    let(:adapter_class) do
-      Class.new do
-        include Gitlab::Database::PostgresqlAdapter::EmptyQueryPing
-
-        def initialize(connection, lock)
-          @connection = connection
-          @lock = lock
-        end
-      end
-    end
-
-    subject { adapter_class.new(connection, lock).active? }
-
-    let(:connection) { double(query: nil) }
-    let(:lock) { double }
-
-    before do
-      allow(lock).to receive(:synchronize).and_yield
-    end
-
-    it 'uses an empty query to check liveness' do
-      expect(connection).to receive(:query).with(';')
-
-      subject
-    end
-
-    it 'returns true if no error was signaled' do
-      expect(subject).to be_truthy
-    end
-
-    it 'returns false when an error occurs' do
-      expect(lock).to receive(:synchronize).and_raise(PG::Error)
-
-      expect(subject).to be_falsey
-    end
-  end
-end
diff --git a/spec/lib/gitlab/database/postgresql_adapter/type_map_cache_spec.rb b/spec/lib/gitlab/database/postgresql_adapter/type_map_cache_spec.rb
index c6542aa2adb..75c3a3650d7 100644
--- a/spec/lib/gitlab/database/postgresql_adapter/type_map_cache_spec.rb
+++ b/spec/lib/gitlab/database/postgresql_adapter/type_map_cache_spec.rb
@@ -13,7 +13,7 @@ RSpec.describe Gitlab::Database::PostgresqlAdapter::TypeMapCache do
   describe '#initialize_type_map' do
     it 'caches loading of types in memory' do
       recorder_without_cache = ActiveRecord::QueryRecorder.new(skip_schema_queries: false) { initialize_connection.disconnect! }
-      expect(recorder_without_cache.log).to include(a_string_matching(/FROM pg_type/)).twice
+      expect(recorder_without_cache.log).to include(a_string_matching(/FROM pg_type/)).exactly(4).times
 
       recorder_with_cache = ActiveRecord::QueryRecorder.new(skip_schema_queries: false) { initialize_connection.disconnect! }
 
@@ -33,7 +33,7 @@ RSpec.describe Gitlab::Database::PostgresqlAdapter::TypeMapCache do
 
       recorder = ActiveRecord::QueryRecorder.new(skip_schema_queries: false) { initialize_connection(other_config).disconnect! }
 
-      expect(recorder.log).to include(a_string_matching(/FROM pg_type/)).twice
+      expect(recorder.log).to include(a_string_matching(/FROM pg_type/)).exactly(4).times
     end
   end
 
@@ -44,7 +44,7 @@ RSpec.describe Gitlab::Database::PostgresqlAdapter::TypeMapCache do
       connection = initialize_connection
       recorder = ActiveRecord::QueryRecorder.new(skip_schema_queries: false) { connection.reload_type_map }
 
-      expect(recorder.log).to include(a_string_matching(/FROM pg_type/)).once
+      expect(recorder.log).to include(a_string_matching(/FROM pg_type/)).exactly(3).times
     end
   end
 
diff --git a/spec/lib/gitlab/database/reindexing_spec.rb b/spec/lib/gitlab/database/reindexing_spec.rb
index 4d0e58b0937..851fc7ea3cd 100644
--- a/spec/lib/gitlab/database/reindexing_spec.rb
+++ b/spec/lib/gitlab/database/reindexing_spec.rb
@@ -99,14 +99,14 @@ RSpec.describe Gitlab::Database::Reindexing, feature_category: :database, time_t
     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)
+      allow(described_class).to receive(:cleanup_leftovers!)
+      allow(described_class).to receive(:perform_from_queue).and_return(0)
+      allow(described_class).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
+      expect(described_class).to receive(:cleanup_leftovers!).ordered
+      expect(described_class).to receive(:perform_from_queue).ordered
 
       subject
     end
@@ -120,8 +120,8 @@ RSpec.describe Gitlab::Database::Reindexing, feature_category: :database, time_t
         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)
+          expect(described_class).to receive(:perform_from_queue).and_return(limit)
+          expect(described_class).not_to receive(:perform_with_heuristic)
 
           subject
         end
@@ -131,8 +131,8 @@ RSpec.describe Gitlab::Database::Reindexing, feature_category: :database, time_t
         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
+          expect(described_class).to receive(:perform_from_queue).ordered.and_return(1)
+          expect(described_class).to receive(:perform_with_heuristic).with(maximum_records: 1).ordered
 
           subject
         end
diff --git a/spec/lib/gitlab/database/schema_validation/adapters/column_database_adapter_spec.rb b/spec/lib/gitlab/database/schema_validation/adapters/column_database_adapter_spec.rb
deleted file mode 100644
index d81f5f3dbec..00000000000
--- a/spec/lib/gitlab/database/schema_validation/adapters/column_database_adapter_spec.rb
+++ /dev/null
@@ -1,72 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe Gitlab::Database::SchemaValidation::Adapters::ColumnDatabaseAdapter, feature_category: :database do
-  subject(:adapter) { described_class.new(db_result) }
-
-  let(:column_name) { 'email' }
-  let(:column_default) { "'no-reply@gitlab.com'::character varying" }
-  let(:not_null) { true }
-  let(:partition_key) { false }
-  let(:db_result) do
-    {
-      'table_name' => 'projects',
-      'column_name' => column_name,
-      'data_type' => 'character varying',
-      'column_default' => column_default,
-      'not_null' => not_null,
-      'partition_key' => partition_key
-    }
-  end
-
-  describe '#name' do
-    it { expect(adapter.name).to eq('email') }
-  end
-
-  describe '#table_name' do
-    it { expect(adapter.table_name).to eq('projects') }
-  end
-
-  describe '#data_type' do
-    it { expect(adapter.data_type).to eq('character varying') }
-  end
-
-  describe '#default' do
-    context "when there's no default value in the column" do
-      let(:column_default) { nil }
-
-      it { expect(adapter.default).to be_nil }
-    end
-
-    context 'when the column name is id' do
-      let(:column_name) { 'id' }
-
-      it { expect(adapter.default).to be_nil }
-    end
-
-    context 'when the column default includes nextval' do
-      let(:column_default) { "nextval('my_seq'::regclass)" }
-
-      it { expect(adapter.default).to be_nil }
-    end
-
-    it { expect(adapter.default).to eq("DEFAULT 'no-reply@gitlab.com'::character varying") }
-  end
-
-  describe '#nullable' do
-    context 'when column is not null' do
-      it { expect(adapter.nullable).to eq('NOT NULL') }
-    end
-
-    context 'when column is nullable' do
-      let(:not_null) { false }
-
-      it { expect(adapter.nullable).to be_nil }
-    end
-  end
-
-  describe '#partition_key?' do
-    it { expect(adapter.partition_key?).to be(false) }
-  end
-end
diff --git a/spec/lib/gitlab/database/schema_validation/adapters/column_structure_sql_adapter_spec.rb b/spec/lib/gitlab/database/schema_validation/adapters/column_structure_sql_adapter_spec.rb
deleted file mode 100644
index 64b59e65be6..00000000000
--- a/spec/lib/gitlab/database/schema_validation/adapters/column_structure_sql_adapter_spec.rb
+++ /dev/null
@@ -1,78 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe Gitlab::Database::SchemaValidation::Adapters::ColumnStructureSqlAdapter, feature_category: :database do
-  subject(:adapter) { described_class.new(table_name, column_def, partition_stmt) }
-
-  let(:table_name) { 'test_table' }
-  let(:file_path) { Rails.root.join('spec/fixtures/structure.sql') }
-  let(:table_stmts) { PgQuery.parse(File.read(file_path)).tree.stmts.filter_map { |s| s.stmt.create_stmt } }
-  let(:table) { table_stmts.find { |table| table.relation.relname == table_name } }
-  let(:partition_stmt) { table.partspec }
-  let(:column_stmts) { table.table_elts }
-  let(:column_def) { column_stmts.find { |col| col.column_def.colname == column_name }.column_def }
-
-  where(:column_name, :data_type, :default_value, :nullable, :partition_key) do
-    [
-      ['id', 'bigint', nil, 'NOT NULL', false],
-      ['integer_column', 'integer', nil, nil, false],
-      ['integer_with_default_column', 'integer', 'DEFAULT 1', nil, false],
-      ['smallint_with_default_column', 'smallint', 'DEFAULT 0', 'NOT NULL', false],
-      ['double_precision_with_default_column', 'double precision', 'DEFAULT 1.0', nil, false],
-      ['numeric_with_default_column', 'numeric', 'DEFAULT 1.0', 'NOT NULL', false],
-      ['boolean_with_default_colum', 'boolean', 'DEFAULT true', 'NOT NULL', false],
-      ['varying_with_default_column', 'character varying', "DEFAULT 'DEFAULT'::character varying", 'NOT NULL', false],
-      ['varying_with_limit_and_default_column', 'character varying(255)', "DEFAULT 'DEFAULT'::character varying",
-        nil, false],
-      ['text_with_default_column', 'text', "DEFAULT ''::text", 'NOT NULL', false],
-      ['array_with_default_column', 'character varying(255)[]', "DEFAULT '{one,two}'::character varying[]",
-        'NOT NULL', false],
-      ['jsonb_with_default_column', 'jsonb', "DEFAULT '[]'::jsonb", 'NOT NULL', false],
-      ['timestamptz_with_default_column', 'timestamp(6) with time zone', "DEFAULT now()", nil, false],
-      ['timestamp_with_default_column', 'timestamp(6) without time zone',
-        "DEFAULT '2022-01-23 00:00:00+00'::timestamp without time zone", 'NOT NULL', false],
-      ['date_with_default_column', 'date', 'DEFAULT 2023-04-05', nil, false],
-      ['inet_with_default_column', 'inet', "DEFAULT '0.0.0.0'::inet", 'NOT NULL', false],
-      ['macaddr_with_default_column', 'macaddr', "DEFAULT '00-00-00-00-00-000'::macaddr", 'NOT NULL', false],
-      ['uuid_with_default_column', 'uuid', "DEFAULT '00000000-0000-0000-0000-000000000000'::uuid", 'NOT NULL', false],
-      ['partition_key', 'bigint', 'DEFAULT 1', 'NOT NULL', true],
-      ['created_at', 'timestamp with time zone', 'DEFAULT now()', 'NOT NULL', true]
-    ]
-  end
-
-  with_them do
-    describe '#name' do
-      it { expect(adapter.name).to eq(column_name) }
-    end
-
-    describe '#table_name' do
-      it { expect(adapter.table_name).to eq(table_name) }
-    end
-
-    describe '#data_type' do
-      it { expect(adapter.data_type).to eq(data_type) }
-    end
-
-    describe '#nullable' do
-      it { expect(adapter.nullable).to eq(nullable) }
-    end
-
-    describe '#default' do
-      it { expect(adapter.default).to eq(default_value) }
-    end
-
-    describe '#partition_key?' do
-      it { expect(adapter.partition_key?).to eq(partition_key) }
-    end
-  end
-
-  context 'when the data type is not mapped' do
-    let(:column_name) { 'unmapped_column_type' }
-    let(:error_class) { Gitlab::Database::SchemaValidation::Adapters::UndefinedPGType }
-
-    describe '#data_type' do
-      it { expect { adapter.data_type }.to raise_error(error_class) }
-    end
-  end
-end
diff --git a/spec/lib/gitlab/database/schema_validation/adapters/foreign_key_database_adapter_spec.rb b/spec/lib/gitlab/database/schema_validation/adapters/foreign_key_database_adapter_spec.rb
deleted file mode 100644
index cfe5572fb51..00000000000
--- a/spec/lib/gitlab/database/schema_validation/adapters/foreign_key_database_adapter_spec.rb
+++ /dev/null
@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe Gitlab::Database::SchemaValidation::Adapters::ForeignKeyDatabaseAdapter, feature_category: :database do
-  subject(:adapter) { described_class.new(query_result) }
-
-  let(:query_result) do
-    {
-      'schema' => 'public',
-      'foreign_key_name' => 'fk_2e88fb7ce9',
-      'table_name' => 'members',
-      'foreign_key_definition' => 'FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE'
-    }
-  end
-
-  describe '#name' do
-    it { expect(adapter.name).to eq('public.fk_2e88fb7ce9') }
-  end
-
-  describe '#table_name' do
-    it { expect(adapter.table_name).to eq('members') }
-  end
-
-  describe '#statement' do
-    it { expect(adapter.statement).to eq('FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE') }
-  end
-end
diff --git a/spec/lib/gitlab/database/schema_validation/adapters/foreign_key_structure_sql_adapter_spec.rb b/spec/lib/gitlab/database/schema_validation/adapters/foreign_key_structure_sql_adapter_spec.rb
deleted file mode 100644
index f7ae0c0f892..00000000000
--- a/spec/lib/gitlab/database/schema_validation/adapters/foreign_key_structure_sql_adapter_spec.rb
+++ /dev/null
@@ -1,42 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe Gitlab::Database::SchemaValidation::Adapters::ForeignKeyStructureSqlAdapter, feature_category: :database do
-  subject(:adapter) { described_class.new(stmt) }
-
-  let(:stmt) { PgQuery.parse(sql).tree.stmts.first.stmt.alter_table_stmt }
-
-  where(:sql, :name, :table_name, :statement) do
-    [
-      [
-        'ALTER TABLE ONLY public.issues ADD CONSTRAINT fk_05f1e72feb FOREIGN KEY (author_id) REFERENCES users (id) ' \
-        'ON DELETE SET NULL',
-        'public.fk_05f1e72feb',
-        'issues',
-        'FOREIGN KEY (author_id) REFERENCES users(id) ON DELETE SET NULL'
-      ],
-      [
-        'ALTER TABLE public.import_failures ADD CONSTRAINT fk_9a9b9ba21c FOREIGN KEY (user_id) REFERENCES users(id) ' \
-        'ON DELETE CASCADE',
-        'public.fk_9a9b9ba21c',
-        'import_failures',
-        'FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE'
-      ]
-    ]
-  end
-
-  with_them do
-    describe '#name' do
-      it { expect(adapter.name).to eq(name) }
-    end
-
-    describe '#table_name' do
-      it { expect(adapter.table_name).to eq(table_name) }
-    end
-
-    describe '#statement' do
-      it { expect(adapter.statement).to eq(statement) }
-    end
-  end
-end
diff --git a/spec/lib/gitlab/database/schema_validation/database_spec.rb b/spec/lib/gitlab/database/schema_validation/database_spec.rb
deleted file mode 100644
index 0b5f433b1c9..00000000000
--- a/spec/lib/gitlab/database/schema_validation/database_spec.rb
+++ /dev/null
@@ -1,93 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.shared_examples 'database schema assertions for' do |fetch_by_name_method, exists_method, all_objects_method|
-  subject(:database) { described_class.new(connection) }
-
-  let(:database_model) { Gitlab::Database.database_base_models['main'] }
-  let(:connection) { database_model.connection }
-
-  before do
-    allow(connection).to receive(:select_rows).and_return(results)
-    allow(connection).to receive(:exec_query).and_return(results)
-  end
-
-  describe "##{fetch_by_name_method}" do
-    it 'returns nil when schema object does not exists' do
-      expect(database.public_send(fetch_by_name_method, 'invalid-object-name')).to be_nil
-    end
-
-    it 'returns the schema object by name' do
-      expect(database.public_send(fetch_by_name_method, valid_schema_object_name).name).to eq(valid_schema_object_name)
-    end
-  end
-
-  describe "##{exists_method}" do
-    it 'returns true when schema object exists' do
-      expect(database.public_send(exists_method, valid_schema_object_name)).to be_truthy
-    end
-
-    it 'returns false when schema object does not exists' do
-      expect(database.public_send(exists_method, 'invalid-object')).to be_falsey
-    end
-  end
-
-  describe "##{all_objects_method}" do
-    it 'returns all the schema objects' do
-      schema_objects = database.public_send(all_objects_method)
-
-      expect(schema_objects).to all(be_a(schema_object))
-      expect(schema_objects.map(&:name)).to eq([valid_schema_object_name])
-    end
-  end
-end
-
-RSpec.describe Gitlab::Database::SchemaValidation::Database, feature_category: :database do
-  context 'when having indexes' do
-    let(:schema_object) { Gitlab::Database::SchemaValidation::SchemaObjects::Index }
-    let(:valid_schema_object_name) { 'index' }
-    let(:results) do
-      [['index', 'CREATE UNIQUE INDEX "index" ON public.achievements USING btree (namespace_id, lower(name))']]
-    end
-
-    include_examples 'database schema assertions for', 'fetch_index_by_name', 'index_exists?', 'indexes'
-  end
-
-  context 'when having triggers' do
-    let(:schema_object) { Gitlab::Database::SchemaValidation::SchemaObjects::Trigger }
-    let(:valid_schema_object_name) { 'my_trigger' }
-    let(:results) do
-      [['my_trigger', 'CREATE TRIGGER my_trigger BEFORE INSERT ON todos FOR EACH ROW EXECUTE FUNCTION trigger()']]
-    end
-
-    include_examples 'database schema assertions for', 'fetch_trigger_by_name', 'trigger_exists?', 'triggers'
-  end
-
-  context 'when having tables' do
-    let(:schema_object) { Gitlab::Database::SchemaValidation::SchemaObjects::Table }
-    let(:valid_schema_object_name) { 'my_table' }
-    let(:results) do
-      [
-        {
-          'table_name' => 'my_table',
-          'column_name' => 'id',
-          'not_null' => true,
-          'data_type' => 'bigint',
-          'partition_key' => false,
-          'column_default' => "nextval('audit_events_id_seq'::regclass)"
-        },
-        {
-          'table_name' => 'my_table',
-          'column_name' => 'details',
-          'not_null' => false,
-          'data_type' => 'text',
-          'partition_key' => false,
-          'column_default' => nil
-        }
-      ]
-    end
-
-    include_examples 'database schema assertions for', 'fetch_table_by_name', 'table_exists?', 'tables'
-  end
-end
diff --git a/spec/lib/gitlab/database/schema_validation/inconsistency_spec.rb b/spec/lib/gitlab/database/schema_validation/inconsistency_spec.rb
deleted file mode 100644
index a49ff8339a1..00000000000
--- a/spec/lib/gitlab/database/schema_validation/inconsistency_spec.rb
+++ /dev/null
@@ -1,96 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe Gitlab::Database::SchemaValidation::Inconsistency, feature_category: :database do
-  let(:validator) { Gitlab::Database::SchemaValidation::Validators::DifferentDefinitionIndexes }
-
-  let(:database_statement) { 'CREATE INDEX index_name ON public.achievements USING btree (namespace_id)' }
-  let(:structure_sql_statement) { 'CREATE INDEX index_name ON public.achievements USING btree (id)' }
-
-  let(:structure_stmt) { PgQuery.parse(structure_sql_statement).tree.stmts.first.stmt.index_stmt }
-  let(:database_stmt) { PgQuery.parse(database_statement).tree.stmts.first.stmt.index_stmt }
-
-  let(:structure_sql_object) { Gitlab::Database::SchemaValidation::SchemaObjects::Index.new(structure_stmt) }
-  let(:database_object) { Gitlab::Database::SchemaValidation::SchemaObjects::Index.new(database_stmt) }
-
-  subject(:inconsistency) { described_class.new(validator, structure_sql_object, database_object) }
-
-  describe '#object_name' do
-    it 'returns the index name' do
-      expect(inconsistency.object_name).to eq('index_name')
-    end
-  end
-
-  describe '#diff' do
-    it 'returns a diff between the structure.sql and the database' do
-      expect(inconsistency.diff).to be_a(Diffy::Diff)
-      expect(inconsistency.diff.string1).to eq("#{structure_sql_statement}\n")
-      expect(inconsistency.diff.string2).to eq("#{database_statement}\n")
-    end
-  end
-
-  describe '#error_message' do
-    it 'returns the error message' do
-      stub_const "#{validator}::ERROR_MESSAGE", 'error message %s'
-
-      expect(inconsistency.error_message).to eq('error message index_name')
-    end
-  end
-
-  describe '#type' do
-    it 'returns the type of the validator' do
-      expect(inconsistency.type).to eq('different_definition_indexes')
-    end
-  end
-
-  describe '#table_name' do
-    it 'returns the table name' do
-      expect(inconsistency.table_name).to eq('achievements')
-    end
-  end
-
-  describe '#object_type' do
-    it 'returns the structure sql object type' do
-      expect(inconsistency.object_type).to eq('Index')
-    end
-
-    context 'when the structure sql object is not available' do
-      subject(:inconsistency) { described_class.new(validator, nil, database_object) }
-
-      it 'returns the database object type' do
-        expect(inconsistency.object_type).to eq('Index')
-      end
-    end
-  end
-
-  describe '#structure_sql_statement' do
-    it 'returns structure sql statement' do
-      expect(inconsistency.structure_sql_statement).to eq("#{structure_sql_statement}\n")
-    end
-  end
-
-  describe '#database_statement' do
-    it 'returns database statement' do
-      expect(inconsistency.database_statement).to eq("#{database_statement}\n")
-    end
-  end
-
-  describe '#inspect' do
-    let(:expected_output) do
-      <<~MSG
-      ------------------------------------------------------
-      The index_name index has a different statement between structure.sql and database
-      Diff:
-      \e[31m-CREATE INDEX index_name ON public.achievements USING btree (id)\e[0m
-      \e[32m+CREATE INDEX index_name ON public.achievements USING btree (namespace_id)\e[0m
-
-      ------------------------------------------------------
-      MSG
-    end
-
-    it 'prints the inconsistency message' do
-      expect(inconsistency.inspect).to eql(expected_output)
-    end
-  end
-end
diff --git a/spec/lib/gitlab/database/schema_validation/runner_spec.rb b/spec/lib/gitlab/database/schema_validation/runner_spec.rb
deleted file mode 100644
index f5d1c6ba31b..00000000000
--- a/spec/lib/gitlab/database/schema_validation/runner_spec.rb
+++ /dev/null
@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe Gitlab::Database::SchemaValidation::Runner, feature_category: :database do
-  let(:structure_file_path) { Rails.root.join('spec/fixtures/structure.sql') }
-  let(:connection) { ActiveRecord::Base.connection }
-
-  let(:database) { Gitlab::Database::SchemaValidation::Database.new(connection) }
-  let(:structure_sql) { Gitlab::Database::SchemaValidation::StructureSql.new(structure_file_path, 'public') }
-
-  describe '#execute' do
-    subject(:inconsistencies) { described_class.new(structure_sql, database).execute }
-
-    it 'returns inconsistencies' do
-      expect(inconsistencies).not_to be_empty
-    end
-
-    it 'execute all validators' do
-      all_validators = Gitlab::Database::SchemaValidation::Validators::BaseValidator.all_validators
-
-      expect(all_validators).to all(receive(:new).with(structure_sql, database).and_call_original)
-
-      inconsistencies
-    end
-
-    context 'when validators are passed' do
-      subject(:inconsistencies) { described_class.new(structure_sql, database, validators: validators).execute }
-
-      let(:class_name) { 'Gitlab::Database::SchemaValidation::Validators::ExtraIndexes' }
-      let(:inconsistency_class_name) { 'Gitlab::Database::SchemaValidation::Inconsistency' }
-
-      let(:extra_indexes) { class_double(class_name) }
-      let(:instace_extra_index) { instance_double(class_name, execute: [inconsistency]) }
-      let(:inconsistency) { instance_double(inconsistency_class_name, object_name: 'test') }
-
-      let(:validators) { [extra_indexes] }
-
-      it 'only execute the validators passed' do
-        expect(extra_indexes).to receive(:new).with(structure_sql, database).and_return(instace_extra_index)
-
-        Gitlab::Database::SchemaValidation::Validators::BaseValidator.all_validators.each do |validator|
-          expect(validator).not_to receive(:new).with(structure_sql, database)
-        end
-
-        expect(inconsistencies.map(&:object_name)).to eql ['test']
-      end
-    end
-  end
-end
diff --git a/spec/lib/gitlab/database/schema_validation/schema_objects/column_spec.rb b/spec/lib/gitlab/database/schema_validation/schema_objects/column_spec.rb
deleted file mode 100644
index 74bc5f43b50..00000000000
--- a/spec/lib/gitlab/database/schema_validation/schema_objects/column_spec.rb
+++ /dev/null
@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe Gitlab::Database::SchemaValidation::SchemaObjects::Column, feature_category: :database do
-  subject(:column) { described_class.new(adapter) }
-
-  let(:database_adapter) { 'Gitlab::Database::SchemaValidation::Adapters::ColumnDatabaseAdapter' }
-  let(:adapter) do
-    instance_double(database_adapter, name: 'id', table_name: 'projects',
-      data_type: 'bigint', default: nil, nullable: 'NOT NULL')
-  end
-
-  describe '#name' do
-    it { expect(column.name).to eq('id') }
-  end
-
-  describe '#table_name' do
-    it { expect(column.table_name).to eq('projects') }
-  end
-
-  describe '#statement' do
-    it { expect(column.statement).to eq('id bigint NOT NULL') }
-  end
-end
diff --git a/spec/lib/gitlab/database/schema_validation/schema_objects/foreign_key_spec.rb b/spec/lib/gitlab/database/schema_validation/schema_objects/foreign_key_spec.rb
deleted file mode 100644
index 7500ad44f82..00000000000
--- a/spec/lib/gitlab/database/schema_validation/schema_objects/foreign_key_spec.rb
+++ /dev/null
@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe Gitlab::Database::SchemaValidation::SchemaObjects::ForeignKey, feature_category: :database do
-  subject(:foreign_key) { described_class.new(adapter) }
-
-  let(:database_adapter) { 'Gitlab::Database::SchemaValidation::Adapters::ForeignKeyDatabaseAdapter' }
-  let(:adapter) do
-    instance_double(database_adapter, name: 'public.fk_1d37cddf91', table_name: 'vulnerabilities',
-      statement: 'FOREIGN KEY (epic_id) REFERENCES epics(id) ON DELETE SET NULL')
-  end
-
-  describe '#name' do
-    it { expect(foreign_key.name).to eq('public.fk_1d37cddf91') }
-  end
-
-  describe '#table_name' do
-    it { expect(foreign_key.table_name).to eq('vulnerabilities') }
-  end
-
-  describe '#statement' do
-    it { expect(foreign_key.statement).to eq('FOREIGN KEY (epic_id) REFERENCES epics(id) ON DELETE SET NULL') }
-  end
-end
diff --git a/spec/lib/gitlab/database/schema_validation/schema_objects/index_spec.rb b/spec/lib/gitlab/database/schema_validation/schema_objects/index_spec.rb
deleted file mode 100644
index 43d8fa38ec8..00000000000
--- a/spec/lib/gitlab/database/schema_validation/schema_objects/index_spec.rb
+++ /dev/null
@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe Gitlab::Database::SchemaValidation::SchemaObjects::Index, feature_category: :database do
-  let(:statement) { 'CREATE INDEX index_name ON public.achievements USING btree (namespace_id)' }
-  let(:name) { 'index_name' }
-  let(:table_name) { 'achievements' }
-
-  include_examples 'schema objects assertions for', 'index_stmt'
-end
diff --git a/spec/lib/gitlab/database/schema_validation/schema_objects/table_spec.rb b/spec/lib/gitlab/database/schema_validation/schema_objects/table_spec.rb
deleted file mode 100644
index 60ea9581517..00000000000
--- a/spec/lib/gitlab/database/schema_validation/schema_objects/table_spec.rb
+++ /dev/null
@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe Gitlab::Database::SchemaValidation::SchemaObjects::Table, feature_category: :database do
-  subject(:table) { described_class.new(name, columns) }
-
-  let(:name) { 'my_table' }
-  let(:column_class) { 'Gitlab::Database::SchemaValidation::SchemaObjects::Column' }
-  let(:columns) do
-    [
-      instance_double(column_class, name: 'id', statement: 'id bigint NOT NULL', partition_key?: false),
-      instance_double(column_class, name: 'col', statement: 'col text', partition_key?: false),
-      instance_double(column_class, name: 'partition', statement: 'partition integer DEFAULT 1', partition_key?: true)
-    ]
-  end
-
-  describe '#name' do
-    it { expect(table.name).to eq('my_table') }
-  end
-
-  describe '#table_name' do
-    it { expect(table.table_name).to eq('my_table') }
-  end
-
-  describe '#statement' do
-    it { expect(table.statement).to eq('CREATE TABLE my_table (id bigint NOT NULL, col text)') }
-
-    it 'ignores the partition column' do
-      expect(table.statement).not_to include('partition integer DEFAULT 1')
-    end
-  end
-
-  describe '#fetch_column_by_name' do
-    it { expect(table.fetch_column_by_name('col')).not_to be_nil }
-
-    it { expect(table.fetch_column_by_name('invalid')).to be_nil }
-  end
-
-  describe '#column_exists?' do
-    it { expect(table.column_exists?('col')).to eq(true) }
-
-    it { expect(table.column_exists?('invalid')).to eq(false) }
-  end
-end
diff --git a/spec/lib/gitlab/database/schema_validation/schema_objects/trigger_spec.rb b/spec/lib/gitlab/database/schema_validation/schema_objects/trigger_spec.rb
deleted file mode 100644
index 3c2481dfae0..00000000000
--- a/spec/lib/gitlab/database/schema_validation/schema_objects/trigger_spec.rb
+++ /dev/null
@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe Gitlab::Database::SchemaValidation::SchemaObjects::Trigger, feature_category: :database do
-  let(:statement) { 'CREATE TRIGGER my_trigger BEFORE INSERT ON todos FOR EACH ROW EXECUTE FUNCTION trigger()' }
-  let(:name) { 'my_trigger' }
-  let(:table_name) { 'todos' }
-
-  include_examples 'schema objects assertions for', 'create_trig_stmt'
-end
diff --git a/spec/lib/gitlab/database/schema_validation/structure_sql_spec.rb b/spec/lib/gitlab/database/schema_validation/structure_sql_spec.rb
deleted file mode 100644
index b0c056ff5db..00000000000
--- a/spec/lib/gitlab/database/schema_validation/structure_sql_spec.rb
+++ /dev/null
@@ -1,66 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.shared_examples 'structure sql schema assertions for' do |object_exists_method, all_objects_method|
-  subject(:structure_sql) { described_class.new(structure_file_path, schema_name) }
-
-  let(:structure_file_path) { Rails.root.join('spec/fixtures/structure.sql') }
-  let(:schema_name) { 'public' }
-
-  describe "##{object_exists_method}" do
-    it 'returns true when schema object exists' do
-      expect(structure_sql.public_send(object_exists_method, valid_schema_object_name)).to be_truthy
-    end
-
-    it 'returns false when schema object does not exists' do
-      expect(structure_sql.public_send(object_exists_method, 'invalid-object-name')).to be_falsey
-    end
-  end
-
-  describe "##{all_objects_method}" do
-    it 'returns all the schema objects' do
-      schema_objects = structure_sql.public_send(all_objects_method)
-
-      expect(schema_objects).to all(be_a(schema_object))
-      expect(schema_objects.map(&:name)).to eq(expected_objects)
-    end
-  end
-end
-
-RSpec.describe Gitlab::Database::SchemaValidation::StructureSql, feature_category: :database do
-  let(:structure_file_path) { Rails.root.join('spec/fixtures/structure.sql') }
-  let(:schema_name) { 'public' }
-
-  subject(:structure_sql) { described_class.new(structure_file_path, schema_name) }
-
-  context 'when having indexes' do
-    let(:schema_object) { Gitlab::Database::SchemaValidation::SchemaObjects::Index }
-    let(:valid_schema_object_name) { 'index' }
-    let(:expected_objects) do
-      %w[missing_index wrong_index index index_namespaces_public_groups_name_id
-        index_on_deploy_keys_id_and_type_and_public index_users_on_public_email_excluding_null_and_empty]
-    end
-
-    include_examples 'structure sql schema assertions for', 'index_exists?', 'indexes'
-  end
-
-  context 'when having triggers' do
-    let(:schema_object) { Gitlab::Database::SchemaValidation::SchemaObjects::Trigger }
-    let(:valid_schema_object_name) { 'trigger' }
-    let(:expected_objects) { %w[trigger wrong_trigger missing_trigger_1 projects_loose_fk_trigger] }
-
-    include_examples 'structure sql schema assertions for', 'trigger_exists?', 'triggers'
-  end
-
-  context 'when having tables' do
-    let(:schema_object) { Gitlab::Database::SchemaValidation::SchemaObjects::Table }
-    let(:valid_schema_object_name) { 'test_table' }
-    let(:expected_objects) do
-      %w[test_table ci_project_mirrors wrong_table extra_table_columns missing_table missing_table_columns
-        operations_user_lists]
-    end
-
-    include_examples 'structure sql schema assertions for', 'table_exists?', 'tables'
-  end
-end
diff --git a/spec/lib/gitlab/database/schema_validation/track_inconsistency_spec.rb b/spec/lib/gitlab/database/schema_validation/track_inconsistency_spec.rb
deleted file mode 100644
index 0b104e40c11..00000000000
--- a/spec/lib/gitlab/database/schema_validation/track_inconsistency_spec.rb
+++ /dev/null
@@ -1,185 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe Gitlab::Database::SchemaValidation::TrackInconsistency, feature_category: :database do
-  describe '#execute' do
-    let(:validator) { Gitlab::Database::SchemaValidation::Validators::DifferentDefinitionIndexes }
-
-    let(:database_statement) { 'CREATE INDEX index_name ON public.achievements USING btree (namespace_id)' }
-    let(:structure_sql_statement) { 'CREATE INDEX index_name ON public.achievements USING btree (id)' }
-
-    let(:structure_stmt) { PgQuery.parse(structure_sql_statement).tree.stmts.first.stmt.index_stmt }
-    let(:database_stmt) { PgQuery.parse(database_statement).tree.stmts.first.stmt.index_stmt }
-
-    let(:structure_sql_object) { Gitlab::Database::SchemaValidation::SchemaObjects::Index.new(structure_stmt) }
-    let(:database_object) { Gitlab::Database::SchemaValidation::SchemaObjects::Index.new(database_stmt) }
-
-    let(:inconsistency) do
-      Gitlab::Database::SchemaValidation::Inconsistency.new(validator, structure_sql_object, database_object)
-    end
-
-    let_it_be(:project) { create(:project) }
-    let_it_be(:user) { create(:user) }
-
-    subject(:execute) { described_class.new(inconsistency, project, user).execute }
-
-    context 'when is not GitLab.com' do
-      it 'does not create a schema inconsistency record' do
-        allow(Gitlab).to receive(:com?).and_return(false)
-
-        expect { execute }.not_to change { Gitlab::Database::SchemaValidation::SchemaInconsistency.count }
-      end
-    end
-
-    context 'when the issue creation fails' do
-      let(:issue_creation) { instance_double(Mutations::Issues::Create, resolve: { errors: 'error' }) }
-
-      let(:convert_object) do
-        instance_double('Gitlab::Database::ConvertFeatureCategoryToGroupLabel', execute: 'group_label')
-      end
-
-      before do
-        allow(Gitlab::Database::ConvertFeatureCategoryToGroupLabel).to receive(:new).and_return(convert_object)
-        allow(Mutations::Issues::Create).to receive(:new).and_return(issue_creation)
-      end
-
-      it 'does not create a schema inconsistency record' do
-        allow(Gitlab).to receive(:com?).and_return(true)
-
-        expect { execute }.not_to change { Gitlab::Database::SchemaValidation::SchemaInconsistency.count }
-      end
-    end
-
-    context 'when a new inconsistency is found' do
-      let(:convert_object) do
-        instance_double('Gitlab::Database::ConvertFeatureCategoryToGroupLabel', execute: 'group_label')
-      end
-
-      before do
-        allow(Gitlab::Database::ConvertFeatureCategoryToGroupLabel).to receive(:new).and_return(convert_object)
-        project.add_developer(user)
-      end
-
-      it 'creates a new schema inconsistency record' do
-        allow(Gitlab).to receive(:com?).and_return(true)
-
-        expect { execute }.to change { Gitlab::Database::SchemaValidation::SchemaInconsistency.count }
-      end
-    end
-
-    context 'when the schema inconsistency already exists' do
-      let(:diff) do
-        "-#{structure_sql_statement}\n" \
-          "+#{database_statement}\n"
-      end
-
-      let!(:schema_inconsistency) do
-        create(:schema_inconsistency, object_name: 'index_name', table_name: 'achievements',
-          valitador_name: 'different_definition_indexes', diff: diff)
-      end
-
-      before do
-        project.add_developer(user)
-      end
-
-      context 'when the issue has the last schema inconsistency' do
-        it 'does not add a note' do
-          allow(Gitlab).to receive(:com?).and_return(true)
-
-          expect { execute }.not_to change { schema_inconsistency.issue.notes.count }
-        end
-      end
-
-      context 'when the issue is outdated' do
-        let!(:schema_inconsistency) do
-          create(:schema_inconsistency, object_name: 'index_name', table_name: 'achievements',
-            valitador_name: 'different_definition_indexes', diff: 'old_diff')
-        end
-
-        it 'adds a note' do
-          allow(Gitlab).to receive(:com?).and_return(true)
-
-          expect { execute }.to change { schema_inconsistency.issue.notes.count }.from(0).to(1)
-        end
-
-        it 'updates the diff' do
-          allow(Gitlab).to receive(:com?).and_return(true)
-
-          execute
-
-          expect(schema_inconsistency.reload.diff).to eq(diff)
-        end
-      end
-
-      context 'when the GitLab issue is open' do
-        it 'does not create a new schema inconsistency record' do
-          allow(Gitlab).to receive(:com?).and_return(true)
-          schema_inconsistency.issue.update!(state_id: Issue.available_states[:opened])
-
-          expect { execute }.not_to change { Gitlab::Database::SchemaValidation::SchemaInconsistency.count }
-        end
-      end
-
-      context 'when the GitLab is not open' do
-        let(:convert_object) do
-          instance_double('Gitlab::Database::ConvertFeatureCategoryToGroupLabel', execute: 'group_label')
-        end
-
-        before do
-          allow(Gitlab::Database::ConvertFeatureCategoryToGroupLabel).to receive(:new).and_return(convert_object)
-          project.add_developer(user)
-        end
-
-        it 'creates a new schema inconsistency record' do
-          allow(Gitlab).to receive(:com?).and_return(true)
-          schema_inconsistency.issue.update!(state_id: Issue.available_states[:closed])
-
-          expect { execute }.to change { Gitlab::Database::SchemaValidation::SchemaInconsistency.count }
-        end
-      end
-    end
-
-    context 'when the dictionary file is not present' do
-      before do
-        allow(Gitlab::Database::GitlabSchema).to receive(:dictionary_paths).and_return(['dictionary_not_found_path/'])
-
-        project.add_developer(user)
-      end
-
-      it 'add the default labels' do
-        allow(Gitlab).to receive(:com?).and_return(true)
-
-        inconsistency = execute
-
-        labels = inconsistency.issue.labels.map(&:name)
-
-        expect(labels).to eq %w[database database-inconsistency-report type::maintenance severity::4]
-      end
-    end
-
-    context 'when dictionary feature_categories are available' do
-      let(:convert_object) do
-        instance_double('Gitlab::Database::ConvertFeatureCategoryToGroupLabel', execute: 'group_label')
-      end
-
-      before do
-        allow(Gitlab::Database::ConvertFeatureCategoryToGroupLabel).to receive(:new).and_return(convert_object)
-
-        allow(Gitlab::Database::GitlabSchema).to receive(:dictionary_paths).and_return(['spec/fixtures/'])
-
-        project.add_developer(user)
-      end
-
-      it 'add the default labels + group labels' do
-        allow(Gitlab).to receive(:com?).and_return(true)
-
-        inconsistency = execute
-
-        labels = inconsistency.issue.labels.map(&:name)
-
-        expect(labels).to eq %w[database database-inconsistency-report type::maintenance severity::4 group_label]
-      end
-    end
-  end
-end
diff --git a/spec/lib/gitlab/database/schema_validation/validators/base_validator_spec.rb b/spec/lib/gitlab/database/schema_validation/validators/base_validator_spec.rb
deleted file mode 100644
index e8c08277d52..00000000000
--- a/spec/lib/gitlab/database/schema_validation/validators/base_validator_spec.rb
+++ /dev/null
@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe Gitlab::Database::SchemaValidation::Validators::BaseValidator, feature_category: :database do
-  describe '.all_validators' do
-    subject(:all_validators) { described_class.all_validators }
-
-    it 'returns an array of all validators' do
-      expect(all_validators).to eq([
-        Gitlab::Database::SchemaValidation::Validators::ExtraTables,
-        Gitlab::Database::SchemaValidation::Validators::ExtraTableColumns,
-        Gitlab::Database::SchemaValidation::Validators::ExtraIndexes,
-        Gitlab::Database::SchemaValidation::Validators::ExtraTriggers,
-        Gitlab::Database::SchemaValidation::Validators::ExtraForeignKeys,
-        Gitlab::Database::SchemaValidation::Validators::MissingTables,
-        Gitlab::Database::SchemaValidation::Validators::MissingTableColumns,
-        Gitlab::Database::SchemaValidation::Validators::MissingIndexes,
-        Gitlab::Database::SchemaValidation::Validators::MissingTriggers,
-        Gitlab::Database::SchemaValidation::Validators::MissingForeignKeys,
-        Gitlab::Database::SchemaValidation::Validators::DifferentDefinitionTables,
-        Gitlab::Database::SchemaValidation::Validators::DifferentDefinitionIndexes,
-        Gitlab::Database::SchemaValidation::Validators::DifferentDefinitionTriggers,
-        Gitlab::Database::SchemaValidation::Validators::DifferentDefinitionForeignKeys
-      ])
-    end
-  end
-
-  describe '#execute' do
-    let(:structure_sql) { instance_double(Gitlab::Database::SchemaValidation::StructureSql) }
-    let(:database) { instance_double(Gitlab::Database::SchemaValidation::Database) }
-
-    subject(:inconsistencies) { described_class.new(structure_sql, database).execute }
-
-    it 'raises an exception' do
-      expect { inconsistencies }.to raise_error(NoMethodError)
-    end
-  end
-end
diff --git a/spec/lib/gitlab/database/schema_validation/validators/different_definition_foreign_keys_spec.rb b/spec/lib/gitlab/database/schema_validation/validators/different_definition_foreign_keys_spec.rb
deleted file mode 100644
index ffebffc3ad2..00000000000
--- a/spec/lib/gitlab/database/schema_validation/validators/different_definition_foreign_keys_spec.rb
+++ /dev/null
@@ -1,8 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe Gitlab::Database::SchemaValidation::Validators::DifferentDefinitionForeignKeys,
-  feature_category: :database do
-  include_examples 'foreign key validators', described_class, ['public.wrong_definition_fk']
-end
diff --git a/spec/lib/gitlab/database/schema_validation/validators/different_definition_indexes_spec.rb b/spec/lib/gitlab/database/schema_validation/validators/different_definition_indexes_spec.rb
deleted file mode 100644
index b9744c86b80..00000000000
--- a/spec/lib/gitlab/database/schema_validation/validators/different_definition_indexes_spec.rb
+++ /dev/null
@@ -1,8 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe Gitlab::Database::SchemaValidation::Validators::DifferentDefinitionIndexes,
-  feature_category: :database do
-  include_examples 'index validators', described_class, ['wrong_index']
-end
diff --git a/spec/lib/gitlab/database/schema_validation/validators/different_definition_tables_spec.rb b/spec/lib/gitlab/database/schema_validation/validators/different_definition_tables_spec.rb
deleted file mode 100644
index 746418b757e..00000000000
--- a/spec/lib/gitlab/database/schema_validation/validators/different_definition_tables_spec.rb
+++ /dev/null
@@ -1,7 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe Gitlab::Database::SchemaValidation::Validators::DifferentDefinitionTables, feature_category: :database do
-  include_examples 'table validators', described_class, ['wrong_table']
-end
diff --git a/spec/lib/gitlab/database/schema_validation/validators/different_definition_triggers_spec.rb b/spec/lib/gitlab/database/schema_validation/validators/different_definition_triggers_spec.rb
deleted file mode 100644
index 4d065929708..00000000000
--- a/spec/lib/gitlab/database/schema_validation/validators/different_definition_triggers_spec.rb
+++ /dev/null
@@ -1,8 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe Gitlab::Database::SchemaValidation::Validators::DifferentDefinitionTriggers,
-  feature_category: :database do
-  include_examples 'trigger validators', described_class, ['wrong_trigger']
-end
diff --git a/spec/lib/gitlab/database/schema_validation/validators/extra_foreign_keys_spec.rb b/spec/lib/gitlab/database/schema_validation/validators/extra_foreign_keys_spec.rb
deleted file mode 100644
index 053153aa214..00000000000
--- a/spec/lib/gitlab/database/schema_validation/validators/extra_foreign_keys_spec.rb
+++ /dev/null
@@ -1,7 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe Gitlab::Database::SchemaValidation::Validators::ExtraForeignKeys, feature_category: :database do
-  include_examples 'foreign key validators', described_class, ['public.extra_fk']
-end
diff --git a/spec/lib/gitlab/database/schema_validation/validators/extra_indexes_spec.rb b/spec/lib/gitlab/database/schema_validation/validators/extra_indexes_spec.rb
deleted file mode 100644
index 842dbb42120..00000000000
--- a/spec/lib/gitlab/database/schema_validation/validators/extra_indexes_spec.rb
+++ /dev/null
@@ -1,7 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe Gitlab::Database::SchemaValidation::Validators::ExtraIndexes, feature_category: :database do
-  include_examples 'index validators', described_class, ['extra_index']
-end
diff --git a/spec/lib/gitlab/database/schema_validation/validators/extra_table_columns_spec.rb b/spec/lib/gitlab/database/schema_validation/validators/extra_table_columns_spec.rb
deleted file mode 100644
index 9d17a2fffa9..00000000000
--- a/spec/lib/gitlab/database/schema_validation/validators/extra_table_columns_spec.rb
+++ /dev/null
@@ -1,7 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe Gitlab::Database::SchemaValidation::Validators::ExtraTableColumns, feature_category: :database do
-  include_examples 'table validators', described_class, ['extra_table_columns']
-end
diff --git a/spec/lib/gitlab/database/schema_validation/validators/extra_tables_spec.rb b/spec/lib/gitlab/database/schema_validation/validators/extra_tables_spec.rb
deleted file mode 100644
index edaf79e3c93..00000000000
--- a/spec/lib/gitlab/database/schema_validation/validators/extra_tables_spec.rb
+++ /dev/null
@@ -1,7 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe Gitlab::Database::SchemaValidation::Validators::ExtraTables, feature_category: :database do
-  include_examples 'table validators', described_class, ['extra_table']
-end
diff --git a/spec/lib/gitlab/database/schema_validation/validators/extra_triggers_spec.rb b/spec/lib/gitlab/database/schema_validation/validators/extra_triggers_spec.rb
deleted file mode 100644
index d2e1c18a1ab..00000000000
--- a/spec/lib/gitlab/database/schema_validation/validators/extra_triggers_spec.rb
+++ /dev/null
@@ -1,7 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe Gitlab::Database::SchemaValidation::Validators::ExtraTriggers, feature_category: :database do
-  include_examples 'trigger validators', described_class, ['extra_trigger']
-end
diff --git a/spec/lib/gitlab/database/schema_validation/validators/missing_foreign_keys_spec.rb b/spec/lib/gitlab/database/schema_validation/validators/missing_foreign_keys_spec.rb
deleted file mode 100644
index a47804abb91..00000000000
--- a/spec/lib/gitlab/database/schema_validation/validators/missing_foreign_keys_spec.rb
+++ /dev/null
@@ -1,7 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe Gitlab::Database::SchemaValidation::Validators::MissingForeignKeys, feature_category: :database do
-  include_examples 'foreign key validators', described_class, %w[public.fk_rails_536b96bff1 public.missing_fk]
-end
diff --git a/spec/lib/gitlab/database/schema_validation/validators/missing_indexes_spec.rb b/spec/lib/gitlab/database/schema_validation/validators/missing_indexes_spec.rb
deleted file mode 100644
index c402c3a2fa7..00000000000
--- a/spec/lib/gitlab/database/schema_validation/validators/missing_indexes_spec.rb
+++ /dev/null
@@ -1,14 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe Gitlab::Database::SchemaValidation::Validators::MissingIndexes, feature_category: :database do
-  missing_indexes = %w[
-    missing_index
-    index_namespaces_public_groups_name_id
-    index_on_deploy_keys_id_and_type_and_public
-    index_users_on_public_email_excluding_null_and_empty
-  ]
-
-  include_examples 'index validators', described_class, missing_indexes
-end
diff --git a/spec/lib/gitlab/database/schema_validation/validators/missing_table_columns_spec.rb b/spec/lib/gitlab/database/schema_validation/validators/missing_table_columns_spec.rb
deleted file mode 100644
index de2956b4dd9..00000000000
--- a/spec/lib/gitlab/database/schema_validation/validators/missing_table_columns_spec.rb
+++ /dev/null
@@ -1,7 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe Gitlab::Database::SchemaValidation::Validators::MissingTableColumns, feature_category: :database do
-  include_examples 'table validators', described_class, ['missing_table_columns']
-end
diff --git a/spec/lib/gitlab/database/schema_validation/validators/missing_tables_spec.rb b/spec/lib/gitlab/database/schema_validation/validators/missing_tables_spec.rb
deleted file mode 100644
index 7c80923e860..00000000000
--- a/spec/lib/gitlab/database/schema_validation/validators/missing_tables_spec.rb
+++ /dev/null
@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe Gitlab::Database::SchemaValidation::Validators::MissingTables, feature_category: :database do
-  missing_tables = %w[ci_project_mirrors missing_table operations_user_lists test_table]
-
-  include_examples 'table validators', described_class, missing_tables
-end
diff --git a/spec/lib/gitlab/database/schema_validation/validators/missing_triggers_spec.rb b/spec/lib/gitlab/database/schema_validation/validators/missing_triggers_spec.rb
deleted file mode 100644
index 87bc3ded808..00000000000
--- a/spec/lib/gitlab/database/schema_validation/validators/missing_triggers_spec.rb
+++ /dev/null
@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe Gitlab::Database::SchemaValidation::Validators::MissingTriggers, feature_category: :database do
-  missing_triggers = %w[missing_trigger_1 projects_loose_fk_trigger]
-
-  include_examples 'trigger validators', described_class, missing_triggers
-end
diff --git a/spec/lib/gitlab/database/similarity_score_spec.rb b/spec/lib/gitlab/database/similarity_score_spec.rb
index cfee70ed208..58ea5a58644 100644
--- a/spec/lib/gitlab/database/similarity_score_spec.rb
+++ b/spec/lib/gitlab/database/similarity_score_spec.rb
@@ -25,7 +25,7 @@ RSpec.describe Gitlab::Database::SimilarityScore do
   end
 
   let(:order_expression) do
-    Gitlab::Database::SimilarityScore.build_expression(search: search, rules: [{ column: Arel.sql('path') }]).to_sql
+    described_class.build_expression(search: search, rules: [{ column: Arel.sql('path') }]).to_sql
   end
 
   subject { query_result.take(3).map { |row| row['path'] } }
@@ -43,7 +43,7 @@ RSpec.describe Gitlab::Database::SimilarityScore do
       let(:search) { 'text' }
 
       let(:order_expression) do
-        Gitlab::Database::SimilarityScore.build_expression(search: search, rules: []).to_sql
+        described_class.build_expression(search: search, rules: []).to_sql
       end
 
       it 'orders by a constant 0 value' do
@@ -78,7 +78,7 @@ RSpec.describe Gitlab::Database::SimilarityScore do
 
   describe 'score multiplier' do
     let(:order_expression) do
-      Gitlab::Database::SimilarityScore.build_expression(search: search, rules:
+      described_class.build_expression(search: search, rules:
         [
           { column: Arel.sql('path'), multiplier: 1 },
           { column: Arel.sql('name'), multiplier: 0.8 }
@@ -94,13 +94,13 @@ RSpec.describe Gitlab::Database::SimilarityScore do
 
   describe 'annotation' do
     it 'annotates the generated SQL expression' do
-      expression = Gitlab::Database::SimilarityScore.build_expression(search: 'test', rules:
+      expression = described_class.build_expression(search: 'test', rules:
         [
           { column: Arel.sql('path'), multiplier: 1 },
           { column: Arel.sql('name'), multiplier: 0.8 }
         ])
 
-      expect(Gitlab::Database::SimilarityScore).to be_order_by_similarity(expression)
+      expect(described_class).to be_order_by_similarity(expression)
     end
   end
 end