651 lines
23 KiB
Ruby
651 lines
23 KiB
Ruby
# frozen_string_literal: true
|
|
|
|
require 'spec_helper'
|
|
|
|
RSpec.describe Gitlab::BitbucketServerImport::Importer do
|
|
include ImportSpecHelper
|
|
|
|
let(:import_url) { 'http://my-bitbucket' }
|
|
let(:bitbucket_user) { 'bitbucket' }
|
|
let(:project_creator) { create(:user, username: 'project_creator', email: 'project_creator@example.org') }
|
|
let(:password) { 'test' }
|
|
let(:project) { create(:project, :repository, import_url: import_url, creator: project_creator) }
|
|
let(:now) { Time.now.utc.change(usec: 0) }
|
|
let(:project_key) { 'TEST' }
|
|
let(:repo_slug) { 'rouge-repo' }
|
|
let(:sample) { RepoHelpers.sample_compare }
|
|
|
|
subject { described_class.new(project, recover_missing_commits: true) }
|
|
|
|
before do
|
|
data = project.create_or_update_import_data(
|
|
data: { project_key: project_key, repo_slug: repo_slug },
|
|
credentials: { base_uri: import_url, user: bitbucket_user, password: password }
|
|
)
|
|
data.save!
|
|
project.save!
|
|
end
|
|
|
|
describe '#import_repository' do
|
|
let(:repo_url) { 'http://bitbucket:test@my-bitbucket' }
|
|
|
|
before do
|
|
expect(project.repository).to receive(:import_repository).with(repo_url)
|
|
end
|
|
|
|
it 'adds a remote' do
|
|
expect(subject).to receive(:import_pull_requests)
|
|
expect(subject).to receive(:delete_temp_branches)
|
|
expect(project.repository).to receive(:fetch_as_mirror)
|
|
.with(repo_url,
|
|
refmap: ['+refs/pull-requests/*/to:refs/merge-requests/*/head'])
|
|
|
|
subject.execute
|
|
end
|
|
|
|
it 'raises a Gitlab::Git::CommandError in the fetch' do
|
|
expect(project.repository).to receive(:fetch_as_mirror).and_raise(::Gitlab::Git::CommandError)
|
|
|
|
expect { subject.execute }.to raise_error(::Gitlab::Git::CommandError)
|
|
end
|
|
|
|
it 'raises an unhandled exception in the fetch' do
|
|
expect(project.repository).to receive(:fetch_as_mirror).and_raise(RuntimeError)
|
|
|
|
expect { subject.execute }.to raise_error(RuntimeError)
|
|
end
|
|
end
|
|
|
|
describe '#import_pull_requests' do
|
|
let(:pull_request_author) { create(:user, username: 'pull_request_author', email: 'pull_request_author@example.org') }
|
|
let(:note_author) { create(:user, username: 'note_author', email: 'note_author@example.org') }
|
|
|
|
let(:pull_request) do
|
|
instance_double(
|
|
BitbucketServer::Representation::PullRequest,
|
|
iid: 10,
|
|
source_branch_sha: sample.commits.last,
|
|
source_branch_name: Gitlab::Git::BRANCH_REF_PREFIX + sample.source_branch,
|
|
target_branch_sha: sample.commits.first,
|
|
target_branch_name: Gitlab::Git::BRANCH_REF_PREFIX + sample.target_branch,
|
|
title: 'This is a title',
|
|
description: 'This is a test pull request',
|
|
state: 'merged',
|
|
author: 'Test Author',
|
|
author_email: pull_request_author.email,
|
|
author_username: pull_request_author.username,
|
|
created_at: Time.now,
|
|
updated_at: Time.now,
|
|
raw: {},
|
|
merged?: true)
|
|
end
|
|
|
|
let(:merge_event) do
|
|
instance_double(
|
|
BitbucketServer::Representation::Activity,
|
|
comment?: false,
|
|
merge_event?: true,
|
|
committer_email: pull_request_author.email,
|
|
merge_timestamp: now,
|
|
merge_commit: '12345678'
|
|
)
|
|
end
|
|
|
|
let(:pr_note) do
|
|
instance_double(
|
|
BitbucketServer::Representation::Comment,
|
|
note: 'Hello world',
|
|
author_email: note_author.email,
|
|
author_username: note_author.username,
|
|
comments: [],
|
|
created_at: now,
|
|
updated_at: now,
|
|
parent_comment: nil)
|
|
end
|
|
|
|
let(:pr_comment) do
|
|
instance_double(
|
|
BitbucketServer::Representation::Activity,
|
|
comment?: true,
|
|
inline_comment?: false,
|
|
merge_event?: false,
|
|
comment: pr_note)
|
|
end
|
|
|
|
before do
|
|
allow(subject).to receive(:import_repository)
|
|
allow(subject).to receive(:delete_temp_branches)
|
|
allow(subject).to receive(:restore_branches)
|
|
|
|
allow(subject.client).to receive(:pull_requests).and_return([pull_request], [])
|
|
end
|
|
|
|
# As we are using Caching with redis, it is best to clean the cache after each test run, else we need to wait for
|
|
# the expiration by the importer
|
|
after do
|
|
Gitlab::Cache::Import::Caching.expire(subject.already_imported_cache_key, 0)
|
|
end
|
|
|
|
it 'imports merge event' do
|
|
expect(subject.client).to receive(:activities).and_return([merge_event])
|
|
|
|
expect { subject.execute }.to change { MergeRequest.count }.by(1)
|
|
|
|
merge_request = MergeRequest.first
|
|
expect(merge_request.metrics.merged_by).to eq(pull_request_author)
|
|
expect(merge_request.metrics.merged_at).to eq(merge_event.merge_timestamp)
|
|
expect(merge_request.merge_commit_sha).to eq('12345678')
|
|
expect(merge_request.state_id).to eq(3)
|
|
end
|
|
|
|
describe 'pull request author user mapping' do
|
|
before do
|
|
allow(subject.client).to receive(:activities).and_return([merge_event])
|
|
end
|
|
|
|
shared_examples 'imports pull requests' do
|
|
it 'maps user' do
|
|
expect { subject.execute }.to change { MergeRequest.count }.by(1)
|
|
|
|
merge_request = MergeRequest.first
|
|
expect(merge_request.author).to eq(expected_author)
|
|
end
|
|
end
|
|
|
|
context 'when bitbucket_server_user_mapping_by_username feature flag is disabled' do
|
|
before do
|
|
stub_feature_flags(bitbucket_server_user_mapping_by_username: false)
|
|
end
|
|
|
|
context 'when email is not present' do
|
|
before do
|
|
allow(pull_request).to receive(:author_email).and_return(nil)
|
|
end
|
|
|
|
let(:expected_author) { project_creator }
|
|
|
|
include_examples 'imports pull requests'
|
|
end
|
|
|
|
context 'when email is present' do
|
|
before do
|
|
allow(pull_request).to receive(:author_email).and_return(pull_request_author.email)
|
|
end
|
|
|
|
let(:expected_author) { pull_request_author }
|
|
|
|
include_examples 'imports pull requests'
|
|
end
|
|
end
|
|
|
|
context 'when bitbucket_server_user_mapping_by_username feature flag is enabled' do
|
|
before do
|
|
stub_feature_flags(bitbucket_server_user_mapping_by_username: true)
|
|
end
|
|
|
|
context 'when username is not present' do
|
|
before do
|
|
allow(pull_request).to receive(:author_username).and_return(nil)
|
|
end
|
|
|
|
let(:expected_author) { project_creator }
|
|
|
|
include_examples 'imports pull requests'
|
|
end
|
|
|
|
context 'when username is present' do
|
|
before do
|
|
allow(pull_request).to receive(:author_username).and_return(pull_request_author.username)
|
|
end
|
|
|
|
let(:expected_author) { pull_request_author }
|
|
|
|
include_examples 'imports pull requests'
|
|
end
|
|
end
|
|
|
|
context 'when user is not found' do
|
|
before do
|
|
allow(pull_request).to receive(:author_username).and_return(nil)
|
|
allow(pull_request).to receive(:author_email).and_return(nil)
|
|
end
|
|
|
|
it 'maps importer user' do
|
|
expect { subject.execute }.to change { MergeRequest.count }.by(1)
|
|
|
|
merge_request = MergeRequest.first
|
|
expect(merge_request.author).to eq(project_creator)
|
|
end
|
|
end
|
|
end
|
|
|
|
describe 'comments' do
|
|
shared_examples 'imports comments' do
|
|
it 'imports comments' do
|
|
expect(subject.client).to receive(:activities).and_return([pr_comment])
|
|
|
|
expect { subject.execute }.to change { MergeRequest.count }.by(1)
|
|
|
|
merge_request = MergeRequest.first
|
|
expect(merge_request.notes.count).to eq(1)
|
|
note = merge_request.notes.first
|
|
expect(note.note).to end_with(pr_note.note)
|
|
expect(note.author).to eq(note_author)
|
|
expect(note.created_at).to eq(pr_note.created_at)
|
|
expect(note.updated_at).to eq(pr_note.created_at)
|
|
end
|
|
end
|
|
|
|
context 'when bitbucket_server_user_mapping_by_username feature flag is disabled' do
|
|
before do
|
|
stub_feature_flags(bitbucket_server_user_mapping_by_username: false)
|
|
end
|
|
|
|
include_examples 'imports comments'
|
|
end
|
|
|
|
context 'when bitbucket_server_user_mapping_by_username feature flag is enabled' do
|
|
before do
|
|
stub_feature_flags(bitbucket_server_user_mapping_by_username: true)
|
|
end
|
|
|
|
include_examples 'imports comments'
|
|
|
|
context 'when username is not present' do
|
|
before do
|
|
allow(pr_note).to receive(:author_username).and_return(nil)
|
|
allow(subject.client).to receive(:activities).and_return([pr_comment])
|
|
end
|
|
|
|
it 'defaults to import user' do
|
|
expect { subject.execute }.to change { MergeRequest.count }.by(1)
|
|
|
|
merge_request = MergeRequest.first
|
|
expect(merge_request.notes.count).to eq(1)
|
|
note = merge_request.notes.first
|
|
expect(note.author).to eq(project_creator)
|
|
end
|
|
end
|
|
|
|
context 'when username is present' do
|
|
before do
|
|
allow(pr_note).to receive(:author_username).and_return(note_author.username)
|
|
allow(subject.client).to receive(:activities).and_return([pr_comment])
|
|
end
|
|
|
|
it 'maps by username' do
|
|
expect { subject.execute }.to change { MergeRequest.count }.by(1)
|
|
|
|
merge_request = MergeRequest.first
|
|
expect(merge_request.notes.count).to eq(1)
|
|
note = merge_request.notes.first
|
|
expect(note.author).to eq(note_author)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
context 'metrics' do
|
|
let(:histogram) { double(:histogram).as_null_object }
|
|
let(:counter) { double('counter', increment: true) }
|
|
|
|
before do
|
|
allow(Gitlab::Metrics).to receive(:counter) { counter }
|
|
allow(Gitlab::Metrics).to receive(:histogram) { histogram }
|
|
allow(subject.client).to receive(:activities).and_return([merge_event])
|
|
end
|
|
|
|
it 'counts and measures duration of imported projects' do
|
|
expect(Gitlab::Metrics).to receive(:counter).with(
|
|
:bitbucket_server_importer_imported_projects_total,
|
|
'The number of imported projects'
|
|
)
|
|
|
|
expect(Gitlab::Metrics).to receive(:histogram).with(
|
|
:bitbucket_server_importer_total_duration_seconds,
|
|
'Total time spent importing projects, in seconds',
|
|
{},
|
|
Gitlab::Import::Metrics::IMPORT_DURATION_BUCKETS
|
|
)
|
|
|
|
expect(counter).to receive(:increment)
|
|
expect(histogram).to receive(:observe).with({ importer: :bitbucket_server_importer }, anything)
|
|
|
|
subject.execute
|
|
end
|
|
|
|
it 'counts imported pull requests' do
|
|
expect(Gitlab::Metrics).to receive(:counter).with(
|
|
:bitbucket_server_importer_imported_merge_requests_total,
|
|
'The number of imported merge (pull) requests'
|
|
)
|
|
|
|
expect(counter).to receive(:increment)
|
|
|
|
subject.execute
|
|
end
|
|
end
|
|
|
|
describe 'threaded discussions' do
|
|
let(:reply_author) { create(:user, username: 'reply_author', email: 'reply_author@example.org') }
|
|
let(:inline_note_author) { create(:user, username: 'inline_note_author', email: 'inline_note_author@example.org') }
|
|
|
|
let(:reply) do
|
|
instance_double(
|
|
BitbucketServer::Representation::PullRequestComment,
|
|
author_email: reply_author.email,
|
|
author_username: reply_author.username,
|
|
note: 'I agree',
|
|
created_at: now,
|
|
updated_at: now)
|
|
end
|
|
|
|
# https://gitlab.com/gitlab-org/gitlab-test/compare/c1acaa58bbcbc3eafe538cb8274ba387047b69f8...5937ac0a7beb003549fc5fd26fc247ad
|
|
let(:inline_note) do
|
|
instance_double(
|
|
BitbucketServer::Representation::PullRequestComment,
|
|
file_type: 'ADDED',
|
|
from_sha: sample.commits.first,
|
|
to_sha: sample.commits.last,
|
|
file_path: '.gitmodules',
|
|
old_pos: nil,
|
|
new_pos: 4,
|
|
note: 'Hello world',
|
|
author_email: inline_note_author.email,
|
|
author_username: inline_note_author.username,
|
|
comments: [reply],
|
|
created_at: now,
|
|
updated_at: now,
|
|
parent_comment: nil)
|
|
end
|
|
|
|
let(:inline_comment) do
|
|
instance_double(
|
|
BitbucketServer::Representation::Activity,
|
|
comment?: true,
|
|
inline_comment?: true,
|
|
merge_event?: false,
|
|
comment: inline_note)
|
|
end
|
|
|
|
before do
|
|
allow(reply).to receive(:parent_comment).and_return(inline_note)
|
|
allow(subject.client).to receive(:activities).and_return([inline_comment])
|
|
end
|
|
|
|
shared_examples 'imports threaded discussions' do
|
|
it 'imports threaded discussions' do
|
|
expect { subject.execute }.to change { MergeRequest.count }.by(1)
|
|
|
|
merge_request = MergeRequest.first
|
|
expect(merge_request.notes.count).to eq(2)
|
|
expect(merge_request.notes.map(&:discussion_id).uniq.count).to eq(1)
|
|
|
|
notes = merge_request.notes.order(:id).to_a
|
|
start_note = notes.first
|
|
expect(start_note.type).to eq('DiffNote')
|
|
expect(start_note.note).to end_with(inline_note.note)
|
|
expect(start_note.created_at).to eq(inline_note.created_at)
|
|
expect(start_note.updated_at).to eq(inline_note.updated_at)
|
|
expect(start_note.position.base_sha).to eq(inline_note.from_sha)
|
|
expect(start_note.position.start_sha).to eq(inline_note.from_sha)
|
|
expect(start_note.position.head_sha).to eq(inline_note.to_sha)
|
|
expect(start_note.position.old_line).to be_nil
|
|
expect(start_note.position.new_line).to eq(inline_note.new_pos)
|
|
expect(start_note.author).to eq(inline_note_author)
|
|
|
|
reply_note = notes.last
|
|
# Make sure author and reply context is included
|
|
expect(reply_note.note).to start_with("> #{inline_note.note}\n\n#{reply.note}")
|
|
expect(reply_note.author).to eq(reply_author)
|
|
expect(reply_note.created_at).to eq(reply.created_at)
|
|
expect(reply_note.updated_at).to eq(reply.created_at)
|
|
expect(reply_note.position.base_sha).to eq(inline_note.from_sha)
|
|
expect(reply_note.position.start_sha).to eq(inline_note.from_sha)
|
|
expect(reply_note.position.head_sha).to eq(inline_note.to_sha)
|
|
expect(reply_note.position.old_line).to be_nil
|
|
expect(reply_note.position.new_line).to eq(inline_note.new_pos)
|
|
end
|
|
end
|
|
|
|
context 'when bitbucket_server_user_mapping_by_username feature flag is disabled' do
|
|
before do
|
|
stub_feature_flags(bitbucket_server_user_mapping_by_username: false)
|
|
end
|
|
|
|
include_examples 'imports threaded discussions'
|
|
end
|
|
|
|
context 'when bitbucket_server_user_mapping_by_username feature flag is enabled' do
|
|
before do
|
|
stub_feature_flags(bitbucket_server_user_mapping_by_username: true)
|
|
end
|
|
|
|
include_examples 'imports threaded discussions' do
|
|
context 'when username is not present' do
|
|
before do
|
|
allow(reply).to receive(:author_username).and_return(nil)
|
|
allow(inline_note).to receive(:author_username).and_return(nil)
|
|
end
|
|
|
|
it 'defaults to import user' do
|
|
expect { subject.execute }.to change { MergeRequest.count }.by(1)
|
|
|
|
notes = MergeRequest.first.notes.order(:id).to_a
|
|
|
|
expect(notes.first.author).to eq(project_creator)
|
|
expect(notes.last.author).to eq(project_creator)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
context 'when user is not found' do
|
|
before do
|
|
allow(reply).to receive(:author_username).and_return(nil)
|
|
allow(reply).to receive(:author_email).and_return(nil)
|
|
allow(inline_note).to receive(:author_username).and_return(nil)
|
|
allow(inline_note).to receive(:author_email).and_return(nil)
|
|
end
|
|
|
|
it 'maps importer user' do
|
|
expect { subject.execute }.to change { MergeRequest.count }.by(1)
|
|
|
|
notes = MergeRequest.first.notes.order(:id).to_a
|
|
|
|
expect(notes.first.author).to eq(project_creator)
|
|
expect(notes.last.author).to eq(project_creator)
|
|
end
|
|
end
|
|
end
|
|
|
|
it 'falls back to comments if diff comments fail to validate' do
|
|
reply = instance_double(
|
|
BitbucketServer::Representation::Comment,
|
|
author_email: 'someuser@gitlab.com',
|
|
author_username: 'Aquaman',
|
|
note: 'I agree',
|
|
created_at: now,
|
|
updated_at: now)
|
|
|
|
# https://gitlab.com/gitlab-org/gitlab-test/compare/c1acaa58bbcbc3eafe538cb8274ba387047b69f8...5937ac0a7beb003549fc5fd26fc247ad
|
|
inline_note = instance_double(
|
|
BitbucketServer::Representation::PullRequestComment,
|
|
file_type: 'REMOVED',
|
|
from_sha: sample.commits.first,
|
|
to_sha: sample.commits.last,
|
|
file_path: '.gitmodules',
|
|
old_pos: 8,
|
|
new_pos: 9,
|
|
note: 'This is a note with an invalid line position.',
|
|
author_email: project.owner.email,
|
|
author_username: 'Owner',
|
|
comments: [reply],
|
|
created_at: now,
|
|
updated_at: now,
|
|
parent_comment: nil)
|
|
|
|
inline_comment = instance_double(
|
|
BitbucketServer::Representation::Activity,
|
|
comment?: true,
|
|
inline_comment?: true,
|
|
merge_event?: false,
|
|
comment: inline_note)
|
|
|
|
allow(reply).to receive(:parent_comment).and_return(inline_note)
|
|
|
|
expect(subject.client).to receive(:activities).and_return([inline_comment])
|
|
|
|
expect { subject.execute }.to change { MergeRequest.count }.by(1)
|
|
|
|
merge_request = MergeRequest.first
|
|
expect(merge_request.notes.count).to eq(2)
|
|
notes = merge_request.notes
|
|
|
|
expect(notes.first.note).to start_with('*Comment on .gitmodules')
|
|
expect(notes.second.note).to start_with('*Comment on .gitmodules')
|
|
end
|
|
|
|
it 'reports an error if an exception is raised' do
|
|
allow(subject).to receive(:import_bitbucket_pull_request).and_raise(RuntimeError)
|
|
expect(Gitlab::ErrorTracking).to receive(:log_exception)
|
|
|
|
subject.execute
|
|
end
|
|
|
|
describe 'import pull requests with caching' do
|
|
let(:pull_request_already_imported) do
|
|
instance_double(
|
|
BitbucketServer::Representation::PullRequest,
|
|
iid: 11)
|
|
end
|
|
|
|
let(:pull_request_to_be_imported) do
|
|
instance_double(
|
|
BitbucketServer::Representation::PullRequest,
|
|
iid: 12,
|
|
source_branch_sha: sample.commits.last,
|
|
source_branch_name: Gitlab::Git::BRANCH_REF_PREFIX + sample.source_branch,
|
|
target_branch_sha: sample.commits.first,
|
|
target_branch_name: Gitlab::Git::BRANCH_REF_PREFIX + sample.target_branch,
|
|
title: 'This is a title',
|
|
description: 'This is a test pull request',
|
|
state: 'merged',
|
|
author: 'Test Author',
|
|
author_email: pull_request_author.email,
|
|
author_username: pull_request_author.username,
|
|
created_at: Time.now,
|
|
updated_at: Time.now,
|
|
raw: {},
|
|
merged?: true)
|
|
end
|
|
|
|
before do
|
|
Gitlab::Cache::Import::Caching.set_add(subject.already_imported_cache_key, pull_request_already_imported.iid)
|
|
allow(subject.client).to receive(:pull_requests).and_return([pull_request_to_be_imported, pull_request_already_imported], [])
|
|
end
|
|
|
|
it 'only imports one Merge Request, as the other on is in the cache' do
|
|
expect(subject.client).to receive(:activities).and_return([merge_event])
|
|
expect { subject.execute }.to change { MergeRequest.count }.by(1)
|
|
|
|
expect(Gitlab::Cache::Import::Caching.set_includes?(subject.already_imported_cache_key, pull_request_already_imported.iid)).to eq(true)
|
|
expect(Gitlab::Cache::Import::Caching.set_includes?(subject.already_imported_cache_key, pull_request_to_be_imported.iid)).to eq(true)
|
|
end
|
|
end
|
|
end
|
|
|
|
describe 'inaccessible branches' do
|
|
let(:id) { 10 }
|
|
let(:temp_branch_from) { "gitlab/import/pull-request/#{id}/from" }
|
|
let(:temp_branch_to) { "gitlab/import/pull-request/#{id}/to" }
|
|
|
|
before do
|
|
pull_request = instance_double(
|
|
BitbucketServer::Representation::PullRequest,
|
|
iid: id,
|
|
source_branch_sha: '12345678',
|
|
source_branch_name: Gitlab::Git::BRANCH_REF_PREFIX + sample.source_branch,
|
|
target_branch_sha: '98765432',
|
|
target_branch_name: Gitlab::Git::BRANCH_REF_PREFIX + sample.target_branch,
|
|
title: 'This is a title',
|
|
description: 'This is a test pull request',
|
|
state: 'merged',
|
|
author: 'Test Author',
|
|
author_email: project.owner.email,
|
|
author_username: 'author',
|
|
created_at: Time.now,
|
|
updated_at: Time.now,
|
|
merged?: true)
|
|
|
|
expect(subject.client).to receive(:pull_requests).and_return([pull_request], [])
|
|
expect(subject.client).to receive(:activities).and_return([])
|
|
expect(subject).to receive(:import_repository).twice
|
|
end
|
|
|
|
it '#restore_branches' do
|
|
expect(subject).to receive(:restore_branches).and_call_original
|
|
expect(subject).to receive(:delete_temp_branches)
|
|
expect(subject.client).to receive(:create_branch)
|
|
.with(project_key, repo_slug,
|
|
temp_branch_from,
|
|
'12345678')
|
|
expect(subject.client).to receive(:create_branch)
|
|
.with(project_key, repo_slug,
|
|
temp_branch_to,
|
|
'98765432')
|
|
|
|
expect { subject.execute }.to change { MergeRequest.count }.by(1)
|
|
end
|
|
|
|
it '#delete_temp_branches' do
|
|
expect(subject.client).to receive(:create_branch).twice
|
|
expect(subject).to receive(:delete_temp_branches).and_call_original
|
|
expect(subject.client).to receive(:delete_branch)
|
|
.with(project_key, repo_slug,
|
|
temp_branch_from,
|
|
'12345678')
|
|
expect(subject.client).to receive(:delete_branch)
|
|
.with(project_key, repo_slug,
|
|
temp_branch_to,
|
|
'98765432')
|
|
expect(project.repository).to receive(:delete_branch).with(temp_branch_from)
|
|
expect(project.repository).to receive(:delete_branch).with(temp_branch_to)
|
|
|
|
expect { subject.execute }.to change { MergeRequest.count }.by(1)
|
|
end
|
|
end
|
|
|
|
context "lfs files" do
|
|
before do
|
|
allow(project).to receive(:lfs_enabled?).and_return(true)
|
|
allow(subject).to receive(:import_repository)
|
|
allow(subject).to receive(:import_pull_requests)
|
|
end
|
|
|
|
it "downloads lfs objects if lfs_enabled is enabled for project" do
|
|
expect_next_instance_of(Projects::LfsPointers::LfsImportService) do |lfs_import_service|
|
|
expect(lfs_import_service).to receive(:execute).and_return(status: :success)
|
|
end
|
|
|
|
subject.execute
|
|
end
|
|
|
|
it "adds the error message when the lfs download fails" do
|
|
allow_next_instance_of(Projects::LfsPointers::LfsImportService) do |lfs_import_service|
|
|
expect(lfs_import_service).to receive(:execute).and_return(status: :error, message: "LFS server not reachable")
|
|
end
|
|
|
|
subject.execute
|
|
|
|
expect(project.import_state.reload.last_error).to eq(Gitlab::Json.dump({
|
|
message: "The remote data could not be fully imported.",
|
|
errors: [{
|
|
type: "lfs_objects",
|
|
errors: "The Lfs import process failed. LFS server not reachable"
|
|
}]
|
|
}))
|
|
end
|
|
end
|
|
end
|