1 files changed, 39 insertions, 44 deletions

diff --git a/spec/lib/gitlab/import/import_failure_service_spec.rb b/spec/lib/gitlab/import/import_failure_service_spec.rb
index c16d4a7c804..e3fec63adde 100644
--- a/spec/lib/gitlab/import/import_failure_service_spec.rb
+++ b/spec/lib/gitlab/import/import_failure_service_spec.rb
@@ -7,58 +7,48 @@ RSpec.describe Gitlab::Import::ImportFailureService, :aggregate_failures do
   let_it_be(:project) { create(:project, :import_started, import_type: import_type) }
 
   let(:exception) { StandardError.new('some error') }
-  let(:arguments) { { project_id: project.id } }
-  let(:base_arguments) { { error_source: 'SomeImporter', exception: exception }.merge(arguments) }
-  let(:exe_arguments) { { fail_import: false, metrics: false } }
+  let(:import_state) { nil }
+  let(:fail_import) { false }
+  let(:metrics) { false }
+
+  let(:arguments) do
+    {
+      project_id: project.id,
+      error_source: 'SomeImporter',
+      exception: exception,
+      fail_import: fail_import,
+      metrics: metrics,
+      import_state: import_state
+    }
+  end
 
   describe '.track' do
+    let(:instance) { double(:failure_service) }
+
     context 'with all arguments provided' do
-      let(:instance) { double(:failure_service) }
-      let(:instance_arguments) do
+      let(:arguments) do
         {
           exception: exception,
           import_state: '_import_state_',
           project_id: '_project_id_',
-          error_source: '_error_source_'
-        }
-      end
-
-      let(:exe_arguments) do
-        {
+          error_source: '_error_source_',
           fail_import: '_fail_import_',
           metrics: '_metrics_'
         }
       end
 
       it 'invokes a new instance and executes' do
-        expect(described_class).to receive(:new).with(**instance_arguments).and_return(instance)
-        expect(instance).to receive(:execute).with(**exe_arguments)
+        expect(described_class).to receive(:new).with(**arguments).and_return(instance)
+        expect(instance).to receive(:execute)
 
-        described_class.track(**instance_arguments.merge(exe_arguments))
+        described_class.track(**arguments)
       end
     end
 
     context 'with only necessary arguments utilizing defaults' do
-      let(:instance) { double(:failure_service) }
-      let(:instance_arguments) do
-        {
-          exception: exception,
-          import_state: nil,
-          project_id: nil,
-          error_source: nil
-        }
-      end
-
-      let(:exe_arguments) do
-        {
-          fail_import: false,
-          metrics: false
-        }
-      end
-
       it 'invokes a new instance and executes' do
-        expect(described_class).to receive(:new).with(**instance_arguments).and_return(instance)
-        expect(instance).to receive(:execute).with(**exe_arguments)
+        expect(described_class).to receive(:new).with(a_hash_including(exception: exception)).and_return(instance)
+        expect(instance).to receive(:execute)
 
         described_class.track(exception: exception)
       end
@@ -66,7 +56,7 @@ RSpec.describe Gitlab::Import::ImportFailureService, :aggregate_failures do
   end
 
   describe '#execute' do
-    subject(:service) { described_class.new(**base_arguments) }
+    subject(:service) { described_class.new(**arguments) }
 
     shared_examples 'logs the exception and fails the import' do
       it 'when the failure does not abort the import' do
@@ -89,13 +79,14 @@ RSpec.describe Gitlab::Import::ImportFailureService, :aggregate_failures do
             source: 'SomeImporter'
           )
 
-        service.execute(**exe_arguments)
+        service.execute
 
         expect(project.import_state.reload.status).to eq('failed')
 
         expect(project.import_failures).not_to be_empty
         expect(project.import_failures.last.exception_class).to eq('StandardError')
         expect(project.import_failures.last.exception_message).to eq('some error')
+        expect(project.import_failures.last.retry_count).to eq(0)
       end
     end
 
@@ -120,32 +111,36 @@ RSpec.describe Gitlab::Import::ImportFailureService, :aggregate_failures do
             source: 'SomeImporter'
           )
 
-        service.execute(**exe_arguments)
+        service.execute
 
         expect(project.import_state.reload.status).to eq('started')
 
         expect(project.import_failures).not_to be_empty
         expect(project.import_failures.last.exception_class).to eq('StandardError')
         expect(project.import_failures.last.exception_message).to eq('some error')
+        expect(project.import_failures.last.retry_count).to eq(nil)
       end
     end
 
     context 'when tracking metrics' do
-      let(:exe_arguments) { { fail_import: false, metrics: true } }
+      let(:metrics) { true }
 
       it 'tracks the failed import' do
-        metrics = double(:metrics)
+        metrics_double = double(:metrics)
 
-        expect(Gitlab::Import::Metrics).to receive(:new).with("#{project.import_type}_importer", project).and_return(metrics)
-        expect(metrics).to receive(:track_failed_import)
+        expect(Gitlab::Import::Metrics)
+          .to receive(:new)
+          .with("#{project.import_type}_importer", project)
+          .and_return(metrics_double)
+        expect(metrics_double).to receive(:track_failed_import)
 
-        service.execute(**exe_arguments)
+        service.execute
       end
     end
 
     context 'when using the project as reference' do
       context 'when it fails the import' do
-        let(:exe_arguments) { { fail_import: true, metrics: false } }
+        let(:fail_import) { true }
 
         it_behaves_like 'logs the exception and fails the import'
       end
@@ -156,10 +151,10 @@ RSpec.describe Gitlab::Import::ImportFailureService, :aggregate_failures do
     end
 
     context 'when using the import_state as reference' do
-      let(:arguments) { { import_state: project.import_state } }
+      let(:import_state) { project.import_state }
 
       context 'when it fails the import' do
-        let(:exe_arguments) { { fail_import: true, metrics: false } }
+        let(:fail_import) { true }
 
         it_behaves_like 'logs the exception and fails the import'
       end