debian-mirror-gitlab/spec/models/project_import_state_spec.rb

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

303 lines
9.2 KiB
Ruby
Raw Normal View History

2019-07-07 11:18:12 +05:30
# frozen_string_literal: true
2019-12-04 20:38:33 +05:30
require 'spec_helper'
2018-10-15 14:42:47 +05:30
2023-03-17 16:20:25 +05:30
RSpec.describe ProjectImportState, type: :model, feature_category: :importers do
2020-04-22 19:07:51 +05:30
let_it_be(:correlation_id) { 'cid' }
let_it_be(:import_state, refind: true) { create(:import_state, correlation_id_value: correlation_id) }
subject { import_state }
2018-10-15 14:42:47 +05:30
describe 'associations' do
it { is_expected.to belong_to(:project) }
end
describe 'validations' do
it { is_expected.to validate_presence_of(:project) }
2023-04-23 21:23:45 +05:30
describe 'checksums attribute' do
let(:import_state) { build(:import_state, checksums: checksums) }
before do
import_state.validate
end
context 'when the checksums attribute has invalid fields' do
let(:checksums) { { fetched: { issue: :foo, note: 20 } } }
it 'adds errors' do
expect(import_state.errors.details.keys).to include(:checksums)
end
end
context 'when the checksums attribute has valid fields' do
let(:checksums) { { fetched: { issue: 8, note: 2 }, imported: { issue: 3, note: 2 } } }
it 'does not add errors' do
expect(import_state.errors.details.keys).not_to include(:checksums)
end
end
end
2018-10-15 14:42:47 +05:30
end
2019-02-15 15:39:39 +05:30
describe 'Project import job' do
2023-03-17 16:20:25 +05:30
let_it_be(:project) { create(:project) }
2019-02-15 15:39:39 +05:30
2023-03-17 16:20:25 +05:30
let(:import_state) { create(:import_state, import_url: generate(:url), project: project) }
let(:jid) { '551d3ceac5f67a116719ce41' }
2019-02-15 15:39:39 +05:30
2023-03-17 16:20:25 +05:30
before do
2019-02-15 15:39:39 +05:30
# Works around https://github.com/rspec/rspec-mocks/issues/910
allow(Project).to receive(:find).with(project.id).and_return(project)
2023-03-17 16:20:25 +05:30
allow(project).to receive(:add_import_job).and_return(jid)
2019-02-15 15:39:39 +05:30
end
2019-12-26 22:10:19 +05:30
it 'imports a project', :sidekiq_might_not_need_inline do
2023-03-17 16:20:25 +05:30
expect { import_state.schedule }.to change { import_state.status }.from('none').to('scheduled')
2020-04-22 19:07:51 +05:30
end
it 'records job and correlation IDs', :sidekiq_might_not_need_inline do
allow(Labkit::Correlation::CorrelationId).to receive(:current_or_new_id).and_return(correlation_id)
import_state.schedule
2023-03-17 16:20:25 +05:30
expect(project).to have_received(:add_import_job)
expect(import_state.jid).to eq(jid)
2020-04-22 19:07:51 +05:30
expect(import_state.correlation_id).to eq(correlation_id)
end
end
describe '#relation_hard_failures' do
let_it_be(:failures) { create_list(:import_failure, 2, :hard_failure, project: import_state.project, correlation_id_value: correlation_id) }
it 'returns hard relation failures related to this import' do
expect(subject.relation_hard_failures(limit: 100)).to match_array(failures)
end
it 'limits returned collection to given maximum' do
expect(subject.relation_hard_failures(limit: 1).size).to eq(1)
2019-02-15 15:39:39 +05:30
end
end
2020-06-23 00:09:42 +05:30
describe '#mark_as_failed' do
let(:error_message) { 'some message' }
it 'logs error when update column fails' do
allow(import_state).to receive(:update_column).and_raise(ActiveRecord::ActiveRecordError)
expect_next_instance_of(Gitlab::Import::Logger) do |logger|
expect(logger).to receive(:error).with(
2022-07-16 23:28:13 +05:30
{
error: 'ActiveRecord::ActiveRecordError',
message: 'Error setting import status to failed',
original_error: error_message
}
2020-06-23 00:09:42 +05:30
)
end
import_state.mark_as_failed(error_message)
end
it 'updates last_error with error message' do
import_state.mark_as_failed(error_message)
expect(import_state.last_error).to eq(error_message)
end
2022-04-04 11:22:00 +05:30
it 'removes project import data' do
import_data = ProjectImportData.new(data: { 'test' => 'some data' })
project = create(:project, import_data: import_data)
import_state = create(:import_state, :started, project: project)
expect do
import_state.mark_as_failed(error_message)
end.to change { project.reload.import_data }.from(import_data).to(nil)
end
2020-06-23 00:09:42 +05:30
end
2019-02-15 15:39:39 +05:30
describe '#human_status_name' do
context 'when import_state exists' do
it 'returns the humanized status name' do
import_state = build(:import_state, :started)
expect(import_state.human_status_name).to eq("started")
end
end
end
2022-06-21 17:19:12 +05:30
describe '#expire_etag_cache' do
context 'when project import type has realtime changes endpoint' do
before do
import_state.project.import_type = 'github'
end
it 'expires revelant etag cache' do
expect_next_instance_of(Gitlab::EtagCaching::Store) do |instance|
expect(instance).to receive(:touch).with(Gitlab::Routing.url_helpers.realtime_changes_import_github_path(format: :json))
end
subject.expire_etag_cache
end
end
context 'when project import type does not have realtime changes endpoint' do
before do
import_state.project.import_type = 'jira'
end
it 'does not touch etag caches' do
expect(Gitlab::EtagCaching::Store).not_to receive(:new)
subject.expire_etag_cache
end
end
end
2019-02-15 15:39:39 +05:30
describe 'import state transitions' do
context 'state transition: [:started] => [:finished]' do
it 'resets last_error' do
error_message = 'Some error'
import_state = create(:import_state, :started, last_error: error_message)
expect { import_state.finish }.to change { import_state.last_error }.from(error_message).to(nil)
end
2022-07-16 23:28:13 +05:30
it 'enqueues housekeeping when an import of a fresh project is completed' do
2019-02-15 15:39:39 +05:30
project = create(:project_empty_repo, :import_started, import_type: :github)
2022-07-16 23:28:13 +05:30
expect(Projects::AfterImportWorker).to receive(:perform_async).with(project.id)
2019-02-15 15:39:39 +05:30
2022-07-16 23:28:13 +05:30
project.import_state.finish
2019-02-15 15:39:39 +05:30
end
it 'does not perform housekeeping when project repository does not exist' do
project = create(:project, :import_started, import_type: :github)
2022-07-16 23:28:13 +05:30
expect(Projects::AfterImportWorker).not_to receive(:perform_async)
2019-02-15 15:39:39 +05:30
2022-07-16 23:28:13 +05:30
project.import_state.finish
2019-02-15 15:39:39 +05:30
end
2022-08-13 15:12:31 +05:30
it 'does not enqueue housekeeping when project does not have a valid import type' do
2019-02-15 15:39:39 +05:30
project = create(:project, :import_started, import_type: nil)
2022-07-16 23:28:13 +05:30
expect(Projects::AfterImportWorker).not_to receive(:perform_async)
2019-02-15 15:39:39 +05:30
2022-07-16 23:28:13 +05:30
project.import_state.finish
2019-02-15 15:39:39 +05:30
end
end
2022-08-13 15:12:31 +05:30
context 'state transition: [:none, :scheduled, :started] => [:canceled]' do
it 'updates the import status' do
import_state = create(:import_state, :none)
expect { import_state.cancel }
.to change { import_state.status }
.from('none').to('canceled')
end
it 'unsets the JID' do
import_state = create(:import_state, :started, jid: '123')
expect(Gitlab::SidekiqStatus)
.to receive(:unset)
.with('123')
.and_call_original
import_state.cancel!
expect(import_state.jid).to be_nil
end
it 'removes import data' do
import_data = ProjectImportData.new(data: { 'test' => 'some data' })
project = create(:project, :import_scheduled, import_data: import_data)
expect(project)
.to receive(:remove_import_data)
.and_call_original
expect do
project.import_state.cancel
project.reload
end.to change { project.import_data }
.from(import_data).to(nil)
end
end
2023-04-23 21:23:45 +05:30
context 'state transition: started: [:finished, :canceled, :failed]' do
using RSpec::Parameterized::TableSyntax
let_it_be_with_reload(:project) { create(:project) }
where(
:import_type,
:import_status,
:transition,
:expected_checksums
) do
'github' | :started | :finish | { 'fetched' => {}, 'imported' => {} }
'github' | :started | :cancel | { 'fetched' => {}, 'imported' => {} }
'github' | :started | :fail_op | { 'fetched' => {}, 'imported' => {} }
'github' | :scheduled | :cancel | {}
'gitlab_project' | :started | :cancel | {}
end
with_them do
before do
create(:import_state, status: import_status, import_type: import_type, project: project)
end
it 'updates (or does not update) checksums' do
project.import_state.send(transition)
expect(project.import_state.checksums).to eq(expected_checksums)
end
end
end
2019-02-15 15:39:39 +05:30
end
2020-01-01 13:55:28 +05:30
describe 'clearing `jid` after finish', :clean_gitlab_redis_cache do
2019-02-15 15:39:39 +05:30
context 'without an JID' do
it 'does nothing' do
2020-01-01 13:55:28 +05:30
import_state = create(:import_state, :started)
2019-02-15 15:39:39 +05:30
expect(Gitlab::SidekiqStatus)
.not_to receive(:unset)
2020-01-01 13:55:28 +05:30
import_state.finish!
2019-02-15 15:39:39 +05:30
end
end
2022-08-13 15:12:31 +05:30
context 'with a JID' do
2019-02-15 15:39:39 +05:30
it 'unsets the JID' do
2020-01-01 13:55:28 +05:30
import_state = create(:import_state, :started, jid: '123')
2019-02-15 15:39:39 +05:30
expect(Gitlab::SidekiqStatus)
.to receive(:unset)
.with('123')
.and_call_original
2020-01-01 13:55:28 +05:30
import_state.finish!
2019-02-15 15:39:39 +05:30
expect(import_state.jid).to be_nil
end
end
end
2022-06-21 17:19:12 +05:30
describe 'callbacks' do
context 'after_commit :expire_etag_cache' do
before do
import_state.project.import_type = 'github'
end
it 'expires etag cache' do
expect_next_instance_of(Gitlab::EtagCaching::Store) do |instance|
expect(instance).to receive(:touch).with(Gitlab::Routing.url_helpers.realtime_changes_import_github_path(format: :json))
end
subject.save!
end
end
end
2018-10-15 14:42:47 +05:30
end