1 files changed, 20 insertions, 133 deletions
diff --git a/spec/lib/backup/repositories_spec.rb b/spec/lib/backup/repositories_spec.rb
index db3e507596f..c6f611e727c 100644
--- a/spec/lib/backup/repositories_spec.rb
+++ b/spec/lib/backup/repositories_spec.rb
@@ -4,18 +4,14 @@ require 'spec_helper'
 
 RSpec.describe Backup::Repositories do
   let(:progress) { spy(:stdout) }
-  let(:parallel_enqueue) { true }
-  let(:strategy) { spy(:strategy, parallel_enqueue?: parallel_enqueue) }
-  let(:max_concurrency) { 1 }
-  let(:max_storage_concurrency) { 1 }
+  let(:strategy) { spy(:strategy) }
   let(:destination) { 'repositories' }
+  let(:backup_id) { 'backup_id' }
 
   subject do
     described_class.new(
       progress,
-      strategy: strategy,
-      max_concurrency: max_concurrency,
-      max_storage_concurrency: max_storage_concurrency
+      strategy: strategy
     )
   end
 
@@ -27,9 +23,9 @@ RSpec.describe Backup::Repositories do
         project_snippet = create(:project_snippet, :repository, project: project)
         personal_snippet = create(:personal_snippet, :repository, author: project.first_owner)
 
-        subject.dump(destination)
+        subject.dump(destination, backup_id)
 
-        expect(strategy).to have_received(:start).with(:create, destination)
+        expect(strategy).to have_received(:start).with(:create, destination, backup_id: backup_id)
         expect(strategy).to have_received(:enqueue).with(project, Gitlab::GlRepository::PROJECT)
         expect(strategy).to have_received(:enqueue).with(project, Gitlab::GlRepository::WIKI)
         expect(strategy).to have_received(:enqueue).with(project, Gitlab::GlRepository::DESIGN)
@@ -51,139 +47,30 @@ RSpec.describe Backup::Repositories do
       it_behaves_like 'creates repository bundles'
     end
 
-    context 'no concurrency' do
-      it 'creates the expected number of threads' do
-        expect(Thread).not_to receive(:new)
+    describe 'command failure' do
+      it 'enqueue_project raises an error' do
+        allow(strategy).to receive(:enqueue).with(anything, Gitlab::GlRepository::PROJECT).and_raise(IOError)
 
-        expect(strategy).to receive(:start).with(:create, destination)
-        projects.each do |project|
-          expect(strategy).to receive(:enqueue).with(project, Gitlab::GlRepository::PROJECT)
-        end
-        expect(strategy).to receive(:finish!)
-
-        subject.dump(destination)
-      end
-
-      describe 'command failure' do
-        it 'enqueue_project raises an error' do
-          allow(strategy).to receive(:enqueue).with(anything, Gitlab::GlRepository::PROJECT).and_raise(IOError)
-
-          expect { subject.dump(destination) }.to raise_error(IOError)
-        end
-
-        it 'project query raises an error' do
-          allow(Project).to receive_message_chain(:includes, :find_each).and_raise(ActiveRecord::StatementTimeout)
-
-          expect { subject.dump(destination) }.to raise_error(ActiveRecord::StatementTimeout)
-        end
+        expect { subject.dump(destination, backup_id) }.to raise_error(IOError)
       end
 
-      it 'avoids N+1 database queries' do
-        control_count = ActiveRecord::QueryRecorder.new do
-          subject.dump(destination)
-        end.count
+      it 'project query raises an error' do
+        allow(Project).to receive_message_chain(:includes, :find_each).and_raise(ActiveRecord::StatementTimeout)
 
-        create_list(:project, 2, :repository)
-
-        expect do
-          subject.dump(destination)
-        end.not_to exceed_query_limit(control_count)
+        expect { subject.dump(destination, backup_id) }.to raise_error(ActiveRecord::StatementTimeout)
       end
     end
 
-    context 'concurrency with a strategy without parallel enqueueing support' do
-      let(:parallel_enqueue) { false }
-      let(:max_concurrency) { 2 }
-      let(:max_storage_concurrency) { 2 }
-
-      it 'enqueues all projects sequentially' do
-        expect(Thread).not_to receive(:new)
-
-        expect(strategy).to receive(:start).with(:create, destination)
-        projects.each do |project|
-          expect(strategy).to receive(:enqueue).with(project, Gitlab::GlRepository::PROJECT)
-        end
-        expect(strategy).to receive(:finish!)
-
-        subject.dump(destination)
-      end
-    end
-
-    [4, 10].each do |max_storage_concurrency|
-      context "max_storage_concurrency #{max_storage_concurrency}", quarantine: 'https://gitlab.com/gitlab-org/gitlab/-/issues/241701' do
-        let(:storage_keys) { %w[default test_second_storage] }
-        let(:max_storage_concurrency) { max_storage_concurrency }
-
-        before do
-          allow(Gitlab.config.repositories.storages).to receive(:keys).and_return(storage_keys)
-        end
-
-        it 'creates the expected number of threads' do
-          expect(Thread).to receive(:new)
-            .exactly(storage_keys.length * (max_storage_concurrency + 1)).times
-            .and_call_original
+    it 'avoids N+1 database queries' do
+      control_count = ActiveRecord::QueryRecorder.new do
+        subject.dump(destination, backup_id)
+      end.count
 
-          expect(strategy).to receive(:start).with(:create, destination)
-          projects.each do |project|
-            expect(strategy).to receive(:enqueue).with(project, Gitlab::GlRepository::PROJECT)
-          end
-          expect(strategy).to receive(:finish!)
+      create_list(:project, 2, :repository)
 
-          subject.dump(destination)
-        end
-
-        context 'with extra max concurrency' do
-          let(:max_concurrency) { 3 }
-
-          it 'creates the expected number of threads' do
-            expect(Thread).to receive(:new)
-              .exactly(storage_keys.length * (max_storage_concurrency + 1)).times
-              .and_call_original
-
-            expect(strategy).to receive(:start).with(:create, destination)
-            projects.each do |project|
-              expect(strategy).to receive(:enqueue).with(project, Gitlab::GlRepository::PROJECT)
-            end
-            expect(strategy).to receive(:finish!)
-
-            subject.dump(destination)
-          end
-        end
-
-        describe 'command failure' do
-          it 'enqueue_project raises an error' do
-            allow(strategy).to receive(:enqueue).and_raise(IOError)
-
-            expect { subject.dump(destination) }.to raise_error(IOError)
-          end
-
-          it 'project query raises an error' do
-            allow(Project).to receive_message_chain(:for_repository_storage, :includes, :find_each).and_raise(ActiveRecord::StatementTimeout)
-
-            expect { subject.dump(destination) }.to raise_error(ActiveRecord::StatementTimeout)
-          end
-
-          context 'misconfigured storages' do
-            let(:storage_keys) { %w[test_second_storage] }
-
-            it 'raises an error' do
-              expect { subject.dump(destination) }.to raise_error(Backup::Error, 'repositories.storages in gitlab.yml is misconfigured')
-            end
-          end
-        end
-
-        it 'avoids N+1 database queries' do
-          control_count = ActiveRecord::QueryRecorder.new do
-            subject.dump(destination)
-          end.count
-
-          create_list(:project, 2, :repository)
-
-          expect do
-            subject.dump(destination)
-          end.not_to exceed_query_limit(control_count)
-        end
-      end
+      expect do
+        subject.dump(destination, backup_id)
+      end.not_to exceed_query_limit(control_count)
     end
   end