1 files changed, 50 insertions, 54 deletions

diff --git a/spec/workers/repository_import_worker_spec.rb b/spec/workers/repository_import_worker_spec.rb
index 1dc77fbf83f..ca7c13fe24e 100644
--- a/spec/workers/repository_import_worker_spec.rb
+++ b/spec/workers/repository_import_worker_spec.rb
@@ -2,92 +2,88 @@
 
 require 'spec_helper'
 
-RSpec.describe RepositoryImportWorker do
+RSpec.describe RepositoryImportWorker, feature_category: :importers do
   describe '#perform' do
-    let(:project) { create(:project, :import_scheduled) }
-    let(:import_state) { project.import_state }
-
-    context 'when worker was reset without cleanup' do
-      it 'imports the project successfully' do
-        jid = '12345678'
-        started_project = create(:project)
-        started_import_state = create(:import_state, :started, project: started_project, jid: jid)
-
-        allow(subject).to receive(:jid).and_return(jid)
+    let(:project) { build_stubbed(:project, :import_scheduled, import_state: import_state, import_url: 'url') }
+    let(:import_state) { create(:import_state, status: :scheduled) }
+    let(:jid) { '12345678' }
+
+    before do
+      allow(subject).to receive(:jid).and_return(jid)
+      allow(Project).to receive(:find_by_id).with(project.id).and_return(project)
+      allow(project).to receive(:after_import)
+      allow(import_state).to receive(:start).and_return(true)
+    end
 
-        expect_next_instance_of(Projects::ImportService) do |instance|
-          expect(instance).to receive(:execute).and_return({ status: :ok })
-        end
+    context 'when project not found (deleted)' do
+      before do
+        allow(Project).to receive(:find_by_id).with(project.id).and_return(nil)
+      end
 
-        # Works around https://github.com/rspec/rspec-mocks/issues/910
-        expect(Project).to receive(:find).with(started_project.id).and_return(started_project)
-        expect(started_project.repository).to receive(:expire_emptiness_caches)
-        expect(started_project.wiki.repository).to receive(:expire_emptiness_caches)
-        expect(started_import_state).to receive(:finish)
+      it 'does not raise any exception' do
+        expect(Projects::ImportService).not_to receive(:new)
 
-        subject.perform(started_project.id)
+        expect { subject.perform(project.id) }.not_to raise_error
       end
     end
 
-    context 'when the import was successful' do
-      it 'imports a project' do
+    context 'when import_state is scheduled' do
+      it 'imports the project successfully' do
         expect_next_instance_of(Projects::ImportService) do |instance|
           expect(instance).to receive(:execute).and_return({ status: :ok })
         end
 
-        # Works around https://github.com/rspec/rspec-mocks/issues/910
-        expect(Project).to receive(:find).with(project.id).and_return(project)
-        expect(project.repository).to receive(:expire_emptiness_caches)
-        expect(project.wiki.repository).to receive(:expire_emptiness_caches)
-        expect(import_state).to receive(:finish)
-
         subject.perform(project.id)
+
+        expect(project).to have_received(:after_import)
+        expect(import_state).to have_received(:start)
       end
     end
 
-    context 'when the import has failed' do
-      it 'updates the error on Import/Export & hides credentials from import URL' do
-        import_url = 'https://user:pass@test.com/root/repoC.git/'
-        error = "#{import_url} not found"
-
-        import_state.update!(jid: '123')
-        project.update!(import_type: 'gitlab_project')
+    context 'when worker was reset without cleanup (import_state is started)' do
+      let(:import_state) { create(:import_state, :started, jid: jid) }
 
+      it 'imports the project successfully' do
         expect_next_instance_of(Projects::ImportService) do |instance|
-          expect(instance).to receive(:track_start_import).and_raise(StandardError, error)
+          expect(instance).to receive(:execute).and_return({ status: :ok })
         end
 
-        expect { subject.perform(project.id) }.not_to raise_error
+        subject.perform(project.id)
 
-        import_state.reload
-        expect(import_state.jid).to eq('123')
-        expect(import_state.status).to eq('failed')
-        expect(import_state.last_error).to include("[FILTERED] not found")
-        expect(import_state.last_error).not_to include(import_url)
+        expect(project).to have_received(:after_import)
+        expect(import_state).not_to have_received(:start)
       end
     end
 
     context 'when using an asynchronous importer' do
       it 'does not mark the import process as finished' do
-        service = double(:service)
+        expect_next_instance_of(Projects::ImportService) do |instance|
+          expect(instance).to receive(:execute).and_return({ status: :ok })
+          expect(instance).to receive(:async?).and_return(true)
+        end
+
+        subject.perform(project.id)
 
-        allow(Projects::ImportService)
-          .to receive(:new)
-          .and_return(service)
+        expect(project).not_to have_received(:after_import)
+      end
+    end
 
-        allow(service)
-          .to receive(:execute)
-          .and_return(true)
+    context 'when the import has failed' do
+      let(:error) { "https://user:pass@test.com/root/repoC.git/ not found" }
 
-        allow(service)
-          .to receive(:async?)
-          .and_return(true)
+      before do
+        allow(import_state).to receive(:mark_as_failed)
+      end
 
-        expect_next_instance_of(ProjectImportState) do |instance|
-          expect(instance).not_to receive(:finish)
+      it 'marks import_state as failed' do
+        expect_next_instance_of(Projects::ImportService) do |instance|
+          expect(instance).to receive(:execute).and_return({ status: :error, message: error })
         end
 
         subject.perform(project.id)
+
+        expect(import_state).to have_received(:mark_as_failed).with(error)
+        expect(project).not_to have_received(:after_import)
       end
     end
   end