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

442 lines
14 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
2020-07-28 23:09:34 +05:30
RSpec.describe RemoteMirror, :mailer do
2018-12-05 23:21:45 +05:30
include GitHelpers
2018-10-15 14:42:47 +05:30
describe 'URL validation' do
context 'with a valid URL' do
2019-07-07 11:18:12 +05:30
it 'is valid' do
2018-10-15 14:42:47 +05:30
remote_mirror = build(:remote_mirror)
expect(remote_mirror).to be_valid
end
end
context 'with an invalid URL' do
2019-07-07 11:18:12 +05:30
it 'is not valid' do
2018-10-15 14:42:47 +05:30
remote_mirror = build(:remote_mirror, url: 'ftp://invalid.invalid')
2018-11-08 19:23:39 +05:30
2018-10-15 14:42:47 +05:30
expect(remote_mirror).not_to be_valid
2018-11-08 19:23:39 +05:30
end
it 'does not allow url with an invalid user' do
remote_mirror = build(:remote_mirror, url: 'http://$user:password@invalid.invalid')
expect(remote_mirror).to be_invalid
expect(remote_mirror.errors[:url].first).to include('Username needs to start with an alphanumeric character')
2018-10-15 14:42:47 +05:30
end
2019-01-03 12:48:30 +05:30
it 'does not allow url pointing to localhost' do
remote_mirror = build(:remote_mirror, url: 'http://127.0.0.2/t.git')
expect(remote_mirror).to be_invalid
expect(remote_mirror.errors[:url].first).to include('Requests to loopback addresses are not allowed')
end
it 'does not allow url pointing to the local network' do
remote_mirror = build(:remote_mirror, url: 'https://192.168.1.1')
expect(remote_mirror).to be_invalid
expect(remote_mirror.errors[:url].first).to include('Requests to the local network are not allowed')
end
2019-12-04 20:38:33 +05:30
it 'returns a nil safe_url' do
remote_mirror = build(:remote_mirror, url: 'http://[0:0:0:0:ffff:123.123.123.123]/foo.git')
expect(remote_mirror.url).to eq('http://[0:0:0:0:ffff:123.123.123.123]/foo.git')
expect(remote_mirror.safe_url).to be_nil
end
2018-10-15 14:42:47 +05:30
end
end
describe 'encrypting credentials' do
context 'when setting URL for a first time' do
it 'stores the URL without credentials' do
mirror = create_mirror(url: 'http://foo:bar@test.com')
expect(mirror.read_attribute(:url)).to eq('http://test.com')
end
it 'stores the credentials on a separate field' do
mirror = create_mirror(url: 'http://foo:bar@test.com')
expect(mirror.credentials).to eq({ user: 'foo', password: 'bar' })
end
it 'handles credentials with large content' do
mirror = create_mirror(url: 'http://bxnhm8dote33ct932r3xavslj81wxmr7o8yux8do10oozckkif:9ne7fuvjn40qjt35dgt8v86q9m9g9essryxj76sumg2ccl2fg26c0krtz2gzfpyq4hf22h328uhq6npuiq6h53tpagtsj7vsrz75@test.com')
expect(mirror.credentials).to eq({
user: 'bxnhm8dote33ct932r3xavslj81wxmr7o8yux8do10oozckkif',
password: '9ne7fuvjn40qjt35dgt8v86q9m9g9essryxj76sumg2ccl2fg26c0krtz2gzfpyq4hf22h328uhq6npuiq6h53tpagtsj7vsrz75'
})
end
end
context 'when updating the URL' do
it 'allows a new URL without credentials' do
mirror = create_mirror(url: 'http://foo:bar@test.com')
mirror.update_attribute(:url, 'http://test.com')
expect(mirror.url).to eq('http://test.com')
expect(mirror.credentials).to eq({ user: nil, password: nil })
end
it 'allows a new URL with credentials' do
mirror = create_mirror(url: 'http://test.com')
mirror.update_attribute(:url, 'http://foo:bar@test.com')
expect(mirror.url).to eq('http://foo:bar@test.com')
expect(mirror.credentials).to eq({ user: 'foo', password: 'bar' })
end
2021-10-27 15:23:28 +05:30
it 'does not update the repository config if credentials changed' do
2018-10-15 14:42:47 +05:30
mirror = create_mirror(url: 'http://foo:bar@test.com')
repo = mirror.project.repository
2021-10-27 15:23:28 +05:30
old_config = rugged_repo(repo).config
2018-10-15 14:42:47 +05:30
mirror.update_attribute(:url, 'http://foo:baz@test.com')
2021-10-27 15:23:28 +05:30
expect(rugged_repo(repo).config.to_hash).to eq(old_config.to_hash)
2018-10-15 14:42:47 +05:30
end
end
end
2020-11-24 15:15:51 +05:30
describe '#bare_url' do
it 'returns the URL without any credentials' do
remote_mirror = build(:remote_mirror, url: 'http://user:pass@example.com/foo')
expect(remote_mirror.bare_url).to eq('http://example.com/foo')
end
it 'returns an empty string when the URL is nil' do
remote_mirror = build(:remote_mirror, url: nil)
expect(remote_mirror.bare_url).to eq('')
end
end
2020-04-22 19:07:51 +05:30
describe '#update_repository' do
2021-10-27 15:23:28 +05:30
it 'performs update including options' do
git_remote_mirror = stub_const('Gitlab::Git::RemoteMirror', spy)
mirror = build(:remote_mirror)
2021-09-04 01:27:46 +05:30
2021-10-27 15:23:28 +05:30
expect(mirror).to receive(:options_for_update).and_return(keep_divergent_refs: true)
mirror.update_repository
2021-09-04 01:27:46 +05:30
2021-10-27 15:23:28 +05:30
expect(git_remote_mirror).to have_received(:new).with(
mirror.project.repository.raw,
mirror.url,
keep_divergent_refs: true
)
expect(git_remote_mirror).to have_received(:update)
2020-04-22 19:07:51 +05:30
end
2020-05-24 23:13:21 +05:30
end
2020-04-22 19:07:51 +05:30
2020-05-24 23:13:21 +05:30
describe '#options_for_update' do
it 'includes the `keep_divergent_refs` option' do
2020-04-22 19:07:51 +05:30
mirror = build_stubbed(:remote_mirror, keep_divergent_refs: true)
2020-05-24 23:13:21 +05:30
options = mirror.options_for_update
2020-04-22 19:07:51 +05:30
2020-05-24 23:13:21 +05:30
expect(options).to include(keep_divergent_refs: true)
end
it 'includes the `only_branches_matching` option' do
branch = create(:protected_branch)
mirror = build_stubbed(:remote_mirror, project: branch.project, only_protected_branches: true)
options = mirror.options_for_update
expect(options).to include(only_branches_matching: [branch.name])
end
it 'includes the `ssh_key` option' do
mirror = build(:remote_mirror, :ssh, ssh_private_key: 'private-key')
options = mirror.options_for_update
expect(options).to include(ssh_key: 'private-key')
end
it 'includes the `known_hosts` option' do
mirror = build(:remote_mirror, :ssh, ssh_known_hosts: 'known-hosts')
options = mirror.options_for_update
expect(options).to include(known_hosts: 'known-hosts')
2020-04-22 19:07:51 +05:30
end
end
2018-10-15 14:42:47 +05:30
describe '#safe_url' do
context 'when URL contains credentials' do
it 'masks the credentials' do
mirror = create_mirror(url: 'http://foo:bar@test.com')
expect(mirror.safe_url).to eq('http://*****:*****@test.com')
end
end
context 'when URL does not contain credentials' do
it 'shows the full URL' do
mirror = create_mirror(url: 'http://test.com')
expect(mirror.safe_url).to eq('http://test.com')
end
end
end
2019-10-12 21:52:04 +05:30
describe '#mark_as_failed!' do
2019-02-15 15:39:39 +05:30
let(:remote_mirror) { create(:remote_mirror) }
let(:error_message) { 'http://user:pass@test.com/root/repoC.git/' }
let(:sanitized_error_message) { 'http://*****:*****@test.com/root/repoC.git/' }
subject do
remote_mirror.update_start
2019-10-12 21:52:04 +05:30
remote_mirror.mark_as_failed!(error_message)
2019-02-15 15:39:39 +05:30
end
it 'sets the update_status to failed' do
subject
expect(remote_mirror.reload.update_status).to eq('failed')
end
it 'saves the sanitized error' do
subject
expect(remote_mirror.last_error).to eq(sanitized_error_message)
end
context 'notifications' do
let(:user) { create(:user) }
before do
remote_mirror.project.add_maintainer(user)
end
2019-12-26 22:10:19 +05:30
it 'notifies the project maintainers', :sidekiq_might_not_need_inline do
2019-02-15 15:39:39 +05:30
perform_enqueued_jobs { subject }
should_email(user)
end
end
end
2021-04-29 21:17:54 +05:30
describe '#hard_retry!' do
let(:remote_mirror) { create(:remote_mirror).tap {|mirror| mirror.update_column(:url, 'invalid') } }
it 'transitions an invalid mirror to the to_retry state' do
remote_mirror.hard_retry!('Invalid')
expect(remote_mirror.update_status).to eq('to_retry')
expect(remote_mirror.last_error).to eq('Invalid')
end
end
describe '#hard_fail!' do
let(:remote_mirror) { create(:remote_mirror).tap {|mirror| mirror.update_column(:url, 'invalid') } }
it 'transitions an invalid mirror to the failed state' do
remote_mirror.hard_fail!('Invalid')
expect(remote_mirror.update_status).to eq('failed')
expect(remote_mirror.last_error).to eq('Invalid')
expect(remote_mirror.last_update_at).not_to be_nil
expect(RemoteMirrorNotificationWorker.jobs).not_to be_empty
end
end
2018-10-15 14:42:47 +05:30
context 'when remote mirror gets destroyed' do
2021-10-27 15:23:28 +05:30
it 'does not remove the remote' do
2018-10-15 14:42:47 +05:30
mirror = create_mirror(url: 'http://foo:bar@test.com')
mirror.destroy!
end
end
context 'stuck mirrors' do
2019-10-12 21:52:04 +05:30
it 'includes mirrors that were started over an hour ago' do
mirror = create_mirror(url: 'http://cantbeblank',
update_status: 'started',
last_update_started_at: 3.hours.ago,
last_update_at: 2.hours.ago)
expect(described_class.stuck.last).to eq(mirror)
end
it 'includes mirrors started over 3 hours ago for their first sync' do
2018-10-15 14:42:47 +05:30
mirror = create_mirror(url: 'http://cantbeblank',
update_status: 'started',
last_update_at: nil,
2019-10-12 21:52:04 +05:30
last_update_started_at: 4.hours.ago)
2018-10-15 14:42:47 +05:30
expect(described_class.stuck.last).to eq(mirror)
end
end
2020-03-13 15:44:24 +05:30
describe '#sync' do
2018-10-15 14:42:47 +05:30
let(:remote_mirror) { create(:project, :repository, :remote_mirror).remote_mirrors.first }
around do |example|
2020-11-24 15:15:51 +05:30
freeze_time { example.run }
2018-10-15 14:42:47 +05:30
end
context 'with remote mirroring disabled' do
it 'returns nil' do
2021-12-11 22:18:48 +05:30
remote_mirror.update!(enabled: false)
2018-10-15 14:42:47 +05:30
expect(remote_mirror.sync).to be_nil
end
end
context 'with remote mirroring enabled' do
2019-02-15 15:39:39 +05:30
it 'defaults to disabling only protected branches' do
expect(remote_mirror.only_protected_branches?).to be_falsey
end
2018-10-15 14:42:47 +05:30
context 'with only protected branches enabled' do
2019-02-15 15:39:39 +05:30
before do
remote_mirror.only_protected_branches = true
end
2018-10-15 14:42:47 +05:30
context 'when it did not update in the last minute' do
it 'schedules a RepositoryUpdateRemoteMirrorWorker to run now' do
2020-06-23 00:09:42 +05:30
expect(RepositoryUpdateRemoteMirrorWorker).to receive(:perform_async).with(remote_mirror.id, Time.current)
2018-10-15 14:42:47 +05:30
remote_mirror.sync
end
end
context 'when it did update in the last minute' do
it 'schedules a RepositoryUpdateRemoteMirrorWorker to run in the next minute' do
2020-06-23 00:09:42 +05:30
remote_mirror.last_update_started_at = Time.current - 30.seconds
2018-10-15 14:42:47 +05:30
2020-06-23 00:09:42 +05:30
expect(RepositoryUpdateRemoteMirrorWorker).to receive(:perform_in).with(RemoteMirror::PROTECTED_BACKOFF_DELAY, remote_mirror.id, Time.current)
2018-10-15 14:42:47 +05:30
remote_mirror.sync
end
end
end
context 'with only protected branches disabled' do
before do
remote_mirror.only_protected_branches = false
end
context 'when it did not update in the last 5 minutes' do
it 'schedules a RepositoryUpdateRemoteMirrorWorker to run now' do
2020-06-23 00:09:42 +05:30
expect(RepositoryUpdateRemoteMirrorWorker).to receive(:perform_async).with(remote_mirror.id, Time.current)
2018-10-15 14:42:47 +05:30
remote_mirror.sync
end
end
context 'when it did update within the last 5 minutes' do
it 'schedules a RepositoryUpdateRemoteMirrorWorker to run in the next 5 minutes' do
2020-06-23 00:09:42 +05:30
remote_mirror.last_update_started_at = Time.current - 30.seconds
2018-10-15 14:42:47 +05:30
2020-06-23 00:09:42 +05:30
expect(RepositoryUpdateRemoteMirrorWorker).to receive(:perform_in).with(RemoteMirror::UNPROTECTED_BACKOFF_DELAY, remote_mirror.id, Time.current)
2018-10-15 14:42:47 +05:30
remote_mirror.sync
end
end
end
end
end
2020-03-13 15:44:24 +05:30
describe '#url=' do
2019-02-15 15:39:39 +05:30
let(:remote_mirror) { create(:project, :repository, :remote_mirror).remote_mirrors.first }
it 'resets all the columns when URL changes' do
2021-12-11 22:18:48 +05:30
remote_mirror.update!(last_error: Time.current,
2020-06-23 00:09:42 +05:30
last_update_at: Time.current,
last_successful_update_at: Time.current,
2019-02-15 15:39:39 +05:30
update_status: 'started',
error_notification_sent: true)
expect { remote_mirror.update_attribute(:url, 'http://new.example.com') }
.to change { remote_mirror.last_error }.to(nil)
.and change { remote_mirror.last_update_at }.to(nil)
.and change { remote_mirror.last_successful_update_at }.to(nil)
.and change { remote_mirror.update_status }.to('finished')
.and change { remote_mirror.error_notification_sent }.to(false)
end
2018-11-20 20:47:30 +05:30
end
2020-03-13 15:44:24 +05:30
describe '#updated_since?' do
2018-10-15 14:42:47 +05:30
let(:remote_mirror) { create(:project, :repository, :remote_mirror).remote_mirrors.first }
2020-06-23 00:09:42 +05:30
let(:timestamp) { Time.current - 5.minutes }
2018-10-15 14:42:47 +05:30
around do |example|
2020-11-24 15:15:51 +05:30
freeze_time { example.run }
2018-10-15 14:42:47 +05:30
end
before do
2021-12-11 22:18:48 +05:30
remote_mirror.update!(last_update_started_at: Time.current)
2018-10-15 14:42:47 +05:30
end
context 'when remote mirror does not have status failed' do
it 'returns true when last update started after the timestamp' do
expect(remote_mirror.updated_since?(timestamp)).to be true
end
it 'returns false when last update started before the timestamp' do
2020-06-23 00:09:42 +05:30
expect(remote_mirror.updated_since?(Time.current + 5.minutes)).to be false
2018-10-15 14:42:47 +05:30
end
end
context 'when remote mirror has status failed' do
it 'returns false when last update started after the timestamp' do
2021-12-11 22:18:48 +05:30
remote_mirror.update!(update_status: 'failed')
2018-10-15 14:42:47 +05:30
expect(remote_mirror.updated_since?(timestamp)).to be false
end
end
end
context 'no project' do
it 'includes mirror with a project in pending_delete' do
mirror = create_mirror(url: 'http://cantbeblank',
update_status: 'finished',
enabled: true,
last_update_at: nil,
updated_at: 25.hours.ago)
project = mirror.project
project.pending_delete = true
2021-12-11 22:18:48 +05:30
project.save!
2018-10-15 14:42:47 +05:30
mirror.reload
expect(mirror.sync).to be_nil
expect(mirror.valid?).to be_truthy
expect(mirror.update_status).to eq('finished')
end
end
2019-07-31 22:56:46 +05:30
describe '#disabled?' do
2020-11-24 15:15:51 +05:30
let_it_be(:project) { create(:project, :repository) }
2019-07-31 22:56:46 +05:30
subject { remote_mirror.disabled? }
context 'when disabled' do
2020-11-24 15:15:51 +05:30
let(:remote_mirror) { build(:remote_mirror, project: project, enabled: false) }
2019-07-31 22:56:46 +05:30
it { is_expected.to be_truthy }
end
context 'when enabled' do
2020-11-24 15:15:51 +05:30
let(:remote_mirror) { build(:remote_mirror, project: project, enabled: true) }
2019-07-31 22:56:46 +05:30
it { is_expected.to be_falsy }
end
end
2018-10-15 14:42:47 +05:30
def create_mirror(params)
project = FactoryBot.create(:project, :repository)
project.remote_mirrors.create!(params)
end
end