Add latest changes from gitlab-org/gitlab@14-1-stable-eev14.1.0-rc42

49 files changed, 819 insertions, 342 deletions

diff --git a/spec/workers/authorized_project_update/user_refresh_from_replica_worker_spec.rb b/spec/workers/authorized_project_update/user_refresh_from_replica_worker_spec.rb
index cdf2cb493b0..c27629c3a15 100644
--- a/spec/workers/authorized_project_update/user_refresh_from_replica_worker_spec.rb
+++ b/spec/workers/authorized_project_update/user_refresh_from_replica_worker_spec.rb
@@ -3,9 +3,72 @@
 require 'spec_helper'
 
 RSpec.describe AuthorizedProjectUpdate::UserRefreshFromReplicaWorker do
+  let_it_be(:project) { create(:project) }
+  let_it_be(:user) { project.namespace.owner }
+
+  let(:execute_worker) { subject.perform(user.id) }
+
   it 'is labeled as low urgency' do
     expect(described_class.get_urgency).to eq(:low)
   end
 
-  it_behaves_like "refreshes user's project authorizations"
+  it_behaves_like 'an idempotent worker' do
+    let(:job_args) { user.id }
+  end
+
+  describe '#perform' do
+    it 'checks if a project_authorization refresh is needed for the user' do
+      expect(AuthorizedProjectUpdate::FindRecordsDueForRefreshService).to(
+        receive(:new).with(user).and_call_original)
+
+      execute_worker
+    end
+
+    context 'when there are project authorization records due for either removal or addition for a specific user' do
+      before do
+        user.project_authorizations.delete_all
+      end
+
+      it 'enqueues a new project authorization update job for the user' do
+        expect(AuthorizedProjectUpdate::UserRefreshWithLowUrgencyWorker).to receive(:perform_async).with(user.id)
+
+        execute_worker
+      end
+    end
+
+    context 'when there are no additions or removals to be made to project authorizations for a specific user' do
+      it 'does not enqueue a new project authorization update job for the user' do
+        expect(AuthorizedProjectUpdate::UserRefreshWithLowUrgencyWorker).not_to receive(:perform_async)
+
+        execute_worker
+      end
+    end
+
+    context 'with load balancing enabled' do
+      before do
+        allow(Gitlab::Database::LoadBalancing).to receive(:enable?).and_return(true)
+      end
+
+      it 'reads from the replica database' do
+        expect(Gitlab::Database::LoadBalancing::Session.current).to receive(:use_replicas_for_read_queries).and_call_original
+
+        execute_worker
+      end
+    end
+
+    context 'when the feature flag `user_refresh_from_replica_worker_uses_replica_db` is disabled' do
+      before do
+        stub_feature_flags(user_refresh_from_replica_worker_uses_replica_db: false)
+      end
+
+      it 'calls Users::RefreshAuthorizedProjectsService' do
+        source = 'AuthorizedProjectUpdate::UserRefreshFromReplicaWorker'
+        expect_next_instance_of(Users::RefreshAuthorizedProjectsService, user, { source: source }) do |service|
+          expect(service).to receive(:execute)
+        end
+
+        execute_worker
+      end
+    end
+  end
 end
diff --git a/spec/workers/build_finished_worker_spec.rb b/spec/workers/build_finished_worker_spec.rb
index 3434980341b..6b7162ee886 100644
--- a/spec/workers/build_finished_worker_spec.rb
+++ b/spec/workers/build_finished_worker_spec.rb
@@ -10,6 +10,7 @@ RSpec.describe BuildFinishedWorker do
       let_it_be(:build) { create(:ci_build, :success, pipeline: create(:ci_pipeline)) }
 
       before do
+        stub_feature_flags(ci_build_finished_worker_namespace_changed: build.project)
         expect(Ci::Build).to receive(:find_by).with(id: build.id).and_return(build)
       end
 
@@ -23,11 +24,23 @@ RSpec.describe BuildFinishedWorker do
 
         expect(BuildHooksWorker).to receive(:perform_async)
         expect(ChatNotificationWorker).not_to receive(:perform_async)
-        expect(ArchiveTraceWorker).to receive(:perform_in)
+        expect(Ci::ArchiveTraceWorker).to receive(:perform_in)
 
         subject
       end
 
+      context 'with ci_build_finished_worker_namespace_changed feature flag disabled' do
+        before do
+          stub_feature_flags(ci_build_finished_worker_namespace_changed: false)
+        end
+
+        it 'calls deprecated worker' do
+          expect(ArchiveTraceWorker).to receive(:perform_in)
+
+          subject
+        end
+      end
+
       context 'when build is failed' do
         before do
           build.update!(status: :failed)
diff --git a/spec/workers/build_queue_worker_spec.rb b/spec/workers/build_queue_worker_spec.rb
index 5f8510abf23..0786722e647 100644
--- a/spec/workers/build_queue_worker_spec.rb
+++ b/spec/workers/build_queue_worker_spec.rb
@@ -26,6 +26,5 @@ RSpec.describe BuildQueueWorker do
 
   it_behaves_like 'worker with data consistency',
                   described_class,
-                  feature_flag: :load_balancing_for_build_queue_worker,
                   data_consistency: :sticky
 end
diff --git a/spec/workers/bulk_imports/export_request_worker_spec.rb b/spec/workers/bulk_imports/export_request_worker_spec.rb
index 8d528011752..cb280c6d263 100644
--- a/spec/workers/bulk_imports/export_request_worker_spec.rb
+++ b/spec/workers/bulk_imports/export_request_worker_spec.rb
@@ -6,12 +6,17 @@ RSpec.describe BulkImports::ExportRequestWorker do
   let_it_be(:bulk_import) { create(:bulk_import) }
   let_it_be(:config) { create(:bulk_import_configuration, bulk_import: bulk_import) }
   let_it_be(:entity) { create(:bulk_import_entity, source_full_path: 'foo/bar', bulk_import: bulk_import) }
+  let_it_be(:version_url) { 'https://gitlab.example/api/v4/version' }
 
   let(:response_double) { double(code: 200, success?: true, parsed_response: {}) }
   let(:job_args) { [entity.id] }
 
   describe '#perform' do
     before do
+      allow(Gitlab::HTTP)
+        .to receive(:get)
+        .with(version_url, anything)
+        .and_return(double(code: 200, success?: true, parsed_response: { 'version' => Gitlab::VERSION }))
       allow(Gitlab::HTTP).to receive(:post).and_return(response_double)
     end
 
diff --git a/spec/workers/ci/archive_trace_worker_spec.rb b/spec/workers/ci/archive_trace_worker_spec.rb
new file mode 100644
index 00000000000..889e0c92042
--- /dev/null
+++ b/spec/workers/ci/archive_trace_worker_spec.rb
@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Ci::ArchiveTraceWorker do
+  describe '#perform' do
+    subject { described_class.new.perform(job&.id) }
+
+    context 'when job is found' do
+      let(:job) { create(:ci_build, :trace_live) }
+
+      it 'executes service' do
+        allow_next_instance_of(Ci::ArchiveTraceService) do |instance|
+          allow(instance).to receive(:execute).with(job, anything)
+        end
+
+        subject
+      end
+    end
+
+    context 'when job is not found' do
+      let(:job) { nil }
+
+      it 'does not execute service' do
+        allow_next_instance_of(Ci::ArchiveTraceService) do |instance|
+          allow(instance).not_to receive(:execute)
+        end
+
+        subject
+      end
+    end
+  end
+end
diff --git a/spec/workers/ci/build_finished_worker_spec.rb b/spec/workers/ci/build_finished_worker_spec.rb
new file mode 100644
index 00000000000..374ecd8619f
--- /dev/null
+++ b/spec/workers/ci/build_finished_worker_spec.rb
@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Ci::BuildFinishedWorker do
+  subject { described_class.new.perform(build.id) }
+
+  describe '#perform' do
+    context 'when build exists' do
+      let_it_be(:build) { create(:ci_build, :success, pipeline: create(:ci_pipeline)) }
+
+      before do
+        stub_feature_flags(ci_build_finished_worker_namespace_changed: build.project)
+        expect(Ci::Build).to receive(:find_by).with(id: build.id).and_return(build)
+      end
+
+      it 'calculates coverage and calls hooks', :aggregate_failures do
+        expect(build).to receive(:parse_trace_sections!).ordered
+        expect(build).to receive(:update_coverage).ordered
+
+        expect_next_instance_of(Ci::BuildReportResultService) do |build_report_result_service|
+          expect(build_report_result_service).to receive(:execute).with(build)
+        end
+
+        expect(BuildHooksWorker).to receive(:perform_async)
+        expect(ChatNotificationWorker).not_to receive(:perform_async)
+        expect(Ci::ArchiveTraceWorker).to receive(:perform_in)
+
+        subject
+      end
+
+      context 'with ci_build_finished_worker_namespace_changed feature flag disabled' do
+        before do
+          stub_feature_flags(ci_build_finished_worker_namespace_changed: false)
+        end
+
+        it 'calls deprecated worker' do
+          expect(ArchiveTraceWorker).to receive(:perform_in)
+
+          subject
+        end
+      end
+
+      context 'when build is failed' do
+        before do
+          build.update!(status: :failed)
+        end
+
+        it 'adds a todo' do
+          expect(::Ci::MergeRequests::AddTodoWhenBuildFailsWorker).to receive(:perform_async)
+
+          subject
+        end
+      end
+
+      context 'when build has a chat' do
+        before do
+          build.pipeline.update!(source: :chat)
+        end
+
+        it 'schedules a ChatNotification job' do
+          expect(ChatNotificationWorker).to receive(:perform_async).with(build.id)
+
+          subject
+        end
+      end
+    end
+
+    context 'when build does not exist' do
+      it 'does not raise exception' do
+        expect { described_class.new.perform(non_existing_record_id) }
+          .not_to raise_error
+      end
+    end
+  end
+end
diff --git a/spec/workers/ci/resource_groups/assign_resource_from_resource_group_worker_spec.rb b/spec/workers/ci/resource_groups/assign_resource_from_resource_group_worker_spec.rb
index f9914a7cecb..650be1e84a9 100644
--- a/spec/workers/ci/resource_groups/assign_resource_from_resource_group_worker_spec.rb
+++ b/spec/workers/ci/resource_groups/assign_resource_from_resource_group_worker_spec.rb
@@ -5,15 +5,23 @@ require 'spec_helper'
 RSpec.describe Ci::ResourceGroups::AssignResourceFromResourceGroupWorker do
   let(:worker) { described_class.new }
 
+  it 'has the `until_executed` deduplicate strategy' do
+    expect(described_class.get_deduplicate_strategy).to eq(:until_executed)
+  end
+
   describe '#perform' do
     subject { worker.perform(resource_group_id) }
 
-    context 'when resource group exists' do
-      let(:resource_group) { create(:ci_resource_group) }
-      let(:resource_group_id) { resource_group.id }
+    let(:resource_group) { create(:ci_resource_group) }
+    let(:resource_group_id) { resource_group.id }
 
+    include_examples 'an idempotent worker' do
+      let(:job_args) { [resource_group_id] }
+    end
+
+    context 'when resource group exists' do
       it 'executes AssignResourceFromResourceGroupService' do
-        expect_next_instance_of(Ci::ResourceGroups::AssignResourceFromResourceGroupService, resource_group.project, nil) do |service|
+        expect_next_instances_of(Ci::ResourceGroups::AssignResourceFromResourceGroupService, 2, resource_group.project, nil) do |service|
           expect(service).to receive(:execute).with(resource_group)
         end
 
@@ -22,7 +30,7 @@ RSpec.describe Ci::ResourceGroups::AssignResourceFromResourceGroupWorker do
     end
 
     context 'when build does not exist' do
-      let(:resource_group_id) { 123 }
+      let(:resource_group_id) { non_existing_record_id }
 
       it 'does not execute AssignResourceFromResourceGroupService' do
         expect(Ci::ResourceGroups::AssignResourceFromResourceGroupService).not_to receive(:new)
diff --git a/spec/workers/clusters/applications/activate_service_worker_spec.rb b/spec/workers/clusters/applications/activate_service_worker_spec.rb
index 7b05b76bebc..019bfe7a750 100644
--- a/spec/workers/clusters/applications/activate_service_worker_spec.rb
+++ b/spec/workers/clusters/applications/activate_service_worker_spec.rb
@@ -4,8 +4,8 @@ require 'spec_helper'
 
 RSpec.describe Clusters::Applications::ActivateServiceWorker, '#perform' do
   context 'cluster exists' do
-    describe 'prometheus service' do
-      let(:service_name) { 'prometheus' }
+    describe 'prometheus integration' do
+      let(:integration_name) { 'prometheus' }
 
       before do
         create(:clusters_integrations_prometheus, cluster: cluster)
@@ -16,9 +16,9 @@ RSpec.describe Clusters::Applications::ActivateServiceWorker, '#perform' do
         let(:project) { create(:project, group: group) }
         let(:cluster) { create(:cluster_for_group, groups: [group]) }
 
-        it 'ensures Prometheus service is activated' do
-          expect { described_class.new.perform(cluster.id, service_name) }
-            .to change { project.reload.prometheus_service&.active }.from(nil).to(true)
+        it 'ensures Prometheus integration is activated' do
+          expect { described_class.new.perform(cluster.id, integration_name) }
+            .to change { project.reload.prometheus_integration&.active }.from(nil).to(true)
         end
       end
 
@@ -26,9 +26,9 @@ RSpec.describe Clusters::Applications::ActivateServiceWorker, '#perform' do
         let(:project) { create(:project) }
         let(:cluster) { create(:cluster, projects: [project]) }
 
-        it 'ensures Prometheus service is activated' do
-          expect { described_class.new.perform(cluster.id, service_name) }
-            .to change { project.reload.prometheus_service&.active }.from(nil).to(true)
+        it 'ensures Prometheus integration is activated' do
+          expect { described_class.new.perform(cluster.id, integration_name) }
+            .to change { project.reload.prometheus_integration&.active }.from(nil).to(true)
         end
       end
 
@@ -36,9 +36,9 @@ RSpec.describe Clusters::Applications::ActivateServiceWorker, '#perform' do
         let(:project) { create(:project) }
         let(:cluster) { create(:cluster, :instance) }
 
-        it 'ensures Prometheus service is activated' do
-          expect { described_class.new.perform(cluster.id, service_name) }
-            .to change { project.reload.prometheus_service&.active }.from(nil).to(true)
+        it 'ensures Prometheus integration is activated' do
+          expect { described_class.new.perform(cluster.id, integration_name) }
+            .to change { project.reload.prometheus_integration&.active }.from(nil).to(true)
         end
       end
     end
diff --git a/spec/workers/clusters/applications/deactivate_service_worker_spec.rb b/spec/workers/clusters/applications/deactivate_service_worker_spec.rb
index 4068c5c9eaa..77788cfa893 100644
--- a/spec/workers/clusters/applications/deactivate_service_worker_spec.rb
+++ b/spec/workers/clusters/applications/deactivate_service_worker_spec.rb
@@ -4,15 +4,15 @@ require 'spec_helper'
 
 RSpec.describe Clusters::Applications::DeactivateServiceWorker, '#perform' do
   context 'cluster exists' do
-    describe 'prometheus service' do
-      let(:service_name) { 'prometheus' }
+    describe 'prometheus integration' do
+      let(:integration_name) { 'prometheus' }
       let!(:integration) { create(:clusters_integrations_prometheus, cluster: cluster) }
 
-      context 'prometheus service exists' do
-        let!(:prometheus_service) { create(:prometheus_service, project: project, manual_configuration: false, active: true) }
+      context 'prometheus integration exists' do
+        let!(:prometheus_integration) { create(:prometheus_integration, project: project, manual_configuration: false, active: true) }
 
         before do
-          integration.delete # prometheus service before save synchronises active stated with integration existence.
+          integration.delete # prometheus integration before save synchronises active stated with integration existence.
         end
 
         context 'cluster type: group' do
@@ -20,9 +20,9 @@ RSpec.describe Clusters::Applications::DeactivateServiceWorker, '#perform' do
           let(:project) { create(:project, group: group) }
           let(:cluster) { create(:cluster_for_group, groups: [group]) }
 
-          it 'ensures Prometheus service is deactivated' do
-            expect { described_class.new.perform(cluster.id, service_name) }
-              .to change { prometheus_service.reload.active }.from(true).to(false)
+          it 'ensures Prometheus integration is deactivated' do
+            expect { described_class.new.perform(cluster.id, integration_name) }
+              .to change { prometheus_integration.reload.active }.from(true).to(false)
           end
         end
 
@@ -30,9 +30,9 @@ RSpec.describe Clusters::Applications::DeactivateServiceWorker, '#perform' do
           let(:project) { create(:project) }
           let(:cluster) { create(:cluster, projects: [project]) }
 
-          it 'ensures Prometheus service is deactivated' do
-            expect { described_class.new.perform(cluster.id, service_name) }
-              .to change { prometheus_service.reload.active }.from(true).to(false)
+          it 'ensures Prometheus integration is deactivated' do
+            expect { described_class.new.perform(cluster.id, integration_name) }
+              .to change { prometheus_integration.reload.active }.from(true).to(false)
           end
         end
 
@@ -40,20 +40,20 @@ RSpec.describe Clusters::Applications::DeactivateServiceWorker, '#perform' do
           let(:project) { create(:project) }
           let(:cluster) { create(:cluster, :instance) }
 
-          it 'ensures Prometheus service is deactivated' do
-            expect { described_class.new.perform(cluster.id, service_name) }
-              .to change { prometheus_service.reload.active }.from(true).to(false)
+          it 'ensures Prometheus integration is deactivated' do
+            expect { described_class.new.perform(cluster.id, integration_name) }
+              .to change { prometheus_integration.reload.active }.from(true).to(false)
           end
         end
       end
 
-      context 'prometheus service does not exist' do
+      context 'prometheus integration does not exist' do
         context 'cluster type: project' do
           let(:project) { create(:project) }
           let(:cluster) { create(:cluster, projects: [project]) }
 
           it 'does not raise errors' do
-            expect { described_class.new.perform(cluster.id, service_name) }.not_to raise_error
+            expect { described_class.new.perform(cluster.id, integration_name) }.not_to raise_error
           end
         end
       end
diff --git a/spec/workers/concerns/application_worker_spec.rb b/spec/workers/concerns/application_worker_spec.rb
index 29c69ff8b4b..ac4e4a682c8 100644
--- a/spec/workers/concerns/application_worker_spec.rb
+++ b/spec/workers/concerns/application_worker_spec.rb
@@ -176,6 +176,77 @@ RSpec.describe ApplicationWorker do
     end
   end
 
+  describe '.data_consistency' do
+    using RSpec::Parameterized::TableSyntax
+
+    where(:data_consistency, :sidekiq_option_retry, :expect_error) do
+      :delayed  | false | true
+      :delayed  | 0     | true
+      :delayed  | 3     | false
+      :delayed  | nil   | false
+      :sticky   | false | false
+      :sticky   | 0     | false
+      :sticky   | 3     | false
+      :sticky   | nil   | false
+      :always   | false | false
+      :always   | 0     | false
+      :always   | 3     | false
+      :always   | nil   | false
+    end
+
+    with_them do
+      before do
+        worker.sidekiq_options retry: sidekiq_option_retry unless sidekiq_option_retry.nil?
+      end
+
+      context "when workers data consistency is #{params['data_consistency']}" do
+        it "#{params['expect_error'] ? '' : 'not to '}raise an exception" do
+          if expect_error
+            expect { worker.data_consistency data_consistency }
+              .to raise_error("Retry support cannot be disabled if data_consistency is set to :delayed")
+          else
+            expect { worker.data_consistency data_consistency }
+              .not_to raise_error
+          end
+        end
+      end
+    end
+  end
+
+  describe '.retry' do
+    using RSpec::Parameterized::TableSyntax
+
+    where(:data_consistency, :sidekiq_option_retry, :expect_error) do
+      :delayed  | false | true
+      :delayed  | 0     | true
+      :delayed  | 3     | false
+      :sticky   | false | false
+      :sticky   | 0     | false
+      :sticky   | 3     | false
+      :always   | false | false
+      :always   | 0     | false
+      :always   | 3     | false
+    end
+
+    with_them do
+      before do
+        worker.data_consistency(data_consistency)
+      end
+
+      context "when retry sidekiq option is #{params['sidekiq_option_retry']}" do
+        it "#{params['expect_error'] ? '' : 'not to '}raise an exception" do
+          if expect_error
+            expect { worker.sidekiq_options retry: sidekiq_option_retry }
+              .to raise_error("Retry support cannot be disabled if data_consistency is set to :delayed")
+          else
+            expect { worker.sidekiq_options retry: sidekiq_option_retry }
+              .not_to raise_error
+          end
+        end
+      end
+    end
+  end
+
   describe '.perform_async' do
     shared_examples_for 'worker utilizes load balancing capabilities' do |data_consistency|
       before do
diff --git a/spec/workers/concerns/gitlab/github_import/object_importer_spec.rb b/spec/workers/concerns/gitlab/github_import/object_importer_spec.rb
index 85e1721461f..4c96daea7b3 100644
--- a/spec/workers/concerns/gitlab/github_import/object_importer_spec.rb
+++ b/spec/workers/concerns/gitlab/github_import/object_importer_spec.rb
@@ -11,12 +11,8 @@ RSpec.describe Gitlab::GithubImport::ObjectImporter do
 
       include(Gitlab::GithubImport::ObjectImporter)
 
-      def counter_name
-        :dummy_counter
-      end
-
-      def counter_description
-        'This is a counter'
+      def object_type
+        :dummy
       end
 
       def representation_class
@@ -42,7 +38,7 @@ RSpec.describe Gitlab::GithubImport::ObjectImporter do
     end)
   end
 
-  describe '#import' do
+  describe '#import', :clean_gitlab_redis_shared_state do
     let(:importer_class) { double(:importer_class, name: 'klass_name') }
     let(:importer_instance) { double(:importer_instance) }
     let(:project) { double(:project, full_path: 'foo/bar', id: 1) }
@@ -64,10 +60,6 @@ RSpec.describe Gitlab::GithubImport::ObjectImporter do
       expect(importer_instance)
         .to receive(:execute)
 
-      expect(worker.counter)
-        .to receive(:increment)
-        .and_call_original
-
       expect_next_instance_of(Gitlab::Import::Logger) do |logger|
         expect(logger)
           .to receive(:info)
@@ -90,6 +82,11 @@ RSpec.describe Gitlab::GithubImport::ObjectImporter do
       end
 
       worker.import(project, client, { 'number' => 10, 'github_id' => 1 })
+
+      expect(Gitlab::GithubImport::ObjectCounter.summary(project)).to eq({
+        'fetched' => {},
+        'imported' => { 'dummy' => 1 }
+      })
     end
 
     it 'logs error when the import fails' do
@@ -176,18 +173,4 @@ RSpec.describe Gitlab::GithubImport::ObjectImporter do
         .to raise_error(KeyError, 'key not found: :github_id')
     end
   end
-
-  describe '#counter' do
-    it 'returns a Prometheus counter' do
-      expect(worker)
-        .to receive(:counter_name)
-        .and_call_original
-
-      expect(worker)
-        .to receive(:counter_description)
-        .and_call_original
-
-      worker.counter
-    end
-  end
 end
diff --git a/spec/workers/concerns/waitable_worker_spec.rb b/spec/workers/concerns/waitable_worker_spec.rb
index 5d08d38380a..824ae8fcf83 100644
--- a/spec/workers/concerns/waitable_worker_spec.rb
+++ b/spec/workers/concerns/waitable_worker_spec.rb
@@ -38,6 +38,12 @@ RSpec.describe WaitableWorker do
     it 'inlines workloads <= 3 jobs' do
       args_list = [[1], [2], [3]]
       expect(worker).to receive(:bulk_perform_inline).with(args_list).and_call_original
+      expect(Gitlab::AppJsonLogger).to(
+        receive(:info).with(a_hash_including('message' => 'running inline',
+                                             'class' => 'Gitlab::Foo::Bar::DummyWorker',
+                                             'job_status' => 'running',
+                                             'queue' => 'foo_bar_dummy'))
+                      .exactly(3).times)
 
       worker.bulk_perform_and_wait(args_list)
 
diff --git a/spec/workers/container_expiration_policies/cleanup_container_repository_worker_spec.rb b/spec/workers/container_expiration_policies/cleanup_container_repository_worker_spec.rb
index c399697cbe0..506124216af 100644
--- a/spec/workers/container_expiration_policies/cleanup_container_repository_worker_spec.rb
+++ b/spec/workers/container_expiration_policies/cleanup_container_repository_worker_spec.rb
@@ -413,20 +413,30 @@ RSpec.describe ContainerExpirationPolicies::CleanupContainerRepositoryWorker do
       disabled_repository.project.container_expiration_policy.update_column(:enabled, false)
     end
 
+    context 'counts and capacity' do
+      where(:scheduled_count, :unfinished_count, :capacity, :expected_count) do
+        2 | 2 | 10 | 4
+        2 | 0 | 10 | 2
+        0 | 2 | 10 | 2
+        4 | 2 | 2  | 4
+        4 | 0 | 2  | 4
+        0 | 4 | 2  | 4
+      end
+
+      with_them do
+        before do
+          allow(worker).to receive(:cleanup_scheduled_count).and_return(scheduled_count)
+          allow(worker).to receive(:cleanup_unfinished_count).and_return(unfinished_count)
+        end
+
+        it { is_expected.to eq(expected_count) }
+      end
+    end
+
     context 'with container repositories waiting for cleanup' do
       let_it_be(:unfinished_repositories) { create_list(:container_repository, 2, :cleanup_unfinished) }
 
       it { is_expected.to eq(3) }
-
-      it 'logs the work count' do
-        expect_log_info(
-          cleanup_scheduled_count: 1,
-          cleanup_unfinished_count: 2,
-          cleanup_total_count: 3
-        )
-
-        subject
-      end
     end
 
     context 'with no container repositories waiting for cleanup' do
@@ -436,16 +446,6 @@ RSpec.describe ContainerExpirationPolicies::CleanupContainerRepositoryWorker do
       end
 
       it { is_expected.to eq(0) }
-
-      it 'logs 0 work count' do
-        expect_log_info(
-          cleanup_scheduled_count: 0,
-          cleanup_unfinished_count: 0,
-          cleanup_total_count: 0
-        )
-
-        subject
-      end
     end
   end
 
@@ -468,9 +468,4 @@ RSpec.describe ContainerExpirationPolicies::CleanupContainerRepositoryWorker do
       it { is_expected.to eq(0) }
     end
   end
-
-  def expect_log_info(structure)
-    expect(worker.logger)
-      .to receive(:info).with(worker.structured_payload(structure))
-  end
 end
diff --git a/spec/workers/container_expiration_policy_worker_spec.rb b/spec/workers/container_expiration_policy_worker_spec.rb
index 6f81d06f653..69ddbe5c0f4 100644
--- a/spec/workers/container_expiration_policy_worker_spec.rb
+++ b/spec/workers/container_expiration_policy_worker_spec.rb
@@ -113,8 +113,8 @@ RSpec.describe ContainerExpirationPolicyWorker do
 
     context 'process stale ongoing cleanups' do
       let_it_be(:stuck_cleanup) { create(:container_repository, :cleanup_ongoing, expiration_policy_started_at: 1.day.ago) }
-      let_it_be(:container_repository) { create(:container_repository, :cleanup_scheduled) }
-      let_it_be(:container_repository) { create(:container_repository, :cleanup_unfinished) }
+      let_it_be(:container_repository1) { create(:container_repository, :cleanup_scheduled) }
+      let_it_be(:container_repository2) { create(:container_repository, :cleanup_unfinished) }
 
       it 'set them as unfinished' do
         expect { subject }
@@ -137,5 +137,36 @@ RSpec.describe ContainerExpirationPolicyWorker do
         expect(container_expiration_policy3.reload.enabled).to be false
       end
     end
+
+    context 'counts logging' do
+      let_it_be(:container_repository1) { create(:container_repository, :cleanup_scheduled) }
+      let_it_be(:container_repository2) { create(:container_repository, :cleanup_unfinished) }
+      let_it_be(:container_repository3) { create(:container_repository, :cleanup_unfinished) }
+
+      before do
+        ContainerExpirationPolicy.update_all(enabled: true)
+        container_repository1.project.container_expiration_policy.update_column(:next_run_at, 5.minutes.ago)
+      end
+
+      it 'logs all the counts' do
+        expect(worker).to receive(:log_extra_metadata_on_done).with(:cleanup_required_count, 1)
+        expect(worker).to receive(:log_extra_metadata_on_done).with(:cleanup_unfinished_count, 2)
+        expect(worker).to receive(:log_extra_metadata_on_done).with(:cleanup_total_count, 3)
+
+        subject
+      end
+
+      context 'with load balancing enabled' do
+        before do
+          allow(Gitlab::Database::LoadBalancing).to receive(:enable?).and_return(true)
+        end
+
+        it 'reads the counts from the replica' do
+          expect(Gitlab::Database::LoadBalancing::Session.current).to receive(:use_replicas_for_read_queries).and_call_original
+
+          subject
+        end
+      end
+    end
   end
 end
diff --git a/spec/workers/database/partition_management_worker_spec.rb b/spec/workers/database/partition_management_worker_spec.rb
new file mode 100644
index 00000000000..01b7f209b2d
--- /dev/null
+++ b/spec/workers/database/partition_management_worker_spec.rb
@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Database::PartitionManagementWorker do
+  describe '#perform' do
+    subject { described_class.new.perform }
+
+    let(:manager) {  instance_double('PartitionManager', sync_partitions: nil) }
+    let(:monitoring) { instance_double('PartitionMonitoring', report_metrics: nil) }
+
+    before do
+      allow(Gitlab::Database::Partitioning::PartitionManager).to receive(:new).and_return(manager)
+      allow(Gitlab::Database::Partitioning::PartitionMonitoring).to receive(:new).and_return(monitoring)
+    end
+
+    it 'delegates to PartitionManager' do
+      expect(manager).to receive(:sync_partitions)
+
+      subject
+    end
+
+    it 'reports partition metrics' do
+      expect(monitoring).to receive(:report_metrics)
+
+      subject
+    end
+  end
+end
diff --git a/spec/workers/every_sidekiq_worker_spec.rb b/spec/workers/every_sidekiq_worker_spec.rb
index 34d42addef3..c75b9b43ef4 100644
--- a/spec/workers/every_sidekiq_worker_spec.rb
+++ b/spec/workers/every_sidekiq_worker_spec.rb
@@ -148,7 +148,9 @@ RSpec.describe 'Every Sidekiq worker' do
         'Chaos::LeakMemWorker' => 3,
         'Chaos::SleepWorker' => 3,
         'ChatNotificationWorker' => false,
+        'Ci::ArchiveTraceWorker' => 3,
         'Ci::BatchResetMinutesWorker' => 10,
+        'Ci::BuildFinishedWorker' => 3,
         'Ci::BuildPrepareWorker' => 3,
         'Ci::BuildScheduleWorker' => 3,
         'Ci::BuildTraceChunkFlushWorker' => 3,
@@ -287,7 +289,7 @@ RSpec.describe 'Every Sidekiq worker' do
         'Gitlab::PhabricatorImport::ImportTasksWorker' => 5,
         'GitlabPerformanceBarStatsWorker' => 3,
         'GitlabShellWorker' => 3,
-        'GitlabUsagePingWorker' => 3,
+        'GitlabServicePingWorker' => 3,
         'GroupDestroyWorker' => 3,
         'GroupExportWorker' => false,
         'GroupImportWorker' => false,
@@ -416,6 +418,7 @@ RSpec.describe 'Every Sidekiq worker' do
         'ScanSecurityReportSecretsWorker' => 17,
         'Security::AutoFixWorker' => 3,
         'Security::StoreScansWorker' => 3,
+        'Security::TrackSecureScansWorker' => 1,
         'SelfMonitoringProjectCreateWorker' => 3,
         'SelfMonitoringProjectDeleteWorker' => 3,
         'ServiceDeskEmailReceiverWorker' => 3,
diff --git a/spec/workers/expire_pipeline_cache_worker_spec.rb b/spec/workers/expire_pipeline_cache_worker_spec.rb
index 6a1a95b8052..8c24aaa985b 100644
--- a/spec/workers/expire_pipeline_cache_worker_spec.rb
+++ b/spec/workers/expire_pipeline_cache_worker_spec.rb
@@ -50,7 +50,6 @@ RSpec.describe ExpirePipelineCacheWorker do
 
     it_behaves_like 'worker with data consistency',
                   described_class,
-                  feature_flag: :load_balancing_for_expire_pipeline_cache_worker,
                   data_consistency: :delayed
   end
 end
diff --git a/spec/workers/gitlab/github_import/import_diff_note_worker_spec.rb b/spec/workers/gitlab/github_import/import_diff_note_worker_spec.rb
index 6476d82eb85..34073d0ea39 100644
--- a/spec/workers/gitlab/github_import/import_diff_note_worker_spec.rb
+++ b/spec/workers/gitlab/github_import/import_diff_note_worker_spec.rb
@@ -34,7 +34,7 @@ RSpec.describe Gitlab::GithubImport::ImportDiffNoteWorker do
       expect(importer)
         .to receive(:execute)
 
-      expect(worker.counter)
+      expect(Gitlab::GithubImport::ObjectCounter)
         .to receive(:increment)
         .and_call_original
 
diff --git a/spec/workers/gitlab/github_import/import_issue_worker_spec.rb b/spec/workers/gitlab/github_import/import_issue_worker_spec.rb
index 9f5bd1d9e5e..dc0338eccad 100644
--- a/spec/workers/gitlab/github_import/import_issue_worker_spec.rb
+++ b/spec/workers/gitlab/github_import/import_issue_worker_spec.rb
@@ -37,7 +37,7 @@ RSpec.describe Gitlab::GithubImport::ImportIssueWorker do
       expect(importer)
         .to receive(:execute)
 
-      expect(worker.counter)
+      expect(Gitlab::GithubImport::ObjectCounter)
         .to receive(:increment)
         .and_call_original
 
diff --git a/spec/workers/gitlab/github_import/import_note_worker_spec.rb b/spec/workers/gitlab/github_import/import_note_worker_spec.rb
index 94bc8e26e4a..bc254e6246d 100644
--- a/spec/workers/gitlab/github_import/import_note_worker_spec.rb
+++ b/spec/workers/gitlab/github_import/import_note_worker_spec.rb
@@ -32,7 +32,7 @@ RSpec.describe Gitlab::GithubImport::ImportNoteWorker do
       expect(importer)
         .to receive(:execute)
 
-      expect(worker.counter)
+      expect(Gitlab::GithubImport::ObjectCounter)
         .to receive(:increment)
         .and_call_original
 
diff --git a/spec/workers/gitlab/github_import/import_pull_request_merged_by_worker_spec.rb b/spec/workers/gitlab/github_import/import_pull_request_merged_by_worker_spec.rb
index c799c676300..728b4c6b440 100644
--- a/spec/workers/gitlab/github_import/import_pull_request_merged_by_worker_spec.rb
+++ b/spec/workers/gitlab/github_import/import_pull_request_merged_by_worker_spec.rb
@@ -12,12 +12,4 @@ RSpec.describe Gitlab::GithubImport::ImportPullRequestMergedByWorker do
   describe '#importer_class' do
     it { expect(subject.importer_class).to eq(Gitlab::GithubImport::Importer::PullRequestMergedByImporter) }
   end
-
-  describe '#counter_name' do
-    it { expect(subject.counter_name).to eq(:github_importer_imported_pull_requests_merged_by) }
-  end
-
-  describe '#counter_description' do
-    it { expect(subject.counter_description).to eq('The number of imported GitHub pull requests merged by') }
-  end
 end
diff --git a/spec/workers/gitlab/github_import/import_pull_request_review_worker_spec.rb b/spec/workers/gitlab/github_import/import_pull_request_review_worker_spec.rb
index cd14d6631d5..0607add52cd 100644
--- a/spec/workers/gitlab/github_import/import_pull_request_review_worker_spec.rb
+++ b/spec/workers/gitlab/github_import/import_pull_request_review_worker_spec.rb
@@ -12,12 +12,4 @@ RSpec.describe Gitlab::GithubImport::ImportPullRequestReviewWorker do
   describe '#importer_class' do
     it { expect(subject.importer_class).to eq(Gitlab::GithubImport::Importer::PullRequestReviewImporter) }
   end
-
-  describe '#counter_name' do
-    it { expect(subject.counter_name).to eq(:github_importer_imported_pull_request_reviews) }
-  end
-
-  describe '#counter_description' do
-    it { expect(subject.counter_description).to eq('The number of imported GitHub pull request reviews') }
-  end
 end
diff --git a/spec/workers/gitlab/github_import/import_pull_request_worker_spec.rb b/spec/workers/gitlab/github_import/import_pull_request_worker_spec.rb
index 1238929fbcb..6fe9741075f 100644
--- a/spec/workers/gitlab/github_import/import_pull_request_worker_spec.rb
+++ b/spec/workers/gitlab/github_import/import_pull_request_worker_spec.rb
@@ -43,7 +43,7 @@ RSpec.describe Gitlab::GithubImport::ImportPullRequestWorker do
       expect(importer)
         .to receive(:execute)
 
-      expect(worker.counter)
+      expect(Gitlab::GithubImport::ObjectCounter)
         .to receive(:increment)
         .and_call_original
 
diff --git a/spec/workers/gitlab/github_import/stage/finish_import_worker_spec.rb b/spec/workers/gitlab/github_import/stage/finish_import_worker_spec.rb
index 2615da2be15..8dea24dc74f 100644
--- a/spec/workers/gitlab/github_import/stage/finish_import_worker_spec.rb
+++ b/spec/workers/gitlab/github_import/stage/finish_import_worker_spec.rb
@@ -33,6 +33,10 @@ RSpec.describe Gitlab::GithubImport::Stage::FinishImportWorker do
             message: 'GitHub project import finished',
             import_stage: 'Gitlab::GithubImport::Stage::FinishImportWorker',
             import_source: :github,
+            object_counts: {
+              'fetched' => {},
+              'imported' => {}
+            },
             project_id: project.id,
             duration_s: a_kind_of(Numeric)
           )
diff --git a/spec/workers/gitlab/jira_import/stage/import_issues_worker_spec.rb b/spec/workers/gitlab/jira_import/stage/import_issues_worker_spec.rb
index f82f6ccd9d6..10702c17cb5 100644
--- a/spec/workers/gitlab/jira_import/stage/import_issues_worker_spec.rb
+++ b/spec/workers/gitlab/jira_import/stage/import_issues_worker_spec.rb
@@ -16,7 +16,7 @@ RSpec.describe Gitlab::JiraImport::Stage::ImportIssuesWorker do
     let_it_be(:jira_import, reload: true) { create(:jira_import_state, :scheduled, project: project) }
 
     before do
-      stub_jira_service_test
+      stub_jira_integration_test
     end
 
     context 'when import did not start' do
@@ -25,7 +25,7 @@ RSpec.describe Gitlab::JiraImport::Stage::ImportIssuesWorker do
     end
 
     context 'when import started', :clean_gitlab_redis_cache do
-      let_it_be(:jira_service) { create(:jira_service, project: project) }
+      let_it_be(:jira_integration) { create(:jira_integration, project: project) }
 
       before do
         jira_import.start!
diff --git a/spec/workers/gitlab/jira_import/stage/import_labels_worker_spec.rb b/spec/workers/gitlab/jira_import/stage/import_labels_worker_spec.rb
index 0b7a35a92e2..52c516b9ff9 100644
--- a/spec/workers/gitlab/jira_import/stage/import_labels_worker_spec.rb
+++ b/spec/workers/gitlab/jira_import/stage/import_labels_worker_spec.rb
@@ -21,10 +21,10 @@ RSpec.describe Gitlab::JiraImport::Stage::ImportLabelsWorker do
     end
 
     context 'when import started' do
-      let!(:jira_service) { create(:jira_service, project: project) }
+      let!(:jira_integration) { create(:jira_integration, project: project) }
 
       before do
-        stub_jira_service_test
+        stub_jira_integration_test
 
         jira_import.start!
 
diff --git a/spec/workers/gitlab_usage_ping_worker_spec.rb b/spec/workers/gitlab_service_ping_worker_spec.rb
index f282b20363c..abccc0dc967 100644
--- a/spec/workers/gitlab_usage_ping_worker_spec.rb
+++ b/spec/workers/gitlab_service_ping_worker_spec.rb
@@ -2,21 +2,21 @@
 
 require 'spec_helper'
 
-RSpec.describe GitlabUsagePingWorker, :clean_gitlab_redis_shared_state do
+RSpec.describe GitlabServicePingWorker, :clean_gitlab_redis_shared_state do
   before do
-    allow_next_instance_of(SubmitUsagePingService) { |service| allow(service).to receive(:execute) }
+    allow_next_instance_of(ServicePing::SubmitService) { |service| allow(service).to receive(:execute) }
     allow(subject).to receive(:sleep)
   end
 
   it 'does not run for GitLab.com' do
     allow(Gitlab).to receive(:com?).and_return(true)
-    expect(SubmitUsagePingService).not_to receive(:new)
+    expect(ServicePing::SubmitService).not_to receive(:new)
 
     subject.perform
   end
 
-  it 'delegates to SubmitUsagePingService' do
-    expect_next_instance_of(SubmitUsagePingService) { |service| expect(service).to receive(:execute) }
+  it 'delegates to ServicePing::SubmitService' do
+    expect_next_instance_of(ServicePing::SubmitService) { |service| expect(service).to receive(:execute) }
 
     subject.perform
   end
@@ -41,8 +41,8 @@ RSpec.describe GitlabUsagePingWorker, :clean_gitlab_redis_shared_state do
       Gitlab::ExclusiveLease.new(described_class::LEASE_KEY, timeout: described_class::LEASE_TIMEOUT).try_obtain
     end
 
-    it 'does not invoke SubmitUsagePingService' do
-      allow_next_instance_of(SubmitUsagePingService) { |service| expect(service).not_to receive(:execute) }
+    it 'does not invoke ServicePing::SubmitService' do
+      allow_next_instance_of(ServicePing::SubmitService) { |service| expect(service).not_to receive(:execute) }
 
       expect { subject.perform }.to raise_error(Gitlab::ExclusiveLeaseHelpers::FailedToObtainLockError)
     end
diff --git a/spec/workers/jira_connect/forward_event_worker_spec.rb b/spec/workers/jira_connect/forward_event_worker_spec.rb
new file mode 100644
index 00000000000..adfc071779a
--- /dev/null
+++ b/spec/workers/jira_connect/forward_event_worker_spec.rb
@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe JiraConnect::ForwardEventWorker do
+  describe '#perform' do
+    let!(:jira_connect_installation) { create(:jira_connect_installation, instance_url: self_managed_url, client_key: client_key, shared_secret: shared_secret) }
+    let(:base_path) { '/-/jira_connect' }
+    let(:event_path) { '/-/jira_connect/events/uninstalled' }
+
+    let(:self_managed_url) { 'http://example.com' }
+    let(:base_url) { self_managed_url + base_path }
+    let(:event_url) { self_managed_url + event_path }
+
+    let(:client_key) { '123' }
+    let(:shared_secret) { '123' }
+
+    subject { described_class.new.perform(jira_connect_installation.id, base_path, event_path) }
+
+    it 'forwards the event including the auth header and deletes the installation' do
+      stub_request(:post, event_url)
+
+      expect(Atlassian::Jwt).to receive(:create_query_string_hash).with(event_url, 'POST', base_url).and_return('some_qsh')
+      expect(Atlassian::Jwt).to receive(:encode).with({ iss: client_key, qsh: 'some_qsh' }, shared_secret).and_return('auth_token')
+      expect { subject }.to change(JiraConnectInstallation, :count).by(-1)
+
+      expect(WebMock).to have_requested(:post, event_url).with(headers: { 'Authorization' => 'JWT auth_token' })
+    end
+
+    context 'when installation does not exist' do
+      let(:jira_connect_installation) { instance_double(JiraConnectInstallation, id: -1) }
+
+      it 'does nothing' do
+        expect { subject }.not_to change(JiraConnectInstallation, :count)
+      end
+    end
+
+    context 'when installation does not have an instance_url' do
+      let!(:jira_connect_installation) { create(:jira_connect_installation) }
+
+      it 'forwards the event including the auth header' do
+        expect { subject }.to change(JiraConnectInstallation, :count).by(-1)
+
+        expect(WebMock).not_to have_requested(:post, '*')
+      end
+    end
+
+    context 'when it fails to forward the event' do
+      it 'still deletes the installation' do
+        allow(Gitlab::HTTP).to receive(:post).and_raise(StandardError)
+
+        expect { subject }.to raise_error(StandardError).and change(JiraConnectInstallation, :count).by(-1)
+      end
+    end
+  end
+end
diff --git a/spec/workers/jira_connect/sync_branch_worker_spec.rb b/spec/workers/jira_connect/sync_branch_worker_spec.rb
index 7c715f36fb4..349ccd10694 100644
--- a/spec/workers/jira_connect/sync_branch_worker_spec.rb
+++ b/spec/workers/jira_connect/sync_branch_worker_spec.rb
@@ -5,6 +5,10 @@ require 'spec_helper'
 RSpec.describe JiraConnect::SyncBranchWorker do
   include AfterNextHelpers
 
+  it_behaves_like 'worker with data consistency',
+                  described_class,
+                  data_consistency: :delayed
+
   describe '#perform' do
     let_it_be(:group) { create(:group) }
     let_it_be(:project) { create(:project, :repository, group: group) }
@@ -15,65 +19,59 @@ RSpec.describe JiraConnect::SyncBranchWorker do
     let(:commit_shas) { %w(b83d6e3 5a62481) }
     let(:update_sequence_id) { 1 }
 
+    def perform
+      described_class.new.perform(project_id, branch_name, commit_shas, update_sequence_id)
+    end
+
     def expect_jira_sync_service_execute(args)
-      expect_next_instances_of(JiraConnect::SyncService, IdempotentWorkerHelper::WORKER_EXEC_TIMES) do |instance|
-        expect(instance).to receive(:execute).with(args)
-      end
+      expect_next(JiraConnect::SyncService).to receive(:execute).with(args)
     end
 
-    it_behaves_like 'an idempotent worker' do
-      let(:job_args) { [project_id, branch_name, commit_shas, update_sequence_id] }
+    it 'calls JiraConnect::SyncService#execute' do
+      expect_jira_sync_service_execute(
+        branches: [instance_of(Gitlab::Git::Branch)],
+        commits: project.commits_by(oids: commit_shas),
+        update_sequence_id: update_sequence_id
+      )
 
-      before do
-        stub_request(:post, 'https://sample.atlassian.net/rest/devinfo/0.10/bulk').to_return(status: 200, body: '', headers: {})
-      end
+      perform
+    end
+
+    context 'without branch name' do
+      let(:branch_name) { nil }
 
       it 'calls JiraConnect::SyncService#execute' do
         expect_jira_sync_service_execute(
-          branches: [instance_of(Gitlab::Git::Branch)],
+          branches: nil,
           commits: project.commits_by(oids: commit_shas),
           update_sequence_id: update_sequence_id
         )
 
-        subject
-      end
-
-      context 'without branch name' do
-        let(:branch_name) { nil }
-
-        it 'calls JiraConnect::SyncService#execute' do
-          expect_jira_sync_service_execute(
-            branches: nil,
-            commits: project.commits_by(oids: commit_shas),
-            update_sequence_id: update_sequence_id
-          )
-
-          subject
-        end
+        perform
       end
+    end
 
-      context 'without commits' do
-        let(:commit_shas) { nil }
+    context 'without commits' do
+      let(:commit_shas) { nil }
 
-        it 'calls JiraConnect::SyncService#execute' do
-          expect_jira_sync_service_execute(
-            branches: [instance_of(Gitlab::Git::Branch)],
-            commits: nil,
-            update_sequence_id: update_sequence_id
-          )
+      it 'calls JiraConnect::SyncService#execute' do
+        expect_jira_sync_service_execute(
+          branches: [instance_of(Gitlab::Git::Branch)],
+          commits: nil,
+          update_sequence_id: update_sequence_id
+        )
 
-          subject
-        end
+        perform
       end
+    end
 
-      context 'when project no longer exists' do
-        let(:project_id) { non_existing_record_id }
+    context 'when project no longer exists' do
+      let(:project_id) { non_existing_record_id }
 
-        it 'does not call JiraConnect::SyncService' do
-          expect(JiraConnect::SyncService).not_to receive(:new)
+      it 'does not call JiraConnect::SyncService' do
+        expect(JiraConnect::SyncService).not_to receive(:new)
 
-          subject
-        end
+        perform
       end
     end
   end
diff --git a/spec/workers/jira_connect/sync_builds_worker_spec.rb b/spec/workers/jira_connect/sync_builds_worker_spec.rb
index 8fb8692fdf7..9be0cccae2b 100644
--- a/spec/workers/jira_connect/sync_builds_worker_spec.rb
+++ b/spec/workers/jira_connect/sync_builds_worker_spec.rb
@@ -4,7 +4,10 @@ require 'spec_helper'
 
 RSpec.describe ::JiraConnect::SyncBuildsWorker do
   include AfterNextHelpers
-  include ServicesHelper
+
+  it_behaves_like 'worker with data consistency',
+                  described_class,
+                  data_consistency: :delayed
 
   describe '#perform' do
     let_it_be(:pipeline) { create(:ci_pipeline) }
diff --git a/spec/workers/jira_connect/sync_deployments_worker_spec.rb b/spec/workers/jira_connect/sync_deployments_worker_spec.rb
index 16fa2643d04..86ba11ebe9c 100644
--- a/spec/workers/jira_connect/sync_deployments_worker_spec.rb
+++ b/spec/workers/jira_connect/sync_deployments_worker_spec.rb
@@ -4,7 +4,10 @@ require 'spec_helper'
 
 RSpec.describe ::JiraConnect::SyncDeploymentsWorker do
   include AfterNextHelpers
-  include ServicesHelper
+
+  it_behaves_like 'worker with data consistency',
+                  described_class,
+                  data_consistency: :delayed
 
   describe '#perform' do
     let_it_be(:deployment) { create(:deployment) }
diff --git a/spec/workers/jira_connect/sync_feature_flags_worker_spec.rb b/spec/workers/jira_connect/sync_feature_flags_worker_spec.rb
index 038eed7b9f1..6763aefcbec 100644
--- a/spec/workers/jira_connect/sync_feature_flags_worker_spec.rb
+++ b/spec/workers/jira_connect/sync_feature_flags_worker_spec.rb
@@ -4,7 +4,10 @@ require 'spec_helper'
 
 RSpec.describe ::JiraConnect::SyncFeatureFlagsWorker do
   include AfterNextHelpers
-  include ServicesHelper
+
+  it_behaves_like 'worker with data consistency',
+                  described_class,
+                  data_consistency: :delayed
 
   describe '#perform' do
     let_it_be(:feature_flag) { create(:operations_feature_flag) }
diff --git a/spec/workers/jira_connect/sync_merge_request_worker_spec.rb b/spec/workers/jira_connect/sync_merge_request_worker_spec.rb
index 6a0a0744f6f..65976566b22 100644
--- a/spec/workers/jira_connect/sync_merge_request_worker_spec.rb
+++ b/spec/workers/jira_connect/sync_merge_request_worker_spec.rb
@@ -5,6 +5,10 @@ require 'spec_helper'
 RSpec.describe JiraConnect::SyncMergeRequestWorker do
   include AfterNextHelpers
 
+  it_behaves_like 'worker with data consistency',
+                  described_class,
+                  data_consistency: :delayed
+
   describe '#perform' do
     let_it_be(:group) { create(:group) }
     let_it_be(:project) { create(:project, :repository, group: group) }
@@ -14,29 +18,24 @@ RSpec.describe JiraConnect::SyncMergeRequestWorker do
     let(:merge_request_id) { merge_request.id }
     let(:update_sequence_id) { 1 }
 
-    it_behaves_like 'an idempotent worker' do
-      let(:job_args) { [merge_request_id, update_sequence_id] }
-
-      before do
-        stub_request(:post, 'https://sample.atlassian.net/rest/devinfo/0.10/bulk').to_return(status: 200, body: '', headers: {})
-      end
+    def perform
+      described_class.new.perform(merge_request_id, update_sequence_id)
+    end
 
-      it 'calls JiraConnect::SyncService#execute' do
-        expect_next_instances_of(JiraConnect::SyncService, IdempotentWorkerHelper::WORKER_EXEC_TIMES) do |service|
-          expect(service).to receive(:execute).with(merge_requests: [merge_request], update_sequence_id: update_sequence_id)
-        end
+    it 'calls JiraConnect::SyncService#execute' do
+      expect_next(JiraConnect::SyncService).to receive(:execute)
+        .with(merge_requests: [merge_request], update_sequence_id: update_sequence_id)
 
-        subject
-      end
+      perform
+    end
 
-      context 'when MR no longer exists' do
-        let(:merge_request_id) { non_existing_record_id }
+    context 'when MR no longer exists' do
+      let(:merge_request_id) { non_existing_record_id }
 
-        it 'does not call JiraConnect::SyncService' do
-          expect(JiraConnect::SyncService).not_to receive(:new)
+      it 'does not call JiraConnect::SyncService' do
+        expect(JiraConnect::SyncService).not_to receive(:new)
 
-          subject
-        end
+        perform
       end
     end
   end
diff --git a/spec/workers/jira_connect/sync_project_worker_spec.rb b/spec/workers/jira_connect/sync_project_worker_spec.rb
index 5c0e7e7609c..d172bde2400 100644
--- a/spec/workers/jira_connect/sync_project_worker_spec.rb
+++ b/spec/workers/jira_connect/sync_project_worker_spec.rb
@@ -3,6 +3,12 @@
 require 'spec_helper'
 
 RSpec.describe JiraConnect::SyncProjectWorker, factory_default: :keep do
+  include AfterNextHelpers
+
+  it_behaves_like 'worker with data consistency',
+                  described_class,
+                  data_consistency: :delayed
+
   describe '#perform' do
     let_it_be(:project) { create_default(:project).freeze }
 
@@ -14,6 +20,22 @@ RSpec.describe JiraConnect::SyncProjectWorker, factory_default: :keep do
     let(:jira_connect_sync_service) { JiraConnect::SyncService.new(project) }
     let(:job_args) { [project.id, update_sequence_id] }
     let(:update_sequence_id) { 1 }
+    let(:request_path) { '/rest/devinfo/0.10/bulk' }
+    let(:request_body) do
+      {
+        repositories: [
+          Atlassian::JiraConnect::Serializers::RepositoryEntity.represent(
+            project,
+            merge_requests: [mr_with_jira_description, mr_with_jira_title],
+            update_sequence_id: update_sequence_id
+          )
+        ]
+      }
+    end
+
+    def perform(project_id, update_sequence_id)
+      described_class.new.perform(project_id, update_sequence_id)
+    end
 
     before do
       stub_request(:post, 'https://sample.atlassian.net/rest/devinfo/0.10/bulk').to_return(status: 200, body: '', headers: {})
@@ -24,54 +46,37 @@ RSpec.describe JiraConnect::SyncProjectWorker, factory_default: :keep do
 
     context 'when the project is not found' do
       it 'does not raise an error' do
-        expect { described_class.new.perform('non_existing_record_id', update_sequence_id) }.not_to raise_error
+        expect { perform('non_existing_record_id', update_sequence_id) }.not_to raise_error
       end
     end
 
     it 'avoids N+1 database queries' do
-      control_count = ActiveRecord::QueryRecorder.new { described_class.new.perform(project.id, update_sequence_id) }.count
+      control_count = ActiveRecord::QueryRecorder.new { perform(project.id, update_sequence_id) }.count
 
       create(:merge_request, :unique_branches, title: 'TEST-123')
 
-      expect { described_class.new.perform(project.id, update_sequence_id) }.not_to exceed_query_limit(control_count)
+      expect { perform(project.id, update_sequence_id) }.not_to exceed_query_limit(control_count)
     end
 
-    it_behaves_like 'an idempotent worker' do
-      let(:request_path) { '/rest/devinfo/0.10/bulk' }
-      let(:request_body) do
-        {
-          repositories: [
-            Atlassian::JiraConnect::Serializers::RepositoryEntity.represent(
-              project,
-              merge_requests: [mr_with_jira_description, mr_with_jira_title],
-              update_sequence_id: update_sequence_id
-            )
-          ]
-        }
-      end
-
-      it 'sends the request with custom update_sequence_id' do
-        allow_next_instances_of(Atlassian::JiraConnect::Client, IdempotentWorkerHelper::WORKER_EXEC_TIMES) do |client|
-          expect(client).to receive(:post).with(request_path, request_body)
-        end
+    it 'sends the request with custom update_sequence_id' do
+      allow_next(Atlassian::JiraConnect::Client).to receive(:post)
+        .with(request_path, request_body)
 
-        subject
-      end
+      perform(project.id, update_sequence_id)
+    end
 
-      context 'when the number of merge requests to sync is higher than the limit' do
-        let!(:most_recent_merge_request) { create(:merge_request, :unique_branches, description: 'TEST-323', title: 'TEST-123') }
+    context 'when the number of merge requests to sync is higher than the limit' do
+      let!(:most_recent_merge_request) { create(:merge_request, :unique_branches, description: 'TEST-323', title: 'TEST-123') }
 
-        before do
-          stub_const("#{described_class}::MERGE_REQUEST_LIMIT", 1)
-        end
+      before do
+        stub_const("#{described_class}::MERGE_REQUEST_LIMIT", 1)
+      end
 
-        it 'syncs only the most recent merge requests within the limit' do
-          expect(jira_connect_sync_service).to receive(:execute)
-            .exactly(IdempotentWorkerHelper::WORKER_EXEC_TIMES).times
-            .with(merge_requests: [most_recent_merge_request], update_sequence_id: update_sequence_id)
+      it 'syncs only the most recent merge requests within the limit' do
+        expect(jira_connect_sync_service).to receive(:execute)
+          .with(merge_requests: [most_recent_merge_request], update_sequence_id: update_sequence_id)
 
-          subject
-        end
+        perform(project.id, update_sequence_id)
       end
     end
   end
diff --git a/spec/workers/merge_request_cleanup_refs_worker_spec.rb b/spec/workers/merge_request_cleanup_refs_worker_spec.rb
index 7401c6dd4d7..1de927a81e4 100644
--- a/spec/workers/merge_request_cleanup_refs_worker_spec.rb
+++ b/spec/workers/merge_request_cleanup_refs_worker_spec.rb
@@ -3,18 +3,41 @@
 require 'spec_helper'
 
 RSpec.describe MergeRequestCleanupRefsWorker do
-  describe '#perform' do
-    context 'when merge request exists' do
-      let(:merge_request) { create(:merge_request) }
-      let(:job_args) { merge_request.id }
-
-      include_examples 'an idempotent worker' do
-        it 'calls MergeRequests::CleanupRefsService#execute' do
-          expect_next_instance_of(MergeRequests::CleanupRefsService, merge_request) do |svc|
-            expect(svc).to receive(:execute).and_call_original
-          end.twice
-
-          subject
+  let(:worker) { described_class.new }
+
+  describe '#perform_work' do
+    context 'when next cleanup schedule is found' do
+      let(:failed_count) { 0 }
+      let!(:cleanup_schedule) { create(:merge_request_cleanup_schedule, failed_count: failed_count) }
+
+      it 'marks the cleanup schedule as completed on success' do
+        stub_cleanup_service(status: :success)
+        worker.perform_work
+
+        expect(cleanup_schedule.reload).to be_completed
+        expect(cleanup_schedule.completed_at).to be_present
+      end
+
+      context 'when service fails' do
+        before do
+          stub_cleanup_service(status: :error)
+          worker.perform_work
+        end
+
+        it 'marks the cleanup schedule as unstarted and track the failure' do
+          expect(cleanup_schedule.reload).to be_unstarted
+          expect(cleanup_schedule.failed_count).to eq(1)
+          expect(cleanup_schedule.completed_at).to be_nil
+        end
+
+        context "and cleanup schedule has already failed #{described_class::FAILURE_THRESHOLD} times" do
+          let(:failed_count) { described_class::FAILURE_THRESHOLD }
+
+          it 'marks the cleanup schedule as failed and track the failure' do
+            expect(cleanup_schedule.reload).to be_failed
+            expect(cleanup_schedule.failed_count).to eq(described_class::FAILURE_THRESHOLD + 1)
+            expect(cleanup_schedule.completed_at).to be_nil
+          end
         end
       end
 
@@ -23,20 +46,52 @@ RSpec.describe MergeRequestCleanupRefsWorker do
           stub_feature_flags(merge_request_refs_cleanup: false)
         end
 
-        it 'does not clean up the merge request' do
+        it 'does nothing' do
           expect(MergeRequests::CleanupRefsService).not_to receive(:new)
 
-          perform_multiple(1)
+          worker.perform_work
         end
       end
     end
 
-    context 'when merge request does not exist' do
-      it 'does not call MergeRequests::CleanupRefsService' do
+    context 'when there is no next cleanup schedule found' do
+      it 'does nothing' do
         expect(MergeRequests::CleanupRefsService).not_to receive(:new)
 
-        perform_multiple(1)
+        worker.perform_work
+      end
+    end
+  end
+
+  describe '#remaining_work_count' do
+    let_it_be(:unstarted) { create_list(:merge_request_cleanup_schedule, 2) }
+    let_it_be(:running) { create_list(:merge_request_cleanup_schedule, 2, :running) }
+    let_it_be(:completed) { create_list(:merge_request_cleanup_schedule, 2, :completed) }
+
+    it 'returns number of scheduled and unstarted cleanup schedule records' do
+      expect(worker.remaining_work_count).to eq(unstarted.count)
+    end
+
+    context 'when count exceeds max_running_jobs' do
+      before do
+        create_list(:merge_request_cleanup_schedule, worker.max_running_jobs)
+      end
+
+      it 'gets capped at max_running_jobs' do
+        expect(worker.remaining_work_count).to eq(worker.max_running_jobs)
       end
     end
   end
+
+  describe '#max_running_jobs' do
+    it 'returns the value of MAX_RUNNING_JOBS' do
+      expect(worker.max_running_jobs).to eq(described_class::MAX_RUNNING_JOBS)
+    end
+  end
+
+  def stub_cleanup_service(result)
+    expect_next_instance_of(MergeRequests::CleanupRefsService, cleanup_schedule.merge_request) do |svc|
+      expect(svc).to receive(:execute).and_return(result)
+    end
+  end
 end
diff --git a/spec/workers/namespaces/in_product_marketing_emails_worker_spec.rb b/spec/workers/namespaces/in_product_marketing_emails_worker_spec.rb
index 3b94eb0d1be..2e7b6356692 100644
--- a/spec/workers/namespaces/in_product_marketing_emails_worker_spec.rb
+++ b/spec/workers/namespaces/in_product_marketing_emails_worker_spec.rb
@@ -2,38 +2,31 @@
 
 require 'spec_helper'
 
-RSpec.describe Namespaces::InProductMarketingEmailsWorker, '#perform' do
-  using RSpec::Parameterized::TableSyntax
-
+RSpec.describe Namespaces::InProductMarketingEmailsWorker, '#perform', unless: Gitlab.ee? do
   # Running this in EE would call the overridden method, which can't be tested in CE.
   # The EE code is covered in a separate EE spec.
-  context 'not on gitlab.com', unless: Gitlab.ee? do
-    let(:is_gitlab_com) { false }
-
-    where(:in_product_marketing_emails_enabled, :experiment_active, :executes_service) do
-      true     | true     | 1
-      true     | false    | 1
-      false    | false    | 0
-      false    | true     | 0
+
+  context 'when the in_product_marketing_emails_enabled setting is disabled' do
+    before do
+      stub_application_setting(in_product_marketing_emails_enabled: false)
     end
 
-    with_them do
-      it_behaves_like 'in-product marketing email'
+    it 'does not execute the email service' do
+      expect(Namespaces::InProductMarketingEmailsService).not_to receive(:send_for_all_tracks_and_intervals)
+
+      subject.perform
     end
   end
 
-  context 'on gitlab.com' do
-    let(:is_gitlab_com) { true }
-
-    where(:in_product_marketing_emails_enabled, :experiment_active, :executes_service) do
-      true     | true     | 1
-      true     | false    | 0
-      false    | false    | 0
-      false    | true     | 0
+  context 'when the in_product_marketing_emails_enabled setting is enabled' do
+    before do
+      stub_application_setting(in_product_marketing_emails_enabled: true)
     end
 
-    with_them do
-      it_behaves_like 'in-product marketing email'
+    it 'executes the email service' do
+      expect(Namespaces::InProductMarketingEmailsService).to receive(:send_for_all_tracks_and_intervals)
+
+      subject.perform
     end
   end
 end
diff --git a/spec/workers/packages/helm/extraction_worker_spec.rb b/spec/workers/packages/helm/extraction_worker_spec.rb
new file mode 100644
index 00000000000..258413a3410
--- /dev/null
+++ b/spec/workers/packages/helm/extraction_worker_spec.rb
@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Packages::Helm::ExtractionWorker, type: :worker do
+  describe '#perform' do
+    let_it_be(:package) { create(:helm_package, without_package_files: true, status: 'processing')}
+
+    let!(:package_file) { create(:helm_package_file, without_loaded_metadatum: true, package: package) }
+    let(:package_file_id) { package_file.id }
+    let(:channel) { 'stable' }
+
+    let(:expected_metadata) do
+      {
+        'apiVersion' => 'v2',
+        'description' => 'File, Block, and Object Storage Services for your Cloud-Native Environment',
+        'icon' => 'https://rook.io/images/rook-logo.svg',
+        'name' => 'rook-ceph',
+        'sources' => ['https://github.com/rook/rook'],
+        'version' => 'v1.5.8'
+      }
+    end
+
+    subject { described_class.new.perform(channel, package_file_id) }
+
+    shared_examples 'handling error' do
+      it 'mark the package as errored', :aggregate_failures do
+        expect(Gitlab::ErrorTracking).to receive(:log_exception).with(
+          instance_of(Packages::Helm::ExtractFileMetadataService::ExtractionError),
+          project_id: package_file.package.project_id
+        )
+        expect { subject }
+          .to not_change { Packages::Package.count }
+          .and not_change { Packages::PackageFile.count }
+          .and change { package.reload.status }.from('processing').to('error')
+      end
+    end
+
+    context 'with valid package file' do
+      it_behaves_like 'an idempotent worker' do
+        let(:job_args) { [channel, package_file_id] }
+
+        it 'updates package and package file', :aggregate_failures do
+          expect(Gitlab::ErrorTracking).not_to receive(:log_exception)
+
+          expect { subject }
+            .to not_change { Packages::Package.count }
+            .and not_change { Packages::PackageFile.count }
+            .and change { Packages::Helm::FileMetadatum.count }.from(0).to(1)
+            .and change { package.reload.status }.from('processing').to('default')
+
+          helm_file_metadatum = package_file.helm_file_metadatum
+
+          expect(helm_file_metadatum.channel).to eq(channel)
+          expect(helm_file_metadatum.metadata).to eq(expected_metadata)
+        end
+      end
+    end
+
+    context 'with invalid package file id' do
+      let(:package_file_id) { 5555 }
+
+      it "doesn't update helm_file_metadatum", :aggregate_failures do
+        expect { subject }
+          .to not_change { Packages::Package.count }
+          .and not_change { Packages::PackageFile.count }
+          .and not_change { Packages::Helm::FileMetadatum.count }
+          .and not_change { package.reload.status }
+      end
+    end
+
+    context 'with an empty package file' do
+      before do
+        expect_next_instance_of(Gem::Package::TarReader) do |tar_reader|
+          expect(tar_reader).to receive(:each).and_return([])
+        end
+      end
+
+      it_behaves_like 'handling error'
+    end
+
+    context 'with an invalid YAML' do
+      before do
+        expect_next_instance_of(Gem::Package::TarReader::Entry) do |entry|
+          expect(entry).to receive(:read).and_return('{')
+        end
+      end
+
+      it_behaves_like 'handling error'
+    end
+  end
+end
diff --git a/spec/workers/partition_creation_worker_spec.rb b/spec/workers/partition_creation_worker_spec.rb
index 37225cc1f79..5d15870b7f6 100644
--- a/spec/workers/partition_creation_worker_spec.rb
+++ b/spec/workers/partition_creation_worker_spec.rb
@@ -1,27 +1,16 @@
 # frozen_string_literal: true
-
-require "spec_helper"
+#
+require 'spec_helper'
 
 RSpec.describe PartitionCreationWorker do
-  describe '#perform' do
-    subject { described_class.new.perform }
-
-    let(:creator) {  instance_double('PartitionCreator', create_partitions: nil) }
-    let(:monitoring) { instance_double('PartitionMonitoring', report_metrics: nil) }
-
-    before do
-      allow(Gitlab::Database::Partitioning::PartitionCreator).to receive(:new).and_return(creator)
-      allow(Gitlab::Database::Partitioning::PartitionMonitoring).to receive(:new).and_return(monitoring)
-    end
+  subject { described_class.new.perform }
 
-    it 'delegates to PartitionCreator' do
-      expect(creator).to receive(:create_partitions)
+  let(:management_worker) { double }
 
-      subject
-    end
-
-    it 'reports partition metrics' do
-      expect(monitoring).to receive(:report_metrics)
+  describe '#perform' do
+    it 'forwards to the Database::PartitionManagementWorker' do
+      expect(Database::PartitionManagementWorker).to receive(:new).and_return(management_worker)
+      expect(management_worker).to receive(:perform)
 
       subject
     end
diff --git a/spec/workers/pipeline_hooks_worker_spec.rb b/spec/workers/pipeline_hooks_worker_spec.rb
index 5957b355c8e..0ed00c0c66a 100644
--- a/spec/workers/pipeline_hooks_worker_spec.rb
+++ b/spec/workers/pipeline_hooks_worker_spec.rb
@@ -25,6 +25,5 @@ RSpec.describe PipelineHooksWorker do
 
   it_behaves_like 'worker with data consistency',
                   described_class,
-                  feature_flag: :load_balancing_for_pipeline_hooks_worker,
                   data_consistency: :delayed
 end
diff --git a/spec/workers/post_receive_spec.rb b/spec/workers/post_receive_spec.rb
index 4d3cc447d9b..04a38874905 100644
--- a/spec/workers/post_receive_spec.rb
+++ b/spec/workers/post_receive_spec.rb
@@ -4,7 +4,6 @@ require 'spec_helper'
 
 RSpec.describe PostReceive do
   include AfterNextHelpers
-  include ServicesHelper
 
   let(:changes) { "123456 789012 refs/heads/tést\n654321 210987 refs/tags/tag" }
   let(:wrongly_encoded_changes) { changes.encode("ISO-8859-1").force_encoding("UTF-8") }
@@ -234,7 +233,7 @@ RSpec.describe PostReceive do
         end
 
         it 'calls Git::ProcessRefChangesService' do
-          expect_execution_of(Git::ProcessRefChangesService)
+          expect(Git::ProcessRefChangesService).to get_executed
 
           perform
         end
@@ -269,7 +268,7 @@ RSpec.describe PostReceive do
           allow(Gitlab::DataBuilder::Repository).to receive(:update).and_return(fake_hook_data)
           # silence hooks so we can isolate
           allow_next(Key).to receive(:post_create_hook).and_return(true)
-          expect_execution_of(Git::ProcessRefChangesService)
+          expect(Git::ProcessRefChangesService).to get_executed
         end
 
         it 'calls SystemHooksService' do
@@ -379,7 +378,7 @@ RSpec.describe PostReceive do
       allow(Project).to receive(:find_by).and_return(project)
 
       expect(project).to receive(:execute_hooks).twice
-      expect(project).to receive(:execute_services).twice
+      expect(project).to receive(:execute_integrations).twice
 
       perform
     end
diff --git a/spec/workers/project_service_worker_spec.rb b/spec/workers/project_service_worker_spec.rb
index 9383e7ec5c4..7813d011274 100644
--- a/spec/workers/project_service_worker_spec.rb
+++ b/spec/workers/project_service_worker_spec.rb
@@ -3,22 +3,24 @@ require 'spec_helper'
 
 RSpec.describe ProjectServiceWorker, '#perform' do
   let(:worker) { described_class.new }
-  let(:service) { Integrations::Jira.new }
+  let(:integration) { Integrations::Jira.new }
 
   before do
-    allow(Integration).to receive(:find).and_return(service)
+    allow(Integration).to receive(:find).and_return(integration)
   end
 
-  it 'executes service with given data' do
+  it 'executes integration with given data' do
     data = { test: 'test' }
-    expect(service).to receive(:execute).with(data)
+    expect(integration).to receive(:execute).with(data)
 
     worker.perform(1, data)
   end
 
   it 'logs error messages' do
-    allow(service).to receive(:execute).and_raise(StandardError, 'invalid URL')
-    expect(Sidekiq.logger).to receive(:error).with({ class: described_class.name, service_class: service.class.name, message: "invalid URL" })
+    error = StandardError.new('invalid URL')
+    allow(integration).to receive(:execute).and_raise(error)
+
+    expect(Gitlab::ErrorTracking).to receive(:log_exception).with(error, integration_class: 'Integrations::Jira')
 
     worker.perform(1, {})
   end
diff --git a/spec/workers/projects/post_creation_worker_spec.rb b/spec/workers/projects/post_creation_worker_spec.rb
index 50c21575878..06acf601666 100644
--- a/spec/workers/projects/post_creation_worker_spec.rb
+++ b/spec/workers/projects/post_creation_worker_spec.rb
@@ -13,16 +13,16 @@ RSpec.describe Projects::PostCreationWorker do
   it_behaves_like 'an idempotent worker' do
     let(:job_args) { [project.id] }
 
-    describe 'Prometheus service' do
+    describe 'Prometheus integration' do
       context 'project is nil' do
         let(:job_args) { [nil] }
 
-        it 'does not create prometheus service' do
+        it 'does not create prometheus integration' do
           expect { subject }.not_to change { Integration.count }
         end
       end
 
-      context 'when project has access to shared service' do
+      context 'when project has access to shared integration' do
         context 'Prometheus application is shared via group cluster' do
           let(:project) { create(:project, group: group) }
           let(:cluster) { create(:cluster, :group, groups: [group]) }
@@ -36,13 +36,13 @@ RSpec.describe Projects::PostCreationWorker do
             create(:clusters_integrations_prometheus, cluster: cluster)
           end
 
-          it 'creates PrometheusService record', :aggregate_failures do
+          it 'creates an Integrations::Prometheus record', :aggregate_failures do
             subject
 
-            service = project.prometheus_service
-            expect(service.active).to be true
-            expect(service.manual_configuration?).to be false
-            expect(service.persisted?).to be true
+            integration = project.prometheus_integration
+            expect(integration.active).to be true
+            expect(integration.manual_configuration?).to be false
+            expect(integration.persisted?).to be true
           end
         end
 
@@ -53,31 +53,31 @@ RSpec.describe Projects::PostCreationWorker do
             create(:clusters_integrations_prometheus, cluster: cluster)
           end
 
-          it 'creates PrometheusService record', :aggregate_failures do
+          it 'creates an Integrations::Prometheus record', :aggregate_failures do
             subject
 
-            service = project.prometheus_service
-            expect(service.active).to be true
-            expect(service.manual_configuration?).to be false
-            expect(service.persisted?).to be true
+            integration = project.prometheus_integration
+            expect(integration.active).to be true
+            expect(integration.manual_configuration?).to be false
+            expect(integration.persisted?).to be true
           end
 
           it 'cleans invalid record and logs warning', :aggregate_failures do
-            invalid_service_record = build(:prometheus_service, properties: { api_url: nil, manual_configuration: true }.to_json)
-            allow(PrometheusService).to receive(:new).and_return(invalid_service_record)
+            invalid_integration_record = build(:prometheus_integration, properties: { api_url: nil, manual_configuration: true }.to_json)
+            allow(::Integrations::Prometheus).to receive(:new).and_return(invalid_integration_record)
 
             expect(Gitlab::ErrorTracking).to receive(:track_exception).with(an_instance_of(ActiveRecord::RecordInvalid), include(extra: { project_id: a_kind_of(Integer) })).twice
             subject
 
-            expect(project.prometheus_service).to be_nil
+            expect(project.prometheus_integration).to be_nil
           end
         end
 
         context 'shared Prometheus application is not available' do
-          it 'does not persist PrometheusService record', :aggregate_failures do
+          it 'does not persist an Integrations::Prometheus record' do
             subject
 
-            expect(project.prometheus_service).to be_nil
+            expect(project.prometheus_integration).to be_nil
           end
         end
       end
diff --git a/spec/workers/propagate_integration_group_worker_spec.rb b/spec/workers/propagate_integration_group_worker_spec.rb
index 1c72bed323a..9d46534df4f 100644
--- a/spec/workers/propagate_integration_group_worker_spec.rb
+++ b/spec/workers/propagate_integration_group_worker_spec.rb
@@ -8,7 +8,7 @@ RSpec.describe PropagateIntegrationGroupWorker do
     let_it_be(:another_group) { create(:group) }
     let_it_be(:subgroup1) { create(:group, parent: group) }
     let_it_be(:subgroup2) { create(:group, parent: group) }
-    let_it_be(:integration) { create(:redmine_service, :instance) }
+    let_it_be(:integration) { create(:redmine_integration, :instance) }
 
     let(:job_args) { [integration.id, group.id, subgroup2.id] }
 
@@ -22,7 +22,7 @@ RSpec.describe PropagateIntegrationGroupWorker do
       end
 
       context 'with a group integration' do
-        let_it_be(:integration) { create(:redmine_service, group: group, project: nil) }
+        let_it_be(:integration) { create(:redmine_integration, group: group, project: nil) }
 
         it 'calls to BulkCreateIntegrationService' do
           expect(BulkCreateIntegrationService).to receive(:new)
diff --git a/spec/workers/propagate_integration_inherit_descendant_worker_spec.rb b/spec/workers/propagate_integration_inherit_descendant_worker_spec.rb
index b5eb0f69017..8a231d4104c 100644
--- a/spec/workers/propagate_integration_inherit_descendant_worker_spec.rb
+++ b/spec/workers/propagate_integration_inherit_descendant_worker_spec.rb
@@ -5,8 +5,8 @@ require 'spec_helper'
 RSpec.describe PropagateIntegrationInheritDescendantWorker do
   let_it_be(:group) { create(:group) }
   let_it_be(:subgroup) { create(:group, parent: group) }
-  let_it_be(:group_integration) { create(:redmine_service, group: group, project: nil) }
-  let_it_be(:subgroup_integration) { create(:redmine_service, group: subgroup, project: nil, inherit_from_id: group_integration.id) }
+  let_it_be(:group_integration) { create(:redmine_integration, group: group, project: nil) }
+  let_it_be(:subgroup_integration) { create(:redmine_integration, group: subgroup, project: nil, inherit_from_id: group_integration.id) }
 
   it_behaves_like 'an idempotent worker' do
     let(:job_args) { [group_integration.id, subgroup_integration.id, subgroup_integration.id] }
diff --git a/spec/workers/propagate_integration_inherit_worker_spec.rb b/spec/workers/propagate_integration_inherit_worker_spec.rb
index 2b4f241f755..dd5d246d7f9 100644
--- a/spec/workers/propagate_integration_inherit_worker_spec.rb
+++ b/spec/workers/propagate_integration_inherit_worker_spec.rb
@@ -4,10 +4,10 @@ require 'spec_helper'
 
 RSpec.describe PropagateIntegrationInheritWorker do
   describe '#perform' do
-    let_it_be(:integration) { create(:redmine_service, :instance) }
-    let_it_be(:integration1) { create(:redmine_service, inherit_from_id: integration.id) }
+    let_it_be(:integration) { create(:redmine_integration, :instance) }
+    let_it_be(:integration1) { create(:redmine_integration, inherit_from_id: integration.id) }
     let_it_be(:integration2) { create(:bugzilla_integration, inherit_from_id: integration.id) }
-    let_it_be(:integration3) { create(:redmine_service) }
+    let_it_be(:integration3) { create(:redmine_integration) }
 
     it_behaves_like 'an idempotent worker' do
       let(:job_args) { [integration.id, integration1.id, integration3.id] }
diff --git a/spec/workers/propagate_integration_project_worker_spec.rb b/spec/workers/propagate_integration_project_worker_spec.rb
index c8293744bec..312631252cc 100644
--- a/spec/workers/propagate_integration_project_worker_spec.rb
+++ b/spec/workers/propagate_integration_project_worker_spec.rb
@@ -8,7 +8,7 @@ RSpec.describe PropagateIntegrationProjectWorker do
     let_it_be(:project1) { create(:project) }
     let_it_be(:project2) { create(:project, group: group) }
     let_it_be(:project3) { create(:project, group: group) }
-    let_it_be(:integration) { create(:redmine_service, :instance) }
+    let_it_be(:integration) { create(:redmine_integration, :instance) }
 
     let(:job_args) { [integration.id, project1.id, project3.id] }
 
@@ -22,7 +22,7 @@ RSpec.describe PropagateIntegrationProjectWorker do
       end
 
       context 'with a group integration' do
-        let_it_be(:integration) { create(:redmine_service, group: group, project: nil) }
+        let_it_be(:integration) { create(:redmine_integration, group: group, project: nil) }
 
         it 'calls to BulkCreateIntegrationService' do
           expect(BulkCreateIntegrationService).to receive(:new)
diff --git a/spec/workers/remove_expired_group_links_worker_spec.rb b/spec/workers/remove_expired_group_links_worker_spec.rb
index ff5f7b9db27..151bbb75226 100644
--- a/spec/workers/remove_expired_group_links_worker_spec.rb
+++ b/spec/workers/remove_expired_group_links_worker_spec.rb
@@ -51,7 +51,7 @@ RSpec.describe RemoveExpiredGroupLinksWorker do
           subject.perform
         end
 
-        it 'removes project authorization' do
+        it 'removes project authorization', :sidekiq_inline do
           shared_group = group_group_link.shared_group
           shared_with_group = group_group_link.shared_with_group
           project = create(:project, group: shared_group)
diff --git a/spec/workers/schedule_merge_request_cleanup_refs_worker_spec.rb b/spec/workers/schedule_merge_request_cleanup_refs_worker_spec.rb
index 869818b257e..ef515e43474 100644
--- a/spec/workers/schedule_merge_request_cleanup_refs_worker_spec.rb
+++ b/spec/workers/schedule_merge_request_cleanup_refs_worker_spec.rb
@@ -6,16 +6,9 @@ RSpec.describe ScheduleMergeRequestCleanupRefsWorker do
   subject(:worker) { described_class.new }
 
   describe '#perform' do
-    before do
-      allow(MergeRequest::CleanupSchedule)
-        .to receive(:scheduled_merge_request_ids)
-        .with(described_class::LIMIT)
-        .and_return([1, 2, 3, 4])
-    end
-
     it 'does nothing if the database is read-only' do
       allow(Gitlab::Database).to receive(:read_only?).and_return(true)
-      expect(MergeRequestCleanupRefsWorker).not_to receive(:bulk_perform_in)
+      expect(MergeRequestCleanupRefsWorker).not_to receive(:perform_with_capacity)
 
       worker.perform
     end
@@ -26,25 +19,17 @@ RSpec.describe ScheduleMergeRequestCleanupRefsWorker do
       end
 
       it 'does not schedule any merge request clean ups' do
-        expect(MergeRequestCleanupRefsWorker).not_to receive(:bulk_perform_in)
+        expect(MergeRequestCleanupRefsWorker).not_to receive(:perform_with_capacity)
 
         worker.perform
       end
     end
 
     include_examples 'an idempotent worker' do
-      it 'schedules MergeRequestCleanupRefsWorker to be performed by batch' do
-        expect(MergeRequestCleanupRefsWorker)
-          .to receive(:bulk_perform_in)
-          .with(
-            described_class::DELAY,
-            [[1], [2], [3], [4]],
-            batch_size: described_class::BATCH_SIZE
-          )
+      it 'schedules MergeRequestCleanupRefsWorker to be performed with capacity' do
+        expect(MergeRequestCleanupRefsWorker).to receive(:perform_with_capacity).twice
 
-        expect(worker).to receive(:log_extra_metadata_on_done).with(:merge_requests_count, 4)
-
-        worker.perform
+        subject
       end
     end
   end
diff --git a/spec/workers/users/deactivate_dormant_users_worker_spec.rb b/spec/workers/users/deactivate_dormant_users_worker_spec.rb
index 32291a143ee..934c497c79a 100644
--- a/spec/workers/users/deactivate_dormant_users_worker_spec.rb
+++ b/spec/workers/users/deactivate_dormant_users_worker_spec.rb
@@ -4,12 +4,12 @@ require 'spec_helper'
 
 RSpec.describe Users::DeactivateDormantUsersWorker do
   describe '#perform' do
+    let_it_be(:dormant) { create(:user, last_activity_on: User::MINIMUM_INACTIVE_DAYS.days.ago.to_date) }
+    let_it_be(:inactive) { create(:user, last_activity_on: nil) }
+
     subject(:worker) { described_class.new }
 
     it 'does not run for GitLab.com' do
-      create(:user, last_activity_on: User::MINIMUM_INACTIVE_DAYS.days.ago.to_date)
-      create(:user, last_activity_on: nil)
-
       expect(Gitlab).to receive(:com?).and_return(true)
       expect(Gitlab::CurrentSettings).not_to receive(:current_application_settings)
 
@@ -29,9 +29,6 @@ RSpec.describe Users::DeactivateDormantUsersWorker do
           stub_const("#{described_class.name}::BATCH_SIZE", 1)
           stub_const("#{described_class.name}::PAUSE_SECONDS", 0)
 
-          create(:user, last_activity_on: User::MINIMUM_INACTIVE_DAYS.days.ago.to_date)
-          create(:user, last_activity_on: nil)
-
           expect(worker).to receive(:sleep).twice
 
           worker.perform
@@ -48,9 +45,6 @@ RSpec.describe Users::DeactivateDormantUsersWorker do
       end
 
       it 'does nothing' do
-        create(:user, last_activity_on: User::MINIMUM_INACTIVE_DAYS.days.ago.to_date)
-        create(:user, last_activity_on: nil)
-
         worker.perform
 
         expect(User.dormant.count).to eq(1)