Add latest changes from gitlab-org/gitlab@master

2 files changed, 35 insertions, 178 deletions

diff --git a/spec/models/jira_import_data_spec.rb b/spec/models/jira_import_data_spec.rb
deleted file mode 100644
index ad7a704236b..00000000000
--- a/spec/models/jira_import_data_spec.rb
+++ /dev/null
@@ -1,134 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe JiraImportData do
-  let(:symbol_keys_project) do
-    { key: 'AA', scheduled_at: 2.days.ago.strftime('%Y-%m-%d %H:%M:%S'), scheduled_by: { 'user_id' => 1, 'name' => 'tester1' } }
-  end
-
-  let(:string_keys_project) do
-    { 'key': 'BB', 'scheduled_at': 1.hour.ago.strftime('%Y-%m-%d %H:%M:%S'), 'scheduled_by': { 'user_id': 2, 'name': 'tester2' } }
-  end
-
-  let(:jira_project_details) do
-    JiraImportData::JiraProjectDetails.new('CC', 1.day.ago.strftime('%Y-%m-%d %H:%M:%S'), { user_id: 3, name: 'tester3' })
-  end
-
-  describe '#projects' do
-    it 'returns empty array if no data' do
-      expect(described_class.new.projects).to eq([])
-    end
-
-    it 'returns empty array if no projects' do
-      import_data = described_class.new(data: { 'some-key' => 10 })
-      expect(import_data.projects).to eq([])
-    end
-
-    it 'returns JiraProjectDetails sorted by scheduled_at time' do
-      import_data = described_class.new(data: { jira: { projects: [symbol_keys_project, string_keys_project, jira_project_details] } })
-
-      expect(import_data.projects.size).to eq 3
-      expect(import_data.projects.map(&:key)).to eq(%w(AA CC BB))
-      expect(import_data.projects.map(&:scheduled_by).map {|e| e['name']}).to eq %w(tester1 tester3 tester2)
-      expect(import_data.projects.map(&:scheduled_by).map {|e| e['user_id']}).to eq [1, 3, 2]
-    end
-  end
-
-  describe 'add projects' do
-    it 'adds project when data is nil' do
-      import_data = described_class.new
-      expect(import_data.data).to be nil
-
-      import_data << string_keys_project
-
-      expect(import_data.data).to eq({ 'jira' => { 'projects' => [string_keys_project] } })
-    end
-
-    it 'adds project when data has some random info' do
-      import_data = described_class.new(data: { 'one-key': 10 })
-      expect(import_data.data).to eq({ 'one-key' => 10 })
-
-      import_data << string_keys_project
-
-      expect(import_data.data).to eq({ 'one-key' => 10, 'jira' => { 'projects' => [string_keys_project] } })
-    end
-
-    it 'adds project when data already has some jira projects' do
-      import_data = described_class.new(data: { jira: { projects: [symbol_keys_project] } })
-      expect(import_data.projects.map(&:to_h)).to eq [symbol_keys_project]
-
-      import_data << string_keys_project
-
-      expect(import_data.data['jira']['projects'].size).to eq 2
-      expect(import_data.projects.map(&:key)).to eq(%w(AA BB))
-      expect(import_data.projects.map(&:scheduled_by).map {|e| e['name']}).to eq %w(tester1 tester2)
-      expect(import_data.projects.map(&:scheduled_by).map {|e| e['user_id']}).to eq [1, 2]
-    end
-  end
-
-  describe '#force_import!' do
-    it 'sets force import when data is nil' do
-      import_data = described_class.new
-
-      import_data.force_import!
-
-      expect(import_data.data['jira'][JiraImportData::FORCE_IMPORT_KEY]).to be true
-      expect(import_data.force_import?).to be false
-    end
-
-    it 'sets force import when data is present but no jira key' do
-      import_data = described_class.new(data: { 'some-key': 'some-data' })
-
-      import_data.force_import!
-
-      expect(import_data.data['jira'][JiraImportData::FORCE_IMPORT_KEY]).to be true
-      expect(import_data.data).to eq({ 'some-key' => 'some-data', 'jira' => { JiraImportData::FORCE_IMPORT_KEY => true } })
-      expect(import_data.force_import?).to be false
-    end
-
-    it 'sets force import when data and jira keys exist' do
-      import_data = described_class.new(data: { 'some-key': 'some-data', 'jira': {} })
-
-      import_data.force_import!
-
-      expect(import_data.data['jira'][JiraImportData::FORCE_IMPORT_KEY]).to be true
-      expect(import_data.data).to eq({ 'some-key' => 'some-data', 'jira' => { JiraImportData::FORCE_IMPORT_KEY => true } })
-      expect(import_data.force_import?).to be false
-    end
-
-    it 'sets force import when data and jira project data exist' do
-      import_data = described_class.new(data: { jira: { projects: [symbol_keys_project], JiraImportData::FORCE_IMPORT_KEY => false }, 'some-key': 'some-data' })
-
-      import_data.force_import!
-
-      expect(import_data.data['jira'][JiraImportData::FORCE_IMPORT_KEY]).to be true
-      expect(import_data.data).to eq({ 'some-key' => 'some-data', 'jira' => { 'projects' => [symbol_keys_project.deep_stringify_keys!], JiraImportData::FORCE_IMPORT_KEY => true } })
-      expect(import_data.force_import?).to be true
-    end
-  end
-
-  describe '#force_import?' do
-    it 'returns false when data blank' do
-      expect(described_class.new.force_import?).to be false
-    end
-
-    it 'returns false if there is no project data present' do
-      import_data = described_class.new(data: { jira: { JiraImportData::FORCE_IMPORT_KEY => true }, 'one-key': 10 })
-
-      expect(import_data.force_import?).to be false
-    end
-
-    it 'returns false when force import set to false' do
-      import_data = described_class.new(data: { jira: { projects: [symbol_keys_project], JiraImportData::FORCE_IMPORT_KEY => false }, 'one-key': 10 })
-
-      expect(import_data.force_import?).to be false
-    end
-
-    it 'returns true when force import set to true' do
-      import_data = described_class.new(data: { jira: { projects: [symbol_keys_project], JiraImportData::FORCE_IMPORT_KEY => true } })
-
-      expect(import_data.force_import?).to be true
-    end
-  end
-end
diff --git a/spec/models/project_spec.rb b/spec/models/project_spec.rb
index 21c074cdce2..3c8afee4466 100644
--- a/spec/models/project_spec.rb
+++ b/spec/models/project_spec.rb
@@ -2281,38 +2281,35 @@ describe Project do
   end
 
   describe '#jira_import_status' do
-    let(:project) { create(:project, :import_started, import_type: 'jira') }
+    let(:project) { create(:project, import_type: 'jira') }
 
-    context 'when import_data is nil' do
+    context 'when no jira imports' do
       it 'returns none' do
-        expect(project.import_data).to be nil
-        expect(project.jira_import_status).to eq('none')
+        expect(project.jira_import_status).to eq('initial')
       end
     end
 
-    context 'when import_data is set' do
-      let(:jira_import_data) { JiraImportData.new }
-      let(:project) { create(:project, :import_started, import_data: jira_import_data, import_type: 'jira') }
+    context 'when there are jira imports' do
+      let(:jira_import1) { build(:jira_import_state, :finished, project: project) }
+      let(:jira_import2) { build(:jira_import_state, project: project) }
 
-      it 'returns none' do
-        expect(project.import_data.becomes(JiraImportData).force_import?).to be false
-        expect(project.jira_import_status).to eq('none')
+      before do
+        expect(project).to receive(:latest_jira_import).and_return(jira_import2)
       end
 
-      context 'when jira_force_import is true' do
-        let(:imported_jira_project) do
-          JiraImportData::JiraProjectDetails.new('xx', Time.now.strftime('%Y-%m-%d %H:%M:%S'), { user_id: 1, name: 'root' })
+      context 'when latest import status is initial or jira imports are mising' do
+        it 'returns initial' do
+          expect(project.jira_import_status).to eq('initial')
         end
+      end
 
+      context 'when latest import status is scheduled' do
         before do
-          jira_import_data = project.import_data.becomes(JiraImportData)
-          jira_import_data << imported_jira_project
-          jira_import_data.force_import!
+          jira_import2.schedule!
         end
 
-        it 'returns started' do
-          expect(project.import_data.becomes(JiraImportData).force_import?).to be true
-          expect(project.jira_import_status).to eq('started')
+        it 'returns scheduled' do
+          expect(project.jira_import_status).to eq('scheduled')
         end
       end
     end
@@ -2375,52 +2372,46 @@ describe Project do
     context 'jira import' do
       it 'schedules a jira import job' do
         project = create(:project, import_type: 'jira')
+        jira_import = create(:jira_import_state, project: project)
 
         expect(Gitlab::JiraImport::Stage::StartImportWorker).to receive(:perform_async).with(project.id).and_return(import_jid)
-        expect(project.add_import_job).to eq(import_jid)
+
+        jira_import.schedule!
+
+        expect(jira_import.jid).to eq(import_jid)
       end
     end
   end
 
   describe '#jira_import?' do
-    subject(:project) { build(:project, import_type: 'jira') }
+    let_it_be(:project) { build(:project, import_type: 'jira') }
+    let_it_be(:jira_import) { build(:jira_import_state, project: project) }
 
-    it { expect(project.jira_import?).to be true }
-    it { expect(project.import?).to be true }
-  end
-
-  describe '#jira_force_import?' do
-    let(:imported_jira_project) do
-      JiraImportData::JiraProjectDetails.new('xx', Time.now.strftime('%Y-%m-%d %H:%M:%S'), { user_id: 1, name: 'root' })
-    end
-    let(:jira_import_data) do
-      data = JiraImportData.new
-      data << imported_jira_project
-      data.force_import!
-      data
+    before do
+      expect(project).to receive(:jira_imports).and_return([jira_import])
     end
 
-    subject(:project) { build(:project, import_type: 'jira', import_data: jira_import_data) }
-
-    it { expect(project.jira_force_import?).to be true }
+    it { expect(project.jira_import?).to be true }
+    it { expect(project.import?).to be true }
   end
 
   describe '#remove_import_data' do
-    let(:import_data) { ProjectImportData.new(data: { 'test' => 'some data' }) }
+    let_it_be(:import_data) { ProjectImportData.new(data: { 'test' => 'some data' }) }
 
     context 'when jira import' do
-      let!(:project) { create(:project, import_type: 'jira', import_data: import_data) }
+      let_it_be(:project, reload: true) { create(:project, import_type: 'jira', import_data: import_data) }
+      let_it_be(:jira_import) { create(:jira_import_state, project: project) }
 
-      it 'does not remove import data' do
+      it 'does remove import data' do
         expect(project.mirror?).to be false
         expect(project.jira_import?).to be true
-        expect { project.remove_import_data }.not_to change { ProjectImportData.count }
+        expect { project.remove_import_data }.to change { ProjectImportData.count }.by(-1)
       end
     end
 
-    context 'when not mirror neither jira import' do
-      let(:user) { create(:user) }
-      let!(:project) { create(:project, import_type: 'github', import_data: import_data) }
+    context 'when neither a mirror nor a jira import' do
+      let_it_be(:user) { create(:user) }
+      let_it_be(:project) { create(:project, import_type: 'github', import_data: import_data) }
 
       it 'removes import data' do
         expect(project.mirror?).to be false