Add latest changes from gitlab-org/gitlab@13-9-stable-eev13.9.0-rc42

27 files changed, 349 insertions, 552 deletions

diff --git a/spec/workers/build_coverage_worker_spec.rb b/spec/workers/build_coverage_worker_spec.rb
deleted file mode 100644
index 4beb6e5972f..00000000000
--- a/spec/workers/build_coverage_worker_spec.rb
+++ /dev/null
@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe BuildCoverageWorker do
-  describe '#perform' do
-    context 'when build exists' do
-      let!(:build) { create(:ci_build) }
-
-      it 'updates code coverage' do
-        expect_any_instance_of(Ci::Build)
-          .to receive(:update_coverage)
-
-        described_class.new.perform(build.id)
-      end
-    end
-
-    context 'when build does not exist' do
-      it 'does not raise exception' do
-        expect { described_class.new.perform(123) }
-          .not_to raise_error
-      end
-    end
-  end
-end
diff --git a/spec/workers/build_finished_worker_spec.rb b/spec/workers/build_finished_worker_spec.rb
index 02e15b7bc22..6d040f83dc7 100644
--- a/spec/workers/build_finished_worker_spec.rb
+++ b/spec/workers/build_finished_worker_spec.rb
@@ -11,20 +11,16 @@ RSpec.describe BuildFinishedWorker do
     context 'when build exists' do
       let!(:build) { create(:ci_build) }
 
-      it 'calculates coverage and calls hooks', :aggregate_failures do
-        trace_worker = double('trace worker')
-        coverage_worker = double('coverage worker')
-
-        allow(BuildTraceSectionsWorker).to receive(:new).and_return(trace_worker)
-        allow(BuildCoverageWorker).to receive(:new).and_return(coverage_worker)
+      before do
+        expect(Ci::Build).to receive(:find_by).with(id: build.id).and_return(build)
+      end
 
-        # Unfortunately, `ordered` does not seem to work when called within `allow_next_instance_of`
-        # so we're doing this the long and dirty way
-        expect(trace_worker).to receive(:perform).ordered
-        expect(coverage_worker).to receive(:perform).ordered
+      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::BuildReportResultWorker) do |instance|
-          expect(instance).to receive(:perform)
+        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)
diff --git a/spec/workers/build_trace_sections_worker_spec.rb b/spec/workers/build_trace_sections_worker_spec.rb
deleted file mode 100644
index 1c84b0083fb..00000000000
--- a/spec/workers/build_trace_sections_worker_spec.rb
+++ /dev/null
@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe BuildTraceSectionsWorker do
-  describe '#perform' do
-    context 'when build exists' do
-      let!(:build) { create(:ci_build) }
-
-      it 'updates trace sections' do
-        expect_any_instance_of(Ci::Build)
-          .to receive(:parse_trace_sections!)
-
-        described_class.new.perform(build.id)
-      end
-    end
-
-    context 'when build does not exist' do
-      it 'does not raise exception' do
-        expect { described_class.new.perform(123) }
-          .not_to raise_error
-      end
-    end
-  end
-end
diff --git a/spec/workers/bulk_import_worker_spec.rb b/spec/workers/bulk_import_worker_spec.rb
index d3a4144d606..8cf14ed6f8b 100644
--- a/spec/workers/bulk_import_worker_spec.rb
+++ b/spec/workers/bulk_import_worker_spec.rb
@@ -72,6 +72,21 @@ RSpec.describe BulkImportWorker do
           expect(bulk_import.entities.map(&:status_name)).to contain_exactly(:created, :started)
         end
       end
+
+      context 'when exception occurs' do
+        it 'tracks the exception & marks import as failed' do
+          bulk_import = create(:bulk_import, :created)
+          create(:bulk_import_entity, :created, bulk_import: bulk_import)
+
+          allow(BulkImports::EntityWorker).to receive(:perform_async).and_raise(StandardError)
+
+          expect(Gitlab::ErrorTracking).to receive(:track_exception).with(kind_of(StandardError), bulk_import_id: bulk_import.id)
+
+          subject.perform(bulk_import.id)
+
+          expect(bulk_import.reload.failed?).to eq(true)
+        end
+      end
     end
   end
 end
diff --git a/spec/workers/bulk_imports/entity_worker_spec.rb b/spec/workers/bulk_imports/entity_worker_spec.rb
index 31515b31947..cd9a6f605b9 100644
--- a/spec/workers/bulk_imports/entity_worker_spec.rb
+++ b/spec/workers/bulk_imports/entity_worker_spec.rb
@@ -24,6 +24,20 @@ RSpec.describe BulkImports::EntityWorker do
 
         expect(entity.reload.jid).to eq(jid)
       end
+
+      context 'when exception occurs' do
+        it 'tracks the exception & marks entity as failed' do
+          allow(BulkImports::Importers::GroupImporter).to receive(:new) { raise StandardError }
+
+          expect(Gitlab::ErrorTracking)
+            .to receive(:track_exception)
+            .with(kind_of(StandardError), bulk_import_id: bulk_import.id, entity_id: entity.id)
+
+          subject.perform(entity.id)
+
+          expect(entity.reload.failed?).to eq(true)
+        end
+      end
     end
 
     context 'when started entity does not exist' do
diff --git a/spec/workers/ci/build_report_result_worker_spec.rb b/spec/workers/ci/build_report_result_worker_spec.rb
deleted file mode 100644
index aedfa70c8b8..00000000000
--- a/spec/workers/ci/build_report_result_worker_spec.rb
+++ /dev/null
@@ -1,30 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe Ci::BuildReportResultWorker do
-  subject { described_class.new.perform(build_id) }
-
-  context 'when build exists' do
-    let(:build) { create(:ci_build) }
-    let(:build_id) { build.id }
-
-    it 'calls build report result service' do
-      expect_next_instance_of(Ci::BuildReportResultService) do |build_report_result_service|
-        expect(build_report_result_service).to receive(:execute)
-      end
-
-      subject
-    end
-  end
-
-  context 'when build does not exist' do
-    let(:build_id) { -1 }
-
-    it 'does not call build report result service' do
-      expect(Ci::BuildReportResultService).not_to receive(:execute)
-
-      subject
-    end
-  end
-end
diff --git a/spec/workers/ci/pipeline_artifacts/create_quality_report_worker_spec.rb b/spec/workers/ci/pipeline_artifacts/create_quality_report_worker_spec.rb
new file mode 100644
index 00000000000..be351032b58
--- /dev/null
+++ b/spec/workers/ci/pipeline_artifacts/create_quality_report_worker_spec.rb
@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe ::Ci::PipelineArtifacts::CreateQualityReportWorker do
+  describe '#perform' do
+    subject { described_class.new.perform(pipeline_id) }
+
+    context 'when pipeline exists' do
+      let(:pipeline) { create(:ci_pipeline, :with_codequality_reports) }
+      let(:pipeline_id) { pipeline.id }
+
+      it 'calls pipeline codequality report service' do
+        expect_next_instance_of(::Ci::PipelineArtifacts::CreateCodeQualityMrDiffReportService) do |quality_report_service|
+          expect(quality_report_service).to receive(:execute)
+        end
+
+        subject
+      end
+
+      it_behaves_like 'an idempotent worker' do
+        let(:job_args) { pipeline_id }
+
+        it 'creates a pipeline artifact' do
+          expect { subject }.to change { pipeline.pipeline_artifacts.count }.by(1)
+        end
+      end
+    end
+
+    context 'when pipeline does not exist' do
+      let(:pipeline_id) { non_existing_record_id }
+
+      it 'does not call pipeline codequality report service' do
+        expect(Ci::PipelineArtifacts::CreateCodeQualityMrDiffReportService).not_to receive(:execute)
+
+        subject
+      end
+    end
+  end
+end
diff --git a/spec/workers/ci/pipeline_artifacts/expire_artifacts_worker_spec.rb b/spec/workers/ci/pipeline_artifacts/expire_artifacts_worker_spec.rb
index 9e9aa962b63..2bdd8345374 100644
--- a/spec/workers/ci/pipeline_artifacts/expire_artifacts_worker_spec.rb
+++ b/spec/workers/ci/pipeline_artifacts/expire_artifacts_worker_spec.rb
@@ -7,7 +7,7 @@ RSpec.describe Ci::PipelineArtifacts::ExpireArtifactsWorker do
 
   describe '#perform' do
     let_it_be(:pipeline_artifact) do
-      create(:ci_pipeline_artifact, expire_at: 1.week.ago)
+      create(:ci_pipeline_artifact, :with_coverage_report, expire_at: 1.week.ago)
     end
 
     it 'executes a service' do
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 e6592f7f204..eb4faaed769 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
@@ -82,6 +82,7 @@ RSpec.describe ContainerExpirationPolicies::CleanupContainerRepositoryWorker do
         it 'skips the repository' do
           expect(ContainerExpirationPolicies::CleanupService).not_to receive(:new)
           expect(worker).to receive(:log_extra_metadata_on_done).with(:container_repository_id, repository.id)
+          expect(worker).to receive(:log_extra_metadata_on_done).with(:project_id, repository.project.id)
           expect(worker).to receive(:log_extra_metadata_on_done).with(:cleanup_status, :skipped)
 
           expect { subject }.to change { ContainerRepository.waiting_for_cleanup.count }.from(1).to(0)
@@ -198,7 +199,7 @@ RSpec.describe ContainerExpirationPolicies::CleanupContainerRepositoryWorker do
       end
     end
 
-    def cleanup_service_response(status: :finished, repository:, cleanup_tags_service_original_size: 100, cleanup_tags_service_before_truncate_size: 80, cleanup_tags_service_after_truncate_size: 80, cleanup_tags_service_before_delete_size: 50)
+    def cleanup_service_response(status: :finished, repository:, cleanup_tags_service_original_size: 100, cleanup_tags_service_before_truncate_size: 80, cleanup_tags_service_after_truncate_size: 80, cleanup_tags_service_before_delete_size: 50, cleanup_tags_service_deleted_size: 50)
       ServiceResponse.success(
         message: "cleanup #{status}",
         payload: {
@@ -213,13 +214,16 @@ RSpec.describe ContainerExpirationPolicies::CleanupContainerRepositoryWorker do
     end
 
     def expect_log_extra_metadata(service_response:, cleanup_status: :finished, truncated: false)
-      expect(worker).to receive(:log_extra_metadata_on_done).with(:cleanup_status, cleanup_status)
       expect(worker).to receive(:log_extra_metadata_on_done).with(:container_repository_id, repository.id)
-      %i[cleanup_tags_service_original_size cleanup_tags_service_before_truncate_size cleanup_tags_service_after_truncate_size cleanup_tags_service_before_delete_size].each do |field|
+      expect(worker).to receive(:log_extra_metadata_on_done).with(:project_id, repository.project.id)
+      expect(worker).to receive(:log_extra_metadata_on_done).with(:cleanup_status, cleanup_status)
+
+      %i[cleanup_tags_service_original_size cleanup_tags_service_before_truncate_size cleanup_tags_service_after_truncate_size cleanup_tags_service_before_delete_size cleanup_tags_service_deleted_size].each do |field|
         value = service_response.payload[field]
         expect(worker).to receive(:log_extra_metadata_on_done).with(field, value) unless value.nil?
       end
       expect(worker).to receive(:log_extra_metadata_on_done).with(:cleanup_tags_service_truncated, truncated)
+      expect(worker).to receive(:log_extra_metadata_on_done).with(:running_jobs_count, 0)
     end
   end
 
diff --git a/spec/workers/git_garbage_collect_worker_spec.rb b/spec/workers/git_garbage_collect_worker_spec.rb
index 13089549086..3df64c35166 100644
--- a/spec/workers/git_garbage_collect_worker_spec.rb
+++ b/spec/workers/git_garbage_collect_worker_spec.rb
@@ -5,350 +5,22 @@ require 'fileutils'
 require 'spec_helper'
 
 RSpec.describe GitGarbageCollectWorker do
-  include GitHelpers
-
   let_it_be(:project) { create(:project, :repository) }
-  let(:shell) { Gitlab::Shell.new }
-  let!(:lease_uuid) { SecureRandom.uuid }
-  let!(:lease_key) { "project_housekeeping:#{project.id}" }
-  let(:params) { [project.id, task, lease_key, lease_uuid] }
-
-  subject { described_class.new }
-
-  shared_examples 'it calls Gitaly' do
-    specify do
-      expect_any_instance_of(Gitlab::GitalyClient::RepositoryService).to receive(gitaly_task)
-        .and_return(nil)
-
-      subject.perform(*params)
-    end
-  end
 
-  shared_examples 'it updates the project statistics' do
-    it 'updates the project statistics' do
-      expect_next_instance_of(Projects::UpdateStatisticsService, project, nil, statistics: [:repository_size, :lfs_objects_size]) do |service|
-        expect(service).to receive(:execute).and_call_original
-      end
-
-      subject.perform(*params)
-    end
+  let(:lease_uuid) { SecureRandom.uuid }
+  let(:lease_key)  { "project_housekeeping:#{project.id}" }
+  let(:task)       { :full_repack }
+  let(:params)     { [project.id, task, lease_key, lease_uuid] }
 
-    it 'does nothing if the database is read-only' do
-      allow(Gitlab::Database).to receive(:read_only?) { true }
-
-      expect_any_instance_of(Projects::UpdateStatisticsService).not_to receive(:execute)
-
-      subject.perform(*params)
-    end
-  end
+  subject { described_class.new }
 
   describe "#perform" do
-    let(:gitaly_task) { :garbage_collect }
-    let(:task) { :gc }
-
-    context 'with active lease_uuid' do
-      before do
-        allow(subject).to receive(:get_lease_uuid).and_return(lease_uuid)
-      end
-
-      it_behaves_like 'it calls Gitaly'
-      it_behaves_like 'it updates the project statistics'
-
-      it "flushes ref caches when the task if 'gc'" do
-        expect(subject).to receive(:renew_lease).with(lease_key, lease_uuid).and_call_original
-        expect_any_instance_of(Repository).to receive(:expire_branches_cache).and_call_original
-        expect_any_instance_of(Repository).to receive(:branch_names).and_call_original
-        expect_any_instance_of(Repository).to receive(:has_visible_content?).and_call_original
-        expect_any_instance_of(Gitlab::Git::Repository).to receive(:has_visible_content?).and_call_original
-
-        subject.perform(*params)
-      end
-
-      it 'handles gRPC errors' do
-        expect_any_instance_of(Gitlab::GitalyClient::RepositoryService).to receive(:garbage_collect).and_raise(GRPC::NotFound)
-
-        expect { subject.perform(*params) }.to raise_exception(Gitlab::Git::Repository::NoRepository)
-      end
-    end
-
-    context 'with different lease than the active one' do
-      before do
-        allow(subject).to receive(:get_lease_uuid).and_return(SecureRandom.uuid)
-      end
-
-      it 'returns silently' do
-        expect_any_instance_of(Repository).not_to receive(:expire_branches_cache).and_call_original
-        expect_any_instance_of(Repository).not_to receive(:branch_names).and_call_original
-        expect_any_instance_of(Repository).not_to receive(:has_visible_content?).and_call_original
-
-        subject.perform(*params)
-      end
-    end
-
-    context 'with no active lease' do
-      let(:params) { [project.id] }
-
-      before do
-        allow(subject).to receive(:get_lease_uuid).and_return(false)
-      end
-
-      context 'when is able to get the lease' do
-        before do
-          allow(subject).to receive(:try_obtain_lease).and_return(SecureRandom.uuid)
-        end
-
-        it_behaves_like 'it calls Gitaly'
-        it_behaves_like 'it updates the project statistics'
-
-        it "flushes ref caches when the task if 'gc'" do
-          expect(subject).to receive(:get_lease_uuid).with("git_gc:#{task}:#{project.id}").and_return(false)
-          expect_any_instance_of(Repository).to receive(:expire_branches_cache).and_call_original
-          expect_any_instance_of(Repository).to receive(:branch_names).and_call_original
-          expect_any_instance_of(Repository).to receive(:has_visible_content?).and_call_original
-          expect_any_instance_of(Gitlab::Git::Repository).to receive(:has_visible_content?).and_call_original
-
-          subject.perform(*params)
-        end
-
-        context 'when the repository has joined a pool' do
-          let!(:pool) { create(:pool_repository, :ready) }
-          let(:project) { pool.source_project }
-
-          it 'ensures the repositories are linked' do
-            expect_any_instance_of(PoolRepository).to receive(:link_repository).once
-
-            subject.perform(*params)
-          end
-        end
-
-        context 'LFS object garbage collection' do
-          before do
-            stub_lfs_setting(enabled: true)
-          end
-
-          let_it_be(:lfs_reference) { create(:lfs_objects_project, project: project) }
-          let(:lfs_object) { lfs_reference.lfs_object }
-
-          it 'cleans up unreferenced LFS objects' do
-            expect_next_instance_of(Gitlab::Cleanup::OrphanLfsFileReferences) do |svc|
-              expect(svc.project).to eq(project)
-              expect(svc.dry_run).to be_falsy
-              expect(svc).to receive(:run!).and_call_original
-            end
-
-            subject.perform(*params)
-
-            expect(project.lfs_objects.reload).not_to include(lfs_object)
-          end
-
-          it 'catches and logs exceptions' do
-            expect_any_instance_of(Gitlab::Cleanup::OrphanLfsFileReferences)
-              .to receive(:run!)
-              .and_raise(/Failed/)
-
-            expect(Gitlab::GitLogger).to receive(:warn)
-            expect(Gitlab::ErrorTracking).to receive(:track_and_raise_for_dev_exception)
-
-            subject.perform(*params)
-          end
-
-          it 'does nothing if the database is read-only' do
-            allow(Gitlab::Database).to receive(:read_only?) { true }
-            expect_any_instance_of(Gitlab::Cleanup::OrphanLfsFileReferences).not_to receive(:run!)
-
-            subject.perform(*params)
-
-            expect(project.lfs_objects.reload).to include(lfs_object)
-          end
-        end
-      end
-
-      context 'when no lease can be obtained' do
-        before do
-          expect(subject).to receive(:try_obtain_lease).and_return(false)
-        end
-
-        it 'returns silently' do
-          expect(subject).not_to receive(:command)
-          expect_any_instance_of(Repository).not_to receive(:expire_branches_cache).and_call_original
-          expect_any_instance_of(Repository).not_to receive(:branch_names).and_call_original
-          expect_any_instance_of(Repository).not_to receive(:has_visible_content?).and_call_original
-
-          subject.perform(*params)
-        end
-      end
-    end
-
-    context "repack_full" do
-      let(:task) { :full_repack }
-      let(:gitaly_task) { :repack_full }
-
-      before do
-        expect(subject).to receive(:get_lease_uuid).and_return(lease_uuid)
+    it 'calls the Projects::GitGarbageGitGarbageCollectWorker with the same params' do
+      expect_next_instance_of(Projects::GitGarbageCollectWorker) do |instance|
+        expect(instance).to receive(:perform).with(*params)
       end
 
-      it_behaves_like 'it calls Gitaly'
-      it_behaves_like 'it updates the project statistics'
-    end
-
-    context "pack_refs" do
-      let(:task) { :pack_refs }
-      let(:gitaly_task) { :pack_refs }
-
-      before do
-        expect(subject).to receive(:get_lease_uuid).and_return(lease_uuid)
-      end
-
-      it "calls Gitaly" do
-        expect_any_instance_of(Gitlab::GitalyClient::RefService).to receive(task)
-          .and_return(nil)
-
-        subject.perform(*params)
-      end
-
-      it 'does not update the project statistics' do
-        expect(Projects::UpdateStatisticsService).not_to receive(:new)
-
-        subject.perform(*params)
-      end
-    end
-
-    context "repack_incremental" do
-      let(:task) { :incremental_repack }
-      let(:gitaly_task) { :repack_incremental }
-
-      before do
-        expect(subject).to receive(:get_lease_uuid).and_return(lease_uuid)
-      end
-
-      it_behaves_like 'it calls Gitaly'
-      it_behaves_like 'it updates the project statistics'
-    end
-
-    shared_examples 'gc tasks' do
-      before do
-        allow(subject).to receive(:get_lease_uuid).and_return(lease_uuid)
-        allow(subject).to receive(:bitmaps_enabled?).and_return(bitmaps_enabled)
-      end
-
-      it 'incremental repack adds a new packfile' do
-        create_objects(project)
-        before_packs = packs(project)
-
-        expect(before_packs.count).to be >= 1
-
-        subject.perform(project.id, 'incremental_repack', lease_key, lease_uuid)
-        after_packs = packs(project)
-
-        # Exactly one new pack should have been created
-        expect(after_packs.count).to eq(before_packs.count + 1)
-
-        # Previously existing packs are still around
-        expect(before_packs & after_packs).to eq(before_packs)
-      end
-
-      it 'full repack consolidates into 1 packfile' do
-        create_objects(project)
-        subject.perform(project.id, 'incremental_repack', lease_key, lease_uuid)
-        before_packs = packs(project)
-
-        expect(before_packs.count).to be >= 2
-
-        subject.perform(project.id, 'full_repack', lease_key, lease_uuid)
-        after_packs = packs(project)
-
-        expect(after_packs.count).to eq(1)
-
-        # Previously existing packs should be gone now
-        expect(after_packs - before_packs).to eq(after_packs)
-
-        expect(File.exist?(bitmap_path(after_packs.first))).to eq(bitmaps_enabled)
-      end
-
-      it 'gc consolidates into 1 packfile and updates packed-refs' do
-        create_objects(project)
-        before_packs = packs(project)
-        before_packed_refs = packed_refs(project)
-
-        expect(before_packs.count).to be >= 1
-
-        expect_any_instance_of(Gitlab::GitalyClient::RepositoryService)
-          .to receive(:garbage_collect)
-          .with(bitmaps_enabled, prune: false)
-          .and_call_original
-
-        subject.perform(project.id, 'gc', lease_key, lease_uuid)
-        after_packed_refs = packed_refs(project)
-        after_packs = packs(project)
-
-        expect(after_packs.count).to eq(1)
-
-        # Previously existing packs should be gone now
-        expect(after_packs - before_packs).to eq(after_packs)
-
-        # The packed-refs file should have been updated during 'git gc'
-        expect(before_packed_refs).not_to eq(after_packed_refs)
-
-        expect(File.exist?(bitmap_path(after_packs.first))).to eq(bitmaps_enabled)
-      end
-
-      it 'cleans up repository after finishing' do
-        expect_any_instance_of(Project).to receive(:cleanup).and_call_original
-
-        subject.perform(project.id, 'gc', lease_key, lease_uuid)
-      end
-
-      it 'prune calls garbage_collect with the option prune: true' do
-        expect_any_instance_of(Gitlab::GitalyClient::RepositoryService)
-          .to receive(:garbage_collect)
-          .with(bitmaps_enabled, prune: true)
-          .and_return(nil)
-
-        subject.perform(project.id, 'prune', lease_key, lease_uuid)
-      end
-    end
-
-    context 'with bitmaps enabled' do
-      let(:bitmaps_enabled) { true }
-
-      include_examples 'gc tasks'
-    end
-
-    context 'with bitmaps disabled' do
-      let(:bitmaps_enabled) { false }
-
-      include_examples 'gc tasks'
-    end
-  end
-
-  # Create a new commit on a random new branch
-  def create_objects(project)
-    rugged = rugged_repo(project.repository)
-    old_commit = rugged.branches.first.target
-    new_commit_sha = Rugged::Commit.create(
-      rugged,
-      message: "hello world #{SecureRandom.hex(6)}",
-      author: { email: 'foo@bar', name: 'baz' },
-      committer: { email: 'foo@bar', name: 'baz' },
-      tree: old_commit.tree,
-      parents: [old_commit]
-    )
-    rugged.references.create("refs/heads/#{SecureRandom.hex(6)}", new_commit_sha)
-  end
-
-  def packs(project)
-    Gitlab::GitalyClient::StorageSettings.allow_disk_access do
-      Dir["#{project.repository.path_to_repo}/objects/pack/*.pack"]
+      subject.perform(*params)
     end
   end
-
-  def packed_refs(project)
-    path = "#{project.repository.path_to_repo}/packed-refs"
-    FileUtils.touch(path)
-    File.read(path)
-  end
-
-  def bitmap_path(pack)
-    pack.sub(/\.pack\z/, '.bitmap')
-  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 7c58803d778..8fb8692fdf7 100644
--- a/spec/workers/jira_connect/sync_builds_worker_spec.rb
+++ b/spec/workers/jira_connect/sync_builds_worker_spec.rb
@@ -32,29 +32,5 @@ RSpec.describe ::JiraConnect::SyncBuildsWorker do
         subject
       end
     end
-
-    context 'when the feature flag is disabled' do
-      before do
-        stub_feature_flags(jira_sync_builds: false)
-      end
-
-      it 'does not call the sync service' do
-        expect_next(::JiraConnect::SyncService).not_to receive(:execute)
-
-        subject
-      end
-    end
-
-    context 'when the feature flag is enabled for this project' do
-      before do
-        stub_feature_flags(jira_sync_builds: pipeline.project)
-      end
-
-      it 'calls the sync service' do
-        expect_next(::JiraConnect::SyncService).to receive(:execute)
-
-        subject
-      end
-    end
   end
 end
diff --git a/spec/workers/jira_connect/sync_deployments_worker_spec.rb b/spec/workers/jira_connect/sync_deployments_worker_spec.rb
index 9485f4cd3a7..16fa2643d04 100644
--- a/spec/workers/jira_connect/sync_deployments_worker_spec.rb
+++ b/spec/workers/jira_connect/sync_deployments_worker_spec.rb
@@ -32,29 +32,5 @@ RSpec.describe ::JiraConnect::SyncDeploymentsWorker do
         subject
       end
     end
-
-    context 'when the feature flag is disabled' do
-      before do
-        stub_feature_flags(jira_sync_deployments: false)
-      end
-
-      it 'does not call the sync service' do
-        expect_next(::JiraConnect::SyncService).not_to receive(:execute)
-
-        subject
-      end
-    end
-
-    context 'when the feature flag is enabled for this project' do
-      before do
-        stub_feature_flags(jira_sync_deployments: deployment.project)
-      end
-
-      it 'calls the sync service' do
-        expect_next(::JiraConnect::SyncService).to receive(:execute)
-
-        subject
-      end
-    end
   end
 end
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 035f4ebdd3c..038eed7b9f1 100644
--- a/spec/workers/jira_connect/sync_feature_flags_worker_spec.rb
+++ b/spec/workers/jira_connect/sync_feature_flags_worker_spec.rb
@@ -32,29 +32,5 @@ RSpec.describe ::JiraConnect::SyncFeatureFlagsWorker do
         subject
       end
     end
-
-    context 'when the feature flag is disabled' do
-      before do
-        stub_feature_flags(jira_sync_feature_flags: false)
-      end
-
-      it 'does not call the sync service' do
-        expect_next(::JiraConnect::SyncService).not_to receive(:execute)
-
-        subject
-      end
-    end
-
-    context 'when the feature flag is enabled for this project' do
-      before do
-        stub_feature_flags(jira_sync_feature_flags: feature_flag.project)
-      end
-
-      it 'calls the sync service' do
-        expect_next(::JiraConnect::SyncService).to receive(:execute)
-
-        subject
-      end
-    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 88d7322536b..7401c6dd4d7 100644
--- a/spec/workers/merge_request_cleanup_refs_worker_spec.rb
+++ b/spec/workers/merge_request_cleanup_refs_worker_spec.rb
@@ -17,6 +17,18 @@ RSpec.describe MergeRequestCleanupRefsWorker do
           subject
         end
       end
+
+      context 'when merge_request_refs_cleanup flag is disabled' do
+        before do
+          stub_feature_flags(merge_request_refs_cleanup: false)
+        end
+
+        it 'does not clean up the merge request' do
+          expect(MergeRequests::CleanupRefsService).not_to receive(:new)
+
+          perform_multiple(1)
+        end
+      end
     end
 
     context 'when merge request does not exist' do
diff --git a/spec/workers/namespaceless_project_destroy_worker_spec.rb b/spec/workers/namespaceless_project_destroy_worker_spec.rb
index 618cd9cabe9..cd66af82364 100644
--- a/spec/workers/namespaceless_project_destroy_worker_spec.rb
+++ b/spec/workers/namespaceless_project_destroy_worker_spec.rb
@@ -49,7 +49,7 @@ RSpec.describe NamespacelessProjectDestroyWorker do
           subject.perform(project.id)
         end
 
-        it 'does not do anything in Project#remove_pages method' do
+        it 'does not do anything in Project#legacy_remove_pages method' do
           expect(Gitlab::PagesTransfer).not_to receive(:new)
 
           subject.perform(project.id)
diff --git a/spec/workers/namespaces/in_product_marketing_emails_worker_spec.rb b/spec/workers/namespaces/in_product_marketing_emails_worker_spec.rb
new file mode 100644
index 00000000000..722ecfc1dec
--- /dev/null
+++ b/spec/workers/namespaces/in_product_marketing_emails_worker_spec.rb
@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Namespaces::InProductMarketingEmailsWorker, '#perform' do
+  context 'when the experiment is inactive' do
+    before do
+      stub_experiment(in_product_marketing_emails: false)
+    end
+
+    it 'does not execute the in product marketing emails service' do
+      expect(Namespaces::InProductMarketingEmailsService).not_to receive(:send_for_all_tracks_and_intervals)
+
+      subject.perform
+    end
+  end
+
+  context 'when the experiment is active' do
+    before do
+      stub_experiment(in_product_marketing_emails: true)
+    end
+
+    it 'calls the send_for_all_tracks_and_intervals method on the in product marketing emails service' do
+      expect(Namespaces::InProductMarketingEmailsService).to receive(:send_for_all_tracks_and_intervals)
+
+      subject.perform
+    end
+  end
+end
diff --git a/spec/workers/namespaces/onboarding_pipeline_created_worker_spec.rb b/spec/workers/namespaces/onboarding_pipeline_created_worker_spec.rb
index f1789fa8fbd..6d69ccb50bd 100644
--- a/spec/workers/namespaces/onboarding_pipeline_created_worker_spec.rb
+++ b/spec/workers/namespaces/onboarding_pipeline_created_worker_spec.rb
@@ -3,30 +3,15 @@
 require 'spec_helper'
 
 RSpec.describe Namespaces::OnboardingPipelineCreatedWorker, '#perform' do
-  include AfterNextHelpers
-
   let_it_be(:ci_pipeline) { create(:ci_pipeline) }
 
-  before do
-    OnboardingProgress.onboard(ci_pipeline.project.namespace)
-  end
-
-  it 'registers an onboarding progress action' do
-    expect_next(OnboardingProgressService, ci_pipeline.project.namespace)
-      .to receive(:execute).with(action: :pipeline_created).and_call_original
+  it_behaves_like 'records an onboarding progress action', :pipeline_created do
+    let(:namespace) { ci_pipeline.project.namespace }
 
-    subject.perform(ci_pipeline.project.namespace_id)
-
-    expect(OnboardingProgress.completed?(ci_pipeline.project.namespace, :pipeline_created)).to eq(true)
+    subject { described_class.new.perform(ci_pipeline.project.namespace_id) }
   end
 
-  context "when a namespace doesn't exist" do
-    it 'does not register an onboarding progress action' do
-      expect_next(OnboardingProgressService, ci_pipeline.project.namespace).not_to receive(:execute)
-
-      subject.perform(nil)
-
-      expect(OnboardingProgress.completed?(ci_pipeline.project.namespace, :pipeline_created)).to eq(false)
-    end
+  it_behaves_like 'does not record an onboarding progress action' do
+    subject { described_class.new.perform(nil) }
   end
 end
diff --git a/spec/workers/namespaces/onboarding_user_added_worker_spec.rb b/spec/workers/namespaces/onboarding_user_added_worker_spec.rb
index a773e160fab..14428c0ecb8 100644
--- a/spec/workers/namespaces/onboarding_user_added_worker_spec.rb
+++ b/spec/workers/namespaces/onboarding_user_added_worker_spec.rb
@@ -3,20 +3,9 @@
 require 'spec_helper'
 
 RSpec.describe Namespaces::OnboardingUserAddedWorker, '#perform' do
-  include AfterNextHelpers
+  let_it_be(:namespace) { create(:group) }
 
-  let_it_be(:group) { create(:group) }
+  subject { described_class.new.perform(namespace.id) }
 
-  before do
-    OnboardingProgress.onboard(group)
-  end
-
-  it 'registers an onboarding progress action' do
-    expect_next(OnboardingProgressService, group)
-      .to receive(:execute).with(action: :user_added).and_call_original
-
-    subject.perform(group.id)
-
-    expect(OnboardingProgress.completed?(group, :user_added)).to be(true)
-  end
+  it_behaves_like 'records an onboarding progress action', :user_added
 end
diff --git a/spec/workers/new_note_worker_spec.rb b/spec/workers/new_note_worker_spec.rb
index 86b6d041e5c..7ba3fe94254 100644
--- a/spec/workers/new_note_worker_spec.rb
+++ b/spec/workers/new_note_worker_spec.rb
@@ -65,4 +65,24 @@ RSpec.describe NewNoteWorker do
       subject.perform(note.id)
     end
   end
+
+  context 'when Note author has been blocked' do
+    let_it_be(:note) { create(:note, author: create(:user, :blocked)) }
+
+    it "does not call NotificationService" do
+      expect(NotificationService).not_to receive(:new)
+
+      described_class.new.perform(note.id)
+    end
+  end
+
+  context 'when Note author has been deleted' do
+    let_it_be(:note) { create(:note, author: User.ghost) }
+
+    it "does not call NotificationService" do
+      expect(NotificationService).not_to receive(:new)
+
+      described_class.new.perform(note.id)
+    end
+  end
 end
diff --git a/spec/workers/packages/composer/cache_cleanup_worker_spec.rb b/spec/workers/packages/composer/cache_cleanup_worker_spec.rb
new file mode 100644
index 00000000000..e69fe55acc2
--- /dev/null
+++ b/spec/workers/packages/composer/cache_cleanup_worker_spec.rb
@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Packages::Composer::CacheCleanupWorker, type: :worker do
+  describe '#perform' do
+    let_it_be(:group) { create(:group) }
+
+    let!(:cache_file1) { create(:composer_cache_file, delete_at: nil, group: group, file_sha256: '124') }
+    let!(:cache_file2) { create(:composer_cache_file, delete_at: 2.days.from_now, group: group, file_sha256: '3456') }
+    let!(:cache_file3) { create(:composer_cache_file, delete_at: 1.day.ago, group: group, file_sha256: '5346') }
+    let!(:cache_file4) { create(:composer_cache_file, delete_at: nil, group: group, file_sha256: '56889') }
+
+    subject { described_class.new.perform }
+
+    before do
+      # emulate group deletion
+      cache_file4.update_columns(namespace_id: nil)
+    end
+
+    it 'deletes expired packages' do
+      expect { subject }.to change { Packages::Composer::CacheFile.count }.by(-2)
+      expect { cache_file1.reload }.not_to raise_error ActiveRecord::RecordNotFound
+      expect { cache_file2.reload }.not_to raise_error ActiveRecord::RecordNotFound
+      expect { cache_file3.reload }.to raise_error ActiveRecord::RecordNotFound
+      expect { cache_file4.reload }.to raise_error ActiveRecord::RecordNotFound
+    end
+  end
+end
diff --git a/spec/workers/pages_remove_worker_spec.rb b/spec/workers/pages_remove_worker_spec.rb
index 638e87043f2..864aa763fa9 100644
--- a/spec/workers/pages_remove_worker_spec.rb
+++ b/spec/workers/pages_remove_worker_spec.rb
@@ -3,24 +3,23 @@
 require 'spec_helper'
 
 RSpec.describe PagesRemoveWorker do
-  let_it_be(:project) { create(:project, path: "my.project")}
-  let_it_be(:domain) { create(:pages_domain, project: project) }
+  let(:project) { create(:project, path: "my.project")}
+  let!(:domain) { create(:pages_domain, project: project) }
+
   subject { described_class.new.perform(project.id) }
 
+  before do
+    project.mark_pages_as_deployed
+  end
+
   it 'deletes published pages' do
+    expect(project.pages_deployed?).to be(true)
+
     expect_any_instance_of(Gitlab::PagesTransfer).to receive(:rename_project).and_return true
     expect(PagesWorker).to receive(:perform_in).with(5.minutes, :remove, project.namespace.full_path, anything)
 
     subject
 
-    expect(project.reload.pages_metadatum.deployed?).to be(false)
-  end
-
-  it 'deletes all domains' do
-    expect(project.pages_domains.count).to be 1
-
-    subject
-
-    expect(project.reload.pages_domains.count).to be 0
+    expect(project.reload.pages_deployed?).to be(false)
   end
 end
diff --git a/spec/workers/pages_transfer_worker_spec.rb b/spec/workers/pages_transfer_worker_spec.rb
index 248a3713bf6..7d17461bc5a 100644
--- a/spec/workers/pages_transfer_worker_spec.rb
+++ b/spec/workers/pages_transfer_worker_spec.rb
@@ -4,7 +4,7 @@ require 'spec_helper'
 
 RSpec.describe PagesTransferWorker do
   describe '#perform' do
-    Gitlab::PagesTransfer::Async::METHODS.each do |meth|
+    Gitlab::PagesTransfer::METHODS.each do |meth|
       context "when method is #{meth}" do
         let(:args) { [1, 2, 3] }
 
diff --git a/spec/workers/post_receive_spec.rb b/spec/workers/post_receive_spec.rb
index 5b8d8878a99..aaae0988602 100644
--- a/spec/workers/post_receive_spec.rb
+++ b/spec/workers/post_receive_spec.rb
@@ -85,6 +85,14 @@ RSpec.describe PostReceive do
 
         perform
       end
+
+      it 'tracks an event for the new_project_readme experiment', :experiment do
+        expect_next_instance_of(NewProjectReadmeExperiment, :new_project_readme, nil, actor: empty_project.owner) do |e|
+          expect(e).to receive(:track_initial_writes).with(empty_project)
+        end
+
+        perform
+      end
     end
 
     shared_examples 'not updating remote mirrors' do
diff --git a/spec/workers/projects/git_garbage_collect_worker_spec.rb b/spec/workers/projects/git_garbage_collect_worker_spec.rb
new file mode 100644
index 00000000000..8c44643ae51
--- /dev/null
+++ b/spec/workers/projects/git_garbage_collect_worker_spec.rb
@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Projects::GitGarbageCollectWorker do
+  let_it_be(:project) { create(:project, :repository) }
+
+  it_behaves_like 'can collect git garbage' do
+    let(:resource) { project }
+    let(:statistics_service_klass) { Projects::UpdateStatisticsService }
+    let(:statistics_keys) { [:repository_size, :lfs_objects_size] }
+    let(:expected_default_lease) { "projects:#{resource.id}" }
+  end
+
+  context 'when is able to get the lease' do
+    let(:params) { [project.id] }
+
+    subject { described_class.new }
+
+    before do
+      allow(subject).to receive(:get_lease_uuid).and_return(false)
+      allow(subject).to receive(:find_resource).and_return(project)
+      allow(subject).to receive(:try_obtain_lease).and_return(SecureRandom.uuid)
+    end
+
+    context 'when the repository has joined a pool' do
+      let!(:pool) { create(:pool_repository, :ready) }
+      let(:project) { pool.source_project }
+
+      it 'ensures the repositories are linked' do
+        expect(project.pool_repository).to receive(:link_repository).once
+
+        subject.perform(*params)
+      end
+    end
+
+    context 'LFS object garbage collection' do
+      let_it_be(:lfs_reference) { create(:lfs_objects_project, project: project) }
+      let(:lfs_object) { lfs_reference.lfs_object }
+
+      before do
+        stub_lfs_setting(enabled: true)
+      end
+
+      it 'cleans up unreferenced LFS objects' do
+        expect_next_instance_of(Gitlab::Cleanup::OrphanLfsFileReferences) do |svc|
+          expect(svc.project).to eq(project)
+          expect(svc.dry_run).to be_falsy
+          expect(svc).to receive(:run!).and_call_original
+        end
+
+        subject.perform(*params)
+
+        expect(project.lfs_objects.reload).not_to include(lfs_object)
+      end
+
+      it 'catches and logs exceptions' do
+        allow_next_instance_of(Gitlab::Cleanup::OrphanLfsFileReferences) do |svc|
+          allow(svg).to receive(:run!).and_raise(/Failed/)
+        end
+
+        expect(Gitlab::GitLogger).to receive(:warn)
+        expect(Gitlab::ErrorTracking).to receive(:track_and_raise_for_dev_exception)
+
+        subject.perform(*params)
+      end
+
+      it 'does nothing if the database is read-only' do
+        allow(Gitlab::Database).to receive(:read_only?) { true }
+        expect(Gitlab::Cleanup::OrphanLfsFileReferences).not_to receive(:new)
+
+        subject.perform(*params)
+
+        expect(project.lfs_objects.reload).to include(lfs_object)
+      end
+    end
+  end
+end
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 0dd50efba1c..869818b257e 100644
--- a/spec/workers/schedule_merge_request_cleanup_refs_worker_spec.rb
+++ b/spec/workers/schedule_merge_request_cleanup_refs_worker_spec.rb
@@ -20,6 +20,18 @@ RSpec.describe ScheduleMergeRequestCleanupRefsWorker do
       worker.perform
     end
 
+    context 'when merge_request_refs_cleanup flag is disabled' do
+      before do
+        stub_feature_flags(merge_request_refs_cleanup: false)
+      end
+
+      it 'does not schedule any merge request clean ups' do
+        expect(MergeRequestCleanupRefsWorker).not_to receive(:bulk_perform_in)
+
+        worker.perform
+      end
+    end
+
     include_examples 'an idempotent worker' do
       it 'schedules MergeRequestCleanupRefsWorker to be performed by batch' do
         expect(MergeRequestCleanupRefsWorker)
diff --git a/spec/workers/user_status_cleanup/batch_worker_spec.rb b/spec/workers/user_status_cleanup/batch_worker_spec.rb
new file mode 100644
index 00000000000..2fd84d0e085
--- /dev/null
+++ b/spec/workers/user_status_cleanup/batch_worker_spec.rb
@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe UserStatusCleanup::BatchWorker do
+  include_examples 'an idempotent worker' do
+    subject do
+      perform_multiple([], worker: described_class.new)
+    end
+  end
+
+  describe '#perform' do
+    subject(:run_worker) { described_class.new.perform }
+
+    context 'when no records are scheduled for cleanup' do
+      let(:user_status) { create(:user_status) }
+
+      it 'does nothing' do
+        expect { run_worker }.not_to change { user_status.reload }
+      end
+    end
+
+    it 'cleans up the records' do
+      user_status_1 = create(:user_status, clear_status_at: 1.year.ago)
+      user_status_2 = create(:user_status, clear_status_at: 2.years.ago)
+
+      run_worker
+
+      deleted_statuses = UserStatus.where(user_id: [user_status_1.user_id, user_status_2.user_id])
+      expect(deleted_statuses).to be_empty
+    end
+  end
+end
diff --git a/spec/workers/wikis/git_garbage_collect_worker_spec.rb b/spec/workers/wikis/git_garbage_collect_worker_spec.rb
new file mode 100644
index 00000000000..77c2e49a83a
--- /dev/null
+++ b/spec/workers/wikis/git_garbage_collect_worker_spec.rb
@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Wikis::GitGarbageCollectWorker do
+  it_behaves_like 'can collect git garbage' do
+    let_it_be(:resource) { create(:project_wiki) }
+    let_it_be(:page) { create(:wiki_page, wiki: resource) }
+
+    let(:statistics_service_klass) { Projects::UpdateStatisticsService }
+    let(:statistics_keys) { [:wiki_size] }
+    let(:expected_default_lease) { "project_wikis:#{resource.id}" }
+  end
+end